mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-11 05:01:25 +00:00
681 lines
13 KiB
C++
681 lines
13 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "Precompiled.h"
|
|
#include "globaldata.h"
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "i_system.h"
|
|
#include "i_sound.h"
|
|
#include "sounds.h"
|
|
#include "s_sound.h"
|
|
|
|
#include "z_zone.h"
|
|
#include "m_random.h"
|
|
#include "w_wad.h"
|
|
|
|
#include "doomdef.h"
|
|
#include "p_local.h"
|
|
|
|
#include "doomstat.h"
|
|
#include "Main.h"
|
|
|
|
// Purpose?
|
|
const char snd_prefixen[]
|
|
= { 'P', 'P', 'A', 'S', 'S', 'S', 'M', 'M', 'M', 'S', 'S', 'S' };
|
|
|
|
|
|
// when to clip out sounds
|
|
// Does not fit the large outdoor areas.
|
|
|
|
// Distance tp origin when sounds should be maxed out.
|
|
// This should relate to movement clipping resolution
|
|
// (see BLOCKMAP handling).
|
|
// Originally: (200*0x10000).
|
|
|
|
|
|
|
|
// Adjustable by menu.
|
|
|
|
|
|
|
|
// percent attenuation from front to back
|
|
|
|
|
|
|
|
// Current music/sfx card - index useless
|
|
// w/o a reference LUT in a sound module.
|
|
// Config file? Same disclaimer as above.
|
|
|
|
|
|
|
|
|
|
|
|
// the set of ::g->channels available
|
|
|
|
// These are not used, but should be (menu).
|
|
// Maximum volume of a sound effect.
|
|
// Internal default is max out of 0-15.
|
|
|
|
// Maximum volume of music. Useless so far.
|
|
|
|
|
|
|
|
// whether songs are ::g->mus_paused
|
|
|
|
// music currently being played
|
|
|
|
// following is set
|
|
// by the defaults code in M_misc:
|
|
// number of ::g->channels available
|
|
|
|
|
|
|
|
|
|
//
|
|
// Internals.
|
|
//
|
|
int
|
|
S_getChannel
|
|
( void* origin,
|
|
sfxinfo_t* sfxinfo );
|
|
|
|
|
|
int
|
|
S_AdjustSoundParams
|
|
( mobj_t* listener,
|
|
mobj_t* source,
|
|
int* vol,
|
|
int* sep,
|
|
int* pitch );
|
|
|
|
void S_StopChannel(int cnum);
|
|
|
|
|
|
|
|
//
|
|
// Initializes sound stuff, including volume
|
|
// Sets ::g->channels, SFX and music volume,
|
|
// allocates channel buffer, sets S_sfx lookup.
|
|
//
|
|
void S_Init
|
|
( int sfxVolume,
|
|
int musicVolume )
|
|
{
|
|
int i;
|
|
|
|
// Whatever these did with DMX, these are rather dummies now.
|
|
I_SetChannels();
|
|
|
|
S_SetSfxVolume(sfxVolume);
|
|
S_SetMusicVolume(musicVolume);
|
|
|
|
// Allocating the internal ::g->channels for mixing
|
|
// (the maximum numer of sounds rendered
|
|
// simultaneously) within zone memory.
|
|
::g->channels =
|
|
(channel_t *) DoomLib::Z_Malloc(::g->numChannels*sizeof(channel_t), PU_STATIC, 0);
|
|
|
|
// Free all ::g->channels for use
|
|
for (i=0 ; i < ::g->numChannels ; i++)
|
|
::g->channels[i].sfxinfo = 0;
|
|
|
|
// no sounds are playing, and they are not ::g->mus_paused
|
|
::g->mus_paused = 0;
|
|
::g->mus_looping = 0;
|
|
|
|
// Note that sounds have not been cached (yet).
|
|
for (i=1 ; i<NUMSFX ; i++)
|
|
S_sfx[i].lumpnum = S_sfx[i].usefulness = -1;
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// Per level startup code.
|
|
// Kills playing sounds at start of level,
|
|
// determines music if any, changes music.
|
|
//
|
|
void S_Start(void)
|
|
{
|
|
int cnum;
|
|
int mnum;
|
|
|
|
// kill all playing sounds at start of level
|
|
// (trust me - a good idea)
|
|
if( ::g->channels ) {
|
|
for (cnum=0 ; cnum < ::g->numChannels ; cnum++)
|
|
if (::g->channels[cnum].sfxinfo)
|
|
S_StopChannel(cnum);
|
|
}
|
|
|
|
// start new music for the level
|
|
::g->mus_paused = 0;
|
|
|
|
if (::g->gamemode == commercial) {
|
|
|
|
mnum = mus_runnin + ::g->gamemap - 1;
|
|
|
|
/*
|
|
Is this necessary?
|
|
|
|
if ( ::g->gamemission == 0 ) {
|
|
mnum = mus_runnin + ::g->gamemap - 1;
|
|
}
|
|
else {
|
|
mnum = mus_runnin + ( gameLocal->GetMissionData( ::g->gamemission )->mapMusic[ ::g->gamemap-1 ] - 1 );
|
|
}
|
|
*/
|
|
}
|
|
else
|
|
{
|
|
int spmus[] = {
|
|
// Song - Who? - Where?
|
|
mus_e3m4, // American e4m1
|
|
mus_e3m2, // Romero e4m2
|
|
mus_e3m3, // Shawn e4m3
|
|
mus_e1m5, // American e4m4
|
|
mus_e2m7, // Tim e4m5
|
|
mus_e2m4, // Romero e4m6
|
|
mus_e2m6, // J.Anderson e4m7 CHIRON.WAD
|
|
mus_e2m5, // Shawn e4m8
|
|
mus_e1m9 // Tim e4m9
|
|
};
|
|
|
|
if (::g->gameepisode < 4)
|
|
mnum = mus_e1m1 + (::g->gameepisode-1)*9 + ::g->gamemap-1;
|
|
else
|
|
mnum = spmus[::g->gamemap-1];
|
|
}
|
|
|
|
S_StopMusic();
|
|
S_ChangeMusic(mnum, true);
|
|
|
|
::g->nextcleanup = 15;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
S_StartSoundAtVolume
|
|
( void* origin_p,
|
|
int sfx_id,
|
|
int volume )
|
|
{
|
|
|
|
int rc;
|
|
int sep;
|
|
int pitch;
|
|
int priority;
|
|
sfxinfo_t* sfx;
|
|
int cnum;
|
|
|
|
mobj_t* origin = (mobj_t *) origin_p;
|
|
|
|
|
|
// Debug.
|
|
/*I_PrintfE
|
|
"S_StartSoundAtVolume: playing sound %d (%s)\n",
|
|
sfx_id, S_sfx[sfx_id].name );*/
|
|
|
|
// check for bogus sound #
|
|
if (sfx_id < 1 || sfx_id > NUMSFX)
|
|
I_Error("Bad sfx #: %d", sfx_id);
|
|
|
|
sfx = &S_sfx[sfx_id];
|
|
|
|
// Initialize sound parameters
|
|
if (sfx->link)
|
|
{
|
|
pitch = sfx->pitch;
|
|
priority = sfx->priority;
|
|
volume += sfx->volume;
|
|
|
|
if (volume < 1)
|
|
return;
|
|
|
|
if ( volume > s_volume_sound.GetInteger() )
|
|
volume = s_volume_sound.GetInteger();
|
|
}
|
|
else
|
|
{
|
|
pitch = NORM_PITCH;
|
|
priority = NORM_PRIORITY;
|
|
|
|
if (volume < 1)
|
|
return;
|
|
|
|
if ( volume > s_volume_sound.GetInteger() )
|
|
volume = s_volume_sound.GetInteger();
|
|
|
|
}
|
|
|
|
|
|
// Check to see if it is audible,
|
|
// and if not, modify the params
|
|
// DHM - Nerve :: chainsaw!!!
|
|
if (origin && ::g->players[::g->consoleplayer].mo && origin != ::g->players[::g->consoleplayer].mo)
|
|
{
|
|
rc = S_AdjustSoundParams(::g->players[::g->consoleplayer].mo,
|
|
origin,
|
|
&volume,
|
|
&sep,
|
|
&pitch);
|
|
|
|
if ( origin->x == ::g->players[::g->consoleplayer].mo->x
|
|
&& origin->y == ::g->players[::g->consoleplayer].mo->y)
|
|
{
|
|
sep = NORM_SEP;
|
|
}
|
|
|
|
if (!rc)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
sep = NORM_SEP;
|
|
}
|
|
|
|
// hacks to vary the sfx pitches
|
|
const bool isChainsawSound = sfx_id >= sfx_sawup && sfx_id <= sfx_sawhit;
|
|
|
|
if ( !isChainsawSound && sfx_id != sfx_itemup && sfx_id != sfx_tink)
|
|
{
|
|
pitch += 16 - (M_Random()&31);
|
|
|
|
if (pitch<0)
|
|
pitch = 0;
|
|
else if (pitch>255)
|
|
pitch = 255;
|
|
}
|
|
|
|
// kill old sound
|
|
//S_StopSound(origin);
|
|
|
|
// try to find a channel
|
|
cnum = S_getChannel(origin, sfx);
|
|
|
|
if (cnum<0) {
|
|
printf( "No sound channels available for sfxid %d.\n", sfx_id );
|
|
return;
|
|
}
|
|
|
|
// get lumpnum if necessary
|
|
if (sfx->lumpnum < 0)
|
|
sfx->lumpnum = I_GetSfxLumpNum(sfx);
|
|
|
|
// increase the usefulness
|
|
if (sfx->usefulness++ < 0)
|
|
sfx->usefulness = 1;
|
|
|
|
// Assigns the handle to one of the ::g->channels in the
|
|
// mix/output buffer.
|
|
::g->channels[cnum].handle = I_StartSound(sfx_id, origin, ::g->players[::g->consoleplayer].mo, volume, pitch, priority);
|
|
}
|
|
|
|
void S_StartSound ( void* origin, int sfx_id )
|
|
{
|
|
S_StartSoundAtVolume(origin, sfx_id, s_volume_sound.GetInteger() );
|
|
}
|
|
|
|
|
|
|
|
|
|
void S_StopSound(void *origin)
|
|
{
|
|
|
|
int cnum;
|
|
|
|
for (cnum=0 ; cnum < ::g->numChannels ; cnum++)
|
|
{
|
|
if (::g->channels[cnum].sfxinfo && ::g->channels[cnum].origin == origin)
|
|
{
|
|
S_StopChannel(cnum);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Stop and resume music, during game PAUSE.
|
|
//
|
|
void S_PauseSound(void)
|
|
{
|
|
if (::g->mus_playing && !::g->mus_paused)
|
|
{
|
|
I_PauseSong(::g->mus_playing->handle);
|
|
::g->mus_paused = true;
|
|
}
|
|
}
|
|
|
|
void S_ResumeSound(void)
|
|
{
|
|
if (::g->mus_playing && ::g->mus_paused)
|
|
{
|
|
I_ResumeSong(::g->mus_playing->handle);
|
|
::g->mus_paused = false;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Updates music & sounds
|
|
//
|
|
void S_UpdateSounds(void* listener_p)
|
|
{
|
|
int audible;
|
|
int cnum;
|
|
int volume;
|
|
int sep;
|
|
int pitch;
|
|
sfxinfo_t* sfx;
|
|
channel_t* c;
|
|
|
|
mobj_t* listener = (mobj_t*)listener_p;
|
|
|
|
for (cnum=0 ; cnum < ::g->numChannels ; cnum++)
|
|
{
|
|
c = &::g->channels[cnum];
|
|
sfx = c->sfxinfo;
|
|
|
|
if(sfx)
|
|
{
|
|
if (I_SoundIsPlaying(c->handle))
|
|
{
|
|
// initialize parameters
|
|
volume = s_volume_sound.GetInteger();
|
|
pitch = NORM_PITCH;
|
|
sep = NORM_SEP;
|
|
|
|
if (sfx->link)
|
|
{
|
|
pitch = sfx->pitch;
|
|
volume += sfx->volume;
|
|
|
|
if (volume < 1) {
|
|
S_StopChannel(cnum);
|
|
continue;
|
|
|
|
} else if ( volume > s_volume_sound.GetInteger() ) {
|
|
volume = s_volume_sound.GetInteger();
|
|
}
|
|
}
|
|
|
|
// check non-local sounds for distance clipping or modify their params
|
|
if (c->origin && listener_p != c->origin)
|
|
{
|
|
audible = S_AdjustSoundParams(listener, (mobj_t*)c->origin, &volume, &sep, &pitch);
|
|
if (!audible) {
|
|
S_StopChannel(cnum);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if channel is allocated but sound has stopped, free it
|
|
S_StopChannel(cnum);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void S_SetMusicVolume(int volume)
|
|
{
|
|
I_SetMusicVolume(volume);
|
|
s_volume_midi.SetInteger( volume );
|
|
}
|
|
|
|
|
|
|
|
void S_SetSfxVolume(int volume)
|
|
{
|
|
I_SetSfxVolume(volume);
|
|
s_volume_sound.SetInteger( volume );
|
|
}
|
|
|
|
//
|
|
// Starts some music with the music id found in sounds.h.
|
|
//
|
|
void S_StartMusic(int m_id)
|
|
{
|
|
S_ChangeMusic(m_id, false);
|
|
}
|
|
|
|
void S_ChangeMusic ( int musicnum, int looping )
|
|
{
|
|
#ifdef ID_ENABLE_DOOM_CLASSIC_NETWORKING
|
|
if (gameLocal->IsSplitscreen() && DoomLib::GetPlayer() > 0 )
|
|
{
|
|
// we aren't the key player... we have no control over music
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
musicinfo_t* music = NULL;
|
|
|
|
if ( (musicnum <= mus_None)
|
|
|| (musicnum >= NUMMUSIC) )
|
|
{
|
|
I_Error("Bad music number %d", musicnum);
|
|
}
|
|
else
|
|
music = &::g->S_music[musicnum];
|
|
|
|
if (::g->mus_playing == music)
|
|
return;
|
|
|
|
//I_Printf("S_ChangeMusic: Playing new track: '%s'\n", music->name);
|
|
|
|
I_PlaySong( music->name, looping );
|
|
|
|
::g->mus_playing = music;
|
|
}
|
|
|
|
|
|
void S_StopMusic(void)
|
|
{
|
|
if (::g->doomcom.consoleplayer)
|
|
{
|
|
// we aren't the key player... we have no control over music
|
|
return;
|
|
}
|
|
|
|
if (::g->mus_playing)
|
|
{
|
|
if (::g->mus_paused)
|
|
I_ResumeSong(::g->mus_playing->handle);
|
|
|
|
I_StopSong(::g->mus_playing->handle);
|
|
I_UnRegisterSong(::g->mus_playing->handle);
|
|
//Z_FreeTags( PU_MUSIC_SHARED, PU_MUSIC_SHARED );
|
|
|
|
::g->mus_playing->data = 0;
|
|
::g->mus_playing = 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void S_StopChannel(int cnum)
|
|
{
|
|
|
|
int i;
|
|
channel_t* c = &::g->channels[cnum];
|
|
|
|
if (c->sfxinfo)
|
|
{
|
|
// stop the sound playing
|
|
if (I_SoundIsPlaying(c->handle))
|
|
{
|
|
#ifdef SAWDEBUG
|
|
if (c->sfxinfo == &S_sfx[sfx_sawful])
|
|
I_PrintfE( "stopped\n");
|
|
#endif
|
|
I_StopSound(c->handle);
|
|
}
|
|
|
|
// check to see
|
|
// if other ::g->channels are playing the sound
|
|
for (i=0 ; i < ::g->numChannels ; i++)
|
|
{
|
|
if (cnum != i
|
|
&& c->sfxinfo == ::g->channels[i].sfxinfo)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// degrade usefulness of sound data
|
|
c->sfxinfo->usefulness--;
|
|
|
|
c->sfxinfo = 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Changes volume, stereo-separation, and pitch variables
|
|
// from the norm of a sound effect to be played.
|
|
// If the sound is not audible, returns a 0.
|
|
// Otherwise, modifies parameters and returns 1.
|
|
//
|
|
int S_AdjustSoundParams( mobj_t* listener, mobj_t* source, int* vol, int* sep, int* pitch ) {
|
|
fixed_t approx_dist;
|
|
fixed_t adx;
|
|
fixed_t ady;
|
|
|
|
// DHM - Nerve :: Could happen in multiplayer if a player exited the level holding the chainsaw
|
|
if ( listener == NULL || source == NULL ) {
|
|
return 0;
|
|
}
|
|
|
|
// calculate the distance to sound origin
|
|
// and clip it if necessary
|
|
adx = abs(listener->x - source->x);
|
|
ady = abs(listener->y - source->y);
|
|
|
|
// From _GG1_ p.428. Appox. eucledian distance fast.
|
|
approx_dist = adx + ady - ((adx < ady ? adx : ady)>>1);
|
|
|
|
if ( approx_dist > S_CLIPPING_DIST) {
|
|
return 0;
|
|
}
|
|
|
|
// angle of source to listener
|
|
*sep = NORM_SEP;
|
|
|
|
// volume calculation
|
|
if (approx_dist < S_CLOSE_DIST) {
|
|
*vol = s_volume_sound.GetInteger();
|
|
}
|
|
else {
|
|
// distance effect
|
|
*vol = ( s_volume_sound.GetInteger()
|
|
* ((S_CLIPPING_DIST - approx_dist)>>FRACBITS))
|
|
/ S_ATTENUATOR;
|
|
}
|
|
|
|
return (*vol > 0);
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
// S_getChannel :
|
|
// If none available, return -1. Otherwise channel #.
|
|
//
|
|
int
|
|
S_getChannel
|
|
( void* origin,
|
|
sfxinfo_t* sfxinfo )
|
|
{
|
|
// channel number to use
|
|
int cnum;
|
|
|
|
channel_t* c;
|
|
|
|
// Find an open channel
|
|
for (cnum=0 ; cnum < ::g->numChannels ; cnum++)
|
|
{
|
|
if (!::g->channels[cnum].sfxinfo)
|
|
break;
|
|
else if ( origin && ::g->channels[cnum].origin == origin &&
|
|
(::g->channels[cnum].handle == sfx_sawidl || ::g->channels[cnum].handle == sfx_sawful) )
|
|
{
|
|
S_StopChannel(cnum);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// None available
|
|
if (cnum == ::g->numChannels)
|
|
{
|
|
// Look for lower priority
|
|
for (cnum=0 ; cnum < ::g->numChannels ; cnum++)
|
|
if (::g->channels[cnum].sfxinfo->priority >= sfxinfo->priority) break;
|
|
|
|
if (cnum == ::g->numChannels)
|
|
{
|
|
// FUCK! No lower priority. Sorry, Charlie.
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, kick out lower priority.
|
|
S_StopChannel(cnum);
|
|
}
|
|
}
|
|
|
|
c = &::g->channels[cnum];
|
|
|
|
// channel is decided to be cnum.
|
|
c->sfxinfo = sfxinfo;
|
|
c->origin = origin;
|
|
|
|
return cnum;
|
|
}
|
|
|
|
|
|
|
|
|
|
|