zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-28 06:53:40 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Removed the S_Sound() variant that allows for pointing the origin at an

Browse source 
arbitrary point. It has been replaced with a variant that takes a polyobject
  as a source, since that was the only use that couldn't be rewritten with the
  other variants. This also fixes the bug that polyobject sounds were not
  successfully saved and caused a crash when reloading the game. Note that
  this is a significant change to how equality of sound sources is determined,
  so some things may not behave quite the same as before. (Which would be a
  bug, but hopefully everything still sounds the same.)


SVN r1059 (trunk)
This commit is contained in:
Randy Heit 2008-07-01 04:06:56 +00:00
parent 601a6ad04c
commit a3e8a0cefd
39 changed files with 477 additions and 255 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
docs/rh-log.txt
View file

@ -1,4 +1,12 @@
June 30, 2008
- Removed the S_Sound() variant that allows for pointing the origin at an
arbitrary point. It has been replaced with a variant that takes a polyobject
as a source, since that was the only use that couldn't be rewritten with the
other variants. This also fixes the bug that polyobject sounds were not
successfully saved and caused a crash when reloading the game. Note that
this is a significant change to how equality of sound sources is determined,
so some things may not behave quite the same as before. (Which would be a
bug, but hopefully everything still sounds the same.)
- Adjusted the noise debug table so that fractional volume levels do not
run into the adjacent columns.
- Added a NullSoundRenderer so that most of the checks against a NULL GSnd

1
src/b_func.cpp
View file

@ -20,7 +20,6 @@
#include "stats.h"
#include "i_system.h"
#include "s_sound.h"
#include "vectors.h"
#include "a_doomglobal.h"
static FRandom pr_botdofire ("BotDoFire");

1
src/c_console.cpp
View file

@ -62,7 +62,6 @@
#include "doomstat.h"
#include "d_gui.h"
#include "v_video.h"
#include "vectors.h"
#include "gi.h"

1
src/d_dehacked.cpp
View file

@ -64,7 +64,6 @@
#include "v_palette.h"
#include "a_sharedglobal.h"
#include "thingdef/thingdef.h"
#include "vectors.h"
#include "dobject.h"
#include "r_translate.h"

1
src/doomtype.h
View file

@ -39,6 +39,7 @@
#include <limits.h>
#include "zstring.h"
#include "name.h"
#include "vectors.h"
// Since this file is included by everything, it seems an appropriate place
// to check the NOASM/USEASM macros.

2
src/f_finale.cpp
View file

@ -349,7 +349,7 @@ void F_Ticker ()
}
else if (FinaleStage == 5 && FinaleCount > FinaleEndCount)
{
S_StopSound ((fixed_t *)NULL, CHAN_VOICE);
S_StopSound (CHAN_VOICE);
F_AdvanceSlideshow ();
FinaleCount = 0;
}

1
src/g_level.cpp
View file

@ -71,7 +71,6 @@
#include "version.h"
#include "m_menu.h"
#include "statnums.h"
#include "vectors.h"
#include "sbarinfo.h"
#include "r_translate.h"
#include "p_lnspec.h"

1
src/g_shared/a_camera.cpp
View file

