
// SoLoud wrapper for Beef (bf)
// This file is autogenerated; any changes will be overwritten

using System;

namespace SoLoud
{

public class SoloudObject
{
    public void* objhandle;
}



public class Soloud : SoloudObject
{
	public const int AUTO = 0;
	public const int SDL1 = 1;
	public const int SDL2 = 2;
	public const int PORTAUDIO = 3;
	public const int WINMM = 4;
	public const int XAUDIO2 = 5;
	public const int WASAPI = 6;
	public const int ALSA = 7;
	public const int JACK = 8;
	public const int OSS = 9;
	public const int OPENAL = 10;
	public const int COREAUDIO = 11;
	public const int OPENSLES = 12;
	public const int VITA_HOMEBREW = 13;
	public const int MINIAUDIO = 14;
	public const int NOSOUND = 15;
	public const int NULLDRIVER = 16;
	public const int BACKEND_MAX = 17;
	public const int CLIP_ROUNDOFF = 1;
	public const int ENABLE_VISUALIZATION = 2;
	public const int LEFT_HANDED_3D = 4;
	public const int NO_FPU_REGISTER_CHANGE = 8;
	public const int WAVE_SQUARE = 0;
	public const int WAVE_SAW = 1;
	public const int WAVE_SIN = 2;
	public const int WAVE_TRIANGLE = 3;
	public const int WAVE_BOUNCE = 4;
	public const int WAVE_JAWS = 5;
	public const int WAVE_HUMPS = 6;
	public const int WAVE_FSQUARE = 7;
	public const int WAVE_FSAW = 8;
	public const int RESAMPLER_POINT = 0;
	public const int RESAMPLER_LINEAR = 1;
	public const int RESAMPLER_CATMULLROM = 2;

