mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2025-03-16 15:41:16 +00:00
737 lines
14 KiB
C++
737 lines
14 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;
|
|
}
|
|
|
|
|
|
|
|
|
|
|