2020-04-09 19:50:24 +01:00
# pragma once
2019-06-24 15:57:54 +01:00
2020-04-28 12:00:38 +01:00
# include "audio_enums.h"
2020-01-25 10:41:22 +00:00
# include "AudioCollision.h"
2021-02-26 09:05:37 +00:00
# include "PolRadio.h"
2019-06-12 18:56:45 +01:00
2020-01-13 17:36:30 +00:00
class tSound
2019-10-19 12:21:35 +01:00
{
public :
2021-08-20 11:02:58 +01:00
int32 m_nEntityIndex ; // audio entity index
2021-08-15 11:14:16 +01:00
# if GTA_VERSION >= GTA3_PC_10
2021-08-20 11:02:58 +01:00
uint32 m_nCounter ; // I'm not sure what this is but it looks like a virtual counter to determine the same sound in queue
// Values higher than 255 are used by reflections
2021-08-15 11:14:16 +01:00
# else
uint8 m_nCounter ;
# endif
2021-08-20 11:02:58 +01:00
uint32 m_nSampleIndex ; // An index of sample from AudioSamples.h
uint8 m_nBankIndex ; // A sound bank index. IDK what's the point of it here since samples are hardcoded anyway
bool8 m_bIs2D ; // If TRUE then sound is played in 2D space (such as frontend or police radio)
uint32 m_nPriority ; // The multiplier for the sound priority (see m_nFinalPriority below). Lesser value means higher priority
uint32 m_nFrequency ; // Sound frequency, plain and simple
uint8 m_nVolume ; // Sound volume (0..127), only used as an actual volume without EXTERNAL_3D_SOUND (see m_nEmittingVolume)
float m_fDistance ; // Distance to camera (useless if m_bIs2D == TRUE)
uint32 m_nLoopCount ; // 0 - always loop, 1 - don't loop, other values never seen
2021-06-12 17:19:31 +01:00
# ifndef GTA_PS2
2021-08-20 11:02:58 +01:00
// Loop offsets
2021-08-17 11:58:48 +01:00
uint32 m_nLoopStart ;
2019-07-12 17:27:12 +01:00
int32 m_nLoopEnd ;
2021-08-11 13:33:50 +01:00
# endif
# ifdef EXTERNAL_3D_SOUND
2021-08-20 11:02:58 +01:00
uint8 m_nEmittingVolume ; // The volume in 3D space, provided to 3D audio engine
2021-07-26 02:18:41 +01:00
# endif
2021-08-20 11:02:58 +01:00
float m_fSpeedMultiplier ; // Used for doppler effect. 0.0f - unaffected by doppler
2021-08-15 11:14:16 +01:00
# if GTA_VERSION >= GTA3_PC_10
2021-08-20 11:02:58 +01:00
float m_MaxDistance ; // The maximum distance at which sound could be heard. Minimum distance = MaxDistance / 5 or MaxDistance / 4 in case of emitting volume (useless if m_bIs2D == TRUE)
2021-08-15 11:14:16 +01:00
# else
2021-08-20 11:02:58 +01:00
uint32 m_MaxDistance ;
2021-08-15 11:14:16 +01:00
# endif
2021-08-20 11:02:58 +01:00
bool8 m_bStatic ; // If TRUE then sound parameters cannot be changed during playback (frequency, position, etc.)
CVector m_vecPos ; // Position of sound in 3D space. Unused if m_bIs2D == TRUE
bool8 m_bReverb ; // Toggles reverb effect
2021-08-17 11:58:48 +01:00
# ifdef AUDIO_REFLECTIONS
2021-08-20 11:02:58 +01:00
uint8 m_nReflectionDelay ; // Number of frames before reflection could be played. This is calculated internally by AudioManager and shouldn't be set by queued sample
bool8 m_bReflections ; // Add sound reflections
2021-08-15 11:14:16 +01:00
# endif
2021-08-20 11:02:58 +01:00
uint8 m_nPan ; // Sound panning (0-127). Controls the volume of the playback coming from left and right speaker. Calculated internally unless m_bIs2D==TRUE.
// 0 = L 100% R 0%
// 63 = L 100% R 100%
// 127 = L 0% R 100%
2021-08-24 11:11:36 +01:00
# ifndef FIX_BUGS
2021-08-20 11:02:58 +01:00
uint32 m_nFramesToPlay ; // Number of frames the sound would be played (if it stops being queued).
// This one is being set by queued sample for looping sounds, otherwise calculated inside AudioManager
2021-08-24 11:11:36 +01:00
# else
float m_nFramesToPlay ; // Made into float for high fps fix
# endif
2021-08-20 11:02:58 +01:00
// all fields below are internal to AudioManager calculations and aren't set by queued sample
bool8 m_bIsBeingPlayed ; // Set to TRUE when the sound was added or changed on current frame to avoid it being overwritten
bool8 m_bIsPlayingFinished ; // Not sure about the name. Set to TRUE when sampman channel becomes free
2021-08-15 11:14:16 +01:00
# if GTA_VERSION < GTA3_PC_10
2021-08-25 06:49:42 +01:00
int32 unk ; // (inherited from GTA 2) Only on PS2, used by static non-looped sounds (AFAIK)
2021-08-20 11:02:58 +01:00
// Looks like it's keeping a number of frames left to play with the purpose of setting m_bIsPlayingFinished=TRUE once value reaches 0
// Default value is -3 for whatever reason
2021-08-15 11:14:16 +01:00
# endif
2021-08-20 11:02:58 +01:00
uint32 m_nFinalPriority ; // Actual value used to compare priority, calculated using volume and m_nPriority. Lesser value means higher priority
2021-08-20 12:28:18 +01:00
int8 m_nVolumeChange ; // How much m_nVolume should reduce per each frame.
2021-08-24 11:11:36 +01:00
# if defined(FIX_BUGS) && defined(EXTERNAL_3D_SOUND)
int8 m_nEmittingVolumeChange ; // same as above but for m_nEmittingVolume
# endif
2019-06-12 18:56:45 +01:00
} ;
2020-05-10 16:49:33 +01:00
VALIDATE_SIZE ( tSound , 92 ) ;
2019-06-12 18:56:45 +01:00
2019-07-02 19:35:47 +01:00
class CPhysical ;
2019-08-02 16:43:40 +01:00
class CAutomobile ;
2019-07-02 19:35:47 +01:00
2019-10-19 12:21:35 +01:00
class tAudioEntity
{
public :
2019-06-12 18:56:45 +01:00
eAudioType m_nType ;
2019-07-16 16:03:37 +01:00
void * m_pEntity ;
2021-05-22 10:11:50 +01:00
bool8 m_bIsUsed ;
2021-07-28 22:40:32 +01:00
bool8 m_bStatus ;
2020-03-21 13:51:30 +00:00
int16 m_awAudioEvent [ NUM_AUDIOENTITY_EVENTS ] ;
float m_afVolume [ NUM_AUDIOENTITY_EVENTS ] ;
2019-10-26 15:47:57 +01:00
uint8 m_AudioEvents ;
2019-06-12 18:56:45 +01:00
} ;
2020-05-10 16:49:33 +01:00
VALIDATE_SIZE ( tAudioEntity , 40 ) ;
2019-06-12 18:56:45 +01:00
2019-10-19 12:21:35 +01:00
class tPedComment
{
public :
2021-08-17 11:58:48 +01:00
uint32 m_nSampleIndex ;
2020-04-07 14:44:31 +01:00
int32 m_nEntityIndex ;
2019-06-12 18:56:45 +01:00
CVector m_vecPos ;
float m_fDistance ;
2021-08-16 12:21:51 +01:00
uint8 m_nVolume ;
2020-04-13 02:19:20 +01:00
int8 m_nProcess ;
2021-08-16 12:21:51 +01:00
# if defined(EXTERNAL_3D_SOUND) && defined(FIX_BUGS)
uint8 m_nEmittingVolume ;
# endif
2019-06-12 18:56:45 +01:00
} ;
2020-05-10 16:49:33 +01:00
VALIDATE_SIZE ( tPedComment , 28 ) ;
2019-06-12 18:56:45 +01:00
2019-06-13 20:16:55 +01:00
class cPedComments
{
2019-06-12 18:56:45 +01:00
public :
2021-08-25 11:41:29 +01:00
tPedComment m_aPedCommentQueue [ NUM_SOUND_QUEUES ] [ NUM_PED_COMMENTS_SLOTS ] ;
uint8 m_aPedCommentOrderList [ NUM_SOUND_QUEUES ] [ NUM_PED_COMMENTS_SLOTS ] ;
uint8 m_nPedCommentCount [ NUM_SOUND_QUEUES ] ;
uint8 m_nActiveQueue ;
2019-07-31 16:54:18 +01:00
2020-05-16 18:29:13 +01:00
cPedComments ( )
{
for ( int i = 0 ; i < NUM_PED_COMMENTS_SLOTS ; i + + )
2021-08-25 11:41:29 +01:00
for ( int j = 0 ; j < NUM_SOUND_QUEUES ; j + + ) {
m_aPedCommentQueue [ j ] [ i ] . m_nProcess = - 1 ;
m_aPedCommentOrderList [ j ] [ i ] = NUM_PED_COMMENTS_SLOTS ;
2020-05-16 18:29:13 +01:00
}
2021-08-25 11:41:29 +01:00
for ( int i = 0 ; i < NUM_SOUND_QUEUES ; i + + )
m_nPedCommentCount [ i ] = 0 ;
m_nActiveQueue = 0 ;
2020-05-16 18:29:13 +01:00
}
2020-04-13 02:19:20 +01:00
void Add ( tPedComment * com ) ;
void Process ( ) ;
2019-06-12 18:56:45 +01:00
} ;
2020-05-10 16:49:33 +01:00
VALIDATE_SIZE ( cPedComments , 1164 ) ;
2019-06-12 18:56:45 +01:00
2020-04-14 15:13:38 +01:00
// name made up
class cAudioScriptObjectManager
{
public :
int32 m_anScriptObjectEntityIndices [ NUM_SCRIPT_MAX_ENTITIES ] ;
int32 m_nScriptObjectEntityTotal ;
cAudioScriptObjectManager ( ) { m_nScriptObjectEntityTotal = 0 ; }
~ cAudioScriptObjectManager ( ) { m_nScriptObjectEntityTotal = 0 ; }
} ;
2020-04-27 18:06:54 +01:00
class cTransmission ;
2021-08-21 10:18:11 +01:00
class CEntity ;
2019-07-16 16:03:37 +01:00
class CPlane ;
class CVehicle ;
2019-07-18 22:49:21 +01:00
class CPed ;
2020-04-27 18:06:54 +01:00
class cPedParams
{
public :
2021-05-22 10:11:50 +01:00
bool8 m_bDistanceCalculated ;
2020-04-27 18:06:54 +01:00
float m_fDistance ;
CPed * m_pPed ;
2020-12-25 15:39:49 +00:00
cPedParams ( )
{
m_bDistanceCalculated = false ;
m_fDistance = 0.0f ;
2020-12-26 12:21:45 +00:00
m_pPed = nil ;
2020-12-25 15:39:49 +00:00
}
2020-04-27 18:06:54 +01:00
} ;
class cVehicleParams
{
public :
2021-05-22 10:11:50 +01:00
bool8 m_bDistanceCalculated ;
2020-04-27 18:06:54 +01:00
float m_fDistance ;
CVehicle * m_pVehicle ;
cTransmission * m_pTransmission ;
2021-08-17 11:58:48 +01:00
uint32 m_nIndex ;
2020-04-27 18:06:54 +01:00
float m_fVelocityChange ;
2020-12-25 18:22:43 +00:00
cVehicleParams ( )
{
m_bDistanceCalculated = false ;
m_fDistance = 0.0f ;
2020-12-26 12:21:45 +00:00
m_pVehicle = nil ;
2020-12-25 18:22:43 +00:00
m_pTransmission = nil ;
m_nIndex = 0 ;
m_fVelocityChange = 0.0f ;
}
2020-04-27 18:06:54 +01:00
} ;
2020-05-10 16:49:33 +01:00
VALIDATE_SIZE ( cVehicleParams , 0x18 ) ;
2019-07-08 20:44:32 +01:00
2019-08-02 16:43:40 +01:00
enum {
2019-08-02 21:20:12 +01:00
/*
REFLECTION_YMAX = 0 , top
REFLECTION_YMIN = 1 , bottom
REFLECTION_XMIN = 2 , left
REFLECTION_XMAX = 3 , right
REFLECTION_ZMAX = 4 ,
*/
REFLECTION_TOP = 0 ,
REFLECTION_BOTTOM ,
REFLECTION_LEFT ,
REFLECTION_RIGHT ,
REFLECTION_UP ,
MAX_REFLECTIONS ,
} ;
2019-08-15 02:43:00 +01:00
2021-07-26 02:18:41 +01:00
enum PLAY_STATUS { PLAY_STATUS_STOPPED = 0 , PLAY_STATUS_PLAYING , PLAY_STATUS_FINISHED } ;
2021-09-01 11:25:47 +01:00
enum LOADING_STATUS { LOADING_STATUS_NOT_LOADED = 0 , LOADING_STATUS_LOADED , LOADING_STATUS_LOADING } ;
2021-07-26 02:18:41 +01:00
2019-06-12 18:56:45 +01:00
class cAudioManager
{
public :
2021-05-22 10:11:50 +01:00
bool8 m_bIsInitialised ;
2021-08-20 11:02:58 +01:00
bool8 m_bIsSurround ; // unused until VC
bool8 m_bReduceReleasingPriority ;
2020-04-28 12:00:38 +01:00
uint8 m_nActiveSamples ;
2021-08-17 11:58:48 +01:00
bool8 m_bDoubleVolume ; // unused
# if GTA_VERSION >= GTA3_PC_10
2021-05-22 10:11:50 +01:00
bool8 m_bDynamicAcousticModelingStatus ;
2021-08-17 11:58:48 +01:00
# endif
2020-04-07 14:44:31 +01:00
float m_fSpeedOfSound ;
2021-05-22 10:11:50 +01:00
bool8 m_bTimerJustReset ;
2021-08-25 06:49:42 +01:00
uint32 m_nTimer ;
2020-01-13 17:36:30 +00:00
tSound m_sQueueSample ;
2021-08-25 06:49:42 +01:00
uint8 m_nActiveQueue ;
tSound m_aRequestedQueue [ NUM_SOUND_QUEUES ] [ NUM_CHANNELS_GENERIC ] ;
uint8 m_aRequestedOrderList [ NUM_SOUND_QUEUES ] [ NUM_CHANNELS_GENERIC ] ;
uint8 m_nRequestedCount [ NUM_SOUND_QUEUES ] ;
2021-05-23 14:14:30 +01:00
tSound m_asActiveSamples [ NUM_CHANNELS_GENERIC ] ;
2020-03-21 13:51:30 +00:00
tAudioEntity m_asAudioEntities [ NUM_AUDIOENTITIES ] ;
2021-08-25 06:49:42 +01:00
uint32 m_aAudioEntityOrderList [ NUM_AUDIOENTITIES ] ;
uint32 m_nAudioEntitiesCount ;
2021-08-17 11:58:48 +01:00
# ifdef AUDIO_REFLECTIONS
2021-08-16 08:29:44 +01:00
CVector m_avecReflectionsPos [ MAX_REFLECTIONS ] ;
float m_afReflectionsDistances [ MAX_REFLECTIONS ] ;
2021-07-26 02:18:41 +01:00
# endif
2020-04-14 15:13:38 +01:00
cAudioScriptObjectManager m_sAudioScriptObjectManager ;
2019-06-12 18:56:45 +01:00
cPedComments m_sPedComments ;
2019-07-12 17:27:12 +01:00
int32 m_nFireAudioEntity ;
int32 m_nWaterCannonEntity ;
int32 m_nPoliceChannelEntity ;
2020-01-25 10:41:22 +00:00
cPoliceRadioQueue m_sPoliceRadioQueue ;
2021-08-21 10:18:11 +01:00
cAMCrime m_aCrimes [ 10 ] ;
2019-07-12 17:27:12 +01:00
int32 m_nFrontEndEntity ;
int32 m_nCollisionEntity ;
2019-06-12 18:56:45 +01:00
cAudioCollisionManager m_sCollisionManager ;
2019-07-12 17:27:12 +01:00
int32 m_nProjectileEntity ;
int32 m_nBridgeEntity ;
2021-08-21 10:18:11 +01:00
// Mission audio stuff
CVector m_vecMissionAudioPosition ;
bool8 m_bIsMissionAudio2D ;
uint32 m_nMissionAudioSampleIndex ;
uint8 m_nMissionAudioLoadingStatus ;
uint8 m_nMissionAudioPlayStatus ;
bool8 m_bIsMissionAudioPlaying ;
2021-08-25 06:49:42 +01:00
int32 m_nMissionAudioFramesToPlay ; // possibly unsigned
2021-08-21 10:18:11 +01:00
bool8 m_bIsMissionAudioAllowedToPlay ;
2019-07-12 17:27:12 +01:00
int32 m_anRandomTable [ 5 ] ;
2020-04-28 12:00:38 +01:00
uint8 m_nTimeSpent ;
2021-08-25 06:49:42 +01:00
bool8 m_bIsPaused ;
bool8 m_bWasPaused ;
2020-02-25 17:24:45 +00:00
uint32 m_FrameCounter ;
2019-08-02 16:43:40 +01:00
2020-04-13 02:19:20 +01:00
cAudioManager ( ) ;
~ cAudioManager ( ) ;
2021-07-26 02:18:41 +01:00
void Initialise ( ) ;
void Terminate ( ) ;
void Service ( ) ;
2020-05-16 18:29:13 +01:00
int32 CreateEntity ( eAudioType type , void * entity ) ;
2020-04-13 02:19:20 +01:00
void DestroyEntity ( int32 id ) ;
2021-07-28 22:40:32 +01:00
bool8 GetEntityStatus ( int32 id ) ;
2021-07-26 02:18:41 +01:00
void SetEntityStatus ( int32 id , bool8 status ) ;
2021-07-28 22:40:32 +01:00
void * GetEntityPointer ( int32 id ) ;
2021-07-26 02:18:41 +01:00
void PlayOneShot ( int32 index , uint16 sound , float vol ) ;
void SetEffectsMasterVolume ( uint8 volume ) ;
void SetMusicMasterVolume ( uint8 volume ) ;
void SetEffectsFadeVol ( uint8 volume ) ;
void SetMusicFadeVol ( uint8 volume ) ;
void SetMonoMode ( bool8 mono ) ;
void ResetTimers ( uint32 time ) ;
void DestroyAllGameCreatedEntities ( ) ;
2019-07-08 20:44:32 +01:00
2021-07-26 02:18:41 +01:00
# ifdef GTA_PC
uint8 GetNum3DProvidersAvailable ( ) ;
char * Get3DProviderName ( uint8 id ) ;
int8 GetCurrent3DProviderIndex ( ) ;
int8 SetCurrent3DProvider ( uint8 which ) ;
void SetSpeakerConfig ( int32 conf ) ;
bool8 IsMP3RadioChannelAvailable ( ) ;
void ReleaseDigitalHandle ( ) ;
void ReacquireDigitalHandle ( ) ;
2021-08-17 11:58:48 +01:00
# ifdef AUDIO_REFLECTIONS
2021-07-26 02:18:41 +01:00
void SetDynamicAcousticModelingStatus ( bool8 status ) ;
2021-08-17 11:58:48 +01:00
# endif
2021-07-26 02:18:41 +01:00
bool8 CheckForAnAudioFileOnCD ( ) ;
char GetCDAudioDriveLetter ( ) ;
bool8 IsAudioInitialised ( ) ;
# endif
2019-08-16 19:17:15 +01:00
2021-07-26 02:18:41 +01:00
void ServiceSoundEffects ( ) ;
uint32 FL ( float f ) ; // not used
2021-08-20 11:02:58 +01:00
uint8 ComputeVolume ( uint8 emittingVolume , float maxDistance , float distance ) ;
2021-07-26 02:18:41 +01:00
void TranslateEntity ( Const CVector * v1 , CVector * v2 ) ;
int32 ComputePan ( float , CVector * ) ;
2021-07-28 08:36:18 +01:00
uint32 ComputeDopplerEffectedFrequency ( uint32 oldFreq , float position1 , float position2 , float speedMultiplier ) ; // inlined on PS2
2021-07-26 02:18:41 +01:00
int32 RandomDisplacement ( uint32 seed ) ;
void InterrogateAudioEntities ( ) ; // inlined on PS2
void AddSampleToRequestedQueue ( ) ;
void AddDetailsToRequestedOrderList ( uint8 sample ) ; // inlined on PS2
2021-08-17 11:58:48 +01:00
# ifdef AUDIO_REFLECTIONS
2021-07-26 02:18:41 +01:00
void AddReflectionsToRequestedQueue ( ) ;
void UpdateReflections ( ) ;
# endif
void AddReleasingSounds ( ) ;
void ProcessActiveQueues ( ) ;
void ClearRequestedQueue ( ) ; // inlined on PS2
void ClearActiveSamples ( ) ;
void GenerateIntegerRandomNumberTable ( ) ; // inlined on PS2
2021-08-30 09:25:14 +01:00
# ifdef GTA_PS2
2021-09-01 06:09:33 +01:00
bool8 LoadBankIfNecessary ( uint8 bank ) ; // this is used only on PS2 but technically not a platform code
2021-08-30 09:25:14 +01:00
# endif
2019-08-16 19:17:15 +01:00
2021-08-11 13:33:50 +01:00
# ifdef EXTERNAL_3D_SOUND // actually must have been && AUDIO_MSS as well
2021-07-26 02:18:41 +01:00
void AdjustSamplesVolume ( ) ;
2021-08-20 12:28:18 +01:00
uint8 ComputeEmittingVolume ( uint8 emittingVolume , float maxDistance , float distance ) ;
2021-07-26 02:18:41 +01:00
# endif
2020-04-13 02:19:20 +01:00
2021-07-26 02:18:41 +01:00
// audio logic
void PreInitialiseGameSpecificSetup ( ) ;
2020-04-13 02:19:20 +01:00
void PostInitialiseGameSpecificSetup ( ) ;
void PreTerminateGameSpecificShutdown ( ) ;
2021-07-26 02:18:41 +01:00
void PostTerminateGameSpecificShutdown ( ) ;
void ResetAudioLogicTimers ( uint32 timer ) ;
void ProcessReverb ( ) ;
float GetDistanceSquared ( const CVector & v ) ;
void CalculateDistance ( bool8 & condition , float dist ) ;
void ProcessSpecial ( ) ;
2021-08-29 07:42:24 +01:00
void ProcessEntity ( int32 id ) ;
2021-07-26 02:18:41 +01:00
void ProcessPhysical ( int32 id ) ;
2021-07-28 08:36:18 +01:00
// vehicles
2021-07-26 02:18:41 +01:00
void ProcessVehicle ( CVehicle * vehicle ) ;
void ProcessRainOnVehicle ( cVehicleParams & params ) ;
bool8 ProcessReverseGear ( cVehicleParams & params ) ;
void ProcessModelCarEngine ( cVehicleParams & params ) ;
bool8 ProcessVehicleRoadNoise ( cVehicleParams & params ) ;
bool8 ProcessWetRoadNoise ( cVehicleParams & params ) ;
2021-08-15 11:14:16 +01:00
bool8 ProcessVehicleEngine ( cVehicleParams & params ) ;
2021-07-26 02:18:41 +01:00
void UpdateGasPedalAudio ( CAutomobile * automobile ) ; // inlined on PS2
void PlayerJustGotInCar ( ) ;
void PlayerJustLeftCar ( ) ;
void AddPlayerCarSample ( uint8 emittingVolume , uint32 freq , uint32 sample , uint8 bank , uint8 counter , bool8 notLooping ) ;
void ProcessCesna ( cVehicleParams & params ) ;
void ProcessPlayersVehicleEngine ( cVehicleParams & params , CAutomobile * automobile ) ;
bool8 ProcessVehicleSkidding ( cVehicleParams & params ) ;
float GetVehicleDriveWheelSkidValue ( uint8 wheel , CAutomobile * automobile , cTransmission * transmission , float velocityChange ) ;
2021-07-28 08:36:18 +01:00
float GetVehicleNonDriveWheelSkidValue ( uint8 wheel , CAutomobile * automobile , cTransmission * transmission , float velocityChange ) ; // inlined on PS2
2021-08-29 07:42:24 +01:00
bool8 ProcessVehicleHorn ( cVehicleParams & params ) ;
2021-07-26 02:18:41 +01:00
bool8 UsesSiren ( uint32 model ) ; // inlined on PS2
bool8 UsesSirenSwitching ( uint32 model ) ; // inlined on PS2
bool8 ProcessVehicleSirenOrAlarm ( cVehicleParams & params ) ;
bool8 UsesReverseWarning ( uint32 model ) ; // inlined on PS2
bool8 ProcessVehicleReverseWarning ( cVehicleParams & params ) ;
bool8 ProcessVehicleDoors ( cVehicleParams & params ) ;
bool8 ProcessAirBrakes ( cVehicleParams & params ) ;
bool8 HasAirBrakes ( uint32 model ) ; // inlined on PS2
bool8 ProcessEngineDamage ( cVehicleParams & params ) ;
bool8 ProcessCarBombTick ( cVehicleParams & params ) ;
void ProcessVehicleOneShots ( cVehicleParams & params ) ;
bool8 ProcessTrainNoise ( cVehicleParams & params ) ;
bool8 ProcessBoatEngine ( cVehicleParams & params ) ;
bool8 ProcessBoatMovingOverWater ( cVehicleParams & params ) ;
bool8 ProcessHelicopter ( cVehicleParams & params ) ;
void ProcessPlane ( cVehicleParams & params ) ; // inlined on PS2
void ProcessJumbo ( cVehicleParams & params ) ;
void ProcessJumboTaxi ( ) ; // inlined on PS2
2020-04-13 02:19:20 +01:00
void ProcessJumboAccel ( CPlane * plane ) ;
2021-07-26 02:18:41 +01:00
void ProcessJumboTakeOff ( CPlane * plane ) ; // inlined on PS2
void ProcessJumboFlying ( ) ; // inlined on PS2
void ProcessJumboLanding ( CPlane * plane ) ; // inlined on PS2
void ProcessJumboDecel ( CPlane * plane ) ; // inlined on PS2
bool8 SetupJumboTaxiSound ( uint8 vol ) ;
bool8 SetupJumboWhineSound ( uint8 emittingVol , uint32 freq ) ;
bool8 SetupJumboEngineSound ( uint8 vol , uint32 freq ) ;
bool8 SetupJumboFlySound ( uint8 emittingVol ) ;
bool8 SetupJumboRumbleSound ( uint8 emittingVol ) ;
int32 GetJumboTaxiFreq ( ) ; // inlined on PS2
// peds
void ProcessPed ( CPhysical * ped ) ; // inlined on PS2
2020-11-22 21:10:41 +00:00
void ProcessPedHeadphones ( cPedParams & params ) ;
void ProcessPedOneShots ( cPedParams & params ) ;
2021-07-26 02:18:41 +01:00
// ped comments
void SetupPedComments ( cPedParams & params , uint16 sound ) ;
int32 GetPedCommentSfx ( CPed * ped , uint16 sound ) ;
void GetPhrase ( uint32 & phrase , uint32 & prevPhrase , uint32 sample , uint32 maxOffset ) ; // inlined on PS2
uint32 GetPlayerTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetCopTalkSfx ( uint16 sound ) ;
uint32 GetSwatTalkSfx ( uint16 sound ) ;
uint32 GetFBITalkSfx ( uint16 sound ) ;
uint32 GetArmyTalkSfx ( uint16 sound ) ;
uint32 GetMedicTalkSfx ( uint16 sound ) ;
uint32 GetFiremanTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetBusinessMaleOldTalkSfx ( uint16 sound ) ;
uint32 GetBusinessMaleYoungTalkSfx ( uint16 sound , uint32 model ) ;
uint32 GetMafiaTalkSfx ( uint16 sound ) ;
uint32 GetTriadTalkSfx ( uint16 sound ) ;
uint32 GetDiabloTalkSfx ( uint16 sound ) ;
uint32 GetYakuzaTalkSfx ( uint16 sound ) ;
uint32 GetYardieTalkSfx ( uint16 sound ) ;
uint32 GetColumbianTalkSfx ( uint16 sound ) ;
uint32 GetHoodTalkSfx ( uint16 sound ) ;
uint32 GetBlackCriminalTalkSfx ( uint16 sound ) ;
uint32 GetWhiteCriminalTalkSfx ( uint16 sound ) ;
uint32 GetCasualMaleOldTalkSfx ( uint16 sound ) ;
uint32 GetCasualMaleYoungTalkSfx ( uint16 sound ) ;
uint32 GetBlackCasualFemaleTalkSfx ( uint16 sound ) ;
uint32 GetWhiteCasualFemaleTalkSfx ( uint16 sound ) ;
uint32 GetFemaleNo3TalkSfx ( uint16 sound ) ;
uint32 GetWhiteBusinessFemaleTalkSfx ( uint16 sound , uint32 model ) ;
uint32 GetBlackFatFemaleTalkSfx ( uint16 sound ) ;
uint32 GetWhiteFatMaleTalkSfx ( uint16 sound ) ;
uint32 GetBlackFatMaleTalkSfx ( uint16 sound ) ;
uint32 GetWhiteFatFemaleTalkSfx ( uint16 sound ) ;
uint32 GetBlackFemaleProstituteTalkSfx ( uint16 sound ) ;
uint32 GetWhiteFemaleProstituteTalkSfx ( uint16 sound ) ;
uint32 GetBlackProjectMaleTalkSfx ( uint16 sound , uint32 model ) ;
uint32 GetBlackProjectFemaleOldTalkSfx ( uint16 sound ) ;
uint32 GetBlackProjectFemaleYoungTalkSfx ( uint16 sound ) ;
uint32 GetChinatownMaleOldTalkSfx ( uint16 sound ) ;
uint32 GetChinatownMaleYoungTalkSfx ( uint16 sound ) ;
uint32 GetChinatownFemaleOldTalkSfx ( uint16 sound ) ;
uint32 GetChinatownFemaleYoungTalkSfx ( uint16 sound ) ;
uint32 GetLittleItalyMaleTalkSfx ( uint16 sound ) ;
uint32 GetLittleItalyFemaleOldTalkSfx ( uint16 sound ) ;
uint32 GetLittleItalyFemaleYoungTalkSfx ( uint16 sound ) ;
uint32 GetWhiteDockerMaleTalkSfx ( uint16 sound ) ;
uint32 GetBlackDockerMaleTalkSfx ( uint16 sound ) ;
uint32 GetScumMaleTalkSfx ( uint16 sound ) ;
uint32 GetScumFemaleTalkSfx ( uint16 sound ) ;
uint32 GetWhiteWorkerMaleTalkSfx ( uint16 sound ) ;
uint32 GetBlackWorkerMaleTalkSfx ( uint16 sound ) ;
uint32 GetBlackBusinessFemaleTalkSfx ( uint16 sound ) ;
uint32 GetSupermodelMaleTalkSfx ( uint16 sound ) ;
uint32 GetSupermodelFemaleTalkSfx ( uint16 sound ) ;
uint32 GetStewardMaleTalkSfx ( uint16 sound ) ;
uint32 GetStewardFemaleTalkSfx ( uint16 sound ) ;
uint32 GetFanMaleTalkSfx ( uint16 sound , uint32 model ) ;
uint32 GetFanFemaleTalkSfx ( uint16 sound ) ;
uint32 GetHospitalMaleTalkSfx ( uint16 sound ) ;
uint32 GetHospitalFemaleTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetWhiteConstructionWorkerTalkSfx ( uint16 sound ) ;
uint32 GetBlackConstructionWorkerTalkSfx ( uint16 sound ) ;
uint32 GetShopperFemaleTalkSfx ( uint16 sound , uint32 model ) ;
uint32 GetStudentMaleTalkSfx ( uint16 sound ) ;
uint32 GetStudentFemaleTalkSfx ( uint16 sound ) ;
uint32 GetSpecialCharacterTalkSfx ( uint32 modelIndex , uint16 sound ) ;
uint32 GetEightBallTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetSalvatoreTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetMistyTalkSfx ( uint16 sound ) ;
uint32 GetOldJapTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetCatalinaTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetBomberTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetSecurityGuardTalkSfx ( uint16 sound ) ;
uint32 GetChunkyTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetAsianTaxiDriverTalkSfx ( uint16 sound ) ; // inlined on PS2
uint32 GetPimpTalkSfx ( uint16 sound ) ;
uint32 GetNormalMaleTalkSfx ( uint16 sound ) ;
uint32 GetGenericMaleTalkSfx ( uint16 sound ) ;
uint32 GetGenericFemaleTalkSfx ( uint16 sound ) ;
// particles
2021-08-29 07:42:24 +01:00
void ProcessExplosions ( int32 id ) ;
void ProcessFires ( int32 id ) ;
void ProcessWaterCannon ( int32 id ) ;
2021-07-26 02:18:41 +01:00
// script objects
void ProcessScriptObject ( int32 id ) ; // inlined on PS2
void ProcessOneShotScriptObject ( uint8 sound ) ;
void ProcessLoopingScriptObject ( uint8 sound ) ;
2020-04-13 02:19:20 +01:00
void ProcessPornCinema ( uint8 sound ) ;
2021-07-26 02:18:41 +01:00
void ProcessWorkShopScriptObject ( uint8 sound ) ;
2020-04-13 02:19:20 +01:00
void ProcessSawMillScriptObject ( uint8 sound ) ;
2021-07-26 02:18:41 +01:00
void ProcessLaunderetteScriptObject ( uint8 sound ) ;
2020-04-13 02:19:20 +01:00
void ProcessShopScriptObject ( uint8 sound ) ;
2021-07-26 02:18:41 +01:00
void ProcessAirportScriptObject ( uint8 sound ) ;
void ProcessCinemaScriptObject ( uint8 sound ) ;
void ProcessDocksScriptObject ( uint8 sound ) ;
void ProcessHomeScriptObject ( uint8 sound ) ;
void ProcessPoliceCellBeatingScriptObject ( uint8 sound ) ;
// misc
2020-04-13 02:19:20 +01:00
void ProcessWeather ( int32 id ) ;
2021-07-26 02:18:41 +01:00
void ProcessFrontEnd ( ) ;
void ProcessCrane ( ) ;
void ProcessProjectiles ( ) ;
void ProcessGarages ( ) ;
void ProcessFireHydrant ( ) ;
2019-07-31 16:54:18 +01:00
2021-07-26 02:18:41 +01:00
// bridge
void ProcessBridge ( ) ; // inlined on PS2
void ProcessBridgeWarning ( ) ;
void ProcessBridgeMotor ( ) ;
void ProcessBridgeOneShots ( ) ;
2020-04-13 02:19:20 +01:00
2021-07-26 02:18:41 +01:00
// mission audio
bool8 MissionScriptAudioUsesPoliceChannel ( uint32 soundMission ) ;
void PreloadMissionAudio ( Const char * name ) ;
uint8 GetMissionAudioLoadingStatus ( ) ;
void SetMissionAudioLocation ( float x , float y , float z ) ;
void PlayLoadedMissionAudio ( ) ;
bool8 IsMissionAudioSampleFinished ( ) ;
2021-08-21 10:18:11 +01:00
bool8 IsMissionAudioSamplePlaying ( ) { return m_nMissionAudioPlayStatus = = PLAY_STATUS_PLAYING ; }
2021-07-26 02:18:41 +01:00
bool8 ShouldDuckMissionAudio ( ) { return IsMissionAudioSamplePlaying ( ) ; }
void ClearMissionAudio ( ) ;
void ProcessMissionAudio ( ) ;
// police radio
void InitialisePoliceRadioZones ( ) ;
void InitialisePoliceRadio ( ) ;
void ResetPoliceRadio ( ) ;
2021-07-27 20:32:47 +01:00
void SetMissionScriptPoliceAudio ( uint32 sfx ) ;
2021-07-26 02:18:41 +01:00
int8 GetMissionScriptPoliceAudioPlayingStatus ( ) ;
void DoPoliceRadioCrackle ( ) ;
2020-04-13 02:19:20 +01:00
void ServicePoliceRadio ( ) ;
2020-10-22 20:03:27 +01:00
void ServicePoliceRadioChannel ( uint8 wantedLevel ) ;
2021-05-22 10:11:50 +01:00
bool8 SetupCrimeReport ( ) ;
2020-04-13 02:19:20 +01:00
void SetupSuspectLastSeenReport ( ) ;
2021-07-26 02:18:41 +01:00
void ReportCrime ( eCrimeType crime , const CVector & pos ) ;
void PlaySuspectLastSeen ( float x , float y , float z ) ;
void AgeCrimes ( ) ; // inlined on PS2
// collision stuff
void ReportCollision ( CEntity * entity1 , CEntity * entity2 , uint8 surface1 , uint8 surface2 , float collisionPower , float intensity2 ) ;
void ServiceCollisions ( ) ;
void SetUpOneShotCollisionSound ( const cAudioCollision & col ) ;
void SetUpLoopingCollisionSound ( const cAudioCollision & col , uint8 counter ) ;
uint32 SetLoopingCollisionRequestedSfxFreqAndGetVol ( const cAudioCollision & audioCollision ) ;
float GetCollisionOneShotRatio ( uint32 a , float b ) ;
float GetCollisionLoopingRatio ( uint32 a , uint32 b , float c ) ; // not used
float GetCollisionRatio ( float a , float b , float c , float d ) ; // inlined on PS2
2019-06-24 15:57:54 +01:00
} ;
2021-06-12 17:19:31 +01:00
/*
Manual loop points are not on PS2 so let ' s have these macros to avoid massive ifndefs .
Setting these manually was pointless anyway since they never change from sdt values .
What were they thinking ?
*/
# ifndef GTA_PS2
# define RESET_LOOP_OFFSETS \
m_sQueueSample . m_nLoopStart = 0 ; \
m_sQueueSample . m_nLoopEnd = - 1 ;
# define SET_LOOP_OFFSETS(sample) \
m_sQueueSample . m_nLoopStart = SampleManager . GetSampleLoopStartOffset ( sample ) ; \
m_sQueueSample . m_nLoopEnd = SampleManager . GetSampleLoopEndOffset ( sample ) ;
# else
# define RESET_LOOP_OFFSETS
# define SET_LOOP_OFFSETS(sample)
# endif
2021-08-11 13:33:50 +01:00
# ifdef EXTERNAL_3D_SOUND
# define SET_EMITTING_VOLUME(vol) m_sQueueSample.m_nEmittingVolume = vol
# else
# define SET_EMITTING_VOLUME(vol)
# endif
2021-08-17 11:58:48 +01:00
# ifdef AUDIO_REFLECTIONS
2021-08-20 11:02:58 +01:00
# define SET_SOUND_REFLECTION(b) m_sQueueSample.m_bReflections = b
2021-08-17 11:58:48 +01:00
# else
# define SET_SOUND_REFLECTION(b)
# endif
2021-06-12 17:19:31 +01:00
2021-05-23 14:14:30 +01:00
# if defined(AUDIO_MSS) && !defined(PS2_AUDIO_CHANNELS)
2020-05-04 18:33:48 +01:00
static_assert ( sizeof ( cAudioManager ) = = 19220 , " cAudioManager: error " ) ;
# endif
2019-06-12 18:56:45 +01:00
2020-04-14 15:13:38 +01:00
extern cAudioManager AudioManager ;
2021-08-29 07:42:24 +01:00
enum
{
PED_COMMENT_VOLUME = 127 ,
PED_COMMENT_VOLUME_BEHIND_WALL = 31 ,
COLLISION_MAX_DIST = 60 ,
} ;