From f40d09cb8f712e87691af4912f3630d92d692779 Mon Sep 17 00:00:00 2001 From: untodesu Date: Thu, 11 Dec 2025 15:14:26 +0500 Subject: Shuffle stuff around - Use the new and improved hierarchy I figured out when making Prospero chat - Re-add NSIS scripts, again from Prospero - Update most build and utility scripts with their most recent versions --- external/salad/CMakeLists.txt | 10 + external/salad/DESCRIPTION | 1 + external/salad/LICENSE | 24 ++ external/salad/include/AL/al.h | 330 ++++++++++++++++++++++++ external/salad/include/AL/alc.h | 147 +++++++++++ external/salad/include/AL/efx.h | 530 ++++++++++++++++++++++++++++++++++++++ external/salad/include/AL/salad.h | 99 +++++++ external/salad/src/salad.c | 340 ++++++++++++++++++++++++ 8 files changed, 1481 insertions(+) create mode 100644 external/salad/CMakeLists.txt create mode 100644 external/salad/DESCRIPTION create mode 100644 external/salad/LICENSE create mode 100644 external/salad/include/AL/al.h create mode 100644 external/salad/include/AL/alc.h create mode 100644 external/salad/include/AL/efx.h create mode 100644 external/salad/include/AL/salad.h create mode 100644 external/salad/src/salad.c (limited to 'external/salad') diff --git a/external/salad/CMakeLists.txt b/external/salad/CMakeLists.txt new file mode 100644 index 0000000..d2d0a68 --- /dev/null +++ b/external/salad/CMakeLists.txt @@ -0,0 +1,10 @@ +add_library(salad STATIC + "${CMAKE_CURRENT_LIST_DIR}/include/AL/al.h" + "${CMAKE_CURRENT_LIST_DIR}/include/AL/alc.h" + "${CMAKE_CURRENT_LIST_DIR}/include/AL/efx.h" + "${CMAKE_CURRENT_LIST_DIR}/include/AL/salad.h" + "${CMAKE_CURRENT_LIST_DIR}/src/salad.c") +target_include_directories(salad PUBLIC "${CMAKE_CURRENT_LIST_DIR}/include") +set_target_properties(salad PROPERTIES FOLDER Dependencies) +target_compile_definitions(salad PRIVATE SALAD_PARANOID) +target_link_libraries(salad PUBLIC ${CMAKE_DL_LIBS}) diff --git a/external/salad/DESCRIPTION b/external/salad/DESCRIPTION new file mode 100644 index 0000000..921ba34 --- /dev/null +++ b/external/salad/DESCRIPTION @@ -0,0 +1 @@ +An OpenAL loader diff --git a/external/salad/LICENSE b/external/salad/LICENSE new file mode 100644 index 0000000..8fe551f --- /dev/null +++ b/external/salad/LICENSE @@ -0,0 +1,24 @@ +BSD 2-Clause License + +Copyright (c) 2021-2025, Kirill Dmitrievich + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/external/salad/include/AL/al.h b/external/salad/include/AL/al.h new file mode 100644 index 0000000..20e78dd --- /dev/null +++ b/external/salad/include/AL/al.h @@ -0,0 +1,330 @@ +/* + * al.h - Core OpenAL functions + * Copyright (C) 2021-2025, Kirill Dmitrievich + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef AL_AL_H +#define AL_AL_H 1 +#include + +#define OPENAL 1 + +#define AL_VERSION_1_0 1 +#define AL_VERSION_1_1 1 + +#define AL_APIENTRY SALAD_ALX_APIENTRY + +typedef salad_float32_type ALfloat; +typedef salad_float64_type ALdouble; +typedef salad_int16_type ALshort; +typedef salad_int32_type ALint; +typedef salad_int32_type ALsizei; +typedef salad_int8_type ALbyte; +typedef salad_uint16_type ALushort; +typedef salad_uint32_type ALenum; +typedef salad_uint32_type ALuint; +typedef salad_uint8_type ALboolean; +typedef salad_uint8_type ALchar; +typedef salad_uint8_type ALubyte; +typedef void ALvoid; + +#define AL_INVALID (0xFFFFFFFF) +#define AL_NONE (0x0000) +#define AL_FALSE (0x0000) +#define AL_TRUE (0x0001) + +#define AL_BITS (0x2002) +#define AL_BUFFER (0x1009) +#define AL_BUFFERS_PROCESSED (0x1016) +#define AL_BUFFERS_QUEUED (0x1015) +#define AL_BYTE_OFFSET (0x1026) +#define AL_CHANNEL_MASK (0x3000) +#define AL_CHANNELS (0x2003) +#define AL_CONE_INNER_ANGLE (0x1001) +#define AL_CONE_OUTER_ANGLE (0x1002) +#define AL_CONE_OUTER_GAIN (0x1022) +#define AL_DIRECTION (0x1005) +#define AL_DISTANCE_MODEL (0xD000) +#define AL_DOPPLER_FACTOR (0xC000) +#define AL_DOPPLER_VELOCITY (0xC001) +#define AL_EXPONENT_DISTANCE (0xD005) +#define AL_EXPONENT_DISTANCE_CLAMPED (0xD006) +#define AL_EXTENSIONS (0xB004) +#define AL_FORMAT_MONO16 (0x1101) +#define AL_FORMAT_MONO8 (0x1100) +#define AL_FORMAT_STEREO16 (0x1103) +#define AL_FORMAT_STEREO8 (0x1102) +#define AL_FREQUENCY (0x2001) +#define AL_GAIN (0x100A) +#define AL_INITIAL (0x1011) +#define AL_INVALID_ENUM (0xA002) +#define AL_INVALID_NAME (0xA001) +#define AL_INVALID_OPERATION (0xA004) +#define AL_INVALID_VALUE (0xA003) +#define AL_INVERSE_DISTANCE (0xD001) +#define AL_INVERSE_DISTANCE_CLAMPED (0xD002) +#define AL_LINEAR_DISTANCE (0xD003) +#define AL_LINEAR_DISTANCE_CLAMPED (0xD004) +#define AL_LOOPING (0x1007) +#define AL_MAX_DISTANCE (0x1023) +#define AL_MAX_GAIN (0x100E) +#define AL_MIN_GAIN (0x100D) +#define AL_NO_ERROR (0x0000) +#define AL_ORIENTATION (0x100F) +#define AL_OUT_OF_MEMORY (0xA005) +#define AL_PAUSED (0x1013) +#define AL_PENDING (0x2011) +#define AL_PITCH (0x1003) +#define AL_PLAYING (0x1012) +#define AL_POSITION (0x1004) +#define AL_PROCESSED (0x2012) +#define AL_REFERENCE_DISTANCE (0x1020) +#define AL_RENDERER (0xB003) +#define AL_ROLLOFF_FACTOR (0x1021) +#define AL_SAMPLE_OFFSET (0x1025) +#define AL_SEC_OFFSET (0x1024) +#define AL_SIZE (0x2004) +#define AL_SOURCE_RELATIVE (0x0202) +#define AL_SOURCE_STATE (0x1010) +#define AL_SOURCE_TYPE (0x1027) +#define AL_SPEED_OF_SOUND (0xC003) +#define AL_STATIC (0x1028) +#define AL_STOPPED (0x1014) +#define AL_STREAMING (0x1029) +#define AL_UNDETERMINED (0x1030) +#define AL_UNUSED (0x2010) +#define AL_VELOCITY (0x1006) +#define AL_VENDOR (0xB001) +#define AL_VERSION (0xB002) + +typedef ALboolean(AL_APIENTRY *PFN_alGetBoolean)(ALenum param); +typedef ALboolean(AL_APIENTRY *PFN_alIsBuffer)(ALuint buffer); +typedef ALboolean(AL_APIENTRY *PFN_alIsEnabled)(ALenum capability); +typedef ALboolean(AL_APIENTRY *PFN_alIsExtensionPresent)(const ALchar *extname); +typedef ALboolean(AL_APIENTRY *PFN_alIsSource)(ALuint source); +typedef ALdouble(AL_APIENTRY *PFN_alGetDouble)(ALenum param); +typedef ALenum(AL_APIENTRY *PFN_alGetEnumValue)(const ALchar *ename); +typedef ALenum(AL_APIENTRY *PFN_alGetError)(void); +typedef ALfloat(AL_APIENTRY *PFN_alGetFloat)(ALenum param); +typedef ALint(AL_APIENTRY *PFN_alGetInteger)(ALenum param); +typedef const ALchar *(AL_APIENTRY *PFN_alGetString)(ALenum param); +typedef void(AL_APIENTRY *PFN_alBuffer3f)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +typedef void(AL_APIENTRY *PFN_alBuffer3i)(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3); +typedef void(AL_APIENTRY *PFN_alBufferData)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq); +typedef void(AL_APIENTRY *PFN_alBufferf)(ALuint buffer, ALenum param, ALfloat value); +typedef void(AL_APIENTRY *PFN_alBufferfv)(ALuint buffer, ALenum param, const ALfloat *values); +typedef void(AL_APIENTRY *PFN_alBufferi)(ALuint buffer, ALenum param, ALint value); +typedef void(AL_APIENTRY *PFN_alBufferiv)(ALuint buffer, ALenum param, const ALint *values); +typedef void(AL_APIENTRY *PFN_alDeleteBuffers)(ALsizei n, const ALuint *buffers); +typedef void(AL_APIENTRY *PFN_alDeleteSources)(ALsizei n, const ALuint *sources); +typedef void(AL_APIENTRY *PFN_alDisable)(ALenum capability); +typedef void(AL_APIENTRY *PFN_alEnable)(ALenum capability); +typedef void(AL_APIENTRY *PFN_alGenBuffers)(ALsizei n, ALuint *buffers); +typedef void(AL_APIENTRY *PFN_alGenSources)(ALsizei n, ALuint *sources); +typedef void(AL_APIENTRY *PFN_alGetBooleanv)(ALenum param, ALboolean *values); +typedef void(AL_APIENTRY *PFN_alGetBuffer3f)(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +typedef void(AL_APIENTRY *PFN_alGetBuffer3i)(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3); +typedef void(AL_APIENTRY *PFN_alGetBufferf)(ALuint buffer, ALenum param, ALfloat *value); +typedef void(AL_APIENTRY *PFN_alGetBufferfv)(ALuint buffer, ALenum param, ALfloat *values); +typedef void(AL_APIENTRY *PFN_alGetBufferi)(ALuint buffer, ALenum param, ALint *value); +typedef void(AL_APIENTRY *PFN_alGetBufferiv)(ALuint buffer, ALenum param, ALint *values); +typedef void(AL_APIENTRY *PFN_alGetDoublev)(ALenum param, ALdouble *values); +typedef void(AL_APIENTRY *PFN_alGetFloatv)(ALenum param, ALfloat *values); +typedef void(AL_APIENTRY *PFN_alGetIntegerv)(ALenum param, ALint *values); +typedef void(AL_APIENTRY *PFN_alGetListener3f)(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +typedef void(AL_APIENTRY *PFN_alGetListener3i)(ALenum param, ALint *value1, ALint *value2, ALint *value3); +typedef void(AL_APIENTRY *PFN_alGetListenerf)(ALenum param, ALfloat *value); +typedef void(AL_APIENTRY *PFN_alGetListenerfv)(ALenum param, ALfloat *values); +typedef void(AL_APIENTRY *PFN_alGetListeneri)(ALenum param, ALint *value); +typedef void(AL_APIENTRY *PFN_alGetListeneriv)(ALenum param, ALint *values); +typedef void(AL_APIENTRY *PFN_alGetSource3f)(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +typedef void(AL_APIENTRY *PFN_alGetSource3i)(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3); +typedef void(AL_APIENTRY *PFN_alGetSourcef)(ALuint source, ALenum param, ALfloat *value); +typedef void(AL_APIENTRY *PFN_alGetSourcefv)(ALuint source, ALenum param, ALfloat *values); +typedef void(AL_APIENTRY *PFN_alGetSourcei)(ALuint source, ALenum param, ALint *value); +typedef void(AL_APIENTRY *PFN_alGetSourceiv)(ALuint source, ALenum param, ALint *values); +typedef void(AL_APIENTRY *PFN_alListener3f)(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +typedef void(AL_APIENTRY *PFN_alListener3i)(ALenum param, ALint value1, ALint value2, ALint value3); +typedef void(AL_APIENTRY *PFN_alListenerf)(ALenum param, ALfloat value); +typedef void(AL_APIENTRY *PFN_alListenerfv)(ALenum param, const ALfloat *values); +typedef void(AL_APIENTRY *PFN_alListeneri)(ALenum param, ALint value); +typedef void(AL_APIENTRY *PFN_alListeneriv)(ALenum param, const ALint *values); +typedef void(AL_APIENTRY *PFN_alSource3f)(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +typedef void(AL_APIENTRY *PFN_alSource3i)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3); +typedef void(AL_APIENTRY *PFN_alSourcef)(ALuint source, ALenum param, ALfloat value); +typedef void(AL_APIENTRY *PFN_alSourcefv)(ALuint source, ALenum param, const ALfloat *values); +typedef void(AL_APIENTRY *PFN_alSourcei)(ALuint source, ALenum param, ALint value); +typedef void(AL_APIENTRY *PFN_alSourceiv)(ALuint source, ALenum param, const ALint *values); +typedef void(AL_APIENTRY *PFN_alSourcePause)(ALuint source); +typedef void(AL_APIENTRY *PFN_alSourcePausev)(ALsizei n, const ALuint *sources); +typedef void(AL_APIENTRY *PFN_alSourcePlay)(ALuint source); +typedef void(AL_APIENTRY *PFN_alSourcePlayv)(ALsizei n, const ALuint *sources); +typedef void(AL_APIENTRY *PFN_alSourceQueueBuffers)(ALuint source, ALsizei nb, const ALuint *buffers); +typedef void(AL_APIENTRY *PFN_alSourceRewind)(ALuint source); +typedef void(AL_APIENTRY *PFN_alSourceRewindv)(ALsizei n, const ALuint *sources); +typedef void(AL_APIENTRY *PFN_alSourceStop)(ALuint source); +typedef void(AL_APIENTRY *PFN_alSourceStopv)(ALsizei n, const ALuint *sources); +typedef void(AL_APIENTRY *PFN_alSourceUnqueueBuffers)(ALuint source, ALsizei nb, ALuint *buffers); +typedef void*(AL_APIENTRY *PFN_alGetProcAddress)(const ALchar *fname); + +SALAD_EXTERN PFN_alBuffer3f SALAD_alBuffer3f; +SALAD_EXTERN PFN_alBuffer3i SALAD_alBuffer3i; +SALAD_EXTERN PFN_alBufferData SALAD_alBufferData; +SALAD_EXTERN PFN_alBufferf SALAD_alBufferf; +SALAD_EXTERN PFN_alBufferfv SALAD_alBufferfv; +SALAD_EXTERN PFN_alBufferi SALAD_alBufferi; +SALAD_EXTERN PFN_alBufferiv SALAD_alBufferiv; +SALAD_EXTERN PFN_alDeleteBuffers SALAD_alDeleteBuffers; +SALAD_EXTERN PFN_alDeleteSources SALAD_alDeleteSources; +SALAD_EXTERN PFN_alDisable SALAD_alDisable; +SALAD_EXTERN PFN_alEnable SALAD_alEnable; +SALAD_EXTERN PFN_alGenBuffers SALAD_alGenBuffers; +SALAD_EXTERN PFN_alGenSources SALAD_alGenSources; +SALAD_EXTERN PFN_alGetBoolean SALAD_alGetBoolean; +SALAD_EXTERN PFN_alGetBooleanv SALAD_alGetBooleanv; +SALAD_EXTERN PFN_alGetBuffer3f SALAD_alGetBuffer3f; +SALAD_EXTERN PFN_alGetBuffer3i SALAD_alGetBuffer3i; +SALAD_EXTERN PFN_alGetBufferf SALAD_alGetBufferf; +SALAD_EXTERN PFN_alGetBufferfv SALAD_alGetBufferfv; +SALAD_EXTERN PFN_alGetBufferi SALAD_alGetBufferi; +SALAD_EXTERN PFN_alGetBufferiv SALAD_alGetBufferiv; +SALAD_EXTERN PFN_alGetDouble SALAD_alGetDouble; +SALAD_EXTERN PFN_alGetDoublev SALAD_alGetDoublev; +SALAD_EXTERN PFN_alGetEnumValue SALAD_alGetEnumValue; +SALAD_EXTERN PFN_alGetError SALAD_alGetError; +SALAD_EXTERN PFN_alGetFloat SALAD_alGetFloat; +SALAD_EXTERN PFN_alGetFloatv SALAD_alGetFloatv; +SALAD_EXTERN PFN_alGetInteger SALAD_alGetInteger; +SALAD_EXTERN PFN_alGetIntegerv SALAD_alGetIntegerv; +SALAD_EXTERN PFN_alGetListener3f SALAD_alGetListener3f; +SALAD_EXTERN PFN_alGetListener3i SALAD_alGetListener3i; +SALAD_EXTERN PFN_alGetListenerf SALAD_alGetListenerf; +SALAD_EXTERN PFN_alGetListenerfv SALAD_alGetListenerfv; +SALAD_EXTERN PFN_alGetListeneri SALAD_alGetListeneri; +SALAD_EXTERN PFN_alGetListeneriv SALAD_alGetListeneriv; +SALAD_EXTERN PFN_alGetProcAddress SALAD_alGetProcAddress; +SALAD_EXTERN PFN_alGetSource3f SALAD_alGetSource3f; +SALAD_EXTERN PFN_alGetSource3i SALAD_alGetSource3i; +SALAD_EXTERN PFN_alGetSourcef SALAD_alGetSourcef; +SALAD_EXTERN PFN_alGetSourcefv SALAD_alGetSourcefv; +SALAD_EXTERN PFN_alGetSourcei SALAD_alGetSourcei; +SALAD_EXTERN PFN_alGetSourceiv SALAD_alGetSourceiv; +SALAD_EXTERN PFN_alGetString SALAD_alGetString; +SALAD_EXTERN PFN_alIsBuffer SALAD_alIsBuffer; +SALAD_EXTERN PFN_alIsEnabled SALAD_alIsEnabled; +SALAD_EXTERN PFN_alIsExtensionPresent SALAD_alIsExtensionPresent; +SALAD_EXTERN PFN_alIsSource SALAD_alIsSource; +SALAD_EXTERN PFN_alListener3f SALAD_alListener3f; +SALAD_EXTERN PFN_alListener3i SALAD_alListener3i; +SALAD_EXTERN PFN_alListenerf SALAD_alListenerf; +SALAD_EXTERN PFN_alListenerfv SALAD_alListenerfv; +SALAD_EXTERN PFN_alListeneri SALAD_alListeneri; +SALAD_EXTERN PFN_alListeneriv SALAD_alListeneriv; +SALAD_EXTERN PFN_alSource3f SALAD_alSource3f; +SALAD_EXTERN PFN_alSource3i SALAD_alSource3i; +SALAD_EXTERN PFN_alSourcef SALAD_alSourcef; +SALAD_EXTERN PFN_alSourcefv SALAD_alSourcefv; +SALAD_EXTERN PFN_alSourcei SALAD_alSourcei; +SALAD_EXTERN PFN_alSourceiv SALAD_alSourceiv; +SALAD_EXTERN PFN_alSourcePause SALAD_alSourcePause; +SALAD_EXTERN PFN_alSourcePausev SALAD_alSourcePausev; +SALAD_EXTERN PFN_alSourcePlay SALAD_alSourcePlay; +SALAD_EXTERN PFN_alSourcePlayv SALAD_alSourcePlayv; +SALAD_EXTERN PFN_alSourceQueueBuffers SALAD_alSourceQueueBuffers; +SALAD_EXTERN PFN_alSourceRewind SALAD_alSourceRewind; +SALAD_EXTERN PFN_alSourceRewindv SALAD_alSourceRewindv; +SALAD_EXTERN PFN_alSourceStop SALAD_alSourceStop; +SALAD_EXTERN PFN_alSourceStopv SALAD_alSourceStopv; +SALAD_EXTERN PFN_alSourceUnqueueBuffers SALAD_alSourceUnqueueBuffers; + +#define alBuffer3f SALAD_alBuffer3f +#define alBuffer3i SALAD_alBuffer3i +#define alBufferData SALAD_alBufferData +#define alBufferf SALAD_alBufferf +#define alBufferfv SALAD_alBufferfv +#define alBufferi SALAD_alBufferi +#define alBufferiv SALAD_alBufferiv +#define alDeleteBuffers SALAD_alDeleteBuffers +#define alDeleteSources SALAD_alDeleteSources +#define alDisable SALAD_alDisable +#define alEnable SALAD_alEnable +#define alGenBuffers SALAD_alGenBuffers +#define alGenSources SALAD_alGenSources +#define alGetBoolean SALAD_alGetBoolean +#define alGetBooleanv SALAD_alGetBooleanv +#define alGetBuffer3f SALAD_alGetBuffer3f +#define alGetBuffer3i SALAD_alGetBuffer3i +#define alGetBufferf SALAD_alGetBufferf +#define alGetBufferfv SALAD_alGetBufferfv +#define alGetBufferi SALAD_alGetBufferi +#define alGetBufferiv SALAD_alGetBufferiv +#define alGetDouble SALAD_alGetDouble +#define alGetDoublev SALAD_alGetDoublev +#define alGetEnumValue SALAD_alGetEnumValue +#define alGetError SALAD_alGetError +#define alGetFloat SALAD_alGetFloat +#define alGetFloatv SALAD_alGetFloatv +#define alGetInteger SALAD_alGetInteger +#define alGetIntegerv SALAD_alGetIntegerv +#define alGetListener3f SALAD_alGetListener3f +#define alGetListener3i SALAD_alGetListener3i +#define alGetListenerf SALAD_alGetListenerf +#define alGetListenerfv SALAD_alGetListenerfv +#define alGetListeneri SALAD_alGetListeneri +#define alGetListeneriv SALAD_alGetListeneriv +#define alGetProcAddress SALAD_alGetProcAddress +#define alGetSource3f SALAD_alGetSource3f +#define alGetSource3i SALAD_alGetSource3i +#define alGetSourcef SALAD_alGetSourcef +#define alGetSourcefv SALAD_alGetSourcefv +#define alGetSourcei SALAD_alGetSourcei +#define alGetSourceiv SALAD_alGetSourceiv +#define alGetString SALAD_alGetString +#define alIsBuffer SALAD_alIsBuffer +#define alIsEnabled SALAD_alIsEnabled +#define alIsExtensionPresent SALAD_alIsExtensionPresent +#define alIsSource SALAD_alIsSource +#define alListener3f SALAD_alListener3f +#define alListener3i SALAD_alListener3i +#define alListenerf SALAD_alListenerf +#define alListenerfv SALAD_alListenerfv +#define alListeneri SALAD_alListeneri +#define alListeneriv SALAD_alListeneriv +#define alSource3f SALAD_alSource3f +#define alSource3i SALAD_alSource3i +#define alSourcef SALAD_alSourcef +#define alSourcefv SALAD_alSourcefv +#define alSourcei SALAD_alSourcei +#define alSourceiv SALAD_alSourceiv +#define alSourcePause SALAD_alSourcePause +#define alSourcePausev SALAD_alSourcePausev +#define alSourcePlay SALAD_alSourcePlay +#define alSourcePlayv SALAD_alSourcePlayv +#define alSourceQueueBuffers SALAD_alSourceQueueBuffers +#define alSourceRewind SALAD_alSourceRewind +#define alSourceRewindv SALAD_alSourceRewindv +#define alSourceStop SALAD_alSourceStop +#define alSourceStopv SALAD_alSourceStopv +#define alSourceUnqueueBuffers SALAD_alSourceUnqueueBuffers + +#endif /* AL_AL_H */ diff --git a/external/salad/include/AL/alc.h b/external/salad/include/AL/alc.h new file mode 100644 index 0000000..4f28de8 --- /dev/null +++ b/external/salad/include/AL/alc.h @@ -0,0 +1,147 @@ +/* + * alc.h - Context OpenAL functions + * Copyright (C) 2021-2025, Kirill Dmtirievich + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef AL_ALC_H +#define AL_ALC_H 1 +#include + +#define ALC_VERSION_0_1 1 + +#define ALC_APIENTRY SALAD_ALX_APIENTRY + +typedef salad_float32_type ALCfloat; +typedef salad_float64_type ALCdouble; +typedef salad_int16_type ALCshort; +typedef salad_int32_type ALCint; +typedef salad_int32_type ALCsizei; +typedef salad_int8_type ALCbyte; +typedef salad_uint16_type ALCushort; +typedef salad_uint32_type ALCenum; +typedef salad_uint32_type ALCuint; +typedef salad_uint8_type ALCboolean; +typedef salad_uint8_type ALCchar; +typedef salad_uint8_type ALCubyte; +typedef void ALCvoid; + +struct ALCdevice; +struct ALCcontext; + +typedef struct ALCdevice ALCdevice; +typedef struct ALCcontext ALCcontext; + +#define ALC_INVALID (0x0000) +#define ALC_FALSE (0x0000) +#define ALC_TRUE (0x0001) + +#define ALC_ALL_ATTRIBUTES (0x1003) +#define ALC_ALL_DEVICES_SPECIFIER (0x1013) +#define ALC_ATTRIBUTES_SIZE (0x1002) +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER (0x0311) +#define ALC_CAPTURE_DEVICE_SPECIFIER (0x0310) +#define ALC_CAPTURE_SAMPLES (0x0312) +#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER (0x1012) +#define ALC_DEFAULT_DEVICE_SPECIFIER (0x1004) +#define ALC_DEVICE_SPECIFIER (0x1005) +#define ALC_ENUMERATE_ALL_EXT (0x0001) +#define ALC_EXT_CAPTURE (0x0001) +#define ALC_EXTENSIONS (0x1006) +#define ALC_FREQUENCY (0x1007) +#define ALC_INVALID_CONTEXT (0xA002) +#define ALC_INVALID_DEVICE (0xA001) +#define ALC_INVALID_ENUM (0xA003) +#define ALC_INVALID_VALUE (0xA004) +#define ALC_MAJOR_VERSION (0x1000) +#define ALC_MINOR_VERSION (0x1001) +#define ALC_MONO_SOURCES (0x1010) +#define ALC_NO_ERROR (0x0000) +#define ALC_OUT_OF_MEMORY (0xA005) +#define ALC_REFRESH (0x1008) +#define ALC_STEREO_SOURCES (0x1011) +#define ALC_SYNC (0x1009) + +typedef ALCboolean(ALC_APIENTRY *PFN_alcCaptureCloseDevice)(ALCdevice *device); +typedef ALCboolean(ALC_APIENTRY *PFN_alcCloseDevice)(ALCdevice *device); +typedef ALCboolean(ALC_APIENTRY *PFN_alcIsExtensionPresent)(ALCdevice *device, const ALCchar *extname); +typedef ALCboolean(ALC_APIENTRY *PFN_alcMakeContextCurrent)(ALCcontext *context); +typedef ALCcontext *(ALC_APIENTRY *PFN_alcCreateContext)(ALCdevice *device, const ALCint *attrlist); +typedef ALCcontext *(ALC_APIENTRY *PFN_alcGetCurrentContext)(void); +typedef ALCdevice *(ALC_APIENTRY *PFN_alcCaptureOpenDevice)(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize); +typedef ALCdevice *(ALC_APIENTRY *PFN_alcGetContextsDevice)(ALCcontext *context); +typedef ALCdevice *(ALC_APIENTRY *PFN_alcOpenDevice)(const ALCchar *devicename); +typedef ALCenum(ALC_APIENTRY *PFN_alcGetEnumValue)(ALCdevice *device, const ALCchar *enumname); +typedef ALCenum(ALC_APIENTRY *PFN_alcGetError)(ALCdevice *device); +typedef ALCvoid *(ALC_APIENTRY *PFN_alcGetProcAddress)(ALCdevice *device, const ALCchar *funcname); +typedef const ALCchar *(ALC_APIENTRY *PFN_alcGetString)(ALCdevice *device, ALCenum param); +typedef void(ALC_APIENTRY *PFN_alcCaptureSamples)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples); +typedef void(ALC_APIENTRY *PFN_alcCaptureStart)(ALCdevice *device); +typedef void(ALC_APIENTRY *PFN_alcCaptureStop)(ALCdevice *device); +typedef void(ALC_APIENTRY *PFN_alcDestroyContext)(ALCcontext *context); +typedef void(ALC_APIENTRY *PFN_alcGetIntegerv)(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values); +typedef void(ALC_APIENTRY *PFN_alcProcessContext)(ALCcontext *context); +typedef void(ALC_APIENTRY *PFN_alcSuspendContext)(ALCcontext *context); + +SALAD_EXTERN PFN_alcCaptureCloseDevice SALAD_alcCaptureCloseDevice; +SALAD_EXTERN PFN_alcCaptureOpenDevice SALAD_alcCaptureOpenDevice; +SALAD_EXTERN PFN_alcCaptureSamples SALAD_alcCaptureSamples; +SALAD_EXTERN PFN_alcCaptureStart SALAD_alcCaptureStart; +SALAD_EXTERN PFN_alcCaptureStop SALAD_alcCaptureStop; +SALAD_EXTERN PFN_alcCloseDevice SALAD_alcCloseDevice; +SALAD_EXTERN PFN_alcCreateContext SALAD_alcCreateContext; +SALAD_EXTERN PFN_alcDestroyContext SALAD_alcDestroyContext; +SALAD_EXTERN PFN_alcGetContextsDevice SALAD_alcGetContextsDevice; +SALAD_EXTERN PFN_alcGetCurrentContext SALAD_alcGetCurrentContext; +SALAD_EXTERN PFN_alcGetEnumValue SALAD_alcGetEnumValue; +SALAD_EXTERN PFN_alcGetError SALAD_alcGetError; +SALAD_EXTERN PFN_alcGetIntegerv SALAD_alcGetIntegerv; +SALAD_EXTERN PFN_alcGetProcAddress SALAD_alcGetProcAddress; +SALAD_EXTERN PFN_alcGetString SALAD_alcGetString; +SALAD_EXTERN PFN_alcIsExtensionPresent SALAD_alcIsExtensionPresent; +SALAD_EXTERN PFN_alcMakeContextCurrent SALAD_alcMakeContextCurrent; +SALAD_EXTERN PFN_alcOpenDevice SALAD_alcOpenDevice; +SALAD_EXTERN PFN_alcProcessContext SALAD_alcProcessContext; +SALAD_EXTERN PFN_alcSuspendContext SALAD_alcSuspendContext; + +#define alcCaptureCloseDevice SALAD_alcCaptureCloseDevice +#define alcCaptureOpenDevice SALAD_alcCaptureOpenDevice +#define alcCaptureSamples SALAD_alcCaptureSamples +#define alcCaptureStart SALAD_alcCaptureStart +#define alcCaptureStop SALAD_alcCaptureStop +#define alcCloseDevice SALAD_alcCloseDevice +#define alcCreateContext SALAD_alcCreateContext +#define alcDestroyContext SALAD_alcDestroyContext +#define alcGetContextsDevice SALAD_alcGetContextsDevice +#define alcGetCurrentContext SALAD_alcGetCurrentContext +#define alcGetEnumValue SALAD_alcGetEnumValue +#define alcGetError SALAD_alcGetError +#define alcGetIntegerv SALAD_alcGetIntegerv +#define alcGetProcAddress SALAD_alcGetProcAddress +#define alcGetString SALAD_alcGetString +#define alcIsExtensionPresent SALAD_alcIsExtensionPresent +#define alcMakeContextCurrent SALAD_alcMakeContextCurrent +#define alcOpenDevice SALAD_alcOpenDevice +#define alcProcessContext SALAD_alcProcessContext +#define alcSuspendContext SALAD_alcSuspendContext + +#endif /* AL_ALC_H */ diff --git a/external/salad/include/AL/efx.h b/external/salad/include/AL/efx.h new file mode 100644 index 0000000..80fa701 --- /dev/null +++ b/external/salad/include/AL/efx.h @@ -0,0 +1,530 @@ +/* + * efx.h - ALC_EXT_EFX extension functions + * Copyright (C) 2021-2025, Kirill Dmitrievich + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef AL_EFX_H +#define AL_EFX_H 1 +#include + +#define ALC_EXT_EFX_NAME "ALC_EXT_EFX" + +#define ALC_EFX_MAJOR_VERSION (0x20001) +#define ALC_EFX_MINOR_VERSION (0x20002) +#define ALC_MAX_AUXILIARY_SENDS (0x20003) + +#define AL_AIR_ABSORPTION_FACTOR (0x20007) + +#define AL_AUTOWAH_ATTACK_TIME (0x00001) +#define AL_AUTOWAH_PEAK_GAIN (0x00004) +#define AL_AUTOWAH_RELEASE_TIME (0x00002) +#define AL_AUTOWAH_RESONANCE (0x00003) + +#define AL_AUXILIARY_SEND_FILTER (0x20006) +#define AL_AUXILIARY_SEND_FILTER_GAIN_AUTO (0x2000B) +#define AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO (0x2000C) + +#define AL_BANDPASS_GAIN (0x00001) +#define AL_BANDPASS_GAINHF (0x00003) +#define AL_BANDPASS_GAINLF (0x00002) + +#define AL_CHORUS_DELAY (0x00006) +#define AL_CHORUS_DEPTH (0x00004) +#define AL_CHORUS_FEEDBACK (0x00005) +#define AL_CHORUS_PHASE (0x00002) +#define AL_CHORUS_RATE (0x00003) +#define AL_CHORUS_WAVEFORM (0x00001) + +#define AL_COMPRESSOR_ONOFF (0x00001) + +#define AL_CONE_OUTER_GAINHF (0x20009) + +#define AL_DIRECT_FILTER (0x20005) +#define AL_DIRECT_FILTER_GAINHF_AUTO (0x2000A) + +#define AL_DISTORTION_EDGE (0x00001) +#define AL_DISTORTION_EQBANDWIDTH (0x00005) +#define AL_DISTORTION_EQCENTER (0x00004) +#define AL_DISTORTION_GAIN (0x00002) +#define AL_DISTORTION_LOWPASS_CUTOFF (0x00003) + +#define AL_ECHO_DAMPING (0x00003) +#define AL_ECHO_DELAY (0x00001) +#define AL_ECHO_FEEDBACK (0x00004) +#define AL_ECHO_LRDELAY (0x00002) +#define AL_ECHO_SPREAD (0x00005) + +#define AL_EFFECT_AUTOWAH (0x0000A) +#define AL_EFFECT_CHORUS (0x00002) +#define AL_EFFECT_COMPRESSOR (0x0000B) +#define AL_EFFECT_DISTORTION (0x00003) +#define AL_EFFECT_ECHO (0x00004) +#define AL_EFFECT_EQUALIZER (0x0000C) +#define AL_EFFECT_FIRST_PARAMETER (0x00000) +#define AL_EFFECT_FLANGER (0x00005) +#define AL_EFFECT_FREQUENCY_SHIFTER (0x00006) +#define AL_EFFECT_LAST_PARAMETER (0x08000) +#define AL_EFFECT_NULL (0x00000) +#define AL_EFFECT_PITCH_SHIFTER (0x00008) +#define AL_EFFECT_REVERB (0x00001) +#define AL_EFFECT_RING_MODULATOR (0x00009) +#define AL_EFFECT_TYPE (0x08001) +#define AL_EFFECT_VOCAL_MORPHER (0x00007) + +#define AL_EFFECTSLOT_AUXILIARY_SEND_AUTO (0x00003) +#define AL_EFFECTSLOT_EFFECT (0x00001) +#define AL_EFFECTSLOT_GAIN (0x00002) +#define AL_EFFECTSLOT_NULL (0x00000) + +#define AL_EQUALIZER_HIGH_CUTOFF (0x0000A) +#define AL_EQUALIZER_HIGH_GAIN (0x00009) +#define AL_EQUALIZER_LOW_CUTOFF (0x00002) +#define AL_EQUALIZER_LOW_GAIN (0x00001) +#define AL_EQUALIZER_MID1_CENTER (0x00004) +#define AL_EQUALIZER_MID1_GAIN (0x00003) +#define AL_EQUALIZER_MID1_WIDTH (0x00005) +#define AL_EQUALIZER_MID2_CENTER (0x00007) +#define AL_EQUALIZER_MID2_GAIN (0x00006) +#define AL_EQUALIZER_MID2_WIDTH (0x00008) + +#define AL_FILTER_BANDPASS (0x00003) +#define AL_FILTER_FIRST_PARAMETER (0x00000) +#define AL_FILTER_HIGHPASS (0x00002) +#define AL_FILTER_LAST_PARAMETER (0x08000) +#define AL_FILTER_LOWPASS (0x00001) +#define AL_FILTER_NULL (0x00000) +#define AL_FILTER_TYPE (0x08001) + +#define AL_FLANGER_DELAY (0x00006) +#define AL_FLANGER_DEPTH (0x00004) +#define AL_FLANGER_FEEDBACK (0x00005) +#define AL_FLANGER_PHASE (0x00002) +#define AL_FLANGER_RATE (0x00003) +#define AL_FLANGER_WAVEFORM (0x00001) + +#define AL_FREQUENCY_SHIFTER_FREQUENCY (0x00001) +#define AL_FREQUENCY_SHIFTER_LEFT_DIRECTION (0x00002) +#define AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION (0x00003) + +#define AL_HIGHPASS_GAIN (0x00001) +#define AL_HIGHPASS_GAINLF (0x00002) + +#define AL_LOWPASS_GAIN (0x00001) +#define AL_LOWPASS_GAINHF (0x00002) + +#define AL_METERS_PER_UNIT (0x20004) + +#define AL_PITCH_SHIFTER_COARSE_TUNE (0x00001) +#define AL_PITCH_SHIFTER_FINE_TUNE (0x00002) + +#define AL_REVERB_AIR_ABSORPTION_GAINHF (0x0000B) +#define AL_REVERB_DECAY_HFLIMIT (0x0000D) +#define AL_REVERB_DECAY_HFRATIO (0x00006) +#define AL_REVERB_DECAY_TIME (0x00005) +#define AL_REVERB_DENSITY (0x00001) +#define AL_REVERB_DIFFUSION (0x00002) +#define AL_REVERB_GAIN (0x00003) +#define AL_REVERB_GAINHF (0x00004) +#define AL_REVERB_LATE_REVERB_DELAY (0x0000A) +#define AL_REVERB_LATE_REVERB_GAIN (0x00009) +#define AL_REVERB_REFLECTIONS_DELAY (0x00008) +#define AL_REVERB_REFLECTIONS_GAIN (0x00007) +#define AL_REVERB_ROOM_ROLLOFF_FACTOR (0x0000C) + +#define AL_RING_MODULATOR_FREQUENCY (0x00001) +#define AL_RING_MODULATOR_HIGHPASS_CUTOFF (0x00002) +#define AL_RING_MODULATOR_WAVEFORM (0x00003) + +#define AL_ROOM_ROLLOFF_FACTOR (0x20008) + +#define AL_VOCAL_MORPHER_PHONEMEA (0x00001) +#define AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING (0x00002) +#define AL_VOCAL_MORPHER_PHONEMEB (0x00003) +#define AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING (0x00004) +#define AL_VOCAL_MORPHER_RATE (0x00006) +#define AL_VOCAL_MORPHER_WAVEFORM (0x00005) + +#define AL_AUTOWAH_DEFAULT_ATTACK_TIME (0.06f) +#define AL_AUTOWAH_DEFAULT_PEAK_GAIN (11.22f) +#define AL_AUTOWAH_DEFAULT_RELEASE_TIME (0.06f) +#define AL_AUTOWAH_DEFAULT_RESONANCE (1000.0f) +#define AL_AUTOWAH_MAX_ATTACK_TIME (1.0f) +#define AL_AUTOWAH_MAX_PEAK_GAIN (31621.0f) +#define AL_AUTOWAH_MAX_RELEASE_TIME (1.0f) +#define AL_AUTOWAH_MAX_RESONANCE (1000.0f) +#define AL_AUTOWAH_MIN_ATTACK_TIME (0.0001f) +#define AL_AUTOWAH_MIN_PEAK_GAIN (0.00003f) +#define AL_AUTOWAH_MIN_RELEASE_TIME (0.0001f) +#define AL_AUTOWAH_MIN_RESONANCE (2.0f) + +#define AL_CHORUS_DEFAULT_DELAY (0.016f) +#define AL_CHORUS_DEFAULT_DEPTH (0.1f) +#define AL_CHORUS_DEFAULT_FEEDBACK (0.25f) +#define AL_CHORUS_DEFAULT_PHASE (90) +#define AL_CHORUS_DEFAULT_RATE (1.1f) +#define AL_CHORUS_DEFAULT_WAVEFORM (1) +#define AL_CHORUS_MAX_DELAY (0.016f) +#define AL_CHORUS_MAX_DEPTH (1.0f) +#define AL_CHORUS_MAX_FEEDBACK (1.0f) +#define AL_CHORUS_MAX_PHASE (180) +#define AL_CHORUS_MAX_RATE (10.0f) +#define AL_CHORUS_MAX_WAVEFORM (1) +#define AL_CHORUS_MIN_DELAY (0.0f) +#define AL_CHORUS_MIN_DEPTH (0.0f) +#define AL_CHORUS_MIN_FEEDBACK (-1.0f) +#define AL_CHORUS_MIN_PHASE (-180) +#define AL_CHORUS_MIN_RATE (0.0f) +#define AL_CHORUS_MIN_WAVEFORM (0) +#define AL_CHORUS_WAVEFORM_SINUSOID (0) +#define AL_CHORUS_WAVEFORM_TRIANGLE (1) + +#define AL_COMPRESSOR_DEFAULT_ONOFF (1) +#define AL_COMPRESSOR_MAX_ONOFF (1) +#define AL_COMPRESSOR_MIN_ONOFF (0) + +#define AL_DEFAULT_AIR_ABSORPTION_FACTOR (0.0f) +#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO (AL_TRUE) +#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO (AL_TRUE) +#define AL_DEFAULT_CONE_OUTER_GAINHF (1.0f) +#define AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO (AL_TRUE) +#define AL_DEFAULT_METERS_PER_UNIT (1.0f) +#define AL_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f) + +#define AL_DISTORTION_DEFAULT_EDGE (0.2f) +#define AL_DISTORTION_DEFAULT_EQBANDWIDTH (3600.0f) +#define AL_DISTORTION_DEFAULT_EQCENTER (3600.0f) +#define AL_DISTORTION_DEFAULT_GAIN (0.05f) +#define AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF (8000.0f) +#define AL_DISTORTION_MAX_EDGE (1.0f) +#define AL_DISTORTION_MAX_EQBANDWIDTH (24000.0f) +#define AL_DISTORTION_MAX_EQCENTER (24000.0f) +#define AL_DISTORTION_MAX_GAIN (1.0f) +#define AL_DISTORTION_MAX_LOWPASS_CUTOFF (24000.0f) +#define AL_DISTORTION_MIN_EDGE (0.0f) +#define AL_DISTORTION_MIN_EQBANDWIDTH (80.0f) +#define AL_DISTORTION_MIN_EQCENTER (80.0f) +#define AL_DISTORTION_MIN_GAIN (0.01f) +#define AL_DISTORTION_MIN_LOWPASS_CUTOFF (80.0f) + +#define AL_ECHO_DEFAULT_DAMPING (0.5f) +#define AL_ECHO_DEFAULT_DELAY (0.1f) +#define AL_ECHO_DEFAULT_FEEDBACK (0.5f) +#define AL_ECHO_DEFAULT_LRDELAY (0.1f) +#define AL_ECHO_DEFAULT_SPREAD (-1.0f) +#define AL_ECHO_MAX_DAMPING (0.99f) +#define AL_ECHO_MAX_DELAY (0.207f) +#define AL_ECHO_MAX_FEEDBACK (1.0f) +#define AL_ECHO_MAX_LRDELAY (0.404f) +#define AL_ECHO_MAX_SPREAD (1.0f) +#define AL_ECHO_MIN_DAMPING (0.0f) +#define AL_ECHO_MIN_DELAY (0.0f) +#define AL_ECHO_MIN_FEEDBACK (0.0f) +#define AL_ECHO_MIN_LRDELAY (0.0f) +#define AL_ECHO_MIN_SPREAD (-1.0f) + +#define AL_EQUALIZER_DEFAULT_HIGH_CUTOFF (6000.0f) +#define AL_EQUALIZER_DEFAULT_HIGH_GAIN (1.0f) +#define AL_EQUALIZER_DEFAULT_LOW_CUTOFF (200.0f) +#define AL_EQUALIZER_DEFAULT_LOW_GAIN (1.0f) +#define AL_EQUALIZER_DEFAULT_MID1_CENTER (500.0f) +#define AL_EQUALIZER_DEFAULT_MID1_GAIN (1.0f) +#define AL_EQUALIZER_DEFAULT_MID1_WIDTH (1.0f) +#define AL_EQUALIZER_DEFAULT_MID2_CENTER (3000.0f) +#define AL_EQUALIZER_DEFAULT_MID2_GAIN (1.0f) +#define AL_EQUALIZER_DEFAULT_MID2_WIDTH (1.0f) +#define AL_EQUALIZER_MAX_HIGH_CUTOFF (16000.0f) +#define AL_EQUALIZER_MAX_HIGH_GAIN (7.943f) +#define AL_EQUALIZER_MAX_LOW_CUTOFF (800.0f) +#define AL_EQUALIZER_MAX_LOW_GAIN (7.943f) +#define AL_EQUALIZER_MAX_MID1_CENTER (3000.0f) +#define AL_EQUALIZER_MAX_MID1_GAIN (7.943f) +#define AL_EQUALIZER_MAX_MID1_WIDTH (1.0f) +#define AL_EQUALIZER_MAX_MID2_CENTER (8000.0f) +#define AL_EQUALIZER_MAX_MID2_GAIN (7.943f) +#define AL_EQUALIZER_MAX_MID2_WIDTH (1.0f) +#define AL_EQUALIZER_MIN_HIGH_CUTOFF (4000.0f) +#define AL_EQUALIZER_MIN_HIGH_GAIN (0.126f) +#define AL_EQUALIZER_MIN_LOW_CUTOFF (50.0f) +#define AL_EQUALIZER_MIN_LOW_GAIN (0.126f) +#define AL_EQUALIZER_MIN_MID1_CENTER (200.0f) +#define AL_EQUALIZER_MIN_MID1_GAIN (0.126f) +#define AL_EQUALIZER_MIN_MID1_WIDTH (0.01f) +#define AL_EQUALIZER_MIN_MID2_CENTER (1000.0f) +#define AL_EQUALIZER_MIN_MID2_GAIN (0.126f) +#define AL_EQUALIZER_MIN_MID2_WIDTH (0.01f) + +#define AL_FLANGER_DEFAULT_DELAY (0.002f) +#define AL_FLANGER_DEFAULT_DEPTH (1.0f) +#define AL_FLANGER_DEFAULT_FEEDBACK (-0.5f) +#define AL_FLANGER_DEFAULT_PHASE (0) +#define AL_FLANGER_DEFAULT_RATE (0.27f) +#define AL_FLANGER_DEFAULT_WAVEFORM (1) +#define AL_FLANGER_MAX_DELAY (0.004f) +#define AL_FLANGER_MAX_DEPTH (1.0f) +#define AL_FLANGER_MAX_FEEDBACK (1.0f) +#define AL_FLANGER_MAX_PHASE (180) +#define AL_FLANGER_MAX_RATE (10.0f) +#define AL_FLANGER_MAX_WAVEFORM (1) +#define AL_FLANGER_MIN_DELAY (0.0f) +#define AL_FLANGER_MIN_DEPTH (0.0f) +#define AL_FLANGER_MIN_FEEDBACK (-1.0f) +#define AL_FLANGER_MIN_PHASE (-180) +#define AL_FLANGER_MIN_RATE (0.0f) +#define AL_FLANGER_MIN_WAVEFORM (0) +#define AL_FLANGER_WAVEFORM_SINUSOID (0) +#define AL_FLANGER_WAVEFORM_TRIANGLE (1) + +#define AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY (0.0f) +#define AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION (0) +#define AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION (0) +#define AL_FREQUENCY_SHIFTER_DIRECTION_DOWN (0) +#define AL_FREQUENCY_SHIFTER_DIRECTION_OFF (2) +#define AL_FREQUENCY_SHIFTER_DIRECTION_UP (1) +#define AL_FREQUENCY_SHIFTER_MAX_FREQUENCY (24000.0f) +#define AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION (2) +#define AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION (2) +#define AL_FREQUENCY_SHIFTER_MIN_FREQUENCY (0.0f) +#define AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION (0) +#define AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION (0) + +#define AL_MAX_AIR_ABSORPTION_FACTOR (10.0f) +#define AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO (AL_TRUE) +#define AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO (AL_TRUE) +#define AL_MAX_CONE_OUTER_GAINHF (1.0f) +#define AL_MAX_DIRECT_FILTER_GAINHF_AUTO (AL_TRUE) +#define AL_MAX_METERS_PER_UNIT (FLT_MAX) +#define AL_MAX_ROOM_ROLLOFF_FACTOR (10.0f) +#define AL_MIN_AIR_ABSORPTION_FACTOR (0.0f) +#define AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO (AL_FALSE) +#define AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO (AL_FALSE) +#define AL_MIN_CONE_OUTER_GAINHF (0.0f) +#define AL_MIN_DIRECT_FILTER_GAINHF_AUTO (AL_FALSE) +#define AL_MIN_METERS_PER_UNIT (FLT_MIN) +#define AL_MIN_ROOM_ROLLOFF_FACTOR (0.0f) + +#define AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE (12) +#define AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE (0) +#define AL_PITCH_SHIFTER_MAX_COARSE_TUNE (12) +#define AL_PITCH_SHIFTER_MAX_FINE_TUNE (50) +#define AL_PITCH_SHIFTER_MIN_COARSE_TUNE (-12) +#define AL_PITCH_SHIFTER_MIN_FINE_TUNE (-50) + +#define AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF (0.994f) +#define AL_REVERB_DEFAULT_DECAY_HFLIMIT (AL_TRUE) +#define AL_REVERB_DEFAULT_DECAY_HFRATIO (0.83f) +#define AL_REVERB_DEFAULT_DECAY_TIME (1.49f) +#define AL_REVERB_DEFAULT_DENSITY (1.0f) +#define AL_REVERB_DEFAULT_DIFFUSION (1.0f) +#define AL_REVERB_DEFAULT_GAIN (0.32f) +#define AL_REVERB_DEFAULT_GAINHF (0.89f) +#define AL_REVERB_DEFAULT_LATE_REVERB_DELAY (0.011f) +#define AL_REVERB_DEFAULT_LATE_REVERB_GAIN (1.26f) +#define AL_REVERB_DEFAULT_REFLECTIONS_DELAY (0.007f) +#define AL_REVERB_DEFAULT_REFLECTIONS_GAIN (0.05f) +#define AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f) +#define AL_REVERB_MAX_AIR_ABSORPTION_GAINHF (1.0f) +#define AL_REVERB_MAX_DECAY_HFLIMIT (AL_TRUE) +#define AL_REVERB_MAX_DECAY_HFRATIO (2.0f) +#define AL_REVERB_MAX_DECAY_TIME (20.0f) +#define AL_REVERB_MAX_DENSITY (1.0f) +#define AL_REVERB_MAX_DIFFUSION (1.0f) +#define AL_REVERB_MAX_GAIN (1.0f) +#define AL_REVERB_MAX_GAINHF (1.0f) +#define AL_REVERB_MAX_LATE_REVERB_DELAY (0.1f) +#define AL_REVERB_MAX_LATE_REVERB_GAIN (10.0f) +#define AL_REVERB_MAX_REFLECTIONS_DELAY (0.3f) +#define AL_REVERB_MAX_REFLECTIONS_GAIN (3.16f) +#define AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR (10.0f) +#define AL_REVERB_MIN_AIR_ABSORPTION_GAINHF (0.892f) +#define AL_REVERB_MIN_DECAY_HFLIMIT (AL_FALSE) +#define AL_REVERB_MIN_DECAY_HFRATIO (0.1f) +#define AL_REVERB_MIN_DECAY_TIME (0.1f) +#define AL_REVERB_MIN_DENSITY (0.0f) +#define AL_REVERB_MIN_DIFFUSION (0.0f) +#define AL_REVERB_MIN_GAIN (0.0f) +#define AL_REVERB_MIN_GAINHF (0.0f) +#define AL_REVERB_MIN_LATE_REVERB_DELAY (0.0f) +#define AL_REVERB_MIN_LATE_REVERB_GAIN (0.0f) +#define AL_REVERB_MIN_REFLECTIONS_DELAY (0.0f) +#define AL_REVERB_MIN_REFLECTIONS_GAIN (0.0f) +#define AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR (0.0f) + +#define AL_RING_MODULATOR_DEFAULT_FREQUENCY (440.0f) +#define AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF (800.0f) +#define AL_RING_MODULATOR_DEFAULT_WAVEFORM (0) +#define AL_RING_MODULATOR_MAX_FREQUENCY (8000.0f) +#define AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF (24000.0f) +#define AL_RING_MODULATOR_MAX_WAVEFORM (2) +#define AL_RING_MODULATOR_MIN_FREQUENCY (0.0f) +#define AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF (0.0f) +#define AL_RING_MODULATOR_MIN_WAVEFORM (0) +#define AL_RING_MODULATOR_SAWTOOTH (1) +#define AL_RING_MODULATOR_SINUSOID (0) +#define AL_RING_MODULATOR_SQUARE (2) + +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA (0) +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING (0) +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB (10) +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING (0) +#define AL_VOCAL_MORPHER_DEFAULT_RATE (1.41f) +#define AL_VOCAL_MORPHER_DEFAULT_WAVEFORM (0) +#define AL_VOCAL_MORPHER_MAX_PHONEMEA (29) +#define AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING (24) +#define AL_VOCAL_MORPHER_MAX_PHONEMEB (29) +#define AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING (24) +#define AL_VOCAL_MORPHER_MAX_RATE (10.0f) +#define AL_VOCAL_MORPHER_MAX_WAVEFORM (2) +#define AL_VOCAL_MORPHER_MIN_PHONEMEA (0) +#define AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING (-24) +#define AL_VOCAL_MORPHER_MIN_PHONEMEB (0) +#define AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING (-24) +#define AL_VOCAL_MORPHER_MIN_RATE (0.0f) +#define AL_VOCAL_MORPHER_MIN_WAVEFORM (0) +#define AL_VOCAL_MORPHER_PHONEME_A (0) +#define AL_VOCAL_MORPHER_PHONEME_AA (5) +#define AL_VOCAL_MORPHER_PHONEME_AE (6) +#define AL_VOCAL_MORPHER_PHONEME_AH (7) +#define AL_VOCAL_MORPHER_PHONEME_AO (8) +#define AL_VOCAL_MORPHER_PHONEME_B (15) +#define AL_VOCAL_MORPHER_PHONEME_D (16) +#define AL_VOCAL_MORPHER_PHONEME_E (1) +#define AL_VOCAL_MORPHER_PHONEME_EH (9) +#define AL_VOCAL_MORPHER_PHONEME_ER (10) +#define AL_VOCAL_MORPHER_PHONEME_F (17) +#define AL_VOCAL_MORPHER_PHONEME_G (18) +#define AL_VOCAL_MORPHER_PHONEME_I (2) +#define AL_VOCAL_MORPHER_PHONEME_IH (11) +#define AL_VOCAL_MORPHER_PHONEME_IY (12) +#define AL_VOCAL_MORPHER_PHONEME_J (19) +#define AL_VOCAL_MORPHER_PHONEME_K (20) +#define AL_VOCAL_MORPHER_PHONEME_L (21) +#define AL_VOCAL_MORPHER_PHONEME_M (22) +#define AL_VOCAL_MORPHER_PHONEME_N (23) +#define AL_VOCAL_MORPHER_PHONEME_O (3) +#define AL_VOCAL_MORPHER_PHONEME_P (24) +#define AL_VOCAL_MORPHER_PHONEME_R (25) +#define AL_VOCAL_MORPHER_PHONEME_S (26) +#define AL_VOCAL_MORPHER_PHONEME_T (27) +#define AL_VOCAL_MORPHER_PHONEME_U (4) +#define AL_VOCAL_MORPHER_PHONEME_UH (13) +#define AL_VOCAL_MORPHER_PHONEME_UW (14) +#define AL_VOCAL_MORPHER_PHONEME_V (28) +#define AL_VOCAL_MORPHER_PHONEME_Z (29) +#define AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH (2) +#define AL_VOCAL_MORPHER_WAVEFORM_SINUSOID (0) +#define AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE (1) + +#define BANDPASS_DEFAULT_GAIN (1.0f) +#define BANDPASS_DEFAULT_GAINHF (1.0f) +#define BANDPASS_DEFAULT_GAINLF (1.0f) +#define BANDPASS_MAX_GAIN (1.0f) +#define BANDPASS_MAX_GAINHF (1.0f) +#define BANDPASS_MAX_GAINLF (1.0f) +#define BANDPASS_MIN_GAIN (0.0f) +#define BANDPASS_MIN_GAINHF (0.0f) +#define BANDPASS_MIN_GAINLF (0.0f) + +#define HIGHPASS_DEFAULT_GAIN (1.0f) +#define HIGHPASS_DEFAULT_GAINLF (1.0f) +#define HIGHPASS_MAX_GAIN (1.0f) +#define HIGHPASS_MAX_GAINLF (1.0f) +#define HIGHPASS_MIN_GAIN (0.0f) +#define HIGHPASS_MIN_GAINLF (0.0f) + +#define LOWPASS_DEFAULT_GAIN (1.0f) +#define LOWPASS_DEFAULT_GAINHF (1.0f) +#define LOWPASS_MAX_GAIN (1.0f) +#define LOWPASS_MAX_GAINHF (1.0f) +#define LOWPASS_MIN_GAIN (0.0f) +#define LOWPASS_MIN_GAINHF (0.0f) + +typedef ALboolean (AL_APIENTRY *PFN_alIsEffect)(ALuint eid); +typedef ALboolean (AL_APIENTRY *PFN_alIsFilter)(ALuint fid); +typedef void (AL_APIENTRY *PFN_alDeleteEffects)(ALsizei n, ALuint *effects); +typedef void (AL_APIENTRY *PFN_alDeleteFilters)(ALsizei n, ALuint *filters); +typedef void (AL_APIENTRY *PFN_alEffectf)(ALuint eid, ALenum param, ALfloat value); +typedef void (AL_APIENTRY *PFN_alEffectfv)(ALuint eid, ALenum param, ALfloat *values); +typedef void (AL_APIENTRY *PFN_alEffecti)(ALuint eid, ALenum param, ALint value); +typedef void (AL_APIENTRY *PFN_alEffectiv)(ALuint eid, ALenum param, ALint *values); +typedef void (AL_APIENTRY *PFN_alFilterf)(ALuint fid, ALenum param, ALfloat value); +typedef void (AL_APIENTRY *PFN_alFilterfv)(ALuint fid, ALenum param, ALfloat *values); +typedef void (AL_APIENTRY *PFN_alFilteri)(ALuint fid, ALenum param, ALint value); +typedef void (AL_APIENTRY *PFN_alFilteriv)(ALuint fid, ALenum param, ALint *values); +typedef void (AL_APIENTRY *PFN_alGenEffects)(ALsizei n, ALuint *effects); +typedef void (AL_APIENTRY *PFN_alGenFilters)(ALsizei n, ALuint *filters); +typedef void (AL_APIENTRY *PFN_alGetEffectf)(ALuint eid, ALenum pname, ALfloat *value); +typedef void (AL_APIENTRY *PFN_alGetEffectfv)(ALuint eid, ALenum pname, ALfloat *values); +typedef void (AL_APIENTRY *PFN_alGetEffecti)(ALuint eid, ALenum pname, ALint *value); +typedef void (AL_APIENTRY *PFN_alGetEffectiv)(ALuint eid, ALenum pname, ALint *values); +typedef void (AL_APIENTRY *PFN_alGetFilterf)(ALuint fid, ALenum pname, ALfloat *value); +typedef void (AL_APIENTRY *PFN_alGetFilterfv)(ALuint fid, ALenum pname, ALfloat *values); +typedef void (AL_APIENTRY *PFN_alGetFilteri)(ALuint fid, ALenum pname, ALint *value); +typedef void (AL_APIENTRY *PFN_alGetFilteriv)(ALuint fid, ALenum pname, ALint *values); + +SALAD_EXTERN PFN_alDeleteEffects SALAD_alDeleteEffects; +SALAD_EXTERN PFN_alDeleteFilters SALAD_alDeleteFilters; +SALAD_EXTERN PFN_alEffectf SALAD_alEffectf; +SALAD_EXTERN PFN_alEffectfv SALAD_alEffectfv; +SALAD_EXTERN PFN_alEffecti SALAD_alEffecti; +SALAD_EXTERN PFN_alEffectiv SALAD_alEffectiv; +SALAD_EXTERN PFN_alFilterf SALAD_alFilterf; +SALAD_EXTERN PFN_alFilterfv SALAD_alFilterfv; +SALAD_EXTERN PFN_alFilteri SALAD_alFilteri; +SALAD_EXTERN PFN_alFilteriv SALAD_alFilteriv; +SALAD_EXTERN PFN_alGenEffects SALAD_alGenEffects; +SALAD_EXTERN PFN_alGenFilters SALAD_alGenFilters; +SALAD_EXTERN PFN_alGetEffectf SALAD_alGetEffectf; +SALAD_EXTERN PFN_alGetEffectfv SALAD_alGetEffectfv; +SALAD_EXTERN PFN_alGetEffecti SALAD_alGetEffecti; +SALAD_EXTERN PFN_alGetEffectiv SALAD_alGetEffectiv; +SALAD_EXTERN PFN_alGetFilterf SALAD_alGetFilterf; +SALAD_EXTERN PFN_alGetFilterfv SALAD_alGetFilterfv; +SALAD_EXTERN PFN_alGetFilteri SALAD_alGetFilteri; +SALAD_EXTERN PFN_alGetFilteriv SALAD_alGetFilteriv; +SALAD_EXTERN PFN_alIsEffect SALAD_alIsEffect; +SALAD_EXTERN PFN_alIsFilter SALAD_alIsFilter; + +#define alDeleteEffects SALAD_alDeleteEffects +#define alDeleteFilters SALAD_alDeleteFilters +#define alEffectf SALAD_alEffectf +#define alEffectfv SALAD_alEffectfv +#define alEffecti SALAD_alEffecti +#define alEffectiv SALAD_alEffectiv +#define alFilterf SALAD_alFilterf +#define alFilterfv SALAD_alFilterfv +#define alFilteri SALAD_alFilteri +#define alFilteriv SALAD_alFilteriv +#define alGenEffects SALAD_alGenEffects +#define alGenFilters SALAD_alGenFilters +#define alGetEffectf SALAD_alGetEffectf +#define alGetEffectfv SALAD_alGetEffectfv +#define alGetEffecti SALAD_alGetEffecti +#define alGetEffectiv SALAD_alGetEffectiv +#define alGetFilterf SALAD_alGetFilterf +#define alGetFilterfv SALAD_alGetFilterfv +#define alGetFilteri SALAD_alGetFilteri +#define alGetFilteriv SALAD_alGetFilteriv +#define alIsEffect SALAD_alIsEffect +#define alIsFilter SALAD_alIsFilter + +#endif /* AL_EFX_H */ diff --git a/external/salad/include/AL/salad.h b/external/salad/include/AL/salad.h new file mode 100644 index 0000000..cce2639 --- /dev/null +++ b/external/salad/include/AL/salad.h @@ -0,0 +1,99 @@ +/* + * salad.h - OpenAL loader declarations + * Copyright (C) 2021-2025, Kirill Dmitrievich + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef AL_SALAD_H +#define AL_SALAD_H 1 +#include + +#define SALAD_VERSION_MAJOR 0 +#define SALAD_VERSION_MINOR 0 +#define SALAD_VERSION_PATCH 2 + +#if defined(_MSC_VER) +#define SALAD_APIENTRY __cdecl +#define SALAD_ALX_APIENTRY __cdecl +#else +#define SALAD_APIENTRY +#define SALAD_ALX_APIENTRY +#endif + +#if defined(__cplusplus) +#define SALAD_EXTERN extern "C" +#else +#define SALAD_EXTERN extern +#endif + +typedef float salad_float32_type; +typedef double salad_float64_type; + +typedef signed char salad_int8_type; +typedef signed short salad_int16_type; + +typedef unsigned char salad_uint8_type; +typedef unsigned short salad_uint16_type; + +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) +#include +typedef int32_t salad_int32_type; +typedef uint32_t salad_uint32_type; +#elif defined(__cplusplus) && __cplusplus >= 201103L +#include +typedef std::int32_t salad_int32_type; +typedef std::uint32_t salad_uint32_type; +#elif defined(_WIN32) +typedef __int32 salad_int32_type; +typedef unsigned __int32 salad_uint32_type; +#else +typedef int salad_int32_type; +typedef unsigned int salad_uint32_type; +#endif + +/** + * A pointer to a function responsible for resolving a function + * with a specific name from the module loaded by SALAD or by the user + * @param procname Function name + * @param arg Optional implementation-used argument + * @returns A resolved function pointer on success, NULL on failure + */ +typedef void* (SALAD_APIENTRY *SALAD_loadfunc_type)(const char *procname, void *arg); + +/** + * Loads OpenAL and extensions using implementation-defined + * dynamic library paths and using implementation-defined API + * @returns Zero on failure, non-zero on success + */ +SALAD_EXTERN int saladLoadALdefault(void); + +/** + * Loads OpenAL and extensions using a user-provided load + * function; Initially this was used to mate Source SDK's dynamic + * linking API and OpenAL but the entire project went nowhere + * @param loadfunc User-provided load function + * @param arg Optional argument for the function + * @returns Zero on failure, non-zero on success + */ +SALAD_EXTERN int saladLoadALfunc(SALAD_loadfunc_type loadfunc, void *arg); + +#endif /* AL_SALAD_H */ diff --git a/external/salad/src/salad.c b/external/salad/src/salad.c new file mode 100644 index 0000000..3330b84 --- /dev/null +++ b/external/salad/src/salad.c @@ -0,0 +1,340 @@ +/* + * salad.c - OpenAL loader implementation + * Copyright (C) 2021-2025, Kirill Dmitrievich + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include +#include + +#include +#include +#include + +#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) +#define SALAD_POSIX 1 +#define SALAD_WIN32 0 +#elif defined(_WIN32) +#define SALAD_POSIX 0 +#define SALAD_WIN32 1 +#endif + +#if SALAD_POSIX +#include +#define salad_load_library(library) dlopen((library), RTLD_LAZY) +#define salad_get_proc(handle, proc) dlsym((handle), (proc)) +#elif SALAD_WIN32 +#define WIN32_LEAN_AND_MEAN 1 +#include +#define salad_load_library(library) ((void *)LoadLibraryA((library))) +#define salad_get_proc(handle, proc) ((void *)GetProcAddress((HMODULE)(handle), (proc))) +#endif + +#if SALAD_POSIX && defined(__APPLE__) +static const char *openal_libnames[] = { "libopenal.dylib", NULL }; +#elif SALAD_POSIX && defined(__linux__) +static const char *openal_libnames[] = { "libopenal.so.1", "libopenal.so", NULL }; +#elif SALAD_WIN32 +static const char *openal_libnames[] = { "openal32.dll", "soft_oal.dll", NULL }; +#endif + +#if SALAD_PARANOID +#define SALAD_RESOLVE(pointer, value) if(((pointer) = (value)) == NULL) return 0; else ((void)(0)) +#else +#define SALAD_RESOLVE(pointer, value) if(((pointer) = (value)) == NULL) ((void)(0)); else((void)(0)) +#endif + +/** + * The default function that uses platform-specific + * library names and a platform-specific dynamic linking API + * @param procname Function name + * @param arg Optional implementation-used argument + * @returns A resolved function pointer on success, NULL on failure + */ +static void* default_loadfunc(const char *procname, void *arg) +{ + if(arg != NULL) + return salad_get_proc(arg, procname); + return NULL; +} + +/* Core OpenAL functions */ +PFN_alBuffer3f SALAD_alBuffer3f = NULL; +PFN_alBuffer3i SALAD_alBuffer3i = NULL; +PFN_alBufferData SALAD_alBufferData = NULL; +PFN_alBufferf SALAD_alBufferf = NULL; +PFN_alBufferfv SALAD_alBufferfv = NULL; +PFN_alBufferi SALAD_alBufferi = NULL; +PFN_alBufferiv SALAD_alBufferiv = NULL; +PFN_alDeleteBuffers SALAD_alDeleteBuffers = NULL; +PFN_alDeleteSources SALAD_alDeleteSources = NULL; +PFN_alDisable SALAD_alDisable = NULL; +PFN_alEnable SALAD_alEnable = NULL; +PFN_alGenBuffers SALAD_alGenBuffers = NULL; +PFN_alGenSources SALAD_alGenSources = NULL; +PFN_alGetBoolean SALAD_alGetBoolean = NULL; +PFN_alGetBooleanv SALAD_alGetBooleanv = NULL; +PFN_alGetBuffer3f SALAD_alGetBuffer3f = NULL; +PFN_alGetBuffer3i SALAD_alGetBuffer3i = NULL; +PFN_alGetBufferf SALAD_alGetBufferf = NULL; +PFN_alGetBufferfv SALAD_alGetBufferfv = NULL; +PFN_alGetBufferi SALAD_alGetBufferi = NULL; +PFN_alGetBufferiv SALAD_alGetBufferiv = NULL; +PFN_alGetDouble SALAD_alGetDouble = NULL; +PFN_alGetDoublev SALAD_alGetDoublev = NULL; +PFN_alGetEnumValue SALAD_alGetEnumValue = NULL; +PFN_alGetError SALAD_alGetError = NULL; +PFN_alGetFloat SALAD_alGetFloat = NULL; +PFN_alGetFloatv SALAD_alGetFloatv = NULL; +PFN_alGetInteger SALAD_alGetInteger = NULL; +PFN_alGetIntegerv SALAD_alGetIntegerv = NULL; +PFN_alGetListener3f SALAD_alGetListener3f = NULL; +PFN_alGetListener3i SALAD_alGetListener3i = NULL; +PFN_alGetListenerf SALAD_alGetListenerf = NULL; +PFN_alGetListenerfv SALAD_alGetListenerfv = NULL; +PFN_alGetListeneri SALAD_alGetListeneri = NULL; +PFN_alGetListeneriv SALAD_alGetListeneriv = NULL; +PFN_alGetProcAddress SALAD_alGetProcAddress = NULL; +PFN_alGetSource3f SALAD_alGetSource3f = NULL; +PFN_alGetSource3i SALAD_alGetSource3i = NULL; +PFN_alGetSourcef SALAD_alGetSourcef = NULL; +PFN_alGetSourcefv SALAD_alGetSourcefv = NULL; +PFN_alGetSourcei SALAD_alGetSourcei = NULL; +PFN_alGetSourceiv SALAD_alGetSourceiv = NULL; +PFN_alGetString SALAD_alGetString = NULL; +PFN_alIsBuffer SALAD_alIsBuffer = NULL; +PFN_alIsEnabled SALAD_alIsEnabled = NULL; +PFN_alIsExtensionPresent SALAD_alIsExtensionPresent = NULL; +PFN_alIsSource SALAD_alIsSource = NULL; +PFN_alListener3f SALAD_alListener3f = NULL; +PFN_alListener3i SALAD_alListener3i = NULL; +PFN_alListenerf SALAD_alListenerf = NULL; +PFN_alListenerfv SALAD_alListenerfv = NULL; +PFN_alListeneri SALAD_alListeneri = NULL; +PFN_alListeneriv SALAD_alListeneriv = NULL; +PFN_alSource3f SALAD_alSource3f = NULL; +PFN_alSource3i SALAD_alSource3i = NULL; +PFN_alSourcef SALAD_alSourcef = NULL; +PFN_alSourcefv SALAD_alSourcefv = NULL; +PFN_alSourcei SALAD_alSourcei = NULL; +PFN_alSourceiv SALAD_alSourceiv = NULL; +PFN_alSourcePause SALAD_alSourcePause = NULL; +PFN_alSourcePausev SALAD_alSourcePausev = NULL; +PFN_alSourcePlay SALAD_alSourcePlay = NULL; +PFN_alSourcePlayv SALAD_alSourcePlayv = NULL; +PFN_alSourceQueueBuffers SALAD_alSourceQueueBuffers = NULL; +PFN_alSourceRewind SALAD_alSourceRewind = NULL; +PFN_alSourceRewindv SALAD_alSourceRewindv = NULL; +PFN_alSourceStop SALAD_alSourceStop = NULL; +PFN_alSourceStopv SALAD_alSourceStopv = NULL; +PFN_alSourceUnqueueBuffers SALAD_alSourceUnqueueBuffers = NULL; + +/* Context OpenAL functions */ +PFN_alcCaptureCloseDevice SALAD_alcCaptureCloseDevice = NULL; +PFN_alcCaptureOpenDevice SALAD_alcCaptureOpenDevice = NULL; +PFN_alcCaptureSamples SALAD_alcCaptureSamples = NULL; +PFN_alcCaptureStart SALAD_alcCaptureStart = NULL; +PFN_alcCaptureStop SALAD_alcCaptureStop = NULL; +PFN_alcCloseDevice SALAD_alcCloseDevice = NULL; +PFN_alcCreateContext SALAD_alcCreateContext = NULL; +PFN_alcDestroyContext SALAD_alcDestroyContext = NULL; +PFN_alcGetContextsDevice SALAD_alcGetContextsDevice = NULL; +PFN_alcGetCurrentContext SALAD_alcGetCurrentContext = NULL; +PFN_alcGetEnumValue SALAD_alcGetEnumValue = NULL; +PFN_alcGetError SALAD_alcGetError = NULL; +PFN_alcGetIntegerv SALAD_alcGetIntegerv = NULL; +PFN_alcGetProcAddress SALAD_alcGetProcAddress = NULL; +PFN_alcGetString SALAD_alcGetString = NULL; +PFN_alcIsExtensionPresent SALAD_alcIsExtensionPresent = NULL; +PFN_alcMakeContextCurrent SALAD_alcMakeContextCurrent = NULL; +PFN_alcOpenDevice SALAD_alcOpenDevice = NULL; +PFN_alcProcessContext SALAD_alcProcessContext = NULL; +PFN_alcSuspendContext SALAD_alcSuspendContext = NULL; + +/* Extension: ALC_EXT_EFX */ +PFN_alDeleteEffects SALAD_alDeleteEffects = NULL; +PFN_alDeleteFilters SALAD_alDeleteFilters = NULL; +PFN_alEffectf SALAD_alEffectf = NULL; +PFN_alEffectfv SALAD_alEffectfv = NULL; +PFN_alEffecti SALAD_alEffecti = NULL; +PFN_alEffectiv SALAD_alEffectiv = NULL; +PFN_alFilterf SALAD_alFilterf = NULL; +PFN_alFilterfv SALAD_alFilterfv = NULL; +PFN_alFilteri SALAD_alFilteri = NULL; +PFN_alFilteriv SALAD_alFilteriv = NULL; +PFN_alGenEffects SALAD_alGenEffects = NULL; +PFN_alGenFilters SALAD_alGenFilters = NULL; +PFN_alGetEffectf SALAD_alGetEffectf = NULL; +PFN_alGetEffectfv SALAD_alGetEffectfv = NULL; +PFN_alGetEffecti SALAD_alGetEffecti = NULL; +PFN_alGetEffectiv SALAD_alGetEffectiv = NULL; +PFN_alGetFilterf SALAD_alGetFilterf = NULL; +PFN_alGetFilterfv SALAD_alGetFilterfv = NULL; +PFN_alGetFilteri SALAD_alGetFilteri = NULL; +PFN_alGetFilteriv SALAD_alGetFilteriv = NULL; +PFN_alIsEffect SALAD_alIsEffect = NULL; +PFN_alIsFilter SALAD_alIsFilter = NULL; + + +int saladLoadALdefault(void) +{ + size_t i; + void *module = NULL; + + for(i = 0; openal_libnames[i]; ++i) { + if((module = salad_load_library(openal_libnames[i]))) + return saladLoadALfunc(&default_loadfunc, module); + continue; + } + + return 0; +} + +int saladLoadALfunc(SALAD_loadfunc_type loadfunc, void *arg) +{ + if(loadfunc == NULL) { + /* Don't bother continuing + * to try and load function pointers + * from literally thin air */ + return 0; + } + + SALAD_RESOLVE(SALAD_alBuffer3f, loadfunc("alBuffer3f", arg)); + SALAD_RESOLVE(SALAD_alBuffer3i, loadfunc("alBuffer3i", arg)); + SALAD_RESOLVE(SALAD_alBufferData, loadfunc("alBufferData", arg)); + SALAD_RESOLVE(SALAD_alBufferf, loadfunc("alBufferf", arg)); + SALAD_RESOLVE(SALAD_alBufferfv, loadfunc("alBufferfv", arg)); + SALAD_RESOLVE(SALAD_alBufferi, loadfunc("alBufferi", arg)); + SALAD_RESOLVE(SALAD_alBufferiv, loadfunc("alBufferiv", arg)); + SALAD_RESOLVE(SALAD_alDeleteBuffers, loadfunc("alDeleteBuffers", arg)); + SALAD_RESOLVE(SALAD_alDeleteSources, loadfunc("alDeleteSources", arg)); + SALAD_RESOLVE(SALAD_alDisable, loadfunc("alDisable", arg)); + SALAD_RESOLVE(SALAD_alEnable, loadfunc("alEnable", arg)); + SALAD_RESOLVE(SALAD_alGenBuffers, loadfunc("alGenBuffers", arg)); + SALAD_RESOLVE(SALAD_alGenSources, loadfunc("alGenSources", arg)); + SALAD_RESOLVE(SALAD_alGetBoolean, loadfunc("alGetBoolean", arg)); + SALAD_RESOLVE(SALAD_alGetBooleanv, loadfunc("alGetBooleanv", arg)); + SALAD_RESOLVE(SALAD_alGetBuffer3f, loadfunc("alGetBuffer3f", arg)); + SALAD_RESOLVE(SALAD_alGetBuffer3i, loadfunc("alGetBuffer3i", arg)); + SALAD_RESOLVE(SALAD_alGetBufferf, loadfunc("alGetBufferf", arg)); + SALAD_RESOLVE(SALAD_alGetBufferfv, loadfunc("alGetBufferfv", arg)); + SALAD_RESOLVE(SALAD_alGetBufferi, loadfunc("alGetBufferi", arg)); + SALAD_RESOLVE(SALAD_alGetBufferiv, loadfunc("alGetBufferiv", arg)); + SALAD_RESOLVE(SALAD_alGetDouble, loadfunc("alGetDouble", arg)); + SALAD_RESOLVE(SALAD_alGetDoublev, loadfunc("alGetDoublev", arg)); + SALAD_RESOLVE(SALAD_alGetEnumValue, loadfunc("alGetEnumValue", arg)); + SALAD_RESOLVE(SALAD_alGetError, loadfunc("alGetError", arg)); + SALAD_RESOLVE(SALAD_alGetFloat, loadfunc("alGetFloat", arg)); + SALAD_RESOLVE(SALAD_alGetFloatv, loadfunc("alGetFloatv", arg)); + SALAD_RESOLVE(SALAD_alGetInteger, loadfunc("alGetInteger", arg)); + SALAD_RESOLVE(SALAD_alGetIntegerv, loadfunc("alGetIntegerv", arg)); + SALAD_RESOLVE(SALAD_alGetListener3f, loadfunc("alGetListener3f", arg)); + SALAD_RESOLVE(SALAD_alGetListener3i, loadfunc("alGetListener3i", arg)); + SALAD_RESOLVE(SALAD_alGetListenerf, loadfunc("alGetListenerf", arg)); + SALAD_RESOLVE(SALAD_alGetListenerfv, loadfunc("alGetListenerfv", arg)); + SALAD_RESOLVE(SALAD_alGetListeneri, loadfunc("alGetListeneri", arg)); + SALAD_RESOLVE(SALAD_alGetListeneriv, loadfunc("alGetListeneriv", arg)); + SALAD_RESOLVE(SALAD_alGetProcAddress, loadfunc("alGetProcAddress", arg)); + SALAD_RESOLVE(SALAD_alGetSource3f, loadfunc("alGetSource3f", arg)); + SALAD_RESOLVE(SALAD_alGetSource3i, loadfunc("alGetSource3i", arg)); + SALAD_RESOLVE(SALAD_alGetSourcef, loadfunc("alGetSourcef", arg)); + SALAD_RESOLVE(SALAD_alGetSourcefv, loadfunc("alGetSourcefv", arg)); + SALAD_RESOLVE(SALAD_alGetSourcei, loadfunc("alGetSourcei", arg)); + SALAD_RESOLVE(SALAD_alGetSourceiv, loadfunc("alGetSourceiv", arg)); + SALAD_RESOLVE(SALAD_alGetString, loadfunc("alGetString", arg)); + SALAD_RESOLVE(SALAD_alIsBuffer, loadfunc("alIsBuffer", arg)); + SALAD_RESOLVE(SALAD_alIsEnabled, loadfunc("alIsEnabled", arg)); + SALAD_RESOLVE(SALAD_alIsExtensionPresent, loadfunc("alIsExtensionPresent", arg)); + SALAD_RESOLVE(SALAD_alIsSource, loadfunc("alIsSource", arg)); + SALAD_RESOLVE(SALAD_alListener3f, loadfunc("alListener3f", arg)); + SALAD_RESOLVE(SALAD_alListener3i, loadfunc("alListener3i", arg)); + SALAD_RESOLVE(SALAD_alListenerf, loadfunc("alListenerf", arg)); + SALAD_RESOLVE(SALAD_alListenerfv, loadfunc("alListenerfv", arg)); + SALAD_RESOLVE(SALAD_alListeneri, loadfunc("alListeneri", arg)); + SALAD_RESOLVE(SALAD_alListeneriv, loadfunc("alListeneriv", arg)); + SALAD_RESOLVE(SALAD_alSource3f, loadfunc("alSource3f", arg)); + SALAD_RESOLVE(SALAD_alSource3i, loadfunc("alSource3i", arg)); + SALAD_RESOLVE(SALAD_alSourcef, loadfunc("alSourcef", arg)); + SALAD_RESOLVE(SALAD_alSourcefv, loadfunc("alSourcefv", arg)); + SALAD_RESOLVE(SALAD_alSourcei, loadfunc("alSourcei", arg)); + SALAD_RESOLVE(SALAD_alSourceiv, loadfunc("alSourceiv", arg)); + SALAD_RESOLVE(SALAD_alSourcePause, loadfunc("alSourcePause", arg)); + SALAD_RESOLVE(SALAD_alSourcePausev, loadfunc("alSourcePausev", arg)); + SALAD_RESOLVE(SALAD_alSourcePlay, loadfunc("alSourcePlay", arg)); + SALAD_RESOLVE(SALAD_alSourcePlayv, loadfunc("alSourcePlayv", arg)); + SALAD_RESOLVE(SALAD_alSourceQueueBuffers, loadfunc("alSourceQueueBuffers", arg)); + SALAD_RESOLVE(SALAD_alSourceRewind, loadfunc("alSourceRewind", arg)); + SALAD_RESOLVE(SALAD_alSourceRewindv, loadfunc("alSourceRewindv", arg)); + SALAD_RESOLVE(SALAD_alSourceStop, loadfunc("alSourceStop", arg)); + SALAD_RESOLVE(SALAD_alSourceStopv, loadfunc("alSourceStopv", arg)); + SALAD_RESOLVE(SALAD_alSourceUnqueueBuffers, loadfunc("alSourceUnqueueBuffers", arg)); + + /* Context OpenAL functions */ + SALAD_RESOLVE(SALAD_alcCaptureCloseDevice, loadfunc("alcCaptureCloseDevice", arg)); + SALAD_RESOLVE(SALAD_alcCaptureOpenDevice, loadfunc("alcCaptureOpenDevice", arg)); + SALAD_RESOLVE(SALAD_alcCaptureSamples, loadfunc("alcCaptureSamples", arg)); + SALAD_RESOLVE(SALAD_alcCaptureStart, loadfunc("alcCaptureStart", arg)); + SALAD_RESOLVE(SALAD_alcCaptureStop, loadfunc("alcCaptureStop", arg)); + SALAD_RESOLVE(SALAD_alcCloseDevice, loadfunc("alcCloseDevice", arg)); + SALAD_RESOLVE(SALAD_alcCreateContext, loadfunc("alcCreateContext", arg)); + SALAD_RESOLVE(SALAD_alcDestroyContext, loadfunc("alcDestroyContext", arg)); + SALAD_RESOLVE(SALAD_alcGetContextsDevice, loadfunc("alcGetContextsDevice", arg)); + SALAD_RESOLVE(SALAD_alcGetCurrentContext, loadfunc("alcGetCurrentContext", arg)); + SALAD_RESOLVE(SALAD_alcGetEnumValue, loadfunc("alcGetEnumValue", arg)); + SALAD_RESOLVE(SALAD_alcGetError, loadfunc("alcGetError", arg)); + SALAD_RESOLVE(SALAD_alcGetIntegerv, loadfunc("alcGetIntegerv", arg)); + SALAD_RESOLVE(SALAD_alcGetProcAddress, loadfunc("alcGetProcAddress", arg)); + SALAD_RESOLVE(SALAD_alcGetString, loadfunc("alcGetString", arg)); + SALAD_RESOLVE(SALAD_alcIsExtensionPresent, loadfunc("alcIsExtensionPresent", arg)); + SALAD_RESOLVE(SALAD_alcMakeContextCurrent, loadfunc("alcMakeContextCurrent", arg)); + SALAD_RESOLVE(SALAD_alcOpenDevice, loadfunc("alcOpenDevice", arg)); + SALAD_RESOLVE(SALAD_alcProcessContext, loadfunc("alcProcessContext", arg)); + SALAD_RESOLVE(SALAD_alcSuspendContext, loadfunc("alcSuspendContext", arg)); + + /* Extension: ALC_EXT_EFX + * NOTE: these are not checked if SALAD_PARANOID + * is defined; checking if they're present is on user code */ + SALAD_alDeleteEffects = loadfunc("alDeleteEffects", arg); + SALAD_alDeleteFilters = loadfunc("alDeleteFilters", arg); + SALAD_alEffectf = loadfunc("alEffectf", arg); + SALAD_alEffectfv = loadfunc("alEffectfv", arg); + SALAD_alEffecti = loadfunc("alEffecti", arg); + SALAD_alEffectiv = loadfunc("alEffectiv", arg); + SALAD_alFilterf = loadfunc("alFilterf", arg); + SALAD_alFilterfv = loadfunc("alFilterfv", arg); + SALAD_alFilteri = loadfunc("alFilteri", arg); + SALAD_alFilteriv = loadfunc("alFilteriv", arg); + SALAD_alGenEffects = loadfunc("alGenEffects", arg); + SALAD_alGenFilters = loadfunc("alGenFilters", arg); + SALAD_alGetEffectf = loadfunc("alGetEffectf", arg); + SALAD_alGetEffectfv = loadfunc("alGetEffectfv", arg); + SALAD_alGetEffecti = loadfunc("alGetEffecti", arg); + SALAD_alGetEffectiv = loadfunc("alGetEffectiv", arg); + SALAD_alGetFilterf = loadfunc("alGetFilterf", arg); + SALAD_alGetFilterfv = loadfunc("alGetFilterfv", arg); + SALAD_alGetFilteri = loadfunc("alGetFilteri", arg); + SALAD_alGetFilteriv = loadfunc("alGetFilteriv", arg); + SALAD_alIsEffect = loadfunc("alIsEffect", arg); + SALAD_alIsFilter = loadfunc("alIsFilter", arg); + + return 1; +} -- cgit