232 SI2 functions (0x4C5900-0x4D2780 plus the DSP, voice chat, zone sound, advanced kit property and internal code), in files named after the 12340 __FILE__ strings (SoundInterface2*.cpp) and best-guess splits after the Mac SI3 files. Replaces the _Triage shells. External WoW callees are declared only (GameTime, DBClient, Unit_C, Item_C, ObjectMgrClient, ChatFrame, GameUI, CGWorldStateInfo, ComSatClient, SFile name overloads) and tracked as open items. Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
1352 lines
38 KiB
C++
1352 lines
38 KiB
C++
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <new>
|
|
#include "WoW/Source/SoundInterface/SoundInterface2.h"
|
|
#include "Engine/Source/Base/CmdLine.h"
|
|
#include "Engine/Source/BlizzardCore/SFile2-Core.h"
|
|
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
|
|
#include "Engine/Source/Event/Event.h"
|
|
#include "Engine/Source/Os/TimeManager.h"
|
|
#include "Engine/Source/Storm/H/storm.h"
|
|
#include "Engine/Source/Tempest/CRandom.h"
|
|
#include "Engine/Source/Tempest/CRange.h"
|
|
#include "WoW/Source/DB/DBClient/DBClient.h"
|
|
#include "WoW/Source/Game/GameClient/ComSatClient.h"
|
|
#include "WoW/Source/SoundInterface/SoundInterface2AdvancedKitProperties.h"
|
|
#include "WoW/Source/SoundInterface/SoundInterface2Internal.h"
|
|
#include "WoW/Source/SoundInterface/SoundInterface2ZoneSounds.h"
|
|
#include "WoW/Source/Ui/ChatFrame.h"
|
|
#include "WoW/Source/Ui/GameUI.h"
|
|
|
|
// STATIC: 0x009F2010
|
|
const char SI2::s_channelGroupNames[18][32] = {
|
|
"SFX",
|
|
"MUSIC",
|
|
"AMBIENCE",
|
|
"CINEMATIC",
|
|
"SCRIPTSOUND",
|
|
"SCRIPTMUSIC",
|
|
"RACIALCINEMATIC",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
"SFX",
|
|
};
|
|
|
|
// STATIC: 0x009F2268
|
|
const int32_t SI2::s_channelGroupMaxSounds[18] = {
|
|
0x7FFFFFFF,
|
|
0x7FFFFFFF,
|
|
0x7FFFFFFF,
|
|
0x7FFFFFFF,
|
|
0x7FFFFFFF,
|
|
0x7FFFFFFF,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
2,
|
|
2,
|
|
1,
|
|
6,
|
|
4,
|
|
1,
|
|
2,
|
|
4,
|
|
};
|
|
|
|
// STATIC: 0x00B4A340
|
|
int32_t SI2::s_channelGroupNumSounds[18];
|
|
|
|
// STATIC: 0x00B4A390
|
|
TSGrowableArray<uint32_t> SI2::s_suppressors;
|
|
|
|
// STATIC: 0x00B4A3A0
|
|
static const char* s_savedVoiceSession;
|
|
|
|
// STATIC: 0x00AC3860
|
|
static int32_t s_savedVoiceSessionType = 4;
|
|
|
|
// STATIC: 0x00B4A3E4
|
|
static float s_chaosRestartTimer;
|
|
|
|
// STATIC: 0x00B4A3E8
|
|
static float s_chaosTimer;
|
|
|
|
// STATIC: 0x00B4A3EC
|
|
static int32_t s_chaosElapsedMs;
|
|
|
|
// STATIC: 0x00B4AA94
|
|
int32_t SI2::sm_bPlayerInside;
|
|
|
|
// STATIC: 0x00B4AA98
|
|
int32_t SI2::sm_bCameraIsUnderwater;
|
|
|
|
// STATIC: 0x00B4AA9C
|
|
int32_t SI2::sm_bUnderwaterChanged;
|
|
|
|
// STATIC: 0x00B4AAA0
|
|
uint32_t SI2::sm_nextZoneMusicTime;
|
|
|
|
// STATIC: 0x00B4AAA4
|
|
int32_t SI2::sm_bLuaMusicPlaying;
|
|
|
|
// VERIFY: 8cb9a901 manual
|
|
// OFFSET: 0x004C5B60
|
|
static int32_t GetDownloadPriority(int32_t group) {
|
|
if (group <= 0 || group > 2) {
|
|
return 5;
|
|
}
|
|
|
|
return 6;
|
|
}
|
|
|
|
// VERIFY: 964e6036 auto
|
|
// OFFSET: 0x004C5990
|
|
void SE2SoundKitProperties::ResetToDefaults() {
|
|
this->m_volume = -1.0f;
|
|
this->m_volumeScale = 1.0f;
|
|
this->m_fileIndex = -1;
|
|
this->m_priority = -1;
|
|
this->m_fadeInTime = 0.0f;
|
|
this->m_fadeOutTime = 0.0f;
|
|
this->m_group = 0;
|
|
this->m_selectMode = 2;
|
|
this->m_maxDistance = -1.0f;
|
|
this->m_loopMode = 0;
|
|
this->m_muteFadeSpeed = 0.5f;
|
|
this->m_suppressorMode = 0;
|
|
this->m_decodeBufferSize = 0;
|
|
this->m_maxAudibleBehavior = 1;
|
|
this->m_coneInsideAngle = 360.0f;
|
|
this->m_reverb = 1;
|
|
this->m_coneOutsideAngle = 360.0f;
|
|
this->m_streaming = false;
|
|
this->m_noRandomStart = 0;
|
|
this->m_blockMusicFiles = 0;
|
|
this->m_software = 0;
|
|
this->m_coneOutsideVolume = 1.0f;
|
|
this->m_coneOrientation = nullptr;
|
|
this->m_useDspChain = 0;
|
|
this->m_forceLoop = 0;
|
|
this->m_checkStreaming = SFile::IsStreamingMode() != 0;
|
|
}
|
|
|
|
// VERIFY: 24efb61f manual
|
|
// OFFSET: 0x004C5A20
|
|
float SI2::GetChannelGroupVolume(int32_t group) {
|
|
return SE2::GetChannelGroupVolume(SI2::s_channelGroupNames[group]);
|
|
}
|
|
|
|
// VERIFY: e2c427b3 auto
|
|
// OFFSET: 0x004C5A40
|
|
void SI2::SetChannelGroupVolume(int32_t group, float volume) {
|
|
SE2::SetChannelGroupVolume(SI2::s_channelGroupNames[group], volume);
|
|
}
|
|
|
|
// VERIFY: 44756337 auto
|
|
// OFFSET: 0x004C5A60
|
|
int32_t SI2::GetNumInputDrivers(int32_t chatSystem) {
|
|
return SE2::GetNumInputDrivers(chatSystem);
|
|
}
|
|
|
|
// VERIFY: fc888c05 auto
|
|
// OFFSET: 0x004C5A70
|
|
int32_t SI2::GetNumInputDrivers_Cached(int32_t chatSystem) {
|
|
return SE2::GetNumInputDrivers_Cached(chatSystem);
|
|
}
|
|
|
|
// VERIFY: 7129b2b8 auto
|
|
// OFFSET: 0x004C5A80
|
|
bool SI2::GetInputDriverName(int32_t index, char* name, int32_t nameLength, int32_t chatSystem) {
|
|
return SE2::GetInputDriverName(index, name, nameLength, chatSystem);
|
|
}
|
|
|
|
// VERIFY: 13e146d1 auto
|
|
// OFFSET: 0x004C5A90
|
|
bool SI2::GetInputDriverName_Cached(int32_t index, char* name, int32_t nameLength, int32_t chatSystem) {
|
|
return SE2::GetInputDriverName_Cached(index, name, nameLength, chatSystem);
|
|
}
|
|
|
|
// VERIFY: 13fd08cb auto
|
|
// OFFSET: 0x004C5AA0
|
|
int32_t SI2::GetNumOutputDrivers(int32_t chatSystem) {
|
|
return SE2::GetNumOutputDrivers(chatSystem);
|
|
}
|
|
|
|
// VERIFY: 7fd5990c auto
|
|
// OFFSET: 0x004C5AB0
|
|
int32_t SI2::GetNumOutputDrivers_Cached(int32_t chatSystem) {
|
|
return SE2::GetNumOutputDrivers_Cached(chatSystem);
|
|
}
|
|
|
|
// VERIFY: ab40eaf2 manual
|
|
// OFFSET: 0x004C5AC0
|
|
bool SI2::GetOutputDriverName(int32_t index, char* name, int32_t nameLength, int32_t chatSystem) {
|
|
if (index < 0) {
|
|
index = 0;
|
|
}
|
|
|
|
return SE2::GetOutputDriverName(index, name, nameLength, chatSystem);
|
|
}
|
|
|
|
// VERIFY: 59635ee4 manual
|
|
// OFFSET: 0x004C5AF0
|
|
bool SI2::GetOutputDriverName_Cached(int32_t index, char* name, int32_t nameLength, int32_t chatSystem) {
|
|
if (index < 0) {
|
|
index = 0;
|
|
}
|
|
|
|
return SE2::GetOutputDriverName_Cached(index, name, nameLength, chatSystem);
|
|
}
|
|
|
|
// VERIFY: 8c87872b auto
|
|
// OFFSET: 0x004C5B20
|
|
int32_t SI2::SetListenerAttributes(const C3Vector* position, const C3Vector* forward, const C3Vector* up, const C3Vector* velocity) {
|
|
SE2::SetListenerAttributes(position, forward, up, velocity);
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: ae8eb23a manual
|
|
// OFFSET: 0x004C5B40
|
|
int32_t SI2::GetListenerPosition(C3Vector* position) {
|
|
if (!position) {
|
|
return 1;
|
|
}
|
|
|
|
SE2::GetListenerPosition(position);
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: 75af4810 manual
|
|
// OFFSET: 0x004C5B80
|
|
void SI2::StopAllSounds() {
|
|
SE2::StopAllSounds();
|
|
}
|
|
|
|
// VERIFY: 696f4de8 auto
|
|
// OFFSET: 0x004C5B90
|
|
int32_t SI2::Set3DPosition(SE2SoundKitObject* object, const C3Vector* position) {
|
|
if (object->m_advancedId) {
|
|
SI2::SetAdvancedSoundPosition(object->m_advancedId, position);
|
|
}
|
|
|
|
object->m_sound.Set3DPosition(*position);
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: 8ab4a07a auto
|
|
// OFFSET: 0x004C5BC0
|
|
int32_t SI2::SetVolume(SE2SoundKitObject* object, float volume) {
|
|
object->m_sound.SetVolume(volume);
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: ff3bc1d9 auto
|
|
// OFFSET: 0x004C5BE0
|
|
bool SI2::IsPlaying(SE2SoundKitObject* object) {
|
|
return object->m_sound.IsPlaying();
|
|
}
|
|
|
|
// VERIFY: 2a2ff92d auto
|
|
// OFFSET: 0x004C5BF0
|
|
uint32_t SI2::IsSoundKitLooping(int32_t soundKitId) {
|
|
VSOUNDKITDEF* def = SI2::GetSoundKitDef(soundKitId);
|
|
|
|
if (!def) {
|
|
return 0;
|
|
}
|
|
|
|
return def->m_flags & 0x200;
|
|
}
|
|
|
|
// VERIFY: dd9e9845 manual
|
|
// OFFSET: 0x004C5C10
|
|
int32_t SI2::GetSoundKitUsage(int32_t soundKitId) {
|
|
VSOUNDKITDEF* def = SI2::GetSoundKitDef(soundKitId);
|
|
|
|
if (def && def->m_advanced) {
|
|
return def->m_advanced->m_usage;
|
|
}
|
|
|
|
return 2;
|
|
}
|
|
|
|
// VERIFY: 9ff69350 manual
|
|
// OFFSET: 0x004C5C40
|
|
bool SI2::IsLooping(SE2SoundKitObject* object) {
|
|
return object->m_sound.IsLooping();
|
|
}
|
|
|
|
// VERIFY: 3dddcdd1 auto
|
|
// OFFSET: 0x004C5C60
|
|
int32_t SI2::GetNumSoundsInSoundKit(int32_t soundKitId) {
|
|
VSOUNDKITDEF* def = SI2::GetSoundKitDef(soundKitId);
|
|
|
|
if (!def) {
|
|
return 0;
|
|
}
|
|
|
|
return def->m_numFiles;
|
|
}
|
|
|
|
// VERIFY: 0259b8b2 auto
|
|
// OFFSET: 0x004C5C80
|
|
int32_t SI2::AttachToObject(SE2SoundKitObject* object, uint64_t guid) {
|
|
if (!object->m_sound.Is3D()) {
|
|
return 12;
|
|
}
|
|
|
|
object->m_sound.AttachToObject(guid);
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: f1864be0 auto
|
|
// OFFSET: 0x004C5CC0
|
|
void SI2::StopAllSounds(float fadeOutTime) {
|
|
SE2::StopAllSounds(SI2::s_channelGroupNames[0], fadeOutTime);
|
|
}
|
|
|
|
// VERIFY: 218e92b2 auto
|
|
// OFFSET: 0x004C5CE0
|
|
int32_t SI2ZoneSoundPair::GetCurrentType() {
|
|
return this->m_sounds[this->m_current].m_type;
|
|
}
|
|
|
|
// VERIFY: 702244e3 manual
|
|
// OFFSET: 0x004C5D00
|
|
bool SI2ZoneSoundPair::IsPlaying() {
|
|
return this->m_sounds[this->m_current].m_object.m_sound.IsPlaying();
|
|
}
|
|
|
|
// VERIFY: 1c86efa7 auto
|
|
// OFFSET: 0x004C5D20
|
|
void SI2ZoneSoundPair::SetFinishedCallback(void (*callback)(SESound*, void*), void* param) {
|
|
this->m_sounds[this->m_current].m_object.m_sound.SetFinishedCallback2(callback, param);
|
|
}
|
|
|
|
// VERIFY: 0f619923 auto
|
|
// OFFSET: 0x004C5DC0
|
|
int32_t SI2::OnFocusChanged(const void* data, void* param) {
|
|
static CVar* s_enableSoundWhenGameIsInBG = CVar::Lookup("Sound_EnableSoundWhenGameIsInBG");
|
|
|
|
CVar* enableVoiceChat = CVar::Lookup("EnableVoiceChat");
|
|
const int32_t* focus = static_cast<const int32_t*>(data);
|
|
|
|
if (!focus) {
|
|
return 1;
|
|
}
|
|
|
|
if (*focus) {
|
|
SE2::MuteAllSound(false);
|
|
SE2::MuteChannelGroup("CINEMATIC", false);
|
|
|
|
if (CGGameUI::m_initialized && enableVoiceChat && enableVoiceChat->m_intValue && s_savedVoiceSession) {
|
|
CGChat::SetActiveVoiceSession(s_savedVoiceSession, s_savedVoiceSessionType, -1);
|
|
s_savedVoiceSession = nullptr;
|
|
s_savedVoiceSessionType = 4;
|
|
}
|
|
} else if (s_enableSoundWhenGameIsInBG->m_intValue) {
|
|
SE2::MuteAllSound(false);
|
|
SE2::MuteChannelGroup("CINEMATIC", false);
|
|
} else {
|
|
SE2::MuteAllSound(true);
|
|
SE2::MuteChannelGroup("CINEMATIC", true);
|
|
|
|
if (CGGameUI::m_initialized && !s_savedVoiceSession) {
|
|
s_savedVoiceSession = CGChat::GetChannelStringForDisplay(CGChat::GetActiveVoiceSession(), &s_savedVoiceSessionType);
|
|
CGChat::SetActiveVoiceSession(nullptr, 4, -1);
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
// VERIFY: e5b8f14f manual
|
|
// OFFSET: 0x004C5F00
|
|
static C3Vector RandomListenerOffset() {
|
|
C3Vector listener;
|
|
listener.x = 0.0f;
|
|
listener.y = 0.0f;
|
|
listener.z = 0.0f;
|
|
|
|
float scale = CRandom::sfloat_(g_rndSeed);
|
|
C3Vector direction = CRandom::C3Vector_(g_rndSeed);
|
|
float x = direction.x * scale * 50.0f;
|
|
float y = direction.y * scale * 50.0f;
|
|
float z = direction.z * scale * 50.0f;
|
|
|
|
SE2::GetListenerPosition(&listener);
|
|
|
|
return C3Vector(x + listener.x, y + listener.y, z + listener.z);
|
|
}
|
|
|
|
// VERIFY: ecf8304e manual
|
|
// OFFSET: 0x004C5FB0
|
|
void SI2::ValidateVoiceChatOutputDriver() {
|
|
char name[256];
|
|
char current[256];
|
|
|
|
int32_t count = SE2::GetNumOutputDrivers_Cached(1);
|
|
int32_t missing = 1;
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
SE2::GetOutputDriverName_Cached(i, current, sizeof(current), 1);
|
|
|
|
if (!strcmp(SE2::GetCurrentChatOutputDeviceName(), current)) {
|
|
missing = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static CVar* s_outputDriverIndex = CVar::Lookup("Sound_VoiceChatOutputDriverIndex");
|
|
|
|
if (missing || (!s_outputDriverIndex->m_intValue && (SE2::GetOutputDriverName_Cached(1, name, sizeof(name), 1), strcmp(SE2::GetCurrentChatOutputDeviceName(), name)))) {
|
|
s_outputDriverIndex->Set("0", true, false, false, true);
|
|
ComSatClient_SetOutputDevice(0);
|
|
}
|
|
}
|
|
|
|
// VERIFY: ded1a63e manual
|
|
// OFFSET: 0x004C60F0
|
|
void SI2::ValidateVoiceChatInputDriver() {
|
|
char name[256];
|
|
char current[256];
|
|
|
|
int32_t count = SE2::GetNumInputDrivers_Cached(1);
|
|
int32_t missing = 1;
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
SE2::GetInputDriverName_Cached(i, current, sizeof(current), 1);
|
|
|
|
if (!strcmp(SE2::GetCurrentChatInputDeviceName(), current)) {
|
|
missing = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static CVar* s_inputDriverIndex = CVar::Lookup("Sound_VoiceChatInputDriverIndex");
|
|
|
|
if (missing || (!s_inputDriverIndex->m_intValue && (SE2::GetInputDriverName_Cached(1, name, sizeof(name), 1), strcmp(SE2::GetCurrentChatInputDeviceName(), name)))) {
|
|
s_inputDriverIndex->Set("0", true, false, false, true);
|
|
ComSatClient_SetCaptureDevice(0);
|
|
}
|
|
}
|
|
|
|
// VERIFY: f1a4c4cd manual
|
|
// OFFSET: 0x004C6230
|
|
int32_t SI2::ShutDown(int32_t restart) {
|
|
EventUnregister(EVENT_ID_FOCUS, SI2::OnFocusChanged);
|
|
EventUnregister(EVENT_ID_POLL, SI2::UpdateAdvancedSounds);
|
|
|
|
if (!restart) {
|
|
SI2::ClearSuppressorSounds();
|
|
}
|
|
|
|
SE2::StopAllSounds();
|
|
|
|
if (!restart) {
|
|
SI2::FreeWorldStateZoneSoundOverrides();
|
|
SI2::FreeZoneSoundOverrides();
|
|
SI2::FreeFootstepSounds();
|
|
SI2::FreeEmoteSounds();
|
|
}
|
|
|
|
SI2::DSP_ShutDown();
|
|
SE2::UnregisterHeartBeat();
|
|
SI2::ReleaseSoundGroups();
|
|
|
|
if (!restart) {
|
|
SI2::FreeSoundKitDefs();
|
|
}
|
|
|
|
SE2::ShutDown(restart);
|
|
|
|
if (!restart) {
|
|
SI2::DestroyVSoundLookup();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: a240cc52 auto
|
|
// OFFSET: 0x004C62B0
|
|
void SI2::SoundFinished(SESound* sound, void* param) {
|
|
SI2SoundUserData* userData = static_cast<SI2SoundUserData*>(sound->GetUserData());
|
|
|
|
if (!userData) {
|
|
return;
|
|
}
|
|
|
|
SI2::s_channelGroupNumSounds[userData->m_group]--;
|
|
|
|
if (userData->m_advancedId && userData->m_def && userData->m_def->m_advanced && userData->m_def->m_advanced->m_usage == 2) {
|
|
SI2::MarkAdvancedSoundStopped(userData->m_advancedId);
|
|
}
|
|
|
|
VSOUNDKITDEF* def = userData->m_def;
|
|
|
|
if (def && (def->m_flags & 0x20)) {
|
|
int32_t id = def->m_id;
|
|
|
|
for (uint32_t i = 0; i < SI2::s_suppressors.Count(); i++) {
|
|
if (SI2::s_suppressors[i] == id) {
|
|
SI2::s_suppressors[i] = 0;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// VERIFY: 551d00f9 auto
|
|
// OFFSET: 0x004C6330
|
|
int32_t SI2::ResetSoundKitVariants(const char* name) {
|
|
int32_t soundKitId = SI2::LookupSoundKitId(name);
|
|
|
|
if (!soundKitId) {
|
|
return 7;
|
|
}
|
|
|
|
VSOUNDKITDEF* def = SI2::GetSoundKitDef(soundKitId);
|
|
|
|
if (!def) {
|
|
return 5;
|
|
}
|
|
|
|
if (!def->m_numFiles) {
|
|
return 6;
|
|
}
|
|
|
|
def->ResetWeights();
|
|
def->m_lastIndex = -1;
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: 2c0f24c2 auto
|
|
// OFFSET: 0x004C6390
|
|
int32_t SI2::StopSound(SE2SoundKitObject* object, int32_t immediate, float fadeOutTime, int32_t stopAdvanced) {
|
|
SI2SoundUserData* userData = static_cast<SI2SoundUserData*>(object->m_sound.GetUserData());
|
|
|
|
if (userData) {
|
|
VSOUNDKITDEF* def = userData->m_def;
|
|
|
|
if (def && (def->m_flags & 0x20)) {
|
|
int32_t id = def->m_id;
|
|
|
|
for (uint32_t i = 0; i < SI2::s_suppressors.Count(); i++) {
|
|
if (SI2::s_suppressors[i] == id) {
|
|
SI2::s_suppressors[i] = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
object->m_sound.Stop(immediate, fadeOutTime);
|
|
|
|
if (stopAdvanced) {
|
|
SI2::StopAdvancedSound(object->m_advancedId);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: 8b75cf26 manual
|
|
// OFFSET: 0x004C6410
|
|
int32_t SI2ZoneSoundPair::GetPlayingSoundKitId() {
|
|
if (this->m_sounds[this->m_current].m_object.m_sound.IsPlaying()) {
|
|
return this->m_sounds[this->m_current].m_soundKitId;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: 71a7805b manual
|
|
// OFFSET: 0x004C6450
|
|
void SI2ZoneSoundPair::Stop(int32_t immediate) {
|
|
SI2::StopSound(&this->m_sounds[this->m_current].m_object, immediate, -1.0f, 1);
|
|
this->m_sounds[this->m_current].m_type = 13;
|
|
this->m_sounds[this->m_current].m_soundKitId = 0;
|
|
|
|
SI2::StopSound(&this->m_sounds[this->m_next].m_object, immediate, -1.0f, 1);
|
|
this->m_sounds[this->m_next].m_type = 13;
|
|
this->m_sounds[this->m_next].m_soundKitId = 0;
|
|
}
|
|
|
|
// VERIFY: 42b96170 auto
|
|
// OFFSET: 0x004C6500
|
|
SI2SoundUserData::SI2SoundUserData() {
|
|
this->m_name = nullptr;
|
|
this->m_soundKitId = 0;
|
|
this->m_def = nullptr;
|
|
this->m_group = 0;
|
|
this->unk_0014 = 0;
|
|
this->m_advancedId = 0;
|
|
}
|
|
|
|
// VERIFY: d9247093 manual
|
|
// OFFSET: 0x004C6520
|
|
SI2SoundUserData::~SI2SoundUserData() {
|
|
this->m_name = nullptr;
|
|
this->m_soundKitId = 0;
|
|
this->m_def = nullptr;
|
|
this->m_group = 0;
|
|
this->unk_0014 = 0;
|
|
this->m_advancedId = 0;
|
|
}
|
|
|
|
// VERIFY: 43b346c5 auto
|
|
// OFFSET: 0x00532950
|
|
void SI2SoundUserData::Release() {
|
|
delete this;
|
|
}
|
|
|
|
// VERIFY: a4a74c7f manual
|
|
// OFFSET: 0x004C6560
|
|
void SI2::ValidateOutputDriver() {
|
|
char name[256];
|
|
char current[256];
|
|
|
|
int32_t count = SE2::GetNumOutputDrivers_Cached(0);
|
|
int32_t missing = 1;
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
SE2::GetOutputDriverName_Cached(i, current, sizeof(current), 0);
|
|
|
|
if (!strcmp(SE2::GetCurrentGameOutputDeviceName(), current)) {
|
|
missing = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static CVar* s_outputDriverIndex = CVar::Lookup("Sound_OutputDriverIndex");
|
|
|
|
if (missing || (!s_outputDriverIndex->m_intValue && (SE2::GetOutputDriverName_Cached(1, name, sizeof(name), 0), strcmp(SE2::GetCurrentGameOutputDeviceName(), name)))) {
|
|
s_outputDriverIndex->Set("0", true, false, false, true);
|
|
int32_t restart = count != 0;
|
|
SI2::ShutDown(restart);
|
|
SI2::Init(restart);
|
|
}
|
|
}
|
|
|
|
// VERIFY: bc4053ef auto
|
|
// OFFSET: 0x004C6700
|
|
void SI2::RegisterDeviceChangeHandler() {
|
|
EventRegister(EVENT_ID_POLL, SI2::HandleSoundDeviceChange);
|
|
}
|
|
|
|
// VERIFY: 5c43095a manual
|
|
// OFFSET: 0x004C6A40
|
|
int32_t SI2::PlaySoundKit(int32_t soundKitId, const C3Vector* position, SE2SoundKitObject* object, SE2SoundKitProperties* properties, uint32_t advancedId, uint32_t* soundId, int32_t checkDistance, int32_t keepPlaying) {
|
|
if (soundKitId <= 0) {
|
|
return 5;
|
|
}
|
|
|
|
VSOUNDKITDEF* def = SI2::GetSoundKitDef(soundKitId);
|
|
|
|
if (!def) {
|
|
return 5;
|
|
}
|
|
|
|
if (!def->m_numFiles) {
|
|
return 6;
|
|
}
|
|
|
|
if (!SE2::IsInitialized()) {
|
|
return 17;
|
|
}
|
|
|
|
static CVar* s_enableAllSound = CVar::Lookup("Sound_EnableAllSound");
|
|
|
|
if (!s_enableAllSound || !s_enableAllSound->m_intValue || CGGameUI::m_inMovie) {
|
|
return 17;
|
|
}
|
|
|
|
SE2SoundKitProperties defaults;
|
|
defaults.ResetToDefaults();
|
|
|
|
if (!properties) {
|
|
properties = &defaults;
|
|
}
|
|
|
|
if (SI2::s_channelGroupNumSounds[properties->m_group] >= SI2::s_channelGroupMaxSounds[properties->m_group]) {
|
|
return 14;
|
|
}
|
|
|
|
if (!strcmp(SI2::s_channelGroupNames[properties->m_group], "SFX")) {
|
|
static CVar* s_enableSFX = CVar::Lookup("Sound_EnableSFX");
|
|
|
|
if (!s_enableSFX || !s_enableSFX->m_intValue) {
|
|
return 9;
|
|
}
|
|
}
|
|
|
|
if (!strcmp(SI2::s_channelGroupNames[properties->m_group], "MUSIC") || !strcmp(SI2::s_channelGroupNames[properties->m_group], "SCRIPTMUSIC")) {
|
|
static CVar* s_enableMusic = CVar::Lookup("Sound_EnableMusic");
|
|
|
|
if (!s_enableMusic || !s_enableMusic->m_intValue) {
|
|
return 10;
|
|
}
|
|
}
|
|
|
|
if (properties->m_group == 2) {
|
|
static CVar* s_enableAmbience = CVar::Lookup("Sound_EnableAmbience");
|
|
|
|
if (!s_enableAmbience || !s_enableAmbience->m_intValue) {
|
|
return 11;
|
|
}
|
|
}
|
|
|
|
if (properties->m_group >= 18) {
|
|
return 8;
|
|
}
|
|
|
|
if (CGChat::IsPaused() && !position) {
|
|
return 9;
|
|
}
|
|
|
|
if (properties->m_suppressorMode == 2) {
|
|
def->m_flags |= 0x20;
|
|
}
|
|
|
|
if (properties->m_suppressorMode == 1) {
|
|
def->m_flags &= ~0x20u;
|
|
}
|
|
|
|
if (def->m_flags & 0x20) {
|
|
for (uint32_t i = 0; i < SI2::s_suppressors.Count(); i++) {
|
|
if (SI2::s_suppressors[i] == static_cast<uint32_t>(soundKitId)) {
|
|
return 15;
|
|
}
|
|
}
|
|
}
|
|
|
|
SESound localSound;
|
|
SESound* sound;
|
|
|
|
if (object) {
|
|
sound = &object->m_sound;
|
|
|
|
if (!keepPlaying) {
|
|
SI2::StopSound(object, 1, -1.0f, 1);
|
|
}
|
|
} else {
|
|
sound = &localSound;
|
|
properties->m_loopMode = 2;
|
|
}
|
|
|
|
const char* file = def->SelectFile(properties->m_selectMode, nullptr, properties->m_fileIndex, GetDownloadPriority(properties->m_group));
|
|
|
|
if (!file) {
|
|
return 16;
|
|
}
|
|
|
|
if (properties->m_checkStreaming) {
|
|
int32_t local = SFile::FileIsLocal(file, GetDownloadPriority(properties->m_group));
|
|
|
|
if (local != 1) {
|
|
if (properties->m_group == 6) {
|
|
if (!SFile::MakeFileLocal(file, 2, true)) {
|
|
return 16;
|
|
}
|
|
} else if (local == 0 || local == 2) {
|
|
if (local == 0) {
|
|
SFile::MakeFileLocal(file, GetDownloadPriority(properties->m_group), false);
|
|
}
|
|
|
|
def->m_downloadPending = 1;
|
|
return 20;
|
|
}
|
|
}
|
|
}
|
|
|
|
def->m_downloadPending = 0;
|
|
|
|
if (properties->m_blockMusicFiles && (SStrStrI(file, "music") || SStrStrI(file, "ambience") || SStrStrI(file, "cinematic"))) {
|
|
return 16;
|
|
}
|
|
|
|
int32_t looping = 0;
|
|
|
|
if (properties->m_loopMode == 0) {
|
|
looping = def->m_flags & 0x200;
|
|
} else if (properties->m_loopMode == 1) {
|
|
looping = 1;
|
|
}
|
|
|
|
if (properties->m_forceLoop) {
|
|
looping = 1;
|
|
properties->m_maxAudibleBehavior = 0;
|
|
properties->m_streaming = true;
|
|
properties->m_software = 1;
|
|
}
|
|
|
|
if (looping && !object) {
|
|
DebugLog("XXXX\nXXXX ERROR!! Sound Kit ID %d is a looping sound but there is no user handle! This sound will play forever!! \nXXXX\n", soundKitId);
|
|
}
|
|
|
|
SE2::SetSoundGroupMaxAudibleBehavior(def->m_loadSoundGroup, 1, 0.0f);
|
|
SE2::SetSoundGroupMaxAudibleBehavior(def->m_soundGroup, properties->m_maxAudibleBehavior, properties->m_muteFadeSpeed);
|
|
|
|
if (def->m_advanced && !advancedId) {
|
|
SI2::AddAdvancedSound(def->m_advanced, soundKitId, position, properties->m_coneOrientation, object, 0, 0, checkDistance, properties->m_loopMode == 1);
|
|
return 0;
|
|
}
|
|
|
|
bool randomStart = properties->m_group != 1 && properties->m_group != 5 && !properties->m_noRandomStart;
|
|
|
|
if (position) {
|
|
if (!sound->Create3D(file, looping, def->m_loadSoundGroup, def->m_soundGroup, randomStart, properties->m_streaming, properties->m_priority, properties->m_software, properties->m_coneInsideAngle, properties->m_coneOutsideAngle, properties->m_coneOutsideVolume, properties->m_coneOrientation)) {
|
|
return 16;
|
|
}
|
|
|
|
sound->Set3DPosition(*position);
|
|
sound->Set3DMinMaxDistance(def->m_minDistance, properties->m_maxDistance > -1.0f ? properties->m_maxDistance : def->m_distanceCutoff);
|
|
} else if (!sound->Create2D(file, looping, def->m_loadSoundGroup, def->m_soundGroup, randomStart, properties->m_streaming, properties->m_reverb, properties->m_priority, properties->m_decodeBufferSize)) {
|
|
return 16;
|
|
}
|
|
|
|
sound->SetChannelGroup(SI2::s_channelGroupNames[properties->m_group], properties->m_group != 3);
|
|
|
|
SI2SoundUserData* userData = new (SMemAlloc(sizeof(SI2SoundUserData), __FILE__, __LINE__, 0)) SI2SoundUserData();
|
|
userData->m_name = def->m_name ? def->m_name : "<UNKNOWN ERROR>";
|
|
userData->m_soundKitId = soundKitId;
|
|
userData->m_def = def;
|
|
userData->m_advancedId = advancedId;
|
|
userData->m_group = properties->m_group;
|
|
sound->SetUserData(userData);
|
|
|
|
float volume;
|
|
|
|
if (properties->m_volume < 0.0f || properties->m_volume > 1.0f) {
|
|
volume = def->m_volume * properties->m_volumeScale;
|
|
|
|
if (def->m_flags & 0x800) {
|
|
CRange range;
|
|
range.m_l = -0.15f;
|
|
range.m_h = 0.15f;
|
|
volume = range.Random(g_rndSeed) + volume;
|
|
}
|
|
} else {
|
|
volume = properties->m_volume;
|
|
}
|
|
|
|
sound->SetVolume(volume);
|
|
|
|
if (def->m_flags & 0x400) {
|
|
CRange range;
|
|
range.m_l = 0.85f;
|
|
range.m_h = 1.15f;
|
|
sound->SetPitch(range.Random(g_rndSeed));
|
|
}
|
|
|
|
if (properties->m_fadeInTime >= 0.0f) {
|
|
sound->SetFadeInTime(properties->m_fadeInTime);
|
|
}
|
|
|
|
if (properties->m_fadeOutTime >= 0.0f) {
|
|
sound->SetFadeOutTime(properties->m_fadeOutTime);
|
|
}
|
|
|
|
SI2::s_channelGroupNumSounds[properties->m_group]++;
|
|
sound->SetFinishedCallback(SI2::SoundFinished, nullptr);
|
|
|
|
if (def->m_flags & 0x20) {
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < SI2::s_suppressors.Count(); i++) {
|
|
if (!SI2::s_suppressors[i]) {
|
|
SI2::s_suppressors[i] = soundKitId;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i >= SI2::s_suppressors.Count()) {
|
|
*SI2::s_suppressors.New() = soundKitId;
|
|
}
|
|
}
|
|
|
|
if (properties->m_useDspChain) {
|
|
sound->SetAttachCustomDSPChainCallback(SI2::DSP_AttachCustomDspChain, properties->m_dspChainName);
|
|
}
|
|
|
|
sound->CompleteNonBlockingLoad();
|
|
|
|
if (soundId) {
|
|
*soundId = sound->GetID();
|
|
}
|
|
|
|
sound->Play();
|
|
return 0;
|
|
}
|
|
|
|
// VERIFY: 4ec0a358 manual
|
|
// OFFSET: 0x004C7140
|
|
int32_t SI2ZoneSoundPair::Transition(int32_t soundKitId, int32_t type, SE2SoundKitProperties* properties, int32_t immediate, float fadeOutTime) {
|
|
if (type >= 11) {
|
|
SI2::StopSound(&this->m_sounds[this->m_current].m_object, 0, -1.0f, 1);
|
|
this->m_sounds[this->m_current].m_type = type;
|
|
this->m_sounds[this->m_current].m_soundKitId = 0;
|
|
return 18;
|
|
}
|
|
|
|
if (immediate) {
|
|
SI2::StopSound(&this->m_sounds[this->m_current].m_object, 1, -1.0f, 1);
|
|
SI2::StopSound(&this->m_sounds[this->m_next].m_object, 1, -1.0f, 1);
|
|
|
|
int32_t result = SI2::PlaySoundKit(soundKitId, nullptr, &this->m_sounds[this->m_current].m_object, properties, 0, nullptr, 1, 0);
|
|
|
|
if (!result) {
|
|
this->m_sounds[this->m_current].m_soundKitId = soundKitId;
|
|
this->m_sounds[this->m_current].m_type = type;
|
|
return 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
if (soundKitId == this->m_sounds[this->m_current].m_soundKitId && this->m_sounds[this->m_current].m_object.m_sound.IsPlaying()) {
|
|
return 15;
|
|
}
|
|
|
|
if (soundKitId == this->m_sounds[this->m_next].m_soundKitId && this->m_sounds[this->m_next].m_object.m_sound.IsPlaying()) {
|
|
if (fadeOutTime >= 0.0f) {
|
|
this->m_sounds[this->m_current].m_object.m_sound.SetFadeOutTime(fadeOutTime);
|
|
}
|
|
|
|
this->m_sounds[this->m_current].m_object.m_sound.FadeOutNow();
|
|
|
|
if (properties) {
|
|
this->m_sounds[this->m_next].m_object.m_sound.SetFadeInTime(properties->m_fadeInTime);
|
|
}
|
|
|
|
this->m_sounds[this->m_next].m_object.m_sound.FadeInNow();
|
|
|
|
uint32_t current = this->m_current;
|
|
this->m_next = current;
|
|
this->m_current = 1 - current;
|
|
return 21;
|
|
}
|
|
|
|
SI2::StopSound(&this->m_sounds[this->m_next].m_object, 0, -1.0f, 1);
|
|
|
|
if (fadeOutTime >= 0.0f) {
|
|
this->m_sounds[this->m_current].m_object.m_sound.SetFadeOutTime(fadeOutTime);
|
|
}
|
|
|
|
this->m_sounds[this->m_current].m_object.m_sound.FadeOutNow();
|
|
|
|
int32_t result = SI2::PlaySoundKit(soundKitId, nullptr, &this->m_sounds[this->m_next].m_object, properties, 0, nullptr, 1, 0);
|
|
|
|
if (!result) {
|
|
this->m_sounds[this->m_next].m_soundKitId = soundKitId;
|
|
this->m_sounds[this->m_next].m_type = type;
|
|
|
|
uint32_t current = this->m_current;
|
|
this->m_next = current;
|
|
this->m_current = 1 - current;
|
|
return 0;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// VERIFY: 212be192 auto
|
|
// OFFSET: 0x004C7410
|
|
SE2SoundKitObject::SE2SoundKitObject() {
|
|
this->m_advancedId = 0;
|
|
this->unk_0010 = 0;
|
|
}
|
|
|
|
// VERIFY: 19a1e756 auto
|
|
// OFFSET: 0x004C7440
|
|
SE2SoundKitObject::~SE2SoundKitObject() {
|
|
if (this->m_advancedId) {
|
|
SI2::StopAdvancedSound(this->m_advancedId);
|
|
}
|
|
}
|
|
|
|
// VERIFY: cf497004 auto
|
|
// OFFSET: 0x004C74A0
|
|
int32_t SI2::PlaySoundKit(const char* name, const C3Vector* position, SE2SoundKitObject* object, SE2SoundKitProperties* properties) {
|
|
if (!SE2::IsInitialized()) {
|
|
return 17;
|
|
}
|
|
|
|
int32_t soundKitId = SI2::LookupSoundKitId(name);
|
|
|
|
if (!soundKitId) {
|
|
return 7;
|
|
}
|
|
|
|
return SI2::PlaySoundKit(soundKitId, position, object, properties, 0, nullptr, 1, 0);
|
|
}
|
|
|
|
// OFFSET: 0x004C74F0
|
|
int32_t SI2::ChaosModeUpdate(const void* data, void* param) {
|
|
static CVar* s_chaosMode = CVar::Lookup("Sound_ChaosMode");
|
|
|
|
int32_t mode = 0;
|
|
|
|
if (s_chaosMode) {
|
|
mode = s_chaosMode->m_intValue;
|
|
}
|
|
|
|
static uint32_t s_maxSoundKitId = g_soundEntriesDB.m_maxID;
|
|
|
|
C3Vector position;
|
|
position.x = 0.0f;
|
|
position.y = 0.0f;
|
|
position.z = 0.0f;
|
|
|
|
uint32_t soundKitId = static_cast<uint32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32);
|
|
|
|
static SE2SoundKitObject s_object2D;
|
|
static SE2SoundKitObject s_object3D;
|
|
static SE2SoundKitObject s_loopObjects[80];
|
|
static uint32_t s_lastTime = OsGetAsyncTimeMs();
|
|
|
|
uint32_t now = OsGetAsyncTimeMs();
|
|
s_chaosElapsedMs += now - s_lastTime;
|
|
float elapsed = static_cast<int32_t>(now - s_lastTime) * 0.001f;
|
|
|
|
SE2SoundKitProperties properties;
|
|
properties.ResetToDefaults();
|
|
properties.m_volumeScale = 0.3f;
|
|
properties.m_loopMode = 2;
|
|
properties.m_streaming = false;
|
|
properties.m_blockMusicFiles = 1;
|
|
|
|
SE2SoundKitProperties loopProperties;
|
|
loopProperties.ResetToDefaults();
|
|
loopProperties.m_volumeScale = 0.3f;
|
|
loopProperties.m_loopMode = 1;
|
|
loopProperties.m_streaming = false;
|
|
loopProperties.m_blockMusicFiles = 1;
|
|
|
|
switch (mode) {
|
|
case 2:
|
|
if (s_chaosElapsedMs < 100) {
|
|
break;
|
|
}
|
|
|
|
properties.m_streaming = true;
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
|
|
case 1:
|
|
if (s_chaosElapsedMs >= 100) {
|
|
properties.m_streaming = false;
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
s_chaosElapsedMs = 0;
|
|
}
|
|
|
|
break;
|
|
|
|
case 4:
|
|
SI2::PlaySoundKit(soundKitId, nullptr, &s_object2D, &properties, 0, nullptr, 1, 0);
|
|
SI2::StopSound(&s_object2D, 1, -1.0f, 1);
|
|
SI2::PlaySoundKit(soundKitId, nullptr, &s_object3D, &properties, 0, nullptr, 1, 0);
|
|
SI2::StopSound(&s_object3D, 1, -1.0f, 1);
|
|
|
|
case 3:
|
|
SI2::PlaySoundKit(soundKitId, nullptr, &s_object2D, &properties, 0, nullptr, 1, 0);
|
|
SI2::StopSound(&s_object2D, 1, -1.0f, 1);
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(soundKitId, &position, &s_object3D, &properties, 0, nullptr, 1, 0);
|
|
SI2::StopSound(&s_object3D, 1, -1.0f, 1);
|
|
break;
|
|
|
|
case 5:
|
|
s_chaosTimer += elapsed;
|
|
|
|
if (s_chaosTimer <= 1.0f) {
|
|
break;
|
|
}
|
|
|
|
for (int32_t i = 80; i; i--) {
|
|
SI2::PlaySoundKit(soundKitId, nullptr, nullptr, &properties, 0, nullptr, 1, 0);
|
|
}
|
|
|
|
s_chaosTimer = 0.0f;
|
|
break;
|
|
|
|
case 6:
|
|
s_chaosTimer += elapsed;
|
|
|
|
if (s_chaosTimer <= 1.0f) {
|
|
break;
|
|
}
|
|
|
|
for (int32_t i = 80; i; i--) {
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(soundKitId, &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
}
|
|
|
|
s_chaosTimer = 0.0f;
|
|
break;
|
|
|
|
case 7:
|
|
s_chaosTimer += elapsed;
|
|
|
|
if (s_chaosTimer <= 1.0f) {
|
|
break;
|
|
}
|
|
|
|
for (SE2SoundKitObject* object = s_loopObjects; object < &s_loopObjects[80]; object++) {
|
|
if (!object->m_sound.IsPlaying()) {
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(soundKitId, &position, object, &loopProperties, 0, nullptr, 1, 0);
|
|
}
|
|
}
|
|
|
|
s_chaosTimer = 0.0f;
|
|
break;
|
|
|
|
case 8:
|
|
s_chaosTimer += elapsed;
|
|
|
|
if (s_chaosTimer <= 0.05f) {
|
|
break;
|
|
}
|
|
|
|
printf("----------playing...\n");
|
|
SI2::PlaySoundFile("Data\\Alert.mp3", 4);
|
|
s_chaosTimer = 0.0f;
|
|
break;
|
|
|
|
case 9:
|
|
s_chaosRestartTimer += elapsed;
|
|
|
|
if (s_chaosRestartTimer <= 10.0f) {
|
|
break;
|
|
}
|
|
|
|
DebugLog("##RESTART SOUND ENGINE!!\n");
|
|
SI2::ShutDown(1);
|
|
SI2::Init(1);
|
|
s_chaosRestartTimer = 0.0f;
|
|
|
|
{
|
|
static CVar* s_chaosMode9 = CVar::Lookup("Sound_ChaosMode");
|
|
s_chaosMode9->Set("9", true, false, false, true);
|
|
}
|
|
|
|
break;
|
|
|
|
case 10:
|
|
s_chaosRestartTimer += elapsed;
|
|
|
|
if (s_chaosElapsedMs < 100) {
|
|
break;
|
|
}
|
|
|
|
s_chaosElapsedMs = 0;
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
|
|
if (s_chaosRestartTimer <= 10.0f) {
|
|
break;
|
|
}
|
|
|
|
DebugLog("##RESTART SOUND ENGINE!!\n");
|
|
SI2::ShutDown(1);
|
|
SI2::Init(1);
|
|
s_chaosRestartTimer = 0.0f;
|
|
|
|
{
|
|
static CVar* s_chaosMode10 = CVar::Lookup("Sound_ChaosMode");
|
|
s_chaosMode10->Set("10", true, false, false, true);
|
|
}
|
|
|
|
break;
|
|
|
|
case 13:
|
|
if (s_chaosElapsedMs < 100) {
|
|
break;
|
|
}
|
|
|
|
properties.m_streaming = true;
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
properties.m_streaming = false;
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
|
|
case 12:
|
|
if (s_chaosElapsedMs < 100) {
|
|
break;
|
|
}
|
|
|
|
properties.m_streaming = true;
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), nullptr, nullptr, &properties, 0, nullptr, 1, 0);
|
|
|
|
case 11:
|
|
if (s_chaosElapsedMs >= 100) {
|
|
properties.m_streaming = false;
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), nullptr, nullptr, &properties, 0, nullptr, 1, 0);
|
|
s_chaosElapsedMs = 0;
|
|
}
|
|
|
|
break;
|
|
|
|
case 14: {
|
|
s_chaosRestartTimer += elapsed;
|
|
|
|
if (s_chaosElapsedMs < 100) {
|
|
break;
|
|
}
|
|
|
|
s_chaosElapsedMs = 0;
|
|
uint32_t sameId = static_cast<uint32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32);
|
|
|
|
for (int32_t i = 20; i; i--) {
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(sameId, &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
}
|
|
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(static_cast<int32_t>((static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * s_maxSoundKitId) >> 32), &position, nullptr, &properties, 0, nullptr, 1, 0);
|
|
|
|
if (s_chaosRestartTimer <= 10.0f) {
|
|
break;
|
|
}
|
|
|
|
DebugLog("##RESTART SOUND ENGINE!!\n");
|
|
SI2::ShutDown(1);
|
|
SI2::Init(1);
|
|
s_chaosRestartTimer = 0.0f;
|
|
|
|
static CVar* s_chaosMode14 = CVar::Lookup("Sound_ChaosMode");
|
|
s_chaosMode14->Set("14", true, false, false, true);
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
int32_t ids[3] = { 13061, 15969, 12173 };
|
|
|
|
for (int32_t i = 0; i < 8; i++) {
|
|
position = RandomListenerOffset();
|
|
SI2::PlaySoundKit(ids[(static_cast<uint64_t>(CRandom::uint32_(g_rndSeed)) * 3) >> 32], &position, &s_object3D, &properties, 0, nullptr, 1, 0);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
s_lastTime = now;
|
|
return 1;
|
|
}
|
|
|
|
// VERIFY: 3e5c36df auto
|
|
// OFFSET: 0x004C82E0
|
|
int32_t SI2::Init(int32_t restart) {
|
|
if (CmdLineGetBool(static_cast<CMDOPT>(26))) {
|
|
SI2::RegisterSoundEngineCVars();
|
|
SI2::RegisterCVars();
|
|
return 17;
|
|
}
|
|
|
|
if (!restart) {
|
|
SI2::CreateVSoundLookup();
|
|
SI2::InitFootstepSounds();
|
|
SI2::InitEmoteSounds();
|
|
SI2::InitWeaponImpactCombatSounds();
|
|
SI2::InitWeaponSwingCombatSounds();
|
|
SI2::RegisterSoundEngineCVars();
|
|
}
|
|
|
|
int32_t enableReverb = 0;
|
|
int32_t enableSoftwareHRTF = 0;
|
|
int32_t numChannels = 4;
|
|
|
|
static CVar* s_enableReverb = CVar::Lookup("Sound_EnableReverb");
|
|
|
|
if (s_enableReverb) {
|
|
enableReverb = s_enableReverb->m_intValue;
|
|
}
|
|
|
|
static CVar* s_enableSoftwareHRTF = CVar::Lookup("Sound_EnableSoftwareHRTF");
|
|
|
|
if (s_enableSoftwareHRTF) {
|
|
enableSoftwareHRTF = s_enableSoftwareHRTF->m_intValue;
|
|
}
|
|
|
|
static CVar* s_numChannels = CVar::Lookup("Sound_NumChannels");
|
|
|
|
if (s_numChannels) {
|
|
numChannels = s_numChannels->m_intValue;
|
|
}
|
|
|
|
int32_t outputDriverIndex = 0;
|
|
const char* outputDriverName = "";
|
|
|
|
static CVar* s_outputDriverIndex = CVar::Lookup("Sound_OutputDriverIndex");
|
|
|
|
if (s_outputDriverIndex) {
|
|
outputDriverIndex = s_outputDriverIndex->m_intValue;
|
|
}
|
|
|
|
static CVar* s_outputDriverName = CVar::Lookup("Sound_OutputDriverName");
|
|
|
|
if (s_outputDriverName) {
|
|
outputDriverName = s_outputDriverName->m_stringValue.m_str;
|
|
}
|
|
|
|
SE2::Init(512, SI2::GetObjectPosition, enableReverb, enableSoftwareHRTF, &numChannels, &outputDriverIndex, outputDriverName, SI2::GetSoundVolume, restart);
|
|
SI2::ClearSuppressors();
|
|
|
|
if (s_outputDriverIndex) {
|
|
char value[32];
|
|
SStrPrintf(value, sizeof(value), "%d", outputDriverIndex);
|
|
s_outputDriverIndex->Set(value, true, false, false, true);
|
|
}
|
|
|
|
static CVar* s_masterVolume = CVar::Lookup("Sound_MasterVolume");
|
|
|
|
if (s_masterVolume) {
|
|
SE2::SetMasterVolume(s_masterVolume->m_floatValue);
|
|
}
|
|
|
|
EventRegister(EVENT_ID_POLL, SI2::UpdateAdvancedSounds);
|
|
EventRegister(EVENT_ID_FOCUS, SI2::OnFocusChanged);
|
|
SI2::RegisterCVars();
|
|
|
|
if (!restart) {
|
|
SI2::InitSoundKitLookup();
|
|
SI2::InitWorldStateZoneSoundOverrides();
|
|
SI2::InitZoneSoundOverrides();
|
|
}
|
|
|
|
SI2::CreateSoundGroups();
|
|
|
|
if (CmdLineGetBool(static_cast<CMDOPT>(27))) {
|
|
EventRegister(EVENT_ID_POLL, SI2::ChaosModeUpdate);
|
|
}
|
|
|
|
SE2::SetDeviceChangeCallback(SI2::RegisterDeviceChangeHandler);
|
|
|
|
static CVar* s_enableDSPEffects = CVar::Lookup("Sound_EnableDSPEffects");
|
|
|
|
if (s_enableDSPEffects->m_intValue) {
|
|
SI2::DSP_Init();
|
|
}
|
|
|
|
return 0;
|
|
}
|