	[LinkName("Soloud_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Soloud_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 Soloud_initEx(void* aObjHandle, uint32 aFlags, uint32 aBackend, uint32 aSamplerate, uint32 aBufferSize, uint32 aChannels);
	public int32 init(uint32 aFlags = CLIP_ROUNDOFF, uint32 aBackend = AUTO, uint32 aSamplerate = AUTO, uint32 aBufferSize = AUTO, uint32 aChannels = 2)
	{
		return Soloud_initEx(objhandle, aFlags, aBackend, aSamplerate, aBufferSize, aChannels);
	}

	[CLink]
	private static extern void Soloud_deinit(void* aObjHandle);
	public void deinit()
	{
		Soloud_deinit(objhandle);
	}

	[CLink]
	private static extern uint32 Soloud_getVersion(void* aObjHandle);
	public uint32 getVersion()
	{
		return Soloud_getVersion(objhandle);
	}

	[CLink]
	private static extern char8 * Soloud_getErrorString(void* aObjHandle, int32 aErrorCode);
	public char8 * getErrorString(int32 aErrorCode)
	{
		return Soloud_getErrorString(objhandle, aErrorCode);
	}

	[CLink]
	private static extern uint32 Soloud_getBackendId(void* aObjHandle);
	public uint32 getBackendId()
	{
		return Soloud_getBackendId(objhandle);
	}

	[CLink]
	private static extern char8 * Soloud_getBackendString(void* aObjHandle);
	public char8 * getBackendString()
	{
		return Soloud_getBackendString(objhandle);
	}

	[CLink]
	private static extern uint32 Soloud_getBackendChannels(void* aObjHandle);
	public uint32 getBackendChannels()
	{
		return Soloud_getBackendChannels(objhandle);
	}

	[CLink]
	private static extern uint32 Soloud_getBackendSamplerate(void* aObjHandle);
	public uint32 getBackendSamplerate()
	{
		return Soloud_getBackendSamplerate(objhandle);
	}

	[CLink]
	private static extern uint32 Soloud_getBackendBufferSize(void* aObjHandle);
	public uint32 getBackendBufferSize()
	{
		return Soloud_getBackendBufferSize(objhandle);
	}

	[CLink]
	private static extern int32 Soloud_setSpeakerPosition(void* aObjHandle, uint32 aChannel, float aX, float aY, float aZ);
	public int32 setSpeakerPosition(uint32 aChannel, float aX, float aY, float aZ)
	{
		return Soloud_setSpeakerPosition(objhandle, aChannel, aX, aY, aZ);
	}

	[CLink]
	private static extern int32 Soloud_getSpeakerPosition(void* aObjHandle, uint32 aChannel, float * aX, float * aY, float * aZ);
	public int32 getSpeakerPosition(uint32 aChannel, float * aX, float * aY, float * aZ)
	{
		return Soloud_getSpeakerPosition(objhandle, aChannel, aX, aY, aZ);
	}

	[CLink]
	private static extern uint32 Soloud_playEx(void* aObjHandle, void * aSound, float aVolume, float aPan, int32 aPaused, uint32 aBus);
	public uint32 play(SoloudObject aSound, float aVolume = -1.0f, float aPan = 0.0f, int32 aPaused = 0, uint32 aBus = 0)
	{
		return Soloud_playEx(objhandle, aSound.objhandle, aVolume, aPan, aPaused, aBus);
	}

	[CLink]
	private static extern uint32 Soloud_playClockedEx(void* aObjHandle, double aSoundTime, void * aSound, float aVolume, float aPan, uint32 aBus);
	public uint32 playClocked(double aSoundTime, SoloudObject aSound, float aVolume = -1.0f, float aPan = 0.0f, uint32 aBus = 0)
	{
		return Soloud_playClockedEx(objhandle, aSoundTime, aSound.objhandle, aVolume, aPan, aBus);
	}

	[CLink]
	private static extern uint32 Soloud_play3dEx(void* aObjHandle, void * aSound, float aPosX, float aPosY, float aPosZ, float aVelX, float aVelY, float aVelZ, float aVolume, int32 aPaused, uint32 aBus);
	public uint32 play3d(SoloudObject aSound, float aPosX, float aPosY, float aPosZ, float aVelX = 0.0f, float aVelY = 0.0f, float aVelZ = 0.0f, float aVolume = 1.0f, int32 aPaused = 0, uint32 aBus = 0)
	{
		return Soloud_play3dEx(objhandle, aSound.objhandle, aPosX, aPosY, aPosZ, aVelX, aVelY, aVelZ, aVolume, aPaused, aBus);
	}

	[CLink]
	private static extern uint32 Soloud_play3dClockedEx(void* aObjHandle, double aSoundTime, void * aSound, float aPosX, float aPosY, float aPosZ, float aVelX, float aVelY, float aVelZ, float aVolume, uint32 aBus);
	public uint32 play3dClocked(double aSoundTime, SoloudObject aSound, float aPosX, float aPosY, float aPosZ, float aVelX = 0.0f, float aVelY = 0.0f, float aVelZ = 0.0f, float aVolume = 1.0f, uint32 aBus = 0)
	{
		return Soloud_play3dClockedEx(objhandle, aSoundTime, aSound.objhandle, aPosX, aPosY, aPosZ, aVelX, aVelY, aVelZ, aVolume, aBus);
	}

	[CLink]
	private static extern uint32 Soloud_playBackgroundEx(void* aObjHandle, void * aSound, float aVolume, int32 aPaused, uint32 aBus);
	public uint32 playBackground(SoloudObject aSound, float aVolume = -1.0f, int32 aPaused = 0, uint32 aBus = 0)
	{
		return Soloud_playBackgroundEx(objhandle, aSound.objhandle, aVolume, aPaused, aBus);
	}

	[CLink]
	private static extern int32 Soloud_seek(void* aObjHandle, uint32 aVoiceHandle, double aSeconds);
	public int32 seek(uint32 aVoiceHandle, double aSeconds)
	{
		return Soloud_seek(objhandle, aVoiceHandle, aSeconds);
	}

	[CLink]
	private static extern void Soloud_stop(void* aObjHandle, uint32 aVoiceHandle);
	public void stop(uint32 aVoiceHandle)
	{
		Soloud_stop(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern void Soloud_stopAll(void* aObjHandle);
	public void stopAll()
	{
		Soloud_stopAll(objhandle);
	}

	[CLink]
	private static extern void Soloud_stopAudioSource(void* aObjHandle, void * aSound);
	public void stopAudioSource(SoloudObject aSound)
	{
		Soloud_stopAudioSource(objhandle, aSound.objhandle);
	}

	[CLink]
	private static extern int32 Soloud_countAudioSource(void* aObjHandle, void * aSound);
	public int32 countAudioSource(SoloudObject aSound)
	{
		return Soloud_countAudioSource(objhandle, aSound.objhandle);
	}

	[CLink]
	private static extern void Soloud_setFilterParameter(void* aObjHandle, uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId, float aValue);
	public void setFilterParameter(uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId, float aValue)
	{
		Soloud_setFilterParameter(objhandle, aVoiceHandle, aFilterId, aAttributeId, aValue);
	}

	[CLink]
	private static extern float Soloud_getFilterParameter(void* aObjHandle, uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId);
	public float getFilterParameter(uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId)
	{
		return Soloud_getFilterParameter(objhandle, aVoiceHandle, aFilterId, aAttributeId);
	}

	[CLink]
	private static extern void Soloud_fadeFilterParameter(void* aObjHandle, uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId, float aTo, double aTime);
	public void fadeFilterParameter(uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId, float aTo, double aTime)
	{
		Soloud_fadeFilterParameter(objhandle, aVoiceHandle, aFilterId, aAttributeId, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_oscillateFilterParameter(void* aObjHandle, uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId, float aFrom, float aTo, double aTime);
	public void oscillateFilterParameter(uint32 aVoiceHandle, uint32 aFilterId, uint32 aAttributeId, float aFrom, float aTo, double aTime)
	{
		Soloud_oscillateFilterParameter(objhandle, aVoiceHandle, aFilterId, aAttributeId, aFrom, aTo, aTime);
	}

	[CLink]
	private static extern double Soloud_getStreamTime(void* aObjHandle, uint32 aVoiceHandle);
	public double getStreamTime(uint32 aVoiceHandle)
	{
		return Soloud_getStreamTime(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern double Soloud_getStreamPosition(void* aObjHandle, uint32 aVoiceHandle);
	public double getStreamPosition(uint32 aVoiceHandle)
	{
		return Soloud_getStreamPosition(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern int32 Soloud_getPause(void* aObjHandle, uint32 aVoiceHandle);
	public int32 getPause(uint32 aVoiceHandle)
	{
		return Soloud_getPause(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float Soloud_getVolume(void* aObjHandle, uint32 aVoiceHandle);
	public float getVolume(uint32 aVoiceHandle)
	{
		return Soloud_getVolume(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float Soloud_getOverallVolume(void* aObjHandle, uint32 aVoiceHandle);
	public float getOverallVolume(uint32 aVoiceHandle)
	{
		return Soloud_getOverallVolume(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float Soloud_getPan(void* aObjHandle, uint32 aVoiceHandle);
	public float getPan(uint32 aVoiceHandle)
	{
		return Soloud_getPan(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float Soloud_getSamplerate(void* aObjHandle, uint32 aVoiceHandle);
	public float getSamplerate(uint32 aVoiceHandle)
	{
		return Soloud_getSamplerate(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern int32 Soloud_getProtectVoice(void* aObjHandle, uint32 aVoiceHandle);
	public int32 getProtectVoice(uint32 aVoiceHandle)
	{
		return Soloud_getProtectVoice(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern uint32 Soloud_getActiveVoiceCount(void* aObjHandle);
	public uint32 getActiveVoiceCount()
	{
		return Soloud_getActiveVoiceCount(objhandle);
	}

	[CLink]
	private static extern uint32 Soloud_getVoiceCount(void* aObjHandle);
	public uint32 getVoiceCount()
	{
		return Soloud_getVoiceCount(objhandle);
	}

	[CLink]
	private static extern int32 Soloud_isValidVoiceHandle(void* aObjHandle, uint32 aVoiceHandle);
	public int32 isValidVoiceHandle(uint32 aVoiceHandle)
	{
		return Soloud_isValidVoiceHandle(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float Soloud_getRelativePlaySpeed(void* aObjHandle, uint32 aVoiceHandle);
	public float getRelativePlaySpeed(uint32 aVoiceHandle)
	{
		return Soloud_getRelativePlaySpeed(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float Soloud_getPostClipScaler(void* aObjHandle);
	public float getPostClipScaler()
	{
		return Soloud_getPostClipScaler(objhandle);
	}

	[CLink]
	private static extern uint32 Soloud_getMainResampler(void* aObjHandle);
	public uint32 getMainResampler()
	{
		return Soloud_getMainResampler(objhandle);
	}

	[CLink]
	private static extern float Soloud_getGlobalVolume(void* aObjHandle);
	public float getGlobalVolume()
	{
		return Soloud_getGlobalVolume(objhandle);
	}

	[CLink]
	private static extern uint32 Soloud_getMaxActiveVoiceCount(void* aObjHandle);
	public uint32 getMaxActiveVoiceCount()
	{
		return Soloud_getMaxActiveVoiceCount(objhandle);
	}

	[CLink]
	private static extern int32 Soloud_getLooping(void* aObjHandle, uint32 aVoiceHandle);
	public int32 getLooping(uint32 aVoiceHandle)
	{
		return Soloud_getLooping(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern int32 Soloud_getAutoStop(void* aObjHandle, uint32 aVoiceHandle);
	public int32 getAutoStop(uint32 aVoiceHandle)
	{
		return Soloud_getAutoStop(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern double Soloud_getLoopPoint(void* aObjHandle, uint32 aVoiceHandle);
	public double getLoopPoint(uint32 aVoiceHandle)
	{
		return Soloud_getLoopPoint(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern void Soloud_setLoopPoint(void* aObjHandle, uint32 aVoiceHandle, double aLoopPoint);
	public void setLoopPoint(uint32 aVoiceHandle, double aLoopPoint)
	{
		Soloud_setLoopPoint(objhandle, aVoiceHandle, aLoopPoint);
	}

	[CLink]
	private static extern void Soloud_setLooping(void* aObjHandle, uint32 aVoiceHandle, int32 aLooping);
	public void setLooping(uint32 aVoiceHandle, int32 aLooping)
	{
		Soloud_setLooping(objhandle, aVoiceHandle, aLooping);
	}

	[CLink]
	private static extern void Soloud_setAutoStop(void* aObjHandle, uint32 aVoiceHandle, int32 aAutoStop);
	public void setAutoStop(uint32 aVoiceHandle, int32 aAutoStop)
	{
		Soloud_setAutoStop(objhandle, aVoiceHandle, aAutoStop);
	}

	[CLink]
	private static extern int32 Soloud_setMaxActiveVoiceCount(void* aObjHandle, uint32 aVoiceCount);
	public int32 setMaxActiveVoiceCount(uint32 aVoiceCount)
	{
		return Soloud_setMaxActiveVoiceCount(objhandle, aVoiceCount);
	}

	[CLink]
	private static extern void Soloud_setInaudibleBehavior(void* aObjHandle, uint32 aVoiceHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(uint32 aVoiceHandle, int32 aMustTick, int32 aKill)
	{
		Soloud_setInaudibleBehavior(objhandle, aVoiceHandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Soloud_setGlobalVolume(void* aObjHandle, float aVolume);
	public void setGlobalVolume(float aVolume)
	{
		Soloud_setGlobalVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Soloud_setPostClipScaler(void* aObjHandle, float aScaler);
	public void setPostClipScaler(float aScaler)
	{
		Soloud_setPostClipScaler(objhandle, aScaler);
	}

	[CLink]
	private static extern void Soloud_setMainResampler(void* aObjHandle, uint32 aResampler);
	public void setMainResampler(uint32 aResampler)
	{
		Soloud_setMainResampler(objhandle, aResampler);
	}

	[CLink]
	private static extern void Soloud_setPause(void* aObjHandle, uint32 aVoiceHandle, int32 aPause);
	public void setPause(uint32 aVoiceHandle, int32 aPause)
	{
		Soloud_setPause(objhandle, aVoiceHandle, aPause);
	}

	[CLink]
	private static extern void Soloud_setPauseAll(void* aObjHandle, int32 aPause);
	public void setPauseAll(int32 aPause)
	{
		Soloud_setPauseAll(objhandle, aPause);
	}

	[CLink]
	private static extern int32 Soloud_setRelativePlaySpeed(void* aObjHandle, uint32 aVoiceHandle, float aSpeed);
	public int32 setRelativePlaySpeed(uint32 aVoiceHandle, float aSpeed)
	{
		return Soloud_setRelativePlaySpeed(objhandle, aVoiceHandle, aSpeed);
	}

	[CLink]
	private static extern void Soloud_setProtectVoice(void* aObjHandle, uint32 aVoiceHandle, int32 aProtect);
	public void setProtectVoice(uint32 aVoiceHandle, int32 aProtect)
	{
		Soloud_setProtectVoice(objhandle, aVoiceHandle, aProtect);
	}

	[CLink]
	private static extern void Soloud_setSamplerate(void* aObjHandle, uint32 aVoiceHandle, float aSamplerate);
	public void setSamplerate(uint32 aVoiceHandle, float aSamplerate)
	{
		Soloud_setSamplerate(objhandle, aVoiceHandle, aSamplerate);
	}

	[CLink]
	private static extern void Soloud_setPan(void* aObjHandle, uint32 aVoiceHandle, float aPan);
	public void setPan(uint32 aVoiceHandle, float aPan)
	{
		Soloud_setPan(objhandle, aVoiceHandle, aPan);
	}

	[CLink]
	private static extern void Soloud_setPanAbsolute(void* aObjHandle, uint32 aVoiceHandle, float aLVolume, float aRVolume);
	public void setPanAbsolute(uint32 aVoiceHandle, float aLVolume, float aRVolume)
	{
		Soloud_setPanAbsolute(objhandle, aVoiceHandle, aLVolume, aRVolume);
	}

	[CLink]
	private static extern void Soloud_setChannelVolume(void* aObjHandle, uint32 aVoiceHandle, uint32 aChannel, float aVolume);
	public void setChannelVolume(uint32 aVoiceHandle, uint32 aChannel, float aVolume)
	{
		Soloud_setChannelVolume(objhandle, aVoiceHandle, aChannel, aVolume);
	}

	[CLink]
	private static extern void Soloud_setVolume(void* aObjHandle, uint32 aVoiceHandle, float aVolume);
	public void setVolume(uint32 aVoiceHandle, float aVolume)
	{
		Soloud_setVolume(objhandle, aVoiceHandle, aVolume);
	}

	[CLink]
	private static extern void Soloud_setDelaySamples(void* aObjHandle, uint32 aVoiceHandle, uint32 aSamples);
	public void setDelaySamples(uint32 aVoiceHandle, uint32 aSamples)
	{
		Soloud_setDelaySamples(objhandle, aVoiceHandle, aSamples);
	}

	[CLink]
	private static extern void Soloud_fadeVolume(void* aObjHandle, uint32 aVoiceHandle, float aTo, double aTime);
	public void fadeVolume(uint32 aVoiceHandle, float aTo, double aTime)
	{
		Soloud_fadeVolume(objhandle, aVoiceHandle, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_fadePan(void* aObjHandle, uint32 aVoiceHandle, float aTo, double aTime);
	public void fadePan(uint32 aVoiceHandle, float aTo, double aTime)
	{
		Soloud_fadePan(objhandle, aVoiceHandle, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_fadeRelativePlaySpeed(void* aObjHandle, uint32 aVoiceHandle, float aTo, double aTime);
	public void fadeRelativePlaySpeed(uint32 aVoiceHandle, float aTo, double aTime)
	{
		Soloud_fadeRelativePlaySpeed(objhandle, aVoiceHandle, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_fadeGlobalVolume(void* aObjHandle, float aTo, double aTime);
	public void fadeGlobalVolume(float aTo, double aTime)
	{
		Soloud_fadeGlobalVolume(objhandle, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_schedulePause(void* aObjHandle, uint32 aVoiceHandle, double aTime);
	public void schedulePause(uint32 aVoiceHandle, double aTime)
	{
		Soloud_schedulePause(objhandle, aVoiceHandle, aTime);
	}

	[CLink]
	private static extern void Soloud_scheduleStop(void* aObjHandle, uint32 aVoiceHandle, double aTime);
	public void scheduleStop(uint32 aVoiceHandle, double aTime)
	{
		Soloud_scheduleStop(objhandle, aVoiceHandle, aTime);
	}

	[CLink]
	private static extern void Soloud_oscillateVolume(void* aObjHandle, uint32 aVoiceHandle, float aFrom, float aTo, double aTime);
	public void oscillateVolume(uint32 aVoiceHandle, float aFrom, float aTo, double aTime)
	{
		Soloud_oscillateVolume(objhandle, aVoiceHandle, aFrom, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_oscillatePan(void* aObjHandle, uint32 aVoiceHandle, float aFrom, float aTo, double aTime);
	public void oscillatePan(uint32 aVoiceHandle, float aFrom, float aTo, double aTime)
	{
		Soloud_oscillatePan(objhandle, aVoiceHandle, aFrom, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_oscillateRelativePlaySpeed(void* aObjHandle, uint32 aVoiceHandle, float aFrom, float aTo, double aTime);
	public void oscillateRelativePlaySpeed(uint32 aVoiceHandle, float aFrom, float aTo, double aTime)
	{
		Soloud_oscillateRelativePlaySpeed(objhandle, aVoiceHandle, aFrom, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_oscillateGlobalVolume(void* aObjHandle, float aFrom, float aTo, double aTime);
	public void oscillateGlobalVolume(float aFrom, float aTo, double aTime)
	{
		Soloud_oscillateGlobalVolume(objhandle, aFrom, aTo, aTime);
	}

	[CLink]
	private static extern void Soloud_setGlobalFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setGlobalFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Soloud_setGlobalFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Soloud_setVisualizationEnable(void* aObjHandle, int32 aEnable);
	public void setVisualizationEnable(int32 aEnable)
	{
		Soloud_setVisualizationEnable(objhandle, aEnable);
	}

	[CLink]
	private static extern float * Soloud_calcFFT(void* aObjHandle);
	public float * calcFFT()
	{
		return Soloud_calcFFT(objhandle);
	}

	[CLink]
	private static extern float * Soloud_getWave(void* aObjHandle);
	public float * getWave()
	{
		return Soloud_getWave(objhandle);
	}

	[CLink]
	private static extern float Soloud_getApproximateVolume(void* aObjHandle, uint32 aChannel);
	public float getApproximateVolume(uint32 aChannel)
	{
		return Soloud_getApproximateVolume(objhandle, aChannel);
	}

	[CLink]
	private static extern uint32 Soloud_getLoopCount(void* aObjHandle, uint32 aVoiceHandle);
	public uint32 getLoopCount(uint32 aVoiceHandle)
	{
		return Soloud_getLoopCount(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float Soloud_getInfo(void* aObjHandle, uint32 aVoiceHandle, uint32 aInfoKey);
	public float getInfo(uint32 aVoiceHandle, uint32 aInfoKey)
	{
		return Soloud_getInfo(objhandle, aVoiceHandle, aInfoKey);
	}

	[CLink]
	private static extern uint32 Soloud_createVoiceGroup(void* aObjHandle);
	public uint32 createVoiceGroup()
	{
		return Soloud_createVoiceGroup(objhandle);
	}

	[CLink]
	private static extern int32 Soloud_destroyVoiceGroup(void* aObjHandle, uint32 aVoiceGroupHandle);
	public int32 destroyVoiceGroup(uint32 aVoiceGroupHandle)
	{
		return Soloud_destroyVoiceGroup(objhandle, aVoiceGroupHandle);
	}

	[CLink]
	private static extern int32 Soloud_addVoiceToGroup(void* aObjHandle, uint32 aVoiceGroupHandle, uint32 aVoiceHandle);
	public int32 addVoiceToGroup(uint32 aVoiceGroupHandle, uint32 aVoiceHandle)
	{
		return Soloud_addVoiceToGroup(objhandle, aVoiceGroupHandle, aVoiceHandle);
	}

	[CLink]
	private static extern int32 Soloud_isVoiceGroup(void* aObjHandle, uint32 aVoiceGroupHandle);
	public int32 isVoiceGroup(uint32 aVoiceGroupHandle)
	{
		return Soloud_isVoiceGroup(objhandle, aVoiceGroupHandle);
	}

	[CLink]
	private static extern int32 Soloud_isVoiceGroupEmpty(void* aObjHandle, uint32 aVoiceGroupHandle);
	public int32 isVoiceGroupEmpty(uint32 aVoiceGroupHandle)
	{
		return Soloud_isVoiceGroupEmpty(objhandle, aVoiceGroupHandle);
	}

	[CLink]
	private static extern void Soloud_update3dAudio(void* aObjHandle);
	public void update3dAudio()
	{
		Soloud_update3dAudio(objhandle);
	}

	[CLink]
	private static extern int32 Soloud_set3dSoundSpeed(void* aObjHandle, float aSpeed);
	public int32 set3dSoundSpeed(float aSpeed)
	{
		return Soloud_set3dSoundSpeed(objhandle, aSpeed);
	}

	[CLink]
	private static extern float Soloud_get3dSoundSpeed(void* aObjHandle);
	public float get3dSoundSpeed()
	{
		return Soloud_get3dSoundSpeed(objhandle);
	}

	[CLink]
	private static extern void Soloud_set3dListenerParametersEx(void* aObjHandle, float aPosX, float aPosY, float aPosZ, float aAtX, float aAtY, float aAtZ, float aUpX, float aUpY, float aUpZ, float aVelocityX, float aVelocityY, float aVelocityZ);
	public void set3dListenerParameters(float aPosX, float aPosY, float aPosZ, float aAtX, float aAtY, float aAtZ, float aUpX, float aUpY, float aUpZ, float aVelocityX = 0.0f, float aVelocityY = 0.0f, float aVelocityZ = 0.0f)
	{
		Soloud_set3dListenerParametersEx(objhandle, aPosX, aPosY, aPosZ, aAtX, aAtY, aAtZ, aUpX, aUpY, aUpZ, aVelocityX, aVelocityY, aVelocityZ);
	}

	[CLink]
	private static extern void Soloud_set3dListenerPosition(void* aObjHandle, float aPosX, float aPosY, float aPosZ);
	public void set3dListenerPosition(float aPosX, float aPosY, float aPosZ)
	{
		Soloud_set3dListenerPosition(objhandle, aPosX, aPosY, aPosZ);
	}

	[CLink]
	private static extern void Soloud_set3dListenerAt(void* aObjHandle, float aAtX, float aAtY, float aAtZ);
	public void set3dListenerAt(float aAtX, float aAtY, float aAtZ)
	{
		Soloud_set3dListenerAt(objhandle, aAtX, aAtY, aAtZ);
	}

	[CLink]
	private static extern void Soloud_set3dListenerUp(void* aObjHandle, float aUpX, float aUpY, float aUpZ);
	public void set3dListenerUp(float aUpX, float aUpY, float aUpZ)
	{
		Soloud_set3dListenerUp(objhandle, aUpX, aUpY, aUpZ);
	}

	[CLink]
	private static extern void Soloud_set3dListenerVelocity(void* aObjHandle, float aVelocityX, float aVelocityY, float aVelocityZ);
	public void set3dListenerVelocity(float aVelocityX, float aVelocityY, float aVelocityZ)
	{
		Soloud_set3dListenerVelocity(objhandle, aVelocityX, aVelocityY, aVelocityZ);
	}

	[CLink]
	private static extern void Soloud_set3dSourceParametersEx(void* aObjHandle, uint32 aVoiceHandle, float aPosX, float aPosY, float aPosZ, float aVelocityX, float aVelocityY, float aVelocityZ);
	public void set3dSourceParameters(uint32 aVoiceHandle, float aPosX, float aPosY, float aPosZ, float aVelocityX = 0.0f, float aVelocityY = 0.0f, float aVelocityZ = 0.0f)
	{
		Soloud_set3dSourceParametersEx(objhandle, aVoiceHandle, aPosX, aPosY, aPosZ, aVelocityX, aVelocityY, aVelocityZ);
	}

	[CLink]
	private static extern void Soloud_set3dSourcePosition(void* aObjHandle, uint32 aVoiceHandle, float aPosX, float aPosY, float aPosZ);
	public void set3dSourcePosition(uint32 aVoiceHandle, float aPosX, float aPosY, float aPosZ)
	{
		Soloud_set3dSourcePosition(objhandle, aVoiceHandle, aPosX, aPosY, aPosZ);
	}

	[CLink]
	private static extern void Soloud_set3dSourceVelocity(void* aObjHandle, uint32 aVoiceHandle, float aVelocityX, float aVelocityY, float aVelocityZ);
	public void set3dSourceVelocity(uint32 aVoiceHandle, float aVelocityX, float aVelocityY, float aVelocityZ)
	{
		Soloud_set3dSourceVelocity(objhandle, aVoiceHandle, aVelocityX, aVelocityY, aVelocityZ);
	}

	[CLink]
	private static extern void Soloud_set3dSourceMinMaxDistance(void* aObjHandle, uint32 aVoiceHandle, float aMinDistance, float aMaxDistance);
	public void set3dSourceMinMaxDistance(uint32 aVoiceHandle, float aMinDistance, float aMaxDistance)
	{
		Soloud_set3dSourceMinMaxDistance(objhandle, aVoiceHandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Soloud_set3dSourceAttenuation(void* aObjHandle, uint32 aVoiceHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dSourceAttenuation(uint32 aVoiceHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Soloud_set3dSourceAttenuation(objhandle, aVoiceHandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Soloud_set3dSourceDopplerFactor(void* aObjHandle, uint32 aVoiceHandle, float aDopplerFactor);
	public void set3dSourceDopplerFactor(uint32 aVoiceHandle, float aDopplerFactor)
	{
		Soloud_set3dSourceDopplerFactor(objhandle, aVoiceHandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Soloud_mix(void* aObjHandle, float * aBuffer, uint32 aSamples);
	public void mix(float * aBuffer, uint32 aSamples)
	{
		Soloud_mix(objhandle, aBuffer, aSamples);
	}

	[CLink]
	private static extern void Soloud_mixSigned16(void* aObjHandle, uint16 * aBuffer, uint32 aSamples);
	public void mixSigned16(uint16 * aBuffer, uint32 aSamples)
	{
		Soloud_mixSigned16(objhandle, aBuffer, aSamples);
	}
}

public class Ay : SoloudObject
{

	[LinkName("Ay_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Ay_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern void Ay_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Ay_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Ay_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Ay_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Ay_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Ay_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Ay_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Ay_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Ay_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Ay_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Ay_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Ay_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Ay_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Ay_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Ay_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Ay_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Ay_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Ay_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Ay_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Ay_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Ay_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Ay_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Ay_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Ay_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Ay_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Ay_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Ay_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Ay_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Ay_stop(void* aObjHandle);
	public void stop()
	{
		Ay_stop(objhandle);
	}
}

public class BassboostFilter : SoloudObject
{
	public const int WET = 0;
	public const int BOOST = 1;

	[LinkName("BassboostFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("BassboostFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 BassboostFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return BassboostFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * BassboostFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return BassboostFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 BassboostFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return BassboostFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float BassboostFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return BassboostFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float BassboostFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return BassboostFilter_getParamMin(objhandle, aParamIndex);
	}

	[CLink]
	private static extern int32 BassboostFilter_setParams(void* aObjHandle, float aBoost);
	public int32 setParams(float aBoost)
	{
		return BassboostFilter_setParams(objhandle, aBoost);
	}
}

public class BiquadResonantFilter : SoloudObject
{
	public const int LOWPASS = 0;
	public const int HIGHPASS = 1;
	public const int BANDPASS = 2;
	public const int WET = 0;
	public const int TYPE = 1;
	public const int FREQUENCY = 2;
	public const int RESONANCE = 3;

	[LinkName("BiquadResonantFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("BiquadResonantFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 BiquadResonantFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return BiquadResonantFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * BiquadResonantFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return BiquadResonantFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 BiquadResonantFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return BiquadResonantFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float BiquadResonantFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return BiquadResonantFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float BiquadResonantFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return BiquadResonantFilter_getParamMin(objhandle, aParamIndex);
	}

	[CLink]
	private static extern int32 BiquadResonantFilter_setParams(void* aObjHandle, int32 aType, float aFrequency, float aResonance);
	public int32 setParams(int32 aType, float aFrequency, float aResonance)
	{
		return BiquadResonantFilter_setParams(objhandle, aType, aFrequency, aResonance);
	}
}

public class Bus : SoloudObject
{

	[LinkName("Bus_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Bus_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern void Bus_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Bus_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern uint32 Bus_playEx(void* aObjHandle, void * aSound, float aVolume, float aPan, int32 aPaused);
	public uint32 play(SoloudObject aSound, float aVolume = 1.0f, float aPan = 0.0f, int32 aPaused = 0)
	{
		return Bus_playEx(objhandle, aSound.objhandle, aVolume, aPan, aPaused);
	}

	[CLink]
	private static extern uint32 Bus_playClockedEx(void* aObjHandle, double aSoundTime, void * aSound, float aVolume, float aPan);
	public uint32 playClocked(double aSoundTime, SoloudObject aSound, float aVolume = 1.0f, float aPan = 0.0f)
	{
		return Bus_playClockedEx(objhandle, aSoundTime, aSound.objhandle, aVolume, aPan);
	}

	[CLink]
	private static extern uint32 Bus_play3dEx(void* aObjHandle, void * aSound, float aPosX, float aPosY, float aPosZ, float aVelX, float aVelY, float aVelZ, float aVolume, int32 aPaused);
	public uint32 play3d(SoloudObject aSound, float aPosX, float aPosY, float aPosZ, float aVelX = 0.0f, float aVelY = 0.0f, float aVelZ = 0.0f, float aVolume = 1.0f, int32 aPaused = 0)
	{
		return Bus_play3dEx(objhandle, aSound.objhandle, aPosX, aPosY, aPosZ, aVelX, aVelY, aVelZ, aVolume, aPaused);
	}

	[CLink]
	private static extern uint32 Bus_play3dClockedEx(void* aObjHandle, double aSoundTime, void * aSound, float aPosX, float aPosY, float aPosZ, float aVelX, float aVelY, float aVelZ, float aVolume);
	public uint32 play3dClocked(double aSoundTime, SoloudObject aSound, float aPosX, float aPosY, float aPosZ, float aVelX = 0.0f, float aVelY = 0.0f, float aVelZ = 0.0f, float aVolume = 1.0f)
	{
		return Bus_play3dClockedEx(objhandle, aSoundTime, aSound.objhandle, aPosX, aPosY, aPosZ, aVelX, aVelY, aVelZ, aVolume);
	}

	[CLink]
	private static extern int32 Bus_setChannels(void* aObjHandle, uint32 aChannels);
	public int32 setChannels(uint32 aChannels)
	{
		return Bus_setChannels(objhandle, aChannels);
	}

	[CLink]
	private static extern void Bus_setVisualizationEnable(void* aObjHandle, int32 aEnable);
	public void setVisualizationEnable(int32 aEnable)
	{
		Bus_setVisualizationEnable(objhandle, aEnable);
	}

	[CLink]
	private static extern void Bus_annexSound(void* aObjHandle, uint32 aVoiceHandle);
	public void annexSound(uint32 aVoiceHandle)
	{
		Bus_annexSound(objhandle, aVoiceHandle);
	}

	[CLink]
	private static extern float * Bus_calcFFT(void* aObjHandle);
	public float * calcFFT()
	{
		return Bus_calcFFT(objhandle);
	}

	[CLink]
	private static extern float * Bus_getWave(void* aObjHandle);
	public float * getWave()
	{
		return Bus_getWave(objhandle);
	}

	[CLink]
	private static extern float Bus_getApproximateVolume(void* aObjHandle, uint32 aChannel);
	public float getApproximateVolume(uint32 aChannel)
	{
		return Bus_getApproximateVolume(objhandle, aChannel);
	}

	[CLink]
	private static extern uint32 Bus_getActiveVoiceCount(void* aObjHandle);
	public uint32 getActiveVoiceCount()
	{
		return Bus_getActiveVoiceCount(objhandle);
	}

	[CLink]
	private static extern uint32 Bus_getResampler(void* aObjHandle);
	public uint32 getResampler()
	{
		return Bus_getResampler(objhandle);
	}

	[CLink]
	private static extern void Bus_setResampler(void* aObjHandle, uint32 aResampler);
	public void setResampler(uint32 aResampler)
	{
		Bus_setResampler(objhandle, aResampler);
	}

	[CLink]
	private static extern void Bus_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Bus_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Bus_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Bus_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Bus_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Bus_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Bus_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Bus_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Bus_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Bus_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Bus_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Bus_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Bus_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Bus_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Bus_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Bus_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Bus_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Bus_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Bus_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Bus_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Bus_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Bus_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Bus_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Bus_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Bus_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Bus_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Bus_stop(void* aObjHandle);
	public void stop()
	{
		Bus_stop(objhandle);
	}
}

public class DCRemovalFilter : SoloudObject
{

	[LinkName("DCRemovalFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("DCRemovalFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 DCRemovalFilter_setParamsEx(void* aObjHandle, float aLength);
	public int32 setParams(float aLength = 0.1f)
	{
		return DCRemovalFilter_setParamsEx(objhandle, aLength);
	}

	[CLink]
	private static extern int32 DCRemovalFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return DCRemovalFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * DCRemovalFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return DCRemovalFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 DCRemovalFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return DCRemovalFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float DCRemovalFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return DCRemovalFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float DCRemovalFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return DCRemovalFilter_getParamMin(objhandle, aParamIndex);
	}
}

public class EchoFilter : SoloudObject
{
	public const int WET = 0;
	public const int DELAY = 1;
	public const int DECAY = 2;
	public const int FILTER = 3;

	[LinkName("EchoFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("EchoFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 EchoFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return EchoFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * EchoFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return EchoFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 EchoFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return EchoFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float EchoFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return EchoFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float EchoFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return EchoFilter_getParamMin(objhandle, aParamIndex);
	}

	[CLink]
	private static extern int32 EchoFilter_setParamsEx(void* aObjHandle, float aDelay, float aDecay, float aFilter);
	public int32 setParams(float aDelay, float aDecay = 0.7f, float aFilter = 0.0f)
	{
		return EchoFilter_setParamsEx(objhandle, aDelay, aDecay, aFilter);
	}
}

public class FFTFilter : SoloudObject
{

	[LinkName("FFTFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("FFTFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 FFTFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return FFTFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * FFTFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return FFTFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 FFTFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return FFTFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float FFTFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return FFTFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float FFTFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return FFTFilter_getParamMin(objhandle, aParamIndex);
	}
}

public class FlangerFilter : SoloudObject
{
	public const int WET = 0;
	public const int DELAY = 1;
	public const int FREQ = 2;

	[LinkName("FlangerFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("FlangerFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 FlangerFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return FlangerFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * FlangerFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return FlangerFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 FlangerFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return FlangerFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float FlangerFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return FlangerFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float FlangerFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return FlangerFilter_getParamMin(objhandle, aParamIndex);
	}

	[CLink]
	private static extern int32 FlangerFilter_setParams(void* aObjHandle, float aDelay, float aFreq);
	public int32 setParams(float aDelay, float aFreq)
	{
		return FlangerFilter_setParams(objhandle, aDelay, aFreq);
	}
}

public class FreeverbFilter : SoloudObject
{
	public const int WET = 0;
	public const int FREEZE = 1;
	public const int ROOMSIZE = 2;
	public const int DAMP = 3;
	public const int WIDTH = 4;

	[LinkName("FreeverbFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("FreeverbFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 FreeverbFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return FreeverbFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * FreeverbFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return FreeverbFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 FreeverbFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return FreeverbFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float FreeverbFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return FreeverbFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float FreeverbFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return FreeverbFilter_getParamMin(objhandle, aParamIndex);
	}

	[CLink]
	private static extern int32 FreeverbFilter_setParams(void* aObjHandle, float aMode, float aRoomSize, float aDamp, float aWidth);
	public int32 setParams(float aMode, float aRoomSize, float aDamp, float aWidth)
	{
		return FreeverbFilter_setParams(objhandle, aMode, aRoomSize, aDamp, aWidth);
	}
}

public class LofiFilter : SoloudObject
{
	public const int WET = 0;
	public const int SAMPLERATE = 1;
	public const int BITDEPTH = 2;

	[LinkName("LofiFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("LofiFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 LofiFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return LofiFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * LofiFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return LofiFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 LofiFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return LofiFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float LofiFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return LofiFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float LofiFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return LofiFilter_getParamMin(objhandle, aParamIndex);
	}

	[CLink]
	private static extern int32 LofiFilter_setParams(void* aObjHandle, float aSampleRate, float aBitdepth);
	public int32 setParams(float aSampleRate, float aBitdepth)
	{
		return LofiFilter_setParams(objhandle, aSampleRate, aBitdepth);
	}
}

public class Monotone : SoloudObject
{

	[LinkName("Monotone_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Monotone_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 Monotone_setParamsEx(void* aObjHandle, int32 aHardwareChannels, int32 aWaveform);
	public int32 setParams(int32 aHardwareChannels, int32 aWaveform = Soloud.WAVE_SQUARE)
	{
		return Monotone_setParamsEx(objhandle, aHardwareChannels, aWaveform);
	}

	[CLink]
	private static extern int32 Monotone_load(void* aObjHandle, char8 * aFilename);
	public int32 load(char8 * aFilename)
	{
		return Monotone_load(objhandle, aFilename);
	}

	[CLink]
	private static extern int32 Monotone_loadMemEx(void* aObjHandle, uint8 * aMem, uint32 aLength, int32 aCopy, int32 aTakeOwnership);
	public int32 loadMem(uint8 * aMem, uint32 aLength, int32 aCopy = 0, int32 aTakeOwnership = 1)
	{
		return Monotone_loadMemEx(objhandle, aMem, aLength, aCopy, aTakeOwnership);
	}

	[CLink]
	private static extern int32 Monotone_loadFile(void* aObjHandle, void * aFile);
	public int32 loadFile(void * aFile)
	{
		return Monotone_loadFile(objhandle, aFile);
	}

	[CLink]
	private static extern void Monotone_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Monotone_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Monotone_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Monotone_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Monotone_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Monotone_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Monotone_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Monotone_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Monotone_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Monotone_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Monotone_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Monotone_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Monotone_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Monotone_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Monotone_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Monotone_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Monotone_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Monotone_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Monotone_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Monotone_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Monotone_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Monotone_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Monotone_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Monotone_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Monotone_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Monotone_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Monotone_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Monotone_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Monotone_stop(void* aObjHandle);
	public void stop()
	{
		Monotone_stop(objhandle);
	}
}

public class Noise : SoloudObject
{
	public const int WHITE = 0;
	public const int PINK = 1;
	public const int BROWNISH = 2;
	public const int BLUEISH = 3;

	[LinkName("Noise_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Noise_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern void Noise_setOctaveScale(void* aObjHandle, float aOct0, float aOct1, float aOct2, float aOct3, float aOct4, float aOct5, float aOct6, float aOct7, float aOct8, float aOct9);
	public void setOctaveScale(float aOct0, float aOct1, float aOct2, float aOct3, float aOct4, float aOct5, float aOct6, float aOct7, float aOct8, float aOct9)
	{
		Noise_setOctaveScale(objhandle, aOct0, aOct1, aOct2, aOct3, aOct4, aOct5, aOct6, aOct7, aOct8, aOct9);
	}

	[CLink]
	private static extern void Noise_setType(void* aObjHandle, int32 aType);
	public void setType(int32 aType)
	{
		Noise_setType(objhandle, aType);
	}

	[CLink]
	private static extern void Noise_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Noise_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Noise_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Noise_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Noise_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Noise_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Noise_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Noise_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Noise_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Noise_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Noise_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Noise_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Noise_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Noise_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Noise_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Noise_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Noise_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Noise_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Noise_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Noise_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Noise_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Noise_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Noise_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Noise_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Noise_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Noise_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Noise_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Noise_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Noise_stop(void* aObjHandle);
	public void stop()
	{
		Noise_stop(objhandle);
	}
}

public class Openmpt : SoloudObject
{

	[LinkName("Openmpt_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Openmpt_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 Openmpt_load(void* aObjHandle, char8 * aFilename);
	public int32 load(char8 * aFilename)
	{
		return Openmpt_load(objhandle, aFilename);
	}

	[CLink]
	private static extern int32 Openmpt_loadMemEx(void* aObjHandle, uint8 * aMem, uint32 aLength, int32 aCopy, int32 aTakeOwnership);
	public int32 loadMem(uint8 * aMem, uint32 aLength, int32 aCopy = 0, int32 aTakeOwnership = 1)
	{
		return Openmpt_loadMemEx(objhandle, aMem, aLength, aCopy, aTakeOwnership);
	}

	[CLink]
	private static extern int32 Openmpt_loadFile(void* aObjHandle, void * aFile);
	public int32 loadFile(void * aFile)
	{
		return Openmpt_loadFile(objhandle, aFile);
	}

	[CLink]
	private static extern void Openmpt_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Openmpt_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Openmpt_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Openmpt_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Openmpt_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Openmpt_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Openmpt_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Openmpt_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Openmpt_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Openmpt_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Openmpt_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Openmpt_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Openmpt_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Openmpt_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Openmpt_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Openmpt_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Openmpt_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Openmpt_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Openmpt_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Openmpt_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Openmpt_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Openmpt_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Openmpt_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Openmpt_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Openmpt_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Openmpt_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Openmpt_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Openmpt_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Openmpt_stop(void* aObjHandle);
	public void stop()
	{
		Openmpt_stop(objhandle);
	}
}

public class Queue : SoloudObject
{

	[LinkName("Queue_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Queue_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 Queue_play(void* aObjHandle, void * aSound);
	public int32 play(SoloudObject aSound)
	{
		return Queue_play(objhandle, aSound.objhandle);
	}

	[CLink]
	private static extern uint32 Queue_getQueueCount(void* aObjHandle);
	public uint32 getQueueCount()
	{
		return Queue_getQueueCount(objhandle);
	}

	[CLink]
	private static extern int32 Queue_isCurrentlyPlaying(void* aObjHandle, void * aSound);
	public int32 isCurrentlyPlaying(SoloudObject aSound)
	{
		return Queue_isCurrentlyPlaying(objhandle, aSound.objhandle);
	}

	[CLink]
	private static extern int32 Queue_setParamsFromAudioSource(void* aObjHandle, void * aSound);
	public int32 setParamsFromAudioSource(SoloudObject aSound)
	{
		return Queue_setParamsFromAudioSource(objhandle, aSound.objhandle);
	}

	[CLink]
	private static extern int32 Queue_setParamsEx(void* aObjHandle, float aSamplerate, uint32 aChannels);
	public int32 setParams(float aSamplerate, uint32 aChannels = 2)
	{
		return Queue_setParamsEx(objhandle, aSamplerate, aChannels);
	}

	[CLink]
	private static extern void Queue_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Queue_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Queue_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Queue_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Queue_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Queue_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Queue_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Queue_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Queue_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Queue_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Queue_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Queue_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Queue_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Queue_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Queue_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Queue_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Queue_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Queue_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Queue_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Queue_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Queue_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Queue_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Queue_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Queue_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Queue_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Queue_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Queue_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Queue_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Queue_stop(void* aObjHandle);
	public void stop()
	{
		Queue_stop(objhandle);
	}
}

public class RobotizeFilter : SoloudObject
{
	public const int WET = 0;
	public const int FREQ = 1;
	public const int WAVE = 2;

	[LinkName("RobotizeFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("RobotizeFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 RobotizeFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return RobotizeFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * RobotizeFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return RobotizeFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 RobotizeFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return RobotizeFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float RobotizeFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return RobotizeFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float RobotizeFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return RobotizeFilter_getParamMin(objhandle, aParamIndex);
	}

	[CLink]
	private static extern void RobotizeFilter_setParams(void* aObjHandle, float aFreq, int32 aWaveform);
	public void setParams(float aFreq, int32 aWaveform)
	{
		RobotizeFilter_setParams(objhandle, aFreq, aWaveform);
	}
}

public class Sfxr : SoloudObject
{
	public const int COIN = 0;
	public const int LASER = 1;
	public const int EXPLOSION = 2;
	public const int POWERUP = 3;
	public const int HURT = 4;
	public const int JUMP = 5;
	public const int BLIP = 6;

	[LinkName("Sfxr_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Sfxr_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern void Sfxr_resetParams(void* aObjHandle);
	public void resetParams()
	{
		Sfxr_resetParams(objhandle);
	}

	[CLink]
	private static extern int32 Sfxr_loadParams(void* aObjHandle, char8 * aFilename);
	public int32 loadParams(char8 * aFilename)
	{
		return Sfxr_loadParams(objhandle, aFilename);
	}

	[CLink]
	private static extern int32 Sfxr_loadParamsMemEx(void* aObjHandle, uint8 * aMem, uint32 aLength, int32 aCopy, int32 aTakeOwnership);
	public int32 loadParamsMem(uint8 * aMem, uint32 aLength, int32 aCopy = 0, int32 aTakeOwnership = 1)
	{
		return Sfxr_loadParamsMemEx(objhandle, aMem, aLength, aCopy, aTakeOwnership);
	}

	[CLink]
	private static extern int32 Sfxr_loadParamsFile(void* aObjHandle, void * aFile);
	public int32 loadParamsFile(void * aFile)
	{
		return Sfxr_loadParamsFile(objhandle, aFile);
	}

	[CLink]
	private static extern int32 Sfxr_loadPreset(void* aObjHandle, int32 aPresetNo, int32 aRandSeed);
	public int32 loadPreset(int32 aPresetNo, int32 aRandSeed)
	{
		return Sfxr_loadPreset(objhandle, aPresetNo, aRandSeed);
	}

	[CLink]
	private static extern void Sfxr_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Sfxr_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Sfxr_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Sfxr_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Sfxr_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Sfxr_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Sfxr_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Sfxr_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Sfxr_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Sfxr_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Sfxr_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Sfxr_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Sfxr_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Sfxr_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Sfxr_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Sfxr_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Sfxr_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Sfxr_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Sfxr_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Sfxr_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Sfxr_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Sfxr_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Sfxr_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Sfxr_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Sfxr_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Sfxr_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Sfxr_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Sfxr_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Sfxr_stop(void* aObjHandle);
	public void stop()
	{
		Sfxr_stop(objhandle);
	}
}

public class Speech : SoloudObject
{
	public const int KW_SAW = 0;
	public const int KW_TRIANGLE = 1;
	public const int KW_SIN = 2;
	public const int KW_SQUARE = 3;
	public const int KW_PULSE = 4;
	public const int KW_NOISE = 5;
	public const int KW_WARBLE = 6;

	[LinkName("Speech_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Speech_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 Speech_setText(void* aObjHandle, char8 * aText);
	public int32 setText(char8 * aText)
	{
		return Speech_setText(objhandle, aText);
	}

	[CLink]
	private static extern int32 Speech_setParamsEx(void* aObjHandle, uint32 aBaseFrequency, float aBaseSpeed, float aBaseDeclination, int32 aBaseWaveform);
	public int32 setParams(uint32 aBaseFrequency = 1330, float aBaseSpeed = 10.0f, float aBaseDeclination = 0.5f, int32 aBaseWaveform = KW_TRIANGLE)
	{
		return Speech_setParamsEx(objhandle, aBaseFrequency, aBaseSpeed, aBaseDeclination, aBaseWaveform);
	}

	[CLink]
	private static extern void Speech_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Speech_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Speech_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Speech_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Speech_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Speech_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Speech_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Speech_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Speech_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Speech_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Speech_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Speech_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Speech_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Speech_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Speech_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Speech_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Speech_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Speech_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Speech_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Speech_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Speech_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Speech_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Speech_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Speech_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Speech_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Speech_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Speech_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Speech_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Speech_stop(void* aObjHandle);
	public void stop()
	{
		Speech_stop(objhandle);
	}
}

public class TedSid : SoloudObject
{

	[LinkName("TedSid_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("TedSid_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 TedSid_load(void* aObjHandle, char8 * aFilename);
	public int32 load(char8 * aFilename)
	{
		return TedSid_load(objhandle, aFilename);
	}

	[CLink]
	private static extern int32 TedSid_loadMemEx(void* aObjHandle, uint8 * aMem, uint32 aLength, int32 aCopy, int32 aTakeOwnership);
	public int32 loadMem(uint8 * aMem, uint32 aLength, int32 aCopy = 0, int32 aTakeOwnership = 1)
	{
		return TedSid_loadMemEx(objhandle, aMem, aLength, aCopy, aTakeOwnership);
	}

	[CLink]
	private static extern int32 TedSid_loadFile(void* aObjHandle, void * aFile);
	public int32 loadFile(void * aFile)
	{
		return TedSid_loadFile(objhandle, aFile);
	}

	[CLink]
	private static extern void TedSid_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		TedSid_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void TedSid_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		TedSid_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void TedSid_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		TedSid_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void TedSid_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		TedSid_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void TedSid_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		TedSid_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void TedSid_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		TedSid_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void TedSid_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		TedSid_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void TedSid_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		TedSid_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void TedSid_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		TedSid_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void TedSid_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		TedSid_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void TedSid_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		TedSid_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void TedSid_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		TedSid_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double TedSid_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return TedSid_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void TedSid_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		TedSid_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void TedSid_stop(void* aObjHandle);
	public void stop()
	{
		TedSid_stop(objhandle);
	}
}

public class Vic : SoloudObject
{
	public const int PAL = 0;
	public const int NTSC = 1;
	public const int BASS = 0;
	public const int ALTO = 1;
	public const int SOPRANO = 2;
	public const int NOISE = 3;
	public const int MAX_REGS = 4;

	[LinkName("Vic_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Vic_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern void Vic_setModel(void* aObjHandle, int32 model);
	public void setModel(int32 model)
	{
		Vic_setModel(objhandle, model);
	}

	[CLink]
	private static extern int32 Vic_getModel(void* aObjHandle);
	public int32 getModel()
	{
		return Vic_getModel(objhandle);
	}

	[CLink]
	private static extern void Vic_setRegister(void* aObjHandle, int32 reg, uint8 value);
	public void setRegister(int32 reg, uint8 value)
	{
		Vic_setRegister(objhandle, reg, value);
	}

	[CLink]
	private static extern uint8 Vic_getRegister(void* aObjHandle, int32 reg);
	public uint8 getRegister(int32 reg)
	{
		return Vic_getRegister(objhandle, reg);
	}

	[CLink]
	private static extern void Vic_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Vic_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Vic_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Vic_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Vic_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Vic_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Vic_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Vic_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Vic_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Vic_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Vic_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Vic_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Vic_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Vic_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Vic_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Vic_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Vic_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Vic_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Vic_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Vic_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Vic_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Vic_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Vic_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Vic_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Vic_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Vic_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Vic_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Vic_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Vic_stop(void* aObjHandle);
	public void stop()
	{
		Vic_stop(objhandle);
	}
}

public class Vizsn : SoloudObject
{

	[LinkName("Vizsn_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Vizsn_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern void Vizsn_setText(void* aObjHandle, char8 * aText);
	public void setText(char8 * aText)
	{
		Vizsn_setText(objhandle, aText);
	}

	[CLink]
	private static extern void Vizsn_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Vizsn_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Vizsn_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Vizsn_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Vizsn_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Vizsn_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Vizsn_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Vizsn_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Vizsn_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Vizsn_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Vizsn_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Vizsn_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Vizsn_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Vizsn_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Vizsn_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Vizsn_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Vizsn_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Vizsn_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Vizsn_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Vizsn_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Vizsn_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Vizsn_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Vizsn_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Vizsn_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Vizsn_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Vizsn_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Vizsn_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Vizsn_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Vizsn_stop(void* aObjHandle);
	public void stop()
	{
		Vizsn_stop(objhandle);
	}
}

public class Wav : SoloudObject
{

	[LinkName("Wav_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("Wav_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 Wav_load(void* aObjHandle, char8 * aFilename);
	public int32 load(char8 * aFilename)
	{
		return Wav_load(objhandle, aFilename);
	}

	[CLink]
	private static extern int32 Wav_loadMemEx(void* aObjHandle, uint8 * aMem, uint32 aLength, int32 aCopy, int32 aTakeOwnership);
	public int32 loadMem(uint8 * aMem, uint32 aLength, int32 aCopy = 0, int32 aTakeOwnership = 1)
	{
		return Wav_loadMemEx(objhandle, aMem, aLength, aCopy, aTakeOwnership);
	}

	[CLink]
	private static extern int32 Wav_loadFile(void* aObjHandle, void * aFile);
	public int32 loadFile(void * aFile)
	{
		return Wav_loadFile(objhandle, aFile);
	}

	[CLink]
	private static extern int32 Wav_loadRawWave8Ex(void* aObjHandle, uint8 * aMem, uint32 aLength, float aSamplerate, uint32 aChannels);
	public int32 loadRawWave8(uint8 * aMem, uint32 aLength, float aSamplerate = 44100.0f, uint32 aChannels = 1)
	{
		return Wav_loadRawWave8Ex(objhandle, aMem, aLength, aSamplerate, aChannels);
	}

	[CLink]
	private static extern int32 Wav_loadRawWave16Ex(void* aObjHandle, uint16 * aMem, uint32 aLength, float aSamplerate, uint32 aChannels);
	public int32 loadRawWave16(uint16 * aMem, uint32 aLength, float aSamplerate = 44100.0f, uint32 aChannels = 1)
	{
		return Wav_loadRawWave16Ex(objhandle, aMem, aLength, aSamplerate, aChannels);
	}

	[CLink]
	private static extern int32 Wav_loadRawWaveEx(void* aObjHandle, float * aMem, uint32 aLength, float aSamplerate, uint32 aChannels, int32 aCopy, int32 aTakeOwnership);
	public int32 loadRawWave(float * aMem, uint32 aLength, float aSamplerate = 44100.0f, uint32 aChannels = 1, int32 aCopy = 0, int32 aTakeOwnership = 1)
	{
		return Wav_loadRawWaveEx(objhandle, aMem, aLength, aSamplerate, aChannels, aCopy, aTakeOwnership);
	}

	[CLink]
	private static extern double Wav_getLength(void* aObjHandle);
	public double getLength()
	{
		return Wav_getLength(objhandle);
	}

	[CLink]
	private static extern void Wav_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		Wav_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void Wav_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		Wav_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void Wav_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		Wav_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void Wav_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		Wav_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void Wav_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		Wav_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void Wav_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		Wav_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void Wav_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		Wav_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void Wav_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		Wav_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void Wav_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		Wav_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void Wav_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		Wav_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void Wav_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		Wav_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void Wav_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		Wav_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double Wav_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return Wav_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void Wav_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		Wav_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void Wav_stop(void* aObjHandle);
	public void stop()
	{
		Wav_stop(objhandle);
	}
}

public class WaveShaperFilter : SoloudObject
{
	public const int WET = 0;
	public const int AMOUNT = 1;

	[LinkName("WaveShaperFilter_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("WaveShaperFilter_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 WaveShaperFilter_setParams(void* aObjHandle, float aAmount);
	public int32 setParams(float aAmount)
	{
		return WaveShaperFilter_setParams(objhandle, aAmount);
	}

	[CLink]
	private static extern int32 WaveShaperFilter_getParamCount(void* aObjHandle);
	public int32 getParamCount()
	{
		return WaveShaperFilter_getParamCount(objhandle);
	}

	[CLink]
	private static extern char8 * WaveShaperFilter_getParamName(void* aObjHandle, uint32 aParamIndex);
	public char8 * getParamName(uint32 aParamIndex)
	{
		return WaveShaperFilter_getParamName(objhandle, aParamIndex);
	}

	[CLink]
	private static extern uint32 WaveShaperFilter_getParamType(void* aObjHandle, uint32 aParamIndex);
	public uint32 getParamType(uint32 aParamIndex)
	{
		return WaveShaperFilter_getParamType(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float WaveShaperFilter_getParamMax(void* aObjHandle, uint32 aParamIndex);
	public float getParamMax(uint32 aParamIndex)
	{
		return WaveShaperFilter_getParamMax(objhandle, aParamIndex);
	}

	[CLink]
	private static extern float WaveShaperFilter_getParamMin(void* aObjHandle, uint32 aParamIndex);
	public float getParamMin(uint32 aParamIndex)
	{
		return WaveShaperFilter_getParamMin(objhandle, aParamIndex);
	}
}

public class WavStream : SoloudObject
{

	[LinkName("WavStream_create")]
	private static extern void* create();
	public this()
	{
		objhandle = create();
	}

	[LinkName("WavStream_destroy")]
	private static extern void* destroy(void* aObjHandle);
	public ~this()
	{
		destroy(objhandle);
	}

	[CLink]
	private static extern int32 WavStream_load(void* aObjHandle, char8 * aFilename);
	public int32 load(char8 * aFilename)
	{
		return WavStream_load(objhandle, aFilename);
	}

	[CLink]
	private static extern int32 WavStream_loadMemEx(void* aObjHandle, uint8 * aData, uint32 aDataLen, int32 aCopy, int32 aTakeOwnership);
	public int32 loadMem(uint8 * aData, uint32 aDataLen, int32 aCopy = 0, int32 aTakeOwnership = 1)
	{
		return WavStream_loadMemEx(objhandle, aData, aDataLen, aCopy, aTakeOwnership);
	}

	[CLink]
	private static extern int32 WavStream_loadToMem(void* aObjHandle, char8 * aFilename);
	public int32 loadToMem(char8 * aFilename)
	{
		return WavStream_loadToMem(objhandle, aFilename);
	}

	[CLink]
	private static extern int32 WavStream_loadFile(void* aObjHandle, void * aFile);
	public int32 loadFile(void * aFile)
	{
		return WavStream_loadFile(objhandle, aFile);
	}

	[CLink]
	private static extern int32 WavStream_loadFileToMem(void* aObjHandle, void * aFile);
	public int32 loadFileToMem(void * aFile)
	{
		return WavStream_loadFileToMem(objhandle, aFile);
	}

	[CLink]
	private static extern double WavStream_getLength(void* aObjHandle);
	public double getLength()
	{
		return WavStream_getLength(objhandle);
	}

	[CLink]
	private static extern void WavStream_setVolume(void* aObjHandle, float aVolume);
	public void setVolume(float aVolume)
	{
		WavStream_setVolume(objhandle, aVolume);
	}

	[CLink]
	private static extern void WavStream_setLooping(void* aObjHandle, int32 aLoop);
	public void setLooping(int32 aLoop)
	{
		WavStream_setLooping(objhandle, aLoop);
	}

	[CLink]
	private static extern void WavStream_setAutoStop(void* aObjHandle, int32 aAutoStop);
	public void setAutoStop(int32 aAutoStop)
	{
		WavStream_setAutoStop(objhandle, aAutoStop);
	}

	[CLink]
	private static extern void WavStream_set3dMinMaxDistance(void* aObjHandle, float aMinDistance, float aMaxDistance);
	public void set3dMinMaxDistance(float aMinDistance, float aMaxDistance)
	{
		WavStream_set3dMinMaxDistance(objhandle, aMinDistance, aMaxDistance);
	}

	[CLink]
	private static extern void WavStream_set3dAttenuation(void* aObjHandle, uint32 aAttenuationModel, float aAttenuationRolloffFactor);
	public void set3dAttenuation(uint32 aAttenuationModel, float aAttenuationRolloffFactor)
	{
		WavStream_set3dAttenuation(objhandle, aAttenuationModel, aAttenuationRolloffFactor);
	}

	[CLink]
	private static extern void WavStream_set3dDopplerFactor(void* aObjHandle, float aDopplerFactor);
	public void set3dDopplerFactor(float aDopplerFactor)
	{
		WavStream_set3dDopplerFactor(objhandle, aDopplerFactor);
	}

	[CLink]
	private static extern void WavStream_set3dListenerRelative(void* aObjHandle, int32 aListenerRelative);
	public void set3dListenerRelative(int32 aListenerRelative)
	{
		WavStream_set3dListenerRelative(objhandle, aListenerRelative);
	}

	[CLink]
	private static extern void WavStream_set3dDistanceDelay(void* aObjHandle, int32 aDistanceDelay);
	public void set3dDistanceDelay(int32 aDistanceDelay)
	{
		WavStream_set3dDistanceDelay(objhandle, aDistanceDelay);
	}

	[CLink]
	private static extern void WavStream_set3dColliderEx(void* aObjHandle, void * aCollider, int32 aUserData);
	public void set3dCollider(SoloudObject aCollider, int32 aUserData = 0)
	{
		WavStream_set3dColliderEx(objhandle, aCollider.objhandle, aUserData);
	}

	[CLink]
	private static extern void WavStream_set3dAttenuator(void* aObjHandle, void * aAttenuator);
	public void set3dAttenuator(SoloudObject aAttenuator)
	{
		WavStream_set3dAttenuator(objhandle, aAttenuator.objhandle);
	}

	[CLink]
	private static extern void WavStream_setInaudibleBehavior(void* aObjHandle, int32 aMustTick, int32 aKill);
	public void setInaudibleBehavior(int32 aMustTick, int32 aKill)
	{
		WavStream_setInaudibleBehavior(objhandle, aMustTick, aKill);
	}

	[CLink]
	private static extern void WavStream_setLoopPoint(void* aObjHandle, double aLoopPoint);
	public void setLoopPoint(double aLoopPoint)
	{
		WavStream_setLoopPoint(objhandle, aLoopPoint);
	}

	[CLink]
	private static extern double WavStream_getLoopPoint(void* aObjHandle);
	public double getLoopPoint()
	{
		return WavStream_getLoopPoint(objhandle);
	}

	[CLink]
	private static extern void WavStream_setFilter(void* aObjHandle, uint32 aFilterId, void * aFilter);
	public void setFilter(uint32 aFilterId, SoloudObject aFilter)
	{
		WavStream_setFilter(objhandle, aFilterId, aFilter.objhandle);
	}

	[CLink]
	private static extern void WavStream_stop(void* aObjHandle);
	public void stop()
	{
		WavStream_stop(objhandle);
	}
}
}
