Substitute/Re3
Substitute/Re3
1
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity

ProcessActiveQueues

Browse Source
This commit is contained in:
Filip Gawin 2019-07-12 18:27:12 +02:00
parent a04d8f24be
commit 113abec6fa
4 changed files with 510 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

375
src/audio/AudioManager.cpp
View File

@ -103,21 +103,22 @@ char &g_nMissionAudioPlayingStatus = *(char *)0x60ED88;
void void
cAudioManager::AddDetailsToRequestedOrderList(uint8 sample) cAudioManager::AddDetailsToRequestedOrderList(uint8 sample)
{ {
int32 offset;
uint32 i = 0; uint32 i = 0;
if(sample != 0) { if(sample != 0) {
for(; i < sample; i++) { for(; i < sample; i++) {
offset = 27 * m_bActiveSampleQueue; if(m_asSamples[m_bActiveSampleQueue]
if(m_asSamples[offset + m_abSampleQueueIndexTable[i + offset]] [m_abSampleQueueIndexTable[m_bActiveSampleQueue][i]]
.calculatedVolume > m_asSamples[offset + sample].calculatedVolume) .calculatedVolume >
m_asSamples[m_bActiveSampleQueue][sample].calculatedVolume)
break; break;
} }
if(i < sample) { if(i < sample) {
memmove(&m_abSampleQueueIndexTable[offset + 1 + i], memmove(&m_abSampleQueueIndexTable[m_bActiveSampleQueue][i + 1],
&m_abSampleQueueIndexTable[offset + i], m_bActiveSamples - i - 1); &m_abSampleQueueIndexTable[m_bActiveSampleQueue][i],
m_bActiveSamples - i - 1);
} }
} }
m_abSampleQueueIndexTable[27 * m_bActiveSampleQueue + i] = sample; m_abSampleQueueIndexTable[m_bActiveSampleQueue][i] = sample;
} }
void void
@ -193,7 +194,7 @@ cAudioManager::AddReflectionsToRequestedQueue()
} }
} }
} }
#if 0 #if 1
WRAPPER void WRAPPER void
cAudioManager::AddReleasingSounds() cAudioManager::AddReleasingSounds()
{ {
@ -271,17 +272,17 @@ cAudioManager::AddSampleToRequestedQueue()
{ {
int32 calculatedVolume; int32 calculatedVolume;
tActiveSample *sample; tActiveSample *sample;
int32 unknown1; uint8 sampleIndex;
uint8 unknown2;
bool bReflections; bool bReflections;
if(m_sQueueSample.m_nSampleIndex < TOTAL_AUDIO_SAMPLES) { if(m_sQueueSample.m_nSampleIndex < TOTAL_AUDIO_SAMPLES) {
calculatedVolume = m_sQueueSample.field_16 * (maxVolume - m_sQueueSample.m_bVolume); calculatedVolume = m_sQueueSample.field_16 * (maxVolume - m_sQueueSample.m_bVolume);
unknown2 = m_bSampleRequestQueuesStatus[m_bActiveSampleQueue]; sampleIndex = m_bSampleRequestQueuesStatus[m_bActiveSampleQueue];
if(unknown2 >= m_bActiveSamples) { if(sampleIndex >= m_bActiveSamples) {
unknown1 = 27 * m_bActiveSampleQueue; sampleIndex = *(&m_asSamples[1][26].field_91 + m_bActiveSamples +
unknown2 = *(&m_asSamples[53].field_91 + m_bActiveSamples + unknown1); 27 * m_bActiveSampleQueue);
if(m_asSamples[unknown1 + unknown2].calculatedVolume <= calculatedVolume) if(m_asSamples[m_bActiveSampleQueue][sampleIndex].calculatedVolume <=
calculatedVolume)
return; return;
} else { } else {
++m_bSampleRequestQueuesStatus[m_bActiveSampleQueue]; ++m_bSampleRequestQueuesStatus[m_bActiveSampleQueue];
@ -302,7 +303,7 @@ cAudioManager::AddSampleToRequestedQueue()
if(!m_bDynamicAcousticModelingStatus) m_sQueueSample.m_bReverbFlag = 0; if(!m_bDynamicAcousticModelingStatus) m_sQueueSample.m_bReverbFlag = 0;
sample = &m_asSamples[27 * m_bActiveSampleQueue + unknown2]; sample = &m_asSamples[m_bActiveSampleQueue][sampleIndex];
sample->m_nEntityIndex = m_sQueueSample.m_nEntityIndex; sample->m_nEntityIndex = m_sQueueSample.m_nEntityIndex;
sample->field_4 = m_sQueueSample.field_4; sample->field_4 = m_sQueueSample.field_4;
sample->m_nSampleIndex = m_sQueueSample.m_nSampleIndex; sample->m_nSampleIndex = m_sQueueSample.m_nSampleIndex;
@ -330,7 +331,7 @@ cAudioManager::AddSampleToRequestedQueue()
sample->calculatedVolume = m_sQueueSample.calculatedVolume; sample->calculatedVolume = m_sQueueSample.calculatedVolume;
sample->field_88 = m_sQueueSample.field_88; sample->field_88 = m_sQueueSample.field_88;
AddDetailsToRequestedOrderList(unknown2); AddDetailsToRequestedOrderList(sampleIndex);
if(bReflections) AddReflectionsToRequestedQueue(); if(bReflections) AddReflectionsToRequestedQueue();
} }
} }
@ -383,7 +384,7 @@ void
cAudioManager::ClearRequestedQueue() cAudioManager::ClearRequestedQueue()
{ {
for(int32 i = 0; i < m_bActiveSamples; i++) { for(int32 i = 0; i < m_bActiveSamples; i++) {
m_abSampleQueueIndexTable[i + 27 * m_bActiveSampleQueue] = m_bActiveSamples; m_abSampleQueueIndexTable[m_bActiveSampleQueue][i] = m_bActiveSamples;
} }
m_bSampleRequestQueuesStatus[m_bActiveSampleQueue] = 0; m_bSampleRequestQueuesStatus[m_bActiveSampleQueue] = 0;
} }
@ -554,6 +555,21 @@ cAudioManager::GetDistanceSquared(CVector *v)
return sq(v->x - c.x) + sq(v->y - c.y) + sq((v->z - c.z) * 0.2f); return sq(v->x - c.x) + sq(v->y - c.y) + sq((v->z - c.z) * 0.2f);
} }
void
cAudioManager::TranslateEntity(CVector *v1, CVector *v2)
{
const RwMatrix &cM = TheCamera.GetMatrix().m_matrix;
const CVector &cV = TheCamera.GetPosition();
float a = v1->z - cV.z;
float b = v1->y - cV.y;
float c = v1->x - cV.x;
v2->x = cM.right.y * b + cM.right.x * c + cM.right.z * a;
v2->y = cM.up.y * b + cM.up.x * c + cM.up.z * a;
v2->z = cM.at.y * b + cM.at.x * c + cM.at.z * a;
}
void void
cAudioManager::Initialise() cAudioManager::Initialise()
{ {
@ -3118,6 +3134,8 @@ cAudioManager::GetGenericFemaleTalkSfx(int16 sound)
return sfx; return sfx;
} }
#if 1
WRAPPER WRAPPER
void void
cAudioManager::ProcessActiveQueues() cAudioManager::ProcessActiveQueues()
@ -3125,6 +3143,320 @@ cAudioManager::ProcessActiveQueues()
EAXJMP(0x57BA60); EAXJMP(0x57BA60);
} }
#else
void
cAudioManager::ProcessActiveQueues()
{
int v3; // ecx
cAudioManager *v4; // edx
tActiveSample *v5; // ebx
cAudioManager *v6; // edi
tActiveSample *v7; // esi
char v8; // al
unsigned __int8 v9; // dl
double v10; // st7
double v11; // st6
float a4; // ST08_4
float a3; // ST04_4
int activeSampleFreq; // ecx
int freq; // edi
int newFreq; // ecx
int v17; // eax
char v18; // al
unsigned __int8 v19; // al
float v20; // ST0C_4
int v21; // edx
unsigned __int8 v22; // bl
cAudioManager *v23; // ebp
int v24; // ecx
cAudioManager *v25; // edx
tActiveSample *v26; // ebx
cAudioManager *v27; // ebp
unsigned int v28; // edi
unsigned int v29; // eax
unsigned __int8 v30; // cl
double v31; // st4
double v32; // st7
double v33; // st6
double v34; // st5
float v35; // ST0C_4
float v36; // ST08_4
float v37; // ST04_4
float v38; // ST0C_4
int v39; // edx
int v40; // [esp+Ch] [ebp-58h]
int v41; // [esp+Ch] [ebp-58h]
unsigned int v42; // [esp+10h] [ebp-54h]
int v43; // [esp+10h] [ebp-54h]
char v44; // [esp+14h] [ebp-50h]
unsigned __int8 v45; // [esp+14h] [ebp-50h]
unsigned __int8 l; // [esp+24h] [ebp-40h]
unsigned __int8 j; // [esp+28h] [ebp-3Ch]
unsigned __int8 k; // [esp+34h] [ebp-30h]
unsigned __int8 i; // [esp+38h] [ebp-2Ch]
CVector a2; // [esp+48h] [ebp-1Ch]
for(uint32 i = 0; i < m_bActiveSamples; i++) {
m_asSamples[m_bActiveSampleQueue][i].m_bIsProcessed = 0;
m_asActiveSamples[i].m_bIsProcessed = 0;
}
for(i = 0;; ++i) {
v21 = m_bActiveSampleQueue;
if(i >= m_bSampleRequestQueuesStatus[v21]) break;
v3 = i + 27 * v21;
v4 = (this + 2484 * v21);
v5 = &v4->m_asSamples[m_abSampleQueueIndexTable[v3]];
if(v4->m_asSamples[m_abSampleQueueIndexTable[v3]].m_nSampleIndex != NO_SAMPLE) {
v6 = this;
for(j = 0;; ++j) {
if(j >= m_bActiveSamples) goto LABEL_58;
v7 = m_asActiveSamples;
if(v5->m_nEntityIndex == m_asActiveSamples[0].m_nEntityIndex &&
v5->field_4 == m_asActiveSamples[0].field_4 &&
v5->m_nSampleIndex == m_asActiveSamples[0].m_nSampleIndex) {
break;
}
LABEL_56:
v6 = (v6 + 92);
}
if(v5->m_nLoopCount) {
if(m_nTimeOfRecentCrime & 1) {
if(!(j & 1)) {
v8 = 0;
goto LABEL_17;
}
LABEL_16:
v8 = 1;
} else {
if(!(j & 1)) goto LABEL_16;
v8 = 0;
}
LABEL_17:
if(v8 && !cSampleManager.GetChannelUsedFlag(j)) {
v5->m_bLoopEnded = 1;
m_asActiveSamples[0].m_bLoopEnded = 1;
m_asActiveSamples[0].m_nSampleIndex = NO_SAMPLE;
v7->m_nEntityIndex = -5;
goto LABEL_56;
}
}
v5->m_bIsProcessed = 1;
m_asActiveSamples[0].m_bIsProcessed = 1;
v5->field_88 = -1;
if(!v5->field_56) {
if(v5->m_bIsDistant) {
if(field_4) {
v9 = v5->m_bEmittingVolume;
if(v9 >= 63u)
v42 = 63;
else
v42 = v9;
v43 = 2 * v42;
} else {
v43 = v5->m_bEmittingVolume;
}
cSampleManager.SetChannelFrequency(j, v5->m_nFrequency);
cSampleManager.SetChannelEmittingVolume(j, v43);
} else {
v10 = m_asActiveSamples[0].m_fDistance;
v11 = v5->m_fDistance;
m_asActiveSamples[0].m_fDistance = v5->m_fDistance;
a4 = v11;
a3 = v10;
v5->m_nFrequency = ComputeDopplerEffectedFrequency(
v5->m_nFrequency, a3, a4, v5->field_48);
activeSampleFreq = m_asActiveSamples[0].m_nFrequency;
freq = v5->m_nFrequency;
if(freq != activeSampleFreq) {
if(freq <= activeSampleFreq) {
if(activeSampleFreq - 6000 > freq)
freq = activeSampleFreq - 6000;
newFreq = freq;
} else if(activeSampleFreq + 6000 >= freq) {
newFreq = v5->m_nFrequency;
} else {
newFreq = activeSampleFreq + 6000;
}
v7->m_nFrequency = newFreq;
cSampleManager.SetChannelFrequency(j, newFreq);
}
v40 = v7->m_bEmittingVolume;
v17 = v5->m_bEmittingVolume;
if(v17 != v40) {
if(v17 <= v40) {
if(v40 - 10 > v17) v17 = v40 - 10;
v41 = v17;
} else if(v40 + 10 >= v17) {
v41 = v5->m_bEmittingVolume;
} else {
v41 = v40 + 10;
}
if(field_4) {
if(v41 >= 63)
v18 = 63;
else
v18 = v41;
v19 = 2 * v18;
} else {
v19 = v41;
}
cSampleManager.SetChannelEmittingVolume(j, v19);
v7->m_bEmittingVolume = v41;
}
TranslateEntity(&v5->m_vecPos, &a2);
cSampleManager.SetChannel3DPosition(j, a2.x, a2.y, a2.z);
v20 = 0.25f * v5->m_fSoundIntensity;
cSampleManager.SetChannel3DDistances(
j, v5->m_fSoundIntensity, v20);
}
cSampleManager.SetChannelReverbFlag(j, v5->m_bReverbFlag);
continue;
}
v5->m_bIsProcessed = 0;
m_asActiveSamples[0].m_bIsProcessed = 0;
goto LABEL_56;
}
LABEL_58:;
}
v22 = 0;
v23 = this;
for(uint32 i = 0; v22 < m_bActiveSamples; i++) {
if(v23->m_asActiveSamples[0].m_nSampleIndex != NO_SAMPLE &&
!v23->m_asActiveSamples[0].m_bIsProcessed) {
cSampleManager.StopChannel(i);
v23->m_asActiveSamples[0].m_nSampleIndex = NO_SAMPLE;
v23->m_asActiveSamples[0].m_nEntityIndex = -5;
}
v23 = (v23 + 92);
}
for(k = 0; k < m_bSampleRequestQueuesStatus[m_bActiveSampleQueue]; ++k) {
v24 = k + 27 * v39;
v25 = (this + 2484 * v39);
v26 = &v25->m_asSamples[m_abSampleQueueIndexTable[v24]];
if(!v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_bIsProcessed &&
!v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_bLoopEnded &&
m_asAudioEntities[v26->m_nEntityIndex].m_bIsUsed &&
v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_nSampleIndex < NO_SAMPLE) {
if(v25->m_asSamples[m_abSampleQueueIndexTable[v24]].field_4 > 255u &&
v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_nLoopCount &&
v25->m_asSamples[m_abSampleQueueIndexTable[v24]].m_bLoopsRemaining) {
--v25->m_asSamples[m_abSampleQueueIndexTable[v24]]
.m_bLoopsRemaining;
v26->field_76 = 1;
} else {
v27 = this;
for(l = 0; l < m_bActiveSamples; ++l) {
if(!v27->m_asActiveSamples[0].m_bIsProcessed) {
if(!v26->m_nLoopCount) goto LABEL_80;
v28 = v26->m_nFrequency / field_19192;
v29 = v26->m_nLoopCount *
cSampleManager.GetSampleLength(
v26->m_nSampleIndex);
if(v28) {
v26->field_76 = v29 / v28 + 1;
LABEL_80:
memcpy(v27->m_asActiveSamples, v26, 92);
if(!v27->m_asActiveSamples[0].m_bIsDistant)
TranslateEntity(
&v27->m_asActiveSamples[0]
.m_vecPos,
&a2);
if(field_4) {
if(v27->m_asActiveSamples[0]
.m_bEmittingVolume >= 63u)
v44 = 63;
else
v44 =
v27
->m_asActiveSamples
[0]
.m_bEmittingVolume;
v45 = 2 * v44;
} else {
v45 = v27->m_asActiveSamples[0]
.m_bEmittingVolume;
}
if(cSampleManager.InitialiseChannel(
l,
v27->m_asActiveSamples[0]
.m_nSampleIndex,
v27->m_asActiveSamples[0]
.m_bBankIndex)) {
cSampleManager.SetChannelFrequency(
l, v27->m_asActiveSamples[0]
.m_nFrequency);
cSampleManager
.SetChannelEmittingVolume(l,
v45);
cSampleManager.SetChannelLoopPoints(
l,
v27->m_asActiveSamples[0]
.m_nLoopStart,
v27->m_asActiveSamples[0]
.m_nLoopEnd);
cSampleManager.SetChannelLoopCount(
l, v27->m_asActiveSamples[0]
.m_nLoopCount);
cSampleManager.SetChannelReverbFlag(
l, v27->m_asActiveSamples[0]
.m_bReverbFlag);
if(v27->m_asActiveSamples[0]
.m_bIsDistant) {
v30 = v27->m_asActiveSamples
[0]
.m_bOffset;
if(v30 == 63) {
v31 = 0.0f;
} else if(v30 >= 63u) {
v31 = (v30 - 63) *
15.873f;
} else {
v31 = -((63 - v30) *
15.873f);
}
v32 = v31;
v33 = 0.0f;
v34 = 0.0f;
v27->m_asActiveSamples[0]
.m_fSoundIntensity =
100000.0f;
} else {
v32 = a2.x;
v33 = a2.y;
v34 = a2.z;
}
v35 = v34;
v36 = v33;
v37 = v32;
cSampleManager.SetChannel3DPosition(
l, v37, v36, v35);
v38 = 0.25f *
v27->m_asActiveSamples[0]
.m_fSoundIntensity;
cSampleManager
.SetChannel3DDistances(
l,
v27->m_asActiveSamples[0]
.m_fSoundIntensity,
v38);
cSampleManager.StartChannel(l);
}
v27->m_asActiveSamples[0].m_bIsProcessed =
1;
v26->m_bIsProcessed = 1;
v26->field_88 = -1;
break;
}
}
v27 = (v27 + 92);
}
}
}
}
}
#endif
#if 1 #if 1
bool bool
cAudioManager::ProcessAirBrakes(cVehicleParams *params) cAudioManager::ProcessAirBrakes(cVehicleParams *params)
@ -3733,9 +4065,9 @@ cAudioManager::ProcessGarages()
EAXJMP(0x578C20); EAXJMP(0x578C20);
} }
void cAudioManager::ProcessHomeScriptObject(uint8 sound) void
cAudioManager::ProcessHomeScriptObject(uint8 sound)
{ {
} }
void void
@ -3820,7 +4152,7 @@ STARTPATCHES
InjectHook(0x57B210, &cAudioManager::AddDetailsToRequestedOrderList, PATCH_JUMP); InjectHook(0x57B210, &cAudioManager::AddDetailsToRequestedOrderList, PATCH_JUMP);
InjectHook(0x56AD30, &cAudioManager::AddPlayerCarSample, PATCH_JUMP); InjectHook(0x56AD30, &cAudioManager::AddPlayerCarSample, PATCH_JUMP);
InjectHook(0x57B300, &cAudioManager::AddReflectionsToRequestedQueue, PATCH_JUMP); InjectHook(0x57B300, &cAudioManager::AddReflectionsToRequestedQueue, PATCH_JUMP);
InjectHook(0x57B8D0, &cAudioManager::AddReleasingSounds, PATCH_JUMP); // InjectHook(0x57B8D0, &cAudioManager::AddReleasingSounds, PATCH_JUMP);
InjectHook(0x57B070, &cAudioManager::AddSampleToRequestedQueue, PATCH_JUMP); InjectHook(0x57B070, &cAudioManager::AddSampleToRequestedQueue, PATCH_JUMP);
InjectHook(0x57A8F0, &cAudioManager::AutoDetect3DProviders, PATCH_JUMP); InjectHook(0x57A8F0, &cAudioManager::AutoDetect3DProviders, PATCH_JUMP);
// InjectHook(0x580AF0, &cAudioManager::AgeCrimes, PATCH_JUMP); // InjectHook(0x580AF0, &cAudioManager::AgeCrimes, PATCH_JUMP);
@ -3977,6 +4309,7 @@ InjectHook(0x575460, &cAudioManager::GetGenericMaleTalkSfx, PATCH_JUMP);
InjectHook(0x575510, &cAudioManager::GetGenericFemaleTalkSfx, PATCH_JUMP); InjectHook(0x575510, &cAudioManager::GetGenericFemaleTalkSfx, PATCH_JUMP);
// Process stuff // Process stuff
// InjectHook(0x57BA60, &cAudioManager::ProcessActiveQueues, PATCH_JUMP);
InjectHook(0x577B30, &cAudioManager::ProcessAirportScriptObject, PATCH_JUMP); InjectHook(0x577B30, &cAudioManager::ProcessAirportScriptObject, PATCH_JUMP);
InjectHook(0x579250, &cAudioManager::ProcessBridgeMotor, PATCH_JUMP); InjectHook(0x579250, &cAudioManager::ProcessBridgeMotor, PATCH_JUMP);
InjectHook(0x579170, &cAudioManager::ProcessBridgeWarning, PATCH_JUMP); InjectHook(0x579170, &cAudioManager::ProcessBridgeWarning, PATCH_JUMP);

