Mergul
cb7609dcaa
*added ImGUI styles *added new assets (fonts, shaders) *added cimgui.dll *added imports for bindbc-sdl (for WASM) *added simple demo *added demo launcher *added snake demo *impoved demo utils *added cimgui.bc library for WASM -improved wasm build script -small change in vector
569 lines
No EOL
23 KiB
D
569 lines
No EOL
23 KiB
D
|
|
// Copyright Michael D. Parker 2018.
|
|
// Distributed under the Boost Software License, Version 1.0.
|
|
// (See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
module bindbc.sdl.mixer;
|
|
|
|
version(BindSDL_Mixer):
|
|
|
|
import bindbc.sdl.config;
|
|
import bindbc.sdl.bind.sdlaudio : AUDIO_S16LSB, SDL_MIX_MAXVOLUME;
|
|
import bindbc.sdl.bind.sdlerror : SDL_GetError, SDL_SetError, SDL_ClearError;
|
|
import bindbc.sdl.bind.sdlrwops : SDL_RWops, SDL_RWFromFile;
|
|
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
|
|
import bindbc.sdl.bind.sdlversion : SDL_version, SDL_VERSIONNUM;
|
|
|
|
alias Mix_SetError = SDL_SetError;
|
|
alias Mix_GetError = SDL_GetError;
|
|
alias Mix_ClearError = SDL_ClearError;
|
|
|
|
enum SDLMixerSupport {
|
|
noLibrary,
|
|
badLibrary,
|
|
sdlMixer200 = 200,
|
|
sdlMixer201 = 201,
|
|
sdlMixer202 = 202,
|
|
}
|
|
|
|
enum ubyte SDL_MIXER_MAJOR_VERSION = 2;
|
|
enum ubyte SDL_MIXER_MINOR_VERSION = 0;
|
|
|
|
version(SDL_Mixer_202) {
|
|
enum sdlMixerSupport = SDLMixerSupport.sdlMixer202;
|
|
enum ubyte SDL_MIXER_PATCHLEVEL = 2;
|
|
}
|
|
else version(SDL_Mixer_201) {
|
|
enum sdlMixerSupport = SDLMixerSupport.sdlMixer201;
|
|
enum ubyte SDL_MIXER_PATCHLEVEL = 1;
|
|
}
|
|
else {
|
|
enum sdlMixerSupport = SDLMixerSupport.sdlMixer200;
|
|
enum ubyte SDL_MIXER_PATCHLEVEL = 0;
|
|
}
|
|
|
|
alias MIX_MAJOR_VERSION = SDL_MIXER_MAJOR_VERSION;
|
|
alias MIX_MINOR_VERSION = SDL_MIXER_MINOR_VERSION;
|
|
alias MIX_PATCH_LEVEL = SDL_MIXER_PATCHLEVEL;
|
|
|
|
@nogc nothrow void SDL_MIXER_VERSION(SDL_version* X)
|
|
{
|
|
X.major = SDL_MIXER_MAJOR_VERSION;
|
|
X.minor = SDL_MIXER_MINOR_VERSION;
|
|
X.patch = SDL_MIXER_PATCHLEVEL;
|
|
}
|
|
alias SDL_MIX_VERSION = SDL_MIX_MAXVOLUME;
|
|
|
|
// These were implemented in SDL_mixer 2.0.2, but are fine for all versions.
|
|
enum SDL_MIXER_COMPILEDVERSION = SDL_VERSIONNUM!(SDL_MIXER_MAJOR_VERSION, SDL_MIXER_MINOR_VERSION, SDL_MIXER_PATCHLEVEL);
|
|
enum SDL_MIXER_VERSION_ATLEAST(ubyte X, ubyte Y, ubyte Z) = SDL_MIXER_COMPILEDVERSION >= SDL_VERSIONNUM!(X, Y, Z);
|
|
|
|
static if(sdlMixerSupport >= SDLMixerSupport.sdlMixer202) {
|
|
enum Mix_InitFlags {
|
|
MIX_INIT_FLAC = 0x00000001,
|
|
MIX_INIT_MOD = 0x00000002,
|
|
MIX_INIT_MP3 = 0x00000008,
|
|
MIX_INIT_OGG = 0x00000010,
|
|
MIX_INIT_MID = 0x00000020,
|
|
}
|
|
}
|
|
else {
|
|
enum Mix_InitFlags {
|
|
MIX_INIT_FLAC = 0x00000001,
|
|
MIX_INIT_MOD = 0x00000002,
|
|
MIX_INIT_MODPLUG = 0x00000004,
|
|
MIX_INIT_MP3 = 0x00000008,
|
|
MIX_INIT_OGG = 0x00000010,
|
|
MIX_INIT_FLUIDSYNTH = 0x00000020,
|
|
}
|
|
}
|
|
mixin(expandEnum!Mix_InitFlags);
|
|
|
|
enum {
|
|
MIX_CHANNELS = 8,
|
|
MIX_DEFAULT_FREQUENCY = 22050,
|
|
MIX_DEFAULT_CHANNELS = 2,
|
|
MIX_MAX_VOLUME = 128,
|
|
MIX_CHANNEL_POST = -2,
|
|
}
|
|
|
|
version(LittleEndian) {
|
|
enum MIX_DEFAULT_FORMAT = AUDIO_S16LSB;
|
|
} else {
|
|
enum MIX_DEFAULT_FORMAT = AUDIO_S16MSB;
|
|
}
|
|
|
|
struct Mix_Chunk {
|
|
int allocated;
|
|
ubyte* abuf;
|
|
uint alen;
|
|
ubyte volume;
|
|
}
|
|
|
|
enum Mix_Fading {
|
|
MIX_NO_FADING,
|
|
MIX_FADING_OUT,
|
|
MIX_FADING_IN
|
|
}
|
|
mixin(expandEnum!Mix_Fading);
|
|
|
|
static if(sdlMixerSupport >= SDLMixerSupport.sdlMixer202) {
|
|
enum Mix_MusicType {
|
|
MUS_NONE,
|
|
MUS_CMD,
|
|
MUS_WAV,
|
|
MUS_MOD,
|
|
MUS_MID,
|
|
MUS_OGG,
|
|
MUS_MP3,
|
|
MUS_MP3_MAD_UNUSED,
|
|
MUS_FLAC,
|
|
MUS_MODPLUG_UNUSED,
|
|
}
|
|
}
|
|
else {
|
|
enum Mix_MusicType {
|
|
MUS_NONE,
|
|
MUS_CMD,
|
|
MUS_WAV,
|
|
MUS_MOD,
|
|
MUS_MID,
|
|
MUS_OGG,
|
|
MUS_MP3,
|
|
MUS_MP3_MAD,
|
|
MUS_FLAC,
|
|
MUS_MODPLUG,
|
|
}
|
|
}
|
|
mixin(expandEnum!Mix_MusicType);
|
|
|
|
struct Mix_Music;
|
|
enum MIX_EFFECTSMAXSPEED = "MIX_EFFECTSMAXSPEED";
|
|
|
|
extern(C) nothrow {
|
|
alias Mix_EffectFunc_t = void function(int,void*,int,void*);
|
|
alias Mix_EffectDone_t = void function(int,void*);
|
|
|
|
// These aren't in SDL_mixer.h and are just here as a convenient and
|
|
// visible means to add the proper attributes these callbacks.
|
|
alias callbackI = void function(int);
|
|
alias callbackVUi8I = void function(void*,ubyte*,int);
|
|
alias callbackN = void function();
|
|
}
|
|
|
|
@nogc nothrow {
|
|
Mix_Chunk* Mix_LoadWAV(const(char)* file) {
|
|
pragma(inline, true);
|
|
return Mix_LoadWAV_RW(SDL_RWFromFile(file,"rb"),1);
|
|
}
|
|
|
|
int Mix_PlayChannel(int channel,Mix_Chunk* chunk,int loops) {
|
|
pragma(inline, true);
|
|
return Mix_PlayChannelTimed(channel,chunk,loops,-1);
|
|
}
|
|
|
|
int Mix_FadeInChannel(int channel,Mix_Chunk* chunk,int loops,int ms) {
|
|
pragma(inline, true);
|
|
return Mix_FadeInChannelTimed(channel,chunk,loops,ms,-1);
|
|
}
|
|
}
|
|
|
|
version(BindSDL_Static) {
|
|
extern(C) @nogc nothrow {
|
|
const(SDL_version)* Mix_Linked_Version();
|
|
int Mix_Init(int);
|
|
void Mix_Quit();
|
|
int Mix_OpenAudio(int,ushort,int,int);
|
|
int Mix_AllocateChannels(int);
|
|
int Mix_QuerySpec(int*,ushort*,int*);
|
|
Mix_Chunk* Mix_LoadWAV_RW(SDL_RWops*,int);
|
|
Mix_Music* Mix_LoadMUS(const(char)*);
|
|
Mix_Music* Mix_LoadMUS_RW(SDL_RWops*,int);
|
|
Mix_Music* Mix_LoadMUSType_RW(SDL_RWops*,Mix_MusicType,int);
|
|
Mix_Chunk* Mix_QuickLoad_WAV(ubyte*);
|
|
Mix_Chunk* Mix_QuickLoad_RAW(ubyte*,uint);
|
|
void Mix_FreeChunk(Mix_Chunk*);
|
|
void Mix_FreeMusic(Mix_Music*);
|
|
int Mix_GetNumChunkDecoders();
|
|
const(char)* Mix_GetChunkDecoder(int);
|
|
int Mix_GetNumMusicDecoders();
|
|
const(char)* Mix_GetMusicDecoder(int);
|
|
Mix_MusicType Mix_GetMusicType(const(Mix_Music)*);
|
|
void Mix_SetPostMix(callbackVUi8I,void*);
|
|
void Mix_HookMusic(callbackVUi8I,void*);
|
|
void Mix_HookMusicFinished(callbackN);
|
|
void* Mix_GetMusicHookData();
|
|
void Mix_ChannelFinished(callbackI);
|
|
int Mix_RegisterEffect(int,Mix_EffectFunc_t,Mix_EffectDone_t,void*);
|
|
int Mix_UnregisterEffect(int,Mix_EffectFunc_t);
|
|
int Mix_UnregisterAllEffects(int);
|
|
int Mix_SetPanning(int,ubyte,ubyte);
|
|
int Mix_SetPosition(int,short,ubyte);
|
|
int Mix_SetDistance(int,ubyte);
|
|
int Mix_SetReverseStereo(int,int);
|
|
int Mix_ReserveChannels(int);
|
|
int Mix_GroupChannel(int,int);
|
|
int Mix_GroupChannels(int,int,int);
|
|
int Mix_GroupAvailable(int);
|
|
int Mix_GroupCount(int);
|
|
int Mix_GroupOldest(int);
|
|
int Mix_GroupNewer(int);
|
|
int Mix_PlayChannelTimed(int,Mix_Chunk*,int,int);
|
|
int Mix_PlayMusic(Mix_Music*,int);
|
|
int Mix_FadeInMusic(Mix_Music*,int,int);
|
|
int Mix_FadeInMusicPos(Mix_Music*,int,int,double);
|
|
int Mix_FadeInChannelTimed(int,Mix_Chunk*,int,int,int);
|
|
int Mix_Volume(int,int);
|
|
int Mix_VolumeChunk(Mix_Chunk*,int);
|
|
int Mix_VolumeMusic(int);
|
|
int Mix_HaltChannel(int);
|
|
int Mix_HaltGroup(int);
|
|
int Mix_HaltMusic();
|
|
int Mix_ExpireChannel(int,int);
|
|
int Mix_FadeOutChannel(int,int);
|
|
int Mix_FadeOutGroup(int,int);
|
|
int Mix_FadeOutMusic(int);
|
|
Mix_Fading Mix_FadingMusic();
|
|
Mix_Fading Mix_FadingChannel(int);
|
|
void Mix_Pause(int);
|
|
void Mix_Resume(int);
|
|
int Mix_Paused(int);
|
|
void Mix_PauseMusic();
|
|
void Mix_ResumeMusic();
|
|
void Mix_RewindMusic();
|
|
int Mix_PausedMusic();
|
|
int Mix_SetMusicPosition(double);
|
|
int Mix_Playing(int);
|
|
int Mix_PlayingMusic();
|
|
int Mix_SetMusicCMD(in char*);
|
|
int Mix_SetSynchroValue(int);
|
|
int Mix_GetSynchroValue();
|
|
Mix_Chunk* Mix_GetChunk(int);
|
|
void Mix_CloseAudio();
|
|
|
|
static if(sdlMixerSupport >= SDLMixerSupport.sdlMixer202) {
|
|
int Mix_OpenAudioDevice(int,ushort,int,int,const(char)*,int);
|
|
SDL_bool Mix_HasChunkDecoder(const(char)*);
|
|
|
|
// Declared in SDL_mixer.h, but not implemented
|
|
// SDL_bool Mix_HasMusicDecoder(const(char)*);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
import bindbc.loader;
|
|
|
|
extern(C) @nogc nothrow {
|
|
alias pMix_Linked_Version = const(SDL_version)* function();
|
|
alias pMix_Init = int function(int);
|
|
alias pMix_Quit = void function();
|
|
alias pMix_OpenAudio = int function(int,ushort,int,int);
|
|
alias pMix_AllocateChannels = int function(int);
|
|
alias pMix_QuerySpec = int function(int*,ushort*,int*);
|
|
alias pMix_LoadWAV_RW = Mix_Chunk* function(SDL_RWops*,int);
|
|
alias pMix_LoadMUS = Mix_Music* function(const(char)*);
|
|
alias pMix_LoadMUS_RW = Mix_Music* function(SDL_RWops*,int);
|
|
alias pMix_LoadMUSType_RW = Mix_Music* function(SDL_RWops*,Mix_MusicType,int);
|
|
alias pMix_QuickLoad_WAV = Mix_Chunk* function(ubyte*);
|
|
alias pMix_QuickLoad_RAW = Mix_Chunk* function(ubyte*,uint);
|
|
alias pMix_FreeChunk = void function(Mix_Chunk*);
|
|
alias pMix_FreeMusic = void function(Mix_Music*);
|
|
alias pMix_GetNumChunkDecoders = int function();
|
|
alias pMix_GetChunkDecoder = const(char)* function(int);
|
|
alias pMix_GetNumMusicDecoders = int function();
|
|
alias pMix_GetMusicDecoder = const(char)* function(int);
|
|
alias pMix_GetMusicType = Mix_MusicType function(const(Mix_Music)*);
|
|
alias pMix_SetPostMix = void function(callbackVUi8I,void*);
|
|
alias pMix_HookMusic = void function(callbackVUi8I,void*);
|
|
alias pMix_HookMusicFinished = void function(callbackN);
|
|
alias pMix_GetMusicHookData = void* function();
|
|
alias pMix_ChannelFinished = void function(callbackI);
|
|
alias pMix_RegisterEffect = int function(int,Mix_EffectFunc_t,Mix_EffectDone_t,void*);
|
|
alias pMix_UnregisterEffect = int function(int,Mix_EffectFunc_t);
|
|
alias pMix_UnregisterAllEffects = int function(int);
|
|
alias pMix_SetPanning = int function(int,ubyte,ubyte);
|
|
alias pMix_SetPosition = int function(int,short,ubyte);
|
|
alias pMix_SetDistance = int function(int,ubyte);
|
|
alias pMix_SetReverseStereo = int function(int,int);
|
|
alias pMix_ReserveChannels = int function(int);
|
|
alias pMix_GroupChannel = int function(int,int);
|
|
alias pMix_GroupChannels = int function(int,int,int);
|
|
alias pMix_GroupAvailable = int function(int);
|
|
alias pMix_GroupCount = int function(int);
|
|
alias pMix_GroupOldest = int function(int);
|
|
alias pMix_GroupNewer = int function(int);
|
|
alias pMix_PlayChannelTimed = int function(int,Mix_Chunk*,int,int);
|
|
alias pMix_PlayMusic = int function(Mix_Music*,int);
|
|
alias pMix_FadeInMusic = int function(Mix_Music*,int,int);
|
|
alias pMix_FadeInMusicPos = int function(Mix_Music*,int,int,double);
|
|
alias pMix_FadeInChannelTimed = int function(int,Mix_Chunk*,int,int,int);
|
|
alias pMix_Volume = int function(int,int);
|
|
alias pMix_VolumeChunk = int function(Mix_Chunk*,int);
|
|
alias pMix_VolumeMusic = int function(int);
|
|
alias pMix_HaltChannel = int function(int);
|
|
alias pMix_HaltGroup = int function(int);
|
|
alias pMix_HaltMusic = int function();
|
|
alias pMix_ExpireChannel = int function(int,int);
|
|
alias pMix_FadeOutChannel = int function(int,int);
|
|
alias pMix_FadeOutGroup = int function(int,int);
|
|
alias pMix_FadeOutMusic = int function(int);
|
|
alias pMix_FadingMusic = Mix_Fading function();
|
|
alias pMix_FadingChannel = Mix_Fading function(int);
|
|
alias pMix_Pause = void function(int);
|
|
alias pMix_Resume = void function(int);
|
|
alias pMix_Paused = int function(int);
|
|
alias pMix_PauseMusic = void function();
|
|
alias pMix_ResumeMusic = void function();
|
|
alias pMix_RewindMusic = void function();
|
|
alias pMix_PausedMusic = int function();
|
|
alias pMix_SetMusicPosition = int function(double);
|
|
alias pMix_Playing = int function(int);
|
|
alias pMix_PlayingMusic = int function();
|
|
alias pMix_SetMusicCMD = int function(in char*);
|
|
alias pMix_SetSynchroValue = int function(int);
|
|
alias pMix_GetSynchroValue = int function();
|
|
alias pMix_GetChunk = Mix_Chunk* function(int);
|
|
alias pMix_CloseAudio = void function();
|
|
}
|
|
|
|
__gshared {
|
|
pMix_Linked_Version Mix_Linked_Version;
|
|
pMix_Init Mix_Init;
|
|
pMix_Quit Mix_Quit;
|
|
pMix_OpenAudio Mix_OpenAudio;
|
|
pMix_AllocateChannels Mix_AllocateChannels;
|
|
pMix_QuerySpec Mix_QuerySpec;
|
|
pMix_LoadWAV_RW Mix_LoadWAV_RW;
|
|
pMix_LoadMUS Mix_LoadMUS;
|
|
pMix_LoadMUS_RW Mix_LoadMUS_RW;
|
|
pMix_LoadMUSType_RW Mix_LoadMUSType_RW;
|
|
pMix_QuickLoad_WAV Mix_QuickLoad_WAV;
|
|
pMix_QuickLoad_RAW Mix_QuickLoad_RAW;
|
|
pMix_FreeChunk Mix_FreeChunk;
|
|
pMix_FreeMusic Mix_FreeMusic;
|
|
pMix_GetNumChunkDecoders Mix_GetNumChunkDecoders;
|
|
pMix_GetChunkDecoder Mix_GetChunkDecoder;
|
|
pMix_GetNumMusicDecoders Mix_GetNumMusicDecoders;
|
|
pMix_GetMusicDecoder Mix_GetMusicDecoder;
|
|
pMix_GetMusicType Mix_GetMusicType;
|
|
pMix_SetPostMix Mix_SetPostMix;
|
|
pMix_HookMusic Mix_HookMusic;
|
|
pMix_HookMusicFinished Mix_HookMusicFinished;
|
|
pMix_GetMusicHookData Mix_GetMusicHookData;
|
|
pMix_ChannelFinished Mix_ChannelFinished;
|
|
pMix_RegisterEffect Mix_RegisterEffect;
|
|
pMix_UnregisterEffect Mix_UnregisterEffect;
|
|
pMix_UnregisterAllEffects Mix_UnregisterAllEffects;
|
|
pMix_SetPanning Mix_SetPanning;
|
|
pMix_SetPosition Mix_SetPosition;
|
|
pMix_SetDistance Mix_SetDistance;
|
|
pMix_SetReverseStereo Mix_SetReverseStereo;
|
|
pMix_ReserveChannels Mix_ReserveChannels;
|
|
pMix_GroupChannel Mix_GroupChannel;
|
|
pMix_GroupChannels Mix_GroupChannels;
|
|
pMix_GroupAvailable Mix_GroupAvailable;
|
|
pMix_GroupCount Mix_GroupCount;
|
|
pMix_GroupOldest Mix_GroupOldest;
|
|
pMix_GroupNewer Mix_GroupNewer;
|
|
pMix_PlayChannelTimed Mix_PlayChannelTimed;
|
|
pMix_PlayMusic Mix_PlayMusic;
|
|
pMix_FadeInMusic Mix_FadeInMusic;
|
|
pMix_FadeInMusicPos Mix_FadeInMusicPos;
|
|
pMix_FadeInChannelTimed Mix_FadeInChannelTimed;
|
|
pMix_Volume Mix_Volume;
|
|
pMix_VolumeChunk Mix_VolumeChunk;
|
|
pMix_VolumeMusic Mix_VolumeMusic;
|
|
pMix_HaltChannel Mix_HaltChannel;
|
|
pMix_HaltGroup Mix_HaltGroup;
|
|
pMix_HaltMusic Mix_HaltMusic;
|
|
pMix_ExpireChannel Mix_ExpireChannel;
|
|
pMix_FadeOutChannel Mix_FadeOutChannel;
|
|
pMix_FadeOutGroup Mix_FadeOutGroup;
|
|
pMix_FadeOutMusic Mix_FadeOutMusic;
|
|
pMix_FadingMusic Mix_FadingMusic;
|
|
pMix_FadingChannel Mix_FadingChannel;
|
|
pMix_Pause Mix_Pause;
|
|
pMix_Resume Mix_Resume;
|
|
pMix_Paused Mix_Paused;
|
|
pMix_PauseMusic Mix_PauseMusic;
|
|
pMix_ResumeMusic Mix_ResumeMusic;
|
|
pMix_RewindMusic Mix_RewindMusic;
|
|
pMix_PausedMusic Mix_PausedMusic;
|
|
pMix_SetMusicPosition Mix_SetMusicPosition;
|
|
pMix_Playing Mix_Playing;
|
|
pMix_PlayingMusic Mix_PlayingMusic;
|
|
pMix_SetMusicCMD Mix_SetMusicCMD;
|
|
pMix_SetSynchroValue Mix_SetSynchroValue;
|
|
pMix_GetSynchroValue Mix_GetSynchroValue;
|
|
pMix_GetChunk Mix_GetChunk;
|
|
pMix_CloseAudio Mix_CloseAudio;
|
|
}
|
|
|
|
|
|
static if(sdlMixerSupport >= SDLMixerSupport.sdlMixer202) {
|
|
extern(C) @nogc nothrow {
|
|
alias pMix_OpenAudioDevice = int function(int,ushort,int,int,const(char)*,int);
|
|
alias pMix_HasChunkDecoder = SDL_bool function(const(char)*);
|
|
|
|
// Declared in SDL_mixer.h, but not implemented
|
|
//alias pMix_HasMusicDecoder = SDL_bool function(const(char)*);
|
|
}
|
|
|
|
__gshared {
|
|
pMix_OpenAudioDevice Mix_OpenAudioDevice;
|
|
pMix_HasChunkDecoder Mix_HasChunkDecoder;
|
|
//pMix_HasMusicDecoder Mix_HasMusicDecoder;
|
|
}
|
|
}
|
|
|
|
private {
|
|
SharedLib lib;
|
|
SDLMixerSupport loadedVersion;
|
|
}
|
|
|
|
void unloadSDLMixer()
|
|
{
|
|
if(lib != invalidHandle) {
|
|
lib.unload();
|
|
}
|
|
}
|
|
|
|
SDLMixerSupport loadedSDLMixerVersion() { return loadedVersion; }
|
|
|
|
bool isSDLMixerLoaded()
|
|
{
|
|
return lib != invalidHandle;
|
|
}
|
|
|
|
|
|
SDLMixerSupport loadSDLMixer()
|
|
{
|
|
version(Windows) {
|
|
const(char)[][1] libNames = ["SDL2_mixer.dll"];
|
|
}
|
|
else version(OSX) {
|
|
const(char)[][6] libNames = [
|
|
"libSDL2_mixer.dylib",
|
|
"/usr/local/lib/libSDL2_mixer.dylib",
|
|
"../Frameworks/SDL2_mixer.framework/SDL2_mixer",
|
|
"/Library/Frameworks/SDL2_mixer.framework/SDL2_mixer",
|
|
"/System/Library/Frameworks/SDL2_mixer.framework/SDL2_mixer",
|
|
"/opt/local/lib/libSDL2_mixer.dylib"
|
|
];
|
|
}
|
|
else version(Posix) {
|
|
const(char)[][6] libNames = [
|
|
"libSDL2_mixer.so",
|
|
"/usr/local/lib/libSDL2_mixer.so",
|
|
"libSDL2-2.0_mixer.so",
|
|
"/usr/local/lib/libSDL2-2.0_mixer.so",
|
|
"libSDL2-2.0_mixer.so.0",
|
|
"/usr/local/lib/libSDL2-2.0_mixer.so.0"
|
|
];
|
|
}
|
|
else static assert(0, "bindbc-sdl is not yet supported on this platform.");
|
|
|
|
SDLMixerSupport ret;
|
|
foreach(name; libNames) {
|
|
ret = loadSDLMixer(name.ptr);
|
|
if(ret != SDLMixerSupport.noLibrary) break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
SDLMixerSupport loadSDLMixer(const(char)* libName)
|
|
{
|
|
lib = load(libName);
|
|
if(lib == invalidHandle) {
|
|
return SDLMixerSupport.noLibrary;
|
|
}
|
|
|
|
auto errCount = errorCount();
|
|
loadedVersion = SDLMixerSupport.badLibrary;
|
|
|
|
lib.bindSymbol(cast(void**)&Mix_Linked_Version,"Mix_Linked_Version");
|
|
lib.bindSymbol(cast(void**)&Mix_Init,"Mix_Init");
|
|
lib.bindSymbol(cast(void**)&Mix_Quit,"Mix_Quit");
|
|
lib.bindSymbol(cast(void**)&Mix_OpenAudio,"Mix_OpenAudio");
|
|
lib.bindSymbol(cast(void**)&Mix_AllocateChannels,"Mix_AllocateChannels");
|
|
lib.bindSymbol(cast(void**)&Mix_QuerySpec,"Mix_QuerySpec");
|
|
lib.bindSymbol(cast(void**)&Mix_LoadWAV_RW,"Mix_LoadWAV_RW");
|
|
lib.bindSymbol(cast(void**)&Mix_LoadMUS,"Mix_LoadMUS");
|
|
lib.bindSymbol(cast(void**)&Mix_LoadMUS_RW,"Mix_LoadMUS_RW");
|
|
lib.bindSymbol(cast(void**)&Mix_LoadMUSType_RW,"Mix_LoadMUSType_RW");
|
|
lib.bindSymbol(cast(void**)&Mix_QuickLoad_WAV,"Mix_QuickLoad_WAV");
|
|
lib.bindSymbol(cast(void**)&Mix_QuickLoad_RAW,"Mix_QuickLoad_RAW");
|
|
lib.bindSymbol(cast(void**)&Mix_FreeChunk,"Mix_FreeChunk");
|
|
lib.bindSymbol(cast(void**)&Mix_FreeMusic,"Mix_FreeMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_GetNumChunkDecoders,"Mix_GetNumChunkDecoders");
|
|
lib.bindSymbol(cast(void**)&Mix_GetChunkDecoder,"Mix_GetChunkDecoder");
|
|
lib.bindSymbol(cast(void**)&Mix_GetNumMusicDecoders,"Mix_GetNumMusicDecoders");
|
|
lib.bindSymbol(cast(void**)&Mix_GetMusicDecoder,"Mix_GetMusicDecoder");
|
|
lib.bindSymbol(cast(void**)&Mix_GetMusicType,"Mix_GetMusicType");
|
|
lib.bindSymbol(cast(void**)&Mix_SetPostMix,"Mix_SetPostMix");
|
|
lib.bindSymbol(cast(void**)&Mix_HookMusic,"Mix_HookMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_HookMusicFinished,"Mix_HookMusicFinished");
|
|
lib.bindSymbol(cast(void**)&Mix_GetMusicHookData,"Mix_GetMusicHookData");
|
|
lib.bindSymbol(cast(void**)&Mix_ChannelFinished,"Mix_ChannelFinished");
|
|
lib.bindSymbol(cast(void**)&Mix_RegisterEffect,"Mix_RegisterEffect");
|
|
lib.bindSymbol(cast(void**)&Mix_UnregisterEffect,"Mix_UnregisterEffect");
|
|
lib.bindSymbol(cast(void**)&Mix_UnregisterAllEffects,"Mix_UnregisterAllEffects");
|
|
lib.bindSymbol(cast(void**)&Mix_SetPanning,"Mix_SetPanning");
|
|
lib.bindSymbol(cast(void**)&Mix_SetPosition,"Mix_SetPosition");
|
|
lib.bindSymbol(cast(void**)&Mix_SetDistance,"Mix_SetDistance");
|
|
lib.bindSymbol(cast(void**)&Mix_SetReverseStereo,"Mix_SetReverseStereo");
|
|
lib.bindSymbol(cast(void**)&Mix_ReserveChannels,"Mix_ReserveChannels");
|
|
lib.bindSymbol(cast(void**)&Mix_GroupChannel,"Mix_GroupChannel");
|
|
lib.bindSymbol(cast(void**)&Mix_GroupChannels,"Mix_GroupChannels");
|
|
lib.bindSymbol(cast(void**)&Mix_GroupAvailable,"Mix_GroupAvailable");
|
|
lib.bindSymbol(cast(void**)&Mix_GroupCount,"Mix_GroupCount");
|
|
lib.bindSymbol(cast(void**)&Mix_GroupOldest,"Mix_GroupOldest");
|
|
lib.bindSymbol(cast(void**)&Mix_GroupNewer,"Mix_GroupNewer");
|
|
lib.bindSymbol(cast(void**)&Mix_PlayChannelTimed,"Mix_PlayChannelTimed");
|
|
lib.bindSymbol(cast(void**)&Mix_PlayMusic,"Mix_PlayMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_FadeInMusic,"Mix_FadeInMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_FadeInMusicPos,"Mix_FadeInMusicPos");
|
|
lib.bindSymbol(cast(void**)&Mix_FadeInChannelTimed,"Mix_FadeInChannelTimed");
|
|
lib.bindSymbol(cast(void**)&Mix_Volume,"Mix_Volume");
|
|
lib.bindSymbol(cast(void**)&Mix_VolumeChunk,"Mix_VolumeChunk");
|
|
lib.bindSymbol(cast(void**)&Mix_VolumeMusic,"Mix_VolumeMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_HaltChannel,"Mix_HaltChannel");
|
|
lib.bindSymbol(cast(void**)&Mix_HaltGroup,"Mix_HaltGroup");
|
|
lib.bindSymbol(cast(void**)&Mix_HaltMusic,"Mix_HaltMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_ExpireChannel,"Mix_ExpireChannel");
|
|
lib.bindSymbol(cast(void**)&Mix_FadeOutChannel,"Mix_FadeOutChannel");
|
|
lib.bindSymbol(cast(void**)&Mix_FadeOutGroup,"Mix_FadeOutGroup");
|
|
lib.bindSymbol(cast(void**)&Mix_FadeOutMusic,"Mix_FadeOutMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_FadingMusic,"Mix_FadingMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_FadingChannel,"Mix_FadingChannel");
|
|
lib.bindSymbol(cast(void**)&Mix_Pause,"Mix_Pause");
|
|
lib.bindSymbol(cast(void**)&Mix_Resume,"Mix_Resume");
|
|
lib.bindSymbol(cast(void**)&Mix_Paused,"Mix_Paused");
|
|
lib.bindSymbol(cast(void**)&Mix_PauseMusic,"Mix_PauseMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_ResumeMusic,"Mix_ResumeMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_RewindMusic,"Mix_RewindMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_PausedMusic,"Mix_PausedMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_SetMusicPosition,"Mix_SetMusicPosition");
|
|
lib.bindSymbol(cast(void**)&Mix_Playing,"Mix_Playing");
|
|
lib.bindSymbol(cast(void**)&Mix_PlayingMusic,"Mix_PlayingMusic");
|
|
lib.bindSymbol(cast(void**)&Mix_SetMusicCMD,"Mix_SetMusicCMD");
|
|
lib.bindSymbol(cast(void**)&Mix_SetSynchroValue,"Mix_SetSynchroValue");
|
|
lib.bindSymbol(cast(void**)&Mix_GetSynchroValue,"Mix_GetSynchroValue");
|
|
lib.bindSymbol(cast(void**)&Mix_GetChunk,"Mix_GetChunk");
|
|
lib.bindSymbol(cast(void**)&Mix_CloseAudio,"Mix_CloseAudio");
|
|
|
|
if(errorCount() != errCount) return SDLMixerSupport.badLibrary;
|
|
else loadedVersion = SDLMixerSupport.sdlMixer200;
|
|
|
|
static if(sdlMixerSupport >= SDLMixerSupport.sdlMixer202) {
|
|
lib.bindSymbol(cast(void**)&Mix_OpenAudioDevice,"Mix_OpenAudioDevice");
|
|
lib.bindSymbol(cast(void**)&Mix_HasChunkDecoder,"Mix_HasChunkDecoder");
|
|
|
|
if(errorCount() != errCount) return SDLMixerSupport.badLibrary;
|
|
else loadedVersion = SDLMixerSupport.sdlMixer202;
|
|
}
|
|
|
|
return loadedVersion;
|
|
}
|
|
} |