diff --git a/Engine/source/sfx/openal/LoadOAL.h b/Engine/source/sfx/openal/LoadOAL.h index 9b2792657..01455797a 100644 --- a/Engine/source/sfx/openal/LoadOAL.h +++ b/Engine/source/sfx/openal/LoadOAL.h @@ -165,6 +165,13 @@ typedef void (ALAPIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint effectslot, A 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); +// Changes for Filters. +typedef void (ALAPIENTRY* LPALGENFILTERS)(ALsizei n, ALuint* filter); +typedef void (ALAPIENTRY* LPALDELETEFILTERS)(ALsizei n, const ALuint* filters); +typedef void (ALAPIENTRY* LPALFILTERI)(ALuint filter , ALenum param, ALint value); +// Changes for HRTF +typedef const ALCchar* (ALCAPIENTRY* LPALCGETSTRINGISOFT)(ALCdevice* device, ALCenum param, ALint value1); + typedef struct { @@ -261,6 +268,12 @@ typedef struct LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf; LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv; #endif + LPALGENFILTERS alGenFilters; + LPALDELETEFILTERS alDeleteFilters; + LPALFILTERI alFilteri; + + LPALCGETSTRINGISOFT alcGetStringiSOFT; + } OPENALFNTABLE, *LPOPENALFNTABLE; #endif diff --git a/Engine/source/sfx/openal/aldlist.cpp b/Engine/source/sfx/openal/aldlist.cpp index 73307f50b..c9a422050 100644 --- a/Engine/source/sfx/openal/aldlist.cpp +++ b/Engine/source/sfx/openal/aldlist.cpp @@ -44,7 +44,6 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft ) char *devices; int index; const char *defaultDeviceName; - const char *actualDeviceName; dMemcpy( &ALFunction, &oalft, sizeof( OPENALFNTABLE ) ); @@ -55,88 +54,52 @@ ALDeviceList::ALDeviceList( const OPENALFNTABLE &oalft ) defaultDeviceIndex = 0; // grab function pointers for 1.0-API functions, and if successful proceed to enumerate all devices - const bool enumerationExtensionPresent = ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT"); - const bool enumerateAllExtensionPresent = ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT"); - if (enumerateAllExtensionPresent || enumerationExtensionPresent) { - if (enumerateAllExtensionPresent) - { + if (ALFunction.alcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT")) { devices = (char *)ALFunction.alcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER); defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER); - } - else - { - devices = (char *)ALFunction.alcGetString(NULL, ALC_DEVICE_SPECIFIER); - defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER); - } + } + else + { + devices = (char *)ALFunction.alcGetString(NULL, ALC_DEVICE_SPECIFIER); + defaultDeviceName = (char *)ALFunction.alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER); + } - index = 0; + index = 0; // go through device list (each device terminated with a single NULL, list terminated with double NULL) - while (*devices != 0) { - if (String::compare(defaultDeviceName, devices) == 0) { - defaultDeviceIndex = index; - } - ALCdevice *device = ALFunction.alcOpenDevice(devices); - if (device) { - ALCcontext *context = ALFunction.alcCreateContext(device, NULL); - if (context) { - ALFunction.alcMakeContextCurrent(context); - // if new actual device name isn't already in the list, then add it... - actualDeviceName = devices; - bool bNewName = true; - for (int i = 0; i < GetNumDevices(); i++) { - if (String::compare(GetDeviceName(i), actualDeviceName) == 0) { - bNewName = false; - } - } - if ((bNewName) && (actualDeviceName != NULL) && (dStrlen(actualDeviceName) > 0)) { - dMemset(&ALDeviceInfo, 0, sizeof(ALDEVICEINFO)); - ALDeviceInfo.bSelected = true; - dStrncpy(ALDeviceInfo.strDeviceName, actualDeviceName, sizeof(ALDeviceInfo.strDeviceName)); - ALFunction.alcGetIntegerv(device, ALC_MAJOR_VERSION, sizeof(int), &ALDeviceInfo.iMajorVersion); - ALFunction.alcGetIntegerv(device, ALC_MINOR_VERSION, sizeof(int), &ALDeviceInfo.iMinorVersion); - - ALDeviceInfo.iCapsFlags = 0; - - // Check for ALC Extensions - if (ALFunction.alcIsExtensionPresent(device, "ALC_EXT_CAPTURE") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALCapture; - if (ALFunction.alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALEFX; - - // Check for AL Extensions - if (ALFunction.alIsExtensionPresent("AL_EXT_OFFSET") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALOffset; - - if (ALFunction.alIsExtensionPresent("AL_EXT_LINEAR_DISTANCE") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALLinearDistance; - if (ALFunction.alIsExtensionPresent("AL_EXT_EXPONENT_DISTANCE") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALExponentDistance; - - if (ALFunction.alIsExtensionPresent("EAX2.0") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALEAX2; - if (ALFunction.alIsExtensionPresent("EAX3.0") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALEAX3; - if (ALFunction.alIsExtensionPresent("EAX4.0") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALEAX4; - if (ALFunction.alIsExtensionPresent("EAX5.0") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALEAX5; - - if (ALFunction.alIsExtensionPresent("EAX-RAM") == AL_TRUE) - ALDeviceInfo.iCapsFlags |= SFXALEAXRAM; - - // Get Source Count - ALDeviceInfo.uiSourceCount = GetMaxNumSources(); - - vDeviceInfo.push_back(ALDeviceInfo); - } - ALFunction.alcMakeContextCurrent(NULL); - ALFunction.alcDestroyContext(context); - } - ALFunction.alcCloseDevice(device); - } - devices += dStrlen(devices) + 1; - index += 1; + while (*devices != 0) { + if (String::compare(defaultDeviceName, devices) == 0) { + defaultDeviceIndex = index; } + + bool bNewName = true; + for (int i = 0; i < GetNumDevices(); i++) { + if (String::compare(GetDeviceName(i), devices) == 0) { + bNewName = false; + } + } + + if ((bNewName) && (devices != NULL) && (dStrlen(devices) > 0)) + { + dMemset(&ALDeviceInfo, 0, sizeof(ALDEVICEINFO)); + ALDeviceInfo.bSelected = true; + dStrncpy(ALDeviceInfo.strInternalDeviceName, devices, sizeof(ALDeviceInfo.strInternalDeviceName)); + char* openFind = dStrchr(devices, '('); + if (openFind) + { + devices = openFind + 1; + char* closeFind = dStrchr(devices, ')'); + if (closeFind) + (*closeFind) = '\0'; + + dStrncpy(ALDeviceInfo.strDeviceName, devices, sizeof(ALDeviceInfo.strDeviceName)); + + } + + vDeviceInfo.push_back(ALDeviceInfo); + } + + devices += dStrlen(devices) + 1; + index += 1; } ResetFilters(); @@ -160,14 +123,23 @@ int ALDeviceList::GetNumDevices() /* * Returns the device name at an index in the complete device list */ -const char *ALDeviceList::GetDeviceName(int index) +const char *ALDeviceList::GetInternalDeviceName(int index) { if (index < GetNumDevices()) - return vDeviceInfo[index].strDeviceName; + return vDeviceInfo[index].strInternalDeviceName; else return NULL; } +const char* ALDeviceList::GetDeviceName(int index) +{ + if (index < GetNumDevices()) + return vDeviceInfo[index].strDeviceName; + else + return NULL; +} + + /* * Returns the major and minor version numbers for a device at a specified index in the complete list */ diff --git a/Engine/source/sfx/openal/aldlist.h b/Engine/source/sfx/openal/aldlist.h index 3b2d7e948..7927914cf 100644 --- a/Engine/source/sfx/openal/aldlist.h +++ b/Engine/source/sfx/openal/aldlist.h @@ -32,11 +32,12 @@ typedef struct { char strDeviceName[256]; + char strInternalDeviceName[256]; S32 iMajorVersion; S32 iMinorVersion; - U32 uiSourceCount; - S32 iCapsFlags; - bool bSelected; + U32 uiSourceCount; + S32 iCapsFlags; + bool bSelected; } ALDEVICEINFO, *LPALDEVICEINFO; class ALDeviceList @@ -52,6 +53,7 @@ public: ~ALDeviceList (); S32 GetNumDevices(); const char *GetDeviceName(S32 index); + const char *GetInternalDeviceName(S32 index); void GetDeviceVersion(S32 index, S32 *major, S32 *minor); U32 GetMaxNumSources(S32 index); bool IsExtensionSupported(S32 index, SFXALCaps caps); diff --git a/Engine/source/sfx/openal/sfxALDevice.cpp b/Engine/source/sfx/openal/sfxALDevice.cpp index 9dd308c58..cab3ea99f 100644 --- a/Engine/source/sfx/openal/sfxALDevice.cpp +++ b/Engine/source/sfx/openal/sfxALDevice.cpp @@ -24,6 +24,201 @@ #include "sfx/openal/sfxALBuffer.h" #include "platform/async/asyncUpdate.h" +//---------------------------------------------------------------------------- +// STATIC OPENAL FUNCTIONS +//---------------------------------------------------------------------------- +void SFXALDevice::printALInfo(ALCdevice* device) +{ + ALCint major, minor; + if (device) + { + const ALCchar* devname = NULL; + Con::printBlankLine(); + + if (mOpenAL.alcIsExtensionPresent(device, "ALC_ENUMERATE_ALL_EXT") != AL_FALSE) + { + devname = mOpenAL.alcGetString(device, ALC_ALL_DEVICES_SPECIFIER); + } + else + { + devname = mOpenAL.alcGetString(device, ALC_DEVICE_SPECIFIER); + } + + Con::printf("| Device info for: %s ", devname); + } + + mOpenAL.alcGetIntegerv(device, ALC_MAJOR_VERSION, 1, &major); + mOpenAL.alcGetIntegerv(device, ALC_MINOR_VERSION, 1, &minor); + Con::printf("| OpenAL Version: %d.%d", major, minor); + + if (device) + { + Con::printf("%s", mOpenAL.alcGetString(device, ALC_EXTENSIONS)); + + U32 err = mOpenAL.alcGetError(device); + if (err != ALC_NO_ERROR) + Con::errorf("SFXALDevice - Error Retrieving ALC Extensions: %s", mOpenAL.alcGetString(device, err)); + } + +} + +void SFXALDevice::printHRTFInfo(ALCdevice* device) +{ + if (mOpenAL.alcIsExtensionPresent(device, "ALC_SOFT_HRTF") == AL_FALSE) + { + Con::printf("HRTF Extensions not compatible"); + return; + } + + ALCint numHrtfs; + + mOpenAL.alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &numHrtfs); + if (!numHrtfs) + Con::printf("No HRTFs Found"); + else + { + Con::printf("Available HRTFs"); + for (U32 i = 0; i < numHrtfs; ++i) + { + const ALCchar* name = mOpenAL.alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i); + printf(" %s", name); + } + } + + U32 err = mOpenAL.alcGetError(device); + if (err != ALC_NO_ERROR) + Con::errorf("SFXALDevice - Error Retrieving HRTF info: %s", mOpenAL.alcGetString(device, err)); + +} + +void SFXALDevice::getEFXInfo(ALCdevice *device) +{ + static const ALint filters[] = { + AL_FILTER_LOWPASS, AL_FILTER_HIGHPASS, AL_FILTER_BANDPASS, + AL_FILTER_NULL + }; + + char filterNames[] = "Low-pass,High-pass,Band-pass,"; + static const ALint effects[] = { + AL_EFFECT_EAXREVERB, AL_EFFECT_REVERB, AL_EFFECT_CHORUS, + AL_EFFECT_DISTORTION, AL_EFFECT_ECHO, AL_EFFECT_FLANGER, + AL_EFFECT_FREQUENCY_SHIFTER, AL_EFFECT_VOCAL_MORPHER, + AL_EFFECT_PITCH_SHIFTER, AL_EFFECT_RING_MODULATOR, + AL_EFFECT_AUTOWAH, AL_EFFECT_COMPRESSOR, AL_EFFECT_EQUALIZER, + AL_EFFECT_NULL + }; + static const ALint dedeffects[] = { + AL_EFFECT_DEDICATED_DIALOGUE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT, + AL_EFFECT_NULL + }; + char effectNames[] = "EAX Reverb,Reverb,Chorus,Distortion,Echo,Flanger," + "Frequency Shifter,Vocal Morpher,Pitch Shifter,Ring Modulator,Autowah," + "Compressor,Equalizer,Dedicated Dialog,Dedicated LFE,"; + + ALCint major, minor, sends; + ALuint obj; + + char* current; + U32 i; + + if (mOpenAL.alcIsExtensionPresent(device, "ALC_EXT_EFX") == AL_FALSE) + { + Con::printf("SFXALDevice - EFX Not available."); + return; + } + + mOpenAL.alcGetIntegerv(device, ALC_EFX_MAJOR_VERSION, 1, &major); + mOpenAL.alcGetIntegerv(device, ALC_EFX_MINOR_VERSION, 1, &minor); + U32 err = mOpenAL.alcGetError(device); + if (err != ALC_NO_ERROR) + Con::errorf("SFXALDevice - Error Retrieving EFX Version: %s", mOpenAL.alcGetString(device, err)); + else + { + Con::printf("| EFX Version: %d.%d", major, minor); + } + + mOpenAL.alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1, &sends); + err = mOpenAL.alcGetError(device); + if (err != ALC_NO_ERROR) + Con::errorf("SFXALDevice - Error Retrieving Auxiliary Sends: %s", mOpenAL.alcGetString(device, err)); + else + { + Con::printf("| Max Aux Sends: %d", sends); + } + + mOpenAL.alGenFilters(1, &obj); + err = mOpenAL.alcGetError(device); + if (err != ALC_NO_ERROR) + Con::errorf("SFXALDevice - Error Generating filter: %s", mOpenAL.alcGetString(device, err)); + + current = filterNames; + for (i = 0; filters[i] != AL_FILTER_NULL; i++) + { + char* next = dStrchr(current, ','); + + mOpenAL.alFilteri(obj, AL_FILTER_TYPE, filters[i]); + if (mOpenAL.alGetError() != AL_NO_ERROR) + dMemmove(current, next + 1, strlen(next)); + else + current = next + 1; + } + + Con::printf("| Supported Filters: %s", filterNames); + + mOpenAL.alDeleteFilters(1, &obj); + + mOpenAL.alGenEffects(1, &obj); + err = mOpenAL.alcGetError(device); + if (err != ALC_NO_ERROR) + Con::errorf("SFXALDevice - Error Generating effects: %s", mOpenAL.alcGetString(device, err)); + + current = effectNames; + for (i = 0; effects[i] != AL_EFFECT_NULL; i++) + { + char* next = dStrchr(current, ','); + mOpenAL.alEffecti(obj, AL_FILTER_TYPE, effects[i]); + if (mOpenAL.alGetError() != AL_NO_ERROR) + dMemmove(current, next + 1, strlen(next)); + else + current = next + 1; + } + + if (mOpenAL.alcIsExtensionPresent(device, "ALC_EXT_DEDICATED")) + { + for (i = 0; dedeffects[i] != AL_EFFECT_NULL; i++) + { + char* next = dStrchr(current, ','); + mOpenAL.alEffecti(obj, AL_FILTER_TYPE, dedeffects[i]); + if (mOpenAL.alGetError() != AL_NO_ERROR) + dMemmove(current, next + 1, strlen(next)); + else + current = next + 1; + } + } + else + { + for (i = 0; dedeffects[i] != AL_EFFECT_NULL; i++) + { + char* next = dStrchr(current, ','); + dMemmove(current, next + 1, strlen(next)); + } + } + + Con::printf("| Supported Effects: %s", effectNames); + + mOpenAL.alDeleteEffects(1, &obj); +} + +S32 SFXALDevice::getMaxSources() +{ + // Clear AL Error Code + mOpenAL.alGetError(); + + ALCint nummono; + mOpenAL.alcGetIntegerv(mDevice, ALC_MONO_SOURCES, 1, &nummono); + + return nummono; +} //----------------------------------------------------------------------------- @@ -53,21 +248,27 @@ SFXALDevice::SFXALDevice( SFXProvider *provider, #endif attribs[1] = 4; + printALInfo(NULL); + mDevice = mOpenAL.alcOpenDevice( name ); - mOpenAL.alcGetError( mDevice ); + U32 err = mOpenAL.alcGetError(mDevice); + if (err != ALC_NO_ERROR) + Con::errorf("SFXALDevice - Device Initialization Error: %s", mOpenAL.alcGetString(mDevice, err)); + if( mDevice ) { mContext = mOpenAL.alcCreateContext( mDevice, attribs ); if( mContext ) mOpenAL.alcMakeContextCurrent( mContext ); + #if defined(AL_ALEXT_PROTOTYPES) mOpenAL.alcGetIntegerv(mDevice, ALC_MAX_AUXILIARY_SENDS, 1, &iSends); #endif U32 err = mOpenAL.alcGetError( mDevice ); if( err != ALC_NO_ERROR ) - Con::errorf( "SFXALDevice - Initialization Error: %s", mOpenAL.alcGetString( mDevice, err ) ); + Con::errorf( "SFXALDevice - Context Initialization Error: %s", mOpenAL.alcGetString( mDevice, err ) ); } AssertFatal( mDevice != NULL && mContext != NULL, "Failed to create OpenAL device and/or context!" ); @@ -89,6 +290,16 @@ SFXALDevice::SFXALDevice( SFXProvider *provider, dMemset(effect, 0, sizeof(effect)); uLoop = 0; #endif + + printALInfo(mDevice); + printHRTFInfo(mDevice); + getEFXInfo(mDevice); + + mMaxBuffers = getMaxSources(); + + // this should be max sources. + Con::printf("| Max Sources: %d", mMaxBuffers); + } //----------------------------------------------------------------------------- diff --git a/Engine/source/sfx/openal/sfxALDevice.h b/Engine/source/sfx/openal/sfxALDevice.h index d6aa7ea82..f4d7374c6 100644 --- a/Engine/source/sfx/openal/sfxALDevice.h +++ b/Engine/source/sfx/openal/sfxALDevice.h @@ -53,7 +53,12 @@ class SFXALDevice : public SFXDevice typedef SFXDevice Parent; friend class SFXALVoice; // mDistanceFactor, mRolloffFactor - SFXALDevice( SFXProvider *provider, + void printALInfo(ALCdevice* device); + void printHRTFInfo(ALCdevice* device); + void getEFXInfo(ALCdevice* device); + S32 getMaxSources(); + + SFXALDevice( SFXProvider *provider, const OPENALFNTABLE &openal, String name, bool useHardware, diff --git a/Engine/source/sfx/openal/sfxALProvider.cpp b/Engine/source/sfx/openal/sfxALProvider.cpp index df4e4f206..4f3e30aff 100644 --- a/Engine/source/sfx/openal/sfxALProvider.cpp +++ b/Engine/source/sfx/openal/sfxALProvider.cpp @@ -98,28 +98,9 @@ void SFXALProvider::init() { ALDeviceInfo* info = new ALDeviceInfo; + info->internalName = String( mALDL->GetInternalDeviceName( i ) ); info->name = String( mALDL->GetDeviceName( i ) ); - S32 major, minor, eax = 0; - - mALDL->GetDeviceVersion( i, &major, &minor ); - - // Apologies for the blatent enum hack -patw - for( S32 j = SFXALEAX2; j < SFXALEAXRAM; j++ ) - eax += (int)mALDL->IsExtensionSupported( i, (SFXALCaps)j ); - - if( eax > 0 ) - { - eax += 2; // EAX support starts at 2.0 - dSprintf( temp, sizeof( temp ), "[EAX %d.0] %s", eax, ( mALDL->IsExtensionSupported( i, SFXALEAXRAM ) ? "EAX-RAM" : "" ) ); - } - else - dStrcpy( temp, "", 256 ); - - info->driver = String::ToString( deviceFormat, major, minor, temp ); - info->hasHardware = eax > 0; - info->maxBuffers = mALDL->GetMaxNumSources( i ); - mDeviceInfo.push_back( info ); } @@ -141,7 +122,7 @@ SFXDevice *SFXALProvider::createDevice( const String& deviceName, bool useHardwa // Do we find one to create? if (info) - return new SFXALDevice(this, mOpenAL, info->name, useHardware, maxBuffers); + return new SFXALDevice(this, mOpenAL, info->internalName, useHardware, maxBuffers); return NULL; } diff --git a/Engine/source/sfx/openal/win32/LoadOAL.cpp b/Engine/source/sfx/openal/win32/LoadOAL.cpp index f591c7477..14ad3f044 100644 --- a/Engine/source/sfx/openal/win32/LoadOAL.cpp +++ b/Engine/source/sfx/openal/win32/LoadOAL.cpp @@ -552,6 +552,35 @@ ALboolean LoadOAL10Library(char *szOALFullPathName, LPOPENALFNTABLE lpOALFnTable OutputDebugStringA("Failed to retrieve 'alGetAuxiliaryEffectSlotiv' function address\n"); } lpOALFnTable->alSource3i = (LPALSOURCE3I)GetProcAddress(g_hOpenALDLL, "alSource3i"); + + lpOALFnTable->alGenFilters = (LPALGENFILTERS)GetProcAddress(g_hOpenALDLL, "alGenFilters"); + if (lpOALFnTable->alGenFilters == NULL) + { + OutputDebugStringA("Failed to retrieve 'alGenFilters' function address\n"); + return AL_FALSE; + } + + lpOALFnTable->alDeleteFilters = (LPALDELETEFILTERS)GetProcAddress(g_hOpenALDLL, "alDeleteFilters"); + if (lpOALFnTable->alGenFilters == NULL) + { + OutputDebugStringA("Failed to retrieve 'alDeleteFilters' function address\n"); + return AL_FALSE; + } + + lpOALFnTable->alFilteri = (LPALFILTERI)GetProcAddress(g_hOpenALDLL, "alFilteri"); + if (lpOALFnTable->alGenFilters == NULL) + { + OutputDebugStringA("Failed to retrieve 'alFilteri' function address\n"); + return AL_FALSE; + } + + lpOALFnTable->alcGetStringiSOFT = (LPALCGETSTRINGISOFT)GetProcAddress(g_hOpenALDLL, "alcGetStringiSOFT"); + if (lpOALFnTable->alcGetStringiSOFT == NULL) + { + OutputDebugStringA("Failed to retrieve 'alcGetStringiSOFT' function address\n"); + return AL_FALSE; + } + #endif return AL_TRUE; } diff --git a/Engine/source/sfx/sfxProvider.h b/Engine/source/sfx/sfxProvider.h index 7cf3408db..6382f92c5 100644 --- a/Engine/source/sfx/sfxProvider.h +++ b/Engine/source/sfx/sfxProvider.h @@ -35,6 +35,7 @@ class SFXDevice; struct SFXDeviceInfo { String driver; + String internalName; String name; bool hasHardware; S32 maxBuffers; @@ -121,4 +122,4 @@ class SFXProvider }; -#endif // _SFXPROVIDER_H_ \ No newline at end of file +#endif // _SFXPROVIDER_H_ diff --git a/Engine/source/sfx/sfxSystem.cpp b/Engine/source/sfx/sfxSystem.cpp index 9c864842f..a08c05ab6 100644 --- a/Engine/source/sfx/sfxSystem.cpp +++ b/Engine/source/sfx/sfxSystem.cpp @@ -1264,7 +1264,8 @@ DefineEngineFunction( sfxGetAvailableDevices, const char*, (),, { const SFXDeviceInfo* info = deviceInfo[d]; const char *providerName = provider->getName().c_str(); - const char *infoName = info->name.c_str(); + char *infoName = (char*)info->name.c_str(); + dSprintf(ptr, len, "%s\t%s\t%s\t%i\n", providerName, infoName, info->hasHardware ? "1" : "0", info->maxBuffers); ptr += dStrlen(ptr);