192
src/audio/AudioManager.h
View File

@ -7,48 +7,48 @@
class tActiveSample class tActiveSample
{ {
public: public:
int m_nEntityIndex; int32 m_nEntityIndex;
int field_4; int32 field_4;
int m_nSampleIndex; int32 m_nSampleIndex;
char m_bBankIndex; uint8 m_bBankIndex;
char m_bIsDistant; uint8 m_bIsDistant;
char field_14; uint8 field_14;
char field_15; uint8 field_15;
int field_16; int32 field_16;
int m_nFrequency; int32 m_nFrequency;
uint8 m_bVolume; uint8 m_bVolume;
char field_25; uint8 field_25;
char field_26; uint8 field_26;
char field_27; uint8 field_27;
float m_fDistance; float m_fDistance;
int m_nLoopCount; int32 m_nLoopCount;
int m_nLoopStart; int32 m_nLoopStart;
int m_nLoopEnd; int32 m_nLoopEnd;
uint8 m_bEmittingVolume; uint8 m_bEmittingVolume;
char field_45; uint8 field_45;
char field_46; uint8 field_46;
char field_47; uint8 field_47;
float field_48; float field_48;
float m_fSoundIntensity; float m_fSoundIntensity;
char field_56; uint8 field_56;
char field_57; uint8 field_57;
char field_58; uint8 field_58;
char field_59; uint8 field_59;
CVector m_vecPos; CVector m_vecPos;
char m_bReverbFlag; uint8 m_bReverbFlag;
char m_bLoopsRemaining; uint8 m_bLoopsRemaining;
char m_bRequireReflection; uint8 m_bRequireReflection;
uint8 m_bOffset; uint8 m_bOffset;
int field_76; int32 field_76;
char m_bIsProcessed; uint8 m_bIsProcessed;
char m_bLoopEnded; uint8 m_bLoopEnded;
char field_82; uint8 field_82;
char field_83; uint8 field_83;
int calculatedVolume; int32 calculatedVolume;
char field_88; uint8 field_88;
char field_89; uint8 field_89;
char field_90; uint8 field_90;
char field_91; uint8 field_91;
}; };
static_assert(sizeof(tActiveSample) == 0x5c, "tActiveSample: error"); static_assert(sizeof(tActiveSample) == 0x5c, "tActiveSample: error");
@ -79,12 +79,12 @@ public:
eAudioType m_nType; eAudioType m_nType;
CPhysical *m_pEntity; CPhysical *m_pEntity;
bool m_bIsUsed; bool m_bIsUsed;
char m_bStatus; uint8 m_bStatus;
int16 m_awAudioEvent[4]; int16 m_awAudioEvent[4];
char gap_18[2]; uint8 gap_18[2];
float m_afVolume[4]; float m_afVolume[4];
char field_24; uint8 field_24;
char field_25[3]; uint8 field_25[3];
}; };
static_assert(sizeof(tAudioEntity) == 0x28, "tAudioEntity: error"); static_assert(sizeof(tAudioEntity) == 0x28, "tAudioEntity: error");
@ -96,9 +96,9 @@ public:
int field_4; int field_4;
CVector m_vecPos; CVector m_vecPos;
float m_fDistance; float m_fDistance;
char m_bVolume; uint8 m_bVolume;
char field_25; uint8 field_25;
char gap_26[2]; uint8 gap_26[2];
}; };
static_assert(sizeof(tPedComment) == 0x1c, "tPedComment: error"); static_assert(sizeof(tPedComment) == 0x1c, "tPedComment: error");
@ -107,10 +107,10 @@ class cPedComments
{ {
public: public:
tPedComment m_asPedComments[40]; tPedComment m_asPedComments[40];
char field_1120[40]; uint8 field_1120[40];
char field_1160[2]; uint8 field_1160[2];
char field_1162; uint8 field_1162;
char gap_1163[1]; uint8 gap_1163[1];
}; };
static_assert(sizeof(cPedComments) == 0x48c, "cPedComments: error"); static_assert(sizeof(cPedComments) == 0x48c, "cPedComments: error");
@ -122,15 +122,15 @@ class cAudioCollision
public: public:
CEntity *m_pEntity1; CEntity *m_pEntity1;
CEntity *m_pEntity2; CEntity *m_pEntity2;
char m_bSurface1; uint8 m_bSurface1;
char m_bSurface2; uint8 m_bSurface2;
char field_10; uint8 field_10;
char field_11; uint8 field_11;
float m_fIntensity1; float m_fIntensity1;
float m_fIntensity2; float m_fIntensity2;
CVector m_vecPosition; CVector m_vecPosition;
float m_fDistance; float m_fDistance;
int m_nBaseVolume; int32 m_nBaseVolume;
}; };
static_assert(sizeof(cAudioCollision) == 0x28, "cAudioCollision: error"); static_assert(sizeof(cAudioCollision) == 0x28, "cAudioCollision: error");
@ -140,9 +140,9 @@ class cAudioCollisionManager
public: public:
cAudioCollision m_asCollisions1[10]; cAudioCollision m_asCollisions1[10];
cAudioCollision m_asCollisions2[10]; cAudioCollision m_asCollisions2[10];
char m_bIndicesTable[10]; uint8 m_bIndicesTable[10];
char m_bCollisionsInQueue; uint8 m_bCollisionsInQueue;
char gap_811; uint8 gap_811;
cAudioCollision m_sQueue; cAudioCollision m_sQueue;
}; };
@ -152,18 +152,18 @@ class cMissionAudio
{ {
public: public:
CVector m_vecPos; CVector m_vecPos;
char field_12; uint8 field_12;
char gap_13[3]; uint8 gap_13[3];
int m_nSampleIndex; int m_nSampleIndex;
char m_bLoadingStatus; uint8 m_bLoadingStatus;
char m_bPlayStatus; uint8 m_bPlayStatus;
char field_22; uint8 field_22;
char field_23; uint8 field_23;
int field_24; int field_24;
bool m_bIsPlayed; bool m_bIsPlayed;
char field_29; uint8 field_29;
char field_30; uint8 field_30;
char field_31; uint8 field_31;
}; };
class cVehicleParams; class cVehicleParams;
@ -174,50 +174,50 @@ class cAudioManager
{ {
public: public:
bool m_bIsInitialised; bool m_bIsInitialised;
char field_1; uint8 field_1;
char field_2; uint8 field_2;
char m_bActiveSamples; uint8 m_bActiveSamples;
char field_4; uint8 field_4;
bool m_bDynamicAcousticModelingStatus; bool m_bDynamicAcousticModelingStatus;
char field_6; uint8 field_6;
char field_7; uint8 field_7;
float speedOfSound; float speedOfSound;
bool m_bTimerJustReset; bool m_bTimerJustReset;
char field_13; uint8 field_13;
char field_14; uint8 field_14;
char field_15; uint8 field_15;
int m_nTimer; int32 m_nTimer;
tActiveSample m_sQueueSample; tActiveSample m_sQueueSample;
uint8 m_bActiveSampleQueue; uint8 m_bActiveSampleQueue;
char gap_109[3]; uint8 gap_109[3];
tActiveSample m_asSamples[54]; tActiveSample m_asSamples[2][27];
char m_abSampleQueueIndexTable[54]; uint8 m_abSampleQueueIndexTable[2][27];
char m_bSampleRequestQueuesStatus[2]; uint8 m_bSampleRequestQueuesStatus[2];
tActiveSample m_asActiveSamples[27]; tActiveSample m_asActiveSamples[27];
tAudioEntity m_asAudioEntities[200]; tAudioEntity m_asAudioEntities[200];
int m_anAudioEntityIndices[200]; int32 m_anAudioEntityIndices[200];
int m_nAudioEntitiesTotal; int32 m_nAudioEntitiesTotal;
CVector m_avecReflectionsPos[5]; CVector m_avecReflectionsPos[5];
float m_afReflectionsDistances[5]; float m_afReflectionsDistances[5];
int m_anScriptObjectEntityIndices[40]; int32 m_anScriptObjectEntityIndices[40];
int m_nScriptObjectEntityTotal; int32 m_nScriptObjectEntityTotal;
cPedComments m_sPedComments; cPedComments m_sPedComments;
int m_nFireAudioEntity; int32 m_nFireAudioEntity;
int m_nWaterCannonEntity; int32 m_nWaterCannonEntity;
int m_nPoliceChannelEntity; int32 m_nPoliceChannelEntity;
char gap45B8[444]; uint8 gap45B8[444];
int m_nFrontEndEntity; int32 m_nFrontEndEntity;
int m_nCollisionEntity; int32 m_nCollisionEntity;
cAudioCollisionManager m_sCollisionManager; cAudioCollisionManager m_sCollisionManager;
int m_nProjectileEntity; int32 m_nProjectileEntity;
int m_nBridgeEntity; int32 m_nBridgeEntity;
cMissionAudio m_sMissionAudio; cMissionAudio m_sMissionAudio;
int m_anRandomTable[5]; int32 m_anRandomTable[5];
char field_19192; uint8 field_19192;
char m_bUserPause; uint8 m_bUserPause;
char m_bPreviousUserPause; uint8 m_bPreviousUserPause;
char field_19195; uint8 field_19195;
int m_nTimeOfRecentCrime; int32 m_nTimeOfRecentCrime;
void AddDetailsToRequestedOrderList(uint8 sample); void AddDetailsToRequestedOrderList(uint8 sample);
void AddPlayerCarSample(uint8 emittingVolume, int32 freq, uint32 sample, uint8 unk1, void AddPlayerCarSample(uint8 emittingVolume, int32 freq, uint32 sample, uint8 unk1,
@ -248,6 +248,8 @@ public:
// done // done
void TranslateEntity(CVector *v1, CVector *v2); // todo hook
void Initialise(); void Initialise();
void PostInitialiseGameSpecificSetup(); void PostInitialiseGameSpecificSetup();
void InitialisePoliceRadioZones(); // todo void InitialisePoliceRadioZones(); // todo

38
src/audio/SampleManager.cpp
View File

@ -14,6 +14,37 @@ CSampleManager::IsMP3RadioChannelAvailable()
return nNumOfMp3Files != 0; return nNumOfMp3Files != 0;
} }
WRAPPER
void CSampleManager::SetChannelFrequency(int32, int32) { EAXJMP(0x5679D0); }
WRAPPER
void CSampleManager::SetChannelEmittingVolume(int32, uint32) { EAXJMP(0x567820); }
WRAPPER
void
CSampleManager::SetChannel3DPosition(int32, float, float, float)
{
EAXJMP(0x567890);
}
WRAPPER
void CSampleManager::SetChannelLoopCount(int32, int32) { EAXJMP(0x567AA0); }
WRAPPER
void CSampleManager::SetChannel3DDistances(int32, int32, int32) { EAXJMP(0x5678D0); }
WRAPPER
void CSampleManager::SetChannelReverbFlag(int32, uint8) { EAXJMP(0x567630); }
WRAPPER
int32 CSampleManager::GetSampleLength(int32) { EAXJMP(0x567300); }
WRAPPER
bool CSampleManager::InitialiseChannel(int32, int32, uint32, uint32) { EAXJMP(0x5676A0); }
WRAPPER
void CSampleManager::SetChannelLoopPoints(int32, int32, int32) { EAXJMP(0x567A30); }
WRAPPER WRAPPER
bool bool
CSampleManager::CheckForAnAudioFileOnCD() CSampleManager::CheckForAnAudioFileOnCD()
@ -126,6 +157,13 @@ CSampleManager::GetChannelUsedFlag(int32 id)
EAXJMP(0x567B00); EAXJMP(0x567B00);
} }
WRAPPER
void
CSampleManager::StartChannel(int32 id)
{
EAXJMP(0x567B80);
}
WRAPPER WRAPPER
void void
CSampleManager::StopChannel(int32 id) CSampleManager::StopChannel(int32 id)