@ -37,7 +37,6 @@
#include "a_sharedglobal.h"
#include "r_main.h"
#include "p_local.h"
#include "vectors.h"
class ADoomBuilderCamera : public AActor
{

1
src/g_shared/a_movingcamera.cpp
View file

@ -36,7 +36,6 @@
#include "info.h"
#include "p_local.h"
#include "p_lnspec.h"
#include "vectors.h"
/*
== InterpolationPoint: node along a camera's path

2
src/g_strife/a_acolyte.cpp
View file

@ -385,7 +385,7 @@ void A_AcolyteDie (AActor *self)
players[0].mo->GiveInventoryType (QuestItemClasses[6]);
players[0].SetLogNumber (14);
S_StopSound ((fixed_t *)NULL, CHAN_VOICE);
S_StopSound (CHAN_VOICE);
S_Sound (CHAN_VOICE, "svox/voc14", 1, ATTN_NORM);
}

1
src/g_strife/a_loremaster.cpp
View file

@ -5,7 +5,6 @@
#include "p_enemy.h"
#include "p_local.h"
#include "s_sound.h"
#include "vectors.h"
static FRandom pr_atk1 ("FooMelee");

2
src/m_menu.cpp
View file

@ -2687,7 +2687,7 @@ void M_StartMessage (const char *string, void (*routine)(int), bool input)
}
if (input)
{
S_StopSound ((AActor *)NULL, CHAN_VOICE);
S_StopSound (CHAN_VOICE);
S_Sound (CHAN_VOICE, "menu/prompt", 1, ATTN_NONE);
}
return;

5
src/p_acs.cpp
View file

@ -53,7 +53,6 @@
#include "i_system.h"
#include "i_movie.h"
#include "sbar.h"
#include "vectors.h"
#include "m_swap.h"
#include "a_sharedglobal.h"
#include "a_doomglobal.h"
@ -4127,8 +4126,8 @@ int DLevelScript::RunScript ()
if (activationline)
{
S_Sound (
activationline->frontsector->soundorg,
CHAN_AUTO,
activationline->frontsector,
CHAN_AUTO, // Not CHAN_AREA, because that'd probably break existing scripts.
lookup,
(float)(STACK(1)) / 127.f,
ATTN_NORM);

1
src/p_buildmap.cpp
View file

@ -12,7 +12,6 @@
#include "v_palette.h"
#include "w_wad.h"
#include "templates.h"
#include "vectors.h"
#include "r_sky.h"
#include "r_main.h"
#include "r_defs.h"

2
src/p_lnspec.cpp
View file

@ -2721,7 +2721,7 @@ FUNC(LS_SendToCommunicator)
if (it->CheckLocalView (consoleplayer))
{
S_StopSound ((fixed_t *)NULL, CHAN_VOICE);
S_StopSound (CHAN_VOICE);
S_Sound (CHAN_VOICE, name, 1, ATTN_NORM);
if (arg2 == 0)
{

1
src/p_local.h
View file

@ -488,7 +488,6 @@ enum
PO_SPAWNHURT_TYPE
};
extern FPolyObj *polyobjs; // list of all poly-objects on the level
extern int po_NumPolyobjs;
extern polyspawns_t *polyspawns; // [RH] list of polyobject things to spawn

1
src/p_map.cpp
View file

@ -26,7 +26,6 @@
#include <math.h>
#include "templates.h"
#include "vectors.h"
#include "m_alloc.h"
#include "m_bbox.h"

1
src/p_maputl.cpp
View file

@ -39,7 +39,6 @@
// State.
#include "r_state.h"
#include "templates.h"
#include "vectors.h"
static AActor *RoughBlockCheck (AActor *mo, int index);

2
src/p_mobj.cpp
View file

@ -4491,7 +4491,7 @@ void P_PlaySpawnSound(AActor *missile, AActor *spawner)
// If there is no spawner use the spawn position.
// But not in a silenced sector.
if (!(missile->Sector->Flags & SECF_SILENT))
S_Sound (&missile->x, CHAN_WEAPON, missile->SeeSound, 1, ATTN_NORM);
S_Sound (missile->x, missile->y, missile->z, CHAN_WEAPON, missile->SeeSound, 1, ATTN_NORM);
}
}
}

1
src/p_setup.cpp
View file

@ -48,7 +48,6 @@
#include "c_console.h"
#include "c_cvars.h"
#include "p_acs.h"
#include "vectors.h"
#include "announcer.h"
#include "wi_stuff.h"
#include "stats.h"

1
src/p_slopes.cpp
View file

@ -33,7 +33,6 @@
*/
#include "doomtype.h"
#include "vectors.h"
#include "p_local.h"
#include "r_data.h"
#include "cmdlib.h"

11
src/p_switch.cpp
View file

@ -577,20 +577,19 @@ bool P_ChangeSwitchTexture (side_t *side, int useAgain, BYTE special, bool *ques
// which wasn't necessarily anywhere near the switch if it was
// facing a big sector (and which wasn't necessarily for the
// button just activated, either).
fixed_t pt[3];
fixed_t pt[2];
line_t *line = &lines[side->linenum];
bool playsound;
pt[0] = line->v1->x + (line->dx >> 1);
pt[1] = line->v1->y + (line->dy >> 1);
pt[2] = 0;
side->SetTexture(texture, SwitchList[i]->u[0].Texture);
if (useAgain || SwitchList[i]->NumFrames > 1)
playsound = P_StartButton (side, texture, i, pt[0], pt[1], !!useAgain);
else
playsound = true;
if (playsound)
S_Sound (pt, CHAN_VOICE|CHAN_LISTENERZ|CHAN_IMMOBILE, sound, 1, ATTN_STATIC);
S_Sound (pt[0], pt[1], 0, CHAN_VOICE|CHAN_LISTENERZ, sound, 1, ATTN_STATIC);
if (quest != NULL)
{
*quest = SwitchList[i]->QuestPanel;
@ -648,16 +647,12 @@ void DActiveButton::Tick ()
FSwitchDef *def = SwitchList[m_SwitchDef];
if (m_Frame == def->NumFrames - 1)
{
fixed_t pt[3];
m_SwitchDef = def->PairIndex;
if (m_SwitchDef != 65535)
{
def = SwitchList[def->PairIndex];
m_Frame = 65535;
pt[0] = m_X;
pt[1] = m_Y;
S_Sound (pt, CHAN_VOICE|CHAN_LISTENERZ|CHAN_IMMOBILE,
S_Sound (m_X, m_Y, 0, CHAN_VOICE|CHAN_LISTENERZ,
def->Sound != 0 ? def->Sound : FSoundID("switches/normbutn"),
1, ATTN_STATIC);
bFlippable = false;

1
src/p_udmf.cpp
View file

@ -36,7 +36,6 @@
#include "r_data.h"
#include "p_setup.h"
#include "sc_man.h"
#include "vectors.h"
#include "p_lnspec.h"
#include "templates.h"
#include "i_system.h"

15
src/r_defs.h
View file

@ -486,7 +486,7 @@ struct sector_t
int sky;
short seqType; // this sector's sound sequence
fixed_t soundorg[3]; // origin for any sounds played by the sector
fixed_t soundorg[2]; // origin for any sounds played by the sector
int validcount; // if == validcount, already checked
AActor* thinglist; // list of mobjs in sector
@ -786,8 +786,19 @@ struct FPolyObj
~FPolyObj();
DInterpolation *SetInterpolation();
void StopInterpolation();
};
extern FPolyObj *polyobjs; // list of all poly-objects on the level
inline FArchive &operator<< (FArchive &arc, FPolyObj *&poly)
{
return arc.SerializePointer (polyobjs, (BYTE **)&poly, sizeof(FPolyObj));
}
inline FArchive &operator<< (FArchive &arc, const FPolyObj *&poly)
{
return arc.SerializePointer (polyobjs, (BYTE **)&poly, sizeof(FPolyObj));
}
//
// BSP node.

1
src/r_main.cpp
View file

@ -44,7 +44,6 @@
#include "stats.h"
#include "i_video.h"
#include "i_system.h"
#include "vectors.h"
#include "a_sharedglobal.h"
#include "r_translate.h"
#include "p_3dmidtex.h"

1
src/r_plane.cpp
View file

@ -48,7 +48,6 @@
#include "m_alloc.h"
#include "v_video.h"
#include "vectors.h"
#include "a_sharedglobal.h"
#include "c_console.h"

5
src/r_state.h
View file

@ -87,6 +87,11 @@ inline FArchive &operator<< (FArchive &arc, sector_t *&sec)
return arc.SerializePointer (sectors, (BYTE **)&sec, sizeof(*sectors));
}
inline FArchive &operator<< (FArchive &arc, const sector_t *&sec)
{
return arc.SerializePointer (sectors, (BYTE **)&sec, sizeof(*sectors));
}
inline FArchive &operator<< (FArchive &arc, line_t *&line)
{
return arc.SerializePointer (lines, (BYTE **)&line, sizeof(*lines));

12
src/s_sndseq.cpp
View file

@ -132,11 +132,11 @@ public:
void Serialize(FArchive &arc);
void MakeSound(int loop, FSoundID id)
{
S_Sound (&m_Poly->startSpot[0], CHAN_BODY|loop, id, clamp(m_Volume, 0.f, 1.f), m_Atten);
S_Sound (m_Poly, CHAN_BODY|loop, id, clamp(m_Volume, 0.f, 1.f), m_Atten);
}
bool IsPlaying()
{
return S_GetSoundPlayingInfo (&m_Poly->startSpot[0], m_CurrentSoundID);
return S_GetSoundPlayingInfo (m_Poly, m_CurrentSoundID);
}
void *Source()
{
@ -165,7 +165,7 @@ public:
}
bool IsPlaying()
{
return S_GetSoundPlayingInfo (m_Sector->soundorg, m_CurrentSoundID);
return S_GetSoundPlayingInfo (m_Sector, m_CurrentSoundID);
}
void *Source()
{
@ -423,7 +423,7 @@ IMPLEMENT_CLASS (DSeqPolyNode)
void DSeqPolyNode::Serialize (FArchive &arc)
{
Super::Serialize (arc);
arc.SerializePointer (polyobjs, (BYTE **)&m_Poly, sizeof(*polyobjs));
arc << m_Poly;
}
IMPLEMENT_CLASS (DSeqSectorNode)
@ -982,7 +982,7 @@ void DSeqActorNode::Destroy ()
void DSeqSectorNode::Destroy ()
{
if (m_StopSound >= 0)
S_StopSound (m_Sector->soundorg, Channel & 7);
S_StopSound (m_Sector, Channel & 7);
if (m_StopSound >= 1)
MakeSound (0, m_StopSound);
Super::Destroy();
@ -991,7 +991,7 @@ void DSeqSectorNode::Destroy ()
void DSeqPolyNode::Destroy ()
{
if (m_StopSound >= 0)
S_StopSound (m_Poly->startSpot, CHAN_BODY);
S_StopSound (m_Poly, CHAN_BODY);
if (m_StopSound >= 1)
MakeSound (0, m_StopSound);
Super::Destroy();

531
src/s_sound.cpp
View file

@ -46,7 +46,6 @@
#include "v_text.h"
#include "a_sharedglobal.h"
#include "gstrings.h"
#include "vectors.h"
#include "gi.h"
#include "templates.h"
#include "zstring.h"
@ -84,6 +83,15 @@ struct MusPlayingInfo
bool loop;
};
enum
{
SOURCE_None, // Sound is always on top of the listener.
SOURCE_Actor, // Sound is coming from an actor.
SOURCE_Sector, // Sound is coming from a sector.
SOURCE_Polyobj, // Sound is coming from a polyobject.
SOURCE_Unattached, // Sound is not attached to any particular emitter.
};
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
extern float S_GetMusicVolume (const char *music);
@ -92,12 +100,13 @@ extern float S_GetMusicVolume (const char *music);
// PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
static bool S_CheckSoundLimit(sfxinfo_t *sfx, float pos[3], int near_limit);
static bool S_CheckSoundLimit(sfxinfo_t *sfx, const FVector3 &pos, int near_limit);
static void S_ActivatePlayList(bool goBack);
static void CalcPosVel(fixed_t *pt, AActor *mover, int constz, float pos[3],
float vel[3]);
static FSoundChan *S_StartSound(fixed_t *pt, AActor *mover, sector_t *sec,
int channel, FSoundID sound_id, float volume, float attenuation);
static void CalcPosVel(const FSoundChan *chan, FVector3 *pos, FVector3 *vel);
static void CalcPosVel(int type, const AActor *actor, const sector_t *sector, const FPolyObj *poly,
const FVector3 *pt, int constz, FVector3 *pos, FVector3 *vel);
static FSoundChan *S_StartSound(AActor *mover, const sector_t *sec, const FPolyObj *poly,
const FVector3 *pt, int channel, FSoundID sound_id, float volume, float attenuation);
static sfxinfo_t *S_LoadSound(sfxinfo_t *sfx);
// PRIVATE DATA DEFINITIONS ------------------------------------------------
@ -138,7 +147,7 @@ void S_NoiseDebug (void)
{
FSoundChan *chan;
FVector3 listener;
fixed_t ox, oy, oz;
FVector3 origin;
int y, color;
y = 32 * CleanYfac;
@ -161,8 +170,8 @@ void S_NoiseDebug (void)
}
listener.X = FIXED2FLOAT(players[consoleplayer].camera->x);
listener.Y = FIXED2FLOAT(players[consoleplayer].camera->y);
listener.Z = FIXED2FLOAT(players[consoleplayer].camera->z);
listener.Y = FIXED2FLOAT(players[consoleplayer].camera->z);
listener.Z = FIXED2FLOAT(players[consoleplayer].camera->y);
// Display the oldest channel first.
for (chan = Channels; chan->NextChan != NULL; chan = chan->NextChan)
@ -171,10 +180,7 @@ void S_NoiseDebug (void)
{
char temp[32];
assert(chan->Pt != NULL);
ox = chan->Pt[0];
oy = chan->Pt[1];
oz = chan->Pt[2];
CalcPosVel(chan, &origin, NULL);
color = (chan->ChanFlags & CHAN_LOOP) ? CR_BROWN : CR_GREY;
// Name
@ -192,23 +198,22 @@ void S_NoiseDebug (void)
else
{
// X coordinate
sprintf (temp, "%d", ox >> FRACBITS);
sprintf (temp, "%.0f", origin.X);
screen->DrawText (color, 70, y, temp, TAG_DONE);
// Y coordinate
sprintf (temp, "%d", oy >> FRACBITS);
sprintf (temp, "%.0f", origin.Z);
screen->DrawText (color, 120, y, temp, TAG_DONE);
// Z coordinate
sprintf (temp, "%d", oz >> FRACBITS);
sprintf (temp, "%.0f", origin.Y);
screen->DrawText (color, 170, y, temp, TAG_DONE);
// Distance
if (chan->DistanceScale > 0)
{
FVector3 sound(ox, oy, oz);
sound /= FRACUNIT;
sprintf (temp, "%.0f", (sound - listener).Length());
origin /= FRACUNIT;
sprintf (temp, "%.0f", (origin - listener).Length());
screen->DrawText (color, 260, y, temp, TAG_DONE);
}
else
@ -226,10 +231,10 @@ void S_NoiseDebug (void)
screen->DrawText (color, 300, y, temp, TAG_DONE);
// Flags
sprintf (temp, "%s3%sZ%sI%sM%sN%sA%sL%sE",
sprintf (temp, "%s3%sZ%sU%sM%sN%sA%sL%sE",
(chan->ChanFlags & CHAN_IS3D) ? TEXTCOLOR_GREEN : TEXTCOLOR_BLACK,
(chan->ChanFlags & CHAN_LISTENERZ) ? TEXTCOLOR_GREEN : TEXTCOLOR_BLACK,
(chan->ChanFlags & CHAN_IMMOBILE) ? TEXTCOLOR_GREEN : TEXTCOLOR_BLACK,
(chan->ChanFlags & CHAN_UI) ? TEXTCOLOR_GREEN : TEXTCOLOR_BLACK,
(chan->ChanFlags & CHAN_MAYBE_LOCAL) ? TEXTCOLOR_GREEN : TEXTCOLOR_BLACK,
(chan->ChanFlags & CHAN_NOPAUSE) ? TEXTCOLOR_GREEN : TEXTCOLOR_BLACK,
(chan->ChanFlags & CHAN_AREA) ? TEXTCOLOR_GREEN : TEXTCOLOR_BLACK,
@ -547,9 +552,9 @@ FSoundChan *S_GetChannel(void *syschan)
void S_ReturnChannel(FSoundChan *chan)
{
if (chan->Mover != NULL)
if (chan->SourceType == SOURCE_Actor && chan->Actor != NULL)
{
chan->Mover->SoundChans &= ~(1 << chan->EntChannel);
chan->Actor->SoundChans &= ~(1 << chan->EntChannel);
}
S_UnlinkChannel(chan);
memset(chan, 0, sizeof(*chan));
@ -596,33 +601,164 @@ void S_LinkChannel(FSoundChan *chan, FSoundChan **head)
//
// CalcPosVel
//
// Calculates a sound's position and velocity for 3D sounds.
// Retrieves a sound's position and velocity for 3D sounds. This version
// is for an already playing sound.
//
//=========================================================================
void CalcPosVel (fixed_t *pt, AActor *mover, int constz,
float pos[3], float vel[3])
void CalcPosVel(const FSoundChan *chan, FVector3 *pos, FVector3 *vel)
{
if (mover != NULL)
if (pos != NULL)
{
vel[0] = FIXED2FLOAT(mover->momx) * TICRATE;
vel[1] = FIXED2FLOAT(mover->momz) * TICRATE;
vel[2] = FIXED2FLOAT(mover->momy) * TICRATE;
fixed_t x, y, z;
switch (chan->SourceType)
{
case SOURCE_None:
default:
if (players[consoleplayer].camera != NULL)
{
x = players[consoleplayer].camera->x;
y = players[consoleplayer].camera->z;
z = players[consoleplayer].camera->y;
}
else
{
vel[0] = vel[1] = vel[2] = 0.f;
z = y = x = 0;
}
break;
case SOURCE_Actor:
x = chan->Actor->x;
y = chan->Actor->z;
z = chan->Actor->y;
break;
case SOURCE_Sector:
x = chan->Sector->soundorg[0];
y = players[consoleplayer].camera != NULL ? players[consoleplayer].camera->z : 0;
z = chan->Sector->soundorg[1];
break;
case SOURCE_Polyobj:
x = chan->Poly->startSpot[0];
y = chan->Poly->startSpot[2];
z = chan->Poly->startSpot[1];
break;
case SOURCE_Unattached:
pos->X = chan->Point[0];
pos->Y = !(chan->ChanFlags & CHAN_LISTENERZ) ? chan->Point[1]
: FIXED2FLOAT(players[consoleplayer].camera->z);
pos->Z = chan->Point[2];
break;
}
if (chan->SourceType != SOURCE_Unattached)
{
if (chan->ChanFlags & CHAN_LISTENERZ)
{
y = players[consoleplayer].camera != NULL ? players[consoleplayer].camera->z : 0;
}
pos->X = FIXED2FLOAT(x);
pos->Y = FIXED2FLOAT(y);
pos->Z = FIXED2FLOAT(z);
}
}
if (vel != NULL)
{
// Only actors maintain velocity information.
if (chan->SourceType == SOURCE_Actor)
{
vel->X = FIXED2FLOAT(chan->Actor->momx) * TICRATE;
vel->Y = FIXED2FLOAT(chan->Actor->momz) * TICRATE;
vel->Z = FIXED2FLOAT(chan->Actor->momy) * TICRATE;
}
else
{
vel->Zero();
}
}
}
pos[0] = FIXED2FLOAT (pt[0]);
pos[2] = FIXED2FLOAT (pt[1]);
if (constz)
//=========================================================================
//
// CalcPosVel
//
// This version is for sounds that haven't started yet so have no channel.
//
//=========================================================================
static void CalcPosVel(int type, const AActor *actor, const sector_t *sector,
const FPolyObj *poly, const FVector3 *pt, int constz, FVector3 *pos, FVector3 *vel)
{
pos[1] = FIXED2FLOAT(players[consoleplayer].camera->z);
vel[1] = 0.f;
if (pos != NULL)
{
fixed_t x, y, z;
switch (type)
{
case SOURCE_None:
default:
if (players[consoleplayer].camera != NULL)
{
x = players[consoleplayer].camera->x;
y = players[consoleplayer].camera->z;
z = players[consoleplayer].camera->y;
}
else
{
pos[1] = FIXED2FLOAT(pt[2]);
z = y = x = 0;
}
break;
case SOURCE_Actor:
x = actor->x;
y = actor->z;
z = actor->y;
break;
case SOURCE_Sector:
x = sector->soundorg[0];
y = players[consoleplayer].camera != NULL ? players[consoleplayer].camera->z : 0;
z = sector->soundorg[1];
break;
case SOURCE_Polyobj:
x = poly->startSpot[0];
y = poly->startSpot[2];
z = poly->startSpot[1];
break;
case SOURCE_Unattached:
pos->X = pt->X;
pos->Y = !constz ? pt->Y : FIXED2FLOAT(players[consoleplayer].camera->z);
pos->Z = pt->Z;
break;
}
if (type != SOURCE_Unattached)
{
if (constz)
{
y = players[consoleplayer].camera != NULL ? players[consoleplayer].camera->z : 0;
}
pos->X = FIXED2FLOAT(x);
pos->Y = FIXED2FLOAT(y);
pos->Z = FIXED2FLOAT(z);
}
}
if (vel != NULL)
{
// Only actors maintain velocity information.
if (type == SOURCE_Actor)
{
vel->X = FIXED2FLOAT(actor->momx) * TICRATE;
vel->Y = FIXED2FLOAT(actor->momz) * TICRATE;
vel->Z = FIXED2FLOAT(actor->momy) * TICRATE;
}
else
{
vel->Zero();
}
}
}
@ -630,50 +766,54 @@ void CalcPosVel (fixed_t *pt, AActor *mover, int constz,
//
// S_StartSound
//
// 0 attenuation means full volume over whole level
// 0<attenuation<=1 means to scale the distance by that amount when
// calculating volume
// 0 attenuation means full volume over whole level.
// 0 < attenuation means to scale the distance by that amount when
// calculating volume.
//
//==========================================================================
static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
int channel, FSoundID sound_id, float volume, float attenuation)
static FSoundChan *S_StartSound(AActor *actor, const sector_t *sec, const FPolyObj *poly,
const FVector3 *pt, int channel, FSoundID sound_id, float volume, float attenuation)
{
sfxinfo_t *sfx;
int chanflags;
int basepriority;
int org_id;
int pitch;
fixed_t x, y, z;
FSoundChan *chan;
float pos[3];
float vel[3];
FVector3 pos, vel;
if (sound_id <= 0 || volume <= 0)
return NULL;
org_id = sound_id;
chanflags = channel & ~7;
int type;
if (pt == NULL)
if (actor != NULL)
{
attenuation = 0;
// Give these variables values, although they don't really matter
x = y = z = 0;
fixed_t pt2[3] = { 0, 0, 0 };
CalcPosVel (pt2, mover, chanflags & CHAN_LISTENERZ, pos, vel);
type = SOURCE_Actor;
}
else if (sec != NULL)
{
type = SOURCE_Sector;
}
else if (poly != NULL)
{
type = SOURCE_Polyobj;
}
else if (pt != NULL)
{
type = SOURCE_Unattached;
}
else
{
x = pt[0];
y = pt[1];
z = pt[2];
CalcPosVel (pt, mover, chanflags & CHAN_LISTENERZ, pos, vel);
type = SOURCE_None;
}
if (chanflags & CHAN_IMMOBILE)
{
pt = NULL;
}
org_id = sound_id;
chanflags = channel & ~7;
CalcPosVel(type, actor, sec, poly, pt, chanflags & CHAN_LISTENERZ, &pos, &vel);
if (i_compatflags & COMPATF_MAGICSILENCE)
{ // For people who just can't play without a silent BFG.
channel = CHAN_WEAPON;
@ -682,7 +822,7 @@ static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
{
if ((channel & CHAN_MAYBE_LOCAL) && (i_compatflags & COMPATF_SILENTPICKUP))
{
if (mover != NULL && mover != players[consoleplayer].camera)
if (actor != NULL && actor != players[consoleplayer].camera)
{
return NULL;
}
@ -706,7 +846,7 @@ static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
{
if (sfx->bPlayerReserve)
{
sound_id = FSoundID(S_FindSkinnedSound (mover, sound_id));
sound_id = FSoundID(S_FindSkinnedSound (actor, sound_id));
near_limit = S_sfx[sound_id].NearLimit;
}
else if (sfx->bRandomHeader)
@ -730,7 +870,7 @@ static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
// If the sound is unpositioned or comes from the listener, it is
// never limited.
if (pt == NULL || mover == players[consoleplayer].camera)
if (type == SOURCE_None || actor == players[consoleplayer].camera)
{
near_limit = 0;
}
@ -760,7 +900,7 @@ static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
}
// Select priority.
if (attenuation <= 0 || mover == players[consoleplayer].camera)
if (type == SOURCE_None || actor == players[consoleplayer].camera)
{
basepriority = 40;
}
@ -769,9 +909,9 @@ static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
basepriority = 0;
}
if (mover != NULL && channel == CHAN_AUTO)
if (actor != NULL && channel == CHAN_AUTO)
{ // Select a channel that isn't already playing something.
BYTE mask = mover->SoundChans;
BYTE mask = actor->SoundChans;
// Try channel 0 first, then travel from channel 7 down.
if ((mask & 1) == 0)
@ -795,17 +935,31 @@ static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
}
// If this actor is already playing something on the selected channel, stop it.
if ((mover == NULL && channel != CHAN_AUTO) || (mover != NULL && mover->SoundChans & (1 << channel)))
if ((actor == NULL && channel != CHAN_AUTO) || (actor != NULL && actor->SoundChans & (1 << channel)))
{
for (chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (((mover != NULL && chan->Mover == mover) || (chan->Pt == pt)) && chan->EntChannel == channel)
if (chan->SourceType == type && chan->EntChannel == channel)
{
bool foundit;
switch (type)
{
case SOURCE_None: foundit = true; break;
case SOURCE_Actor: foundit = (chan->Actor == actor); break;
case SOURCE_Sector: foundit = (chan->Sector == sec); break;
case SOURCE_Polyobj: foundit = (chan->Poly == poly); break;
case SOURCE_Unattached: foundit = (chan->Point[0] == pt->X && chan->Point[2] == pt->Z && chan->Point[1] == pt->Y); break;
default: foundit = false; break;
}
if (foundit)
{
GSnd->StopSound(chan);
break;
}
}
}
}
// Vary the sfx pitches.
if (sfx->PitchMask != 0)
@ -846,23 +1000,22 @@ static FSoundChan *S_StartSound (fixed_t *pt, AActor *mover, sector_t *sec,
{
chan->SoundID = sound_id;
chan->OrgID = FSoundID(org_id);
chan->Mover = mover;
chan->Pt = pt != NULL ? pt : &chan->X;
chan->Sector = sec;
chan->SfxInfo = sfx;
chan->EntChannel = channel;
chan->Volume = volume;
chan->X = x;
chan->Y = y;
chan->Z = z;
chan->ChanFlags |= chanflags;
chan->NearLimit = near_limit;
chan->Pitch = pitch;
chan->Priority = basepriority;
chan->DistanceScale = attenuation;
if (mover != NULL)
chan->SourceType = type;
switch (type)
{
mover->SoundChans |= 1 << channel;
case SOURCE_Actor: chan->Actor = actor; actor->SoundChans |= 1 << channel; break;
case SOURCE_Sector: chan->Sector = sec; break;
case SOURCE_Polyobj: chan->Poly = poly; break;
case SOURCE_Unattached: chan->Point[0] = pt->X; chan->Point[1] = pt->Y; chan->Point[2] = pt->Z; break;
default: break;
}
}
return chan;
@ -898,9 +1051,9 @@ void S_RestartSound(FSoundChan *chan)
if (chan->ChanFlags & CHAN_IS3D)
{
float pos[3], vel[3];
FVector3 pos, vel;
CalcPosVel(chan->Pt, chan->Mover, chan->ChanFlags & CHAN_LISTENERZ, pos, vel);
CalcPosVel(chan, &pos, &vel);
// If this sound doesn't like playing near itself, don't play it if
// that's what would happen.
@ -923,9 +1076,9 @@ void S_RestartSound(FSoundChan *chan)
// When called from the savegame loader, the actor's SoundChans
// flags will be cleared. During normal gameplay, they should still
// be set.
if (ochan->Mover != NULL)
if (ochan->SourceType == SOURCE_Actor)
{
ochan->Mover->SoundChans |= 1 << ochan->EntChannel;
ochan->Actor->SoundChans |= 1 << ochan->EntChannel;
}
}
}
@ -938,12 +1091,12 @@ void S_RestartSound(FSoundChan *chan)
void S_Sound (int channel, FSoundID sound_id, float volume, float attenuation)
{
S_StartSound ((fixed_t *)NULL, NULL, NULL, channel, sound_id, volume, attenuation);
S_StartSound (NULL, NULL, NULL, NULL, channel, sound_id, volume, attenuation);
}
//==========================================================================
//
// S_Sound - Actor is source
// S_Sound - An actor is source
//
//==========================================================================
@ -951,18 +1104,18 @@ void S_Sound (AActor *ent, int channel, FSoundID sound_id, float volume, float a
{
if (ent->Sector->Flags & SECF_SILENT)
return;
S_StartSound (&ent->x, ent, NULL, channel, sound_id, volume, attenuation);
S_StartSound (ent, NULL, NULL, NULL, channel, sound_id, volume, attenuation);
}
//==========================================================================
//
// S_Sound - A random coordinate is source
// S_Sound - A polyobject is source
//
//==========================================================================
void S_Sound (fixed_t *pt, int channel, FSoundID sound_id, float volume, float attenuation)
void S_Sound (const FPolyObj *poly, int channel, FSoundID sound_id, float volume, float attenuation)
{
S_StartSound (pt, NULL, NULL, channel, sound_id, volume, attenuation);
S_StartSound (NULL, NULL, poly, NULL, channel, sound_id, volume, attenuation);
}
//==========================================================================
@ -973,11 +1126,8 @@ void S_Sound (fixed_t *pt, int channel, FSoundID sound_id, float volume, float a
void S_Sound (fixed_t x, fixed_t y, fixed_t z, int channel, FSoundID sound_id, float volume, float attenuation)
{
fixed_t pt[3];
pt[0] = x;
pt[1] = y;
pt[2] = z;
S_StartSound (pt, NULL, NULL, channel|CHAN_IMMOBILE, sound_id, volume, attenuation);
FVector3 pt(FIXED2FLOAT(x), FIXED2FLOAT(z), FIXED2FLOAT(y));
S_StartSound (NULL, NULL, NULL, &pt, channel, sound_id, volume, attenuation);
}
//==========================================================================
@ -986,9 +1136,9 @@ void S_Sound (fixed_t x, fixed_t y, fixed_t z, int channel, FSoundID sound_id, f
//
//==========================================================================
void S_Sound (sector_t *sec, int channel, FSoundID sfxid, float volume, float attenuation)
void S_Sound (const sector_t *sec, int channel, FSoundID sfxid, float volume, float attenuation)
{
S_StartSound (sec->soundorg, NULL, sec, channel, sfxid, volume, attenuation);
S_StartSound (NULL, sec, NULL, NULL, channel, sfxid, volume, attenuation);
}
//==========================================================================
@ -1043,7 +1193,7 @@ bool S_CheckSingular(int sound_id)
//
//==========================================================================
bool S_CheckSoundLimit(sfxinfo_t *sfx, float pos[3], int near_limit)
bool S_CheckSoundLimit(sfxinfo_t *sfx, const FVector3 &pos, int near_limit)
{
FSoundChan *chan;
int count;
@ -1052,10 +1202,10 @@ bool S_CheckSoundLimit(sfxinfo_t *sfx, float pos[3], int near_limit)
{
if (!(chan->ChanFlags & CHAN_EVICTED) && chan->SfxInfo == sfx)
{
double dx = FIXED2FLOAT(chan->Pt[0]) - pos[0];
double dy = FIXED2FLOAT(chan->Pt[1]) - pos[2];
double dz = FIXED2FLOAT(chan->Pt[2]) - pos[1];
if (dx*dx + dy*dy + dz*dz <= 256.0*256.0)
FVector3 chanorigin;
CalcPosVel(chan, &chanorigin, NULL);
if ((chanorigin - pos).LengthSquared() <= 256.0*256.0)
{
count++;
}
@ -1068,27 +1218,86 @@ bool S_CheckSoundLimit(sfxinfo_t *sfx, float pos[3], int near_limit)
//
// S_StopSound
//
// Stops a sound from a single source playing on a specific channel.
// Stops an unpositioned sound from playing on a specific channel.
//
//==========================================================================
void S_StopSound (fixed_t *pt, int channel)
void S_StopSound (int channel)
{
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (((pt == NULL && chan->Pt == &chan->X) || chan->Pt == pt) &&
((i_compatflags & COMPATF_MAGICSILENCE) || chan->EntChannel == channel))
if (chan->SourceType == SOURCE_None &&
(chan->EntChannel == channel || (i_compatflags & COMPATF_MAGICSILENCE)))
{
GSnd->StopSound(chan);
}
}
}
void S_StopSound (AActor *ent, int channel)
//==========================================================================
//
// S_StopSound
//
// Stops a sound from a single actor from playing on a specific channel.
//
//==========================================================================
void S_StopSound (AActor *actor, int channel)
{
// No need to search every channel if we know it's not playing anything.
if (ent != NULL && ent->SoundChans & (1 << channel))
if (actor != NULL && actor->SoundChans & (1 << channel))
{
S_StopSound (&ent->x, channel);
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->SourceType == SOURCE_Actor &&
chan->Actor == actor &&
(chan->EntChannel == channel || (i_compatflags & COMPATF_MAGICSILENCE)))
{
GSnd->StopSound(chan);
}
}
}
}
//==========================================================================
//
// S_StopSound
//
// Stops a sound from a single sector from playing on a specific channel.
//
//==========================================================================
void S_StopSound (const sector_t *sec, int channel)
{
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->SourceType == SOURCE_Sector &&
chan->Sector == sec &&
(chan->EntChannel == channel || (i_compatflags & COMPATF_MAGICSILENCE)))
{
GSnd->StopSound(chan);
}
}
}
//==========================================================================
//
// S_StopSound
//
// Stops a sound from a single polyobject from playing on a specific channel.
//
//==========================================================================
void S_StopSound (const FPolyObj *poly, int channel)
{
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->SourceType == SOURCE_Polyobj &&
chan->Poly == poly &&
(chan->EntChannel == channel || (i_compatflags & COMPATF_MAGICSILENCE)))
{
GSnd->StopSound(chan);
}
}
}
@ -1123,18 +1332,18 @@ void S_RelinkSound (AActor *from, AActor *to)
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->Mover == from)
if (chan->SourceType == SOURCE_Actor && chan->Actor == from)
{
if (to != NULL || !(chan->ChanFlags & CHAN_LOOP))
if (to != NULL)
{
if (chan->Pt == &from->x)
{
chan->Pt = to ? &to->x : &chan->X;
chan->X = from->x;
chan->Y = from->y;
chan->Z = from->z;
chan->Actor = to;
}
chan->Mover = to;
else if (!(chan->ChanFlags & CHAN_LOOP))
{
chan->SourceType = SOURCE_Unattached;
chan->Point[0] = FIXED2FLOAT(from->x);
chan->Point[1] = FIXED2FLOAT(from->z);
chan->Point[2] = FIXED2FLOAT(from->y);
}
else
{
@ -1148,25 +1357,58 @@ void S_RelinkSound (AActor *from, AActor *to)
//
// S_GetSoundPlayingInfo
//
// Is a sound being played by a specific actor/point?
// Is a sound being played by a specific emitter?
//==========================================================================
bool S_GetSoundPlayingInfo (fixed_t *pt, int sound_id)
bool S_GetSoundPlayingInfo (const AActor *actor, int sound_id)
{
if (sound_id > 0)
{
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->Pt == pt && chan->OrgID == sound_id)
if (chan->OrgID == sound_id &&
chan->SourceType == SOURCE_Actor &&
chan->Actor == actor)
{
return true;
}
}
}
return false;
}
bool S_GetSoundPlayingInfo (AActor *ent, int sound_id)
bool S_GetSoundPlayingInfo (const sector_t *sec, int sound_id)
{
return S_GetSoundPlayingInfo (ent ? &ent->x : NULL, sound_id);
if (sound_id > 0)
{
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->OrgID == sound_id &&
chan->SourceType == SOURCE_Sector &&
chan->Sector == sec)
{
return true;
}
}
}
return false;
}
bool S_GetSoundPlayingInfo (const FPolyObj *poly, int sound_id)
{
if (sound_id > 0)
{
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->OrgID == sound_id &&
chan->SourceType == SOURCE_Polyobj &&
chan->Poly == poly)
{
return true;
}
}
}
return false;
}
//==========================================================================
@ -1189,7 +1431,7 @@ bool S_IsActorPlayingSomething (AActor *actor, int channel, int sound_id)
for (FSoundChan *chan = Channels; chan != NULL; chan = chan->NextChan)
{
if (chan->Pt == &actor->x)
if (chan->SourceType == SOURCE_Actor && chan->Actor == actor)
{
if (channel == 0 || chan->EntChannel == channel)
{
@ -1319,7 +1561,7 @@ void S_RestoreEvictedChannels()
void S_UpdateSounds (void *listener_p)
{
float pos[3], vel[3];
FVector3 pos, vel;
I_UpdateMusic();
@ -1338,7 +1580,7 @@ void S_UpdateSounds (void *listener_p)
{
if ((chan->ChanFlags & (CHAN_EVICTED | CHAN_IS3D)) == CHAN_IS3D)
{
CalcPosVel(chan->Pt, chan->Mover, chan->ChanFlags & CHAN_LISTENERZ, pos, vel);
CalcPosVel(chan, &pos, &vel);
GSnd->UpdateSoundParams3D(chan, pos, vel);
}
chan->ChanFlags &= ~CHAN_JUSTSTARTED;
@ -1379,31 +1621,16 @@ FArchive &operator<<(FArchive &arc, FSoundID &sid)
static FArchive &operator<<(FArchive &arc, FSoundChan &chan)
{
BYTE pt_type;
if (arc.IsStoring())
arc << chan.SourceType;
switch (chan.SourceType)
{
if (chan.Pt == &chan.X)
{
pt_type = 2;
case SOURCE_None: break;
case SOURCE_Actor: arc << chan.Actor; break;
case SOURCE_Sector: arc << chan.Sector; break;
case SOURCE_Polyobj: arc << chan.Poly; break;
case SOURCE_Unattached: arc << chan.Point[0] << chan.Point[1] << chan.Point[2]; break;
default: I_Error("Unknown sound source type %d\n", chan.SourceType); break;
}
else if (chan.Pt == &chan.Mover->x)
{
pt_type = 1;
}
else
{ // WTF?
assert(0);
pt_type = 0;
}
}
arc << pt_type;
arc << chan.Mover;
arc << chan.Sector;
arc << chan.X;
arc << chan.Y;
arc << chan.Z;
arc << chan.SoundID;
arc << chan.OrgID;
arc << chan.Volume;
@ -1418,18 +1645,6 @@ static FArchive &operator<<(FArchive &arc, FSoundChan &chan)
if (arc.IsLoading())
{
chan.SfxInfo = &S_sfx[chan.SoundID];
if (pt_type == 1)
{
chan.Pt = &chan.Mover->x;
}
else if (pt_type == 2)
{
chan.Pt = &chan.X;
}
else
{
chan.Pt = &chan.Mover->x;
}
}
return arc;
}

41
src/s_sound.h
View file

@ -167,26 +167,31 @@ extern int S_SoundCurveSize;
// Information about one playing sound.
struct sector_t;
struct FPolyObj;
struct FSoundChan
{
void *SysChannel;// Channel information from the system interface.
FSoundChan *NextChan; // Next channel in this list.
FSoundChan **PrevChan; // Previous channel in this list.
AActor *Mover; // Used for velocity.
sector_t *Sector; // Sector for area sounds.
fixed_t *Pt; // Origin of sound.
sfxinfo_t *SfxInfo; // Sound information.
fixed_t X,Y,Z; // Origin if Mover is NULL.
QWORD_UNION StartTime; // Sound start time in DSP clocks.
FSoundID SoundID; // Sound ID of playing sound.
FSoundID OrgID; // Sound ID of sound used to start this channel.
float Volume;
float DistanceScale;
int Pitch; // Pitch variation.
int ChanFlags;
SWORD Pitch; // Pitch variation.
BYTE EntChannel; // Actor's sound channel.
SBYTE Priority;
SWORD NearLimit;
QWORD_UNION StartTime; // Sound start time in DSP clocks.
BYTE SourceType;
union
{
AActor *Actor; // Used for position and velocity.
const sector_t *Sector; // Sector for area sounds.
const FPolyObj *Poly; // Polyobject sound source.
float Point[3]; // Sound is not attached to any source.
};
};
extern FSoundChan *Channels;
@ -219,9 +224,9 @@ void S_CacheSound (sfxinfo_t *sfx);
// Start sound for thing at <ent>
void S_Sound (int channel, FSoundID sfxid, float volume, float attenuation);
void S_Sound (AActor *ent, int channel, FSoundID sfxid, float volume, float attenuation);
void S_Sound (fixed_t *pt, int channel, FSoundID sfxid, float volume, float attenuation);
void S_Sound (const FPolyObj *poly, int channel, FSoundID sfxid, float volume, float attenuation);
void S_Sound (const sector_t *sec, int channel, FSoundID sfxid, float volume, float attenuation);
void S_Sound (fixed_t x, fixed_t y, fixed_t z, int channel, FSoundID sfxid, float volume, float attenuation);
void S_Sound (sector_t *sec, int channel, FSoundID sfxid, float volume, float attenuation);
// sound channels
// channel 0 never willingly overrides
@ -249,8 +254,8 @@ void S_Sound (sector_t *sec, int channel, FSoundID sfxid, float volume, float at
// modifier flags
#define CHAN_LISTENERZ 8
#define CHAN_IMMOBILE 16
#define CHAN_MAYBE_LOCAL 32
#define CHAN_MAYBE_LOCAL 16
#define CHAN_UI 32 // Do not record sound in savegames.
#define CHAN_NOPAUSE 64 // Do not pause this sound in menus.
#define CHAN_AREA 128 // Sound plays from all around. Only valid with sector sounds.
#define CHAN_LOOP 256
@ -274,16 +279,22 @@ void S_CacheRandomSound (sfxinfo_t *sfx);
// Checks if a copy of this sound is already playing.
bool S_CheckSingular (int sound_id);
// Stops a sound emanating from one of an entity's channels
// Stops a sound emanating from one of an emitter's channels.
void S_StopSound (AActor *ent, int channel);
void S_StopSound (fixed_t *pt, int channel);
void S_StopSound (const sector_t *sec, int channel);
void S_StopSound (const FPolyObj *poly, int channel);
// Stops an origin-less sound from playing from this channel.
void S_StopSound (int channel);
// Stop sound for all channels
void S_StopAllChannels (void);
// Is the sound playing on one of the entity's channels?
bool S_GetSoundPlayingInfo (AActor *ent, int sound_id);
bool S_GetSoundPlayingInfo (fixed_t *pt, int sound_id);
// Is the sound playing on one of the emitter's channels?
bool S_GetSoundPlayingInfo (const AActor *actor, int sound_id);
bool S_GetSoundPlayingInfo (const sector_t *sector, int sound_id);
bool S_GetSoundPlayingInfo (const FPolyObj *poly, int sound_id);
bool S_IsActorPlayingSomething (AActor *actor, int channel, int sound_id);
// Moves all sounds from one mobj to another

38
src/sound/fmodsound.cpp
View file

@ -67,8 +67,6 @@ extern HWND Window;
// Just some extra for music and whatever
#define NUM_EXTRA_SOFTWARE_CHANNELS 1
#define FIXED2FLOAT(x) ((x)/65536.f)
#define MAX_CHANNELS 256
#define SPECTRUM_SIZE 256
@ -1408,8 +1406,8 @@ FSoundChan *FMODSoundRenderer::StartSound(sfxinfo_t *sfx, float vol, int pitch,
CVAR(Float, snd_3dspread, 180, 0)
FSoundChan *FMODSoundRenderer::StartSound3D(sfxinfo_t *sfx, float vol, float distscale,
int pitch, int priority, float pos[3], float vel[3], sector_t *sector, int channum, int chanflags,
FSoundChan *reuse_chan)
int pitch, int priority, const FVector3 &pos, const FVector3 &vel, const sector_t *sector,
int channum, int chanflags, FSoundChan *reuse_chan)
{
int id = int(sfx - &S_sfx[0]);
FMOD_RESULT result;
@ -1480,7 +1478,7 @@ FSoundChan *FMODSoundRenderer::StartSound3D(sfxinfo_t *sfx, float vol, float dis
chan->setVolume(vol);
if (mode & FMOD_3D)
{
chan->set3DAttributes((FMOD_VECTOR *)pos, (FMOD_VECTOR *)vel);
chan->set3DAttributes((FMOD_VECTOR *)&pos[0], (FMOD_VECTOR *)&vel[0]);
chan->set3DSpread(snd_3dspread);
}
HandleChannelDelay(chan, reuse_chan, freq);
@ -1546,16 +1544,17 @@ void FMODSoundRenderer::HandleChannelDelay(FMOD::Channel *chan, FSoundChan *reus
//
//==========================================================================
FMOD_MODE FMODSoundRenderer::SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t *sfx, float pos[3], int channum, int chanflags, sector_t *sec, FMOD_MODE oldmode) const
FMOD_MODE FMODSoundRenderer::SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t *sfx, const FVector3 &pos, int channum, int chanflags, const sector_t *sec, FMOD_MODE oldmode) const
{
if (players[consoleplayer].camera == NULL)
{
return oldmode;
}
float cpos[3];
cpos[0] = FIXED2FLOAT(players[consoleplayer].camera->x);
cpos[2] = FIXED2FLOAT(players[consoleplayer].camera->y);
cpos[1] = FIXED2FLOAT(players[consoleplayer].camera->z);
FVector3 cpos, mpos;
cpos.X = FIXED2FLOAT(players[consoleplayer].camera->x);
cpos.Y = FIXED2FLOAT(players[consoleplayer].camera->z);
cpos.Z = FIXED2FLOAT(players[consoleplayer].camera->y);
mpos = pos;
if ((chanflags & CHAN_AREA) && sec != NULL)
{
@ -1567,8 +1566,8 @@ FMOD_MODE FMODSoundRenderer::SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t
// Are we inside the sector? If yes, the closest point is the one we're on.
if (P_PointInSector(players[consoleplayer].camera->x, players[consoleplayer].camera->y) == sec)
{
pos[0] = cpos[0];
pos[2] = cpos[2];
mpos[0] = cpos[0];
mpos[2] = cpos[2];
cx = players[consoleplayer].camera->x;
cy = players[consoleplayer].camera->y;
}
@ -1577,8 +1576,8 @@ FMOD_MODE FMODSoundRenderer::SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t
// Find the closest point on the sector's boundary lines and use
// that as the perceived origin of the sound.
sec->ClosestPoint(players[consoleplayer].camera->x, players[consoleplayer].camera->y, cx, cy);
pos[0] = FIXED2FLOAT(cx);
pos[2] = FIXED2FLOAT(cy);
mpos[0] = FIXED2FLOAT(cx);
mpos[2] = FIXED2FLOAT(cy);
}
// Set sound height based on channel.
if (channum == CHAN_FLOOR)
@ -1598,13 +1597,12 @@ FMOD_MODE FMODSoundRenderer::SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t
{
cz = players[consoleplayer].camera->z;
}
pos[1] = FIXED2FLOAT(cz);
mpos[1] = FIXED2FLOAT(cz);
// How far are we from the perceived sound origin? Within a certain
// short distance, we interpolate between 2D panning and full 3D panning.
const double interp_range = 32.0;
double dx = cpos[0] - pos[0], dy = cpos[1] - pos[1], dz = cpos[2] - pos[2];
double dist_sqr = dx*dx + dy*dy + dz*dz;
double dist_sqr = (cpos - mpos).LengthSquared();
if (dist_sqr == 0)
{
@ -1630,7 +1628,7 @@ FMOD_MODE FMODSoundRenderer::SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t
}
return oldmode;
}
else if (cpos[0] == pos[0] && cpos[1] == pos[1] && cpos[2] == pos[2])
else if (cpos == mpos)
{ // Head relative
return (oldmode & ~FMOD_3D) | FMOD_2D;
}
@ -1754,7 +1752,7 @@ void FMODSoundRenderer::SetInactive(bool inactive)
//
//==========================================================================
void FMODSoundRenderer::UpdateSoundParams3D(FSoundChan *chan, float pos[3], float vel[3])
void FMODSoundRenderer::UpdateSoundParams3D(FSoundChan *chan, const FVector3 &pos, const FVector3 &vel)
{
if (chan == NULL || chan->SysChannel == NULL)
return;
@ -1771,7 +1769,7 @@ void FMODSoundRenderer::UpdateSoundParams3D(FSoundChan *chan, float pos[3], floa
{ // Only set the mode if it changed.
fchan->setMode(mode);
}
fchan->set3DAttributes((FMOD_VECTOR *)pos, (FMOD_VECTOR *)vel);
fchan->set3DAttributes((FMOD_VECTOR *)&pos[0], (FMOD_VECTOR *)&vel[0]);
}
//==========================================================================

6
src/sound/fmodsound.h
View file

@ -26,7 +26,7 @@ public:
// Starts a sound.
FSoundChan *StartSound (sfxinfo_t *sfx, float vol, int pitch, int chanflags, FSoundChan *reuse_chan);
FSoundChan *StartSound3D (sfxinfo_t *sfx, float vol, float distscale, int pitch, int priority, float pos[3], float vel[3], sector_t *sector, int channum, int chanflags, FSoundChan *reuse_chan);
FSoundChan *StartSound3D (sfxinfo_t *sfx, float vol, float distscale, int pitch, int priority, const FVector3 &pos, const FVector3 &vel, const sector_t *sector, int channum, int chanflags, FSoundChan *reuse_chan);
// Stops a sound channel.
void StopSound (FSoundChan *chan);
@ -44,7 +44,7 @@ public:
void SetInactive (bool inactive);
// Updates the position of a sound channel.
void UpdateSoundParams3D (FSoundChan *chan, float pos[3], float vel[3]);
void UpdateSoundParams3D (FSoundChan *chan, const FVector3 &pos, const FVector3 &vel);
void UpdateListener ();
void UpdateSounds ();
@ -69,7 +69,7 @@ private:
void HandleChannelDelay(FMOD::Channel *chan, FSoundChan *reuse_chan, float freq) const;
FSoundChan *CommonChannelSetup(FMOD::Channel *chan, FSoundChan *reuse_chan) const;
FMOD_MODE SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t *sfx, float pos[3], int channum, int chanflags, sector_t *sec, FMOD_MODE oldmode) const;
FMOD_MODE SetChanHeadSettings(FMOD::Channel *chan, sfxinfo_t *sfx, const FVector3 &pos, int channum, int chanflags, const sector_t *sec, FMOD_MODE oldmode) const;
void DoLoad (void **slot, sfxinfo_t *sfx);
void getsfx (sfxinfo_t *sfx);

4
src/sound/i_sound.cpp
View file

@ -148,7 +148,7 @@ public:
{
return NULL;
}
FSoundChan *StartSound3D (sfxinfo_t *sfx, float vol, float distscale, int pitch, int priority, float pos[3], float vel[3], sector_t *sector, int channum, int chanflags, FSoundChan *reuse_chan)
FSoundChan *StartSound3D (sfxinfo_t *sfx, float vol, float distscale, int pitch, int priority, const FVector3 &pos, const FVector3 &vel, const sector_t *sector, int channum, int chanflags, FSoundChan *reuse_chan)
{
return NULL;
}
@ -184,7 +184,7 @@ public:
}
// Updates the volume, separation, and pitch of a sound channel.
void UpdateSoundParams3D (FSoundChan *chan, float pos[3], float vel[3])
void UpdateSoundParams3D (FSoundChan *chan, const FVector3 &pos, const FVector3 &vel)
{
}

4
src/sound/i_sound.h
View file

@ -90,7 +90,7 @@ public:
// Starts a sound.
virtual FSoundChan *StartSound (sfxinfo_t *sfx, float vol, int pitch, int chanflags, FSoundChan *reuse_chan) = 0;
virtual FSoundChan *StartSound3D (sfxinfo_t *sfx, float vol, float distscale, int pitch, int priority, float pos[3], float vel[3], sector_t *sector, int channum, int chanflags, FSoundChan *reuse_chan) = 0;
virtual FSoundChan *StartSound3D (sfxinfo_t *sfx, float vol, float distscale, int pitch, int priority, const FVector3 &pos, const FVector3 &vel, const sector_t *sector, int channum, int chanflags, FSoundChan *reuse_chan) = 0;
// Stops a sound channel.
virtual void StopSound (FSoundChan *chan) = 0;
@ -108,7 +108,7 @@ public:
virtual void SetInactive(bool inactive) = 0;
// Updates the volume, separation, and pitch of a sound channel.
virtual void UpdateSoundParams3D (FSoundChan *chan, float pos[3], float vel[3]) = 0;
virtual void UpdateSoundParams3D (FSoundChan *chan, const FVector3 &pos, const FVector3 &vel) = 0;
virtual void UpdateListener () = 0;
virtual void UpdateSounds () = 0;

1
src/textures/multipatchtexture.cpp
View file

@ -43,7 +43,6 @@
#include "st_start.h"
#include "sc_man.h"
#include "templates.h"
#include "vectors.h"
#include "r_translate.h"
#include "bitmap.h"

1
src/thingdef/olddecorations.cpp
View file

@ -50,7 +50,6 @@
#include "decallib.h"
#include "i_system.h"
#include "thingdef.h"
#include "vectors.h"
#include "r_translate.h"
// TYPES -------------------------------------------------------------------

1
src/thingdef/thingdef_codeptr.cpp
View file

@ -60,7 +60,6 @@
#include "p_local.h"
#include "c_console.h"
#include "doomerrors.h"
#include "vectors.h"
#include "a_sharedglobal.h"
#include "a_doomglobal.h"
#include "thingdef/thingdef.h"

1
src/thingdef/thingdef_exp.cpp
View file

@ -41,7 +41,6 @@
#include "sc_man.h"
#include "tarray.h"
#include "templates.h"
#include "vectors.h"
#include "cmdlib.h"
#include "i_system.h"
#include "m_random.h"

1
src/thingdef/thingdef_main.cpp
View file

@ -43,7 +43,6 @@
#include "s_sound.h"
#include "cmdlib.h"
#include "thingdef.h"
#include "vectors.h"
// EXTERNAL FUNCTION PROTOTYPES --------------------------------------------