OpenTK.Audio.OpenAL.EffectsExtension Class Reference

Provides access to the OpenAL effects extension. More...

List of all members.

Public Member Functions

void BindEffect (uint eid, EfxEffectType type)
 (Helper) Selects the Effect type used by this Effect handle.
void BindEffect (int eid, EfxEffectType type)
 (Helper) Selects the Effect type used by this Effect handle.
void BindFilterToSource (uint source, uint filter)
 (Helper) reroutes the output of a Source through a Filter.
void BindFilterToSource (int source, int filter)
 (Helper) reroutes the output of a Source through a Filter.
void BindEffectToAuxiliarySlot (uint auxiliaryeffectslot, uint effect)
 (Helper) Attaches an Effect to an Auxiliary Effect Slot.
void BindEffectToAuxiliarySlot (int auxiliaryeffectslot, int effect)
 (Helper) Attaches an Effect to an Auxiliary Effect Slot.
void BindSourceToAuxiliarySlot (uint source, uint slot, int slotnumber, uint filter)
 (Helper) Reroutes a Source's output into an Auxiliary Effect Slot.
void BindSourceToAuxiliarySlot (int source, int slot, int slotnumber, int filter)
 (Helper) Reroutes a Source's output into an Auxiliary Effect Slot.
void GenEffects (int n, out uint effects)
 The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object.
void GenEffects (int n, out int effects)
 The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object.
int[] GenEffects (int n)
 Generates one or more effect objects.
int GenEffect ()
 Generates a single effect object.
void GenEffect (out uint effect)
 Generates a single effect object.
void DeleteEffects (int n, ref uint effects)
 The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.
void DeleteEffects (int n, ref int effects)
 The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.
void DeleteEffects (int[] effects)
 The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.
void DeleteEffects (uint[] effects)
 The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.
void DeleteEffect (int effect)
 This function deletes one Effect only.
void DeleteEffect (ref uint effect)
 This function deletes one Effect only.
bool IsEffect (uint eid)
 The IsEffect function is used to determine if an object identifier is a valid Effect object.
bool IsEffect (int eid)
 The IsEffect function is used to determine if an object identifier is a valid Effect object.
void Effect (uint eid, EfxEffecti param, int value)
 This function is used to set integer properties on Effect objects.
void Effect (int eid, EfxEffecti param, int value)
 This function is used to set integer properties on Effect objects.
void Effect (uint eid, EfxEffectf param, float value)
 This function is used to set floating-point properties on Effect objects.
void Effect (int eid, EfxEffectf param, float value)
 This function is used to set floating-point properties on Effect objects.
void Effect (uint eid, EfxEffect3f param, ref Vector3 values)
 This function is used to set 3 floating-point properties on Effect objects.
void Effect (int eid, EfxEffect3f param, ref Vector3 values)
 This function is used to set 3 floating-point properties on Effect objects.
void GetEffect (uint eid, EfxEffecti pname, out int value)
 This function is used to retrieve integer properties from Effect objects.
void GetEffect (int eid, EfxEffecti pname, out int value)
 This function is used to retrieve integer properties from Effect objects.
void GetEffect (uint eid, EfxEffectf pname, out float value)
 This function is used to retrieve floating-point properties from Effect objects.
void GetEffect (int eid, EfxEffectf pname, out float value)
 This function is used to retrieve floating-point properties from Effect objects.
void GetEffect (uint eid, EfxEffect3f param, out Vector3 values)
 This function is used to retrieve 3 floating-point properties from Effect objects.
void GetEffect (int eid, EfxEffect3f param, out Vector3 values)
 This function is used to retrieve 3 floating-point properties from Effect objects.
void GenFilters (int n, out uint filters)
 The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters.
void GenFilters (int n, out int filters)
 The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters.
int[] GenFilters (int n)
 The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters.
int GenFilter ()
 This function generates only one Filter.
unsafe void GenFilter (out uint filter)
 This function generates only one Filter.
void DeleteFilters (int n, ref uint filters)
 The DeleteFilters function is used to delete and free resources for Filter objects previously created with GenFilters.
void DeleteFilters (int n, ref int filters)
 The DeleteFilters function is used to delete and free resources for Filter objects previously created with GenFilters.
void DeleteFilters (uint[] filters)
 This function deletes one Filter only.
void DeleteFilters (int[] filters)
 This function deletes one Filter only.
void DeleteFilter (int filter)
 This function deletes one Filter only.
void DeleteFilter (ref uint filter)
 This function deletes one Filter only.
bool IsFilter (uint fid)
 The IsFilter function is used to determine if an object identifier is a valid Filter object.
bool IsFilter (int fid)
 The IsFilter function is used to determine if an object identifier is a valid Filter object.
void Filter (uint fid, EfxFilteri param, int value)
 This function is used to set integer properties on Filter objects.
void Filter (int fid, EfxFilteri param, int value)
 This function is used to set integer properties on Filter objects.
void Filter (uint fid, EfxFilterf param, float value)
 This function is used to set floating-point properties on Filter objects.
void Filter (int fid, EfxFilterf param, float value)
 This function is used to set floating-point properties on Filter objects.
void GetFilter (uint fid, EfxFilteri pname, out int value)
 This function is used to retrieve integer properties from Filter objects.
void GetFilter (int fid, EfxFilteri pname, out int value)
 This function is used to retrieve integer properties from Filter objects.
void GetFilter (uint fid, EfxFilterf pname, out float value)
 This function is used to retrieve floating-point properties from Filter objects.
void GetFilter (int fid, EfxFilterf pname, out float value)
 This function is used to retrieve floating-point properties from Filter objects.
void GenAuxiliaryEffectSlots (int n, out uint slots)
 The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used.
void GenAuxiliaryEffectSlots (int n, out int slots)
 The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used.
int[] GenAuxiliaryEffectSlots (int n)
 The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used.
int GenAuxiliaryEffectSlot ()
 This function generates only one Auxiliary Effect Slot.
void GenAuxiliaryEffectSlot (out uint slot)
 This function generates only one Auxiliary Effect Slot.
void DeleteAuxiliaryEffectSlots (int n, ref uint slots)
 The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots.
void DeleteAuxiliaryEffectSlots (int n, ref int slots)
 The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots.
void DeleteAuxiliaryEffectSlots (int[] slots)
 The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots.
void DeleteAuxiliaryEffectSlots (uint[] slots)
 This function deletes one AuxiliaryEffectSlot only.
