diff options
author | Joerg Mueller <nexyon@gmail.com> | 2010-07-31 02:20:08 +0400 |
---|---|---|
committer | Joerg Mueller <nexyon@gmail.com> | 2010-07-31 02:20:08 +0400 |
commit | c59b930d135ce7527542da96d1984842cf5e42ff (patch) | |
tree | 1aa694ab37b0441c75d87d9d376c3a4e0aed3445 /intern/audaspace | |
parent | 3ff872bf593f9f4716a21f3be20a13ed136708f2 (diff) |
Audaspace: Refactored the complete 3D Device code giving a nicer API.
Diffstat (limited to 'intern/audaspace')
-rw-r--r-- | intern/audaspace/OpenAL/AUD_OpenALDevice.cpp | 549 | ||||
-rw-r--r-- | intern/audaspace/OpenAL/AUD_OpenALDevice.h | 45 | ||||
-rw-r--r-- | intern/audaspace/Python/AUD_PyAPI.cpp | 699 | ||||
-rw-r--r-- | intern/audaspace/intern/AUD_3DMath.h | 189 | ||||
-rw-r--r-- | intern/audaspace/intern/AUD_C-API.cpp | 244 | ||||
-rw-r--r-- | intern/audaspace/intern/AUD_C-API.h | 151 | ||||
-rw-r--r-- | intern/audaspace/intern/AUD_I3DDevice.h | 289 | ||||
-rw-r--r-- | intern/audaspace/intern/AUD_IDevice.h | 4 | ||||
-rw-r--r-- | intern/audaspace/intern/AUD_Space.h | 51 |
9 files changed, 1615 insertions, 606 deletions
diff --git a/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp b/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp index 4d908261ae8..6d1f9a5527b 100644 --- a/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp +++ b/intern/audaspace/OpenAL/AUD_OpenALDevice.cpp @@ -1099,214 +1099,447 @@ bool AUD_OpenALDevice::bufferFactory(void *value) /**************************** 3D Device Code **********************************/ /******************************************************************************/ -AUD_Handle* AUD_OpenALDevice::play3D(AUD_IFactory* factory, bool keep) +AUD_Vector3 AUD_OpenALDevice::getListenerLocation() const { - AUD_OpenALHandle* handle = (AUD_OpenALHandle*)play(factory, keep); - if(handle) - alSourcei(handle->source, AL_SOURCE_RELATIVE, 0); - return handle; + ALfloat p[3]; + alGetListenerfv(AL_POSITION, p); + return AUD_Vector3(p[0], p[1], p[2]); } -bool AUD_OpenALDevice::updateListener(AUD_3DData &data) +void AUD_OpenALDevice::setListenerLocation(const AUD_Vector3& location) { - alListenerfv(AL_POSITION, (ALfloat*)data.position); - alListenerfv(AL_VELOCITY, (ALfloat*)data.velocity); - alListenerfv(AL_ORIENTATION, (ALfloat*)&(data.orientation[3])); + alListenerfv(AL_POSITION, (ALfloat*)location.get()); +} - return true; +AUD_Vector3 AUD_OpenALDevice::getListenerVelocity() const +{ + ALfloat v[3]; + alGetListenerfv(AL_VELOCITY, v); + return AUD_Vector3(v[0], v[1], v[2]); +} + +void AUD_OpenALDevice::setListenerVelocity(const AUD_Vector3& velocity) +{ + alListenerfv(AL_VELOCITY, (ALfloat*)velocity.get()); +} + +AUD_Quaternion AUD_OpenALDevice::getListenerOrientation() const +{ + // AUD_XXX not implemented yet + return AUD_Quaternion(0, 0, 0, 0); +} + +void AUD_OpenALDevice::setListenerOrientation(const AUD_Quaternion& orientation) +{ + ALfloat direction[6]; + direction[0] = -2 * (orientation.w() * orientation.y() + + orientation.x() * orientation.z()); + direction[1] = 2 * (orientation.x() * orientation.w() - + orientation.z() * orientation.y()); + direction[2] = 2 * (orientation.x() * orientation.x() + + orientation.y() * orientation.y()) - 1; + direction[3] = 2 * (orientation.x() * orientation.y() - + orientation.w() * orientation.z()); + direction[4] = 1 - 2 * (orientation.x() * orientation.x() + + orientation.z() * orientation.z()); + direction[5] = 2 * (orientation.w() * orientation.x() + + orientation.y() * orientation.z()); + alListenerfv(AL_ORIENTATION, direction); +} + +float AUD_OpenALDevice::getSpeedOfSound() const +{ + return alGetFloat(AL_SPEED_OF_SOUND); +} + +void AUD_OpenALDevice::setSpeedOfSound(float speed) +{ + alSpeedOfSound(speed); } -bool AUD_OpenALDevice::setSetting(AUD_3DSetting setting, float value) +float AUD_OpenALDevice::getDopplerFactor() const { - switch(setting) + return alGetFloat(AL_DOPPLER_FACTOR); +} + +void AUD_OpenALDevice::setDopplerFactor(float factor) +{ + alDopplerFactor(factor); +} + +AUD_DistanceModel AUD_OpenALDevice::getDistanceModel() const +{ + switch(alGetInteger(AL_DISTANCE_MODEL)) { - case AUD_3DS_DISTANCE_MODEL: - if(value == AUD_DISTANCE_MODEL_NONE) - alDistanceModel(AL_NONE); - else if(value == AUD_DISTANCE_MODEL_INVERSE) - alDistanceModel(AL_INVERSE_DISTANCE); - else if(value == AUD_DISTANCE_MODEL_INVERSE_CLAMPED) - alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED); - else if(value == AUD_DISTANCE_MODEL_LINEAR) - alDistanceModel(AL_LINEAR_DISTANCE); - else if(value == AUD_DISTANCE_MODEL_LINEAR_CLAMPED) - alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED); - else if(value == AUD_DISTANCE_MODEL_EXPONENT) - alDistanceModel(AL_EXPONENT_DISTANCE); - else if(value == AUD_DISTANCE_MODEL_EXPONENT_CLAMPED) - alDistanceModel(AL_EXPONENT_DISTANCE_CLAMPED); - else - return false; - return true; - case AUD_3DS_DOPPLER_FACTOR: - alDopplerFactor(value); - return true; - case AUD_3DS_SPEED_OF_SOUND: - alSpeedOfSound(value); - return true; + case AL_INVERSE_DISTANCE: + return AUD_DISTANCE_MODEL_INVERSE; + case AL_INVERSE_DISTANCE_CLAMPED: + return AUD_DISTANCE_MODEL_INVERSE_CLAMPED; + case AL_LINEAR_DISTANCE: + return AUD_DISTANCE_MODEL_LINEAR; + case AL_LINEAR_DISTANCE_CLAMPED: + return AUD_DISTANCE_MODEL_LINEAR_CLAMPED; + case AL_EXPONENT_DISTANCE: + return AUD_DISTANCE_MODEL_EXPONENT; + case AL_EXPONENT_DISTANCE_CLAMPED: + return AUD_DISTANCE_MODEL_EXPONENT_CLAMPED; default: - return false; + return AUD_DISTANCE_MODEL_INVALID; } } -float AUD_OpenALDevice::getSetting(AUD_3DSetting setting) +void AUD_OpenALDevice::setDistanceModel(AUD_DistanceModel model) { - switch(setting) + switch(model) { - case AUD_3DS_DISTANCE_MODEL: - switch(alGetInteger(AL_DISTANCE_MODEL)) - { - case AL_NONE: - return AUD_DISTANCE_MODEL_NONE; - case AL_INVERSE_DISTANCE: - return AUD_DISTANCE_MODEL_INVERSE; - case AL_INVERSE_DISTANCE_CLAMPED: - return AUD_DISTANCE_MODEL_INVERSE_CLAMPED; - case AL_LINEAR_DISTANCE: - return AUD_DISTANCE_MODEL_LINEAR; - case AL_LINEAR_DISTANCE_CLAMPED: - return AUD_DISTANCE_MODEL_LINEAR_CLAMPED; - case AL_EXPONENT_DISTANCE: - return AUD_DISTANCE_MODEL_EXPONENT; - case AL_EXPONENT_DISTANCE_CLAMPED: - return AUD_DISTANCE_MODEL_EXPONENT_CLAMPED; - } - case AUD_3DS_DOPPLER_FACTOR: - return alGetFloat(AL_DOPPLER_FACTOR); - case AUD_3DS_SPEED_OF_SOUND: - return alGetFloat(AL_SPEED_OF_SOUND); + case AUD_DISTANCE_MODEL_INVERSE: + alDistanceModel(AL_INVERSE_DISTANCE); + break; + case AUD_DISTANCE_MODEL_INVERSE_CLAMPED: + alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED); + break; + case AUD_DISTANCE_MODEL_LINEAR: + alDistanceModel(AL_LINEAR_DISTANCE); + break; + case AUD_DISTANCE_MODEL_LINEAR_CLAMPED: + alDistanceModel(AL_LINEAR_DISTANCE_CLAMPED); + break; + case AUD_DISTANCE_MODEL_EXPONENT: + alDistanceModel(AL_EXPONENT_DISTANCE); + break; + case AUD_DISTANCE_MODEL_EXPONENT_CLAMPED: + alDistanceModel(AL_EXPONENT_DISTANCE_CLAMPED); + break; default: - return std::numeric_limits<float>::quiet_NaN(); + alDistanceModel(AL_NONE); } } -bool AUD_OpenALDevice::updateSource(AUD_Handle* handle, AUD_3DData &data) +AUD_Vector3 AUD_OpenALDevice::getSourceLocation(AUD_Handle* handle) { - bool result = false; - + AUD_Vector3 result = AUD_Vector3(0, 0, 0); + ALfloat p[3]; lock(); if(isValid(handle)) { - int source = ((AUD_OpenALHandle*)handle)->source; - alSourcefv(source, AL_POSITION, (ALfloat*)data.position); - alSourcefv(source, AL_VELOCITY, (ALfloat*)data.velocity); - alSourcefv(source, AL_DIRECTION, (ALfloat*)&(data.orientation[3])); - result = true; + alGetSourcefv(((AUD_OpenALHandle*)handle)->source, AL_POSITION, p); + result = AUD_Vector3(p[0], p[1], p[2]); } unlock(); - return result; } -bool AUD_OpenALDevice::setSourceSetting(AUD_Handle* handle, - AUD_3DSourceSetting setting, - float value) +bool AUD_OpenALDevice::setSourceLocation(AUD_Handle* handle, const AUD_Vector3& location) { lock(); + bool result = isValid(handle); - bool result = false; + if(result) + alSourcefv(((AUD_OpenALHandle*)handle)->source, AL_POSITION, + (ALfloat*)location.get()); + + unlock(); + return result; +} + +AUD_Vector3 AUD_OpenALDevice::getSourceVelocity(AUD_Handle* handle) +{ + AUD_Vector3 result = AUD_Vector3(0, 0, 0); + ALfloat v[3]; + lock(); if(isValid(handle)) { - int source = ((AUD_OpenALHandle*)handle)->source; + alGetSourcefv(((AUD_OpenALHandle*)handle)->source, AL_VELOCITY, v); + result = AUD_Vector3(v[0], v[1], v[2]); + } - switch(setting) - { - case AUD_3DSS_CONE_INNER_ANGLE: - alSourcef(source, AL_CONE_INNER_ANGLE, value); - result = true; - break; - case AUD_3DSS_CONE_OUTER_ANGLE: - alSourcef(source, AL_CONE_OUTER_ANGLE, value); - result = true; - break; - case AUD_3DSS_CONE_OUTER_GAIN: - alSourcef(source, AL_CONE_OUTER_GAIN, value); - result = true; - break; - case AUD_3DSS_IS_RELATIVE: - alSourcei(source, AL_SOURCE_RELATIVE, value > 0.0f); - result = true; - break; - case AUD_3DSS_MAX_DISTANCE: - alSourcef(source, AL_MAX_DISTANCE, value); - result = true; - break; - case AUD_3DSS_MAX_GAIN: - alSourcef(source, AL_MAX_GAIN, value); - result = true; - break; - case AUD_3DSS_MIN_GAIN: - alSourcef(source, AL_MIN_GAIN, value); - result = true; - break; - case AUD_3DSS_REFERENCE_DISTANCE: - alSourcef(source, AL_REFERENCE_DISTANCE, value); - result = true; - break; - case AUD_3DSS_ROLLOFF_FACTOR: - alSourcef(source, AL_ROLLOFF_FACTOR, value); - result = true; - break; - default: - break; - } + unlock(); + return result; +} + +bool AUD_OpenALDevice::setSourceVelocity(AUD_Handle* handle, const AUD_Vector3& velocity) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcefv(((AUD_OpenALHandle*)handle)->source, AL_VELOCITY, + (ALfloat*)velocity.get()); + + unlock(); + return result; +} + +AUD_Quaternion AUD_OpenALDevice::getSourceOrientation(AUD_Handle* handle) +{ + // AUD_XXX not implemented yet + return AUD_Quaternion(0, 0, 0, 0); +} + +bool AUD_OpenALDevice::setSourceOrientation(AUD_Handle* handle, const AUD_Quaternion& orientation) +{ + lock(); + bool result = isValid(handle); + + if(result) + { + ALfloat direction[3]; + direction[0] = -2 * (orientation.w() * orientation.y() + + orientation.x() * orientation.z()); + direction[1] = 2 * (orientation.x() * orientation.w() - + orientation.z() * orientation.y()); + direction[2] = 2 * (orientation.x() * orientation.x() + + orientation.y() * orientation.y()) - 1; + alSourcefv(((AUD_OpenALHandle*)handle)->source, AL_DIRECTION, + direction); } unlock(); return result; } -float AUD_OpenALDevice::getSourceSetting(AUD_Handle* handle, - AUD_3DSourceSetting setting) +bool AUD_OpenALDevice::isRelative(AUD_Handle* handle) +{ + int result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcei(((AUD_OpenALHandle*)handle)->source, AL_SOURCE_RELATIVE, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setRelative(AUD_Handle* handle, bool relative) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcei(((AUD_OpenALHandle*)handle)->source, AL_SOURCE_RELATIVE, + relative); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getVolumeMaximum(AUD_Handle* handle) { float result = std::numeric_limits<float>::quiet_NaN();; lock(); if(isValid(handle)) - { - int source = ((AUD_OpenALHandle*)handle)->source; + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_MAX_GAIN, + &result); - switch(setting) - { - case AUD_3DSS_CONE_INNER_ANGLE: - alGetSourcef(source, AL_CONE_INNER_ANGLE, &result); - break; - case AUD_3DSS_CONE_OUTER_ANGLE: - alGetSourcef(source, AL_CONE_OUTER_ANGLE, &result); - break; - case AUD_3DSS_CONE_OUTER_GAIN: - alGetSourcef(source, AL_CONE_OUTER_GAIN, &result); - break; - case AUD_3DSS_IS_RELATIVE: - { - ALint i; - alGetSourcei(source, AL_SOURCE_RELATIVE, &i); - result = i ? 1.0f : 0.0f; - break; - } - case AUD_3DSS_MAX_DISTANCE: - alGetSourcef(source, AL_MAX_DISTANCE, &result); - break; - case AUD_3DSS_MAX_GAIN: - alGetSourcef(source, AL_MAX_GAIN, &result); - break; - case AUD_3DSS_MIN_GAIN: - alGetSourcef(source, AL_MIN_GAIN, &result); - break; - case AUD_3DSS_REFERENCE_DISTANCE: - alGetSourcef(source, AL_REFERENCE_DISTANCE, &result); - break; - case AUD_3DSS_ROLLOFF_FACTOR: - alGetSourcef(source, AL_ROLLOFF_FACTOR, &result); - break; - default: - break; - } - } + unlock(); + return result; +} + +bool AUD_OpenALDevice::setVolumeMaximum(AUD_Handle* handle, float volume) +{ + lock(); + bool result = isValid(handle); + + if(result) + + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_MAX_GAIN, + volume); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getVolumeMinimum(AUD_Handle* handle) +{ + float result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_MIN_GAIN, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setVolumeMinimum(AUD_Handle* handle, float volume) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_MIN_GAIN, + volume); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getDistanceMaximum(AUD_Handle* handle) +{ + float result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_MAX_DISTANCE, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setDistanceMaximum(AUD_Handle* handle, float distance) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_MAX_DISTANCE, + distance); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getDistanceReference(AUD_Handle* handle) +{ + float result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_REFERENCE_DISTANCE, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setDistanceReference(AUD_Handle* handle, float distance) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_REFERENCE_DISTANCE, + distance); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getAttenuation(AUD_Handle* handle) +{ + float result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_ROLLOFF_FACTOR, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setAttenuation(AUD_Handle* handle, float factor) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_ROLLOFF_FACTOR, + factor); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getConeAngleOuter(AUD_Handle* handle) +{ + float result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_CONE_OUTER_ANGLE, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setConeAngleOuter(AUD_Handle* handle, float angle) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_CONE_OUTER_ANGLE, + angle); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getConeAngleInner(AUD_Handle* handle) +{ + float result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_CONE_INNER_ANGLE, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setConeAngleInner(AUD_Handle* handle, float angle) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_CONE_INNER_ANGLE, + angle); + + unlock(); + return result; +} + +float AUD_OpenALDevice::getConeVolumeOuter(AUD_Handle* handle) +{ + float result = std::numeric_limits<float>::quiet_NaN();; + + lock(); + + if(isValid(handle)) + alGetSourcef(((AUD_OpenALHandle*)handle)->source, AL_CONE_OUTER_GAIN, + &result); + + unlock(); + return result; +} + +bool AUD_OpenALDevice::setConeVolumeOuter(AUD_Handle* handle, float volume) +{ + lock(); + bool result = isValid(handle); + + if(result) + alSourcef(((AUD_OpenALHandle*)handle)->source, AL_CONE_OUTER_GAIN, + volume); unlock(); return result; diff --git a/intern/audaspace/OpenAL/AUD_OpenALDevice.h b/intern/audaspace/OpenAL/AUD_OpenALDevice.h index fa8f7c55134..cba031f25f9 100644 --- a/intern/audaspace/OpenAL/AUD_OpenALDevice.h +++ b/intern/audaspace/OpenAL/AUD_OpenALDevice.h @@ -159,15 +159,42 @@ public: virtual float getPitch(AUD_Handle* handle); virtual bool setPitch(AUD_Handle* handle, float pitch); - virtual AUD_Handle* play3D(AUD_IFactory* factory, bool keep = false); - virtual bool updateListener(AUD_3DData &data); - virtual bool setSetting(AUD_3DSetting setting, float value); - virtual float getSetting(AUD_3DSetting setting); - virtual bool updateSource(AUD_Handle* handle, AUD_3DData &data); - virtual bool setSourceSetting(AUD_Handle* handle, - AUD_3DSourceSetting setting, float value); - virtual float getSourceSetting(AUD_Handle* handle, - AUD_3DSourceSetting setting); + virtual AUD_Vector3 getListenerLocation() const; + virtual void setListenerLocation(const AUD_Vector3& location); + virtual AUD_Vector3 getListenerVelocity() const; + virtual void setListenerVelocity(const AUD_Vector3& velocity); + virtual AUD_Quaternion getListenerOrientation() const; + virtual void setListenerOrientation(const AUD_Quaternion& orientation); + virtual float getSpeedOfSound() const; + virtual void setSpeedOfSound(float speed); + virtual float getDopplerFactor() const; + virtual void setDopplerFactor(float factor); + virtual AUD_DistanceModel getDistanceModel() const; + virtual void setDistanceModel(AUD_DistanceModel model); + virtual AUD_Vector3 getSourceLocation(AUD_Handle* handle); + virtual bool setSourceLocation(AUD_Handle* handle, const AUD_Vector3& location); + virtual AUD_Vector3 getSourceVelocity(AUD_Handle* handle); + virtual bool setSourceVelocity(AUD_Handle* handle, const AUD_Vector3& velocity); + virtual AUD_Quaternion getSourceOrientation(AUD_Handle* handle); + virtual bool setSourceOrientation(AUD_Handle* handle, const AUD_Quaternion& orientation); + virtual bool isRelative(AUD_Handle* handle); + virtual bool setRelative(AUD_Handle* handle, bool relative); + virtual float getVolumeMaximum(AUD_Handle* handle); + virtual bool setVolumeMaximum(AUD_Handle* handle, float volume); + virtual float getVolumeMinimum(AUD_Handle* handle); + virtual bool setVolumeMinimum(AUD_Handle* handle, float volume); + virtual float getDistanceMaximum(AUD_Handle* handle); + virtual bool setDistanceMaximum(AUD_Handle* handle, float distance); + virtual float getDistanceReference(AUD_Handle* handle); + virtual bool setDistanceReference(AUD_Handle* handle, float distance); + virtual float getAttenuation(AUD_Handle* handle); + virtual bool setAttenuation(AUD_Handle* handle, float factor); + virtual float getConeAngleOuter(AUD_Handle* handle); + virtual bool setConeAngleOuter(AUD_Handle* handle, float angle); + virtual float getConeAngleInner(AUD_Handle* handle); + virtual bool setConeAngleInner(AUD_Handle* handle, float angle); + virtual float getConeVolumeOuter(AUD_Handle* handle); + virtual bool setConeVolumeOuter(AUD_Handle* handle, float volume); }; #endif //AUD_OPENALDEVICE diff --git a/intern/audaspace/Python/AUD_PyAPI.cpp b/intern/audaspace/Python/AUD_PyAPI.cpp index b26abee26e4..13617283a1e 100644 --- a/intern/audaspace/Python/AUD_PyAPI.cpp +++ b/intern/audaspace/Python/AUD_PyAPI.cpp @@ -26,6 +26,7 @@ #include "AUD_PyAPI.h" #include "structmember.h" +#include "AUD_I3DDevice.h" #include "AUD_NULLDevice.h" #include "AUD_DelayFactory.h" #include "AUD_DoubleFactory.h" @@ -1008,55 +1009,6 @@ Handle_stop(Handle *self) Py_RETURN_FALSE; } -PyDoc_STRVAR(M_aud_Handle_update_doc, - "update(info)\n\n" - "Updates the 3D information of the source.\n\n" - ":arg info: The 3D info in the format (fff)(fff)((fff)(fff)(fff))." - " Position, velocity and a 3x3 orientation matrix.\n" - ":type info: float tuple\n" - ":return: Whether the action succeeded.\n" - ":rtype: boolean"); - -static PyObject * -Handle_update(Handle *self, PyObject *args) -{ - AUD_3DData data; - - if(!PyArg_Parse(args, "(fff)(fff)((fff)(fff)(fff))", - &data.position[0], &data.position[1], &data.position[2], - &data.velocity[0], &data.velocity[1], &data.velocity[2], - &data.orientation[0], &data.orientation[1], &data.orientation[2], - &data.orientation[3], &data.orientation[4], &data.orientation[5], - &data.orientation[6], &data.orientation[7], &data.orientation[8])) - return NULL; - - Device* dev = (Device*)self->device; - - try - { - AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); - if(device) - { - if(device->updateSource(self->handle, data)) - { - Py_RETURN_TRUE; - } - } - else - { - PyErr_SetString(AUDError, "Device is not a 3D device!"); - return NULL; - } - } - catch(AUD_Exception&) - { - PyErr_SetString(AUDError, "Couldn't update the source!"); - return NULL; - } - - Py_RETURN_FALSE; -} - static PyMethodDef Handle_methods[] = { {"pause", (PyCFunction)Handle_pause, METH_NOARGS, M_aud_Handle_pause_doc @@ -1067,9 +1019,6 @@ static PyMethodDef Handle_methods[] = { {"stop", (PyCFunction)Handle_stop, METH_NOARGS, M_aud_Handle_stop_doc }, - {"update", (PyCFunction)Handle_update, METH_O, - M_aud_Handle_update_doc - }, {NULL} /* Sentinel */ }; @@ -1318,8 +1267,185 @@ Handle_set_loop_count(Handle *self, PyObject* args, void* nothing) return -1; } +PyDoc_STRVAR(M_aud_Handle_location_doc, + "The source's location in 3D space, a 3D tuple of floats."); + +static PyObject * +Handle_get_location(Handle *self, void* nothing) +{ + Device* dev = (Device*)self->device; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); + if(device) + { + AUD_Vector3 v = device->getSourceLocation(self->handle); + return Py_BuildValue("(fff)", v.x(), v.y(), v.z()); + } + else + { + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't retrieve the location!"); + } + + return NULL; +} + +static int +Handle_set_location(Handle *self, PyObject* args, void* nothing) +{ + float x, y, z; + + if(!PyArg_Parse(args, "(fff)", &x, &y, &z)) + return NULL; + + Device* dev = (Device*)self->device; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); + if(device) + { + AUD_Vector3 location(x, y, z); + device->setSourceLocation(self->handle, location); + return 0; + } + else + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't set the location!"); + } + + return -1; +} + +PyDoc_STRVAR(M_aud_Handle_velocity_doc, + "The source's velocity in 3D space, a 3D tuple of floats."); + +static PyObject * +Handle_get_velocity(Handle *self, void* nothing) +{ + Device* dev = (Device*)self->device; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); + if(device) + { + AUD_Vector3 v = device->getSourceVelocity(self->handle); + return Py_BuildValue("(fff)", v.x(), v.y(), v.z()); + } + else + { + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't retrieve the velocity!"); + } + + return NULL; +} + +static int +Handle_set_velocity(Handle *self, PyObject* args, void* nothing) +{ + float x, y, z; + + if(!PyArg_Parse(args, "(fff)", &x, &y, &z)) + return NULL; + + Device* dev = (Device*)self->device; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); + if(device) + { + AUD_Vector3 velocity(x, y, z); + device->setSourceVelocity(self->handle, velocity); + return 0; + } + else + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't set the velocity!"); + } + + return -1; +} + +PyDoc_STRVAR(M_aud_Handle_orientation_doc, + "The source's orientation in 3D space as quaternion, a 4 float tuple."); + +static PyObject * +Handle_get_orientation(Handle *self, void* nothing) +{ + Device* dev = (Device*)self->device; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); + if(device) + { + AUD_Quaternion o = device->getSourceOrientation(self->handle); + return Py_BuildValue("(ffff)", o.w(), o.x(), o.y(), o.z()); + } + else + { + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't retrieve the orientation!"); + } + + return NULL; +} + +static int +Handle_set_orientation(Handle *self, PyObject* args, void* nothing) +{ + float w, x, y, z; + + if(!PyArg_Parse(args, "(ffff)", &w, &x, &y, &z)) + return NULL; + + Device* dev = (Device*)self->device; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); + if(device) + { + AUD_Quaternion orientation(w, x, y, z); + device->setSourceOrientation(self->handle, orientation); + return 0; + } + else + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't set the orientation!"); + } + + return -1; +} + PyDoc_STRVAR(M_aud_Handle_relative_doc, - "Whether the source's position is relative or absolute to the listener."); + "Whether the source's location, velocity and orientation is relative or absolute to the listener."); static PyObject * Handle_get_relative(Handle *self, void* nothing) @@ -1331,7 +1457,7 @@ Handle_get_relative(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - if(device->getSourceSetting(self->handle, AUD_3DSS_IS_RELATIVE) > 0) + if(device->isRelative(self->handle)) { Py_RETURN_TRUE; } @@ -1362,7 +1488,7 @@ Handle_set_relative(Handle *self, PyObject* args, void* nothing) return -1; } - float relative = (args == Py_True); + bool relative = (args == Py_True); Device* dev = (Device*)self->device; try @@ -1370,7 +1496,7 @@ Handle_set_relative(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_IS_RELATIVE, relative); + device->setRelative(self->handle, relative); return 0; } else @@ -1384,11 +1510,11 @@ Handle_set_relative(Handle *self, PyObject* args, void* nothing) return -1; } -PyDoc_STRVAR(M_aud_Handle_min_gain_doc, - "The minimum gain of the source."); +PyDoc_STRVAR(M_aud_Handle_volume_minimum_doc, + "The minimum volume of the source."); static PyObject * -Handle_get_min_gain(Handle *self, void* nothing) +Handle_get_volume_minimum(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1397,7 +1523,7 @@ Handle_get_min_gain(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_MIN_GAIN)); + return Py_BuildValue("f", device->getVolumeMinimum(self->handle)); } else { @@ -1407,17 +1533,17 @@ Handle_get_min_gain(Handle *self, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't retrieve the minimum gain of the sound!"); + PyErr_SetString(AUDError, "Couldn't retrieve the minimum volume of the sound!"); return NULL; } } static int -Handle_set_min_gain(Handle *self, PyObject* args, void* nothing) +Handle_set_volume_minimum(Handle *self, PyObject* args, void* nothing) { - float gain; + float volume; - if(!PyArg_Parse(args, "f", &gain)) + if(!PyArg_Parse(args, "f", &volume)) return -1; Device* dev = (Device*)self->device; @@ -1427,7 +1553,7 @@ Handle_set_min_gain(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_MIN_GAIN, gain); + device->setVolumeMinimum(self->handle, volume); return 0; } else @@ -1435,17 +1561,17 @@ Handle_set_min_gain(Handle *self, PyObject* args, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't set the minimum source gain!"); + PyErr_SetString(AUDError, "Couldn't set the minimum source volume!"); } return -1; } -PyDoc_STRVAR(M_aud_Handle_max_gain_doc, - "The maximum gain of the source."); +PyDoc_STRVAR(M_aud_Handle_volume_maximum_doc, + "The maximum volume of the source."); static PyObject * -Handle_get_max_gain(Handle *self, void* nothing) +Handle_get_volume_maximum(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1454,7 +1580,7 @@ Handle_get_max_gain(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_MAX_GAIN)); + return Py_BuildValue("f", device->getVolumeMaximum(self->handle)); } else { @@ -1464,17 +1590,17 @@ Handle_get_max_gain(Handle *self, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't retrieve the maximum gain of the sound!"); + PyErr_SetString(AUDError, "Couldn't retrieve the maximum volume of the sound!"); return NULL; } } static int -Handle_set_max_gain(Handle *self, PyObject* args, void* nothing) +Handle_set_volume_maximum(Handle *self, PyObject* args, void* nothing) { - float gain; + float volume; - if(!PyArg_Parse(args, "f", &gain)) + if(!PyArg_Parse(args, "f", &volume)) return -1; Device* dev = (Device*)self->device; @@ -1484,7 +1610,7 @@ Handle_set_max_gain(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_MAX_GAIN, gain); + device->setVolumeMaximum(self->handle, volume); return 0; } else @@ -1492,17 +1618,17 @@ Handle_set_max_gain(Handle *self, PyObject* args, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't set the maximum source gain!"); + PyErr_SetString(AUDError, "Couldn't set the maximum source volume!"); } return -1; } -PyDoc_STRVAR(M_aud_Handle_reference_distance_doc, +PyDoc_STRVAR(M_aud_Handle_distance_reference_doc, "The reference distance of the source."); static PyObject * -Handle_get_reference_distance(Handle *self, void* nothing) +Handle_get_distance_reference(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1511,7 +1637,7 @@ Handle_get_reference_distance(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_REFERENCE_DISTANCE)); + return Py_BuildValue("f", device->getDistanceReference(self->handle)); } else { @@ -1527,7 +1653,7 @@ Handle_get_reference_distance(Handle *self, void* nothing) } static int -Handle_set_reference_distance(Handle *self, PyObject* args, void* nothing) +Handle_set_distance_reference(Handle *self, PyObject* args, void* nothing) { float distance; @@ -1541,7 +1667,7 @@ Handle_set_reference_distance(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_REFERENCE_DISTANCE, distance); + device->setDistanceReference(self->handle, distance); return 0; } else @@ -1555,11 +1681,11 @@ Handle_set_reference_distance(Handle *self, PyObject* args, void* nothing) return -1; } -PyDoc_STRVAR(M_aud_Handle_max_distance_doc, +PyDoc_STRVAR(M_aud_Handle_distance_maximum_doc, "The maximum distance of the source."); static PyObject * -Handle_get_max_distance(Handle *self, void* nothing) +Handle_get_distance_maximum(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1568,7 +1694,7 @@ Handle_get_max_distance(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_MAX_DISTANCE)); + return Py_BuildValue("f", device->getDistanceMaximum(self->handle)); } else { @@ -1584,7 +1710,7 @@ Handle_get_max_distance(Handle *self, void* nothing) } static int -Handle_set_max_distance(Handle *self, PyObject* args, void* nothing) +Handle_set_distance_maximum(Handle *self, PyObject* args, void* nothing) { float distance; @@ -1598,7 +1724,7 @@ Handle_set_max_distance(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_MAX_DISTANCE, distance); + device->setDistanceMaximum(self->handle, distance); return 0; } else @@ -1612,11 +1738,11 @@ Handle_set_max_distance(Handle *self, PyObject* args, void* nothing) return -1; } -PyDoc_STRVAR(M_aud_Handle_rolloff_factor_doc, - "The rolloff factor of the source."); +PyDoc_STRVAR(M_aud_Handle_attenuation_doc, + "The attenuation of the source."); static PyObject * -Handle_get_rolloff_factor(Handle *self, void* nothing) +Handle_get_attenuation(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1625,7 +1751,7 @@ Handle_get_rolloff_factor(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_ROLLOFF_FACTOR)); + return Py_BuildValue("f", device->getAttenuation(self->handle)); } else { @@ -1635,13 +1761,13 @@ Handle_get_rolloff_factor(Handle *self, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't retrieve the rolloff factor of the sound!"); + PyErr_SetString(AUDError, "Couldn't retrieve the attenuation of the sound!"); return NULL; } } static int -Handle_set_rolloff_factor(Handle *self, PyObject* args, void* nothing) +Handle_set_attenuation(Handle *self, PyObject* args, void* nothing) { float factor; @@ -1655,7 +1781,7 @@ Handle_set_rolloff_factor(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_ROLLOFF_FACTOR, factor); + device->setAttenuation(self->handle, factor); return 0; } else @@ -1663,17 +1789,17 @@ Handle_set_rolloff_factor(Handle *self, PyObject* args, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't set the rolloff factor!"); + PyErr_SetString(AUDError, "Couldn't set the attenuation!"); } return -1; } -PyDoc_STRVAR(M_aud_Handle_cone_inner_angle_doc, +PyDoc_STRVAR(M_aud_Handle_cone_angle_inner_doc, "The cone inner angle of the source."); static PyObject * -Handle_get_cone_inner_angle(Handle *self, void* nothing) +Handle_get_cone_angle_inner(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1682,7 +1808,7 @@ Handle_get_cone_inner_angle(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_CONE_INNER_ANGLE)); + return Py_BuildValue("f", device->getConeAngleInner(self->handle)); } else { @@ -1698,7 +1824,7 @@ Handle_get_cone_inner_angle(Handle *self, void* nothing) } static int -Handle_set_cone_inner_angle(Handle *self, PyObject* args, void* nothing) +Handle_set_cone_angle_inner(Handle *self, PyObject* args, void* nothing) { float angle; @@ -1712,7 +1838,7 @@ Handle_set_cone_inner_angle(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_CONE_INNER_ANGLE, angle); + device->setConeAngleInner(self->handle, angle); return 0; } else @@ -1726,11 +1852,11 @@ Handle_set_cone_inner_angle(Handle *self, PyObject* args, void* nothing) return -1; } -PyDoc_STRVAR(M_aud_Handle_cone_outer_angle_doc, +PyDoc_STRVAR(M_aud_Handle_cone_angle_outer_doc, "The cone outer angle of the source."); static PyObject * -Handle_get_cone_outer_angle(Handle *self, void* nothing) +Handle_get_cone_angle_outer(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1739,7 +1865,7 @@ Handle_get_cone_outer_angle(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_CONE_OUTER_ANGLE)); + return Py_BuildValue("f", device->getConeAngleOuter(self->handle)); } else { @@ -1755,7 +1881,7 @@ Handle_get_cone_outer_angle(Handle *self, void* nothing) } static int -Handle_set_cone_outer_angle(Handle *self, PyObject* args, void* nothing) +Handle_set_cone_angle_outer(Handle *self, PyObject* args, void* nothing) { float angle; @@ -1769,7 +1895,7 @@ Handle_set_cone_outer_angle(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_CONE_OUTER_ANGLE, angle); + device->setConeAngleOuter(self->handle, angle); return 0; } else @@ -1783,11 +1909,11 @@ Handle_set_cone_outer_angle(Handle *self, PyObject* args, void* nothing) return -1; } -PyDoc_STRVAR(M_aud_Handle_cone_outer_gain_doc, - "The cone outer gain of the source."); +PyDoc_STRVAR(M_aud_Handle_cone_volume_outer_doc, + "The cone outer volume of the source."); static PyObject * -Handle_get_cone_outer_gain(Handle *self, void* nothing) +Handle_get_cone_volume_outer(Handle *self, void* nothing) { Device* dev = (Device*)self->device; @@ -1796,7 +1922,7 @@ Handle_get_cone_outer_gain(Handle *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - return Py_BuildValue("f", device->getSourceSetting(self->handle, AUD_3DSS_CONE_OUTER_GAIN)); + return Py_BuildValue("f", device->getConeVolumeOuter(self->handle)); } else { @@ -1806,17 +1932,17 @@ Handle_get_cone_outer_gain(Handle *self, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't retrieve the cone outer gain of the sound!"); + PyErr_SetString(AUDError, "Couldn't retrieve the cone outer volume of the sound!"); return NULL; } } static int -Handle_set_cone_outer_gain(Handle *self, PyObject* args, void* nothing) +Handle_set_cone_volume_outer(Handle *self, PyObject* args, void* nothing) { - float gain; + float volume; - if(!PyArg_Parse(args, "f", &gain)) + if(!PyArg_Parse(args, "f", &volume)) return -1; Device* dev = (Device*)self->device; @@ -1826,7 +1952,7 @@ Handle_set_cone_outer_gain(Handle *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(dev->device); if(device) { - device->setSourceSetting(self->handle, AUD_3DSS_CONE_OUTER_GAIN, gain); + device->setConeVolumeOuter(self->handle, volume); return 0; } else @@ -1834,7 +1960,7 @@ Handle_set_cone_outer_gain(Handle *self, PyObject* args, void* nothing) } catch(AUD_Exception&) { - PyErr_SetString(AUDError, "Couldn't set the cone outer gain!"); + PyErr_SetString(AUDError, "Couldn't set the cone outer volume!"); } return -1; @@ -1853,24 +1979,30 @@ static PyGetSetDef Handle_properties[] = { M_aud_Handle_pitch_doc, NULL }, {(char*)"loop_count", (getter)Handle_get_loop_count, (setter)Handle_set_loop_count, M_aud_Handle_loop_count_doc, NULL }, + {(char*)"location", (getter)Handle_get_location, (setter)Handle_set_location, + M_aud_Handle_location_doc, NULL }, + {(char*)"velocity", (getter)Handle_get_velocity, (setter)Handle_set_velocity, + M_aud_Handle_velocity_doc, NULL }, + {(char*)"orientation", (getter)Handle_get_orientation, (setter)Handle_set_orientation, + M_aud_Handle_orientation_doc, NULL }, {(char*)"relative", (getter)Handle_get_relative, (setter)Handle_set_relative, M_aud_Handle_relative_doc, NULL }, - {(char*)"min_gain", (getter)Handle_get_min_gain, (setter)Handle_set_min_gain, - M_aud_Handle_min_gain_doc, NULL }, - {(char*)"max_gain", (getter)Handle_get_max_gain, (setter)Handle_set_max_gain, - M_aud_Handle_max_gain_doc, NULL }, - {(char*)"reference_distance", (getter)Handle_get_reference_distance, (setter)Handle_set_reference_distance, - M_aud_Handle_reference_distance_doc, NULL }, - {(char*)"max_distance", (getter)Handle_get_max_distance, (setter)Handle_set_max_distance, - M_aud_Handle_max_distance_doc, NULL }, - {(char*)"rolloff_factor", (getter)Handle_get_rolloff_factor, (setter)Handle_set_rolloff_factor, - M_aud_Handle_rolloff_factor_doc, NULL }, - {(char*)"cone_inner_angle", (getter)Handle_get_cone_inner_angle, (setter)Handle_set_cone_inner_angle, - M_aud_Handle_cone_inner_angle_doc, NULL }, - {(char*)"cone_outer_angle", (getter)Handle_get_cone_outer_angle, (setter)Handle_set_cone_outer_angle, - M_aud_Handle_cone_outer_angle_doc, NULL }, - {(char*)"cone_outer_gain", (getter)Handle_get_cone_outer_gain, (setter)Handle_set_cone_outer_gain, - M_aud_Handle_cone_outer_gain_doc, NULL }, + {(char*)"volume_minimum", (getter)Handle_get_volume_minimum, (setter)Handle_set_volume_minimum, + M_aud_Handle_volume_minimum_doc, NULL }, + {(char*)"volume_maximum", (getter)Handle_get_volume_maximum, (setter)Handle_set_volume_maximum, + M_aud_Handle_volume_maximum_doc, NULL }, + {(char*)"distance_reference", (getter)Handle_get_distance_reference, (setter)Handle_set_distance_reference, + M_aud_Handle_distance_reference_doc, NULL }, + {(char*)"distance_maximum", (getter)Handle_get_distance_maximum, (setter)Handle_set_distance_maximum, + M_aud_Handle_distance_maximum_doc, NULL }, + {(char*)"attenuation", (getter)Handle_get_attenuation, (setter)Handle_set_attenuation, + M_aud_Handle_attenuation_doc, NULL }, + {(char*)"cone_angle_inner", (getter)Handle_get_cone_angle_inner, (setter)Handle_set_cone_angle_inner, + M_aud_Handle_cone_angle_inner_doc, NULL }, + {(char*)"cone_angle_outer", (getter)Handle_get_cone_angle_outer, (setter)Handle_set_cone_angle_outer, + M_aud_Handle_cone_angle_outer_doc, NULL }, + {(char*)"cone_volume_outer", (getter)Handle_get_cone_volume_outer, (setter)Handle_set_cone_volume_outer, + M_aud_Handle_cone_volume_outer_doc, NULL }, {NULL} /* Sentinel */ }; @@ -2036,122 +2168,6 @@ Device_unlock(Device *self) } } -PyDoc_STRVAR(M_aud_Device_play3D_doc, - "play3d(sound[, keep])\n\n" - "Plays a sound 3 dimensional if possible.\n\n" - ":arg sound: The sound to play.\n" - ":type sound: aud.Sound\n" - ":arg keep: Whether the sound should be kept paused in the device when its end is reached.\n" - ":type keep: boolean\n" - ":return: The playback handle.\n" - ":rtype: aud.Handle"); - -static PyObject * -Device_play3D(Device *self, PyObject *args, PyObject *kwds) -{ - PyObject* object; - PyObject* keepo = NULL; - - bool keep = false; - - static const char *kwlist[] = {"sound", "keep", NULL}; - - if(!PyArg_ParseTupleAndKeywords(args, kwds, "O|O", const_cast<char**>(kwlist), &object, &keepo)) - return NULL; - - if(!PyObject_TypeCheck(object, &SoundType)) - { - PyErr_SetString(PyExc_TypeError, "Object is not of type aud.Sound!"); - return NULL; - } - - if(keepo != NULL) - { - if(!PyBool_Check(keepo)) - { - PyErr_SetString(PyExc_TypeError, "keep is not a boolean!"); - return NULL; - } - - keep = keepo == Py_True; - } - - Sound* sound = (Sound*)object; - Handle *handle; - - handle = (Handle*)HandleType.tp_alloc(&HandleType, 0); - if(handle != NULL) - { - handle->device = (PyObject*)self; - Py_INCREF(self); - - try - { - AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); - if(device) - { - handle->handle = device->play3D(sound->factory, keep); - } - else - { - Py_DECREF(handle); - PyErr_SetString(AUDError, "Device is not a 3D device!"); - return NULL; - } - } - catch(AUD_Exception&) - { - Py_DECREF(handle); - PyErr_SetString(AUDError, "Couldn't play the sound!"); - return NULL; - } - } - - return (PyObject *)handle; -} - -PyDoc_STRVAR(M_aud_Device_update_listener_doc, - "update_listener(info)\n\n" - "Updates the 3D information of the listener.\n\n" - ":arg info: The 3D info in the format (fff)(fff)((fff)(fff)(fff))." - " Position, velocity and a 3x3 orientation matrix.\n" - ":type info: float tuple"); - -static PyObject * -Device_update_listener(Device *self, PyObject *args) -{ - AUD_3DData data; - - if(!PyArg_ParseTuple(args, "(fff)(fff)((fff)(fff)(fff))", - &data.position[0], &data.position[1], &data.position[2], - &data.velocity[0], &data.velocity[1], &data.velocity[2], - &data.orientation[0], &data.orientation[1], &data.orientation[2], - &data.orientation[3], &data.orientation[4], &data.orientation[5], - &data.orientation[6], &data.orientation[7], &data.orientation[8])) - return NULL; - - try - { - AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); - if(device) - { - device->updateListener(data); - } - else - { - PyErr_SetString(AUDError, "Device is not a 3D device!"); - return NULL; - } - } - catch(AUD_Exception&) - { - PyErr_SetString(AUDError, "Couldn't update the listener!"); - return NULL; - } - - Py_RETURN_NONE; -} - PyDoc_STRVAR(M_aud_Device_OpenAL_doc, "OpenAL([frequency[, buffer_size]])\n\n" "Creates an OpenAL device.\n\n" @@ -2213,12 +2229,6 @@ static PyMethodDef Device_methods[] = { {"unlock", (PyCFunction)Device_unlock, METH_NOARGS, M_aud_Device_unlock_doc }, - {"play3D", (PyCFunction)Device_play3D, METH_VARARGS | METH_KEYWORDS, - M_aud_Device_play3D_doc - }, - {"update_listener", (PyCFunction)Device_update_listener, METH_VARARGS, - M_aud_Device_update_listener_doc - }, {"OpenAL", (PyCFunction)Device_OpenAL, METH_VARARGS | METH_STATIC | METH_KEYWORDS, M_aud_Device_OpenAL_doc }, @@ -2325,6 +2335,171 @@ Device_set_volume(Device *self, PyObject* args, void* nothing) } } +PyDoc_STRVAR(M_aud_Device_listener_location_doc, + "The listeners's location in 3D space, a 3D tuple of floats."); + +static PyObject * +Device_get_listener_location(Device *self, void* nothing) +{ + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); + if(device) + { + AUD_Vector3 v = device->getListenerLocation(); + return Py_BuildValue("(fff)", v.x(), v.y(), v.z()); + } + else + { + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't retrieve the location!"); + } + + return NULL; +} + +static int +Device_set_listener_location(Device *self, PyObject* args, void* nothing) +{ + float x, y, z; + + if(!PyArg_Parse(args, "(fff)", &x, &y, &z)) + return NULL; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); + if(device) + { + AUD_Vector3 location(x, y, z); + device->setListenerLocation(location); + return 0; + } + else + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't set the location!"); + } + + return -1; +} + +PyDoc_STRVAR(M_aud_Device_listener_velocity_doc, + "The listener's velocity in 3D space, a 3D tuple of floats."); + +static PyObject * +Device_get_listener_velocity(Device *self, void* nothing) +{ + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); + if(device) + { + AUD_Vector3 v = device->getListenerVelocity(); + return Py_BuildValue("(fff)", v.x(), v.y(), v.z()); + } + else + { + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't retrieve the velocity!"); + } + + return NULL; +} + +static int +Device_set_listener_velocity(Device *self, PyObject* args, void* nothing) +{ + float x, y, z; + + if(!PyArg_Parse(args, "(fff)", &x, &y, &z)) + return NULL; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); + if(device) + { + AUD_Vector3 velocity(x, y, z); + device->setListenerVelocity(velocity); + return 0; + } + else + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't set the velocity!"); + } + + return -1; +} + +PyDoc_STRVAR(M_aud_Device_listener_orientation_doc, + "The listener's orientation in 3D space as quaternion, a 4 float tuple."); + +static PyObject * +Device_get_listener_orientation(Device *self, void* nothing) +{ + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); + if(device) + { + AUD_Quaternion o = device->getListenerOrientation(); + return Py_BuildValue("(ffff)", o.w(), o.x(), o.y(), o.z()); + } + else + { + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't retrieve the orientation!"); + } + + return NULL; +} + +static int +Device_set_listener_orientation(Device *self, PyObject* args, void* nothing) +{ + float w, x, y, z; + + if(!PyArg_Parse(args, "(ffff)", &w, &x, &y, &z)) + return NULL; + + try + { + AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); + if(device) + { + AUD_Quaternion orientation(w, x, y, z); + device->setListenerOrientation(orientation); + return 0; + } + else + PyErr_SetString(AUDError, "Device is not a 3D device!"); + } + catch(AUD_Exception&) + { + PyErr_SetString(AUDError, "Couldn't set the orientation!"); + } + + return -1; +} + PyDoc_STRVAR(M_aud_Device_speed_of_sound_doc, "The speed of sound of the device."); @@ -2336,7 +2511,7 @@ Device_get_speed_of_sound(Device *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); if(device) { - return Py_BuildValue("f", device->getSetting(AUD_3DS_SPEED_OF_SOUND)); + return Py_BuildValue("f", device->getSpeedOfSound()); } else { @@ -2364,7 +2539,7 @@ Device_set_speed_of_sound(Device *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); if(device) { - device->setSetting(AUD_3DS_SPEED_OF_SOUND, speed); + device->setSpeedOfSound(speed); return 0; } else @@ -2389,7 +2564,7 @@ Device_get_doppler_factor(Device *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); if(device) { - return Py_BuildValue("f", device->getSetting(AUD_3DS_DOPPLER_FACTOR)); + return Py_BuildValue("f", device->getDopplerFactor()); } else { @@ -2417,7 +2592,7 @@ Device_set_doppler_factor(Device *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); if(device) { - device->setSetting(AUD_3DS_DOPPLER_FACTOR, factor); + device->setDopplerFactor(factor); return 0; } else @@ -2442,7 +2617,7 @@ Device_get_distance_model(Device *self, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); if(device) { - return Py_BuildValue("i", int(device->getSetting(AUD_3DS_DISTANCE_MODEL))); + return Py_BuildValue("i", int(device->getDistanceModel())); } else { @@ -2470,7 +2645,7 @@ Device_set_distance_model(Device *self, PyObject* args, void* nothing) AUD_I3DDevice* device = dynamic_cast<AUD_I3DDevice*>(self->device); if(device) { - device->setSetting(AUD_3DS_DISTANCE_MODEL, model); + device->setDistanceModel(AUD_DistanceModel(model)); return 0; } else @@ -2493,6 +2668,12 @@ static PyGetSetDef Device_properties[] = { M_aud_Device_channels_doc, NULL }, {(char*)"volume", (getter)Device_get_volume, (setter)Device_set_volume, M_aud_Device_volume_doc, NULL }, + {(char*)"listener_location", (getter)Device_get_listener_location, (setter)Device_set_listener_location, + M_aud_Device_listener_location_doc, NULL }, + {(char*)"listener_velocity", (getter)Device_get_listener_velocity, (setter)Device_set_listener_velocity, + M_aud_Device_listener_velocity_doc, NULL }, + {(char*)"listener_orientation", (getter)Device_get_listener_orientation, (setter)Device_set_listener_orientation, + M_aud_Device_listener_orientation_doc, NULL }, {(char*)"speed_of_sound", (getter)Device_get_speed_of_sound, (setter)Device_set_speed_of_sound, M_aud_Device_speed_of_sound_doc, NULL }, {(char*)"doppler_factor", (getter)Device_get_doppler_factor, (setter)Device_set_doppler_factor, @@ -2779,7 +2960,7 @@ PyInit_aud(void) PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_INVERSE_CLAMPED); PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_LINEAR); PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_LINEAR_CLAMPED); - PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_NONE); + PY_MODULE_ADD_CONSTANT(m, AUD_DISTANCE_MODEL_INVALID); return m; } diff --git a/intern/audaspace/intern/AUD_3DMath.h b/intern/audaspace/intern/AUD_3DMath.h new file mode 100644 index 00000000000..a3405bf4d31 --- /dev/null +++ b/intern/audaspace/intern/AUD_3DMath.h @@ -0,0 +1,189 @@ +/* + * $Id$ + * + * ***** BEGIN LGPL LICENSE BLOCK ***** + * + * Copyright 2009 Jörg Hermann Müller + * + * This file is part of AudaSpace. + * + * AudaSpace is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * AudaSpace is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with AudaSpace. If not, see <http://www.gnu.org/licenses/>. + * + * ***** END LGPL LICENSE BLOCK ***** + */ + +#ifndef AUD_3DMATH +#define AUD_3DMATH + +class AUD_Quaternion +{ +private: + union + { + float m_v[4]; + struct + { + const float m_w; + const float m_x; + const float m_y; + const float m_z; + }; + }; + +public: + /** + * Creates a new quaternion. + * \param w The w component. + * \param x The x component. + * \param y The y component. + * \param z The z component. + */ + inline AUD_Quaternion(float w, float x, float y, float z) : + m_w(w), m_x(x), m_y(y), m_z(z) + { + } + + /** + * Retrieves the w component of the quarternion. + * \return The w component. + */ + inline const float& w() const + { + return m_w; + } + + /** + * Retrieves the x component of the quarternion. + * \return The x component. + */ + inline const float& x() const + { + return m_x; + } + + /** + * Retrieves the y component of the quarternion. + * \return The y component. + */ + inline const float& y() const + { + return m_y; + } + + /** + * Retrieves the z component of the quarternion. + * \return The z component. + */ + inline const float& z() const + { + return m_z; + } + + /** + * Retrieves the components of the vector. + * \param destination Where the 4 float values should be saved to. + */ + inline void get(float* destination) const + { + destination[0] = m_w; + destination[1] = m_x; + destination[2] = m_y; + destination[3] = m_z; + } + + /** + * Retrieves the components of the vector. + * \return The components as float[4]. + */ + inline const float* get() const + { + return m_v; + } +}; + +class AUD_Vector3 +{ +private: + union + { + float m_v[3]; + struct + { + const float m_x; + const float m_y; + const float m_z; + }; + }; + +public: + /** + * Creates a new 3 dimensional vector. + * \param x The x component. + * \param y The y component. + * \param z The z component. + */ + inline AUD_Vector3(float x, float y, float z) : + m_x(x), m_y(y), m_z(z) + { + } + + /** + * Retrieves the x component of the vector. + * \return The x component. + */ + inline const float& x() const + { + return m_x; + } + + /** + * Retrieves the y component of the vector. + * \return The y component. + */ + inline const float& y() const + { + return m_y; + } + + /** + * Retrieves the z component of the vector. + * \return The z component. + */ + inline const float& z() const + { + return m_z; + } + + /** + * Retrieves the components of the vector. + * \param destination Where the 3 float values should be saved to. + */ + inline void get(float* destination) const + { + destination[0] = m_x; + destination[1] = m_y; + destination[2] = m_z; + } + + /** + * Retrieves the components of the vector. + * \return The components as float[3]. + */ + inline const float* get() const + { + return m_v; + } +}; + +#endif //AUD_3DMATH diff --git a/intern/audaspace/intern/AUD_C-API.cpp b/intern/audaspace/intern/AUD_C-API.cpp index 2236af09904..1f9e76c4535 100644 --- a/intern/audaspace/intern/AUD_C-API.cpp +++ b/intern/audaspace/intern/AUD_C-API.cpp @@ -443,124 +443,244 @@ AUD_Status AUD_getStatus(AUD_Channel* handle) return AUD_device->getStatus(handle); } -AUD_Channel* AUD_play3D(AUD_Sound* sound, int keep) +int AUD_setListenerLocation(const float* location) { assert(AUD_device); - assert(sound); - try + if(AUD_3ddevice) { - if(AUD_3ddevice) - return AUD_3ddevice->play3D(sound, keep); - else - return AUD_device->play(sound, keep); + AUD_Vector3 v(location[0], location[1], location[2]); + AUD_3ddevice->setListenerLocation(v); + return true; } - catch(AUD_Exception&) + + return false; +} + +int AUD_setListenerVelocity(const float* velocity) +{ + assert(AUD_device); + + if(AUD_3ddevice) { - return NULL; + AUD_Vector3 v(velocity[0], velocity[1], velocity[2]); + AUD_3ddevice->setListenerVelocity(v); + return true; } + + return false; } -int AUD_updateListener(AUD_3DData* data) +int AUD_setListenerOrientation(const float* orientation) { assert(AUD_device); - assert(data); - try + if(AUD_3ddevice) { - if(AUD_3ddevice) - return AUD_3ddevice->updateListener(*data); + AUD_Quaternion q(orientation[0], orientation[1], orientation[2], orientation[3]); + AUD_3ddevice->setListenerOrientation(q); + return true; } - catch(AUD_Exception&) + + return false; +} + +int AUD_setSpeedOfSound(float speed) +{ + assert(AUD_device); + + if(AUD_3ddevice) { + AUD_3ddevice->setSpeedOfSound(speed); + return true; } + return false; } -int AUD_set3DSetting(AUD_3DSetting setting, float value) +int AUD_setDopplerFactor(float factor) { assert(AUD_device); - try + if(AUD_3ddevice) { - if(AUD_3ddevice) - return AUD_3ddevice->setSetting(setting, value); + AUD_3ddevice->setDopplerFactor(factor); + return true; } - catch(AUD_Exception&) + + return false; +} + +int AUD_setDistanceModel(AUD_DistanceModel model) +{ + assert(AUD_device); + + if(AUD_3ddevice) { + AUD_3ddevice->setDistanceModel(model); + return true; } + return false; } -float AUD_get3DSetting(AUD_3DSetting setting) +int AUD_setSourceLocation(AUD_Channel* handle, const float* location) { assert(AUD_device); + assert(handle); - try + if(AUD_3ddevice) { - if(AUD_3ddevice) - return AUD_3ddevice->getSetting(setting); + AUD_Vector3 v(location[0], location[1], location[2]); + return AUD_3ddevice->setSourceLocation(handle, v); } - catch(AUD_Exception&) + + return false; +} + +int AUD_setSourceVelocity(AUD_Channel* handle, const float* velocity) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) { + AUD_Vector3 v(velocity[0], velocity[1], velocity[2]); + return AUD_3ddevice->setSourceVelocity(handle, v); } - return 0.0f; + + return false; } -int AUD_update3DSource(AUD_Channel* handle, AUD_3DData* data) +int AUD_setSourceOrientation(AUD_Channel* handle, const float* orientation) { - if(handle) + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) { - assert(AUD_device); - assert(data); + AUD_Quaternion q(orientation[0], orientation[1], orientation[2], orientation[3]); + return AUD_3ddevice->setSourceOrientation(handle, q); + } - try - { - if(AUD_3ddevice) - return AUD_3ddevice->updateSource(handle, *data); - } - catch(AUD_Exception&) - { - } + return false; +} + +int AUD_setRelative(AUD_Channel* handle, int relative) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) + { + return AUD_3ddevice->setRelative(handle, relative); } + return false; } -int AUD_set3DSourceSetting(AUD_Channel* handle, - AUD_3DSourceSetting setting, float value) +int AUD_setVolumeMaximum(AUD_Channel* handle, float volume) { - if(handle) + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) { - assert(AUD_device); + return AUD_3ddevice->setVolumeMaximum(handle, volume); + } - try - { - if(AUD_3ddevice) - return AUD_3ddevice->setSourceSetting(handle, setting, value); - } - catch(AUD_Exception&) - { - } + return false; +} + +int AUD_setVolumeMinimum(AUD_Channel* handle, float volume) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) + { + return AUD_3ddevice->setVolumeMinimum(handle, volume); } + return false; } -float AUD_get3DSourceSetting(AUD_Channel* handle, AUD_3DSourceSetting setting) +int AUD_setDistanceMaximum(AUD_Channel* handle, float distance) { - if(handle) + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) { - assert(AUD_device); + return AUD_3ddevice->setDistanceMaximum(handle, distance); + } - try - { - if(AUD_3ddevice) - return AUD_3ddevice->getSourceSetting(handle, setting); - } - catch(AUD_Exception&) - { - } + return false; +} + +int AUD_setDistanceReference(AUD_Channel* handle, float distance) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) + { + return AUD_3ddevice->setDistanceReference(handle, distance); + } + + return false; +} + +int AUD_setAttenuation(AUD_Channel* handle, float factor) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) + { + return AUD_3ddevice->setAttenuation(handle, factor); + } + + return false; +} + +int AUD_setConeAngleOuter(AUD_Channel* handle, float angle) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) + { + return AUD_3ddevice->setConeAngleOuter(handle, angle); + } + + return false; +} + +int AUD_setConeAngleInner(AUD_Channel* handle, float angle) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) + { + return AUD_3ddevice->setConeAngleInner(handle, angle); + } + + return false; +} + +int AUD_setConeVolumeOuter(AUD_Channel* handle, float volume) +{ + assert(AUD_device); + assert(handle); + + if(AUD_3ddevice) + { + return AUD_3ddevice->setConeVolumeOuter(handle, volume); } - return 0.0f; + + return false; } int AUD_setSoundVolume(AUD_Channel* handle, float volume) diff --git a/intern/audaspace/intern/AUD_C-API.h b/intern/audaspace/intern/AUD_C-API.h index 83feb234a6e..6b7f7c1a2ea 100644 --- a/intern/audaspace/intern/AUD_C-API.h +++ b/intern/audaspace/intern/AUD_C-API.h @@ -246,64 +246,145 @@ extern float AUD_getPosition(AUD_Channel* handle); extern AUD_Status AUD_getStatus(AUD_Channel* handle); /** - * Plays a 3D sound. - * \param sound The handle of the sound file. - * \param keep When keep is true the sound source will not be deleted but set to - * paused when its end has been reached. - * \return A handle to the played back sound. - * \note The factory must provide a mono (single channel) source and the device - * must support 3D audio, otherwise the sound is played back normally. + * Sets the listener location. + * \param location The new location. + */ +extern int AUD_setListenerLocation(const float* location); + +/** + * Sets the listener velocity. + * \param velocity The new velocity. + */ +extern int AUD_setListenerVelocity(const float* velocity); + +/** + * Sets the listener orientation. + * \param orientation The new orientation as quaternion. */ -extern AUD_Channel* AUD_play3D(AUD_Sound* sound, int keep); +extern int AUD_setListenerOrientation(const float* orientation); /** - * Updates the listener 3D data. - * \param data The 3D data. + * Sets the speed of sound. + * This value is needed for doppler effect calculation. + * \param speed The new speed of sound. + */ +extern int AUD_setSpeedOfSound(float speed); + +/** + * Sets the doppler factor. + * This value is a scaling factor for the velocity vectors of sources and + * listener which is used while calculating the doppler effect. + * \param factor The new doppler factor. + */ +extern int AUD_setDopplerFactor(float factor); + +/** + * Sets the distance model. + * \param model distance model. + */ +extern int AUD_setDistanceModel(AUD_DistanceModel model); + +/** + * Sets the location of a source. + * \param handle The handle of the source. + * \param location The new location. * \return Whether the action succeeded. */ -extern int AUD_updateListener(AUD_3DData* data); +extern int AUD_setSourceLocation(AUD_Channel* handle, const float* location); /** - * Sets a 3D device setting. - * \param setting The setting type. - * \param value The new setting value. + * Sets the velocity of a source. + * \param handle The handle of the source. + * \param velocity The new velocity. * \return Whether the action succeeded. */ -extern int AUD_set3DSetting(AUD_3DSetting setting, float value); +extern int AUD_setSourceVelocity(AUD_Channel* handle, const float* velocity); /** - * Retrieves a 3D device setting. - * \param setting The setting type. - * \return The setting value. + * Sets the orientation of a source. + * \param handle The handle of the source. + * \param orientation The new orientation as quaternion. + * \return Whether the action succeeded. */ -extern float AUD_get3DSetting(AUD_3DSetting setting); +extern int AUD_setSourceOrientation(AUD_Channel* handle, const float* orientation); /** - * Updates a listeners 3D data. - * \param handle The source handle. - * \param data The 3D data. + * Sets whether the source location, velocity and orientation are relative + * to the listener. + * \param handle The handle of the source. + * \param relative Whether the source is relative. * \return Whether the action succeeded. */ -extern int AUD_update3DSource(AUD_Channel* handle, AUD_3DData* data); +extern int AUD_setRelative(AUD_Channel* handle, int relative); /** - * Sets a 3D source setting. - * \param handle The source handle. - * \param setting The setting type. - * \param value The new setting value. + * Sets the maximum volume of a source. + * \param handle The handle of the source. + * \param volume The new maximum volume. * \return Whether the action succeeded. */ -extern int AUD_set3DSourceSetting(AUD_Channel* handle, - AUD_3DSourceSetting setting, float value); +extern int AUD_setVolumeMaximum(AUD_Channel* handle, float volume); /** - * Retrieves a 3D source setting. - * \param handle The source handle. - * \param setting The setting type. - * \return The setting value. + * Sets the minimum volume of a source. + * \param handle The handle of the source. + * \param volume The new minimum volume. + * \return Whether the action succeeded. + */ +extern int AUD_setVolumeMinimum(AUD_Channel* handle, float volume); + +/** + * Sets the maximum distance of a source. + * If a source is further away from the reader than this distance, the + * volume will automatically be set to 0. + * \param handle The handle of the source. + * \param distance The new maximum distance. + * \return Whether the action succeeded. + */ +extern int AUD_setDistanceMaximum(AUD_Channel* handle, float distance); + +/** + * Sets the reference distance of a source. + * \param handle The handle of the source. + * \param distance The new reference distance. + * \return Whether the action succeeded. + */ +extern int AUD_setDistanceReference(AUD_Channel* handle, float distance); + +/** + * Sets the attenuation of a source. + * This value is used for distance calculation. + * \param handle The handle of the source. + * \param factor The new attenuation. + * \return Whether the action succeeded. + */ +extern int AUD_setAttenuation(AUD_Channel* handle, float factor); + +/** + * Sets the outer angle of the cone of a source. + * \param handle The handle of the source. + * \param angle The new outer angle of the cone. + * \return Whether the action succeeded. + */ +extern int AUD_setConeAngleOuter(AUD_Channel* handle, float angle); + +/** + * Sets the inner angle of the cone of a source. + * \param handle The handle of the source. + * \param angle The new inner angle of the cone. + * \return Whether the action succeeded. + */ +extern int AUD_setConeAngleInner(AUD_Channel* handle, float angle); + +/** + * Sets the outer volume of the cone of a source. + * The volume between inner and outer angle is interpolated between inner + * volume and this value. + * \param handle The handle of the source. + * \param volume The new outer volume of the cone. + * \return Whether the action succeeded. */ -extern float AUD_get3DSourceSetting(AUD_Channel* handle, - AUD_3DSourceSetting setting); +extern int AUD_setConeVolumeOuter(AUD_Channel* handle, float volume); /** * Sets the volume of a played back sound. diff --git a/intern/audaspace/intern/AUD_I3DDevice.h b/intern/audaspace/intern/AUD_I3DDevice.h index 8e3f2e5958a..629b0997d4d 100644 --- a/intern/audaspace/intern/AUD_I3DDevice.h +++ b/intern/audaspace/intern/AUD_I3DDevice.h @@ -27,6 +27,9 @@ #define AUD_I3DDEVICE #include "AUD_Space.h" +#include "AUD_3DMath.h" + +struct AUD_Handle; /** * This class represents an output device for 3D sound. @@ -35,67 +38,277 @@ class AUD_I3DDevice { public: /** - * Plays a 3D sound source. - * \param factory The factory to create the reader for the sound source. - * \param keep When keep is true the sound source will not be deleted but - * set to paused when its end has been reached. - * \return Returns a handle with which the playback can be controlled. - * This is NULL if the sound couldn't be played back. - * \exception AUD_Exception Thrown if there's an unexpected (from the - * device side) error during creation of the reader. - * \note The factory must provide a mono (single channel) source otherwise - * the sound is played back normally. + * Retrieves the listener location. + * \return The listener location. + */ + virtual AUD_Vector3 getListenerLocation() const=0; + + /** + * Sets the listener location. + * \param location The new location. + */ + virtual void setListenerLocation(const AUD_Vector3& location)=0; + + /** + * Retrieves the listener velocity. + * \return The listener velocity. + */ + virtual AUD_Vector3 getListenerVelocity() const=0; + + /** + * Sets the listener velocity. + * \param velocity The new velocity. + */ + virtual void setListenerVelocity(const AUD_Vector3& velocity)=0; + + /** + * Retrieves the listener orientation. + * \return The listener orientation as quaternion. + */ + virtual AUD_Quaternion getListenerOrientation() const=0; + + /** + * Sets the listener orientation. + * \param orientation The new orientation as quaternion. + */ + virtual void setListenerOrientation(const AUD_Quaternion& orientation)=0; + + + /** + * Retrieves the speed of sound. + * This value is needed for doppler effect calculation. + * \return The speed of sound. + */ + virtual float getSpeedOfSound() const=0; + + /** + * Sets the speed of sound. + * This value is needed for doppler effect calculation. + * \param speed The new speed of sound. + */ + virtual void setSpeedOfSound(float speed)=0; + + /** + * Retrieves the doppler factor. + * This value is a scaling factor for the velocity vectors of sources and + * listener which is used while calculating the doppler effect. + * \return The doppler factor. + */ + virtual float getDopplerFactor() const=0; + + /** + * Sets the doppler factor. + * This value is a scaling factor for the velocity vectors of sources and + * listener which is used while calculating the doppler effect. + * \param factor The new doppler factor. + */ + virtual void setDopplerFactor(float factor)=0; + + /** + * Retrieves the distance model. + * \return The distance model. + */ + virtual AUD_DistanceModel getDistanceModel() const=0; + + /** + * Sets the distance model. + * \param model distance model. + */ + virtual void setDistanceModel(AUD_DistanceModel model)=0; + + + + /** + * Retrieves the location of a source. + * \param handle The handle of the source. + * \return The location. + */ + virtual AUD_Vector3 getSourceLocation(AUD_Handle* handle)=0; + + /** + * Sets the location of a source. + * \param handle The handle of the source. + * \param location The new location. + * \return Whether the action succeeded. + */ + virtual bool setSourceLocation(AUD_Handle* handle, const AUD_Vector3& location)=0; + + /** + * Retrieves the velocity of a source. + * \param handle The handle of the source. + * \return The velocity. + */ + virtual AUD_Vector3 getSourceVelocity(AUD_Handle* handle)=0; + + /** + * Sets the velocity of a source. + * \param handle The handle of the source. + * \param velocity The new velocity. + * \return Whether the action succeeded. + */ + virtual bool setSourceVelocity(AUD_Handle* handle, const AUD_Vector3& velocity)=0; + + /** + * Retrieves the orientation of a source. + * \param handle The handle of the source. + * \return The orientation as quaternion. + */ + virtual AUD_Quaternion getSourceOrientation(AUD_Handle* handle)=0; + + /** + * Sets the orientation of a source. + * \param handle The handle of the source. + * \param orientation The new orientation as quaternion. + * \return Whether the action succeeded. + */ + virtual bool setSourceOrientation(AUD_Handle* handle, const AUD_Quaternion& orientation)=0; + + + /** + * Checks whether the source location, velocity and orientation are relative + * to the listener. + * \param handle The handle of the source. + * \return Whether the source is relative. + */ + virtual bool isRelative(AUD_Handle* handle)=0; + + /** + * Sets whether the source location, velocity and orientation are relative + * to the listener. + * \param handle The handle of the source. + * \param relative Whether the source is relative. + * \return Whether the action succeeded. + */ + virtual bool setRelative(AUD_Handle* handle, bool relative)=0; + + /** + * Retrieves the maximum volume of a source. + * \param handle The handle of the source. + * \return The maximum volume. + */ + virtual float getVolumeMaximum(AUD_Handle* handle)=0; + + /** + * Sets the maximum volume of a source. + * \param handle The handle of the source. + * \param volume The new maximum volume. + * \return Whether the action succeeded. + */ + virtual bool setVolumeMaximum(AUD_Handle* handle, float volume)=0; + + /** + * Retrieves the minimum volume of a source. + * \param handle The handle of the source. + * \return The minimum volume. */ - virtual AUD_Handle* play3D(AUD_IFactory* factory, bool keep = false)=0; + virtual float getVolumeMinimum(AUD_Handle* handle)=0; /** - * Updates a listeners 3D data. - * \param data The 3D data. + * Sets the minimum volume of a source. + * \param handle The handle of the source. + * \param volume The new minimum volume. * \return Whether the action succeeded. */ - virtual bool updateListener(AUD_3DData &data)=0; + virtual bool setVolumeMinimum(AUD_Handle* handle, float volume)=0; + + /** + * Retrieves the maximum distance of a source. + * If a source is further away from the reader than this distance, the + * volume will automatically be set to 0. + * \param handle The handle of the source. + * \return The maximum distance. + */ + virtual float getDistanceMaximum(AUD_Handle* handle)=0; /** - * Sets a 3D device setting. - * \param setting The setting type. - * \param value The new setting value. + * Sets the maximum distance of a source. + * If a source is further away from the reader than this distance, the + * volume will automatically be set to 0. + * \param handle The handle of the source. + * \param distance The new maximum distance. * \return Whether the action succeeded. */ - virtual bool setSetting(AUD_3DSetting setting, float value)=0; + virtual bool setDistanceMaximum(AUD_Handle* handle, float distance)=0; /** - * Retrieves a 3D device setting. - * \param setting The setting type. - * \return The setting value. + * Retrieves the reference distance of a source. + * \param handle The handle of the source. + * \return The reference distance. */ - virtual float getSetting(AUD_3DSetting setting)=0; + virtual float getDistanceReference(AUD_Handle* handle)=0; /** - * Updates a listeners 3D data. - * \param handle The source handle. - * \param data The 3D data. + * Sets the reference distance of a source. + * \param handle The handle of the source. + * \param distance The new reference distance. * \return Whether the action succeeded. */ - virtual bool updateSource(AUD_Handle* handle, AUD_3DData &data)=0; + virtual bool setDistanceReference(AUD_Handle* handle, float distance)=0; + + /** + * Retrieves the attenuation of a source. + * \param handle The handle of the source. + * \return The attenuation. + */ + virtual float getAttenuation(AUD_Handle* handle)=0; /** - * Sets a 3D source setting. - * \param handle The source handle. - * \param setting The setting type. - * \param value The new setting value. + * Sets the attenuation of a source. + * This value is used for distance calculation. + * \param handle The handle of the source. + * \param factor The new attenuation. * \return Whether the action succeeded. */ - virtual bool setSourceSetting(AUD_Handle* handle, - AUD_3DSourceSetting setting, float value)=0; + virtual bool setAttenuation(AUD_Handle* handle, float factor)=0; /** - * Retrieves a 3D source setting. - * \param handle The source handle. - * \param setting The setting type. - * \return The setting value. + * Retrieves the outer angle of the cone of a source. + * \param handle The handle of the source. + * \return The outer angle of the cone. + */ + virtual float getConeAngleOuter(AUD_Handle* handle)=0; + + /** + * Sets the outer angle of the cone of a source. + * \param handle The handle of the source. + * \param angle The new outer angle of the cone. + * \return Whether the action succeeded. + */ + virtual bool setConeAngleOuter(AUD_Handle* handle, float angle)=0; + + /** + * Retrieves the inner angle of the cone of a source. + * \param handle The handle of the source. + * \return The inner angle of the cone. + */ + virtual float getConeAngleInner(AUD_Handle* handle)=0; + + /** + * Sets the inner angle of the cone of a source. + * \param handle The handle of the source. + * \param angle The new inner angle of the cone. + * \return Whether the action succeeded. + */ + virtual bool setConeAngleInner(AUD_Handle* handle, float angle)=0; + + /** + * Retrieves the outer volume of the cone of a source. + * The volume between inner and outer angle is interpolated between inner + * volume and this value. + * \param handle The handle of the source. + * \return The outer volume of the cone. + */ + virtual float getConeVolumeOuter(AUD_Handle* handle)=0; + + /** + * Sets the outer volume of the cone of a source. + * The volume between inner and outer angle is interpolated between inner + * volume and this value. + * \param handle The handle of the source. + * \param volume The new outer volume of the cone. + * \return Whether the action succeeded. */ - virtual float getSourceSetting(AUD_Handle* handle, - AUD_3DSourceSetting setting)=0; + virtual bool setConeVolumeOuter(AUD_Handle* handle, float volume)=0; }; #endif //AUD_I3DDEVICE diff --git a/intern/audaspace/intern/AUD_IDevice.h b/intern/audaspace/intern/AUD_IDevice.h index dfafb6713b0..4170e274574 100644 --- a/intern/audaspace/intern/AUD_IDevice.h +++ b/intern/audaspace/intern/AUD_IDevice.h @@ -30,9 +30,9 @@ class AUD_IFactory; /// Handle structure, for inherition. -typedef struct +struct AUD_Handle { -} AUD_Handle; +}; /** * This class represents an output device for sound sources. diff --git a/intern/audaspace/intern/AUD_Space.h b/intern/audaspace/intern/AUD_Space.h index 1c3a018daa9..5c0350fed15 100644 --- a/intern/audaspace/intern/AUD_Space.h +++ b/intern/audaspace/intern/AUD_Space.h @@ -124,39 +124,17 @@ typedef enum AUD_FADE_OUT } AUD_FadeType; -/// 3D device settings. -typedef enum -{ - AUD_3DS_NONE, /// No setting. - AUD_3DS_SPEED_OF_SOUND, /// Speed of sound. - AUD_3DS_DOPPLER_FACTOR, /// Doppler factor. - AUD_3DS_DISTANCE_MODEL /// Distance model. -} AUD_3DSetting; - /// Possible distance models for the 3D device. -#define AUD_DISTANCE_MODEL_NONE 0.0f -#define AUD_DISTANCE_MODEL_INVERSE 1.0f -#define AUD_DISTANCE_MODEL_INVERSE_CLAMPED 2.0f -#define AUD_DISTANCE_MODEL_LINEAR 3.0f -#define AUD_DISTANCE_MODEL_LINEAR_CLAMPED 4.0f -#define AUD_DISTANCE_MODEL_EXPONENT 5.0f -#define AUD_DISTANCE_MODEL_EXPONENT_CLAMPED 6.0f - -/// 3D source settings. typedef enum { - AUD_3DSS_NONE, /// No setting. - AUD_3DSS_IS_RELATIVE, /// > 0 tells that the sound source is - /// relative to the listener - AUD_3DSS_MIN_GAIN, /// Minimum gain. - AUD_3DSS_MAX_GAIN, /// Maximum gain. - AUD_3DSS_REFERENCE_DISTANCE, /// Reference distance. - AUD_3DSS_MAX_DISTANCE, /// Maximum distance. - AUD_3DSS_ROLLOFF_FACTOR, /// Rolloff factor. - AUD_3DSS_CONE_INNER_ANGLE, /// Cone inner angle. - AUD_3DSS_CONE_OUTER_ANGLE, /// Cone outer angle. - AUD_3DSS_CONE_OUTER_GAIN /// Cone outer gain. -} AUD_3DSourceSetting; + AUD_DISTANCE_MODEL_INVALID = 0, + AUD_DISTANCE_MODEL_INVERSE, + AUD_DISTANCE_MODEL_INVERSE_CLAMPED, + AUD_DISTANCE_MODEL_LINEAR, + AUD_DISTANCE_MODEL_LINEAR_CLAMPED, + AUD_DISTANCE_MODEL_EXPONENT, + AUD_DISTANCE_MODEL_EXPONENT_CLAMPED, +} AUD_DistanceModel; /// Sample type.(float samples) typedef float sample_t; @@ -206,17 +184,4 @@ typedef struct // void* userData; - for the case it is needed someday } AUD_Exception; -/// Handle structure, for inherition. -typedef struct -{ - /// x, y and z coordinates of the object. - float position[3]; - - /// x, y and z coordinates telling the velocity and direction of the object. - float velocity[3]; - - /// 3x3 matrix telling the orientation of the object. - float orientation[9]; -} AUD_3DData; - #endif //AUD_SPACE |