18
src/audio/SampleManager.h
View File

@ -13,6 +13,20 @@ struct tSample {
class CSampleManager class CSampleManager
{ {
public: public:
void SetChannelFrequency(int32, int32);
void SetChannelEmittingVolume(int32, uint32);
void SetChannel3DPosition(int32, float, float, float);
void SetChannelLoopCount(int32, int32);
void SetChannel3DDistances(int32, int32, int32);
void SetChannelReverbFlag(int32, uint8);
int32 GetSampleLength(int32);
bool InitialiseChannel(int32, int32, uint32, uint32 something = 0);
void SetChannelLoopPoints(int32, int32, int32);
bool CheckForAnAudioFileOnCD(); bool CheckForAnAudioFileOnCD();
int32 GetSampleBaseFrequency(int32); int32 GetSampleBaseFrequency(int32);
@ -40,6 +54,8 @@ public:
void SetSpeakerConfig(uint32 config); void SetSpeakerConfig(uint32 config);
bool GetChannelUsedFlag(int32 id); bool GetChannelUsedFlag(int32 id);
void StartChannel(int32 id);
void StopChannel(int32 id); void StopChannel(int32 id);
static bool IsMP3RadioChannelAvailable(); static bool IsMP3RadioChannelAvailable();
@ -47,6 +63,6 @@ public:
extern uint32 &nNumOfMp3Files; extern uint32 &nNumOfMp3Files;
extern uint8 &num3DProvidersAvailable; extern uint8 &num3DProvidersAvailable;
extern uint32* asName3DProviders; extern uint32 *asName3DProviders;
extern CSampleManager &cSampleManager; extern CSampleManager &cSampleManager;