void DeleteAuxiliaryEffectSlot (int slot)
 This function deletes one AuxiliaryEffectSlot only.
void DeleteAuxiliaryEffectSlot (ref uint slot)
 This function deletes one AuxiliaryEffectSlot only.
bool IsAuxiliaryEffectSlot (uint slot)
 The IsAuxiliaryEffectSlot function is used to determine if an object identifier is a valid Auxiliary Effect Slot object.
bool IsAuxiliaryEffectSlot (int slot)
 The IsAuxiliaryEffectSlot function is used to determine if an object identifier is a valid Auxiliary Effect Slot object.
void AuxiliaryEffectSlot (uint asid, EfxAuxiliaryi param, int value)
 This function is used to set integer properties on Auxiliary Effect Slot objects.
void AuxiliaryEffectSlot (int asid, EfxAuxiliaryi param, int value)
 This function is used to set integer properties on Auxiliary Effect Slot objects.
void AuxiliaryEffectSlot (uint asid, EfxAuxiliaryf param, float value)
 This function is used to set floating-point properties on Auxiliary Effect Slot objects.
void AuxiliaryEffectSlot (int asid, EfxAuxiliaryf param, float value)
 This function is used to set floating-point properties on Auxiliary Effect Slot objects.
void GetAuxiliaryEffectSlot (uint asid, EfxAuxiliaryi pname, out int value)
 This function is used to retrieve integer properties on Auxiliary Effect Slot objects.
void GetAuxiliaryEffectSlot (int asid, EfxAuxiliaryi pname, out int value)
 This function is used to retrieve integer properties on Auxiliary Effect Slot objects.
void GetAuxiliaryEffectSlot (uint asid, EfxAuxiliaryf pname, out float value)
 This function is used to retrieve floating properties on Auxiliary Effect Slot objects.
void GetAuxiliaryEffectSlot (int asid, EfxAuxiliaryf pname, out float value)
 This function is used to retrieve floating properties on Auxiliary Effect Slot objects.
 EffectsExtension ()
 Constructs a new EffectsExtension instance.

Static Public Member Functions

static void GetEaxFromEfxEax (ref EaxReverb input, out EfxEaxReverb output)

Properties

bool IsInitialized [get]
 Returns True if the EFX Extension has been found and could be initialized.

Detailed Description

Provides access to the OpenAL effects extension.

Definition at line 20 of file EffectsExtension.cs.

Constructor & Destructor Documentation

OpenTK.Audio.OpenAL.EffectsExtension.EffectsExtension (  ) 

Constructs a new EffectsExtension instance.

Definition at line 1215 of file EffectsExtension.cs.

