mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-19 20:24:49 +00:00
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
This commit is contained in:
marauder2k7
parent
0b9ac45747
commit
ef9a9da83f
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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]);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -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_
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 ) {}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue