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

@@ -36,6 +36,8 @@
 #else
 #  include <al/al.h>
 #  include <al/alc.h>
+#  include <AL/alext.h>
+#  include <AL/efx-presets.h>
 #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
 

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]);
+
+   }
+
+}

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_

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

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;
 }
 

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);
+   }
 };
 
 

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);
       }
    }
 

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 ) {}

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);
 }

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.

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 )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvGeneric )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvRoom )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvPaddedCell )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvBathroom )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvLivingRoom )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvStoneRoom )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvAuditorium )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvConcertHall )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvCave )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvArena )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvHangar )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvCarpettedHallway )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvHallway )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvStoneCorridor )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvAlley )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvForest )
-{
-   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;
-};
-
-singleton SFXEnvironment( AudioEnvCity )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvMountains )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvQuary )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvPlain )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvParkingLot )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvSewerPipe )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvUnderwater )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvDrugged )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvDizzy )
-{
-  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;
-};
-
-singleton SFXEnvironment( AudioEnvPsychotic )
-{
-  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;
+singleton SFXEnvironment(Generic) 
+{
+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(PaddedCell) 
+{
+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(PresetRoom) 
+{
+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(PresetBathroom) 
+{
+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(PresetLivingroom) 
+{
+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(PresetStoneroom) 
+{
+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(PresetAuditorium) 
+{
+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(PresetConcerthall) 
+{
+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(PresetCave) 
+{
+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(PresetArena) 
+{
+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(PresetHangar) 
+{
+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(PresetCarpetedHall) 
+{
+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(PresetHallway) 
+{
+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(PresetStoneCorridor) 
+{
+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(PresetStoneAlley)
+{
+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(PresetFroest)
+{
+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(PresetCity)
+{
+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(PresetMountains)
+{
+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(PresetQuarry)
+{
+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(PresetPlain)
+{
+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(PresetParkinglot)
+{
+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(PresetSewerpipe)
+{
+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(PresetUnderwater)
+{
+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(PresetDrugged)
+{
+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(PresetDizzy)
+{
+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(PresetPsychotic)
+{
+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(CastleSmallroom)
+{
+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";
+};