From ef9a9da83f7227ed9190e930ad1d03f2bf8e0020 Mon Sep 17 00:00:00 2001 From: marauder2k7 Date: Mon, 29 Oct 2018 18:01:56 +0000 Subject: [PATCH] OpenALEffects Ground work, this commit enables reverb zones and opens the slots for other effects to be added later. Tested using the full template. Build your openal dll and your full.exe use one of the environment presets and it will work --- Engine/source/sfx/openal/LoadOAL.h | 51 + Engine/source/sfx/openal/sfxALDevice.cpp | 131 +- Engine/source/sfx/openal/sfxALDevice.h | 9 + Engine/source/sfx/openal/sfxALVoice.cpp | 3 +- Engine/source/sfx/openal/win32/LoadOAL.cpp | 111 + Engine/source/sfx/sfxCommon.h | 343 +-- Engine/source/sfx/sfxDescription.cpp | 212 +- Engine/source/sfx/sfxDevice.h | 3 + Engine/source/sfx/sfxEnvironment.cpp | 211 +- Engine/source/sfx/sfxSystem.cpp | 6 + .../core/scripts/client/audioEnvironments.cs | 2093 ++++++++++------- 11 files changed, 1961 insertions(+), 1212 deletions(-) diff --git a/Engine/source/sfx/openal/LoadOAL.h b/Engine/source/sfx/openal/LoadOAL.h index 0a58e074b..b52047cca 100644 --- a/Engine/source/sfx/openal/LoadOAL.h +++ b/Engine/source/sfx/openal/LoadOAL.h @@ -36,6 +36,8 @@ #else # include # include +# include +# include #endif #ifndef ALAPIENTRY @@ -134,6 +136,31 @@ typedef void * (ALCAPIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, con typedef ALCenum (ALCAPIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname ); typedef const ALCchar* (ALCAPIENTRY *LPALCGETSTRING)( ALCdevice *device, ALCenum param ); typedef void (ALCAPIENTRY *LPALCGETINTEGERV)( ALCdevice *device, ALCenum param, ALCsizei size, ALCint *dest ); +///Changes for effects +typedef void (ALAPIENTRY *LPALGENEFFECTS)(ALsizei n, ALuint *effects); +typedef void (ALAPIENTRY *LPALDELETEEFFECTS)(ALsizei n, const ALuint *effects); +typedef ALboolean (ALAPIENTRY *LPALISEFFECT)(ALuint effect); +typedef void (ALAPIENTRY *LPALEFFECTI)(ALuint effect, ALenum param, ALint value); +typedef void (ALAPIENTRY *LPALEFFECTIV)(ALuint effect, ALenum param, const ALint *values); +typedef void (ALAPIENTRY *LPALEFFECTF)(ALuint effect, ALenum param, ALfloat value); +typedef void (ALAPIENTRY *LPALEFFECTFV)(ALuint effect, ALenum param, const ALfloat *values); +typedef void (ALAPIENTRY *LPALGETEFFECTI)(ALuint effect, ALenum param, ALint *value); +typedef void (ALAPIENTRY *LPALGETEFFECTIV)(ALuint effect, ALenum param, ALint *values); +typedef void (ALAPIENTRY *LPALGETEFFECTF)(ALuint effect, ALenum param, ALfloat *value); +typedef void (ALAPIENTRY *LPALGETEFFECTFV)(ALuint effect, ALenum param, ALfloat *values); +typedef void (ALAPIENTRY *LPALRELEASEALEFFECTS)(ALCdevice *device); +typedef void (ALAPIENTRY *LPALGENAUXILIARYEFFECTSLOTS)(ALsizei n, ALuint *effectslots); +typedef void (ALAPIENTRY *LPALDELETEAUXILIARYEFFECTSLOTS)(ALsizei n, const ALuint *effectslots); +typedef ALboolean (ALAPIENTRY *LPALISAUXILIARYEFFECTSLOT)(ALuint effectslot); +typedef void (ALAPIENTRY *LPALAUXILIARYEFFECTSLOTI)(ALuint effectslot, ALenum param, ALint value); +typedef void (ALAPIENTRY *LPALAUXILIARYEFFECTSLOTIV)(ALuint effectslot, ALenum param, const ALint *values); +typedef void (ALAPIENTRY *LPALAUXILIARYEFFECTSLOTF)(ALuint effectslot, ALenum param, ALfloat value); +typedef void (ALAPIENTRY *LPALAUXILIARYEFFECTSLOTFV)(ALuint effectslot, ALenum param, const ALfloat *values); +typedef void (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTI)(ALuint effectslot, ALenum param, ALint *value); +typedef void (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint effectslot, ALenum param, ALint *values); +typedef void (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint effectslot, ALenum param, ALfloat *value); +typedef void (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint effectslot, ALenum param, ALfloat *values); +typedef void (ALAPIENTRY *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3); typedef struct { @@ -166,6 +193,7 @@ typedef struct LPALISSOURCE alIsSource; LPALSOURCEI alSourcei; LPALSOURCEF alSourcef; + LPALSOURCE3I alSource3i; LPALSOURCE3F alSource3f; LPALSOURCEFV alSourcefv; LPALGETSOURCEI alGetSourcei; @@ -203,6 +231,29 @@ typedef struct LPALCISEXTENSIONPRESENT alcIsExtensionPresent; LPALCGETPROCADDRESS alcGetProcAddress; LPALCGETENUMVALUE alcGetEnumValue; + LPALGENEFFECTS alGenEffects; + LPALDELETEEFFECTS alDeleteEffects; + LPALISEFFECT alIsEffect; + LPALEFFECTI alEffecti; + LPALEFFECTIV alEffectiv; + LPALEFFECTF alEffectf; + LPALEFFECTFV alEffectfv; + LPALGETEFFECTI alGetEffecti; + LPALGETEFFECTIV alGetEffectiv; + LPALGETEFFECTF alGetEffectf; + LPALGETEFFECTFV alGetEffectfv; + LPALRELEASEALEFFECTS alReleaseEffects; + LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots; + LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots; + LPALISAUXILIARYEFFECTSLOT alIsAuxiliaryEffectSlot; + LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti; + LPALAUXILIARYEFFECTSLOTIV alAuxiliaryEffectSlotiv; + LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf; + LPALAUXILIARYEFFECTSLOTFV alAuxiliaryEffectSlotfv; + LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti; + LPALGETAUXILIARYEFFECTSLOTIV alGetAuxiliaryEffectSlotiv; + LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf; + LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv; } OPENALFNTABLE, *LPOPENALFNTABLE; #endif diff --git a/Engine/source/sfx/openal/sfxALDevice.cpp b/Engine/source/sfx/openal/sfxALDevice.cpp index 13e891ece..e620a483c 100644 --- a/Engine/source/sfx/openal/sfxALDevice.cpp +++ b/Engine/source/sfx/openal/sfxALDevice.cpp @@ -42,16 +42,21 @@ SFXALDevice::SFXALDevice( SFXProvider *provider, // TODO: The OpenAL device doesn't set the primary buffer // $pref::SFX::frequency or $pref::SFX::bitrate! + //check auxiliary device sends 4 and add them to the device + ALint attribs[4] = { 0 }; + ALCint iSends = 0; + attribs[0] = ALC_MAX_AUXILIARY_SENDS; + attribs[1] = 4; mDevice = mOpenAL.alcOpenDevice( name ); mOpenAL.alcGetError( mDevice ); if( mDevice ) { - mContext = mOpenAL.alcCreateContext( mDevice, NULL ); + mContext = mOpenAL.alcCreateContext( mDevice, attribs ); if( mContext ) mOpenAL.alcMakeContextCurrent( mContext ); - + mOpenAL.alcGetIntegerv(mDevice, ALC_MAX_AUXILIARY_SENDS, 1, &iSends); U32 err = mOpenAL.alcGetError( mDevice ); if( err != ALC_NO_ERROR ) @@ -78,7 +83,10 @@ SFXALDevice::SFXALDevice( SFXProvider *provider, SFXALDevice::~SFXALDevice() { _releaseAllResources(); - + ///cleanup our effects + mOpenAL.alDeleteAuxiliaryEffectSlots(4, effectSlot); + mOpenAL.alDeleteEffects(2, effect); + ///cleanup of effects ends mOpenAL.alcMakeContextCurrent( NULL ); mOpenAL.alcDestroyContext( mContext ); mOpenAL.alcCloseDevice( mDevice ); @@ -145,6 +153,9 @@ void SFXALDevice::setListener( U32 index, const SFXListenerProperties& listener mOpenAL.alListenerfv( AL_POSITION, pos ); mOpenAL.alListenerfv( AL_VELOCITY, velocity ); mOpenAL.alListenerfv( AL_ORIENTATION, (const F32 *)&tupple[0] ); + ///Pass a unit size to openal, 1.0 assumes 1 meter to 1 game unit. + ///Crucial for air absorbtion calculations. + mOpenAL.alListenerf(AL_METERS_PER_UNIT, 1.0f); } //----------------------------------------------------------------------------- @@ -164,7 +175,13 @@ void SFXALDevice::setDistanceModel( SFXDistanceModel model ) if( mUserRolloffFactor != mRolloffFactor ) _setRolloffFactor( mUserRolloffFactor ); break; - + /// create a case for our exponential distance model + case SFXDistanceModelExponent: + mOpenAL.alDistanceModel(AL_EXPONENT_DISTANCE_CLAMPED); + if (mUserRolloffFactor != mRolloffFactor) + _setRolloffFactor(mUserRolloffFactor); + break; + default: AssertWarn( false, "SFXALDevice::setDistanceModel - distance model not implemented" ); } @@ -200,3 +217,109 @@ void SFXALDevice::setRolloffFactor( F32 factor ) mUserRolloffFactor = factor; } + +void SFXALDevice::openSlots() +{ + for (uLoop = 0; uLoop < 4; uLoop++) + { + mOpenAL.alGenAuxiliaryEffectSlots(1, &effectSlot[uLoop]); + } + + for (uLoop = 0; uLoop < 2; uLoop++) + { + mOpenAL.alGenEffects(1, &effect[uLoop]); + } + ///debug string output so we know our slots are open + Platform::outputDebugString("Slots Open"); +} + +///create reverb effect +void SFXALDevice::setReverb(const SFXReverbProperties& reverb) +{ + ///output a debug string so we know each time the reverb changes + Platform::outputDebugString("Updated"); + + ///load an efxeaxreverb default and add our values from + ///sfxreverbproperties to it + EFXEAXREVERBPROPERTIES prop = EFX_REVERB_PRESET_GENERIC; + + prop.flDensity = reverb.flDensity; + prop.flDiffusion = reverb.flDiffusion; + prop.flGain = reverb.flGain; + prop.flGainHF = reverb.flGainHF; + prop.flGainLF = reverb.flGainLF; + prop.flDecayTime = reverb.flDecayTime; + prop.flDecayHFRatio = reverb.flDecayHFRatio; + prop.flDecayLFRatio = reverb.flDecayLFRatio; + prop.flReflectionsGain = reverb.flReflectionsGain; + prop.flReflectionsDelay = reverb.flReflectionsDelay; + prop.flLateReverbGain = reverb.flLateReverbGain; + prop.flLateReverbDelay = reverb.flLateReverbDelay; + prop.flEchoTime = reverb.flEchoTime; + prop.flEchoDepth = reverb.flEchoDepth; + prop.flModulationTime = reverb.flModulationTime; + prop.flModulationDepth = reverb.flModulationDepth; + prop.flAirAbsorptionGainHF = reverb.flAirAbsorptionGainHF; + prop.flHFReference = reverb.flHFReference; + prop.flLFReference = reverb.flLFReference; + prop.flRoomRolloffFactor = reverb.flRoomRolloffFactor; + prop.iDecayHFLimit = reverb.iDecayHFLimit; + + if (mOpenAL.alGetEnumValue("AL_EFFECT_EAXREVERB") != 0) + { + + /// EAX Reverb is available. Set the EAX effect type + + mOpenAL.alEffecti(effect[0], AL_EFFECT_TYPE, AL_EFFECT_EAXREVERB); + + ///add our values to the setup of the reverb + + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_DENSITY, prop.flDensity); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_DIFFUSION, prop.flDiffusion); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_GAIN, prop.flGain); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_GAINHF, prop.flGainHF); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_GAINLF, prop.flGainLF); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_DECAY_TIME, prop.flDecayTime); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_DECAY_HFRATIO, prop.flDecayHFRatio); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_DECAY_LFRATIO, prop.flDecayLFRatio); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_REFLECTIONS_GAIN, prop.flReflectionsGain); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_REFLECTIONS_DELAY, prop.flReflectionsDelay); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_LATE_REVERB_GAIN, prop.flLateReverbGain); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_LATE_REVERB_DELAY, prop.flLateReverbDelay); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_ECHO_TIME, prop.flEchoTime); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_ECHO_DEPTH, prop.flEchoDepth); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_MODULATION_TIME, prop.flModulationTime); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_MODULATION_DEPTH, prop.flModulationDepth); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_AIR_ABSORPTION_GAINHF, prop.flAirAbsorptionGainHF); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_HFREFERENCE, prop.flHFReference); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_LFREFERENCE, prop.flLFReference); + mOpenAL.alEffectf(effect[0], AL_EAXREVERB_ROOM_ROLLOFF_FACTOR, prop.flRoomRolloffFactor); + mOpenAL.alEffecti(effect[0], AL_EAXREVERB_DECAY_HFLIMIT, prop.iDecayHFLimit); + mOpenAL.alAuxiliaryEffectSloti(1, AL_EFFECTSLOT_EFFECT, effect[0]); + Platform::outputDebugString("eax reverb properties set"); + + } + else + { + + /// No EAX Reverb. Set the standard reverb effect + mOpenAL.alEffecti(effect[0], AL_EFFECT_TYPE, AL_EFFECT_REVERB); + + mOpenAL.alEffectf(effect[0], AL_REVERB_DENSITY, prop.flDensity); + mOpenAL.alEffectf(effect[0], AL_REVERB_DIFFUSION, prop.flDiffusion); + mOpenAL.alEffectf(effect[0], AL_REVERB_GAIN, prop.flGain); + mOpenAL.alEffectf(effect[0], AL_REVERB_GAINHF, prop.flGainHF); + mOpenAL.alEffectf(effect[0], AL_REVERB_DECAY_TIME, prop.flDecayTime); + mOpenAL.alEffectf(effect[0], AL_REVERB_DECAY_HFRATIO, prop.flDecayHFRatio); + mOpenAL.alEffectf(effect[0], AL_REVERB_REFLECTIONS_GAIN, prop.flReflectionsGain); + mOpenAL.alEffectf(effect[0], AL_REVERB_REFLECTIONS_DELAY, prop.flReflectionsDelay); + mOpenAL.alEffectf(effect[0], AL_REVERB_LATE_REVERB_GAIN, prop.flLateReverbGain); + mOpenAL.alEffectf(effect[0], AL_REVERB_LATE_REVERB_DELAY, prop.flLateReverbDelay); + mOpenAL.alEffectf(effect[0], AL_REVERB_AIR_ABSORPTION_GAINHF, prop.flAirAbsorptionGainHF); + mOpenAL.alEffectf(effect[0], AL_REVERB_ROOM_ROLLOFF_FACTOR, prop.flRoomRolloffFactor); + mOpenAL.alEffecti(effect[0], AL_REVERB_DECAY_HFLIMIT, prop.iDecayHFLimit); + mOpenAL.alAuxiliaryEffectSloti(1, AL_EFFECTSLOT_EFFECT, effect[0]); + + } + +} \ No newline at end of file diff --git a/Engine/source/sfx/openal/sfxALDevice.h b/Engine/source/sfx/openal/sfxALDevice.h index ee6f1ccdb..277b2496a 100644 --- a/Engine/source/sfx/openal/sfxALDevice.h +++ b/Engine/source/sfx/openal/sfxALDevice.h @@ -85,6 +85,15 @@ class SFXALDevice : public SFXDevice virtual void setDistanceModel( SFXDistanceModel model ); virtual void setDopplerFactor( F32 factor ); virtual void setRolloffFactor( F32 factor ); + //function for openAL to open slots + virtual void openSlots(); + //slots + ALuint effectSlot[4] = { 0 }; + ALuint effect[2] = { 0 }; + ALuint uLoop; + //get values from sfxreverbproperties and pass it to openal device + virtual void setReverb(const SFXReverbProperties& reverb); + virtual void resetReverb() {} }; #endif // _SFXALDEVICE_H_ \ No newline at end of file diff --git a/Engine/source/sfx/openal/sfxALVoice.cpp b/Engine/source/sfx/openal/sfxALVoice.cpp index 21fc51700..ccba74143 100644 --- a/Engine/source/sfx/openal/sfxALVoice.cpp +++ b/Engine/source/sfx/openal/sfxALVoice.cpp @@ -118,7 +118,8 @@ void SFXALVoice::_play() #ifdef DEBUG_SPEW Platform::outputDebugString( "[SFXALVoice] Starting playback" ); #endif - + //send every voice that plays to the alauxiliary slot that has the reverb + mOpenAL.alSource3i(mSourceName, AL_AUXILIARY_SEND_FILTER, 1, 0, AL_FILTER_NULL); mOpenAL.alSourcePlay( mSourceName ); //WORKAROUND: Adjust play cursor for buggy OAL when resuming playback. Do this after alSourcePlay diff --git a/Engine/source/sfx/openal/win32/LoadOAL.cpp b/Engine/source/sfx/openal/win32/LoadOAL.cpp index a3a31a0f7..df28cd440 100644 --- a/Engine/source/sfx/openal/win32/LoadOAL.cpp +++ b/Engine/source/sfx/openal/win32/LoadOAL.cpp @@ -439,7 +439,118 @@ ALboolean LoadOAL10Library(char *szOALFullPathName, LPOPENALFNTABLE lpOALFnTable OutputDebugStringA("Failed to retrieve 'alcGetEnumValue' function address\n"); return AL_FALSE; } + lpOALFnTable->alGenEffects = (LPALGENEFFECTS)GetProcAddress(g_hOpenALDLL, "alGenEffects"); + if (lpOALFnTable->alGenEffects == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGenEffects' function address\n"); + } + lpOALFnTable->alEffecti = (LPALEFFECTI)GetProcAddress(g_hOpenALDLL, "alEffecti"); + if (lpOALFnTable->alEffecti == NULL) + { + OutputDebugStringA("Failed to retrieve 'alEffecti' function address\n"); + } + lpOALFnTable->alEffectiv = (LPALEFFECTIV)GetProcAddress(g_hOpenALDLL, "alEffectiv"); + if (lpOALFnTable->alEffectiv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alEffectiv' function address\n"); + } + lpOALFnTable->alEffectf = (LPALEFFECTF)GetProcAddress(g_hOpenALDLL, "alEffectf"); + if (lpOALFnTable->alEffectf == NULL) + { + OutputDebugStringA("Failed to retrieve 'alEffectf' function address\n"); + } + lpOALFnTable->alEffectfv = (LPALEFFECTFV)GetProcAddress(g_hOpenALDLL, "alEffectfv"); + if (lpOALFnTable->alEffectfv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alEffectfv' function address\n"); + } + lpOALFnTable->alGetEffecti = (LPALGETEFFECTI)GetProcAddress(g_hOpenALDLL, "alGetEffecti"); + if (lpOALFnTable->alGetEffecti == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetEffecti' function address\n"); + } + lpOALFnTable->alGetEffectiv = (LPALGETEFFECTIV)GetProcAddress(g_hOpenALDLL, "alGetEffectiv"); + if (lpOALFnTable->alGetEffectiv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetEffectiv' function address\n"); + } + lpOALFnTable->alGetEffectf = (LPALGETEFFECTF)GetProcAddress(g_hOpenALDLL, "alGetEffectf"); + if (lpOALFnTable->alGetEffectf == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetEffectf' function address\n"); + } + lpOALFnTable->alGetEffectfv = (LPALGETEFFECTFV)GetProcAddress(g_hOpenALDLL, "alGetEffectfv"); + if (lpOALFnTable->alGetEffectfv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetEffectfv' function address\n"); + } + lpOALFnTable->alDeleteEffects = (LPALDELETEEFFECTS)GetProcAddress(g_hOpenALDLL, "alDeleteEffects"); + if (lpOALFnTable->alDeleteEffects == NULL) + { + OutputDebugStringA("Failed to retrieve 'alDeleteEffects' function address\n"); + } + lpOALFnTable->alIsEffect = (LPALISEFFECT)GetProcAddress(g_hOpenALDLL, "alIsEffect"); + if (lpOALFnTable->alIsEffect == NULL) + { + OutputDebugStringA("Failed to retrieve 'alIsEffect' function address\n"); + } + lpOALFnTable->alAuxiliaryEffectSlotf = (LPALAUXILIARYEFFECTSLOTF)GetProcAddress(g_hOpenALDLL, "alAuxiliaryEffectSlotf"); + if (lpOALFnTable->alAuxiliaryEffectSlotf == NULL) + { + OutputDebugStringA("Failed to retrieve 'alAuxiliaryEffectSlotf' function address\n"); + } + lpOALFnTable->alAuxiliaryEffectSlotfv = (LPALAUXILIARYEFFECTSLOTFV)GetProcAddress(g_hOpenALDLL, "alAuxiliaryEffectSlotfv"); + if (lpOALFnTable->alAuxiliaryEffectSlotfv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alAuxiliaryEffectSlotfv' function address\n"); + } + lpOALFnTable->alAuxiliaryEffectSloti = (LPALAUXILIARYEFFECTSLOTI)GetProcAddress(g_hOpenALDLL, "alAuxiliaryEffectSloti"); + if (lpOALFnTable->alAuxiliaryEffectSloti == NULL) + { + OutputDebugStringA("Failed to retrieve 'alAuxiliaryEffectSloti' function address\n"); + } + lpOALFnTable->alAuxiliaryEffectSlotiv = (LPALAUXILIARYEFFECTSLOTIV)GetProcAddress(g_hOpenALDLL, "alAuxiliaryEffectSlotiv"); + if (lpOALFnTable->alAuxiliaryEffectSlotiv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alAuxiliaryEffectSlotiv' function address\n"); + } + lpOALFnTable->alIsAuxiliaryEffectSlot = (LPALISAUXILIARYEFFECTSLOT)GetProcAddress(g_hOpenALDLL, "alIsAuxiliaryEffectSlot"); + if (lpOALFnTable->alIsAuxiliaryEffectSlot == NULL) + { + OutputDebugStringA("Failed to retrieve 'alIsAuxiliaryEffectSlot' function address\n"); + } + lpOALFnTable->alGenAuxiliaryEffectSlots = (LPALGENAUXILIARYEFFECTSLOTS)GetProcAddress(g_hOpenALDLL, "alGenAuxiliaryEffectSlots"); + if (lpOALFnTable->alGenAuxiliaryEffectSlots == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGenAuxiliaryEffectSlots' function address\n"); + } + lpOALFnTable->alDeleteAuxiliaryEffectSlots = (LPALDELETEAUXILIARYEFFECTSLOTS)GetProcAddress(g_hOpenALDLL, "alDeleteAuxiliaryEffectSlots"); + if (lpOALFnTable->alDeleteAuxiliaryEffectSlots == NULL) + { + OutputDebugStringA("Failed to retrieve 'alDeleteAuxiliaryEffectSlots' function address\n"); + } + lpOALFnTable->alGetAuxiliaryEffectSlotf = (LPALGETAUXILIARYEFFECTSLOTF)GetProcAddress(g_hOpenALDLL, "alGetAuxiliaryEffectSlotf"); + if (lpOALFnTable->alGetAuxiliaryEffectSlotf == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetAuxiliaryEffectSlotf' function address\n"); + } + lpOALFnTable->alGetAuxiliaryEffectSlotfv = (LPALGETAUXILIARYEFFECTSLOTFV)GetProcAddress(g_hOpenALDLL, "alGetAuxiliaryEffectSlotfv"); + if (lpOALFnTable->alGetAuxiliaryEffectSlotfv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetAuxiliaryEffectSlotfv' function address\n"); + } + lpOALFnTable->alGetAuxiliaryEffectSloti = (LPALGETAUXILIARYEFFECTSLOTI)GetProcAddress(g_hOpenALDLL, "alGetAuxiliaryEffectSloti"); + if (lpOALFnTable->alGetAuxiliaryEffectSloti == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetAuxiliaryEffectSloti' function address\n"); + } + lpOALFnTable->alGetAuxiliaryEffectSlotiv = (LPALGETAUXILIARYEFFECTSLOTIV)GetProcAddress(g_hOpenALDLL, "alGetAuxiliaryEffectSlotiv"); + if (lpOALFnTable->alGetAuxiliaryEffectSlotiv == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGetAuxiliaryEffectSlotiv' function address\n"); + } + lpOALFnTable->alSource3i = (LPALSOURCE3I)GetProcAddress(g_hOpenALDLL, "alSource3i"); return AL_TRUE; } diff --git a/Engine/source/sfx/sfxCommon.h b/Engine/source/sfx/sfxCommon.h index 7b69b2506..a6c764ab9 100644 --- a/Engine/source/sfx/sfxCommon.h +++ b/Engine/source/sfx/sfxCommon.h @@ -153,6 +153,7 @@ enum SFXDistanceModel { SFXDistanceModelLinear, ///< Volume decreases linearly from min to max where it reaches zero. SFXDistanceModelLogarithmic, ///< Volume halves every min distance steps starting from min distance; attenuation stops at max distance. + SFXDistanceModelExponent, /// exponential falloff for distance attenuation. }; DefineEnumType( SFXDistanceModel ); @@ -187,6 +188,14 @@ inline F32 SFXDistanceAttenuation( SFXDistanceModel model, F32 minDistance, F32 gain = minDistance / ( minDistance + rolloffFactor * ( distance - minDistance ) ); break; + + ///create exponential distance model + case SFXDistanceModelExponent: + distance = getMax(distance, minDistance); + distance = getMin(distance, maxDistance); + + gain = pow((distance / minDistance), (-rolloffFactor)); + break; } @@ -313,97 +322,97 @@ class SFXFormat /// Reverb environment properties. /// /// @note A given device may not implement all properties. +///restructure our reverbproperties to match openal + class SFXReverbProperties { - public: - - typedef void Parent; - - F32 mEnvSize; - F32 mEnvDiffusion; - S32 mRoom; - S32 mRoomHF; - S32 mRoomLF; - F32 mDecayTime; - F32 mDecayHFRatio; - F32 mDecayLFRatio; - S32 mReflections; - F32 mReflectionsDelay; - F32 mReflectionsPan[ 3 ]; - S32 mReverb; - F32 mReverbDelay; - F32 mReverbPan[ 3 ]; - F32 mEchoTime; - F32 mEchoDepth; - F32 mModulationTime; - F32 mModulationDepth; - F32 mAirAbsorptionHF; - F32 mHFReference; - F32 mLFReference; - F32 mRoomRolloffFactor; - F32 mDiffusion; - F32 mDensity; - S32 mFlags; - - SFXReverbProperties() - : mEnvSize( 7.5f ), - mEnvDiffusion( 1.0f ), - mRoom( -1000 ), - mRoomHF( -100 ), - mRoomLF( 0 ), - mDecayTime( 1.49f ), - mDecayHFRatio( 0.83f ), - mDecayLFRatio( 1.0f ), - mReflections( -2602 ), - mReflectionsDelay( 0.007f ), - mReverb( 200 ), - mReverbDelay( 0.011f ), - mEchoTime( 0.25f ), - mEchoDepth( 0.0f ), - mModulationTime( 0.25f ), - mModulationDepth( 0.0f ), - mAirAbsorptionHF( -5.0f ), - mHFReference( 5000.0f ), - mLFReference( 250.0f ), - mRoomRolloffFactor( 0.0f ), - mDiffusion( 100.0f ), - mDensity( 100.0f ), - mFlags( 0 ) - { - mReflectionsPan[ 0 ] = 0.0f; - mReflectionsPan[ 1 ] = 0.0f; - mReflectionsPan[ 2 ] = 0.0f; - - mReverbPan[ 0 ] = 0.0f; - mReverbPan[ 1 ] = 0.0f; - mReverbPan[ 2 ] = 0.0f; - } - - void validate() - { - mEnvSize = mClampF( mEnvSize, 1.0f, 100.0f ); - mEnvDiffusion = mClampF( mEnvDiffusion, 0.0f, 1.0f ); - mRoom = mClamp( mRoom, -10000, 0 ); - mRoomHF = mClamp( mRoomHF, -10000, 0 ); - mRoomLF = mClamp( mRoomLF, -10000, 0 ); - mDecayTime = mClampF( mDecayTime, 0.1f, 20.0f ); - mDecayHFRatio = mClampF( mDecayHFRatio, 0.1f, 2.0f ); - mDecayLFRatio = mClampF( mDecayLFRatio, 0.1f, 2.0f ); - mReflections = mClamp( mReflections, -10000, 1000 ); - mReflectionsDelay = mClampF( mReflectionsDelay, 0.0f, 0.3f ); - mReverb = mClamp( mReverb, -10000, 2000 ); - mReverbDelay = mClampF( mReverbDelay, 0.0f, 0.1f ); - mEchoTime = mClampF( mEchoTime, 0.075f, 0.25f ); - mEchoDepth = mClampF( mEchoDepth, 0.0f, 1.0f ); - mModulationTime = mClampF( mModulationTime, 0.04f, 4.0f ); - mModulationDepth = mClampF( mModulationDepth, 0.0f, 1.0f ); - mAirAbsorptionHF = mClampF( mAirAbsorptionHF, -100.0f, 0.0f ); - mHFReference = mClampF( mHFReference, 1000.0f, 20000.0f ); - mLFReference = mClampF( mLFReference, 20.0f, 1000.0f ); - mRoomRolloffFactor = mClampF( mRoomRolloffFactor, 0.0f, 10.0f ); - mDiffusion = mClampF( mDiffusion, 0.0f, 100.0f ); - mDensity = mClampF( mDensity, 0.0f, 100.0f ); - } +public: + + struct Parent; + + float flDensity; + float flDiffusion; + float flGain; + float flGainHF; + float flGainLF; + float flDecayTime; + float flDecayHFRatio; + float flDecayLFRatio; + float flReflectionsGain; + float flReflectionsDelay; + float flReflectionsPan[3]; + float flLateReverbGain; + float flLateReverbDelay; + float flLateReverbPan[3]; + float flEchoTime; + float flEchoDepth; + float flModulationTime; + float flModulationDepth; + float flAirAbsorptionGainHF; + float flHFReference; + float flLFReference; + float flRoomRolloffFactor; + int iDecayHFLimit; + + ///set our defaults to be the same as no reverb otherwise our reverb + ///effects menu sounds + SFXReverbProperties() + { + flDensity = 0.0f; + flDiffusion = 0.0f; + flGain = 0.0f; + flGainHF = 0.0f; + flGainLF = 0.0000f; + flDecayTime = 0.0f; + flDecayHFRatio = 0.0f; + flDecayLFRatio = 0.0f; + flReflectionsGain = 0.0f; + flReflectionsDelay = 0.0f; + flReflectionsPan[3] = 0.0f; + flLateReverbGain = 0.0f; + flLateReverbDelay = 0.0f; + flLateReverbPan[3] = 0.0f; + flEchoTime = 0.0f; + flEchoDepth = 0.0f; + flModulationTime = 0.0f; + flModulationDepth = 0.0f; + flAirAbsorptionGainHF = 0.0f; + flHFReference = 0.0f; + flLFReference = 0.0f; + flRoomRolloffFactor = 0.0f; + iDecayHFLimit = 0; + } + + void validate() + { + flDensity = mClampF(flDensity, 0.0f, 1.0f); + flDiffusion = mClampF(flDiffusion, 0.0f, 1.0f); + flGain = mClampF(flGain, 0.0f, 1.0f); + flGainHF = mClampF(flGainHF, 0.0f, 1.0f); + flGainLF = mClampF(flGainLF, 0.0f, 1.0f); + flDecayTime = mClampF(flDecayTime, 0.1f, 20.0f); + flDecayHFRatio = mClampF(flDecayHFRatio, 0.1f, 2.0f); + flDecayLFRatio = mClampF(flDecayLFRatio, 0.1f, 2.0f); + flReflectionsGain = mClampF(flReflectionsGain, 0.0f, 3.16f); + flReflectionsDelay = mClampF(flReflectionsDelay, 0.0f, 0.3f); + flReflectionsPan[0] = mClampF(flReflectionsPan[0], -1.0f, 1.0f); + flReflectionsPan[1] = mClampF(flReflectionsPan[1], -1.0f, 1.0f); + flReflectionsPan[2] = mClampF(flReflectionsPan[2], -1.0f, 1.0f); + flLateReverbGain = mClampF(flLateReverbGain, 0.0f, 10.0f); + flLateReverbDelay = mClampF(flLateReverbDelay, 0.0f, 0.1f); + flLateReverbPan[0] = mClampF(flLateReverbPan[0], -1.0f, 1.0f); + flLateReverbPan[1] = mClampF(flLateReverbPan[1], -1.0f, 1.0f); + flLateReverbPan[2] = mClampF(flLateReverbPan[2], -1.0f, 1.0f); + flEchoTime = mClampF(flEchoTime, 0.075f, 0.25f); + flEchoDepth = mClampF(flEchoDepth, 0.0f, 1.0f); + flModulationTime = mClampF(flModulationTime, 0.04f, 4.0f); + flModulationDepth = mClampF(flModulationDepth, 0.0f, 1.0f); + flAirAbsorptionGainHF = mClampF(flAirAbsorptionGainHF, 0.892f, 1.0f); + flHFReference = mClampF(flHFReference, 1000.0f, 20000.0f); + flLFReference = mClampF(flLFReference, 20.0f, 1000.0f); + flRoomRolloffFactor = mClampF(flRoomRolloffFactor, 0.0f, 10.0f); + iDecayHFLimit = mClampF(iDecayHFLimit, 0, 1); + } }; @@ -415,73 +424,99 @@ class SFXReverbProperties /// Sound reverb properties. /// /// @note A given SFX device may not implement all properties. +///not in use by openal yet if u are going to use ambient reverb zones its +///probably best to not have reverb on the sound effect itself. class SFXSoundReverbProperties { - public: - - typedef void Parent; - - S32 mDirect; - S32 mDirectHF; - S32 mRoom; - S32 mRoomHF; - S32 mObstruction; - F32 mObstructionLFRatio; - S32 mOcclusion; - F32 mOcclusionLFRatio; - F32 mOcclusionRoomRatio; - F32 mOcclusionDirectRatio; - S32 mExclusion; - F32 mExclusionLFRatio; - S32 mOutsideVolumeHF; - F32 mDopplerFactor; - F32 mRolloffFactor; - F32 mRoomRolloffFactor; - F32 mAirAbsorptionFactor; - S32 mFlags; - - SFXSoundReverbProperties() - : mDirect( 0 ), - mDirectHF( 0 ), - mRoom( 0 ), - mRoomHF( 0 ), - mObstruction( 0 ), - mObstructionLFRatio( 0.0f ), - mOcclusion( 0 ), - mOcclusionLFRatio( 0.25f ), - mOcclusionRoomRatio( 1.5f ), - mOcclusionDirectRatio( 1.0f ), - mExclusion( 0 ), - mExclusionLFRatio( 1.0f ), - mOutsideVolumeHF( 0 ), - mDopplerFactor( 0.0f ), - mRolloffFactor( 0.0f ), - mRoomRolloffFactor( 0.0f ), - mAirAbsorptionFactor( 1.0f ), - mFlags( 0 ) - { - } - - void validate() - { - mDirect = mClamp( mDirect, -10000, 1000 ); - mDirectHF = mClamp( mDirectHF, -10000, 0 ); - mRoom = mClamp( mRoom, -10000, 1000 ); - mRoomHF = mClamp( mRoomHF, -10000, 0 ); - mObstruction = mClamp( mObstruction, -10000, 0 ); - mObstructionLFRatio = mClampF( mObstructionLFRatio, 0.0f, 1.0f ); - mOcclusion = mClamp( mOcclusion, -10000, 0 ); - mOcclusionLFRatio = mClampF( mOcclusionLFRatio, 0.0f, 1.0f ); - mOcclusionRoomRatio = mClampF( mOcclusionRoomRatio, 0.0f, 10.0f ); - mOcclusionDirectRatio= mClampF( mOcclusionDirectRatio, 0.0f, 10.0f ); - mExclusion = mClamp( mExclusion, -10000, 0 ); - mExclusionLFRatio = mClampF( mExclusionLFRatio, 0.0f, 1.0f ); - mOutsideVolumeHF = mClamp( mOutsideVolumeHF, -10000, 0 ); - mDopplerFactor = mClampF( mDopplerFactor, 0.0f, 10.0f ); - mRolloffFactor = mClampF( mRolloffFactor, 0.0f, 10.0f ); - mRoomRolloffFactor = mClampF( mRoomRolloffFactor, 0.0f, 10.0f ); - mAirAbsorptionFactor = mClampF( mAirAbsorptionFactor, 0.0f, 10.0f ); - } +public: + + typedef void Parent; + + float flDensity; + float flDiffusion; + float flGain; + float flGainHF; + float flGainLF; + float flDecayTime; + float flDecayHFRatio; + float flDecayLFRatio; + float flReflectionsGain; + float flReflectionsDelay; + float flReflectionsPan[3]; + float flLateReverbGain; + float flLateReverbDelay; + float flLateReverbPan[3]; + float flEchoTime; + float flEchoDepth; + float flModulationTime; + float flModulationDepth; + float flAirAbsorptionGainHF; + float flHFReference; + float flLFReference; + float flRoomRolloffFactor; + int iDecayHFLimit; + + + ///Set our defaults to have no reverb + ///if you are going to use zone reverbs its + ///probably best not to use per-voice reverb + SFXSoundReverbProperties() + { + flDensity = 0.0f; + flDiffusion = 0.0f; + flGain = 0.0f; + flGainHF = 0.0f; + flGainLF = 0.0000f; + flDecayTime = 0.0f; + flDecayHFRatio = 0.0f; + flDecayLFRatio = 0.0f; + flReflectionsGain = 0.0f; + flReflectionsDelay = 0.0f; + flReflectionsPan[3] = 0.0f; + flLateReverbGain = 0.0f; + flLateReverbDelay = 0.0f; + flLateReverbPan[3] = 0.0f; + flEchoTime = 0.0f; + flEchoDepth = 0.0f; + flModulationTime = 0.0f; + flModulationDepth = 0.0f; + flAirAbsorptionGainHF = 0.0f; + flHFReference = 0.0f; + flLFReference = 0.0f; + flRoomRolloffFactor = 0.0f; + iDecayHFLimit = 0; + } + + void validate() + { + flDensity = mClampF(flDensity, 0.0f, 1.0f); + flDiffusion = mClampF(flDiffusion, 0.0f, 1.0f); + flGain = mClampF(flGain, 0.0f, 1.0f); + flGainHF = mClampF(flGainHF, 0.0f, 1.0f); + flGainLF = mClampF(flGainLF, 0.0f, 1.0f); + flDecayTime = mClampF(flDecayTime, 0.1f, 20.0f); + flDecayHFRatio = mClampF(flDecayHFRatio, 0.1f, 2.0f); + flDecayLFRatio = mClampF(flDecayLFRatio, 0.1f, 2.0f); + flReflectionsGain = mClampF(flReflectionsGain, 0.0f, 3.16f); + flReflectionsDelay = mClampF(flReflectionsDelay, 0.0f, 0.3f); + flReflectionsPan[0] = mClampF(flReflectionsPan[0], -1.0f, 1.0f); + flReflectionsPan[1] = mClampF(flReflectionsPan[1], -1.0f, 1.0f); + flReflectionsPan[2] = mClampF(flReflectionsPan[2], -1.0f, 1.0f); + flLateReverbGain = mClampF(flLateReverbGain, 0.0f, 10.0f); + flLateReverbDelay = mClampF(flLateReverbDelay, 0.0f, 0.1f); + flLateReverbPan[0] = mClampF(flLateReverbPan[0], -1.0f, 1.0f); + flLateReverbPan[1] = mClampF(flLateReverbPan[1], -1.0f, 1.0f); + flLateReverbPan[2] = mClampF(flLateReverbPan[2], -1.0f, 1.0f); + flEchoTime = mClampF(flEchoTime, 0.075f, 0.25f); + flEchoDepth = mClampF(flEchoDepth, 0.0f, 1.0f); + flModulationTime = mClampF(flModulationTime, 0.04f, 4.0f); + flModulationDepth = mClampF(flModulationDepth, 0.0f, 1.0f); + flAirAbsorptionGainHF = mClampF(flAirAbsorptionGainHF, 0.892f, 1.0f); + flHFReference = mClampF(flHFReference, 1000.0f, 20000.0f); + flLFReference = mClampF(flLFReference, 20.0f, 1000.0f); + flRoomRolloffFactor = mClampF(flRoomRolloffFactor, 0.0f, 10.0f); + iDecayHFLimit = mClampF(iDecayHFLimit, 0, 1); + } }; diff --git a/Engine/source/sfx/sfxDescription.cpp b/Engine/source/sfx/sfxDescription.cpp index 1c82ba6a5..3b41b9b80 100644 --- a/Engine/source/sfx/sfxDescription.cpp +++ b/Engine/source/sfx/sfxDescription.cpp @@ -389,91 +389,55 @@ void SFXDescription::initPersistFields() addGroup( "Reverb" ); - addField( "useCustomReverb", TypeBool, Offset( mUseReverb, SFXDescription ), - "If true, use the reverb properties defined here on sounds.\n" - "By default, sounds will be assigned a generic reverb profile. By setting this flag to true, " - "a custom reverb setup can be defined using the \"Reverb\" properties that will then be assigned " - "to sounds playing with the description.\n\n" - "@ref SFX_reverb" ); - addField( "reverbDirect", TypeS32, Offset( mReverb.mDirect, SFXDescription ), - "Direct path level (at low and mid frequencies).\n" - "@note SUPPORTED: EAX/I3DL2/FMODSFX\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbDirectHF", TypeS32, Offset( mReverb.mDirectHF, SFXDescription ), - "Relative direct path level at high frequencies.\n" - "@note SUPPORTED: EAX/I3DL2\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbRoom", TypeS32, Offset( mReverb.mRoom, SFXDescription ), - "Room effect level (at low and mid frequencies).\n" - "@note SUPPORTED: EAX/I3DL2/FMODSFX\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbRoomHF", TypeS32, Offset( mReverb.mRoomHF, SFXDescription ), - "Relative room effect level at high frequencies.\n" - "@note SUPPORTED: EAX/I3DL2\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbObstruction", TypeS32, Offset( mReverb.mObstruction, SFXDescription ), - "Main obstruction control (attenuation at high frequencies).\n" - "@note SUPPORTED: EAX/I3DL2\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbObstructionLFRatio", TypeF32, Offset( mReverb.mObstructionLFRatio, SFXDescription ), - "Obstruction low-frequency level re. main control.\n" - "@note SUPPORTED: EAX/I3DL2\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbOcclusion", TypeS32, Offset( mReverb.mOcclusion, SFXDescription ), - "Main occlusion control (attenuation at high frequencies)." - "@note SUPPORTED: EAX/I3DL2\n\n" - "\n@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbOcclusionLFRatio", TypeF32, Offset( mReverb.mOcclusionLFRatio, SFXDescription ), - "Occlusion low-frequency level re. main control.\n" - "@note SUPPORTED: EAX/I3DL2\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbOcclusionRoomRatio", TypeF32, Offset( mReverb.mOcclusionRoomRatio, SFXDescription ), - "Relative occlusion control for room effect.\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbOcclusionDirectRatio",TypeF32, Offset( mReverb.mOcclusionDirectRatio, SFXDescription ), - "Relative occlusion control for direct path.\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbExclusion", TypeS32, Offset( mReverb.mExclusion, SFXDescription ), - "Main exclusion control (attenuation at high frequencies).\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbExclusionLFRatio", TypeF32, Offset( mReverb.mExclusionLFRatio, SFXDescription ), - "Exclusion low-frequency level re. main control.\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbOutsideVolumeHF", TypeS32, Offset( mReverb.mOutsideVolumeHF, SFXDescription ), - "Outside sound cone level at high frequencies.\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbDopplerFactor", TypeF32, Offset( mReverb.mDopplerFactor, SFXDescription ), - "Per-source doppler factor.\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbReverbRolloffFactor", TypeF32, Offset( mReverb.mRolloffFactor, SFXDescription ), - "Per-source logarithmic falloff factor.\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbRoomRolloffFactor", TypeF32, Offset( mReverb.mRoomRolloffFactor, SFXDescription ), - "Room effect falloff factor.\n" - "@note SUPPORTED: EAX/I3DL2\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbAirAbsorptionFactor", TypeF32, Offset( mReverb.mAirAbsorptionFactor, SFXDescription ), - "Multiplies SFXEnvironment::airAbsorptionHR.\n" - "@note SUPPORTED: EAX Only\n\n" - "@see http://www.atc.creative.com/algorithms/eax20.pdf" ); - addField( "reverbFlags", TypeS32, Offset( mReverb.mFlags, SFXDescription ), - "Bitfield combination of per-sound reverb flags.\n" - "@see REVERB_DIRECTHFAUTO\n" - "@see REVERB_ROOMAUTO\n" - "@see REVERB_ROOMHFAUTO\n" - "@see REVERB_INSTANCE0\n" - "@see REVERB_INSTANCE1\n" - "@see REVERB_INSTANCE2\n" - "@see REVERB_INSTANCE3\n" ); - - endGroup( "Reverb" ); + addField("useCustomReverb", TypeBool, Offset(mUseReverb, SFXDescription), + "If true, use the reverb properties defined here on sounds.\n" + "By default, sounds will be assigned a generic reverb profile. By setting this flag to true, " + "a custom reverb setup can be defined using the \"Reverb\" properties that will then be assigned " + "to sounds playing with the description.\n\n" + "@ref SFX_reverb"); + addField("reverbDensity", TypeF32, Offset(mReverb.flDensity, SFXDescription), + "Density of reverb environment."); + addField("reverbDiffusion", TypeF32, Offset(mReverb.flDiffusion, SFXDescription), + "Environment diffusion."); + addField("reverbGain", TypeF32, Offset(mReverb.flGain, SFXDescription), + "Reverb Gain Level."); + addField("reverbGainHF", TypeF32, Offset(mReverb.flGainHF, SFXDescription), + "Reverb Gain to high frequencies"); + addField("reverbGainLF", TypeF32, Offset(mReverb.flGainLF, SFXDescription), + "Reverb Gain to high frequencies"); + addField("reverbDecayTime", TypeF32, Offset(mReverb.flDecayTime, SFXDescription), + "Decay time for the reverb."); + addField("reverbDecayHFRatio", TypeF32, Offset(mReverb.flDecayHFRatio, SFXDescription), + "High frequency decay time ratio."); + addField("reverbDecayLFRatio", TypeF32, Offset(mReverb.flDecayLFRatio, SFXDescription), + "High frequency decay time ratio."); + addField("reflectionsGain", TypeF32, Offset(mReverb.flReflectionsGain, SFXDescription), + "Reflection Gain."); + addField("reflectionDelay", TypeF32, Offset(mReverb.flReflectionsDelay, SFXDescription), + "How long to delay reflections."); + addField("lateReverbGain", TypeF32, Offset(mReverb.flLateReverbGain, SFXDescription), + "Late reverb gain amount."); + addField("lateReverbDelay", TypeF32, Offset(mReverb.flLateReverbDelay, SFXDescription), + "Late reverb delay time."); + addField("reverbEchoTime", TypeF32, Offset(mReverb.flEchoTime, SFXDescription), + "Reverb echo time."); + addField("reverbEchoDepth", TypeF32, Offset(mReverb.flEchoDepth, SFXDescription), + "Reverb echo depth."); + addField("reverbModTime", TypeF32, Offset(mReverb.flModulationTime, SFXDescription), + "Reverb Modulation time."); + addField("reverbModTime", TypeF32, Offset(mReverb.flModulationDepth, SFXDescription), + "Reverb Modulation time."); + addField("airAbsorbtionGainHF", TypeF32, Offset(mReverb.flAirAbsorptionGainHF, SFXDescription), + "High Frequency air absorbtion"); + addField("reverbHFRef", TypeF32, Offset(mReverb.flHFReference, SFXDescription), + "Reverb High Frequency Reference."); + addField("reverbLFRef", TypeF32, Offset(mReverb.flLFReference, SFXDescription), + "Reverb Low Frequency Reference."); + addField("roomRolloffFactor", TypeF32, Offset(mReverb.flRoomRolloffFactor, SFXDescription), + "Rolloff factor for reverb."); + addField("decayHFLimit", TypeS32, Offset(mReverb.iDecayHFLimit, SFXDescription), + "High Frequency decay limit."); + endGroup("Reverb"); Parent::initPersistFields(); } @@ -570,24 +534,27 @@ void SFXDescription::packData( BitStream *stream ) if( mUseReverb ) { - stream->writeRangedS32( mReverb.mDirect, -10000, 1000 ); - stream->writeRangedS32( mReverb.mDirectHF, -10000, 0 ); - stream->writeRangedS32( mReverb.mRoom, -10000, 1000 ); - stream->writeRangedS32( mReverb.mRoomHF, -10000, 0 ); - stream->writeRangedS32( mReverb.mObstruction, -10000, 0 ); - stream->writeRangedF32( mReverb.mObstructionLFRatio, 0.0, 1.0, 7 ); - stream->writeRangedS32( mReverb.mOcclusion, -10000, 0 ); - stream->writeRangedF32( mReverb.mOcclusionLFRatio, 0.0, 1.0, 7 ); - stream->writeRangedF32( mReverb.mOcclusionRoomRatio, 0.0, 10.0, 7 ); - stream->writeRangedF32( mReverb.mOcclusionDirectRatio, 0.0, 10.0, 7 ); - stream->writeRangedS32( mReverb.mExclusion, -10000, 0 ); - stream->writeRangedF32( mReverb.mExclusionLFRatio, 0.0, 1.0, 7 ); - stream->writeRangedS32( mReverb.mOutsideVolumeHF, -10000, 0 ); - stream->writeRangedF32( mReverb.mDopplerFactor, 0.0, 10.0, 7 ); - stream->writeRangedF32( mReverb.mRolloffFactor, 0.0, 10.0, 7 ); - stream->writeRangedF32( mReverb.mRoomRolloffFactor, 0.0, 10.0, 7 ); - stream->writeRangedF32( mReverb.mAirAbsorptionFactor, 0.0, 10.0, 7 ); - stream->writeInt( mReverb.mFlags, 6 ); + stream->write(mReverb.flDensity); + stream->write(mReverb.flDiffusion); + stream->write(mReverb.flGain); + stream->write(mReverb.flGainHF); + stream->write(mReverb.flGainLF); + stream->write(mReverb.flDecayTime); + stream->write(mReverb.flDecayHFRatio); + stream->write(mReverb.flDecayLFRatio); + stream->write(mReverb.flReflectionsGain); + stream->write(mReverb.flReflectionsDelay); + stream->write(mReverb.flLateReverbGain); + stream->write(mReverb.flLateReverbDelay); + stream->write(mReverb.flEchoTime); + stream->write(mReverb.flEchoDepth); + stream->write(mReverb.flModulationTime); + stream->write(mReverb.flModulationDepth); + stream->write(mReverb.flAirAbsorptionGainHF); + stream->write(mReverb.flHFReference); + stream->write(mReverb.flLFReference); + stream->write(mReverb.flRoomRolloffFactor); + stream->write(mReverb.iDecayHFLimit); } } @@ -640,24 +607,27 @@ void SFXDescription::unpackData( BitStream *stream ) if( mUseReverb ) { - mReverb.mDirect = stream->readRangedS32( -10000, 1000 ); - mReverb.mDirectHF = stream->readRangedS32( -10000, 0 ); - mReverb.mRoom = stream->readRangedS32( -10000, 1000 ); - mReverb.mRoomHF = stream->readRangedS32( -10000, 0 ); - mReverb.mObstruction = stream->readRangedS32( -10000, 0 ); - mReverb.mObstructionLFRatio = stream->readRangedF32( 0.0, 1.0, 7 ); - mReverb.mOcclusion = stream->readRangedS32( -10000, 0 ); - mReverb.mOcclusionLFRatio = stream->readRangedF32( 0.0, 1.0, 7 ); - mReverb.mOcclusionRoomRatio = stream->readRangedF32( 0.0, 10.0, 7 ); - mReverb.mOcclusionDirectRatio = stream->readRangedF32( 0.0, 10.0, 7 ); - mReverb.mExclusion = stream->readRangedS32( -10000, 0 ); - mReverb.mExclusionLFRatio = stream->readRangedF32( 0.0, 1.0, 7 ); - mReverb.mOutsideVolumeHF = stream->readRangedS32( -10000, 0 ); - mReverb.mDopplerFactor = stream->readRangedF32( 0.0, 10.0, 7 ); - mReverb.mRolloffFactor = stream->readRangedF32( 0.0, 10.0, 7 ); - mReverb.mRoomRolloffFactor = stream->readRangedF32( 0.0, 10.0, 7 ); - mReverb.mAirAbsorptionFactor = stream->readRangedF32( 0.0, 10.0, 7 ); - mReverb.mFlags = stream->readInt( 6 ); + stream->read(&mReverb.flDensity); + stream->read(&mReverb.flDiffusion); + stream->read(&mReverb.flGain); + stream->read(&mReverb.flGainHF); + stream->read(&mReverb.flGainLF); + stream->read(&mReverb.flDecayTime); + stream->read(&mReverb.flDecayHFRatio); + stream->read(&mReverb.flDecayLFRatio); + stream->read(&mReverb.flReflectionsGain); + stream->read(&mReverb.flReflectionsDelay); + stream->read(&mReverb.flLateReverbGain); + stream->read(&mReverb.flLateReverbDelay); + stream->read(&mReverb.flEchoTime); + stream->read(&mReverb.flEchoDepth); + stream->read(&mReverb.flModulationTime); + stream->read(&mReverb.flModulationDepth); + stream->read(&mReverb.flAirAbsorptionGainHF); + stream->read(&mReverb.flHFReference); + stream->read(&mReverb.flLFReference); + stream->read(&mReverb.flRoomRolloffFactor); + stream->read(&mReverb.iDecayHFLimit); } } diff --git a/Engine/source/sfx/sfxDevice.h b/Engine/source/sfx/sfxDevice.h index b4d6485e3..f7dc66b77 100644 --- a/Engine/source/sfx/sfxDevice.h +++ b/Engine/source/sfx/sfxDevice.h @@ -178,6 +178,9 @@ public: /// Set the rolloff scale factor for distance attenuation of 3D sounds. virtual void setRolloffFactor( F32 factor ) {} + + /// send empty function to all sfxdevices + virtual void openSlots() {} /// Set the global reverb environment. virtual void setReverb( const SFXReverbProperties& reverb ) {} diff --git a/Engine/source/sfx/sfxEnvironment.cpp b/Engine/source/sfx/sfxEnvironment.cpp index 54bfc7d7d..780821719 100644 --- a/Engine/source/sfx/sfxEnvironment.cpp +++ b/Engine/source/sfx/sfxEnvironment.cpp @@ -144,70 +144,53 @@ void SFXEnvironment::initPersistFields() { addGroup( "Reverb" ); - addField( "envSize", TypeF32, Offset( mReverb.mEnvSize, SFXEnvironment ), - "Environment size in meters." ); - addField( "envDiffusion", TypeF32, Offset( mReverb.mEnvDiffusion, SFXEnvironment ), - "Environment diffusion." ); - addField( "room", TypeS32, Offset( mReverb.mRoom, SFXEnvironment ), - "Room effect level at mid-frequencies." ); - addField( "roomHF", TypeS32, Offset( mReverb.mRoomHF, SFXEnvironment ), - "Relative room effect level at high frequencies." ); - addField( "roomLF", TypeS32, Offset( mReverb.mRoomLF, SFXEnvironment ), - "Relative room effect level at low frequencies." ); - addField( "decayTime", TypeF32, Offset( mReverb.mDecayTime, SFXEnvironment ), - "Reverberation decay time at mid frequencies." ); - addField( "decayHFRatio", TypeF32, Offset( mReverb.mDecayHFRatio, SFXEnvironment ), - "High-frequency to mid-frequency decay time ratio." ); - addField( "decayLFRatio", TypeF32, Offset( mReverb.mDecayLFRatio, SFXEnvironment ), - "Low-frequency to mid-frequency decay time ratio." ); - addField( "reflections", TypeS32, Offset( mReverb.mReflections, SFXEnvironment ), - "Early reflections level relative to room effect." ); - addField( "reflectionsDelay", TypeF32, Offset( mReverb.mReflectionsDelay, SFXEnvironment ), - "Initial reflection delay time." ); - addField( "reflectionsPan", TypeF32, Offset( mReverb.mReflectionsPan, SFXEnvironment ), 3, - "Early reflections panning vector." ); - addField( "reverb", TypeS32, Offset( mReverb.mReverb, SFXEnvironment ), - "Late reverberation level relative to room effect." ); - addField( "reverbDelay", TypeF32, Offset( mReverb.mReverbDelay, SFXEnvironment ), - "Late reverberation delay time relative to initial reflection." ); - addField( "reverbPan", TypeF32, Offset( mReverb.mReverbPan, SFXEnvironment ), 3, - "Late reverberation panning vector." ); - addField( "echoTime", TypeF32, Offset( mReverb.mEchoTime, SFXEnvironment ), - "Echo time." ); - addField( "echoDepth", TypeF32, Offset( mReverb.mEchoDepth, SFXEnvironment ), - "Echo depth." ); - addField( "modulationTime", TypeF32, Offset( mReverb.mModulationTime, SFXEnvironment ), - "Modulation time." ); - addField( "modulationDepth", TypeF32, Offset( mReverb.mModulationDepth, SFXEnvironment ), - "Modulation depth." ); - addField( "airAbsorptionHF", TypeF32, Offset( mReverb.mAirAbsorptionHF, SFXEnvironment ), - "Change in level per meter at high frequencies." ); - addField( "HFReference", TypeF32, Offset( mReverb.mHFReference, SFXEnvironment ), - "Reference high frequency in Hertz." ); - addField( "LFReference", TypeF32, Offset( mReverb.mLFReference, SFXEnvironment ), - "Reference low frequency in Hertz." ); - addField( "roomRolloffFactor", TypeF32, Offset( mReverb.mRoomRolloffFactor, SFXEnvironment ), - "Logarithmic distance attenuation rolloff scale factor for reverb room size effect." ); - addField( "diffusion", TypeF32, Offset( mReverb.mDiffusion, SFXEnvironment ), - "Value that controls the echo density in the late reverberation decay." ); - addField( "density", TypeF32, Offset( mReverb.mDensity, SFXEnvironment ), - "Value that controls the modal density in the late reverberation decay." ); - addField( "flags", TypeS32, Offset( mReverb.mFlags, SFXEnvironment ), - "A bitfield of reverb flags.\n" - "@see REVERB_DECAYTIMESCALE\n" - "@see REVERB_REFLECTIONSSCALE\n" - "@see REVERB_REFLECTIONSDELAYSCALE\n" - "@see REVERB_REVERBSCALE\n" - "@see REVERB_REVERBDELAYSCALE\n" - "@see REVERB_DECAYHFLIMIT\n" - "@see REVERB_ECHOTIMESCALE\n" - "@see REVERB_MODULATIONTIMESCALE\n" - "@see REVERB_CORE0\n" - "@see REVERB_CORE1\n" - "@see REVERB_HIGHQUALITYREVERB\n" - "@see REVERB_HIGHQUALITYDPL2REVERB\n" ); - - endGroup( "Reverb" ); + addField("reverbDensity", TypeF32, Offset(mReverb.flDensity, SFXEnvironment), + "Density of reverb environment."); + addField("reverbDiffusion", TypeF32, Offset(mReverb.flDiffusion, SFXEnvironment), + "Environment diffusion."); + addField("reverbGain", TypeF32, Offset(mReverb.flGain, SFXEnvironment), + "Reverb Gain Level."); + addField("reverbGainHF", TypeF32, Offset(mReverb.flGainHF, SFXEnvironment), + "Reverb Gain to high frequencies"); + addField("reverbGainLF", TypeF32, Offset(mReverb.flGainLF, SFXEnvironment), + "Reverb Gain to high frequencies"); + addField("reverbDecayTime", TypeF32, Offset(mReverb.flDecayTime, SFXEnvironment), + "Decay time for the reverb."); + addField("reverbDecayHFRatio", TypeF32, Offset(mReverb.flDecayHFRatio, SFXEnvironment), + "High frequency decay time ratio."); + addField("reverbDecayLFRatio", TypeF32, Offset(mReverb.flDecayLFRatio, SFXEnvironment), + "High frequency decay time ratio."); + addField("reflectionsGain", TypeF32, Offset(mReverb.flReflectionsGain, SFXEnvironment), + "Reflection Gain."); + addField("reflectionDelay", TypeF32, Offset(mReverb.flReflectionsDelay, SFXEnvironment), + "How long to delay reflections."); + addField("reflectionsPan", TypeF32, Offset(mReverb.flReflectionsPan, SFXEnvironment), 3, + "Reflection reverberation panning vector."); + addField("lateReverbGain", TypeF32, Offset(mReverb.flLateReverbGain, SFXEnvironment), + "Late reverb gain amount."); + addField("lateReverbDelay", TypeF32, Offset(mReverb.flLateReverbDelay, SFXEnvironment), + "Late reverb delay time."); + addField("lateReverbPan", TypeF32, Offset(mReverb.flLateReverbPan, SFXEnvironment), 3, + "Late reverberation panning vector."); + addField("reverbEchoTime", TypeF32, Offset(mReverb.flEchoTime, SFXEnvironment), + "Reverb echo time."); + addField("reverbEchoDepth", TypeF32, Offset(mReverb.flEchoDepth, SFXEnvironment), + "Reverb echo depth."); + addField("reverbModTime", TypeF32, Offset(mReverb.flModulationTime, SFXEnvironment), + "Reverb Modulation time."); + addField("reverbModDepth", TypeF32, Offset(mReverb.flModulationDepth, SFXEnvironment), + "Reverb Modulation time."); + addField("airAbsorbtionGainHF", TypeF32, Offset(mReverb.flAirAbsorptionGainHF, SFXEnvironment), + "High Frequency air absorbtion"); + addField("reverbHFRef", TypeF32, Offset(mReverb.flHFReference, SFXEnvironment), + "Reverb High Frequency Reference."); + addField("reverbLFRef", TypeF32, Offset(mReverb.flLFReference, SFXEnvironment), + "Reverb Low Frequency Reference."); + addField("roomRolloffFactor", TypeF32, Offset(mReverb.flRoomRolloffFactor, SFXEnvironment), + "Rolloff factor for reverb."); + addField("decayHFLimit", TypeS32, Offset(mReverb.iDecayHFLimit, SFXEnvironment), + "High Frequency decay limit."); + endGroup("Reverb"); Parent::initPersistFields(); } @@ -257,35 +240,27 @@ void SFXEnvironment::packData( BitStream* stream ) { Parent::packData( stream ); - stream->write( mReverb.mEnvSize ); - stream->write( mReverb.mEnvDiffusion ); - stream->write( mReverb.mRoom ); - stream->write( mReverb.mRoomHF ); - stream->write( mReverb.mRoomLF ); - stream->write( mReverb.mDecayTime ); - stream->write( mReverb.mDecayHFRatio ); - stream->write( mReverb.mDecayLFRatio ); - stream->write( mReverb.mReflections ); - stream->write( mReverb.mReflectionsDelay ); - stream->write( mReverb.mReflectionsPan[ 0 ] ); - stream->write( mReverb.mReflectionsPan[ 1 ] ); - stream->write( mReverb.mReflectionsPan[ 2 ] ); - stream->write( mReverb.mReverb ); - stream->write( mReverb.mReverbDelay ); - stream->write( mReverb.mReverbPan[ 0 ] ); - stream->write( mReverb.mReverbPan[ 1 ] ); - stream->write( mReverb.mReverbPan[ 2 ] ); - stream->write( mReverb.mEchoTime ); - stream->write( mReverb.mEchoDepth ); - stream->write( mReverb.mModulationTime ); - stream->write( mReverb.mModulationDepth ); - stream->write( mReverb.mAirAbsorptionHF ); - stream->write( mReverb.mHFReference ); - stream->write( mReverb.mLFReference ); - stream->write( mReverb.mRoomRolloffFactor ); - stream->write( mReverb.mDiffusion ); - stream->write( mReverb.mDensity ); - stream->write( mReverb.mFlags ); + stream->write(mReverb.flDensity); + stream->write(mReverb.flDiffusion); + stream->write(mReverb.flGain); + stream->write(mReverb.flGainHF); + stream->write(mReverb.flGainLF); + stream->write(mReverb.flDecayTime); + stream->write(mReverb.flDecayHFRatio); + stream->write(mReverb.flDecayLFRatio); + stream->write(mReverb.flReflectionsGain); + stream->write(mReverb.flReflectionsDelay); + stream->write(mReverb.flLateReverbGain); + stream->write(mReverb.flLateReverbDelay); + stream->write(mReverb.flEchoTime); + stream->write(mReverb.flEchoDepth); + stream->write(mReverb.flModulationTime); + stream->write(mReverb.flModulationDepth); + stream->write(mReverb.flAirAbsorptionGainHF); + stream->write(mReverb.flHFReference); + stream->write(mReverb.flLFReference); + stream->write(mReverb.flRoomRolloffFactor); + stream->write(mReverb.iDecayHFLimit); } //----------------------------------------------------------------------------- @@ -294,33 +269,25 @@ void SFXEnvironment::unpackData( BitStream* stream ) { Parent::unpackData( stream ); - stream->read( &mReverb.mEnvSize ); - stream->read( &mReverb.mEnvDiffusion ); - stream->read( &mReverb.mRoom ); - stream->read( &mReverb.mRoomHF ); - stream->read( &mReverb.mRoomLF ); - stream->read( &mReverb.mDecayTime ); - stream->read( &mReverb.mDecayHFRatio ); - stream->read( &mReverb.mDecayLFRatio ); - stream->read( &mReverb.mReflections ); - stream->read( &mReverb.mReflectionsDelay ); - stream->read( &mReverb.mReflectionsPan[ 0 ] ); - stream->read( &mReverb.mReflectionsPan[ 1 ] ); - stream->read( &mReverb.mReflectionsPan[ 2 ] ); - stream->read( &mReverb.mReverb ); - stream->read( &mReverb.mReverbDelay ); - stream->read( &mReverb.mReverbPan[ 0 ] ); - stream->read( &mReverb.mReverbPan[ 1 ] ); - stream->read( &mReverb.mReverbPan[ 2 ] ); - stream->read( &mReverb.mEchoTime ); - stream->read( &mReverb.mEchoDepth ); - stream->read( &mReverb.mModulationTime ); - stream->read( &mReverb.mModulationDepth ); - stream->read( &mReverb.mAirAbsorptionHF ); - stream->read( &mReverb.mHFReference ); - stream->read( &mReverb.mLFReference ); - stream->read( &mReverb.mRoomRolloffFactor ); - stream->read( &mReverb.mDiffusion ); - stream->read( &mReverb.mDensity ); - stream->read( &mReverb.mFlags ); + stream->read(&mReverb.flDensity); + stream->read(&mReverb.flDiffusion); + stream->read(&mReverb.flGain); + stream->read(&mReverb.flGainHF); + stream->read(&mReverb.flGainLF); + stream->read(&mReverb.flDecayTime); + stream->read(&mReverb.flDecayHFRatio); + stream->read(&mReverb.flDecayLFRatio); + stream->read(&mReverb.flReflectionsGain); + stream->read(&mReverb.flReflectionsDelay); + stream->read(&mReverb.flLateReverbGain); + stream->read(&mReverb.flLateReverbDelay); + stream->read(&mReverb.flEchoTime); + stream->read(&mReverb.flEchoDepth); + stream->read(&mReverb.flModulationTime); + stream->read(&mReverb.flModulationDepth); + stream->read(&mReverb.flAirAbsorptionGainHF); + stream->read(&mReverb.flHFReference); + stream->read(&mReverb.flLFReference); + stream->read(&mReverb.flRoomRolloffFactor); + stream->read(&mReverb.iDecayHFLimit); } diff --git a/Engine/source/sfx/sfxSystem.cpp b/Engine/source/sfx/sfxSystem.cpp index 5cf340cf2..d586e921c 100644 --- a/Engine/source/sfx/sfxSystem.cpp +++ b/Engine/source/sfx/sfxSystem.cpp @@ -94,6 +94,9 @@ ImplementEnumType( SFXDistanceModel, { SFXDistanceModelLogarithmic, "Logarithmic", "Volume attenuates logarithmically starting from the reference distance and halving every reference distance step from there on. " "Attenuation stops at max distance but volume won't reach zero." }, + { SFXDistanceModelExponent, "Exponential", + "Volume attenuates exponentially starting from the reference distance and attenuating every reference distance step by the rolloff factor. " + "Attenuation stops at max distance but volume won't reach zero." }, EndImplementEnumType; ImplementEnumType( SFXChannel, @@ -473,6 +476,9 @@ bool SFXSystem::createDevice( const String& providerName, const String& deviceNa mDevice->setDistanceModel( mDistanceModel ); mDevice->setDopplerFactor( mDopplerFactor ); mDevice->setRolloffFactor( mRolloffFactor ); + //OpenAL requires slots for effects, this creates an empty function + //that will run when a sfxdevice is created. + mDevice->openSlots(); mDevice->setReverb( mReverb ); // Signal system. diff --git a/Templates/Full/game/core/scripts/client/audioEnvironments.cs b/Templates/Full/game/core/scripts/client/audioEnvironments.cs index 09fc4de1a..71050d8c4 100644 --- a/Templates/Full/game/core/scripts/client/audioEnvironments.cs +++ b/Templates/Full/game/core/scripts/client/audioEnvironments.cs @@ -24,893 +24,1366 @@ // // For customized presets, best derive from one of these presets. -singleton SFXEnvironment( AudioEnvOff ) +singleton SFXEnvironment(Generic) { - envSize = "7.5"; - envDiffusion = "1.0"; - room = "-10000"; - roomHF = "-10000"; - roomLF = "0"; - decayTime = "1.0"; - decayHFRatio = "1.0"; - decayLFRatio = "1.0"; - reflections = "-2602"; - reflectionsDelay = "0.007"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "200"; - reverbDelay = "0.011"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "0.0"; - density = "0.0"; - flags = 0x33; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.8913"; +reverbGainLF = "1.000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.0500"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.2589"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvGeneric ) +singleton SFXEnvironment(PaddedCell) { - envSize = "7.5"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-100"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.83"; - decayLFRatio = "1.0"; - reflections = "-2602"; - reflectionsDelay = "0.007"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "200"; - reverbDelay = "0.011"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "0.1715"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.0010"; +reverbGainLF = "1.000"; +reverbDecayTime = "0.1700"; +reverbDecayHFRatio = "0.1000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2500"; +reflectionDelay = "0.0010"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.2691"; +lateReverbDelay = "0.0020"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvRoom ) +singleton SFXEnvironment(PresetRoom) { - envSize = "1.9"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-454"; - roomLF = "0"; - decayTime = "0.4"; - decayHFRatio = "0.83"; - decayLFRatio = "1.0"; - reflections = "-1646"; - reflectionsDelay = "0.002"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "53"; - reverbDelay = "0.003"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "0.4287"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.5929"; +reverbGainLF = "1.000"; +reverbDecayTime = "0.4000"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.1503"; +reflectionDelay = "0.0020"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.0629"; +lateReverbDelay = "0.0030"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvPaddedCell ) +singleton SFXEnvironment(PresetBathroom) { - envSize = "1.4"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-6000"; - roomLF = "0"; - decayTime = "0.17"; - decayHFRatio = "0.1"; - decayLFRatio = "1.0"; - reflections = "-1204"; - reflectionsDelay = "0.001"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "207"; - reverbDelay = "0.002"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "0.1715"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.2512"; +reverbGainLF = "1.000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.5400"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.6531"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "3.2734"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvBathroom ) +singleton SFXEnvironment(PresetLivingroom) { - envSize = "1.4"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-1200"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.54"; - decayLFRatio = "1.0"; - reflections = "-370"; - reflectionsDelay = "0.007"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "1030"; - reverbDelay = "0.011"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "60.0"; - flags = 0x3f; +reverbDensity = "0.9766"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.0010"; +reverbGainLF = "1.0000"; +reverbDecayTime = "0.0900"; +reverbDecayHFRatio = "0.5000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2051"; +reflectionDelay = "0.0030"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.2805"; +lateReverbDelay = "0.0040"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvLivingRoom ) +singleton SFXEnvironment(PresetStoneroom) { - envSize = "2.5"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-6000"; - roomLF = "0"; - decayTime = "0.5"; - decayHFRatio = "0.1"; - decayLFRatio = "1.0"; - reflections = "-1376"; - reflectionsDelay = "0.003"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-1104"; - reverbDelay = "0.004"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.7079"; +reverbGainLF = "1.0000"; +reverbDecayTime = "2.3100"; +reverbDecayHFRatio = "0.6400"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.4411"; +reflectionDelay = "0.0120"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.1003"; +lateReverbDelay = "0.0170"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvStoneRoom ) +singleton SFXEnvironment(PresetAuditorium) { - envSize = "11.6"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "300"; - roomLF = "0"; - decayTime = "2.31"; - decayHFRatio = "0.64"; - decayLFRatio = "1.0"; - reflections = "-711"; - reflectionsDelay = "0.012"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "83"; - reverbDelay = "0.017"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "-5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.5781"; +reverbGainLF = "1.0000"; +reverbDecayTime = "4.3200"; +reverbDecayHFRatio = "0.5900"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.4032"; +reflectionDelay = "0.0200"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.7170"; +lateReverbDelay = "0.0300"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvAuditorium ) +singleton SFXEnvironment(PresetConcerthall) { - envSize = "21.6"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-476"; - roomLF = "0"; - decayTime = "4.32"; - decayHFRatio = "0.59"; - decayLFRatio = "1.0"; - reflections = "0.789"; - reflectionsDelay = "0.02"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-289"; - reverbDelay = "0.03"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.5632"; +reverbGainLF = "1.0000"; +reverbDecayTime = "3.9200"; +reverbDecayHFRatio = "0.7000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2427"; +reflectionDelay = "0.0200"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.9977"; +lateReverbDelay = "0.0290"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvConcertHall ) +singleton SFXEnvironment(PresetCave) { - envSize = "19.6"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-500"; - roomLF = "0"; - decayTime = "3.92"; - decayHFRatio = "0.7"; - decayLFRatio = "1.0"; - reflections = "-1230"; - reflectionsDelay = "0.02"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-2"; - reverbDelay = "0.029"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "1.000"; +reverbGainLF = "1.0000"; +reverbDecayTime = "2.9100"; +reverbDecayHFRatio = "1.3000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.5000"; +reflectionDelay = "0.0250"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.7063"; +lateReverbDelay = "0.0220"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "0"; }; -singleton SFXEnvironment( AudioEnvCave ) +singleton SFXEnvironment(PresetArena) { - envSize = "14.6"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "0"; - roomLF = "0"; - decayTime = "2.91"; - decayHFRatio = "1.3"; - decayLFRatio = "1.0"; - reflections = "-602"; - reflectionsDelay = "0.015"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-302"; - reverbDelay = "0.022"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x1f; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.4477"; +reverbGainLF = "1.0000"; +reverbDecayTime = "7.2400"; +reverbDecayHFRatio = "0.3300"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2612"; +reflectionDelay = "0.0200"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.0186"; +lateReverbDelay = "0.0300"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvArena ) +singleton SFXEnvironment(PresetHangar) { - envSize = "36.2f"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-698"; - roomLF = "0"; - decayTime = "7.24"; - decayHFRatio = "0.33"; - decayLFRatio = "1.0"; - reflections = "-1166"; - reflectionsDelay = "0.02"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "16"; - reverbDelay = "0.03"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.3162"; +reverbGainLF = "1.0000"; +reverbDecayTime = "10.0500"; +reverbDecayHFRatio = "0.2300"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.5000"; +reflectionDelay = "0.0200"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.2560"; +lateReverbDelay = "0.0300"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvHangar ) +singleton SFXEnvironment(PresetCarpetedHall) { - envSize = "50.3"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-1000"; - roomLF = "0"; - decayTime = "10.05"; - decayHFRatio = "0.23"; - decayLFRatio = "1.0"; - reflections = "-602"; - reflectionsDelay = "0.02"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "198"; - reverbDelay = "0.03"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "0.4287"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.0100"; +reverbGainLF = "1.0000"; +reverbDecayTime = "0.3000"; +reverbDecayHFRatio = "0.1000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.1215"; +reflectionDelay = "0.0020"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.1531"; +lateReverbDelay = "0.0300"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvCarpettedHallway ) +singleton SFXEnvironment(PresetHallway) { - envSize = "1.9"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-4000"; - roomLF = "0"; - decayTime = "0.3"; - decayHFRatio = "0.1"; - decayLFRatio = "1.0"; - reflections = "-1831"; - reflectionsDelay = "0.002"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-1630"; - reverbDelay = "0.03"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "0.3645"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.7079"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.5900"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2458"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.6615"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvHallway ) +singleton SFXEnvironment(PresetStoneCorridor) { - envSize = "1.8"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-300"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.59"; - decayLFRatio = "1.0"; - reflections = "-1219"; - reflectionsDelay = "0.007"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "441"; - reverbDelay = "0.011"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "1.000"; +reverbGain = "0.3162"; +reverbGainHF = "0.7612"; +reverbGainLF = "1.0000"; +reverbDecayTime = "2.7000"; +reverbDecayHFRatio = "0.7900"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2472"; +reflectionDelay = "0.0130"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.5758"; +lateReverbDelay = "0.0200"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvStoneCorridor ) +singleton SFXEnvironment(PresetStoneAlley) { - envSize = "13.5"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-237"; - roomLF = "0"; - decayTime = "2.7"; - decayHFRatio = "0.79"; - decayLFRatio = "1.0"; - reflections = "-1214"; - reflectionsDelay = "0.013"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "395"; - reverbDelay = "0.02"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "0.300"; +reverbGain = "0.3162"; +reverbGainHF = "0.7328"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.8600"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2500"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.9954"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1250"; +reverbEchoDepth = "0.9500"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvAlley ) +singleton SFXEnvironment(PresetFroest) { - envSize = "7.5"; - envDiffusion = "0.3"; - room = "-1000"; - roomHF = "-270"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.86"; - decayLFRatio = "1.0"; - reflections = "-1204"; - reflectionsDelay = "0.007"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-4"; - reverbDelay = "0.011"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.125"; - echoDepth = "0.95"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "0.300"; +reverbGain = "0.3162"; +reverbGainHF = "0.0224"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.5400"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.0525"; +reflectionDelay = "0.1620"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.7682"; +lateReverbDelay = "0.0880"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1250"; +reverbEchoDepth = "1.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvForest ) +singleton SFXEnvironment(PresetCity) { - envSize = "38.0"; - envDiffusion = "0.3"; - room = "-1000"; - roomHF = "-3300"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.54"; - decayLFRatio = "1.0"; - reflections = "-2560"; - reflectionsDelay = "0.162"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-229"; - reverbDelay = "0.088"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.125"; - echoDepth = "1.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "79.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "0.500"; +reverbGain = "0.3162"; +reverbGainHF = "0.3981"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.6700"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.0730"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.1427"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1250"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvCity ) +singleton SFXEnvironment(PresetMountains) { - envSize = "7.5"; - envDiffusion = "0.5"; - room = "-1000"; - roomHF = "-800"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.67"; - decayLFRatio = "1.0"; - reflections = "-2273"; - reflectionsDelay = "0.007"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-1691"; - reverbDelay = "0.011"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "50.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "0.2700"; +reverbGain = "0.3162"; +reverbGainHF = "0.0562"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.2100"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.0407"; +reflectionDelay = "0.3000"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.1919"; +lateReverbDelay = "0.1000"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1250"; +reverbEchoDepth = "1.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "0"; }; -singleton SFXEnvironment( AudioEnvMountains ) +singleton SFXEnvironment(PresetQuarry) { - envSize = "100.0"; - envDiffusion = "0.27"; - room = "-1000"; - roomHF = "-2500"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.21"; - decayLFRatio = "1.0"; - reflections = "-2780"; - reflectionsDelay = "0.3"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-1434"; - reverbDelay = "0.1"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "1.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "27.0"; - density = "100.0"; - flags = 0x1f; +reverbDensity = "1.000"; +reverbDiffusion = "1.0000"; +reverbGain = "0.3162"; +reverbGainHF = "0.3162"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.0000"; +reflectionDelay = "0.0610"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.7783"; +lateReverbDelay = "0.0250"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1250"; +reverbEchoDepth = "0.7000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvQuary ) +singleton SFXEnvironment(PresetPlain) { - envSize = "17.5"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-1000"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.83"; - decayLFRatio = "1.0"; - reflections = "-10000"; - reflectionsDelay = "0.061"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "500"; - reverbDelay = "0.025"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.125"; - echoDepth = "0.7"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "0.2100"; +reverbGain = "0.3162"; +reverbGainHF = "0.1000"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.5000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.0585"; +reflectionDelay = "0.1790"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.1089"; +lateReverbDelay = "0.1000"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "1.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvPlain ) +singleton SFXEnvironment(PresetParkinglot) { - envSize = "42.5"; - envDiffusion = "0.21"; - room = "-1000"; - roomHF = "-2000"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.5"; - decayLFRatio = "1.0"; - reflections = "-2466"; - reflectionsDelay = "0.179"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-1926"; - reverbDelay = "0.1"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "1.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "21.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "1.000"; +reverbDiffusion = "1.0000"; +reverbGain = "0.3162"; +reverbGainHF = "1.0000"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.6500"; +reverbDecayHFRatio = "1.5000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.2082"; +reflectionDelay = "0.0080"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.2652"; +lateReverbDelay = "0.0120"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "0"; }; -singleton SFXEnvironment( AudioEnvParkingLot ) +singleton SFXEnvironment(PresetSewerpipe) { - envSize = "8.3"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "0"; - roomLF = "0"; - decayTime = "1.65"; - decayHFRatio = "1.5"; - decayLFRatio = "1.0"; - reflections = "-1363"; - reflectionsDelay = "0.008"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-1153"; - reverbDelay = "0.012"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x1f; +reverbDensity = "0.3071"; +reverbDiffusion = "0.8000"; +reverbGain = "0.3162"; +reverbGainHF = "0.3162"; +reverbGainLF = "1.0000"; +reverbDecayTime = "2.8100"; +reverbDecayHFRatio = "0.1400"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "1.6387"; +reflectionDelay = "0.0140"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "3.2471"; +lateReverbDelay = "0.0210"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvSewerPipe ) +singleton SFXEnvironment(PresetUnderwater) { - envSize = "1.7"; - envDiffusion = "0.8"; - room = "-1000"; - roomHF = "-1000"; - roomLF = "0"; - decayTime = "2.81"; - decayHFRatio = "0.14"; - decayLFRatio = "1.0"; - reflections = "429"; - reflectionsDelay = "0.014"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "1023"; - reverbDelay = "0.21"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "0.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "80.0"; - density = "60.0"; - flags = 0x3f; +reverbDensity = "0.3645"; +reverbDiffusion = "1.0000"; +reverbGain = "0.3162"; +reverbGainHF = "0.0100"; +reverbGainLF = "1.0000"; +reverbDecayTime = "1.4900"; +reverbDecayHFRatio = "0.1000"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.5963"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "7.0795"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "1.1800"; +reverbModDepth = "0.3480"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; -singleton SFXEnvironment( AudioEnvUnderwater ) +singleton SFXEnvironment(PresetDrugged) { - envSize = "1.8"; - envDiffusion = "1.0"; - room = "-1000"; - roomHF = "-4000"; - roomLF = "0"; - decayTime = "1.49"; - decayHFRatio = "0.1"; - decayLFRatio = "1.0"; - reflections = "-449"; - reflectionsDelay = "0.007"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "1700"; - reverbDelay = "0.011"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "1.18"; - modulationDepth = "0.348"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x3f; +reverbDensity = "0.4287"; +reverbDiffusion = "0.5000"; +reverbGain = "0.3162"; +reverbGainHF = "1.0000"; +reverbGainLF = "1.0000"; +reverbDecayTime = "8.3900"; +reverbDecayHFRatio = "1.3900"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.8760"; +reflectionDelay = "0.0020"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "3.1081"; +lateReverbDelay = "0.0300"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "1.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "0"; }; -singleton SFXEnvironment( AudioEnvDrugged ) +singleton SFXEnvironment(PresetDizzy) { - envSize = "1.9"; - envDiffusion = "0.5"; - room = "-1000"; - roomHF = "0"; - roomLF = "0"; - decayTime = "8.39"; - decayHFRatio = "1.39"; - decayLFRatio = "1.0"; - reflections = "-115"; - reflectionsDelay = "0.002"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "985"; - reverbDelay = "0.03"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "0.25"; - modulationDepth = "1.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x1f; +reverbDensity = "0.3645"; +reverbDiffusion = "0.6000"; +reverbGain = "0.3162"; +reverbGainHF = "0.6310"; +reverbGainLF = "1.0000"; +reverbDecayTime = "17.2300"; +reverbDecayHFRatio = "0.5600"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.1392"; +reflectionDelay = "0.0200"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.4937"; +lateReverbDelay = "0.0300"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "1.0000"; +reverbModTime = "0.8100"; +reverbModDepth = "0.3100"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "0"; }; -singleton SFXEnvironment( AudioEnvDizzy ) +singleton SFXEnvironment(PresetPsychotic) { - envSize = "1.8"; - envDiffusion = "0.6"; - room = "-1000.0"; - roomHF = "-400"; - roomLF = "0"; - decayTime = "17.23"; - decayHFRatio = "0.56"; - decayLFRatio = "1.0"; - reflections = "-1713"; - reflectionsDelay = "0.02"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "-613"; - reverbDelay = "0.03"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "1.0"; - modulationTime = "0.81"; - modulationDepth = "0.31"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x1f; +reverbDensity = "0.0625"; +reverbDiffusion = "0.5000"; +reverbGain = "0.3162"; +reverbGainHF = "0.8404"; +reverbGainLF = "1.0000"; +reverbDecayTime = "7.5600"; +reverbDecayHFRatio = "0.9100"; +reverbDecayLFRatio = "1.0000"; +reflectionsGain = "0.4864"; +reflectionDelay = "0.0200"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "2.4378"; +lateReverbDelay = "0.0300"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "4.0000"; +reverbModDepth = "1.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "0"; }; -singleton SFXEnvironment( AudioEnvPsychotic ) +singleton SFXEnvironment(CastleSmallroom) { - envSize = "1.0"; - envDiffusion = "0.5"; - room = "-1000"; - roomHF = "-151"; - roomLF = "0"; - decayTime = "7.56"; - decayHFRatio = "0.91"; - decayLFRatio = "1.0"; - reflections = "-626"; - reflectionsDelay = "0.02"; - reflectionsPan[ 0 ] = "0.0"; - reflectionsPan[ 1 ] = "0.0"; - reflectionsPan[ 2 ] = "0.0"; - reverb = "774"; - reverbDelay = "0.03"; - reverbPan[ 0 ] = "0.0"; - reverbPan[ 1 ] = "0.0"; - reverbPan[ 2 ] = "0.0"; - echoTime = "0.25"; - echoDepth = "0.0"; - modulationTime = "4.0"; - modulationDepth = "1.0"; - airAbsorptionHF = "-5.0"; - HFReference = "5000.0"; - LFReference = "250.0"; - roomRolloffFactor = "0.0"; - diffusion = "100.0"; - density = "100.0"; - flags = 0x1f; +reverbDensity = "1.0000"; +reverbDiffusion = "0.8900"; +reverbGain = "0.3162"; +reverbGainHF = "0.3981"; +reverbGainLF = "0.1000"; +reverbDecayTime = "1.2200"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "0.3100"; +reflectionsGain = "0.8913"; +reflectionDelay = "0.0220"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.9953"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1380"; +reverbEchoDepth = "0.0800"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; }; + +singleton SFXEnvironment(CastleShortPassage) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.8900"; +reverbGain = "0.3162"; +reverbGainHF = "0.3162"; +reverbGainLF = "0.1000"; +reverbDecayTime = "2.3200"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "0.3100"; +reflectionsGain = "0.8913"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.2589"; +lateReverbDelay = "0.0230"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1380"; +reverbEchoDepth = "0.0800"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5168.0001"; +reverbLFRef = "139.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(CastleMediumRoom) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.9300"; +reverbGain = "0.3162"; +reverbGainHF = "0.2818"; +reverbGainLF = "0.1000"; +reverbDecayTime = "2.0400"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "0.4600"; +reflectionsGain = "0.6310"; +reflectionDelay = "0.0220"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.5849"; +lateReverbDelay = "0.0110"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1550"; +reverbEchoDepth = "0.0300"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5168.0001"; +reverbLFRef = "139.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(CastleLargeRoom) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.8200"; +reverbGain = "0.3162"; +reverbGainHF = "0.2818"; +reverbGainLF = "0.1259"; +reverbDecayTime = "2.5300"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "0.5000"; +reflectionsGain = "0.4467"; +reflectionDelay = "0.0340"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.2589"; +lateReverbDelay = "0.0160"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1850"; +reverbEchoDepth = "0.0700"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5168.0001"; +reverbLFRef = "139.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(CastleLongPassage) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.8900"; +reverbGain = "0.3162"; +reverbGainHF = "0.3981"; +reverbGainLF = "0.1000"; +reverbDecayTime = "3.4200"; +reverbDecayHFRatio = "0.8300"; +reverbDecayLFRatio = "0.3100"; +reflectionsGain = "0.8913"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.4125"; +lateReverbDelay = "0.0230"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1380"; +reverbEchoDepth = "0.0800"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5168.0001"; +reverbLFRef = "139.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(CastleHall) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.8100"; +reverbGain = "0.3162"; +reverbGainHF = "0.2818"; +reverbGainLF = "0.1778"; +reverbDecayTime = "3.1400"; +reverbDecayHFRatio = "0.7900"; +reverbDecayLFRatio = "0.6200"; +reflectionsGain = "0.1778"; +reflectionDelay = "0.0560"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.1220"; +lateReverbDelay = "0.0240"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5168.0001"; +reverbLFRef = "139.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(CastleCupboard) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.8900"; +reverbGain = "0.3162"; +reverbGainHF = "0.2818"; +reverbGainLF = "0.1000"; +reverbDecayTime = "0.6700"; +reverbDecayHFRatio = "0.8700"; +reverbDecayLFRatio = "0.3100"; +reflectionsGain = "1.4125"; +reflectionDelay = "0.0100"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "3.5481"; +lateReverbDelay = "0.0070"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1380"; +reverbEchoDepth = "0.0800"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5168.0001"; +reverbLFRef = "139.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(CastleCourtyard) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.4200"; +reverbGain = "0.3162"; +reverbGainHF = "0.4467"; +reverbGainLF = "0.1995"; +reverbDecayTime = "2.1300"; +reverbDecayHFRatio = "0.6100"; +reverbDecayLFRatio = "0.2300"; +reflectionsGain = "0.2239"; +reflectionDelay = "0.1600"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.7079"; +lateReverbDelay = "0.0360"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.3700"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5000.0000"; +reverbLFRef = "250.0000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "0"; +}; + +singleton SFXEnvironment(CastleAlcove) +{ +reverbDensity = "1.0000"; +reverbDiffusion = "0.8900"; +reverbGain = "0.3162"; +reverbGainHF = "0.5012"; +reverbGainLF = "0.1000"; +reverbDecayTime = "1.6400"; +reverbDecayHFRatio = "0.8700"; +reverbDecayLFRatio = "0.3100"; +reflectionsGain = "1.0000"; +reflectionDelay = "0.0070"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.4125"; +lateReverbDelay = "0.0340"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1380"; +reverbEchoDepth = "0.0800"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "5168.0001"; +reverbLFRef = "139.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactorySmallRoom) +{ +reverbDensity = "0.3645"; +reverbDiffusion = "0.8200"; +reverbGain = "0.3162"; +reverbGainHF = "0.7943"; +reverbGainLF = "0.5012"; +reverbDecayTime = "1.7200"; +reverbDecayHFRatio = "0.6500"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "0.7079"; +reflectionDelay = "0.0100"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.7783"; +lateReverbDelay = "0.0240"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1190"; +reverbEchoDepth = "0.0700"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryShortPassage) +{ +reverbDensity = "0.3645"; +reverbDiffusion = "0.6400"; +reverbGain = "0.2512"; +reverbGainHF = "0.7943"; +reverbGainLF = "0.5012"; +reverbDecayTime = "2.5300"; +reverbDecayHFRatio = "0.6500"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "1.0000"; +reflectionDelay = "0.0100"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.2589"; +lateReverbDelay = "0.0380"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1350"; +reverbEchoDepth = "0.2300"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryMediumRoom) +{ +reverbDensity = "0.4287"; +reverbDiffusion = "0.8200"; +reverbGain = "0.2512"; +reverbGainHF = "0.7943"; +reverbGainLF = "0.5012"; +reverbDecayTime = "2.7600"; +reverbDecayHFRatio = "0.6500"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "0.2818"; +reflectionDelay = "0.0220"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.4125"; +lateReverbDelay = "0.0230"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1740"; +reverbEchoDepth = "0.0700"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryLargeRoom) +{ +reverbDensity = "0.4287"; +reverbDiffusion = "0.7500"; +reverbGain = "0.2512"; +reverbGainHF = "0.7079"; +reverbGainLF = "0.6310"; +reverbDecayTime = "4.2400"; +reverbDecayHFRatio = "0.5100"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "0.1778"; +reflectionDelay = "0.0390"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.1220"; +lateReverbDelay = "0.0230"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2310"; +reverbEchoDepth = "0.0700"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryLongPassage) +{ +reverbDensity = "0.3645"; +reverbDiffusion = "0.6400"; +reverbGain = "0.2512"; +reverbGainHF = "0.7943"; +reverbGainLF = "0.5012"; +reverbDecayTime = "4.0000"; +reverbDecayHFRatio = "0.6500"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "1.0000"; +reflectionDelay = "0.0200"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.2589"; +lateReverbDelay = "0.0370"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1350"; +reverbEchoDepth = "0.2300"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryHall) +{ +reverbDensity = "0.4287"; +reverbDiffusion = "0.7500"; +reverbGain = "0.3162"; +reverbGainHF = "0.7079"; +reverbGainLF = "0.6310"; +reverbDecayTime = "7.4300"; +reverbDecayHFRatio = "0.5100"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "0.0631"; +reflectionDelay = "0.0730"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.8913"; +lateReverbDelay = "0.0270"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.0700"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryCupboard) +{ +reverbDensity = "0.3071"; +reverbDiffusion = "0.6300"; +reverbGain = "0.2512"; +reverbGainHF = "0.7943"; +reverbGainLF = "0.5012"; +reverbDecayTime = "0.4900"; +reverbDecayHFRatio = "0.6500"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "1.2589"; +reflectionDelay = "0.0100"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.9953"; +lateReverbDelay = "0.0320"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1070"; +reverbEchoDepth = "0.0700"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryCourtyard) +{ +reverbDensity = "0.3071"; +reverbDiffusion = "0.5700"; +reverbGain = "0.3162"; +reverbGainHF = "0.3162"; +reverbGainLF = "0.6310"; +reverbDecayTime = "2.3200"; +reverbDecayHFRatio = "0.2900"; +reverbDecayLFRatio = "0.5600"; +reflectionsGain = "0.2239"; +reflectionDelay = "0.1400"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "0.3981"; +lateReverbDelay = "0.0390"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.2500"; +reverbEchoDepth = "0.2900"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; + +singleton SFXEnvironment(FactoryAlcove) +{ +reverbDensity = "0.3645"; +reverbDiffusion = "0.5900"; +reverbGain = "0.2512"; +reverbGainHF = "0.7943"; +reverbGainLF = "0.5012"; +reverbDecayTime = "3.1400"; +reverbDecayHFRatio = "0.6500"; +reverbDecayLFRatio = "1.3100"; +reflectionsGain = "1.4125"; +reflectionDelay = "0.0100"; +reflectionsPan[ 0 ] = "0.0"; +reflectionsPan[ 1 ] = "0.0"; +reflectionsPan[ 2 ] = "0.0"; +lateReverbGain = "1.0000"; +lateReverbDelay = "0.0380"; +lateReverbPan[ 0 ] = "0.0"; +lateReverbPan[ 1 ] = "0.0"; +lateReverbPan[ 2 ] = "0.0"; +reverbEchoTime = "0.1140"; +reverbEchoDepth = "0.1000"; +reverbModTime = "0.2500"; +reverbModDepth = "0.0000"; +airAbsorbtionGainHF = "0.9943"; +reverbHFRef = "3762.6001"; +reverbLFRef = "362.5000"; +roomRolloffFactor = "0.0000"; +decayHFLimit = "1"; +}; \ No newline at end of file