01216         {
01217             _valid = false;
01218 
01219             if (AudioContext.CurrentContext == null)
01220                 throw new InvalidOperationException("AL.LoadAll() needs a current AudioContext.");
01221 
01222             if (!AudioContext.CurrentContext.SupportsExtension("ALC_EXT_EFX"))
01223             {
01224                 Debug.Print("EFX Extension (ALC_EXT_EFX) is not supported(AudioContext: {0}).", AudioContext.CurrentContext.ToString());
01225                 return;
01226             }
01227             // Console.WriteLine("ALC_EXT_EFX found. Efx can be used.");
01228 
01229             try
01230             {
01231                 Imported_alGenEffects = (Delegate_alGenEffects)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenEffects"), typeof(Delegate_alGenEffects));
01232                 Imported_alDeleteEffects = (Delegate_alDeleteEffects)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteEffects"), typeof(Delegate_alDeleteEffects));
01233                 Imported_alIsEffect = (Delegate_alIsEffect)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsEffect"), typeof(Delegate_alIsEffect));
01234                 Imported_alEffecti = (Delegate_alEffecti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alEffecti"), typeof(Delegate_alEffecti));
01235                 Imported_alEffectf = (Delegate_alEffectf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alEffectf"), typeof(Delegate_alEffectf));
01236                 Imported_alEffectfv = (Delegate_alEffectfv)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alEffectfv"), typeof(Delegate_alEffectfv));
01237                 Imported_alGetEffecti = (Delegate_alGetEffecti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetEffecti"), typeof(Delegate_alGetEffecti));
01238                 Imported_alGetEffectf = (Delegate_alGetEffectf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetEffectf"), typeof(Delegate_alGetEffectf));
01239                 Imported_alGetEffectfv = (Delegate_alGetEffectfv)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetEffectfv"), typeof(Delegate_alGetEffectfv));
01240             }
01241             catch (Exception e)
01242             {
01243                 Debug.WriteLine("Failed to marshal Effect functions. " + e.ToString());
01244                 return;
01245             }
01246             // Console.WriteLine("Effect functions appear to be ok.");
01247 
01248             try
01249             {
01250                 Imported_alGenFilters = (Delegate_alGenFilters)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenFilters"), typeof(Delegate_alGenFilters));
01251                 Imported_alDeleteFilters = (Delegate_alDeleteFilters)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteFilters"), typeof(Delegate_alDeleteFilters));
01252                 Imported_alIsFilter = (Delegate_alIsFilter)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsFilter"), typeof(Delegate_alIsFilter));
01253                 Imported_alFilteri = (Delegate_alFilteri)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alFilteri"), typeof(Delegate_alFilteri));
01254                 Imported_alFilterf = (Delegate_alFilterf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alFilterf"), typeof(Delegate_alFilterf));
01255                 Imported_alGetFilteri = (Delegate_alGetFilteri)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetFilteri"), typeof(Delegate_alGetFilteri));
01256                 Imported_alGetFilterf = (Delegate_alGetFilterf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetFilterf"), typeof(Delegate_alGetFilterf));
01257             }
01258             catch (Exception e)
01259             {
01260                 Debug.WriteLine("Failed to marshal Filter functions. " + e.ToString());
01261                 return;
01262             }
01263             // Console.WriteLine("Filter functions appear to be ok.");
01264 
01265             try
01266             {
01267                 Imported_alGenAuxiliaryEffectSlots = (Delegate_alGenAuxiliaryEffectSlots)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGenAuxiliaryEffectSlots"), typeof(Delegate_alGenAuxiliaryEffectSlots));
01268                 Imported_alDeleteAuxiliaryEffectSlots = (Delegate_alDeleteAuxiliaryEffectSlots)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alDeleteAuxiliaryEffectSlots"), typeof(Delegate_alDeleteAuxiliaryEffectSlots));
01269                 Imported_alIsAuxiliaryEffectSlot = (Delegate_alIsAuxiliaryEffectSlot)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alIsAuxiliaryEffectSlot"), typeof(Delegate_alIsAuxiliaryEffectSlot));
01270                 Imported_alAuxiliaryEffectSloti = (Delegate_alAuxiliaryEffectSloti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alAuxiliaryEffectSloti"), typeof(Delegate_alAuxiliaryEffectSloti));
01271                 Imported_alAuxiliaryEffectSlotf = (Delegate_alAuxiliaryEffectSlotf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alAuxiliaryEffectSlotf"), typeof(Delegate_alAuxiliaryEffectSlotf));
01272                 Imported_alGetAuxiliaryEffectSloti = (Delegate_alGetAuxiliaryEffectSloti)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetAuxiliaryEffectSloti"), typeof(Delegate_alGetAuxiliaryEffectSloti));
01273                 Imported_alGetAuxiliaryEffectSlotf = (Delegate_alGetAuxiliaryEffectSlotf)Marshal.GetDelegateForFunctionPointer(AL.GetProcAddress("alGetAuxiliaryEffectSlotf"), typeof(Delegate_alGetAuxiliaryEffectSlotf));
01274             }
01275             catch (Exception e)
01276             {
01277                 Debug.WriteLine("Failed to marshal AuxiliaryEffectSlot functions. " + e.ToString());
01278                 return;
01279             }
01280             // Console.WriteLine("Auxiliary Effect Slot functions appear to be ok.");
01281 
01282             // didn't return so far, everything went fine.
01283             _valid = true;
01284         }

Member Function Documentation

void OpenTK.Audio.OpenAL.EffectsExtension.AuxiliaryEffectSlot ( int  asid,
EfxAuxiliaryf  param,
float  value 
)

This function is used to set floating-point properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
param Auxiliary Effect Slot property to set.
value Floating-point value.

Definition at line 1110 of file EffectsExtension.cs.

01111         {
01112             Imported_alAuxiliaryEffectSlotf((uint)asid, param, value);
01113         }

void OpenTK.Audio.OpenAL.EffectsExtension.AuxiliaryEffectSlot ( uint  asid,
EfxAuxiliaryf  param,
float  value 
)

This function is used to set floating-point properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
param Auxiliary Effect Slot property to set.
value Floating-point value.

Definition at line 1100 of file EffectsExtension.cs.

01101         {
01102             Imported_alAuxiliaryEffectSlotf(asid, param, value);
01103         }

void OpenTK.Audio.OpenAL.EffectsExtension.AuxiliaryEffectSlot ( int  asid,
EfxAuxiliaryi  param,
int  value 
)

This function is used to set integer properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
param Auxiliary Effect Slot property to set.
value Integer value.

Definition at line 1079 of file EffectsExtension.cs.

01080         {
01081             Imported_alAuxiliaryEffectSloti((uint)asid, param, value);
01082         }

void OpenTK.Audio.OpenAL.EffectsExtension.AuxiliaryEffectSlot ( uint  asid,
EfxAuxiliaryi  param,
int  value 
)

This function is used to set integer properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
param Auxiliary Effect Slot property to set.
value Integer value.

Definition at line 1069 of file EffectsExtension.cs.

01070         {
01071             Imported_alAuxiliaryEffectSloti(asid, param, value);
01072         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindEffect ( int  eid,
EfxEffectType  type 
)

(Helper) Selects the Effect type used by this Effect handle.

Parameters:
eid Effect id returned from a successful call to GenEffects.
type Effect type.

Definition at line 39 of file EffectsExtension.cs.

00040         {
00041             Imported_alEffecti((uint)eid, EfxEffecti.EffectType, (int)type);
00042         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindEffect ( uint  eid,
EfxEffectType  type 
)

(Helper) Selects the Effect type used by this Effect handle.

Parameters:
eid Effect id returned from a successful call to GenEffects.
type Effect type.

Definition at line 30 of file EffectsExtension.cs.

00031         {
00032             Imported_alEffecti(eid, EfxEffecti.EffectType, (int)type);
00033         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindEffectToAuxiliarySlot ( int  auxiliaryeffectslot,
int  effect 
)

(Helper) Attaches an Effect to an Auxiliary Effect Slot.

Parameters:
auxiliaryeffectslot The slot handle to attach the Effect to.
effect The Effect handle that is being attached.

Definition at line 83 of file EffectsExtension.cs.

00084         {
00085             AuxiliaryEffectSlot((uint)auxiliaryeffectslot, EfxAuxiliaryi.EffectslotEffect, (int)effect);
00086         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindEffectToAuxiliarySlot ( uint  auxiliaryeffectslot,
uint  effect 
)

(Helper) Attaches an Effect to an Auxiliary Effect Slot.

Parameters:
auxiliaryeffectslot The slot handle to attach the Effect to.
effect The Effect handle that is being attached.

Definition at line 74 of file EffectsExtension.cs.

00075         {
00076             AuxiliaryEffectSlot(auxiliaryeffectslot, EfxAuxiliaryi.EffectslotEffect, (int)effect);
00077         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindFilterToSource ( int  source,
int  filter 
)

(Helper) reroutes the output of a Source through a Filter.

Parameters:
source A valid Source handle.
filter A valid Filter handle.

Definition at line 61 of file EffectsExtension.cs.

00062         {
00063             AL.Source((uint)source, ALSourcei.EfxDirectFilter, (int)filter);
00064         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindFilterToSource ( uint  source,
uint  filter 
)

(Helper) reroutes the output of a Source through a Filter.

Parameters:
source A valid Source handle.
filter A valid Filter handle.

Definition at line 52 of file EffectsExtension.cs.

00053         {
00054             AL.Source(source, ALSourcei.EfxDirectFilter, (int)filter);
00055         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindSourceToAuxiliarySlot ( int  source,
int  slot,
int  slotnumber,
int  filter 
)

(Helper) Reroutes a Source's output into an Auxiliary Effect Slot.

Parameters:
source The Source handle who's output is forwarded.
slot The Auxiliary Effect Slot handle that receives input from the Source.
slotnumber Every Source has only a limited number of slots it can feed buffer to. The number must stay below AlcContextAttributes.EfxMaxAuxiliarySends
filter Filter handle to be attached between Source ouput and Auxiliary Slot input. Use 0 or EfxFilterType.FilterNull for no filter.

Definition at line 109 of file EffectsExtension.cs.

00110         {
00111             AL.Source((uint)source, ALSource3i.EfxAuxiliarySendFilter, (int)slot, (int)slotnumber, (int)filter);
00112         }

void OpenTK.Audio.OpenAL.EffectsExtension.BindSourceToAuxiliarySlot ( uint  source,
uint  slot,
int  slotnumber,
uint  filter 
)

(Helper) Reroutes a Source's output into an Auxiliary Effect Slot.

Parameters:
source The Source handle who's output is forwarded.
slot The Auxiliary Effect Slot handle that receives input from the Source.
slotnumber Every Source has only a limited number of slots it can feed buffer to. The number must stay below AlcContextAttributes.EfxMaxAuxiliarySends
filter Filter handle to be attached between Source ouput and Auxiliary Slot input. Use 0 or EfxFilterType.FilterNull for no filter.

Definition at line 98 of file EffectsExtension.cs.

00099         {
00100             AL.Source(source, ALSource3i.EfxAuxiliarySendFilter, (int)slot, (int)slotnumber, (int)filter);
00101         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteAuxiliaryEffectSlot ( ref uint  slot  ) 

This function deletes one AuxiliaryEffectSlot only.

Parameters:
slot Pointer to an auxiliary effect slot name/handle identifying the Auxiliary Effect Slot Object to be deleted.

Definition at line 1013 of file EffectsExtension.cs.

01014         {
01015             unsafe
01016             {
01017                 fixed (uint* ptr = &slot)
01018                 {
01019                     Imported_alDeleteAuxiliaryEffectSlots(1, ptr);
01020                 }
01021             }
01022         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteAuxiliaryEffectSlot ( int  slot  ) 

This function deletes one AuxiliaryEffectSlot only.

Parameters:
slot Pointer to an auxiliary effect slot name/handle identifying the Auxiliary Effect Slot Object to be deleted.

Definition at line 1005 of file EffectsExtension.cs.

01006         {
01007             DeleteAuxiliaryEffectSlots(1, ref slot);
01008         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteAuxiliaryEffectSlots ( uint[]  slots  ) 

This function deletes one AuxiliaryEffectSlot only.

Parameters:
slots Pointer to an auxiliary effect slot name/handle identifying the Auxiliary Effect Slot Object to be deleted.

Definition at line 997 of file EffectsExtension.cs.

00998         {
00999             if (slots == null) throw new ArgumentNullException("slots");
01000             DeleteAuxiliaryEffectSlots(slots.Length, ref slots[0]);
01001         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteAuxiliaryEffectSlots ( int[]  slots  ) 

The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots.

Parameters:
slots Pointer to n Effect Slot object identifiers.

Definition at line 988 of file EffectsExtension.cs.

00989         {
00990             if (slots == null) throw new ArgumentNullException("slots");
00991             DeleteAuxiliaryEffectSlots(slots.Length, ref slots[0]);
00992         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteAuxiliaryEffectSlots ( int  n,
ref int  slots 
)

The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots.

Parameters:
n Number of Auxiliary Effect Slots to be deleted.
slots Pointer to n Effect Slot object identifiers.

Definition at line 975 of file EffectsExtension.cs.

00976         {
00977             unsafe
00978             {
00979                 fixed (int* ptr = &slots)
00980                 {
00981                     Imported_alDeleteAuxiliaryEffectSlots(n, (uint*)ptr);
00982                 }
00983             }
00984         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteAuxiliaryEffectSlots ( int  n,
ref uint  slots 
)

The DeleteAuxiliaryEffectSlots function is used to delete and free resources for Auxiliary Effect Slots previously created with GenAuxiliaryEffectSlots.

Parameters:
n Number of Auxiliary Effect Slots to be deleted.
slots Pointer to n Effect Slot object identifiers.

Definition at line 961 of file EffectsExtension.cs.

00962         {
00963             unsafe
00964             {
00965                 fixed (uint* ptr = &slots)
00966                 {
00967                     Imported_alDeleteAuxiliaryEffectSlots(n, ptr);
00968                 }
00969             }
00970         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteEffect ( ref uint  effect  ) 

This function deletes one Effect only.

Parameters:
effect Pointer to an effect name/handle identifying the Effect Object to be deleted.

Definition at line 272 of file EffectsExtension.cs.

00273         {
00274             unsafe
00275             {
00276                 fixed (uint* ptr = &effect)
00277                 {
00278                     Imported_alDeleteEffects(1, ptr);
00279                 }
00280             }
00281         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteEffect ( int  effect  ) 

This function deletes one Effect only.

Parameters:
effect Pointer to an effect name/handle identifying the Effect Object to be deleted.

Definition at line 264 of file EffectsExtension.cs.

00265         {
00266             DeleteEffects(1, ref effect);
00267         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteEffects ( uint[]  effects  ) 

The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.

Parameters:
effects Pointer to n Effect object identifiers.

Definition at line 256 of file EffectsExtension.cs.

00257         {
00258             if (effects == null) throw new ArgumentNullException("effects");
00259             DeleteEffects(effects.Length, ref effects[0]);
00260         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteEffects ( int[]  effects  ) 

The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.

Parameters:
effects Pointer to n Effect object identifiers.

Definition at line 247 of file EffectsExtension.cs.

00248         {
00249             if (effects == null) throw new ArgumentNullException("effects");
00250             DeleteEffects(effects.Length, ref effects[0]);
00251         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteEffects ( int  n,
ref int  effects 
)

The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.

Parameters:
n Number of Effects to be deleted.
effects Pointer to n Effect object identifiers.

Definition at line 234 of file EffectsExtension.cs.

00235         {
00236             unsafe
00237             {
00238                 fixed (int* ptr = &effects)
00239                 {
00240                     Imported_alDeleteEffects(n, (uint*)ptr);
00241                 }
00242             }
00243         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteEffects ( int  n,
ref uint  effects 
)

The DeleteEffects function is used to delete and free resources for Effect objects previously created with GenEffects.

Parameters:
n Number of Effects to be deleted.
effects Pointer to n Effect object identifiers.

Definition at line 220 of file EffectsExtension.cs.

00221         {
00222             unsafe
00223             {
00224                 fixed (uint* ptr = &effects)
00225                 {
00226                     Imported_alDeleteEffects(n, ptr);
00227                 }
00228             }
00229         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteFilter ( ref uint  filter  ) 

This function deletes one Filter only.

Parameters:
filter Pointer to an filter name/handle identifying the Filter Object to be deleted.

Definition at line 682 of file EffectsExtension.cs.

00683         {
00684             unsafe
00685             {
00686                 fixed (uint* ptr = &filter)
00687                 {
00688                     Imported_alDeleteFilters(1, ptr);
00689                 }
00690             }
00691         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteFilter ( int  filter  ) 

This function deletes one Filter only.

Parameters:
filter Pointer to an filter name/handle identifying the Filter Object to be deleted.

Definition at line 674 of file EffectsExtension.cs.

00675         {
00676             DeleteFilters(1, ref filter);
00677         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteFilters ( int[]  filters  ) 

This function deletes one Filter only.

Parameters:
filters Pointer to an filter name/handle identifying the Filter Object to be deleted.

Definition at line 666 of file EffectsExtension.cs.

00667         {
00668             if (filters == null) throw new ArgumentNullException("filters");
00669             DeleteFilters(filters.Length, ref filters[0]);
00670         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteFilters ( uint[]  filters  ) 

This function deletes one Filter only.

Parameters:
filters Pointer to an filter name/handle identifying the Filter Object to be deleted.

Definition at line 658 of file EffectsExtension.cs.

00659         {
00660             if (filters == null) throw new ArgumentNullException("filters");
00661             DeleteFilters(filters.Length, ref filters[0]);
00662         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteFilters ( int  n,
ref int  filters 
)

The DeleteFilters function is used to delete and free resources for Filter objects previously created with GenFilters.

Parameters:
n Number of Filters to be deleted.
filters Pointer to n Filter object identifiers.

Definition at line 644 of file EffectsExtension.cs.

00645         {
00646             unsafe
00647             {
00648                 fixed (int* ptr = &filters)
00649                 {
00650                     Imported_alDeleteFilters(n, (uint*)ptr);
00651                 }
00652             }
00653         }

void OpenTK.Audio.OpenAL.EffectsExtension.DeleteFilters ( int  n,
ref uint  filters 
)

The DeleteFilters function is used to delete and free resources for Filter objects previously created with GenFilters.

Parameters:
n Number of Filters to be deleted.
filters Pointer to n Filter object identifiers.

Definition at line 630 of file EffectsExtension.cs.

00631         {
00632             unsafe
00633             {
00634                 fixed (uint* ptr = &filters)
00635                 {
00636                     Imported_alDeleteFilters(n, ptr);
00637                 }
00638             }
00639         }

void OpenTK.Audio.OpenAL.EffectsExtension.Effect ( int  eid,
EfxEffect3f  param,
ref Vector3  values 
)

This function is used to set 3 floating-point properties on Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to set.
values Pointer to Math.Vector3.

Definition at line 406 of file EffectsExtension.cs.

00407         {
00408             Effect((uint)eid, param, ref values);
00409         }

void OpenTK.Audio.OpenAL.EffectsExtension.Effect ( uint  eid,
EfxEffect3f  param,
ref Vector3  values 
)

This function is used to set 3 floating-point properties on Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to set.
values Pointer to Math.Vector3.

Definition at line 390 of file EffectsExtension.cs.

00391         {
00392             unsafe
00393             {
00394                 fixed (float* ptr = &values.X)
00395                 {
00396                     Imported_alEffectfv(eid, param, ptr);
00397                 }
00398             }
00399         }

void OpenTK.Audio.OpenAL.EffectsExtension.Effect ( int  eid,
EfxEffectf  param,
float  value 
)

This function is used to set floating-point properties on Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to set.
value Floating-point value.

Definition at line 369 of file EffectsExtension.cs.

00370         {
00371             Imported_alEffectf((uint)eid, param, value);
00372         }

void OpenTK.Audio.OpenAL.EffectsExtension.Effect ( uint  eid,
EfxEffectf  param,
float  value 
)

This function is used to set floating-point properties on Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to set.
value Floating-point value.

Definition at line 359 of file EffectsExtension.cs.

00360         {
00361             Imported_alEffectf(eid, param, value);
00362         }

void OpenTK.Audio.OpenAL.EffectsExtension.Effect ( int  eid,
EfxEffecti  param,
int  value 
)

This function is used to set integer properties on Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to set.
value Integer value.

Definition at line 338 of file EffectsExtension.cs.

00339         {
00340             Imported_alEffecti((uint)eid, param, value);
00341         }

void OpenTK.Audio.OpenAL.EffectsExtension.Effect ( uint  eid,
EfxEffecti  param,
int  value 
)

This function is used to set integer properties on Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to set.
value Integer value.

Definition at line 328 of file EffectsExtension.cs.

00329         {
00330             Imported_alEffecti(eid, param, value);
00331         }

void OpenTK.Audio.OpenAL.EffectsExtension.Filter ( int  fid,
EfxFilterf  param,
float  value 
)

This function is used to set floating-point properties on Filter objects.

Parameters:
fid Filter object identifier.
param Effect property to set.
value Floating-point value.

Definition at line 779 of file EffectsExtension.cs.

00780         {
00781             Imported_alFilterf((uint)fid, param, value);
00782         }

void OpenTK.Audio.OpenAL.EffectsExtension.Filter ( uint  fid,
EfxFilterf  param,
float  value 
)

This function is used to set floating-point properties on Filter objects.

Parameters:
fid Filter object identifier.
param Effect property to set.
value Floating-point value.

Definition at line 769 of file EffectsExtension.cs.

00770         {
00771             Imported_alFilterf(fid, param, value);
00772         }

void OpenTK.Audio.OpenAL.EffectsExtension.Filter ( int  fid,
EfxFilteri  param,
int  value 
)

This function is used to set integer properties on Filter objects.

Parameters:
fid Filter object identifier.
param Effect property to set.
value Integer value.

Definition at line 748 of file EffectsExtension.cs.

00749         {
00750             Imported_alFilteri((uint)fid, param, value);
00751         }

void OpenTK.Audio.OpenAL.EffectsExtension.Filter ( uint  fid,
EfxFilteri  param,
int  value 
)

This function is used to set integer properties on Filter objects.

Parameters:
fid Filter object identifier.
param Effect property to set.
value Integer value.

Definition at line 738 of file EffectsExtension.cs.

00739         {
00740             Imported_alFilteri(fid, param, value);
00741         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenAuxiliaryEffectSlot ( out uint  slot  ) 

This function generates only one Auxiliary Effect Slot.

Returns:
Storage UInt32 for the new auxiliary effect slot name/handle.

Definition at line 936 of file EffectsExtension.cs.

00937         {
00938             unsafe
00939             {
00940                 fixed (uint* ptr = &slot)
00941                 {
00942                     Imported_alGenAuxiliaryEffectSlots(1, ptr);
00943                     slot = *ptr;
00944                 }
00945             }
00946         }

int OpenTK.Audio.OpenAL.EffectsExtension.GenAuxiliaryEffectSlot (  ) 

This function generates only one Auxiliary Effect Slot.

Returns:
Storage Int32 for the new auxiliary effect slot name/handle.

Definition at line 926 of file EffectsExtension.cs.

00927         {
00928             int temp;
00929             GenAuxiliaryEffectSlots(1, out temp);
00930             return temp;
00931         }

int [] OpenTK.Audio.OpenAL.EffectsExtension.GenAuxiliaryEffectSlots ( int  n  ) 

The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used.

An application should check the OpenAL error state after making this call to determine if the Effect Slot was successfully created. If the function call fails then none of the requested Effect Slots are created. A good strategy for creating any OpenAL object is to use a for-loop and generate one object each loop iteration and then check for an error condition. If an error is set then the loop can be broken and the application can determine if sufficient resources are available.

Parameters:
n Number of Auxiliary Effect Slots to be created.
Returns:
Pointer addressing sufficient memory to store n Effect Slot object identifiers.

Definition at line 916 of file EffectsExtension.cs.

00917         {
00918             if (n <= 0) throw new ArgumentOutOfRangeException("n", "Must be higher than 0.");
00919             int[] slots = new int[n];
00920             GenAuxiliaryEffectSlots(slots.Length, out slots[0]);
00921             return slots;
00922         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenAuxiliaryEffectSlots ( int  n,
out int  slots 
)

The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used.

An application should check the OpenAL error state after making this call to determine if the Effect Slot was successfully created. If the function call fails then none of the requested Effect Slots are created. A good strategy for creating any OpenAL object is to use a for-loop and generate one object each loop iteration and then check for an error condition. If an error is set then the loop can be broken and the application can determine if sufficient resources are available.

Parameters:
n Number of Auxiliary Effect Slots to be created.
slots Pointer addressing sufficient memory to store n Effect Slot object identifiers.

Definition at line 900 of file EffectsExtension.cs.

00901         {
00902             unsafe
00903             {
00904                 fixed (int* ptr = &slots)
00905                 {
00906                     Imported_alGenAuxiliaryEffectSlots(n, (uint*)ptr);
00907                     slots = *ptr;
00908                 }
00909             }
00910         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenAuxiliaryEffectSlots ( int  n,
out uint  slots 
)

The GenAuxiliaryEffectSlots function is used to create one or more Auxiliary Effect Slots. The number of slots that can be created will be dependant upon the Open AL device used.

An application should check the OpenAL error state after making this call to determine if the Effect Slot was successfully created. If the function call fails then none of the requested Effect Slots are created. A good strategy for creating any OpenAL object is to use a for-loop and generate one object each loop iteration and then check for an error condition. If an error is set then the loop can be broken and the application can determine if sufficient resources are available.

Parameters:
n Number of Auxiliary Effect Slots to be created.
slots Pointer addressing sufficient memory to store n Effect Slot object identifiers.

Definition at line 884 of file EffectsExtension.cs.

00885         {
00886             unsafe
00887             {
00888                 fixed (uint* ptr = &slots)
00889                 {
00890                     Imported_alGenAuxiliaryEffectSlots(n, ptr);
00891                     slots = *ptr;
00892                 }
00893             }
00894         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenEffect ( out uint  effect  ) 

Generates a single effect object.

Parameters:
effect A handle to the generated effect object.

Definition at line 192 of file EffectsExtension.cs.

00193         {
00194             unsafe
00195             {
00196                 fixed (uint* ptr = &effect)
00197                 {
00198                     Imported_alGenEffects(1, ptr);
00199                     effect = *ptr;
00200                 }
00201             }
00202 
00203         }

int OpenTK.Audio.OpenAL.EffectsExtension.GenEffect (  ) 

Generates a single effect object.

Returns:
A handle to the generated effect object.

The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object.

After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti.

Definition at line 182 of file EffectsExtension.cs.

00183         {
00184             int temp;
00185             GenEffects(1, out temp);
00186             return temp;
00187         }

int [] OpenTK.Audio.OpenAL.EffectsExtension.GenEffects ( int  n  ) 

Generates one or more effect objects.

Parameters:
n Number of Effect object identifiers to generate.

The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object.

After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti.

Definition at line 168 of file EffectsExtension.cs.

00169         {
00170             if (n <= 0) throw new ArgumentOutOfRangeException("n", "Must be higher than 0.");
00171             int[] effects = new int[n];
00172             GenEffects(n, out effects[0]);
00173             return effects;
00174         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenEffects ( int  n,
out int  effects 
)

The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object.

After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti.

Parameters:
n Number of Effects to be created.
effects Pointer addressing sufficient memory to store n Effect object identifiers.

Definition at line 150 of file EffectsExtension.cs.

00151         {
00152             unsafe
00153             {
00154                 fixed (int* ptr = &effects)
00155                 {
00156                     Imported_alGenEffects(n, (uint*)ptr);
00157                     effects = *ptr;
00158                 }
00159             }
00160         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenEffects ( int  n,
out uint  effects 
)

The GenEffects function is used to create one or more Effect objects. An Effect object stores an effect type and a set of parameter values to control that Effect. In order to use an Effect it must be attached to an Auxiliary Effect Slot object.

After creation an Effect has no type (EfxEffectType.Null), so before it can be used to store a set of parameters, the application must specify what type of effect should be stored in the object, using Effect() with EfxEffecti.

Parameters:
n Number of Effects to be created.
effects Pointer addressing sufficient memory to store n Effect object identifiers.

Definition at line 134 of file EffectsExtension.cs.

00135         {
00136             unsafe
00137             {
00138                 fixed (uint* ptr = &effects)
00139                 {
00140                     Imported_alGenEffects(n, ptr);
00141                     effects = *ptr;
00142                 }
00143             }
00144         }

unsafe void OpenTK.Audio.OpenAL.EffectsExtension.GenFilter ( out uint  filter  ) 

This function generates only one Filter.

Parameters:
filter Storage UInt32 for the new filter name/handle.

Definition at line 603 of file EffectsExtension.cs.

00604         {
00605             unsafe
00606             {
00607                 fixed (uint* ptr = &filter)
00608                 {
00609                     Imported_alGenFilters(1, ptr);
00610                     filter = *ptr;
00611                 }
00612             }
00613         }

int OpenTK.Audio.OpenAL.EffectsExtension.GenFilter (  ) 

This function generates only one Filter.

Returns:
Storage Int32 for the new filter name/handle.

Definition at line 593 of file EffectsExtension.cs.

00594         {
00595             int filter;
00596             GenFilters(1, out filter);
00597             return filter;
00598         }

int [] OpenTK.Audio.OpenAL.EffectsExtension.GenFilters ( int  n  ) 

The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters.

After creation a Filter has no type (EfxFilterType.Null), so before it can be used to store a set of parameters, the application must specify what type of filter should be stored in the object, using Filter() with EfxFilteri.

Parameters:
n Number of Filters to be created.
Returns:
Pointer addressing sufficient memory to store n Filter object identifiers.

Definition at line 582 of file EffectsExtension.cs.

00583         {
00584 
00585             if (n <= 0) throw new ArgumentOutOfRangeException("n", "Must be higher than 0.");
00586             int[] filters = new int[n];
00587             GenFilters(filters.Length, out filters[0]);
00588             return filters;
00589         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenFilters ( int  n,
out int  filters 
)

The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters.

After creation a Filter has no type (EfxFilterType.Null), so before it can be used to store a set of parameters, the application must specify what type of filter should be stored in the object, using Filter() with EfxFilteri.

Parameters:
n Number of Filters to be created.
filters Pointer addressing sufficient memory to store n Filter object identifiers.

Definition at line 565 of file EffectsExtension.cs.

00566         {
00567             unsafe
00568             {
00569                 fixed (int* ptr = &filters)
00570                 {
00571                     Imported_alGenFilters(n, (uint*)ptr);
00572                     filters = *ptr;
00573                 }
00574             }
00575         }

void OpenTK.Audio.OpenAL.EffectsExtension.GenFilters ( int  n,
out uint  filters 
)

The GenFilters function is used to create one or more Filter objects. A Filter object stores a filter type and a set of parameter values to control that Filter. Filter objects can be attached to Sources as Direct Filters or Auxiliary Send Filters.

After creation a Filter has no type (EfxFilterType.Null), so before it can be used to store a set of parameters, the application must specify what type of filter should be stored in the object, using Filter() with EfxFilteri.

Parameters:
n Number of Filters to be created.
filters Pointer addressing sufficient memory to store n Filter object identifiers.

Definition at line 549 of file EffectsExtension.cs.

00550         {
00551             unsafe
00552             {
00553                 fixed (uint* ptr = &filters)
00554                 {
00555                     Imported_alGenFilters(n, ptr);
00556                     filters = *ptr;
00557                 }
00558             }
00559         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetAuxiliaryEffectSlot ( int  asid,
EfxAuxiliaryf  pname,
out float  value 
)

This function is used to retrieve floating properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
pname Auxiliary Effect Slot property to retrieve.
value Address where floating-point value will be stored.

Definition at line 1184 of file EffectsExtension.cs.

01185         {
01186             GetAuxiliaryEffectSlot((uint)asid, pname, out value);
01187         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetAuxiliaryEffectSlot ( uint  asid,
EfxAuxiliaryf  pname,
out float  value 
)

This function is used to retrieve floating properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
pname Auxiliary Effect Slot property to retrieve.
value Address where floating-point value will be stored.

Definition at line 1168 of file EffectsExtension.cs.

01169         {
01170             unsafe
01171             {
01172                 fixed (float* ptr = &value)
01173                 {
01174                     Imported_alGetAuxiliaryEffectSlotf(asid, pname, ptr);
01175                 }
01176             }
01177         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetAuxiliaryEffectSlot ( int  asid,
EfxAuxiliaryi  pname,
out int  value 
)

This function is used to retrieve integer properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
pname Auxiliary Effect Slot property to retrieve.
value Address where integer value will be stored.

Definition at line 1147 of file EffectsExtension.cs.

01148         {
01149             GetAuxiliaryEffectSlot((uint)asid, pname, out value);
01150         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetAuxiliaryEffectSlot ( uint  asid,
EfxAuxiliaryi  pname,
out int  value 
)

This function is used to retrieve integer properties on Auxiliary Effect Slot objects.

Parameters:
asid Auxiliary Effect Slot object identifier.
pname Auxiliary Effect Slot property to retrieve.
value Address where integer value will be stored.

Definition at line 1131 of file EffectsExtension.cs.

01132         {
01133             unsafe
01134             {
01135                 fixed (int* ptr = &value)
01136                 {
01137                     Imported_alGetAuxiliaryEffectSloti(asid, pname, ptr);
01138                 }
01139             }
01140         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetEffect ( int  eid,
EfxEffect3f  param,
out Vector3  values 
)

This function is used to retrieve 3 floating-point properties from Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to retrieve.
values A Math.Vector3 to hold the values.

Definition at line 520 of file EffectsExtension.cs.

00521         {
00522             GetEffect((uint)eid, param, out values);
00523         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetEffect ( uint  eid,
EfxEffect3f  param,
out Vector3  values 
)

This function is used to retrieve 3 floating-point properties from Effect objects.

Parameters:
eid Effect object identifier.
param Effect property to retrieve.
values A Math.Vector3 to hold the values.

Definition at line 501 of file EffectsExtension.cs.

00502         {
00503             unsafe
00504             {
00505                 fixed (float* ptr = &values.X)
00506                 {
00507                     Imported_alGetEffectfv(eid, param, ptr);
00508                     values.X = ptr[0];
00509                     values.Y = ptr[1];
00510                     values.Z = ptr[2];
00511                 }
00512             }
00513         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetEffect ( int  eid,
EfxEffectf  pname,
out float  value 
)

This function is used to retrieve floating-point properties from Effect objects.

Parameters:
eid Effect object identifier.
pname Effect property to retrieve.
value Address where floating-point value will be stored.

Definition at line 480 of file EffectsExtension.cs.

00481         {
00482             GetEffect((uint)eid, pname, out value);
00483         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetEffect ( uint  eid,
EfxEffectf  pname,
out float  value 
)

This function is used to retrieve floating-point properties from Effect objects.

Parameters:
eid Effect object identifier.
pname Effect property to retrieve.
value Address where floating-point value will be stored.

Definition at line 464 of file EffectsExtension.cs.

00465         {
00466             unsafe
00467             {
00468                 fixed (float* ptr = &value)
00469                 {
00470                     Imported_alGetEffectf(eid, pname, ptr);
00471                 }
00472             }
00473         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetEffect ( int  eid,
EfxEffecti  pname,
out int  value 
)

This function is used to retrieve integer properties from Effect objects.

Parameters:
eid Effect object identifier.
pname Effect property to retrieve.
value Address where integer value will be stored.

Definition at line 443 of file EffectsExtension.cs.

00444         {
00445             GetEffect((uint)eid, pname, out value);
00446         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetEffect ( uint  eid,
EfxEffecti  pname,
out int  value 
)

This function is used to retrieve integer properties from Effect objects.

Parameters:
eid Effect object identifier.
pname Effect property to retrieve.
value Address where integer value will be stored.

Definition at line 427 of file EffectsExtension.cs.

00428         {
00429             unsafe
00430             {
00431                 fixed (int* ptr = &value)
00432                 {
00433                     Imported_alGetEffecti(eid, pname, ptr);
00434                 }
00435             }
00436         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetFilter ( int  fid,
EfxFilterf  pname,
out float  value 
)

This function is used to retrieve floating-point properties from Filter objects.

Parameters:
fid Filter object identifier.
pname Effect property to retrieve.
value Address where floating-point value will be stored.

Definition at line 853 of file EffectsExtension.cs.

00854         {
00855             GetFilter((uint)fid, pname, out value);
00856         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetFilter ( uint  fid,
EfxFilterf  pname,
out float  value 
)

This function is used to retrieve floating-point properties from Filter objects.

Parameters:
fid Filter object identifier.
pname Effect property to retrieve.
value Address where floating-point value will be stored.

Definition at line 837 of file EffectsExtension.cs.

00838         {
00839             unsafe
00840             {
00841                 fixed (float* ptr = &value)
00842                 {
00843                     Imported_alGetFilterf(fid, pname, ptr);
00844                 }
00845             }
00846         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetFilter ( int  fid,
EfxFilteri  pname,
out int  value 
)

This function is used to retrieve integer properties from Filter objects.

Parameters:
fid Filter object identifier.
pname Effect property to retrieve.
value Address where integer value will be stored.

Definition at line 816 of file EffectsExtension.cs.

00817         {
00818             GetFilter((uint)fid, pname, out value);
00819         }

void OpenTK.Audio.OpenAL.EffectsExtension.GetFilter ( uint  fid,
EfxFilteri  pname,
out int  value 
)

This function is used to retrieve integer properties from Filter objects.

Parameters:
fid Filter object identifier.
pname Effect property to retrieve.
value Address where integer value will be stored.

Definition at line 800 of file EffectsExtension.cs.

00801         {
00802             unsafe
00803             {
00804                 fixed (int* ptr = &value)
00805                 {
00806                     Imported_alGetFilteri(fid, pname, ptr);
00807                 }
00808             }
00809         }

bool OpenTK.Audio.OpenAL.EffectsExtension.IsAuxiliaryEffectSlot ( int  slot  ) 

The IsAuxiliaryEffectSlot function is used to determine if an object identifier is a valid Auxiliary Effect Slot object.

Parameters:
slot Effect Slot object identifier to validate.
Returns:
True if the identifier is a valid Auxiliary Effect Slot, False otherwise.

Definition at line 1048 of file EffectsExtension.cs.

01049         {
01050             return Imported_alIsAuxiliaryEffectSlot((uint)slot);
01051         }

bool OpenTK.Audio.OpenAL.EffectsExtension.IsAuxiliaryEffectSlot ( uint  slot  ) 

The IsAuxiliaryEffectSlot function is used to determine if an object identifier is a valid Auxiliary Effect Slot object.

Parameters:
slot Effect Slot object identifier to validate.
Returns:
True if the identifier is a valid Auxiliary Effect Slot, False otherwise.

Definition at line 1039 of file EffectsExtension.cs.

01040         {
01041             return Imported_alIsAuxiliaryEffectSlot(slot);
01042         }

bool OpenTK.Audio.OpenAL.EffectsExtension.IsEffect ( int  eid  ) 

The IsEffect function is used to determine if an object identifier is a valid Effect object.

Parameters:
eid Effect identifier to validate.
Returns:
True if the identifier is a valid Effect, False otherwise.

Definition at line 307 of file EffectsExtension.cs.

00308         {
00309             return Imported_alIsEffect((uint)eid);
00310         }

bool OpenTK.Audio.OpenAL.EffectsExtension.IsEffect ( uint  eid  ) 

The IsEffect function is used to determine if an object identifier is a valid Effect object.

Parameters:
eid Effect identifier to validate.
Returns:
True if the identifier is a valid Effect, False otherwise.

Definition at line 298 of file EffectsExtension.cs.

00299         {
00300             return Imported_alIsEffect(eid);
00301         }

bool OpenTK.Audio.OpenAL.EffectsExtension.IsFilter ( int  fid  ) 

The IsFilter function is used to determine if an object identifier is a valid Filter object.

Parameters:
fid Effect identifier to validate.
Returns:
True if the identifier is a valid Filter, False otherwise.

Definition at line 717 of file EffectsExtension.cs.

00718         {
00719             return Imported_alIsFilter((uint)fid);
00720         }

bool OpenTK.Audio.OpenAL.EffectsExtension.IsFilter ( uint  fid  ) 

The IsFilter function is used to determine if an object identifier is a valid Filter object.

Parameters:
fid Effect identifier to validate.
Returns:
True if the identifier is a valid Filter, False otherwise.

Definition at line 708 of file EffectsExtension.cs.

00709         {
00710             return Imported_alIsFilter(fid);
00711         }

Property Documentation

bool OpenTK.Audio.OpenAL.EffectsExtension.IsInitialized [get]

Returns True if the EFX Extension has been found and could be initialized.

Definition at line 1205 of file EffectsExtension.cs.

 All Classes Functions Variables Enumerations Properties Events
Generated on Tue Mar 9 14:59:21 2010 for The Open Toolkit library by  doxygen 1.6.1