ryujinx/Opentk
1
0
Fork 0
mirror of https://github.com/Ryujinx/Opentk.git synced 2025-01-27 10:51:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

v0.8 EFX largely done, public Filter/Auxiliary methods missing.

Browse source
This commit is contained in:
chrisbrandtner 2008-01-18 13:32:51 +00:00
parent 5b74d9e227
commit a4a8fb0f99
9 changed files with 1151 additions and 1135 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

358
Source/OpenTK/OpenAL/AlFunctions.cs
View file

@ -66,7 +66,7 @@ typedef void ALvoid;
namespace OpenTK.OpenAL namespace OpenTK.OpenAL
{ {
// Al = Audio Library // AL = Audio Library
public static class AL public static class AL
{ {
#region Constants #region Constants
@ -87,35 +87,35 @@ namespace OpenTK.OpenAL
/// <summary>This function enables a feature of the OpenAL driver. There are no capabilities defined in OpenAL 1.1 to be used with this function, but it may be used by an extension.</summary> /// <summary>This function enables a feature of the OpenAL driver. There are no capabilities defined in OpenAL 1.1 to be used with this function, but it may be used by an extension.</summary>
/// <param name="capability">The name of a capability to enable.</param> /// <param name="capability">The name of a capability to enable.</param>
[DllImport(AL.Lib, EntryPoint = "alEnable", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alEnable",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Enable(Enums.ALCapability capability); public static extern void Enable( Enums.ALCapability capability );
//AL_API void AL_APIENTRY alEnable( ALenum capability ); //AL_API void AL_APIENTRY alEnable( ALenum capability );
/// <summary>This function disables a feature of the OpenAL driver.</summary> /// <summary>This function disables a feature of the OpenAL driver.</summary>
/// <param name="capability">The name of a capability to disable.</param> /// <param name="capability">The name of a capability to disable.</param>
[DllImport(AL.Lib, EntryPoint = "alDisable", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alDisable",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Disable(Enums.ALCapability capability); public static extern void Disable( Enums.ALCapability capability );
// AL_API void AL_APIENTRY alDisable( ALenum capability ); // AL_API void AL_APIENTRY alDisable( ALenum capability );
/// <summary>This function returns a boolean indicating if a specific feature is enabled in the OpenAL driver.</summary> /// <summary>This function returns a boolean indicating if a specific feature is enabled in the OpenAL driver.</summary>
/// <param name="capability">The name of a capability to enable.</param> /// <param name="capability">The name of a capability to enable.</param>
/// <returns>True if enabled, False if disabled.</returns> /// <returns>True if enabled, False if disabled.</returns>
[DllImport(AL.Lib, EntryPoint = "alIsEnabled", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alIsEnabled",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern bool IsEnabled(Enums.ALCapability capability); public static extern bool IsEnabled( Enums.ALCapability capability );
// AL_API ALboolean AL_APIENTRY alIsEnabled( ALenum capability ); // AL_API ALboolean AL_APIENTRY alIsEnabled( ALenum capability );
#endregion Renderer State management #endregion Renderer State management
#region State retrieval #region State retrieval
[DllImport(AL.Lib, EntryPoint = "alGetString", ExactSpelling = true, CallingConvention = AL.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetString",ExactSpelling = true,CallingConvention = AL.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
private static extern IntPtr GetStringPrivate(Enums.ALGetString param); // accepts the enums Enums.AlError, Enums.AlContextString private static extern IntPtr GetStringPrivate( Enums.ALGetString param ); // accepts the enums Enums.AlError, Enums.AlContextString
// AL_API const ALchar* AL_APIENTRY alGetString( ALenum param ); // AL_API const ALchar* AL_APIENTRY alGetString( ALenum param );
/// <summary>This function retrieves an OpenAL string property.</summary> /// <summary>This function retrieves an OpenAL string property.</summary>
/// <param name="param">The property to be returned: AL_VENDOR, AL_VERSION, AL_RENDERER, AL_EXTENSIONS</param> /// <param name="param">The property to be returned: AL_VENDOR, AL_VERSION, AL_RENDERER, AL_EXTENSIONS</param>
/// <returns>Returns a pointer to a null-terminated string.</returns> /// <returns>Returns a pointer to a null-terminated string.</returns>
public static string Get(Enums.ALGetString param) public static string Get( Enums.ALGetString param )
{ {
return Marshal.PtrToStringAnsi(GetStringPrivate(param)); return Marshal.PtrToStringAnsi(GetStringPrivate(param));
} }
@ -123,9 +123,9 @@ namespace OpenTK.OpenAL
/// <summary>This function retrieves an OpenAL string property.</summary> /// <summary>This function retrieves an OpenAL string property.</summary>
/// <param name="param">The human-readable errorstring to be returned.</param> /// <param name="param">The human-readable errorstring to be returned.</param>
/// <returns>Returns a pointer to a null-terminated string.</returns> /// <returns>Returns a pointer to a null-terminated string.</returns>
public static string GetErrorString(Enums.ALError param) public static string GetErrorString( Enums.ALError param )
{ {
return Marshal.PtrToStringAnsi(GetStringPrivate((Enums.ALGetString)param)); return Marshal.PtrToStringAnsi(GetStringPrivate((Enums.ALGetString) param));
} }
/* no functions return more than 1 result .. /* no functions return more than 1 result ..
@ -147,15 +147,15 @@ namespace OpenTK.OpenAL
/// <summary>This function returns an integer OpenAL state.</summary> /// <summary>This function returns an integer OpenAL state.</summary>
/// <param name="param">the state to be queried: AL_DOPPLER_FACTOR, AL_SPEED_OF_SOUND, AL_DISTANCE_MODEL</param> /// <param name="param">the state to be queried: AL_DOPPLER_FACTOR, AL_SPEED_OF_SOUND, AL_DISTANCE_MODEL</param>
/// <returns>The integer state described by param will be returned.</returns> /// <returns>The integer state described by param will be returned.</returns>
[DllImport(AL.Lib, EntryPoint = "alGetInteger", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetInteger",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern int Get(Enums.ALGetInteger param); public static extern int Get( Enums.ALGetInteger param );
// AL_API ALint AL_APIENTRY alGetInteger( ALenum param ); // AL_API ALint AL_APIENTRY alGetInteger( ALenum param );
/// <summary>This function returns a floating point OpenAL state.</summary> /// <summary>This function returns a floating point OpenAL state.</summary>
/// <param name="param">the state to be queried: AL_DOPPLER_FACTOR, AL_SPEED_OF_SOUND, AL_DISTANCE_MODEL</param> /// <param name="param">the state to be queried: AL_DOPPLER_FACTOR, AL_SPEED_OF_SOUND, AL_DISTANCE_MODEL</param>
/// <returns>The floating point state described by param will be returned.</returns> /// <returns>The floating point state described by param will be returned.</returns>
[DllImport(AL.Lib, EntryPoint = "alGetFloat", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetFloat",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern float Get(Enums.ALGetFloat param); public static extern float Get( Enums.ALGetFloat param );
// AL_API ALfloat AL_APIENTRY alGetFloat( ALenum param ); // AL_API ALfloat AL_APIENTRY alGetFloat( ALenum param );
/* disabled due to no token using it /* disabled due to no token using it
@ -169,33 +169,33 @@ namespace OpenTK.OpenAL
/// <summary>Error support. Obtain the most recent error generated in the AL state machine. When an error is detected by AL, a flag is set and the error code is recorded. Further errors, if they occur, do not affect this recorded code. When alGetError is called, the code is returned and the flag is cleared, so that a further error will again record its code.</summary> /// <summary>Error support. Obtain the most recent error generated in the AL state machine. When an error is detected by AL, a flag is set and the error code is recorded. Further errors, if they occur, do not affect this recorded code. When alGetError is called, the code is returned and the flag is cleared, so that a further error will again record its code.</summary>
/// <returns>The first error that occured. can be used with Al.GetString. Returns an Alenum representing the error state. When an OpenAL error occurs, the error state is set and will not be changed until the error state is retrieved using alGetError. Whenever alGetError is called, the error state is cleared and the last state (the current state when the call was made) is returned. To isolate error detection to a specific portion of code, alGetError should be called before the isolated section to clear the current error state.</returns> /// <returns>The first error that occured. can be used with Al.GetString. Returns an Alenum representing the error state. When an OpenAL error occurs, the error state is set and will not be changed until the error state is retrieved using alGetError. Whenever alGetError is called, the error state is cleared and the last state (the current state when the call was made) is returned. To isolate error detection to a specific portion of code, alGetError should be called before the isolated section to clear the current error state.</returns>
[DllImport(AL.Lib, EntryPoint = "alGetError", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetError",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern Enums.ALError GetError(); public static extern Enums.ALError GetError( );
// AL_API ALenum AL_APIENTRY alGetError( void ); // AL_API ALenum AL_APIENTRY alGetError( void );
#endregion State retrieval #endregion State retrieval
#region Extension support. #region Extension support.
///<summary>This function tests if a specific extension is available for the OpenAL driver.</summary> ///<summary>This function tests if a specific extension is available for the OpenAL driver.</summary>
/// <param name="extname">A null-terminated string describing the desired extension.</param> /// <param name="extname">A null-terminated string describing the desired extension.</param>
/// <returns>Returns AL_TRUE if the extension is available, AL_FALSE if the extension is not available.</returns> /// <returns>Returns AL_TRUE if the extension is available, AL_FALSE if the extension is not available.</returns>
[DllImport(AL.Lib, EntryPoint = "alIsExtensionPresent", ExactSpelling = true, CallingConvention = AL.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alIsExtensionPresent",ExactSpelling = true,CallingConvention = AL.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern bool IsExtensionPresent([In] string extname); public static extern bool IsExtensionPresent( [In] string extname );
// AL_API ALboolean AL_APIENTRY alIsExtensionPresent( const ALchar* extname ); // AL_API ALboolean AL_APIENTRY alIsExtensionPresent( const ALchar* extname );
/// <summary>This function returns the address of an OpenAL extension function. Handle with care.</summary> /// <summary>This function returns the address of an OpenAL extension function. Handle with care.</summary>
/// <param name="fname">A null-terminated string containing the function name.</param> /// <param name="fname">A null-terminated string containing the function name.</param>
/// <returns>The return value is a pointer to the specified function. The return value will be NULL if the function is not found.</returns> /// <returns>The return value is a pointer to the specified function. The return value will be NULL if the function is not found.</returns>
[DllImport(AL.Lib, EntryPoint = "alGetProcAddress", ExactSpelling = true, CallingConvention = AL.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetProcAddress",ExactSpelling = true,CallingConvention = AL.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern IntPtr GetProcAddress([In] string fname); public static extern IntPtr GetProcAddress( [In] string fname );
// AL_API void* AL_APIENTRY alGetProcAddress( const ALchar* fname ); // AL_API void* AL_APIENTRY alGetProcAddress( const ALchar* fname );
/// <summary>This function returns the enumeration value of an OpenAL enum described by a string.</summary> /// <summary>This function returns the enumeration value of an OpenAL enum described by a string.</summary>
/// <param name="ename">A null-terminated string describing an OpenAL enum.</param> /// <param name="ename">A null-terminated string describing an OpenAL enum.</param>
/// <returns>Returns the actual ALenum described by a string. Returns NULL if the string doesn’t describe a valid OpenAL enum.</returns> /// <returns>Returns the actual ALenum described by a string. Returns NULL if the string doesn’t describe a valid OpenAL enum.</returns>
[DllImport(AL.Lib, EntryPoint = "alGetEnumValue", ExactSpelling = true, CallingConvention = AL.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetEnumValue",ExactSpelling = true,CallingConvention = AL.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern int GetEnumValue([In] string ename); public static extern int GetEnumValue( [In] string ename );
// AL_API ALenum AL_APIENTRY alGetEnumValue( const ALchar* ename ); // AL_API ALenum AL_APIENTRY alGetEnumValue( const ALchar* ename );
#endregion Extension support. #endregion Extension support.
@ -218,8 +218,8 @@ namespace OpenTK.OpenAL
/// <summary>This function sets a floating point property for the listener.</summary> /// <summary>This function sets a floating point property for the listener.</summary>
/// <param name="param">The name of the attribute to be set: AL_GAIN</param> /// <param name="param">The name of the attribute to be set: AL_GAIN</param>
/// <param name="value">The float value to set the attribute to.</param> /// <param name="value">The float value to set the attribute to.</param>
[DllImport(AL.Lib, EntryPoint = "alListenerf", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alListenerf",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Listener(Enums.ALListenerf param, float value); public static extern void Listener( Enums.ALListenerf param,float value );
// AL_API void AL_APIENTRY alListenerf( ALenum param, ALfloat value ); // AL_API void AL_APIENTRY alListenerf( ALenum param, ALfloat value );
/// <summary>This function sets a floating point property for the listener.</summary> /// <summary>This function sets a floating point property for the listener.</summary>
@ -227,32 +227,32 @@ namespace OpenTK.OpenAL
/// <param name="value1">The value to set the attribute to.</param> /// <param name="value1">The value to set the attribute to.</param>
/// <param name="value2">The value to set the attribute to.</param> /// <param name="value2">The value to set the attribute to.</param>
/// <param name="value3">The value to set the attribute to.</param> /// <param name="value3">The value to set the attribute to.</param>
[DllImport(AL.Lib, EntryPoint = "alListener3f", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alListener3f",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Listener(Enums.ALListener3f param, float value1, float value2, float value3); public static extern void Listener( Enums.ALListener3f param,float value1,float value2,float value3 );
// AL_API void AL_APIENTRY alListener3f( ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); // AL_API void AL_APIENTRY alListener3f( ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );
/// <summary>This function sets a Math.Vector3 property for the listener.</summary> /// <summary>This function sets a Math.Vector3 property for the listener.</summary>
/// <param name="param">The name of the attribute to set: AL_POSITION, AL_VELOCITY</param> /// <param name="param">The name of the attribute to set: AL_POSITION, AL_VELOCITY</param>
/// <param name="values">The Math.Vector3 to set the attribute to.</param> /// <param name="values">The Math.Vector3 to set the attribute to.</param>
public static void Listener(Enums.ALListener3f param, ref Vector3 values) public static void Listener( Enums.ALListener3f param,ref Vector3 values )
{ {
Listener(param, values.X, values.Y, values.Z); Listener(param,values.X,values.Y,values.Z);
} }
[DllImport(AL.Lib, EntryPoint = "alListenerfv", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alListenerfv",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
unsafe private static extern void ListenerPrivate(Enums.ALListenerfv param, float* values); unsafe private static extern void ListenerPrivate( Enums.ALListenerfv param,float* values );
// AL_API void AL_APIENTRY alListenerfv( ALenum param, const ALfloat* values ); // AL_API void AL_APIENTRY alListenerfv( ALenum param, const ALfloat* values );
/// <summary>This function sets a floating point-vector property of the listener.</summary> /// <summary>This function sets a floating point-vector property of the listener.</summary>
/// <param name="param">The name of the attribute to be set: AL_POSITION, AL_VELOCITY, AL_ORIENTATION</param> /// <param name="param">The name of the attribute to be set: AL_POSITION, AL_VELOCITY, AL_ORIENTATION</param>
/// <param name="values">Pointer to floating point-vector values.</param> /// <param name="values">Pointer to floating point-vector values.</param>
public static void Listener(Enums.ALListenerfv param, ref float[] values) public static void Listener( Enums.ALListenerfv param,ref float[] values )
{ {
unsafe unsafe
{ {
fixed (float* ptr = &values[0]) fixed ( float* ptr = &values[0] )
{ {
ListenerPrivate(param, ptr); ListenerPrivate(param,ptr);
} }
} }
} }
@ -261,7 +261,7 @@ namespace OpenTK.OpenAL
/// <param name="param">The name of the attribute to be set: AL_ORIENTATION</param> /// <param name="param">The name of the attribute to be set: AL_ORIENTATION</param>
/// <param name="at">A Math.Vector3 for the At-Vector.</param> /// <param name="at">A Math.Vector3 for the At-Vector.</param>
/// <param name="up">A Math.Vector3 for the Up-Vector.</param> /// <param name="up">A Math.Vector3 for the Up-Vector.</param>
public static void Listener(Enums.ALListenerfv param, ref Vector3 at, ref Vector3 up) public static void Listener( Enums.ALListenerfv param,ref Vector3 at,ref Vector3 up )
{ {
float[] temp = new float[6]; float[] temp = new float[6];
@ -275,9 +275,9 @@ namespace OpenTK.OpenAL
unsafe unsafe
{ {
fixed (float* ptr = &temp[0]) fixed ( float* ptr = &temp[0] )
{ {
ListenerPrivate(param, ptr); ListenerPrivate(param,ptr);
} }
} }
} }
@ -293,8 +293,8 @@ namespace OpenTK.OpenAL
/// <summary>This function retrieves a floating point property of the listener.</summary> /// <summary>This function retrieves a floating point property of the listener.</summary>
/// <param name="param">the name of the attribute to be retrieved: AL_GAIN</param> /// <param name="param">the name of the attribute to be retrieved: AL_GAIN</param>
/// <param name="value">a pointer to the floating point value being retrieved.</param> /// <param name="value">a pointer to the floating point value being retrieved.</param>
[DllImport(AL.Lib, EntryPoint = "alGetListenerf", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetListenerf",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void GetListener(Enums.ALListenerf param, [Out] out float value); public static extern void GetListener( Enums.ALListenerf param,[Out] out float value );
// AL_API void AL_APIENTRY alGetListenerf( ALenum param, ALfloat* value ); // AL_API void AL_APIENTRY alGetListenerf( ALenum param, ALfloat* value );
/// <summary>This function retrieves a set of three floating point values from a property of the listener.</summary> /// <summary>This function retrieves a set of three floating point values from a property of the listener.</summary>
@ -302,37 +302,37 @@ namespace OpenTK.OpenAL
/// <param name="value1">Pointers to the three floating point being retrieved.</param> /// <param name="value1">Pointers to the three floating point being retrieved.</param>
/// <param name="value2">Pointers to the three floating point being retrieved.</param> /// <param name="value2">Pointers to the three floating point being retrieved.</param>
/// <param name="value3">Pointers to the three floating point being retrieved.</param> /// <param name="value3">Pointers to the three floating point being retrieved.</param>
[DllImport(AL.Lib, EntryPoint = "alGetListener3f", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alGetListener3f",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void GetListener(Enums.ALListener3f param, [Out] out float value1, [Out] out float value2, [Out] out float value3); public static extern void GetListener( Enums.ALListener3f param,[Out] out float value1,[Out] out float value2,[Out] out float value3 );
// AL_API void AL_APIENTRY alGetListener3f( ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3 ); // AL_API void AL_APIENTRY alGetListener3f( ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3 );
/// <summary>This function retrieves a Math.Vector3 from a property of the listener.</summary> /// <summary>This function retrieves a Math.Vector3 from a property of the listener.</summary>
/// <param name="param">The name of the attribute to be retrieved: AL_POSITION, AL_VELOCITY</param> /// <param name="param">The name of the attribute to be retrieved: AL_POSITION, AL_VELOCITY</param>
/// <param name="values">A Math.Vector3 to hold the three floats being retrieved.</param> /// <param name="values">A Math.Vector3 to hold the three floats being retrieved.</param>
public static void GetListener(Enums.ALListener3f param, out Vector3 values) public static void GetListener( Enums.ALListener3f param,out Vector3 values )
{ {
GetListener(param, out values.X, out values.Y, out values.Z); GetListener(param,out values.X,out values.Y,out values.Z);
} }
/// <summary>This function retrieves a floating point-vector property of the listener. You must pin it manually.</summary> /// <summary>This function retrieves a floating point-vector property of the listener. You must pin it manually.</summary>
/// <param name="param">the name of the attribute to be retrieved: AL_POSITION, AL_VELOCITY, AL_ORIENTATION</param> /// <param name="param">the name of the attribute to be retrieved: AL_POSITION, AL_VELOCITY, AL_ORIENTATION</param>
/// <param name="values">A pointer to the floating point-vector value being retrieved.</param> /// <param name="values">A pointer to the floating point-vector value being retrieved.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alGetListenerfv", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alGetListenerfv",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
unsafe public static extern void GetListener(Enums.ALListenerfv param, float* values); unsafe public static extern void GetListener( Enums.ALListenerfv param,float* values );
// AL_API void AL_APIENTRY alGetListenerfv( ALenum param, ALfloat* values ); // AL_API void AL_APIENTRY alGetListenerfv( ALenum param, ALfloat* values );
/// <summary>This function retrieves two Math.Vector3 properties of the listener.</summary> /// <summary>This function retrieves two Math.Vector3 properties of the listener.</summary>
/// <param name="param">the name of the attribute to be retrieved: AL_ORIENTATION</param> /// <param name="param">the name of the attribute to be retrieved: AL_ORIENTATION</param>
/// <param name="at">A Math.Vector3 for the At-Vector.</param> /// <param name="at">A Math.Vector3 for the At-Vector.</param>
/// <param name="up">A Math.Vector3 for the Up-Vector.</param> /// <param name="up">A Math.Vector3 for the Up-Vector.</param>
public static void GetListener(Enums.ALListenerfv param, out Vector3 at, out Vector3 up) public static void GetListener( Enums.ALListenerfv param,out Vector3 at,out Vector3 up )
{ {
float[] pinned = new float[6]; // should lose scope when the function exits float[] pinned = new float[6]; // should lose scope when the function exits
unsafe unsafe
{ {
fixed (float* ptr = &pinned[0]) fixed ( float* ptr = &pinned[0] )
{ {
GetListener(param, ptr); GetListener(param,ptr);
at.X = pinned[0]; at.X = pinned[0];
at.Y = pinned[1]; at.Y = pinned[1];
@ -391,21 +391,21 @@ namespace OpenTK.OpenAL
#region Create Source objects #region Create Source objects
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alGenSources", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alGenSources",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
unsafe public static extern void GenSources(int n, [Out] uint* sources); unsafe private static extern void GenSourcesPrivate( int n,[Out] uint* sources );
// AL_API void AL_APIENTRY alGenSources( ALsizei n, ALuint* Sources ); // AL_API void AL_APIENTRY alGenSources( ALsizei n, ALuint* Sources );
/// <summary>This function generates one or more sources. References to sources are ALuint values, which are used wherever a source reference is needed (in calls such as alDeleteSources and alSourcei).</summary> /// <summary>This function generates one or more sources. References to sources are ALuint values, which are used wherever a source reference is needed (in calls such as alDeleteSources and alSourcei).</summary>
/// <param name="n">The number of sources to be generated.</param> /// <param name="n">The number of sources to be generated.</param>
/// <param name="sources">Pointer to an array of uint values which will store the names of the new sources.</param> /// <param name="sources">Pointer to an array of uint values which will store the names of the new sources.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void GenSources(int n, out uint sources) public static void GenSources( int n,out uint sources )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &sources) fixed ( uint* ptr = &sources )
{ {
GenSources(n, (uint*)ptr); GenSourcesPrivate(n,(uint*) ptr);
sources = *ptr; sources = *ptr;
} }
} }
@ -414,26 +414,26 @@ namespace OpenTK.OpenAL
/// <summary>This function generates one source only. References to sources are ALuint values, which are used wherever a source reference is needed (in calls such as alDeleteSources and alSourcei).</summary> /// <summary>This function generates one source only. References to sources are ALuint values, which are used wherever a source reference is needed (in calls such as alDeleteSources and alSourcei).</summary>
/// <param name="sources">Pointer to an uint value which will store the name of the new source.</param> /// <param name="sources">Pointer to an uint value which will store the name of the new source.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void GenSources(out uint source) public static void GenSources( out uint source )
{ {
GenSources(1, out source); GenSources(1,out source);
} }
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alDeleteSources", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alDeleteSources",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
unsafe public static extern void DeleteSources(int n, [In] uint* sources); // Delete Source objects unsafe public static extern void DeleteSources( int n,[In] uint* sources ); // Delete Source objects
// AL_API void AL_APIENTRY alDeleteSources( ALsizei n, const ALuint* Sources ); // AL_API void AL_APIENTRY alDeleteSources( ALsizei n, const ALuint* Sources );
/// <summary>This function deletes one or more sources.</summary> /// <summary>This function deletes one or more sources.</summary>
/// <param name="n">The number of sources to be deleted.</param> /// <param name="n">The number of sources to be deleted.</param>
/// <param name="sources">Pointer to an array of source names identifying the sources to be deleted.</param> /// <param name="sources">Pointer to an array of source names identifying the sources to be deleted.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void DeleteSources(int n, ref uint[] sources) public static void DeleteSources( int n,ref uint[] sources )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = sources) fixed ( uint* ptr = sources )
{ {
DeleteSources(n, (uint*)ptr); DeleteSources(n,(uint*) ptr);
} }
} }
} }
@ -441,18 +441,18 @@ namespace OpenTK.OpenAL
/// <summary>This function deletes one source only.</summary> /// <summary>This function deletes one source only.</summary>
/// <param name="sources">Pointer to a source name identifying the source to be deleted.</param> /// <param name="sources">Pointer to a source name identifying the source to be deleted.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void DeleteSources(ref uint source) public static void DeleteSources( ref uint source )
{ {
uint[] t = new uint[1]; uint[] t = new uint[1];
t[0] = source; t[0] = source;
DeleteSources(1, ref t); DeleteSources(1,ref t);
} }
/// <summary>This function tests if a source name is valid, returning True if valid and False if not.</summary> /// <summary>This function tests if a source name is valid, returning True if valid and False if not.</summary>
/// <param name="sid">A source name to be tested for validity</param> /// <param name="sid">A source name to be tested for validity</param>
/// <returns>Success.</returns> /// <returns>Success.</returns>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alIsSource", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alIsSource",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern bool IsSource(uint sid); // Verify a handle is a valid Source public static extern bool IsSource( uint sid ); // Verify a handle is a valid Source
// AL_API ALboolean AL_APIENTRY alIsSource( ALuint sid ); // AL_API ALboolean AL_APIENTRY alIsSource( ALuint sid );
#endregion Create Source objects #endregion Create Source objects
@ -463,8 +463,8 @@ namespace OpenTK.OpenAL
/// <param name="sid">Source name whose attribute is being set</param> /// <param name="sid">Source name whose attribute is being set</param>
/// <param name="param">The name of the attribute to set: AL_PITCH, AL_GAIN, AL_MIN_GAIN, AL_MAX_GAIN, AL_MAX_DISTANCE, AL_ROLLOFF_FACTOR, AL_CONE_OUTER_GAIN, AL_CONE_INNER_ANGLE, AL_CONE_OUTER_ANGLE, AL_REFERENCE_DISTANCE</param> /// <param name="param">The name of the attribute to set: AL_PITCH, AL_GAIN, AL_MIN_GAIN, AL_MAX_GAIN, AL_MAX_DISTANCE, AL_ROLLOFF_FACTOR, AL_CONE_OUTER_GAIN, AL_CONE_INNER_ANGLE, AL_CONE_OUTER_ANGLE, AL_REFERENCE_DISTANCE</param>
/// <param name="value">The value to set the attribute to.</param> /// <param name="value">The value to set the attribute to.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourcef", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourcef",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Source(uint sid, Enums.ALSourcef param, float value); public static extern void Source( uint sid,Enums.ALSourcef param,float value );
// AL_API void AL_APIENTRY alSourcef( ALuint sid, ALenum param, ALfloat value ); // AL_API void AL_APIENTRY alSourcef( ALuint sid, ALenum param, ALfloat value );
/// <summary>This function sets a source property requiring three floating point values.</summary> /// <summary>This function sets a source property requiring three floating point values.</summary>
@ -473,8 +473,8 @@ namespace OpenTK.OpenAL
/// <param name="value1">The three ALfloat values which the attribute will be set to.</param> /// <param name="value1">The three ALfloat values which the attribute will be set to.</param>
/// <param name="value2">The three ALfloat values which the attribute will be set to.</param> /// <param name="value2">The three ALfloat values which the attribute will be set to.</param>
/// <param name="value3">The three ALfloat values which the attribute will be set to.</param> /// <param name="value3">The three ALfloat values which the attribute will be set to.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSource3f", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSource3f",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Source(uint sid, Enums.ALSource3f param, float value1, float value2, float value3); public static extern void Source( uint sid,Enums.ALSource3f param,float value1,float value2,float value3 );
// AL_API void AL_APIENTRY alSource3f( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 ); // AL_API void AL_APIENTRY alSource3f( ALuint sid, ALenum param, ALfloat value1, ALfloat value2, ALfloat value3 );
/// <summary>This function sets a source property requiring three floating point values.</summary> /// <summary>This function sets a source property requiring three floating point values.</summary>
@ -482,17 +482,17 @@ namespace OpenTK.OpenAL
/// <param name="param">The name of the attribute to set: AL_POSITION, AL_VELOCITY, AL_DIRECTION</param> /// <param name="param">The name of the attribute to set: AL_POSITION, AL_VELOCITY, AL_DIRECTION</param>
/// <param name="values">A Math.Vector3 which the attribute will be set to.</param> /// <param name="values">A Math.Vector3 which the attribute will be set to.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void Source(uint sid, Enums.ALSource3f param, ref Vector3 values) public static void Source( uint sid,Enums.ALSource3f param,ref Vector3 values )
{ {
Source(sid, param, values.X, values.Y, values.Z); Source(sid,param,values.X,values.Y,values.Z);
} }
/// <summary>This function sets an integer property of a source.</summary> /// <summary>This function sets an integer property of a source.</summary>
/// <param name="sid">Source name whose attribute is being set.</param> /// <param name="sid">Source name whose attribute is being set.</param>
/// <param name="param">The name of the attribute to set: AL_SOURCE_RELATIVE, AL_CONE_INNER_ANGLE, AL_CONE_OUTER_ANGLE, AL_LOOPING, AL_BUFFER, AL_SOURCE_STATE</param> /// <param name="param">The name of the attribute to set: AL_SOURCE_RELATIVE, AL_CONE_INNER_ANGLE, AL_CONE_OUTER_ANGLE, AL_LOOPING, AL_BUFFER, AL_SOURCE_STATE</param>
/// <param name="value">The value to set the attribute to.</param> /// <param name="value">The value to set the attribute to.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourcei", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourcei",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Source(uint sid, Enums.ALSourcei param, int value); public static extern void Source( uint sid,Enums.ALSourcei param,int value );
// AL_API void AL_APIENTRY alSourcei( ALuint sid, ALenum param, ALint value ); // AL_API void AL_APIENTRY alSourcei( ALuint sid, ALenum param, ALint value );
/// <summary>This function sets an bool property of a source.</summary> /// <summary>This function sets an bool property of a source.</summary>
@ -500,13 +500,22 @@ namespace OpenTK.OpenAL
/// <param name="param">The name of the attribute to set: AL_SOURCE_RELATIVE, AL_LOOPING</param> /// <param name="param">The name of the attribute to set: AL_SOURCE_RELATIVE, AL_LOOPING</param>
/// <param name="value">The value to set the attribute to.</param> /// <param name="value">The value to set the attribute to.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void Source(uint sid, Enums.ALSourceb param, bool value) public static void Source( uint sid,Enums.ALSourceb param,bool value )
{ {
Source(sid, (Enums.ALSourcei)param, (value) ? 1 : 0); Source(sid,(Enums.ALSourcei) param,( value ) ? 1 : 0);
} }
// AL_API void AL_APIENTRY alSourcefv( ALuint sid, ALenum param, const ALfloat* values ); // <summary>This function sets 3 integer properties of a source. This property is used to establish connections between Sources and Auxiliary Effect Slots.</summary>
/// <param name="sid">Source name whose attribute is being set.</param>
/// <param name="param">The name of the attribute to set: EfxAuxiliarySendFilter</param>
/// <param name="value1">The value to set the attribute to. (EFX Extension) The destination Auxiliary Effect Slot ID</param>
/// <param name="value2">The value to set the attribute to. (EFX Extension) The Auxiliary Send number.</param>
///<param name="value3">The value to set the attribute to. (EFX Extension) optional Filter ID.</param>
[CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSource3i",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void Source( uint sid,Enums.ALSource3i param,int value1,int value2,int value3 );
// AL_API void AL_APIENTRY alSource3i( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 ); // AL_API void AL_APIENTRY alSource3i( ALuint sid, ALenum param, ALint value1, ALint value2, ALint value3 );
// AL_API void AL_APIENTRY alSourcefv( ALuint sid, ALenum param, const ALfloat* values );
// AL_API void AL_APIENTRY alSourceiv( ALuint sid, ALenum param, const ALint* values ); // AL_API void AL_APIENTRY alSourceiv( ALuint sid, ALenum param, const ALint* values );
#endregion Set Source parameters #endregion Set Source parameters
@ -517,8 +526,8 @@ namespace OpenTK.OpenAL
/// <param name="sid">Source name whose attribute is being retrieved.</param> /// <param name="sid">Source name whose attribute is being retrieved.</param>
/// <param name="param">The name of the attribute to retrieve: AL_PITCH, AL_GAIN, AL_MIN_GAIN, AL_MAX_GAIN, AL_MAX_DISTANCE, AL_ROLLOFF_FACTOR, AL_CONE_OUTER_GAIN, AL_CONE_INNER_ANGLE, AL_CONE_OUTER_ANGLE, AL_REFERENCE_DISTANCE</param> /// <param name="param">The name of the attribute to retrieve: AL_PITCH, AL_GAIN, AL_MIN_GAIN, AL_MAX_GAIN, AL_MAX_DISTANCE, AL_ROLLOFF_FACTOR, AL_CONE_OUTER_GAIN, AL_CONE_INNER_ANGLE, AL_CONE_OUTER_ANGLE, AL_REFERENCE_DISTANCE</param>
/// <param name="value">A pointer to the floating point value being retrieved</param> /// <param name="value">A pointer to the floating point value being retrieved</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alGetSourcef", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alGetSourcef",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void GetSource(uint sid, Enums.ALSourcef param, [Out] out float value); public static extern void GetSource( uint sid,Enums.ALSourcef param,[Out] out float value );
// AL_API void AL_APIENTRY alGetSourcef( ALuint sid, ALenum param, ALfloat* value ); // AL_API void AL_APIENTRY alGetSourcef( ALuint sid, ALenum param, ALfloat* value );
/// <summary>This function retrieves three floating point values representing a property of a source.</summary> /// <summary>This function retrieves three floating point values representing a property of a source.</summary>
@ -527,8 +536,8 @@ namespace OpenTK.OpenAL
/// <param name="value1">Pointer to the value to retrieve.</param> /// <param name="value1">Pointer to the value to retrieve.</param>
/// <param name="value2">Pointer to the value to retrieve.</param> /// <param name="value2">Pointer to the value to retrieve.</param>
/// <param name="value3">Pointer to the value to retrieve.</param> /// <param name="value3">Pointer to the value to retrieve.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alGetSource3f", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alGetSource3f",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void GetSource(uint sid, Enums.ALSource3f param, [Out] out float value1, [Out] out float value2, [Out] out float value3); public static extern void GetSource( uint sid,Enums.ALSource3f param,[Out] out float value1,[Out] out float value2,[Out] out float value3 );
// AL_API void AL_APIENTRY alGetSource3f( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3); // AL_API void AL_APIENTRY alGetSource3f( ALuint sid, ALenum param, ALfloat* value1, ALfloat* value2, ALfloat* value3);
/// <summary>This function retrieves three floating point values representing a property of a source.</summary> /// <summary>This function retrieves three floating point values representing a property of a source.</summary>
@ -536,17 +545,17 @@ namespace OpenTK.OpenAL
/// <param name="param">the name of the attribute being retrieved: AL_POSITION, AL_VELOCITY, AL_DIRECTION</param> /// <param name="param">the name of the attribute being retrieved: AL_POSITION, AL_VELOCITY, AL_DIRECTION</param>
/// <param name="values">A Math.Vector3 to retrieve the values to.</param> /// <param name="values">A Math.Vector3 to retrieve the values to.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void GetSource(uint sid, Enums.ALSource3f param, out Vector3 values) public static void GetSource( uint sid,Enums.ALSource3f param,out Vector3 values )
{ {
GetSource(sid, param, out values.X, out values.Y, out values.Z); GetSource(sid,param,out values.X,out values.Y,out values.Z);
} }
/// <summary>This function retrieves an integer property of a source.</summary> /// <summary>This function retrieves an integer property of a source.</summary>
/// <param name="sid">Source name whose attribute is being retrieved.</param> /// <param name="sid">Source name whose attribute is being retrieved.</param>
/// <param name="param">The name of the attribute to retrieve: AL_SOURCE_RELATIVE, AL_BUFFER, AL_SOURCE_STATE, AL_BUFFERS_QUEUED, AL_BUFFERS_PROCESSED</param> /// <param name="param">The name of the attribute to retrieve: AL_SOURCE_RELATIVE, AL_BUFFER, AL_SOURCE_STATE, AL_BUFFERS_QUEUED, AL_BUFFERS_PROCESSED</param>
/// <param name="value">A pointer to the integer value being retrieved.</param> /// <param name="value">A pointer to the integer value being retrieved.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alGetSourcei", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alGetSourcei",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void GetSource(uint sid, Enums.ALSourceiGet param, [Out] out int value); public static extern void GetSource( uint sid,Enums.ALSourceiGet param,[Out] out int value );
// AL_API void AL_APIENTRY alGetSourcei( ALuint sid, ALenum param, ALint* value ); // AL_API void AL_APIENTRY alGetSourcei( ALuint sid, ALenum param, ALint* value );
/// <summary>This function retrieves a bool property of a source.</summary> /// <summary>This function retrieves a bool property of a source.</summary>
@ -554,39 +563,40 @@ namespace OpenTK.OpenAL
/// <param name="param">The name of the attribute to get: AL_SOURCE_RELATIVE, AL_LOOPING</param> /// <param name="param">The name of the attribute to get: AL_SOURCE_RELATIVE, AL_LOOPING</param>
/// <param name="value">A pointer to the bool value being retrieved.</param> /// <param name="value">A pointer to the bool value being retrieved.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void GetSource(uint sid, Enums.ALSourceb param, [Out] out bool value) public static void GetSource( uint sid,Enums.ALSourceb param,[Out] out bool value )
{ {
int result; int result;
GetSource(sid, (Enums.ALSourceiGet)param, out result); GetSource(sid,(Enums.ALSourceiGet) param,out result);
if (result == 1) if ( result == 1 )
value = true; value = true;
else else
value = false; value = false;
} }
// AL_API void AL_APIENTRY alGetSourcefv( ALuint sid, ALenum param, ALfloat* values );
// AL_API void AL_APIENTRY alGetSource3i( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3); // AL_API void AL_APIENTRY alGetSource3i( ALuint sid, ALenum param, ALint* value1, ALint* value2, ALint* value3);
// AL_API void AL_APIENTRY alGetSourcefv( ALuint sid, ALenum param, ALfloat* values );
// AL_API void AL_APIENTRY alGetSourceiv( ALuint sid, ALenum param, ALint* values ); // AL_API void AL_APIENTRY alGetSourceiv( ALuint sid, ALenum param, ALint* values );
#endregion Get Source parameters #endregion Get Source parameters
#region Source vector based playback calls #region Source vector based playback calls
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourcePlayv"), SuppressUnmanagedCodeSecurity] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourcePlayv"),SuppressUnmanagedCodeSecurity]
unsafe public static extern void SourcePlay(int ns, [In] uint* sids); unsafe public static extern void SourcePlay( int ns,[In] uint* sids );
// AL_API void AL_APIENTRY alSourcePlayv( ALsizei ns, const ALuint *sids ); // AL_API void AL_APIENTRY alSourcePlayv( ALsizei ns, const ALuint *sids );
/// <summary>This function plays a set of sources. The playing sources will have their state changed to AL_PLAYING. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the AL_STOPPED state.</summary> /// <summary>This function plays a set of sources. The playing sources will have their state changed to AL_PLAYING. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the AL_STOPPED state.</summary>
/// <param name="ns">The number of sources to be played.</param> /// <param name="ns">The number of sources to be played.</param>
/// <param name="sids">A pointer to an array of sources to be played.</param> /// <param name="sids">A pointer to an array of sources to be played.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourcePlay(int ns, [In] uint[] sids) public static void SourcePlay( int ns,[In] uint[] sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = sids) fixed ( uint* ptr = sids )
{ {
SourcePlay(ns, ptr); SourcePlay(ns,ptr);
} }
} }
} }
@ -595,32 +605,32 @@ namespace OpenTK.OpenAL
/// <param name="ns">The number of sources to be played.</param> /// <param name="ns">The number of sources to be played.</param>
/// <param name="sids">A pointer to an array of sources to be played.</param> /// <param name="sids">A pointer to an array of sources to be played.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourcePlay(int ns, [In] ref uint sids) public static void SourcePlay( int ns,[In] ref uint sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &sids) fixed ( uint* ptr = &sids )
{ {
SourcePlay(ns, ptr); SourcePlay(ns,ptr);
} }
} }
} }
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourceStopv"), SuppressUnmanagedCodeSecurity] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourceStopv"),SuppressUnmanagedCodeSecurity]
unsafe public static extern void SourceStop(int ns, [In] uint* sids); unsafe public static extern void SourceStop( int ns,[In] uint* sids );
// AL_API void AL_APIENTRY alSourceStopv( ALsizei ns, const ALuint *sids ); // AL_API void AL_APIENTRY alSourceStopv( ALsizei ns, const ALuint *sids );
/// <summary>This function stops a set of sources. The stopped sources will have their state changed to AL_STOPPED.</summary> /// <summary>This function stops a set of sources. The stopped sources will have their state changed to AL_STOPPED.</summary>
/// <param name="ns">The number of sources to stop.</param> /// <param name="ns">The number of sources to stop.</param>
/// <param name="sids">A pointer to an array of sources to be stopped.</param> /// <param name="sids">A pointer to an array of sources to be stopped.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceStop(int ns, [In] uint[] sids) public static void SourceStop( int ns,[In] uint[] sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = sids) fixed ( uint* ptr = sids )
{ {
SourceStop(ns, ptr); SourceStop(ns,ptr);
} }
} }
} }
@ -629,32 +639,32 @@ namespace OpenTK.OpenAL
/// <param name="ns">The number of sources to stop.</param> /// <param name="ns">The number of sources to stop.</param>
/// <param name="sids">A pointer to an array of sources to be stopped.</param> /// <param name="sids">A pointer to an array of sources to be stopped.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceStop(int ns, [In] ref uint sids) public static void SourceStop( int ns,[In] ref uint sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &sids) fixed ( uint* ptr = &sids )
{ {
SourceStop(ns, ptr); SourceStop(ns,ptr);
} }
} }
} }
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourceRewindv"), SuppressUnmanagedCodeSecurity] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourceRewindv"),SuppressUnmanagedCodeSecurity]
unsafe public static extern void SourceRewind(int ns, [In] uint* sids); unsafe public static extern void SourceRewind( int ns,[In] uint* sids );
// AL_API void AL_APIENTRY alSourceRewindv( ALsizei ns, const ALuint *sids ); // AL_API void AL_APIENTRY alSourceRewindv( ALsizei ns, const ALuint *sids );
/// <summary>This function stops a set of sources and sets all their states to AL_INITIAL.</summary> /// <summary>This function stops a set of sources and sets all their states to AL_INITIAL.</summary>
/// <param name="ns">The number of sources to be rewound.</param> /// <param name="ns">The number of sources to be rewound.</param>
/// <param name="sids">A pointer to an array of sources to be rewound.</param> /// <param name="sids">A pointer to an array of sources to be rewound.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceRewind(int ns, [In] uint[] sids) public static void SourceRewind( int ns,[In] uint[] sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = sids) fixed ( uint* ptr = sids )
{ {
SourceRewind(ns, ptr); SourceRewind(ns,ptr);
} }
} }
} }
@ -663,32 +673,32 @@ namespace OpenTK.OpenAL
/// <param name="ns">The number of sources to be rewound.</param> /// <param name="ns">The number of sources to be rewound.</param>
/// <param name="sids">A pointer to an array of sources to be rewound.</param> /// <param name="sids">A pointer to an array of sources to be rewound.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceRewind(int ns, [In] ref uint sids) public static void SourceRewind( int ns,[In] ref uint sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &sids) fixed ( uint* ptr = &sids )
{ {
SourceRewind(ns, ptr); SourceRewind(ns,ptr);
} }
} }
} }
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourcePausev"), SuppressUnmanagedCodeSecurity] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourcePausev"),SuppressUnmanagedCodeSecurity]
unsafe public static extern void SourcePause(int ns, [In] uint* sids); unsafe public static extern void SourcePause( int ns,[In] uint* sids );
// AL_API void AL_APIENTRY alSourcePausev( ALsizei ns, const ALuint *sids ); // AL_API void AL_APIENTRY alSourcePausev( ALsizei ns, const ALuint *sids );
/// <summary>This function pauses a set of sources. The paused sources will have their state changed to AL_PAUSED.</summary> /// <summary>This function pauses a set of sources. The paused sources will have their state changed to AL_PAUSED.</summary>
/// <param name="ns">The number of sources to be paused.</param> /// <param name="ns">The number of sources to be paused.</param>
/// <param name="sids">A pointer to an array of sources to be paused.</param> /// <param name="sids">A pointer to an array of sources to be paused.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourcePause(int ns, [In] uint[] sids) public static void SourcePause( int ns,[In] uint[] sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = sids) fixed ( uint* ptr = sids )
{ {
SourcePause(ns, ptr); SourcePause(ns,ptr);
} }
} }
} }
@ -697,13 +707,13 @@ namespace OpenTK.OpenAL
/// <param name="ns">The number of sources to be paused.</param> /// <param name="ns">The number of sources to be paused.</param>
/// <param name="sids">A pointer to an array of sources to be paused.</param> /// <param name="sids">A pointer to an array of sources to be paused.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourcePause(int ns, [In] ref uint sids) public static void SourcePause( int ns,[In] ref uint sids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &sids) fixed ( uint* ptr = &sids )
{ {
SourcePause(ns, ptr); SourcePause(ns,ptr);
} }
} }
} }
@ -714,34 +724,34 @@ namespace OpenTK.OpenAL
/// <summary>This function plays a source. The playing source will have its state changed to AL_PLAYING. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the AL_STOPPED state.</summary> /// <summary>This function plays a source. The playing source will have its state changed to AL_PLAYING. When called on a source which is already playing, the source will restart at the beginning. When the attached buffer(s) are done playing, the source will progress to the AL_STOPPED state.</summary>
/// <param name="sid">The name of the source to be played.</param> /// <param name="sid">The name of the source to be played.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourcePlay", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourcePlay",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void SourcePlay(uint sid);// Play, replay, or resume a Source public static extern void SourcePlay( uint sid );// Play, replay, or resume a Source
// AL_API void AL_APIENTRY alSourcePlay( ALuint sid ); // AL_API void AL_APIENTRY alSourcePlay( ALuint sid );
/// <summary>This function stops a source. The stopped source will have its state changed to AL_STOPPED.</summary> /// <summary>This function stops a source. The stopped source will have its state changed to AL_STOPPED.</summary>
/// <param name="sid">The name of the source to be stopped.</param> /// <param name="sid">The name of the source to be stopped.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourceStop", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourceStop",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void SourceStop(uint sid); // Stop a Source public static extern void SourceStop( uint sid ); // Stop a Source
// AL_API void AL_APIENTRY alSourceStop( ALuint sid ); // AL_API void AL_APIENTRY alSourceStop( ALuint sid );
/// <summary>This function stops the source and sets its state to AL_INITIAL.</summary> /// <summary>This function stops the source and sets its state to AL_INITIAL.</summary>
/// <param name="sid">The name of the source to be rewound.</param> /// <param name="sid">The name of the source to be rewound.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourceRewind", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourceRewind",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void SourceRewind(uint sid);// Rewind a Source (set playback postiton to beginning) public static extern void SourceRewind( uint sid );// Rewind a Source (set playback postiton to beginning)
// AL_API void AL_APIENTRY alSourceRewind( ALuint sid ); // AL_API void AL_APIENTRY alSourceRewind( ALuint sid );
/// <summary>This function pauses a source. The paused source will have its state changed to AL_PAUSED.</summary> /// <summary>This function pauses a source. The paused source will have its state changed to AL_PAUSED.</summary>
/// <param name="sid">The name of the source to be paused.</param> /// <param name="sid">The name of the source to be paused.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourcePause", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourcePause",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void SourcePause(uint sid); // Pause a Source public static extern void SourcePause( uint sid ); // Pause a Source
// AL_API void AL_APIENTRY alSourcePause( ALuint sid ); // AL_API void AL_APIENTRY alSourcePause( ALuint sid );
#endregion Source based playback calls #endregion Source based playback calls
#region Source Queuing #region Source Queuing
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourceQueueBuffers"), SuppressUnmanagedCodeSecurity] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourceQueueBuffers"),SuppressUnmanagedCodeSecurity]
unsafe public static extern void SourceQueueBuffers(uint sid, int numEntries, [In] uint* bids); unsafe public static extern void SourceQueueBuffers( uint sid,int numEntries,[In] uint* bids );
// AL_API void AL_APIENTRY alSourceQueueBuffers( ALuint sid, ALsizei numEntries, const ALuint *bids ); // AL_API void AL_APIENTRY alSourceQueueBuffers( ALuint sid, ALsizei numEntries, const ALuint *bids );
/// <summary>This function queues a set of buffers on a source. All buffers attached to a source will be played in sequence, and the number of processed buffers can be detected using an alSourcei call to retrieve AL_BUFFERS_PROCESSED. When first created, a source will be of type AL_UNDETERMINED. A successful alSourceQueueBuffers call will change the source type to AL_STREAMING.</summary> /// <summary>This function queues a set of buffers on a source. All buffers attached to a source will be played in sequence, and the number of processed buffers can be detected using an alSourcei call to retrieve AL_BUFFERS_PROCESSED. When first created, a source will be of type AL_UNDETERMINED. A successful alSourceQueueBuffers call will change the source type to AL_STREAMING.</summary>
@ -749,13 +759,13 @@ namespace OpenTK.OpenAL
/// <param name="numEntries">The number of buffers to be queued.</param> /// <param name="numEntries">The number of buffers to be queued.</param>
/// <param name="bids">A pointer to an array of buffer names to be queued.</param> /// <param name="bids">A pointer to an array of buffer names to be queued.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceQueueBuffers(uint sid, int numEntries, [In] uint[] bids) public static void SourceQueueBuffers( uint sid,int numEntries,[In] uint[] bids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = bids) fixed ( uint* ptr = bids )
{ {
SourceQueueBuffers(sid, numEntries, ptr); SourceQueueBuffers(sid,numEntries,ptr);
} }
} }
} }
@ -765,19 +775,19 @@ namespace OpenTK.OpenAL
/// <param name="numEntries">The number of buffers to be queued.</param> /// <param name="numEntries">The number of buffers to be queued.</param>
/// <param name="bids">A pointer to an array of buffer names to be queued.</param> /// <param name="bids">A pointer to an array of buffer names to be queued.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceQueueBuffers(uint sid, int numEntries, [In] ref uint bids) public static void SourceQueueBuffers( uint sid,int numEntries,[In] ref uint bids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &bids) fixed ( uint* ptr = &bids )
{ {
SourceQueueBuffers(sid, numEntries, ptr); SourceQueueBuffers(sid,numEntries,ptr);
} }
} }
} }
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alSourceUnqueueBuffers"), SuppressUnmanagedCodeSecurity] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alSourceUnqueueBuffers"),SuppressUnmanagedCodeSecurity]
unsafe public static extern void SourceUnqueueBuffers(uint sid, int numEntries, [In] uint* bids); unsafe public static extern void SourceUnqueueBuffers( uint sid,int numEntries,[In] uint* bids );
// AL_API void AL_APIENTRY alSourceUnqueueBuffers( ALuint sid, ALsizei numEntries, ALuint *bids ); // AL_API void AL_APIENTRY alSourceUnqueueBuffers( ALuint sid, ALsizei numEntries, ALuint *bids );
/// <summary>This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using an alSourcei call to retrieve AL_BUFFERS_PROCESSED, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue.</summary> /// <summary>This function unqueues a set of buffers attached to a source. The number of processed buffers can be detected using an alSourcei call to retrieve AL_BUFFERS_PROCESSED, which is the maximum number of buffers that can be unqueued using this call. The unqueue operation will only take place if all n buffers can be removed from the queue.</summary>
@ -785,13 +795,13 @@ namespace OpenTK.OpenAL
/// <param name="numEntries">The number of buffers to be unqueued.</param> /// <param name="numEntries">The number of buffers to be unqueued.</param>
/// <param name="bids">A pointer to an array of buffer names that were removed.</param> /// <param name="bids">A pointer to an array of buffer names that were removed.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceUnqueueBuffers(uint sid, int numEntries, [In] uint[] bids) public static void SourceUnqueueBuffers( uint sid,int numEntries,[In] uint[] bids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = bids) fixed ( uint* ptr = bids )
{ {
SourceUnqueueBuffers(sid, numEntries, ptr); SourceUnqueueBuffers(sid,numEntries,ptr);
} }
} }
} }
@ -801,13 +811,13 @@ namespace OpenTK.OpenAL
/// <param name="numEntries">The number of buffers to be unqueued.</param> /// <param name="numEntries">The number of buffers to be unqueued.</param>
/// <param name="bids">A pointer to an array of buffer names that were removed.</param> /// <param name="bids">A pointer to an array of buffer names that were removed.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void SourceUnqueueBuffers(uint sid, int numEntries, [In] ref uint bids) public static void SourceUnqueueBuffers( uint sid,int numEntries,[In] ref uint bids )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &bids) fixed ( uint* ptr = &bids )
{ {
SourceUnqueueBuffers(sid, numEntries, ptr); SourceUnqueueBuffers(sid,numEntries,ptr);
} }
} }
} }
@ -830,21 +840,21 @@ namespace OpenTK.OpenAL
#region Buffer objects #region Buffer objects
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alGenBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alGenBuffers",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
unsafe public static extern void GenBuffers(int n, [Out] uint* buffers); unsafe public static extern void GenBuffers( int n,[Out] uint* buffers );
// AL_API void AL_APIENTRY alGenBuffers( ALsizei n, ALuint* Buffers ); // AL_API void AL_APIENTRY alGenBuffers( ALsizei n, ALuint* Buffers );
/// <summary>This function generates one or more buffers, which contain audio data (see alBufferData). References to buffers are ALuint values, which are used wherever a buffer reference is needed (in calls such as alDeleteBuffers, alSourcei, alSourceQueueBuffers, and alSourceUnqueueBuffers).</summary> /// <summary>This function generates one or more buffers, which contain audio data (see alBufferData). References to buffers are ALuint values, which are used wherever a buffer reference is needed (in calls such as alDeleteBuffers, alSourcei, alSourceQueueBuffers, and alSourceUnqueueBuffers).</summary>
/// <param name="n">The number of buffers to be generated.</param> /// <param name="n">The number of buffers to be generated.</param>
/// <param name="buffers">Pointer to an array of uint values which will store the names of the new buffers.</param> /// <param name="buffers">Pointer to an array of uint values which will store the names of the new buffers.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void GenBuffers(int n, out uint buffers) public static void GenBuffers( int n,out uint buffers )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &buffers) fixed ( uint* ptr = &buffers )
{ {
GenBuffers(n, (uint*)ptr); GenBuffers(n,(uint*) ptr);
buffers = *ptr; buffers = *ptr;
} }
} }
@ -853,26 +863,26 @@ namespace OpenTK.OpenAL
/// <summary>This function generates one buffer only, which contain audio data (see alBufferData). References to buffers are ALuint values, which are used wherever a buffer reference is needed (in calls such as alDeleteBuffers, alSourcei, alSourceQueueBuffers, and alSourceUnqueueBuffers).</summary> /// <summary>This function generates one buffer only, which contain audio data (see alBufferData). References to buffers are ALuint values, which are used wherever a buffer reference is needed (in calls such as alDeleteBuffers, alSourcei, alSourceQueueBuffers, and alSourceUnqueueBuffers).</summary>
/// <param name="buffers">Pointer to an uint value which will store the name of the new buffer.</param> /// <param name="buffers">Pointer to an uint value which will store the name of the new buffer.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void GenBuffers(out uint buffer) public static void GenBuffers( out uint buffer )
{ {
GenBuffers(1, out buffer); GenBuffers(1,out buffer);
} }
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alDeleteBuffers", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alDeleteBuffers",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
unsafe public static extern void DeleteBuffers(int n, [In] uint* buffers); // Delete Buffer objects unsafe public static extern void DeleteBuffers( int n,[In] uint* buffers ); // Delete Buffer objects
// AL_API void AL_APIENTRY alDeleteBuffers( ALsizei n, const ALuint* Buffers ); // AL_API void AL_APIENTRY alDeleteBuffers( ALsizei n, const ALuint* Buffers );
/// <summary>This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See alSourcei and alSourceUnqueueBuffers for information on how to detach a buffer from a source.</summary> /// <summary>This function deletes one or more buffers, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See alSourcei and alSourceUnqueueBuffers for information on how to detach a buffer from a source.</summary>
/// <param name="n">The number of buffers to be deleted.</param> /// <param name="n">The number of buffers to be deleted.</param>
/// <param name="buffers">Pointer to an array of buffer names identifying the buffers to be deleted.</param> /// <param name="buffers">Pointer to an array of buffer names identifying the buffers to be deleted.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void DeleteBuffers(int n, ref uint[] buffers) public static void DeleteBuffers( int n,ref uint[] buffers )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = buffers) fixed ( uint* ptr = buffers )
{ {
DeleteBuffers(n, (uint*)ptr); DeleteBuffers(n,(uint*) ptr);
} }
} }
} }
@ -880,13 +890,13 @@ namespace OpenTK.OpenAL
/// <summary>This function deletes one buffer only, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source.</summary> /// <summary>This function deletes one buffer only, freeing the resources used by the buffer. Buffers which are attached to a source can not be deleted. See AL.Source and AL.SourceUnqueueBuffers for information on how to detach a buffer from a source.</summary>
/// <param name="buffers">Pointer to a buffer name identifying the buffer to be deleted.</param> /// <param name="buffers">Pointer to a buffer name identifying the buffer to be deleted.</param>
[CLSCompliant(false)] [CLSCompliant(false)]
public static void DeleteBuffers(ref uint buffer) public static void DeleteBuffers( ref uint buffer )
{ {
unsafe unsafe
{ {
fixed (uint* ptr = &buffer) fixed ( uint* ptr = &buffer )
{ {
DeleteBuffers(1, (uint*)ptr); DeleteBuffers(1,(uint*) ptr);
} }
} }
} }
@ -894,8 +904,8 @@ namespace OpenTK.OpenAL
/// <summary>This function tests if a buffer name is valid, returning AL_TRUE if valid, AL_FALSE if not.</summary> /// <summary>This function tests if a buffer name is valid, returning AL_TRUE if valid, AL_FALSE if not.</summary>
/// <param name="bid">A buffer Handle previously allocated with <see cref="Al.GenBuffers"/>.</param> /// <param name="bid">A buffer Handle previously allocated with <see cref="Al.GenBuffers"/>.</param>
/// <returns>Success.</returns> /// <returns>Success.</returns>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alIsBuffer", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alIsBuffer",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern bool IsBuffer(uint bid); public static extern bool IsBuffer( uint bid );
// AL_API ALboolean AL_APIENTRY alIsBuffer( ALuint bid ); // AL_API ALboolean AL_APIENTRY alIsBuffer( ALuint bid );
/// <summary>This function fills a buffer with audio data. All the pre-defined formats are PCM data, but this function may be used by extensions to load other data types as well.</summary> /// <summary>This function fills a buffer with audio data. All the pre-defined formats are PCM data, but this function may be used by extensions to load other data types as well.</summary>
@ -904,8 +914,8 @@ namespace OpenTK.OpenAL
/// <param name="data">Pointer to the audio data. YOU MUST PIN THIS MANUALLY.</param> /// <param name="data">Pointer to the audio data. YOU MUST PIN THIS MANUALLY.</param>
/// <param name="size">The size of the audio data in bytes.</param> /// <param name="size">The size of the audio data in bytes.</param>
/// <param name="freq">The frequency of the audio data.</param> /// <param name="freq">The frequency of the audio data.</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alBufferData", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alBufferData",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void BufferData(uint bid, Enums.ALFormat format, IntPtr data, int size, int freq); // Specify the data to be copied into a Buffer public static extern void BufferData( uint bid,Enums.ALFormat format,IntPtr data,int size,int freq ); // Specify the data to be copied into a Buffer
// AL_API void AL_APIENTRY alBufferData( ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq ); // AL_API void AL_APIENTRY alBufferData( ALuint bid, ALenum format, const ALvoid* data, ALsizei size, ALsizei freq );
#endregion Buffer objects #endregion Buffer objects
@ -941,8 +951,8 @@ namespace OpenTK.OpenAL
/// <param name="bid">Buffer name whose attribute is being retrieved</param> /// <param name="bid">Buffer name whose attribute is being retrieved</param>
/// <param name="param">The name of the attribute to be retrieved: AL_FREQUENCY, AL_BITS, AL_CHANNELS, AL_SIZE, and the currently hidden AL_DATA.</param> /// <param name="param">The name of the attribute to be retrieved: AL_FREQUENCY, AL_BITS, AL_CHANNELS, AL_SIZE, and the currently hidden AL_DATA.</param>
/// <param name="value">A pointer to an ALint to hold the retrieved data</param> /// <param name="value">A pointer to an ALint to hold the retrieved data</param>
[CLSCompliant(false), DllImport(AL.Lib, EntryPoint = "alGetBufferi", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(AL.Lib,EntryPoint = "alGetBufferi",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void GetBuffer(uint bid, Enums.ALGetBufferi param, [Out] out int value); public static extern void GetBuffer( uint bid,Enums.ALGetBufferi param,[Out] out int value );
// AL_API void AL_APIENTRY alGetBufferi( ALuint bid, ALenum param, ALint* value ); // AL_API void AL_APIENTRY alGetBufferi( ALuint bid, ALenum param, ALint* value );
// AL_API void AL_APIENTRY alGetBufferf( ALuint bid, ALenum param, ALfloat* value ); // AL_API void AL_APIENTRY alGetBufferf( ALuint bid, ALenum param, ALfloat* value );
@ -957,20 +967,20 @@ namespace OpenTK.OpenAL
/// <summary>AL.DopplerFactor is a simple scaling of source and listener velocities to exaggerate or deemphasize the Doppler (pitch) shift resulting from the calculation.</summary> /// <summary>AL.DopplerFactor is a simple scaling of source and listener velocities to exaggerate or deemphasize the Doppler (pitch) shift resulting from the calculation.</summary>
/// <param name="value">A negative value will result in an error, the command is then ignored. The default value is 1f. The current setting can be queried using Al.GetFloat.</param> /// <param name="value">A negative value will result in an error, the command is then ignored. The default value is 1f. The current setting can be queried using Al.GetFloat.</param>
[DllImport(AL.Lib, EntryPoint = "alDopplerFactor", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alDopplerFactor",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void DopplerFactor(float value); public static extern void DopplerFactor( float value );
// AL_API void AL_APIENTRY alDopplerFactor( ALfloat value ); // AL_API void AL_APIENTRY alDopplerFactor( ALfloat value );
/// <summary>This function is deprecated and should not be used.</summary> /// <summary>This function is deprecated and should not be used.</summary>
/// <param name="value">The default is 1.0f.</param> /// <param name="value">The default is 1.0f.</param>
[DllImport(AL.Lib, EntryPoint = "alDopplerVelocity", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alDopplerVelocity",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void DopplerVelocity(float value); public static extern void DopplerVelocity( float value );
// AL_API void AL_APIENTRY alDopplerVelocity( ALfloat value ); // AL_API void AL_APIENTRY alDopplerVelocity( ALfloat value );
/// <summary>Al.SpeedOfSound allows the application to change the reference (propagation) speed used in the Doppler calculation. The source and listener velocities should be expressed in the same units as the speed of sound.</summary> /// <summary>Al.SpeedOfSound allows the application to change the reference (propagation) speed used in the Doppler calculation. The source and listener velocities should be expressed in the same units as the speed of sound.</summary>
/// <param name="value">A negative or zero value will result in an error, and the command is ignored. The default value is 343.3f (appropriate for velocity units of meters and air as the propagation medium). The current setting can be queried using Al.GetFloat</param> /// <param name="value">A negative or zero value will result in an error, and the command is ignored. The default value is 343.3f (appropriate for velocity units of meters and air as the propagation medium). The current setting can be queried using Al.GetFloat</param>
[DllImport(AL.Lib, EntryPoint = "alSpeedOfSound", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alSpeedOfSound",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void SpeedOfSound(float value); public static extern void SpeedOfSound( float value );
// AL_API void AL_APIENTRY alSpeedOfSound( ALfloat value ); // AL_API void AL_APIENTRY alSpeedOfSound( ALfloat value );
/// <summary>This function selects the OpenAL distance model – AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED, AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED, AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED, or AL_NONE. The default distance model in OpenAL is AL_INVERSE_DISTANCE_CLAMPED.</summary> /// <summary>This function selects the OpenAL distance model – AL_INVERSE_DISTANCE, AL_INVERSE_DISTANCE_CLAMPED, AL_LINEAR_DISTANCE, AL_LINEAR_DISTANCE_CLAMPED, AL_EXPONENT_DISTANCE, AL_EXPONENT_DISTANCE_CLAMPED, or AL_NONE. The default distance model in OpenAL is AL_INVERSE_DISTANCE_CLAMPED.</summary>
@ -1004,8 +1014,8 @@ namespace OpenTK.OpenAL
/// gain = 1f; /// gain = 1f;
/// </remarks> /// </remarks>
/// <param name="distancemodel"></param> /// <param name="distancemodel"></param>
[DllImport(AL.Lib, EntryPoint = "alDistanceModel", ExactSpelling = true, CallingConvention = AL.Style), SuppressUnmanagedCodeSecurity()] [DllImport(AL.Lib,EntryPoint = "alDistanceModel",ExactSpelling = true,CallingConvention = AL.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void DistanceModel(Enums.ALDistanceModel distancemodel); public static extern void DistanceModel( Enums.ALDistanceModel distancemodel );
// AL_API void AL_APIENTRY alDistanceModel( ALenum distanceModel ); // AL_API void AL_APIENTRY alDistanceModel( ALenum distanceModel );
#endregion Global Parameters #endregion Global Parameters

59
Source/OpenTK/OpenAL/AlTokens.cs
View file

@ -22,6 +22,9 @@ namespace OpenTK.OpenAL.Enums
{ {
///<summary>Indicate the gain (volume amplification) applied. Type: float. Range: [0.0f - ? ] A value of 1.0 means un-attenuated/unchanged. Each division by 2 equals an attenuation of -6dB. Each multiplicaton with 2 equals an amplification of +6dB. A value of 0.0f is meaningless with respect to a logarithmic scale; it is interpreted as zero volume - the channel is effectively disabled.</summary> ///<summary>Indicate the gain (volume amplification) applied. Type: float. Range: [0.0f - ? ] A value of 1.0 means un-attenuated/unchanged. Each division by 2 equals an attenuation of -6dB. Each multiplicaton with 2 equals an amplification of +6dB. A value of 0.0f is meaningless with respect to a logarithmic scale; it is interpreted as zero volume - the channel is effectively disabled.</summary>
Gain = 0x100A, Gain = 0x100A,
///<summary>(EFX Extension) This setting is critical if Air Absorption effects are enabled because the amount of Air Absorption applied is directly related to the real-world distance between the Source and the Listener. centimeters 0.01f meters 1.0f kilometers 1000.0f Range [float.MinValue .. float.MaxValue] Default: 1.0f</summary>
EfxMetersPerUnit = 0x20004,
} }
public enum ALListener3f : int public enum ALListener3f : int
@ -73,6 +76,16 @@ namespace OpenTK.OpenAL.Enums
/// <summary>The playback position, expressed in seconds.</summary> /// <summary>The playback position, expressed in seconds.</summary>
SecOffset = 0x1024, // AL_EXT_OFFSET extension. SecOffset = 0x1024, // AL_EXT_OFFSET extension.
///<summary>(EFX Extension) This property is a multiplier on the amount of Air Absorption applied to the Source. The AL_AIR_ABSORPTION_FACTOR is multiplied by an internal Air Absorption Gain HF value of 0.994 (-0.05dB) per meter which represents normal atmospheric humidity and temperature. Range [0.0f .. 10.0f] Default: 0.0f</summary>
EfxAirAbsorptionFactor = 0x20007,
///<summary>(EFX Extension) This property is defined the same way as the Reverb Room Rolloff property: it is one of two methods available in the Effect Extension to attenuate the reflected sound (early reflections and reverberation) according to source-listener distance. Range [0.0f .. 10.0f] Default: 0.0f</summary>
EfxRoomRolloffFactor = 0x20008,
///<summary>(EFX Extension) A directed Source points in a specified direction. The Source sounds at full volume when the listener is directly in front of the source; it is attenuated as the listener circles the Source away from the front. Range [0.0f .. 1.0f] Default: 1.0f</summary>
EfxConeOuterGainHighFrequency = 0x20009,
} }
public enum ALSource3f : int public enum ALSource3f : int
@ -94,6 +107,15 @@ namespace OpenTK.OpenAL.Enums
///<summary>Indicate whether Source is looping. Type: Al.Bool Range: [True, False] Default: False.</summary> ///<summary>Indicate whether Source is looping. Type: Al.Bool Range: [True, False] Default: False.</summary>
Looping = 0x1007, Looping = 0x1007,
///<summary>(EFX Extension)If this Source property is set to AL_TRUE (its default value), this Source’s direct-path is automatically filtered according to the orientation of the source relative to the listener and the setting of the Source property AL_CONE_OUTER_GAINHF. Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary>
EfxDirectFilterGainHighFrequencyAuto = 0x2000A,
///<summary>(EFX Extension)If this Source property is set to AL_TRUE (its default value), the intensity of this Source’s reflected sound is automatically attenuated according to source-listener distance and source directivity (as determined by the cone parameters). If it is AL_FALSE, the reflected sound is not attenuated according to distance and directivity. Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary>
EfxAuxiliarySendFilterGainAuto = 0x2000B,
///<summary>(EFX Extension)If this Source property is AL_TRUE (its default value), the intensity of this Source’s reflected sound at high frequencies will be automatically attenuated according to the high-frequency source directivity as set by the AL_CONE_OUTER_GAINHF property. If this property is AL_FALSE, the Source’s reflected sound is not filtered at all according to the Source’s directivity. Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary>
EfxAuxiliarySendFilterGainHighFrequencyAuto = 0x2000C,
} }
public enum ALSourcei : int public enum ALSourcei : int
@ -109,6 +131,15 @@ namespace OpenTK.OpenAL.Enums
///<summary>Source type (Static, Streaming or undetermined). Use enum AlSourceType for comparison</summary> ///<summary>Source type (Static, Streaming or undetermined). Use enum AlSourceType for comparison</summary>
SourceType = 0x1027, SourceType = 0x1027,
///<summary>(EFX Extension)This Source property is used to apply filtering on the direct-path (dry signal) of a Source.</summary>
EfxDirectFilter = 0x20005,
}
public enum ALSource3i : int
{
///<summary>(EFX Extension) This Source property is used to establish connections between Sources and Auxiliary Effect Slots. For a Source to feed an Effect that has been loaded into an Auxiliary Effect Slot the application must configure one of the Source’s auxiliary sends. This process involves setting 3 variables – the destination Auxiliary Effect Slot ID, the Auxiliary Send number, and an optional Filter ID.</summary>
EfxAuxiliarySendFilter = 0x20006,
} }
public enum ALSourceiGet : int public enum ALSourceiGet : int
@ -159,8 +190,10 @@ namespace OpenTK.OpenAL.Enums
{ {
///<summary>Source is Static if a Buffer has been attached using AL_Buffer</summary> ///<summary>Source is Static if a Buffer has been attached using AL_Buffer</summary>
Static = 0x1028, Static = 0x1028,
///<summary>Source is Streaming if one or more Buffers have been attached using alSourceQueueBuffers</summary> ///<summary>Source is Streaming if one or more Buffers have been attached using alSourceQueueBuffers</summary>
Streaming = 0x1029, Streaming = 0x1029,
///<summary>Source is undetermined when it has the NULL Buffer attached</summary> ///<summary>Source is undetermined when it has the NULL Buffer attached</summary>
Undetermined = 0x1030, Undetermined = 0x1030,
} }
@ -185,10 +218,13 @@ namespace OpenTK.OpenAL.Enums
{ {
///<summary>Sound sample's frequency, in units of Hertz [Hz]. This is the number of samples per second. Half of the sample frequency marks the maximum significant frequency component.</summary> ///<summary>Sound sample's frequency, in units of Hertz [Hz]. This is the number of samples per second. Half of the sample frequency marks the maximum significant frequency component.</summary>
Frequency = 0x2001, Frequency = 0x2001,
/// <summary>Bit depth of buffer. Should be 8 or 16.</summary> /// <summary>Bit depth of buffer. Should be 8 or 16.</summary>
Bits = 0x2002, Bits = 0x2002,
/// <summary>Number of channels in buffer. > 1 is valid, but buffer won’t be positioned when played. 1 for Mono, 2 for Stereo.</summary> /// <summary>Number of channels in buffer. > 1 is valid, but buffer won’t be positioned when played. 1 for Mono, 2 for Stereo.</summary>
Channels = 0x2003, Channels = 0x2003,
/// <summary>size of buffer in bytes</summary> /// <summary>size of buffer in bytes</summary>
Size = 0x2004, Size = 0x2004,
@ -200,8 +236,10 @@ namespace OpenTK.OpenAL.Enums
{ {
///<summary>Buffer state. Not supported for public use (yet).</summary> ///<summary>Buffer state. Not supported for public use (yet).</summary>
Unused = 0x2010, Unused = 0x2010,
///<summary>Buffer state. Not supported for public use (yet).</summary> ///<summary>Buffer state. Not supported for public use (yet).</summary>
Pending = 0x2011, Pending = 0x2011,
///<summary>Buffer state. Not supported for public use (yet).</summary> ///<summary>Buffer state. Not supported for public use (yet).</summary>
Processed = 0x2012, Processed = 0x2012,
} }
@ -271,16 +309,21 @@ namespace OpenTK.OpenAL.Enums
///<summary>InverseDistance is equivalent to the IASIG I3DL2 model with the exception that AL_REFERENCE_DISTANCE does not imply any clamping.</summary> ///<summary>InverseDistance is equivalent to the IASIG I3DL2 model with the exception that AL_REFERENCE_DISTANCE does not imply any clamping.</summary>
InverseDistance = 0xD001, InverseDistance = 0xD001,
///<summary>InverseDistanceClamped is the IASIG I3DL2 model, with AL_REFERENCE_DISTANCE indicating both the reference distance and the distance below which gain will be clamped.</summary> ///<summary>InverseDistanceClamped is the IASIG I3DL2 model, with AL_REFERENCE_DISTANCE indicating both the reference distance and the distance below which gain will be clamped.</summary>
InverseDistanceClamped = 0xD002, InverseDistanceClamped = 0xD002,
///<summary></summary>
LinearDistance = 0xD003, // AL_EXT_LINEAR_DISTANCE extension. ///<summary>AL_EXT_LINEAR_DISTANCE extension.</summary>
///<summary></summary> LinearDistance = 0xD003,
LinearDistanceClamped = 0xD004, // AL_EXT_LINEAR_DISTANCE extension.
///<summary></summary> ///<summary>AL_EXT_LINEAR_DISTANCE extension.</summary>
ExponentDistance = 0xD005, // AL_EXT_EXPONENT_DISTANCE extension. LinearDistanceClamped = 0xD004,
///<summary></summary>
ExponentDistanceClamped = 0xD006, // AL_EXT_EXPONENT_DISTANCE extension. ///<summary>AL_EXT_EXPONENT_DISTANCE extension.</summary>
ExponentDistance = 0xD005,
///<summary>AL_EXT_EXPONENT_DISTANCE extension.</summary>
ExponentDistanceClamped = 0xD006,
} }
} }

117
Source/OpenTK/OpenAL/AlcFunctions.cs
View file

@ -87,9 +87,9 @@ namespace OpenTK.OpenAL
/// <param name="device">a pointer to a device</param> /// <param name="device">a pointer to a device</param>
/// <param name="attrlist">a pointer to a set of attributes: ALC_FREQUENCY, ALC_MONO_SOURCES, ALC_REFRESH, ALC_STEREO_SOURCES, ALC_SYNC</param> /// <param name="attrlist">a pointer to a set of attributes: ALC_FREQUENCY, ALC_MONO_SOURCES, ALC_REFRESH, ALC_STEREO_SOURCES, ALC_SYNC</param>
/// <returns>Returns a pointer to the new context (NULL on failure). The attribute list can be NULL, or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values.</returns> /// <returns>Returns a pointer to the new context (NULL on failure). The attribute list can be NULL, or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcCreateContext", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity] [DllImport(Alc.Lib,EntryPoint = "alcCreateContext",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity]
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe public static extern IntPtr CreateContext([In] IntPtr device, [In] int* attrlist); unsafe public static extern IntPtr CreateContext( [In] IntPtr device,[In] int* attrlist );
// ALC_API ALCcontext * ALC_APIENTRY alcCreateContext( ALCdevice *device, const ALCint* attrlist ); // ALC_API ALCcontext * ALC_APIENTRY alcCreateContext( ALCdevice *device, const ALCint* attrlist );
/// <summary>This function creates a context using a specified device.</summary> /// <summary>This function creates a context using a specified device.</summary>
@ -97,13 +97,13 @@ namespace OpenTK.OpenAL
/// <param name="attrlist">an array of a set of attributes: ALC_FREQUENCY, ALC_MONO_SOURCES, ALC_REFRESH, ALC_STEREO_SOURCES, ALC_SYNC</param> /// <param name="attrlist">an array of a set of attributes: ALC_FREQUENCY, ALC_MONO_SOURCES, ALC_REFRESH, ALC_STEREO_SOURCES, ALC_SYNC</param>
/// <returns>Returns a pointer to the new context (NULL on failure).</returns> /// <returns>Returns a pointer to the new context (NULL on failure).</returns>
/// <remarks>The attribute list can be NULL, or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values.</remarks> /// <remarks>The attribute list can be NULL, or a zero terminated list of integer pairs composed of valid ALC attribute tokens and requested values.</remarks>
public static IntPtr CreateContext(IntPtr device, int[] attriblist) public static IntPtr CreateContext( IntPtr device,int[] attriblist )
{ {
unsafe unsafe
{ {
fixed (int* attriblist_ptr = attriblist) fixed ( int* attriblist_ptr = attriblist )
{ {
return CreateContext(device, attriblist_ptr); return CreateContext(device,attriblist_ptr);
} }
} }
} }
@ -113,39 +113,39 @@ namespace OpenTK.OpenAL
/// <summary>This function makes a specified context the current context.</summary> /// <summary>This function makes a specified context the current context.</summary>
/// <param name="context">A pointer to the new context.</param> /// <param name="context">A pointer to the new context.</param>
/// <returns>Returns True on success, or False on failure.</returns> /// <returns>Returns True on success, or False on failure.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcMakeContextCurrent", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcMakeContextCurrent",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern bool MakeContextCurrent([In] IntPtr context); public static extern bool MakeContextCurrent( [In] IntPtr context );
// ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent( ALCcontext *context ); // ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent( ALCcontext *context );
/// <summary>This function tells a context to begin processing. When a context is suspended, changes in OpenAL state will be accepted but will not be processed. alcSuspendContext can be used to suspend a context, and then all the OpenAL state changes can be applied at once, followed by a call to alcProcessContext to apply all the state changes immediately. In some cases, this procedure may be more efficient than application of properties in a non-suspended state. In some implementations, process and suspend calls are each a NOP.</summary> /// <summary>This function tells a context to begin processing. When a context is suspended, changes in OpenAL state will be accepted but will not be processed. alcSuspendContext can be used to suspend a context, and then all the OpenAL state changes can be applied at once, followed by a call to alcProcessContext to apply all the state changes immediately. In some cases, this procedure may be more efficient than application of properties in a non-suspended state. In some implementations, process and suspend calls are each a NOP.</summary>
/// <param name="context">a pointer to the new context</param> /// <param name="context">a pointer to the new context</param>
[DllImport(Alc.Lib, EntryPoint = "alcProcessContext", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcProcessContext",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void ProcessContext([In] IntPtr context); public static extern void ProcessContext( [In] IntPtr context );
// ALC_API void ALC_APIENTRY alcProcessContext( ALCcontext *context ); // ALC_API void ALC_APIENTRY alcProcessContext( ALCcontext *context );
/// <summary>This function suspends processing on a specified context. When a context is suspended, changes in OpenAL state will be accepted but will not be processed. A typical use of alcSuspendContext would be to suspend a context, apply all the OpenAL state changes at once, and then call alcProcessContext to apply all the state changes at once. In some cases, this procedure may be more efficient than application of properties in a non-suspended state. In some implementations, process and suspend calls are each a NOP.</summary> /// <summary>This function suspends processing on a specified context. When a context is suspended, changes in OpenAL state will be accepted but will not be processed. A typical use of alcSuspendContext would be to suspend a context, apply all the OpenAL state changes at once, and then call alcProcessContext to apply all the state changes at once. In some cases, this procedure may be more efficient than application of properties in a non-suspended state. In some implementations, process and suspend calls are each a NOP.</summary>
/// <param name="context">a pointer to the context to be suspended.</param> /// <param name="context">a pointer to the context to be suspended.</param>
[DllImport(Alc.Lib, EntryPoint = "alcSuspendContext", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcSuspendContext",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void SuspendContext([In] IntPtr context); public static extern void SuspendContext( [In] IntPtr context );
// ALC_API void ALC_APIENTRY alcSuspendContext( ALCcontext *context ); // ALC_API void ALC_APIENTRY alcSuspendContext( ALCcontext *context );
/// <summary>This function destroys a context.</summary> /// <summary>This function destroys a context.</summary>
/// <param name="context">a pointer to the new context.</param> /// <param name="context">a pointer to the new context.</param>
[DllImport(Alc.Lib, EntryPoint = "alcDestroyContext", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcDestroyContext",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void DestroyContext([In] IntPtr context); public static extern void DestroyContext( [In] IntPtr context );
// ALC_API void ALC_APIENTRY alcDestroyContext( ALCcontext *context ); // ALC_API void ALC_APIENTRY alcDestroyContext( ALCcontext *context );
/// <summary>This function retrieves the current context.</summary> /// <summary>This function retrieves the current context.</summary>
/// <returns>Returns a pointer to the current context.</returns> /// <returns>Returns a pointer to the current context.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcGetCurrentContext", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcGetCurrentContext",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern IntPtr GetCurrentContext(); public static extern IntPtr GetCurrentContext( );
// ALC_API ALCcontext * ALC_APIENTRY alcGetCurrentContext( void ); // ALC_API ALCcontext * ALC_APIENTRY alcGetCurrentContext( void );
/// <summary>This function retrieves a context's device pointer.</summary> /// <summary>This function retrieves a context's device pointer.</summary>
/// <param name="context">a pointer to a context.</param> /// <param name="context">a pointer to a context.</param>
/// <returns>Returns a pointer to the specified context's device.</returns> /// <returns>Returns a pointer to the specified context's device.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcGetContextsDevice", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcGetContextsDevice",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern IntPtr GetContextsDevice([In] IntPtr context); public static extern IntPtr GetContextsDevice( [In] IntPtr context );
// ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice( ALCcontext *context ); // ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice( ALCcontext *context );
#endregion Context Management #endregion Context Management
@ -155,15 +155,15 @@ namespace OpenTK.OpenAL
/// <summary>This function opens a device by name.</summary> /// <summary>This function opens a device by name.</summary>
/// <param name="devicename">a null-terminated string describing a device.</param> /// <param name="devicename">a null-terminated string describing a device.</param>
/// <returns>Returns a pointer to the opened device. The return value will be NULL if there is an error.</returns> /// <returns>Returns a pointer to the opened device. The return value will be NULL if there is an error.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcOpenDevice", ExactSpelling = true, CallingConvention = Alc.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcOpenDevice",ExactSpelling = true,CallingConvention = Alc.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern IntPtr OpenDevice([In] string devicename); public static extern IntPtr OpenDevice( [In] string devicename );
// ALC_API ALCdevice * ALC_APIENTRY alcOpenDevice( const ALCchar *devicename ); // ALC_API ALCdevice * ALC_APIENTRY alcOpenDevice( const ALCchar *devicename );
/// <summary>This function closes a device by name.</summary> /// <summary>This function closes a device by name.</summary>
/// <param name="device">a pointer to an opened device</param> /// <param name="device">a pointer to an opened device</param>
/// <returns>True will be returned on success or False on failure. Closing a device will fail if the device contains any contexts or buffers.</returns> /// <returns>True will be returned on success or False on failure. Closing a device will fail if the device contains any contexts or buffers.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcCloseDevice", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcCloseDevice",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern bool CloseDevice([In] IntPtr device); public static extern bool CloseDevice( [In] IntPtr device );
// ALC_API ALCboolean ALC_APIENTRY alcCloseDevice( ALCdevice *device ); // ALC_API ALCboolean ALC_APIENTRY alcCloseDevice( ALCdevice *device );
#endregion Device Management #endregion Device Management
@ -173,8 +173,8 @@ namespace OpenTK.OpenAL
/// <summary>This function retrieves the current context error state.</summary> /// <summary>This function retrieves the current context error state.</summary>
/// <param name="device">a pointer to the device to retrieve the error state from</param> /// <param name="device">a pointer to the device to retrieve the error state from</param>
/// <returns>Errorcode Int32.</returns> /// <returns>Errorcode Int32.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcGetError", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcGetError",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern Enums.AlcError GetError([In] IntPtr device); public static extern Enums.AlcError GetError( [In] IntPtr device );
// ALC_API ALCenum ALC_APIENTRY alcGetError( ALCdevice *device ); // ALC_API ALCenum ALC_APIENTRY alcGetError( ALCdevice *device );
#endregion Error support. #endregion Error support.
@ -185,32 +185,32 @@ namespace OpenTK.OpenAL
/// <param name="device">a pointer to the device to be queried for an extension.</param> /// <param name="device">a pointer to the device to be queried for an extension.</param>
/// <param name="extname">a null-terminated string describing the extension.</param> /// <param name="extname">a null-terminated string describing the extension.</param>
/// <returns>Returns True if the extension is available, False if the extension is not available.</returns> /// <returns>Returns True if the extension is available, False if the extension is not available.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcIsExtensionPresent", ExactSpelling = true, CallingConvention = Alc.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcIsExtensionPresent",ExactSpelling = true,CallingConvention = Alc.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern bool IsExtensionPresent([In] IntPtr device, [In] string extname); public static extern bool IsExtensionPresent( [In] IntPtr device,[In] string extname );
// ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent( ALCdevice *device, const ALCchar *extname ); // ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent( ALCdevice *device, const ALCchar *extname );
/// <summary>This function retrieves the address of a specified context extension function.</summary> /// <summary>This function retrieves the address of a specified context extension function.</summary>
/// <param name="device">a pointer to the device to be queried for the function.</param> /// <param name="device">a pointer to the device to be queried for the function.</param>
/// <param name="funcname">a null-terminated string describing the function.</param> /// <param name="funcname">a null-terminated string describing the function.</param>
/// <returns>Returns the address of the function, or NULL if it is not found.</returns> /// <returns>Returns the address of the function, or NULL if it is not found.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcGetProcAddress", ExactSpelling = true, CallingConvention = Alc.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcGetProcAddress",ExactSpelling = true,CallingConvention = Alc.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern IntPtr GetProcAddress([In] IntPtr device, [In] string funcname); public static extern IntPtr GetProcAddress( [In] IntPtr device,[In] string funcname );
// ALC_API void * ALC_APIENTRY alcGetProcAddress( ALCdevice *device, const ALCchar *funcname ); // ALC_API void * ALC_APIENTRY alcGetProcAddress( ALCdevice *device, const ALCchar *funcname );
/// <summary>This function retrieves the enum value for a specified enumeration name.</summary> /// <summary>This function retrieves the enum value for a specified enumeration name.</summary>
/// <param name="device">a pointer to the device to be queried.</param> /// <param name="device">a pointer to the device to be queried.</param>
/// <param name="enumname">a null terminated string describing the enum value.</param> /// <param name="enumname">a null terminated string describing the enum value.</param>
/// <returns>Returns the enum value described by the enumName string. This is most often used for querying an enum value for an ALC extension.</returns> /// <returns>Returns the enum value described by the enumName string. This is most often used for querying an enum value for an ALC extension.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcGetEnumValue", ExactSpelling = true, CallingConvention = Alc.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcGetEnumValue",ExactSpelling = true,CallingConvention = Alc.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern int GetEnumValue([In] IntPtr device, [In] string enumname); public static extern int GetEnumValue( [In] IntPtr device,[In] string enumname );
// ALC_API ALCenum ALC_APIENTRY alcGetEnumValue( ALCdevice *device, const ALCchar *enumname ); // ALC_API ALCenum ALC_APIENTRY alcGetEnumValue( ALCdevice *device, const ALCchar *enumname );
#endregion Extension support. #endregion Extension support.
#region Query functions #region Query functions
[DllImport(Alc.Lib, EntryPoint = "alcGetString", ExactSpelling = true, CallingConvention = Alc.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcGetString",ExactSpelling = true,CallingConvention = Alc.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
private static extern IntPtr GetStringPrivate([In] IntPtr device, Enums.AlcGetString param); private static extern IntPtr GetStringPrivate( [In] IntPtr device,Enums.AlcGetString param );
// ALC_API const ALCchar * ALC_APIENTRY alcGetString( ALCdevice *device, ALCenum param ); // ALC_API const ALCchar * ALC_APIENTRY alcGetString( ALCdevice *device, ALCenum param );
/// <summary>This function returns pointers to strings related to the context.</summary> /// <summary>This function returns pointers to strings related to the context.</summary>
@ -224,9 +224,9 @@ namespace OpenTK.OpenAL
/// <param name="device">a pointer to the device to be queried.</param> /// <param name="device">a pointer to the device to be queried.</param>
/// <param name="param">an attribute to be retrieved: ALC_DEFAULT_DEVICE_SPECIFIER, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER, ALC_DEVICE_SPECIFIER, ALC_CAPTURE_DEVICE_SPECIFIER, ALC_EXTENSIONS</param> /// <param name="param">an attribute to be retrieved: ALC_DEFAULT_DEVICE_SPECIFIER, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER, ALC_DEVICE_SPECIFIER, ALC_CAPTURE_DEVICE_SPECIFIER, ALC_EXTENSIONS</param>
/// <returns>A string containing the name of the Device.</returns> /// <returns>A string containing the name of the Device.</returns>
public static string GetString(IntPtr device, Enums.AlcGetString param) public static string GetString( IntPtr device,Enums.AlcGetString param )
{ {
return Marshal.PtrToStringAnsi(GetStringPrivate(device, param)); return Marshal.PtrToStringAnsi(GetStringPrivate(device,param));
} }
/// <summary>This function returns a List of strings related to the context.</summary> /// <summary>This function returns a List of strings related to the context.</summary>
@ -238,29 +238,29 @@ namespace OpenTK.OpenAL
/// <param name="device">a pointer to the device to be queried.</param> /// <param name="device">a pointer to the device to be queried.</param>
/// <param name="param">an attribute to be retrieved: ALC_DEVICE_SPECIFIER, ALC_CAPTURE_DEVICE_SPECIFIER, ALC_ALL_DEVICES_SPECIFIER</param> /// <param name="param">an attribute to be retrieved: ALC_DEVICE_SPECIFIER, ALC_CAPTURE_DEVICE_SPECIFIER, ALC_ALL_DEVICES_SPECIFIER</param>
/// <returns>A List of strings containing the names of the Devices.</returns> /// <returns>A List of strings containing the names of the Devices.</returns>
public static IList<string> GetString(IntPtr device, Enums.AlcGetStringList param) public static IList<string> GetString( IntPtr device,Enums.AlcGetStringList param )
{ {
List<string> result = new List<string>(); List<string> result = new List<string>( );
IntPtr t = GetStringPrivate(AL.Null, (Enums.AlcGetString)Enums.AlcGetStringList.DeviceSpecifier); IntPtr t = GetStringPrivate(AL.Null,(Enums.AlcGetString) Enums.AlcGetStringList.DeviceSpecifier);
System.Text.StringBuilder sb = new System.Text.StringBuilder(); System.Text.StringBuilder sb = new System.Text.StringBuilder( );
byte b; byte b;
int offset = 0; int offset = 0;
do do
{ {
b = Marshal.ReadByte(t, offset++); b = Marshal.ReadByte(t,offset++);
if (b != 0) if ( b != 0 )
sb.Append((char)b); sb.Append((char) b);
if (b == 0) if ( b == 0 )
{ {
result.Add(sb.ToString()); result.Add(sb.ToString( ));
if (Marshal.ReadByte(t, offset) == 0) // offset already properly increased through ++ if ( Marshal.ReadByte(t,offset) == 0 ) // offset already properly increased through ++
break; // 2x null break; // 2x null
else else
sb.Remove(0, sb.Length); // 1x null sb.Remove(0,sb.Length); // 1x null
} }
} while (true); } while ( true );
return (IList<string>)result; return (IList<string>) result;
} }
/// <summary>This function returns integers related to the context.</summary> /// <summary>This function returns integers related to the context.</summary>
@ -268,8 +268,8 @@ namespace OpenTK.OpenAL
/// <param name="param">an attribute to be retrieved: ALC_MAJOR_VERSION, ALC_MINOR_VERSION, ALC_ATTRIBUTES_SIZE, ALC_ALL_ATTRIBUTES</param> /// <param name="param">an attribute to be retrieved: ALC_MAJOR_VERSION, ALC_MINOR_VERSION, ALC_ATTRIBUTES_SIZE, ALC_ALL_ATTRIBUTES</param>
/// <param name="size">the size of the destination buffer provided. In bytes.</param> /// <param name="size">the size of the destination buffer provided. In bytes.</param>
/// <param name="data">a pointer to the data to be returned</param> /// <param name="data">a pointer to the data to be returned</param>
[DllImport(Alc.Lib, EntryPoint = "alcGetIntegerv", ExactSpelling = true, CallingConvention = Alc.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcGetIntegerv",ExactSpelling = true,CallingConvention = Alc.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern void GetInteger([In] IntPtr device, Enums.AlcGetInteger param, int size, [Out] out int data); public static extern void GetInteger( [In] IntPtr device,Enums.AlcGetInteger param,int size,[Out] out int data );
// ALC_API void ALC_APIENTRY alcGetIntegerv( ALCdevice *device, ALCenum param, ALCsizei size, ALCint *data ); // ALC_API void ALC_APIENTRY alcGetIntegerv( ALCdevice *device, ALCenum param, ALCsizei size, ALCint *data );
#endregion Query functions #endregion Query functions
@ -282,39 +282,40 @@ namespace OpenTK.OpenAL
/// <param name="format">the requested capture buffer format</param> /// <param name="format">the requested capture buffer format</param>
/// <param name="buffersize">the size of the capture buffer in bytes</param> /// <param name="buffersize">the size of the capture buffer in bytes</param>
/// <returns>Returns the capture device pointer, or NULL on failure.</returns> /// <returns>Returns the capture device pointer, or NULL on failure.</returns>
[CLSCompliant(false), DllImport(Alc.Lib, EntryPoint = "alcCaptureOpenDevice", ExactSpelling = true, CallingConvention = Alc.Style, CharSet = CharSet.Ansi), SuppressUnmanagedCodeSecurity()] [CLSCompliant(false),DllImport(Alc.Lib,EntryPoint = "alcCaptureOpenDevice",ExactSpelling = true,CallingConvention = Alc.Style,CharSet = CharSet.Ansi),SuppressUnmanagedCodeSecurity( )]
public static extern IntPtr CaptureOpenDevice(string devicename, uint frequency, Enums.ALFormat format, int buffersize); public static extern IntPtr CaptureOpenDevice( string devicename,uint frequency,Enums.ALFormat format,int buffersize );
// ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice( const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize ); // ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice( const ALCchar *devicename, ALCuint frequency, ALCenum format, ALCsizei buffersize );
/// <summary>This function closes the specified capture device.</summary> /// <summary>This function closes the specified capture device.</summary>
/// <param name="device">a pointer to a capture device.</param> /// <param name="device">a pointer to a capture device.</param>
/// <returns>Returns True if the close operation was successful, False on failure.</returns> /// <returns>Returns True if the close operation was successful, False on failure.</returns>
[DllImport(Alc.Lib, EntryPoint = "alcCaptureCloseDevice", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcCaptureCloseDevice",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern bool CaptureCloseDevice([In] IntPtr device); public static extern bool CaptureCloseDevice( [In] IntPtr device );
// ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice( ALCdevice *device ); // ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice( ALCdevice *device );
/// <summary>This function begins a capture operation.</summary> /// <summary>This function begins a capture operation.</summary>
/// <remarks>alcCaptureStart will begin recording to an internal ring buffer of the size specified when opening the capture device. The application can then retrieve the number of samples currently available using the ALC_CAPTURE_SAPMPLES token with alcGetIntegerv. When the application determines that enough samples are available for processing, then it can obtain them with a call to alcCaptureSamples.</remarks> /// <remarks>alcCaptureStart will begin recording to an internal ring buffer of the size specified when opening the capture device. The application can then retrieve the number of samples currently available using the ALC_CAPTURE_SAPMPLES token with alcGetIntegerv. When the application determines that enough samples are available for processing, then it can obtain them with a call to alcCaptureSamples.</remarks>
/// <param name="device">a pointer to a capture device.</param> /// <param name="device">a pointer to a capture device.</param>
[DllImport(Alc.Lib, EntryPoint = "alcCaptureStart", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcCaptureStart",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void CaptureStart([In] IntPtr device); public static extern void CaptureStart( [In] IntPtr device );
// ALC_API void ALC_APIENTRY alcCaptureStart( ALCdevice *device ); // ALC_API void ALC_APIENTRY alcCaptureStart( ALCdevice *device );
/// <summary>This function stops a capture operation.</summary> /// <summary>This function stops a capture operation.</summary>
/// <param name="device">a pointer to a capture device.</param> /// <param name="device">a pointer to a capture device.</param>
[DllImport(Alc.Lib, EntryPoint = "alcCaptureStop", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcCaptureStop",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void CaptureStop([In] IntPtr device); public static extern void CaptureStop( [In] IntPtr device );
// ALC_API void ALC_APIENTRY alcCaptureStop( ALCdevice *device ); // ALC_API void ALC_APIENTRY alcCaptureStop( ALCdevice *device );
/// <summary>This function completes a capture operation, and does not block.</summary> /// <summary>This function completes a capture operation, and does not block.</summary>
/// <param name="device">a pointer to a capture device.</param> /// <param name="device">a pointer to a capture device.</param>
/// <param name="buffer">a pointer to a data buffer, which must be large enough to accommodate samples number of samples.</param> /// <param name="buffer">a pointer to a data buffer, which must be large enough to accommodate samples number of samples.</param>
/// <param name="samples">the number of samples to be retrieved.</param> /// <param name="samples">the number of samples to be retrieved.</param>
[DllImport(Alc.Lib, EntryPoint = "alcCaptureSamples", ExactSpelling = true, CallingConvention = Alc.Style), SuppressUnmanagedCodeSecurity()] [DllImport(Alc.Lib,EntryPoint = "alcCaptureSamples",ExactSpelling = true,CallingConvention = Alc.Style),SuppressUnmanagedCodeSecurity( )]
public static extern void CaptureSamples([In] IntPtr device, [Out] out IntPtr buffer, [Out] out int samples); public static extern void CaptureSamples( [In] IntPtr device,[Out] out IntPtr buffer,[Out] out int samples );
// ALC_API void ALC_APIENTRY alcCaptureSamples( ALCdevice *device, ALCvoid *buffer, ALCsizei samples ); // ALC_API void ALC_APIENTRY alcCaptureSamples( ALCdevice *device, ALCvoid *buffer, ALCsizei samples );
#endregion Capture functions #endregion Capture functions
} }
} }

12
Source/OpenTK/OpenAL/AlcTokens.cs
View file

@ -28,6 +28,9 @@ namespace OpenTK.OpenAL.Enums
///<summary>Followed by System.Int32 Num of requested Stereo Sources</summary> ///<summary>Followed by System.Int32 Num of requested Stereo Sources</summary>
StereoSources = 0x1011, StereoSources = 0x1011,
/// <summary>(EFX Extension) This Context property can be passed to OpenAL during Context creation (alcCreateContext) to request a maximum number of Auxiliary Sends desired on each Source. It is not guaranteed that the desired number of sends will be available, so an application should query this property after creating the context using alcGetIntergerv. Default: 2</summary>
EfxMaxAuxiliarySends = 0x20003,
} }
public enum AlcError : int public enum AlcError : int
@ -105,5 +108,14 @@ namespace OpenTK.OpenAL.Enums
///<summary>The number of capture samples available. NULL is an invalid device.</summary> ///<summary>The number of capture samples available. NULL is an invalid device.</summary>
CaptureSamples = 0x312, CaptureSamples = 0x312,
/// <summary>(EFX Extension) This property can be used by the application to retrieve the Major version number of the Effects Extension supported by this OpenAL implementation. As this is a Context property is should be retrieved using alcGetIntegerv.</summary>
EfxMajorVersion = 0x20001,
/// <summary>(EFX Extension) This property can be used by the application to retrieve the Minor version number of the Effects Extension supported by this OpenAL implementation. As this is a Context property is should be retrieved using alcGetIntegerv.</summary>
EfxMinorVersion = 0x20002,
/// <summary>(EFX Extension) This Context property can be passed to OpenAL during Context creation (alcCreateContext) to request a maximum number of Auxiliary Sends desired on each Source. It is not guaranteed that the desired number of sends will be available, so an application should query this property after creating the context using alcGetIntergerv. Default: 2</summary>
EfxMaxAuxiliarySends = 0x20003,
} }
} }

311
Source/OpenTK/OpenAL/EfxFunctions.cs
View file

@ -12,37 +12,169 @@ using System.Runtime.InteropServices;
namespace OpenTK.OpenAL namespace OpenTK.OpenAL
{ {
public partial class Efx
public partial class EfxExtension
{ {
#region Effect object delegates #region Effect Object
#region alGenEffects
// typedef void (__cdecl *LPALGENEFFECTS)( ALsizei n, ALuint* effects ); // typedef void (__cdecl *LPALGENEFFECTS)( ALsizei n, ALuint* effects );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGenEffects(int n, [Out] uint* effects); unsafe private delegate void Delegate_alGenEffects( int n,[Out] uint* effects );
[CLSCompliant(false)]
private Delegate_alGenEffects Imported_alGenEffects;
[CLSCompliant(false)]
public void GenEffects( int n,out uint sources )
{
unsafe
{
fixed ( uint* ptr = &sources )
{
Imported_alGenEffects(n,ptr);
sources = *ptr;
}
}
}
[CLSCompliant(false)]
/// <summary>This function generates only one Effect.</summary>
/// <param name="sources">Storage UInt32 for the new effect name/handle.</param>
public void GenEffects( out uint source )
{
unsafe
{
fixed ( uint* ptr = &source )
{
Imported_alGenEffects(1,ptr);
}
}
}
#endregion alGenEffects
#region alDeleteEffects
// typedef void (__cdecl *LPALDELETEEFFECTS)( ALsizei n, ALuint* effects ); // typedef void (__cdecl *LPALDELETEEFFECTS)( ALsizei n, ALuint* effects );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alDeleteEffects(int n, [In] uint* effects); unsafe private delegate void Delegate_alDeleteEffects( int n,[In] uint* effects );
[CLSCompliant(false)]
private Delegate_alDeleteEffects Imported_alDeleteEffects;
[CLSCompliant(false)]
public void DeleteEffects( int n,ref uint[] sources )
{
unsafe
{
fixed ( uint* ptr = sources )
{
Imported_alDeleteEffects(n,ptr);
}
}
}
/// <summary>This function deletes one Effect only.</summary>
/// <param name="sources">Pointer to an effect name/handle identifying the Effect Object to be deleted.</param>
[CLSCompliant(false)]
public void DeleteEffects( ref uint source )
{
unsafe
{
fixed ( uint* ptr = &source )
{
Imported_alDeleteEffects(1,ptr);
}
}
}
#endregion alDeleteEffects
#region alIsEffect
// typedef ALboolean (__cdecl *LPALISEFFECT)( ALuint eid ); // typedef ALboolean (__cdecl *LPALISEFFECT)( ALuint eid );
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate bool Delegate_alIsEffect(uint eid); public delegate bool Delegate_alIsEffect( uint eid );
[CLSCompliant(false)]
public Delegate_alIsEffect IsEffect;
#endregion alIsEffect
#region alEffecti
// typedef void (__cdecl *LPALEFFECTI)( ALuint eid, ALenum param, ALint value); // typedef void (__cdecl *LPALEFFECTI)( ALuint eid, ALenum param, ALint value);
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate void Delegate_alEffecti(uint eid, Enums.EfxEffecti param, int value); public delegate void Delegate_alEffecti( uint eid,Enums.EfxEffecti param,int value );
[CLSCompliant(false)]
public Delegate_alEffecti Effecti;
public void BindEffect( uint eid,Enums.EfxEffectType type )
{
Effecti(eid,Enums.EfxEffecti.EffectType,(int) type);
}
#endregion alEffecti
#region alEffectf
// typedef void (__cdecl *LPALEFFECTF)( ALuint eid, ALenum param, ALfloat value); // typedef void (__cdecl *LPALEFFECTF)( ALuint eid, ALenum param, ALfloat value);
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate void Delegate_alEffectf(uint eid, Enums.EfxEffectf param, float value); public delegate void Delegate_alEffectf( uint eid,Enums.EfxEffectf param,float value );
[CLSCompliant(false)]
public Delegate_alEffectf Effectf;
#endregion alEffectf
#region alGetEffecti
// typedef void (__cdecl *LPALGETEFFECTI)( ALuint eid, ALenum pname, ALint* value ); // typedef void (__cdecl *LPALGETEFFECTI)( ALuint eid, ALenum pname, ALint* value );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGetEffecti(uint eid, Enums.EfxEffecti pname, [Out] int* value); unsafe private delegate void Delegate_alGetEffecti( uint eid,Enums.EfxEffecti pname,[Out] int* value );
[CLSCompliant(false)]
private Delegate_alGetEffecti Imported_alGetEffecti;
[CLSCompliant(false)]
public void GetEffect( uint eid,Enums.EfxEffecti pname,out int value )
{
unsafe
{
fixed ( int* ptr = &value )
{
Imported_alGetEffecti(eid,pname,ptr);
}
}
}
#endregion alGetEffecti
#region alGetEffectf
// typedef void (__cdecl *LPALGETEFFECTF)( ALuint eid, ALenum pname, ALfloat* value ); // typedef void (__cdecl *LPALGETEFFECTF)( ALuint eid, ALenum pname, ALfloat* value );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGetEffectf(uint eid, Enums.EfxEffectf pname, [Out]float* value); unsafe private delegate void Delegate_alGetEffectf( uint eid,Enums.EfxEffectf pname,[Out]float* value );
[CLSCompliant(false)]
private Delegate_alGetEffectf Imported_alGetEffectf;
[CLSCompliant(false)]
public void GetEffect( uint eid,Enums.EfxEffectf pname,out float value )
{
unsafe
{
fixed ( float* ptr = &value )
{
Imported_alGetEffectf(eid,pname,ptr);
}
}
}
#endregion alGetEffectf
// Not used: // Not used:
// typedef void (__cdecl *LPALEFFECTIV)( ALuint eid, ALenum param, ALint* values ); // typedef void (__cdecl *LPALEFFECTIV)( ALuint eid, ALenum param, ALint* values );
@ -50,37 +182,39 @@ namespace OpenTK.OpenAL
// typedef void (__cdecl *LPALGETEFFECTIV)( ALuint eid, ALenum pname, ALint* values ); // typedef void (__cdecl *LPALGETEFFECTIV)( ALuint eid, ALenum pname, ALint* values );
// typedef void (__cdecl *LPALGETEFFECTFV)( ALuint eid, ALenum pname, ALfloat* values ); // typedef void (__cdecl *LPALGETEFFECTFV)( ALuint eid, ALenum pname, ALfloat* values );
#endregion Effect object delegates #endregion Effect Object
#region Filter Object
#region Filter object delegates #region Filter object delegates
// typedef void (__cdecl *LPALGENFILTERS)( ALsizei n, ALuint* filters ); // typedef void (__cdecl *LPALGENFILTERS)( ALsizei n, ALuint* filters );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGenFilters(int n, [Out] uint* filters); unsafe private delegate void Delegate_alGenFilters( int n,[Out] uint* filters );
// typedef void (__cdecl *LPALDELETEFILTERS)( ALsizei n, ALuint* filters ); // typedef void (__cdecl *LPALDELETEFILTERS)( ALsizei n, ALuint* filters );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alDeleteFilters(int n, [In] uint* filters); unsafe private delegate void Delegate_alDeleteFilters( int n,[In] uint* filters );
// typedef ALboolean (__cdecl *LPALISFILTER)( ALuint fid ); // typedef ALboolean (__cdecl *LPALISFILTER)( ALuint fid );
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate bool Delegate_alIsFilter(uint fid); public delegate bool Delegate_alIsFilter( uint fid );
// typedef void (__cdecl *LPALFILTERI)( ALuint fid, ALenum param, ALint value ); // typedef void (__cdecl *LPALFILTERI)( ALuint fid, ALenum param, ALint value );
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate void Delegate_alFilteri(uint fid, Enums.EfxFilteri param, int value); public delegate void Delegate_alFilteri( uint fid,Enums.EfxFilteri param,int value );
// typedef void (__cdecl *LPALFILTERF)( ALuint fid, ALenum param, ALfloat value); // typedef void (__cdecl *LPALFILTERF)( ALuint fid, ALenum param, ALfloat value);
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate void Delegate_alFilterf(uint fid, Enums.EfxFilterf param, float value); public delegate void Delegate_alFilterf( uint fid,Enums.EfxFilterf param,float value );
// typedef void (__cdecl *LPALGETFILTERI)( ALuint fid, ALenum pname, ALint* value ); // typedef void (__cdecl *LPALGETFILTERI)( ALuint fid, ALenum pname, ALint* value );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGetFilteri(uint fid, Enums.EfxFilteri pname, [Out] int* value); unsafe private delegate void Delegate_alGetFilteri( uint fid,Enums.EfxFilteri pname,[Out] int* value );
// typedef void (__cdecl *LPALGETFILTERF)( ALuint fid, ALenum pname, ALfloat* value ); // typedef void (__cdecl *LPALGETFILTERF)( ALuint fid, ALenum pname, ALfloat* value );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGetFilterf(uint fid, Enums.EfxFilterf pname, [Out] float* value); unsafe private delegate void Delegate_alGetFilterf( uint fid,Enums.EfxFilterf pname,[Out] float* value );
// Not used: // Not used:
// typedef void (__cdecl *LPALFILTERIV)( ALuint fid, ALenum param, ALint* values ); // typedef void (__cdecl *LPALFILTERIV)( ALuint fid, ALenum param, ALint* values );
@ -90,35 +224,57 @@ namespace OpenTK.OpenAL
#endregion Filter object delegates #endregion Filter object delegates
#region Filter object functions
[CLSCompliant(false)]
private Delegate_alGenFilters Imported_alGenFilters;
[CLSCompliant(false)]
private Delegate_alDeleteFilters Imported_alDeleteFilters;
[CLSCompliant(false)]
public Delegate_alIsFilter IsFilter;
[CLSCompliant(false)]
public Delegate_alFilteri Filteri;
[CLSCompliant(false)]
public Delegate_alFilterf Filterf;
[CLSCompliant(false)]
private Delegate_alGetFilteri Imported_alGetFilteri;
[CLSCompliant(false)]
private Delegate_alGetFilterf Imported_alGetFilterf;
#endregion Filter object functions
#endregion Filter Object
#region Auxiliary Slot object delegates #region Auxiliary Slot object delegates
// typedef void (__cdecl *LPALGENAUXILIARYEFFECTSLOTS)( ALsizei n, ALuint* slots ); // typedef void (__cdecl *LPALGENAUXILIARYEFFECTSLOTS)( ALsizei n, ALuint* slots );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGenAuxiliaryEffectSlots(int n, [Out] uint* slots); unsafe private delegate void Delegate_alGenAuxiliaryEffectSlots( int n,[Out] uint* slots );
// typedef void (__cdecl *LPALDELETEAUXILIARYEFFECTSLOTS)( ALsizei n, ALuint* slots ); // typedef void (__cdecl *LPALDELETEAUXILIARYEFFECTSLOTS)( ALsizei n, ALuint* slots );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alDeleteAuxiliaryEffectSlots(int n, [In] uint* slots); unsafe private delegate void Delegate_alDeleteAuxiliaryEffectSlots( int n,[In] uint* slots );
// typedef ALboolean (__cdecl *LPALISAUXILIARYEFFECTSLOT)( ALuint slot ); // typedef ALboolean (__cdecl *LPALISAUXILIARYEFFECTSLOT)( ALuint slot );
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate bool Delegate_alIsAuxiliaryEffectSlot(uint slot); public delegate bool Delegate_alIsAuxiliaryEffectSlot( uint slot );
// typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTI)( ALuint asid, ALenum param, ALint value ); // typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTI)( ALuint asid, ALenum param, ALint value );
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate void Delegate_alAuxiliaryEffectSloti(uint asid, Enums.EfxAuxiliaryi param, int value); public delegate void Delegate_alAuxiliaryEffectSloti( uint asid,Enums.EfxAuxiliaryi param,int value );
// typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTF)( ALuint asid, ALenum param, ALfloat value ); // typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTF)( ALuint asid, ALenum param, ALfloat value );
[CLSCompliant(false)] [CLSCompliant(false)]
private delegate void Delegate_alAuxiliaryEffectSlotf(uint asid, Enums.EfxAuxiliaryf param, float value); public delegate void Delegate_alAuxiliaryEffectSlotf( uint asid,Enums.EfxAuxiliaryf param,float value );
// typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTI)( ALuint asid, ALenum pname, ALint* value ); // typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTI)( ALuint asid, ALenum pname, ALint* value );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGetAuxiliaryEffectSloti(uint asid, Enums.EfxAuxiliaryi pname, [Out] int* value); unsafe private delegate void Delegate_alGetAuxiliaryEffectSloti( uint asid,Enums.EfxAuxiliaryi pname,[Out] int* value );
// typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTF)( ALuint asid, ALenum pname, ALfloat* value ); // typedef void (__cdecl *LPALGETAUXILIARYEFFECTSLOTF)( ALuint asid, ALenum pname, ALfloat* value );
[CLSCompliant(false)] [CLSCompliant(false)]
unsafe private delegate void Delegate_alGetAuxiliaryEffectSlotf(uint asid, Enums.EfxAuxiliaryf pname, [Out] float* value); unsafe private delegate void Delegate_alGetAuxiliaryEffectSlotf( uint asid,Enums.EfxAuxiliaryf pname,[Out] float* value );
// Not used: // Not used:
// typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTIV)( ALuint asid, ALenum param, ALint* values ); // typedef void (__cdecl *LPALAUXILIARYEFFECTSLOTIV)( ALuint asid, ALenum param, ALint* values );
@ -128,44 +284,6 @@ namespace OpenTK.OpenAL
#endregion Auxiliary Slot object delegates #endregion Auxiliary Slot object delegates
#region Effect object functions
[CLSCompliant(false)]
private Delegate_alGenEffects Imported_alGenEffects;
[CLSCompliant(false)]
private Delegate_alDeleteEffects Imported_alDeleteEffects;
[CLSCompliant(false)]
private Delegate_alIsEffect Imported_alIsEffect;
[CLSCompliant(false)]
private Delegate_alEffecti Imported_alEffecti;
[CLSCompliant(false)]
private Delegate_alEffectf Imported_alEffectf;
[CLSCompliant(false)]
private Delegate_alGetEffecti Imported_alGetEffecti;
[CLSCompliant(false)]
private Delegate_alGetEffectf Imported_alGetEffectf;
#endregion Effect object functions
#region Filter object functions
[CLSCompliant(false)]
private Delegate_alGenFilters Imported_alGenFilters;
[CLSCompliant(false)]
private Delegate_alDeleteFilters Imported_alDeleteFilters;
[CLSCompliant(false)]
private Delegate_alIsFilter Imported_alIsFilter;
[CLSCompliant(false)]
private Delegate_alFilteri Imported_alFilteri;
[CLSCompliant(false)]
private Delegate_alFilterf Imported_alFilterf;
[CLSCompliant(false)]
private Delegate_alGetFilteri Imported_alGetFilteri;
[CLSCompliant(false)]
private Delegate_alGetFilterf Imported_alGetFilterf;
#endregion Filter object functions
#region Auxiliary Effect Slot functions #region Auxiliary Effect Slot functions
[CLSCompliant(false)] [CLSCompliant(false)]
@ -173,11 +291,11 @@ namespace OpenTK.OpenAL
[CLSCompliant(false)] [CLSCompliant(false)]
private Delegate_alDeleteAuxiliaryEffectSlots Imported_alDeleteAuxiliaryEffectSlots; private Delegate_alDeleteAuxiliaryEffectSlots Imported_alDeleteAuxiliaryEffectSlots;
[CLSCompliant(false)] [CLSCompliant(false)]
private Delegate_alIsAuxiliaryEffectSlot Imported_alIsAuxiliaryEffectSlot; public Delegate_alIsAuxiliaryEffectSlot IsAuxiliaryEffectSlot;
[CLSCompliant(false)] [CLSCompliant(false)]
private Delegate_alAuxiliaryEffectSloti Imported_alAuxiliaryEffectSloti; public Delegate_alAuxiliaryEffectSloti AuxiliaryEffectSloti;
[CLSCompliant(false)] [CLSCompliant(false)]
private Delegate_alAuxiliaryEffectSlotf Imported_alAuxiliaryEffectSlotf; public Delegate_alAuxiliaryEffectSlotf AuxiliaryEffectSlotf;
[CLSCompliant(false)] [CLSCompliant(false)]
private Delegate_alGetAuxiliaryEffectSloti Imported_alGetAuxiliaryEffectSloti; private Delegate_alGetAuxiliaryEffectSloti Imported_alGetAuxiliaryEffectSloti;
[CLSCompliant(false)] [CLSCompliant(false)]
@ -185,7 +303,6 @@ namespace OpenTK.OpenAL
#endregion Auxiliary Effect Slot functions #endregion Auxiliary Effect Slot functions
#region Constructor / Extension Loading #region Constructor / Extension Loading
private bool _valid; private bool _valid;
@ -194,11 +311,11 @@ namespace OpenTK.OpenAL
public bool IsInitialized public bool IsInitialized
{ get { return _valid; } } { get { return _valid; } }
public Efx() public EfxExtension( )
{ {
_valid = false; _valid = false;
if (Alc.IsExtensionPresent( Alc.GetContextsDevice( Alc.GetCurrentContext()) , "ALC_EXT_EFX") == false) if ( Alc.IsExtensionPresent(Alc.GetContextsDevice(Alc.GetCurrentContext( )),"ALC_EXT_EFX") == false )
{ {
Console.WriteLine("Extension unknown."); Console.WriteLine("Extension unknown.");
return; return;
@ -207,51 +324,48 @@ namespace OpenTK.OpenAL
try try
{ {
Imported_alGenEffects = (Delegate_alGenEffects)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenEffects"), typeof(Delegate_alGenEffects)); Imported_alGenEffects = (Delegate_alGenEffects) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenEffects"),typeof(Delegate_alGenEffects));
Imported_alDeleteEffects = (Delegate_alDeleteEffects)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteEffects"), typeof(Delegate_alDeleteEffects)); Imported_alDeleteEffects = (Delegate_alDeleteEffects) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteEffects"),typeof(Delegate_alDeleteEffects));
Imported_alIsEffect = (Delegate_alIsEffect)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsEffect"), typeof(Delegate_alIsEffect)); IsEffect = (Delegate_alIsEffect) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsEffect"),typeof(Delegate_alIsEffect));
Imported_alEffecti = (Delegate_alEffecti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alEffecti"), typeof(Delegate_alEffecti)); Effecti = (Delegate_alEffecti) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alEffecti"),typeof(Delegate_alEffecti));
Imported_alEffectf = (Delegate_alEffectf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alEffectf"), typeof(Delegate_alEffectf)); Effectf = (Delegate_alEffectf) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alEffectf"),typeof(Delegate_alEffectf));
Imported_alGetEffecti = (Delegate_alGetEffecti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetEffecti"), typeof(Delegate_alGetEffecti)); Imported_alGetEffecti = (Delegate_alGetEffecti) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetEffecti"),typeof(Delegate_alGetEffecti));
Imported_alGetEffectf = (Delegate_alGetEffectf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetEffectf"), typeof(Delegate_alGetEffectf)); Imported_alGetEffectf = (Delegate_alGetEffectf) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetEffectf"),typeof(Delegate_alGetEffectf));
} } catch ( Exception e )
catch (Exception e)
{ {
Console.WriteLine("Failed to marshal Effect functions. " + e.ToString()); Console.WriteLine("Failed to marshal Effect functions. " + e.ToString( ));
return; return;
} }
Console.WriteLine("Effect functions appear to be ok."); Console.WriteLine("Effect functions appear to be ok.");
try try
{ {
Imported_alGenFilters = (Delegate_alGenFilters)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenFilters"), typeof(Delegate_alGenFilters)); Imported_alGenFilters = (Delegate_alGenFilters) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenFilters"),typeof(Delegate_alGenFilters));
Imported_alDeleteFilters = (Delegate_alDeleteFilters)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteFilters"), typeof(Delegate_alDeleteFilters)); Imported_alDeleteFilters = (Delegate_alDeleteFilters) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteFilters"),typeof(Delegate_alDeleteFilters));
Imported_alIsFilter = (Delegate_alIsFilter)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsFilter"), typeof(Delegate_alIsFilter)); IsFilter = (Delegate_alIsFilter) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsFilter"),typeof(Delegate_alIsFilter));
Imported_alFilteri = (Delegate_alFilteri)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alFilteri"), typeof(Delegate_alFilteri)); Filteri = (Delegate_alFilteri) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alFilteri"),typeof(Delegate_alFilteri));
Imported_alFilterf = (Delegate_alFilterf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alFilterf"), typeof(Delegate_alFilterf)); Filterf = (Delegate_alFilterf) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alFilterf"),typeof(Delegate_alFilterf));
Imported_alGetFilteri = (Delegate_alGetFilteri)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetFilteri"), typeof(Delegate_alGetFilteri)); Imported_alGetFilteri = (Delegate_alGetFilteri) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetFilteri"),typeof(Delegate_alGetFilteri));
Imported_alGetFilterf = (Delegate_alGetFilterf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetFilterf"), typeof(Delegate_alGetFilterf)); Imported_alGetFilterf = (Delegate_alGetFilterf) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetFilterf"),typeof(Delegate_alGetFilterf));
} } catch ( Exception e )
catch (Exception e)
{ {
Console.WriteLine("Failed to marshal Filter functions. " + e.ToString()); Console.WriteLine("Failed to marshal Filter functions. " + e.ToString( ));
return; return;
} }
Console.WriteLine("Filter functions appear to be ok."); Console.WriteLine("Filter functions appear to be ok.");
try try
{ {
Imported_alGenAuxiliaryEffectSlots = (Delegate_alGenAuxiliaryEffectSlots)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenAuxiliaryEffectSlots"), typeof(Delegate_alGenAuxiliaryEffectSlots)); Imported_alGenAuxiliaryEffectSlots = (Delegate_alGenAuxiliaryEffectSlots) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenAuxiliaryEffectSlots"),typeof(Delegate_alGenAuxiliaryEffectSlots));
Imported_alDeleteAuxiliaryEffectSlots = (Delegate_alDeleteAuxiliaryEffectSlots)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteAuxiliaryEffectSlots"), typeof(Delegate_alDeleteAuxiliaryEffectSlots)); Imported_alDeleteAuxiliaryEffectSlots = (Delegate_alDeleteAuxiliaryEffectSlots) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteAuxiliaryEffectSlots"),typeof(Delegate_alDeleteAuxiliaryEffectSlots));
Imported_alIsAuxiliaryEffectSlot = (Delegate_alIsAuxiliaryEffectSlot)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsAuxiliaryEffectSlot"), typeof(Delegate_alIsAuxiliaryEffectSlot)); IsAuxiliaryEffectSlot = (Delegate_alIsAuxiliaryEffectSlot) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsAuxiliaryEffectSlot"),typeof(Delegate_alIsAuxiliaryEffectSlot));
Imported_alAuxiliaryEffectSloti = (Delegate_alAuxiliaryEffectSloti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alAuxiliaryEffectSloti"), typeof(Delegate_alAuxiliaryEffectSloti)); AuxiliaryEffectSloti = (Delegate_alAuxiliaryEffectSloti) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alAuxiliaryEffectSloti"),typeof(Delegate_alAuxiliaryEffectSloti));
Imported_alAuxiliaryEffectSlotf = (Delegate_alAuxiliaryEffectSlotf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alAuxiliaryEffectSlotf"), typeof(Delegate_alAuxiliaryEffectSlotf)); AuxiliaryEffectSlotf = (Delegate_alAuxiliaryEffectSlotf) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alAuxiliaryEffectSlotf"),typeof(Delegate_alAuxiliaryEffectSlotf));
Imported_alGetAuxiliaryEffectSloti = (Delegate_alGetAuxiliaryEffectSloti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetAuxiliaryEffectSloti"), typeof(Delegate_alGetAuxiliaryEffectSloti)); Imported_alGetAuxiliaryEffectSloti = (Delegate_alGetAuxiliaryEffectSloti) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetAuxiliaryEffectSloti"),typeof(Delegate_alGetAuxiliaryEffectSloti));
Imported_alGetAuxiliaryEffectSlotf = (Delegate_alGetAuxiliaryEffectSlotf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetAuxiliaryEffectSlotf"), typeof(Delegate_alGetAuxiliaryEffectSlotf)); Imported_alGetAuxiliaryEffectSlotf = (Delegate_alGetAuxiliaryEffectSlotf) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetAuxiliaryEffectSlotf"),typeof(Delegate_alGetAuxiliaryEffectSlotf));
} } catch ( Exception e )
catch (Exception e)
{ {
Console.WriteLine("Failed to marshal AuxiliaryEffectSlot functions. " + e.ToString()); Console.WriteLine("Failed to marshal AuxiliaryEffectSlot functions. " + e.ToString( ));
return; return;
} }
Console.WriteLine("Auxiliary Effect Slot functions appear to be ok."); Console.WriteLine("Auxiliary Effect Slot functions appear to be ok.");
@ -262,4 +376,5 @@ namespace OpenTK.OpenAL
#endregion Constructor / Extension Loading #endregion Constructor / Extension Loading
} }
} }

634
Source/OpenTK/OpenAL/EfxPresets.cs
View file

@ -13,402 +13,314 @@ using OpenTK.Math;
namespace OpenTK.OpenAL namespace OpenTK.OpenAL
{ {
public partial class Efx
public partial class EfxExtension
{ {
public struct _EAXREVERBPROPERTIES public struct EaxReverb
{ {
uint ulEnvironment; public uint ulEnvironment;
float flEnvironmentSize; public float flEnvironmentSize;
float flEnvironmentDiffusion; public float flEnvironmentDiffusion;
int lRoom; public int lRoom;
int lRoomHF; public int lRoomHF;
int lRoomLF; public int lRoomLF;
float flDecayTime; public float flDecayTime;
float flDecayHFRatio; public float flDecayHFRatio;
float flDecayLFRatio; public float flDecayLFRatio;
int lReflections; public int lReflections;
float flReflectionsDelay; public float flReflectionsDelay;
Vector3 vReflectionsPan; public Vector3 vReflectionsPan;
int lReverb; public int lReverb;
float flReverbDelay; public float flReverbDelay;
Vector3 vReverbPan; public Vector3 vReverbPan;
float flEchoTime; public float flEchoTime;
float flEchoDepth; public float flEchoDepth;
float flModulationTime; public float flModulationTime;
float flModulationDepth; public float flModulationDepth;
float flAirAbsorptionHF; public float flAirAbsorptionHF;
float flHFReference; public float flHFReference;
float flLFReference; public float flLFReference;
float flRoomRolloffFactor; public float flRoomRolloffFactor;
uint ulFlags; public uint ulFlags;
}
_EAXREVERBPROPERTIES EAXREVERBPROPERTIES; //, *LPEAXREVERBPROPERTIES;
public struct _EFXEAXREVERBPROPERTIES public EaxReverb( uint Environment,
{ float EnvironmentSize,
float flDensity; float EnvironmentDiffusion,
float flDiffusion; int Room,
float flGain; int RoomHF,
float flGainHF; int RoomLF,
float flGainLF; float DecayTime,
float flDecayTime; float DecayHFRatio,
float flDecayHFRatio; float DecayLFRatio,
float flDecayLFRatio; int Reflections,
float flReflectionsGain; float ReflectionsDelay,
float flReflectionsDelay; float ReflectionsPanX,
Vector3 flReflectionsPan; float ReflectionsPanY,
float flLateReverbGain; float ReflectionsPanZ,
float flLateReverbDelay; int Reverb,
Vector3 flLateReverbPan; float ReverbDelay,
float flEchoTime; float ReverbPanX,
float flEchoDepth; float ReverbPanY,
float flModulationTime; float ReverbPanZ,
float flModulationDepth; float EchoTime,
float flAirAbsorptionGainHF; float EchoDepth,
float flHFReference; float ModulationTime,
float flLFReference; float ModulationDepth,
float flRoomRolloffFactor; float AirAbsorptionHF,
int iDecayHFLimit; float HFReference,
float LFReference,
float RoomRolloffFactor,
uint Flags )
{
ulEnvironment = Environment;
flEnvironmentSize = EnvironmentSize;
flEnvironmentDiffusion = EnvironmentDiffusion;
lRoom = Room;
lRoomHF = RoomHF;
lRoomLF = RoomLF;
flDecayTime = DecayTime;
flDecayHFRatio = DecayHFRatio;
flDecayLFRatio = DecayLFRatio;
lReflections = Reflections;
flReflectionsDelay = ReflectionsDelay;
vReflectionsPan = new Vector3(ReflectionsPanX,ReflectionsPanY,ReflectionsPanZ);
lReverb = Reverb;
flReverbDelay = ReverbDelay;
vReverbPan = new Vector3(ReverbPanX,ReverbPanY,ReverbPanZ);
flEchoTime = EchoTime;
flEchoDepth = EchoDepth;
flModulationTime = ModulationTime;
flModulationDepth = ModulationDepth;
flAirAbsorptionHF = AirAbsorptionHF;
flHFReference = HFReference;
flLFReference = LFReference;
flRoomRolloffFactor = RoomRolloffFactor;
ulFlags = Flags;
}
} }
_EFXEAXREVERBPROPERTIES EFXEAXREVERBPROPERTIES;//, *LPEFXEAXREVERBPROPERTIES;
public struct _EAXOBSTRUCTIONPROPERTIES
{
int lObstruction;
float flObstructionLFRatio;
}
_EAXOBSTRUCTIONPROPERTIES EAXOBSTRUCTIONPROPERTIES;//, *LPEAXOBSTRUCTIONPROPERTIES;
public struct _EAXOCCLUSIONPROPERTIES
{
int lOcclusion;
float flOcclusionLFRatio;
float flOcclusionRoomRatio;
float flOcclusionDirectRatio;
}
_EAXOCCLUSIONPROPERTIES EAXOCCLUSIONPROPERTIES;//, *LPEAXOCCLUSIONPROPERTIES;
public struct _EAXEXCLUSIONPROPERTIES
{
int lExclusion;
float flExclusionLFRatio;
}
_EAXEXCLUSIONPROPERTIES EAXEXCLUSIONPROPERTIES;//, *LPEAXEXCLUSIONPROPERTIES;
public struct _EFXLOWPASSFILTER
{
float flGain;
float flGainHF;
}
_EFXLOWPASSFILTER EFXLOWPASSFILTER;//, *LPEFXLOWPASSFILTER;
/* /*
void ConvertReverbParameters(EAXREVERBPROPERTIES *pEAXProp, EFXEAXREVERBPROPERTIES *pEFXEAXReverb); public struct _EFXEAXREVERBPROPERTIES
void ConvertObstructionParameters(EAXOBSTRUCTIONPROPERTIES *pObProp, EFXLOWPASSFILTER *pDirectLowPassFilter); {
void ConvertExclusionParameters(EAXEXCLUSIONPROPERTIES *pExProp, EFXLOWPASSFILTER *pSendLowPassFilter); public float flDensity;
void ConvertOcclusionParameters(EAXOCCLUSIONPROPERTIES *pOcProp, EFXLOWPASSFILTER *pDirectLowPassFilter, EFXLOWPASSFILTER *pSendLowPassFilter); public float flDiffusion;
*/ public float flGain;
public float flGainHF;
public float flGainLF;
public float flDecayTime;
public float flDecayHFRatio;
public float flDecayLFRatio;
public float flReflectionsGain;
public float flReflectionsDelay;
public Vector3 flReflectionsPan;
public float flLateReverbGain;
public float flLateReverbDelay;
public Vector3 flLateReverbPan;
public float flEchoTime;
public float flEchoDepth;
public float flModulationTime;
public float flModulationDepth;
public float flAirAbsorptionGainHF;
public float flHFReference;
public float flLFReference;
public float flRoomRolloffFactor;
public int iDecayHFLimit;
}
_EFXEAXREVERBPROPERTIES EFXEAXREVERBPROPERTIES;//, *LPEFXEAXREVERBPROPERTIES;
/***********************************************************************************************\ public struct _EAXOBSTRUCTIONPROPERTIES
* {
* EAX Reverb Presets in legacy format - use ConvertReverbParameters() to convert to public int lObstruction;
* EFX EAX Reverb Presets for use with the OpenAL Effects Extension. public float flObstructionLFRatio;
* }
************************************************************************************************/ _EAXOBSTRUCTIONPROPERTIES EAXOBSTRUCTIONPROPERTIES;//, *LPEAXOBSTRUCTIONPROPERTIES;
/*
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS public struct _EAXOCCLUSIONPROPERTIES
#define REVERB_PRESET_GENERIC \ {
{0, 7.5f, 1.000f, -1000, -100, 0, 1.49f, 0.83f, 1.00f, -2602, 0.007f, 0.00f,0.00f,0.00f, 200, 0.011f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } public int lOcclusion;
#define REVERB_PRESET_PADDEDCELL \ public float flOcclusionLFRatio;
{1, 1.4f, 1.000f, -1000, -6000, 0, 0.17f, 0.10f, 1.00f, -1204, 0.001f, 0.00f,0.00f,0.00f, 207, 0.002f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } public float flOcclusionRoomRatio;
#define REVERB_PRESET_ROOM \ public float flOcclusionDirectRatio;
{2, 1.9f, 1.000f, -1000, -454, 0, 0.40f, 0.83f, 1.00f, -1646, 0.002f, 0.00f,0.00f,0.00f, 53, 0.003f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } }
#define REVERB_PRESET_BATHROOM \ _EAXOCCLUSIONPROPERTIES EAXOCCLUSIONPROPERTIES;//, *LPEAXOCCLUSIONPROPERTIES;
{3, 1.4f, 1.000f, -1000, -1200, 0, 1.49f, 0.54f, 1.00f, -370, 0.007f, 0.00f,0.00f,0.00f, 1030, 0.011f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_LIVINGROOM \ public struct _EAXEXCLUSIONPROPERTIES
{4, 2.5f, 1.000f, -1000, -6000, 0, 0.50f, 0.10f, 1.00f, -1376, 0.003f, 0.00f,0.00f,0.00f, -1104, 0.004f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } {
#define REVERB_PRESET_STONEROOM \ public int lExclusion;
{5, 11.6f, 1.000f, -1000, -300, 0, 2.31f, 0.64f, 1.00f, -711, 0.012f, 0.00f,0.00f,0.00f, 83, 0.017f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } public float flExclusionLFRatio;
#define REVERB_PRESET_AUDITORIUM \ }
{6, 21.6f, 1.000f, -1000, -476, 0, 4.32f, 0.59f, 1.00f, -789, 0.020f, 0.00f,0.00f,0.00f, -289, 0.030f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } _EAXEXCLUSIONPROPERTIES EAXEXCLUSIONPROPERTIES;//, *LPEAXEXCLUSIONPROPERTIES;
#define REVERB_PRESET_CONCERTHALL \
{7, 19.6f, 1.000f, -1000, -500, 0, 3.92f, 0.70f, 1.00f, -1230, 0.020f, 0.00f,0.00f,0.00f, -02, 0.029f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } public struct _EFXLOWPASSFILTER
#define REVERB_PRESET_CAVE \ {
{8, 14.6f, 1.000f, -1000, 0, 0, 2.91f, 1.30f, 1.00f, -602, 0.015f, 0.00f,0.00f,0.00f, -302, 0.022f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f } public float flGain;
#define REVERB_PRESET_ARENA \ public float flGainHF;
{9, 36.2f, 1.000f, -1000, -698, 0, 7.24f, 0.33f, 1.00f, -1166, 0.020f, 0.00f,0.00f,0.00f, 16, 0.030f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f } }
#define REVERB_PRESET_HANGAR \ _EFXLOWPASSFILTER EFXLOWPASSFILTER;//, *LPEFXLOWPASSFILTER;
{10, 50.3f, 1.000f, -1000, -1000, 0, 10.05f, 0.23f, 1.00f, -602, 0.020f, 0.00f,0.00f,0.00f, 198, 0.030f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_CARPETTEDHALLWAY \
{11, 1.9f, 1.000f, -1000, -4000, 0, 0.30f, 0.10f, 1.00f, -1831, 0.002f, 0.00f,0.00f,0.00f, -1630, 0.030f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_HALLWAY \
{12, 1.8f, 1.000f, -1000, -300, 0, 1.49f, 0.59f, 1.00f, -1219, 0.007f, 0.00f,0.00f,0.00f, 441, 0.011f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_STONECORRIDOR \
{13, 13.5f, 1.000f, -1000, -237, 0, 2.70f, 0.79f, 1.00f, -1214, 0.013f, 0.00f,0.00f,0.00f, 395, 0.020f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_ALLEY \
{14, 7.5f, 0.300f, -1000, -270, 0, 1.49f, 0.86f, 1.00f, -1204, 0.007f, 0.00f,0.00f,0.00f, -4, 0.011f, 0.00f,0.00f,0.00f, 0.125f, 0.950f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_FOREST \
{15, 38.0f, 0.300f, -1000, -3300, 0, 1.49f, 0.54f, 1.00f, -2560, 0.162f, 0.00f,0.00f,0.00f, -229, 0.088f, 0.00f,0.00f,0.00f, 0.125f, 1.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_CITY \
{16, 7.5f, 0.500f, -1000, -800, 0, 1.49f, 0.67f, 1.00f, -2273, 0.007f, 0.00f,0.00f,0.00f, -1691, 0.011f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_MOUNTAINS \
{17, 100.0f, 0.270f, -1000, -2500, 0, 1.49f, 0.21f, 1.00f, -2780, 0.300f, 0.00f,0.00f,0.00f, -1434, 0.100f, 0.00f,0.00f,0.00f, 0.250f, 1.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f }
#define REVERB_PRESET_QUARRY \
{18, 17.5f, 1.000f, -1000, -1000, 0, 1.49f, 0.83f, 1.00f, -10000, 0.061f, 0.00f,0.00f,0.00f, 500, 0.025f, 0.00f,0.00f,0.00f, 0.125f, 0.700f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_PLAIN \
{19, 42.5f, 0.210f, -1000, -2000, 0, 1.49f, 0.50f, 1.00f, -2466, 0.179f, 0.00f,0.00f,0.00f, -1926, 0.100f, 0.00f,0.00f,0.00f, 0.250f, 1.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_PARKINGLOT \
{20, 8.3f, 1.000f, -1000, 0, 0, 1.65f, 1.50f, 1.00f, -1363, 0.008f, 0.00f,0.00f,0.00f, -1153, 0.012f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f }
#define REVERB_PRESET_SEWERPIPE \
{21, 1.7f, 0.800f, -1000, -1000, 0, 2.81f, 0.14f, 1.00f, 429, 0.014f, 0.00f,0.00f,0.00f, 1023, 0.021f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_UNDERWATER \
{22, 1.8f, 1.000f, -1000, -4000, 0, 1.49f, 0.10f, 1.00f, -449, 0.007f, 0.00f,0.00f,0.00f, 1700, 0.011f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 1.180f, 0.348f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_DRUGGED \
{23, 1.9f, 0.500f, -1000, 0, 0, 8.39f, 1.39f, 1.00f, -115, 0.002f, 0.00f,0.00f,0.00f, 985, 0.030f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 1.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f }
#define REVERB_PRESET_DIZZY \
{24, 1.8f, 0.600f, -1000, -400, 0, 17.23f, 0.56f, 1.00f, -1713, 0.020f, 0.00f,0.00f,0.00f, -613, 0.030f, 0.00f,0.00f,0.00f, 0.250f, 1.000f, 0.810f, 0.310f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f }
#define REVERB_PRESET_PSYCHOTIC \
{25, 1.0f, 0.500f, -1000, -151, 0, 7.56f, 0.91f, 1.00f, -626, 0.020f, 0.00f,0.00f,0.00f, 774, 0.030f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 4.000f, 1.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f }
// CASTLE PRESETS void ConvertReverbParameters(EAXREVERBPROPERTIES *pEAXProp, EFXEAXREVERBPROPERTIES *pEFXEAXReverb);
void ConvertObstructionParameters(EAXOBSTRUCTIONPROPERTIES *pObProp, EFXLOWPASSFILTER *pDirectLowPassFilter);
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS void ConvertExclusionParameters(EAXEXCLUSIONPROPERTIES *pExProp, EFXLOWPASSFILTER *pSendLowPassFilter);
#define REVERB_PRESET_CASTLE_SMALLROOM \ void ConvertOcclusionParameters(EAXOCCLUSIONPROPERTIES *pOcProp, EFXLOWPASSFILTER *pDirectLowPassFilter, EFXLOWPASSFILTER *pSendLowPassFilter);
{ 26, 8.3f, 0.890f, -1000, -800, -2000, 1.22f, 0.83f, 0.31f, -100, 0.022f, 0.00f,0.00f,0.00f, 600, 0.011f, 0.00f,0.00f,0.00f, 0.138f, 0.080f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 } */
#define REVERB_PRESET_CASTLE_SHORTPASSAGE \
{ 26, 8.3f, 0.890f, -1000, -1000, -2000, 2.32f, 0.83f, 0.31f, -100, 0.007f, 0.00f,0.00f,0.00f, 200, 0.023f, 0.00f,0.00f,0.00f, 0.138f, 0.080f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 }
#define REVERB_PRESET_CASTLE_MEDIUMROOM \
{ 26, 8.3f, 0.930f, -1000, -1100, -2000, 2.04f, 0.83f, 0.46f, -400, 0.022f, 0.00f,0.00f,0.00f, 400, 0.011f, 0.00f,0.00f,0.00f, 0.155f, 0.030f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 }
#define REVERB_PRESET_CASTLE_LONGPASSAGE \
{ 26, 8.3f, 0.890f, -1000, -800, -2000, 3.42f, 0.83f, 0.31f, -100, 0.007f, 0.00f,0.00f,0.00f, 300, 0.023f, 0.00f,0.00f,0.00f, 0.138f, 0.080f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 }
#define REVERB_PRESET_CASTLE_LARGEROOM \
{ 26, 8.3f, 0.820f, -1000, -1100, -1800, 2.53f, 0.83f, 0.50f, -700, 0.034f, 0.00f,0.00f,0.00f, 200, 0.016f, 0.00f,0.00f,0.00f, 0.185f, 0.070f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 }
#define REVERB_PRESET_CASTLE_HALL \
{ 26, 8.3f, 0.810f, -1000, -1100, -1500, 3.14f, 0.79f, 0.62f, -1500, 0.056f, 0.00f,0.00f,0.00f, 100, 0.024f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 }
#define REVERB_PRESET_CASTLE_CUPBOARD \
{ 26, 8.3f, 0.890f, -1000, -1100, -2000, 0.67f, 0.87f, 0.31f, 300, 0.010f, 0.00f,0.00f,0.00f, 1100, 0.007f, 0.00f,0.00f,0.00f, 0.138f, 0.080f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 }
#define REVERB_PRESET_CASTLE_COURTYARD \
{ 26, 8.3f, 0.420f, -1000, -700, -1400, 2.13f, 0.61f, 0.23f, -1300, 0.160f, 0.00f,0.00f,0.00f, -300, 0.036f, 0.00f,0.00f,0.00f, 0.250f, 0.370f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f }
#define REVERB_PRESET_CASTLE_ALCOVE \
{ 26, 8.3f, 0.890f, -1000, -600, -2000, 1.64f, 0.87f, 0.31f, 00, 0.007f, 0.00f,0.00f,0.00f, 300, 0.034f, 0.00f,0.00f,0.00f, 0.138f, 0.080f, 0.250f, 0.000f, -5.0f, 5168.6f, 139.5f, 0.00f, 0x20 }
// FACTORY PRESETS ///<summary>EAX Reverb Presets in legacy format - use ConvertReverbParameters() to convert to EFX EAX Reverb Presets for use with the OpenAL Effects Extension.</summary>
public static class ReverbPresets
{
// CASTLE PRESETS
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS public static EaxReverb CastleSmallRoom = new EaxReverb(26,8.3f,0.890f,-1000,-800,-2000,1.22f,0.83f,0.31f,-100,0.022f,0f,0f,0f,600,0.011f,0f,0f,0f,0.138f,0.080f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
#define REVERB_PRESET_FACTORY_ALCOVE \ public static EaxReverb CastleShortPassage = new EaxReverb(26,8.3f,0.890f,-1000,-1000,-2000,2.32f,0.83f,0.31f,-100,0.007f,0f,0f,0f,200,0.023f,0f,0f,0f,0.138f,0.080f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
{ 26, 1.8f, 0.590f, -1200, -200, -600, 3.14f, 0.65f, 1.31f, 300, 0.010f, 0.00f,0.00f,0.00f, 000, 0.038f, 0.00f,0.00f,0.00f, 0.114f, 0.100f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 } public static EaxReverb CastleMediumroom = new EaxReverb(26,8.3f,0.930f,-1000,-1100,-2000,2.04f,0.83f,0.46f,-400,0.022f,0f,0f,0f,400,0.011f,0f,0f,0f,0.155f,0.030f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
#define REVERB_PRESET_FACTORY_SHORTPASSAGE \ public static EaxReverb CastleLongpassage = new EaxReverb(26,8.3f,0.890f,-1000,-800,-2000,3.42f,0.83f,0.31f,-100,0.007f,0f,0f,0f,300,0.023f,0f,0f,0f,0.138f,0.080f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
{ 26, 1.8f, 0.640f, -1200, -200, -600, 2.53f, 0.65f, 1.31f, 0, 0.010f, 0.00f,0.00f,0.00f, 200, 0.038f, 0.00f,0.00f,0.00f, 0.135f, 0.230f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 } public static EaxReverb CastleLargeroom = new EaxReverb(26,8.3f,0.820f,-1000,-1100,-1800,2.53f,0.83f,0.50f,-700,0.034f,0f,0f,0f,200,0.016f,0f,0f,0f,0.185f,0.070f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
#define REVERB_PRESET_FACTORY_MEDIUMROOM \ public static EaxReverb CastleHall = new EaxReverb(26,8.3f,0.810f,-1000,-1100,-1500,3.14f,0.79f,0.62f,-1500,0.056f,0f,0f,0f,100,0.024f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
{ 26, 1.9f, 0.820f, -1200, -200, -600, 2.76f, 0.65f, 1.31f, -1100, 0.022f, 0.00f,0.00f,0.00f, 300, 0.023f, 0.00f,0.00f,0.00f, 0.174f, 0.070f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 } public static EaxReverb CastleCupboard = new EaxReverb(26,8.3f,0.890f,-1000,-1100,-2000,0.67f,0.87f,0.31f,300,0.010f,0f,0f,0f,1100,0.007f,0f,0f,0f,0.138f,0.080f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
#define REVERB_PRESET_FACTORY_LONGPASSAGE \ public static EaxReverb CastleCourtyard = new EaxReverb(26,8.3f,0.420f,-1000,-700,-1400,2.13f,0.61f,0.23f,-1300,0.160f,0f,0f,0f,-300,0.036f,0f,0f,0f,0.250f,0.370f,0.250f,0f,-5f,5000f,250f,0f,0x1f);
{ 26, 1.8f, 0.640f, -1200, -200, -600, 4.06f, 0.65f, 1.31f, 0, 0.020f, 0.00f,0.00f,0.00f, 200, 0.037f, 0.00f,0.00f,0.00f, 0.135f, 0.230f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 } public static EaxReverb CastleAlcove = new EaxReverb(26,8.3f,0.890f,-1000,-600,-2000,1.64f,0.87f,0.31f,00,0.007f,0f,0f,0f,300,0.034f,0f,0f,0f,0.138f,0.080f,0.250f,0f,-5f,5168.6f,139.5f,0f,0x20);
#define REVERB_PRESET_FACTORY_LARGEROOM \
{ 26, 1.9f, 0.750f, -1200, -300, -400, 4.24f, 0.51f, 1.31f, -1500, 0.039f, 0.00f,0.00f,0.00f, 100, 0.023f, 0.00f,0.00f,0.00f, 0.231f, 0.070f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 }
#define REVERB_PRESET_FACTORY_HALL \
{ 26, 1.9f, 0.750f, -1000, -300, -400, 7.43f, 0.51f, 1.31f, -2400, 0.073f, 0.00f,0.00f,0.00f, -100, 0.027f, 0.00f,0.00f,0.00f, 0.250f, 0.070f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 }
#define REVERB_PRESET_FACTORY_CUPBOARD \
{ 26, 1.7f, 0.630f, -1200, -200, -600, 0.49f, 0.65f, 1.31f, 200, 0.010f, 0.00f,0.00f,0.00f, 600, 0.032f, 0.00f,0.00f,0.00f, 0.107f, 0.070f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 }
#define REVERB_PRESET_FACTORY_COURTYARD \
{ 26, 1.7f, 0.570f, -1000, -1000, -400, 2.32f, 0.29f, 0.56f, -1300, 0.140f, 0.00f,0.00f,0.00f, -800, 0.039f, 0.00f,0.00f,0.00f, 0.250f, 0.290f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 }
#define REVERB_PRESET_FACTORY_SMALLROOM \
{ 26, 1.8f, 0.820f, -1000, -200, -600, 1.72f, 0.65f, 1.31f, -300, 0.010f, 0.00f,0.00f,0.00f, 500, 0.024f, 0.00f,0.00f,0.00f, 0.119f, 0.070f, 0.250f, 0.000f, -5.0f, 3762.6f, 362.5f, 0.00f, 0x20 }
// FACTORY PRESETS
// ICE PALACE PRESETS public static EaxReverb FactoryAlcove = new EaxReverb(26,1.8f,0.590f,-1200,-200,-600,3.14f,0.65f,1.31f,300,0.010f,0f,0f,0f,000,0.038f,0f,0f,0f,0.114f,0.100f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactoryShortpassage = new EaxReverb(26,1.8f,0.640f,-1200,-200,-600,2.53f,0.65f,1.31f,0,0.010f,0f,0f,0f,200,0.038f,0f,0f,0f,0.135f,0.230f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactoryMediumroom = new EaxReverb(26,1.9f,0.820f,-1200,-200,-600,2.76f,0.65f,1.31f,-1100,0.022f,0f,0f,0f,300,0.023f,0f,0f,0f,0.174f,0.070f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactoryLongpassage = new EaxReverb(26,1.8f,0.640f,-1200,-200,-600,4.06f,0.65f,1.31f,0,0.020f,0f,0f,0f,200,0.037f,0f,0f,0f,0.135f,0.230f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactoryLargeroom = new EaxReverb(26,1.9f,0.750f,-1200,-300,-400,4.24f,0.51f,1.31f,-1500,0.039f,0f,0f,0f,100,0.023f,0f,0f,0f,0.231f,0.070f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactoryHall = new EaxReverb(26,1.9f,0.750f,-1000,-300,-400,7.43f,0.51f,1.31f,-2400,0.073f,0f,0f,0f,-100,0.027f,0f,0f,0f,0.250f,0.070f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactoryCupboard = new EaxReverb(26,1.7f,0.630f,-1200,-200,-600,0.49f,0.65f,1.31f,200,0.010f,0f,0f,0f,600,0.032f,0f,0f,0f,0.107f,0.070f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactoryCourtyard = new EaxReverb(26,1.7f,0.570f,-1000,-1000,-400,2.32f,0.29f,0.56f,-1300,0.140f,0f,0f,0f,-800,0.039f,0f,0f,0f,0.250f,0.290f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
public static EaxReverb FactorySmallroom = new EaxReverb(26,1.8f,0.820f,-1000,-200,-600,1.72f,0.65f,1.31f,-300,0.010f,0f,0f,0f,500,0.024f,0f,0f,0f,0.119f,0.070f,0.250f,0f,-5f,3762.6f,362.5f,0f,0x20);
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS // ICE PALACE PRESETS
#define REVERB_PRESET_ICEPALACE_ALCOVE \
{ 26, 2.7f, 0.840f, -1000, -500, -1100, 2.76f, 1.46f, 0.28f, 100, 0.010f, 0.00f,0.00f,0.00f, -100, 0.030f, 0.00f,0.00f,0.00f, 0.161f, 0.090f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_SHORTPASSAGE \
{ 26, 2.7f, 0.750f, -1000, -500, -1100, 1.79f, 1.46f, 0.28f, -600, 0.010f, 0.00f,0.00f,0.00f, 100, 0.019f, 0.00f,0.00f,0.00f, 0.177f, 0.090f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_MEDIUMROOM \
{ 26, 2.7f, 0.870f, -1000, -500, -700, 2.22f, 1.53f, 0.32f, -800, 0.039f, 0.00f,0.00f,0.00f, 100, 0.027f, 0.00f,0.00f,0.00f, 0.186f, 0.120f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_LONGPASSAGE \
{ 26, 2.7f, 0.770f, -1000, -500, -800, 3.01f, 1.46f, 0.28f, -200, 0.012f, 0.00f,0.00f,0.00f, 200, 0.025f, 0.00f,0.00f,0.00f, 0.186f, 0.040f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_LARGEROOM \
{ 26, 2.9f, 0.810f, -1000, -500, -700, 3.14f, 1.53f, 0.32f, -1200, 0.039f, 0.00f,0.00f,0.00f, 000, 0.027f, 0.00f,0.00f,0.00f, 0.214f, 0.110f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_HALL \
{ 26, 2.9f, 0.760f, -1000, -700, -500, 5.49f, 1.53f, 0.38f, -1900, 0.054f, 0.00f,0.00f,0.00f, -400, 0.052f, 0.00f,0.00f,0.00f, 0.226f, 0.110f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_CUPBOARD \
{ 26, 2.7f, 0.830f, -1000, -600, -1300, 0.76f, 1.53f, 0.26f, 100, 0.012f, 0.00f,0.00f,0.00f, 600, 0.016f, 0.00f,0.00f,0.00f, 0.143f, 0.080f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_COURTYARD \
{ 26, 2.9f, 0.590f, -1000, -1100, -1000, 2.04f, 1.20f, 0.38f, -1000, 0.173f, 0.00f,0.00f,0.00f, -1000, 0.043f, 0.00f,0.00f,0.00f, 0.235f, 0.480f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
#define REVERB_PRESET_ICEPALACE_SMALLROOM \
{ 26, 2.7f, 0.840f, -1000, -500, -1100, 1.51f, 1.53f, 0.27f, -100, 0.010f, 0.00f,0.00f,0.00f, 300, 0.011f, 0.00f,0.00f,0.00f, 0.164f, 0.140f, 0.250f, 0.000f, -5.0f, 12428.5f, 99.6f, 0.00f, 0x20 }
public static EaxReverb IcepalaceAlcove = new EaxReverb(26,2.7f,0.840f,-1000,-500,-1100,2.76f,1.46f,0.28f,100,0.010f,0f,0f,0f,-100,0.030f,0f,0f,0f,0.161f,0.090f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceShortpassage = new EaxReverb(26,2.7f,0.750f,-1000,-500,-1100,1.79f,1.46f,0.28f,-600,0.010f,0f,0f,0f,100,0.019f,0f,0f,0f,0.177f,0.090f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceMediumroom = new EaxReverb(26,2.7f,0.870f,-1000,-500,-700,2.22f,1.53f,0.32f,-800,0.039f,0f,0f,0f,100,0.027f,0f,0f,0f,0.186f,0.120f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceLongpassage = new EaxReverb(26,2.7f,0.770f,-1000,-500,-800,3.01f,1.46f,0.28f,-200,0.012f,0f,0f,0f,200,0.025f,0f,0f,0f,0.186f,0.040f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceLargeroom = new EaxReverb(26,2.9f,0.810f,-1000,-500,-700,3.14f,1.53f,0.32f,-1200,0.039f,0f,0f,0f,000,0.027f,0f,0f,0f,0.214f,0.110f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceHall = new EaxReverb(26,2.9f,0.760f,-1000,-700,-500,5.49f,1.53f,0.38f,-1900,0.054f,0f,0f,0f,-400,0.052f,0f,0f,0f,0.226f,0.110f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceCupboard = new EaxReverb(26,2.7f,0.830f,-1000,-600,-1300,0.76f,1.53f,0.26f,100,0.012f,0f,0f,0f,600,0.016f,0f,0f,0f,0.143f,0.080f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceCourtyard = new EaxReverb(26,2.9f,0.590f,-1000,-1100,-1000,2.04f,1.20f,0.38f,-1000,0.173f,0f,0f,0f,-1000,0.043f,0f,0f,0f,0.235f,0.480f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
public static EaxReverb IcepalaceSmallroom = new EaxReverb(26,2.7f,0.840f,-1000,-500,-1100,1.51f,1.53f,0.27f,-100,0.010f,0f,0f,0f,300,0.011f,0f,0f,0f,0.164f,0.140f,0.250f,0f,-5f,12428.5f,99.6f,0f,0x20);
// SPACE STATION PRESETS // SPACE STATION PRESETS
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS public static EaxReverb SpacestationAlcove = new EaxReverb(26,1.5f,0.780f,-1000,-300,-100,1.16f,0.81f,0.55f,300,0.007f,0f,0f,0f,000,0.018f,0f,0f,0f,0.192f,0.210f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
#define REVERB_PRESET_SPACESTATION_ALCOVE \ public static EaxReverb SpacestationMediumroom = new EaxReverb(26,1.5f,0.750f,-1000,-400,-100,3.01f,0.50f,0.55f,-800,0.034f,0f,0f,0f,100,0.035f,0f,0f,0f,0.209f,0.310f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
{ 26, 1.5f, 0.780f, -1000, -300, -100, 1.16f, 0.81f, 0.55f, 300, 0.007f, 0.00f,0.00f,0.00f, 000, 0.018f, 0.00f,0.00f,0.00f, 0.192f, 0.210f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 } public static EaxReverb SpacestationShortpassage = new EaxReverb(26,1.5f,0.870f,-1000,-400,-100,3.57f,0.50f,0.55f,0,0.012f,0f,0f,0f,100,0.016f,0f,0f,0f,0.172f,0.200f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
#define REVERB_PRESET_SPACESTATION_MEDIUMROOM \ public static EaxReverb SpacestationLongpassage = new EaxReverb(26,1.9f,0.820f,-1000,-400,-100,4.62f,0.62f,0.55f,0,0.012f,0f,0f,0f,200,0.031f,0f,0f,0f,0.250f,0.230f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
{ 26, 1.5f, 0.750f, -1000, -400, -100, 3.01f, 0.50f, 0.55f, -800, 0.034f, 0.00f,0.00f,0.00f, 100, 0.035f, 0.00f,0.00f,0.00f, 0.209f, 0.310f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 } public static EaxReverb SpacestationLargeroom = new EaxReverb(26,1.8f,0.810f,-1000,-400,-100,3.89f,0.38f,0.61f,-1000,0.056f,0f,0f,0f,-100,0.035f,0f,0f,0f,0.233f,0.280f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
#define REVERB_PRESET_SPACESTATION_SHORTPASSAGE \ public static EaxReverb SpacestationHall = new EaxReverb(26,1.9f,0.870f,-1000,-400,-100,7.11f,0.38f,0.61f,-1500,0.100f,0f,0f,0f,-400,0.047f,0f,0f,0f,0.250f,0.250f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
{ 26, 1.5f, 0.870f, -1000, -400, -100, 3.57f, 0.50f, 0.55f, 0, 0.012f, 0.00f,0.00f,0.00f, 100, 0.016f, 0.00f,0.00f,0.00f, 0.172f, 0.200f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 } public static EaxReverb SpacestationCupboard = new EaxReverb(26,1.4f,0.560f,-1000,-300,-100,0.79f,0.81f,0.55f,300,0.007f,0f,0f,0f,500,0.018f,0f,0f,0f,0.181f,0.310f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
#define REVERB_PRESET_SPACESTATION_LONGPASSAGE \ public static EaxReverb SpacestationSmallroom = new EaxReverb(26,1.5f,0.700f,-1000,-300,-100,1.72f,0.82f,0.55f,-200,0.007f,0f,0f,0f,300,0.013f,0f,0f,0f,0.188f,0.260f,0.250f,0f,-5f,3316.1f,458.2f,0f,0x20);
{ 26, 1.9f, 0.820f, -1000, -400, -100, 4.62f, 0.62f, 0.55f, 0, 0.012f, 0.00f,0.00f,0.00f, 200, 0.031f, 0.00f,0.00f,0.00f, 0.250f, 0.230f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 }
#define REVERB_PRESET_SPACESTATION_LARGEROOM \
{ 26, 1.8f, 0.810f, -1000, -400, -100, 3.89f, 0.38f, 0.61f, -1000, 0.056f, 0.00f,0.00f,0.00f, -100, 0.035f, 0.00f,0.00f,0.00f, 0.233f, 0.280f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 }
#define REVERB_PRESET_SPACESTATION_HALL \
{ 26, 1.9f, 0.870f, -1000, -400, -100, 7.11f, 0.38f, 0.61f, -1500, 0.100f, 0.00f,0.00f,0.00f, -400, 0.047f, 0.00f,0.00f,0.00f, 0.250f, 0.250f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 }
#define REVERB_PRESET_SPACESTATION_CUPBOARD \
{ 26, 1.4f, 0.560f, -1000, -300, -100, 0.79f, 0.81f, 0.55f, 300, 0.007f, 0.00f,0.00f,0.00f, 500, 0.018f, 0.00f,0.00f,0.00f, 0.181f, 0.310f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 }
#define REVERB_PRESET_SPACESTATION_SMALLROOM \
{ 26, 1.5f, 0.700f, -1000, -300, -100, 1.72f, 0.82f, 0.55f, -200, 0.007f, 0.00f,0.00f,0.00f, 300, 0.013f, 0.00f,0.00f,0.00f, 0.188f, 0.260f, 0.250f, 0.000f, -5.0f, 3316.1f, 458.2f, 0.00f, 0x20 }
// WOODEN GALLEON PRESETS
// WOODEN GALLEON PRESETS public static EaxReverb WoodenAlcove = new EaxReverb(26,7.5f,1f,-1000,-1800,-1000,1.22f,0.62f,0.91f,100,0.012f,0f,0f,0f,-300,0.024f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenShortpassage = new EaxReverb(26,7.5f,1f,-1000,-1800,-1000,1.75f,0.50f,0.87f,-100,0.012f,0f,0f,0f,-400,0.024f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenMediumroom = new EaxReverb(26,7.5f,1f,-1000,-2000,-1100,1.47f,0.42f,0.82f,-100,0.049f,0f,0f,0f,-100,0.029f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenLongpassage = new EaxReverb(26,7.5f,1f,-1000,-2000,-1000,1.99f,0.40f,0.79f,000,0.020f,0f,0f,0f,-700,0.036f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenLargeroom = new EaxReverb(26,7.5f,1f,-1000,-2100,-1100,2.65f,0.33f,0.82f,-100,0.066f,0f,0f,0f,-200,0.049f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenHall = new EaxReverb(26,7.5f,1f,-1000,-2200,-1100,3.45f,0.30f,0.82f,-100,0.088f,0f,0f,0f,-200,0.063f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenCupboard = new EaxReverb(26,7.5f,1f,-1000,-1700,-1000,0.56f,0.46f,0.91f,100,0.012f,0f,0f,0f,100,0.028f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenSmallroom = new EaxReverb(26,7.5f,1f,-1000,-1900,-1000,0.79f,0.32f,0.87f,00,0.032f,0f,0f,0f,-100,0.029f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
public static EaxReverb WoodenCourtyard = new EaxReverb(26,7.5f,0.650f,-1000,-2200,-1000,1.79f,0.35f,0.79f,-500,0.123f,0f,0f,0f,-2000,0.032f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,4705f,99.6f,0f,0x3f);
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS // SPORTS PRESETS
#define REVERB_PRESET_WOODEN_ALCOVE \
{ 26, 7.5f, 1.000f, -1000, -1800, -1000, 1.22f, 0.62f, 0.91f, 100, 0.012f, 0.00f,0.00f,0.00f, -300, 0.024f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_SHORTPASSAGE \
{ 26, 7.5f, 1.000f, -1000, -1800, -1000, 1.75f, 0.50f, 0.87f, -100, 0.012f, 0.00f,0.00f,0.00f, -400, 0.024f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_MEDIUMROOM \
{ 26, 7.5f, 1.000f, -1000, -2000, -1100, 1.47f, 0.42f, 0.82f, -100, 0.049f, 0.00f,0.00f,0.00f, -100, 0.029f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_LONGPASSAGE \
{ 26, 7.5f, 1.000f, -1000, -2000, -1000, 1.99f, 0.40f, 0.79f, 000, 0.020f, 0.00f,0.00f,0.00f, -700, 0.036f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_LARGEROOM \
{ 26, 7.5f, 1.000f, -1000, -2100, -1100, 2.65f, 0.33f, 0.82f, -100, 0.066f, 0.00f,0.00f,0.00f, -200, 0.049f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_HALL \
{ 26, 7.5f, 1.000f, -1000, -2200, -1100, 3.45f, 0.30f, 0.82f, -100, 0.088f, 0.00f,0.00f,0.00f, -200, 0.063f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_CUPBOARD \
{ 26, 7.5f, 1.000f, -1000, -1700, -1000, 0.56f, 0.46f, 0.91f, 100, 0.012f, 0.00f,0.00f,0.00f, 100, 0.028f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_SMALLROOM \
{ 26, 7.5f, 1.000f, -1000, -1900, -1000, 0.79f, 0.32f, 0.87f, 00, 0.032f, 0.00f,0.00f,0.00f, -100, 0.029f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
#define REVERB_PRESET_WOODEN_COURTYARD \
{ 26, 7.5f, 0.650f, -1000, -2200, -1000, 1.79f, 0.35f, 0.79f, -500, 0.123f, 0.00f,0.00f,0.00f, -2000, 0.032f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 4705.0f, 99.6f, 0.00f, 0x3f }
public static EaxReverb SportEmptystadium = new EaxReverb(26,7.2f,1f,-1000,-700,-200,6.26f,0.51f,1.10f,-2400,0.183f,0f,0f,0f,-800,0.038f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x20);
public static EaxReverb SportSquashcourt = new EaxReverb(26,7.5f,0.750f,-1000,-1000,-200,2.22f,0.91f,1.16f,-700,0.007f,0f,0f,0f,-200,0.011f,0f,0f,0f,0.126f,0.190f,0.250f,0f,-5f,7176.9f,211.2f,0f,0x20);
public static EaxReverb SportSmallswimmingpool = new EaxReverb(26,36.2f,0.700f,-1000,-200,-100,2.76f,1.25f,1.14f,-400,0.020f,0f,0f,0f,-200,0.030f,0f,0f,0f,0.179f,0.150f,0.895f,0.190f,-5f,5000f,250f,0f,0x0);
public static EaxReverb SportLargeswimmingpool = new EaxReverb(26,36.2f,0.820f,-1000,-200,0,5.49f,1.31f,1.14f,-700,0.039f,0f,0f,0f,-600,0.049f,0f,0f,0f,0.222f,0.550f,1.159f,0.210f,-5f,5000f,250f,0f,0x0);
public static EaxReverb SportGymnasium = new EaxReverb(26,7.5f,0.810f,-1000,-700,-100,3.14f,1.06f,1.35f,-800,0.029f,0f,0f,0f,-500,0.045f,0f,0f,0f,0.146f,0.140f,0.250f,0f,-5f,7176.9f,211.2f,0f,0x20);
public static EaxReverb SportFullstadium = new EaxReverb(26,7.2f,1f,-1000,-2300,-200,5.25f,0.17f,0.80f,-2000,0.188f,0f,0f,0f,-1100,0.038f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x20);
public static EaxReverb SportStadimtannoy = new EaxReverb(26,3f,0.780f,-1000,-500,-600,2.53f,0.88f,0.68f,-1100,0.230f,0f,0f,0f,-600,0.063f,0f,0f,0f,0.250f,0.200f,0.250f,0f,-5f,5000f,250f,0f,0x20);
// SPORTS PRESETS // PREFAB PRESETS
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS public static EaxReverb PrefabWorkshop = new EaxReverb(26,1.9f,1f,-1000,-1700,-800,0.76f,1f,1f,0,0.012f,0f,0f,0f,100,0.012f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x0);
#define REVERB_PRESET_SPORT_EMPTYSTADIUM \ public static EaxReverb PrefabSchoolroom = new EaxReverb(26,1.86f,0.690f,-1000,-400,-600,0.98f,0.45f,0.18f,300,0.017f,0f,0f,0f,300,0.015f,0f,0f,0f,0.095f,0.140f,0.250f,0f,-5f,7176.9f,211.2f,0f,0x20);
{ 26, 7.2f, 1.000f, -1000, -700, -200, 6.26f, 0.51f, 1.10f, -2400, 0.183f, 0.00f,0.00f,0.00f, -800, 0.038f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x20 } public static EaxReverb PrefabPractiseroom = new EaxReverb(26,1.86f,0.870f,-1000,-800,-600,1.12f,0.56f,0.18f,200,0.010f,0f,0f,0f,300,0.011f,0f,0f,0f,0.095f,0.140f,0.250f,0f,-5f,7176.9f,211.2f,0f,0x20);
#define REVERB_PRESET_SPORT_SQUASHCOURT \ public static EaxReverb PrefabOuthouse = new EaxReverb(26,80.3f,0.820f,-1000,-1900,-1600,1.38f,0.38f,0.35f,-100,0.024f,0f,0f,-0f,-400,0.044f,0f,0f,0f,0.121f,0.170f,0.250f,0f,-5f,2854.4f,107.5f,0f,0x0);
{ 26, 7.5f, 0.750f, -1000, -1000, -200, 2.22f, 0.91f, 1.16f, -700, 0.007f, 0.00f,0.00f,0.00f, -200, 0.011f, 0.00f,0.00f,0.00f, 0.126f, 0.190f, 0.250f, 0.000f, -5.0f, 7176.9f, 211.2f, 0.00f, 0x20 } public static EaxReverb PrefabCaravan = new EaxReverb(26,8.3f,1f,-1000,-2100,-1800,0.43f,1.50f,1f,0,0.012f,0f,0f,0f,600,0.012f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x1f);
#define REVERB_PRESET_SPORT_SMALLSWIMMINGPOOL \
{ 26, 36.2f, 0.700f, -1000, -200, -100, 2.76f, 1.25f, 1.14f, -400, 0.020f, 0.00f,0.00f,0.00f, -200, 0.030f, 0.00f,0.00f,0.00f, 0.179f, 0.150f, 0.895f, 0.190f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x0 }
#define REVERB_PRESET_SPORT_LARGESWIMMINGPOOL\
{ 26, 36.2f, 0.820f, -1000, -200, 0, 5.49f, 1.31f, 1.14f, -700, 0.039f, 0.00f,0.00f,0.00f, -600, 0.049f, 0.00f,0.00f,0.00f, 0.222f, 0.550f, 1.159f, 0.210f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x0 }
#define REVERB_PRESET_SPORT_GYMNASIUM \
{ 26, 7.5f, 0.810f, -1000, -700, -100, 3.14f, 1.06f, 1.35f, -800, 0.029f, 0.00f,0.00f,0.00f, -500, 0.045f, 0.00f,0.00f,0.00f, 0.146f, 0.140f, 0.250f, 0.000f, -5.0f, 7176.9f, 211.2f, 0.00f, 0x20 }
#define REVERB_PRESET_SPORT_FULLSTADIUM \
{ 26, 7.2f, 1.000f, -1000, -2300, -200, 5.25f, 0.17f, 0.80f, -2000, 0.188f, 0.00f,0.00f,0.00f, -1100, 0.038f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x20 }
#define REVERB_PRESET_SPORT_STADIUMTANNOY \
{ 26, 3.0f, 0.780f, -1000, -500, -600, 2.53f, 0.88f, 0.68f, -1100, 0.230f, 0.00f,0.00f,0.00f, -600, 0.063f, 0.00f,0.00f,0.00f, 0.250f, 0.200f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x20 }
// DOME AND PIPE PRESETS
// PREFAB PRESETS public static EaxReverb DomeTomb = new EaxReverb(26,51.8f,0.790f,-1000,-900,-1300,4.18f,0.21f,0.10f,-825,0.030f,0f,0f,0f,450,0.022f,0f,0f,0f,0.177f,0.190f,0.250f,0f,-5f,2854.4f,20f,0f,0x0);
public static EaxReverb DomeSaintPauls = new EaxReverb(26,50.3f,0.870f,-1000,-900,-1300,10.48f,0.19f,0.10f,-1500,0.090f,0f,0f,0f,200,0.042f,0f,0f,0f,0.250f,0.120f,0.250f,0f,-5f,2854.4f,20f,0f,0x3f);
public static EaxReverb PipeSmall = new EaxReverb(26,50.3f,1f,-1000,-900,-1300,5.04f,0.10f,0.10f,-600,0.032f,0f,0f,0f,800,0.015f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,2854.4f,20f,0f,0x3f);
public static EaxReverb PipeLongthin = new EaxReverb(26,1.6f,0.910f,-1000,-700,-1100,9.21f,0.18f,0.10f,-300,0.010f,0f,0f,0f,-300,0.022f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,2854.4f,20f,0f,0x0);
public static EaxReverb PipeLarge = new EaxReverb(26,50.3f,1f,-1000,-900,-1300,8.45f,0.10f,0.10f,-800,0.046f,0f,0f,0f,400,0.032f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,2854.4f,20f,0f,0x3f);
public static EaxReverb PipeResonant = new EaxReverb(26,1.3f,0.910f,-1000,-700,-1100,6.81f,0.18f,0.10f,-300,0.010f,0f,0f,0f,00,0.022f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,2854.4f,20f,0f,0x0);
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS // OUTDOORS PRESETS
#define REVERB_PRESET_PREFAB_WORKSHOP \
{ 26, 1.9f, 1.000f, -1000, -1700, -800, 0.76f, 1.00f, 1.00f, 0, 0.012f, 0.00f,0.00f,0.00f, 100, 0.012f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x0 }
#define REVERB_PRESET_PREFAB_SCHOOLROOM \
{ 26, 1.86f, 0.690f, -1000, -400, -600, 0.98f, 0.45f, 0.18f, 300, 0.017f, 0.00f,0.00f,0.00f, 300, 0.015f, 0.00f,0.00f,0.00f, 0.095f, 0.140f, 0.250f, 0.000f, -5.0f, 7176.9f, 211.2f, 0.00f, 0x20 }
#define REVERB_PRESET_PREFAB_PRACTISEROOM \
{ 26, 1.86f, 0.870f, -1000, -800, -600, 1.12f, 0.56f, 0.18f, 200, 0.010f, 0.00f,0.00f,0.00f, 300, 0.011f, 0.00f,0.00f,0.00f, 0.095f, 0.140f, 0.250f, 0.000f, -5.0f, 7176.9f, 211.2f, 0.00f, 0x20 }
#define REVERB_PRESET_PREFAB_OUTHOUSE \
{ 26, 80.3f, 0.820f, -1000, -1900, -1600, 1.38f, 0.38f, 0.35f, -100, 0.024f, 0.00f,0.00f,-0.00f, -400, 0.044f, 0.00f,0.00f,0.00f, 0.121f, 0.170f, 0.250f, 0.000f, -5.0f, 2854.4f, 107.5f, 0.00f, 0x0 }
#define REVERB_PRESET_PREFAB_CARAVAN \
{ 26, 8.3f, 1.000f, -1000, -2100, -1800, 0.43f, 1.50f, 1.00f, 0, 0.012f, 0.00f,0.00f,0.00f, 600, 0.012f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x1f }
// for US developers, a caravan is the same as a trailer =o)
public static EaxReverb OutdoorsBackyard = new EaxReverb(26,80.3f,0.450f,-1000,-1200,-600,1.12f,0.34f,0.46f,-700,0.069f,0f,0f,-0f,-300,0.023f,0f,0f,0f,0.218f,0.340f,0.250f,0f,-5f,4399.1f,242.9f,0f,0x0);
public static EaxReverb OutdoorsRollingplains = new EaxReverb(26,80.3f,0f,-1000,-3900,-400,2.13f,0.21f,0.46f,-1500,0.300f,0f,0f,-0f,-700,0.019f,0f,0f,0f,0.250f,1f,0.250f,0f,-5f,4399.1f,242.9f,0f,0x0);
public static EaxReverb OutdoorsDeepcanyon = new EaxReverb(26,80.3f,0.740f,-1000,-1500,-400,3.89f,0.21f,0.46f,-1000,0.223f,0f,0f,-0f,-900,0.019f,0f,0f,0f,0.250f,1f,0.250f,0f,-5f,4399.1f,242.9f,0f,0x0);
public static EaxReverb OutdoorsCreek = new EaxReverb(26,80.3f,0.350f,-1000,-1500,-600,2.13f,0.21f,0.46f,-800,0.115f,0f,0f,-0f,-1400,0.031f,0f,0f,0f,0.218f,0.340f,0.250f,0f,-5f,4399.1f,242.9f,0f,0x0);
public static EaxReverb OutdoorsValley = new EaxReverb(26,80.3f,0.280f,-1000,-3100,-1600,2.88f,0.26f,0.35f,-1700,0.263f,0f,0f,-0f,-800,0.100f,0f,0f,0f,0.250f,0.340f,0.250f,0f,-5f,2854.4f,107.5f,0f,0x0);
// DOME AND PIPE PRESETS // MOOD PRESETS
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS public static EaxReverb MoodHeaven = new EaxReverb(26,19.6f,0.940f,-1000,-200,-700,5.04f,1.12f,0.56f,-1230,0.020f,0f,0f,0f,200,0.029f,0f,0f,0f,0.250f,0.080f,2.742f,0.050f,-2f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_DOME_TOMB \ public static EaxReverb MoodHell = new EaxReverb(26,100f,0.570f,-1000,-900,-700,3.57f,0.49f,2f,-10000,0.020f,0f,0f,0f,300,0.030f,0f,0f,0f,0.110f,0.040f,2.109f,0.520f,-5f,5000f,139.5f,0f,0x40);
{ 26, 51.8f, 0.790f, -1000, -900, -1300, 4.18f, 0.21f, 0.10f, -825, 0.030f, 0.00f,0.00f,0.00f, 450, 0.022f, 0.00f,0.00f,0.00f, 0.177f, 0.190f, 0.250f, 0.000f, -5.0f, 2854.4f, 20.0f, 0.00f, 0x0 } public static EaxReverb MoodMemory = new EaxReverb(26,8f,0.850f,-1000,-400,-900,4.06f,0.82f,0.56f,-2800,0f,0f,0f,0f,100,0f,0f,0f,0f,0.250f,0f,0.474f,0.450f,-10f,5000f,250f,0f,0x0);
#define REVERB_PRESET_PIPE_SMALL \
{ 26, 50.3f, 1.000f, -1000, -900, -1300, 5.04f, 0.10f, 0.10f, -600, 0.032f, 0.00f,0.00f,0.00f, 800, 0.015f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 2854.4f, 20.0f, 0.00f, 0x3f }
#define REVERB_PRESET_DOME_SAINTPAULS \
{ 26, 50.3f, 0.870f, -1000, -900, -1300, 10.48f, 0.19f, 0.10f, -1500, 0.090f, 0.00f,0.00f,0.00f, 200, 0.042f, 0.00f,0.00f,0.00f, 0.250f, 0.120f, 0.250f, 0.000f, -5.0f, 2854.4f, 20.0f, 0.00f, 0x3f }
#define REVERB_PRESET_PIPE_LONGTHIN \
{ 26, 1.6f, 0.910f, -1000, -700, -1100, 9.21f, 0.18f, 0.10f, -300, 0.010f, 0.00f,0.00f,0.00f, -300, 0.022f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 2854.4f, 20.0f, 0.00f, 0x0 }
#define REVERB_PRESET_PIPE_LARGE \
{ 26, 50.3f, 1.000f, -1000, -900, -1300, 8.45f, 0.10f, 0.10f, -800, 0.046f, 0.00f,0.00f,0.00f, 400, 0.032f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 2854.4f, 20.0f, 0.00f, 0x3f }
#define REVERB_PRESET_PIPE_RESONANT \
{ 26, 1.3f, 0.910f, -1000, -700, -1100, 6.81f, 0.18f, 0.10f, -300, 0.010f, 0.00f,0.00f,0.00f, 00, 0.022f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 2854.4f, 20.0f, 0.00f, 0x0 }
// DRIVING SIMULATION PRESETS
// OUTDOORS PRESETS public static EaxReverb DrivingCommentator = new EaxReverb(26,3f,0f,1000,-500,-600,2.42f,0.88f,0.68f,-1400,0.093f,0f,0f,0f,-1200,0.017f,0f,0f,0f,0.250f,1f,0.250f,0f,-10f,5000f,250f,0f,0x20);
public static EaxReverb DrivingPitgarage = new EaxReverb(26,1.9f,0.590f,-1000,-300,-500,1.72f,0.93f,0.87f,-500,0f,0f,0f,0f,200,0.016f,0f,0f,0f,0.250f,0.110f,0.250f,0f,-5f,5000f,250f,0f,0x0);
public static EaxReverb DrivingIncarRacer = new EaxReverb(26,1.1f,0.800f,-1000,0,-200,0.17f,2f,0.41f,500,0.007f,0f,0f,0f,-300,0.015f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,10268.2f,251f,0f,0x20);
public static EaxReverb DrivingIncarSports = new EaxReverb(26,1.1f,0.800f,-1000,-400,0,0.17f,0.75f,0.41f,0,0.010f,0f,0f,0f,-500,0f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,10268.2f,251f,0f,0x20);
public static EaxReverb DrivingIncarLuxury = new EaxReverb(26,1.6f,1f,-1000,-2000,-600,0.13f,0.41f,0.46f,-200,0.010f,0f,0f,0f,400,0.010f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,10268.2f,251f,0f,0x20);
public static EaxReverb DrivingFullgrandstand = new EaxReverb(26,8.3f,1f,-1000,-1100,-400,3.01f,1.37f,1.28f,-900,0.090f,0f,0f,0f,-1500,0.049f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,10420.2f,250f,0f,0x1f);
public static EaxReverb DrivingEmptygrandstand = new EaxReverb(26,8.3f,1f,-1000,0,-200,4.62f,1.75f,1.40f,-1363,0.090f,0f,0f,0f,-1200,0.049f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,10420.2f,250f,0f,0x1f);
public static EaxReverb DrivingTunnel = new EaxReverb(26,3.1f,0.810f,-1000,-800,-100,3.42f,0.94f,1.31f,-300,0.051f,0f,0f,0f,-300,0.047f,0f,0f,0f,0.214f,0.050f,0.250f,0f,-5f,5000f,155.3f,0f,0x20);
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS // CITY PRESETS
#define REVERB_PRESET_OUTDOORS_BACKYARD \
{ 26, 80.3f, 0.450f, -1000, -1200, -600, 1.12f, 0.34f, 0.46f, -700, 0.069f, 0.00f,0.00f,-0.00f, -300, 0.023f, 0.00f,0.00f,0.00f, 0.218f, 0.340f, 0.250f, 0.000f, -5.0f, 4399.1f, 242.9f, 0.00f, 0x0 }
#define REVERB_PRESET_OUTDOORS_ROLLINGPLAINS \
{ 26, 80.3f, 0.000f, -1000, -3900, -400, 2.13f, 0.21f, 0.46f, -1500, 0.300f, 0.00f,0.00f,-0.00f, -700, 0.019f, 0.00f,0.00f,0.00f, 0.250f, 1.000f, 0.250f, 0.000f, -5.0f, 4399.1f, 242.9f, 0.00f, 0x0 }
#define REVERB_PRESET_OUTDOORS_DEEPCANYON \
{ 26, 80.3f, 0.740f, -1000, -1500, -400, 3.89f, 0.21f, 0.46f, -1000, 0.223f, 0.00f,0.00f,-0.00f, -900, 0.019f, 0.00f,0.00f,0.00f, 0.250f, 1.000f, 0.250f, 0.000f, -5.0f, 4399.1f, 242.9f, 0.00f, 0x0 }
#define REVERB_PRESET_OUTDOORS_CREEK \
{ 26, 80.3f, 0.350f, -1000, -1500, -600, 2.13f, 0.21f, 0.46f, -800, 0.115f, 0.00f,0.00f,-0.00f, -1400, 0.031f, 0.00f,0.00f,0.00f, 0.218f, 0.340f, 0.250f, 0.000f, -5.0f, 4399.1f, 242.9f, 0.00f, 0x0 }
#define REVERB_PRESET_OUTDOORS_VALLEY \
{ 26, 80.3f, 0.280f, -1000, -3100, -1600, 2.88f, 0.26f, 0.35f, -1700, 0.263f, 0.00f,0.00f,-0.00f, -800, 0.100f, 0.00f,0.00f,0.00f, 0.250f, 0.340f, 0.250f, 0.000f, -5.0f, 2854.4f, 107.5f, 0.00f, 0x0 }
public static EaxReverb CityStreets = new EaxReverb(26,3f,0.780f,-1000,-300,-100,1.79f,1.12f,0.91f,-1100,0.046f,0f,0f,0f,-1400,0.028f,0f,0f,0f,0.250f,0.200f,0.250f,0f,-5f,5000f,250f,0f,0x20);
public static EaxReverb CitySubway = new EaxReverb(26,3f,0.740f,-1000,-300,-100,3.01f,1.23f,0.91f,-300,0.046f,0f,0f,0f,200,0.028f,0f,0f,0f,0.125f,0.210f,0.250f,0f,-5f,5000f,250f,0f,0x20);
public static EaxReverb CityMuseum = new EaxReverb(26,80.3f,0.820f,-1000,-1500,-1500,3.28f,1.40f,0.57f,-1200,0.039f,0f,0f,-0f,-100,0.034f,0f,0f,0f,0.130f,0.170f,0.250f,0f,-5f,2854.4f,107.5f,0f,0x0);
public static EaxReverb CityLibrary = new EaxReverb(26,80.3f,0.820f,-1000,-1100,-2100,2.76f,0.89f,0.41f,-900,0.029f,0f,0f,-0f,-100,0.020f,0f,0f,0f,0.130f,0.170f,0.250f,0f,-5f,2854.4f,107.5f,0f,0x0);
public static EaxReverb CityUnderpass = new EaxReverb(26,3f,0.820f,-1000,-700,-100,3.57f,1.12f,0.91f,-800,0.059f,0f,0f,0f,-100,0.037f,0f,0f,0f,0.250f,0.140f,0.250f,0f,-7f,5000f,250f,0f,0x20);
public static EaxReverb CityAbandoned = new EaxReverb(26,3f,0.690f,-1000,-200,-100,3.28f,1.17f,0.91f,-700,0.044f,0f,0f,0f,-1100,0.024f,0f,0f,0f,0.250f,0.200f,0.250f,0f,-3f,5000f,250f,0f,0x20);
// MOOD PRESETS // MISC ROOMS
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS public static EaxReverb Generic = new EaxReverb(0,7.5f,1f,-1000,-100,0,1.49f,0.83f,1f,-2602,0.007f,0f,0f,0f,200,0.011f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_MOOD_HEAVEN \ public static EaxReverb Paddedcell = new EaxReverb(1,1.4f,1f,-1000,-6000,0,0.17f,0.10f,1f,-1204,0.001f,0f,0f,0f,207,0.002f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
{ 26, 19.6f, 0.940f, -1000, -200, -700, 5.04f, 1.12f, 0.56f, -1230, 0.020f, 0.00f,0.00f,0.00f, 200, 0.029f, 0.00f,0.00f,0.00f, 0.250f, 0.080f, 2.742f, 0.050f, -2.0f, 5000.0f, 250.0f, 0.00f, 0x3f } public static EaxReverb Room = new EaxReverb(2,1.9f,1f,-1000,-454,0,0.40f,0.83f,1f,-1646,0.002f,0f,0f,0f,53,0.003f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_MOOD_HELL \ public static EaxReverb Bathroom = new EaxReverb(3,1.4f,1f,-1000,-1200,0,1.49f,0.54f,1f,-370,0.007f,0f,0f,0f,1030,0.011f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
{ 26, 100.0f, 0.570f, -1000, -900, -700, 3.57f, 0.49f, 2.00f, -10000, 0.020f, 0.00f,0.00f,0.00f, 300, 0.030f, 0.00f,0.00f,0.00f, 0.110f, 0.040f, 2.109f, 0.520f, -5.0f, 5000.0f, 139.5f, 0.00f, 0x40 } public static EaxReverb Livingroom = new EaxReverb(4,2.5f,1f,-1000,-6000,0,0.50f,0.10f,1f,-1376,0.003f,0f,0f,0f,-1104,0.004f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_MOOD_MEMORY \ public static EaxReverb Stoneroom = new EaxReverb(5,11.6f,1f,-1000,-300,0,2.31f,0.64f,1f,-711,0.012f,0f,0f,0f,83,0.017f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
{ 26, 8.0f, 0.850f, -1000, -400, -900, 4.06f, 0.82f, 0.56f, -2800, 0.000f, 0.00f,0.00f,0.00f, 100, 0.000f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.474f, 0.450f, -10.0f, 5000.0f, 250.0f, 0.00f, 0x0 } public static EaxReverb Auditorium = new EaxReverb(6,21.6f,1f,-1000,-476,0,4.32f,0.59f,1f,-789,0.020f,0f,0f,0f,-289,0.030f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
public static EaxReverb Concerthall = new EaxReverb(7,19.6f,1f,-1000,-500,0,3.92f,0.70f,1f,-1230,0.020f,0f,0f,0f,-02,0.029f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
public static EaxReverb Cave = new EaxReverb(8,14.6f,1f,-1000,0,0,2.91f,1.30f,1f,-602,0.015f,0f,0f,0f,-302,0.022f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x1f);
// DRIVING SIMULATION PRESETS public static EaxReverb Arena = new EaxReverb(9,36.2f,1f,-1000,-698,0,7.24f,0.33f,1f,-1166,0.020f,0f,0f,0f,16,0.030f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
public static EaxReverb Hangar = new EaxReverb(10,50.3f,1f,-1000,-1000,0,10.05f,0.23f,1f,-602,0.020f,0f,0f,0f,198,0.030f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS public static EaxReverb Carpettedhallway = new EaxReverb(11,1.9f,1f,-1000,-4000,0,0.30f,0.10f,1f,-1831,0.002f,0f,0f,0f,-1630,0.030f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_DRIVING_COMMENTATOR \ public static EaxReverb Hallway = new EaxReverb(12,1.8f,1f,-1000,-300,0,1.49f,0.59f,1f,-1219,0.007f,0f,0f,0f,441,0.011f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
{ 26, 3.0f, 0.000f, 1000, -500, -600, 2.42f, 0.88f, 0.68f, -1400, 0.093f, 0.00f,0.00f,0.00f, -1200, 0.017f, 0.00f,0.00f,0.00f, 0.250f, 1.000f, 0.250f, 0.000f, -10.0f, 5000.0f, 250.0f, 0.00f, 0x20 } public static EaxReverb Stonecorridor = new EaxReverb(13,13.5f,1f,-1000,-237,0,2.70f,0.79f,1f,-1214,0.013f,0f,0f,0f,395,0.020f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_DRIVING_PITGARAGE \ public static EaxReverb Alley = new EaxReverb(14,7.5f,0.300f,-1000,-270,0,1.49f,0.86f,1f,-1204,0.007f,0f,0f,0f,-4,0.011f,0f,0f,0f,0.125f,0.950f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
{ 26, 1.9f, 0.590f, -1000, -300, -500, 1.72f, 0.93f, 0.87f, -500, 0.000f, 0.00f,0.00f,0.00f, 200, 0.016f, 0.00f,0.00f,0.00f, 0.250f, 0.110f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x0 } public static EaxReverb Forest = new EaxReverb(15,38f,0.300f,-1000,-3300,0,1.49f,0.54f,1f,-2560,0.162f,0f,0f,0f,-229,0.088f,0f,0f,0f,0.125f,1f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_DRIVING_INCAR_RACER \ public static EaxReverb City = new EaxReverb(16,7.5f,0.500f,-1000,-800,0,1.49f,0.67f,1f,-2273,0.007f,0f,0f,0f,-1691,0.011f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
{ 26, 1.1f, 0.800f, -1000, 0, -200, 0.17f, 2.00f, 0.41f, 500, 0.007f, 0.00f,0.00f,0.00f, -300, 0.015f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 10268.2f, 251.0f, 0.00f, 0x20 } public static EaxReverb Mountains = new EaxReverb(17,100f,0.270f,-1000,-2500,0,1.49f,0.21f,1f,-2780,0.300f,0f,0f,0f,-1434,0.100f,0f,0f,0f,0.250f,1f,0.250f,0f,-5f,5000f,250f,0f,0x1f);
#define REVERB_PRESET_DRIVING_INCAR_SPORTS \ public static EaxReverb Quarry = new EaxReverb(18,17.5f,1f,-1000,-1000,0,1.49f,0.83f,1f,-10000,0.061f,0f,0f,0f,500,0.025f,0f,0f,0f,0.125f,0.700f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
{ 26, 1.1f, 0.800f, -1000, -400, 0, 0.17f, 0.75f, 0.41f, 0, 0.010f, 0.00f,0.00f,0.00f, -500, 0.000f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 10268.2f, 251.0f, 0.00f, 0x20 } public static EaxReverb Plain = new EaxReverb(19,42.5f,0.210f,-1000,-2000,0,1.49f,0.50f,1f,-2466,0.179f,0f,0f,0f,-1926,0.100f,0f,0f,0f,0.250f,1f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_DRIVING_INCAR_LUXURY \ public static EaxReverb Parkinglot = new EaxReverb(20,8.3f,1f,-1000,0,0,1.65f,1.50f,1f,-1363,0.008f,0f,0f,0f,-1153,0.012f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x1f);
{ 26, 1.6f, 1.000f, -1000, -2000, -600, 0.13f, 0.41f, 0.46f, -200, 0.010f, 0.00f,0.00f,0.00f, 400, 0.010f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 10268.2f, 251.0f, 0.00f, 0x20 } public static EaxReverb Sewerpipe = new EaxReverb(21,1.7f,0.800f,-1000,-1000,0,2.81f,0.14f,1f,429,0.014f,0f,0f,0f,1023,0.021f,0f,0f,0f,0.250f,0f,0.250f,0f,-5f,5000f,250f,0f,0x3f);
#define REVERB_PRESET_DRIVING_FULLGRANDSTAND \ public static EaxReverb Underwater = new EaxReverb(22,1.8f,1f,-1000,-4000,0,1.49f,0.10f,1f,-449,0.007f,0f,0f,0f,1700,0.011f,0f,0f,0f,0.250f,0f,1.180f,0.348f,-5f,5000f,250f,0f,0x3f);
{ 26, 8.3f, 1.000f, -1000, -1100, -400, 3.01f, 1.37f, 1.28f, -900, 0.090f, 0.00f,0.00f,0.00f, -1500, 0.049f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 10420.2f, 250.0f, 0.00f, 0x1f } public static EaxReverb Drugged = new EaxReverb(23,1.9f,0.500f,-1000,0,0,8.39f,1.39f,1f,-115,0.002f,0f,0f,0f,985,0.030f,0f,0f,0f,0.250f,0f,0.250f,1f,-5f,5000f,250f,0f,0x1f);
#define REVERB_PRESET_DRIVING_EMPTYGRANDSTAND \ public static EaxReverb Dizzy = new EaxReverb(24,1.8f,0.600f,-1000,-400,0,17.23f,0.56f,1f,-1713,0.020f,0f,0f,0f,-613,0.030f,0f,0f,0f,0.250f,1f,0.810f,0.310f,-5f,5000f,250f,0f,0x1f);
{ 26, 8.3f, 1.000f, -1000, 0, -200, 4.62f, 1.75f, 1.40f, -1363, 0.090f, 0.00f,0.00f,0.00f, -1200, 0.049f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.000f, -5.0f, 10420.2f, 250.0f, 0.00f, 0x1f } public static EaxReverb Psychotic = new EaxReverb(25,1f,0.500f,-1000,-151,0,7.56f,0.91f,1f,-626,0.020f,0f,0f,0f,774,0.030f,0f,0f,0f,0.250f,0f,4f,1f,-5f,5000f,250f,0f,0x1f);
#define REVERB_PRESET_DRIVING_TUNNEL \ public static EaxReverb Dustyroom = new EaxReverb(26,1.8f,0.560f,-1000,-200,-300,1.79f,0.38f,0.21f,-600,0.002f,0f,0f,0f,200,0.006f,0f,0f,0f,0.202f,0.050f,0.250f,0f,-10f,13046f,163.3f,0f,0x20);
{ 26, 3.1f, 0.810f, -1000, -800, -100, 3.42f, 0.94f, 1.31f, -300, 0.051f, 0.00f,0.00f,0.00f, -300, 0.047f, 0.00f,0.00f,0.00f, 0.214f, 0.050f, 0.250f, 0.000f, -5.0f, 5000.0f, 155.3f, 0.00f, 0x20 } public static EaxReverb Chapel = new EaxReverb(26,19.6f,0.840f,-1000,-500,0,4.62f,0.64f,1.23f,-700,0.032f,0f,0f,0f,-200,0.049f,0f,0f,0f,0.250f,0f,0.250f,0.110f,-5f,5000f,250f,0f,0x3f);
public static EaxReverb Smallwaterroom = new EaxReverb(26,36.2f,0.700f,-1000,-698,0,1.51f,1.25f,1.14f,-100,0.020f,0f,0f,0f,300,0.030f,0f,0f,0f,0.179f,0.150f,0.895f,0.190f,-7f,5000f,250f,0f,0x0);
}
// CITY PRESETS
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS
#define REVERB_PRESET_CITY_STREETS \
{ 26, 3.0f, 0.780f, -1000, -300, -100, 1.79f, 1.12f, 0.91f, -1100, 0.046f, 0.00f,0.00f,0.00f, -1400, 0.028f, 0.00f,0.00f,0.00f, 0.250f, 0.200f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x20 }
#define REVERB_PRESET_CITY_SUBWAY \
{ 26, 3.0f, 0.740f, -1000, -300, -100, 3.01f, 1.23f, 0.91f, -300, 0.046f, 0.00f,0.00f,0.00f, 200, 0.028f, 0.00f,0.00f,0.00f, 0.125f, 0.210f, 0.250f, 0.000f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x20 }
#define REVERB_PRESET_CITY_MUSEUM \
{ 26, 80.3f, 0.820f, -1000, -1500, -1500, 3.28f, 1.40f, 0.57f, -1200, 0.039f, 0.00f,0.00f,-0.00f, -100, 0.034f, 0.00f,0.00f,0.00f, 0.130f, 0.170f, 0.250f, 0.000f, -5.0f, 2854.4f, 107.5f, 0.00f, 0x0 }
#define REVERB_PRESET_CITY_LIBRARY \
{ 26, 80.3f, 0.820f, -1000, -1100, -2100, 2.76f, 0.89f, 0.41f, -900, 0.029f, 0.00f,0.00f,-0.00f, -100, 0.020f, 0.00f,0.00f,0.00f, 0.130f, 0.170f, 0.250f, 0.000f, -5.0f, 2854.4f, 107.5f, 0.00f, 0x0 }
#define REVERB_PRESET_CITY_UNDERPASS \
{ 26, 3.0f, 0.820f, -1000, -700, -100, 3.57f, 1.12f, 0.91f, -800, 0.059f, 0.00f,0.00f,0.00f, -100, 0.037f, 0.00f,0.00f,0.00f, 0.250f, 0.140f, 0.250f, 0.000f, -7.0f, 5000.0f, 250.0f, 0.00f, 0x20 }
#define REVERB_PRESET_CITY_ABANDONED \
{ 26, 3.0f, 0.690f, -1000, -200, -100, 3.28f, 1.17f, 0.91f, -700, 0.044f, 0.00f,0.00f,0.00f, -1100, 0.024f, 0.00f,0.00f,0.00f, 0.250f, 0.200f, 0.250f, 0.000f, -3.0f, 5000.0f, 250.0f, 0.00f, 0x20 }
// MISC ROOMS
// Env Size Diffus Room RoomHF RoomLF DecTm DcHF DcLF Refl RefDel Ref Pan Revb RevDel Rev Pan EchTm EchDp ModTm ModDp AirAbs HFRef LFRef RRlOff FLAGS
#define REVERB_PRESET_DUSTYROOM \
{ 26, 1.8f, 0.560f, -1000, -200, -300, 1.79f, 0.38f, 0.21f, -600, 0.002f, 0.00f,0.00f,0.00f, 200, 0.006f, 0.00f,0.00f,0.00f, 0.202f, 0.050f, 0.250f, 0.000f, -10.0f, 13046.0f, 163.3f, 0.00f, 0x20 }
#define REVERB_PRESET_CHAPEL \
{ 26, 19.6f, 0.840f, -1000, -500, 0, 4.62f, 0.64f, 1.23f, -700, 0.032f, 0.00f,0.00f,0.00f, -200, 0.049f, 0.00f,0.00f,0.00f, 0.250f, 0.000f, 0.250f, 0.110f, -5.0f, 5000.0f, 250.0f, 0.00f, 0x3f }
#define REVERB_PRESET_SMALLWATERROOM \
{ 26, 36.2f, 0.700f, -1000, -698, 0, 1.51f, 1.25f, 1.14f, -100, 0.020f, 0.00f,0.00f,0.00f, 300, 0.030f, 0.00f,0.00f,0.00f, 0.179f, 0.150f, 0.895f, 0.190f, -7.0f, 5000.0f, 250.0f, 0.00f, 0x0 }
*/
} }
} }

677
Source/OpenTK/OpenAL/EfxTokens.cs
View file

@ -10,418 +10,361 @@
using System; using System;
namespace OpenTK.OpenAL.Enums namespace OpenTK.OpenAL.Enums
{ {
// Constants, might be removed if inline docu is sufficiently describing it
// AL chorus effect parameter ranges and defaults
// AL_CHORUS_WAVEFORM_SINUSOID 0
// AL_CHORUS_WAVEFORM_TRIANGLE 1
// AL chorus effect parameter ranges and defaults // AL flanger effect parameter ranges and defaults
// AL_CHORUS_WAVEFORM_SINUSOID 0 // AL_FLANGER_WAVEFORM_SINUSOID 0
// AL_CHORUS_WAVEFORM_TRIANGLE 1 // AL_FLANGER_WAVEFORM_TRIANGLE 1
// AL flanger effect parameter ranges and defaults // AL ring modulator effect parameter ranges and defaults
// AL_FLANGER_WAVEFORM_SINUSOID 0 // AL_RING_MODULATOR_SINUSOID 0
// AL_FLANGER_WAVEFORM_TRIANGLE 1 // AL_RING_MODULATOR_SAWTOOTH 1
// AL_RING_MODULATOR_SQUARE 2
// AL ring modulator effect parameter ranges and defaults // AL vocal morpher effect parameter ranges and defaults
// AL_RING_MODULATOR_SINUSOID 0 // AL_VOCAL_MORPHER_WAVEFORM_SINUSOID 0
// AL_RING_MODULATOR_SAWTOOTH 1 // AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE 1
// AL_RING_MODULATOR_SQUARE 2 // AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH 2
// AL vocal morpher effect parameter ranges and defaults // AL frequency shifter effect parameter ranges and defaults
// AL_VOCAL_MORPHER_WAVEFORM_SINUSOID 0 // AL_FREQUENCY_SHIFTER_DIRECTION_DOWN 0
// AL_VOCAL_MORPHER_WAVEFORM_TRIANGLE 1 // AL_FREQUENCY_SHIFTER_DIRECTION_UP 1
// AL_VOCAL_MORPHER_WAVEFORM_SAWTOOTH 2 // AL_FREQUENCY_SHIFTER_DIRECTION_OFF 2
// AL frequency shifter effect parameter ranges and defaults #region Effect
// AL_FREQUENCY_SHIFTER_DIRECTION_DOWN 0
// AL_FREQUENCY_SHIFTER_DIRECTION_UP 1
// AL_FREQUENCY_SHIFTER_DIRECTION_OFF 2
public enum EfxEffectf : int
{
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.1f</summary>
AL_REVERB_DENSITY = 0x0001,
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.1f</summary>
AL_REVERB_DIFFUSION = 0x0002,
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.32f</summary>
AL_REVERB_GAIN = 0x0003,
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.89f</summary>
AL_REVERB_GAINHF = 0x0004,
///<summary>Reverb Parameter. Unit: Seconds Range [0.1f .. 20.0f] Default: 1.49f</summary>
AL_REVERB_DECAY_TIME = 0x0005,
///<summary>Reverb Parameter. Range [0.1f .. 2.0f] Default: 0.83f</summary>
AL_REVERB_DECAY_HFRATIO = 0x0006,
///<summary>Reverb Parameter. Range [0.0f .. 3.16f] Default: 0.05f</summary>
AL_REVERB_REFLECTIONS_GAIN = 0x0007,
///<summary>Reverb Parameter. Unit: Seconds Range [0.0f .. 0.3f] Default: 0.007f</summary>
AL_REVERB_REFLECTIONS_DELAY = 0x0008,
///<summary>Reverb Parameter. Range [0.0f .. 10.0f] Default: 1.26f</summary>
AL_REVERB_LATE_REVERB_GAIN = 0x0009,
///<summary>Reverb Parameter. Unit: Seconds Range [0.0f .. 0.1f] Default: 0.011f</summary>
AL_REVERB_LATE_REVERB_DELAY = 0x000A,
///<summary>Reverb Parameter. Range [0.892f .. 1.0f] Default: 0.994f</summary>
AL_REVERB_AIR_ABSORPTION_GAINHF = 0x000B,
///<summary>Reverb Parameter. Range [0.0f .. 10.0f] Default: 0.0f</summary>
AL_REVERB_ROOM_ROLLOFF_FACTOR = 0x000C,
///<summary>Chorus Parameter. Unit: Hz Range [0.0f .. 10.0f] Default: 1.1f</summary>
AL_CHORUS_RATE = 0x0003,
///<summary>Chorus Parameter. Range [0.0f .. 1.0f] Default: 0.1f</summary>
AL_CHORUS_DEPTH = 0x0004,
///<summary>Chorus Parameter. Range [-1.0f .. +1.0f] Default: +0.25f</summary>
AL_CHORUS_FEEDBACK = 0x0005,
///<summary>Chorus Parameter. Unit: Seconds Range [0.0f .. 0.016f] Default: 0.016f</summary>
AL_CHORUS_DELAY = 0x0006,
/** ///<summary>Distortion Parameter. Range [0.0f .. 1.0f] Default: 0.2f</summary>
* Context definitions to be used with alcCreateContext. AL_DISTORTION_EDGE = 0x0001,
* These values must be unique and not conflict with other ///<summary>Distortion Parameter. Range [0.01f .. 1.0f] Default: 0.05f</summary>
* al context values. AL_DISTORTION_GAIN = 0x0002,
*/ ///<summary>Distortion Parameter. Unit: Hz Range [80.0f .. 24000.0f] Default: 8000.0f</summary>
public enum NEWALCTOKENS : int AL_DISTORTION_LOWPASS_CUTOFF = 0x0003,
{ ///<summary>Distortion Parameter. Unit: Hz Range [80.0f .. 24000.0f] Default: 3600.0f</summary>
/// <summary>This Context property can be used by the application to retrieve the Major version number of the Effects Extension supported by this OpenAL implementation. As this is a Context property is should be retrieved using alcGetIntegerv.</summary> AL_DISTORTION_EQCENTER = 0x0004,
ALC_EFX_MAJOR_VERSION = 0x20001, ///<summary>Distortion Parameter. Unit: Hz Range [80.0f .. 24000.0f] Default: 3600.0f</summary>
AL_DISTORTION_EQBANDWIDTH = 0x0005,
/// <summary>This Context property can be used by the application to retrieve the Minor version number of the Effects Extension supported by this OpenAL implementation. As this is a Context property is should be retrieved using alcGetIntegerv.</summary> ///<summary>Echo Parameter. Unit: Seconds Range [0.0f .. 0.207f] Default: 0.1f</summary>
ALC_EFX_MINOR_VERSION = 0x20002, AL_ECHO_DELAY = 0x0001,
///<summary>Echo Parameter. Unit: Seconds Range [0.0f .. 0.404f] Default: 0.1f</summary>
AL_ECHO_LRDELAY = 0x0002,
///<summary>Echo Parameter. Range [0.0f .. 0.99f] Default: 0.5f</summary>
AL_ECHO_DAMPING = 0x0003,
///<summary>Echo Parameter. Range [0.0f .. 1.0f] Default: 0.5f</summary>
AL_ECHO_FEEDBACK = 0x0004,
///<summary>Echo Parameter. Range [-1.0f .. +1.0f] Default: -1.0f</summary>
AL_ECHO_SPREAD = 0x0005,
/// <summary>This Context property can be passed to OpenAL during Context creation (alcCreateContext) to request a maximum number of Auxiliary Sends desired on each Source. It is not guaranteed that the desired number of sends will be available, so an application should query this property after creating the context using alcGetIntergerv. Default: 2</summary> ///<summary>Flanger Parameter. Range [0.0f .. 10.0f] Default: 0.27f</summary>
ALC_MAX_AUXILIARY_SENDS = 0x20003, AL_FLANGER_RATE = 0x0003,
} ///<summary>Flanger Parameter. Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_FLANGER_DEPTH = 0x0004,
///<summary>Flanger Parameter. Range [-1.0f .. +1.0f] Default: -0.5f</summary>
AL_FLANGER_FEEDBACK = 0x0005,
///<summary>Flanger Parameter. Unit: Seconds Range [0.0f .. 0.004f] Default: 0.002f</summary>
AL_FLANGER_DELAY = 0x0006,
public enum NEWLISTENERTOKENS : int ///<summary>Frequencyshifter Parameter. Unit: Hz Range [0.0f .. 24000.0f] Default: 0.0f</summary>
{ AL_FREQUENCY_SHIFTER_FREQUENCY = 0x0001,
/* Listener definitions to be used with alListener functions. ///<summary>Vocalmorpher Parameter. Unit: Hz Range [0.0f .. 10.0f] Default: 1.41f</summary>
* These values must be unique and not conflict with other AL_VOCAL_MORPHER_RATE = 0x0006,
* al listener values.*/
///<summary>The Listener property allows an application to specify the relationship between the units passed to OpenAL calls such as positions, velocities, reference distance, etc … and the real-world. This information is critical if Air Absorption effects are enabled because the amount of Air Absorption applied is directly related to the real-world distance between the Source and the Listener. If the application is using centimeters for distance units, then this property should be set to 0.01 so that the amount of air absorption applied is not 100 times too great! Range [float.MinValue .. float.MaxValue] Default: 1.0f</summary> ///<summary>Ringmodulator Parameter. Unit: Hz Range [0.0f .. 8000.0f] Default: 440.0f</summary>
AL_METERS_PER_UNIT = 0x20004, AL_RING_MODULATOR_FREQUENCY = 0x0001,
} ///<summary>Ringmodulator Parameter. Unit: Hz Range [0.0f .. 24000.0f] Default: 800.0f</summary>
AL_RING_MODULATOR_HIGHPASS_CUTOFF = 0x0002,
public enum NEWSSOURCETOKENS : int ///<summary>Autowah Parameter. Unit: Seconds Range [0.0001f .. 1.0f] Default: 0.06f</summary>
{ AL_AUTOWAH_ATTACK_TIME = 0x0001,
/** ///<summary>Autowah Parameter. Unit: Seconds Range [0.0001f .. 1.0f] Default: 0.06f</summary>
* Source definitions to be used with alSource functions. AL_AUTOWAH_RELEASE_TIME = 0x0002,
* These values must be unique and not conflict with other ///<summary>Autowah Parameter. Range [2.0f .. 1000.0f] Default: 1000.0f</summary>
* al source values. AL_AUTOWAH_RESONANCE = 0x0003,
*/ ///<summary>Autowah Parameter. Range [0.00003f .. 31621.0f] Default: 11.22f</summary>
///<summary>This Source property is used to apply filtering on the direct-path (dry signal) of a Source.</summary> AL_AUTOWAH_PEAK_GAIN = 0x0004,
AL_DIRECT_FILTER = 0x20005,
///<summary>This Source property is used to establish connections between Sources and Auxiliary Effect Slots. For a Source to feed an Effect that has been loaded into an Auxiliary Effect Slot the application must configure one of the Source’s auxiliary sends. This process involves setting 3 variables – the destination Auxiliary Effect Slot ID, the Auxiliary Send number, and an optional Filter ID.</summary>
AL_AUXILIARY_SEND_FILTER = 0x20006, // Sourcei3
///<summary>This Source property is a multiplier on the amount of Air Absorption applied to the Source. The AL_AIR_ABSORPTION_FACTOR is multiplied by an internal Air Absorption Gain HF value of 0.994 (-0.05dB) per meter which represents normal atmospheric humidity and temperature. Range [0.0f .. 10.0f] Default: 0.0f</summary> ///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary>
AL_AIR_ABSORPTION_FACTOR = 0x20007, AL_EQUALIZER_LOW_GAIN = 0x0001,
///<summary>This Source property is defined the same way as the Reverb Room Rolloff property: it is one of two methods available in the Effect Extension to attenuate the reflected sound (early reflections and reverberation) according to source-listener distance. Range [0.0f .. 10.0f] Default: 0.0f</summary> ///<summary>Equalizer Parameter. Unit: Hz Range [50.0f .. 800.0f] Default: 200.0f</summary>
AL_ROOM_ROLLOFF_FACTOR = 0x20008, AL_EQUALIZER_LOW_CUTOFF = 0x0002,
///<summary>This Source property enhances the directivity for individual Sources. A directed Source points in a specified direction. The Source sounds at full volume when the listener is directly in front of the source; it is attenuated as the listener circles the Source away from the front. Range [0.0f .. 1.0f] Default: 1.0f</summary> ///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary>
AL_CONE_OUTER_GAINHF = 0x20009, AL_EQUALIZER_MID1_GAIN = 0x0003,
///<summary>If this Source property is set to AL_TRUE (its default value), this Source’s direct-path is automatically filtered according to the orientation of the source relative to the listener and the setting of the Source property AL_CONE_OUTER_GAINHF. Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary> ///<summary>Equalizer Parameter. Unit: Hz Range [200.0f .. 3000.0f] Default: 500.0f</summary>
AL_DIRECT_FILTER_GAINHF_AUTO = 0x2000A, AL_EQUALIZER_MID1_CENTER = 0x0004,
///<summary>If this Source property is set to AL_TRUE (its default value), the intensity of this Source’s reflected sound is automatically attenuated according to source-listener distance and source directivity (as determined by the cone parameters). If it is AL_FALSE, the reflected sound is not attenuated according to distance and directivity. Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary> ///<summary>Equalizer Parameter. Range [0.01f .. 1.0f] Default: 1.0f</summary>
AL_AUXILIARY_SEND_FILTER_GAIN_AUTO = 0x2000B, AL_EQUALIZER_MID1_WIDTH = 0x0005,
///<summary>If this Source property is AL_TRUE (its default value), the intensity of this Source’s reflected sound at high frequencies will be automatically attenuated according to the high-frequency source directivity as set by the AL_CONE_OUTER_GAINHF property. If this property is AL_FALSE, the Source’s reflected sound is not filtered at all according to the Source’s directivity. Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary> ///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary>
AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO = 0x2000C, AL_EQUALIZER_MID2_GAIN = 0x0006,
} ///<summary>Equalizer Parameter. Unit: Hz Range [1000.0f .. 8000.0f] Default: 3000.0f</summary>
AL_EQUALIZER_MID2_CENTER = 0x0007,
///<summary>Equalizer Parameter. Range [0.01f .. 1.0f] Default: 1.0f</summary>
AL_EQUALIZER_MID2_WIDTH = 0x0008,
///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary>
AL_EQUALIZER_HIGH_GAIN = 0x0009,
///<summary>Equalizer Parameter. Unit: Hz Range [4000.0f .. 16000.0f] Default: 6000.0f</summary>
AL_EQUALIZER_HIGH_CUTOFF = 0x000A,
#region Effect ///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_EAXREVERB_DENSITY = 0x0001,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_EAXREVERB_DIFFUSION = 0x0002,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.32f</summary>
AL_EAXREVERB_GAIN = 0x0003,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.89f</summary>
AL_EAXREVERB_GAINHF = 0x0004,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_EAXREVERB_GAINLF = 0x0005,
///<summary>EAXReverb effect parameters. Unit: Seconds Range [0.1f .. 20.0f] Default: 1.49f</summary>
AL_EAXREVERB_DECAY_TIME = 0x0006,
///<summary>EAXReverb effect parameters. Range [0.1f .. 2.0f] Default: 0.83f</summary>
AL_EAXREVERB_DECAY_HFRATIO = 0x0007,
///<summary>EAXReverb effect parameters. Range [0.1f .. 2.0f] Default: 1.0f</summary>
AL_EAXREVERB_DECAY_LFRATIO = 0x0008,
///<summary>EAXReverb effect parameters. Range [0.0f .. 3.16f] Default: 0.05f</summary>
AL_EAXREVERB_REFLECTIONS_GAIN = 0x0009,
///<summary>EAXReverb effect parameters. Unit: Seconds Range [0.0f .. 0.3f] Default: 0.007f</summary>
AL_EAXREVERB_REFLECTIONS_DELAY = 0x000A,
/// <summary>EAXReverb effect parameters. Unit: Vector3 Default: {0.0f, 0.0f, 0.0f}</summary>
AL_EAXREVERB_REFLECTIONS_PAN = 0x000B,
///<summary>EAXReverb effect parameters. Range [0.0f .. 10.0f] Default: 1.26f</summary>
AL_EAXREVERB_LATE_REVERB_GAIN = 0x000C,
///<summary>EAXReverb effect parameters. Unit: Seconds Range [0.0f .. 0.1f] Default: 0.011f</summary>
AL_EAXREVERB_LATE_REVERB_DELAY = 0x000D,
/// <summary>EAXReverb effect parameters. Unit: Vector3 Default: {0.0f, 0.0f, 0.0f}</summary>
AL_EAXREVERB_LATE_REVERB_PAN = 0x000E,
///<summary>EAXReverb effect parameters. Range [0.075f .. 0.25f] Default: 0.25f</summary>
AL_EAXREVERB_ECHO_TIME = 0x000F,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.0f</summary>
AL_EAXREVERB_ECHO_DEPTH = 0x0010,
///<summary>EAXReverb effect parameters. Range [0.04f .. 4.0f] Default: 0.25f</summary>
AL_EAXREVERB_MODULATION_TIME = 0x0011,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.0f</summary>
AL_EAXREVERB_MODULATION_DEPTH = 0x0012,
///<summary>EAXReverb effect parameters. Range [0.892f .. 1.0f] Default: 0.994f</summary>
AL_EAXREVERB_AIR_ABSORPTION_GAINHF = 0x0013,
///<summary>EAXReverb effect parameters. Unit: Hz Range [1000.0f .. 20000.0f] Default: 5000.0f</summary>
AL_EAXREVERB_HFREFERENCE = 0x0014,
///<summary>EAXReverb effect parameters. Unit: Hz Range [20.0f .. 1000.0f] Default: 250.0f</summary>
AL_EAXREVERB_LFREFERENCE = 0x0015,
///<summary>EAXReverb effect parameters. Range [0.0f .. 10.0f] Default: 0.0f</summary>
AL_EAXREVERB_ROOM_ROLLOFF_FACTOR = 0x0016,
}
public enum EfxEffectf : int public enum EfxEffecti : int
{ {
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.1f</summary> ///<summary>Chorus Parameter. Unit: (0) Sinusoid, (1) Triangle [0 .. 1] Default: 1</summary>
AL_REVERB_DENSITY = 0x0001, AL_CHORUS_WAVEFORM = 0x0001,
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.1f</summary> ///<summary>Chorus Parameter. Unit: Degrees Range [-180 .. 180] Default: 90</summary>
AL_REVERB_DIFFUSION = 0x0002, AL_CHORUS_PHASE = 0x0002,
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.32f</summary>
AL_REVERB_GAIN = 0x0003,
///<summary>Reverb Parameter. Range [0.0f .. 1.0f] Default: 0.89f</summary>
AL_REVERB_GAINHF = 0x0004,
///<summary>Reverb Parameter. Unit: Seconds Range [0.1f .. 20.0f] Default: 1.49f</summary>
AL_REVERB_DECAY_TIME = 0x0005,
///<summary>Reverb Parameter. Range [0.1f .. 2.0f] Default: 0.83f</summary>
AL_REVERB_DECAY_HFRATIO = 0x0006,
///<summary>Reverb Parameter. Range [0.0f .. 3.16f] Default: 0.05f</summary>
AL_REVERB_REFLECTIONS_GAIN = 0x0007,
///<summary>Reverb Parameter. Unit: Seconds Range [0.0f .. 0.3f] Default: 0.007f</summary>
AL_REVERB_REFLECTIONS_DELAY = 0x0008,
///<summary>Reverb Parameter. Range [0.0f .. 10.0f] Default: 1.26f</summary>
AL_REVERB_LATE_REVERB_GAIN = 0x0009,
///<summary>Reverb Parameter. Unit: Seconds Range [0.0f .. 0.1f] Default: 0.011f</summary>
AL_REVERB_LATE_REVERB_DELAY = 0x000A,
///<summary>Reverb Parameter. Range [0.892f .. 1.0f] Default: 0.994f</summary>
AL_REVERB_AIR_ABSORPTION_GAINHF = 0x000B,
///<summary>Reverb Parameter. Range [0.0f .. 10.0f] Default: 0.0f</summary>
AL_REVERB_ROOM_ROLLOFF_FACTOR = 0x000C,
///<summary>Chorus Parameter. Unit: Hz Range [0.0f .. 10.0f] Default: 1.1f</summary> ///<summary>Flanger Parameter. Unit: (0) Sinusoid, (1) Triangle Range [0 .. 1] Default: 1</summary>
AL_CHORUS_RATE = 0x0003, AL_FLANGER_WAVEFORM = 0x0001,
///<summary>Chorus Parameter. Range [0.0f .. 1.0f] Default: 0.1f</summary> ///<summary>Flanger Parameter. Range [-180 .. +180] Default: 0</summary>
AL_CHORUS_DEPTH = 0x0004, AL_FLANGER_PHASE = 0x0002,
///<summary>Chorus Parameter. Range [-1.0f .. +1.0f] Default: +0.25f</summary>
AL_CHORUS_FEEDBACK = 0x0005,
///<summary>Chorus Parameter. Unit: Seconds Range [0.0f .. 0.016f] Default: 0.016f</summary>
AL_CHORUS_DELAY = 0x0006,
///<summary>Distortion Parameter. Range [0.0f .. 1.0f] Default: 0.2f</summary> ///<summary>Frequencyshifter Parameter. Unit: (0) Down, (1) Up, (2) Off Range [0 .. 2] Default: 0</summary>
AL_DISTORTION_EDGE = 0x0001, AL_FREQUENCY_SHIFTER_LEFT_DIRECTION = 0x0002,
///<summary>Distortion Parameter. Range [0.01f .. 1.0f] Default: 0.05f</summary> ///<summary>Frequencyshifter Parameter. Unit: (0) Down, (1) Up, (2) Off Range [0 .. 2] Default: 0</summary>
AL_DISTORTION_GAIN = 0x0002, AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION = 0x0003,
///<summary>Distortion Parameter. Unit: Hz Range [80.0f .. 24000.0f] Default: 8000.0f</summary>
AL_DISTORTION_LOWPASS_CUTOFF = 0x0003,
///<summary>Distortion Parameter. Unit: Hz Range [80.0f .. 24000.0f] Default: 3600.0f</summary>
AL_DISTORTION_EQCENTER = 0x0004,
///<summary>Distortion Parameter. Unit: Hz Range [80.0f .. 24000.0f] Default: 3600.0f</summary>
AL_DISTORTION_EQBANDWIDTH = 0x0005,
///<summary>Echo Parameter. Unit: Seconds Range [0.0f .. 0.207f] Default: 0.1f</summary> ///<summary>Vocalmorpher Parameter. Unit: Use enum EfxFormantFilterSettings Range [0 .. 29] Default: 0, AL_VOCAL_MORPHER_PHONEME_A</summary>
AL_ECHO_DELAY = 0x0001, AL_VOCAL_MORPHER_PHONEMEA = 0x0001,
///<summary>Echo Parameter. Unit: Seconds Range [0.0f .. 0.404f] Default: 0.1f</summary> ///<summary>Vocalmorpher Parameter. Unit: Semitones Range [-24 .. +24] Default: 0</summary>
AL_ECHO_LRDELAY = 0x0002, AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING = 0x0002,
///<summary>Echo Parameter. Range [0.0f .. 0.99f] Default: 0.5f</summary> ///<summary>Vocalmorpher Parameter. Unit: Use enum EfxFormantFilterSettings Range [0 .. 29] Default: 10, AL_VOCAL_MORPHER_PHONEME_ER</summary>
AL_ECHO_DAMPING = 0x0003, AL_VOCAL_MORPHER_PHONEMEB = 0x0003,
///<summary>Echo Parameter. Range [0.0f .. 1.0f] Default: 0.5f</summary> ///<summary>Vocalmorpher Parameter. Unit: Semitones Range [-24 .. +24] Default: 0</summary>
AL_ECHO_FEEDBACK = 0x0004, AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING = 0x0004,
///<summary>Echo Parameter. Range [-1.0f .. +1.0f] Default: -1.0f</summary> ///<summary>Vocalmorpher Parameter. Unit: (0) Sinusoid, (1) Triangle, (2) Sawtooth Range [0 .. 2] Default: 0</summary>
AL_ECHO_SPREAD = 0x0005, AL_VOCAL_MORPHER_WAVEFORM = 0x0005,
///<summary>Flanger Parameter. Range [0.0f .. 10.0f] Default: 0.27f</summary> ///<summary>Pitchshifter Parameter. Unit: Semitones Range [-12 .. +12] Default: +12</summary>
AL_FLANGER_RATE = 0x0003, AL_PITCH_SHIFTER_COARSE_TUNE = 0x0001,
///<summary>Flanger Parameter. Range [0.0f .. 1.0f] Default: 1.0f</summary> ///<summary>Pitchshifter Parameter. Unit: Cents Range [-50 .. +50] Default: 0</summary>
AL_FLANGER_DEPTH = 0x0004, AL_PITCH_SHIFTER_FINE_TUNE = 0x0002,
///<summary>Flanger Parameter. Range [-1.0f .. +1.0f] Default: -0.5f</summary>
AL_FLANGER_FEEDBACK = 0x0005,
///<summary>Flanger Parameter. Unit: Seconds Range [0.0f .. 0.004f] Default: 0.002f</summary>
AL_FLANGER_DELAY = 0x0006,
///<summary>Frequencyshifter Parameter. Unit: Hz Range [0.0f .. 24000.0f] Default: 0.0f</summary> ///<summary>Ringmodulator Parameter. Unit: (0) Sinusoid, (1) Sawtooth, (2) Square Range [0 .. 2] Default: 0</summary>
AL_FREQUENCY_SHIFTER_FREQUENCY = 0x0001, AL_RING_MODULATOR_WAVEFORM = 0x0003,
///<summary>Vocalmorpher Parameter. Unit: Hz Range [0.0f .. 10.0f] Default: 1.41f</summary> ///<summary>Compressor Parameter. Unit: (0) Off, (1) On Range [0 .. 1] Default: 1</summary>
AL_VOCAL_MORPHER_RATE = 0x0006, AL_COMPRESSOR_ONOFF = 0x0001,
///<summary>Ringmodulator Parameter. Unit: Hz Range [0.0f .. 8000.0f] Default: 440.0f</summary> ///<summary>Reverb Parameter. Unit: (0) False, (1) True Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary>
AL_RING_MODULATOR_FREQUENCY = 0x0001, AL_REVERB_DECAY_HFLIMIT = 0x000D,
///<summary>Ringmodulator Parameter. Unit: Hz Range [0.0f .. 24000.0f] Default: 800.0f</summary>
AL_RING_MODULATOR_HIGHPASS_CUTOFF = 0x0002,
///<summary>Autowah Parameter. Unit: Seconds Range [0.0001f .. 1.0f] Default: 0.06f</summary> ///<summary>EAXReverb effect parameters. Unit: (0) False, (1) True Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary>
AL_AUTOWAH_ATTACK_TIME = 0x0001, AL_EAXREVERB_DECAY_HFLIMIT = 0x0017,
///<summary>Autowah Parameter. Unit: Seconds Range [0.0001f .. 1.0f] Default: 0.06f</summary>
AL_AUTOWAH_RELEASE_TIME = 0x0002,
///<summary>Autowah Parameter. Range [2.0f .. 1000.0f] Default: 1000.0f</summary>
AL_AUTOWAH_RESONANCE = 0x0003,
///<summary>Autowah Parameter. Range [0.00003f .. 31621.0f] Default: 11.22f</summary>
AL_AUTOWAH_PEAK_GAIN = 0x0004,
///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary> AL_EFFECT_FIRST_PARAMETER = 0x0000,// deprecated?
AL_EQUALIZER_LOW_GAIN = 0x0001, AL_EFFECT_LAST_PARAMETER = 0x8000, // deprecated?
///<summary>Equalizer Parameter. Unit: Hz Range [50.0f .. 800.0f] Default: 200.0f</summary>
AL_EQUALIZER_LOW_CUTOFF = 0x0002,
///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary>
AL_EQUALIZER_MID1_GAIN = 0x0003,
///<summary>Equalizer Parameter. Unit: Hz Range [200.0f .. 3000.0f] Default: 500.0f</summary>
AL_EQUALIZER_MID1_CENTER = 0x0004,
///<summary>Equalizer Parameter. Range [0.01f .. 1.0f] Default: 1.0f</summary>
AL_EQUALIZER_MID1_WIDTH = 0x0005,
///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary>
AL_EQUALIZER_MID2_GAIN = 0x0006,
///<summary>Equalizer Parameter. Unit: Hz Range [1000.0f .. 8000.0f] Default: 3000.0f</summary>
AL_EQUALIZER_MID2_CENTER = 0x0007,
///<summary>Equalizer Parameter. Range [0.01f .. 1.0f] Default: 1.0f</summary>
AL_EQUALIZER_MID2_WIDTH = 0x0008,
///<summary>Equalizer Parameter. Range [0.126f .. 7.943f] Default: 1.0f</summary>
AL_EQUALIZER_HIGH_GAIN = 0x0009,
///<summary>Equalizer Parameter. Unit: Hz Range [4000.0f .. 16000.0f] Default: 6000.0f</summary>
AL_EQUALIZER_HIGH_CUTOFF = 0x000A,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 1.0f</summary> /// <summary>Used with the enum EfxEffectType as it's parameter.</summary>
AL_EAXREVERB_DENSITY = 0x0001, EffectType = 0x8001,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 1.0f</summary> }
AL_EAXREVERB_DIFFUSION = 0x0002,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.32f</summary>
AL_EAXREVERB_GAIN = 0x0003,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.89f</summary>
AL_EAXREVERB_GAINHF = 0x0004,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_EAXREVERB_GAINLF = 0x0005,
///<summary>EAXReverb effect parameters. Unit: Seconds Range [0.1f .. 20.0f] Default: 1.49f</summary>
AL_EAXREVERB_DECAY_TIME = 0x0006,
///<summary>EAXReverb effect parameters. Range [0.1f .. 2.0f] Default: 0.83f</summary>
AL_EAXREVERB_DECAY_HFRATIO = 0x0007,
///<summary>EAXReverb effect parameters. Range [0.1f .. 2.0f] Default: 1.0f</summary>
AL_EAXREVERB_DECAY_LFRATIO = 0x0008,
///<summary>EAXReverb effect parameters. Range [0.0f .. 3.16f] Default: 0.05f</summary>
AL_EAXREVERB_REFLECTIONS_GAIN = 0x0009,
///<summary>EAXReverb effect parameters. Unit: Seconds Range [0.0f .. 0.3f] Default: 0.007f</summary>
AL_EAXREVERB_REFLECTIONS_DELAY = 0x000A,
/// <summary>EAXReverb effect parameters. Unit: Vector3 Default: {0.0f, 0.0f, 0.0f}</summary>
AL_EAXREVERB_REFLECTIONS_PAN = 0x000B,
///<summary>EAXReverb effect parameters. Range [0.0f .. 10.0f] Default: 1.26f</summary>
AL_EAXREVERB_LATE_REVERB_GAIN = 0x000C,
///<summary>EAXReverb effect parameters. Unit: Seconds Range [0.0f .. 0.1f] Default: 0.011f</summary>
AL_EAXREVERB_LATE_REVERB_DELAY = 0x000D,
/// <summary>EAXReverb effect parameters. Unit: Vector3 Default: {0.0f, 0.0f, 0.0f}</summary>
AL_EAXREVERB_LATE_REVERB_PAN = 0x000E,
///<summary>EAXReverb effect parameters. Range [0.075f .. 0.25f] Default: 0.25f</summary>
AL_EAXREVERB_ECHO_TIME = 0x000F,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.0f</summary>
AL_EAXREVERB_ECHO_DEPTH = 0x0010,
///<summary>EAXReverb effect parameters. Range [0.04f .. 4.0f] Default: 0.25f</summary>
AL_EAXREVERB_MODULATION_TIME = 0x0011,
///<summary>EAXReverb effect parameters. Range [0.0f .. 1.0f] Default: 0.0f</summary>
AL_EAXREVERB_MODULATION_DEPTH = 0x0012,
///<summary>EAXReverb effect parameters. Range [0.892f .. 1.0f] Default: 0.994f</summary>
AL_EAXREVERB_AIR_ABSORPTION_GAINHF = 0x0013,
///<summary>EAXReverb effect parameters. Unit: Hz Range [1000.0f .. 20000.0f] Default: 5000.0f</summary>
AL_EAXREVERB_HFREFERENCE = 0x0014,
///<summary>EAXReverb effect parameters. Unit: Hz Range [20.0f .. 1000.0f] Default: 250.0f</summary>
AL_EAXREVERB_LFREFERENCE = 0x0015,
///<summary>EAXReverb effect parameters. Range [0.0f .. 10.0f] Default: 0.0f</summary>
AL_EAXREVERB_ROOM_ROLLOFF_FACTOR = 0x0016,
}
public enum EfxEffecti : int ///<summary>Vocal morpher effect parameters.</summary>
{ public enum EfxFormantFilterSettings : int
///<summary>Chorus Parameter. Unit: (0) Sinusoid, (1) Triangle [0 .. 1] Default: 1</summary> {
AL_CHORUS_WAVEFORM = 0x0001, AL_VOCAL_MORPHER_PHONEME_A = 0,
///<summary>Chorus Parameter. Unit: Degrees Range [-180 .. 180] Default: 90</summary> AL_VOCAL_MORPHER_PHONEME_E = 1,
AL_CHORUS_PHASE = 0x0002, AL_VOCAL_MORPHER_PHONEME_I = 2,
AL_VOCAL_MORPHER_PHONEME_O = 3,
AL_VOCAL_MORPHER_PHONEME_U = 4,
AL_VOCAL_MORPHER_PHONEME_AA = 5,
AL_VOCAL_MORPHER_PHONEME_AE = 6,
AL_VOCAL_MORPHER_PHONEME_AH = 7,
AL_VOCAL_MORPHER_PHONEME_AO = 8,
AL_VOCAL_MORPHER_PHONEME_EH = 9,
AL_VOCAL_MORPHER_PHONEME_ER = 10,
AL_VOCAL_MORPHER_PHONEME_IH = 11,
AL_VOCAL_MORPHER_PHONEME_IY = 12,
AL_VOCAL_MORPHER_PHONEME_UH = 13,
AL_VOCAL_MORPHER_PHONEME_UW = 14,
AL_VOCAL_MORPHER_PHONEME_B = 15,
AL_VOCAL_MORPHER_PHONEME_D = 16,
AL_VOCAL_MORPHER_PHONEME_F = 17,
AL_VOCAL_MORPHER_PHONEME_G = 18,
AL_VOCAL_MORPHER_PHONEME_J = 19,
AL_VOCAL_MORPHER_PHONEME_K = 20,
AL_VOCAL_MORPHER_PHONEME_L = 21,
AL_VOCAL_MORPHER_PHONEME_M = 22,
AL_VOCAL_MORPHER_PHONEME_N = 23,
AL_VOCAL_MORPHER_PHONEME_P = 24,
AL_VOCAL_MORPHER_PHONEME_R = 25,
AL_VOCAL_MORPHER_PHONEME_S = 26,
AL_VOCAL_MORPHER_PHONEME_T = 27,
AL_VOCAL_MORPHER_PHONEME_V = 28,
AL_VOCAL_MORPHER_PHONEME_Z = 29,
}
///<summary>Flanger Parameter. Unit: (0) Sinusoid, (1) Triangle Range [0 .. 1] Default: 1</summary> ///<summary>Effect type definitions to be used with AL_EFFECT_TYPE.</summary>
AL_FLANGER_WAVEFORM = 0x0001, public enum EfxEffectType : int
///<summary>Flanger Parameter. Range [-180 .. +180] Default: 0</summary> {
AL_FLANGER_PHASE = 0x0002, AL_EFFECT_NULL = 0x0000, /* Can also be used as an Effect Object ID */
AL_EFFECT_REVERB = 0x0001,
AL_EFFECT_CHORUS = 0x0002,
AL_EFFECT_DISTORTION = 0x0003,
AL_EFFECT_ECHO = 0x0004,
AL_EFFECT_FLANGER = 0x0005,
AL_EFFECT_FREQUENCY_SHIFTER = 0x0006,
AL_EFFECT_VOCAL_MORPHER = 0x0007,
AL_EFFECT_PITCH_SHIFTER = 0x0008,
AL_EFFECT_RING_MODULATOR = 0x0009,
AL_EFFECT_AUTOWAH = 0x000A,
AL_EFFECT_COMPRESSOR = 0x000B,
AL_EFFECT_EQUALIZER = 0x000C,
///<summary>Frequencyshifter Parameter. Unit: (0) Down, (1) Up, (2) Off Range [0 .. 2] Default: 0</summary> AL_EFFECT_EAXREVERB = 0x8000,
AL_FREQUENCY_SHIFTER_LEFT_DIRECTION = 0x0002, }
///<summary>Frequencyshifter Parameter. Unit: (0) Down, (1) Up, (2) Off Range [0 .. 2] Default: 0</summary>
AL_FREQUENCY_SHIFTER_RIGHT_DIRECTION = 0x0003,
///<summary>Vocalmorpher Parameter. Unit: Use enum EfxFormantFilterSettings Range [0 .. 29] Default: 0, AL_VOCAL_MORPHER_PHONEME_A</summary> #endregion Effect
AL_VOCAL_MORPHER_PHONEMEA = 0x0001,
///<summary>Vocalmorpher Parameter. Unit: Semitones Range [-24 .. +24] Default: 0</summary>
AL_VOCAL_MORPHER_PHONEMEA_COARSE_TUNING = 0x0002,
///<summary>Vocalmorpher Parameter. Unit: Use enum EfxFormantFilterSettings Range [0 .. 29] Default: 10, AL_VOCAL_MORPHER_PHONEME_ER</summary>
AL_VOCAL_MORPHER_PHONEMEB = 0x0003,
///<summary>Vocalmorpher Parameter. Unit: Semitones Range [-24 .. +24] Default: 0</summary>
AL_VOCAL_MORPHER_PHONEMEB_COARSE_TUNING = 0x0004,
///<summary>Vocalmorpher Parameter. Unit: (0) Sinusoid, (1) Triangle, (2) Sawtooth Range [0 .. 2] Default: 0</summary>
AL_VOCAL_MORPHER_WAVEFORM = 0x0005,
///<summary>Pitchshifter Parameter. Unit: Semitones Range [-12 .. +12] Default: +12</summary> #region Auxiliary Effect Slot
AL_PITCH_SHIFTER_COARSE_TUNE = 0x0001,
///<summary>Pitchshifter Parameter. Unit: Cents Range [-50 .. +50] Default: 0</summary>
AL_PITCH_SHIFTER_FINE_TUNE = 0x0002,
///<summary>Ringmodulator Parameter. Unit: (0) Sinusoid, (1) Sawtooth, (2) Square Range [0 .. 2] Default: 0</summary> public enum EfxAuxiliaryi : int
AL_RING_MODULATOR_WAVEFORM = 0x0003, {
// Auxiliary Slot object definitions to be used with alAuxiliaryEffectSlot functions.
/// <summary>This property is used to attach an Effect object to the Auxiliary Effect Slot object. After the attachment, the Auxiliary Effect Slot object will contain the effect type and have the same effect parameters that were stored in the Effect object. Any Sources feeding the Auxiliary Effect Slot will immediate feed the new effect type and new effect parameters.</summary>
AL_EFFECTSLOT_EFFECT = 0x0001,
///<summary>Compressor Parameter. Unit: (0) Off, (1) On Range [0 .. 1] Default: 1</summary> /// <summary>This property is used to enable or disable automatic send adjustments based on the physical positions of the sources and the listener. This property should be enabled when an application wishes to use a reverb effect to simulate the environment surrounding a listener or a collection of Sources. Range [False .. True] Default: True </summary>
AL_COMPRESSOR_ONOFF = 0x0001, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO = 0x0003,
///<summary>Reverb Parameter. Unit: (0) False, (1) True Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary> // Value to be used as an Auxiliary Slot ID to disable a source send..
AL_REVERB_DECAY_HFLIMIT = 0x000D, // AL_EFFECTSLOT_NULL = 0x0000, // remove, seems not to belong here. it's a target, not a token
}
///<summary>EAXReverb effect parameters. Unit: (0) False, (1) True Range [AL_FALSE .. AL_TRUE] Default: AL_TRUE</summary> public enum EfxAuxiliaryf : int
AL_EAXREVERB_DECAY_HFLIMIT = 0x0017, {
/// <summary>This property is used to specify an output level for the Auxiliary Effect Slot. Setting the gain to 0.0f mutes the output. Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_EFFECTSLOT_GAIN = 0x0002,
}
AL_EFFECT_FIRST_PARAMETER = 0x0000, #endregion Auxiliary Effect Slot
AL_EFFECT_LAST_PARAMETER = 0x8000,
/// <summary>Used with the enum EfxEffectType as it's parameter.</summary> #region Filter Object
AL_EFFECT_TYPE = 0x8001, // AL.BindEffect()
}
///<summary>Vocal morpher effect parameters.</summary> // Filter object definitions to be used with alFilter functions.
public enum EfxFormantFilterSettings : int public enum EfxFilterf : int
{ {
AL_VOCAL_MORPHER_PHONEME_A = 0, ///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_VOCAL_MORPHER_PHONEME_E = 1, AL_LOWPASS_GAIN = 0x0001,
AL_VOCAL_MORPHER_PHONEME_I = 2, ///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_VOCAL_MORPHER_PHONEME_O = 3, AL_LOWPASS_GAINHF = 0x0002,
AL_VOCAL_MORPHER_PHONEME_U = 4,
AL_VOCAL_MORPHER_PHONEME_AA = 5,
AL_VOCAL_MORPHER_PHONEME_AE = 6,
AL_VOCAL_MORPHER_PHONEME_AH = 7,
AL_VOCAL_MORPHER_PHONEME_AO = 8,
AL_VOCAL_MORPHER_PHONEME_EH = 9,
AL_VOCAL_MORPHER_PHONEME_ER = 10,
AL_VOCAL_MORPHER_PHONEME_IH = 11,
AL_VOCAL_MORPHER_PHONEME_IY = 12,
AL_VOCAL_MORPHER_PHONEME_UH = 13,
AL_VOCAL_MORPHER_PHONEME_UW = 14,
AL_VOCAL_MORPHER_PHONEME_B = 15,
AL_VOCAL_MORPHER_PHONEME_D = 16,
AL_VOCAL_MORPHER_PHONEME_F = 17,
AL_VOCAL_MORPHER_PHONEME_G = 18,
AL_VOCAL_MORPHER_PHONEME_J = 19,
AL_VOCAL_MORPHER_PHONEME_K = 20,
AL_VOCAL_MORPHER_PHONEME_L = 21,
AL_VOCAL_MORPHER_PHONEME_M = 22,
AL_VOCAL_MORPHER_PHONEME_N = 23,
AL_VOCAL_MORPHER_PHONEME_P = 24,
AL_VOCAL_MORPHER_PHONEME_R = 25,
AL_VOCAL_MORPHER_PHONEME_S = 26,
AL_VOCAL_MORPHER_PHONEME_T = 27,
AL_VOCAL_MORPHER_PHONEME_V = 28,
AL_VOCAL_MORPHER_PHONEME_Z = 29,
}
///<summary>Effect type definitions to be used with AL_EFFECT_TYPE.</summary> ///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
public enum EfxEffectType : int AL_HIGHPASS_GAIN = 0x0001,
{ ///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_EFFECT_NULL = 0x0000, /* Can also be used as an Effect Object ID */ AL_HIGHPASS_GAINLF = 0x0002,
AL_EFFECT_REVERB = 0x0001,
AL_EFFECT_CHORUS = 0x0002,
AL_EFFECT_DISTORTION = 0x0003,
AL_EFFECT_ECHO = 0x0004,
AL_EFFECT_FLANGER = 0x0005,
AL_EFFECT_FREQUENCY_SHIFTER = 0x0006,
AL_EFFECT_VOCAL_MORPHER = 0x0007,
AL_EFFECT_PITCH_SHIFTER = 0x0008,
AL_EFFECT_RING_MODULATOR = 0x0009,
AL_EFFECT_AUTOWAH = 0x000A,
AL_EFFECT_COMPRESSOR = 0x000B,
AL_EFFECT_EQUALIZER = 0x000C,
AL_EFFECT_EAXREVERB = 0x8000, ///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
} AL_BANDPASS_GAIN = 0x0001,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_BANDPASS_GAINLF = 0x0002,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_BANDPASS_GAINHF = 0x0003,
}
#endregion Effect // Filter type
public enum EfxFilteri : int
{
AL_FILTER_FIRST_PARAMETER = 0x0000, // deprecated?
AL_FILTER_LAST_PARAMETER = 0x8000, // deprecated?
#region Auxiliary Effect Slot /// <summary>Used with the enum EfxFilterType as Parameter.</summary>
AL_FILTER_TYPE = 0x8001,
}
public enum EfxAuxiliaryi : int ///<summary>Filter type definitions to be used with AL_FILTER_TYPE.</summary>
{ public enum EfxFilterType : int
// Auxiliary Slot object definitions to be used with alAuxiliaryEffectSlot functions. {
/// <summary>This property is used to attach an Effect object to the Auxiliary Effect Slot object. After the attachment, the Auxiliary Effect Slot object will contain the effect type and have the same effect parameters that were stored in the Effect object. Any Sources feeding the Auxiliary Effect Slot will immediate feed the new effect type and new effect parameters.</summary> AL_FILTER_NULL = 0x0000, // Can also be used as a Filter Object ID
AL_EFFECTSLOT_EFFECT = 0x0001, AL_FILTER_LOWPASS = 0x0001,
AL_FILTER_HIGHPASS = 0x0002,
AL_FILTER_BANDPASS = 0x0003,
}
/// <summary>This property is used to enable or disable automatic send adjustments based on the physical positions of the sources and the listener. This property should be enabled when an application wishes to use a reverb effect to simulate the environment surrounding a listener or a collection of Sources. Range [False .. True] Default: True </summary> #endregion Filter Object
AL_EFFECTSLOT_AUXILIARY_SEND_AUTO = 0x0003,
// Value to be used as an Auxiliary Slot ID to disable a source send..
// AL_EFFECTSLOT_NULL = 0x0000, // remove, seems not to belong here. it's a target, not a token
}
public enum EfxAuxiliaryf : int
{
/// <summary>This property is used to specify an output level for the Auxiliary Effect Slot. Setting the gain to 0.0f mutes the output. Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_EFFECTSLOT_GAIN = 0x0002,
}
#endregion Auxiliary Effect Slot
#region Filter Object
// Filter object definitions to be used with alFilter functions.
public enum EfxFilterf : int
{
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_LOWPASS_GAIN = 0x0001,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_LOWPASS_GAINHF = 0x0002,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_HIGHPASS_GAIN = 0x0001,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_HIGHPASS_GAINLF = 0x0002,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_BANDPASS_GAIN = 0x0001,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_BANDPASS_GAINLF = 0x0002,
///<summary>Range [0.0f .. 1.0f] Default: 1.0f</summary>
AL_BANDPASS_GAINHF = 0x0003,
}
// Filter type
public enum EfxFilteri : int
{
AL_FILTER_FIRST_PARAMETER = 0x0000, // deprecated?
AL_FILTER_LAST_PARAMETER = 0x8000, // deprecated?
/// <summary>Used with the enum EfxFilterType as Parameter.</summary>
AL_FILTER_TYPE = 0x8001,
}
///<summary>Filter type definitions to be used with AL_FILTER_TYPE.</summary>
public enum EfxFilterType : int
{
AL_FILTER_NULL = 0x0000, // Can also be used as a Filter Object ID
AL_FILTER_LOWPASS = 0x0001,
AL_FILTER_HIGHPASS = 0x0002,
AL_FILTER_BANDPASS = 0x0003,
}
#endregion Filter Object
} }

50
Source/OpenTK/OpenAL/History.txt
View file

@ -1,12 +1,12 @@
Version History: Version History:
0.1 Initial v0.1-0.7
- Tokens AL_TRUE and AL_FALSE removed, created new type. see AL.Bool
Tokens ALC_TRUE and ALC_FALSE removed, created new type. see AL.Bool
- Added AL.Null for convenience when working with C Manuals. - Added AL.Null for convenience when working with C Manuals.
- Alut: The following functions are not bound/imported. Issue of undoing C malloc to prevent memory leaks. - Alut: The following functions are not bound/imported. Issue of undoing C malloc to prevent memory leaks.
"alutLoadMemoryFromFile, alutLoadMemoryFromFileImage, alutLoadMemoryHelloWorld, alutLoadMemoryWaveform" "alutLoadMemoryFromFile, alutLoadMemoryFromFileImage, alutLoadMemoryHelloWorld, alutLoadMemoryWaveform"
Please use Alut.CreateBuffer* functions instead, which have similar functionality and return a Buffer Handle instead. Please use Alut.CreateBuffer* functions instead, which have similar functionality and return a Buffer Handle instead.
Disabled Alut.Sleep, rather use Thread.Sleep
- Alc: All functions imported, Bool and Double functions disabled.
- AL: Functions not imported: - AL: Functions not imported:
alListeneri, alListener3i, alListeneriv alListeneri, alListener3i, alListeneriv
alGetListeneri, alGetListener3i, alGetListeneriv alGetListeneri, alGetListener3i, alGetListeneriv
@ -15,46 +15,26 @@ Version History:
alBufferf, alBufferfv, alBufferi, alBuffer3i, alBufferiv alBufferf, alBufferfv, alBufferi, alBuffer3i, alBufferiv
imported, but currently disabled: alBuffer3f imported, but currently disabled: alBuffer3f
alGetBufferf, alGetBuffer3f, alGetBufferfv, alGetBuffer3i, alGetBufferiv alGetBufferf, alGetBuffer3f, alGetBufferfv, alGetBuffer3i, alGetBufferiv
DopplerVelocity, ChannelMask are deprecated and marked.
0.2 The Token AL_DATA is hidden now, as it returns a pointer to unmanaged memory
- Largely improved documentation, found homes for previously orphaned Tokens. where the buffer was located previously to calling AL.BufferData(). (It is usually freed after buffering)
- The Token AL_DATA is hidden now, as it returns a pointer to unmanaged memory
where the buffer was located previously to calling AL.BufferData(). (It is usually freed after buffering)
- Added Function AL.GetErrorString() - Added Function AL.GetErrorString()
- Added overloads for requesting/deleting a single buffer/source at a time. - Added overloads for requesting/deleting a single buffer/source at a time.
- Added Vector3 overloads where applicable.
0.3 - breaks former written examples.
- Using a single changelog now, as the number of issues per file has significantly shrunk.
- Refactored -i -fv -3f functions to be overloads e.g AL.GetSource, AL.GetListener - Refactored -i -fv -3f functions to be overloads e.g AL.GetSource, AL.GetListener
- Added XRam Extension prototype. Untested, as it requires special hardware. - X-Ram Extension untested, as it requires special hardware. !verify parameters of GetBufferMode()!
- Refactored extensively to match OpenTK naming conventions. - functions with ushort, uint, ulong marked as not CLS compliant.
- Moved functions into overloads
- Removed all C prototype comments from AL/ALC/ALUT
- Documented Alc properly
0.4 v0.8
- changed Alc enum GetString/GetStringList -added Efx tokens to AL/Alc enums.
- disabled Alut.Sleep, rather use Thread.Sleep -All Efx Effect functions imported. Filter and Auxiliary missing public methods.
- DopplerVelocity, ChannelMask are deprecated and marked.
- functions with ushort, uint, ulong marked
0.5 vanilla complete
- Fix Alc.GetString( Enums.AlcGetStringList ) to terminate with 2 null, and split at 1 null
0.6 Todo:
- Begun working on Efx
- X-Ram changed, must be tested properly. verify parameters of GetBufferMode()
0.7
- Efx continued.
- removed AL.Bool, replaced with System.Boolean. Seems to work so far.
Next Version:
- EFX Extension - EFX Extension
- Enums themselves require summaries (do EFX 1st) - Enums themselves require summaries (do EFX 1st)
- Identify: AL_FILTER_FIRST_PARAMETER, AL_FILTER_LAST_PARAMETER - Identify: AL_FILTER_FIRST_PARAMETER, AL_FILTER_LAST_PARAMETER
AL_EFFECT_FIRST_PARAMETER, AL_EFFECT_LAST_PARAMETER AL_EFFECT_FIRST_PARAMETER, AL_EFFECT_LAST_PARAMETER
- use [MarshalAs(UnmanagedType)] attribute, instead of AL.Bool? investigate - use [MarshalAs(UnmanagedType)] attribute, instead of bool? investigate
- AL.BindBuffer helper function ala GL.BindBuffer? (Wraps AL.Source, better consistency) - AL.BindBuffer helper function ala GL.BindBuffer? (Wraps AL.Source, better consistency)
- change all "name" into "handle" to avoid confusion?

60
Source/OpenTK/OpenAL/XRamExtension.cs
View file

@ -30,11 +30,11 @@ namespace OpenTK.OpenAL
#region X-RAM Function pointer definitions #region X-RAM Function pointer definitions
[CLSCompliant(false)] [CLSCompliant(false)]
public unsafe delegate bool Delegate_SetBufferMode(int n, ref uint buffers, int value); public unsafe delegate bool Delegate_SetBufferMode( int n,ref uint buffers,int value );
//typedef ALboolean (__cdecl *EAXSetBufferMode)(ALsizei n, ALuint *buffers, ALint value); //typedef ALboolean (__cdecl *EAXSetBufferMode)(ALsizei n, ALuint *buffers, ALint value);
[CLSCompliant(false)] [CLSCompliant(false)]
public delegate int Delegate_GetBufferMode(uint buffer, out int value); public delegate int Delegate_GetBufferMode( uint buffer,out int value );
//typedef ALenum (__cdecl *EAXGetBufferMode)(ALuint buffer, ALint *value); //typedef ALenum (__cdecl *EAXGetBufferMode)(ALuint buffer, ALint *value);
[CLSCompliant(false)] [CLSCompliant(false)]
@ -53,10 +53,10 @@ namespace OpenTK.OpenAL
#region Constructor / Extension Loading #region Constructor / Extension Loading
public XRamExtension() public XRamExtension( )
{ // Query if Extension supported and retrieve Tokens/Pointers if it is. { // Query if Extension supported and retrieve Tokens/Pointers if it is.
_valid = false; _valid = false;
if (AL.IsExtensionPresent("EAX-RAM") == false) if ( AL.IsExtensionPresent("EAX-RAM") == false )
return; return;
AL_EAX_RAM_SIZE = AL.GetEnumValue("AL_EAX_RAM_SIZE"); AL_EAX_RAM_SIZE = AL.GetEnumValue("AL_EAX_RAM_SIZE");
@ -65,28 +65,27 @@ namespace OpenTK.OpenAL
AL_STORAGE_HARDWARE = AL.GetEnumValue("AL_STORAGE_HARDWARE"); AL_STORAGE_HARDWARE = AL.GetEnumValue("AL_STORAGE_HARDWARE");
AL_STORAGE_ACCESSIBLE = AL.GetEnumValue("AL_STORAGE_ACCESSIBLE"); AL_STORAGE_ACCESSIBLE = AL.GetEnumValue("AL_STORAGE_ACCESSIBLE");
Console.WriteLine("RamSize: {0} RamFree: {1} StorageAuto: {2} StorageHW: {3} StorageAccess: {4}", AL_EAX_RAM_SIZE, AL_EAX_RAM_FREE, AL_STORAGE_AUTOMATIC, AL_STORAGE_HARDWARE, AL_STORAGE_ACCESSIBLE); Console.WriteLine("RamSize: {0} RamFree: {1} StorageAuto: {2} StorageHW: {3} StorageAccess: {4}",AL_EAX_RAM_SIZE,AL_EAX_RAM_FREE,AL_STORAGE_AUTOMATIC,AL_STORAGE_HARDWARE,AL_STORAGE_ACCESSIBLE);
if (AL_EAX_RAM_SIZE == 0 || if ( AL_EAX_RAM_SIZE == 0 ||
AL_EAX_RAM_FREE == 0 || AL_EAX_RAM_FREE == 0 ||
AL_STORAGE_AUTOMATIC == 0 || AL_STORAGE_AUTOMATIC == 0 ||
AL_STORAGE_HARDWARE == 0 || AL_STORAGE_HARDWARE == 0 ||
AL_STORAGE_ACCESSIBLE == 0) AL_STORAGE_ACCESSIBLE == 0 )
{ {
Console.WriteLine("Token values could not be retrieved."); Console.WriteLine("Token values could not be retrieved.");
return; return;
} }
Console.WriteLine("Free Ram: {0} / {1}", GetRamFree(), GetRamSize()); Console.WriteLine("Free Ram: {0} / {1}",GetRamFree( ),GetRamSize( ));
try try
{ {
Imported_GetBufferMode = (Delegate_GetBufferMode)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("EAXGetBufferMode"), typeof(Delegate_GetBufferMode)); Imported_GetBufferMode = (Delegate_GetBufferMode) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("EAXGetBufferMode"),typeof(Delegate_GetBufferMode));
Imported_SetBufferMode = (Delegate_SetBufferMode)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("EAXSetBufferMode"), typeof(Delegate_SetBufferMode)); Imported_SetBufferMode = (Delegate_SetBufferMode) Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("EAXSetBufferMode"),typeof(Delegate_SetBufferMode));
} } catch ( Exception e )
catch (Exception e)
{ {
Console.WriteLine("Attempt to marshal AL.GetProcAddress failed. " + e.ToString()); Console.WriteLine("Attempt to marshal AL.GetProcAddress failed. " + e.ToString( ));
return; return;
} }
@ -98,15 +97,15 @@ namespace OpenTK.OpenAL
#region Public Methods #region Public Methods
/// <summary>Query total amount of X-RAM.</summary> /// <summary>Query total amount of X-RAM.</summary>
public int GetRamSize() public int GetRamSize( )
{ {
return AL.Get((Enums.ALGetInteger)AL_EAX_RAM_SIZE); return AL.Get((Enums.ALGetInteger) AL_EAX_RAM_SIZE);
} }
/// <summary>Query free X-RAM available.</summary> /// <summary>Query free X-RAM available.</summary>
public int GetRamFree() public int GetRamFree( )
{ {
return AL.Get((Enums.ALGetInteger)AL_EAX_RAM_FREE); return AL.Get((Enums.ALGetInteger) AL_EAX_RAM_FREE);
} }
public enum XRamStorage : byte public enum XRamStorage : byte
@ -129,29 +128,30 @@ namespace OpenTK.OpenAL
} }
[CLSCompliant(false)] [CLSCompliant(false)]
public void SetBufferMode(int n, ref uint buffer, XRamStorage mode) public void SetBufferMode( int n,ref uint buffer,XRamStorage mode )
{ {
switch (mode) switch ( mode )
{ {
case XRamStorage.Acessible: case XRamStorage.Acessible:
Imported_SetBufferMode(1, ref buffer, AL_STORAGE_ACCESSIBLE); Imported_SetBufferMode(1,ref buffer,AL_STORAGE_ACCESSIBLE);
break; break;
case XRamStorage.Hardware: case XRamStorage.Hardware:
Imported_SetBufferMode(1, ref buffer, AL_STORAGE_HARDWARE); Imported_SetBufferMode(1,ref buffer,AL_STORAGE_HARDWARE);
break; break;
default: default:
Imported_SetBufferMode(1, ref buffer, AL_STORAGE_AUTOMATIC); Imported_SetBufferMode(1,ref buffer,AL_STORAGE_AUTOMATIC);
break; break;
} }
} }
[CLSCompliant(false)] [CLSCompliant(false)]
public XRamStorage GetBufferMode(ref uint buffer) public XRamStorage GetBufferMode( ref uint buffer )
{ {
int t; // this is improper, find sample codes using it and figure out what 2nd param does. int t; // this is improper, find sample codes using it and figure out what 2nd param does.
return (XRamStorage)Imported_GetBufferMode(buffer, out t); return (XRamStorage) Imported_GetBufferMode(buffer,out t);
} }
#endregion Public Methods #endregion Public Methods
} }
} }