2021-01-23 22:13:40 +00:00
# pragma once
2019-06-24 14:57:54 +00:00
2020-04-28 11:00:38 +00: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"
2020-09-18 17:32:25 +00:00
# include "VehicleModelInfo.h"
2020-10-26 11:02:11 +00:00
# include "Vehicle.h"
2019-06-12 17:56:45 +00:00
2020-01-13 17:36:30 +00:00
class tSound
2019-10-19 11:21:35 +00:00
{
public :
2021-08-20 11:28:55 +00:00
int32 m_nEntityIndex ; // audio entity index
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
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:04:30 +00:00
# ifndef GTA_PS2
2021-08-20 11:28:55 +00:00
// Loop offsets
2021-08-18 12:49:06 +00:00
uint32 m_nLoopStart ;
2019-07-12 16:27:12 +00:00
int32 m_nLoopEnd ;
2021-08-12 11:57:16 +00:00
# endif
# ifdef EXTERNAL_3D_SOUND
2021-08-20 11:28:55 +00:00
uint8 m_nEmittingVolume ; // The volume in 3D space, provided to 3D audio engine
2021-07-27 19:29:40 +00:00
# endif
2021-08-20 11:28:55 +00:00
float m_fSpeedMultiplier ; // Used for doppler effect. 0.0f - unaffected by doppler
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)
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
2021-08-19 07:53:14 +00:00
# if !defined(GTA_PS2) || defined(AUDIO_REVERB) // GTA_PS2 because this field exists on mobile but not on PS2
2021-08-20 11:28:55 +00:00
bool8 m_bReverb ; // Toggles reverb effect
2021-08-16 07:00:10 +00:00
# endif
2021-08-18 12:49:06 +00:00
# ifdef AUDIO_REFLECTIONS
2021-08-20 11:28:55 +00: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-18 12:49:06 +00:00
# endif
2021-08-20 11:28:55 +00: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%
uint8 m_nFrontRearPan ; // Used on PS2 for surround panning
2021-08-24 11:58:41 +00:00
# ifndef FIX_BUGS
2021-08-20 11:28:55 +00: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:58:41 +00:00
# else
float m_nFramesToPlay ; // Made into float for high fps fix
# endif
2021-08-20 11:28:55 +00: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
uint32 m_nFinalPriority ; // Actual value used to compare priority, calculated using volume and m_nPriority. Lesser value means higher priority
int8 m_nVolumeChange ; // How much m_nVolume should reduce per each frame.
2021-08-24 11:58:41 +00:00
# if defined(FIX_BUGS) && defined(EXTERNAL_3D_SOUND)
int8 m_nEmittingVolumeChange ; // same as above but for m_nEmittingVolume
# endif
2019-06-12 17:56:45 +00:00
} ;
2020-06-08 11:29:55 +00:00
VALIDATE_SIZE ( tSound , 96 ) ;
2019-06-12 17:56:45 +00:00
2019-07-02 18:35:47 +00:00
class CPhysical ;
2019-08-02 15:43:40 +00:00
class CAutomobile ;
2019-07-02 18:35:47 +00:00
2019-10-19 11:21:35 +00:00
class tAudioEntity
{
public :
2019-06-12 17:56:45 +00:00
eAudioType m_nType ;
2019-07-16 15:03:37 +00:00
void * m_pEntity ;
2021-05-22 10:08:26 +00:00
bool8 m_bIsUsed ;
2021-07-28 21:40:32 +00: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 14:47:57 +00:00
uint8 m_AudioEvents ;
2019-06-12 17:56:45 +00:00
} ;
2020-05-10 15:49:33 +00:00
VALIDATE_SIZE ( tAudioEntity , 40 ) ;
2019-06-12 17:56:45 +00:00
2019-10-19 11:21:35 +00:00
class tPedComment
{
public :
2020-11-07 12:39:53 +00:00
uint32 m_nSampleIndex ;
2020-04-07 13:44:31 +00:00
int32 m_nEntityIndex ;
2019-06-12 17:56:45 +00:00
CVector m_vecPos ;
float m_fDistance ;
2021-08-16 11:21:51 +00:00
uint8 m_nVolume ;
2020-04-13 01:19:20 +00:00
int8 m_nProcess ;
2021-08-16 11:21:51 +00:00
# if defined(EXTERNAL_3D_SOUND) && defined(FIX_BUGS)
uint8 m_nEmittingVolume ;
# endif
2019-06-12 17:56:45 +00:00
} ;
2020-05-10 15:49:33 +00:00
VALIDATE_SIZE ( tPedComment , 28 ) ;
2019-06-12 17:56:45 +00:00
2019-06-13 19:16:55 +00:00
class cPedComments
{
2019-06-12 17:56:45 +00:00
public :
2021-08-25 10:41:41 +00: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 ;
2020-11-07 12:39:53 +00:00
# ifdef GTA_PC
2021-05-22 10:08:26 +00:00
bool8 m_bDelay ;
2020-10-22 09:38:09 +00:00
uint32 m_nDelayTimer ;
2020-11-07 12:39:53 +00:00
# endif
2019-07-31 15:54:18 +00:00
2020-05-16 17:29:13 +00:00
cPedComments ( )
{
for ( int i = 0 ; i < NUM_PED_COMMENTS_SLOTS ; i + + )
2021-08-25 10:41:41 +00: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 17:29:13 +00:00
}
2021-08-25 10:41:41 +00:00
for ( int i = 0 ; i < NUM_SOUND_QUEUES ; i + + )
m_nPedCommentCount [ i ] = 0 ;
m_nActiveQueue = 0 ;
2020-05-16 17:29:13 +00:00
}
2021-07-11 01:59:37 +00:00
void Add ( tPedComment * com ) ;
void Process ( ) ;
2019-06-12 17:56:45 +00:00
} ;
2020-10-12 17:55:19 +00:00
VALIDATE_SIZE ( cPedComments , 0x490 ) ;
2019-06-12 17:56:45 +00:00
2020-06-08 07:34:31 +00:00
# define MISSION_AUDIO_SLOTS (2)
2020-04-14 14:13:38 +00: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 17:06:54 +00:00
class cTransmission ;
2021-08-21 10:02:07 +00:00
class CEntity ;
2019-07-16 15:03:37 +00:00
class CPlane ;
class CVehicle ;
2019-07-18 21:49:21 +00:00
class CPed ;
2020-04-27 17:06:54 +00:00
class cPedParams
{
public :
2021-05-22 10:08:26 +00:00
bool8 m_bDistanceCalculated ;
2020-04-27 17:06:54 +00:00
float m_fDistance ;
CPed * m_pPed ;
2020-12-26 05:53:30 +00:00
cPedParams ( )
{
m_bDistanceCalculated = false ;
m_fDistance = 0.0f ;
m_pPed = nil ;
}
2020-04-27 17:06:54 +00:00
} ;
class cVehicleParams
{
public :
2020-12-25 18:27:37 +00:00
int32 m_VehicleType ;
2021-05-22 10:08:26 +00:00
bool8 m_bDistanceCalculated ;
2020-04-27 17:06:54 +00:00
float m_fDistance ;
CVehicle * m_pVehicle ;
cTransmission * m_pTransmission ;
2021-08-18 12:49:06 +00:00
uint32 m_nIndex ;
2020-04-27 17:06:54 +00:00
float m_fVelocityChange ;
2020-12-25 18:27:37 +00:00
cVehicleParams ( )
{
m_VehicleType = - 1 ;
m_bDistanceCalculated = false ;
m_fDistance = 0.0f ;
2020-12-26 05:53:30 +00:00
m_pVehicle = nil ;
2020-12-25 18:27:37 +00:00
m_pTransmission = nil ;
m_nIndex = 0 ;
m_fVelocityChange = 0.0f ;
}
2020-04-27 17:06:54 +00:00
} ;
2020-12-25 18:27:37 +00:00
VALIDATE_SIZE ( cVehicleParams , 0x1C ) ;
2019-07-08 19:44:32 +00:00
2021-08-16 07:02:29 +00:00
# if GTA_VERSION < GTAVC_PC_10
enum {
/*
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 ,
} ;
# else
2019-08-02 15:43:40 +00:00
enum {
2020-10-11 02:25:15 +00:00
REFLECTION_NORTH = 0 ,
REFLECTION_SOUTH ,
REFLECTION_WEST ,
REFLECTION_EAST ,
REFLECTION_CEIL_NORTH ,
REFLECTION_CEIL_SOUTH ,
REFLECTION_CEIL_WEST ,
REFLECTION_CEIL_EAST ,
2019-08-02 20:20:12 +00:00
MAX_REFLECTIONS ,
} ;
2021-08-16 07:02:29 +00:00
# endif
2019-08-15 01:43:00 +00:00
2021-07-26 01:18:41 +00:00
enum PLAY_STATUS { PLAY_STATUS_STOPPED = 0 , PLAY_STATUS_PLAYING , PLAY_STATUS_FINISHED } ;
enum LOADING_STATUS { LOADING_STATUS_NOT_LOADED = 0 , LOADING_STATUS_LOADED , LOADING_STATUS_FAILED } ;
2019-06-12 17:56:45 +00:00
class cAudioManager
{
public :
2021-05-22 10:08:26 +00:00
bool8 m_bIsInitialised ;
2021-08-20 11:28:55 +00:00
bool8 m_bIsSurround ; // used on PS2
bool8 m_bReduceReleasingPriority ;
2020-04-28 11:00:38 +00:00
uint8 m_nActiveSamples ;
2021-08-18 12:49:06 +00:00
bool8 m_bDoubleVolume ; // unused
2021-05-22 10:08:26 +00:00
bool8 m_bDynamicAcousticModelingStatus ;
2021-08-20 12:45:18 +00:00
uint8 m_nChannelOffset ;
2020-04-07 13:44:31 +00:00
float m_fSpeedOfSound ;
2021-05-22 10:08:26 +00:00
bool8 m_bTimerJustReset ;
2021-08-25 05:49:58 +00:00
uint32 m_nTimer ;
2020-01-13 17:36:30 +00:00
tSound m_sQueueSample ;
2021-08-25 05:49:58 +00: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 13:47:16 +00:00
tSound m_asActiveSamples [ NUM_CHANNELS_GENERIC ] ;
2020-03-21 13:51:30 +00:00
tAudioEntity m_asAudioEntities [ NUM_AUDIOENTITIES ] ;
2021-08-25 05:49:58 +00:00
uint32 m_aAudioEntityOrderList [ NUM_AUDIOENTITIES ] ;
uint32 m_nAudioEntitiesCount ;
2021-08-18 12:49:06 +00:00
# ifdef AUDIO_REFLECTIONS
2021-08-16 07:31:35 +00:00
CVector m_avecReflectionsPos [ MAX_REFLECTIONS ] ;
float m_afReflectionsDistances [ MAX_REFLECTIONS ] ;
2021-08-18 12:49:06 +00:00
# endif
2020-04-14 14:13:38 +00:00
cAudioScriptObjectManager m_sAudioScriptObjectManager ;
2020-06-08 11:29:55 +00:00
// miami
2021-05-22 10:08:26 +00:00
bool8 m_bIsPlayerShutUp ;
2020-09-09 22:08:44 +00:00
uint8 m_nPlayerMood ;
2020-09-09 21:32:51 +00:00
uint32 m_nPlayerMoodTimer ;
2021-08-21 10:02:07 +00:00
uint32 field_4B38_vc ;
2021-05-22 10:08:26 +00:00
bool8 m_bGenericSfx ;
2020-06-08 11:29:55 +00:00
2019-06-12 17:56:45 +00:00
cPedComments m_sPedComments ;
2019-07-12 16:27:12 +00: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:02:07 +00:00
cAMCrime m_aCrimes [ 10 ] ;
2019-07-12 16:27:12 +00:00
int32 m_nFrontEndEntity ;
int32 m_nCollisionEntity ;
2019-06-12 17:56:45 +00:00
cAudioCollisionManager m_sCollisionManager ;
2019-07-12 16:27:12 +00:00
int32 m_nProjectileEntity ;
2021-08-21 10:02:07 +00:00
int32 m_nEscalatorEntity ;
int32 m_nExtraSoundsEntity ;
2020-06-08 11:29:55 +00:00
# ifdef GTA_BRIDGE
2019-07-12 16:27:12 +00:00
int32 m_nBridgeEntity ;
2020-06-08 11:29:55 +00:00
# endif
2021-08-21 10:02:07 +00:00
// Mission audio stuff
// So instead of making an array of struct they've added [MISSION_AUDIO_SLOTS] to every field...
// Only someone with a VERY EXTRAORDINARY mind could have come up with that
CVector m_vecMissionAudioPosition [ MISSION_AUDIO_SLOTS ] ;
bool8 m_bIsMissionAudio2D [ MISSION_AUDIO_SLOTS ] ;
uint32 m_nMissionAudioSampleIndex [ MISSION_AUDIO_SLOTS ] ;
uint8 m_nMissionAudioLoadingStatus [ MISSION_AUDIO_SLOTS ] ;
uint8 m_nMissionAudioPlayStatus [ MISSION_AUDIO_SLOTS ] ;
bool8 m_bIsMissionAudioPlaying [ MISSION_AUDIO_SLOTS ] ;
2021-08-25 05:49:58 +00:00
int32 m_nMissionAudioFramesToPlay [ MISSION_AUDIO_SLOTS ] ; // possibly unsigned
2021-08-21 10:02:07 +00:00
bool8 m_bIsMissionAudioAllowedToPlay [ MISSION_AUDIO_SLOTS ] ;
bool8 m_bIsMissionAudioPhoneCall [ MISSION_AUDIO_SLOTS ] ;
uint8 m_nGlobalSfxVolumeMultiplier ; // used to lower sfx volume during phone calls
2019-07-12 16:27:12 +00:00
int32 m_anRandomTable [ 5 ] ;
2020-04-28 11:00:38 +00:00
uint8 m_nTimeSpent ;
2021-08-25 05:49:58 +00:00
bool8 m_bIsPaused ;
bool8 m_bWasPaused ;
2020-02-25 17:24:45 +00:00
uint32 m_FrameCounter ;
2019-08-02 15:43:40 +00:00
2020-04-13 01:19:20 +00:00
cAudioManager ( ) ;
~ cAudioManager ( ) ;
2021-07-28 07:32:43 +00:00
void Initialise ( ) ;
void Terminate ( ) ;
void Service ( ) ;
int32 CreateEntity ( eAudioType type , void * entity ) ;
void DestroyEntity ( int32 id ) ; // inlined in vc
2021-07-28 21:40:32 +00:00
bool8 GetEntityStatus ( int32 id ) ;
2021-07-28 07:32:43 +00:00
void SetEntityStatus ( int32 id , bool8 status ) ;
2021-07-28 21:40:32 +00:00
void * GetEntityPointer ( int32 id ) ;
2021-07-28 07:32:43 +00:00
void PlayOneShot ( int32 index , uint16 sound , float vol ) ;
void SetEffectsMasterVolume ( uint8 volume ) ;
void SetMusicMasterVolume ( uint8 volume ) ;
void SetMP3BoostVolume ( uint8 volume ) ;
void SetEffectsFadeVol ( uint8 volume ) ;
void SetMusicFadeVol ( uint8 volume ) ;
2021-07-28 22:52:49 +00:00
void SetOutputMode ( bool8 surround ) ;
2021-07-28 07:32:43 +00:00
void ResetTimers ( uint32 time ) ;
void DestroyAllGameCreatedEntities ( ) ;
# ifdef GTA_PC
uint8 GetNum3DProvidersAvailable ( ) ;
char * Get3DProviderName ( uint8 id ) ;
int8 GetCurrent3DProviderIndex ( ) ;
int8 AutoDetect3DProviders ( ) ;
int8 SetCurrent3DProvider ( uint8 which ) ;
void SetSpeakerConfig ( int32 conf ) ;
bool8 IsMP3RadioChannelAvailable ( ) ;
void ReleaseDigitalHandle ( ) ;
void ReacquireDigitalHandle ( ) ;
2021-08-18 12:49:06 +00:00
# ifdef AUDIO_REFLECTIONS
2021-07-28 07:32:43 +00:00
void SetDynamicAcousticModelingStatus ( bool8 status ) ;
2021-08-18 12:49:06 +00:00
# endif
2021-07-28 07:32:43 +00:00
bool8 CheckForAnAudioFileOnCD ( ) ;
char GetCDAudioDriveLetter ( ) ;
bool8 IsAudioInitialised ( ) ;
# endif
2019-06-12 17:56:45 +00:00
2021-07-28 07:32:43 +00:00
void ServiceSoundEffects ( ) ;
2021-08-20 11:28:55 +00:00
uint8 ComputeVolume ( uint8 emittingVolume , float maxDistance , float distance ) ;
2021-07-28 07:32:43 +00:00
void TranslateEntity ( Const CVector * v1 , CVector * v2 ) ;
2021-07-28 22:52:49 +00:00
int32 ComputeFrontRearMix ( float , CVector * ) ;
2021-07-28 07:32:43 +00:00
int32 ComputePan ( float , CVector * ) ;
uint32 ComputeDopplerEffectedFrequency ( uint32 oldFreq , float position1 , float position2 , float speedMultiplier ) ;
int32 RandomDisplacement ( uint32 seed ) ;
void InterrogateAudioEntities ( ) ; // inlined
void AddSampleToRequestedQueue ( ) ;
2021-07-11 01:59:37 +00:00
void AddDetailsToRequestedOrderList ( uint8 sample ) ; // inlined in vc
2021-08-18 12:49:06 +00:00
# ifdef AUDIO_REFLECTIONS
2021-07-11 01:59:37 +00:00
void AddReflectionsToRequestedQueue ( ) ;
2021-07-28 07:32:43 +00:00
void UpdateReflections ( ) ;
2021-08-18 12:49:06 +00:00
# endif
2021-07-11 01:59:37 +00:00
void AddReleasingSounds ( ) ;
2021-07-28 07:32:43 +00:00
void ProcessActiveQueues ( ) ;
void ClearRequestedQueue ( ) ; // inlined in vc
void ClearActiveSamples ( ) ;
void GenerateIntegerRandomNumberTable ( ) ;
2021-08-30 08:25:14 +00:00
# ifdef GTA_PS2
void LoadBankIfNecessary ( uint8 bank ) ; // this is used only on PS2 but technically not a platform code
# endif
2021-07-11 01:59:37 +00:00
2021-08-12 11:57:16 +00:00
# ifdef EXTERNAL_3D_SOUND // actually must have been && AUDIO_MSS as well
2021-07-28 07:32:43 +00:00
void AdjustSamplesVolume ( ) ; // inlined
2021-08-20 11:28:55 +00:00
uint8 ComputeEmittingVolume ( uint8 emittingVolume , float maxDistance , float distance ) ; // inlined
2021-07-28 07:32:43 +00:00
# endif
// audio logic
void PreInitialiseGameSpecificSetup ( ) ;
void PostInitialiseGameSpecificSetup ( ) ;
void PreTerminateGameSpecificShutdown ( ) ;
void PostTerminateGameSpecificShutdown ( ) ;
void ResetAudioLogicTimers ( uint32 timer ) ;
void ProcessReverb ( ) ;
float GetDistanceSquared ( const CVector & v ) ; // inlined in vc
2021-07-11 01:59:37 +00:00
void CalculateDistance ( bool8 & condition , float dist ) ;
2021-07-28 07:32:43 +00:00
CVehicle * FindVehicleOfPlayer ( ) ;
void ProcessSpecial ( ) ;
void ProcessEntity ( int32 sound ) ;
void ProcessPhysical ( int32 id ) ;
2021-07-11 01:59:37 +00:00
2021-07-28 07:32:43 +00:00
// vehicles
void ProcessVehicle ( CVehicle * vehicle ) ;
2021-08-29 06:42:32 +00:00
bool8 ProcessCarHeli ( cVehicleParams & params ) ;
2021-07-28 07:32:43 +00:00
void ProcessRainOnVehicle ( cVehicleParams & params ) ;
bool8 ProcessReverseGear ( cVehicleParams & params ) ;
void ProcessModelHeliVehicle ( cVehicleParams & params ) ;
void ProcessModelVehicle ( cVehicleParams & params ) ;
2021-08-29 06:42:32 +00:00
bool8 ProcessVehicleFlatTyre ( cVehicleParams & params ) ;
2021-07-28 07:32:43 +00:00
bool8 ProcessVehicleRoadNoise ( cVehicleParams & params ) ;
bool8 ProcessWetRoadNoise ( cVehicleParams & params ) ;
2021-08-16 07:00:10 +00:00
bool8 ProcessVehicleEngine ( cVehicleParams & params ) ;
2021-07-28 07:32:43 +00:00
void UpdateGasPedalAudio ( CVehicle * veh , int vehType ) ;
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 , CVehicle * veh ) ;
bool8 ProcessVehicleSkidding ( cVehicleParams & params ) ;
float GetVehicleDriveWheelSkidValue ( CVehicle * veh , tWheelState wheelState , float gasPedalAudio , cTransmission * transmission , float velocityChange ) ;
float GetVehicleNonDriveWheelSkidValue ( CVehicle * veh , tWheelState wheelState , cTransmission * transmission , float velocityChange ) ;
bool8 ProcessVehicleHorn ( cVehicleParams & params ) ;
bool8 UsesSiren ( cVehicleParams & params ) ;
bool8 UsesSirenSwitching ( cVehicleParams & params ) ;
bool8 ProcessVehicleSirenOrAlarm ( cVehicleParams & params ) ;
bool8 UsesReverseWarning ( uint32 model ) ;
bool8 ProcessVehicleReverseWarning ( cVehicleParams & params ) ;
bool8 ProcessVehicleDoors ( cVehicleParams & params ) ;
bool8 ProcessAirBrakes ( cVehicleParams & params ) ;
bool8 HasAirBrakes ( uint32 model ) ;
bool8 ProcessEngineDamage ( cVehicleParams & params ) ;
bool8 ProcessCarBombTick ( cVehicleParams & params ) ;
void ProcessVehicleOneShots ( cVehicleParams & params ) ;
# ifdef GTA_TRAIN
bool8 ProcessTrainNoise ( cVehicleParams & params ) ;
# endif
bool8 ProcessBoatEngine ( cVehicleParams & params ) ;
bool8 ProcessBoatMovingOverWater ( cVehicleParams & params ) ;
void ProcessPlane ( cVehicleParams & params ) ;
void ProcessJumbo ( cVehicleParams & params ) ;
void ProcessJumboTaxi ( ) ;
void ProcessJumboAccel ( CPlane * plane ) ;
void ProcessJumboTakeOff ( CPlane * plane ) ;
void ProcessJumboFlying ( ) ;
void ProcessJumboLanding ( CPlane * plane ) ;
void ProcessJumboDecel ( CPlane * plane ) ;
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 in vc
2019-07-08 19:44:32 +00:00
2021-07-28 07:32:43 +00:00
// peds
void ProcessPed ( CPhysical * ped ) ;
void ProcessPedOneShots ( cPedParams & params ) ;
void SetPedTalkingStatus ( CPed * ped , bool8 status ) ;
void SetPlayersMood ( uint8 mood , uint32 time ) ;
void ProcessPlayerMood ( ) ;
// ped comments
void SetupPedComments ( cPedParams & params , uint16 sound ) ;
uint32 GetPedCommentSfx ( CPed * ped , uint16 sound ) ;
void GetPhrase ( uint32 & phrase , uint32 & prevPhrase , uint32 sample , uint32 maxOffset ) ;
2021-07-28 06:17:38 +00:00
uint32 GetPlayerTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 07:32:43 +00:00
uint32 GetGenericMaleTalkSfx ( CPed * ped , uint16 sound ) ; // inlined in vc
uint32 GetGenericFemaleTalkSfx ( CPed * ped , uint16 sound ) ; // inlined in vc
uint32 GetDefaultTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 06:17:38 +00:00
uint32 GetCopTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetSwatTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetFBITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetArmyTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetMedicTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetFiremanTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 07:32:43 +00:00
uint32 GetWFYG1TalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYG2TalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 06:17:38 +00:00
uint32 GetHFYSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFOSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMYSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMOSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFYRITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFORITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMYRITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMORITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFYBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFOBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMYBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMOBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFYBUTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFYMDTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFYCGTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFYPRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHFOTRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMOTRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMOCATalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMYCRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFYSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFOSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMYSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMOSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFYRITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFORITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMYRITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFYBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMYBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFOBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMOBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMYBUTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFYPRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBFOTRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMOTRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMYPITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetBMYBBTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYCRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYSTTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 07:32:43 +00:00
uint32 GetWFYSKTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYSKTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 06:17:38 +00:00
uint32 GetWFOSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMOSTTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYRITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFORITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYRITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMORITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFOBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMOBETalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYCWTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYGOTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFOGOTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMOGOTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYLGTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYLGTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYBUTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYBUTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMOBUTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYPRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFOTRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMOTRTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYPITalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMOCATalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYSHTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFOSHTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetJFOTOTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetJMOTOTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHNTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 07:32:43 +00:00
uint32 GetBKTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetCBTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 06:17:38 +00:00
uint32 GetSGTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetCLTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetGDTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetPGTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetViceWhiteTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetViceBlackTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 07:32:43 +00:00
uint32 GetBMODKTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetHMYAPTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWFYJGTalkSfx ( CPed * ped , uint16 sound ) ;
uint32 GetWMYJGTalkSfx ( CPed * ped , uint16 sound ) ;
2021-07-28 22:52:49 +00:00
uint32 GetSpecialCharacterTalkSfx ( CPed * ped , int32 model , uint16 sound ) ;
void DebugPlayPedComment ( int32 sound ) ;
2021-07-11 01:59:37 +00:00
2021-07-28 07:32:43 +00:00
// particles
void ProcessExplosions ( int32 explosion ) ;
void ProcessFires ( int32 entity ) ;
void ProcessWaterCannon ( int32 ) ;
2021-07-27 19:29:40 +00:00
2021-07-28 07:32:43 +00:00
// script objects
void ProcessScriptObject ( int32 id ) ;
void ProcessOneShotScriptObject ( uint8 sound ) ;
void ProcessLoopingScriptObject ( uint8 sound ) ;
2021-07-11 01:59:37 +00:00
2021-07-28 07:32:43 +00:00
// misc
void ProcessWeather ( int32 id ) ;
void ProcessFrontEnd ( ) ;
//void ProcessCrane();
void ProcessProjectiles ( ) ;
void ProcessEscalators ( ) ;
void ProcessExtraSounds ( ) ;
void ProcessGarages ( ) ;
void ProcessFireHydrant ( ) ;
2021-07-11 01:59:37 +00:00
2020-05-26 15:25:34 +00:00
# ifdef GTA_BRIDGE
2021-07-11 01:59:37 +00:00
void ProcessBridge ( ) ;
2021-07-28 07:32:43 +00:00
void ProcessBridgeWarning ( ) ;
2021-07-11 01:59:37 +00:00
void ProcessBridgeMotor ( ) ;
void ProcessBridgeOneShots ( ) ;
2020-05-26 15:25:34 +00:00
# endif
2021-07-28 07:32:43 +00:00
// mission audio
2021-07-28 22:52:49 +00:00
const char * GetMissionAudioLoadedLabel ( uint8 slot ) ;
2021-07-28 07:32:43 +00:00
bool8 MissionScriptAudioUsesPoliceChannel ( uint32 soundMission ) ;
void PreloadMissionAudio ( uint8 slot , Const char * name ) ;
uint8 GetMissionAudioLoadingStatus ( uint8 slot ) ;
void SetMissionAudioLocation ( uint8 slot , float x , float y , float z ) ;
void PlayLoadedMissionAudio ( uint8 slot ) ;
bool8 ShouldDuckMissionAudio ( uint8 slot ) ;
bool8 IsMissionAudioSamplePlaying ( uint8 slot ) ;
bool8 IsMissionAudioSampleFinished ( uint8 slot ) ;
void ClearMissionAudio ( uint8 slot ) ; // inlined in vc
2021-07-11 01:59:37 +00:00
void ProcessMissionAudioSlot ( uint8 slot ) ;
2021-07-28 07:32:43 +00:00
void ProcessMissionAudio ( ) ;
2021-07-11 01:59:37 +00:00
2021-07-28 07:32:43 +00:00
// police radio
void InitialisePoliceRadioZones ( ) ;
void InitialisePoliceRadio ( ) ;
2021-07-11 01:59:37 +00:00
void ResetPoliceRadio ( ) ;
2021-07-28 07:32:43 +00:00
void SetMissionScriptPoliceAudio ( uint32 sfx ) ; // inlined and optimized
int8 GetMissionScriptPoliceAudioPlayingStatus ( ) ;
void DoPoliceRadioCrackle ( ) ;
2021-07-11 01:59:37 +00:00
void ServicePoliceRadio ( ) ;
void ServicePoliceRadioChannel ( uint8 wantedLevel ) ;
bool8 SetupCrimeReport ( ) ;
2020-04-13 01:19:20 +00:00
void SetupSuspectLastSeenReport ( ) ;
2021-07-28 07:32:43 +00:00
void ReportCrime ( eCrimeType crime , const CVector & pos ) ;
void PlaySuspectLastSeen ( float x , float y , float z ) ;
void AgeCrimes ( ) ; // inlined in vc
// 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 in vc
2020-09-09 16:37:44 +00:00
2020-12-25 15:22:18 +00:00
float Sqrt ( float v ) const { return v < = 0.0f ? 0.0f : : : Sqrt ( v ) ; }
2019-06-24 14:57:54 +00:00
} ;
2021-06-12 16:59:28 +00: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-12 11:57:16 +00:00
# ifdef EXTERNAL_3D_SOUND
# define SET_EMITTING_VOLUME(vol) m_sQueueSample.m_nEmittingVolume = vol
# else
# define SET_EMITTING_VOLUME(vol)
# endif
2021-08-18 12:49:06 +00:00
# ifdef AUDIO_REFLECTIONS
2021-08-20 11:28:55 +00:00
# define SET_SOUND_REFLECTION(b) m_sQueueSample.m_bReflections = b
2021-08-18 12:49:06 +00:00
# else
# define SET_SOUND_REFLECTION(b)
# endif
2021-08-19 07:53:14 +00:00
# ifdef AUDIO_REVERB
2021-08-20 11:28:55 +00:00
# define SET_SOUND_REVERB(b) m_sQueueSample.m_bReverb = b
2021-08-19 07:53:14 +00:00
# else
# define SET_SOUND_REVERB(b)
# endif
2021-06-12 16:59:28 +00:00
2021-05-23 13:47:16 +00:00
# if defined(AUDIO_MSS) && !defined(PS2_AUDIO_CHANNELS)
2020-06-08 11:29:55 +00:00
static_assert ( sizeof ( cAudioManager ) = = 0x5558 , " cAudioManager: error " ) ;
2020-05-04 17:33:48 +00:00
# endif
2019-06-12 17:56:45 +00:00
2020-04-14 14:13:38 +00:00
extern cAudioManager AudioManager ;
2021-08-29 06:42:32 +00:00
enum
{
PED_COMMENT_VOLUME = 127 ,
PED_COMMENT_VOLUME_BEHIND_WALL = 31 ,
COLLISION_MAX_DIST = 60 ,
} ;