diff --git a/Generator/Generator.csproj b/Generator/Generator.csproj new file mode 100644 index 0000000..a166eb7 --- /dev/null +++ b/Generator/Generator.csproj @@ -0,0 +1,40 @@ + + + + Exe + net8.0 + enable + enable + + + + + + + + + Always + + + Always + + + Always + + + Always + + + Always + + + Always + + + Always + + + Always + + + diff --git a/Generator/Program.cs b/Generator/Program.cs new file mode 100644 index 0000000..80f5640 --- /dev/null +++ b/Generator/Program.cs @@ -0,0 +1,9 @@ +// See https://aka.ms/new-console-template for more information +using HexaGen; +using HexaGen.Patching; + +CsCodeGeneratorConfig config = CsCodeGeneratorConfig.Load("generator.json"); +CsCodeGenerator generator = new(config); +generator.PatchEngine.RegisterPrePatch(new NamingPatch(["Alc", "Al"], NamingPatchOptions.None)); +generator.LogToConsole(); +generator.Generate(["include/main.h"], "../../../../Hexa.NET.OpenAL/Generated"); \ No newline at end of file diff --git a/Generator/generator.json b/Generator/generator.json new file mode 100644 index 0000000..89b6da1 --- /dev/null +++ b/Generator/generator.json @@ -0,0 +1,58 @@ +{ + "Namespace": "Hexa.NET.OpenAL", + "ApiName": "OpenAL", + "LibName": "OpenAL32", + "ImportType": "FunctionTable", + "GenerateSizeOfStructs": false, + "GenerateMetadata": true, + "NameMappings": { + "LPEFXEAXREVERBPROPERTIES": "LPEFXEAXReverbProperties", + "EFXEAXREVERBPROPERTIES": "EFXEAXReverbProperties" + }, + "TypeMappings": { + "uint8_t": "byte", + "uint16_t": "ushort", + "uint32_t": "uint", + "uint64_t": "ulong", + "int8_t": "sbyte", + "int32_t": "int", + "int16_t": "short", + "int64_t": "long", + "int64_t*": "long*", + "unsigned char": "byte", + "signed char": "sbyte", + "char": "byte", + "size_t": "nuint", + "bool": "bool", + "ALboolean": "byte", + "ALchar": "byte", + "ALbyte": "sbyte", + "ALubyte": "byte", + "ALshort": "short", + "ALushort": "ushort", + "ALint": "int", + "ALuint": "uint", + "ALsizei": "int", + "ALenum": "int", + "ALfloat": "float", + "ALdouble": "double", + "ALvoid": "void", + "ALint64SOFT": "long", + "ALuint64SOFT": "ulong", + "ALCboolean": "byte", + "ALCchar": "byte", + "ALCbyte": "sbyte", + "ALCubyte": "byte", + "ALCshort": "short", + "ALCushort": "ushort", + "ALCint": "int", + "ALCuint": "uint", + "ALCsizei": "int", + "ALCenum": "int", + "ALCfloat": "float", + "ALCdouble": "double", + "ALCvoid": "void", + "ALCint64SOFT": "long", + "ALCuint64SOFT": "ulong" + } +} \ No newline at end of file diff --git a/Generator/include/al.h b/Generator/include/al.h new file mode 100644 index 0000000..5071fa5 --- /dev/null +++ b/Generator/include/al.h @@ -0,0 +1,674 @@ +#ifndef AL_AL_H +#define AL_AL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef AL_API + #if defined(AL_LIBTYPE_STATIC) + #define AL_API + #elif defined(_WIN32) + #define AL_API __declspec(dllimport) + #else + #define AL_API extern + #endif +#endif + +#ifdef _WIN32 + #define AL_APIENTRY __cdecl +#else + #define AL_APIENTRY +#endif + + +/* Deprecated macros. */ +#define OPENAL +#define ALAPI AL_API +#define ALAPIENTRY AL_APIENTRY +#define AL_INVALID (-1) +#define AL_ILLEGAL_ENUM AL_INVALID_ENUM +#define AL_ILLEGAL_COMMAND AL_INVALID_OPERATION + +/* Supported AL versions. */ +#define AL_VERSION_1_0 +#define AL_VERSION_1_1 + +/** 8-bit boolean */ +typedef char ALboolean; + +/** character */ +typedef char ALchar; + +/** signed 8-bit integer */ +typedef signed char ALbyte; + +/** unsigned 8-bit integer */ +typedef unsigned char ALubyte; + +/** signed 16-bit integer */ +typedef short ALshort; + +/** unsigned 16-bit integer */ +typedef unsigned short ALushort; + +/** signed 32-bit integer */ +typedef int ALint; + +/** unsigned 32-bit integer */ +typedef unsigned int ALuint; + +/** non-negative 32-bit integer size */ +typedef int ALsizei; + +/** 32-bit enumeration value */ +typedef int ALenum; + +/** 32-bit IEEE-754 floating-point */ +typedef float ALfloat; + +/** 64-bit IEEE-754 floating-point */ +typedef double ALdouble; + +/** void type (opaque pointers only) */ +typedef void ALvoid; + + +/* Enumeration values begin at column 50. Do not use tabs. */ + +/** No distance model or no buffer */ +#define AL_NONE 0 + +/** Boolean False. */ +#define AL_FALSE 0 + +/** Boolean True. */ +#define AL_TRUE 1 + + +/** + * Relative source. + * Type: ALboolean + * Range: [AL_FALSE, AL_TRUE] + * Default: AL_FALSE + * + * Specifies if the source uses relative coordinates. + */ +#define AL_SOURCE_RELATIVE 0x202 + + +/** + * Inner cone angle, in degrees. + * Type: ALint, ALfloat + * Range: [0 - 360] + * Default: 360 + * + * The angle covered by the inner cone, the area within which the source will + * not be attenuated by direction. + */ +#define AL_CONE_INNER_ANGLE 0x1001 + +/** + * Outer cone angle, in degrees. + * Range: [0 - 360] + * Default: 360 + * + * The angle covered by the outer cone, the area outside of which the source + * will be fully attenuated by direction. + */ +#define AL_CONE_OUTER_ANGLE 0x1002 + +/** + * Source pitch. + * Type: ALfloat + * Range: [0.5 - 2.0] + * Default: 1.0 + * + * A multiplier for the sample rate of the source's buffer. + */ +#define AL_PITCH 0x1003 + +/** + * Source or listener position. + * Type: ALfloat[3], ALint[3] + * Default: {0, 0, 0} + * + * The source or listener location in three dimensional space. + * + * OpenAL uses a right handed coordinate system, like OpenGL, where with a + * default view, X points right (thumb), Y points up (index finger), and Z + * points towards the viewer/camera (middle finger). + * + * To change from or to a left handed coordinate system, negate the Z + * component. + */ +#define AL_POSITION 0x1004 + +/** + * Source direction. + * Type: ALfloat[3], ALint[3] + * Default: {0, 0, 0} + * + * Specifies the current direction in local space. A zero-length vector + * specifies an omni-directional source (cone is ignored). + * + * To change from or to a left handed coordinate system, negate the Z + * component. + */ +#define AL_DIRECTION 0x1005 + +/** + * Source or listener velocity. + * Type: ALfloat[3], ALint[3] + * Default: {0, 0, 0} + * + * Specifies the current velocity, relative to the position. + * + * To change from or to a left handed coordinate system, negate the Z + * component. + */ +#define AL_VELOCITY 0x1006 + +/** + * Source looping. + * Type: ALboolean + * Range: [AL_FALSE, AL_TRUE] + * Default: AL_FALSE + * + * Specifies whether source playback loops. + */ +#define AL_LOOPING 0x1007 + +/** + * Source buffer. + * Type: ALuint + * Range: any valid Buffer ID + * Default: AL_NONE + * + * Specifies the buffer to provide sound samples for a source. + */ +#define AL_BUFFER 0x1009 + +/** + * Source or listener gain. + * Type: ALfloat + * Range: [0.0 - ] + * + * For sources, an initial linear gain value (before attenuation is applied). + * For the listener, an output linear gain adjustment. + * + * A value of 1.0 means unattenuated. Each division by 2 equals an attenuation + * of about -6dB. Each multiplication by 2 equals an amplification of about + * +6dB. + */ +#define AL_GAIN 0x100A + +/** + * Minimum source gain. + * Type: ALfloat + * Range: [0.0 - 1.0] + * + * The minimum gain allowed for a source, after distance and cone attenuation + * are applied (if applicable). + */ +#define AL_MIN_GAIN 0x100D + +/** + * Maximum source gain. + * Type: ALfloat + * Range: [0.0 - 1.0] + * + * The maximum gain allowed for a source, after distance and cone attenuation + * are applied (if applicable). + */ +#define AL_MAX_GAIN 0x100E + +/** + * Listener orientation. + * Type: ALfloat[6] + * Default: {0.0, 0.0, -1.0, 0.0, 1.0, 0.0} + * + * Effectively two three dimensional vectors. The first vector is the front (or + * "at") and the second is the top (or "up"). Both vectors are relative to the + * listener position. + * + * To change from or to a left handed coordinate system, negate the Z + * component of both vectors. + */ +#define AL_ORIENTATION 0x100F + +/** + * Source state (query only). + * Type: ALenum + * Range: [AL_INITIAL, AL_PLAYING, AL_PAUSED, AL_STOPPED] + */ +#define AL_SOURCE_STATE 0x1010 + +/* Source state values. */ +#define AL_INITIAL 0x1011 +#define AL_PLAYING 0x1012 +#define AL_PAUSED 0x1013 +#define AL_STOPPED 0x1014 + +/** + * Source Buffer Queue size (query only). + * Type: ALint + * + * The number of buffers queued using alSourceQueueBuffers, minus the buffers + * removed with alSourceUnqueueBuffers. + */ +#define AL_BUFFERS_QUEUED 0x1015 + +/** + * Source Buffer Queue processed count (query only). + * Type: ALint + * + * The number of queued buffers that have been fully processed, and can be + * removed with alSourceUnqueueBuffers. + * + * Looping sources will never fully process buffers because they will be set to + * play again for when the source loops. + */ +#define AL_BUFFERS_PROCESSED 0x1016 + +/** + * Source reference distance. + * Type: ALfloat + * Range: [0.0 - ] + * Default: 1.0 + * + * The distance in units that no distance attenuation occurs. + * + * At 0.0, no distance attenuation occurs with non-linear attenuation models. + */ +#define AL_REFERENCE_DISTANCE 0x1020 + +/** + * Source rolloff factor. + * Type: ALfloat + * Range: [0.0 - ] + * Default: 1.0 + * + * Multiplier to exaggerate or diminish distance attenuation. + * + * At 0.0, no distance attenuation ever occurs. + */ +#define AL_ROLLOFF_FACTOR 0x1021 + +/** + * Outer cone gain. + * Type: ALfloat + * Range: [0.0 - 1.0] + * Default: 0.0 + * + * The gain attenuation applied when the listener is outside of the source's + * outer cone angle. + */ +#define AL_CONE_OUTER_GAIN 0x1022 + +/** + * Source maximum distance. + * Type: ALfloat + * Range: [0.0 - ] + * Default: FLT_MAX + * + * The distance above which the source is not attenuated any further with a + * clamped distance model, or where attenuation reaches 0.0 gain for linear + * distance models with a default rolloff factor. + */ +#define AL_MAX_DISTANCE 0x1023 + +/** Source buffer offset, in seconds */ +#define AL_SEC_OFFSET 0x1024 +/** Source buffer offset, in sample frames */ +#define AL_SAMPLE_OFFSET 0x1025 +/** Source buffer offset, in bytes */ +#define AL_BYTE_OFFSET 0x1026 + +/** + * Source type (query only). + * Type: ALenum + * Range: [AL_STATIC, AL_STREAMING, AL_UNDETERMINED] + * + * A Source is Static if a Buffer has been attached using AL_BUFFER. + * + * A Source is Streaming if one or more Buffers have been attached using + * alSourceQueueBuffers. + * + * A Source is Undetermined when it has the NULL buffer attached using + * AL_BUFFER. + */ +#define AL_SOURCE_TYPE 0x1027 + +/* Source type values. */ +#define AL_STATIC 0x1028 +#define AL_STREAMING 0x1029 +#define AL_UNDETERMINED 0x1030 + +/** Unsigned 8-bit mono buffer format. */ +#define AL_FORMAT_MONO8 0x1100 +/** Signed 16-bit mono buffer format. */ +#define AL_FORMAT_MONO16 0x1101 +/** Unsigned 8-bit stereo buffer format. */ +#define AL_FORMAT_STEREO8 0x1102 +/** Signed 16-bit stereo buffer format. */ +#define AL_FORMAT_STEREO16 0x1103 + +/** Buffer frequency/sample rate (query only). */ +#define AL_FREQUENCY 0x2001 +/** Buffer bits per sample (query only). */ +#define AL_BITS 0x2002 +/** Buffer channel count (query only). */ +#define AL_CHANNELS 0x2003 +/** Buffer data size in bytes (query only). */ +#define AL_SIZE 0x2004 + +/* Buffer state. Not for public use. */ +#define AL_UNUSED 0x2010 +#define AL_PENDING 0x2011 +#define AL_PROCESSED 0x2012 + + +/** No error. */ +#define AL_NO_ERROR 0 + +/** Invalid name (ID) passed to an AL call. */ +#define AL_INVALID_NAME 0xA001 + +/** Invalid enumeration passed to AL call. */ +#define AL_INVALID_ENUM 0xA002 + +/** Invalid value passed to AL call. */ +#define AL_INVALID_VALUE 0xA003 + +/** Illegal AL call. */ +#define AL_INVALID_OPERATION 0xA004 + +/** Not enough memory to execute the AL call. */ +#define AL_OUT_OF_MEMORY 0xA005 + + +/** Context string: Vendor name. */ +#define AL_VENDOR 0xB001 +/** Context string: Version. */ +#define AL_VERSION 0xB002 +/** Context string: Renderer name. */ +#define AL_RENDERER 0xB003 +/** Context string: Space-separated extension list. */ +#define AL_EXTENSIONS 0xB004 + +/** + * Doppler scale. + * Type: ALfloat + * Range: [0.0 - ] + * Default: 1.0 + * + * Scale for source and listener velocities. + */ +#define AL_DOPPLER_FACTOR 0xC000 + +/** + * Doppler velocity (deprecated). + * + * A multiplier applied to the Speed of Sound. + */ +#define AL_DOPPLER_VELOCITY 0xC001 + +/** + * Speed of Sound, in units per second. + * Type: ALfloat + * Range: [0.0001 - ] + * Default: 343.3 + * + * The speed at which sound waves are assumed to travel, when calculating the + * doppler effect from source and listener velocities. + */ +#define AL_SPEED_OF_SOUND 0xC003 + +/** + * Distance attenuation model. + * Type: ALenum + * Range: [AL_NONE, AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED, + * AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED, + * AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED] + * Default: AL_INVERSE_DISTANCE_CLAMPED + * + * The model by which sources attenuate with distance. + * + * None - No distance attenuation. + * Inverse - Doubling the distance halves the source gain. + * Linear - Linear gain scaling between the reference and max distances. + * Exponent - Exponential gain dropoff. + * + * Clamped variations work like the non-clamped counterparts, except the + * distance calculated is clamped between the reference and max distances. + */ +#define AL_DISTANCE_MODEL 0xD000 + +/* Distance model values. */ +#define AL_INVERSE_DISTANCE 0xD001 +#define AL_INVERSE_DISTANCE_CLAMPED 0xD002 +#define AL_LINEAR_DISTANCE 0xD003 +#define AL_LINEAR_DISTANCE_CLAMPED 0xD004 +#define AL_EXPONENT_DISTANCE 0xD005 +#define AL_EXPONENT_DISTANCE_CLAMPED 0xD006 + +#ifndef AL_NO_PROTOTYPES +/* Renderer State management. */ +AL_API void AL_APIENTRY alEnable(ALenum capability); +AL_API void AL_APIENTRY alDisable(ALenum capability); +AL_API ALboolean AL_APIENTRY alIsEnabled(ALenum capability); + +/* Context state setting. */ +AL_API void AL_APIENTRY alDopplerFactor(ALfloat value); +AL_API void AL_APIENTRY alDopplerVelocity(ALfloat value); +AL_API void AL_APIENTRY alSpeedOfSound(ALfloat value); +AL_API void AL_APIENTRY alDistanceModel(ALenum distanceModel); + +/* Context state retrieval. */ +AL_API const ALchar* AL_APIENTRY alGetString(ALenum param); +AL_API void AL_APIENTRY alGetBooleanv(ALenum param, ALboolean *values); +AL_API void AL_APIENTRY alGetIntegerv(ALenum param, ALint *values); +AL_API void AL_APIENTRY alGetFloatv(ALenum param, ALfloat *values); +AL_API void AL_APIENTRY alGetDoublev(ALenum param, ALdouble *values); +AL_API ALboolean AL_APIENTRY alGetBoolean(ALenum param); +AL_API ALint AL_APIENTRY alGetInteger(ALenum param); +AL_API ALfloat AL_APIENTRY alGetFloat(ALenum param); +AL_API ALdouble AL_APIENTRY alGetDouble(ALenum param); + +/** + * Obtain the first error generated in the AL context since the last call to + * this function. + */ +AL_API ALenum AL_APIENTRY alGetError(void); + +/** Query for the presence of an extension on the AL context. */ +AL_API ALboolean AL_APIENTRY alIsExtensionPresent(const ALchar *extname); +/** + * Retrieve the address of a function. The returned function may be context- + * specific. + */ +AL_API void* AL_APIENTRY alGetProcAddress(const ALchar *fname); +/** + * Retrieve the value of an enum. The returned value may be context-specific. + */ +AL_API ALenum AL_APIENTRY alGetEnumValue(const ALchar *ename); + + +/* Set listener parameters. */ +AL_API void AL_APIENTRY alListenerf(ALenum param, ALfloat value); +AL_API void AL_APIENTRY alListener3f(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +AL_API void AL_APIENTRY alListenerfv(ALenum param, const ALfloat *values); +AL_API void AL_APIENTRY alListeneri(ALenum param, ALint value); +AL_API void AL_APIENTRY alListener3i(ALenum param, ALint value1, ALint value2, ALint value3); +AL_API void AL_APIENTRY alListeneriv(ALenum param, const ALint *values); + +/* Get listener parameters. */ +AL_API void AL_APIENTRY alGetListenerf(ALenum param, ALfloat *value); +AL_API void AL_APIENTRY alGetListener3f(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +AL_API void AL_APIENTRY alGetListenerfv(ALenum param, ALfloat *values); +AL_API void AL_APIENTRY alGetListeneri(ALenum param, ALint *value); +AL_API void AL_APIENTRY alGetListener3i(ALenum param, ALint *value1, ALint *value2, ALint *value3); +AL_API void AL_APIENTRY alGetListeneriv(ALenum param, ALint *values); + + +/** Create source objects. */ +AL_API void AL_APIENTRY alGenSources(ALsizei n, ALuint *sources); +/** Delete source objects. */ +AL_API void AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources); +/** Verify an ID is for a valid source. */ +AL_API ALboolean AL_APIENTRY alIsSource(ALuint source); + +/* Set source parameters. */ +AL_API void AL_APIENTRY alSourcef(ALuint source, ALenum param, ALfloat value); +AL_API void AL_APIENTRY alSource3f(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +AL_API void AL_APIENTRY alSourcefv(ALuint source, ALenum param, const ALfloat *values); +AL_API void AL_APIENTRY alSourcei(ALuint source, ALenum param, ALint value); +AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3); +AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum param, const ALint *values); + +/* Get source parameters. */ +AL_API void AL_APIENTRY alGetSourcef(ALuint source, ALenum param, ALfloat *value); +AL_API void AL_APIENTRY alGetSource3f(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +AL_API void AL_APIENTRY alGetSourcefv(ALuint source, ALenum param, ALfloat *values); +AL_API void AL_APIENTRY alGetSourcei(ALuint source, ALenum param, ALint *value); +AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3); +AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum param, ALint *values); + + +/** Play, restart, or resume a source, setting its state to AL_PLAYING. */ +AL_API void AL_APIENTRY alSourcePlay(ALuint source); +/** Stop a source, setting its state to AL_STOPPED if playing or paused. */ +AL_API void AL_APIENTRY alSourceStop(ALuint source); +/** Rewind a source, setting its state to AL_INITIAL. */ +AL_API void AL_APIENTRY alSourceRewind(ALuint source); +/** Pause a source, setting its state to AL_PAUSED if playing. */ +AL_API void AL_APIENTRY alSourcePause(ALuint source); + +/** Play, restart, or resume a list of sources atomically. */ +AL_API void AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources); +/** Stop a list of sources atomically. */ +AL_API void AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources); +/** Rewind a list of sources atomically. */ +AL_API void AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources); +/** Pause a list of sources atomically. */ +AL_API void AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources); + +/** Queue buffers onto a source */ +AL_API void AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei nb, const ALuint *buffers); +/** Unqueue processed buffers from a source */ +AL_API void AL_APIENTRY alSourceUnqueueBuffers(ALuint source, ALsizei nb, ALuint *buffers); + + +/** Create buffer objects */ +AL_API void AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers); +/** Delete buffer objects */ +AL_API void AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers); +/** Verify an ID is a valid buffer (including the NULL buffer) */ +AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer); + +/** + * Copies data into the buffer, interpreting it using the specified format and + * samplerate. + */ +AL_API void AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate); + +/* Set buffer parameters. */ +AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat value); +AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values); +AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value); +AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3); +AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values); + +/* Get buffer parameters. */ +AL_API void AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value); +AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values); +AL_API void AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value); +AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3); +AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values); +#endif /* AL_NO_PROTOTYPES */ + +/* Pointer-to-function types, useful for storing dynamically loaded AL entry + * points. + */ +typedef void (AL_APIENTRY *LPALENABLE)(ALenum capability); +typedef void (AL_APIENTRY *LPALDISABLE)(ALenum capability); +typedef ALboolean (AL_APIENTRY *LPALISENABLED)(ALenum capability); +typedef const ALchar* (AL_APIENTRY *LPALGETSTRING)(ALenum param); +typedef void (AL_APIENTRY *LPALGETBOOLEANV)(ALenum param, ALboolean *values); +typedef void (AL_APIENTRY *LPALGETINTEGERV)(ALenum param, ALint *values); +typedef void (AL_APIENTRY *LPALGETFLOATV)(ALenum param, ALfloat *values); +typedef void (AL_APIENTRY *LPALGETDOUBLEV)(ALenum param, ALdouble *values); +typedef ALboolean (AL_APIENTRY *LPALGETBOOLEAN)(ALenum param); +typedef ALint (AL_APIENTRY *LPALGETINTEGER)(ALenum param); +typedef ALfloat (AL_APIENTRY *LPALGETFLOAT)(ALenum param); +typedef ALdouble (AL_APIENTRY *LPALGETDOUBLE)(ALenum param); +typedef ALenum (AL_APIENTRY *LPALGETERROR)(void); +typedef ALboolean (AL_APIENTRY *LPALISEXTENSIONPRESENT)(const ALchar *extname); +typedef void* (AL_APIENTRY *LPALGETPROCADDRESS)(const ALchar *fname); +typedef ALenum (AL_APIENTRY *LPALGETENUMVALUE)(const ALchar *ename); +typedef void (AL_APIENTRY *LPALLISTENERF)(ALenum param, ALfloat value); +typedef void (AL_APIENTRY *LPALLISTENER3F)(ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +typedef void (AL_APIENTRY *LPALLISTENERFV)(ALenum param, const ALfloat *values); +typedef void (AL_APIENTRY *LPALLISTENERI)(ALenum param, ALint value); +typedef void (AL_APIENTRY *LPALLISTENER3I)(ALenum param, ALint value1, ALint value2, ALint value3); +typedef void (AL_APIENTRY *LPALLISTENERIV)(ALenum param, const ALint *values); +typedef void (AL_APIENTRY *LPALGETLISTENERF)(ALenum param, ALfloat *value); +typedef void (AL_APIENTRY *LPALGETLISTENER3F)(ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +typedef void (AL_APIENTRY *LPALGETLISTENERFV)(ALenum param, ALfloat *values); +typedef void (AL_APIENTRY *LPALGETLISTENERI)(ALenum param, ALint *value); +typedef void (AL_APIENTRY *LPALGETLISTENER3I)(ALenum param, ALint *value1, ALint *value2, ALint *value3); +typedef void (AL_APIENTRY *LPALGETLISTENERIV)(ALenum param, ALint *values); +typedef void (AL_APIENTRY *LPALGENSOURCES)(ALsizei n, ALuint *sources); +typedef void (AL_APIENTRY *LPALDELETESOURCES)(ALsizei n, const ALuint *sources); +typedef ALboolean (AL_APIENTRY *LPALISSOURCE)(ALuint source); +typedef void (AL_APIENTRY *LPALSOURCEF)(ALuint source, ALenum param, ALfloat value); +typedef void (AL_APIENTRY *LPALSOURCE3F)(ALuint source, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +typedef void (AL_APIENTRY *LPALSOURCEFV)(ALuint source, ALenum param, const ALfloat *values); +typedef void (AL_APIENTRY *LPALSOURCEI)(ALuint source, ALenum param, ALint value); +typedef void (AL_APIENTRY *LPALSOURCE3I)(ALuint source, ALenum param, ALint value1, ALint value2, ALint value3); +typedef void (AL_APIENTRY *LPALSOURCEIV)(ALuint source, ALenum param, const ALint *values); +typedef void (AL_APIENTRY *LPALGETSOURCEF)(ALuint source, ALenum param, ALfloat *value); +typedef void (AL_APIENTRY *LPALGETSOURCE3F)(ALuint source, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +typedef void (AL_APIENTRY *LPALGETSOURCEFV)(ALuint source, ALenum param, ALfloat *values); +typedef void (AL_APIENTRY *LPALGETSOURCEI)(ALuint source, ALenum param, ALint *value); +typedef void (AL_APIENTRY *LPALGETSOURCE3I)(ALuint source, ALenum param, ALint *value1, ALint *value2, ALint *value3); +typedef void (AL_APIENTRY *LPALGETSOURCEIV)(ALuint source, ALenum param, ALint *values); +typedef void (AL_APIENTRY *LPALSOURCEPLAYV)(ALsizei n, const ALuint *sources); +typedef void (AL_APIENTRY *LPALSOURCESTOPV)(ALsizei n, const ALuint *sources); +typedef void (AL_APIENTRY *LPALSOURCEREWINDV)(ALsizei n, const ALuint *sources); +typedef void (AL_APIENTRY *LPALSOURCEPAUSEV)(ALsizei n, const ALuint *sources); +typedef void (AL_APIENTRY *LPALSOURCEPLAY)(ALuint source); +typedef void (AL_APIENTRY *LPALSOURCESTOP)(ALuint source); +typedef void (AL_APIENTRY *LPALSOURCEREWIND)(ALuint source); +typedef void (AL_APIENTRY *LPALSOURCEPAUSE)(ALuint source); +typedef void (AL_APIENTRY *LPALSOURCEQUEUEBUFFERS)(ALuint source, ALsizei nb, const ALuint *buffers); +typedef void (AL_APIENTRY *LPALSOURCEUNQUEUEBUFFERS)(ALuint source, ALsizei nb, ALuint *buffers); +typedef void (AL_APIENTRY *LPALGENBUFFERS)(ALsizei n, ALuint *buffers); +typedef void (AL_APIENTRY *LPALDELETEBUFFERS)(ALsizei n, const ALuint *buffers); +typedef ALboolean (AL_APIENTRY *LPALISBUFFER)(ALuint buffer); +typedef void (AL_APIENTRY *LPALBUFFERDATA)(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei samplerate); +typedef void (AL_APIENTRY *LPALBUFFERF)(ALuint buffer, ALenum param, ALfloat value); +typedef void (AL_APIENTRY *LPALBUFFER3F)(ALuint buffer, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3); +typedef void (AL_APIENTRY *LPALBUFFERFV)(ALuint buffer, ALenum param, const ALfloat *values); +typedef void (AL_APIENTRY *LPALBUFFERI)(ALuint buffer, ALenum param, ALint value); +typedef void (AL_APIENTRY *LPALBUFFER3I)(ALuint buffer, ALenum param, ALint value1, ALint value2, ALint value3); +typedef void (AL_APIENTRY *LPALBUFFERIV)(ALuint buffer, ALenum param, const ALint *values); +typedef void (AL_APIENTRY *LPALGETBUFFERF)(ALuint buffer, ALenum param, ALfloat *value); +typedef void (AL_APIENTRY *LPALGETBUFFER3F)(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3); +typedef void (AL_APIENTRY *LPALGETBUFFERFV)(ALuint buffer, ALenum param, ALfloat *values); +typedef void (AL_APIENTRY *LPALGETBUFFERI)(ALuint buffer, ALenum param, ALint *value); +typedef void (AL_APIENTRY *LPALGETBUFFER3I)(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3); +typedef void (AL_APIENTRY *LPALGETBUFFERIV)(ALuint buffer, ALenum param, ALint *values); +typedef void (AL_APIENTRY *LPALDOPPLERFACTOR)(ALfloat value); +typedef void (AL_APIENTRY *LPALDOPPLERVELOCITY)(ALfloat value); +typedef void (AL_APIENTRY *LPALSPEEDOFSOUND)(ALfloat value); +typedef void (AL_APIENTRY *LPALDISTANCEMODEL)(ALenum distanceModel); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* AL_AL_H */ diff --git a/Generator/include/alc.h b/Generator/include/alc.h new file mode 100644 index 0000000..6d21033 --- /dev/null +++ b/Generator/include/alc.h @@ -0,0 +1,274 @@ +#ifndef AL_ALC_H +#define AL_ALC_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef ALC_API + #if defined(AL_LIBTYPE_STATIC) + #define ALC_API + #elif defined(_WIN32) + #define ALC_API __declspec(dllimport) + #else + #define ALC_API extern + #endif +#endif + +#ifdef _WIN32 + #define ALC_APIENTRY __cdecl +#else + #define ALC_APIENTRY +#endif + + +/* Deprecated macros. */ +#define ALCAPI ALC_API +#define ALCAPIENTRY ALC_APIENTRY +#define ALC_INVALID 0 + +/** Supported ALC version? */ +#define ALC_VERSION_0_1 1 + +/** Opaque device handle */ +typedef struct ALCdevice ALCdevice; +/** Opaque context handle */ +typedef struct ALCcontext ALCcontext; + +/** 8-bit boolean */ +typedef char ALCboolean; + +/** character */ +typedef char ALCchar; + +/** signed 8-bit integer */ +typedef signed char ALCbyte; + +/** unsigned 8-bit integer */ +typedef unsigned char ALCubyte; + +/** signed 16-bit integer */ +typedef short ALCshort; + +/** unsigned 16-bit integer */ +typedef unsigned short ALCushort; + +/** signed 32-bit integer */ +typedef int ALCint; + +/** unsigned 32-bit integer */ +typedef unsigned int ALCuint; + +/** non-negative 32-bit integer size */ +typedef int ALCsizei; + +/** 32-bit enumeration value */ +typedef int ALCenum; + +/** 32-bit IEEE-754 floating-point */ +typedef float ALCfloat; + +/** 64-bit IEEE-754 floating-point */ +typedef double ALCdouble; + +/** void type (for opaque pointers only) */ +typedef void ALCvoid; + + +/* Enumeration values begin at column 50. Do not use tabs. */ + +/** Boolean False. */ +#define ALC_FALSE 0 + +/** Boolean True. */ +#define ALC_TRUE 1 + +/** Context attribute: Hz. */ +#define ALC_FREQUENCY 0x1007 + +/** Context attribute: Hz. */ +#define ALC_REFRESH 0x1008 + +/** Context attribute: AL_TRUE or AL_FALSE synchronous context? */ +#define ALC_SYNC 0x1009 + +/** Context attribute: requested Mono (3D) Sources. */ +#define ALC_MONO_SOURCES 0x1010 + +/** Context attribute: requested Stereo Sources. */ +#define ALC_STEREO_SOURCES 0x1011 + +/** No error. */ +#define ALC_NO_ERROR 0 + +/** Invalid device handle. */ +#define ALC_INVALID_DEVICE 0xA001 + +/** Invalid context handle. */ +#define ALC_INVALID_CONTEXT 0xA002 + +/** Invalid enumeration passed to an ALC call. */ +#define ALC_INVALID_ENUM 0xA003 + +/** Invalid value passed to an ALC call. */ +#define ALC_INVALID_VALUE 0xA004 + +/** Out of memory. */ +#define ALC_OUT_OF_MEMORY 0xA005 + + +/** Runtime ALC major version. */ +#define ALC_MAJOR_VERSION 0x1000 +/** Runtime ALC minor version. */ +#define ALC_MINOR_VERSION 0x1001 + +/** Context attribute list size. */ +#define ALC_ATTRIBUTES_SIZE 0x1002 +/** Context attribute list properties. */ +#define ALC_ALL_ATTRIBUTES 0x1003 + +/** String for the default device specifier. */ +#define ALC_DEFAULT_DEVICE_SPECIFIER 0x1004 +/** + * Device specifier string. + * + * If device handle is NULL, it is instead a null-character separated list of + * strings of known device specifiers (list ends with an empty string). + */ +#define ALC_DEVICE_SPECIFIER 0x1005 +/** String for space-separated list of ALC extensions. */ +#define ALC_EXTENSIONS 0x1006 + + +/** Capture extension */ +#define ALC_EXT_CAPTURE 1 +/** + * Capture device specifier string. + * + * If device handle is NULL, it is instead a null-character separated list of + * strings of known capture device specifiers (list ends with an empty string). + */ +#define ALC_CAPTURE_DEVICE_SPECIFIER 0x310 +/** String for the default capture device specifier. */ +#define ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER 0x311 +/** Number of sample frames available for capture. */ +#define ALC_CAPTURE_SAMPLES 0x312 + + +/** Enumerate All extension */ +#define ALC_ENUMERATE_ALL_EXT 1 +/** String for the default extended device specifier. */ +#define ALC_DEFAULT_ALL_DEVICES_SPECIFIER 0x1012 +/** + * Device's extended specifier string. + * + * If device handle is NULL, it is instead a null-character separated list of + * strings of known extended device specifiers (list ends with an empty string). + */ +#define ALC_ALL_DEVICES_SPECIFIER 0x1013 + + +#ifndef ALC_NO_PROTOTYPES +/* Context management. */ + +/** Create and attach a context to the given device. */ +ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrlist); +/** + * Makes the given context the active process-wide context. Passing NULL clears + * the active context. + */ +ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context); +/** Resumes processing updates for the given context. */ +ALC_API void ALC_APIENTRY alcProcessContext(ALCcontext *context); +/** Suspends updates for the given context. */ +ALC_API void ALC_APIENTRY alcSuspendContext(ALCcontext *context); +/** Remove a context from its device and destroys it. */ +ALC_API void ALC_APIENTRY alcDestroyContext(ALCcontext *context); +/** Returns the currently active context. */ +ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(void); +/** Returns the device that a particular context is attached to. */ +ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *context); + +/* Device management. */ + +/** Opens the named playback device. */ +ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *devicename); +/** Closes the given playback device. */ +ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *device); + +/* Error support. */ + +/** Obtain the most recent Device error. */ +ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device); + +/* Extension support. */ + +/** + * Query for the presence of an extension on the device. Pass a NULL device to + * query a device-inspecific extension. + */ +ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extname); +/** + * Retrieve the address of a function. Given a non-NULL device, the returned + * function may be device-specific. + */ +ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcname); +/** + * Retrieve the value of an enum. Given a non-NULL device, the returned value + * may be device-specific. + */ +ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumname); + +/* Query functions. */ + +/** Returns information about the device, and error strings. */ +ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *device, ALCenum param); +/** Returns information about the device and the version of OpenAL. */ +ALC_API void ALC_APIENTRY alcGetIntegerv(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values); + +/* Capture functions. */ + +/** + * Opens the named capture device with the given frequency, format, and buffer + * size. + */ +ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize); +/** Closes the given capture device. */ +ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *device); +/** Starts capturing samples into the device buffer. */ +ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device); +/** Stops capturing samples. Samples in the device buffer remain available. */ +ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device); +/** Reads samples from the device buffer. */ +ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples); +#endif /* ALC_NO_PROTOTYPES */ + +/* Pointer-to-function types, useful for storing dynamically loaded ALC entry + * points. + */ +typedef ALCcontext* (ALC_APIENTRY *LPALCCREATECONTEXT)(ALCdevice *device, const ALCint *attrlist); +typedef ALCboolean (ALC_APIENTRY *LPALCMAKECONTEXTCURRENT)(ALCcontext *context); +typedef void (ALC_APIENTRY *LPALCPROCESSCONTEXT)(ALCcontext *context); +typedef void (ALC_APIENTRY *LPALCSUSPENDCONTEXT)(ALCcontext *context); +typedef void (ALC_APIENTRY *LPALCDESTROYCONTEXT)(ALCcontext *context); +typedef ALCcontext* (ALC_APIENTRY *LPALCGETCURRENTCONTEXT)(void); +typedef ALCdevice* (ALC_APIENTRY *LPALCGETCONTEXTSDEVICE)(ALCcontext *context); +typedef ALCdevice* (ALC_APIENTRY *LPALCOPENDEVICE)(const ALCchar *devicename); +typedef ALCboolean (ALC_APIENTRY *LPALCCLOSEDEVICE)(ALCdevice *device); +typedef ALCenum (ALC_APIENTRY *LPALCGETERROR)(ALCdevice *device); +typedef ALCboolean (ALC_APIENTRY *LPALCISEXTENSIONPRESENT)(ALCdevice *device, const ALCchar *extname); +typedef ALCvoid* (ALC_APIENTRY *LPALCGETPROCADDRESS)(ALCdevice *device, const ALCchar *funcname); +typedef ALCenum (ALC_APIENTRY *LPALCGETENUMVALUE)(ALCdevice *device, const ALCchar *enumname); +typedef const ALCchar* (ALC_APIENTRY *LPALCGETSTRING)(ALCdevice *device, ALCenum param); +typedef void (ALC_APIENTRY *LPALCGETINTEGERV)(ALCdevice *device, ALCenum param, ALCsizei size, ALCint *values); +typedef ALCdevice* (ALC_APIENTRY *LPALCCAPTUREOPENDEVICE)(const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize); +typedef ALCboolean (ALC_APIENTRY *LPALCCAPTURECLOSEDEVICE)(ALCdevice *device); +typedef void (ALC_APIENTRY *LPALCCAPTURESTART)(ALCdevice *device); +typedef void (ALC_APIENTRY *LPALCCAPTURESTOP)(ALCdevice *device); +typedef void (ALC_APIENTRY *LPALCCAPTURESAMPLES)(ALCdevice *device, ALCvoid *buffer, ALCsizei samples); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* AL_ALC_H */ diff --git a/Generator/include/alext.h b/Generator/include/alext.h new file mode 100644 index 0000000..d313a99 --- /dev/null +++ b/Generator/include/alext.h @@ -0,0 +1,655 @@ +#ifndef AL_ALEXT_H +#define AL_ALEXT_H + +#include +/* Define int64 and uint64 types */ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ + (defined(__cplusplus) && __cplusplus >= 201103L) +#include +typedef int64_t _alsoft_int64_t; +typedef uint64_t _alsoft_uint64_t; +#elif defined(_WIN32) +typedef __int64 _alsoft_int64_t; +typedef unsigned __int64 _alsoft_uint64_t; +#else +/* Fallback if nothing above works */ +#include +typedef int64_t _alsoft_int64_t; +typedef uint64_t _alsoft_uint64_t; +#endif + +#include "alc.h" +#include "al.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef AL_LOKI_IMA_ADPCM_format +#define AL_LOKI_IMA_ADPCM_format 1 +#define AL_FORMAT_IMA_ADPCM_MONO16_EXT 0x10000 +#define AL_FORMAT_IMA_ADPCM_STEREO16_EXT 0x10001 +#endif + +#ifndef AL_LOKI_WAVE_format +#define AL_LOKI_WAVE_format 1 +#define AL_FORMAT_WAVE_EXT 0x10002 +#endif + +#ifndef AL_EXT_vorbis +#define AL_EXT_vorbis 1 +#define AL_FORMAT_VORBIS_EXT 0x10003 +#endif + +#ifndef AL_LOKI_quadriphonic +#define AL_LOKI_quadriphonic 1 +#define AL_FORMAT_QUAD8_LOKI 0x10004 +#define AL_FORMAT_QUAD16_LOKI 0x10005 +#endif + +#ifndef AL_EXT_float32 +#define AL_EXT_float32 1 +#define AL_FORMAT_MONO_FLOAT32 0x10010 +#define AL_FORMAT_STEREO_FLOAT32 0x10011 +#endif + +#ifndef AL_EXT_double +#define AL_EXT_double 1 +#define AL_FORMAT_MONO_DOUBLE_EXT 0x10012 +#define AL_FORMAT_STEREO_DOUBLE_EXT 0x10013 +#endif + +#ifndef AL_EXT_MULAW +#define AL_EXT_MULAW 1 +#define AL_FORMAT_MONO_MULAW_EXT 0x10014 +#define AL_FORMAT_STEREO_MULAW_EXT 0x10015 +#endif + +#ifndef AL_EXT_ALAW +#define AL_EXT_ALAW 1 +#define AL_FORMAT_MONO_ALAW_EXT 0x10016 +#define AL_FORMAT_STEREO_ALAW_EXT 0x10017 +#endif + +#ifndef ALC_LOKI_audio_channel +#define ALC_LOKI_audio_channel 1 +#define ALC_CHAN_MAIN_LOKI 0x500001 +#define ALC_CHAN_PCM_LOKI 0x500002 +#define ALC_CHAN_CD_LOKI 0x500003 +#endif + +#ifndef AL_EXT_MCFORMATS +#define AL_EXT_MCFORMATS 1 +/* Provides support for surround sound buffer formats with 8, 16, and 32-bit + * samples. + * + * QUAD8: Unsigned 8-bit, Quadraphonic (Front Left, Front Right, Rear Left, + * Rear Right). + * QUAD16: Signed 16-bit, Quadraphonic. + * QUAD32: 32-bit float, Quadraphonic. + * REAR8: Unsigned 8-bit, Rear Stereo (Rear Left, Rear Right). + * REAR16: Signed 16-bit, Rear Stereo. + * REAR32: 32-bit float, Rear Stereo. + * 51CHN8: Unsigned 8-bit, 5.1 Surround (Front Left, Front Right, Front Center, + * LFE, Side Left, Side Right). Note that some audio systems may label + * 5.1's Side channels as Rear or Surround; they are equivalent for the + * purposes of this extension. + * 51CHN16: Signed 16-bit, 5.1 Surround. + * 51CHN32: 32-bit float, 5.1 Surround. + * 61CHN8: Unsigned 8-bit, 6.1 Surround (Front Left, Front Right, Front Center, + * LFE, Rear Center, Side Left, Side Right). + * 61CHN16: Signed 16-bit, 6.1 Surround. + * 61CHN32: 32-bit float, 6.1 Surround. + * 71CHN8: Unsigned 8-bit, 7.1 Surround (Front Left, Front Right, Front Center, + * LFE, Rear Left, Rear Right, Side Left, Side Right). + * 71CHN16: Signed 16-bit, 7.1 Surround. + * 71CHN32: 32-bit float, 7.1 Surround. + */ +#define AL_FORMAT_QUAD8 0x1204 +#define AL_FORMAT_QUAD16 0x1205 +#define AL_FORMAT_QUAD32 0x1206 +#define AL_FORMAT_REAR8 0x1207 +#define AL_FORMAT_REAR16 0x1208 +#define AL_FORMAT_REAR32 0x1209 +#define AL_FORMAT_51CHN8 0x120A +#define AL_FORMAT_51CHN16 0x120B +#define AL_FORMAT_51CHN32 0x120C +#define AL_FORMAT_61CHN8 0x120D +#define AL_FORMAT_61CHN16 0x120E +#define AL_FORMAT_61CHN32 0x120F +#define AL_FORMAT_71CHN8 0x1210 +#define AL_FORMAT_71CHN16 0x1211 +#define AL_FORMAT_71CHN32 0x1212 +#endif + +#ifndef AL_EXT_MULAW_MCFORMATS +#define AL_EXT_MULAW_MCFORMATS 1 +#define AL_FORMAT_MONO_MULAW 0x10014 +#define AL_FORMAT_STEREO_MULAW 0x10015 +#define AL_FORMAT_QUAD_MULAW 0x10021 +#define AL_FORMAT_REAR_MULAW 0x10022 +#define AL_FORMAT_51CHN_MULAW 0x10023 +#define AL_FORMAT_61CHN_MULAW 0x10024 +#define AL_FORMAT_71CHN_MULAW 0x10025 +#endif + +#ifndef AL_EXT_IMA4 +#define AL_EXT_IMA4 1 +#define AL_FORMAT_MONO_IMA4 0x1300 +#define AL_FORMAT_STEREO_IMA4 0x1301 +#endif + +#ifndef AL_EXT_STATIC_BUFFER +#define AL_EXT_STATIC_BUFFER 1 +typedef void (AL_APIENTRY*PFNALBUFFERDATASTATICPROC)(const ALuint,ALenum,ALvoid*,ALsizei,ALsizei); +#ifdef AL_ALEXT_PROTOTYPES +void AL_APIENTRY alBufferDataStatic(const ALuint buffer, ALenum format, ALvoid *data, ALsizei size, ALsizei freq); +#endif +#endif + +#ifndef ALC_EXT_EFX +#define ALC_EXT_EFX 1 +#include "efx.h" +#endif + +#ifndef ALC_EXT_disconnect +#define ALC_EXT_disconnect 1 +#define ALC_CONNECTED 0x313 +#endif + +#ifndef ALC_EXT_thread_local_context +#define ALC_EXT_thread_local_context 1 +typedef ALCboolean (ALC_APIENTRY*PFNALCSETTHREADCONTEXTPROC)(ALCcontext *context); +typedef ALCcontext* (ALC_APIENTRY*PFNALCGETTHREADCONTEXTPROC)(void); +#ifdef AL_ALEXT_PROTOTYPES +ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context); +ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void); +#endif +#endif + +#ifndef AL_EXT_source_distance_model +#define AL_EXT_source_distance_model 1 +#define AL_SOURCE_DISTANCE_MODEL 0x200 +#endif + +#ifndef AL_SOFT_buffer_sub_data +#define AL_SOFT_buffer_sub_data 1 +#define AL_BYTE_RW_OFFSETS_SOFT 0x1031 +#define AL_SAMPLE_RW_OFFSETS_SOFT 0x1032 +typedef void (AL_APIENTRY*PFNALBUFFERSUBDATASOFTPROC)(ALuint,ALenum,const ALvoid*,ALsizei,ALsizei); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length); +#endif +#endif + +#ifndef AL_SOFT_loop_points +#define AL_SOFT_loop_points 1 +#define AL_LOOP_POINTS_SOFT 0x2015 +#endif + +#ifndef AL_EXT_FOLDBACK +#define AL_EXT_FOLDBACK 1 +#define AL_EXT_FOLDBACK_NAME "AL_EXT_FOLDBACK" +#define AL_FOLDBACK_EVENT_BLOCK 0x4112 +#define AL_FOLDBACK_EVENT_START 0x4111 +#define AL_FOLDBACK_EVENT_STOP 0x4113 +#define AL_FOLDBACK_MODE_MONO 0x4101 +#define AL_FOLDBACK_MODE_STEREO 0x4102 +typedef void (AL_APIENTRY*LPALFOLDBACKCALLBACK)(ALenum,ALsizei); +typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTART)(ALenum,ALsizei,ALsizei,ALfloat*,LPALFOLDBACKCALLBACK); +typedef void (AL_APIENTRY*LPALREQUESTFOLDBACKSTOP)(void); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alRequestFoldbackStart(ALenum mode,ALsizei count,ALsizei length,ALfloat *mem,LPALFOLDBACKCALLBACK callback); +AL_API void AL_APIENTRY alRequestFoldbackStop(void); +#endif +#endif + +#ifndef ALC_EXT_DEDICATED +#define ALC_EXT_DEDICATED 1 +#define AL_DEDICATED_GAIN 0x0001 +#define AL_EFFECT_DEDICATED_DIALOGUE 0x9001 +#define AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT 0x9000 +#endif + +#ifndef AL_SOFT_buffer_samples +#define AL_SOFT_buffer_samples 1 +/* Channel configurations */ +#define AL_MONO_SOFT 0x1500 +#define AL_STEREO_SOFT 0x1501 +#define AL_REAR_SOFT 0x1502 +#define AL_QUAD_SOFT 0x1503 +#define AL_5POINT1_SOFT 0x1504 +#define AL_6POINT1_SOFT 0x1505 +#define AL_7POINT1_SOFT 0x1506 + +/* Sample types */ +#define AL_BYTE_SOFT 0x1400 +#define AL_UNSIGNED_BYTE_SOFT 0x1401 +#define AL_SHORT_SOFT 0x1402 +#define AL_UNSIGNED_SHORT_SOFT 0x1403 +#define AL_INT_SOFT 0x1404 +#define AL_UNSIGNED_INT_SOFT 0x1405 +#define AL_FLOAT_SOFT 0x1406 +#define AL_DOUBLE_SOFT 0x1407 +#define AL_BYTE3_SOFT 0x1408 +#define AL_UNSIGNED_BYTE3_SOFT 0x1409 + +/* Storage formats */ +#define AL_MONO8_SOFT 0x1100 +#define AL_MONO16_SOFT 0x1101 +#define AL_MONO32F_SOFT 0x10010 +#define AL_STEREO8_SOFT 0x1102 +#define AL_STEREO16_SOFT 0x1103 +#define AL_STEREO32F_SOFT 0x10011 +#define AL_QUAD8_SOFT 0x1204 +#define AL_QUAD16_SOFT 0x1205 +#define AL_QUAD32F_SOFT 0x1206 +#define AL_REAR8_SOFT 0x1207 +#define AL_REAR16_SOFT 0x1208 +#define AL_REAR32F_SOFT 0x1209 +#define AL_5POINT1_8_SOFT 0x120A +#define AL_5POINT1_16_SOFT 0x120B +#define AL_5POINT1_32F_SOFT 0x120C +#define AL_6POINT1_8_SOFT 0x120D +#define AL_6POINT1_16_SOFT 0x120E +#define AL_6POINT1_32F_SOFT 0x120F +#define AL_7POINT1_8_SOFT 0x1210 +#define AL_7POINT1_16_SOFT 0x1211 +#define AL_7POINT1_32F_SOFT 0x1212 + +/* Buffer attributes */ +#define AL_INTERNAL_FORMAT_SOFT 0x2008 +#define AL_BYTE_LENGTH_SOFT 0x2009 +#define AL_SAMPLE_LENGTH_SOFT 0x200A +#define AL_SEC_LENGTH_SOFT 0x200B + +typedef void (AL_APIENTRY*LPALBUFFERSAMPLESSOFT)(ALuint,ALuint,ALenum,ALsizei,ALenum,ALenum,const ALvoid*); +typedef void (AL_APIENTRY*LPALBUFFERSUBSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,const ALvoid*); +typedef void (AL_APIENTRY*LPALGETBUFFERSAMPLESSOFT)(ALuint,ALsizei,ALsizei,ALenum,ALenum,ALvoid*); +typedef ALboolean (AL_APIENTRY*LPALISBUFFERFORMATSUPPORTEDSOFT)(ALenum); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer, ALuint samplerate, ALenum internalformat, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data); +AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, const ALvoid *data); +AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer, ALsizei offset, ALsizei samples, ALenum channels, ALenum type, ALvoid *data); +AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format); +#endif +#endif + +#ifndef AL_SOFT_direct_channels +#define AL_SOFT_direct_channels 1 +#define AL_DIRECT_CHANNELS_SOFT 0x1033 +#endif + +#ifndef ALC_SOFT_loopback +#define ALC_SOFT_loopback 1 +#define ALC_FORMAT_CHANNELS_SOFT 0x1990 +#define ALC_FORMAT_TYPE_SOFT 0x1991 + +/* Sample types */ +#define ALC_BYTE_SOFT 0x1400 +#define ALC_UNSIGNED_BYTE_SOFT 0x1401 +#define ALC_SHORT_SOFT 0x1402 +#define ALC_UNSIGNED_SHORT_SOFT 0x1403 +#define ALC_INT_SOFT 0x1404 +#define ALC_UNSIGNED_INT_SOFT 0x1405 +#define ALC_FLOAT_SOFT 0x1406 + +/* Channel configurations */ +#define ALC_MONO_SOFT 0x1500 +#define ALC_STEREO_SOFT 0x1501 +#define ALC_QUAD_SOFT 0x1503 +#define ALC_5POINT1_SOFT 0x1504 +#define ALC_6POINT1_SOFT 0x1505 +#define ALC_7POINT1_SOFT 0x1506 + +typedef ALCdevice* (ALC_APIENTRY*LPALCLOOPBACKOPENDEVICESOFT)(const ALCchar*); +typedef ALCboolean (ALC_APIENTRY*LPALCISRENDERFORMATSUPPORTEDSOFT)(ALCdevice*,ALCsizei,ALCenum,ALCenum); +typedef void (ALC_APIENTRY*LPALCRENDERSAMPLESSOFT)(ALCdevice*,ALCvoid*,ALCsizei); +#ifdef AL_ALEXT_PROTOTYPES +ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName); +ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type); +ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples); +#endif +#endif + +#ifndef AL_EXT_STEREO_ANGLES +#define AL_EXT_STEREO_ANGLES 1 +#define AL_STEREO_ANGLES 0x1030 +#endif + +#ifndef AL_EXT_SOURCE_RADIUS +#define AL_EXT_SOURCE_RADIUS 1 +#define AL_SOURCE_RADIUS 0x1031 +#endif + +#ifndef AL_SOFT_source_latency +#define AL_SOFT_source_latency 1 +#define AL_SAMPLE_OFFSET_LATENCY_SOFT 0x1200 +#define AL_SEC_OFFSET_LATENCY_SOFT 0x1201 +typedef _alsoft_int64_t ALint64SOFT; +typedef _alsoft_uint64_t ALuint64SOFT; +typedef void (AL_APIENTRY*LPALSOURCEDSOFT)(ALuint,ALenum,ALdouble); +typedef void (AL_APIENTRY*LPALSOURCE3DSOFT)(ALuint,ALenum,ALdouble,ALdouble,ALdouble); +typedef void (AL_APIENTRY*LPALSOURCEDVSOFT)(ALuint,ALenum,const ALdouble*); +typedef void (AL_APIENTRY*LPALGETSOURCEDSOFT)(ALuint,ALenum,ALdouble*); +typedef void (AL_APIENTRY*LPALGETSOURCE3DSOFT)(ALuint,ALenum,ALdouble*,ALdouble*,ALdouble*); +typedef void (AL_APIENTRY*LPALGETSOURCEDVSOFT)(ALuint,ALenum,ALdouble*); +typedef void (AL_APIENTRY*LPALSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT); +typedef void (AL_APIENTRY*LPALSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT,ALint64SOFT,ALint64SOFT); +typedef void (AL_APIENTRY*LPALSOURCEI64VSOFT)(ALuint,ALenum,const ALint64SOFT*); +typedef void (AL_APIENTRY*LPALGETSOURCEI64SOFT)(ALuint,ALenum,ALint64SOFT*); +typedef void (AL_APIENTRY*LPALGETSOURCE3I64SOFT)(ALuint,ALenum,ALint64SOFT*,ALint64SOFT*,ALint64SOFT*); +typedef void (AL_APIENTRY*LPALGETSOURCEI64VSOFT)(ALuint,ALenum,ALint64SOFT*); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alSourcedSOFT(ALuint source, ALenum param, ALdouble value); +AL_API void AL_APIENTRY alSource3dSOFT(ALuint source, ALenum param, ALdouble value1, ALdouble value2, ALdouble value3); +AL_API void AL_APIENTRY alSourcedvSOFT(ALuint source, ALenum param, const ALdouble *values); +AL_API void AL_APIENTRY alGetSourcedSOFT(ALuint source, ALenum param, ALdouble *value); +AL_API void AL_APIENTRY alGetSource3dSOFT(ALuint source, ALenum param, ALdouble *value1, ALdouble *value2, ALdouble *value3); +AL_API void AL_APIENTRY alGetSourcedvSOFT(ALuint source, ALenum param, ALdouble *values); +AL_API void AL_APIENTRY alSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT value); +AL_API void AL_APIENTRY alSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT value1, ALint64SOFT value2, ALint64SOFT value3); +AL_API void AL_APIENTRY alSourcei64vSOFT(ALuint source, ALenum param, const ALint64SOFT *values); +AL_API void AL_APIENTRY alGetSourcei64SOFT(ALuint source, ALenum param, ALint64SOFT *value); +AL_API void AL_APIENTRY alGetSource3i64SOFT(ALuint source, ALenum param, ALint64SOFT *value1, ALint64SOFT *value2, ALint64SOFT *value3); +AL_API void AL_APIENTRY alGetSourcei64vSOFT(ALuint source, ALenum param, ALint64SOFT *values); +#endif +#endif + +#ifndef ALC_EXT_DEFAULT_FILTER_ORDER +#define ALC_EXT_DEFAULT_FILTER_ORDER 1 +#define ALC_DEFAULT_FILTER_ORDER 0x1100 +#endif + +#ifndef AL_SOFT_deferred_updates +#define AL_SOFT_deferred_updates 1 +#define AL_DEFERRED_UPDATES_SOFT 0xC002 +typedef void (AL_APIENTRY*LPALDEFERUPDATESSOFT)(void); +typedef void (AL_APIENTRY*LPALPROCESSUPDATESSOFT)(void); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alDeferUpdatesSOFT(void); +AL_API void AL_APIENTRY alProcessUpdatesSOFT(void); +#endif +#endif + +#ifndef AL_SOFT_block_alignment +#define AL_SOFT_block_alignment 1 +#define AL_UNPACK_BLOCK_ALIGNMENT_SOFT 0x200C +#define AL_PACK_BLOCK_ALIGNMENT_SOFT 0x200D +#endif + +#ifndef AL_SOFT_MSADPCM +#define AL_SOFT_MSADPCM 1 +#define AL_FORMAT_MONO_MSADPCM_SOFT 0x1302 +#define AL_FORMAT_STEREO_MSADPCM_SOFT 0x1303 +#endif + +#ifndef AL_SOFT_source_length +#define AL_SOFT_source_length 1 +/*#define AL_BYTE_LENGTH_SOFT 0x2009*/ +/*#define AL_SAMPLE_LENGTH_SOFT 0x200A*/ +/*#define AL_SEC_LENGTH_SOFT 0x200B*/ +#endif + +#ifndef AL_SOFT_buffer_length_query +#define AL_SOFT_buffer_length_query 1 +/*#define AL_BYTE_LENGTH_SOFT 0x2009*/ +/*#define AL_SAMPLE_LENGTH_SOFT 0x200A*/ +/*#define AL_SEC_LENGTH_SOFT 0x200B*/ +#endif + +#ifndef ALC_SOFT_pause_device +#define ALC_SOFT_pause_device 1 +typedef void (ALC_APIENTRY*LPALCDEVICEPAUSESOFT)(ALCdevice *device); +typedef void (ALC_APIENTRY*LPALCDEVICERESUMESOFT)(ALCdevice *device); +#ifdef AL_ALEXT_PROTOTYPES +ALC_API void ALC_APIENTRY alcDevicePauseSOFT(ALCdevice *device); +ALC_API void ALC_APIENTRY alcDeviceResumeSOFT(ALCdevice *device); +#endif +#endif + +#ifndef AL_EXT_BFORMAT +#define AL_EXT_BFORMAT 1 +/* Provides support for B-Format ambisonic buffers (first-order, FuMa scaling + * and layout). + * + * BFORMAT2D_8: Unsigned 8-bit, 3-channel non-periphonic (WXY). + * BFORMAT2D_16: Signed 16-bit, 3-channel non-periphonic (WXY). + * BFORMAT2D_FLOAT32: 32-bit float, 3-channel non-periphonic (WXY). + * BFORMAT3D_8: Unsigned 8-bit, 4-channel periphonic (WXYZ). + * BFORMAT3D_16: Signed 16-bit, 4-channel periphonic (WXYZ). + * BFORMAT3D_FLOAT32: 32-bit float, 4-channel periphonic (WXYZ). + */ +#define AL_FORMAT_BFORMAT2D_8 0x20021 +#define AL_FORMAT_BFORMAT2D_16 0x20022 +#define AL_FORMAT_BFORMAT2D_FLOAT32 0x20023 +#define AL_FORMAT_BFORMAT3D_8 0x20031 +#define AL_FORMAT_BFORMAT3D_16 0x20032 +#define AL_FORMAT_BFORMAT3D_FLOAT32 0x20033 +#endif + +#ifndef AL_EXT_MULAW_BFORMAT +#define AL_EXT_MULAW_BFORMAT 1 +#define AL_FORMAT_BFORMAT2D_MULAW 0x10031 +#define AL_FORMAT_BFORMAT3D_MULAW 0x10032 +#endif + +#ifndef ALC_SOFT_HRTF +#define ALC_SOFT_HRTF 1 +#define ALC_HRTF_SOFT 0x1992 +#define ALC_DONT_CARE_SOFT 0x0002 +#define ALC_HRTF_STATUS_SOFT 0x1993 +#define ALC_HRTF_DISABLED_SOFT 0x0000 +#define ALC_HRTF_ENABLED_SOFT 0x0001 +#define ALC_HRTF_DENIED_SOFT 0x0002 +#define ALC_HRTF_REQUIRED_SOFT 0x0003 +#define ALC_HRTF_HEADPHONES_DETECTED_SOFT 0x0004 +#define ALC_HRTF_UNSUPPORTED_FORMAT_SOFT 0x0005 +#define ALC_NUM_HRTF_SPECIFIERS_SOFT 0x1994 +#define ALC_HRTF_SPECIFIER_SOFT 0x1995 +#define ALC_HRTF_ID_SOFT 0x1996 +typedef const ALCchar* (ALC_APIENTRY*LPALCGETSTRINGISOFT)(ALCdevice *device, ALCenum paramName, ALCsizei index); +typedef ALCboolean (ALC_APIENTRY*LPALCRESETDEVICESOFT)(ALCdevice *device, const ALCint *attribs); +#ifdef AL_ALEXT_PROTOTYPES +ALC_API const ALCchar* ALC_APIENTRY alcGetStringiSOFT(ALCdevice *device, ALCenum paramName, ALCsizei index); +ALC_API ALCboolean ALC_APIENTRY alcResetDeviceSOFT(ALCdevice *device, const ALCint *attribs); +#endif +#endif + +#ifndef AL_SOFT_gain_clamp_ex +#define AL_SOFT_gain_clamp_ex 1 +#define AL_GAIN_LIMIT_SOFT 0x200E +#endif + +#ifndef AL_SOFT_source_resampler +#define AL_SOFT_source_resampler +#define AL_NUM_RESAMPLERS_SOFT 0x1210 +#define AL_DEFAULT_RESAMPLER_SOFT 0x1211 +#define AL_SOURCE_RESAMPLER_SOFT 0x1212 +#define AL_RESAMPLER_NAME_SOFT 0x1213 +typedef const ALchar* (AL_APIENTRY*LPALGETSTRINGISOFT)(ALenum pname, ALsizei index); +#ifdef AL_ALEXT_PROTOTYPES +AL_API const ALchar* AL_APIENTRY alGetStringiSOFT(ALenum pname, ALsizei index); +#endif +#endif + +#ifndef AL_SOFT_source_spatialize +#define AL_SOFT_source_spatialize +#define AL_SOURCE_SPATIALIZE_SOFT 0x1214 +#define AL_AUTO_SOFT 0x0002 +#endif + +#ifndef ALC_SOFT_output_limiter +#define ALC_SOFT_output_limiter +#define ALC_OUTPUT_LIMITER_SOFT 0x199A +#endif + +#ifndef ALC_SOFT_device_clock +#define ALC_SOFT_device_clock 1 +typedef _alsoft_int64_t ALCint64SOFT; +typedef _alsoft_uint64_t ALCuint64SOFT; +#define ALC_DEVICE_CLOCK_SOFT 0x1600 +#define ALC_DEVICE_LATENCY_SOFT 0x1601 +#define ALC_DEVICE_CLOCK_LATENCY_SOFT 0x1602 +#define AL_SAMPLE_OFFSET_CLOCK_SOFT 0x1202 +#define AL_SEC_OFFSET_CLOCK_SOFT 0x1203 +typedef void (ALC_APIENTRY*LPALCGETINTEGER64VSOFT)(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values); +#ifdef AL_ALEXT_PROTOTYPES +ALC_API void ALC_APIENTRY alcGetInteger64vSOFT(ALCdevice *device, ALCenum pname, ALsizei size, ALCint64SOFT *values); +#endif +#endif + +#ifndef AL_SOFT_direct_channels_remix +#define AL_SOFT_direct_channels_remix 1 +#define AL_DROP_UNMATCHED_SOFT 0x0001 +#define AL_REMIX_UNMATCHED_SOFT 0x0002 +#endif + +#ifndef AL_SOFT_bformat_ex +#define AL_SOFT_bformat_ex 1 +#define AL_AMBISONIC_LAYOUT_SOFT 0x1997 +#define AL_AMBISONIC_SCALING_SOFT 0x1998 + +/* Ambisonic layouts */ +#define AL_FUMA_SOFT 0x0000 +#define AL_ACN_SOFT 0x0001 + +/* Ambisonic scalings (normalization) */ +/*#define AL_FUMA_SOFT*/ +#define AL_SN3D_SOFT 0x0001 +#define AL_N3D_SOFT 0x0002 +#endif + +#ifndef ALC_SOFT_loopback_bformat +#define ALC_SOFT_loopback_bformat 1 +#define ALC_AMBISONIC_LAYOUT_SOFT 0x1997 +#define ALC_AMBISONIC_SCALING_SOFT 0x1998 +#define ALC_AMBISONIC_ORDER_SOFT 0x1999 +#define ALC_MAX_AMBISONIC_ORDER_SOFT 0x199B + +#define ALC_BFORMAT3D_SOFT 0x1507 + +/* Ambisonic layouts */ +#define ALC_FUMA_SOFT 0x0000 +#define ALC_ACN_SOFT 0x0001 + +/* Ambisonic scalings (normalization) */ +/*#define ALC_FUMA_SOFT*/ +#define ALC_SN3D_SOFT 0x0001 +#define ALC_N3D_SOFT 0x0002 +#endif + +#ifndef AL_SOFT_effect_target +#define AL_SOFT_effect_target +#define AL_EFFECTSLOT_TARGET_SOFT 0x199C +#endif + +#ifndef AL_SOFT_events +#define AL_SOFT_events 1 +#define AL_EVENT_CALLBACK_FUNCTION_SOFT 0x19A2 +#define AL_EVENT_CALLBACK_USER_PARAM_SOFT 0x19A3 +#define AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT 0x19A4 +#define AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT 0x19A5 +#define AL_EVENT_TYPE_DISCONNECTED_SOFT 0x19A6 +typedef void (AL_APIENTRY*ALEVENTPROCSOFT)(ALenum eventType, ALuint object, ALuint param, + ALsizei length, const ALchar *message, + void *userParam); +typedef void (AL_APIENTRY*LPALEVENTCONTROLSOFT)(ALsizei count, const ALenum *types, ALboolean enable); +typedef void (AL_APIENTRY*LPALEVENTCALLBACKSOFT)(ALEVENTPROCSOFT callback, void *userParam); +typedef void* (AL_APIENTRY*LPALGETPOINTERSOFT)(ALenum pname); +typedef void (AL_APIENTRY*LPALGETPOINTERVSOFT)(ALenum pname, void **values); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable); +AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam); +AL_API void* AL_APIENTRY alGetPointerSOFT(ALenum pname); +AL_API void AL_APIENTRY alGetPointervSOFT(ALenum pname, void **values); +#endif +#endif + +#ifndef ALC_SOFT_reopen_device +#define ALC_SOFT_reopen_device +typedef ALCboolean (ALC_APIENTRY*LPALCREOPENDEVICESOFT)(ALCdevice *device, + const ALCchar *deviceName, const ALCint *attribs); +#ifdef AL_ALEXT_PROTOTYPES +ALCboolean ALC_APIENTRY alcReopenDeviceSOFT(ALCdevice *device, const ALCchar *deviceName, + const ALCint *attribs); +#endif +#endif + +#ifndef AL_SOFT_callback_buffer +#define AL_SOFT_callback_buffer +#define AL_BUFFER_CALLBACK_FUNCTION_SOFT 0x19A0 +#define AL_BUFFER_CALLBACK_USER_PARAM_SOFT 0x19A1 +typedef ALsizei (AL_APIENTRY*ALBUFFERCALLBACKTYPESOFT)(ALvoid *userptr, ALvoid *sampledata, ALsizei numbytes); +typedef void (AL_APIENTRY*LPALBUFFERCALLBACKSOFT)(ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr); +typedef void (AL_APIENTRY*LPALGETBUFFERPTRSOFT)(ALuint buffer, ALenum param, ALvoid **value); +typedef void (AL_APIENTRY*LPALGETBUFFER3PTRSOFT)(ALuint buffer, ALenum param, ALvoid **value1, ALvoid **value2, ALvoid **value3); +typedef void (AL_APIENTRY*LPALGETBUFFERPTRVSOFT)(ALuint buffer, ALenum param, ALvoid **values); +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alBufferCallbackSOFT(ALuint buffer, ALenum format, ALsizei freq, ALBUFFERCALLBACKTYPESOFT callback, ALvoid *userptr); +AL_API void AL_APIENTRY alGetBufferPtrSOFT(ALuint buffer, ALenum param, ALvoid **ptr); +AL_API void AL_APIENTRY alGetBuffer3PtrSOFT(ALuint buffer, ALenum param, ALvoid **ptr0, ALvoid **ptr1, ALvoid **ptr2); +AL_API void AL_APIENTRY alGetBufferPtrvSOFT(ALuint buffer, ALenum param, ALvoid **ptr); +#endif +#endif + +#ifndef AL_SOFT_UHJ +#define AL_SOFT_UHJ +#define AL_FORMAT_UHJ2CHN8_SOFT 0x19A2 +#define AL_FORMAT_UHJ2CHN16_SOFT 0x19A3 +#define AL_FORMAT_UHJ2CHN_FLOAT32_SOFT 0x19A4 +#define AL_FORMAT_UHJ3CHN8_SOFT 0x19A5 +#define AL_FORMAT_UHJ3CHN16_SOFT 0x19A6 +#define AL_FORMAT_UHJ3CHN_FLOAT32_SOFT 0x19A7 +#define AL_FORMAT_UHJ4CHN8_SOFT 0x19A8 +#define AL_FORMAT_UHJ4CHN16_SOFT 0x19A9 +#define AL_FORMAT_UHJ4CHN_FLOAT32_SOFT 0x19AA + +#define AL_STEREO_MODE_SOFT 0x19B0 +#define AL_NORMAL_SOFT 0x0000 +#define AL_SUPER_STEREO_SOFT 0x0001 +#define AL_SUPER_STEREO_WIDTH_SOFT 0x19B1 +#endif + +#ifndef AL_SOFT_UHJ_ex +#define AL_SOFT_UHJ_ex +#define AL_FORMAT_UHJ2CHN_MULAW_SOFT 0x19B3 +#define AL_FORMAT_UHJ2CHN_ALAW_SOFT 0x19B4 +#define AL_FORMAT_UHJ2CHN_IMA4_SOFT 0x19B5 +#define AL_FORMAT_UHJ2CHN_MSADPCM_SOFT 0x19B6 +#define AL_FORMAT_UHJ3CHN_MULAW_SOFT 0x19B7 +#define AL_FORMAT_UHJ3CHN_ALAW_SOFT 0x19B8 +#define AL_FORMAT_UHJ4CHN_MULAW_SOFT 0x19B9 +#define AL_FORMAT_UHJ4CHN_ALAW_SOFT 0x19BA +#endif + +#ifndef ALC_SOFT_output_mode +#define ALC_SOFT_output_mode +#define ALC_OUTPUT_MODE_SOFT 0x19AC +#define ALC_ANY_SOFT 0x19AD +/*#define ALC_MONO_SOFT 0x1500*/ +/*#define ALC_STEREO_SOFT 0x1501*/ +#define ALC_STEREO_BASIC_SOFT 0x19AE +#define ALC_STEREO_UHJ_SOFT 0x19AF +#define ALC_STEREO_HRTF_SOFT 0x19B2 +/*#define ALC_QUAD_SOFT 0x1503*/ +#define ALC_SURROUND_5_1_SOFT 0x1504 +#define ALC_SURROUND_6_1_SOFT 0x1505 +#define ALC_SURROUND_7_1_SOFT 0x1506 +#endif + +#ifndef AL_SOFT_source_start_delay +#define AL_SOFT_source_start_delay +typedef void (AL_APIENTRY*LPALSOURCEPLAYATTIMESOFT)(ALuint source, ALint64SOFT start_time); +typedef void (AL_APIENTRY*LPALSOURCEPLAYATTIMEVSOFT)(ALsizei n, const ALuint *sources, ALint64SOFT start_time); +#ifdef AL_ALEXT_PROTOTYPES +void AL_APIENTRY alSourcePlayAtTimeSOFT(ALuint source, ALint64SOFT start_time); +void AL_APIENTRY alSourcePlayAtTimevSOFT(ALsizei n, const ALuint *sources, ALint64SOFT start_time); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Generator/include/efx-creative.h b/Generator/include/efx-creative.h new file mode 100644 index 0000000..0a04c98 --- /dev/null +++ b/Generator/include/efx-creative.h @@ -0,0 +1,3 @@ +/* The tokens that would be defined here are already defined in efx.h. This + * empty file is here to provide compatibility with Windows-based projects + * that would include it. */ diff --git a/Generator/include/efx-presets.h b/Generator/include/efx-presets.h new file mode 100644 index 0000000..8539fd5 --- /dev/null +++ b/Generator/include/efx-presets.h @@ -0,0 +1,402 @@ +/* Reverb presets for EFX */ + +#ifndef EFX_PRESETS_H +#define EFX_PRESETS_H + +#ifndef EFXEAXREVERBPROPERTIES_DEFINED +#define EFXEAXREVERBPROPERTIES_DEFINED +typedef struct { + float flDensity; + float flDiffusion; + float flGain; + float flGainHF; + float flGainLF; + float flDecayTime; + float flDecayHFRatio; + float flDecayLFRatio; + float flReflectionsGain; + float flReflectionsDelay; + float flReflectionsPan[3]; + float flLateReverbGain; + float flLateReverbDelay; + float flLateReverbPan[3]; + float flEchoTime; + float flEchoDepth; + float flModulationTime; + float flModulationDepth; + float flAirAbsorptionGainHF; + float flHFReference; + float flLFReference; + float flRoomRolloffFactor; + int iDecayHFLimit; +} EFXEAXREVERBPROPERTIES, *LPEFXEAXREVERBPROPERTIES; +#endif + +/* Default Presets */ + +#define EFX_REVERB_PRESET_GENERIC \ + { 1.0000f, 1.0000f, 0.3162f, 0.8913f, 1.0000f, 1.4900f, 0.8300f, 1.0000f, 0.0500f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_PADDEDCELL \ + { 0.1715f, 1.0000f, 0.3162f, 0.0010f, 1.0000f, 0.1700f, 0.1000f, 1.0000f, 0.2500f, 0.0010f, { 0.0000f, 0.0000f, 0.0000f }, 1.2691f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ROOM \ + { 0.4287f, 1.0000f, 0.3162f, 0.5929f, 1.0000f, 0.4000f, 0.8300f, 1.0000f, 0.1503f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 1.0629f, 0.0030f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_BATHROOM \ + { 0.1715f, 1.0000f, 0.3162f, 0.2512f, 1.0000f, 1.4900f, 0.5400f, 1.0000f, 0.6531f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 3.2734f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_LIVINGROOM \ + { 0.9766f, 1.0000f, 0.3162f, 0.0010f, 1.0000f, 0.5000f, 0.1000f, 1.0000f, 0.2051f, 0.0030f, { 0.0000f, 0.0000f, 0.0000f }, 0.2805f, 0.0040f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_STONEROOM \ + { 1.0000f, 1.0000f, 0.3162f, 0.7079f, 1.0000f, 2.3100f, 0.6400f, 1.0000f, 0.4411f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1003f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_AUDITORIUM \ + { 1.0000f, 1.0000f, 0.3162f, 0.5781f, 1.0000f, 4.3200f, 0.5900f, 1.0000f, 0.4032f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.7170f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CONCERTHALL \ + { 1.0000f, 1.0000f, 0.3162f, 0.5623f, 1.0000f, 3.9200f, 0.7000f, 1.0000f, 0.2427f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.9977f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CAVE \ + { 1.0000f, 1.0000f, 0.3162f, 1.0000f, 1.0000f, 2.9100f, 1.3000f, 1.0000f, 0.5000f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.7063f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_ARENA \ + { 1.0000f, 1.0000f, 0.3162f, 0.4477f, 1.0000f, 7.2400f, 0.3300f, 1.0000f, 0.2612f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.0186f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_HANGAR \ + { 1.0000f, 1.0000f, 0.3162f, 0.3162f, 1.0000f, 10.0500f, 0.2300f, 1.0000f, 0.5000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2560f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CARPETEDHALLWAY \ + { 0.4287f, 1.0000f, 0.3162f, 0.0100f, 1.0000f, 0.3000f, 0.1000f, 1.0000f, 0.1215f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 0.1531f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_HALLWAY \ + { 0.3645f, 1.0000f, 0.3162f, 0.7079f, 1.0000f, 1.4900f, 0.5900f, 1.0000f, 0.2458f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.6615f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_STONECORRIDOR \ + { 1.0000f, 1.0000f, 0.3162f, 0.7612f, 1.0000f, 2.7000f, 0.7900f, 1.0000f, 0.2472f, 0.0130f, { 0.0000f, 0.0000f, 0.0000f }, 1.5758f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ALLEY \ + { 1.0000f, 0.3000f, 0.3162f, 0.7328f, 1.0000f, 1.4900f, 0.8600f, 1.0000f, 0.2500f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.9954f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.9500f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FOREST \ + { 1.0000f, 0.3000f, 0.3162f, 0.0224f, 1.0000f, 1.4900f, 0.5400f, 1.0000f, 0.0525f, 0.1620f, { 0.0000f, 0.0000f, 0.0000f }, 0.7682f, 0.0880f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CITY \ + { 1.0000f, 0.5000f, 0.3162f, 0.3981f, 1.0000f, 1.4900f, 0.6700f, 1.0000f, 0.0730f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.1427f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_MOUNTAINS \ + { 1.0000f, 0.2700f, 0.3162f, 0.0562f, 1.0000f, 1.4900f, 0.2100f, 1.0000f, 0.0407f, 0.3000f, { 0.0000f, 0.0000f, 0.0000f }, 0.1919f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_QUARRY \ + { 1.0000f, 1.0000f, 0.3162f, 0.3162f, 1.0000f, 1.4900f, 0.8300f, 1.0000f, 0.0000f, 0.0610f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0250f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.7000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_PLAIN \ + { 1.0000f, 0.2100f, 0.3162f, 0.1000f, 1.0000f, 1.4900f, 0.5000f, 1.0000f, 0.0585f, 0.1790f, { 0.0000f, 0.0000f, 0.0000f }, 0.1089f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_PARKINGLOT \ + { 1.0000f, 1.0000f, 0.3162f, 1.0000f, 1.0000f, 1.6500f, 1.5000f, 1.0000f, 0.2082f, 0.0080f, { 0.0000f, 0.0000f, 0.0000f }, 0.2652f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_SEWERPIPE \ + { 0.3071f, 0.8000f, 0.3162f, 0.3162f, 1.0000f, 2.8100f, 0.1400f, 1.0000f, 1.6387f, 0.0140f, { 0.0000f, 0.0000f, 0.0000f }, 3.2471f, 0.0210f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_UNDERWATER \ + { 0.3645f, 1.0000f, 0.3162f, 0.0100f, 1.0000f, 1.4900f, 0.1000f, 1.0000f, 0.5963f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 7.0795f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 1.1800f, 0.3480f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_DRUGGED \ + { 0.4287f, 0.5000f, 0.3162f, 1.0000f, 1.0000f, 8.3900f, 1.3900f, 1.0000f, 0.8760f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 3.1081f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 1.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_DIZZY \ + { 0.3645f, 0.6000f, 0.3162f, 0.6310f, 1.0000f, 17.2300f, 0.5600f, 1.0000f, 0.1392f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.4937f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.8100f, 0.3100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_PSYCHOTIC \ + { 0.0625f, 0.5000f, 0.3162f, 0.8404f, 1.0000f, 7.5600f, 0.9100f, 1.0000f, 0.4864f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 2.4378f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 4.0000f, 1.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +/* Castle Presets */ + +#define EFX_REVERB_PRESET_CASTLE_SMALLROOM \ + { 1.0000f, 0.8900f, 0.3162f, 0.3981f, 0.1000f, 1.2200f, 0.8300f, 0.3100f, 0.8913f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CASTLE_SHORTPASSAGE \ + { 1.0000f, 0.8900f, 0.3162f, 0.3162f, 0.1000f, 2.3200f, 0.8300f, 0.3100f, 0.8913f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CASTLE_MEDIUMROOM \ + { 1.0000f, 0.9300f, 0.3162f, 0.2818f, 0.1000f, 2.0400f, 0.8300f, 0.4600f, 0.6310f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1550f, 0.0300f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CASTLE_LARGEROOM \ + { 1.0000f, 0.8200f, 0.3162f, 0.2818f, 0.1259f, 2.5300f, 0.8300f, 0.5000f, 0.4467f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1850f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CASTLE_LONGPASSAGE \ + { 1.0000f, 0.8900f, 0.3162f, 0.3981f, 0.1000f, 3.4200f, 0.8300f, 0.3100f, 0.8913f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CASTLE_HALL \ + { 1.0000f, 0.8100f, 0.3162f, 0.2818f, 0.1778f, 3.1400f, 0.7900f, 0.6200f, 0.1778f, 0.0560f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CASTLE_CUPBOARD \ + { 1.0000f, 0.8900f, 0.3162f, 0.2818f, 0.1000f, 0.6700f, 0.8700f, 0.3100f, 1.4125f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 3.5481f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CASTLE_COURTYARD \ + { 1.0000f, 0.4200f, 0.3162f, 0.4467f, 0.1995f, 2.1300f, 0.6100f, 0.2300f, 0.2239f, 0.1600f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0360f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.3700f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_CASTLE_ALCOVE \ + { 1.0000f, 0.8900f, 0.3162f, 0.5012f, 0.1000f, 1.6400f, 0.8700f, 0.3100f, 1.0000f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 0.1380f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 5168.6001f, 139.5000f, 0.0000f, 0x1 } + +/* Factory Presets */ + +#define EFX_REVERB_PRESET_FACTORY_SMALLROOM \ + { 0.3645f, 0.8200f, 0.3162f, 0.7943f, 0.5012f, 1.7200f, 0.6500f, 1.3100f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.1190f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_SHORTPASSAGE \ + { 0.3645f, 0.6400f, 0.2512f, 0.7943f, 0.5012f, 2.5300f, 0.6500f, 1.3100f, 1.0000f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.1350f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_MEDIUMROOM \ + { 0.4287f, 0.8200f, 0.2512f, 0.7943f, 0.5012f, 2.7600f, 0.6500f, 1.3100f, 0.2818f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1740f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_LARGEROOM \ + { 0.4287f, 0.7500f, 0.2512f, 0.7079f, 0.6310f, 4.2400f, 0.5100f, 1.3100f, 0.1778f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.2310f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_LONGPASSAGE \ + { 0.3645f, 0.6400f, 0.2512f, 0.7943f, 0.5012f, 4.0600f, 0.6500f, 1.3100f, 1.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0370f, { 0.0000f, 0.0000f, 0.0000f }, 0.1350f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_HALL \ + { 0.4287f, 0.7500f, 0.3162f, 0.7079f, 0.6310f, 7.4300f, 0.5100f, 1.3100f, 0.0631f, 0.0730f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_CUPBOARD \ + { 0.3071f, 0.6300f, 0.2512f, 0.7943f, 0.5012f, 0.4900f, 0.6500f, 1.3100f, 1.2589f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.1070f, 0.0700f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_COURTYARD \ + { 0.3071f, 0.5700f, 0.3162f, 0.3162f, 0.6310f, 2.3200f, 0.2900f, 0.5600f, 0.2239f, 0.1400f, { 0.0000f, 0.0000f, 0.0000f }, 0.3981f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2900f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_FACTORY_ALCOVE \ + { 0.3645f, 0.5900f, 0.2512f, 0.7943f, 0.5012f, 3.1400f, 0.6500f, 1.3100f, 1.4125f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.1140f, 0.1000f, 0.2500f, 0.0000f, 0.9943f, 3762.6001f, 362.5000f, 0.0000f, 0x1 } + +/* Ice Palace Presets */ + +#define EFX_REVERB_PRESET_ICEPALACE_SMALLROOM \ + { 1.0000f, 0.8400f, 0.3162f, 0.5623f, 0.2818f, 1.5100f, 1.5300f, 0.2700f, 0.8913f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1640f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_SHORTPASSAGE \ + { 1.0000f, 0.7500f, 0.3162f, 0.5623f, 0.2818f, 1.7900f, 1.4600f, 0.2800f, 0.5012f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.1770f, 0.0900f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_MEDIUMROOM \ + { 1.0000f, 0.8700f, 0.3162f, 0.5623f, 0.4467f, 2.2200f, 1.5300f, 0.3200f, 0.3981f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.1860f, 0.1200f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_LARGEROOM \ + { 1.0000f, 0.8100f, 0.3162f, 0.5623f, 0.4467f, 3.1400f, 1.5300f, 0.3200f, 0.2512f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0270f, { 0.0000f, 0.0000f, 0.0000f }, 0.2140f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_LONGPASSAGE \ + { 1.0000f, 0.7700f, 0.3162f, 0.5623f, 0.3981f, 3.0100f, 1.4600f, 0.2800f, 0.7943f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0250f, { 0.0000f, 0.0000f, 0.0000f }, 0.1860f, 0.0400f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_HALL \ + { 1.0000f, 0.7600f, 0.3162f, 0.4467f, 0.5623f, 5.4900f, 1.5300f, 0.3800f, 0.1122f, 0.0540f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0520f, { 0.0000f, 0.0000f, 0.0000f }, 0.2260f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_CUPBOARD \ + { 1.0000f, 0.8300f, 0.3162f, 0.5012f, 0.2239f, 0.7600f, 1.5300f, 0.2600f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1430f, 0.0800f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_COURTYARD \ + { 1.0000f, 0.5900f, 0.3162f, 0.2818f, 0.3162f, 2.0400f, 1.2000f, 0.3800f, 0.3162f, 0.1730f, { 0.0000f, 0.0000f, 0.0000f }, 0.3162f, 0.0430f, { 0.0000f, 0.0000f, 0.0000f }, 0.2350f, 0.4800f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_ICEPALACE_ALCOVE \ + { 1.0000f, 0.8400f, 0.3162f, 0.5623f, 0.2818f, 2.7600f, 1.4600f, 0.2800f, 1.1220f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1610f, 0.0900f, 0.2500f, 0.0000f, 0.9943f, 12428.5000f, 99.6000f, 0.0000f, 0x1 } + +/* Space Station Presets */ + +#define EFX_REVERB_PRESET_SPACESTATION_SMALLROOM \ + { 0.2109f, 0.7000f, 0.3162f, 0.7079f, 0.8913f, 1.7200f, 0.8200f, 0.5500f, 0.7943f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0130f, { 0.0000f, 0.0000f, 0.0000f }, 0.1880f, 0.2600f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPACESTATION_SHORTPASSAGE \ + { 0.2109f, 0.8700f, 0.3162f, 0.6310f, 0.8913f, 3.5700f, 0.5000f, 0.5500f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.1720f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPACESTATION_MEDIUMROOM \ + { 0.2109f, 0.7500f, 0.3162f, 0.6310f, 0.8913f, 3.0100f, 0.5000f, 0.5500f, 0.3981f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0350f, { 0.0000f, 0.0000f, 0.0000f }, 0.2090f, 0.3100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPACESTATION_LARGEROOM \ + { 0.3645f, 0.8100f, 0.3162f, 0.6310f, 0.8913f, 3.8900f, 0.3800f, 0.6100f, 0.3162f, 0.0560f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0350f, { 0.0000f, 0.0000f, 0.0000f }, 0.2330f, 0.2800f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPACESTATION_LONGPASSAGE \ + { 0.4287f, 0.8200f, 0.3162f, 0.6310f, 0.8913f, 4.6200f, 0.6200f, 0.5500f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0310f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2300f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPACESTATION_HALL \ + { 0.4287f, 0.8700f, 0.3162f, 0.6310f, 0.8913f, 7.1100f, 0.3800f, 0.6100f, 0.1778f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0470f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2500f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPACESTATION_CUPBOARD \ + { 0.1715f, 0.5600f, 0.3162f, 0.7079f, 0.8913f, 0.7900f, 0.8100f, 0.5500f, 1.4125f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.7783f, 0.0180f, { 0.0000f, 0.0000f, 0.0000f }, 0.1810f, 0.3100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPACESTATION_ALCOVE \ + { 0.2109f, 0.7800f, 0.3162f, 0.7079f, 0.8913f, 1.1600f, 0.8100f, 0.5500f, 1.4125f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0180f, { 0.0000f, 0.0000f, 0.0000f }, 0.1920f, 0.2100f, 0.2500f, 0.0000f, 0.9943f, 3316.1001f, 458.2000f, 0.0000f, 0x1 } + +/* Wooden Galleon Presets */ + +#define EFX_REVERB_PRESET_WOODEN_SMALLROOM \ + { 1.0000f, 1.0000f, 0.3162f, 0.1122f, 0.3162f, 0.7900f, 0.3200f, 0.8700f, 1.0000f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_SHORTPASSAGE \ + { 1.0000f, 1.0000f, 0.3162f, 0.1259f, 0.3162f, 1.7500f, 0.5000f, 0.8700f, 0.8913f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.6310f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_MEDIUMROOM \ + { 1.0000f, 1.0000f, 0.3162f, 0.1000f, 0.2818f, 1.4700f, 0.4200f, 0.8200f, 0.8913f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_LARGEROOM \ + { 1.0000f, 1.0000f, 0.3162f, 0.0891f, 0.2818f, 2.6500f, 0.3300f, 0.8200f, 0.8913f, 0.0660f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_LONGPASSAGE \ + { 1.0000f, 1.0000f, 0.3162f, 0.1000f, 0.3162f, 1.9900f, 0.4000f, 0.7900f, 1.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.4467f, 0.0360f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_HALL \ + { 1.0000f, 1.0000f, 0.3162f, 0.0794f, 0.2818f, 3.4500f, 0.3000f, 0.8200f, 0.8913f, 0.0880f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0630f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_CUPBOARD \ + { 1.0000f, 1.0000f, 0.3162f, 0.1413f, 0.3162f, 0.5600f, 0.4600f, 0.9100f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_COURTYARD \ + { 1.0000f, 0.6500f, 0.3162f, 0.0794f, 0.3162f, 1.7900f, 0.3500f, 0.7900f, 0.5623f, 0.1230f, { 0.0000f, 0.0000f, 0.0000f }, 0.1000f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_WOODEN_ALCOVE \ + { 1.0000f, 1.0000f, 0.3162f, 0.1259f, 0.3162f, 1.2200f, 0.6200f, 0.9100f, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 4705.0000f, 99.6000f, 0.0000f, 0x1 } + +/* Sports Presets */ + +#define EFX_REVERB_PRESET_SPORT_EMPTYSTADIUM \ + { 1.0000f, 1.0000f, 0.3162f, 0.4467f, 0.7943f, 6.2600f, 0.5100f, 1.1000f, 0.0631f, 0.1830f, { 0.0000f, 0.0000f, 0.0000f }, 0.3981f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPORT_SQUASHCOURT \ + { 1.0000f, 0.7500f, 0.3162f, 0.3162f, 0.7943f, 2.2200f, 0.9100f, 1.1600f, 0.4467f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.1260f, 0.1900f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPORT_SMALLSWIMMINGPOOL \ + { 1.0000f, 0.7000f, 0.3162f, 0.7943f, 0.8913f, 2.7600f, 1.2500f, 1.1400f, 0.6310f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1790f, 0.1500f, 0.8950f, 0.1900f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_SPORT_LARGESWIMMINGPOOL \ + { 1.0000f, 0.8200f, 0.3162f, 0.7943f, 1.0000f, 5.4900f, 1.3100f, 1.1400f, 0.4467f, 0.0390f, { 0.0000f, 0.0000f, 0.0000f }, 0.5012f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2220f, 0.5500f, 1.1590f, 0.2100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_SPORT_GYMNASIUM \ + { 1.0000f, 0.8100f, 0.3162f, 0.4467f, 0.8913f, 3.1400f, 1.0600f, 1.3500f, 0.3981f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.5623f, 0.0450f, { 0.0000f, 0.0000f, 0.0000f }, 0.1460f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPORT_FULLSTADIUM \ + { 1.0000f, 1.0000f, 0.3162f, 0.0708f, 0.7943f, 5.2500f, 0.1700f, 0.8000f, 0.1000f, 0.1880f, { 0.0000f, 0.0000f, 0.0000f }, 0.2818f, 0.0380f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SPORT_STADIUMTANNOY \ + { 1.0000f, 0.7800f, 0.3162f, 0.5623f, 0.5012f, 2.5300f, 0.8800f, 0.6800f, 0.2818f, 0.2300f, { 0.0000f, 0.0000f, 0.0000f }, 0.5012f, 0.0630f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +/* Prefab Presets */ + +#define EFX_REVERB_PRESET_PREFAB_WORKSHOP \ + { 0.4287f, 1.0000f, 0.3162f, 0.1413f, 0.3981f, 0.7600f, 1.0000f, 1.0000f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_PREFAB_SCHOOLROOM \ + { 0.4022f, 0.6900f, 0.3162f, 0.6310f, 0.5012f, 0.9800f, 0.4500f, 0.1800f, 1.4125f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.0950f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_PREFAB_PRACTISEROOM \ + { 0.4022f, 0.8700f, 0.3162f, 0.3981f, 0.5012f, 1.1200f, 0.5600f, 0.1800f, 1.2589f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0110f, { 0.0000f, 0.0000f, 0.0000f }, 0.0950f, 0.1400f, 0.2500f, 0.0000f, 0.9943f, 7176.8999f, 211.2000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_PREFAB_OUTHOUSE \ + { 1.0000f, 0.8200f, 0.3162f, 0.1122f, 0.1585f, 1.3800f, 0.3800f, 0.3500f, 0.8913f, 0.0240f, { 0.0000f, 0.0000f, -0.0000f }, 0.6310f, 0.0440f, { 0.0000f, 0.0000f, 0.0000f }, 0.1210f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_PREFAB_CARAVAN \ + { 1.0000f, 1.0000f, 0.3162f, 0.0891f, 0.1259f, 0.4300f, 1.5000f, 1.0000f, 1.0000f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 1.9953f, 0.0120f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +/* Dome and Pipe Presets */ + +#define EFX_REVERB_PRESET_DOME_TOMB \ + { 1.0000f, 0.7900f, 0.3162f, 0.3548f, 0.2239f, 4.1800f, 0.2100f, 0.1000f, 0.3868f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 1.6788f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.1770f, 0.1900f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_PIPE_SMALL \ + { 1.0000f, 1.0000f, 0.3162f, 0.3548f, 0.2239f, 5.0400f, 0.1000f, 0.1000f, 0.5012f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 2.5119f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_DOME_SAINTPAULS \ + { 1.0000f, 0.8700f, 0.3162f, 0.3548f, 0.2239f, 10.4800f, 0.1900f, 0.1000f, 0.1778f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0420f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1200f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_PIPE_LONGTHIN \ + { 0.2560f, 0.9100f, 0.3162f, 0.4467f, 0.2818f, 9.2100f, 0.1800f, 0.1000f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_PIPE_LARGE \ + { 1.0000f, 1.0000f, 0.3162f, 0.3548f, 0.2239f, 8.4500f, 0.1000f, 0.1000f, 0.3981f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_PIPE_RESONANT \ + { 0.1373f, 0.9100f, 0.3162f, 0.4467f, 0.2818f, 6.8100f, 0.1800f, 0.1000f, 0.7079f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.0000f, 0.0220f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 20.0000f, 0.0000f, 0x0 } + +/* Outdoors Presets */ + +#define EFX_REVERB_PRESET_OUTDOORS_BACKYARD \ + { 1.0000f, 0.4500f, 0.3162f, 0.2512f, 0.5012f, 1.1200f, 0.3400f, 0.4600f, 0.4467f, 0.0690f, { 0.0000f, 0.0000f, -0.0000f }, 0.7079f, 0.0230f, { 0.0000f, 0.0000f, 0.0000f }, 0.2180f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_OUTDOORS_ROLLINGPLAINS \ + { 1.0000f, 0.0000f, 0.3162f, 0.0112f, 0.6310f, 2.1300f, 0.2100f, 0.4600f, 0.1778f, 0.3000f, { 0.0000f, 0.0000f, -0.0000f }, 0.4467f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_OUTDOORS_DEEPCANYON \ + { 1.0000f, 0.7400f, 0.3162f, 0.1778f, 0.6310f, 3.8900f, 0.2100f, 0.4600f, 0.3162f, 0.2230f, { 0.0000f, 0.0000f, -0.0000f }, 0.3548f, 0.0190f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_OUTDOORS_CREEK \ + { 1.0000f, 0.3500f, 0.3162f, 0.1778f, 0.5012f, 2.1300f, 0.2100f, 0.4600f, 0.3981f, 0.1150f, { 0.0000f, 0.0000f, -0.0000f }, 0.1995f, 0.0310f, { 0.0000f, 0.0000f, 0.0000f }, 0.2180f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 4399.1001f, 242.9000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_OUTDOORS_VALLEY \ + { 1.0000f, 0.2800f, 0.3162f, 0.0282f, 0.1585f, 2.8800f, 0.2600f, 0.3500f, 0.1413f, 0.2630f, { 0.0000f, 0.0000f, -0.0000f }, 0.3981f, 0.1000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.3400f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 } + +/* Mood Presets */ + +#define EFX_REVERB_PRESET_MOOD_HEAVEN \ + { 1.0000f, 0.9400f, 0.3162f, 0.7943f, 0.4467f, 5.0400f, 1.1200f, 0.5600f, 0.2427f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0290f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0800f, 2.7420f, 0.0500f, 0.9977f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_MOOD_HELL \ + { 1.0000f, 0.5700f, 0.3162f, 0.3548f, 0.4467f, 3.5700f, 0.4900f, 2.0000f, 0.0000f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1100f, 0.0400f, 2.1090f, 0.5200f, 0.9943f, 5000.0000f, 139.5000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_MOOD_MEMORY \ + { 1.0000f, 0.8500f, 0.3162f, 0.6310f, 0.3548f, 4.0600f, 0.8200f, 0.5600f, 0.0398f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.1220f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.4740f, 0.4500f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +/* Driving Presets */ + +#define EFX_REVERB_PRESET_DRIVING_COMMENTATOR \ + { 1.0000f, 0.0000f, 0.3162f, 0.5623f, 0.5012f, 2.4200f, 0.8800f, 0.6800f, 0.1995f, 0.0930f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0170f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 1.0000f, 0.2500f, 0.0000f, 0.9886f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_DRIVING_PITGARAGE \ + { 0.4287f, 0.5900f, 0.3162f, 0.7079f, 0.5623f, 1.7200f, 0.9300f, 0.8700f, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0160f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_DRIVING_INCAR_RACER \ + { 0.0832f, 0.8000f, 0.3162f, 1.0000f, 0.7943f, 0.1700f, 2.0000f, 0.4100f, 1.7783f, 0.0070f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0150f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_DRIVING_INCAR_SPORTS \ + { 0.0832f, 0.8000f, 0.3162f, 0.6310f, 1.0000f, 0.1700f, 0.7500f, 0.4100f, 1.0000f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.5623f, 0.0000f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_DRIVING_INCAR_LUXURY \ + { 0.2560f, 1.0000f, 0.3162f, 0.1000f, 0.5012f, 0.1300f, 0.4100f, 0.4600f, 0.7943f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 1.5849f, 0.0100f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10268.2002f, 251.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_DRIVING_FULLGRANDSTAND \ + { 1.0000f, 1.0000f, 0.3162f, 0.2818f, 0.6310f, 3.0100f, 1.3700f, 1.2800f, 0.3548f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 0.1778f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10420.2002f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_DRIVING_EMPTYGRANDSTAND \ + { 1.0000f, 1.0000f, 0.3162f, 1.0000f, 0.7943f, 4.6200f, 1.7500f, 1.4000f, 0.2082f, 0.0900f, { 0.0000f, 0.0000f, 0.0000f }, 0.2512f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.0000f, 0.9943f, 10420.2002f, 250.0000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_DRIVING_TUNNEL \ + { 1.0000f, 0.8100f, 0.3162f, 0.3981f, 0.8913f, 3.4200f, 0.9400f, 1.3100f, 0.7079f, 0.0510f, { 0.0000f, 0.0000f, 0.0000f }, 0.7079f, 0.0470f, { 0.0000f, 0.0000f, 0.0000f }, 0.2140f, 0.0500f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 155.3000f, 0.0000f, 0x1 } + +/* City Presets */ + +#define EFX_REVERB_PRESET_CITY_STREETS \ + { 1.0000f, 0.7800f, 0.3162f, 0.7079f, 0.8913f, 1.7900f, 1.1200f, 0.9100f, 0.2818f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 0.1995f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CITY_SUBWAY \ + { 1.0000f, 0.7400f, 0.3162f, 0.7079f, 0.8913f, 3.0100f, 1.2300f, 0.9100f, 0.7079f, 0.0460f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0280f, { 0.0000f, 0.0000f, 0.0000f }, 0.1250f, 0.2100f, 0.2500f, 0.0000f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CITY_MUSEUM \ + { 1.0000f, 0.8200f, 0.3162f, 0.1778f, 0.1778f, 3.2800f, 1.4000f, 0.5700f, 0.2512f, 0.0390f, { 0.0000f, 0.0000f, -0.0000f }, 0.8913f, 0.0340f, { 0.0000f, 0.0000f, 0.0000f }, 0.1300f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_CITY_LIBRARY \ + { 1.0000f, 0.8200f, 0.3162f, 0.2818f, 0.0891f, 2.7600f, 0.8900f, 0.4100f, 0.3548f, 0.0290f, { 0.0000f, 0.0000f, -0.0000f }, 0.8913f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 0.1300f, 0.1700f, 0.2500f, 0.0000f, 0.9943f, 2854.3999f, 107.5000f, 0.0000f, 0x0 } + +#define EFX_REVERB_PRESET_CITY_UNDERPASS \ + { 1.0000f, 0.8200f, 0.3162f, 0.4467f, 0.8913f, 3.5700f, 1.1200f, 0.9100f, 0.3981f, 0.0590f, { 0.0000f, 0.0000f, 0.0000f }, 0.8913f, 0.0370f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.1400f, 0.2500f, 0.0000f, 0.9920f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CITY_ABANDONED \ + { 1.0000f, 0.6900f, 0.3162f, 0.7943f, 0.8913f, 3.2800f, 1.1700f, 0.9100f, 0.4467f, 0.0440f, { 0.0000f, 0.0000f, 0.0000f }, 0.2818f, 0.0240f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.2000f, 0.2500f, 0.0000f, 0.9966f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +/* Misc. Presets */ + +#define EFX_REVERB_PRESET_DUSTYROOM \ + { 0.3645f, 0.5600f, 0.3162f, 0.7943f, 0.7079f, 1.7900f, 0.3800f, 0.2100f, 0.5012f, 0.0020f, { 0.0000f, 0.0000f, 0.0000f }, 1.2589f, 0.0060f, { 0.0000f, 0.0000f, 0.0000f }, 0.2020f, 0.0500f, 0.2500f, 0.0000f, 0.9886f, 13046.0000f, 163.3000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_CHAPEL \ + { 1.0000f, 0.8400f, 0.3162f, 0.5623f, 1.0000f, 4.6200f, 0.6400f, 1.2300f, 0.4467f, 0.0320f, { 0.0000f, 0.0000f, 0.0000f }, 0.7943f, 0.0490f, { 0.0000f, 0.0000f, 0.0000f }, 0.2500f, 0.0000f, 0.2500f, 0.1100f, 0.9943f, 5000.0000f, 250.0000f, 0.0000f, 0x1 } + +#define EFX_REVERB_PRESET_SMALLWATERROOM \ + { 1.0000f, 0.7000f, 0.3162f, 0.4477f, 1.0000f, 1.5100f, 1.2500f, 1.1400f, 0.8913f, 0.0200f, { 0.0000f, 0.0000f, 0.0000f }, 1.4125f, 0.0300f, { 0.0000f, 0.0000f, 0.0000f }, 0.1790f, 0.1500f, 0.8950f, 0.1900f, 0.9920f, 5000.0000f, 250.0000f, 0.0000f, 0x0 } + +#endif /* EFX_PRESETS_H */ diff --git a/Generator/include/efx.h b/Generator/include/efx.h new file mode 100644 index 0000000..5ab64a6 --- /dev/null +++ b/Generator/include/efx.h @@ -0,0 +1,762 @@ +#ifndef AL_EFX_H +#define AL_EFX_H + +#include + +#include "alc.h" +#include "al.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#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 + + +/* Listener properties. */ +#define AL_METERS_PER_UNIT 0x20004 + +/* Source properties. */ +#define AL_DIRECT_FILTER 0x20005 +#define AL_AUXILIARY_SEND_FILTER 0x20006 +#define AL_AIR_ABSORPTION_FACTOR 0x20007 +#define AL_ROOM_ROLLOFF_FACTOR 0x20008 +#define AL_CONE_OUTER_GAINHF 0x20009 +#define AL_DIRECT_FILTER_GAINHF_AUTO 0x2000A +#define AL_AUXILIARY_SEND_FILTER_GAIN_AUTO 0x2000B +#define AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO 0x2000C + + +/* Effect properties. */ + +/* Reverb effect parameters */ +#define AL_REVERB_DENSITY 0x0001 +#define AL_REVERB_DIFFUSION 0x0002 +#define AL_REVERB_GAIN 0x0003 +#define AL_REVERB_GAINHF 0x0004 +#define AL_REVERB_DECAY_TIME 0x0005 +#define AL_REVERB_DECAY_HFRATIO 0x0006 +#define AL_REVERB_REFLECTIONS_GAIN 0x0007 +#define AL_REVERB_REFLECTIONS_DELAY 0x0008 +#define AL_REVERB_LATE_REVERB_GAIN 0x0009 +#define AL_REVERB_LATE_REVERB_DELAY 0x000A +#define AL_REVERB_AIR_ABSORPTION_GAINHF 0x000B +#define AL_REVERB_ROOM_ROLLOFF_FACTOR 0x000C +#define AL_REVERB_DECAY_HFLIMIT 0x000D + +/* EAX Reverb effect parameters */ +#define AL_EAXREVERB_DENSITY 0x0001 +#define AL_EAXREVERB_DIFFUSION 0x0002 +#define AL_EAXREVERB_GAIN 0x0003 +#define AL_EAXREVERB_GAINHF 0x0004 +#define AL_EAXREVERB_GAINLF 0x0005 +#define AL_EAXREVERB_DECAY_TIME 0x0006 +#define AL_EAXREVERB_DECAY_HFRATIO 0x0007 +#define AL_EAXREVERB_DECAY_LFRATIO 0x0008 +#define AL_EAXREVERB_REFLECTIONS_GAIN 0x0009 +#define AL_EAXREVERB_REFLECTIONS_DELAY 0x000A +#define AL_EAXREVERB_REFLECTIONS_PAN 0x000B +#define AL_EAXREVERB_LATE_REVERB_GAIN 0x000C +#define AL_EAXREVERB_LATE_REVERB_DELAY 0x000D +#define AL_EAXREVERB_LATE_REVERB_PAN 0x000E +#define AL_EAXREVERB_ECHO_TIME 0x000F +#define AL_EAXREVERB_ECHO_DEPTH 0x0010 +#define AL_EAXREVERB_MODULATION_TIME 0x0011 +#define AL_EAXREVERB_MODULATION_DEPTH 0x0012 +#define AL_EAXREVERB_AIR_ABSORPTION_GAINHF 0x0013 +#define AL_EAXREVERB_HFREFERENCE 0x0014 +#define AL_EAXREVERB_LFREFERENCE 0x0015 +#define AL_EAXREVERB_ROOM_ROLLOFF_FACTOR 0x0016 +#define AL_EAXREVERB_DECAY_HFLIMIT 0x0017 + +/* Chorus effect parameters */ +#define AL_CHORUS_WAVEFORM 0x0001 +#define AL_CHORUS_PHASE 0x0002 +#define AL_CHORUS_RATE 0x0003 +#define AL_CHORUS_DEPTH 0x0004 +#define AL_CHORUS_FEEDBACK 0x0005 +#define AL_CHORUS_DELAY 0x0006 + +/* Distortion effect parameters */ +#define AL_DISTORTION_EDGE 0x0001 +#define AL_DISTORTION_GAIN 0x0002 +#define AL_DISTORTION_LOWPASS_CUTOFF 0x0003 +#define AL_DISTORTION_EQCENTER 0x0004 +#define AL_DISTORTION_EQBANDWIDTH 0x0005 + +/* Echo effect parameters */ +#define AL_ECHO_DELAY 0x0001 +#define AL_ECHO_LRDELAY 0x0002 +#define AL_ECHO_DAMPING 0x0003 +#define AL_ECHO_FEEDBACK 0x0004 +#define AL_ECHO_SPREAD 0x0005 + +/* Flanger effect parameters */ +#define AL_FLANGER_WAVEFORM 0x0001 +#define AL_FLANGER_PHASE 0x0002 +#define AL_FLANGER_RATE 0x0003 +#define AL_FLANGER_DEPTH 0x0004 +#define AL_FLANGER_FEEDBACK 0x0005 +#define AL_FLANGER_DELAY 0x0006 + +/* Frequency shifter effect parameters */ +#define AL_FREQUENCY_SHIFTER_FREQUENCY 0x0001 +#define AL_FREQUENCY_SHIFTER_LEFT_DIRECTION 0x0002 +#define AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION 0x0003 + +/* Vocal morpher effect parameters */ +#define AL_VOCAL_MORPHER_PHONEMEA 0x0001 +#define AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING 0x0002 +#define AL_VOCAL_MORPHER_PHONEMEB 0x0003 +#define AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING 0x0004 +#define AL_VOCAL_MORPHER_WAVEFORM 0x0005 +#define AL_VOCAL_MORPHER_RATE 0x0006 + +/* Pitchshifter effect parameters */ +#define AL_PITCH_SHIFTER_COARSE_TUNE 0x0001 +#define AL_PITCH_SHIFTER_FINE_TUNE 0x0002 + +/* Ringmodulator effect parameters */ +#define AL_RING_MODULATOR_FREQUENCY 0x0001 +#define AL_RING_MODULATOR_HIGHPASS_CUTOFF 0x0002 +#define AL_RING_MODULATOR_WAVEFORM 0x0003 + +/* Autowah effect parameters */ +#define AL_AUTOWAH_ATTACK_TIME 0x0001 +#define AL_AUTOWAH_RELEASE_TIME 0x0002 +#define AL_AUTOWAH_RESONANCE 0x0003 +#define AL_AUTOWAH_PEAK_GAIN 0x0004 + +/* Compressor effect parameters */ +#define AL_COMPRESSOR_ONOFF 0x0001 + +/* Equalizer effect parameters */ +#define AL_EQUALIZER_LOW_GAIN 0x0001 +#define AL_EQUALIZER_LOW_CUTOFF 0x0002 +#define AL_EQUALIZER_MID1_GAIN 0x0003 +#define AL_EQUALIZER_MID1_CENTER 0x0004 +#define AL_EQUALIZER_MID1_WIDTH 0x0005 +#define AL_EQUALIZER_MID2_GAIN 0x0006 +#define AL_EQUALIZER_MID2_CENTER 0x0007 +#define AL_EQUALIZER_MID2_WIDTH 0x0008 +#define AL_EQUALIZER_HIGH_GAIN 0x0009 +#define AL_EQUALIZER_HIGH_CUTOFF 0x000A + +/* Effect type */ +#define AL_EFFECT_FIRST_PARAMETER 0x0000 +#define AL_EFFECT_LAST_PARAMETER 0x8000 +#define AL_EFFECT_TYPE 0x8001 + +/* Effect types, used with the AL_EFFECT_TYPE property */ +#define AL_EFFECT_NULL 0x0000 +#define AL_EFFECT_REVERB 0x0001 +#define AL_EFFECT_CHORUS 0x0002 +#define AL_EFFECT_DISTORTION 0x0003 +#define AL_EFFECT_ECHO 0x0004 +#define AL_EFFECT_FLANGER 0x0005 +#define AL_EFFECT_FREQUENCY_SHIFTER 0x0006 +#define AL_EFFECT_VOCAL_MORPHER 0x0007 +#define AL_EFFECT_PITCH_SHIFTER 0x0008 +#define AL_EFFECT_RING_MODULATOR 0x0009 +#define AL_EFFECT_AUTOWAH 0x000A +#define AL_EFFECT_COMPRESSOR 0x000B +#define AL_EFFECT_EQUALIZER 0x000C +#define AL_EFFECT_EAXREVERB 0x8000 + +/* Auxiliary Effect Slot properties. */ +#define AL_EFFECTSLOT_EFFECT 0x0001 +#define AL_EFFECTSLOT_GAIN 0x0002 +#define AL_EFFECTSLOT_AUXILIARY_SEND_AUTO 0x0003 + +/* NULL Auxiliary Slot ID to disable a source send. */ +#define AL_EFFECTSLOT_NULL 0x0000 + + +/* Filter properties. */ + +/* Lowpass filter parameters */ +#define AL_LOWPASS_GAIN 0x0001 +#define AL_LOWPASS_GAINHF 0x0002 + +/* Highpass filter parameters */ +#define AL_HIGHPASS_GAIN 0x0001 +#define AL_HIGHPASS_GAINLF 0x0002 + +/* Bandpass filter parameters */ +#define AL_BANDPASS_GAIN 0x0001 +#define AL_BANDPASS_GAINLF 0x0002 +#define AL_BANDPASS_GAINHF 0x0003 + +/* Filter type */ +#define AL_FILTER_FIRST_PARAMETER 0x0000 +#define AL_FILTER_LAST_PARAMETER 0x8000 +#define AL_FILTER_TYPE 0x8001 + +/* Filter types, used with the AL_FILTER_TYPE property */ +#define AL_FILTER_NULL 0x0000 +#define AL_FILTER_LOWPASS 0x0001 +#define AL_FILTER_HIGHPASS 0x0002 +#define AL_FILTER_BANDPASS 0x0003 + + +/* Effect object function types. */ +typedef void (AL_APIENTRY *LPALGENEFFECTS)(ALsizei, ALuint*); +typedef void (AL_APIENTRY *LPALDELETEEFFECTS)(ALsizei, const ALuint*); +typedef ALboolean (AL_APIENTRY *LPALISEFFECT)(ALuint); +typedef void (AL_APIENTRY *LPALEFFECTI)(ALuint, ALenum, ALint); +typedef void (AL_APIENTRY *LPALEFFECTIV)(ALuint, ALenum, const ALint*); +typedef void (AL_APIENTRY *LPALEFFECTF)(ALuint, ALenum, ALfloat); +typedef void (AL_APIENTRY *LPALEFFECTFV)(ALuint, ALenum, const ALfloat*); +typedef void (AL_APIENTRY *LPALGETEFFECTI)(ALuint, ALenum, ALint*); +typedef void (AL_APIENTRY *LPALGETEFFECTIV)(ALuint, ALenum, ALint*); +typedef void (AL_APIENTRY *LPALGETEFFECTF)(ALuint, ALenum, ALfloat*); +typedef void (AL_APIENTRY *LPALGETEFFECTFV)(ALuint, ALenum, ALfloat*); + +/* Filter object function types. */ +typedef void (AL_APIENTRY *LPALGENFILTERS)(ALsizei, ALuint*); +typedef void (AL_APIENTRY *LPALDELETEFILTERS)(ALsizei, const ALuint*); +typedef ALboolean (AL_APIENTRY *LPALISFILTER)(ALuint); +typedef void (AL_APIENTRY *LPALFILTERI)(ALuint, ALenum, ALint); +typedef void (AL_APIENTRY *LPALFILTERIV)(ALuint, ALenum, const ALint*); +typedef void (AL_APIENTRY *LPALFILTERF)(ALuint, ALenum, ALfloat); +typedef void (AL_APIENTRY *LPALFILTERFV)(ALuint, ALenum, const ALfloat*); +typedef void (AL_APIENTRY *LPALGETFILTERI)(ALuint, ALenum, ALint*); +typedef void (AL_APIENTRY *LPALGETFILTERIV)(ALuint, ALenum, ALint*); +typedef void (AL_APIENTRY *LPALGETFILTERF)(ALuint, ALenum, ALfloat*); +typedef void (AL_APIENTRY *LPALGETFILTERFV)(ALuint, ALenum, ALfloat*); + +/* Auxiliary Effect Slot object function types. */ +typedef void (AL_APIENTRY *LPALGENAUXILIARYEFFECTSLOTS)(ALsizei, ALuint*); +typedef void (AL_APIENTRY *LPALDELETEAUXILIARYEFFECTSLOTS)(ALsizei, const ALuint*); +typedef ALboolean (AL_APIENTRY *LPALISAUXILIARYEFFECTSLOT)(ALuint); +typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint); +typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, const ALint*); +typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat); +typedef void (AL_APIENTRY *LPALAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, const ALfloat*); +typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTI)(ALuint, ALenum, ALint*); +typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTIV)(ALuint, ALenum, ALint*); +typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTF)(ALuint, ALenum, ALfloat*); +typedef void (AL_APIENTRY *LPALGETAUXILIARYEFFECTSLOTFV)(ALuint, ALenum, ALfloat*); + +#ifdef AL_ALEXT_PROTOTYPES +AL_API void AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects); +AL_API void AL_APIENTRY alDeleteEffects(ALsizei n, const ALuint *effects); +AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect); +AL_API void AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue); +AL_API void AL_APIENTRY alEffectiv(ALuint effect, ALenum param, const ALint *piValues); +AL_API void AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue); +AL_API void AL_APIENTRY alEffectfv(ALuint effect, ALenum param, const ALfloat *pflValues); +AL_API void AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue); +AL_API void AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues); +AL_API void AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue); +AL_API void AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues); + +AL_API void AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters); +AL_API void AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters); +AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter); +AL_API void AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue); +AL_API void AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues); +AL_API void AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue); +AL_API void AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues); +AL_API void AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue); +AL_API void AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues); +AL_API void AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue); +AL_API void AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues); + +AL_API void AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots); +AL_API void AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, const ALuint *effectslots); +AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot); +AL_API void AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue); +AL_API void AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, const ALint *piValues); +AL_API void AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue); +AL_API void AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, const ALfloat *pflValues); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue); +AL_API void AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues); +#endif + +/* Filter ranges and defaults. */ + +/* Lowpass filter */ +#define AL_LOWPASS_MIN_GAIN (0.0f) +#define AL_LOWPASS_MAX_GAIN (1.0f) +#define AL_LOWPASS_DEFAULT_GAIN (1.0f) + +#define AL_LOWPASS_MIN_GAINHF (0.0f) +#define AL_LOWPASS_MAX_GAINHF (1.0f) +#define AL_LOWPASS_DEFAULT_GAINHF (1.0f) + +/* Highpass filter */ +#define AL_HIGHPASS_MIN_GAIN (0.0f) +#define AL_HIGHPASS_MAX_GAIN (1.0f) +#define AL_HIGHPASS_DEFAULT_GAIN (1.0f) + +#define AL_HIGHPASS_MIN_GAINLF (0.0f) +#define AL_HIGHPASS_MAX_GAINLF (1.0f) +#define AL_HIGHPASS_DEFAULT_GAINLF (1.0f) + +/* Bandpass filter */ +#define AL_BANDPASS_MIN_GAIN (0.0f) +#define AL_BANDPASS_MAX_GAIN (1.0f) +#define AL_BANDPASS_DEFAULT_GAIN (1.0f) + +#define AL_BANDPASS_MIN_GAINHF (0.0f) +#define AL_BANDPASS_MAX_GAINHF (1.0f) +#define AL_BANDPASS_DEFAULT_GAINHF (1.0f) + +#define AL_BANDPASS_MIN_GAINLF (0.0f) +#define AL_BANDPASS_MAX_GAINLF (1.0f) +#define AL_BANDPASS_DEFAULT_GAINLF (1.0f) + + +/* Effect parameter ranges and defaults. */ + +/* Standard reverb effect */ +#define AL_REVERB_MIN_DENSITY (0.0f) +#define AL_REVERB_MAX_DENSITY (1.0f) +#define AL_REVERB_DEFAULT_DENSITY (1.0f) + +#define AL_REVERB_MIN_DIFFUSION (0.0f) +#define AL_REVERB_MAX_DIFFUSION (1.0f) +#define AL_REVERB_DEFAULT_DIFFUSION (1.0f) + +#define AL_REVERB_MIN_GAIN (0.0f) +#define AL_REVERB_MAX_GAIN (1.0f) +#define AL_REVERB_DEFAULT_GAIN (0.32f) + +#define AL_REVERB_MIN_GAINHF (0.0f) +#define AL_REVERB_MAX_GAINHF (1.0f) +#define AL_REVERB_DEFAULT_GAINHF (0.89f) + +#define AL_REVERB_MIN_DECAY_TIME (0.1f) +#define AL_REVERB_MAX_DECAY_TIME (20.0f) +#define AL_REVERB_DEFAULT_DECAY_TIME (1.49f) + +#define AL_REVERB_MIN_DECAY_HFRATIO (0.1f) +#define AL_REVERB_MAX_DECAY_HFRATIO (2.0f) +#define AL_REVERB_DEFAULT_DECAY_HFRATIO (0.83f) + +#define AL_REVERB_MIN_REFLECTIONS_GAIN (0.0f) +#define AL_REVERB_MAX_REFLECTIONS_GAIN (3.16f) +#define AL_REVERB_DEFAULT_REFLECTIONS_GAIN (0.05f) + +#define AL_REVERB_MIN_REFLECTIONS_DELAY (0.0f) +#define AL_REVERB_MAX_REFLECTIONS_DELAY (0.3f) +#define AL_REVERB_DEFAULT_REFLECTIONS_DELAY (0.007f) + +#define AL_REVERB_MIN_LATE_REVERB_GAIN (0.0f) +#define AL_REVERB_MAX_LATE_REVERB_GAIN (10.0f) +#define AL_REVERB_DEFAULT_LATE_REVERB_GAIN (1.26f) + +#define AL_REVERB_MIN_LATE_REVERB_DELAY (0.0f) +#define AL_REVERB_MAX_LATE_REVERB_DELAY (0.1f) +#define AL_REVERB_DEFAULT_LATE_REVERB_DELAY (0.011f) + +#define AL_REVERB_MIN_AIR_ABSORPTION_GAINHF (0.892f) +#define AL_REVERB_MAX_AIR_ABSORPTION_GAINHF (1.0f) +#define AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF (0.994f) + +#define AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR (0.0f) +#define AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR (10.0f) +#define AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f) + +#define AL_REVERB_MIN_DECAY_HFLIMIT AL_FALSE +#define AL_REVERB_MAX_DECAY_HFLIMIT AL_TRUE +#define AL_REVERB_DEFAULT_DECAY_HFLIMIT AL_TRUE + +/* EAX reverb effect */ +#define AL_EAXREVERB_MIN_DENSITY (0.0f) +#define AL_EAXREVERB_MAX_DENSITY (1.0f) +#define AL_EAXREVERB_DEFAULT_DENSITY (1.0f) + +#define AL_EAXREVERB_MIN_DIFFUSION (0.0f) +#define AL_EAXREVERB_MAX_DIFFUSION (1.0f) +#define AL_EAXREVERB_DEFAULT_DIFFUSION (1.0f) + +#define AL_EAXREVERB_MIN_GAIN (0.0f) +#define AL_EAXREVERB_MAX_GAIN (1.0f) +#define AL_EAXREVERB_DEFAULT_GAIN (0.32f) + +#define AL_EAXREVERB_MIN_GAINHF (0.0f) +#define AL_EAXREVERB_MAX_GAINHF (1.0f) +#define AL_EAXREVERB_DEFAULT_GAINHF (0.89f) + +#define AL_EAXREVERB_MIN_GAINLF (0.0f) +#define AL_EAXREVERB_MAX_GAINLF (1.0f) +#define AL_EAXREVERB_DEFAULT_GAINLF (1.0f) + +#define AL_EAXREVERB_MIN_DECAY_TIME (0.1f) +#define AL_EAXREVERB_MAX_DECAY_TIME (20.0f) +#define AL_EAXREVERB_DEFAULT_DECAY_TIME (1.49f) + +#define AL_EAXREVERB_MIN_DECAY_HFRATIO (0.1f) +#define AL_EAXREVERB_MAX_DECAY_HFRATIO (2.0f) +#define AL_EAXREVERB_DEFAULT_DECAY_HFRATIO (0.83f) + +#define AL_EAXREVERB_MIN_DECAY_LFRATIO (0.1f) +#define AL_EAXREVERB_MAX_DECAY_LFRATIO (2.0f) +#define AL_EAXREVERB_DEFAULT_DECAY_LFRATIO (1.0f) + +#define AL_EAXREVERB_MIN_REFLECTIONS_GAIN (0.0f) +#define AL_EAXREVERB_MAX_REFLECTIONS_GAIN (3.16f) +#define AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN (0.05f) + +#define AL_EAXREVERB_MIN_REFLECTIONS_DELAY (0.0f) +#define AL_EAXREVERB_MAX_REFLECTIONS_DELAY (0.3f) +#define AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY (0.007f) + +#define AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ (0.0f) + +#define AL_EAXREVERB_MIN_LATE_REVERB_GAIN (0.0f) +#define AL_EAXREVERB_MAX_LATE_REVERB_GAIN (10.0f) +#define AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN (1.26f) + +#define AL_EAXREVERB_MIN_LATE_REVERB_DELAY (0.0f) +#define AL_EAXREVERB_MAX_LATE_REVERB_DELAY (0.1f) +#define AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY (0.011f) + +#define AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ (0.0f) + +#define AL_EAXREVERB_MIN_ECHO_TIME (0.075f) +#define AL_EAXREVERB_MAX_ECHO_TIME (0.25f) +#define AL_EAXREVERB_DEFAULT_ECHO_TIME (0.25f) + +#define AL_EAXREVERB_MIN_ECHO_DEPTH (0.0f) +#define AL_EAXREVERB_MAX_ECHO_DEPTH (1.0f) +#define AL_EAXREVERB_DEFAULT_ECHO_DEPTH (0.0f) + +#define AL_EAXREVERB_MIN_MODULATION_TIME (0.04f) +#define AL_EAXREVERB_MAX_MODULATION_TIME (4.0f) +#define AL_EAXREVERB_DEFAULT_MODULATION_TIME (0.25f) + +#define AL_EAXREVERB_MIN_MODULATION_DEPTH (0.0f) +#define AL_EAXREVERB_MAX_MODULATION_DEPTH (1.0f) +#define AL_EAXREVERB_DEFAULT_MODULATION_DEPTH (0.0f) + +#define AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF (0.892f) +#define AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF (1.0f) +#define AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF (0.994f) + +#define AL_EAXREVERB_MIN_HFREFERENCE (1000.0f) +#define AL_EAXREVERB_MAX_HFREFERENCE (20000.0f) +#define AL_EAXREVERB_DEFAULT_HFREFERENCE (5000.0f) + +#define AL_EAXREVERB_MIN_LFREFERENCE (20.0f) +#define AL_EAXREVERB_MAX_LFREFERENCE (1000.0f) +#define AL_EAXREVERB_DEFAULT_LFREFERENCE (250.0f) + +#define AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR (0.0f) +#define AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR (10.0f) +#define AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f) + +#define AL_EAXREVERB_MIN_DECAY_HFLIMIT AL_FALSE +#define AL_EAXREVERB_MAX_DECAY_HFLIMIT AL_TRUE +#define AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT AL_TRUE + +/* Chorus effect */ +#define AL_CHORUS_WAVEFORM_SINUSOID (0) +#define AL_CHORUS_WAVEFORM_TRIANGLE (1) + +#define AL_CHORUS_MIN_WAVEFORM (0) +#define AL_CHORUS_MAX_WAVEFORM (1) +#define AL_CHORUS_DEFAULT_WAVEFORM (1) + +#define AL_CHORUS_MIN_PHASE (-180) +#define AL_CHORUS_MAX_PHASE (180) +#define AL_CHORUS_DEFAULT_PHASE (90) + +#define AL_CHORUS_MIN_RATE (0.0f) +#define AL_CHORUS_MAX_RATE (10.0f) +#define AL_CHORUS_DEFAULT_RATE (1.1f) + +#define AL_CHORUS_MIN_DEPTH (0.0f) +#define AL_CHORUS_MAX_DEPTH (1.0f) +#define AL_CHORUS_DEFAULT_DEPTH (0.1f) + +#define AL_CHORUS_MIN_FEEDBACK (-1.0f) +#define AL_CHORUS_MAX_FEEDBACK (1.0f) +#define AL_CHORUS_DEFAULT_FEEDBACK (0.25f) + +#define AL_CHORUS_MIN_DELAY (0.0f) +#define AL_CHORUS_MAX_DELAY (0.016f) +#define AL_CHORUS_DEFAULT_DELAY (0.016f) + +/* Distortion effect */ +#define AL_DISTORTION_MIN_EDGE (0.0f) +#define AL_DISTORTION_MAX_EDGE (1.0f) +#define AL_DISTORTION_DEFAULT_EDGE (0.2f) + +#define AL_DISTORTION_MIN_GAIN (0.01f) +#define AL_DISTORTION_MAX_GAIN (1.0f) +#define AL_DISTORTION_DEFAULT_GAIN (0.05f) + +#define AL_DISTORTION_MIN_LOWPASS_CUTOFF (80.0f) +#define AL_DISTORTION_MAX_LOWPASS_CUTOFF (24000.0f) +#define AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF (8000.0f) + +#define AL_DISTORTION_MIN_EQCENTER (80.0f) +#define AL_DISTORTION_MAX_EQCENTER (24000.0f) +#define AL_DISTORTION_DEFAULT_EQCENTER (3600.0f) + +#define AL_DISTORTION_MIN_EQBANDWIDTH (80.0f) +#define AL_DISTORTION_MAX_EQBANDWIDTH (24000.0f) +#define AL_DISTORTION_DEFAULT_EQBANDWIDTH (3600.0f) + +/* Echo effect */ +#define AL_ECHO_MIN_DELAY (0.0f) +#define AL_ECHO_MAX_DELAY (0.207f) +#define AL_ECHO_DEFAULT_DELAY (0.1f) + +#define AL_ECHO_MIN_LRDELAY (0.0f) +#define AL_ECHO_MAX_LRDELAY (0.404f) +#define AL_ECHO_DEFAULT_LRDELAY (0.1f) + +#define AL_ECHO_MIN_DAMPING (0.0f) +#define AL_ECHO_MAX_DAMPING (0.99f) +#define AL_ECHO_DEFAULT_DAMPING (0.5f) + +#define AL_ECHO_MIN_FEEDBACK (0.0f) +#define AL_ECHO_MAX_FEEDBACK (1.0f) +#define AL_ECHO_DEFAULT_FEEDBACK (0.5f) + +#define AL_ECHO_MIN_SPREAD (-1.0f) +#define AL_ECHO_MAX_SPREAD (1.0f) +#define AL_ECHO_DEFAULT_SPREAD (-1.0f) + +/* Flanger effect */ +#define AL_FLANGER_WAVEFORM_SINUSOID (0) +#define AL_FLANGER_WAVEFORM_TRIANGLE (1) + +#define AL_FLANGER_MIN_WAVEFORM (0) +#define AL_FLANGER_MAX_WAVEFORM (1) +#define AL_FLANGER_DEFAULT_WAVEFORM (1) + +#define AL_FLANGER_MIN_PHASE (-180) +#define AL_FLANGER_MAX_PHASE (180) +#define AL_FLANGER_DEFAULT_PHASE (0) + +#define AL_FLANGER_MIN_RATE (0.0f) +#define AL_FLANGER_MAX_RATE (10.0f) +#define AL_FLANGER_DEFAULT_RATE (0.27f) + +#define AL_FLANGER_MIN_DEPTH (0.0f) +#define AL_FLANGER_MAX_DEPTH (1.0f) +#define AL_FLANGER_DEFAULT_DEPTH (1.0f) + +#define AL_FLANGER_MIN_FEEDBACK (-1.0f) +#define AL_FLANGER_MAX_FEEDBACK (1.0f) +#define AL_FLANGER_DEFAULT_FEEDBACK (-0.5f) + +#define AL_FLANGER_MIN_DELAY (0.0f) +#define AL_FLANGER_MAX_DELAY (0.004f) +#define AL_FLANGER_DEFAULT_DELAY (0.002f) + +/* Frequency shifter effect */ +#define AL_FREQUENCY_SHIFTER_MIN_FREQUENCY (0.0f) +#define AL_FREQUENCY_SHIFTER_MAX_FREQUENCY (24000.0f) +#define AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY (0.0f) + +#define AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION (0) +#define AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION (2) +#define AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION (0) + +#define AL_FREQUENCY_SHIFTER_DIRECTION_DOWN (0) +#define AL_FREQUENCY_SHIFTER_DIRECTION_UP (1) +#define AL_FREQUENCY_SHIFTER_DIRECTION_OFF (2) + +#define AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION (0) +#define AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION (2) +#define AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION (0) + +/* Vocal morpher effect */ +#define AL_VOCAL_MORPHER_MIN_PHONEMEA (0) +#define AL_VOCAL_MORPHER_MAX_PHONEMEA (29) +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA (0) + +#define AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING (-24) +#define AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING (24) +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING (0) + +#define AL_VOCAL_MORPHER_MIN_PHONEMEB (0) +#define AL_VOCAL_MORPHER_MAX_PHONEMEB (29) +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB (10) + +#define AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING (-24) +#define AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING (24) +#define AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING (0) + +#define AL_VOCAL_MORPHER_PHONEME_A (0) +#define AL_VOCAL_MORPHER_PHONEME_E (1) +#define AL_VOCAL_MORPHER_PHONEME_I (2) +#define AL_VOCAL_MORPHER_PHONEME_O (3) +#define AL_VOCAL_MORPHER_PHONEME_U (4) +#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_EH (9) +#define AL_VOCAL_MORPHER_PHONEME_ER (10) +#define AL_VOCAL_MORPHER_PHONEME_IH (11) +#define AL_VOCAL_MORPHER_PHONEME_IY (12) +#define AL_VOCAL_MORPHER_PHONEME_UH (13) +#define AL_VOCAL_MORPHER_PHONEME_UW (14) +#define AL_VOCAL_MORPHER_PHONEME_B (15) +#define AL_VOCAL_MORPHER_PHONEME_D (16) +#define AL_VOCAL_MORPHER_PHONEME_F (17) +#define AL_VOCAL_MORPHER_PHONEME_G (18) +#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_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_V (28) +#define AL_VOCAL_MORPHER_PHONEME_Z (29) + +#define AL_VOCAL_MORPHER_WAVEFORM_SINUSOID (0) +#define AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE (1) +#define AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH (2) + +#define AL_VOCAL_MORPHER_MIN_WAVEFORM (0) +#define AL_VOCAL_MORPHER_MAX_WAVEFORM (2) +#define AL_VOCAL_MORPHER_DEFAULT_WAVEFORM (0) + +#define AL_VOCAL_MORPHER_MIN_RATE (0.0f) +#define AL_VOCAL_MORPHER_MAX_RATE (10.0f) +#define AL_VOCAL_MORPHER_DEFAULT_RATE (1.41f) + +/* Pitch shifter effect */ +#define AL_PITCH_SHIFTER_MIN_COARSE_TUNE (-12) +#define AL_PITCH_SHIFTER_MAX_COARSE_TUNE (12) +#define AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE (12) + +#define AL_PITCH_SHIFTER_MIN_FINE_TUNE (-50) +#define AL_PITCH_SHIFTER_MAX_FINE_TUNE (50) +#define AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE (0) + +/* Ring modulator effect */ +#define AL_RING_MODULATOR_MIN_FREQUENCY (0.0f) +#define AL_RING_MODULATOR_MAX_FREQUENCY (8000.0f) +#define AL_RING_MODULATOR_DEFAULT_FREQUENCY (440.0f) + +#define AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF (0.0f) +#define AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF (24000.0f) +#define AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF (800.0f) + +#define AL_RING_MODULATOR_SINUSOID (0) +#define AL_RING_MODULATOR_SAWTOOTH (1) +#define AL_RING_MODULATOR_SQUARE (2) + +#define AL_RING_MODULATOR_MIN_WAVEFORM (0) +#define AL_RING_MODULATOR_MAX_WAVEFORM (2) +#define AL_RING_MODULATOR_DEFAULT_WAVEFORM (0) + +/* Autowah effect */ +#define AL_AUTOWAH_MIN_ATTACK_TIME (0.0001f) +#define AL_AUTOWAH_MAX_ATTACK_TIME (1.0f) +#define AL_AUTOWAH_DEFAULT_ATTACK_TIME (0.06f) + +#define AL_AUTOWAH_MIN_RELEASE_TIME (0.0001f) +#define AL_AUTOWAH_MAX_RELEASE_TIME (1.0f) +#define AL_AUTOWAH_DEFAULT_RELEASE_TIME (0.06f) + +#define AL_AUTOWAH_MIN_RESONANCE (2.0f) +#define AL_AUTOWAH_MAX_RESONANCE (1000.0f) +#define AL_AUTOWAH_DEFAULT_RESONANCE (1000.0f) + +#define AL_AUTOWAH_MIN_PEAK_GAIN (0.00003f) +#define AL_AUTOWAH_MAX_PEAK_GAIN (31621.0f) +#define AL_AUTOWAH_DEFAULT_PEAK_GAIN (11.22f) + +/* Compressor effect */ +#define AL_COMPRESSOR_MIN_ONOFF (0) +#define AL_COMPRESSOR_MAX_ONOFF (1) +#define AL_COMPRESSOR_DEFAULT_ONOFF (1) + +/* Equalizer effect */ +#define AL_EQUALIZER_MIN_LOW_GAIN (0.126f) +#define AL_EQUALIZER_MAX_LOW_GAIN (7.943f) +#define AL_EQUALIZER_DEFAULT_LOW_GAIN (1.0f) + +#define AL_EQUALIZER_MIN_LOW_CUTOFF (50.0f) +#define AL_EQUALIZER_MAX_LOW_CUTOFF (800.0f) +#define AL_EQUALIZER_DEFAULT_LOW_CUTOFF (200.0f) + +#define AL_EQUALIZER_MIN_MID1_GAIN (0.126f) +#define AL_EQUALIZER_MAX_MID1_GAIN (7.943f) +#define AL_EQUALIZER_DEFAULT_MID1_GAIN (1.0f) + +#define AL_EQUALIZER_MIN_MID1_CENTER (200.0f) +#define AL_EQUALIZER_MAX_MID1_CENTER (3000.0f) +#define AL_EQUALIZER_DEFAULT_MID1_CENTER (500.0f) + +#define AL_EQUALIZER_MIN_MID1_WIDTH (0.01f) +#define AL_EQUALIZER_MAX_MID1_WIDTH (1.0f) +#define AL_EQUALIZER_DEFAULT_MID1_WIDTH (1.0f) + +#define AL_EQUALIZER_MIN_MID2_GAIN (0.126f) +#define AL_EQUALIZER_MAX_MID2_GAIN (7.943f) +#define AL_EQUALIZER_DEFAULT_MID2_GAIN (1.0f) + +#define AL_EQUALIZER_MIN_MID2_CENTER (1000.0f) +#define AL_EQUALIZER_MAX_MID2_CENTER (8000.0f) +#define AL_EQUALIZER_DEFAULT_MID2_CENTER (3000.0f) + +#define AL_EQUALIZER_MIN_MID2_WIDTH (0.01f) +#define AL_EQUALIZER_MAX_MID2_WIDTH (1.0f) +#define AL_EQUALIZER_DEFAULT_MID2_WIDTH (1.0f) + +#define AL_EQUALIZER_MIN_HIGH_GAIN (0.126f) +#define AL_EQUALIZER_MAX_HIGH_GAIN (7.943f) +#define AL_EQUALIZER_DEFAULT_HIGH_GAIN (1.0f) + +#define AL_EQUALIZER_MIN_HIGH_CUTOFF (4000.0f) +#define AL_EQUALIZER_MAX_HIGH_CUTOFF (16000.0f) +#define AL_EQUALIZER_DEFAULT_HIGH_CUTOFF (6000.0f) + + +/* Source parameter value ranges and defaults. */ +#define AL_MIN_AIR_ABSORPTION_FACTOR (0.0f) +#define AL_MAX_AIR_ABSORPTION_FACTOR (10.0f) +#define AL_DEFAULT_AIR_ABSORPTION_FACTOR (0.0f) + +#define AL_MIN_ROOM_ROLLOFF_FACTOR (0.0f) +#define AL_MAX_ROOM_ROLLOFF_FACTOR (10.0f) +#define AL_DEFAULT_ROOM_ROLLOFF_FACTOR (0.0f) + +#define AL_MIN_CONE_OUTER_GAINHF (0.0f) +#define AL_MAX_CONE_OUTER_GAINHF (1.0f) +#define AL_DEFAULT_CONE_OUTER_GAINHF (1.0f) + +#define AL_MIN_DIRECT_FILTER_GAINHF_AUTO AL_FALSE +#define AL_MAX_DIRECT_FILTER_GAINHF_AUTO AL_TRUE +#define AL_DEFAULT_DIRECT_FILTER_GAINHF_AUTO AL_TRUE + +#define AL_MIN_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_FALSE +#define AL_MAX_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_TRUE +#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAIN_AUTO AL_TRUE + +#define AL_MIN_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_FALSE +#define AL_MAX_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE +#define AL_DEFAULT_AUXILIARY_SEND_FILTER_GAINHF_AUTO AL_TRUE + + +/* Listener parameter value ranges and defaults. */ +#define AL_MIN_METERS_PER_UNIT FLT_MIN +#define AL_MAX_METERS_PER_UNIT FLT_MAX +#define AL_DEFAULT_METERS_PER_UNIT (1.0f) + + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* AL_EFX_H */ diff --git a/Generator/include/main.h b/Generator/include/main.h new file mode 100644 index 0000000..9d3f322 --- /dev/null +++ b/Generator/include/main.h @@ -0,0 +1,6 @@ +#include "al.h" +#include "alc.h" +#include "alext.h" +#include "efx.h" +#include "efx-creative.h" +#include "efx-presets.h" \ No newline at end of file diff --git a/Hexa.NET.OpenAL.sln b/Hexa.NET.OpenAL.sln new file mode 100644 index 0000000..7906546 --- /dev/null +++ b/Hexa.NET.OpenAL.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.11.35327.3 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Hexa.NET.OpenAL", "Hexa.NET.OpenAL\Hexa.NET.OpenAL.csproj", "{27BBE7DC-BCC5-4535-AD59-3C1F01F06954}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Generator", "Generator\Generator.csproj", "{B1DB7A8E-9847-4B53-A55D-3EFCE2B15215}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {27BBE7DC-BCC5-4535-AD59-3C1F01F06954}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {27BBE7DC-BCC5-4535-AD59-3C1F01F06954}.Debug|Any CPU.Build.0 = Debug|Any CPU + {27BBE7DC-BCC5-4535-AD59-3C1F01F06954}.Release|Any CPU.ActiveCfg = Release|Any CPU + {27BBE7DC-BCC5-4535-AD59-3C1F01F06954}.Release|Any CPU.Build.0 = Release|Any CPU + {B1DB7A8E-9847-4B53-A55D-3EFCE2B15215}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B1DB7A8E-9847-4B53-A55D-3EFCE2B15215}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B1DB7A8E-9847-4B53-A55D-3EFCE2B15215}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B1DB7A8E-9847-4B53-A55D-3EFCE2B15215}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {3DF65713-A4F2-4687-9CF1-CE61D0DD955F} + EndGlobalSection +EndGlobal diff --git a/Hexa.NET.OpenAL/Generated/Constants/Constants.000.cs b/Hexa.NET.OpenAL/Generated/Constants/Constants.000.cs new file mode 100644 index 0000000..44f9803 --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Constants/Constants.000.cs @@ -0,0 +1,3250 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + public unsafe partial class OpenAL + { + [NativeName(NativeNameType.Const, "AL_INVALID")] + [NativeName(NativeNameType.Value, "(-1)")] + public const int AL_INVALID = (-1); + + [NativeName(NativeNameType.Const, "AL_NONE")] + [NativeName(NativeNameType.Value, "0")] + public const int AL_NONE = 0; + + [NativeName(NativeNameType.Const, "AL_FALSE")] + [NativeName(NativeNameType.Value, "0")] + public const int AL_FALSE = 0; + + [NativeName(NativeNameType.Const, "AL_TRUE")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_TRUE = 1; + + [NativeName(NativeNameType.Const, "AL_SOURCE_RELATIVE")] + [NativeName(NativeNameType.Value, "0x202")] + public const int AL_SOURCE_RELATIVE = 0x202; + + [NativeName(NativeNameType.Const, "AL_CONE_INNER_ANGLE")] + [NativeName(NativeNameType.Value, "0x1001")] + public const int AL_CONE_INNER_ANGLE = 0x1001; + + [NativeName(NativeNameType.Const, "AL_CONE_OUTER_ANGLE")] + [NativeName(NativeNameType.Value, "0x1002")] + public const int AL_CONE_OUTER_ANGLE = 0x1002; + + [NativeName(NativeNameType.Const, "AL_PITCH")] + [NativeName(NativeNameType.Value, "0x1003")] + public const int AL_PITCH = 0x1003; + + [NativeName(NativeNameType.Const, "AL_POSITION")] + [NativeName(NativeNameType.Value, "0x1004")] + public const int AL_POSITION = 0x1004; + + [NativeName(NativeNameType.Const, "AL_DIRECTION")] + [NativeName(NativeNameType.Value, "0x1005")] + public const int AL_DIRECTION = 0x1005; + + [NativeName(NativeNameType.Const, "AL_VELOCITY")] + [NativeName(NativeNameType.Value, "0x1006")] + public const int AL_VELOCITY = 0x1006; + + [NativeName(NativeNameType.Const, "AL_LOOPING")] + [NativeName(NativeNameType.Value, "0x1007")] + public const int AL_LOOPING = 0x1007; + + [NativeName(NativeNameType.Const, "AL_BUFFER")] + [NativeName(NativeNameType.Value, "0x1009")] + public const int AL_BUFFER = 0x1009; + + [NativeName(NativeNameType.Const, "AL_GAIN")] + [NativeName(NativeNameType.Value, "0x100A")] + public const int AL_GAIN = 0x100A; + + [NativeName(NativeNameType.Const, "AL_MIN_GAIN")] + [NativeName(NativeNameType.Value, "0x100D")] + public const int AL_MIN_GAIN = 0x100D; + + [NativeName(NativeNameType.Const, "AL_MAX_GAIN")] + [NativeName(NativeNameType.Value, "0x100E")] + public const int AL_MAX_GAIN = 0x100E; + + [NativeName(NativeNameType.Const, "AL_ORIENTATION")] + [NativeName(NativeNameType.Value, "0x100F")] + public const int AL_ORIENTATION = 0x100F; + + [NativeName(NativeNameType.Const, "AL_SOURCE_STATE")] + [NativeName(NativeNameType.Value, "0x1010")] + public const int AL_SOURCE_STATE = 0x1010; + + [NativeName(NativeNameType.Const, "AL_INITIAL")] + [NativeName(NativeNameType.Value, "0x1011")] + public const int AL_INITIAL = 0x1011; + + [NativeName(NativeNameType.Const, "AL_PLAYING")] + [NativeName(NativeNameType.Value, "0x1012")] + public const int AL_PLAYING = 0x1012; + + [NativeName(NativeNameType.Const, "AL_PAUSED")] + [NativeName(NativeNameType.Value, "0x1013")] + public const int AL_PAUSED = 0x1013; + + [NativeName(NativeNameType.Const, "AL_STOPPED")] + [NativeName(NativeNameType.Value, "0x1014")] + public const int AL_STOPPED = 0x1014; + + [NativeName(NativeNameType.Const, "AL_BUFFERS_QUEUED")] + [NativeName(NativeNameType.Value, "0x1015")] + public const int AL_BUFFERS_QUEUED = 0x1015; + + [NativeName(NativeNameType.Const, "AL_BUFFERS_PROCESSED")] + [NativeName(NativeNameType.Value, "0x1016")] + public const int AL_BUFFERS_PROCESSED = 0x1016; + + [NativeName(NativeNameType.Const, "AL_REFERENCE_DISTANCE")] + [NativeName(NativeNameType.Value, "0x1020")] + public const int AL_REFERENCE_DISTANCE = 0x1020; + + [NativeName(NativeNameType.Const, "AL_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "0x1021")] + public const int AL_ROLLOFF_FACTOR = 0x1021; + + [NativeName(NativeNameType.Const, "AL_CONE_OUTER_GAIN")] + [NativeName(NativeNameType.Value, "0x1022")] + public const int AL_CONE_OUTER_GAIN = 0x1022; + + [NativeName(NativeNameType.Const, "AL_MAX_DISTANCE")] + [NativeName(NativeNameType.Value, "0x1023")] + public const int AL_MAX_DISTANCE = 0x1023; + + [NativeName(NativeNameType.Const, "AL_SEC_OFFSET")] + [NativeName(NativeNameType.Value, "0x1024")] + public const int AL_SEC_OFFSET = 0x1024; + + [NativeName(NativeNameType.Const, "AL_SAMPLE_OFFSET")] + [NativeName(NativeNameType.Value, "0x1025")] + public const int AL_SAMPLE_OFFSET = 0x1025; + + [NativeName(NativeNameType.Const, "AL_BYTE_OFFSET")] + [NativeName(NativeNameType.Value, "0x1026")] + public const int AL_BYTE_OFFSET = 0x1026; + + [NativeName(NativeNameType.Const, "AL_SOURCE_TYPE")] + [NativeName(NativeNameType.Value, "0x1027")] + public const int AL_SOURCE_TYPE = 0x1027; + + [NativeName(NativeNameType.Const, "AL_STATIC")] + [NativeName(NativeNameType.Value, "0x1028")] + public const int AL_STATIC = 0x1028; + + [NativeName(NativeNameType.Const, "AL_STREAMING")] + [NativeName(NativeNameType.Value, "0x1029")] + public const int AL_STREAMING = 0x1029; + + [NativeName(NativeNameType.Const, "AL_UNDETERMINED")] + [NativeName(NativeNameType.Value, "0x1030")] + public const int AL_UNDETERMINED = 0x1030; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO8")] + [NativeName(NativeNameType.Value, "0x1100")] + public const int AL_FORMAT_MONO8 = 0x1100; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO16")] + [NativeName(NativeNameType.Value, "0x1101")] + public const int AL_FORMAT_MONO16 = 0x1101; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO8")] + [NativeName(NativeNameType.Value, "0x1102")] + public const int AL_FORMAT_STEREO8 = 0x1102; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO16")] + [NativeName(NativeNameType.Value, "0x1103")] + public const int AL_FORMAT_STEREO16 = 0x1103; + + [NativeName(NativeNameType.Const, "AL_FREQUENCY")] + [NativeName(NativeNameType.Value, "0x2001")] + public const int AL_FREQUENCY = 0x2001; + + [NativeName(NativeNameType.Const, "AL_BITS")] + [NativeName(NativeNameType.Value, "0x2002")] + public const int AL_BITS = 0x2002; + + [NativeName(NativeNameType.Const, "AL_CHANNELS")] + [NativeName(NativeNameType.Value, "0x2003")] + public const int AL_CHANNELS = 0x2003; + + [NativeName(NativeNameType.Const, "AL_SIZE")] + [NativeName(NativeNameType.Value, "0x2004")] + public const int AL_SIZE = 0x2004; + + [NativeName(NativeNameType.Const, "AL_UNUSED")] + [NativeName(NativeNameType.Value, "0x2010")] + public const int AL_UNUSED = 0x2010; + + [NativeName(NativeNameType.Const, "AL_PENDING")] + [NativeName(NativeNameType.Value, "0x2011")] + public const int AL_PENDING = 0x2011; + + [NativeName(NativeNameType.Const, "AL_PROCESSED")] + [NativeName(NativeNameType.Value, "0x2012")] + public const int AL_PROCESSED = 0x2012; + + [NativeName(NativeNameType.Const, "AL_NO_ERROR")] + [NativeName(NativeNameType.Value, "0")] + public const int AL_NO_ERROR = 0; + + [NativeName(NativeNameType.Const, "AL_INVALID_NAME")] + [NativeName(NativeNameType.Value, "0xA001")] + public const int AL_INVALID_NAME = 0xA001; + + [NativeName(NativeNameType.Const, "AL_INVALID_ENUM")] + [NativeName(NativeNameType.Value, "0xA002")] + public const int AL_INVALID_ENUM = 0xA002; + + [NativeName(NativeNameType.Const, "AL_INVALID_VALUE")] + [NativeName(NativeNameType.Value, "0xA003")] + public const int AL_INVALID_VALUE = 0xA003; + + [NativeName(NativeNameType.Const, "AL_INVALID_OPERATION")] + [NativeName(NativeNameType.Value, "0xA004")] + public const int AL_INVALID_OPERATION = 0xA004; + + [NativeName(NativeNameType.Const, "AL_OUT_OF_MEMORY")] + [NativeName(NativeNameType.Value, "0xA005")] + public const int AL_OUT_OF_MEMORY = 0xA005; + + [NativeName(NativeNameType.Const, "AL_VENDOR")] + [NativeName(NativeNameType.Value, "0xB001")] + public const int AL_VENDOR = 0xB001; + + [NativeName(NativeNameType.Const, "AL_VERSION")] + [NativeName(NativeNameType.Value, "0xB002")] + public const int AL_VERSION = 0xB002; + + [NativeName(NativeNameType.Const, "AL_RENDERER")] + [NativeName(NativeNameType.Value, "0xB003")] + public const int AL_RENDERER = 0xB003; + + [NativeName(NativeNameType.Const, "AL_EXTENSIONS")] + [NativeName(NativeNameType.Value, "0xB004")] + public const int AL_EXTENSIONS = 0xB004; + + [NativeName(NativeNameType.Const, "AL_DOPPLER_FACTOR")] + [NativeName(NativeNameType.Value, "0xC000")] + public const int AL_DOPPLER_FACTOR = 0xC000; + + [NativeName(NativeNameType.Const, "AL_DOPPLER_VELOCITY")] + [NativeName(NativeNameType.Value, "0xC001")] + public const int AL_DOPPLER_VELOCITY = 0xC001; + + [NativeName(NativeNameType.Const, "AL_SPEED_OF_SOUND")] + [NativeName(NativeNameType.Value, "0xC003")] + public const int AL_SPEED_OF_SOUND = 0xC003; + + [NativeName(NativeNameType.Const, "AL_DISTANCE_MODEL")] + [NativeName(NativeNameType.Value, "0xD000")] + public const int AL_DISTANCE_MODEL = 0xD000; + + [NativeName(NativeNameType.Const, "AL_INVERSE_DISTANCE")] + [NativeName(NativeNameType.Value, "0xD001")] + public const int AL_INVERSE_DISTANCE = 0xD001; + + [NativeName(NativeNameType.Const, "AL_INVERSE_DISTANCE_CLAMPED")] + [NativeName(NativeNameType.Value, "0xD002")] + public const int AL_INVERSE_DISTANCE_CLAMPED = 0xD002; + + [NativeName(NativeNameType.Const, "AL_LINEAR_DISTANCE")] + [NativeName(NativeNameType.Value, "0xD003")] + public const int AL_LINEAR_DISTANCE = 0xD003; + + [NativeName(NativeNameType.Const, "AL_LINEAR_DISTANCE_CLAMPED")] + [NativeName(NativeNameType.Value, "0xD004")] + public const int AL_LINEAR_DISTANCE_CLAMPED = 0xD004; + + [NativeName(NativeNameType.Const, "AL_EXPONENT_DISTANCE")] + [NativeName(NativeNameType.Value, "0xD005")] + public const int AL_EXPONENT_DISTANCE = 0xD005; + + [NativeName(NativeNameType.Const, "AL_EXPONENT_DISTANCE_CLAMPED")] + [NativeName(NativeNameType.Value, "0xD006")] + public const int AL_EXPONENT_DISTANCE_CLAMPED = 0xD006; + + [NativeName(NativeNameType.Const, "ALC_INVALID")] + [NativeName(NativeNameType.Value, "0")] + public const int ALC_INVALID = 0; + + [NativeName(NativeNameType.Const, "ALC_VERSION_0_1")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_VERSION_0_1 = 1; + + [NativeName(NativeNameType.Const, "ALC_FALSE")] + [NativeName(NativeNameType.Value, "0")] + public const int ALC_FALSE = 0; + + [NativeName(NativeNameType.Const, "ALC_TRUE")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_TRUE = 1; + + [NativeName(NativeNameType.Const, "ALC_FREQUENCY")] + [NativeName(NativeNameType.Value, "0x1007")] + public const int ALC_FREQUENCY = 0x1007; + + [NativeName(NativeNameType.Const, "ALC_REFRESH")] + [NativeName(NativeNameType.Value, "0x1008")] + public const int ALC_REFRESH = 0x1008; + + [NativeName(NativeNameType.Const, "ALC_SYNC")] + [NativeName(NativeNameType.Value, "0x1009")] + public const int ALC_SYNC = 0x1009; + + [NativeName(NativeNameType.Const, "ALC_MONO_SOURCES")] + [NativeName(NativeNameType.Value, "0x1010")] + public const int ALC_MONO_SOURCES = 0x1010; + + [NativeName(NativeNameType.Const, "ALC_STEREO_SOURCES")] + [NativeName(NativeNameType.Value, "0x1011")] + public const int ALC_STEREO_SOURCES = 0x1011; + + [NativeName(NativeNameType.Const, "ALC_NO_ERROR")] + [NativeName(NativeNameType.Value, "0")] + public const int ALC_NO_ERROR = 0; + + [NativeName(NativeNameType.Const, "ALC_INVALID_DEVICE")] + [NativeName(NativeNameType.Value, "0xA001")] + public const int ALC_INVALID_DEVICE = 0xA001; + + [NativeName(NativeNameType.Const, "ALC_INVALID_CONTEXT")] + [NativeName(NativeNameType.Value, "0xA002")] + public const int ALC_INVALID_CONTEXT = 0xA002; + + [NativeName(NativeNameType.Const, "ALC_INVALID_ENUM")] + [NativeName(NativeNameType.Value, "0xA003")] + public const int ALC_INVALID_ENUM = 0xA003; + + [NativeName(NativeNameType.Const, "ALC_INVALID_VALUE")] + [NativeName(NativeNameType.Value, "0xA004")] + public const int ALC_INVALID_VALUE = 0xA004; + + [NativeName(NativeNameType.Const, "ALC_OUT_OF_MEMORY")] + [NativeName(NativeNameType.Value, "0xA005")] + public const int ALC_OUT_OF_MEMORY = 0xA005; + + [NativeName(NativeNameType.Const, "ALC_MAJOR_VERSION")] + [NativeName(NativeNameType.Value, "0x1000")] + public const int ALC_MAJOR_VERSION = 0x1000; + + [NativeName(NativeNameType.Const, "ALC_MINOR_VERSION")] + [NativeName(NativeNameType.Value, "0x1001")] + public const int ALC_MINOR_VERSION = 0x1001; + + [NativeName(NativeNameType.Const, "ALC_ATTRIBUTES_SIZE")] + [NativeName(NativeNameType.Value, "0x1002")] + public const int ALC_ATTRIBUTES_SIZE = 0x1002; + + [NativeName(NativeNameType.Const, "ALC_ALL_ATTRIBUTES")] + [NativeName(NativeNameType.Value, "0x1003")] + public const int ALC_ALL_ATTRIBUTES = 0x1003; + + [NativeName(NativeNameType.Const, "ALC_DEFAULT_DEVICE_SPECIFIER")] + [NativeName(NativeNameType.Value, "0x1004")] + public const int ALC_DEFAULT_DEVICE_SPECIFIER = 0x1004; + + [NativeName(NativeNameType.Const, "ALC_DEVICE_SPECIFIER")] + [NativeName(NativeNameType.Value, "0x1005")] + public const int ALC_DEVICE_SPECIFIER = 0x1005; + + [NativeName(NativeNameType.Const, "ALC_EXTENSIONS")] + [NativeName(NativeNameType.Value, "0x1006")] + public const int ALC_EXTENSIONS = 0x1006; + + [NativeName(NativeNameType.Const, "ALC_EXT_CAPTURE")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_EXT_CAPTURE = 1; + + [NativeName(NativeNameType.Const, "ALC_CAPTURE_DEVICE_SPECIFIER")] + [NativeName(NativeNameType.Value, "0x310")] + public const int ALC_CAPTURE_DEVICE_SPECIFIER = 0x310; + + [NativeName(NativeNameType.Const, "ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER")] + [NativeName(NativeNameType.Value, "0x311")] + public const int ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER = 0x311; + + [NativeName(NativeNameType.Const, "ALC_CAPTURE_SAMPLES")] + [NativeName(NativeNameType.Value, "0x312")] + public const int ALC_CAPTURE_SAMPLES = 0x312; + + [NativeName(NativeNameType.Const, "ALC_ENUMERATE_ALL_EXT")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_ENUMERATE_ALL_EXT = 1; + + [NativeName(NativeNameType.Const, "ALC_DEFAULT_ALL_DEVICES_SPECIFIER")] + [NativeName(NativeNameType.Value, "0x1012")] + public const int ALC_DEFAULT_ALL_DEVICES_SPECIFIER = 0x1012; + + [NativeName(NativeNameType.Const, "ALC_ALL_DEVICES_SPECIFIER")] + [NativeName(NativeNameType.Value, "0x1013")] + public const int ALC_ALL_DEVICES_SPECIFIER = 0x1013; + + [NativeName(NativeNameType.Const, "AL_LOKI_IMA_ADPCM_format")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_LOKI_IMA_ADPCM_format = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_IMA_ADPCM_MONO16_EXT")] + [NativeName(NativeNameType.Value, "0x10000")] + public const int AL_FORMAT_IMA_ADPCM_MONO16_EXT = 0x10000; + + [NativeName(NativeNameType.Const, "AL_FORMAT_IMA_ADPCM_STEREO16_EXT")] + [NativeName(NativeNameType.Value, "0x10001")] + public const int AL_FORMAT_IMA_ADPCM_STEREO16_EXT = 0x10001; + + [NativeName(NativeNameType.Const, "AL_LOKI_WAVE_format")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_LOKI_WAVE_format = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_WAVE_EXT")] + [NativeName(NativeNameType.Value, "0x10002")] + public const int AL_FORMAT_WAVE_EXT = 0x10002; + + [NativeName(NativeNameType.Const, "AL_EXT_vorbis")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_vorbis = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_VORBIS_EXT")] + [NativeName(NativeNameType.Value, "0x10003")] + public const int AL_FORMAT_VORBIS_EXT = 0x10003; + + [NativeName(NativeNameType.Const, "AL_LOKI_quadriphonic")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_LOKI_quadriphonic = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_QUAD8_LOKI")] + [NativeName(NativeNameType.Value, "0x10004")] + public const int AL_FORMAT_QUAD8_LOKI = 0x10004; + + [NativeName(NativeNameType.Const, "AL_FORMAT_QUAD16_LOKI")] + [NativeName(NativeNameType.Value, "0x10005")] + public const int AL_FORMAT_QUAD16_LOKI = 0x10005; + + [NativeName(NativeNameType.Const, "AL_EXT_float32")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_float32 = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO_FLOAT32")] + [NativeName(NativeNameType.Value, "0x10010")] + public const int AL_FORMAT_MONO_FLOAT32 = 0x10010; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO_FLOAT32")] + [NativeName(NativeNameType.Value, "0x10011")] + public const int AL_FORMAT_STEREO_FLOAT32 = 0x10011; + + [NativeName(NativeNameType.Const, "AL_EXT_double")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_double = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO_DOUBLE_EXT")] + [NativeName(NativeNameType.Value, "0x10012")] + public const int AL_FORMAT_MONO_DOUBLE_EXT = 0x10012; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO_DOUBLE_EXT")] + [NativeName(NativeNameType.Value, "0x10013")] + public const int AL_FORMAT_STEREO_DOUBLE_EXT = 0x10013; + + [NativeName(NativeNameType.Const, "AL_EXT_MULAW")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_MULAW = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO_MULAW_EXT")] + [NativeName(NativeNameType.Value, "0x10014")] + public const int AL_FORMAT_MONO_MULAW_EXT = 0x10014; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO_MULAW_EXT")] + [NativeName(NativeNameType.Value, "0x10015")] + public const int AL_FORMAT_STEREO_MULAW_EXT = 0x10015; + + [NativeName(NativeNameType.Const, "AL_EXT_ALAW")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_ALAW = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO_ALAW_EXT")] + [NativeName(NativeNameType.Value, "0x10016")] + public const int AL_FORMAT_MONO_ALAW_EXT = 0x10016; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO_ALAW_EXT")] + [NativeName(NativeNameType.Value, "0x10017")] + public const int AL_FORMAT_STEREO_ALAW_EXT = 0x10017; + + [NativeName(NativeNameType.Const, "ALC_LOKI_audio_channel")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_LOKI_audio_channel = 1; + + [NativeName(NativeNameType.Const, "ALC_CHAN_MAIN_LOKI")] + [NativeName(NativeNameType.Value, "0x500001")] + public const int ALC_CHAN_MAIN_LOKI = 0x500001; + + [NativeName(NativeNameType.Const, "ALC_CHAN_PCM_LOKI")] + [NativeName(NativeNameType.Value, "0x500002")] + public const int ALC_CHAN_PCM_LOKI = 0x500002; + + [NativeName(NativeNameType.Const, "ALC_CHAN_CD_LOKI")] + [NativeName(NativeNameType.Value, "0x500003")] + public const int ALC_CHAN_CD_LOKI = 0x500003; + + [NativeName(NativeNameType.Const, "AL_EXT_MCFORMATS")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_MCFORMATS = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_QUAD8")] + [NativeName(NativeNameType.Value, "0x1204")] + public const int AL_FORMAT_QUAD8 = 0x1204; + + [NativeName(NativeNameType.Const, "AL_FORMAT_QUAD16")] + [NativeName(NativeNameType.Value, "0x1205")] + public const int AL_FORMAT_QUAD16 = 0x1205; + + [NativeName(NativeNameType.Const, "AL_FORMAT_QUAD32")] + [NativeName(NativeNameType.Value, "0x1206")] + public const int AL_FORMAT_QUAD32 = 0x1206; + + [NativeName(NativeNameType.Const, "AL_FORMAT_REAR8")] + [NativeName(NativeNameType.Value, "0x1207")] + public const int AL_FORMAT_REAR8 = 0x1207; + + [NativeName(NativeNameType.Const, "AL_FORMAT_REAR16")] + [NativeName(NativeNameType.Value, "0x1208")] + public const int AL_FORMAT_REAR16 = 0x1208; + + [NativeName(NativeNameType.Const, "AL_FORMAT_REAR32")] + [NativeName(NativeNameType.Value, "0x1209")] + public const int AL_FORMAT_REAR32 = 0x1209; + + [NativeName(NativeNameType.Const, "AL_FORMAT_51CHN8")] + [NativeName(NativeNameType.Value, "0x120A")] + public const int AL_FORMAT_51CHN8 = 0x120A; + + [NativeName(NativeNameType.Const, "AL_FORMAT_51CHN16")] + [NativeName(NativeNameType.Value, "0x120B")] + public const int AL_FORMAT_51CHN16 = 0x120B; + + [NativeName(NativeNameType.Const, "AL_FORMAT_51CHN32")] + [NativeName(NativeNameType.Value, "0x120C")] + public const int AL_FORMAT_51CHN32 = 0x120C; + + [NativeName(NativeNameType.Const, "AL_FORMAT_61CHN8")] + [NativeName(NativeNameType.Value, "0x120D")] + public const int AL_FORMAT_61CHN8 = 0x120D; + + [NativeName(NativeNameType.Const, "AL_FORMAT_61CHN16")] + [NativeName(NativeNameType.Value, "0x120E")] + public const int AL_FORMAT_61CHN16 = 0x120E; + + [NativeName(NativeNameType.Const, "AL_FORMAT_61CHN32")] + [NativeName(NativeNameType.Value, "0x120F")] + public const int AL_FORMAT_61CHN32 = 0x120F; + + [NativeName(NativeNameType.Const, "AL_FORMAT_71CHN8")] + [NativeName(NativeNameType.Value, "0x1210")] + public const int AL_FORMAT_71CHN8 = 0x1210; + + [NativeName(NativeNameType.Const, "AL_FORMAT_71CHN16")] + [NativeName(NativeNameType.Value, "0x1211")] + public const int AL_FORMAT_71CHN16 = 0x1211; + + [NativeName(NativeNameType.Const, "AL_FORMAT_71CHN32")] + [NativeName(NativeNameType.Value, "0x1212")] + public const int AL_FORMAT_71CHN32 = 0x1212; + + [NativeName(NativeNameType.Const, "AL_EXT_MULAW_MCFORMATS")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_MULAW_MCFORMATS = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO_MULAW")] + [NativeName(NativeNameType.Value, "0x10014")] + public const int AL_FORMAT_MONO_MULAW = 0x10014; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO_MULAW")] + [NativeName(NativeNameType.Value, "0x10015")] + public const int AL_FORMAT_STEREO_MULAW = 0x10015; + + [NativeName(NativeNameType.Const, "AL_FORMAT_QUAD_MULAW")] + [NativeName(NativeNameType.Value, "0x10021")] + public const int AL_FORMAT_QUAD_MULAW = 0x10021; + + [NativeName(NativeNameType.Const, "AL_FORMAT_REAR_MULAW")] + [NativeName(NativeNameType.Value, "0x10022")] + public const int AL_FORMAT_REAR_MULAW = 0x10022; + + [NativeName(NativeNameType.Const, "AL_FORMAT_51CHN_MULAW")] + [NativeName(NativeNameType.Value, "0x10023")] + public const int AL_FORMAT_51CHN_MULAW = 0x10023; + + [NativeName(NativeNameType.Const, "AL_FORMAT_61CHN_MULAW")] + [NativeName(NativeNameType.Value, "0x10024")] + public const int AL_FORMAT_61CHN_MULAW = 0x10024; + + [NativeName(NativeNameType.Const, "AL_FORMAT_71CHN_MULAW")] + [NativeName(NativeNameType.Value, "0x10025")] + public const int AL_FORMAT_71CHN_MULAW = 0x10025; + + [NativeName(NativeNameType.Const, "AL_EXT_IMA4")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_IMA4 = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO_IMA4")] + [NativeName(NativeNameType.Value, "0x1300")] + public const int AL_FORMAT_MONO_IMA4 = 0x1300; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO_IMA4")] + [NativeName(NativeNameType.Value, "0x1301")] + public const int AL_FORMAT_STEREO_IMA4 = 0x1301; + + [NativeName(NativeNameType.Const, "AL_EXT_STATIC_BUFFER")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_STATIC_BUFFER = 1; + + [NativeName(NativeNameType.Const, "ALC_EXT_EFX")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_EXT_EFX = 1; + + [NativeName(NativeNameType.Const, "ALC_EXT_EFX_NAME")] + [NativeName(NativeNameType.Value, "\"ALC_EXT_EFX\"")] + public const string ALC_EXT_EFX_NAME = "ALC_EXT_EFX"; + + [NativeName(NativeNameType.Const, "ALC_EFX_MAJOR_VERSION")] + [NativeName(NativeNameType.Value, "0x20001")] + public const int ALC_EFX_MAJOR_VERSION = 0x20001; + + [NativeName(NativeNameType.Const, "ALC_EFX_MINOR_VERSION")] + [NativeName(NativeNameType.Value, "0x20002")] + public const int ALC_EFX_MINOR_VERSION = 0x20002; + + [NativeName(NativeNameType.Const, "ALC_MAX_AUXILIARY_SENDS")] + [NativeName(NativeNameType.Value, "0x20003")] + public const int ALC_MAX_AUXILIARY_SENDS = 0x20003; + + [NativeName(NativeNameType.Const, "AL_METERS_PER_UNIT")] + [NativeName(NativeNameType.Value, "0x20004")] + public const int AL_METERS_PER_UNIT = 0x20004; + + [NativeName(NativeNameType.Const, "AL_DIRECT_FILTER")] + [NativeName(NativeNameType.Value, "0x20005")] + public const int AL_DIRECT_FILTER = 0x20005; + + [NativeName(NativeNameType.Const, "AL_AUXILIARY_SEND_FILTER")] + [NativeName(NativeNameType.Value, "0x20006")] + public const int AL_AUXILIARY_SEND_FILTER = 0x20006; + + [NativeName(NativeNameType.Const, "AL_AIR_ABSORPTION_FACTOR")] + [NativeName(NativeNameType.Value, "0x20007")] + public const int AL_AIR_ABSORPTION_FACTOR = 0x20007; + + [NativeName(NativeNameType.Const, "AL_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "0x20008")] + public const int AL_ROOM_ROLLOFF_FACTOR = 0x20008; + + [NativeName(NativeNameType.Const, "AL_CONE_OUTER_GAINHF")] + [NativeName(NativeNameType.Value, "0x20009")] + public const int AL_CONE_OUTER_GAINHF = 0x20009; + + [NativeName(NativeNameType.Const, "AL_DIRECT_FILTER_GAINHF_AUTO")] + [NativeName(NativeNameType.Value, "0x2000A")] + public const int AL_DIRECT_FILTER_GAINHF_AUTO = 0x2000A; + + [NativeName(NativeNameType.Const, "AL_AUXILIARY_SEND_FILTER_GAIN_AUTO")] + [NativeName(NativeNameType.Value, "0x2000B")] + public const int AL_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x2000B; + + [NativeName(NativeNameType.Const, "AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO")] + [NativeName(NativeNameType.Value, "0x2000C")] + public const int AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x2000C; + + [NativeName(NativeNameType.Const, "AL_REVERB_DENSITY")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_REVERB_DENSITY = 0x0001; + + [NativeName(NativeNameType.Const, "AL_REVERB_DIFFUSION")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_REVERB_DIFFUSION = 0x0002; + + [NativeName(NativeNameType.Const, "AL_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_REVERB_GAIN = 0x0003; + + [NativeName(NativeNameType.Const, "AL_REVERB_GAINHF")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_REVERB_GAINHF = 0x0004; + + [NativeName(NativeNameType.Const, "AL_REVERB_DECAY_TIME")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_REVERB_DECAY_TIME = 0x0005; + + [NativeName(NativeNameType.Const, "AL_REVERB_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "0x0006")] + public const int AL_REVERB_DECAY_HFRATIO = 0x0006; + + [NativeName(NativeNameType.Const, "AL_REVERB_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "0x0007")] + public const int AL_REVERB_REFLECTIONS_GAIN = 0x0007; + + [NativeName(NativeNameType.Const, "AL_REVERB_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "0x0008")] + public const int AL_REVERB_REFLECTIONS_DELAY = 0x0008; + + [NativeName(NativeNameType.Const, "AL_REVERB_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "0x0009")] + public const int AL_REVERB_LATE_REVERB_GAIN = 0x0009; + + [NativeName(NativeNameType.Const, "AL_REVERB_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "0x000A")] + public const int AL_REVERB_LATE_REVERB_DELAY = 0x000A; + + [NativeName(NativeNameType.Const, "AL_REVERB_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "0x000B")] + public const int AL_REVERB_AIR_ABSORPTION_GAINHF = 0x000B; + + [NativeName(NativeNameType.Const, "AL_REVERB_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "0x000C")] + public const int AL_REVERB_ROOM_ROLLOFF_FACTOR = 0x000C; + + [NativeName(NativeNameType.Const, "AL_REVERB_DECAY_HFLIMIT")] + [NativeName(NativeNameType.Value, "0x000D")] + public const int AL_REVERB_DECAY_HFLIMIT = 0x000D; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DENSITY")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_EAXREVERB_DENSITY = 0x0001; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DIFFUSION")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_EAXREVERB_DIFFUSION = 0x0002; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_GAIN")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_EAXREVERB_GAIN = 0x0003; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_GAINHF")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_EAXREVERB_GAINHF = 0x0004; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_GAINLF")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_EAXREVERB_GAINLF = 0x0005; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DECAY_TIME")] + [NativeName(NativeNameType.Value, "0x0006")] + public const int AL_EAXREVERB_DECAY_TIME = 0x0006; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "0x0007")] + public const int AL_EAXREVERB_DECAY_HFRATIO = 0x0007; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DECAY_LFRATIO")] + [NativeName(NativeNameType.Value, "0x0008")] + public const int AL_EAXREVERB_DECAY_LFRATIO = 0x0008; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "0x0009")] + public const int AL_EAXREVERB_REFLECTIONS_GAIN = 0x0009; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "0x000A")] + public const int AL_EAXREVERB_REFLECTIONS_DELAY = 0x000A; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_REFLECTIONS_PAN")] + [NativeName(NativeNameType.Value, "0x000B")] + public const int AL_EAXREVERB_REFLECTIONS_PAN = 0x000B; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "0x000C")] + public const int AL_EAXREVERB_LATE_REVERB_GAIN = 0x000C; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "0x000D")] + public const int AL_EAXREVERB_LATE_REVERB_DELAY = 0x000D; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_LATE_REVERB_PAN")] + [NativeName(NativeNameType.Value, "0x000E")] + public const int AL_EAXREVERB_LATE_REVERB_PAN = 0x000E; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_ECHO_TIME")] + [NativeName(NativeNameType.Value, "0x000F")] + public const int AL_EAXREVERB_ECHO_TIME = 0x000F; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_ECHO_DEPTH")] + [NativeName(NativeNameType.Value, "0x0010")] + public const int AL_EAXREVERB_ECHO_DEPTH = 0x0010; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MODULATION_TIME")] + [NativeName(NativeNameType.Value, "0x0011")] + public const int AL_EAXREVERB_MODULATION_TIME = 0x0011; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MODULATION_DEPTH")] + [NativeName(NativeNameType.Value, "0x0012")] + public const int AL_EAXREVERB_MODULATION_DEPTH = 0x0012; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "0x0013")] + public const int AL_EAXREVERB_AIR_ABSORPTION_GAINHF = 0x0013; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_HFREFERENCE")] + [NativeName(NativeNameType.Value, "0x0014")] + public const int AL_EAXREVERB_HFREFERENCE = 0x0014; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_LFREFERENCE")] + [NativeName(NativeNameType.Value, "0x0015")] + public const int AL_EAXREVERB_LFREFERENCE = 0x0015; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "0x0016")] + public const int AL_EAXREVERB_ROOM_ROLLOFF_FACTOR = 0x0016; + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DECAY_HFLIMIT")] + [NativeName(NativeNameType.Value, "0x0017")] + public const int AL_EAXREVERB_DECAY_HFLIMIT = 0x0017; + + [NativeName(NativeNameType.Const, "AL_CHORUS_WAVEFORM")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_CHORUS_WAVEFORM = 0x0001; + + [NativeName(NativeNameType.Const, "AL_CHORUS_PHASE")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_CHORUS_PHASE = 0x0002; + + [NativeName(NativeNameType.Const, "AL_CHORUS_RATE")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_CHORUS_RATE = 0x0003; + + [NativeName(NativeNameType.Const, "AL_CHORUS_DEPTH")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_CHORUS_DEPTH = 0x0004; + + [NativeName(NativeNameType.Const, "AL_CHORUS_FEEDBACK")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_CHORUS_FEEDBACK = 0x0005; + + [NativeName(NativeNameType.Const, "AL_CHORUS_DELAY")] + [NativeName(NativeNameType.Value, "0x0006")] + public const int AL_CHORUS_DELAY = 0x0006; + + [NativeName(NativeNameType.Const, "AL_DISTORTION_EDGE")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_DISTORTION_EDGE = 0x0001; + + [NativeName(NativeNameType.Const, "AL_DISTORTION_GAIN")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_DISTORTION_GAIN = 0x0002; + + [NativeName(NativeNameType.Const, "AL_DISTORTION_LOWPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_DISTORTION_LOWPASS_CUTOFF = 0x0003; + + [NativeName(NativeNameType.Const, "AL_DISTORTION_EQCENTER")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_DISTORTION_EQCENTER = 0x0004; + + [NativeName(NativeNameType.Const, "AL_DISTORTION_EQBANDWIDTH")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_DISTORTION_EQBANDWIDTH = 0x0005; + + [NativeName(NativeNameType.Const, "AL_ECHO_DELAY")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_ECHO_DELAY = 0x0001; + + [NativeName(NativeNameType.Const, "AL_ECHO_LRDELAY")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_ECHO_LRDELAY = 0x0002; + + [NativeName(NativeNameType.Const, "AL_ECHO_DAMPING")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_ECHO_DAMPING = 0x0003; + + [NativeName(NativeNameType.Const, "AL_ECHO_FEEDBACK")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_ECHO_FEEDBACK = 0x0004; + + [NativeName(NativeNameType.Const, "AL_ECHO_SPREAD")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_ECHO_SPREAD = 0x0005; + + [NativeName(NativeNameType.Const, "AL_FLANGER_WAVEFORM")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_FLANGER_WAVEFORM = 0x0001; + + [NativeName(NativeNameType.Const, "AL_FLANGER_PHASE")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_FLANGER_PHASE = 0x0002; + + [NativeName(NativeNameType.Const, "AL_FLANGER_RATE")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_FLANGER_RATE = 0x0003; + + [NativeName(NativeNameType.Const, "AL_FLANGER_DEPTH")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_FLANGER_DEPTH = 0x0004; + + [NativeName(NativeNameType.Const, "AL_FLANGER_FEEDBACK")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_FLANGER_FEEDBACK = 0x0005; + + [NativeName(NativeNameType.Const, "AL_FLANGER_DELAY")] + [NativeName(NativeNameType.Value, "0x0006")] + public const int AL_FLANGER_DELAY = 0x0006; + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_FREQUENCY")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_FREQUENCY_SHIFTER_FREQUENCY = 0x0001; + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_LEFT_DIRECTION")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_FREQUENCY_SHIFTER_LEFT_DIRECTION = 0x0002; + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION = 0x0003; + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEMEA")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_VOCAL_MORPHER_PHONEMEA = 0x0001; + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING = 0x0002; + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEMEB")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_VOCAL_MORPHER_PHONEMEB = 0x0003; + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING = 0x0004; + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_WAVEFORM")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_VOCAL_MORPHER_WAVEFORM = 0x0005; + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_RATE")] + [NativeName(NativeNameType.Value, "0x0006")] + public const int AL_VOCAL_MORPHER_RATE = 0x0006; + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_COARSE_TUNE")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_PITCH_SHIFTER_COARSE_TUNE = 0x0001; + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_FINE_TUNE")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_PITCH_SHIFTER_FINE_TUNE = 0x0002; + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_FREQUENCY")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_RING_MODULATOR_FREQUENCY = 0x0001; + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_HIGHPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_RING_MODULATOR_HIGHPASS_CUTOFF = 0x0002; + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_WAVEFORM")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_RING_MODULATOR_WAVEFORM = 0x0003; + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_ATTACK_TIME")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_AUTOWAH_ATTACK_TIME = 0x0001; + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_RELEASE_TIME")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_AUTOWAH_RELEASE_TIME = 0x0002; + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_RESONANCE")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_AUTOWAH_RESONANCE = 0x0003; + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_PEAK_GAIN")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_AUTOWAH_PEAK_GAIN = 0x0004; + + [NativeName(NativeNameType.Const, "AL_COMPRESSOR_ONOFF")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_COMPRESSOR_ONOFF = 0x0001; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_LOW_GAIN")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_EQUALIZER_LOW_GAIN = 0x0001; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_LOW_CUTOFF")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_EQUALIZER_LOW_CUTOFF = 0x0002; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MID1_GAIN")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_EQUALIZER_MID1_GAIN = 0x0003; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MID1_CENTER")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_EQUALIZER_MID1_CENTER = 0x0004; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MID1_WIDTH")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_EQUALIZER_MID1_WIDTH = 0x0005; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MID2_GAIN")] + [NativeName(NativeNameType.Value, "0x0006")] + public const int AL_EQUALIZER_MID2_GAIN = 0x0006; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MID2_CENTER")] + [NativeName(NativeNameType.Value, "0x0007")] + public const int AL_EQUALIZER_MID2_CENTER = 0x0007; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MID2_WIDTH")] + [NativeName(NativeNameType.Value, "0x0008")] + public const int AL_EQUALIZER_MID2_WIDTH = 0x0008; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_HIGH_GAIN")] + [NativeName(NativeNameType.Value, "0x0009")] + public const int AL_EQUALIZER_HIGH_GAIN = 0x0009; + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_HIGH_CUTOFF")] + [NativeName(NativeNameType.Value, "0x000A")] + public const int AL_EQUALIZER_HIGH_CUTOFF = 0x000A; + + [NativeName(NativeNameType.Const, "AL_EFFECT_FIRST_PARAMETER")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int AL_EFFECT_FIRST_PARAMETER = 0x0000; + + [NativeName(NativeNameType.Const, "AL_EFFECT_LAST_PARAMETER")] + [NativeName(NativeNameType.Value, "0x8000")] + public const int AL_EFFECT_LAST_PARAMETER = 0x8000; + + [NativeName(NativeNameType.Const, "AL_EFFECT_TYPE")] + [NativeName(NativeNameType.Value, "0x8001")] + public const int AL_EFFECT_TYPE = 0x8001; + + [NativeName(NativeNameType.Const, "AL_EFFECT_NULL")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int AL_EFFECT_NULL = 0x0000; + + [NativeName(NativeNameType.Const, "AL_EFFECT_REVERB")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_EFFECT_REVERB = 0x0001; + + [NativeName(NativeNameType.Const, "AL_EFFECT_CHORUS")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_EFFECT_CHORUS = 0x0002; + + [NativeName(NativeNameType.Const, "AL_EFFECT_DISTORTION")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_EFFECT_DISTORTION = 0x0003; + + [NativeName(NativeNameType.Const, "AL_EFFECT_ECHO")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int AL_EFFECT_ECHO = 0x0004; + + [NativeName(NativeNameType.Const, "AL_EFFECT_FLANGER")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int AL_EFFECT_FLANGER = 0x0005; + + [NativeName(NativeNameType.Const, "AL_EFFECT_FREQUENCY_SHIFTER")] + [NativeName(NativeNameType.Value, "0x0006")] + public const int AL_EFFECT_FREQUENCY_SHIFTER = 0x0006; + + [NativeName(NativeNameType.Const, "AL_EFFECT_VOCAL_MORPHER")] + [NativeName(NativeNameType.Value, "0x0007")] + public const int AL_EFFECT_VOCAL_MORPHER = 0x0007; + + [NativeName(NativeNameType.Const, "AL_EFFECT_PITCH_SHIFTER")] + [NativeName(NativeNameType.Value, "0x0008")] + public const int AL_EFFECT_PITCH_SHIFTER = 0x0008; + + [NativeName(NativeNameType.Const, "AL_EFFECT_RING_MODULATOR")] + [NativeName(NativeNameType.Value, "0x0009")] + public const int AL_EFFECT_RING_MODULATOR = 0x0009; + + [NativeName(NativeNameType.Const, "AL_EFFECT_AUTOWAH")] + [NativeName(NativeNameType.Value, "0x000A")] + public const int AL_EFFECT_AUTOWAH = 0x000A; + + [NativeName(NativeNameType.Const, "AL_EFFECT_COMPRESSOR")] + [NativeName(NativeNameType.Value, "0x000B")] + public const int AL_EFFECT_COMPRESSOR = 0x000B; + + [NativeName(NativeNameType.Const, "AL_EFFECT_EQUALIZER")] + [NativeName(NativeNameType.Value, "0x000C")] + public const int AL_EFFECT_EQUALIZER = 0x000C; + + [NativeName(NativeNameType.Const, "AL_EFFECT_EAXREVERB")] + [NativeName(NativeNameType.Value, "0x8000")] + public const int AL_EFFECT_EAXREVERB = 0x8000; + + [NativeName(NativeNameType.Const, "AL_EFFECTSLOT_EFFECT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_EFFECTSLOT_EFFECT = 0x0001; + + [NativeName(NativeNameType.Const, "AL_EFFECTSLOT_GAIN")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_EFFECTSLOT_GAIN = 0x0002; + + [NativeName(NativeNameType.Const, "AL_EFFECTSLOT_AUXILIARY_SEND_AUTO")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_EFFECTSLOT_AUXILIARY_SEND_AUTO = 0x0003; + + [NativeName(NativeNameType.Const, "AL_EFFECTSLOT_NULL")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int AL_EFFECTSLOT_NULL = 0x0000; + + [NativeName(NativeNameType.Const, "AL_LOWPASS_GAIN")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_LOWPASS_GAIN = 0x0001; + + [NativeName(NativeNameType.Const, "AL_LOWPASS_GAINHF")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_LOWPASS_GAINHF = 0x0002; + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_GAIN")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_HIGHPASS_GAIN = 0x0001; + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_GAINLF")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_HIGHPASS_GAINLF = 0x0002; + + [NativeName(NativeNameType.Const, "AL_BANDPASS_GAIN")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_BANDPASS_GAIN = 0x0001; + + [NativeName(NativeNameType.Const, "AL_BANDPASS_GAINLF")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_BANDPASS_GAINLF = 0x0002; + + [NativeName(NativeNameType.Const, "AL_BANDPASS_GAINHF")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_BANDPASS_GAINHF = 0x0003; + + [NativeName(NativeNameType.Const, "AL_FILTER_FIRST_PARAMETER")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int AL_FILTER_FIRST_PARAMETER = 0x0000; + + [NativeName(NativeNameType.Const, "AL_FILTER_LAST_PARAMETER")] + [NativeName(NativeNameType.Value, "0x8000")] + public const int AL_FILTER_LAST_PARAMETER = 0x8000; + + [NativeName(NativeNameType.Const, "AL_FILTER_TYPE")] + [NativeName(NativeNameType.Value, "0x8001")] + public const int AL_FILTER_TYPE = 0x8001; + + [NativeName(NativeNameType.Const, "AL_FILTER_NULL")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int AL_FILTER_NULL = 0x0000; + + [NativeName(NativeNameType.Const, "AL_FILTER_LOWPASS")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_FILTER_LOWPASS = 0x0001; + + [NativeName(NativeNameType.Const, "AL_FILTER_HIGHPASS")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_FILTER_HIGHPASS = 0x0002; + + [NativeName(NativeNameType.Const, "AL_FILTER_BANDPASS")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int AL_FILTER_BANDPASS = 0x0003; + + [NativeName(NativeNameType.Const, "AL_LOWPASS_MIN_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_LOWPASS_MIN_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_LOWPASS_MAX_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_LOWPASS_MAX_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_LOWPASS_DEFAULT_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_LOWPASS_DEFAULT_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_LOWPASS_MIN_GAINHF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_LOWPASS_MIN_GAINHF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_LOWPASS_MAX_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_LOWPASS_MAX_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_LOWPASS_DEFAULT_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_LOWPASS_DEFAULT_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_MIN_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_HIGHPASS_MIN_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_MAX_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_HIGHPASS_MAX_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_DEFAULT_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_HIGHPASS_DEFAULT_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_MIN_GAINLF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_HIGHPASS_MIN_GAINLF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_MAX_GAINLF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_HIGHPASS_MAX_GAINLF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_HIGHPASS_DEFAULT_GAINLF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_HIGHPASS_DEFAULT_GAINLF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_MIN_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_BANDPASS_MIN_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_MAX_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_BANDPASS_MAX_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_DEFAULT_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_BANDPASS_DEFAULT_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_MIN_GAINHF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_BANDPASS_MIN_GAINHF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_MAX_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_BANDPASS_MAX_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_DEFAULT_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_BANDPASS_DEFAULT_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_MIN_GAINLF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_BANDPASS_MIN_GAINLF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_MAX_GAINLF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_BANDPASS_MAX_GAINLF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_BANDPASS_DEFAULT_GAINLF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_BANDPASS_DEFAULT_GAINLF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_DENSITY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_DENSITY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_DENSITY")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_REVERB_MAX_DENSITY = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_DENSITY")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_REVERB_DEFAULT_DENSITY = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_DIFFUSION")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_DIFFUSION = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_DIFFUSION")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_REVERB_MAX_DIFFUSION = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_DIFFUSION")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_REVERB_DEFAULT_DIFFUSION = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_REVERB_MAX_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_GAIN")] + [NativeName(NativeNameType.Value, "(0.32f)")] + public const float AL_REVERB_DEFAULT_GAIN = (0.32f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_GAINHF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_GAINHF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_REVERB_MAX_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_GAINHF")] + [NativeName(NativeNameType.Value, "(0.89f)")] + public const float AL_REVERB_DEFAULT_GAINHF = (0.89f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_DECAY_TIME")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_REVERB_MIN_DECAY_TIME = (0.1f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_DECAY_TIME")] + [NativeName(NativeNameType.Value, "(20.0f)")] + public const float AL_REVERB_MAX_DECAY_TIME = (20.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_DECAY_TIME")] + [NativeName(NativeNameType.Value, "(1.49f)")] + public const float AL_REVERB_DEFAULT_DECAY_TIME = (1.49f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_REVERB_MIN_DECAY_HFRATIO = (0.1f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "(2.0f)")] + public const float AL_REVERB_MAX_DECAY_HFRATIO = (2.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "(0.83f)")] + public const float AL_REVERB_DEFAULT_DECAY_HFRATIO = (0.83f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_REFLECTIONS_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "(3.16f)")] + public const float AL_REVERB_MAX_REFLECTIONS_GAIN = (3.16f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "(0.05f)")] + public const float AL_REVERB_DEFAULT_REFLECTIONS_GAIN = (0.05f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_REFLECTIONS_DELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "(0.3f)")] + public const float AL_REVERB_MAX_REFLECTIONS_DELAY = (0.3f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "(0.007f)")] + public const float AL_REVERB_DEFAULT_REFLECTIONS_DELAY = (0.007f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_LATE_REVERB_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_REVERB_MAX_LATE_REVERB_GAIN = (10.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "(1.26f)")] + public const float AL_REVERB_DEFAULT_LATE_REVERB_GAIN = (1.26f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_LATE_REVERB_DELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_REVERB_MAX_LATE_REVERB_DELAY = (0.1f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "(0.011f)")] + public const float AL_REVERB_DEFAULT_LATE_REVERB_DELAY = (0.011f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "(0.892f)")] + public const float AL_REVERB_MIN_AIR_ABSORPTION_GAINHF = (0.892f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_REVERB_MAX_AIR_ABSORPTION_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "(0.994f)")] + public const float AL_REVERB_DEFAULT_AIR_ABSORPTION_GAINHF = (0.994f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR = (10.0f); + + [NativeName(NativeNameType.Const, "AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_REVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_DENSITY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_DENSITY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_DENSITY")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_DENSITY = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_DENSITY")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_DEFAULT_DENSITY = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_DIFFUSION")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_DIFFUSION = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_DIFFUSION")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_DIFFUSION = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_DIFFUSION")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_DEFAULT_DIFFUSION = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_GAIN")] + [NativeName(NativeNameType.Value, "(0.32f)")] + public const float AL_EAXREVERB_DEFAULT_GAIN = (0.32f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_GAINHF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_GAINHF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_GAINHF")] + [NativeName(NativeNameType.Value, "(0.89f)")] + public const float AL_EAXREVERB_DEFAULT_GAINHF = (0.89f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_GAINLF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_GAINLF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_GAINLF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_GAINLF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_GAINLF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_DEFAULT_GAINLF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_DECAY_TIME")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_EAXREVERB_MIN_DECAY_TIME = (0.1f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_DECAY_TIME")] + [NativeName(NativeNameType.Value, "(20.0f)")] + public const float AL_EAXREVERB_MAX_DECAY_TIME = (20.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_DECAY_TIME")] + [NativeName(NativeNameType.Value, "(1.49f)")] + public const float AL_EAXREVERB_DEFAULT_DECAY_TIME = (1.49f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_EAXREVERB_MIN_DECAY_HFRATIO = (0.1f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "(2.0f)")] + public const float AL_EAXREVERB_MAX_DECAY_HFRATIO = (2.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_DECAY_HFRATIO")] + [NativeName(NativeNameType.Value, "(0.83f)")] + public const float AL_EAXREVERB_DEFAULT_DECAY_HFRATIO = (0.83f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_DECAY_LFRATIO")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_EAXREVERB_MIN_DECAY_LFRATIO = (0.1f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_DECAY_LFRATIO")] + [NativeName(NativeNameType.Value, "(2.0f)")] + public const float AL_EAXREVERB_MAX_DECAY_LFRATIO = (2.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_DECAY_LFRATIO")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_DEFAULT_DECAY_LFRATIO = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_REFLECTIONS_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "(3.16f)")] + public const float AL_EAXREVERB_MAX_REFLECTIONS_GAIN = (3.16f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN")] + [NativeName(NativeNameType.Value, "(0.05f)")] + public const float AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN = (0.05f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_REFLECTIONS_DELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "(0.3f)")] + public const float AL_EAXREVERB_MAX_REFLECTIONS_DELAY = (0.3f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY")] + [NativeName(NativeNameType.Value, "(0.007f)")] + public const float AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY = (0.007f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_LATE_REVERB_GAIN = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_EAXREVERB_MAX_LATE_REVERB_GAIN = (10.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN")] + [NativeName(NativeNameType.Value, "(1.26f)")] + public const float AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN = (1.26f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_LATE_REVERB_DELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_EAXREVERB_MAX_LATE_REVERB_DELAY = (0.1f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY")] + [NativeName(NativeNameType.Value, "(0.011f)")] + public const float AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY = (0.011f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_ECHO_TIME")] + [NativeName(NativeNameType.Value, "(0.075f)")] + public const float AL_EAXREVERB_MIN_ECHO_TIME = (0.075f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_ECHO_TIME")] + [NativeName(NativeNameType.Value, "(0.25f)")] + public const float AL_EAXREVERB_MAX_ECHO_TIME = (0.25f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_ECHO_TIME")] + [NativeName(NativeNameType.Value, "(0.25f)")] + public const float AL_EAXREVERB_DEFAULT_ECHO_TIME = (0.25f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_ECHO_DEPTH")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_ECHO_DEPTH = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_ECHO_DEPTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_ECHO_DEPTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_ECHO_DEPTH")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_DEFAULT_ECHO_DEPTH = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_MODULATION_TIME")] + [NativeName(NativeNameType.Value, "(0.04f)")] + public const float AL_EAXREVERB_MIN_MODULATION_TIME = (0.04f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_MODULATION_TIME")] + [NativeName(NativeNameType.Value, "(4.0f)")] + public const float AL_EAXREVERB_MAX_MODULATION_TIME = (4.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_MODULATION_TIME")] + [NativeName(NativeNameType.Value, "(0.25f)")] + public const float AL_EAXREVERB_DEFAULT_MODULATION_TIME = (0.25f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_MODULATION_DEPTH")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_MODULATION_DEPTH = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_MODULATION_DEPTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_MODULATION_DEPTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_MODULATION_DEPTH")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_DEFAULT_MODULATION_DEPTH = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "(0.892f)")] + public const float AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF = (0.892f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF")] + [NativeName(NativeNameType.Value, "(0.994f)")] + public const float AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF = (0.994f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_HFREFERENCE")] + [NativeName(NativeNameType.Value, "(1000.0f)")] + public const float AL_EAXREVERB_MIN_HFREFERENCE = (1000.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_HFREFERENCE")] + [NativeName(NativeNameType.Value, "(20000.0f)")] + public const float AL_EAXREVERB_MAX_HFREFERENCE = (20000.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_HFREFERENCE")] + [NativeName(NativeNameType.Value, "(5000.0f)")] + public const float AL_EAXREVERB_DEFAULT_HFREFERENCE = (5000.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_LFREFERENCE")] + [NativeName(NativeNameType.Value, "(20.0f)")] + public const float AL_EAXREVERB_MIN_LFREFERENCE = (20.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_LFREFERENCE")] + [NativeName(NativeNameType.Value, "(1000.0f)")] + public const float AL_EAXREVERB_MAX_LFREFERENCE = (1000.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_LFREFERENCE")] + [NativeName(NativeNameType.Value, "(250.0f)")] + public const float AL_EAXREVERB_DEFAULT_LFREFERENCE = (250.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_MIN_ROOM_ROLLOFF_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_EAXREVERB_MAX_ROOM_ROLLOFF_FACTOR = (10.0f); + + [NativeName(NativeNameType.Const, "AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_WAVEFORM_SINUSOID")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_CHORUS_WAVEFORM_SINUSOID = (0); + + [NativeName(NativeNameType.Const, "AL_CHORUS_WAVEFORM_TRIANGLE")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_CHORUS_WAVEFORM_TRIANGLE = (1); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MIN_WAVEFORM")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_CHORUS_MIN_WAVEFORM = (0); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MAX_WAVEFORM")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_CHORUS_MAX_WAVEFORM = (1); + + [NativeName(NativeNameType.Const, "AL_CHORUS_DEFAULT_WAVEFORM")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_CHORUS_DEFAULT_WAVEFORM = (1); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MIN_PHASE")] + [NativeName(NativeNameType.Value, "(-180)")] + public const int AL_CHORUS_MIN_PHASE = (-180); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MAX_PHASE")] + [NativeName(NativeNameType.Value, "(180)")] + public const int AL_CHORUS_MAX_PHASE = (180); + + [NativeName(NativeNameType.Const, "AL_CHORUS_DEFAULT_PHASE")] + [NativeName(NativeNameType.Value, "(90)")] + public const int AL_CHORUS_DEFAULT_PHASE = (90); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MIN_RATE")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_CHORUS_MIN_RATE = (0.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MAX_RATE")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_CHORUS_MAX_RATE = (10.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_DEFAULT_RATE")] + [NativeName(NativeNameType.Value, "(1.1f)")] + public const float AL_CHORUS_DEFAULT_RATE = (1.1f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MIN_DEPTH")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_CHORUS_MIN_DEPTH = (0.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MAX_DEPTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_CHORUS_MAX_DEPTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_DEFAULT_DEPTH")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_CHORUS_DEFAULT_DEPTH = (0.1f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MIN_FEEDBACK")] + [NativeName(NativeNameType.Value, "(-1.0f)")] + public const float AL_CHORUS_MIN_FEEDBACK = (-1.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MAX_FEEDBACK")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_CHORUS_MAX_FEEDBACK = (1.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_DEFAULT_FEEDBACK")] + [NativeName(NativeNameType.Value, "(0.25f)")] + public const float AL_CHORUS_DEFAULT_FEEDBACK = (0.25f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MIN_DELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_CHORUS_MIN_DELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_MAX_DELAY")] + [NativeName(NativeNameType.Value, "(0.016f)")] + public const float AL_CHORUS_MAX_DELAY = (0.016f); + + [NativeName(NativeNameType.Const, "AL_CHORUS_DEFAULT_DELAY")] + [NativeName(NativeNameType.Value, "(0.016f)")] + public const float AL_CHORUS_DEFAULT_DELAY = (0.016f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MIN_EDGE")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_DISTORTION_MIN_EDGE = (0.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MAX_EDGE")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_DISTORTION_MAX_EDGE = (1.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_DEFAULT_EDGE")] + [NativeName(NativeNameType.Value, "(0.2f)")] + public const float AL_DISTORTION_DEFAULT_EDGE = (0.2f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MIN_GAIN")] + [NativeName(NativeNameType.Value, "(0.01f)")] + public const float AL_DISTORTION_MIN_GAIN = (0.01f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MAX_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_DISTORTION_MAX_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_DEFAULT_GAIN")] + [NativeName(NativeNameType.Value, "(0.05f)")] + public const float AL_DISTORTION_DEFAULT_GAIN = (0.05f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MIN_LOWPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "(80.0f)")] + public const float AL_DISTORTION_MIN_LOWPASS_CUTOFF = (80.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MAX_LOWPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "(24000.0f)")] + public const float AL_DISTORTION_MAX_LOWPASS_CUTOFF = (24000.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "(8000.0f)")] + public const float AL_DISTORTION_DEFAULT_LOWPASS_CUTOFF = (8000.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MIN_EQCENTER")] + [NativeName(NativeNameType.Value, "(80.0f)")] + public const float AL_DISTORTION_MIN_EQCENTER = (80.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MAX_EQCENTER")] + [NativeName(NativeNameType.Value, "(24000.0f)")] + public const float AL_DISTORTION_MAX_EQCENTER = (24000.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_DEFAULT_EQCENTER")] + [NativeName(NativeNameType.Value, "(3600.0f)")] + public const float AL_DISTORTION_DEFAULT_EQCENTER = (3600.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MIN_EQBANDWIDTH")] + [NativeName(NativeNameType.Value, "(80.0f)")] + public const float AL_DISTORTION_MIN_EQBANDWIDTH = (80.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_MAX_EQBANDWIDTH")] + [NativeName(NativeNameType.Value, "(24000.0f)")] + public const float AL_DISTORTION_MAX_EQBANDWIDTH = (24000.0f); + + [NativeName(NativeNameType.Const, "AL_DISTORTION_DEFAULT_EQBANDWIDTH")] + [NativeName(NativeNameType.Value, "(3600.0f)")] + public const float AL_DISTORTION_DEFAULT_EQBANDWIDTH = (3600.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MIN_DELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_ECHO_MIN_DELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MAX_DELAY")] + [NativeName(NativeNameType.Value, "(0.207f)")] + public const float AL_ECHO_MAX_DELAY = (0.207f); + + [NativeName(NativeNameType.Const, "AL_ECHO_DEFAULT_DELAY")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_ECHO_DEFAULT_DELAY = (0.1f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MIN_LRDELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_ECHO_MIN_LRDELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MAX_LRDELAY")] + [NativeName(NativeNameType.Value, "(0.404f)")] + public const float AL_ECHO_MAX_LRDELAY = (0.404f); + + [NativeName(NativeNameType.Const, "AL_ECHO_DEFAULT_LRDELAY")] + [NativeName(NativeNameType.Value, "(0.1f)")] + public const float AL_ECHO_DEFAULT_LRDELAY = (0.1f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MIN_DAMPING")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_ECHO_MIN_DAMPING = (0.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MAX_DAMPING")] + [NativeName(NativeNameType.Value, "(0.99f)")] + public const float AL_ECHO_MAX_DAMPING = (0.99f); + + [NativeName(NativeNameType.Const, "AL_ECHO_DEFAULT_DAMPING")] + [NativeName(NativeNameType.Value, "(0.5f)")] + public const float AL_ECHO_DEFAULT_DAMPING = (0.5f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MIN_FEEDBACK")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_ECHO_MIN_FEEDBACK = (0.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MAX_FEEDBACK")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_ECHO_MAX_FEEDBACK = (1.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_DEFAULT_FEEDBACK")] + [NativeName(NativeNameType.Value, "(0.5f)")] + public const float AL_ECHO_DEFAULT_FEEDBACK = (0.5f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MIN_SPREAD")] + [NativeName(NativeNameType.Value, "(-1.0f)")] + public const float AL_ECHO_MIN_SPREAD = (-1.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_MAX_SPREAD")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_ECHO_MAX_SPREAD = (1.0f); + + [NativeName(NativeNameType.Const, "AL_ECHO_DEFAULT_SPREAD")] + [NativeName(NativeNameType.Value, "(-1.0f)")] + public const float AL_ECHO_DEFAULT_SPREAD = (-1.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_WAVEFORM_SINUSOID")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FLANGER_WAVEFORM_SINUSOID = (0); + + [NativeName(NativeNameType.Const, "AL_FLANGER_WAVEFORM_TRIANGLE")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_FLANGER_WAVEFORM_TRIANGLE = (1); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MIN_WAVEFORM")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FLANGER_MIN_WAVEFORM = (0); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MAX_WAVEFORM")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_FLANGER_MAX_WAVEFORM = (1); + + [NativeName(NativeNameType.Const, "AL_FLANGER_DEFAULT_WAVEFORM")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_FLANGER_DEFAULT_WAVEFORM = (1); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MIN_PHASE")] + [NativeName(NativeNameType.Value, "(-180)")] + public const int AL_FLANGER_MIN_PHASE = (-180); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MAX_PHASE")] + [NativeName(NativeNameType.Value, "(180)")] + public const int AL_FLANGER_MAX_PHASE = (180); + + [NativeName(NativeNameType.Const, "AL_FLANGER_DEFAULT_PHASE")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FLANGER_DEFAULT_PHASE = (0); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MIN_RATE")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_FLANGER_MIN_RATE = (0.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MAX_RATE")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_FLANGER_MAX_RATE = (10.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_DEFAULT_RATE")] + [NativeName(NativeNameType.Value, "(0.27f)")] + public const float AL_FLANGER_DEFAULT_RATE = (0.27f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MIN_DEPTH")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_FLANGER_MIN_DEPTH = (0.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MAX_DEPTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_FLANGER_MAX_DEPTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_DEFAULT_DEPTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_FLANGER_DEFAULT_DEPTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MIN_FEEDBACK")] + [NativeName(NativeNameType.Value, "(-1.0f)")] + public const float AL_FLANGER_MIN_FEEDBACK = (-1.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MAX_FEEDBACK")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_FLANGER_MAX_FEEDBACK = (1.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_DEFAULT_FEEDBACK")] + [NativeName(NativeNameType.Value, "(-0.5f)")] + public const float AL_FLANGER_DEFAULT_FEEDBACK = (-0.5f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MIN_DELAY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_FLANGER_MIN_DELAY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_MAX_DELAY")] + [NativeName(NativeNameType.Value, "(0.004f)")] + public const float AL_FLANGER_MAX_DELAY = (0.004f); + + [NativeName(NativeNameType.Const, "AL_FLANGER_DEFAULT_DELAY")] + [NativeName(NativeNameType.Value, "(0.002f)")] + public const float AL_FLANGER_DEFAULT_DELAY = (0.002f); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_MIN_FREQUENCY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_FREQUENCY_SHIFTER_MIN_FREQUENCY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_MAX_FREQUENCY")] + [NativeName(NativeNameType.Value, "(24000.0f)")] + public const float AL_FREQUENCY_SHIFTER_MAX_FREQUENCY = (24000.0f); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_FREQUENCY_SHIFTER_DEFAULT_FREQUENCY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FREQUENCY_SHIFTER_MIN_LEFT_DIRECTION = (0); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_FREQUENCY_SHIFTER_MAX_LEFT_DIRECTION = (2); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FREQUENCY_SHIFTER_DEFAULT_LEFT_DIRECTION = (0); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_DIRECTION_DOWN")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FREQUENCY_SHIFTER_DIRECTION_DOWN = (0); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_DIRECTION_UP")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_FREQUENCY_SHIFTER_DIRECTION_UP = (1); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_DIRECTION_OFF")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_FREQUENCY_SHIFTER_DIRECTION_OFF = (2); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FREQUENCY_SHIFTER_MIN_RIGHT_DIRECTION = (0); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_FREQUENCY_SHIFTER_MAX_RIGHT_DIRECTION = (2); + + [NativeName(NativeNameType.Const, "AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_FREQUENCY_SHIFTER_DEFAULT_RIGHT_DIRECTION = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MIN_PHONEMEA")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_MIN_PHONEMEA = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MAX_PHONEMEA")] + [NativeName(NativeNameType.Value, "(29)")] + public const int AL_VOCAL_MORPHER_MAX_PHONEMEA = (29); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_DEFAULT_PHONEMEA")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_DEFAULT_PHONEMEA = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "(-24)")] + public const int AL_VOCAL_MORPHER_MIN_PHONEMEA_COARSE_TUNING = (-24); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "(24)")] + public const int AL_VOCAL_MORPHER_MAX_PHONEMEA_COARSE_TUNING = (24); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_DEFAULT_PHONEMEA_COARSE_TUNING = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MIN_PHONEMEB")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_MIN_PHONEMEB = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MAX_PHONEMEB")] + [NativeName(NativeNameType.Value, "(29)")] + public const int AL_VOCAL_MORPHER_MAX_PHONEMEB = (29); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_DEFAULT_PHONEMEB")] + [NativeName(NativeNameType.Value, "(10)")] + public const int AL_VOCAL_MORPHER_DEFAULT_PHONEMEB = (10); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "(-24)")] + public const int AL_VOCAL_MORPHER_MIN_PHONEMEB_COARSE_TUNING = (-24); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "(24)")] + public const int AL_VOCAL_MORPHER_MAX_PHONEMEB_COARSE_TUNING = (24); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_DEFAULT_PHONEMEB_COARSE_TUNING = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_A")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_PHONEME_A = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_E")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_VOCAL_MORPHER_PHONEME_E = (1); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_I")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_VOCAL_MORPHER_PHONEME_I = (2); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_O")] + [NativeName(NativeNameType.Value, "(3)")] + public const int AL_VOCAL_MORPHER_PHONEME_O = (3); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_U")] + [NativeName(NativeNameType.Value, "(4)")] + public const int AL_VOCAL_MORPHER_PHONEME_U = (4); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_AA")] + [NativeName(NativeNameType.Value, "(5)")] + public const int AL_VOCAL_MORPHER_PHONEME_AA = (5); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_AE")] + [NativeName(NativeNameType.Value, "(6)")] + public const int AL_VOCAL_MORPHER_PHONEME_AE = (6); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_AH")] + [NativeName(NativeNameType.Value, "(7)")] + public const int AL_VOCAL_MORPHER_PHONEME_AH = (7); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_AO")] + [NativeName(NativeNameType.Value, "(8)")] + public const int AL_VOCAL_MORPHER_PHONEME_AO = (8); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_EH")] + [NativeName(NativeNameType.Value, "(9)")] + public const int AL_VOCAL_MORPHER_PHONEME_EH = (9); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_ER")] + [NativeName(NativeNameType.Value, "(10)")] + public const int AL_VOCAL_MORPHER_PHONEME_ER = (10); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_IH")] + [NativeName(NativeNameType.Value, "(11)")] + public const int AL_VOCAL_MORPHER_PHONEME_IH = (11); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_IY")] + [NativeName(NativeNameType.Value, "(12)")] + public const int AL_VOCAL_MORPHER_PHONEME_IY = (12); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_UH")] + [NativeName(NativeNameType.Value, "(13)")] + public const int AL_VOCAL_MORPHER_PHONEME_UH = (13); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_UW")] + [NativeName(NativeNameType.Value, "(14)")] + public const int AL_VOCAL_MORPHER_PHONEME_UW = (14); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_B")] + [NativeName(NativeNameType.Value, "(15)")] + public const int AL_VOCAL_MORPHER_PHONEME_B = (15); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_D")] + [NativeName(NativeNameType.Value, "(16)")] + public const int AL_VOCAL_MORPHER_PHONEME_D = (16); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_F")] + [NativeName(NativeNameType.Value, "(17)")] + public const int AL_VOCAL_MORPHER_PHONEME_F = (17); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_G")] + [NativeName(NativeNameType.Value, "(18)")] + public const int AL_VOCAL_MORPHER_PHONEME_G = (18); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_J")] + [NativeName(NativeNameType.Value, "(19)")] + public const int AL_VOCAL_MORPHER_PHONEME_J = (19); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_K")] + [NativeName(NativeNameType.Value, "(20)")] + public const int AL_VOCAL_MORPHER_PHONEME_K = (20); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_L")] + [NativeName(NativeNameType.Value, "(21)")] + public const int AL_VOCAL_MORPHER_PHONEME_L = (21); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_M")] + [NativeName(NativeNameType.Value, "(22)")] + public const int AL_VOCAL_MORPHER_PHONEME_M = (22); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_N")] + [NativeName(NativeNameType.Value, "(23)")] + public const int AL_VOCAL_MORPHER_PHONEME_N = (23); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_P")] + [NativeName(NativeNameType.Value, "(24)")] + public const int AL_VOCAL_MORPHER_PHONEME_P = (24); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_R")] + [NativeName(NativeNameType.Value, "(25)")] + public const int AL_VOCAL_MORPHER_PHONEME_R = (25); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_S")] + [NativeName(NativeNameType.Value, "(26)")] + public const int AL_VOCAL_MORPHER_PHONEME_S = (26); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_T")] + [NativeName(NativeNameType.Value, "(27)")] + public const int AL_VOCAL_MORPHER_PHONEME_T = (27); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_V")] + [NativeName(NativeNameType.Value, "(28)")] + public const int AL_VOCAL_MORPHER_PHONEME_V = (28); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_PHONEME_Z")] + [NativeName(NativeNameType.Value, "(29)")] + public const int AL_VOCAL_MORPHER_PHONEME_Z = (29); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_WAVEFORM_SINUSOID")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_WAVEFORM_SINUSOID = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE = (1); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH = (2); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MIN_WAVEFORM")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_MIN_WAVEFORM = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MAX_WAVEFORM")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_VOCAL_MORPHER_MAX_WAVEFORM = (2); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_DEFAULT_WAVEFORM")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_VOCAL_MORPHER_DEFAULT_WAVEFORM = (0); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MIN_RATE")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_VOCAL_MORPHER_MIN_RATE = (0.0f); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_MAX_RATE")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_VOCAL_MORPHER_MAX_RATE = (10.0f); + + [NativeName(NativeNameType.Const, "AL_VOCAL_MORPHER_DEFAULT_RATE")] + [NativeName(NativeNameType.Value, "(1.41f)")] + public const float AL_VOCAL_MORPHER_DEFAULT_RATE = (1.41f); + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_MIN_COARSE_TUNE")] + [NativeName(NativeNameType.Value, "(-12)")] + public const int AL_PITCH_SHIFTER_MIN_COARSE_TUNE = (-12); + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_MAX_COARSE_TUNE")] + [NativeName(NativeNameType.Value, "(12)")] + public const int AL_PITCH_SHIFTER_MAX_COARSE_TUNE = (12); + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE")] + [NativeName(NativeNameType.Value, "(12)")] + public const int AL_PITCH_SHIFTER_DEFAULT_COARSE_TUNE = (12); + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_MIN_FINE_TUNE")] + [NativeName(NativeNameType.Value, "(-50)")] + public const int AL_PITCH_SHIFTER_MIN_FINE_TUNE = (-50); + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_MAX_FINE_TUNE")] + [NativeName(NativeNameType.Value, "(50)")] + public const int AL_PITCH_SHIFTER_MAX_FINE_TUNE = (50); + + [NativeName(NativeNameType.Const, "AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_PITCH_SHIFTER_DEFAULT_FINE_TUNE = (0); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_MIN_FREQUENCY")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_RING_MODULATOR_MIN_FREQUENCY = (0.0f); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_MAX_FREQUENCY")] + [NativeName(NativeNameType.Value, "(8000.0f)")] + public const float AL_RING_MODULATOR_MAX_FREQUENCY = (8000.0f); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_DEFAULT_FREQUENCY")] + [NativeName(NativeNameType.Value, "(440.0f)")] + public const float AL_RING_MODULATOR_DEFAULT_FREQUENCY = (440.0f); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_RING_MODULATOR_MIN_HIGHPASS_CUTOFF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "(24000.0f)")] + public const float AL_RING_MODULATOR_MAX_HIGHPASS_CUTOFF = (24000.0f); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF")] + [NativeName(NativeNameType.Value, "(800.0f)")] + public const float AL_RING_MODULATOR_DEFAULT_HIGHPASS_CUTOFF = (800.0f); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_SINUSOID")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_RING_MODULATOR_SINUSOID = (0); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_SAWTOOTH")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_RING_MODULATOR_SAWTOOTH = (1); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_SQUARE")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_RING_MODULATOR_SQUARE = (2); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_MIN_WAVEFORM")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_RING_MODULATOR_MIN_WAVEFORM = (0); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_MAX_WAVEFORM")] + [NativeName(NativeNameType.Value, "(2)")] + public const int AL_RING_MODULATOR_MAX_WAVEFORM = (2); + + [NativeName(NativeNameType.Const, "AL_RING_MODULATOR_DEFAULT_WAVEFORM")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_RING_MODULATOR_DEFAULT_WAVEFORM = (0); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MIN_ATTACK_TIME")] + [NativeName(NativeNameType.Value, "(0.0001f)")] + public const float AL_AUTOWAH_MIN_ATTACK_TIME = (0.0001f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MAX_ATTACK_TIME")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_AUTOWAH_MAX_ATTACK_TIME = (1.0f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_DEFAULT_ATTACK_TIME")] + [NativeName(NativeNameType.Value, "(0.06f)")] + public const float AL_AUTOWAH_DEFAULT_ATTACK_TIME = (0.06f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MIN_RELEASE_TIME")] + [NativeName(NativeNameType.Value, "(0.0001f)")] + public const float AL_AUTOWAH_MIN_RELEASE_TIME = (0.0001f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MAX_RELEASE_TIME")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_AUTOWAH_MAX_RELEASE_TIME = (1.0f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_DEFAULT_RELEASE_TIME")] + [NativeName(NativeNameType.Value, "(0.06f)")] + public const float AL_AUTOWAH_DEFAULT_RELEASE_TIME = (0.06f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MIN_RESONANCE")] + [NativeName(NativeNameType.Value, "(2.0f)")] + public const float AL_AUTOWAH_MIN_RESONANCE = (2.0f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MAX_RESONANCE")] + [NativeName(NativeNameType.Value, "(1000.0f)")] + public const float AL_AUTOWAH_MAX_RESONANCE = (1000.0f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_DEFAULT_RESONANCE")] + [NativeName(NativeNameType.Value, "(1000.0f)")] + public const float AL_AUTOWAH_DEFAULT_RESONANCE = (1000.0f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MIN_PEAK_GAIN")] + [NativeName(NativeNameType.Value, "(0.00003f)")] + public const float AL_AUTOWAH_MIN_PEAK_GAIN = (0.00003f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_MAX_PEAK_GAIN")] + [NativeName(NativeNameType.Value, "(31621.0f)")] + public const float AL_AUTOWAH_MAX_PEAK_GAIN = (31621.0f); + + [NativeName(NativeNameType.Const, "AL_AUTOWAH_DEFAULT_PEAK_GAIN")] + [NativeName(NativeNameType.Value, "(11.22f)")] + public const float AL_AUTOWAH_DEFAULT_PEAK_GAIN = (11.22f); + + [NativeName(NativeNameType.Const, "AL_COMPRESSOR_MIN_ONOFF")] + [NativeName(NativeNameType.Value, "(0)")] + public const int AL_COMPRESSOR_MIN_ONOFF = (0); + + [NativeName(NativeNameType.Const, "AL_COMPRESSOR_MAX_ONOFF")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_COMPRESSOR_MAX_ONOFF = (1); + + [NativeName(NativeNameType.Const, "AL_COMPRESSOR_DEFAULT_ONOFF")] + [NativeName(NativeNameType.Value, "(1)")] + public const int AL_COMPRESSOR_DEFAULT_ONOFF = (1); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_LOW_GAIN")] + [NativeName(NativeNameType.Value, "(0.126f)")] + public const float AL_EQUALIZER_MIN_LOW_GAIN = (0.126f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_LOW_GAIN")] + [NativeName(NativeNameType.Value, "(7.943f)")] + public const float AL_EQUALIZER_MAX_LOW_GAIN = (7.943f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_LOW_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_DEFAULT_LOW_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_LOW_CUTOFF")] + [NativeName(NativeNameType.Value, "(50.0f)")] + public const float AL_EQUALIZER_MIN_LOW_CUTOFF = (50.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_LOW_CUTOFF")] + [NativeName(NativeNameType.Value, "(800.0f)")] + public const float AL_EQUALIZER_MAX_LOW_CUTOFF = (800.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_LOW_CUTOFF")] + [NativeName(NativeNameType.Value, "(200.0f)")] + public const float AL_EQUALIZER_DEFAULT_LOW_CUTOFF = (200.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_MID1_GAIN")] + [NativeName(NativeNameType.Value, "(0.126f)")] + public const float AL_EQUALIZER_MIN_MID1_GAIN = (0.126f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_MID1_GAIN")] + [NativeName(NativeNameType.Value, "(7.943f)")] + public const float AL_EQUALIZER_MAX_MID1_GAIN = (7.943f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_MID1_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_DEFAULT_MID1_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_MID1_CENTER")] + [NativeName(NativeNameType.Value, "(200.0f)")] + public const float AL_EQUALIZER_MIN_MID1_CENTER = (200.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_MID1_CENTER")] + [NativeName(NativeNameType.Value, "(3000.0f)")] + public const float AL_EQUALIZER_MAX_MID1_CENTER = (3000.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_MID1_CENTER")] + [NativeName(NativeNameType.Value, "(500.0f)")] + public const float AL_EQUALIZER_DEFAULT_MID1_CENTER = (500.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_MID1_WIDTH")] + [NativeName(NativeNameType.Value, "(0.01f)")] + public const float AL_EQUALIZER_MIN_MID1_WIDTH = (0.01f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_MID1_WIDTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_MAX_MID1_WIDTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_MID1_WIDTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_DEFAULT_MID1_WIDTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_MID2_GAIN")] + [NativeName(NativeNameType.Value, "(0.126f)")] + public const float AL_EQUALIZER_MIN_MID2_GAIN = (0.126f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_MID2_GAIN")] + [NativeName(NativeNameType.Value, "(7.943f)")] + public const float AL_EQUALIZER_MAX_MID2_GAIN = (7.943f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_MID2_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_DEFAULT_MID2_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_MID2_CENTER")] + [NativeName(NativeNameType.Value, "(1000.0f)")] + public const float AL_EQUALIZER_MIN_MID2_CENTER = (1000.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_MID2_CENTER")] + [NativeName(NativeNameType.Value, "(8000.0f)")] + public const float AL_EQUALIZER_MAX_MID2_CENTER = (8000.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_MID2_CENTER")] + [NativeName(NativeNameType.Value, "(3000.0f)")] + public const float AL_EQUALIZER_DEFAULT_MID2_CENTER = (3000.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_MID2_WIDTH")] + [NativeName(NativeNameType.Value, "(0.01f)")] + public const float AL_EQUALIZER_MIN_MID2_WIDTH = (0.01f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_MID2_WIDTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_MAX_MID2_WIDTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_MID2_WIDTH")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_DEFAULT_MID2_WIDTH = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_HIGH_GAIN")] + [NativeName(NativeNameType.Value, "(0.126f)")] + public const float AL_EQUALIZER_MIN_HIGH_GAIN = (0.126f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_HIGH_GAIN")] + [NativeName(NativeNameType.Value, "(7.943f)")] + public const float AL_EQUALIZER_MAX_HIGH_GAIN = (7.943f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_HIGH_GAIN")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_EQUALIZER_DEFAULT_HIGH_GAIN = (1.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MIN_HIGH_CUTOFF")] + [NativeName(NativeNameType.Value, "(4000.0f)")] + public const float AL_EQUALIZER_MIN_HIGH_CUTOFF = (4000.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_MAX_HIGH_CUTOFF")] + [NativeName(NativeNameType.Value, "(16000.0f)")] + public const float AL_EQUALIZER_MAX_HIGH_CUTOFF = (16000.0f); + + [NativeName(NativeNameType.Const, "AL_EQUALIZER_DEFAULT_HIGH_CUTOFF")] + [NativeName(NativeNameType.Value, "(6000.0f)")] + public const float AL_EQUALIZER_DEFAULT_HIGH_CUTOFF = (6000.0f); + + [NativeName(NativeNameType.Const, "AL_MIN_AIR_ABSORPTION_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_MIN_AIR_ABSORPTION_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_MAX_AIR_ABSORPTION_FACTOR")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_MAX_AIR_ABSORPTION_FACTOR = (10.0f); + + [NativeName(NativeNameType.Const, "AL_DEFAULT_AIR_ABSORPTION_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_DEFAULT_AIR_ABSORPTION_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_MIN_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_MIN_ROOM_ROLLOFF_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_MAX_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(10.0f)")] + public const float AL_MAX_ROOM_ROLLOFF_FACTOR = (10.0f); + + [NativeName(NativeNameType.Const, "AL_DEFAULT_ROOM_ROLLOFF_FACTOR")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_DEFAULT_ROOM_ROLLOFF_FACTOR = (0.0f); + + [NativeName(NativeNameType.Const, "AL_MIN_CONE_OUTER_GAINHF")] + [NativeName(NativeNameType.Value, "(0.0f)")] + public const float AL_MIN_CONE_OUTER_GAINHF = (0.0f); + + [NativeName(NativeNameType.Const, "AL_MAX_CONE_OUTER_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_MAX_CONE_OUTER_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_DEFAULT_CONE_OUTER_GAINHF")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_DEFAULT_CONE_OUTER_GAINHF = (1.0f); + + [NativeName(NativeNameType.Const, "AL_DEFAULT_METERS_PER_UNIT")] + [NativeName(NativeNameType.Value, "(1.0f)")] + public const float AL_DEFAULT_METERS_PER_UNIT = (1.0f); + + [NativeName(NativeNameType.Const, "ALC_EXT_disconnect")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_EXT_disconnect = 1; + + [NativeName(NativeNameType.Const, "ALC_CONNECTED")] + [NativeName(NativeNameType.Value, "0x313")] + public const int ALC_CONNECTED = 0x313; + + [NativeName(NativeNameType.Const, "ALC_EXT_thread_local_context")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_EXT_thread_local_context = 1; + + [NativeName(NativeNameType.Const, "AL_EXT_source_distance_model")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_source_distance_model = 1; + + [NativeName(NativeNameType.Const, "AL_SOURCE_DISTANCE_MODEL")] + [NativeName(NativeNameType.Value, "0x200")] + public const int AL_SOURCE_DISTANCE_MODEL = 0x200; + + [NativeName(NativeNameType.Const, "AL_SOFT_buffer_sub_data")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_buffer_sub_data = 1; + + [NativeName(NativeNameType.Const, "AL_BYTE_RW_OFFSETS_SOFT")] + [NativeName(NativeNameType.Value, "0x1031")] + public const int AL_BYTE_RW_OFFSETS_SOFT = 0x1031; + + [NativeName(NativeNameType.Const, "AL_SAMPLE_RW_OFFSETS_SOFT")] + [NativeName(NativeNameType.Value, "0x1032")] + public const int AL_SAMPLE_RW_OFFSETS_SOFT = 0x1032; + + [NativeName(NativeNameType.Const, "AL_SOFT_loop_points")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_loop_points = 1; + + [NativeName(NativeNameType.Const, "AL_LOOP_POINTS_SOFT")] + [NativeName(NativeNameType.Value, "0x2015")] + public const int AL_LOOP_POINTS_SOFT = 0x2015; + + [NativeName(NativeNameType.Const, "AL_EXT_FOLDBACK")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_FOLDBACK = 1; + + [NativeName(NativeNameType.Const, "AL_EXT_FOLDBACK_NAME")] + [NativeName(NativeNameType.Value, "\"AL_EXT_FOLDBACK\"")] + public const string AL_EXT_FOLDBACK_NAME = "AL_EXT_FOLDBACK"; + + [NativeName(NativeNameType.Const, "AL_FOLDBACK_EVENT_BLOCK")] + [NativeName(NativeNameType.Value, "0x4112")] + public const int AL_FOLDBACK_EVENT_BLOCK = 0x4112; + + [NativeName(NativeNameType.Const, "AL_FOLDBACK_EVENT_START")] + [NativeName(NativeNameType.Value, "0x4111")] + public const int AL_FOLDBACK_EVENT_START = 0x4111; + + [NativeName(NativeNameType.Const, "AL_FOLDBACK_EVENT_STOP")] + [NativeName(NativeNameType.Value, "0x4113")] + public const int AL_FOLDBACK_EVENT_STOP = 0x4113; + + [NativeName(NativeNameType.Const, "AL_FOLDBACK_MODE_MONO")] + [NativeName(NativeNameType.Value, "0x4101")] + public const int AL_FOLDBACK_MODE_MONO = 0x4101; + + [NativeName(NativeNameType.Const, "AL_FOLDBACK_MODE_STEREO")] + [NativeName(NativeNameType.Value, "0x4102")] + public const int AL_FOLDBACK_MODE_STEREO = 0x4102; + + [NativeName(NativeNameType.Const, "ALC_EXT_DEDICATED")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_EXT_DEDICATED = 1; + + [NativeName(NativeNameType.Const, "AL_DEDICATED_GAIN")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_DEDICATED_GAIN = 0x0001; + + [NativeName(NativeNameType.Const, "AL_EFFECT_DEDICATED_DIALOGUE")] + [NativeName(NativeNameType.Value, "0x9001")] + public const int AL_EFFECT_DEDICATED_DIALOGUE = 0x9001; + + [NativeName(NativeNameType.Const, "AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT")] + [NativeName(NativeNameType.Value, "0x9000")] + public const int AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT = 0x9000; + + [NativeName(NativeNameType.Const, "AL_SOFT_buffer_samples")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_buffer_samples = 1; + + [NativeName(NativeNameType.Const, "AL_MONO_SOFT")] + [NativeName(NativeNameType.Value, "0x1500")] + public const int AL_MONO_SOFT = 0x1500; + + [NativeName(NativeNameType.Const, "AL_STEREO_SOFT")] + [NativeName(NativeNameType.Value, "0x1501")] + public const int AL_STEREO_SOFT = 0x1501; + + [NativeName(NativeNameType.Const, "AL_REAR_SOFT")] + [NativeName(NativeNameType.Value, "0x1502")] + public const int AL_REAR_SOFT = 0x1502; + + [NativeName(NativeNameType.Const, "AL_QUAD_SOFT")] + [NativeName(NativeNameType.Value, "0x1503")] + public const int AL_QUAD_SOFT = 0x1503; + + [NativeName(NativeNameType.Const, "AL_5POINT1_SOFT")] + [NativeName(NativeNameType.Value, "0x1504")] + public const int AL_5POINT1_SOFT = 0x1504; + + [NativeName(NativeNameType.Const, "AL_6POINT1_SOFT")] + [NativeName(NativeNameType.Value, "0x1505")] + public const int AL_6POINT1_SOFT = 0x1505; + + [NativeName(NativeNameType.Const, "AL_7POINT1_SOFT")] + [NativeName(NativeNameType.Value, "0x1506")] + public const int AL_7POINT1_SOFT = 0x1506; + + [NativeName(NativeNameType.Const, "AL_BYTE_SOFT")] + [NativeName(NativeNameType.Value, "0x1400")] + public const int AL_BYTE_SOFT = 0x1400; + + [NativeName(NativeNameType.Const, "AL_UNSIGNED_BYTE_SOFT")] + [NativeName(NativeNameType.Value, "0x1401")] + public const int AL_UNSIGNED_BYTE_SOFT = 0x1401; + + [NativeName(NativeNameType.Const, "AL_SHORT_SOFT")] + [NativeName(NativeNameType.Value, "0x1402")] + public const int AL_SHORT_SOFT = 0x1402; + + [NativeName(NativeNameType.Const, "AL_UNSIGNED_SHORT_SOFT")] + [NativeName(NativeNameType.Value, "0x1403")] + public const int AL_UNSIGNED_SHORT_SOFT = 0x1403; + + [NativeName(NativeNameType.Const, "AL_INT_SOFT")] + [NativeName(NativeNameType.Value, "0x1404")] + public const int AL_INT_SOFT = 0x1404; + + [NativeName(NativeNameType.Const, "AL_UNSIGNED_INT_SOFT")] + [NativeName(NativeNameType.Value, "0x1405")] + public const int AL_UNSIGNED_INT_SOFT = 0x1405; + + [NativeName(NativeNameType.Const, "AL_FLOAT_SOFT")] + [NativeName(NativeNameType.Value, "0x1406")] + public const int AL_FLOAT_SOFT = 0x1406; + + [NativeName(NativeNameType.Const, "AL_DOUBLE_SOFT")] + [NativeName(NativeNameType.Value, "0x1407")] + public const int AL_DOUBLE_SOFT = 0x1407; + + [NativeName(NativeNameType.Const, "AL_BYTE3_SOFT")] + [NativeName(NativeNameType.Value, "0x1408")] + public const int AL_BYTE3_SOFT = 0x1408; + + [NativeName(NativeNameType.Const, "AL_UNSIGNED_BYTE3_SOFT")] + [NativeName(NativeNameType.Value, "0x1409")] + public const int AL_UNSIGNED_BYTE3_SOFT = 0x1409; + + [NativeName(NativeNameType.Const, "AL_MONO8_SOFT")] + [NativeName(NativeNameType.Value, "0x1100")] + public const int AL_MONO8_SOFT = 0x1100; + + [NativeName(NativeNameType.Const, "AL_MONO16_SOFT")] + [NativeName(NativeNameType.Value, "0x1101")] + public const int AL_MONO16_SOFT = 0x1101; + + [NativeName(NativeNameType.Const, "AL_MONO32F_SOFT")] + [NativeName(NativeNameType.Value, "0x10010")] + public const int AL_MONO32F_SOFT = 0x10010; + + [NativeName(NativeNameType.Const, "AL_STEREO8_SOFT")] + [NativeName(NativeNameType.Value, "0x1102")] + public const int AL_STEREO8_SOFT = 0x1102; + + [NativeName(NativeNameType.Const, "AL_STEREO16_SOFT")] + [NativeName(NativeNameType.Value, "0x1103")] + public const int AL_STEREO16_SOFT = 0x1103; + + [NativeName(NativeNameType.Const, "AL_STEREO32F_SOFT")] + [NativeName(NativeNameType.Value, "0x10011")] + public const int AL_STEREO32F_SOFT = 0x10011; + + [NativeName(NativeNameType.Const, "AL_QUAD8_SOFT")] + [NativeName(NativeNameType.Value, "0x1204")] + public const int AL_QUAD8_SOFT = 0x1204; + + [NativeName(NativeNameType.Const, "AL_QUAD16_SOFT")] + [NativeName(NativeNameType.Value, "0x1205")] + public const int AL_QUAD16_SOFT = 0x1205; + + [NativeName(NativeNameType.Const, "AL_QUAD32F_SOFT")] + [NativeName(NativeNameType.Value, "0x1206")] + public const int AL_QUAD32F_SOFT = 0x1206; + + [NativeName(NativeNameType.Const, "AL_REAR8_SOFT")] + [NativeName(NativeNameType.Value, "0x1207")] + public const int AL_REAR8_SOFT = 0x1207; + + [NativeName(NativeNameType.Const, "AL_REAR16_SOFT")] + [NativeName(NativeNameType.Value, "0x1208")] + public const int AL_REAR16_SOFT = 0x1208; + + [NativeName(NativeNameType.Const, "AL_REAR32F_SOFT")] + [NativeName(NativeNameType.Value, "0x1209")] + public const int AL_REAR32F_SOFT = 0x1209; + + [NativeName(NativeNameType.Const, "AL_5POINT1_8_SOFT")] + [NativeName(NativeNameType.Value, "0x120A")] + public const int AL_5POINT1_8_SOFT = 0x120A; + + [NativeName(NativeNameType.Const, "AL_5POINT1_16_SOFT")] + [NativeName(NativeNameType.Value, "0x120B")] + public const int AL_5POINT1_16_SOFT = 0x120B; + + [NativeName(NativeNameType.Const, "AL_5POINT1_32F_SOFT")] + [NativeName(NativeNameType.Value, "0x120C")] + public const int AL_5POINT1_32F_SOFT = 0x120C; + + [NativeName(NativeNameType.Const, "AL_6POINT1_8_SOFT")] + [NativeName(NativeNameType.Value, "0x120D")] + public const int AL_6POINT1_8_SOFT = 0x120D; + + [NativeName(NativeNameType.Const, "AL_6POINT1_16_SOFT")] + [NativeName(NativeNameType.Value, "0x120E")] + public const int AL_6POINT1_16_SOFT = 0x120E; + + [NativeName(NativeNameType.Const, "AL_6POINT1_32F_SOFT")] + [NativeName(NativeNameType.Value, "0x120F")] + public const int AL_6POINT1_32F_SOFT = 0x120F; + + [NativeName(NativeNameType.Const, "AL_7POINT1_8_SOFT")] + [NativeName(NativeNameType.Value, "0x1210")] + public const int AL_7POINT1_8_SOFT = 0x1210; + + [NativeName(NativeNameType.Const, "AL_7POINT1_16_SOFT")] + [NativeName(NativeNameType.Value, "0x1211")] + public const int AL_7POINT1_16_SOFT = 0x1211; + + [NativeName(NativeNameType.Const, "AL_7POINT1_32F_SOFT")] + [NativeName(NativeNameType.Value, "0x1212")] + public const int AL_7POINT1_32F_SOFT = 0x1212; + + [NativeName(NativeNameType.Const, "AL_INTERNAL_FORMAT_SOFT")] + [NativeName(NativeNameType.Value, "0x2008")] + public const int AL_INTERNAL_FORMAT_SOFT = 0x2008; + + [NativeName(NativeNameType.Const, "AL_BYTE_LENGTH_SOFT")] + [NativeName(NativeNameType.Value, "0x2009")] + public const int AL_BYTE_LENGTH_SOFT = 0x2009; + + [NativeName(NativeNameType.Const, "AL_SAMPLE_LENGTH_SOFT")] + [NativeName(NativeNameType.Value, "0x200A")] + public const int AL_SAMPLE_LENGTH_SOFT = 0x200A; + + [NativeName(NativeNameType.Const, "AL_SEC_LENGTH_SOFT")] + [NativeName(NativeNameType.Value, "0x200B")] + public const int AL_SEC_LENGTH_SOFT = 0x200B; + + [NativeName(NativeNameType.Const, "AL_SOFT_direct_channels")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_direct_channels = 1; + + [NativeName(NativeNameType.Const, "AL_DIRECT_CHANNELS_SOFT")] + [NativeName(NativeNameType.Value, "0x1033")] + public const int AL_DIRECT_CHANNELS_SOFT = 0x1033; + + [NativeName(NativeNameType.Const, "ALC_SOFT_loopback")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_SOFT_loopback = 1; + + [NativeName(NativeNameType.Const, "ALC_FORMAT_CHANNELS_SOFT")] + [NativeName(NativeNameType.Value, "0x1990")] + public const int ALC_FORMAT_CHANNELS_SOFT = 0x1990; + + [NativeName(NativeNameType.Const, "ALC_FORMAT_TYPE_SOFT")] + [NativeName(NativeNameType.Value, "0x1991")] + public const int ALC_FORMAT_TYPE_SOFT = 0x1991; + + [NativeName(NativeNameType.Const, "ALC_BYTE_SOFT")] + [NativeName(NativeNameType.Value, "0x1400")] + public const int ALC_BYTE_SOFT = 0x1400; + + [NativeName(NativeNameType.Const, "ALC_UNSIGNED_BYTE_SOFT")] + [NativeName(NativeNameType.Value, "0x1401")] + public const int ALC_UNSIGNED_BYTE_SOFT = 0x1401; + + [NativeName(NativeNameType.Const, "ALC_SHORT_SOFT")] + [NativeName(NativeNameType.Value, "0x1402")] + public const int ALC_SHORT_SOFT = 0x1402; + + [NativeName(NativeNameType.Const, "ALC_UNSIGNED_SHORT_SOFT")] + [NativeName(NativeNameType.Value, "0x1403")] + public const int ALC_UNSIGNED_SHORT_SOFT = 0x1403; + + [NativeName(NativeNameType.Const, "ALC_INT_SOFT")] + [NativeName(NativeNameType.Value, "0x1404")] + public const int ALC_INT_SOFT = 0x1404; + + [NativeName(NativeNameType.Const, "ALC_UNSIGNED_INT_SOFT")] + [NativeName(NativeNameType.Value, "0x1405")] + public const int ALC_UNSIGNED_INT_SOFT = 0x1405; + + [NativeName(NativeNameType.Const, "ALC_FLOAT_SOFT")] + [NativeName(NativeNameType.Value, "0x1406")] + public const int ALC_FLOAT_SOFT = 0x1406; + + [NativeName(NativeNameType.Const, "ALC_MONO_SOFT")] + [NativeName(NativeNameType.Value, "0x1500")] + public const int ALC_MONO_SOFT = 0x1500; + + [NativeName(NativeNameType.Const, "ALC_STEREO_SOFT")] + [NativeName(NativeNameType.Value, "0x1501")] + public const int ALC_STEREO_SOFT = 0x1501; + + [NativeName(NativeNameType.Const, "ALC_QUAD_SOFT")] + [NativeName(NativeNameType.Value, "0x1503")] + public const int ALC_QUAD_SOFT = 0x1503; + + [NativeName(NativeNameType.Const, "ALC_5POINT1_SOFT")] + [NativeName(NativeNameType.Value, "0x1504")] + public const int ALC_5POINT1_SOFT = 0x1504; + + [NativeName(NativeNameType.Const, "ALC_6POINT1_SOFT")] + [NativeName(NativeNameType.Value, "0x1505")] + public const int ALC_6POINT1_SOFT = 0x1505; + + [NativeName(NativeNameType.Const, "ALC_7POINT1_SOFT")] + [NativeName(NativeNameType.Value, "0x1506")] + public const int ALC_7POINT1_SOFT = 0x1506; + + [NativeName(NativeNameType.Const, "AL_EXT_STEREO_ANGLES")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_STEREO_ANGLES = 1; + + [NativeName(NativeNameType.Const, "AL_STEREO_ANGLES")] + [NativeName(NativeNameType.Value, "0x1030")] + public const int AL_STEREO_ANGLES = 0x1030; + + [NativeName(NativeNameType.Const, "AL_EXT_SOURCE_RADIUS")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_SOURCE_RADIUS = 1; + + [NativeName(NativeNameType.Const, "AL_SOURCE_RADIUS")] + [NativeName(NativeNameType.Value, "0x1031")] + public const int AL_SOURCE_RADIUS = 0x1031; + + [NativeName(NativeNameType.Const, "AL_SOFT_source_latency")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_source_latency = 1; + + [NativeName(NativeNameType.Const, "AL_SAMPLE_OFFSET_LATENCY_SOFT")] + [NativeName(NativeNameType.Value, "0x1200")] + public const int AL_SAMPLE_OFFSET_LATENCY_SOFT = 0x1200; + + [NativeName(NativeNameType.Const, "AL_SEC_OFFSET_LATENCY_SOFT")] + [NativeName(NativeNameType.Value, "0x1201")] + public const int AL_SEC_OFFSET_LATENCY_SOFT = 0x1201; + + [NativeName(NativeNameType.Const, "ALC_EXT_DEFAULT_FILTER_ORDER")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_EXT_DEFAULT_FILTER_ORDER = 1; + + [NativeName(NativeNameType.Const, "ALC_DEFAULT_FILTER_ORDER")] + [NativeName(NativeNameType.Value, "0x1100")] + public const int ALC_DEFAULT_FILTER_ORDER = 0x1100; + + [NativeName(NativeNameType.Const, "AL_SOFT_deferred_updates")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_deferred_updates = 1; + + [NativeName(NativeNameType.Const, "AL_DEFERRED_UPDATES_SOFT")] + [NativeName(NativeNameType.Value, "0xC002")] + public const int AL_DEFERRED_UPDATES_SOFT = 0xC002; + + [NativeName(NativeNameType.Const, "AL_SOFT_block_alignment")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_block_alignment = 1; + + [NativeName(NativeNameType.Const, "AL_UNPACK_BLOCK_ALIGNMENT_SOFT")] + [NativeName(NativeNameType.Value, "0x200C")] + public const int AL_UNPACK_BLOCK_ALIGNMENT_SOFT = 0x200C; + + [NativeName(NativeNameType.Const, "AL_PACK_BLOCK_ALIGNMENT_SOFT")] + [NativeName(NativeNameType.Value, "0x200D")] + public const int AL_PACK_BLOCK_ALIGNMENT_SOFT = 0x200D; + + [NativeName(NativeNameType.Const, "AL_SOFT_MSADPCM")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_MSADPCM = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_MONO_MSADPCM_SOFT")] + [NativeName(NativeNameType.Value, "0x1302")] + public const int AL_FORMAT_MONO_MSADPCM_SOFT = 0x1302; + + [NativeName(NativeNameType.Const, "AL_FORMAT_STEREO_MSADPCM_SOFT")] + [NativeName(NativeNameType.Value, "0x1303")] + public const int AL_FORMAT_STEREO_MSADPCM_SOFT = 0x1303; + + [NativeName(NativeNameType.Const, "AL_SOFT_source_length")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_source_length = 1; + + [NativeName(NativeNameType.Const, "AL_SOFT_buffer_length_query")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_buffer_length_query = 1; + + [NativeName(NativeNameType.Const, "ALC_SOFT_pause_device")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_SOFT_pause_device = 1; + + [NativeName(NativeNameType.Const, "AL_EXT_BFORMAT")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_BFORMAT = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT2D_8")] + [NativeName(NativeNameType.Value, "0x20021")] + public const int AL_FORMAT_BFORMAT2D_8 = 0x20021; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT2D_16")] + [NativeName(NativeNameType.Value, "0x20022")] + public const int AL_FORMAT_BFORMAT2D_16 = 0x20022; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT2D_FLOAT32")] + [NativeName(NativeNameType.Value, "0x20023")] + public const int AL_FORMAT_BFORMAT2D_FLOAT32 = 0x20023; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT3D_8")] + [NativeName(NativeNameType.Value, "0x20031")] + public const int AL_FORMAT_BFORMAT3D_8 = 0x20031; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT3D_16")] + [NativeName(NativeNameType.Value, "0x20032")] + public const int AL_FORMAT_BFORMAT3D_16 = 0x20032; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT3D_FLOAT32")] + [NativeName(NativeNameType.Value, "0x20033")] + public const int AL_FORMAT_BFORMAT3D_FLOAT32 = 0x20033; + + [NativeName(NativeNameType.Const, "AL_EXT_MULAW_BFORMAT")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_EXT_MULAW_BFORMAT = 1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT2D_MULAW")] + [NativeName(NativeNameType.Value, "0x10031")] + public const int AL_FORMAT_BFORMAT2D_MULAW = 0x10031; + + [NativeName(NativeNameType.Const, "AL_FORMAT_BFORMAT3D_MULAW")] + [NativeName(NativeNameType.Value, "0x10032")] + public const int AL_FORMAT_BFORMAT3D_MULAW = 0x10032; + + [NativeName(NativeNameType.Const, "ALC_SOFT_HRTF")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_SOFT_HRTF = 1; + + [NativeName(NativeNameType.Const, "ALC_HRTF_SOFT")] + [NativeName(NativeNameType.Value, "0x1992")] + public const int ALC_HRTF_SOFT = 0x1992; + + [NativeName(NativeNameType.Const, "ALC_DONT_CARE_SOFT")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int ALC_DONT_CARE_SOFT = 0x0002; + + [NativeName(NativeNameType.Const, "ALC_HRTF_STATUS_SOFT")] + [NativeName(NativeNameType.Value, "0x1993")] + public const int ALC_HRTF_STATUS_SOFT = 0x1993; + + [NativeName(NativeNameType.Const, "ALC_HRTF_DISABLED_SOFT")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int ALC_HRTF_DISABLED_SOFT = 0x0000; + + [NativeName(NativeNameType.Const, "ALC_HRTF_ENABLED_SOFT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int ALC_HRTF_ENABLED_SOFT = 0x0001; + + [NativeName(NativeNameType.Const, "ALC_HRTF_DENIED_SOFT")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int ALC_HRTF_DENIED_SOFT = 0x0002; + + [NativeName(NativeNameType.Const, "ALC_HRTF_REQUIRED_SOFT")] + [NativeName(NativeNameType.Value, "0x0003")] + public const int ALC_HRTF_REQUIRED_SOFT = 0x0003; + + [NativeName(NativeNameType.Const, "ALC_HRTF_HEADPHONES_DETECTED_SOFT")] + [NativeName(NativeNameType.Value, "0x0004")] + public const int ALC_HRTF_HEADPHONES_DETECTED_SOFT = 0x0004; + + [NativeName(NativeNameType.Const, "ALC_HRTF_UNSUPPORTED_FORMAT_SOFT")] + [NativeName(NativeNameType.Value, "0x0005")] + public const int ALC_HRTF_UNSUPPORTED_FORMAT_SOFT = 0x0005; + + [NativeName(NativeNameType.Const, "ALC_NUM_HRTF_SPECIFIERS_SOFT")] + [NativeName(NativeNameType.Value, "0x1994")] + public const int ALC_NUM_HRTF_SPECIFIERS_SOFT = 0x1994; + + [NativeName(NativeNameType.Const, "ALC_HRTF_SPECIFIER_SOFT")] + [NativeName(NativeNameType.Value, "0x1995")] + public const int ALC_HRTF_SPECIFIER_SOFT = 0x1995; + + [NativeName(NativeNameType.Const, "ALC_HRTF_ID_SOFT")] + [NativeName(NativeNameType.Value, "0x1996")] + public const int ALC_HRTF_ID_SOFT = 0x1996; + + [NativeName(NativeNameType.Const, "AL_SOFT_gain_clamp_ex")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_gain_clamp_ex = 1; + + [NativeName(NativeNameType.Const, "AL_GAIN_LIMIT_SOFT")] + [NativeName(NativeNameType.Value, "0x200E")] + public const int AL_GAIN_LIMIT_SOFT = 0x200E; + + [NativeName(NativeNameType.Const, "AL_NUM_RESAMPLERS_SOFT")] + [NativeName(NativeNameType.Value, "0x1210")] + public const int AL_NUM_RESAMPLERS_SOFT = 0x1210; + + [NativeName(NativeNameType.Const, "AL_DEFAULT_RESAMPLER_SOFT")] + [NativeName(NativeNameType.Value, "0x1211")] + public const int AL_DEFAULT_RESAMPLER_SOFT = 0x1211; + + [NativeName(NativeNameType.Const, "AL_SOURCE_RESAMPLER_SOFT")] + [NativeName(NativeNameType.Value, "0x1212")] + public const int AL_SOURCE_RESAMPLER_SOFT = 0x1212; + + [NativeName(NativeNameType.Const, "AL_RESAMPLER_NAME_SOFT")] + [NativeName(NativeNameType.Value, "0x1213")] + public const int AL_RESAMPLER_NAME_SOFT = 0x1213; + + [NativeName(NativeNameType.Const, "AL_SOURCE_SPATIALIZE_SOFT")] + [NativeName(NativeNameType.Value, "0x1214")] + public const int AL_SOURCE_SPATIALIZE_SOFT = 0x1214; + + [NativeName(NativeNameType.Const, "AL_AUTO_SOFT")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_AUTO_SOFT = 0x0002; + + [NativeName(NativeNameType.Const, "ALC_OUTPUT_LIMITER_SOFT")] + [NativeName(NativeNameType.Value, "0x199A")] + public const int ALC_OUTPUT_LIMITER_SOFT = 0x199A; + + [NativeName(NativeNameType.Const, "ALC_SOFT_device_clock")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_SOFT_device_clock = 1; + + [NativeName(NativeNameType.Const, "ALC_DEVICE_CLOCK_SOFT")] + [NativeName(NativeNameType.Value, "0x1600")] + public const int ALC_DEVICE_CLOCK_SOFT = 0x1600; + + [NativeName(NativeNameType.Const, "ALC_DEVICE_LATENCY_SOFT")] + [NativeName(NativeNameType.Value, "0x1601")] + public const int ALC_DEVICE_LATENCY_SOFT = 0x1601; + + [NativeName(NativeNameType.Const, "ALC_DEVICE_CLOCK_LATENCY_SOFT")] + [NativeName(NativeNameType.Value, "0x1602")] + public const int ALC_DEVICE_CLOCK_LATENCY_SOFT = 0x1602; + + [NativeName(NativeNameType.Const, "AL_SAMPLE_OFFSET_CLOCK_SOFT")] + [NativeName(NativeNameType.Value, "0x1202")] + public const int AL_SAMPLE_OFFSET_CLOCK_SOFT = 0x1202; + + [NativeName(NativeNameType.Const, "AL_SEC_OFFSET_CLOCK_SOFT")] + [NativeName(NativeNameType.Value, "0x1203")] + public const int AL_SEC_OFFSET_CLOCK_SOFT = 0x1203; + + [NativeName(NativeNameType.Const, "AL_SOFT_direct_channels_remix")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_direct_channels_remix = 1; + + [NativeName(NativeNameType.Const, "AL_DROP_UNMATCHED_SOFT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_DROP_UNMATCHED_SOFT = 0x0001; + + [NativeName(NativeNameType.Const, "AL_REMIX_UNMATCHED_SOFT")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_REMIX_UNMATCHED_SOFT = 0x0002; + + [NativeName(NativeNameType.Const, "AL_SOFT_bformat_ex")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_bformat_ex = 1; + + [NativeName(NativeNameType.Const, "AL_AMBISONIC_LAYOUT_SOFT")] + [NativeName(NativeNameType.Value, "0x1997")] + public const int AL_AMBISONIC_LAYOUT_SOFT = 0x1997; + + [NativeName(NativeNameType.Const, "AL_AMBISONIC_SCALING_SOFT")] + [NativeName(NativeNameType.Value, "0x1998")] + public const int AL_AMBISONIC_SCALING_SOFT = 0x1998; + + [NativeName(NativeNameType.Const, "AL_FUMA_SOFT")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int AL_FUMA_SOFT = 0x0000; + + [NativeName(NativeNameType.Const, "AL_ACN_SOFT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_ACN_SOFT = 0x0001; + + [NativeName(NativeNameType.Const, "AL_SN3D_SOFT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_SN3D_SOFT = 0x0001; + + [NativeName(NativeNameType.Const, "AL_N3D_SOFT")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int AL_N3D_SOFT = 0x0002; + + [NativeName(NativeNameType.Const, "ALC_SOFT_loopback_bformat")] + [NativeName(NativeNameType.Value, "1")] + public const int ALC_SOFT_loopback_bformat = 1; + + [NativeName(NativeNameType.Const, "ALC_AMBISONIC_LAYOUT_SOFT")] + [NativeName(NativeNameType.Value, "0x1997")] + public const int ALC_AMBISONIC_LAYOUT_SOFT = 0x1997; + + [NativeName(NativeNameType.Const, "ALC_AMBISONIC_SCALING_SOFT")] + [NativeName(NativeNameType.Value, "0x1998")] + public const int ALC_AMBISONIC_SCALING_SOFT = 0x1998; + + [NativeName(NativeNameType.Const, "ALC_AMBISONIC_ORDER_SOFT")] + [NativeName(NativeNameType.Value, "0x1999")] + public const int ALC_AMBISONIC_ORDER_SOFT = 0x1999; + + [NativeName(NativeNameType.Const, "ALC_MAX_AMBISONIC_ORDER_SOFT")] + [NativeName(NativeNameType.Value, "0x199B")] + public const int ALC_MAX_AMBISONIC_ORDER_SOFT = 0x199B; + + [NativeName(NativeNameType.Const, "ALC_BFORMAT3D_SOFT")] + [NativeName(NativeNameType.Value, "0x1507")] + public const int ALC_BFORMAT3D_SOFT = 0x1507; + + [NativeName(NativeNameType.Const, "ALC_FUMA_SOFT")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int ALC_FUMA_SOFT = 0x0000; + + [NativeName(NativeNameType.Const, "ALC_ACN_SOFT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int ALC_ACN_SOFT = 0x0001; + + [NativeName(NativeNameType.Const, "ALC_SN3D_SOFT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int ALC_SN3D_SOFT = 0x0001; + + [NativeName(NativeNameType.Const, "ALC_N3D_SOFT")] + [NativeName(NativeNameType.Value, "0x0002")] + public const int ALC_N3D_SOFT = 0x0002; + + [NativeName(NativeNameType.Const, "AL_EFFECTSLOT_TARGET_SOFT")] + [NativeName(NativeNameType.Value, "0x199C")] + public const int AL_EFFECTSLOT_TARGET_SOFT = 0x199C; + + [NativeName(NativeNameType.Const, "AL_SOFT_events")] + [NativeName(NativeNameType.Value, "1")] + public const int AL_SOFT_events = 1; + + [NativeName(NativeNameType.Const, "AL_EVENT_CALLBACK_FUNCTION_SOFT")] + [NativeName(NativeNameType.Value, "0x19A2")] + public const int AL_EVENT_CALLBACK_FUNCTION_SOFT = 0x19A2; + + [NativeName(NativeNameType.Const, "AL_EVENT_CALLBACK_USER_PARAM_SOFT")] + [NativeName(NativeNameType.Value, "0x19A3")] + public const int AL_EVENT_CALLBACK_USER_PARAM_SOFT = 0x19A3; + + [NativeName(NativeNameType.Const, "AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT")] + [NativeName(NativeNameType.Value, "0x19A4")] + public const int AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT = 0x19A4; + + [NativeName(NativeNameType.Const, "AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT")] + [NativeName(NativeNameType.Value, "0x19A5")] + public const int AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT = 0x19A5; + + [NativeName(NativeNameType.Const, "AL_EVENT_TYPE_DISCONNECTED_SOFT")] + [NativeName(NativeNameType.Value, "0x19A6")] + public const int AL_EVENT_TYPE_DISCONNECTED_SOFT = 0x19A6; + + [NativeName(NativeNameType.Const, "AL_BUFFER_CALLBACK_FUNCTION_SOFT")] + [NativeName(NativeNameType.Value, "0x19A0")] + public const int AL_BUFFER_CALLBACK_FUNCTION_SOFT = 0x19A0; + + [NativeName(NativeNameType.Const, "AL_BUFFER_CALLBACK_USER_PARAM_SOFT")] + [NativeName(NativeNameType.Value, "0x19A1")] + public const int AL_BUFFER_CALLBACK_USER_PARAM_SOFT = 0x19A1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ2CHN8_SOFT")] + [NativeName(NativeNameType.Value, "0x19A2")] + public const int AL_FORMAT_UHJ2CHN8_SOFT = 0x19A2; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ2CHN16_SOFT")] + [NativeName(NativeNameType.Value, "0x19A3")] + public const int AL_FORMAT_UHJ2CHN16_SOFT = 0x19A3; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ2CHN_FLOAT32_SOFT")] + [NativeName(NativeNameType.Value, "0x19A4")] + public const int AL_FORMAT_UHJ2CHN_FLOAT32_SOFT = 0x19A4; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ3CHN8_SOFT")] + [NativeName(NativeNameType.Value, "0x19A5")] + public const int AL_FORMAT_UHJ3CHN8_SOFT = 0x19A5; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ3CHN16_SOFT")] + [NativeName(NativeNameType.Value, "0x19A6")] + public const int AL_FORMAT_UHJ3CHN16_SOFT = 0x19A6; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ3CHN_FLOAT32_SOFT")] + [NativeName(NativeNameType.Value, "0x19A7")] + public const int AL_FORMAT_UHJ3CHN_FLOAT32_SOFT = 0x19A7; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ4CHN8_SOFT")] + [NativeName(NativeNameType.Value, "0x19A8")] + public const int AL_FORMAT_UHJ4CHN8_SOFT = 0x19A8; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ4CHN16_SOFT")] + [NativeName(NativeNameType.Value, "0x19A9")] + public const int AL_FORMAT_UHJ4CHN16_SOFT = 0x19A9; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ4CHN_FLOAT32_SOFT")] + [NativeName(NativeNameType.Value, "0x19AA")] + public const int AL_FORMAT_UHJ4CHN_FLOAT32_SOFT = 0x19AA; + + [NativeName(NativeNameType.Const, "AL_STEREO_MODE_SOFT")] + [NativeName(NativeNameType.Value, "0x19B0")] + public const int AL_STEREO_MODE_SOFT = 0x19B0; + + [NativeName(NativeNameType.Const, "AL_NORMAL_SOFT")] + [NativeName(NativeNameType.Value, "0x0000")] + public const int AL_NORMAL_SOFT = 0x0000; + + [NativeName(NativeNameType.Const, "AL_SUPER_STEREO_SOFT")] + [NativeName(NativeNameType.Value, "0x0001")] + public const int AL_SUPER_STEREO_SOFT = 0x0001; + + [NativeName(NativeNameType.Const, "AL_SUPER_STEREO_WIDTH_SOFT")] + [NativeName(NativeNameType.Value, "0x19B1")] + public const int AL_SUPER_STEREO_WIDTH_SOFT = 0x19B1; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ2CHN_MULAW_SOFT")] + [NativeName(NativeNameType.Value, "0x19B3")] + public const int AL_FORMAT_UHJ2CHN_MULAW_SOFT = 0x19B3; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ2CHN_ALAW_SOFT")] + [NativeName(NativeNameType.Value, "0x19B4")] + public const int AL_FORMAT_UHJ2CHN_ALAW_SOFT = 0x19B4; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ2CHN_IMA4_SOFT")] + [NativeName(NativeNameType.Value, "0x19B5")] + public const int AL_FORMAT_UHJ2CHN_IMA4_SOFT = 0x19B5; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ2CHN_MSADPCM_SOFT")] + [NativeName(NativeNameType.Value, "0x19B6")] + public const int AL_FORMAT_UHJ2CHN_MSADPCM_SOFT = 0x19B6; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ3CHN_MULAW_SOFT")] + [NativeName(NativeNameType.Value, "0x19B7")] + public const int AL_FORMAT_UHJ3CHN_MULAW_SOFT = 0x19B7; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ3CHN_ALAW_SOFT")] + [NativeName(NativeNameType.Value, "0x19B8")] + public const int AL_FORMAT_UHJ3CHN_ALAW_SOFT = 0x19B8; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ4CHN_MULAW_SOFT")] + [NativeName(NativeNameType.Value, "0x19B9")] + public const int AL_FORMAT_UHJ4CHN_MULAW_SOFT = 0x19B9; + + [NativeName(NativeNameType.Const, "AL_FORMAT_UHJ4CHN_ALAW_SOFT")] + [NativeName(NativeNameType.Value, "0x19BA")] + public const int AL_FORMAT_UHJ4CHN_ALAW_SOFT = 0x19BA; + + [NativeName(NativeNameType.Const, "ALC_OUTPUT_MODE_SOFT")] + [NativeName(NativeNameType.Value, "0x19AC")] + public const int ALC_OUTPUT_MODE_SOFT = 0x19AC; + + [NativeName(NativeNameType.Const, "ALC_ANY_SOFT")] + [NativeName(NativeNameType.Value, "0x19AD")] + public const int ALC_ANY_SOFT = 0x19AD; + + [NativeName(NativeNameType.Const, "ALC_STEREO_BASIC_SOFT")] + [NativeName(NativeNameType.Value, "0x19AE")] + public const int ALC_STEREO_BASIC_SOFT = 0x19AE; + + [NativeName(NativeNameType.Const, "ALC_STEREO_UHJ_SOFT")] + [NativeName(NativeNameType.Value, "0x19AF")] + public const int ALC_STEREO_UHJ_SOFT = 0x19AF; + + [NativeName(NativeNameType.Const, "ALC_STEREO_HRTF_SOFT")] + [NativeName(NativeNameType.Value, "0x19B2")] + public const int ALC_STEREO_HRTF_SOFT = 0x19B2; + + [NativeName(NativeNameType.Const, "ALC_SURROUND_5_1_SOFT")] + [NativeName(NativeNameType.Value, "0x1504")] + public const int ALC_SURROUND_5_1_SOFT = 0x1504; + + [NativeName(NativeNameType.Const, "ALC_SURROUND_6_1_SOFT")] + [NativeName(NativeNameType.Value, "0x1505")] + public const int ALC_SURROUND_6_1_SOFT = 0x1505; + + [NativeName(NativeNameType.Const, "ALC_SURROUND_7_1_SOFT")] + [NativeName(NativeNameType.Value, "0x1506")] + public const int ALC_SURROUND_7_1_SOFT = 0x1506; + + } +} diff --git a/Hexa.NET.OpenAL/Generated/Delegates/Delegates.000.cs b/Hexa.NET.OpenAL/Generated/Delegates/Delegates.000.cs new file mode 100644 index 0000000..e0e4681 --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Delegates/Delegates.000.cs @@ -0,0 +1,3136 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + #if NET5_0_OR_GREATER + /// + /// Pointer-to-function types, useful for storing dynamically loaded AL entry
+ /// points.
+ /// + [NativeName(NativeNameType.Delegate, "LPALENABLE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALENABLE([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability); + + #else + /// + /// Pointer-to-function types, useful for storing dynamically loaded AL entry
+ /// points.
+ /// + [NativeName(NativeNameType.Delegate, "LPALENABLE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALENABLE([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDISABLE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDISABLE([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDISABLE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDISABLE([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISENABLED")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISENABLED([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISENABLED")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISENABLED([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSTRING")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte* LPALGETSTRING([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSTRING")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALGETSTRING([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBOOLEANV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBOOLEANV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALboolean*")] byte* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBOOLEANV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBOOLEANV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALboolean*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETINTEGERV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETINTEGERV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETINTEGERV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETINTEGERV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFLOATV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFLOATV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFLOATV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFLOATV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETDOUBLEV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETDOUBLEV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALdouble*")] double* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETDOUBLEV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETDOUBLEV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALdouble*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBOOLEAN")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALGETBOOLEAN([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBOOLEAN")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALGETBOOLEAN([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETINTEGER")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALGETINTEGER([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETINTEGER")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALGETINTEGER([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFLOAT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate float LPALGETFLOAT([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFLOAT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate float LPALGETFLOAT([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETDOUBLE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate double LPALGETDOUBLE([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETDOUBLE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate double LPALGETDOUBLE([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETERROR")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALGETERROR(); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETERROR")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALGETERROR(); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISEXTENSIONPRESENT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISEXTENSIONPRESENT([NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* extname); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISEXTENSIONPRESENT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISEXTENSIONPRESENT([NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALchar*")] nint extname); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETPROCADDRESS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void* LPALGETPROCADDRESS([NativeName(NativeNameType.Param, "fname")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* fname); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETPROCADDRESS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALGETPROCADDRESS([NativeName(NativeNameType.Param, "fname")] [NativeName(NativeNameType.Type, "const ALchar*")] nint fname); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETENUMVALUE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALGETENUMVALUE([NativeName(NativeNameType.Param, "ename")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* ename); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETENUMVALUE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALGETENUMVALUE([NativeName(NativeNameType.Param, "ename")] [NativeName(NativeNameType.Type, "const ALchar*")] nint ename); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERF([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERF([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENER3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENER3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERFV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERFV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERI([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERI([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENER3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENER3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERIV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALLISTENERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALLISTENERIV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERF([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERF([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENER3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENER3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERFV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERFV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERI([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERI([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] nint value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENER3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENER3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] nint value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] nint value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] nint value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERIV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETLISTENERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETLISTENERIV([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGENSOURCES")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENSOURCES([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "ALuint*")] uint* sources); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGENSOURCES")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENSOURCES([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "ALuint*")] nint sources); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETESOURCES")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETESOURCES([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETESOURCES")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETESOURCES([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] nint sources); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISSOURCE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISSOURCE([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISSOURCE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISSOURCE([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEF([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEF([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEFV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEFV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEI([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEI([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEIV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEIV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEF([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEF([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEFV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEFV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEI([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEI([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] nint value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] nint value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] nint value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] nint value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEIV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEIV([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAYV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAYV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAYV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAYV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] nint sources); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCESTOPV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCESTOPV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCESTOPV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCESTOPV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] nint sources); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEREWINDV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEREWINDV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEREWINDV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEREWINDV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] nint sources); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPAUSEV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPAUSEV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPAUSEV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPAUSEV([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] nint sources); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAY")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAY([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAY")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAY([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCESTOP")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCESTOP([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCESTOP")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCESTOP([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEREWIND")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEREWIND([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEREWIND")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEREWIND([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPAUSE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPAUSE([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPAUSE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPAUSE([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEQUEUEBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEQUEUEBUFFERS([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* buffers); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEQUEUEBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEQUEUEBUFFERS([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] nint buffers); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEUNQUEUEBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEUNQUEUEBUFFERS([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] uint* buffers); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEUNQUEUEBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEUNQUEUEBUFFERS([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] nint buffers); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGENBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENBUFFERS([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] uint* buffers); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGENBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENBUFFERS([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] nint buffers); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEBUFFERS([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* buffers); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEBUFFERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEBUFFERS([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] nint buffers); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISBUFFER")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISBUFFER([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISBUFFER")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISBUFFER([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERDATA")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERDATA([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALenum")] int format, [NativeName(NativeNameType.Param, "data")] [NativeName(NativeNameType.Type, "const ALvoid*")] void* data, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALsizei")] int size, [NativeName(NativeNameType.Param, "samplerate")] [NativeName(NativeNameType.Type, "ALsizei")] int samplerate); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERDATA")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERDATA([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALenum")] int format, [NativeName(NativeNameType.Param, "data")] [NativeName(NativeNameType.Type, "const ALvoid*")] nint data, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALsizei")] int size, [NativeName(NativeNameType.Param, "samplerate")] [NativeName(NativeNameType.Type, "ALsizei")] int samplerate); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERF([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERF([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFER3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFER3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERFV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERFV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERI([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERI([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFER3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFER3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERIV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERIV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERF([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERF([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFER3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFER3F")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFER3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] nint value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERFV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERFV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERI([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERI([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] nint value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFER3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFER3I")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFER3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] nint value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] nint value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] nint value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERIV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERIV([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDOPPLERFACTOR")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDOPPLERFACTOR([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDOPPLERFACTOR")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDOPPLERFACTOR([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDOPPLERVELOCITY")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDOPPLERVELOCITY([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDOPPLERVELOCITY")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDOPPLERVELOCITY([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSPEEDOFSOUND")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSPEEDOFSOUND([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSPEEDOFSOUND")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSPEEDOFSOUND([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDISTANCEMODEL")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDISTANCEMODEL([NativeName(NativeNameType.Param, "distanceModel")] [NativeName(NativeNameType.Type, "ALenum")] int distanceModel); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDISTANCEMODEL")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDISTANCEMODEL([NativeName(NativeNameType.Param, "distanceModel")] [NativeName(NativeNameType.Type, "ALenum")] int distanceModel); + + #endif + + #if NET5_0_OR_GREATER + /// + /// Pointer-to-function types, useful for storing dynamically loaded ALC entry
+ /// points.
+ /// + [NativeName(NativeNameType.Delegate, "LPALCCREATECONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate ALCcontext* LPALCCREATECONTEXT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "attrlist")] [NativeName(NativeNameType.Type, "const ALCint*")] int* attrlist); + + #else + /// + /// Pointer-to-function types, useful for storing dynamically loaded ALC entry
+ /// points.
+ /// + [NativeName(NativeNameType.Delegate, "LPALCCREATECONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCCREATECONTEXT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "attrlist")] [NativeName(NativeNameType.Type, "const ALCint*")] nint attrlist); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCMAKECONTEXTCURRENT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCMAKECONTEXTCURRENT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCMAKECONTEXTCURRENT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCMAKECONTEXTCURRENT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] nint context); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCPROCESSCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCPROCESSCONTEXT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCPROCESSCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCPROCESSCONTEXT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] nint context); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCSUSPENDCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCSUSPENDCONTEXT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCSUSPENDCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCSUSPENDCONTEXT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] nint context); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCDESTROYCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCDESTROYCONTEXT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCDESTROYCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCDESTROYCONTEXT([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] nint context); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETCURRENTCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate ALCcontext* LPALCGETCURRENTCONTEXT(); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETCURRENTCONTEXT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCGETCURRENTCONTEXT(); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETCONTEXTSDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate ALCdevice* LPALCGETCONTEXTSDEVICE([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETCONTEXTSDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCGETCONTEXTSDEVICE([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] nint context); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCOPENDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate ALCdevice* LPALCOPENDEVICE([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* devicename); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCOPENDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCOPENDEVICE([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] nint devicename); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCLOSEDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCCLOSEDEVICE([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCLOSEDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCCLOSEDEVICE([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETERROR")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALCGETERROR([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETERROR")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALCGETERROR([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCISEXTENSIONPRESENT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCISEXTENSIONPRESENT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* extname); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCISEXTENSIONPRESENT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCISEXTENSIONPRESENT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALCchar*")] nint extname); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETPROCADDRESS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void* LPALCGETPROCADDRESS([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "funcname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* funcname); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETPROCADDRESS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCGETPROCADDRESS([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "funcname")] [NativeName(NativeNameType.Type, "const ALCchar*")] nint funcname); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETENUMVALUE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALCGETENUMVALUE([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "enumname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* enumname); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETENUMVALUE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int LPALCGETENUMVALUE([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "enumname")] [NativeName(NativeNameType.Type, "const ALCchar*")] nint enumname); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETSTRING")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte* LPALCGETSTRING([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETSTRING")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCGETSTRING([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETINTEGERV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCGETINTEGERV([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALCsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint*")] int* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETINTEGERV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCGETINTEGERV([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALCsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTUREOPENDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate ALCdevice* LPALCCAPTUREOPENDEVICE([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* devicename, [NativeName(NativeNameType.Param, "frequency")] [NativeName(NativeNameType.Type, "ALCuint")] uint frequency, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALCenum")] int format, [NativeName(NativeNameType.Param, "buffersize")] [NativeName(NativeNameType.Type, "ALCsizei")] int buffersize); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTUREOPENDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCCAPTUREOPENDEVICE([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] nint devicename, [NativeName(NativeNameType.Param, "frequency")] [NativeName(NativeNameType.Type, "ALCuint")] uint frequency, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALCenum")] int format, [NativeName(NativeNameType.Param, "buffersize")] [NativeName(NativeNameType.Type, "ALCsizei")] int buffersize); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURECLOSEDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCCAPTURECLOSEDEVICE([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURECLOSEDEVICE")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCCAPTURECLOSEDEVICE([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURESTART")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCCAPTURESTART([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURESTART")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCCAPTURESTART([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURESTOP")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCCAPTURESTOP([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURESTOP")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCCAPTURESTOP([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURESAMPLES")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCCAPTURESAMPLES([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALCvoid*")] void* buffer, [NativeName(NativeNameType.Param, "samples")] [NativeName(NativeNameType.Type, "ALCsizei")] int samples); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCCAPTURESAMPLES")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCCAPTURESAMPLES([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALCvoid*")] nint buffer, [NativeName(NativeNameType.Param, "samples")] [NativeName(NativeNameType.Type, "ALCsizei")] int samples); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALBUFFERDATASTATICPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void PFNALBUFFERDATASTATICPROC([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALvoid*")] void* unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown4); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALBUFFERDATASTATICPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void PFNALBUFFERDATASTATICPROC([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALvoid*")] nint unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown4); + + #endif + + #if NET5_0_OR_GREATER + /// + /// Effect object function types.
+ /// + [NativeName(NativeNameType.Delegate, "LPALGENEFFECTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENEFFECTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint*")] uint* unknown1); + + #else + /// + /// Effect object function types.
+ /// + [NativeName(NativeNameType.Delegate, "LPALGENEFFECTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENEFFECTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint*")] nint unknown1); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEEFFECTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEEFFECTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* unknown1); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEEFFECTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEEFFECTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint*")] nint unknown1); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISEFFECT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISEFFECT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISEFFECT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISEFFECT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint")] int unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint")] int unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat")] float unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat")] float unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEFFECTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEFFECTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETEFFECTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETEFFECTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// Filter object function types.
+ /// + [NativeName(NativeNameType.Delegate, "LPALGENFILTERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENFILTERS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint*")] uint* unknown1); + + #else + /// + /// Filter object function types.
+ /// + [NativeName(NativeNameType.Delegate, "LPALGENFILTERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENFILTERS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint*")] nint unknown1); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEFILTERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEFILTERS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* unknown1); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEFILTERS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEFILTERS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint*")] nint unknown1); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISFILTER")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISFILTER([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISFILTER")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISFILTER([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint")] int unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint")] int unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat")] float unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat")] float unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFILTERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFILTERFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETFILTERFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETFILTERFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// Auxiliary Effect Slot object function types.
+ /// + [NativeName(NativeNameType.Delegate, "LPALGENAUXILIARYEFFECTSLOTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENAUXILIARYEFFECTSLOTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint*")] uint* unknown1); + + #else + /// + /// Auxiliary Effect Slot object function types.
+ /// + [NativeName(NativeNameType.Delegate, "LPALGENAUXILIARYEFFECTSLOTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGENAUXILIARYEFFECTSLOTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint*")] nint unknown1); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEAUXILIARYEFFECTSLOTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEAUXILIARYEFFECTSLOTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* unknown1); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDELETEAUXILIARYEFFECTSLOTS")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDELETEAUXILIARYEFFECTSLOTS([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALuint*")] nint unknown1); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISAUXILIARYEFFECTSLOT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISAUXILIARYEFFECTSLOT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISAUXILIARYEFFECTSLOT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISAUXILIARYEFFECTSLOT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint")] int unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint")] int unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat")] float unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat")] float unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALAUXILIARYEFFECTSLOTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALAUXILIARYEFFECTSLOTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTI")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTI([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] int* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTIV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTIV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTF")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTF([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] float* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETAUXILIARYEFFECTSLOTFV")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETAUXILIARYEFFECTSLOTFV([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALCSETTHREADCONTEXTPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte PFNALCSETTHREADCONTEXTPROC([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALCSETTHREADCONTEXTPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte PFNALCSETTHREADCONTEXTPROC([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] nint context); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALCGETTHREADCONTEXTPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate ALCcontext* PFNALCGETTHREADCONTEXTPROC(); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALCGETTHREADCONTEXTPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint PFNALCGETTHREADCONTEXTPROC(); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALBUFFERSUBDATASOFTPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void PFNALBUFFERSUBDATASOFTPROC([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALvoid*")] void* unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown4); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "PFNALBUFFERSUBDATASOFTPROC")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void PFNALBUFFERSUBDATASOFTPROC([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALvoid*")] nint unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown4); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFOLDBACKCALLBACK")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFOLDBACKCALLBACK([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALFOLDBACKCALLBACK")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALFOLDBACKCALLBACK([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALREQUESTFOLDBACKSTART")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALREQUESTFOLDBACKSTART([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] float* unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "LPALFOLDBACKCALLBACK")] delegate* unknown4); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALREQUESTFOLDBACKSTART")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALREQUESTFOLDBACKSTART([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALfloat*")] nint unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "LPALFOLDBACKCALLBACK")] nint unknown4); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALREQUESTFOLDBACKSTOP")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALREQUESTFOLDBACKSTOP(); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALREQUESTFOLDBACKSTOP")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALREQUESTFOLDBACKSTOP(); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown4, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown5, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALvoid*")] void* unknown6); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown4, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown5, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALvoid*")] nint unknown6); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERSUBSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERSUBSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown4, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALvoid*")] void* unknown5); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERSUBSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERSUBSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown4, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALvoid*")] nint unknown5); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown4, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALvoid*")] void* unknown5); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALsizei")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown4, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALvoid*")] nint unknown5); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISBUFFERFORMATSUPPORTEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISBUFFERFORMATSUPPORTEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown0); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALISBUFFERFORMATSUPPORTEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALISBUFFERFORMATSUPPORTEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown0); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCLOOPBACKOPENDEVICESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate ALCdevice* LPALCLOOPBACKOPENDEVICESOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* unknown0); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCLOOPBACKOPENDEVICESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCLOOPBACKOPENDEVICESOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALCchar*")] nint unknown0); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCISRENDERFORMATSUPPORTEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCISRENDERFORMATSUPPORTEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCenum")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCenum")] int unknown3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCISRENDERFORMATSUPPORTEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCISRENDERFORMATSUPPORTEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCsizei")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCenum")] int unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCenum")] int unknown3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCRENDERSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCRENDERSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCvoid*")] void* unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCsizei")] int unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCRENDERSAMPLESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCRENDERSAMPLESSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCvoid*")] nint unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALCsizei")] int unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3DSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3DSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown4); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3DSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3DSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble")] double unknown4); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEDVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEDVSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALdouble*")] double* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEDVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEDVSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALdouble*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] double* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEDSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEDSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3DSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3DSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] double* unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] double* unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] double* unknown4); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3DSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3DSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] nint unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] nint unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] nint unknown4); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEDVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEDVSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] double* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEDVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEDVSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALdouble*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEI64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEI64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEI64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEI64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3I64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3I64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown4); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCE3I64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCE3I64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long unknown4); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEI64VSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEI64VSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint64SOFT*")] long* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEI64VSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEI64VSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "const ALint64SOFT*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEI64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEI64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] long* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEI64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEI64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3I64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3I64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] long* unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] long* unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] long* unknown4); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCE3I64SOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCE3I64SOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] nint unknown2, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] nint unknown3, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] nint unknown4); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEI64VSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEI64VSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] long* unknown2); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSOURCEI64VSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETSOURCEI64VSOFT([NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALuint")] uint unknown0, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALenum")] int unknown1, [NativeName(NativeNameType.Param, "")] [NativeName(NativeNameType.Type, "ALint64SOFT*")] nint unknown2); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDEFERUPDATESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDEFERUPDATESSOFT(); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALDEFERUPDATESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALDEFERUPDATESSOFT(); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALPROCESSUPDATESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALPROCESSUPDATESSOFT(); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALPROCESSUPDATESSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALPROCESSUPDATESSOFT(); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCDEVICEPAUSESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCDEVICEPAUSESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCDEVICEPAUSESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCDEVICEPAUSESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCDEVICERESUMESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCDEVICERESUMESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCDEVICERESUMESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCDEVICERESUMESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETSTRINGISOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte* LPALCGETSTRINGISOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "paramName")] [NativeName(NativeNameType.Type, "ALCenum")] int paramName, [NativeName(NativeNameType.Param, "index")] [NativeName(NativeNameType.Type, "ALCsizei")] int index); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETSTRINGISOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALCGETSTRINGISOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "paramName")] [NativeName(NativeNameType.Type, "ALCenum")] int paramName, [NativeName(NativeNameType.Param, "index")] [NativeName(NativeNameType.Type, "ALCsizei")] int index); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCRESETDEVICESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCRESETDEVICESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "attribs")] [NativeName(NativeNameType.Type, "const ALCint*")] int* attribs); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCRESETDEVICESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCRESETDEVICESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "attribs")] [NativeName(NativeNameType.Type, "const ALCint*")] nint attribs); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSTRINGISOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte* LPALGETSTRINGISOFT([NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALenum")] int pname, [NativeName(NativeNameType.Param, "index")] [NativeName(NativeNameType.Type, "ALsizei")] int index); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETSTRINGISOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALGETSTRINGISOFT([NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALenum")] int pname, [NativeName(NativeNameType.Param, "index")] [NativeName(NativeNameType.Type, "ALsizei")] int index); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETINTEGER64VSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCGETINTEGER64VSOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALCenum")] int pname, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint64SOFT*")] long* values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCGETINTEGER64VSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALCGETINTEGER64VSOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALCenum")] int pname, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint64SOFT*")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "ALEVENTPROCSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void ALEVENTPROCSOFT([NativeName(NativeNameType.Param, "eventType")] [NativeName(NativeNameType.Type, "ALenum")] int eventType, [NativeName(NativeNameType.Param, "object")] [NativeName(NativeNameType.Type, "ALuint")] uint @object, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALuint")] uint param, [NativeName(NativeNameType.Param, "length")] [NativeName(NativeNameType.Type, "ALsizei")] int length, [NativeName(NativeNameType.Param, "message")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* message, [NativeName(NativeNameType.Param, "userParam")] [NativeName(NativeNameType.Type, "void*")] void* userParam); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "ALEVENTPROCSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void ALEVENTPROCSOFT([NativeName(NativeNameType.Param, "eventType")] [NativeName(NativeNameType.Type, "ALenum")] int eventType, [NativeName(NativeNameType.Param, "object")] [NativeName(NativeNameType.Type, "ALuint")] uint @object, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALuint")] uint param, [NativeName(NativeNameType.Param, "length")] [NativeName(NativeNameType.Type, "ALsizei")] int length, [NativeName(NativeNameType.Param, "message")] [NativeName(NativeNameType.Type, "const ALchar*")] nint message, [NativeName(NativeNameType.Param, "userParam")] [NativeName(NativeNameType.Type, "void*")] nint userParam); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEVENTCONTROLSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEVENTCONTROLSOFT([NativeName(NativeNameType.Param, "count")] [NativeName(NativeNameType.Type, "ALsizei")] int count, [NativeName(NativeNameType.Param, "types")] [NativeName(NativeNameType.Type, "const ALenum*")] int* types, [NativeName(NativeNameType.Param, "enable")] [NativeName(NativeNameType.Type, "ALboolean")] byte enable); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEVENTCONTROLSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEVENTCONTROLSOFT([NativeName(NativeNameType.Param, "count")] [NativeName(NativeNameType.Type, "ALsizei")] int count, [NativeName(NativeNameType.Param, "types")] [NativeName(NativeNameType.Type, "const ALenum*")] nint types, [NativeName(NativeNameType.Param, "enable")] [NativeName(NativeNameType.Type, "ALboolean")] byte enable); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEVENTCALLBACKSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEVENTCALLBACKSOFT([NativeName(NativeNameType.Param, "callback")] [NativeName(NativeNameType.Type, "ALEVENTPROCSOFT")] delegate* callback, [NativeName(NativeNameType.Param, "userParam")] [NativeName(NativeNameType.Type, "void*")] void* userParam); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALEVENTCALLBACKSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALEVENTCALLBACKSOFT([NativeName(NativeNameType.Param, "callback")] [NativeName(NativeNameType.Type, "ALEVENTPROCSOFT")] nint callback, [NativeName(NativeNameType.Param, "userParam")] [NativeName(NativeNameType.Type, "void*")] nint userParam); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETPOINTERSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void* LPALGETPOINTERSOFT([NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALenum")] int pname); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETPOINTERSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate nint LPALGETPOINTERSOFT([NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALenum")] int pname); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETPOINTERVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETPOINTERVSOFT([NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALenum")] int pname, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "void**")] void** values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETPOINTERVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETPOINTERVSOFT([NativeName(NativeNameType.Param, "pname")] [NativeName(NativeNameType.Type, "ALenum")] int pname, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "void**")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCREOPENDEVICESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCREOPENDEVICESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "deviceName")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* deviceName, [NativeName(NativeNameType.Param, "attribs")] [NativeName(NativeNameType.Type, "const ALCint*")] int* attribs); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALCREOPENDEVICESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate byte LPALCREOPENDEVICESOFT([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] nint device, [NativeName(NativeNameType.Param, "deviceName")] [NativeName(NativeNameType.Type, "const ALCchar*")] nint deviceName, [NativeName(NativeNameType.Param, "attribs")] [NativeName(NativeNameType.Type, "const ALCint*")] nint attribs); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "ALBUFFERCALLBACKTYPESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int ALBUFFERCALLBACKTYPESOFT([NativeName(NativeNameType.Param, "userptr")] [NativeName(NativeNameType.Type, "ALvoid*")] void* userptr, [NativeName(NativeNameType.Param, "sampledata")] [NativeName(NativeNameType.Type, "ALvoid*")] void* sampledata, [NativeName(NativeNameType.Param, "numbytes")] [NativeName(NativeNameType.Type, "ALsizei")] int numbytes); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "ALBUFFERCALLBACKTYPESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int ALBUFFERCALLBACKTYPESOFT([NativeName(NativeNameType.Param, "userptr")] [NativeName(NativeNameType.Type, "ALvoid*")] nint userptr, [NativeName(NativeNameType.Param, "sampledata")] [NativeName(NativeNameType.Type, "ALvoid*")] nint sampledata, [NativeName(NativeNameType.Param, "numbytes")] [NativeName(NativeNameType.Type, "ALsizei")] int numbytes); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERCALLBACKSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERCALLBACKSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALenum")] int format, [NativeName(NativeNameType.Param, "freq")] [NativeName(NativeNameType.Type, "ALsizei")] int freq, [NativeName(NativeNameType.Param, "callback")] [NativeName(NativeNameType.Type, "ALBUFFERCALLBACKTYPESOFT")] delegate* callback, [NativeName(NativeNameType.Param, "userptr")] [NativeName(NativeNameType.Type, "ALvoid*")] void* userptr); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALBUFFERCALLBACKSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALBUFFERCALLBACKSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALenum")] int format, [NativeName(NativeNameType.Param, "freq")] [NativeName(NativeNameType.Type, "ALsizei")] int freq, [NativeName(NativeNameType.Param, "callback")] [NativeName(NativeNameType.Type, "ALBUFFERCALLBACKTYPESOFT")] nint callback, [NativeName(NativeNameType.Param, "userptr")] [NativeName(NativeNameType.Type, "ALvoid*")] nint userptr); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERPTRSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERPTRSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALvoid**")] void** value); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERPTRSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERPTRSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALvoid**")] nint value); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFER3PTRSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFER3PTRSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALvoid**")] void** value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALvoid**")] void** value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALvoid**")] void** value3); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFER3PTRSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFER3PTRSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALvoid**")] nint value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALvoid**")] nint value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALvoid**")] nint value3); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERPTRVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERPTRVSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALvoid**")] void** values); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALGETBUFFERPTRVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALGETBUFFERPTRVSOFT([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALvoid**")] nint values); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAYATTIMESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAYATTIMESOFT([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "start_time")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long startTime); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAYATTIMESOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAYATTIMESOFT([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "start_time")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long startTime); + + #endif + + #if NET5_0_OR_GREATER + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAYATTIMEVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAYATTIMEVSOFT([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources, [NativeName(NativeNameType.Param, "start_time")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long startTime); + + #else + /// + /// To be documented. + /// + [NativeName(NativeNameType.Delegate, "LPALSOURCEPLAYATTIMEVSOFT")] + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate void LPALSOURCEPLAYATTIMEVSOFT([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] nint sources, [NativeName(NativeNameType.Param, "start_time")] [NativeName(NativeNameType.Type, "ALint64SOFT")] long startTime); + + #endif + +} diff --git a/Hexa.NET.OpenAL/Generated/Extensions/Extensions.000.cs b/Hexa.NET.OpenAL/Generated/Extensions/Extensions.000.cs new file mode 100644 index 0000000..0b657fa --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Extensions/Extensions.000.cs @@ -0,0 +1,20 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + public static unsafe partial class Extensions + { + } +} diff --git a/Hexa.NET.OpenAL/Generated/FunctionTable.cs b/Hexa.NET.OpenAL/Generated/FunctionTable.cs new file mode 100644 index 0000000..0e040ae --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/FunctionTable.cs @@ -0,0 +1,127 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + public unsafe partial class OpenAL + { + internal static FunctionTable funcTable; + + /// + /// Initializes the function table, automatically called. Do not call manually, only after . + /// + public static void InitApi() + { + funcTable = new FunctionTable(LibraryLoader.LoadLibrary(GetLibraryName, null), 93); + funcTable.Load(0, "alEnable"); + funcTable.Load(1, "alDisable"); + funcTable.Load(2, "alIsEnabled"); + funcTable.Load(3, "alDopplerFactor"); + funcTable.Load(4, "alDopplerVelocity"); + funcTable.Load(5, "alSpeedOfSound"); + funcTable.Load(6, "alDistanceModel"); + funcTable.Load(7, "alGetString"); + funcTable.Load(8, "alGetBooleanv"); + funcTable.Load(9, "alGetIntegerv"); + funcTable.Load(10, "alGetFloatv"); + funcTable.Load(11, "alGetDoublev"); + funcTable.Load(12, "alGetBoolean"); + funcTable.Load(13, "alGetInteger"); + funcTable.Load(14, "alGetFloat"); + funcTable.Load(15, "alGetDouble"); + funcTable.Load(16, "alGetError"); + funcTable.Load(17, "alIsExtensionPresent"); + funcTable.Load(18, "alGetProcAddress"); + funcTable.Load(19, "alGetEnumValue"); + funcTable.Load(20, "alListenerf"); + funcTable.Load(21, "alListener3f"); + funcTable.Load(22, "alListenerfv"); + funcTable.Load(23, "alListeneri"); + funcTable.Load(24, "alListener3i"); + funcTable.Load(25, "alListeneriv"); + funcTable.Load(26, "alGetListenerf"); + funcTable.Load(27, "alGetListener3f"); + funcTable.Load(28, "alGetListenerfv"); + funcTable.Load(29, "alGetListeneri"); + funcTable.Load(30, "alGetListener3i"); + funcTable.Load(31, "alGetListeneriv"); + funcTable.Load(32, "alGenSources"); + funcTable.Load(33, "alDeleteSources"); + funcTable.Load(34, "alIsSource"); + funcTable.Load(35, "alSourcef"); + funcTable.Load(36, "alSource3f"); + funcTable.Load(37, "alSourcefv"); + funcTable.Load(38, "alSourcei"); + funcTable.Load(39, "alSource3i"); + funcTable.Load(40, "alSourceiv"); + funcTable.Load(41, "alGetSourcef"); + funcTable.Load(42, "alGetSource3f"); + funcTable.Load(43, "alGetSourcefv"); + funcTable.Load(44, "alGetSourcei"); + funcTable.Load(45, "alGetSource3i"); + funcTable.Load(46, "alGetSourceiv"); + funcTable.Load(47, "alSourcePlay"); + funcTable.Load(48, "alSourceStop"); + funcTable.Load(49, "alSourceRewind"); + funcTable.Load(50, "alSourcePause"); + funcTable.Load(51, "alSourcePlayv"); + funcTable.Load(52, "alSourceStopv"); + funcTable.Load(53, "alSourceRewindv"); + funcTable.Load(54, "alSourcePausev"); + funcTable.Load(55, "alSourceQueueBuffers"); + funcTable.Load(56, "alSourceUnqueueBuffers"); + funcTable.Load(57, "alGenBuffers"); + funcTable.Load(58, "alDeleteBuffers"); + funcTable.Load(59, "alIsBuffer"); + funcTable.Load(60, "alBufferData"); + funcTable.Load(61, "alBufferf"); + funcTable.Load(62, "alBuffer3f"); + funcTable.Load(63, "alBufferfv"); + funcTable.Load(64, "alBufferi"); + funcTable.Load(65, "alBuffer3i"); + funcTable.Load(66, "alBufferiv"); + funcTable.Load(67, "alGetBufferf"); + funcTable.Load(68, "alGetBuffer3f"); + funcTable.Load(69, "alGetBufferfv"); + funcTable.Load(70, "alGetBufferi"); + funcTable.Load(71, "alGetBuffer3i"); + funcTable.Load(72, "alGetBufferiv"); + funcTable.Load(73, "alcCreateContext"); + funcTable.Load(74, "alcMakeContextCurrent"); + funcTable.Load(75, "alcProcessContext"); + funcTable.Load(76, "alcSuspendContext"); + funcTable.Load(77, "alcDestroyContext"); + funcTable.Load(78, "alcGetCurrentContext"); + funcTable.Load(79, "alcGetContextsDevice"); + funcTable.Load(80, "alcOpenDevice"); + funcTable.Load(81, "alcCloseDevice"); + funcTable.Load(82, "alcGetError"); + funcTable.Load(83, "alcIsExtensionPresent"); + funcTable.Load(84, "alcGetProcAddress"); + funcTable.Load(85, "alcGetEnumValue"); + funcTable.Load(86, "alcGetString"); + funcTable.Load(87, "alcGetIntegerv"); + funcTable.Load(88, "alcCaptureOpenDevice"); + funcTable.Load(89, "alcCaptureCloseDevice"); + funcTable.Load(90, "alcCaptureStart"); + funcTable.Load(91, "alcCaptureStop"); + funcTable.Load(92, "alcCaptureSamples"); + } + + public static void FreeApi() + { + funcTable.Free(); + } + } +} diff --git a/Hexa.NET.OpenAL/Generated/Functions/Functions.000.cs b/Hexa.NET.OpenAL/Generated/Functions/Functions.000.cs new file mode 100644 index 0000000..429aa80 --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Functions/Functions.000.cs @@ -0,0 +1,3897 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + public unsafe partial class OpenAL + { + /// + /// Renderer State management.
+ /// + [NativeName(NativeNameType.Func, "alEnable")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void EnableNative([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[0])(capability); + #else + ((delegate* unmanaged[Cdecl])funcTable[0])(capability); + #endif + } + + /// + /// Renderer State management.
+ /// + [NativeName(NativeNameType.Func, "alEnable")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Enable([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability) + { + EnableNative(capability); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alDisable")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void DisableNative([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[1])(capability); + #else + ((delegate* unmanaged[Cdecl])funcTable[1])(capability); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alDisable")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Disable([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability) + { + DisableNative(capability); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alIsEnabled")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte IsEnabledNative([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[2])(capability); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[2])(capability); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alIsEnabled")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + public static byte IsEnabled([NativeName(NativeNameType.Param, "capability")] [NativeName(NativeNameType.Type, "ALenum")] int capability) + { + byte ret = IsEnabledNative(capability); + return ret; + } + + /// + /// Context state setting.
+ /// + [NativeName(NativeNameType.Func, "alDopplerFactor")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void DopplerFactorNative([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[3])(value); + #else + ((delegate* unmanaged[Cdecl])funcTable[3])(value); + #endif + } + + /// + /// Context state setting.
+ /// + [NativeName(NativeNameType.Func, "alDopplerFactor")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DopplerFactor([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + DopplerFactorNative(value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alDopplerVelocity")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void DopplerVelocityNative([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[4])(value); + #else + ((delegate* unmanaged[Cdecl])funcTable[4])(value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alDopplerVelocity")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DopplerVelocity([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + DopplerVelocityNative(value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSpeedOfSound")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SpeedOfSoundNative([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[5])(value); + #else + ((delegate* unmanaged[Cdecl])funcTable[5])(value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSpeedOfSound")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SpeedOfSound([NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + SpeedOfSoundNative(value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alDistanceModel")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void DistanceModelNative([NativeName(NativeNameType.Param, "distanceModel")] [NativeName(NativeNameType.Type, "ALenum")] int distanceModel) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[6])(distanceModel); + #else + ((delegate* unmanaged[Cdecl])funcTable[6])(distanceModel); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alDistanceModel")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DistanceModel([NativeName(NativeNameType.Param, "distanceModel")] [NativeName(NativeNameType.Type, "ALenum")] int distanceModel) + { + DistanceModelNative(distanceModel); + } + + /// + /// Context state retrieval.
+ /// + [NativeName(NativeNameType.Func, "alGetString")] + [return: NativeName(NativeNameType.Type, "const ALchar*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte* GetStringNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[7])(param); + #else + return (byte*)((delegate* unmanaged[Cdecl])funcTable[7])(param); + #endif + } + + /// + /// Context state retrieval.
+ /// + [NativeName(NativeNameType.Func, "alGetString")] + [return: NativeName(NativeNameType.Type, "const ALchar*")] + public static byte* GetString([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + byte* ret = GetStringNative(param); + return ret; + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBooleanv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetBooleanvNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALboolean*")] byte* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[8])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[8])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBooleanv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBooleanv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALboolean*")] byte* values) + { + GetBooleanvNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBooleanv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBooleanv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALboolean*")] ref byte values) + { + fixed (byte* pvalues = &values) + { + GetBooleanvNative(param, (byte*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetIntegervNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[9])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[9])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetIntegerv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + GetIntegervNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetIntegerv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] ref int values) + { + fixed (int* pvalues = &values) + { + GetIntegervNative(param, (int*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetFloatv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetFloatvNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[10])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[10])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetFloatv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetFloatv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + GetFloatvNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetFloatv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetFloatv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float values) + { + fixed (float* pvalues = &values) + { + GetFloatvNative(param, (float*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetDoublev")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetDoublevNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALdouble*")] double* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[11])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[11])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetDoublev")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetDoublev([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALdouble*")] double* values) + { + GetDoublevNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetDoublev")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetDoublev([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALdouble*")] ref double values) + { + fixed (double* pvalues = &values) + { + GetDoublevNative(param, (double*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBoolean")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte GetBooleanNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[12])(param); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[12])(param); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBoolean")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + public static byte GetBoolean([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + byte ret = GetBooleanNative(param); + return ret; + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetInteger")] + [return: NativeName(NativeNameType.Type, "ALint")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int GetIntegerNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[13])(param); + #else + return (int)((delegate* unmanaged[Cdecl])funcTable[13])(param); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetInteger")] + [return: NativeName(NativeNameType.Type, "ALint")] + public static int GetInteger([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + int ret = GetIntegerNative(param); + return ret; + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetFloat")] + [return: NativeName(NativeNameType.Type, "ALfloat")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static float GetFloatNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[14])(param); + #else + return (float)((delegate* unmanaged[Cdecl])funcTable[14])(param); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetFloat")] + [return: NativeName(NativeNameType.Type, "ALfloat")] + public static float GetFloat([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + float ret = GetFloatNative(param); + return ret; + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetDouble")] + [return: NativeName(NativeNameType.Type, "ALdouble")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static double GetDoubleNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[15])(param); + #else + return (double)((delegate* unmanaged[Cdecl])funcTable[15])(param); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetDouble")] + [return: NativeName(NativeNameType.Type, "ALdouble")] + public static double GetDouble([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param) + { + double ret = GetDoubleNative(param); + return ret; + } + + /// + /// Obtain the first error generated in the AL context since the last call to
+ /// this function.
+ /// + [NativeName(NativeNameType.Func, "alGetError")] + [return: NativeName(NativeNameType.Type, "ALenum")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int GetErrorNative() + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[16])(); + #else + return (int)((delegate* unmanaged[Cdecl])funcTable[16])(); + #endif + } + + /// + /// Obtain the first error generated in the AL context since the last call to
+ /// this function.
+ /// + [NativeName(NativeNameType.Func, "alGetError")] + [return: NativeName(NativeNameType.Type, "ALenum")] + public static int GetError() + { + int ret = GetErrorNative(); + return ret; + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte IsExtensionPresentNative([NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* extname) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[17])(extname); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[17])((nint)extname); + #endif + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + public static byte IsExtensionPresent([NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* extname) + { + byte ret = IsExtensionPresentNative(extname); + return ret; + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + public static byte IsExtensionPresent([NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALchar*")] ref byte extname) + { + fixed (byte* pextname = &extname) + { + byte ret = IsExtensionPresentNative((byte*)pextname); + return ret; + } + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alGetProcAddress")] + [return: NativeName(NativeNameType.Type, "void*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void* GetProcAddressNative([NativeName(NativeNameType.Param, "fname")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* fname) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[18])(fname); + #else + return (void*)((delegate* unmanaged[Cdecl])funcTable[18])((nint)fname); + #endif + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alGetProcAddress")] + [return: NativeName(NativeNameType.Type, "void*")] + public static void* GetProcAddress([NativeName(NativeNameType.Param, "fname")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* fname) + { + void* ret = GetProcAddressNative(fname); + return ret; + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alGetProcAddress")] + [return: NativeName(NativeNameType.Type, "void*")] + public static void* GetProcAddress([NativeName(NativeNameType.Param, "fname")] [NativeName(NativeNameType.Type, "const ALchar*")] ref byte fname) + { + fixed (byte* pfname = &fname) + { + void* ret = GetProcAddressNative((byte*)pfname); + return ret; + } + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALenum")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int GetEnumValueNative([NativeName(NativeNameType.Param, "ename")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* ename) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[19])(ename); + #else + return (int)((delegate* unmanaged[Cdecl])funcTable[19])((nint)ename); + #endif + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALenum")] + public static int GetEnumValue([NativeName(NativeNameType.Param, "ename")] [NativeName(NativeNameType.Type, "const ALchar*")] byte* ename) + { + int ret = GetEnumValueNative(ename); + return ret; + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALenum")] + public static int GetEnumValue([NativeName(NativeNameType.Param, "ename")] [NativeName(NativeNameType.Type, "const ALchar*")] ref byte ename) + { + fixed (byte* pename = &ename) + { + int ret = GetEnumValueNative((byte*)pename); + return ret; + } + } + + /// + /// Set listener parameters.
+ /// + [NativeName(NativeNameType.Func, "alListenerf")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void ListenerfNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[20])(param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[20])(param, value); + #endif + } + + /// + /// Set listener parameters.
+ /// + [NativeName(NativeNameType.Func, "alListenerf")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listenerf([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + ListenerfNative(param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void Listener3FNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[21])(param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[21])(param, value1, value2, value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3) + { + Listener3FNative(param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListenerfv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void ListenerfvNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[22])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[22])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListenerfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listenerfv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values) + { + ListenerfvNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListenerfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listenerfv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] ref float values) + { + fixed (float* pvalues = &values) + { + ListenerfvNative(param, (float*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListeneri")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void ListeneriNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[23])(param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[23])(param, value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListeneri")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listeneri([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value) + { + ListeneriNative(param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void Listener3INative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[24])(param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[24])(param, value1, value2, value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3) + { + Listener3INative(param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListeneriv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void ListenerivNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[25])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[25])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListeneriv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listeneriv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values) + { + ListenerivNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alListeneriv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Listeneriv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] ref int values) + { + fixed (int* pvalues = &values) + { + ListenerivNative(param, (int*)pvalues); + } + } + + /// + /// Get listener parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetListenerf")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetListenerfNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[26])(param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[26])(param, (nint)value); + #endif + } + + /// + /// Get listener parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetListenerf")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListenerf([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value) + { + GetListenerfNative(param, value); + } + + /// + /// Get listener parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetListenerf")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListenerf([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value) + { + fixed (float* pvalue = &value) + { + GetListenerfNative(param, (float*)pvalue); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetListener3FNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[27])(param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[27])(param, (nint)value1, (nint)value2, (nint)value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + GetListener3FNative(param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue1 = &value1) + { + GetListener3FNative(param, (float*)pvalue1, value2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue2 = &value2) + { + GetListener3FNative(param, value1, (float*)pvalue2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue2 = &value2) + { + GetListener3FNative(param, (float*)pvalue1, (float*)pvalue2, value3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue3 = &value3) + { + GetListener3FNative(param, value1, value2, (float*)pvalue3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue3 = &value3) + { + GetListener3FNative(param, (float*)pvalue1, value2, (float*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue2 = &value2) + { + fixed (float* pvalue3 = &value3) + { + GetListener3FNative(param, value1, (float*)pvalue2, (float*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3F([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue2 = &value2) + { + fixed (float* pvalue3 = &value3) + { + GetListener3FNative(param, (float*)pvalue1, (float*)pvalue2, (float*)pvalue3); + } + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListenerfv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetListenerfvNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[28])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[28])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListenerfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListenerfv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + GetListenerfvNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListenerfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListenerfv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float values) + { + fixed (float* pvalues = &values) + { + GetListenerfvNative(param, (float*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListeneri")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetListeneriNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[29])(param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[29])(param, (nint)value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListeneri")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListeneri([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value) + { + GetListeneriNative(param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListeneri")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListeneri([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] ref int value) + { + fixed (int* pvalue = &value) + { + GetListeneriNative(param, (int*)pvalue); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetListener3INative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[30])(param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[30])(param, (nint)value1, (nint)value2, (nint)value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + GetListener3INative(param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue1 = &value1) + { + GetListener3INative(param, (int*)pvalue1, value2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue2 = &value2) + { + GetListener3INative(param, value1, (int*)pvalue2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue2 = &value2) + { + GetListener3INative(param, (int*)pvalue1, (int*)pvalue2, value3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue3 = &value3) + { + GetListener3INative(param, value1, value2, (int*)pvalue3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue3 = &value3) + { + GetListener3INative(param, (int*)pvalue1, value2, (int*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue2 = &value2) + { + fixed (int* pvalue3 = &value3) + { + GetListener3INative(param, value1, (int*)pvalue2, (int*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListener3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListener3I([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue2 = &value2) + { + fixed (int* pvalue3 = &value3) + { + GetListener3INative(param, (int*)pvalue1, (int*)pvalue2, (int*)pvalue3); + } + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListeneriv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetListenerivNative([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[31])(param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[31])(param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListeneriv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListeneriv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + GetListenerivNative(param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetListeneriv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetListeneriv([NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] ref int values) + { + fixed (int* pvalues = &values) + { + GetListenerivNative(param, (int*)pvalues); + } + } + + /// + /// Create source objects.
+ /// + [NativeName(NativeNameType.Func, "alGenSources")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GenSourcesNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "ALuint*")] uint* sources) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[32])(n, sources); + #else + ((delegate* unmanaged[Cdecl])funcTable[32])(n, (nint)sources); + #endif + } + + /// + /// Create source objects.
+ /// + [NativeName(NativeNameType.Func, "alGenSources")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GenSources([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "ALuint*")] uint* sources) + { + GenSourcesNative(n, sources); + } + + /// + /// Create source objects.
+ /// + [NativeName(NativeNameType.Func, "alGenSources")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GenSources([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "ALuint*")] ref uint sources) + { + fixed (uint* psources = &sources) + { + GenSourcesNative(n, (uint*)psources); + } + } + + /// + /// Delete source objects.
+ /// + [NativeName(NativeNameType.Func, "alDeleteSources")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void DeleteSourcesNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[33])(n, sources); + #else + ((delegate* unmanaged[Cdecl])funcTable[33])(n, (nint)sources); + #endif + } + + /// + /// Delete source objects.
+ /// + [NativeName(NativeNameType.Func, "alDeleteSources")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DeleteSources([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + DeleteSourcesNative(n, sources); + } + + /// + /// Delete source objects.
+ /// + [NativeName(NativeNameType.Func, "alDeleteSources")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DeleteSources([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] ref uint sources) + { + fixed (uint* psources = &sources) + { + DeleteSourcesNative(n, (uint*)psources); + } + } + + /// + /// Verify an ID is for a valid source.
+ /// + [NativeName(NativeNameType.Func, "alIsSource")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte IsSourceNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[34])(source); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[34])(source); + #endif + } + + /// + /// Verify an ID is for a valid source.
+ /// + [NativeName(NativeNameType.Func, "alIsSource")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + public static byte IsSource([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + byte ret = IsSourceNative(source); + return ret; + } + + /// + /// Set source parameters.
+ /// + [NativeName(NativeNameType.Func, "alSourcef")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourcefNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[35])(source, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[35])(source, param, value); + #endif + } + + /// + /// Set source parameters.
+ /// + [NativeName(NativeNameType.Func, "alSourcef")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Sourcef([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + SourcefNative(source, param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void Source3FNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[36])(source, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[36])(source, param, value1, value2, value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Source3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3) + { + Source3FNative(source, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourcefv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourcefvNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[37])(source, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[37])(source, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourcefv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Sourcefv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values) + { + SourcefvNative(source, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourcefv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Sourcefv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] ref float values) + { + fixed (float* pvalues = &values) + { + SourcefvNative(source, param, (float*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourcei")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceiNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[38])(source, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[38])(source, param, value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourcei")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Sourcei([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value) + { + SourceiNative(source, param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void Source3INative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[39])(source, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[39])(source, param, value1, value2, value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Source3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3) + { + Source3INative(source, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourceiv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceivNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[40])(source, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[40])(source, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourceiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Sourceiv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values) + { + SourceivNative(source, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alSourceiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Sourceiv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] ref int values) + { + fixed (int* pvalues = &values) + { + SourceivNative(source, param, (int*)pvalues); + } + } + + /// + /// Get source parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetSourcef")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetSourcefNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[41])(source, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[41])(source, param, (nint)value); + #endif + } + + /// + /// Get source parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetSourcef")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourcef([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value) + { + GetSourcefNative(source, param, value); + } + + /// + /// Get source parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetSourcef")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourcef([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value) + { + fixed (float* pvalue = &value) + { + GetSourcefNative(source, param, (float*)pvalue); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetSource3FNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[42])(source, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[42])(source, param, (nint)value1, (nint)value2, (nint)value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + GetSource3FNative(source, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue1 = &value1) + { + GetSource3FNative(source, param, (float*)pvalue1, value2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue2 = &value2) + { + GetSource3FNative(source, param, value1, (float*)pvalue2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue2 = &value2) + { + GetSource3FNative(source, param, (float*)pvalue1, (float*)pvalue2, value3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue3 = &value3) + { + GetSource3FNative(source, param, value1, value2, (float*)pvalue3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue3 = &value3) + { + GetSource3FNative(source, param, (float*)pvalue1, value2, (float*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue2 = &value2) + { + fixed (float* pvalue3 = &value3) + { + GetSource3FNative(source, param, value1, (float*)pvalue2, (float*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3F([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue2 = &value2) + { + fixed (float* pvalue3 = &value3) + { + GetSource3FNative(source, param, (float*)pvalue1, (float*)pvalue2, (float*)pvalue3); + } + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourcefv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetSourcefvNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[43])(source, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[43])(source, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourcefv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourcefv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + GetSourcefvNative(source, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourcefv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourcefv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float values) + { + fixed (float* pvalues = &values) + { + GetSourcefvNative(source, param, (float*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourcei")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetSourceiNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[44])(source, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[44])(source, param, (nint)value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourcei")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourcei([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value) + { + GetSourceiNative(source, param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourcei")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourcei([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] ref int value) + { + fixed (int* pvalue = &value) + { + GetSourceiNative(source, param, (int*)pvalue); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetSource3INative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[45])(source, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[45])(source, param, (nint)value1, (nint)value2, (nint)value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + GetSource3INative(source, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue1 = &value1) + { + GetSource3INative(source, param, (int*)pvalue1, value2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue2 = &value2) + { + GetSource3INative(source, param, value1, (int*)pvalue2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue2 = &value2) + { + GetSource3INative(source, param, (int*)pvalue1, (int*)pvalue2, value3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue3 = &value3) + { + GetSource3INative(source, param, value1, value2, (int*)pvalue3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue3 = &value3) + { + GetSource3INative(source, param, (int*)pvalue1, value2, (int*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue2 = &value2) + { + fixed (int* pvalue3 = &value3) + { + GetSource3INative(source, param, value1, (int*)pvalue2, (int*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSource3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSource3I([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue2 = &value2) + { + fixed (int* pvalue3 = &value3) + { + GetSource3INative(source, param, (int*)pvalue1, (int*)pvalue2, (int*)pvalue3); + } + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourceiv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetSourceivNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[46])(source, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[46])(source, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourceiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourceiv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + GetSourceivNative(source, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetSourceiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetSourceiv([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] ref int values) + { + fixed (int* pvalues = &values) + { + GetSourceivNative(source, param, (int*)pvalues); + } + } + + /// + /// Play, restart, or resume a source, setting its state to AL_PLAYING.
+ /// + [NativeName(NativeNameType.Func, "alSourcePlay")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourcePlayNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[47])(source); + #else + ((delegate* unmanaged[Cdecl])funcTable[47])(source); + #endif + } + + /// + /// Play, restart, or resume a source, setting its state to AL_PLAYING.
+ /// + [NativeName(NativeNameType.Func, "alSourcePlay")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourcePlay([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + SourcePlayNative(source); + } + + /// + /// Stop a source, setting its state to AL_STOPPED if playing or paused.
+ /// + [NativeName(NativeNameType.Func, "alSourceStop")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceStopNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[48])(source); + #else + ((delegate* unmanaged[Cdecl])funcTable[48])(source); + #endif + } + + /// + /// Stop a source, setting its state to AL_STOPPED if playing or paused.
+ /// + [NativeName(NativeNameType.Func, "alSourceStop")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceStop([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + SourceStopNative(source); + } + + /// + /// Rewind a source, setting its state to AL_INITIAL.
+ /// + [NativeName(NativeNameType.Func, "alSourceRewind")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceRewindNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[49])(source); + #else + ((delegate* unmanaged[Cdecl])funcTable[49])(source); + #endif + } + + /// + /// Rewind a source, setting its state to AL_INITIAL.
+ /// + [NativeName(NativeNameType.Func, "alSourceRewind")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceRewind([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + SourceRewindNative(source); + } + + /// + /// Pause a source, setting its state to AL_PAUSED if playing.
+ /// + [NativeName(NativeNameType.Func, "alSourcePause")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourcePauseNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[50])(source); + #else + ((delegate* unmanaged[Cdecl])funcTable[50])(source); + #endif + } + + /// + /// Pause a source, setting its state to AL_PAUSED if playing.
+ /// + [NativeName(NativeNameType.Func, "alSourcePause")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourcePause([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source) + { + SourcePauseNative(source); + } + + /// + /// Play, restart, or resume a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourcePlayv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourcePlayvNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[51])(n, sources); + #else + ((delegate* unmanaged[Cdecl])funcTable[51])(n, (nint)sources); + #endif + } + + /// + /// Play, restart, or resume a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourcePlayv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourcePlayv([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + SourcePlayvNative(n, sources); + } + + /// + /// Play, restart, or resume a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourcePlayv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourcePlayv([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] ref uint sources) + { + fixed (uint* psources = &sources) + { + SourcePlayvNative(n, (uint*)psources); + } + } + + /// + /// Stop a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourceStopv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceStopvNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[52])(n, sources); + #else + ((delegate* unmanaged[Cdecl])funcTable[52])(n, (nint)sources); + #endif + } + + /// + /// Stop a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourceStopv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceStopv([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + SourceStopvNative(n, sources); + } + + /// + /// Stop a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourceStopv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceStopv([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] ref uint sources) + { + fixed (uint* psources = &sources) + { + SourceStopvNative(n, (uint*)psources); + } + } + + /// + /// Rewind a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourceRewindv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceRewindvNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[53])(n, sources); + #else + ((delegate* unmanaged[Cdecl])funcTable[53])(n, (nint)sources); + #endif + } + + /// + /// Rewind a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourceRewindv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceRewindv([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + SourceRewindvNative(n, sources); + } + + /// + /// Rewind a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourceRewindv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceRewindv([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] ref uint sources) + { + fixed (uint* psources = &sources) + { + SourceRewindvNative(n, (uint*)psources); + } + } + + /// + /// Pause a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourcePausev")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourcePausevNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[54])(n, sources); + #else + ((delegate* unmanaged[Cdecl])funcTable[54])(n, (nint)sources); + #endif + } + + /// + /// Pause a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourcePausev")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourcePausev([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* sources) + { + SourcePausevNative(n, sources); + } + + /// + /// Pause a list of sources atomically.
+ /// + [NativeName(NativeNameType.Func, "alSourcePausev")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourcePausev([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "sources")] [NativeName(NativeNameType.Type, "const ALuint*")] ref uint sources) + { + fixed (uint* psources = &sources) + { + SourcePausevNative(n, (uint*)psources); + } + } + + /// + /// Queue buffers onto a source
+ /// + [NativeName(NativeNameType.Func, "alSourceQueueBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceQueueBuffersNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* buffers) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[55])(source, nb, buffers); + #else + ((delegate* unmanaged[Cdecl])funcTable[55])(source, nb, (nint)buffers); + #endif + } + + /// + /// Queue buffers onto a source
+ /// + [NativeName(NativeNameType.Func, "alSourceQueueBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceQueueBuffers([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* buffers) + { + SourceQueueBuffersNative(source, nb, buffers); + } + + /// + /// Queue buffers onto a source
+ /// + [NativeName(NativeNameType.Func, "alSourceQueueBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceQueueBuffers([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] ref uint buffers) + { + fixed (uint* pbuffers = &buffers) + { + SourceQueueBuffersNative(source, nb, (uint*)pbuffers); + } + } + + /// + /// Unqueue processed buffers from a source
+ /// + [NativeName(NativeNameType.Func, "alSourceUnqueueBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SourceUnqueueBuffersNative([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] uint* buffers) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[56])(source, nb, buffers); + #else + ((delegate* unmanaged[Cdecl])funcTable[56])(source, nb, (nint)buffers); + #endif + } + + /// + /// Unqueue processed buffers from a source
+ /// + [NativeName(NativeNameType.Func, "alSourceUnqueueBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceUnqueueBuffers([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] uint* buffers) + { + SourceUnqueueBuffersNative(source, nb, buffers); + } + + /// + /// Unqueue processed buffers from a source
+ /// + [NativeName(NativeNameType.Func, "alSourceUnqueueBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SourceUnqueueBuffers([NativeName(NativeNameType.Param, "source")] [NativeName(NativeNameType.Type, "ALuint")] uint source, [NativeName(NativeNameType.Param, "nb")] [NativeName(NativeNameType.Type, "ALsizei")] int nb, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] ref uint buffers) + { + fixed (uint* pbuffers = &buffers) + { + SourceUnqueueBuffersNative(source, nb, (uint*)pbuffers); + } + } + + /// + /// Create buffer objects
+ /// + [NativeName(NativeNameType.Func, "alGenBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GenBuffersNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] uint* buffers) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[57])(n, buffers); + #else + ((delegate* unmanaged[Cdecl])funcTable[57])(n, (nint)buffers); + #endif + } + + /// + /// Create buffer objects
+ /// + [NativeName(NativeNameType.Func, "alGenBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GenBuffers([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] uint* buffers) + { + GenBuffersNative(n, buffers); + } + + /// + /// Create buffer objects
+ /// + [NativeName(NativeNameType.Func, "alGenBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GenBuffers([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "ALuint*")] ref uint buffers) + { + fixed (uint* pbuffers = &buffers) + { + GenBuffersNative(n, (uint*)pbuffers); + } + } + + /// + /// Delete buffer objects
+ /// + [NativeName(NativeNameType.Func, "alDeleteBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void DeleteBuffersNative([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* buffers) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[58])(n, buffers); + #else + ((delegate* unmanaged[Cdecl])funcTable[58])(n, (nint)buffers); + #endif + } + + /// + /// Delete buffer objects
+ /// + [NativeName(NativeNameType.Func, "alDeleteBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DeleteBuffers([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] uint* buffers) + { + DeleteBuffersNative(n, buffers); + } + + /// + /// Delete buffer objects
+ /// + [NativeName(NativeNameType.Func, "alDeleteBuffers")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DeleteBuffers([NativeName(NativeNameType.Param, "n")] [NativeName(NativeNameType.Type, "ALsizei")] int n, [NativeName(NativeNameType.Param, "buffers")] [NativeName(NativeNameType.Type, "const ALuint*")] ref uint buffers) + { + fixed (uint* pbuffers = &buffers) + { + DeleteBuffersNative(n, (uint*)pbuffers); + } + } + + /// + /// Verify an ID is a valid buffer (including the NULL buffer)
+ /// + [NativeName(NativeNameType.Func, "alIsBuffer")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte IsBufferNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[59])(buffer); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[59])(buffer); + #endif + } + + /// + /// Verify an ID is a valid buffer (including the NULL buffer)
+ /// + [NativeName(NativeNameType.Func, "alIsBuffer")] + [return: NativeName(NativeNameType.Type, "ALboolean")] + public static byte IsBuffer([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer) + { + byte ret = IsBufferNative(buffer); + return ret; + } + + /// + /// Copies data into the buffer, interpreting it using the specified format and
+ /// samplerate.
+ /// + [NativeName(NativeNameType.Func, "alBufferData")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void BufferDataNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALenum")] int format, [NativeName(NativeNameType.Param, "data")] [NativeName(NativeNameType.Type, "const ALvoid*")] void* data, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALsizei")] int size, [NativeName(NativeNameType.Param, "samplerate")] [NativeName(NativeNameType.Type, "ALsizei")] int samplerate) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[60])(buffer, format, data, size, samplerate); + #else + ((delegate* unmanaged[Cdecl])funcTable[60])(buffer, format, (nint)data, size, samplerate); + #endif + } + + /// + /// Copies data into the buffer, interpreting it using the specified format and
+ /// samplerate.
+ /// + [NativeName(NativeNameType.Func, "alBufferData")] + [return: NativeName(NativeNameType.Type, "void")] + public static void BufferData([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALenum")] int format, [NativeName(NativeNameType.Param, "data")] [NativeName(NativeNameType.Type, "const ALvoid*")] void* data, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALsizei")] int size, [NativeName(NativeNameType.Param, "samplerate")] [NativeName(NativeNameType.Type, "ALsizei")] int samplerate) + { + BufferDataNative(buffer, format, data, size, samplerate); + } + + /// + /// Set buffer parameters.
+ /// + [NativeName(NativeNameType.Func, "alBufferf")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void BufferfNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[61])(buffer, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[61])(buffer, param, value); + #endif + } + + /// + /// Set buffer parameters.
+ /// + [NativeName(NativeNameType.Func, "alBufferf")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Bufferf([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat")] float value) + { + BufferfNative(buffer, param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void Buffer3FNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[62])(buffer, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[62])(buffer, param, value1, value2, value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Buffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat")] float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat")] float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat")] float value3) + { + Buffer3FNative(buffer, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferfv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void BufferfvNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[63])(buffer, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[63])(buffer, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Bufferfv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] float* values) + { + BufferfvNative(buffer, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Bufferfv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALfloat*")] ref float values) + { + fixed (float* pvalues = &values) + { + BufferfvNative(buffer, param, (float*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferi")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void BufferiNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[64])(buffer, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[64])(buffer, param, value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferi")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Bufferi([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint")] int value) + { + BufferiNative(buffer, param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void Buffer3INative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[65])(buffer, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[65])(buffer, param, value1, value2, value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Buffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint")] int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint")] int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint")] int value3) + { + Buffer3INative(buffer, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferiv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void BufferivNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[66])(buffer, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[66])(buffer, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Bufferiv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] int* values) + { + BufferivNative(buffer, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alBufferiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void Bufferiv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "const ALint*")] ref int values) + { + fixed (int* pvalues = &values) + { + BufferivNative(buffer, param, (int*)pvalues); + } + } + + /// + /// Get buffer parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetBufferf")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetBufferfNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[67])(buffer, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[67])(buffer, param, (nint)value); + #endif + } + + /// + /// Get buffer parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetBufferf")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferf([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value) + { + GetBufferfNative(buffer, param, value); + } + + /// + /// Get buffer parameters.
+ /// + [NativeName(NativeNameType.Func, "alGetBufferf")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferf([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value) + { + fixed (float* pvalue = &value) + { + GetBufferfNative(buffer, param, (float*)pvalue); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetBuffer3FNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[68])(buffer, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[68])(buffer, param, (nint)value1, (nint)value2, (nint)value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + GetBuffer3FNative(buffer, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue1 = &value1) + { + GetBuffer3FNative(buffer, param, (float*)pvalue1, value2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue2 = &value2) + { + GetBuffer3FNative(buffer, param, value1, (float*)pvalue2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue2 = &value2) + { + GetBuffer3FNative(buffer, param, (float*)pvalue1, (float*)pvalue2, value3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue3 = &value3) + { + GetBuffer3FNative(buffer, param, value1, value2, (float*)pvalue3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue3 = &value3) + { + GetBuffer3FNative(buffer, param, (float*)pvalue1, value2, (float*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] float* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue2 = &value2) + { + fixed (float* pvalue3 = &value3) + { + GetBuffer3FNative(buffer, param, value1, (float*)pvalue2, (float*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3f")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3F([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float value3) + { + fixed (float* pvalue1 = &value1) + { + fixed (float* pvalue2 = &value2) + { + fixed (float* pvalue3 = &value3) + { + GetBuffer3FNative(buffer, param, (float*)pvalue1, (float*)pvalue2, (float*)pvalue3); + } + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferfv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetBufferfvNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[69])(buffer, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[69])(buffer, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferfv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] float* values) + { + GetBufferfvNative(buffer, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferfv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferfv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALfloat*")] ref float values) + { + fixed (float* pvalues = &values) + { + GetBufferfvNative(buffer, param, (float*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferi")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetBufferiNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[70])(buffer, param, value); + #else + ((delegate* unmanaged[Cdecl])funcTable[70])(buffer, param, (nint)value); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferi")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferi([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] int* value) + { + GetBufferiNative(buffer, param, value); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferi")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferi([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value")] [NativeName(NativeNameType.Type, "ALint*")] ref int value) + { + fixed (int* pvalue = &value) + { + GetBufferiNative(buffer, param, (int*)pvalue); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetBuffer3INative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[71])(buffer, param, value1, value2, value3); + #else + ((delegate* unmanaged[Cdecl])funcTable[71])(buffer, param, (nint)value1, (nint)value2, (nint)value3); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + GetBuffer3INative(buffer, param, value1, value2, value3); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue1 = &value1) + { + GetBuffer3INative(buffer, param, (int*)pvalue1, value2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue2 = &value2) + { + GetBuffer3INative(buffer, param, value1, (int*)pvalue2, value3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] int* value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue2 = &value2) + { + GetBuffer3INative(buffer, param, (int*)pvalue1, (int*)pvalue2, value3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue3 = &value3) + { + GetBuffer3INative(buffer, param, value1, value2, (int*)pvalue3); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] int* value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue3 = &value3) + { + GetBuffer3INative(buffer, param, (int*)pvalue1, value2, (int*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] int* value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue2 = &value2) + { + fixed (int* pvalue3 = &value3) + { + GetBuffer3INative(buffer, param, value1, (int*)pvalue2, (int*)pvalue3); + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBuffer3i")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBuffer3I([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "value1")] [NativeName(NativeNameType.Type, "ALint*")] ref int value1, [NativeName(NativeNameType.Param, "value2")] [NativeName(NativeNameType.Type, "ALint*")] ref int value2, [NativeName(NativeNameType.Param, "value3")] [NativeName(NativeNameType.Type, "ALint*")] ref int value3) + { + fixed (int* pvalue1 = &value1) + { + fixed (int* pvalue2 = &value2) + { + fixed (int* pvalue3 = &value3) + { + GetBuffer3INative(buffer, param, (int*)pvalue1, (int*)pvalue2, (int*)pvalue3); + } + } + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferiv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetBufferivNative([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[72])(buffer, param, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[72])(buffer, param, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferiv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] int* values) + { + GetBufferivNative(buffer, param, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alGetBufferiv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetBufferiv([NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALuint")] uint buffer, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALenum")] int param, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALint*")] ref int values) + { + fixed (int* pvalues = &values) + { + GetBufferivNative(buffer, param, (int*)pvalues); + } + } + + /// + /// Create and attach a context to the given device.
+ /// + [NativeName(NativeNameType.Func, "alcCreateContext")] + [return: NativeName(NativeNameType.Type, "ALCcontext*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static ALCcontext* CreateContextNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "attrlist")] [NativeName(NativeNameType.Type, "const ALCint*")] int* attrlist) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[73])(device, attrlist); + #else + return (ALCcontext*)((delegate* unmanaged[Cdecl])funcTable[73])((nint)device, (nint)attrlist); + #endif + } + + /// + /// Create and attach a context to the given device.
+ /// + [NativeName(NativeNameType.Func, "alcCreateContext")] + [return: NativeName(NativeNameType.Type, "ALCcontext*")] + public static ALCcontext* CreateContext([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "attrlist")] [NativeName(NativeNameType.Type, "const ALCint*")] int* attrlist) + { + ALCcontext* ret = CreateContextNative(device, attrlist); + return ret; + } + + /// + /// Create and attach a context to the given device.
+ /// + [NativeName(NativeNameType.Func, "alcCreateContext")] + [return: NativeName(NativeNameType.Type, "ALCcontext*")] + public static ALCcontext* CreateContext([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "attrlist")] [NativeName(NativeNameType.Type, "const ALCint*")] int* attrlist) + { + fixed (ALCdevice* pdevice = &device) + { + ALCcontext* ret = CreateContextNative((ALCdevice*)pdevice, attrlist); + return ret; + } + } + + /// + /// Create and attach a context to the given device.
+ /// + [NativeName(NativeNameType.Func, "alcCreateContext")] + [return: NativeName(NativeNameType.Type, "ALCcontext*")] + public static ALCcontext* CreateContext([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "attrlist")] [NativeName(NativeNameType.Type, "const ALCint*")] ref int attrlist) + { + fixed (int* pattrlist = &attrlist) + { + ALCcontext* ret = CreateContextNative(device, (int*)pattrlist); + return ret; + } + } + + /// + /// Create and attach a context to the given device.
+ /// + [NativeName(NativeNameType.Func, "alcCreateContext")] + [return: NativeName(NativeNameType.Type, "ALCcontext*")] + public static ALCcontext* CreateContext([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "attrlist")] [NativeName(NativeNameType.Type, "const ALCint*")] ref int attrlist) + { + fixed (ALCdevice* pdevice = &device) + { + fixed (int* pattrlist = &attrlist) + { + ALCcontext* ret = CreateContextNative((ALCdevice*)pdevice, (int*)pattrlist); + return ret; + } + } + } + + /// + /// Makes the given context the active process-wide context. Passing NULL clears
+ /// the active context.
+ /// + [NativeName(NativeNameType.Func, "alcMakeContextCurrent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte MakeContextCurrentNative([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[74])(context); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[74])((nint)context); + #endif + } + + /// + /// Makes the given context the active process-wide context. Passing NULL clears
+ /// the active context.
+ /// + [NativeName(NativeNameType.Func, "alcMakeContextCurrent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte MakeContextCurrent([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + byte ret = MakeContextCurrentNative(context); + return ret; + } + + /// + /// Makes the given context the active process-wide context. Passing NULL clears
+ /// the active context.
+ /// + [NativeName(NativeNameType.Func, "alcMakeContextCurrent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte MakeContextCurrent([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ref ALCcontext context) + { + fixed (ALCcontext* pcontext = &context) + { + byte ret = MakeContextCurrentNative((ALCcontext*)pcontext); + return ret; + } + } + + /// + /// Resumes processing updates for the given context.
+ /// + [NativeName(NativeNameType.Func, "alcProcessContext")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void ProcessContextNative([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[75])(context); + #else + ((delegate* unmanaged[Cdecl])funcTable[75])((nint)context); + #endif + } + + /// + /// Resumes processing updates for the given context.
+ /// + [NativeName(NativeNameType.Func, "alcProcessContext")] + [return: NativeName(NativeNameType.Type, "void")] + public static void ProcessContext([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + ProcessContextNative(context); + } + + /// + /// Resumes processing updates for the given context.
+ /// + [NativeName(NativeNameType.Func, "alcProcessContext")] + [return: NativeName(NativeNameType.Type, "void")] + public static void ProcessContext([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ref ALCcontext context) + { + fixed (ALCcontext* pcontext = &context) + { + ProcessContextNative((ALCcontext*)pcontext); + } + } + + /// + /// Suspends updates for the given context.
+ /// + [NativeName(NativeNameType.Func, "alcSuspendContext")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void SuspendContextNative([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[76])(context); + #else + ((delegate* unmanaged[Cdecl])funcTable[76])((nint)context); + #endif + } + + /// + /// Suspends updates for the given context.
+ /// + [NativeName(NativeNameType.Func, "alcSuspendContext")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SuspendContext([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + SuspendContextNative(context); + } + + /// + /// Suspends updates for the given context.
+ /// + [NativeName(NativeNameType.Func, "alcSuspendContext")] + [return: NativeName(NativeNameType.Type, "void")] + public static void SuspendContext([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ref ALCcontext context) + { + fixed (ALCcontext* pcontext = &context) + { + SuspendContextNative((ALCcontext*)pcontext); + } + } + + /// + /// Remove a context from its device and destroys it.
+ /// + [NativeName(NativeNameType.Func, "alcDestroyContext")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void DestroyContextNative([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[77])(context); + #else + ((delegate* unmanaged[Cdecl])funcTable[77])((nint)context); + #endif + } + + /// + /// Remove a context from its device and destroys it.
+ /// + [NativeName(NativeNameType.Func, "alcDestroyContext")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DestroyContext([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + DestroyContextNative(context); + } + + /// + /// Remove a context from its device and destroys it.
+ /// + [NativeName(NativeNameType.Func, "alcDestroyContext")] + [return: NativeName(NativeNameType.Type, "void")] + public static void DestroyContext([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ref ALCcontext context) + { + fixed (ALCcontext* pcontext = &context) + { + DestroyContextNative((ALCcontext*)pcontext); + } + } + + /// + /// Returns the currently active context.
+ /// + [NativeName(NativeNameType.Func, "alcGetCurrentContext")] + [return: NativeName(NativeNameType.Type, "ALCcontext*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static ALCcontext* GetCurrentContextNative() + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[78])(); + #else + return (ALCcontext*)((delegate* unmanaged[Cdecl])funcTable[78])(); + #endif + } + + /// + /// Returns the currently active context.
+ /// + [NativeName(NativeNameType.Func, "alcGetCurrentContext")] + [return: NativeName(NativeNameType.Type, "ALCcontext*")] + public static ALCcontext* GetCurrentContext() + { + ALCcontext* ret = GetCurrentContextNative(); + return ret; + } + + /// + /// Returns the device that a particular context is attached to.
+ /// + [NativeName(NativeNameType.Func, "alcGetContextsDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static ALCdevice* GetContextsDeviceNative([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[79])(context); + #else + return (ALCdevice*)((delegate* unmanaged[Cdecl])funcTable[79])((nint)context); + #endif + } + + /// + /// Returns the device that a particular context is attached to.
+ /// + [NativeName(NativeNameType.Func, "alcGetContextsDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + public static ALCdevice* GetContextsDevice([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ALCcontext* context) + { + ALCdevice* ret = GetContextsDeviceNative(context); + return ret; + } + + /// + /// Returns the device that a particular context is attached to.
+ /// + [NativeName(NativeNameType.Func, "alcGetContextsDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + public static ALCdevice* GetContextsDevice([NativeName(NativeNameType.Param, "context")] [NativeName(NativeNameType.Type, "ALCcontext*")] ref ALCcontext context) + { + fixed (ALCcontext* pcontext = &context) + { + ALCdevice* ret = GetContextsDeviceNative((ALCcontext*)pcontext); + return ret; + } + } + + /// + /// Opens the named playback device.
+ /// + [NativeName(NativeNameType.Func, "alcOpenDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static ALCdevice* OpenDeviceNative([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* devicename) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[80])(devicename); + #else + return (ALCdevice*)((delegate* unmanaged[Cdecl])funcTable[80])((nint)devicename); + #endif + } + + /// + /// Opens the named playback device.
+ /// + [NativeName(NativeNameType.Func, "alcOpenDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + public static ALCdevice* OpenDevice([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* devicename) + { + ALCdevice* ret = OpenDeviceNative(devicename); + return ret; + } + + /// + /// Opens the named playback device.
+ /// + [NativeName(NativeNameType.Func, "alcOpenDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + public static ALCdevice* OpenDevice([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte devicename) + { + fixed (byte* pdevicename = &devicename) + { + ALCdevice* ret = OpenDeviceNative((byte*)pdevicename); + return ret; + } + } + + /// + /// Closes the given playback device.
+ /// + [NativeName(NativeNameType.Func, "alcCloseDevice")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte CloseDeviceNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[81])(device); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[81])((nint)device); + #endif + } + + /// + /// Closes the given playback device.
+ /// + [NativeName(NativeNameType.Func, "alcCloseDevice")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte CloseDevice([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + byte ret = CloseDeviceNative(device); + return ret; + } + + /// + /// Closes the given playback device.
+ /// + [NativeName(NativeNameType.Func, "alcCloseDevice")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte CloseDevice([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device) + { + fixed (ALCdevice* pdevice = &device) + { + byte ret = CloseDeviceNative((ALCdevice*)pdevice); + return ret; + } + } + + /// + /// Obtain the first error generated in the AL context since the last call to
+ /// this function.
+ /// + [NativeName(NativeNameType.Func, "alcGetError")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int GetErrorNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[82])(device); + #else + return (int)((delegate* unmanaged[Cdecl])funcTable[82])((nint)device); + #endif + } + + /// + /// Obtain the first error generated in the AL context since the last call to
+ /// this function.
+ /// + [NativeName(NativeNameType.Func, "alcGetError")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + public static int GetError([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + int ret = GetErrorNative(device); + return ret; + } + + /// + /// Obtain the first error generated in the AL context since the last call to
+ /// this function.
+ /// + [NativeName(NativeNameType.Func, "alcGetError")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + public static int GetError([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device) + { + fixed (ALCdevice* pdevice = &device) + { + int ret = GetErrorNative((ALCdevice*)pdevice); + return ret; + } + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alcIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte IsExtensionPresentNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* extname) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[83])(device, extname); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[83])((nint)device, (nint)extname); + #endif + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alcIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte IsExtensionPresent([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* extname) + { + byte ret = IsExtensionPresentNative(device, extname); + return ret; + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alcIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte IsExtensionPresent([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* extname) + { + fixed (ALCdevice* pdevice = &device) + { + byte ret = IsExtensionPresentNative((ALCdevice*)pdevice, extname); + return ret; + } + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alcIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte IsExtensionPresent([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte extname) + { + fixed (byte* pextname = &extname) + { + byte ret = IsExtensionPresentNative(device, (byte*)pextname); + return ret; + } + } + + /// + /// Query for the presence of an extension on the AL context.
+ /// + [NativeName(NativeNameType.Func, "alcIsExtensionPresent")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte IsExtensionPresent([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "extname")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte extname) + { + fixed (ALCdevice* pdevice = &device) + { + fixed (byte* pextname = &extname) + { + byte ret = IsExtensionPresentNative((ALCdevice*)pdevice, (byte*)pextname); + return ret; + } + } + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetProcAddress")] + [return: NativeName(NativeNameType.Type, "ALCvoid*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void* GetProcAddressNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "funcname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* funcname) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[84])(device, funcname); + #else + return (void*)((delegate* unmanaged[Cdecl])funcTable[84])((nint)device, (nint)funcname); + #endif + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetProcAddress")] + [return: NativeName(NativeNameType.Type, "ALCvoid*")] + public static void* GetProcAddress([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "funcname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* funcname) + { + void* ret = GetProcAddressNative(device, funcname); + return ret; + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetProcAddress")] + [return: NativeName(NativeNameType.Type, "ALCvoid*")] + public static void* GetProcAddress([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "funcname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* funcname) + { + fixed (ALCdevice* pdevice = &device) + { + void* ret = GetProcAddressNative((ALCdevice*)pdevice, funcname); + return ret; + } + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetProcAddress")] + [return: NativeName(NativeNameType.Type, "ALCvoid*")] + public static void* GetProcAddress([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "funcname")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte funcname) + { + fixed (byte* pfuncname = &funcname) + { + void* ret = GetProcAddressNative(device, (byte*)pfuncname); + return ret; + } + } + + /// + /// Retrieve the address of a function. The returned function may be context-
+ /// specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetProcAddress")] + [return: NativeName(NativeNameType.Type, "ALCvoid*")] + public static void* GetProcAddress([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "funcname")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte funcname) + { + fixed (ALCdevice* pdevice = &device) + { + fixed (byte* pfuncname = &funcname) + { + void* ret = GetProcAddressNative((ALCdevice*)pdevice, (byte*)pfuncname); + return ret; + } + } + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static int GetEnumValueNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "enumname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* enumname) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[85])(device, enumname); + #else + return (int)((delegate* unmanaged[Cdecl])funcTable[85])((nint)device, (nint)enumname); + #endif + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + public static int GetEnumValue([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "enumname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* enumname) + { + int ret = GetEnumValueNative(device, enumname); + return ret; + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + public static int GetEnumValue([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "enumname")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* enumname) + { + fixed (ALCdevice* pdevice = &device) + { + int ret = GetEnumValueNative((ALCdevice*)pdevice, enumname); + return ret; + } + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + public static int GetEnumValue([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "enumname")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte enumname) + { + fixed (byte* penumname = &enumname) + { + int ret = GetEnumValueNative(device, (byte*)penumname); + return ret; + } + } + + /// + /// Retrieve the value of an enum. The returned value may be context-specific.
+ /// + [NativeName(NativeNameType.Func, "alcGetEnumValue")] + [return: NativeName(NativeNameType.Type, "ALCenum")] + public static int GetEnumValue([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "enumname")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte enumname) + { + fixed (ALCdevice* pdevice = &device) + { + fixed (byte* penumname = &enumname) + { + int ret = GetEnumValueNative((ALCdevice*)pdevice, (byte*)penumname); + return ret; + } + } + } + + /// + /// Context state retrieval.
+ /// + [NativeName(NativeNameType.Func, "alcGetString")] + [return: NativeName(NativeNameType.Type, "const ALCchar*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte* GetStringNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[86])(device, param); + #else + return (byte*)((delegate* unmanaged[Cdecl])funcTable[86])((nint)device, param); + #endif + } + + /// + /// Context state retrieval.
+ /// + [NativeName(NativeNameType.Func, "alcGetString")] + [return: NativeName(NativeNameType.Type, "const ALCchar*")] + public static byte* GetString([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param) + { + byte* ret = GetStringNative(device, param); + return ret; + } + + /// + /// Context state retrieval.
+ /// + [NativeName(NativeNameType.Func, "alcGetString")] + [return: NativeName(NativeNameType.Type, "const ALCchar*")] + public static byte* GetString([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param) + { + fixed (ALCdevice* pdevice = &device) + { + byte* ret = GetStringNative((ALCdevice*)pdevice, param); + return ret; + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alcGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void GetIntegervNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALCsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint*")] int* values) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[87])(device, param, size, values); + #else + ((delegate* unmanaged[Cdecl])funcTable[87])((nint)device, param, size, (nint)values); + #endif + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alcGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetIntegerv([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALCsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint*")] int* values) + { + GetIntegervNative(device, param, size, values); + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alcGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetIntegerv([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALCsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint*")] int* values) + { + fixed (ALCdevice* pdevice = &device) + { + GetIntegervNative((ALCdevice*)pdevice, param, size, values); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alcGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetIntegerv([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALCsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint*")] ref int values) + { + fixed (int* pvalues = &values) + { + GetIntegervNative(device, param, size, (int*)pvalues); + } + } + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Func, "alcGetIntegerv")] + [return: NativeName(NativeNameType.Type, "void")] + public static void GetIntegerv([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "param")] [NativeName(NativeNameType.Type, "ALCenum")] int param, [NativeName(NativeNameType.Param, "size")] [NativeName(NativeNameType.Type, "ALCsizei")] int size, [NativeName(NativeNameType.Param, "values")] [NativeName(NativeNameType.Type, "ALCint*")] ref int values) + { + fixed (ALCdevice* pdevice = &device) + { + fixed (int* pvalues = &values) + { + GetIntegervNative((ALCdevice*)pdevice, param, size, (int*)pvalues); + } + } + } + + /// + /// Opens the named capture device with the given frequency, format, and buffer
+ /// size.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureOpenDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static ALCdevice* CaptureOpenDeviceNative([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* devicename, [NativeName(NativeNameType.Param, "frequency")] [NativeName(NativeNameType.Type, "ALCuint")] uint frequency, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALCenum")] int format, [NativeName(NativeNameType.Param, "buffersize")] [NativeName(NativeNameType.Type, "ALCsizei")] int buffersize) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[88])(devicename, frequency, format, buffersize); + #else + return (ALCdevice*)((delegate* unmanaged[Cdecl])funcTable[88])((nint)devicename, frequency, format, buffersize); + #endif + } + + /// + /// Opens the named capture device with the given frequency, format, and buffer
+ /// size.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureOpenDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + public static ALCdevice* CaptureOpenDevice([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] byte* devicename, [NativeName(NativeNameType.Param, "frequency")] [NativeName(NativeNameType.Type, "ALCuint")] uint frequency, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALCenum")] int format, [NativeName(NativeNameType.Param, "buffersize")] [NativeName(NativeNameType.Type, "ALCsizei")] int buffersize) + { + ALCdevice* ret = CaptureOpenDeviceNative(devicename, frequency, format, buffersize); + return ret; + } + + /// + /// Opens the named capture device with the given frequency, format, and buffer
+ /// size.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureOpenDevice")] + [return: NativeName(NativeNameType.Type, "ALCdevice*")] + public static ALCdevice* CaptureOpenDevice([NativeName(NativeNameType.Param, "devicename")] [NativeName(NativeNameType.Type, "const ALCchar*")] ref byte devicename, [NativeName(NativeNameType.Param, "frequency")] [NativeName(NativeNameType.Type, "ALCuint")] uint frequency, [NativeName(NativeNameType.Param, "format")] [NativeName(NativeNameType.Type, "ALCenum")] int format, [NativeName(NativeNameType.Param, "buffersize")] [NativeName(NativeNameType.Type, "ALCsizei")] int buffersize) + { + fixed (byte* pdevicename = &devicename) + { + ALCdevice* ret = CaptureOpenDeviceNative((byte*)pdevicename, frequency, format, buffersize); + return ret; + } + } + + /// + /// Closes the given capture device.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureCloseDevice")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static byte CaptureCloseDeviceNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + #if NET5_0_OR_GREATER + return ((delegate* unmanaged[Cdecl])funcTable[89])(device); + #else + return (byte)((delegate* unmanaged[Cdecl])funcTable[89])((nint)device); + #endif + } + + /// + /// Closes the given capture device.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureCloseDevice")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte CaptureCloseDevice([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + byte ret = CaptureCloseDeviceNative(device); + return ret; + } + + /// + /// Closes the given capture device.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureCloseDevice")] + [return: NativeName(NativeNameType.Type, "ALCboolean")] + public static byte CaptureCloseDevice([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device) + { + fixed (ALCdevice* pdevice = &device) + { + byte ret = CaptureCloseDeviceNative((ALCdevice*)pdevice); + return ret; + } + } + + /// + /// Starts capturing samples into the device buffer.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureStart")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void CaptureStartNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[90])(device); + #else + ((delegate* unmanaged[Cdecl])funcTable[90])((nint)device); + #endif + } + + /// + /// Starts capturing samples into the device buffer.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureStart")] + [return: NativeName(NativeNameType.Type, "void")] + public static void CaptureStart([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + CaptureStartNative(device); + } + + /// + /// Starts capturing samples into the device buffer.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureStart")] + [return: NativeName(NativeNameType.Type, "void")] + public static void CaptureStart([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device) + { + fixed (ALCdevice* pdevice = &device) + { + CaptureStartNative((ALCdevice*)pdevice); + } + } + + /// + /// Stops capturing samples. Samples in the device buffer remain available.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureStop")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void CaptureStopNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[91])(device); + #else + ((delegate* unmanaged[Cdecl])funcTable[91])((nint)device); + #endif + } + + /// + /// Stops capturing samples. Samples in the device buffer remain available.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureStop")] + [return: NativeName(NativeNameType.Type, "void")] + public static void CaptureStop([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device) + { + CaptureStopNative(device); + } + + /// + /// Stops capturing samples. Samples in the device buffer remain available.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureStop")] + [return: NativeName(NativeNameType.Type, "void")] + public static void CaptureStop([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device) + { + fixed (ALCdevice* pdevice = &device) + { + CaptureStopNative((ALCdevice*)pdevice); + } + } + + /// + /// Reads samples from the device buffer.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureSamples")] + [return: NativeName(NativeNameType.Type, "void")] + [MethodImpl(MethodImplOptions.AggressiveInlining)] + internal static void CaptureSamplesNative([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALCvoid*")] void* buffer, [NativeName(NativeNameType.Param, "samples")] [NativeName(NativeNameType.Type, "ALCsizei")] int samples) + { + #if NET5_0_OR_GREATER + ((delegate* unmanaged[Cdecl])funcTable[92])(device, buffer, samples); + #else + ((delegate* unmanaged[Cdecl])funcTable[92])((nint)device, (nint)buffer, samples); + #endif + } + + /// + /// Reads samples from the device buffer.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureSamples")] + [return: NativeName(NativeNameType.Type, "void")] + public static void CaptureSamples([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ALCdevice* device, [NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALCvoid*")] void* buffer, [NativeName(NativeNameType.Param, "samples")] [NativeName(NativeNameType.Type, "ALCsizei")] int samples) + { + CaptureSamplesNative(device, buffer, samples); + } + + /// + /// Reads samples from the device buffer.
+ /// + [NativeName(NativeNameType.Func, "alcCaptureSamples")] + [return: NativeName(NativeNameType.Type, "void")] + public static void CaptureSamples([NativeName(NativeNameType.Param, "device")] [NativeName(NativeNameType.Type, "ALCdevice*")] ref ALCdevice device, [NativeName(NativeNameType.Param, "buffer")] [NativeName(NativeNameType.Type, "ALCvoid*")] void* buffer, [NativeName(NativeNameType.Param, "samples")] [NativeName(NativeNameType.Type, "ALCsizei")] int samples) + { + fixed (ALCdevice* pdevice = &device) + { + CaptureSamplesNative((ALCdevice*)pdevice, buffer, samples); + } + } + + } +} diff --git a/Hexa.NET.OpenAL/Generated/Handles/LPEFXEAXReverbProperties.cs b/Hexa.NET.OpenAL/Generated/Handles/LPEFXEAXReverbProperties.cs new file mode 100644 index 0000000..b9cf135 --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Handles/LPEFXEAXReverbProperties.cs @@ -0,0 +1,44 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + /// + /// To be documented. + /// + [NativeName(NativeNameType.Typedef, "LPEFXEAXREVERBPROPERTIES")] + #if NET5_0_OR_GREATER + [DebuggerDisplay("{DebuggerDisplay,nq}")] + #endif + public readonly partial struct LPEFXEAXReverbProperties : IEquatable + { + public LPEFXEAXReverbProperties(nint handle) { Handle = handle; } + public nint Handle { get; } + public bool IsNull => Handle == 0; + public static LPEFXEAXReverbProperties Null => new LPEFXEAXReverbProperties(0); + public static implicit operator LPEFXEAXReverbProperties(nint handle) => new LPEFXEAXReverbProperties(handle); + public static bool operator ==(LPEFXEAXReverbProperties left, LPEFXEAXReverbProperties right) => left.Handle == right.Handle; + public static bool operator !=(LPEFXEAXReverbProperties left, LPEFXEAXReverbProperties right) => left.Handle != right.Handle; + public static bool operator ==(LPEFXEAXReverbProperties left, nint right) => left.Handle == right; + public static bool operator !=(LPEFXEAXReverbProperties left, nint right) => left.Handle != right; + public bool Equals(LPEFXEAXReverbProperties other) => Handle == other.Handle; + /// + public override bool Equals(object obj) => obj is LPEFXEAXReverbProperties handle && Equals(handle); + /// + public override int GetHashCode() => Handle.GetHashCode(); + #if NET5_0_OR_GREATER + private string DebuggerDisplay => string.Format("LPEFXEAXReverbProperties [0x{0}]", Handle.ToString("X")); + #endif + } +} diff --git a/Hexa.NET.OpenAL/Generated/Structs/ALCcontext.cs b/Hexa.NET.OpenAL/Generated/Structs/ALCcontext.cs new file mode 100644 index 0000000..793ded4 --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Structs/ALCcontext.cs @@ -0,0 +1,29 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + /// + /// Opaque context handle
+ /// + [NativeName(NativeNameType.StructOrClass, "ALCcontext")] + [StructLayout(LayoutKind.Sequential)] + public partial struct ALCcontext + { + + + } + +} diff --git a/Hexa.NET.OpenAL/Generated/Structs/ALCdevice.cs b/Hexa.NET.OpenAL/Generated/Structs/ALCdevice.cs new file mode 100644 index 0000000..9ef5ee3 --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Structs/ALCdevice.cs @@ -0,0 +1,29 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + /// + /// Opaque device handle
+ /// + [NativeName(NativeNameType.StructOrClass, "ALCdevice")] + [StructLayout(LayoutKind.Sequential)] + public partial struct ALCdevice + { + + + } + +} diff --git a/Hexa.NET.OpenAL/Generated/Structs/EFXEAXReverbProperties.cs b/Hexa.NET.OpenAL/Generated/Structs/EFXEAXReverbProperties.cs new file mode 100644 index 0000000..d82fd2a --- /dev/null +++ b/Hexa.NET.OpenAL/Generated/Structs/EFXEAXReverbProperties.cs @@ -0,0 +1,274 @@ +// ------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +// ------------------------------------------------------------------------------ + +using System; +using System.Diagnostics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using HexaGen.Runtime; + +namespace Hexa.NET.OpenAL +{ + /// + /// To be documented. + /// + [NativeName(NativeNameType.StructOrClass, "EFXEAXREVERBPROPERTIES")] + [StructLayout(LayoutKind.Sequential)] + public partial struct EFXEAXReverbProperties + { + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flDensity")] + [NativeName(NativeNameType.Type, "float")] + public float FlDensity; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flDiffusion")] + [NativeName(NativeNameType.Type, "float")] + public float FlDiffusion; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flGain")] + [NativeName(NativeNameType.Type, "float")] + public float FlGain; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flGainHF")] + [NativeName(NativeNameType.Type, "float")] + public float FlGainHF; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flGainLF")] + [NativeName(NativeNameType.Type, "float")] + public float FlGainLF; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flDecayTime")] + [NativeName(NativeNameType.Type, "float")] + public float FlDecayTime; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flDecayHFRatio")] + [NativeName(NativeNameType.Type, "float")] + public float FlDecayHFRatio; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flDecayLFRatio")] + [NativeName(NativeNameType.Type, "float")] + public float FlDecayLFRatio; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flReflectionsGain")] + [NativeName(NativeNameType.Type, "float")] + public float FlReflectionsGain; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flReflectionsDelay")] + [NativeName(NativeNameType.Type, "float")] + public float FlReflectionsDelay; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flReflectionsPan")] + [NativeName(NativeNameType.Type, "float[3]")] + public float FlReflectionsPan_0; + public float FlReflectionsPan_1; + public float FlReflectionsPan_2; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flLateReverbGain")] + [NativeName(NativeNameType.Type, "float")] + public float FlLateReverbGain; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flLateReverbDelay")] + [NativeName(NativeNameType.Type, "float")] + public float FlLateReverbDelay; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flLateReverbPan")] + [NativeName(NativeNameType.Type, "float[3]")] + public float FlLateReverbPan_0; + public float FlLateReverbPan_1; + public float FlLateReverbPan_2; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flEchoTime")] + [NativeName(NativeNameType.Type, "float")] + public float FlEchoTime; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flEchoDepth")] + [NativeName(NativeNameType.Type, "float")] + public float FlEchoDepth; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flModulationTime")] + [NativeName(NativeNameType.Type, "float")] + public float FlModulationTime; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flModulationDepth")] + [NativeName(NativeNameType.Type, "float")] + public float FlModulationDepth; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flAirAbsorptionGainHF")] + [NativeName(NativeNameType.Type, "float")] + public float FlAirAbsorptionGainHF; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flHFReference")] + [NativeName(NativeNameType.Type, "float")] + public float FlHFReference; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flLFReference")] + [NativeName(NativeNameType.Type, "float")] + public float FlLFReference; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "flRoomRolloffFactor")] + [NativeName(NativeNameType.Type, "float")] + public float FlRoomRolloffFactor; + + /// + /// To be documented. + /// + [NativeName(NativeNameType.Field, "iDecayHFLimit")] + [NativeName(NativeNameType.Type, "int")] + public int IDecayHFLimit; + + + /// + /// To be documented. + /// + public unsafe EFXEAXReverbProperties(float flDensity = default, float flDiffusion = default, float flGain = default, float flGainHF = default, float flGainLF = default, float flDecayTime = default, float flDecayHFRatio = default, float flDecayLFRatio = default, float flReflectionsGain = default, float flReflectionsDelay = default, float* flReflectionsPan = default, float flLateReverbGain = default, float flLateReverbDelay = default, float* flLateReverbPan = default, float flEchoTime = default, float flEchoDepth = default, float flModulationTime = default, float flModulationDepth = default, float flAirAbsorptionGainHF = default, float flHFReference = default, float flLFReference = default, float flRoomRolloffFactor = default, int iDecayHFLimit = default) + { + FlDensity = flDensity; + FlDiffusion = flDiffusion; + FlGain = flGain; + FlGainHF = flGainHF; + FlGainLF = flGainLF; + FlDecayTime = flDecayTime; + FlDecayHFRatio = flDecayHFRatio; + FlDecayLFRatio = flDecayLFRatio; + FlReflectionsGain = flReflectionsGain; + FlReflectionsDelay = flReflectionsDelay; + if (flReflectionsPan != default(float*)) + { + FlReflectionsPan_0 = flReflectionsPan[0]; + FlReflectionsPan_1 = flReflectionsPan[1]; + FlReflectionsPan_2 = flReflectionsPan[2]; + } + FlLateReverbGain = flLateReverbGain; + FlLateReverbDelay = flLateReverbDelay; + if (flLateReverbPan != default(float*)) + { + FlLateReverbPan_0 = flLateReverbPan[0]; + FlLateReverbPan_1 = flLateReverbPan[1]; + FlLateReverbPan_2 = flLateReverbPan[2]; + } + FlEchoTime = flEchoTime; + FlEchoDepth = flEchoDepth; + FlModulationTime = flModulationTime; + FlModulationDepth = flModulationDepth; + FlAirAbsorptionGainHF = flAirAbsorptionGainHF; + FlHFReference = flHFReference; + FlLFReference = flLFReference; + FlRoomRolloffFactor = flRoomRolloffFactor; + IDecayHFLimit = iDecayHFLimit; + } + + /// + /// To be documented. + /// + public unsafe EFXEAXReverbProperties(float flDensity = default, float flDiffusion = default, float flGain = default, float flGainHF = default, float flGainLF = default, float flDecayTime = default, float flDecayHFRatio = default, float flDecayLFRatio = default, float flReflectionsGain = default, float flReflectionsDelay = default, Span flReflectionsPan = default, float flLateReverbGain = default, float flLateReverbDelay = default, Span flLateReverbPan = default, float flEchoTime = default, float flEchoDepth = default, float flModulationTime = default, float flModulationDepth = default, float flAirAbsorptionGainHF = default, float flHFReference = default, float flLFReference = default, float flRoomRolloffFactor = default, int iDecayHFLimit = default) + { + FlDensity = flDensity; + FlDiffusion = flDiffusion; + FlGain = flGain; + FlGainHF = flGainHF; + FlGainLF = flGainLF; + FlDecayTime = flDecayTime; + FlDecayHFRatio = flDecayHFRatio; + FlDecayLFRatio = flDecayLFRatio; + FlReflectionsGain = flReflectionsGain; + FlReflectionsDelay = flReflectionsDelay; + if (flReflectionsPan != default(Span)) + { + FlReflectionsPan_0 = flReflectionsPan[0]; + FlReflectionsPan_1 = flReflectionsPan[1]; + FlReflectionsPan_2 = flReflectionsPan[2]; + } + FlLateReverbGain = flLateReverbGain; + FlLateReverbDelay = flLateReverbDelay; + if (flLateReverbPan != default(Span)) + { + FlLateReverbPan_0 = flLateReverbPan[0]; + FlLateReverbPan_1 = flLateReverbPan[1]; + FlLateReverbPan_2 = flLateReverbPan[2]; + } + FlEchoTime = flEchoTime; + FlEchoDepth = flEchoDepth; + FlModulationTime = flModulationTime; + FlModulationDepth = flModulationDepth; + FlAirAbsorptionGainHF = flAirAbsorptionGainHF; + FlHFReference = flHFReference; + FlLFReference = flLFReference; + FlRoomRolloffFactor = flRoomRolloffFactor; + IDecayHFLimit = iDecayHFLimit; + } + + + } + +} diff --git a/Hexa.NET.OpenAL/Hexa.NET.OpenAL.csproj b/Hexa.NET.OpenAL/Hexa.NET.OpenAL.csproj new file mode 100644 index 0000000..835491f --- /dev/null +++ b/Hexa.NET.OpenAL/Hexa.NET.OpenAL.csproj @@ -0,0 +1,14 @@ + + + + net8.0 + enable + enable + true + + + + + + + diff --git a/Hexa.NET.OpenAL/OpenAL.cs b/Hexa.NET.OpenAL/OpenAL.cs new file mode 100644 index 0000000..e73fc19 --- /dev/null +++ b/Hexa.NET.OpenAL/OpenAL.cs @@ -0,0 +1,21 @@ +namespace Hexa.NET.OpenAL +{ + using System.Runtime.InteropServices; + + public static partial class OpenAL + { + static OpenAL() + { + InitApi(); + } + + public static string GetLibraryName() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + return "OpenAL32"; + } + return "libopenal"; + } + } +} \ No newline at end of file diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..b5dae7a --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Juna Meinhold + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..5759de5 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +A .NET Wrapper for OpenAL (v 1.23.1) \ No newline at end of file