Bubel/bubel-ecs
2
0
Fork 0
Code Issues 1 Pull requests 2 Projects Releases Packages Wiki Activity Actions

-improved WASM compilation scripts

Browse source 
-added external bindbc.sdl import for WASM
-working on demos (WIP, working simple demo with ECS and SDL2)
-small change in ecs.std
This commit is contained in:
Mergul 2019-11-06 20:38:46 +01:00
parent a8c74d5045
commit 73f2aa6861
60 changed files with 9015 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

46
demos/external/imports/bindbc/sdl/bind/package.d vendored Normal file
View file

@ -0,0 +1,46 @@
// 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.bind;
public
import bindbc.sdl.bind.sdl,
bindbc.sdl.bind.sdlassert,
bindbc.sdl.bind.sdlaudio,
bindbc.sdl.bind.sdlblendmode,
bindbc.sdl.bind.sdlclipboard,
bindbc.sdl.bind.sdlcpuinfo,
bindbc.sdl.bind.sdlerror,
bindbc.sdl.bind.sdlevents,
bindbc.sdl.bind.sdlfilesystem,
bindbc.sdl.bind.sdlgamecontroller,
bindbc.sdl.bind.sdlgesture,
bindbc.sdl.bind.sdlhaptic,
bindbc.sdl.bind.sdlhints,
bindbc.sdl.bind.sdljoystick,
bindbc.sdl.bind.sdlkeyboard,
bindbc.sdl.bind.sdlkeycode,
bindbc.sdl.bind.sdlloadso,
bindbc.sdl.bind.sdllog,
bindbc.sdl.bind.sdlmessagebox,
bindbc.sdl.bind.sdlmouse,
bindbc.sdl.bind.sdlpixels,
bindbc.sdl.bind.sdlplatform,
bindbc.sdl.bind.sdlpower,
bindbc.sdl.bind.sdlrect,
bindbc.sdl.bind.sdlrender,
bindbc.sdl.bind.sdlrwops,
bindbc.sdl.bind.sdlscancode,
bindbc.sdl.bind.sdlshape,
bindbc.sdl.bind.sdlstdinc,
bindbc.sdl.bind.sdlsurface,
bindbc.sdl.bind.sdlsystem,
bindbc.sdl.bind.sdlsyswm,
bindbc.sdl.bind.sdltimer,
bindbc.sdl.bind.sdltouch,
bindbc.sdl.bind.sdlversion,
bindbc.sdl.bind.sdlvideo,
bindbc.sdl.bind.sdlvulkan;

69
demos/external/imports/bindbc/sdl/bind/sdl.d vendored Normal file
View file

@ -0,0 +1,69 @@
// 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.bind.sdl;
import bindbc.sdl.config;
static if(sdlSupport >= SDLSupport.sdl209) {
enum : uint {
SDL_INIT_TIMER = 0x00000001,
SDL_INIT_AUDIO = 0x00000010,
SDL_INIT_VIDEO = 0x00000020,
SDL_INIT_JOYSTICK = 0x00000200,
SDL_INIT_HAPTIC = 0x00001000,
SDL_INIT_GAMECONTROLLER = 0x00002000,
SDL_INIT_EVENTS = 0x00004000,
SDL_INIT_SENSOR = 0x00008000,
SDL_INIT_NOPARACHUTE = 0x00100000,
SDL_INIT_EVERYTHING =
SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO |
SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER |
SDL_INIT_EVENTS | SDL_INIT_SENSOR
}
} else {
enum : uint {
SDL_INIT_TIMER = 0x00000001,
SDL_INIT_AUDIO = 0x00000010,
SDL_INIT_VIDEO = 0x00000020,
SDL_INIT_JOYSTICK = 0x00000200,
SDL_INIT_HAPTIC = 0x00001000,
SDL_INIT_GAMECONTROLLER = 0x00002000,
SDL_INIT_EVENTS = 0x00004000,
SDL_INIT_NOPARACHUTE = 0x00100000,
SDL_INIT_EVERYTHING =
SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO |
SDL_INIT_JOYSTICK | SDL_INIT_HAPTIC | SDL_INIT_GAMECONTROLLER |
SDL_INIT_EVENTS
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_Init(uint);
int SDL_InitSubSystem(uint);
void SDL_QuitSubSystem(uint);
uint SDL_WasInit(uint);
void SDL_Quit();
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_Init = int function(uint);
alias pSDL_InitSubSystem = int function(uint);
alias pSDL_QuitSubSystem = void function(uint);
alias pSDL_WasInit = uint function(uint);
alias pSDL_Quit = void function();
}
__gshared {
pSDL_Init SDL_Init;
pSDL_InitSubSystem SDL_InitSubSystem;
pSDL_QuitSubSystem SDL_QuitSubSystem;
pSDL_WasInit SDL_WasInit;
pSDL_Quit SDL_Quit;
}
}

70
demos/external/imports/bindbc/sdl/bind/sdlassert.d vendored Normal file
View file

@ -0,0 +1,70 @@
// 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.bind.sdlassert;
import bindbc.sdl.config;
enum SDL_assert_state : uint {
SDL_ASSERTION_RETRY = 0,
SDL_ASSERTION_BREAK = 1,
SDL_ASSERTION_ABORT = 2,
SDL_ASSERTION_IGNORE = 3,
SDL_ASSERTION_ALWAYS_IGNORE = 4
}
alias SDL_AssertState = SDL_assert_state;
mixin(expandEnum!SDL_AssertState);
struct SDL_assert_data {
int always_ignore;
uint trigger_count;
const(char) *condition;
const(char) *filename;
int linenum;
const(char) *function_;
const(SDL_assert_data) *next;
}
alias SDL_AssertData = SDL_assert_data;
extern(C) nothrow alias SDL_AssertionHandler = SDL_AssertState function(const(SDL_AssertData)* data, void* userdata);
version(BindSDL_Static) {
extern(C) @nogc nothrow {
void SDL_SetAssertionHandler(SDL_AssertionHandler,void*);
const(SDL_assert_data)* SDL_GetAssertionReport();
void SDL_ResetAssertionReport();
static if(sdlSupport >= SDLSupport.sdl202) {
SDL_AssertionHandler SDL_GetAssertionHandler(void**);
SDL_AssertionHandler SDL_GetDefaultAssertionHandler();
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_SetAssertionHandler = void function(SDL_AssertionHandler,void*);
alias pSDL_GetAssertionReport = const(SDL_assert_data)* function();
alias pSDL_ResetAssertionReport = void function();
}
__gshared {
pSDL_SetAssertionHandler SDL_SetAssertionHandler;
pSDL_GetAssertionReport SDL_GetAssertionReport;
pSDL_ResetAssertionReport SDL_ResetAssertionReport;
}
static if(sdlSupport >= SDLSupport.sdl202) {
extern(C) @nogc nothrow {
alias pSDL_GetAssertionHandler = SDL_AssertionHandler function(void**);
alias pSDL_GetDefaultAssertionHandler = SDL_AssertionHandler function();
}
__gshared {
pSDL_GetAssertionHandler SDL_GetAssertionHandler;
pSDL_GetDefaultAssertionHandler SDL_GetDefaultAssertionHandler;
}
}
}

283
demos/external/imports/bindbc/sdl/bind/sdlaudio.d vendored Normal file
View file

@ -0,0 +1,283 @@
// 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.bind.sdlaudio;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlrwops;
enum : ushort {
SDL_AUDIO_MASK_BITSIZE = 0xFF,
SDL_AUDIO_MASK_DATATYPE = 1<<8,
SDL_AUDIO_MASK_ENDIAN = 1<<12,
SDL_AUDIO_MASK_SIGNED = 1<<15,
}
enum SDL_AudioFormat : ushort {
AUDIO_U8 = 0x0008,
AUDIO_S8 = 0x8008,
AUDIO_U16LSB = 0x0010,
AUDIO_S16LSB = 0x8010,
AUDIO_U16MSB = 0x1010,
AUDIO_S16MSB = 0x9010,
AUDIO_U16 = AUDIO_U16LSB,
AUDIO_S16 = AUDIO_S16LSB,
AUDIO_S32LSB = 0x8020,
AUDIO_S32MSB = 0x9020,
AUDIO_S32 = AUDIO_S32LSB,
AUDIO_F32LSB = 0x8120,
AUDIO_F32MSB = 0x9120,
AUDIO_F32 = AUDIO_F32LSB,
}
mixin(expandEnum!SDL_AudioFormat);
version(LittleEndian) {
alias AUDIO_U16SYS = AUDIO_U16LSB;
alias AUDIO_S16SYS = AUDIO_S16LSB;
alias AUDIO_S32SYS = AUDIO_S32LSB;
alias AUDIO_F32SYS = AUDIO_F32LSB;
} else {
alias AUDIO_U16SYS = AUDIO_U16MSB;
alias AUDIO_S16SYS = AUDIO_S16MSB;
alias AUDIO_S32SYS = AUDIO_S32MSB;
alias AUDIO_F32SYS = AUDIO_F32MSB;
}
enum SDL_AUDIO_BITSIZE(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_BITSIZE;
enum SDL_AUDIO_ISFLOAT(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_DATATYPE;
enum SDL_AUDIO_ISBIGENDIAN(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_ENDIAN;
enum SDL_AUDIO_ISSIGNED(SDL_AudioFormat x) = x & SDL_AUDIO_MASK_SIGNED;
enum SDL_AUDIO_ISINT(SDL_AudioFormat x) = !SDL_AUDIO_ISFLOAT!x;
enum SDL_AUDIO_ISLITTLEENDIAN(SDL_AudioFormat x) = !SDL_AUDIO_ISBIGENDIAN!x;
enum SDL_AUDIO_ISUNSIGNED(SDL_AudioFormat x) = !SDL_AUDIO_ISSIGNED!x;
static if(sdlSupport >= SDLSupport.sdl209) {
enum {
SDL_AUDIO_ALLOW_FREQUENCY_CHANGE = 0x00000001,
SDL_AUDIO_ALLOW_FORMAT_CHANGE = 0x00000002,
SDL_AUDIO_ALLOW_CHANNELS_CHANGE = 0x00000004,
SDL_AUDIO_ALLOW_SAMPLES_CHANGE = 0x00000008,
SDL_AUDIO_ALLOW_ANY_CHANGE = SDL_AUDIO_ALLOW_FREQUENCY_CHANGE |
SDL_AUDIO_ALLOW_FORMAT_CHANGE |
SDL_AUDIO_ALLOW_CHANNELS_CHANGE |
SDL_AUDIO_ALLOW_SAMPLES_CHANGE,
}
}
else {
enum {
SDL_AUDIO_ALLOW_FREQUENCY_CHANGE = 0x00000001,
SDL_AUDIO_ALLOW_FORMAT_CHANGE = 0x00000002,
SDL_AUDIO_ALLOW_CHANNELS_CHANGE = 0x00000004,
SDL_AUDIO_ALLOW_ANY_CHANGE = SDL_AUDIO_ALLOW_FREQUENCY_CHANGE |
SDL_AUDIO_ALLOW_FORMAT_CHANGE |
SDL_AUDIO_ALLOW_CHANNELS_CHANGE,
}
}
extern(C) nothrow alias SDL_AudioCallback = void function(void* userdata, ubyte* stream, int len);
struct SDL_AudioSpec {
int freq;
SDL_AudioFormat format;
ubyte channels;
ubyte silence;
ushort samples;
ushort padding;
uint size;
SDL_AudioCallback callback;
void* userdata;
}
// Declared in 2.0.6, but doesn't hurt to use here
enum SDL_AUDIOCVT_MAX_FILTERS = 9;
extern(C) nothrow alias SDL_AudioFilter = void function(SDL_AudioCVT* cvt, SDL_AudioFormat format);
struct SDL_AudioCVT {
int needed;
SDL_AudioFormat src_format;
SDL_AudioFormat dst_format;
double rate_incr;
ubyte* buf;
int len;
int len_cvt;
int len_mult;
double len_ratio;
SDL_AudioFilter[SDL_AUDIOCVT_MAX_FILTERS + 1] filters;
int filter_index;
}
alias SDL_AudioDeviceID = uint;
enum SDL_AudioStatus {
SDL_AUDIO_STOPPED = 0,
SDL_AUDIO_PLAYING,
SDL_AUDIO_PAUSED,
}
mixin(expandEnum!SDL_AudioStatus);
enum SDL_MIX_MAXVOLUME = 128;
static if(sdlSupport >= SDLSupport.sdl207) {
struct SDL_AudioStream;
}
@nogc nothrow
SDL_AudioSpec* SDL_LoadWAV(const(char)* file, SDL_AudioSpec* spec, ubyte** audio_buf, uint* len) {
pragma(inline, true);
return SDL_LoadWAV_RW(SDL_RWFromFile(file,"rb"),1,spec,audio_buf,len);
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_GetNumAudioDrivers();
const(char)* SDL_GetAudioDriver(int);
int SDL_AudioInit(const(char)*);
void SDL_AudioQuit();
const(char)* SDL_GetCurrentAudioDriver();
int SDL_OpenAudio(SDL_AudioSpec*,SDL_AudioSpec*);
int SDL_GetNumAudioDevices(int);
const(char)* SDL_GetAudioDeviceName(int,int);
SDL_AudioDeviceID SDL_OpenAudioDevice(const(char)*,int,const(SDL_AudioSpec)*,SDL_AudioSpec*,int);
SDL_AudioStatus SDL_GetAudioStatus();
SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID);
void SDL_PauseAudio(int);
void SDL_PauseAudioDevice(SDL_AudioDeviceID,int);
SDL_AudioSpec* SDL_LoadWAV_RW(SDL_RWops*,int,SDL_AudioSpec*,ubyte**,uint*);
void SDL_FreeWAV(ubyte*);
int SDL_BuildAudioCVT(SDL_AudioCVT*,SDL_AudioFormat,ubyte,int,SDL_AudioFormat,ubyte,int);
int SDL_ConvertAudio(SDL_AudioCVT*);
void SDL_MixAudio(ubyte*,const(ubyte)*,uint,int);
void SDL_MixAudioFormat(ubyte*,const(ubyte)*,SDL_AudioFormat,uint,int);
void SDL_LockAudio();
void SDL_LockAudioDevice(SDL_AudioDeviceID);
void SDL_UnlockAudio();
void SDL_UnlockAudioDevice(SDL_AudioDeviceID);
void SDL_CloseAudio();
void SDL_CloseAudioDevice(SDL_AudioDeviceID);
static if(sdlSupport >= SDLSupport.sdl204) {
int SDL_ClearQueuedAudio(SDL_AudioDeviceID);
int SDL_GetQueuedAudioSize(SDL_AudioDeviceID);
int SDL_QueueAudio(SDL_AudioDeviceID,const (void)*,uint);
}
static if(sdlSupport >= SDLSupport.sdl205) {
uint SDL_DequeueAudio(SDL_AudioDeviceID,void*,uint);
}
static if(sdlSupport >= SDLSupport.sdl207) {
SDL_AudioStream* SDL_NewAudioStream(const(SDL_AudioFormat),const(ubyte),const(int),const(SDL_AudioFormat),const(ubyte),const(int));
int SDL_AudioStreamPut(SDL_AudioStream*,const(void)*,int);
int SDL_AudioStreamGet(SDL_AudioStream*,void*,int);
int SDL_AudioStreamAvailable(SDL_AudioStream*);
int SDL_AudioStreamFlush(SDL_AudioStream*);
void SDL_AudioStreamClear(SDL_AudioStream*);
void SDL_FreeAudioStream(SDL_AudioStream*);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetNumAudioDrivers = int function();
alias pSDL_GetAudioDriver = const(char)* function(int);
alias pSDL_AudioInit = int function(const(char)*);
alias pSDL_AudioQuit = void function();
alias pSDL_GetCurrentAudioDriver = const(char)* function();
alias pSDL_OpenAudio = int function(SDL_AudioSpec*,SDL_AudioSpec*);
alias pSDL_GetNumAudioDevices = int function(int);
alias pSDL_GetAudioDeviceName = const(char)* function(int,int);
alias pSDL_OpenAudioDevice = SDL_AudioDeviceID function(const(char)*,int,const(SDL_AudioSpec)*,SDL_AudioSpec*,int);
alias pSDL_GetAudioStatus = SDL_AudioStatus function();
alias pSDL_GetAudioDeviceStatus = SDL_AudioStatus function(SDL_AudioDeviceID);
alias pSDL_PauseAudio = void function(int);
alias pSDL_PauseAudioDevice = void function(SDL_AudioDeviceID,int);
alias pSDL_LoadWAV_RW = SDL_AudioSpec* function(SDL_RWops*,int,SDL_AudioSpec*,ubyte**,uint*);
alias pSDL_FreeWAV = void function(ubyte*);
alias pSDL_BuildAudioCVT = int function(SDL_AudioCVT*,SDL_AudioFormat,ubyte,int,SDL_AudioFormat,ubyte,int);
alias pSDL_ConvertAudio = int function(SDL_AudioCVT*);
alias pSDL_MixAudio = void function(ubyte*,const(ubyte)*,uint,int);
alias pSDL_MixAudioFormat = void function(ubyte*,const(ubyte)*,SDL_AudioFormat,uint,int);
alias pSDL_LockAudio = void function();
alias pSDL_LockAudioDevice = void function(SDL_AudioDeviceID);
alias pSDL_UnlockAudio = void function();
alias pSDL_UnlockAudioDevice = void function(SDL_AudioDeviceID);
alias pSDL_CloseAudio = void function();
alias pSDL_CloseAudioDevice = void function(SDL_AudioDeviceID);
}
__gshared {
pSDL_GetNumAudioDrivers SDL_GetNumAudioDrivers;
pSDL_GetAudioDriver SDL_GetAudioDriver;
pSDL_AudioInit SDL_AudioInit;
pSDL_AudioQuit SDL_AudioQuit;
pSDL_GetCurrentAudioDriver SDL_GetCurrentAudioDriver;
pSDL_OpenAudio SDL_OpenAudio;
pSDL_GetNumAudioDevices SDL_GetNumAudioDevices;
pSDL_GetAudioDeviceName SDL_GetAudioDeviceName;
pSDL_OpenAudioDevice SDL_OpenAudioDevice;
pSDL_GetAudioStatus SDL_GetAudioStatus;
pSDL_GetAudioDeviceStatus SDL_GetAudioDeviceStatus;
pSDL_PauseAudio SDL_PauseAudio;
pSDL_PauseAudioDevice SDL_PauseAudioDevice;
pSDL_LoadWAV_RW SDL_LoadWAV_RW;
pSDL_FreeWAV SDL_FreeWAV;
pSDL_BuildAudioCVT SDL_BuildAudioCVT;
pSDL_ConvertAudio SDL_ConvertAudio;
pSDL_MixAudio SDL_MixAudio;
pSDL_MixAudioFormat SDL_MixAudioFormat;
pSDL_LockAudio SDL_LockAudio;
pSDL_LockAudioDevice SDL_LockAudioDevice;
pSDL_UnlockAudio SDL_UnlockAudio;
pSDL_UnlockAudioDevice SDL_UnlockAudioDevice;
pSDL_CloseAudio SDL_CloseAudio;
pSDL_CloseAudioDevice SDL_CloseAudioDevice;
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_ClearQueuedAudio = int function(SDL_AudioDeviceID);
alias pSDL_GetQueuedAudioSize = int function(SDL_AudioDeviceID);
alias pSDL_QueueAudio = int function(SDL_AudioDeviceID,const (void)*,uint);
}
__gshared {
pSDL_ClearQueuedAudio SDL_ClearQueuedAudio;
pSDL_GetQueuedAudioSize SDL_GetQueuedAudioSize;
pSDL_QueueAudio SDL_QueueAudio;
}
}
static if(sdlSupport >= SDLSupport.sdl205) {
extern(C) @nogc nothrow {
alias pSDL_DequeueAudio = uint function(SDL_AudioDeviceID,void*,uint);
}
__gshared {
pSDL_DequeueAudio SDL_DequeueAudio;
}
}
static if(sdlSupport >= SDLSupport.sdl207) {
extern(C) @nogc nothrow {
alias pSDL_NewAudioStream = SDL_AudioStream* function(const(SDL_AudioFormat),const(ubyte),const(int),const(SDL_AudioFormat),const(ubyte),const(int));
alias pSDL_AudioStreamPut = int function(SDL_AudioStream*,const(void)*,int);
alias pSDL_AudioStreamGet = int function(SDL_AudioStream*,void*,int);
alias pSDL_AudioStreamAvailable = int function(SDL_AudioStream*);
alias pSDL_AudioStreamFlush = int function(SDL_AudioStream*);
alias pSDL_AudioStreamClear = void function(SDL_AudioStream*);
alias pSDL_FreeAudioStream = void function(SDL_AudioStream*);
}
__gshared {
pSDL_NewAudioStream SDL_NewAudioStream;
pSDL_AudioStreamPut SDL_AudioStreamPut;
pSDL_AudioStreamGet SDL_AudioStreamGet;
pSDL_AudioStreamAvailable SDL_AudioStreamAvailable;
pSDL_AudioStreamFlush SDL_AudioStreamFlush;
pSDL_AudioStreamClear SDL_AudioStreamClear;
pSDL_FreeAudioStream SDL_FreeAudioStream;
}
}
}

71
demos/external/imports/bindbc/sdl/bind/sdlblendmode.d vendored Normal file
View file

@ -0,0 +1,71 @@
// 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.bind.sdlblendmode;
import bindbc.sdl.config;
static if(sdlSupport >= SDLSupport.sdl206) {
enum SDL_BlendMode {
SDL_BLENDMODE_NONE = 0x00000000,
SDL_BLENDMODE_BLEND = 0x00000001,
SDL_BLENDMODE_ADD = 0x00000002,
SDL_BLENDMODE_MOD = 0x00000004,
SDL_BLENDMODE_INVALID = 0x7FFFFFFF,
}
mixin(expandEnum!SDL_BlendMode);
enum SDL_BlendOperation {
SDL_BLENDOPERATION_ADD = 0x1,
SDL_BLENDOPERATION_SUBTRACT = 0x2,
SDL_BLENDOPERATION_REV_SUBTRACT = 0x3,
SDL_BLENDOPERATION_MINIMUM = 0x4,
SDL_BLENDOPERATION_MAXIMUM = 0x5,
}
mixin(expandEnum!SDL_BlendOperation);
enum SDL_BlendFactor {
SDL_BLENDFACTOR_ZERO = 0x1,
SDL_BLENDFACTOR_ONE = 0x2,
SDL_BLENDFACTOR_SRC_COLOR = 0x3,
SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR = 0x4,
SDL_BLENDFACTOR_SRC_ALPHA = 0x5,
SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA = 0x6,
SDL_BLENDFACTOR_DST_COLOR = 0x7,
SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR = 0x8,
SDL_BLENDFACTOR_DST_ALPHA = 0x9,
SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 0xA,
}
mixin(expandEnum!SDL_BlendFactor);
}
else {
enum SDL_BlendMode {
SDL_BLENDMODE_NONE = 0x00000000,
SDL_BLENDMODE_BLEND = 0x00000001,
SDL_BLENDMODE_ADD = 0x00000002,
SDL_BLENDMODE_MOD = 0x00000004,
}
mixin(expandEnum!SDL_BlendMode);
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
static if(sdlSupport >= SDLSupport.sdl206) {
SDL_BlendMode SDL_ComposeCustomBlendMode(SDL_BlendFactor,SDL_BlendFactor,SDL_BlendOperation,SDL_BlendFactor,SDL_BlendFactor,SDL_BlendOperation);
}
}
}
else {
static if(sdlSupport >= SDLSupport.sdl206) {
extern(C) @nogc nothrow {
alias pSDL_ComposeCustomBlendMode = SDL_BlendMode function(SDL_BlendFactor,SDL_BlendFactor,SDL_BlendOperation,SDL_BlendFactor,SDL_BlendFactor,SDL_BlendOperation);
}
__gshared {
pSDL_ComposeCustomBlendMode SDL_ComposeCustomBlendMode;
}
}
}

31
demos/external/imports/bindbc/sdl/bind/sdlclipboard.d vendored Normal file
View file

@ -0,0 +1,31 @@
// 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.bind.sdlclipboard;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_SetClipboardText(const(char)*);
char* SDL_GetClipboardText();
SDL_bool SDL_HasClipboardText();
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_SetClipboardText = int function(const(char)*);
alias pSDL_GetClipboardText = char* function();
alias pSDL_HasClipboardText = SDL_bool function();
}
__gshared {
pSDL_SetClipboardText SDL_SetClipboardText;
pSDL_GetClipboardText SDL_GetClipboardText;
pSDL_HasClipboardText SDL_HasClipboardText;
}
}

130
demos/external/imports/bindbc/sdl/bind/sdlcpuinfo.d vendored Normal file
View file

@ -0,0 +1,130 @@
// 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.bind.sdlcpuinfo;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
enum SDL_CACHELINE_SIZE = 128;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_GetCPUCount();
int SDL_GetCPUCacheLineSize();
SDL_bool SDL_HasRDTSC();
SDL_bool SDL_HasAltiVec();
SDL_bool SDL_HasMMX();
SDL_bool SDL_Has3DNow();
SDL_bool SDL_HasSSE();
SDL_bool SDL_HasSSE2();
SDL_bool SDL_HasSSE3();
SDL_bool SDL_HasSSE41();
SDL_bool SDL_HasSSE42();
static if(sdlSupport >= SDLSupport.sdl201) {
int SDL_GetSystemRAM();
}
static if(sdlSupport >= SDLSupport.sdl202) {
SDL_bool SDL_HasAVX();
}
static if(sdlSupport >= SDLSupport.sdl204) {
SDL_bool SDL_HasAVX2();
}
static if(sdlSupport >= SDLSupport.sdl206) {
SDL_bool SDL_HasNEON();
}
static if(sdlSupport >= SDLSupport.sdl209) {
SDL_bool SDL_HasAVX512F();
}
static if(sdlSupport >= SDLSupport.sdl2010) {
size_t SDL_SIMDGetAlignment();
void* SDL_SIMDAlloc(const(size_t));
void SDL_SIMDFree(void*);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetCPUCount = int function();
alias pSDL_GetCPUCacheLineSize = int function();
alias pSDL_HasRDTSC = SDL_bool function();
alias pSDL_HasAltiVec = SDL_bool function();
alias pSDL_HasMMX = SDL_bool function();
alias pSDL_Has3DNow = SDL_bool function();
alias pSDL_HasSSE = SDL_bool function();
alias pSDL_HasSSE2 = SDL_bool function();
alias pSDL_HasSSE3 = SDL_bool function();
alias pSDL_HasSSE41 = SDL_bool function();
alias pSDL_HasSSE42 = SDL_bool function();
}
__gshared {
pSDL_GetCPUCount SDL_GetCPUCount;
pSDL_GetCPUCacheLineSize SDL_GetCPUCacheLineSize;
pSDL_HasRDTSC SDL_HasRDTSC;
pSDL_HasAltiVec SDL_HasAltiVec;
pSDL_HasMMX SDL_HasMMX;
pSDL_Has3DNow SDL_Has3DNow;
pSDL_HasSSE SDL_HasSSE;
pSDL_HasSSE2 SDL_HasSSE2;
pSDL_HasSSE3 SDL_HasSSE3;
pSDL_HasSSE41 SDL_HasSSE41;
pSDL_HasSSE42 SDL_HasSSE42;
}
static if(sdlSupport >= SDLSupport.sdl201) {
extern(C) @nogc nothrow {
alias pSDL_GetSystemRAM = int function();
}
__gshared {
pSDL_GetSystemRAM SDL_GetSystemRAM;
}
}
static if(sdlSupport >= SDLSupport.sdl202) {
extern(C) @nogc nothrow {
alias pSDL_HasAVX = SDL_bool function();
}
__gshared {
pSDL_HasAVX SDL_HasAVX;
}
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_HasAVX2 = SDL_bool function();
}
__gshared {
pSDL_HasAVX2 SDL_HasAVX2;
}
}
static if(sdlSupport >= SDLSupport.sdl206) {
extern(C) @nogc nothrow {
alias pSDL_HasNEON = SDL_bool function();
}
__gshared {
pSDL_HasNEON SDL_HasNEON;
}
}
static if(sdlSupport >= SDLSupport.sdl209) {
extern(C) @nogc nothrow {
alias pSDL_HasAVX512F = SDL_bool function();
}
__gshared {
pSDL_HasAVX512F SDL_HasAVX512F;
}
}
static if(sdlSupport >= SDLSupport.sdl2010) {
extern(C) @nogc nothrow {
alias pSDL_SIMDGetAlignment = size_t function();
alias pSDL_SIMDAlloc = void* function(const(size_t));
alias pSDL_SIMDFree = void function(void*);
}
__gshared {
pSDL_SIMDGetAlignment SDL_SIMDGetAlignment;
pSDL_SIMDAlloc SDL_SIMDAlloc;
pSDL_SIMDFree SDL_SIMDFree;
}
}
}

28
demos/external/imports/bindbc/sdl/bind/sdlerror.d vendored Normal file
View file

@ -0,0 +1,28 @@
// 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.bind.sdlerror;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
void SDL_SetError(const(char)*,...);
const(char)* SDL_GetError();
void SDL_ClearError();
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_SetError = void function(const(char)*,...);
alias pSDL_GetError = const(char)* function();
alias pSDL_ClearError = void function();
}
__gshared {
pSDL_SetError SDL_SetError;
pSDL_GetError SDL_GetError;
pSDL_ClearError SDL_ClearError;
}
}

674
demos/external/imports/bindbc/sdl/bind/sdlevents.d vendored Normal file
View file

@ -0,0 +1,674 @@
// 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.bind.sdlevents;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlgesture,
bindbc.sdl.bind.sdljoystick,
bindbc.sdl.bind.sdlkeyboard,
bindbc.sdl.bind.sdlkeycode,
bindbc.sdl.bind.sdlstdinc,
bindbc.sdl.bind.sdlsyswm,
bindbc.sdl.bind.sdltouch,
bindbc.sdl.bind.sdlvideo;
enum {
SDL_RELEASED = 0,
SDL_PRESSED = 1,
}
static if(sdlSupport >= SDLSupport.sdl209) {
enum SDL_EventType {
SDL_FIRSTEVENT = 0,
SDL_QUIT = 0x100,
SDL_APP_TERMINATING,
SDL_APP_LOWMEMORY,
SDL_APP_WILLENTERBACKGROUND,
SDL_APP_DIDENTERBACKGROUND,
SDL_APP_WILLENTERFOREGROUND,
SDL_APP_DIDENTERFOREGROUND,
SDL_DISPLAYEVENT = 0x150,
SDL_WINDOWEVENT = 0x200,
SDL_SYSWMEVENT,
SDL_KEYDOWN = 0x300,
SDL_KEYUP,
SDL_TEXTEDITING,
SDL_TEXTINPUT,
SDL_KEYMAPCHANGED,
SDL_MOUSEMOTION = 0x400,
SDL_MOUSEBUTTONDOWN,
SDL_MOUSEBUTTONUP,
SDL_MOUSEWHEEL,
SDL_JOYAXISMOTION = 0x600,
SDL_JOYBALLMOTION,
SDL_JOYHATMOTION,
SDL_JOYBUTTONDOWN,
SDL_JOYBUTTONUP,
SDL_JOYDEVICEADDED,
SDL_JOYDEVICEREMOVED,
SDL_CONTROLLERAXISMOTION = 0x650,
SDL_CONTROLLERBUTTONDOWN,
SDL_CONTROLLERBUTTONUP,
SDL_CONTROLLERDEVICEADDED,
SDL_CONTROLLERDEVICEREMOVED,
SDL_CONTROLLERDEVICEREMAPPED,
SDL_FINGERDOWN = 0x700,
SDL_FINGERUP,
SDL_FINGERMOTION,
SDL_DOLLARGESTURE = 0x800,
SDL_DOLLARRECORD,
SDL_MULTIGESTURE,
SDL_CLIPBOARDUPDATE = 0x900,
SDL_DROPFILE = 0x1000,
SDL_DROPTEXT,
SDL_DROPBEGIN,
SDL_DROPCOMPLETE,
SDL_AUDIODEVICEADDED = 0x1100,
SDL_AUDIODEVICEREMOVED,
SDL_SENSORUPDATE = 0x1200,
SDL_RENDER_TARGETS_RESET = 0x2000,
SDL_RENDER_DEVICE_RESET,
SDL_USEREVENT = 0x8000,
SDL_LASTEVENT = 0xFFFF
}
}
else static if(sdlSupport >= SDLSupport.sdl205) {
enum SDL_EventType {
SDL_FIRSTEVENT = 0,
SDL_QUIT = 0x100,
SDL_APP_TERMINATING,
SDL_APP_LOWMEMORY,
SDL_APP_WILLENTERBACKGROUND,
SDL_APP_DIDENTERBACKGROUND,
SDL_APP_WILLENTERFOREGROUND,
SDL_APP_DIDENTERFOREGROUND,
SDL_WINDOWEVENT = 0x200,
SDL_SYSWMEVENT,
SDL_KEYDOWN = 0x300,
SDL_KEYUP,
SDL_TEXTEDITING,
SDL_TEXTINPUT,
SDL_KEYMAPCHANGED,
SDL_MOUSEMOTION = 0x400,
SDL_MOUSEBUTTONDOWN,
SDL_MOUSEBUTTONUP,
SDL_MOUSEWHEEL,
SDL_JOYAXISMOTION = 0x600,
SDL_JOYBALLMOTION,
SDL_JOYHATMOTION,
SDL_JOYBUTTONDOWN,
SDL_JOYBUTTONUP,
SDL_JOYDEVICEADDED,
SDL_JOYDEVICEREMOVED,
SDL_CONTROLLERAXISMOTION = 0x650,
SDL_CONTROLLERBUTTONDOWN,
SDL_CONTROLLERBUTTONUP,
SDL_CONTROLLERDEVICEADDED,
SDL_CONTROLLERDEVICEREMOVED,
SDL_CONTROLLERDEVICEREMAPPED,
SDL_FINGERDOWN = 0x700,
SDL_FINGERUP,
SDL_FINGERMOTION,
SDL_DOLLARGESTURE = 0x800,
SDL_DOLLARRECORD,
SDL_MULTIGESTURE,
SDL_CLIPBOARDUPDATE = 0x900,
SDL_DROPFILE = 0x1000,
SDL_DROPTEXT,
SDL_DROPBEGIN,
SDL_DROPCOMPLETE,
SDL_AUDIODEVICEADDED = 0x1100,
SDL_AUDIODEVICEREMOVED,
SDL_RENDER_TARGETS_RESET = 0x2000,
SDL_RENDER_DEVICE_RESET,
SDL_USEREVENT = 0x8000,
SDL_LASTEVENT = 0xFFFF
}
}
else static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_EventType {
SDL_FIRSTEVENT = 0,
SDL_QUIT = 0x100,
SDL_APP_TERMINATING,
SDL_APP_LOWMEMORY,
SDL_APP_WILLENTERBACKGROUND,
SDL_APP_DIDENTERBACKGROUND,
SDL_APP_WILLENTERFOREGROUND,
SDL_APP_DIDENTERFOREGROUND,
SDL_WINDOWEVENT = 0x200,
SDL_SYSWMEVENT,
SDL_KEYDOWN = 0x300,
SDL_KEYUP,
SDL_TEXTEDITING,
SDL_TEXTINPUT,
SDL_KEYMAPCHANGED,
SDL_MOUSEMOTION = 0x400,
SDL_MOUSEBUTTONDOWN,
SDL_MOUSEBUTTONUP,
SDL_MOUSEWHEEL,
SDL_JOYAXISMOTION = 0x600,
SDL_JOYBALLMOTION,
SDL_JOYHATMOTION,
SDL_JOYBUTTONDOWN,
SDL_JOYBUTTONUP,
SDL_JOYDEVICEADDED,
SDL_JOYDEVICEREMOVED,
SDL_CONTROLLERAXISMOTION = 0x650,
SDL_CONTROLLERBUTTONDOWN,
SDL_CONTROLLERBUTTONUP,
SDL_CONTROLLERDEVICEADDED,
SDL_CONTROLLERDEVICEREMOVED,
SDL_CONTROLLERDEVICEREMAPPED,
SDL_FINGERDOWN = 0x700,
SDL_FINGERUP,
SDL_FINGERMOTION,
SDL_DOLLARGESTURE = 0x800,
SDL_DOLLARRECORD,
SDL_MULTIGESTURE,
SDL_CLIPBOARDUPDATE = 0x900,
SDL_DROPFILE = 0x1000,
SDL_AUDIODEVICEADDED = 0x1100,
SDL_AUDIODEVICEREMOVED,
SDL_RENDER_TARGETS_RESET = 0x2000,
SDL_RENDER_DEVICE_RESET,
SDL_USEREVENT = 0x8000,
SDL_LASTEVENT = 0xFFFF
}
}
else static if(sdlSupport >= SDLSupport.sdl201) {
enum SDL_EventType {
SDL_FIRSTEVENT = 0,
SDL_QUIT = 0x100,
SDL_APP_TERMINATING,
SDL_APP_LOWMEMORY,
SDL_APP_WILLENTERBACKGROUND,
SDL_APP_DIDENTERBACKGROUND,
SDL_APP_WILLENTERFOREGROUND,
SDL_APP_DIDENTERFOREGROUND,
SDL_WINDOWEVENT = 0x200,
SDL_SYSWMEVENT,
SDL_KEYDOWN = 0x300,
SDL_KEYUP,
SDL_TEXTEDITING,
SDL_TEXTINPUT,
SDL_MOUSEMOTION = 0x400,
SDL_MOUSEBUTTONDOWN,
SDL_MOUSEBUTTONUP,
SDL_MOUSEWHEEL,
SDL_JOYAXISMOTION = 0x600,
SDL_JOYBALLMOTION,
SDL_JOYHATMOTION,
SDL_JOYBUTTONDOWN,
SDL_JOYBUTTONUP,
SDL_JOYDEVICEADDED,
SDL_JOYDEVICEREMOVED,
SDL_CONTROLLERAXISMOTION = 0x650,
SDL_CONTROLLERBUTTONDOWN,
SDL_CONTROLLERBUTTONUP,
SDL_CONTROLLERDEVICEADDED,
SDL_CONTROLLERDEVICEREMOVED,
SDL_CONTROLLERDEVICEREMAPPED,
SDL_FINGERDOWN = 0x700,
SDL_FINGERUP,
SDL_FINGERMOTION,
SDL_DOLLARGESTURE = 0x800,
SDL_DOLLARRECORD,
SDL_MULTIGESTURE,
SDL_CLIPBOARDUPDATE = 0x900,
SDL_DROPFILE = 0x1000,
SDL_RENDER_TARGETS_RESET = 0x2000,
SDL_USEREVENT = 0x8000,
SDL_LASTEVENT = 0xFFFF
}
}
else {
enum SDL_EventType {
SDL_FIRSTEVENT = 0,
SDL_QUIT = 0x100,
SDL_APP_TERMINATING,
SDL_APP_LOWMEMORY,
SDL_APP_WILLENTERBACKGROUND,
SDL_APP_DIDENTERBACKGROUND,
SDL_APP_WILLENTERFOREGROUND,
SDL_APP_DIDENTERFOREGROUND,
SDL_WINDOWEVENT = 0x200,
SDL_SYSWMEVENT,
SDL_KEYDOWN = 0x300,
SDL_KEYUP,
SDL_TEXTEDITING,
SDL_TEXTINPUT,
SDL_MOUSEMOTION = 0x400,
SDL_MOUSEBUTTONDOWN,
SDL_MOUSEBUTTONUP,
SDL_MOUSEWHEEL,
SDL_JOYAXISMOTION = 0x600,
SDL_JOYBALLMOTION,
SDL_JOYHATMOTION,
SDL_JOYBUTTONDOWN,
SDL_JOYBUTTONUP,
SDL_JOYDEVICEADDED,
SDL_JOYDEVICEREMOVED,
SDL_CONTROLLERAXISMOTION = 0x650,
SDL_CONTROLLERBUTTONDOWN,
SDL_CONTROLLERBUTTONUP,
SDL_CONTROLLERDEVICEADDED,
SDL_CONTROLLERDEVICEREMOVED,
SDL_CONTROLLERDEVICEREMAPPED,
SDL_FINGERDOWN = 0x700,
SDL_FINGERUP,
SDL_FINGERMOTION,
SDL_DOLLARGESTURE = 0x800,
SDL_DOLLARRECORD,
SDL_MULTIGESTURE,
SDL_CLIPBOARDUPDATE = 0x900,
SDL_DROPFILE = 0x1000,
SDL_USEREVENT = 0x8000,
SDL_LASTEVENT = 0xFFFF
}
}
mixin(expandEnum!SDL_EventType);
struct SDL_CommonEvent {
SDL_EventType type;
uint timestamp;
}
static if(sdlSupport >= SDLSupport.sdl209) {
struct SDL_DisplayEvent {
SDL_EventType type;
uint timestamp;
uint display;
ubyte event;
ubyte padding1;
ubyte padding2;
ubyte padding3;
int data1;
}
}
struct SDL_WindowEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
SDL_WindowEventID event;
ubyte padding1;
ubyte padding2;
ubyte padding3;
int data1;
int data2;
}
struct SDL_KeyboardEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
ubyte state;
ubyte repeat;
ubyte padding2;
ubyte padding3;
SDL_Keysym keysym;
}
enum SDL_TEXTEDITINGEVENT_TEXT_SIZE = 32;
struct SDL_TextEditingEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
char[SDL_TEXTEDITINGEVENT_TEXT_SIZE] text;
int start;
int length;
}
enum SDL_TEXTINPUTEVENT_TEXT_SIZE = 32;
struct SDL_TextInputEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
char[SDL_TEXTINPUTEVENT_TEXT_SIZE] text;
}
struct SDL_MouseMotionEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
uint which;
uint state;
int x;
int y;
int xrel;
int yrel;
}
struct SDL_MouseButtonEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
uint which;
ubyte button;
ubyte state;
static if(sdlSupport == SDLSupport.sdl200) {
ubyte padding1;
ubyte padding2;
}
else {
ubyte clicks;
ubyte padding1;
}
int x;
int y;
}
struct SDL_MouseWheelEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
uint which;
int x;
int y;
static if(sdlSupport >= SDLSupport.sdl204) {
uint direction;
}
}
struct SDL_JoyAxisEvent {
SDL_EventType type;
uint timestamp;
SDL_JoystickID which;
ubyte axis;
ubyte padding1;
ubyte padding2;
ubyte padding3;
short value;
ushort padding4;
}
struct SDL_JoyBallEvent {
SDL_EventType type;
uint timestamp;
SDL_JoystickID which;
ubyte ball;
ubyte padding1;
ubyte padding2;
ubyte padding3;
short xrel;
short yrel;
}
struct SDL_JoyHatEvent {
SDL_EventType type;
uint timestamp;
SDL_JoystickID which;
ubyte hat;
ubyte value;
ubyte padding1;
ubyte padding2;
}
struct SDL_JoyButtonEvent {
SDL_EventType type;
uint timestamp;
SDL_JoystickID which;
ubyte button;
ubyte state;
ubyte padding1;
ubyte padding2;
}
struct SDL_JoyDeviceEvent {
SDL_EventType type;
uint timestamp;
int which;
}
struct SDL_ControllerAxisEvent {
SDL_EventType type;
uint timestamp;
SDL_JoystickID which;
ubyte axis;
ubyte padding1;
ubyte padding2;
ubyte padding3;
short value;
ushort padding4;
}
struct SDL_ControllerButtonEvent {
SDL_EventType type;
uint timestamp;
SDL_JoystickID which;
ubyte button;
ubyte state;
ubyte padding1;
ubyte padding2;
}
struct SDL_ControllerDeviceEvent {
SDL_EventType type;
uint timestamp;
int which;
}
static if(sdlSupport >= SDLSupport.sdl204) {
struct SDL_AudioDeviceEvent {
uint type;
uint timestamp;
uint which;
ubyte iscapture;
ubyte padding1;
ubyte padding2;
ubyte padding3;
}
}
struct SDL_TouchFingerEvent {
SDL_EventType type;
uint timestamp;
SDL_TouchID touchId;
SDL_FingerID fingerId;
float x;
float y;
float dx;
float dy;
float pressure;
}
struct SDL_MultiGestureEvent {
SDL_EventType type;
uint timestamp;
SDL_TouchID touchId;
float dTheta;
float dDist;
float x;
float y;
ushort numFingers;
ushort padding;
}
struct SDL_DollarGestureEvent {
SDL_EventType type;
uint timestamp;
SDL_TouchID touchId;
SDL_GestureID gestureId;
uint numFingers;
float error;
float x;
float y;
}
struct SDL_DropEvent {
SDL_EventType type;
uint timestamp;
char* file;
static if(sdlSupport >= SDLSupport.sdl205) {
uint windowID;
}
}
struct SDL_SensorEvent {
SDL_EventType type;
uint timestamp;
int which;
float[6] data;
}
struct SDL_QuitEvent {
SDL_EventType type;
uint timestamp;
}
struct SDL_OSEvent {
SDL_EventType type;
uint timestamp;
}
struct SDL_UserEvent {
SDL_EventType type;
uint timestamp;
uint windowID;
int code;
void* data1;
void* data2;
}
struct SDL_SysWMEvent {
SDL_EventType type;
uint timestamp;
SDL_SysWMmsg* msg;
}
union SDL_Event {
SDL_EventType type;
SDL_CommonEvent common;
static if(sdlSupport >= SDLSupport.sdl209) {
SDL_DisplayEvent display;
}
SDL_WindowEvent window;
SDL_KeyboardEvent key;
SDL_TextEditingEvent edit;
SDL_TextInputEvent text;
SDL_MouseMotionEvent motion;
SDL_MouseButtonEvent button;
SDL_MouseWheelEvent wheel;
SDL_JoyAxisEvent jaxis;
SDL_JoyBallEvent jball;
SDL_JoyHatEvent jhat;
SDL_JoyButtonEvent jbutton;
SDL_JoyDeviceEvent jdevice;
SDL_ControllerAxisEvent caxis;
SDL_ControllerButtonEvent cbutton;
SDL_ControllerDeviceEvent cdevice;
static if(sdlSupport >= SDLSupport.sdl204) {
SDL_AudioDeviceEvent adevice;
}
static if(sdlSupport >= SDLSupport.sdl209) {
SDL_SensorEvent sensor;
}
SDL_QuitEvent quit;
SDL_UserEvent user;
SDL_SysWMEvent syswm;
SDL_TouchFingerEvent tfinger;
SDL_MultiGestureEvent mgesture;
SDL_DollarGestureEvent dgesture;
SDL_DropEvent drop;
ubyte[56] padding;
}
enum SDL_eventaction {
SDL_ADDEVENT,
SDL_PEEKEVENT,
SDL_GETEVENT
}
alias SDL_EventAction = SDL_eventaction;
mixin(expandEnum!SDL_EventAction);
extern(C) nothrow alias SDL_EventFilter = int function(void* userdata, SDL_Event* event);
enum {
SDL_QUERY = -1,
SDL_IGNORE = 0,
SDL_DISABLE = 0,
SDL_ENABLE = 1,
}
@nogc nothrow {
int SDL_GetEventState(SDL_EventType type) {
pragma(inline, true);
return SDL_EventState(type, SDL_QUERY);
}
// This is implemented in SDL_quit.h, but works better here.
bool SDL_QuitRequested() {
pragma(inline, true);
SDL_PumpEvents();
return SDL_PeepEvents(null,0,SDL_PEEKEVENT,SDL_QUIT,SDL_QUIT) > 0;
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
void SDL_PumpEvents();
int SDL_PeepEvents(SDL_Event*,int,SDL_eventaction,uint,uint);
SDL_bool SDL_HasEvent(uint);
SDL_bool SDL_HasEvents(uint,uint);
void SDL_FlushEvent(uint);
void SDL_FlushEvents(uint,uint);
int SDL_PollEvent(SDL_Event*);
int SDL_WaitEvent(SDL_Event*);
int SDL_WaitEventTimeout(SDL_Event*,int);
int SDL_PushEvent(SDL_Event*);
void SDL_SetEventFilter(SDL_EventFilter,void*);
SDL_bool SDL_GetEventFilter(SDL_EventFilter*,void**);
void SDL_AddEventWatch(SDL_EventFilter,void*);
void SDL_DelEventWatch(SDL_EventFilter,void*);
void SDL_FilterEvents(SDL_EventFilter,void*);
ubyte SDL_EventState(uint,int);
uint SDL_RegisterEvents(int);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_PumpEvents = void function();
alias pSDL_PeepEvents = int function(SDL_Event*,int,SDL_eventaction,uint,uint);
alias pSDL_HasEvent = SDL_bool function(uint);
alias pSDL_HasEvents = SDL_bool function(uint,uint);
alias pSDL_FlushEvent = void function(uint);
alias pSDL_FlushEvents = void function(uint,uint);
alias pSDL_PollEvent = int function(SDL_Event*);
alias pSDL_WaitEvent = int function(SDL_Event*);
alias pSDL_WaitEventTimeout = int function(SDL_Event*,int);
alias pSDL_PushEvent = int function(SDL_Event*);
alias pSDL_SetEventFilter = void function(SDL_EventFilter,void*);
alias pSDL_GetEventFilter = SDL_bool function(SDL_EventFilter*,void**);
alias pSDL_AddEventWatch = void function(SDL_EventFilter,void*);
alias pSDL_DelEventWatch = void function(SDL_EventFilter,void*);
alias pSDL_FilterEvents = void function(SDL_EventFilter,void*);
alias pSDL_EventState = ubyte function(uint,int);
alias pSDL_RegisterEvents = uint function(int);
}
__gshared {
pSDL_PumpEvents SDL_PumpEvents;
pSDL_PeepEvents SDL_PeepEvents;
pSDL_HasEvent SDL_HasEvent;
pSDL_HasEvents SDL_HasEvents;
pSDL_FlushEvent SDL_FlushEvent;
pSDL_FlushEvents SDL_FlushEvents;
pSDL_PollEvent SDL_PollEvent;
pSDL_WaitEvent SDL_WaitEvent;
pSDL_WaitEventTimeout SDL_WaitEventTimeout;
pSDL_PushEvent SDL_PushEvent;
pSDL_SetEventFilter SDL_SetEventFilter;
pSDL_GetEventFilter SDL_GetEventFilter;
pSDL_AddEventWatch SDL_AddEventWatch;
pSDL_DelEventWatch SDL_DelEventWatch;
pSDL_FilterEvents SDL_FilterEvents;
pSDL_EventState SDL_EventState;
pSDL_RegisterEvents SDL_RegisterEvents;
}
}

31
demos/external/imports/bindbc/sdl/bind/sdlfilesystem.d vendored Normal file
View file

@ -0,0 +1,31 @@
// 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.bind.sdlfilesystem;
import bindbc.sdl.config;
version(BindSDL_Static){
extern(C) @nogc nothrow {
static if(sdlSupport >= SDLSupport.sdl201) {
char* SDL_GetBasePath();
char* SDL_GetPrefPath(const(char)* org,const(char)* app);
}
}
}
else {
static if(sdlSupport >= SDLSupport.sdl201) {
extern(C) @nogc nothrow {
alias pSDL_GetBasePath = char* function();
alias pSDL_GetPrefPath = char* function(const(char)* org,const(char)* app);
}
__gshared {
pSDL_GetBasePath SDL_GetBasePath;
pSDL_GetPrefPath SDL_GetPrefPath;
}
}
}

225
demos/external/imports/bindbc/sdl/bind/sdlgamecontroller.d vendored Normal file
View file

@ -0,0 +1,225 @@
// 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.bind.sdlgamecontroller;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdljoystick,
bindbc.sdl.bind.sdlrwops;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
struct SDL_GameController;
enum SDL_GameControllerBindType {
SDL_CONTROLLER_BINDTYPE_NONE = 0,
SDL_CONTROLLER_BINDTYPE_BUTTON,
SDL_CONTROLLER_BINDTYPE_AXIS,
SDL_CONTROLLER_BINDTYPE_HAT,
}
mixin(expandEnum!SDL_GameControllerBindType);
struct SDL_GameControllerButtonBind {
SDL_GameControllerBindType bindType;
union value {
int button;
int axis;
struct hat {
int hat;
int hat_mask;
}
}
alias button = value.button;
alias axis = value.axis;
alias hat = value.hat;
}
enum SDL_GameControllerAxis {
SDL_CONTROLLER_AXIS_INVALID = -1,
SDL_CONTROLLER_AXIS_LEFTX,
SDL_CONTROLLER_AXIS_LEFTY,
SDL_CONTROLLER_AXIS_RIGHTX,
SDL_CONTROLLER_AXIS_RIGHTY,
SDL_CONTROLLER_AXIS_TRIGGERLEFT,
SDL_CONTROLLER_AXIS_TRIGGERRIGHT,
SDL_CONTROLLER_AXIS_MAX
}
mixin(expandEnum!SDL_GameControllerAxis);
enum SDL_GameControllerButton {
SDL_CONTROLLER_BUTTON_INVALID = -1,
SDL_CONTROLLER_BUTTON_A,
SDL_CONTROLLER_BUTTON_B,
SDL_CONTROLLER_BUTTON_X,
SDL_CONTROLLER_BUTTON_Y,
SDL_CONTROLLER_BUTTON_BACK,
SDL_CONTROLLER_BUTTON_GUIDE,
SDL_CONTROLLER_BUTTON_START,
SDL_CONTROLLER_BUTTON_LEFTSTICK,
SDL_CONTROLLER_BUTTON_RIGHTSTICK,
SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
SDL_CONTROLLER_BUTTON_DPAD_UP,
SDL_CONTROLLER_BUTTON_DPAD_DOWN,
SDL_CONTROLLER_BUTTON_DPAD_LEFT,
SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
SDL_CONTROLLER_BUTTON_MAX
}
mixin(expandEnum!SDL_GameControllerButton);
static if(sdlSupport >= SDLSupport.sdl202) {
@nogc nothrow
int SDL_GameControllerAddMappingsFromFile(const(char)* file) {
pragma(inline, true);
return SDL_GameControllerAddMappingsFromRW(SDL_RWFromFile(file,"rb"),1);
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_GameControllerAddMapping(const(char)*);
char* SDL_GameControllerMappingForGUID(SDL_JoystickGUID);
char* SDL_GameControllerMapping(SDL_GameController*);
SDL_bool SDL_IsGameController(int);
const(char)* SDL_GameControllerNameForIndex(int);
SDL_GameController* SDL_GameControllerOpen(int);
const(char)* SDL_GameControllerName(SDL_GameController*);
SDL_bool SDL_GameControllerGetAttached(SDL_GameController*);
SDL_Joystick* SDL_GameControllerGetJoystick(SDL_GameController*);
int SDL_GameControllerEventState(int);
void SDL_GameControllerUpdate();
SDL_GameControllerAxis SDL_GameControllerGetAxisFromString(const(char)*);
const(char)* SDL_GameControllerGetStringForAxis(SDL_GameControllerAxis);
SDL_GameControllerButtonBind SDL_GameControllerGetBindForAxis(SDL_GameController*,SDL_GameControllerAxis);
short SDL_GameControllerGetAxis(SDL_GameController*,SDL_GameControllerAxis);
SDL_GameControllerButton SDL_GameControllerGetButtonFromString(const(char*));
const(char)* SDL_GameControllerGetStringForButton(SDL_GameControllerButton);
SDL_GameControllerButtonBind SDL_GameControllerGetBindForButton(SDL_GameController*,SDL_GameControllerButton);
ubyte SDL_GameControllerGetButton(SDL_GameController*,SDL_GameControllerButton);
void SDL_GameControllerClose(SDL_GameController*);
static if(sdlSupport >= SDLSupport.sdl202) {
int SDL_GameControllerAddMappingsFromRW(SDL_RWops*,int);
}
static if(sdlSupport >= SDLSupport.sdl204) {
SDL_GameController* SDL_GameControllerFromInstanceID(SDL_JoystickID);
}
static if(sdlSupport >= SDLSupport.sdl206) {
ushort SDL_GameControllerGetProduct(SDL_GameController*);
ushort SDL_GameControllerGetProductVersion(SDL_GameController*);
ushort SDL_GameControllerGetVendor(SDL_GameController*);
char* SDL_GameControllerMappingForIndex(int);
int SDL_GameControllerNumMappings();
}
static if(sdlSupport >= SDLSupport.sdl209) {
char* SDL_GameControllerMappingForDeviceIndex(int);
int SDL_GameControllerRumble(SDL_GameController*,ushort,ushort,uint);
}
static if(sdlSupport >= SDLSupport.sdl2010) {
int SDL_GameControllerGetPlayerIndex(SDL_GameController*);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GameControllerAddMapping = int function(const(char)*);
alias pSDL_GameControllerMappingForGUID = char* function(SDL_JoystickGUID);
alias pSDL_GameControllerMapping = char* function(SDL_GameController*);
alias pSDL_IsGameController = SDL_bool function(int);
alias pSDL_GameControllerNameForIndex = const(char)* function(int);
alias pSDL_GameControllerOpen = SDL_GameController* function(int);
alias pSDL_GameControllerName = const(char)* function(SDL_GameController*);
alias pSDL_GameControllerGetAttached = SDL_bool function(SDL_GameController*);
alias pSDL_GameControllerGetJoystick = SDL_Joystick* function(SDL_GameController*);
alias pSDL_GameControllerEventState = int function(int);
alias pSDL_GameControllerUpdate = void function();
alias pSDL_GameControllerGetAxisFromString = SDL_GameControllerAxis function(const(char)*);
alias pSDL_GameControllerGetStringForAxis = const(char)* function(SDL_GameControllerAxis);
alias pSDL_GameControllerGetBindForAxis = SDL_GameControllerButtonBind function(SDL_GameController*,SDL_GameControllerAxis);
alias pSDL_GameControllerGetAxis = short function(SDL_GameController*,SDL_GameControllerAxis);
alias pSDL_GameControllerGetButtonFromString = SDL_GameControllerButton function(const(char*));
alias pSDL_GameControllerGetStringForButton = const(char)* function(SDL_GameControllerButton);
alias pSDL_GameControllerGetBindForButton = SDL_GameControllerButtonBind function(SDL_GameController*,SDL_GameControllerButton);
alias pSDL_GameControllerGetButton = ubyte function(SDL_GameController*,SDL_GameControllerButton);
alias pSDL_GameControllerClose = void function(SDL_GameController*);
}
__gshared {
pSDL_GameControllerAddMapping SDL_GameControllerAddMapping;
pSDL_GameControllerMappingForGUID SDL_GameControllerMappingForGUID;
pSDL_GameControllerMapping SDL_GameControllerMapping;
pSDL_IsGameController SDL_IsGameController;
pSDL_GameControllerNameForIndex SDL_GameControllerNameForIndex;
pSDL_GameControllerOpen SDL_GameControllerOpen;
pSDL_GameControllerName SDL_GameControllerName;
pSDL_GameControllerGetAttached SDL_GameControllerGetAttached;
pSDL_GameControllerGetJoystick SDL_GameControllerGetJoystick;
pSDL_GameControllerEventState SDL_GameControllerEventState;
pSDL_GameControllerUpdate SDL_GameControllerUpdate;
pSDL_GameControllerGetAxisFromString SDL_GameControllerGetAxisFromString;
pSDL_GameControllerGetStringForAxis SDL_GameControllerGetStringForAxis;
pSDL_GameControllerGetBindForAxis SDL_GameControllerGetBindForAxis;
pSDL_GameControllerGetAxis SDL_GameControllerGetAxis;
pSDL_GameControllerGetButtonFromString SDL_GameControllerGetButtonFromString;
pSDL_GameControllerGetStringForButton SDL_GameControllerGetStringForButton;
pSDL_GameControllerGetBindForButton SDL_GameControllerGetBindForButton;
pSDL_GameControllerGetButton SDL_GameControllerGetButton;
pSDL_GameControllerClose SDL_GameControllerClose;
}
static if(sdlSupport >= SDLSupport.sdl202) {
extern(C) @nogc nothrow {
alias pSDL_GameControllerAddMappingsFromRW = int function(SDL_RWops*,int);
}
__gshared {
pSDL_GameControllerAddMappingsFromRW SDL_GameControllerAddMappingsFromRW;
}
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_GameControllerFromInstanceID = SDL_GameController* function(SDL_JoystickID);
}
__gshared {
pSDL_GameControllerFromInstanceID SDL_GameControllerFromInstanceID;
}
}
static if(sdlSupport >= SDLSupport.sdl206) {
extern(C) @nogc nothrow {
alias pSDL_GameControllerGetProduct = ushort function(SDL_GameController*);
alias pSDL_GameControllerGetProductVersion = ushort function(SDL_GameController*);
alias pSDL_GameControllerGetVendor = ushort function(SDL_GameController*);
alias pSDL_GameControllerMappingForIndex = char* function(int);
alias pSDL_GameControllerNumMappings = int function();
}
__gshared {
pSDL_GameControllerGetProduct SDL_GameControllerGetProduct;
pSDL_GameControllerGetProductVersion SDL_GameControllerGetProductVersion;
pSDL_GameControllerGetVendor SDL_GameControllerGetVendor;
pSDL_GameControllerMappingForIndex SDL_GameControllerMappingForIndex;
pSDL_GameControllerNumMappings SDL_GameControllerNumMappings;
}
}
static if(sdlSupport >= SDLSupport.sdl209) {
extern(C) @nogc nothrow {
alias pSDL_GameControllerMappingForDeviceIndex = char* function(int);
alias pSDL_GameControllerRumble = int function(SDL_GameController*,ushort,ushort,uint);
}
__gshared {
pSDL_GameControllerMappingForDeviceIndex SDL_GameControllerMappingForDeviceIndex;
pSDL_GameControllerRumble SDL_GameControllerRumble;
}
}
static if(sdlSupport >= SDLSupport.sdl2010) {
extern(C) @nogc nothrow {
alias pSDL_GameControllerGetPlayerIndex = int function(SDL_GameController*);
}
__gshared {
pSDL_GameControllerGetPlayerIndex SDL_GameControllerGetPlayerIndex;
}
}
}

36
demos/external/imports/bindbc/sdl/bind/sdlgesture.d vendored Normal file
View file

@ -0,0 +1,36 @@
// 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.bind.sdlgesture;
import bindbc.sdl.bind.sdltouch : SDL_TouchID;
import bindbc.sdl.bind.sdlrwops : SDL_RWops;
alias SDL_GestureID = long;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_RecordGesture(SDL_TouchID);
int SDL_SaveAllDollarTemplates(SDL_RWops*);
int SDL_SaveDollarTemplate(SDL_GestureID,SDL_RWops*);
int SDL_LoadDollarTemplates(SDL_TouchID,SDL_RWops*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_RecordGesture = int function(SDL_TouchID);
alias pSDL_SaveAllDollarTemplates = int function(SDL_RWops*);
alias pSDL_SaveDollarTemplate = int function(SDL_GestureID,SDL_RWops*);
alias pSDL_LoadDollarTemplates = int function(SDL_TouchID,SDL_RWops*);
}
__gshared {
pSDL_RecordGesture SDL_RecordGesture;
pSDL_SaveAllDollarTemplates SDL_SaveAllDollarTemplates;
pSDL_SaveDollarTemplate SDL_SaveDollarTemplate;
pSDL_LoadDollarTemplates SDL_LoadDollarTemplates;
}
}

240
demos/external/imports/bindbc/sdl/bind/sdlhaptic.d vendored Normal file
View file

@ -0,0 +1,240 @@
// 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.bind.sdlhaptic;
import bindbc.sdl.bind.sdljoystick : SDL_Joystick;
struct SDL_Haptic;
enum : ushort {
SDL_HAPTIC_CONSTANT = 1u<<0,
SDL_HAPTIC_SINE = 1u<<1,
SDL_HAPTIC_LEFTRIGHT = 1u<<2,
SDL_HAPTIC_TRIANGLE = 1u<<3,
SDL_HAPTIC_SAWTOOTHUP = 1u<<4,
SDL_HAPTIC_SAWTOOTHDOWN = 1u<<5,
SDL_HAPTIC_RAMP = 1u<<6,
SDL_HAPTIC_SPRING = 1u<<7,
SDL_HAPTIC_DAMPER = 1u<<8,
SDL_HAPTIC_INERTIA = 1u<<9,
SDL_HAPTIC_FRICTION = 1u<<10,
SDL_HAPTIC_CUSTOM = 1u<<11,
SDL_HAPTIC_GAIN = 1u<<12,
SDL_HAPTIC_AUTOCENTER = 1u<<13,
SDL_HAPTIC_STATUS = 1u<<14,
SDL_HAPTIC_PAUSE = 1u<<15,
}
enum {
SDL_HAPTIC_POLAR = 0,
SDL_HAPTIC_CARTESIAN = 1,
SDL_HAPTIC_SPHERICAL = 2,
}
enum SDL_HAPTIC_INFINITY = 4294967295U;
struct SDL_HapticDirection {
ubyte type;
int[3] dir;
}
struct SDL_HapticConstant {
ushort type;
SDL_HapticDirection direction;
uint length;
ushort delay;
ushort button;
ushort interval;
short level;
ushort attack_length;
ushort attack_level;
ushort fade_length;
ushort fade_level;
}
struct SDL_HapticPeriodic {
ushort type;
SDL_HapticDirection direction;
uint length;
uint delay;
ushort button;
ushort interval;
ushort period;
short magnitude;
short offset;
ushort phase;
ushort attack_length;
ushort attack_level;
ushort fade_length;
ushort fade_level;
}
struct SDL_HapticCondition {
ushort type;
SDL_HapticDirection direciton;
uint length;
ushort delay;
ushort button;
ushort interval;
ushort[3] right_sat;
ushort[3] left_sat;
short[3] right_coeff;
short[3] left_coeff;
ushort[3] deadband;
ushort[3] center;
}
struct SDL_HapticRamp {
ushort type;
SDL_HapticDirection direction;
uint length;
ushort delay;
ushort button;
ushort interval;
short start;
short end;
ushort attack_length;
ushort attack_level;
ushort fade_length;
ushort fade_level;
}
struct SDL_HapticLeftRight {
ushort type;
uint length;
ushort large_magnitude;
ushort small_magnitude;
}
struct SDL_HapticCustom {
ushort type;
SDL_HapticDirection direction;
uint length;
ushort delay;
ushort button;
ushort interval;
ubyte channels;
ushort period;
ushort samples;
ushort* data;
ushort attack_length;
ushort attack_level;
ushort fade_length;
ushort fade_level;
}
union SDL_HapticEffect {
ushort type;
SDL_HapticConstant constant;
SDL_HapticPeriodic periodic;
SDL_HapticCondition condition;
SDL_HapticRamp ramp;
SDL_HapticLeftRight leftright;
SDL_HapticCustom custom;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_NumHaptics();
const(char)* SDL_HapticName(int);
SDL_Haptic* SDL_HapticOpen(int);
int SDL_HapticOpened(int);
int SDL_HapticIndex(SDL_Haptic*);
int SDL_MouseIsHaptic();
SDL_Haptic* SDL_HapticOpenFromMouse();
int SDL_JoystickIsHaptic(SDL_Joystick*);
SDL_Haptic* SDL_HapticOpenFromJoystick(SDL_Joystick*);
int SDL_HapticClose(SDL_Haptic*);
int SDL_HapticNumEffects(SDL_Haptic*);
int SDL_HapticNumEffectsPlaying(SDL_Haptic*);
uint SDL_HapticQuery(SDL_Haptic*);
int SDL_HapticNumAxes(SDL_Haptic*);
int SDL_HapticEffectSupported(SDL_Haptic*,SDL_HapticEffect*);
int SDL_HapticNewEffect(SDL_Haptic*,SDL_HapticEffect*);
int SDL_HapticUpdateEffect(SDL_Haptic*,int,SDL_HapticEffect*);
int SDL_HapticRunEffect(SDL_Haptic*,int,uint);
int SDL_HapticStopEffect(SDL_Haptic*,int);
int SDL_HapticDestroyEffect(SDL_Haptic*,int);
int SDL_HapticGetEffectStatus(SDL_Haptic*,int);
int SDL_HapticSetGain(SDL_Haptic*,int);
int SDL_HapticSetAutocenter(SDL_Haptic*,int);
int SDL_HapticPause(SDL_Haptic*);
int SDL_HapticUnpause(SDL_Haptic*);
int SDL_HapticStopAll(SDL_Haptic*);
int SDL_HapticRumbleSupported(SDL_Haptic*);
int SDL_HapticRumbleInit(SDL_Haptic*);
int SDL_HapticRumblePlay(SDL_Haptic*,float,uint);
int SDL_HapticRumbleStop(SDL_Haptic*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_NumHaptics = int function();
alias pSDL_HapticName = const(char)* function(int);
alias pSDL_HapticOpen = SDL_Haptic* function(int);
alias pSDL_HapticOpened = int function(int);
alias pSDL_HapticIndex = int function(SDL_Haptic*);
alias pSDL_MouseIsHaptic = int function();
alias pSDL_HapticOpenFromMouse = SDL_Haptic* function();
alias pSDL_JoystickIsHaptic = int function(SDL_Joystick*);
alias pSDL_HapticOpenFromJoystick = SDL_Haptic* function(SDL_Joystick*);
alias pSDL_HapticClose = int function(SDL_Haptic*);
alias pSDL_HapticNumEffects = int function(SDL_Haptic*);
alias pSDL_HapticNumEffectsPlaying = int function(SDL_Haptic*);
alias pSDL_HapticQuery = uint function(SDL_Haptic*);
alias pSDL_HapticNumAxes = int function(SDL_Haptic*);
alias pSDL_HapticEffectSupported = int function(SDL_Haptic*,SDL_HapticEffect*);
alias pSDL_HapticNewEffect = int function(SDL_Haptic*,SDL_HapticEffect*);
alias pSDL_HapticUpdateEffect = int function(SDL_Haptic*,int,SDL_HapticEffect*);
alias pSDL_HapticRunEffect = int function(SDL_Haptic*,int,uint);
alias pSDL_HapticStopEffect = int function(SDL_Haptic*,int);
alias pSDL_HapticDestroyEffect = int function(SDL_Haptic*,int);
alias pSDL_HapticGetEffectStatus = int function(SDL_Haptic*,int);
alias pSDL_HapticSetGain = int function(SDL_Haptic*,int);
alias pSDL_HapticSetAutocenter = int function(SDL_Haptic*,int);
alias pSDL_HapticPause = int function(SDL_Haptic*);
alias pSDL_HapticUnpause = int function(SDL_Haptic*);
alias pSDL_HapticStopAll = int function(SDL_Haptic*);
alias pSDL_HapticRumbleSupported = int function(SDL_Haptic*);
alias pSDL_HapticRumbleInit = int function(SDL_Haptic*);
alias pSDL_HapticRumblePlay = int function(SDL_Haptic*,float,uint);
alias pSDL_HapticRumbleStop = int function(SDL_Haptic*);
}
__gshared {
pSDL_NumHaptics SDL_NumHaptics;
pSDL_HapticName SDL_HapticName;
pSDL_HapticOpen SDL_HapticOpen;
pSDL_HapticOpened SDL_HapticOpened;
pSDL_HapticIndex SDL_HapticIndex;
pSDL_MouseIsHaptic SDL_MouseIsHaptic;
pSDL_HapticOpenFromMouse SDL_HapticOpenFromMouse;
pSDL_JoystickIsHaptic SDL_JoystickIsHaptic;
pSDL_HapticOpenFromJoystick SDL_HapticOpenFromJoystick;
pSDL_HapticClose SDL_HapticClose;
pSDL_HapticNumEffects SDL_HapticNumEffects;
pSDL_HapticNumEffectsPlaying SDL_HapticNumEffectsPlaying;
pSDL_HapticQuery SDL_HapticQuery;
pSDL_HapticNumAxes SDL_HapticNumAxes;
pSDL_HapticEffectSupported SDL_HapticEffectSupported;
pSDL_HapticNewEffect SDL_HapticNewEffect;
pSDL_HapticUpdateEffect SDL_HapticUpdateEffect;
pSDL_HapticRunEffect SDL_HapticRunEffect;
pSDL_HapticStopEffect SDL_HapticStopEffect;
pSDL_HapticDestroyEffect SDL_HapticDestroyEffect;
pSDL_HapticGetEffectStatus SDL_HapticGetEffectStatus;
pSDL_HapticSetGain SDL_HapticSetGain;
pSDL_HapticSetAutocenter SDL_HapticSetAutocenter;
pSDL_HapticPause SDL_HapticPause;
pSDL_HapticUnpause SDL_HapticUnpause;
pSDL_HapticStopAll SDL_HapticStopAll;
pSDL_HapticRumbleSupported SDL_HapticRumbleSupported;
pSDL_HapticRumbleInit SDL_HapticRumbleInit;
pSDL_HapticRumblePlay SDL_HapticRumblePlay;
pSDL_HapticRumbleStop SDL_HapticRumbleStop;
}
}

186
demos/external/imports/bindbc/sdl/bind/sdlhints.d vendored Normal file
View file

@ -0,0 +1,186 @@
// 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.bind.sdlhints;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
enum SDL_HINT_FRAMEBUFFER_ACCELERATION = "SDL_FRAMEBUFFER_ACCELERATION";
enum SDL_HINT_RENDER_DRIVER = "SDL_RENDER_DRIVER";
enum SDL_HINT_RENDER_OPENGL_SHADERS = "SDL_RENDER_OPENGL_SHADERS";
enum SDL_HINT_RENDER_SCALE_QUALITY = "SDL_RENDER_SCALE_QUALITY";
enum SDL_HINT_RENDER_VSYNC = "SDL_RENDER_VSYNC";
enum SDL_HINT_VIDEO_X11_XVIDMODE = "SDL_VIDEO_X11_XVIDMODE";
enum SDL_HINT_VIDEO_X11_XINERAMA = "SDL_VIDEO_X11_XINERAMA";
enum SDL_HINT_VIDEO_X11_XRANDR = "SDL_VIDEO_X11_XRANDR";
enum SDL_HINT_GRAB_KEYBOARD = "SDL_GRAB_KEYBOARD";
enum SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS = "SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS";
enum SDL_HINT_IDLE_TIMER_DISABLED = "SDL_IOS_IDLE_TIMER_DISABLED";
enum SDL_HINT_ORIENTATIONS = "SDL_IOS_ORIENTATIONS";
enum SDL_HINT_XINPUT_ENABLED = "SDL_XINPUT_ENABLED";
enum SDL_HINT_GAMECONTROLLERCONFIG = "SDL_GAMECONTROLLERCONFIG";
enum SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS = "SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS";
enum SDL_HINT_ALLOW_TOPMOST = "SDL_ALLOW_TOPMOST";
enum SDL_HINT_TIMER_RESOLUTION = "SDL_TIMER_RESOLUTION";
static if(sdlSupport >= SDLSupport.sdl201) {
enum SDL_HINT_RENDER_DIRECT3D_THREADSAFE = "SDL_RENDER_DIRECT3D_THREADSAFE";
enum SDL_HINT_VIDEO_HIGHDPI_DISABLED = "SDL_VIDEO_HIGHDPI_DISABLED";
}
static if(sdlSupport >= SDLSupport.sdl202) {
enum SDL_HINT_VIDEO_ALLOW_SCREENSAVER = "SDL_VIDEO_ALLOW_SCREENSAVER";
enum SDL_HINT_MOUSE_RELATIVE_MODE_WARP = "SDL_MOUSE_RELATIVE_MODE_WARP";
enum SDL_HINT_ACCELEROMETER_AS_JOYSTICK = "SDL_ACCELEROMETER_AS_JOYSTICK";
enum SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK = "SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK";
enum SDL_HINT_VIDEO_WIN_D3DCOMPILER = "SDL_VIDEO_WIN_D3DCOMPILER";
enum SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT = "SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT";
enum SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES = "SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES";
}
// This is *intended* to be == and not >=. The values for all of these changed in 2.0.4.
static if(sdlSupport == SDLSupport.sdl203) {
enum SDL_HINT_RENDER_DIRECT3D11_DEBUG = "SDL_HINT_RENDER_DIRECT3D11_DEBUG";
enum SDL_HINT_WINRT_PRIVACY_POLICY_URL = "SDL_HINT_WINRT_PRIVACY_POLICY_URL";
enum SDL_HINT_WINRT_PRIVACY_POLICY_LABEL = "SDL_HINT_WINRT_PRIVACY_POLICY_LABEL";
enum SDL_HINT_WINRT_HANDLE_BACK_BUTTON = "SDL_HINT_WINRT_HANDLE_BACK_BUTTON";
}
static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_HINT_VIDEO_X11_NET_WM_PING = "SDL_VIDEO_X11_NET_WM_PING";
enum SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN = "SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN";
enum SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP = "SDL_WINDOWS_ENABLE_MESSAGELOOP";
enum SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING = "SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING";
enum SDL_HINT_THREAD_STACK_SIZE = "SDL_THREAD_STACK_SIZE";
enum SDL_HINT_MAC_BACKGROUND_APP = "SDL_MAC_BACKGROUND_APP";
enum SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION = "SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION";
enum SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION = "SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION";
enum SDL_HINT_IME_INTERNAL_EDITING = "SDL_IME_INTERNAL_EDITING";
enum SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT = "SDL_EMSCRIPTEN_KEYBOARD_ELEMENT";
enum SDL_HINT_NO_SIGNAL_HANDLERS = "SDL_NO_SIGNAL_HANDLERS";
enum SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4 = "SDL_WINDOWS_NO_CLOSE_ON_ALT_F4";
// Changed values from those introduced in 2.0.3
enum SDL_HINT_RENDER_DIRECT3D11_DEBUG = "SDL_RENDER_DIRECT3D11_DEBUG";
enum SDL_HINT_WINRT_PRIVACY_POLICY_URL = "SDL_WINRT_PRIVACY_POLICY_URL";
enum SDL_HINT_WINRT_PRIVACY_POLICY_LABEL = "SDL_WINRT_PRIVACY_POLICY_LABEL";
enum SDL_HINT_WINRT_HANDLE_BACK_BUTTON = "SDL_WINRT_HANDLE_BACK_BUTTON";
}
static if(sdlSupport >= SDLSupport.sdl205) {
enum SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH = "SDL_MOUSE_FOCUS_CLICKTHROUGH";
enum SDL_HINT_APPLE_TV_CONTROLLER_UI_EVENTS = "SDL_APPLE_TV_CONTROLLER_UI_EVENTS";
enum SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION = "SDL_APPLE_TV_REMOTE_ALLOW_ROTATION";
enum SDL_HINT_BMP_SAVE_LEGACY_FORMAT = "SDL_BMP_SAVE_LEGACY_FORMAT";
enum SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING = "SDL_WINDOWS_DISABLE_THREAD_NAMING";
enum SDL_HINT_RPI_VIDEO_LAYER = "SDL_RPI_VIDEO_LAYER";
}
static if(sdlSupport >= SDLSupport.sdl206) {
enum SDL_HINT_RENDER_LOGICAL_SIZE_MODE = "SDL_RENDER_LOGICAL_SIZE_MODE";
enum SDL_HINT_WINDOWS_INTRESOURCE_ICON = "SDL_WINDOWS_INTRESOURCE_ICON";
enum SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL = "SDL_WINDOWS_INTRESOURCE_ICON_SMALL";
enum SDL_HINT_MOUSE_NORMAL_SPEED_SCALE = "SDL_MOUSE_NORMAL_SPEED_SCALE";
enum SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE = "SDL_MOUSE_RELATIVE_SPEED_SCALE";
enum SDL_HINT_TOUCH_MOUSE_EVENTS = "SDL_TOUCH_MOUSE_EVENTS";
enum SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES = "SDL_GAMECONTROLLER_IGNORE_DEVICES";
enum SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT = "SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT";
enum SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION = "SDL_QTWAYLAND_CONTENT_ORIENTATION";
enum SDL_HINT_QTWAYLAND_WINDOW_FLAGS = "SDL_QTWAYLAND_WINDOW_FLAGS";
enum SDL_HINT_OPENGL_ES_DRIVER = "SDL_OPENGL_ES_DRIVER";
enum SDL_HINT_AUDIO_RESAMPLING_MODE = "SDL_AUDIO_RESAMPLING_MODE";
enum SDL_HINT_AUDIO_CATEGORY = "SDL_AUDIO_CATEGORY";
}
static if(sdlSupport >= SDLSupport.sdl208) {
enum SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR = "SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR";
enum SDL_HINT_IOS_HIDE_HOME_INDICATOR = "SDL_IOS_HIDE_HOME_INDICATOR";
enum SDL_HINT_TV_REMOTE_AS_JOYSTICK = "SDL_TV_REMOTE_AS_JOYSTICK";
enum SDL_HINT_RETURN_KEY_HIDES_IME = "SDL_RETURN_KEY_HIDES_IME";
enum SDL_HINT_VIDEO_DOUBLE_BUFFER = "SDL_VIDEO_DOUBLE_BUFFER";
}
static if(sdlSupport >= SDLSupport.sdl209) {
enum SDL_HINT_MOUSE_DOUBLE_CLICK_TIME = "SDL_MOUSE_DOUBLE_CLICK_TIME";
enum SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS = "SDL_MOUSE_DOUBLE_CLICK_RADIUS";
enum SDL_HINT_JOYSTICK_HIDAPI = "SDL_JOYSTICK_HIDAPI";
enum SDL_HINT_JOYSTICK_HIDAPI_PS4 = "SDL_JOYSTICK_HIDAPI_PS4";
enum SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE = "SDL_JOYSTICK_HIDAPI_PS4_RUMBLE";
enum SDL_HINT_JOYSTICK_HIDAPI_STEAM = "SDL_JOYSTICK_HIDAPI_STEAM";
enum SDL_HINT_JOYSTICK_HIDAPI_SWITCH = "SDL_JOYSTICK_HIDAPI_SWITCH";
enum SDL_HINT_JOYSTICK_HIDAPI_XBOX = "SDL_JOYSTICK_HIDAPI_XBOX";
enum SDL_HINT_ENABLE_STEAM_CONTROLLERS = "SDL_ENABLE_STEAM_CONTROLLERS";
enum SDL_HINT_ANDROID_TRAP_BACK_BUTTON = "SDL_ANDROID_TRAP_BACK_BUTTON";
}
static if(sdlSupport >= SDLSupport.sdl2010) {
enum SDL_HINT_MOUSE_TOUCH_EVENTS = "SDL_MOUSE_TOUCH_EVENTS";
enum SDL_HINT_GAMECONTROLLERCONFIG_FILE = "SDL_GAMECONTROLLERCONFIG_FILE";
enum SDL_HINT_ANDROID_BLOCK_ON_PAUSE = "SDL_ANDROID_BLOCK_ON_PAUSE";
enum SDL_HINT_RENDER_BATCHING = "SDL_RENDER_BATCHING";
enum SDL_HINT_EVENT_LOGGING = "SDL_EVENT_LOGGING";
enum SDL_HINT_WAVE_RIFF_CHUNK_SIZE = "SDL_WAVE_RIFF_CHUNK_SIZE";
enum SDL_HINT_WAVE_TRUNCATION = "SDL_WAVE_TRUNCATION";
enum SDL_HINT_WAVE_FACT_CHUNK = "SDL_WAVE_FACT_CHUNK";
}
else static if(sdlSupport >= SDLSupport.sdl204) {
// Added in 2.0.4, removed in 2.0.10.
enum SDL_HINT_ANDROID_SEPARATE_MOUSE_AND_TOUCH = "SDL_ANDROID_SEPARATE_MOUSE_AND_TOUCH";
}
enum SDL_HintPriority {
SDL_HINT_DEFAULT,
SDL_HINT_NORMAL,
SDL_HINT_OVERRIDE,
}
mixin(expandEnum!SDL_HintPriority);
extern(C) nothrow alias SDL_HintCallback = void function(void*, const(char)*, const(char)*);
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_bool SDL_SetHintWithPriority(const(char)*,const(char)*,SDL_HintPriority);
SDL_bool SDL_SetHint(const(char)*,const(char)*);
const(char)* SDL_GetHint(const(char)*);
void SDL_AddHintCallback(const(char)*,SDL_HintCallback,void*);
void SDL_DelHintCallback(const(char)*,SDL_HintCallback,void*);
void SDL_ClearHints();
static if(sdlSupport >= SDLSupport.sdl205) {
SDL_bool SDL_GetHintBoolean(const(char)*,SDL_bool);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_SetHintWithPriority = SDL_bool function(const(char)*,const(char)*,SDL_HintPriority);
alias pSDL_SetHint = SDL_bool function(const(char)*,const(char)*);
alias pSDL_GetHint = const(char)* function(const(char)*);
alias pSDL_AddHintCallback = void function(const(char)*,SDL_HintCallback,void*);
alias pSDL_DelHintCallback = void function(const(char)*,SDL_HintCallback,void*);
alias pSDL_ClearHints = void function();
}
__gshared {
pSDL_SetHintWithPriority SDL_SetHintWithPriority;
pSDL_SetHint SDL_SetHint;
pSDL_GetHint SDL_GetHint;
pSDL_AddHintCallback SDL_AddHintCallback;
pSDL_DelHintCallback SDL_DelHintCallback;
pSDL_ClearHints SDL_ClearHints;
}
static if(sdlSupport >= SDLSupport.sdl205) {
extern(C) @nogc nothrow {
alias pSDL_GetHintBoolean = SDL_bool function(const(char)*,SDL_bool);
}
__gshared {
pSDL_GetHintBoolean SDL_GetHintBoolean;
}
}
}

231
demos/external/imports/bindbc/sdl/bind/sdljoystick.d vendored Normal file
View file

@ -0,0 +1,231 @@
// 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.bind.sdljoystick;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
struct SDL_Joystick;
struct SDL_JoystickGUID {
ubyte[16] data;
}
alias SDL_JoystickID = int;
enum : ubyte {
SDL_HAT_CENTERED = 0x00,
SDL_HAT_UP = 0x01,
SDL_HAT_RIGHT = 0x02,
SDL_HAT_DOWN = 0x04,
SDL_HAT_LEFT = 0x08,
SDL_HAT_RIGHTUP = (SDL_HAT_RIGHT|SDL_HAT_UP),
SDL_HAT_RIGHTDOWN = (SDL_HAT_RIGHT|SDL_HAT_DOWN),
SDL_HAT_LEFTUP = (SDL_HAT_LEFT|SDL_HAT_UP),
SDL_HAT_LEFTDOWN = (SDL_HAT_LEFT|SDL_HAT_DOWN),
}
static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_JoystickPowerLevel {
SDL_JOYSTICK_POWER_UNKNOWN = -1,
SDL_JOYSTICK_POWER_EMPTY,
SDL_JOYSTICK_POWER_LOW,
SDL_JOYSTICK_POWER_MEDIUM,
SDL_JOYSTICK_POWER_FULL,
SDL_JOYSTICK_POWER_WIRED,
SDL_JOYSTICK_POWER_MAX
}
mixin(expandEnum!SDL_JoystickPowerLevel);
}
static if(sdlSupport >= SDLSupport.sdl206) {
enum SDL_JoystickType {
SDL_JOYSTICK_TYPE_UNKNOWN,
SDL_JOYSTICK_TYPE_GAMECONTROLLER,
SDL_JOYSTICK_TYPE_WHEEL,
SDL_JOYSTICK_TYPE_ARCADE_STICK,
SDL_JOYSTICK_TYPE_FLIGHT_STICK,
SDL_JOYSTICK_TYPE_DANCE_PAD,
SDL_JOYSTICK_TYPE_GUITAR,
SDL_JOYSTICK_TYPE_DRUM_KIT,
SDL_JOYSTICK_TYPE_ARCADE_PAD,
SDL_JOYSTICK_TYPE_THROTTLE,
}
mixin(expandEnum!SDL_JoystickType);
enum {
SDL_JOYSTICK_AXIS_MAX = 32767,
SDL_JOYSTICK_AXIS_MIN = -32768,
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_NumJoysticks();
const(char)* SDL_JoystickNameForIndex(int);
SDL_JoystickGUID SDL_JoystickGetDeviceGUID(int);
SDL_Joystick* SDL_JoystickOpen(int);
const(char)* SDL_JoystickName(SDL_Joystick*);
SDL_JoystickGUID SDL_JoystickGetGUID(SDL_Joystick*);
char* SDL_JoystickGetGUIDString(SDL_JoystickGUID);
SDL_JoystickGUID SDL_JoystickGetGUIDFromString(const(char)*);
SDL_bool SDL_JoystickGetAttached(SDL_Joystick*);
SDL_JoystickID SDL_JoystickInstanceID(SDL_Joystick*);
int SDL_JoystickNumAxes(SDL_Joystick*);
int SDL_JoystickNumBalls(SDL_Joystick*);
int SDL_JoystickNumHats(SDL_Joystick*);
int SDL_JoystickNumButtons(SDL_Joystick*);
void SDL_JoystickUpdate();
int SDL_JoystickEventState(int);
short SDL_JoystickGetAxis(SDL_Joystick*,int);
ubyte SDL_JoystickGetHat(SDL_Joystick*,int);
int SDL_JoystickGetBall(SDL_Joystick*,int,int*,int*);
ubyte SDL_JoystickGetButton(SDL_Joystick*,int);
void SDL_JoystickClose(SDL_Joystick*);
static if(sdlSupport >= SDLSupport.sdl204) {
SDL_JoystickPowerLevel SDL_JoystickCurrentPowerLevel(SDL_Joystick*);
SDL_Joystick* SDL_JoystickFromInstanceID(SDL_JoystickID);
}
static if(sdlSupport >= SDLSupport.sdl206) {
SDL_bool SDL_JoystickGetAxisInitialState(SDL_Joystick*,int,short*);
SDL_JoystickType SDL_JoystickGetDeviceInstanceID(int);
ushort SDL_JoystickGetDeviceProduct(int);
ushort SDL_JoystickGetDeviceProductVersion(int);
SDL_JoystickType SDL_JoystickGetDeviceType(int);
ushort SDL_JoystickGetDeviceVendor(int);
ushort SDL_JoystickGetProduct(SDL_Joystick*);
ushort SDL_JoystickGetProductVersion(SDL_Joystick*);
SDL_JoystickType SDL_JoystickGetType(SDL_Joystick*);
ushort SDL_JoystickGetVendor(SDL_Joystick*);
}
static if(sdlSupport >= SDLSupport.sdl207) {
void SDL_LockJoysticks();
void SDL_UnlockJoysticks();
}
static if(sdlSupport >= SDLSupport.sdl209) {
int SDL_JoystickRumble(SDL_Joystick*,ushort,ushort,uint);
}
static if(sdlSupport >= SDLSupport.sdl2010) {
int SDL_JoystickGetDevicePlayerIndex(int);
int SDL_JoystickGetPlayerIndex(SDL_Joystick*);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_NumJoysticks = int function();
alias pSDL_JoystickNameForIndex = const(char)* function(int);
alias pSDL_JoystickGetDeviceGUID = SDL_JoystickGUID function(int);
alias pSDL_JoystickOpen = SDL_Joystick* function(int);
alias pSDL_JoystickName = const(char)* function(SDL_Joystick*);
alias pSDL_JoystickGetGUID = SDL_JoystickGUID function(SDL_Joystick*);
alias pSDL_JoystickGetGUIDString = char* function(SDL_JoystickGUID);
alias pSDL_JoystickGetGUIDFromString = SDL_JoystickGUID function(const(char)*);
alias pSDL_JoystickGetAttached = SDL_bool function(SDL_Joystick*);
alias pSDL_JoystickInstanceID = SDL_JoystickID function(SDL_Joystick*);
alias pSDL_JoystickNumAxes = int function(SDL_Joystick*);
alias pSDL_JoystickNumBalls = int function(SDL_Joystick*);
alias pSDL_JoystickNumHats = int function(SDL_Joystick*);
alias pSDL_JoystickNumButtons = int function(SDL_Joystick*);
alias pSDL_JoystickUpdate = void function();
alias pSDL_JoystickEventState = int function(int);
alias pSDL_JoystickGetAxis = short function(SDL_Joystick*,int);
alias pSDL_JoystickGetHat = ubyte function(SDL_Joystick*,int);
alias pSDL_JoystickGetBall = int function(SDL_Joystick*,int,int*,int*);
alias pSDL_JoystickGetButton = ubyte function(SDL_Joystick*,int);
alias pSDL_JoystickClose = void function(SDL_Joystick*);
}
__gshared {
pSDL_NumJoysticks SDL_NumJoysticks;
pSDL_JoystickNameForIndex SDL_JoystickNameForIndex;
pSDL_JoystickGetDeviceGUID SDL_JoystickGetDeviceGUID;
pSDL_JoystickOpen SDL_JoystickOpen;
pSDL_JoystickName SDL_JoystickName;
pSDL_JoystickGetGUID SDL_JoystickGetGUID;
pSDL_JoystickGetGUIDString SDL_JoystickGetGUIDString;
pSDL_JoystickGetGUIDFromString SDL_JoystickGetGUIDFromString;
pSDL_JoystickGetAttached SDL_JoystickGetAttached;
pSDL_JoystickInstanceID SDL_JoystickInstanceID;
pSDL_JoystickNumAxes SDL_JoystickNumAxes;
pSDL_JoystickNumBalls SDL_JoystickNumBalls;
pSDL_JoystickNumHats SDL_JoystickNumHats;
pSDL_JoystickNumButtons SDL_JoystickNumButtons;
pSDL_JoystickUpdate SDL_JoystickUpdate;
pSDL_JoystickEventState SDL_JoystickEventState;
pSDL_JoystickGetAxis SDL_JoystickGetAxis;
pSDL_JoystickGetHat SDL_JoystickGetHat;
pSDL_JoystickGetBall SDL_JoystickGetBall;
pSDL_JoystickGetButton SDL_JoystickGetButton;
pSDL_JoystickClose SDL_JoystickClose;
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_JoystickCurrentPowerLevel = SDL_JoystickPowerLevel function(SDL_Joystick*);
alias pSDL_JoystickFromInstanceID = SDL_Joystick* function(SDL_JoystickID);
}
__gshared {
pSDL_JoystickCurrentPowerLevel SDL_JoystickCurrentPowerLevel;
pSDL_JoystickFromInstanceID SDL_JoystickFromInstanceID;
}
}
static if(sdlSupport >= SDLSupport.sdl206) {
extern(C) @nogc nothrow {
alias pSDL_JoystickGetAxisInitialState = SDL_bool function(SDL_Joystick*,int,short*);
alias pSDL_JoystickGetDeviceInstanceID = SDL_JoystickType function(int);
alias pSDL_JoystickGetDeviceProduct = ushort function(int);
alias pSDL_JoystickGetDeviceProductVersion = ushort function(int);
alias pSDL_JoystickGetDeviceType = SDL_JoystickType function(int);
alias pSDL_JoystickGetDeviceVendor = ushort function(int);
alias pSDL_JoystickGetProduct = ushort function(SDL_Joystick*);
alias pSDL_JoystickGetProductVersion = ushort function(SDL_Joystick*);
alias pSDL_JoystickGetType = SDL_JoystickType function(SDL_Joystick*);
alias pSDL_JoystickGetVendor = ushort function(SDL_Joystick*);
}
__gshared {
pSDL_JoystickGetAxisInitialState SDL_JoystickGetAxisInitialState;
pSDL_JoystickGetDeviceInstanceID SDL_JoystickGetDeviceInstanceID;
pSDL_JoystickGetDeviceProduct SDL_JoystickGetDeviceProduct;
pSDL_JoystickGetDeviceProductVersion SDL_JoystickGetDeviceProductVersion;
pSDL_JoystickGetDeviceType SDL_JoystickGetDeviceType;
pSDL_JoystickGetDeviceVendor SDL_JoystickGetDeviceVendor;
pSDL_JoystickGetProduct SDL_JoystickGetProduct;
pSDL_JoystickGetProductVersion SDL_JoystickGetProductVersion;
pSDL_JoystickGetType SDL_JoystickGetType;
pSDL_JoystickGetVendor SDL_JoystickGetVendor;
}
}
static if(sdlSupport >= SDLSupport.sdl207) {
extern(C) @nogc nothrow {
alias pSDL_LockJoysticks = void function();
alias pSDL_UnlockJoysticks = void function();
}
__gshared {
pSDL_LockJoysticks SDL_LockJoysticks;
pSDL_UnlockJoysticks SDL_UnlockJoysticks;
}
}
static if(sdlSupport >= SDLSupport.sdl209) {
extern(C) @nogc nothrow {
alias pSDL_JoystickRumble = int function(SDL_Joystick*,ushort,ushort,uint);
}
__gshared {
pSDL_JoystickRumble SDL_JoystickRumble;
}
}
static if(sdlSupport >= SDLSupport.sdl2010) {
extern(C) @nogc nothrow {
alias pSDL_JoystickGetDevicePlayerIndex = int function(int);
alias pSDL_JoystickGetPlayerIndex = int function(SDL_Joystick*);
}
__gshared {
pSDL_JoystickGetDevicePlayerIndex SDL_JoystickGetDevicePlayerIndex;
pSDL_JoystickGetPlayerIndex SDL_JoystickGetPlayerIndex;
}
}
}

80
demos/external/imports/bindbc/sdl/bind/sdlkeyboard.d vendored Normal file
View file

@ -0,0 +1,80 @@
// 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.bind.sdlkeyboard;
import bindbc.sdl.bind.sdlkeycode : SDL_Keycode, SDL_Keymod;
import bindbc.sdl.bind.sdlrect : SDL_Rect;
import bindbc.sdl.bind.sdlscancode : SDL_Scancode;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
struct SDL_Keysym {
SDL_Scancode scancode;
SDL_Keycode sym;
ushort mod;
uint unused;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_Window* SDL_GetKeyboardFocus();
ubyte* SDL_GetKeyboardState(int*);
SDL_Keymod SDL_GetModState();
void SDL_SetModState(SDL_Keymod);
SDL_Keycode SDL_GetKeyFromScancode(SDL_Scancode);
SDL_Scancode SDL_GetScancodeFromKey(SDL_Keycode);
const(char)* SDL_GetScancodeName(SDL_Scancode);
SDL_Scancode SDL_GetScancodeFromName(const(char)*);
const(char)* SDL_GetKeyName(SDL_Keycode);
SDL_Keycode SDL_GetKeyFromName(const(char)*);
void SDL_StartTextInput();
SDL_bool SDL_IsTextInputActive();
void SDL_StopTextInput();
void SDL_SetTextInputRect(SDL_Rect*);
SDL_bool SDL_HasScreenKeyboardSupport();
SDL_bool SDL_IsScreenKeyboardShown(SDL_Window*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetKeyboardFocus = SDL_Window* function();
alias pSDL_GetKeyboardState = ubyte* function(int*);
alias pSDL_GetModState = SDL_Keymod function();
alias pSDL_SetModState = void function(SDL_Keymod);
alias pSDL_GetKeyFromScancode = SDL_Keycode function(SDL_Scancode);
alias pSDL_GetScancodeFromKey = SDL_Scancode function(SDL_Keycode);
alias pSDL_GetScancodeName = const(char)* function(SDL_Scancode);
alias pSDL_GetScancodeFromName = SDL_Scancode function(const(char)*);
alias pSDL_GetKeyName = const(char)* function(SDL_Keycode);
alias pSDL_GetKeyFromName = SDL_Keycode function(const(char)*);
alias pSDL_StartTextInput = void function();
alias pSDL_IsTextInputActive = SDL_bool function();
alias pSDL_StopTextInput = void function();
alias pSDL_SetTextInputRect = void function(SDL_Rect*);
alias pSDL_HasScreenKeyboardSupport = SDL_bool function();
alias pSDL_IsScreenKeyboardShown = SDL_bool function(SDL_Window*);
}
__gshared {
pSDL_GetKeyboardFocus SDL_GetKeyboardFocus;
pSDL_GetKeyboardState SDL_GetKeyboardState;
pSDL_GetModState SDL_GetModState;
pSDL_SetModState SDL_SetModState;
pSDL_GetKeyFromScancode SDL_GetKeyFromScancode;
pSDL_GetScancodeFromKey SDL_GetScancodeFromKey;
pSDL_GetScancodeName SDL_GetScancodeName;
pSDL_GetScancodeFromName SDL_GetScancodeFromName;
pSDL_GetKeyName SDL_GetKeyName;
pSDL_GetKeyFromName SDL_GetKeyFromName;
pSDL_StartTextInput SDL_StartTextInput;
pSDL_IsTextInputActive SDL_IsTextInputActive;
pSDL_StopTextInput SDL_StopTextInput;
pSDL_SetTextInputRect SDL_SetTextInputRect;
pSDL_HasScreenKeyboardSupport SDL_HasScreenKeyboardSupport;
pSDL_IsScreenKeyboardShown SDL_IsScreenKeyboardShown;
}
}

288
demos/external/imports/bindbc/sdl/bind/sdlkeycode.d vendored Normal file
View file

@ -0,0 +1,288 @@
// 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.bind.sdlkeycode;
import bindbc.sdl.config,
bindbc.sdl.bind.sdlscancode;
enum SDLK_SCANCODE_MASK = 1<<30;
enum SDL_SCANCODE_TO_KEYCODE(SDL_Scancode x) = x | SDLK_SCANCODE_MASK;
enum SDL_Keycode {
SDLK_UNKNOWN = 0,
SDLK_RETURN = '\r',
SDLK_ESCAPE = '\033',
SDLK_BACKSPACE = '\b',
SDLK_TAB = '\t',
SDLK_SPACE = ' ',
SDLK_EXCLAIM = '!',
SDLK_QUOTEDBL = '"',
SDLK_HASH = '#',
SDLK_PERCENT = '%',
SDLK_DOLLAR = '$',
SDLK_AMPERSAND = '&',
SDLK_QUOTE = '\'',
SDLK_LEFTPAREN = '(',
SDLK_RIGHTPAREN = ')',
SDLK_ASTERISK = '*',
SDLK_PLUS = '+',
SDLK_COMMA = ',',
SDLK_MINUS = '-',
SDLK_PERIOD = '.',
SDLK_SLASH = '/',
SDLK_0 = '0',
SDLK_1 = '1',
SDLK_2 = '2',
SDLK_3 = '3',
SDLK_4 = '4',
SDLK_5 = '5',
SDLK_6 = '6',
SDLK_7 = '7',
SDLK_8 = '8',
SDLK_9 = '9',
SDLK_COLON = ':',
SDLK_SEMICOLON = ';',
SDLK_LESS = '<',
SDLK_EQUALS = '=',
SDLK_GREATER = '>',
SDLK_QUESTION = '?',
SDLK_AT = '@',
SDLK_LEFTBRACKET = '[',
SDLK_BACKSLASH = '\\',
SDLK_RIGHTBRACKET = ']',
SDLK_CARET = '^',
SDLK_UNDERSCORE = '_',
SDLK_BACKQUOTE = '`',
SDLK_a = 'a',
SDLK_b = 'b',
SDLK_c = 'c',
SDLK_d = 'd',
SDLK_e = 'e',
SDLK_f = 'f',
SDLK_g = 'g',
SDLK_h = 'h',
SDLK_i = 'i',
SDLK_j = 'j',
SDLK_k = 'k',
SDLK_l = 'l',
SDLK_m = 'm',
SDLK_n = 'n',
SDLK_o = 'o',
SDLK_p = 'p',
SDLK_q = 'q',
SDLK_r = 'r',
SDLK_s = 's',
SDLK_t = 't',
SDLK_u = 'u',
SDLK_v = 'v',
SDLK_w = 'w',
SDLK_x = 'x',
SDLK_y = 'y',
SDLK_z = 'z',
SDLK_CAPSLOCK = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CAPSLOCK),
SDLK_F1 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F1),
SDLK_F2 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F2),
SDLK_F3 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F3),
SDLK_F4 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F4),
SDLK_F5 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F5),
SDLK_F6 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F6),
SDLK_F7 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F7),
SDLK_F8 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F8),
SDLK_F9 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F9),
SDLK_F10 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F10),
SDLK_F11 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F11),
SDLK_F12 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F12),
SDLK_PRINTSCREEN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_PRINTSCREEN),
SDLK_SCROLLLOCK = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_SCROLLLOCK),
SDLK_PAUSE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_PAUSE),
SDLK_INSERT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_INSERT),
SDLK_HOME = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_HOME),
SDLK_PAGEUP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_PAGEUP),
SDLK_DELETE = '\177',
SDLK_END = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_END),
SDLK_PAGEDOWN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_PAGEDOWN),
SDLK_RIGHT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_RIGHT),
SDLK_LEFT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_LEFT),
SDLK_DOWN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_DOWN),
SDLK_UP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_UP),
SDLK_NUMLOCKCLEAR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_NUMLOCKCLEAR),
SDLK_KP_DIVIDE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_DIVIDE),
SDLK_KP_MULTIPLY = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MULTIPLY),
SDLK_KP_MINUS = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MINUS),
SDLK_KP_PLUS = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_PLUS),
SDLK_KP_ENTER = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_ENTER),
SDLK_KP_1 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_1),
SDLK_KP_2 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_2),
SDLK_KP_3 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_3),
SDLK_KP_4 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_4),
SDLK_KP_5 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_5),
SDLK_KP_6 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_6),
SDLK_KP_7 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_7),
SDLK_KP_8 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_8),
SDLK_KP_9 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_9),
SDLK_KP_0 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_0),
SDLK_KP_PERIOD = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_PERIOD),
SDLK_APPLICATION = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_APPLICATION),
SDLK_POWER = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_POWER),
SDLK_KP_EQUALS = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_EQUALS),
SDLK_F13 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F13),
SDLK_F14 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F14),
SDLK_F15 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F15),
SDLK_F16 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F16),
SDLK_F17 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F17),
SDLK_F18 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F18),
SDLK_F19 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F19),
SDLK_F20 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F20),
SDLK_F21 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F21),
SDLK_F22 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F22),
SDLK_F23 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F23),
SDLK_F24 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_F24),
SDLK_EXECUTE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_EXECUTE),
SDLK_HELP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_HELP),
SDLK_MENU = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_MENU),
SDLK_SELECT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_SELECT),
SDLK_STOP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_STOP),
SDLK_AGAIN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AGAIN),
SDLK_UNDO = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_UNDO),
SDLK_CUT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CUT),
SDLK_COPY = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_COPY),
SDLK_PASTE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_PASTE),
SDLK_FIND = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_FIND),
SDLK_MUTE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_MUTE),
SDLK_VOLUMEUP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_VOLUMEUP),
SDLK_VOLUMEDOWN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_VOLUMEDOWN),
SDLK_KP_COMMA = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_COMMA),
SDLK_KP_EQUALSAS400 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_EQUALSAS400),
SDLK_ALTERASE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_ALTERASE),
SDLK_SYSREQ = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_SYSREQ),
SDLK_CANCEL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CANCEL),
SDLK_CLEAR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CLEAR),
SDLK_PRIOR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_PRIOR),
SDLK_RETURN2 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_RETURN2),
SDLK_SEPARATOR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_SEPARATOR),
SDLK_OUT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_OUT),
SDLK_OPER = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_OPER),
SDLK_CLEARAGAIN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CLEARAGAIN),
SDLK_CRSEL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CRSEL),
SDLK_EXSEL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_EXSEL),
SDLK_KP_00 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_00),
SDLK_KP_000 = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_000),
SDLK_THOUSANDSSEPARATOR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_THOUSANDSSEPARATOR),
SDLK_DECIMALSEPARATOR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_DECIMALSEPARATOR),
SDLK_CURRENCYUNIT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CURRENCYUNIT),
SDLK_CURRENCYSUBUNIT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CURRENCYSUBUNIT),
SDLK_KP_LEFTPAREN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_LEFTPAREN),
SDLK_KP_RIGHTPAREN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_RIGHTPAREN),
SDLK_KP_LEFTBRACE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_LEFTBRACE),
SDLK_KP_RIGHTBRACE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_RIGHTBRACE),
SDLK_KP_TAB = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_TAB),
SDLK_KP_BACKSPACE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_BACKSPACE),
SDLK_KP_A = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_A),
SDLK_KP_B = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_B),
SDLK_KP_C = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_C),
SDLK_KP_D = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_D),
SDLK_KP_E = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_E),
SDLK_KP_F = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_F),
SDLK_KP_XOR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_XOR),
SDLK_KP_POWER = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_POWER),
SDLK_KP_PERCENT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_PERCENT),
SDLK_KP_LESS = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_LESS),
SDLK_KP_GREATER = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_GREATER),
SDLK_KP_AMPERSAND = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_AMPERSAND),
SDLK_KP_DBLAMPERSAND = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_DBLAMPERSAND),
SDLK_KP_VERTICALBAR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_VERTICALBAR),
SDLK_KP_DBLVERTICALBAR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_DBLVERTICALBAR),
SDLK_KP_COLON = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_COLON),
SDLK_KP_HASH = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_HASH),
SDLK_KP_SPACE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_SPACE),
SDLK_KP_AT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_AT),
SDLK_KP_EXCLAM = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_EXCLAM),
SDLK_KP_MEMSTORE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MEMSTORE),
SDLK_KP_MEMRECALL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MEMRECALL),
SDLK_KP_MEMCLEAR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MEMCLEAR),
SDLK_KP_MEMADD = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MEMADD),
SDLK_KP_MEMSUBTRACT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MEMSUBTRACT),
SDLK_KP_MEMMULTIPLY = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MEMMULTIPLY),
SDLK_KP_MEMDIVIDE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_MEMDIVIDE),
SDLK_KP_PLUSMINUS = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_PLUSMINUS),
SDLK_KP_CLEAR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_CLEAR),
SDLK_KP_CLEARENTRY = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_CLEARENTRY),
SDLK_KP_BINARY = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_BINARY),
SDLK_KP_OCTAL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_OCTAL),
SDLK_KP_DECIMAL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_DECIMAL),
SDLK_KP_HEXADECIMAL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KP_HEXADECIMAL),
SDLK_LCTRL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_LCTRL),
SDLK_LSHIFT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_LSHIFT),
SDLK_LALT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_LALT),
SDLK_LGUI = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_LGUI),
SDLK_RCTRL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_RCTRL),
SDLK_RSHIFT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_RSHIFT),
SDLK_RALT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_RALT),
SDLK_RGUI = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_RGUI),
SDLK_MODE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_MODE),
SDLK_AUDIONEXT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AUDIONEXT),
SDLK_AUDIOPREV = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AUDIOPREV),
SDLK_AUDIOSTOP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AUDIOSTOP),
SDLK_AUDIOPLAY = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AUDIOPLAY),
SDLK_AUDIOMUTE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AUDIOMUTE),
SDLK_MEDIASELECT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_MEDIASELECT),
SDLK_WWW = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_WWW),
SDLK_MAIL = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_MAIL),
SDLK_CALCULATOR = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_CALCULATOR),
SDLK_COMPUTER = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_COMPUTER),
SDLK_AC_SEARCH = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AC_SEARCH),
SDLK_AC_HOME = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AC_HOME),
SDLK_AC_BACK = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AC_BACK),
SDLK_AC_FORWARD = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AC_FORWARD),
SDLK_AC_STOP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AC_STOP),
SDLK_AC_REFRESH = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AC_REFRESH),
SDLK_AC_BOOKMARKS = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_AC_BOOKMARKS),
SDLK_BRIGHTNESSDOWN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_BRIGHTNESSDOWN),
SDLK_BRIGHTNESSUP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_BRIGHTNESSUP),
SDLK_DISPLAYSWITCH = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_DISPLAYSWITCH),
SDLK_KBDILLUMTOGGLE = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KBDILLUMTOGGLE),
SDLK_KBDILLUMDOWN = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KBDILLUMDOWN),
SDLK_KBDILLUMUP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_KBDILLUMUP),
SDLK_EJECT = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_EJECT),
SDLK_SLEEP = SDL_SCANCODE_TO_KEYCODE!(SDL_Scancode.SDL_SCANCODE_SLEEP),
}
mixin(expandEnum!SDL_Keycode);
enum SDL_Keymod {
KMOD_NONE = 0x0000,
KMOD_LSHIFT = 0x0001,
KMOD_RSHIFT = 0x0002,
KMOD_LCTRL = 0x0040,
KMOD_RCTRL = 0x0080,
KMOD_LALT = 0x0100,
KMOD_RALT = 0x0200,
KMOD_LGUI = 0x0400,
KMOD_RGUI = 0x0800,
KMOD_NUM = 0x1000,
KMOD_CAPS = 0x2000,
KMOD_MODE = 0x4000,
KMOD_RESERVED = 0x8000,
KMOD_CTRL = (KMOD_LCTRL|KMOD_RCTRL),
KMOD_SHIFT = (KMOD_LSHIFT|KMOD_RSHIFT),
KMOD_ALT = (KMOD_LALT|KMOD_RALT),
KMOD_GUI = (KMOD_LGUI|KMOD_RGUI),
}
mixin(expandEnum!SDL_Keymod);

28
demos/external/imports/bindbc/sdl/bind/sdlloadso.d vendored Normal file
View file

@ -0,0 +1,28 @@
// 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.bind.sdlloadso;
version(BindSDL_Static){
extern(C) @nogc nothrow {
void* SDL_LoadObject(const(char)*);
void* SDL_LoadFunction(void*,const(char*));
void SDL_UnloadObject(void*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_LoadObject = void* function(const(char)*);
alias pSDL_LoadFunction = void* function(void*,const(char*));
alias pSDL_UnloadObject = void function(void*);
}
__gshared {
pSDL_LoadObject SDL_LoadObject;
pSDL_LoadFunction SDL_LoadFunction;
pSDL_UnloadObject SDL_UnloadObject;
}
}

107
demos/external/imports/bindbc/sdl/bind/sdllog.d vendored Normal file
View file

@ -0,0 +1,107 @@
// 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.bind.sdllog;
import core.stdc.stdarg : va_list;
import bindbc.sdl.config;
enum SDL_MAX_LOG_MESSAGE = 4096;
enum {
SDL_LOG_CATEGORY_APPLICATION,
SDL_LOG_CATEGORY_ERROR,
SDL_LOG_CATEGORY_ASSERT,
SDL_LOG_CATEGORY_SYSTEM,
SDL_LOG_CATEGORY_AUDIO,
SDL_LOG_CATEGORY_VIDEO,
SDL_LOG_CATEGORY_RENDER,
SDL_LOG_CATEGORY_INPUT,
SDL_LOG_CATEGORY_TEST,
SDL_LOG_CATEGORY_RESERVED1,
SDL_LOG_CATEGORY_RESERVED2,
SDL_LOG_CATEGORY_RESERVED3,
SDL_LOG_CATEGORY_RESERVED4,
SDL_LOG_CATEGORY_RESERVED5,
SDL_LOG_CATEGORY_RESERVED6,
SDL_LOG_CATEGORY_RESERVED7,
SDL_LOG_CATEGORY_RESERVED8,
SDL_LOG_CATEGORY_RESERVED9,
SDL_LOG_CATEGORY_RESERVED10,
SDL_LOG_CATEGORY_CUSTOM
}
enum SDL_LogPriority {
SDL_LOG_PRIORITY_VERBOSE = 1,
SDL_LOG_PRIORITY_DEBUG,
SDL_LOG_PRIORITY_INFO,
SDL_LOG_PRIORITY_WARN,
SDL_LOG_PRIORITY_ERROR,
SDL_LOG_PRIORITY_CRITICAL,
SDL_NUM_LOG_PRIORITIES
}
mixin(expandEnum!SDL_LogPriority);
extern(C) nothrow alias SDL_LogOutputFunction = void function(void*, int, SDL_LogPriority, const(char)*);
version(BindSDL_Static) {
extern(C) @nogc nothrow {
void SDL_LogSetAllPriority(SDL_LogPriority);
void SDL_LogSetPriority(int,SDL_LogPriority);
SDL_LogPriority SDL_LogGetPriority(int);
void SDL_LogResetPriorities();
void SDL_Log(const(char)*,...);
void SDL_LogVerbose(int,const(char)*,...);
void SDL_LogDebug(int,const(char)*,...);
void SDL_LogInfo(int,const(char)*,...);
void SDL_LogWarn(int,const(char)*,...);
void SDL_LogError(int,const(char)*,...);
void SDL_LogCritical(int,const(char)*,...);
void SDL_LogMessage(int,SDL_LogPriority,const(char)*,...);
void SDL_LogMessageV(int,SDL_LogPriority,const(char)*,va_list);
void SDL_LogGetOutputFunction(SDL_LogOutputFunction,void**);
void SDL_LogSetOutputFunction(SDL_LogOutputFunction,void*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_LogSetAllPriority = void function(SDL_LogPriority);
alias pSDL_LogSetPriority = void function(int,SDL_LogPriority);
alias pSDL_LogGetPriority = SDL_LogPriority function(int);
alias pSDL_LogResetPriorities = void function();
alias pSDL_Log = void function(const(char)*,...);
alias pSDL_LogVerbose = void function(int,const(char)*,...);
alias pSDL_LogDebug = void function(int,const(char)*,...);
alias pSDL_LogInfo = void function(int,const(char)*,...);
alias pSDL_LogWarn = void function(int,const(char)*,...);
alias pSDL_LogError = void function(int,const(char)*,...);
alias pSDL_LogCritical = void function(int,const(char)*,...);
alias pSDL_LogMessage = void function(int,SDL_LogPriority,const(char)*,...);
alias pSDL_LogMessageV = void function(int,SDL_LogPriority,const(char)*,va_list);
alias pSDL_LogGetOutputFunction = void function(SDL_LogOutputFunction,void**);
alias pSDL_LogSetOutputFunction = void function(SDL_LogOutputFunction,void*);
}
__gshared {
pSDL_LogSetAllPriority SDL_LogSetAllPriority;
pSDL_LogSetPriority SDL_LogSetPriority;
pSDL_LogGetPriority SDL_LogGetPriority;
pSDL_LogResetPriorities SDL_LogResetPriorities;
pSDL_Log SDL_Log;
pSDL_LogVerbose SDL_LogVerbose;
pSDL_LogDebug SDL_LogDebug;
pSDL_LogInfo SDL_LogInfo;
pSDL_LogWarn SDL_LogWarn;
pSDL_LogError SDL_LogError;
pSDL_LogCritical SDL_LogCritical;
pSDL_LogMessage SDL_LogMessage;
pSDL_LogMessageV SDL_LogMessageV;
pSDL_LogGetOutputFunction SDL_LogGetOutputFunction;
pSDL_LogSetOutputFunction SDL_LogSetOutputFunction;
}
}

75
demos/external/imports/bindbc/sdl/bind/sdlmessagebox.d vendored Normal file
View file

@ -0,0 +1,75 @@
// 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.bind.sdlmessagebox;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
enum SDL_MessageBoxFlags {
SDL_MESSAGEBOX_ERROR = 0x00000010,
SDL_MESSAGEBOX_WARNING = 0x00000020,
SDL_MESSAGEBOX_INFORMATION = 0x00000040,
}
mixin(expandEnum!SDL_MessageBoxFlags);
enum SDL_MessageBoxButtonFlags {
SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = 0x00000001,
SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT = 0x00000002,
}
mixin(expandEnum!SDL_MessageBoxButtonFlags);
struct SDL_MessageBoxButtonData {
uint flags;
int buttonid;
const(char)* text;
}
struct SDL_MessageBoxColor {
ubyte r, g, b;
}
enum SDL_MessageBoxColorType {
SDL_MESSAGEBOX_COLOR_BACKGROUND,
SDL_MESSAGEBOX_COLOR_TEXT,
SDL_MESSAGEBOX_COLOR_BUTTON_BORDER,
SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND,
SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED,
SDL_MESSAGEBOX_COLOR_MAX,
}
mixin(expandEnum!SDL_MessageBoxColorType);
struct SDL_MessageBoxColorScheme {
SDL_MessageBoxColor[SDL_MESSAGEBOX_COLOR_MAX] colors;
}
struct SDL_MessageBoxData {
uint flags;
SDL_Window* window;
const(char)* title;
const(char)* message;
int numbuttons;
const(SDL_MessageBoxButtonData)* buttons;
const(SDL_MessageBoxColorScheme)* colorScheme;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_ShowMessageBox(const(SDL_MessageBoxData)*,int*);
int SDL_ShowSimpleMessageBox(uint,const(char)*,const(char)*,SDL_Window*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_ShowMessageBox = int function(const(SDL_MessageBoxData)*,int*);
alias pSDL_ShowSimpleMessageBox = int function(uint,const(char)*,const(char)*,SDL_Window*);
}
__gshared {
pSDL_ShowMessageBox SDL_ShowMessageBox;
pSDL_ShowSimpleMessageBox SDL_ShowSimpleMessageBox;
}
}

140
demos/external/imports/bindbc/sdl/bind/sdlmouse.d vendored Normal file
View file

@ -0,0 +1,140 @@
// 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.bind.sdlmouse;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlsurface : SDL_Surface;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
struct SDL_Cursor;
enum SDL_SystemCursor {
SDL_SYSTEM_CURSOR_ARROW,
SDL_SYSTEM_CURSOR_IBEAM,
SDL_SYSTEM_CURSOR_WAIT,
SDL_SYSTEM_CURSOR_CROSSHAIR,
SDL_SYSTEM_CURSOR_WAITARROW,
SDL_SYSTEM_CURSOR_SIZENWSE,
SDL_SYSTEM_CURSOR_SIZENESW,
SDL_SYSTEM_CURSOR_SIZEWE,
SDL_SYSTEM_CURSOR_SIZENS,
SDL_SYSTEM_CURSOR_SIZEALL,
SDL_SYSTEM_CURSOR_NO,
SDL_SYSTEM_CURSOR_HAND,
SDL_NUM_SYSTEM_CURSORS
}
alias SDL_SYSTEM_CURSOR_ARROW = SDL_SystemCursor.SDL_SYSTEM_CURSOR_ARROW;
alias SDL_SYSTEM_CURSOR_IBEAM = SDL_SystemCursor.SDL_SYSTEM_CURSOR_IBEAM;
alias SDL_SYSTEM_CURSOR_WAIT = SDL_SystemCursor.SDL_SYSTEM_CURSOR_WAIT;
alias SDL_SYSTEM_CURSOR_CROSSHAIR = SDL_SystemCursor.SDL_SYSTEM_CURSOR_CROSSHAIR;
alias SDL_SYSTEM_CURSOR_WAITARROW = SDL_SystemCursor.SDL_SYSTEM_CURSOR_WAITARROW;
alias SDL_SYSTEM_CURSOR_SIZENWSE = SDL_SystemCursor.SDL_SYSTEM_CURSOR_SIZENWSE;
alias SDL_SYSTEM_CURSOR_SIZENESW = SDL_SystemCursor.SDL_SYSTEM_CURSOR_SIZENESW;
alias SDL_SYSTEM_CURSOR_SIZEWE = SDL_SystemCursor.SDL_SYSTEM_CURSOR_SIZEWE;
alias SDL_SYSTEM_CURSOR_SIZENS = SDL_SystemCursor.SDL_SYSTEM_CURSOR_SIZENS;
alias SDL_SYSTEM_CURSOR_SIZEALL = SDL_SystemCursor.SDL_SYSTEM_CURSOR_SIZEALL;
alias SDL_SYSTEM_CURSOR_NO = SDL_SystemCursor.SDL_SYSTEM_CURSOR_NO;
alias SDL_SYSTEM_CURSOR_HAND = SDL_SystemCursor.SDL_SYSTEM_CURSOR_HAND;
alias SDL_NUM_SYSTEM_CURSORS = SDL_SystemCursor.SDL_NUM_SYSTEM_CURSORS;
enum SDL_BUTTON(ubyte x) = 1 << (x-1);
enum : ubyte {
SDL_BUTTON_LEFT = 1,
SDL_BUTTON_MIDDLE = 2,
SDL_BUTTON_RIGHT = 3,
SDL_BUTTON_X1 = 4,
SDL_BUTTON_X2 = 5,
SDL_BUTTON_LMASK = SDL_BUTTON!(SDL_BUTTON_LEFT),
SDL_BUTTON_MMASK = SDL_BUTTON!(SDL_BUTTON_MIDDLE),
SDL_BUTTON_RMASK = SDL_BUTTON!(SDL_BUTTON_RIGHT),
SDL_BUTTON_X1MASK = SDL_BUTTON!(SDL_BUTTON_X1),
SDL_BUTTON_X2MASK = SDL_BUTTON!(SDL_BUTTON_X2),
}
static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_MouseWheelDirection {
SDL_MOUSEWHEEL_NORMAL,
SDL_MOUSEWHEEL_FLIPPED,
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_Window* SDL_GetMouseFocus();
uint SDL_GetMouseState(int*,int*);
uint SDL_GetRelativeMouseState(int*,int*);
void SDL_WarpMouseInWindow(SDL_Window*,int,int);
int SDL_SetRelativeMouseMode(SDL_bool);
SDL_bool SDL_GetRelativeMouseMode();
SDL_Cursor* SDL_CreateCursor(const(ubyte)*,const(ubyte)*,int,int,int,int);
SDL_Cursor* SDL_CreateColorCursor(SDL_Surface*,int,int);
SDL_Cursor* SDL_CreateSystemCursor(SDL_SystemCursor);
void SDL_SetCursor(SDL_Cursor*);
SDL_Cursor* SDL_GetCursor();
SDL_Cursor* SDL_GetDefaultCursor();
void SDL_FreeCursor(SDL_Cursor*);
int SDL_ShowCursor(int);
static if(sdlSupport >= SDLSupport.sdl204) {
int SDL_CaptureMouse(SDL_bool);
uint SDL_GetGlobalMouseState(int*,int*);
void SDL_WarpMouseGlobal(int,int);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetMouseFocus = SDL_Window* function();
alias pSDL_GetMouseState = uint function(int*,int*);
alias pSDL_GetRelativeMouseState = uint function(int*,int*);
alias pSDL_WarpMouseInWindow = void function(SDL_Window*,int,int);
alias pSDL_SetRelativeMouseMode = int function(SDL_bool);
alias pSDL_GetRelativeMouseMode = SDL_bool function();
alias pSDL_CreateCursor = SDL_Cursor* function(const(ubyte)*,const(ubyte)*,int,int,int,int);
alias pSDL_CreateColorCursor = SDL_Cursor* function(SDL_Surface*,int,int);
alias pSDL_CreateSystemCursor = SDL_Cursor* function(SDL_SystemCursor);
alias pSDL_SetCursor = void function(SDL_Cursor*);
alias pSDL_GetCursor = SDL_Cursor* function();
alias pSDL_GetDefaultCursor = SDL_Cursor* function();
alias pSDL_FreeCursor = void function(SDL_Cursor*);
alias pSDL_ShowCursor = int function(int);
}
__gshared {
pSDL_GetMouseFocus SDL_GetMouseFocus;
pSDL_GetMouseState SDL_GetMouseState;
pSDL_GetRelativeMouseState SDL_GetRelativeMouseState;
pSDL_WarpMouseInWindow SDL_WarpMouseInWindow;
pSDL_SetRelativeMouseMode SDL_SetRelativeMouseMode;
pSDL_GetRelativeMouseMode SDL_GetRelativeMouseMode;
pSDL_CreateCursor SDL_CreateCursor;
pSDL_CreateColorCursor SDL_CreateColorCursor;
pSDL_CreateSystemCursor SDL_CreateSystemCursor;
pSDL_SetCursor SDL_SetCursor;
pSDL_GetCursor SDL_GetCursor;
pSDL_GetDefaultCursor SDL_GetDefaultCursor;
pSDL_FreeCursor SDL_FreeCursor;
pSDL_ShowCursor SDL_ShowCursor;
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_CaptureMouse = int function(SDL_bool);
alias pSDL_GetGlobalMouseState = uint function(int*,int*);
alias pSDL_WarpMouseGlobal = void function(int,int);
}
__gshared {
pSDL_CaptureMouse SDL_CaptureMouse;
pSDL_GetGlobalMouseState SDL_GetGlobalMouseState;
pSDL_WarpMouseGlobal SDL_WarpMouseGlobal;
}
}
}

283
demos/external/imports/bindbc/sdl/bind/sdlpixels.d vendored Normal file
View file

@ -0,0 +1,283 @@
// 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.bind.sdlpixels;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_FOURCC, SDL_bool;
enum SDL_ALPHA_OPAQUE = 255;
enum SDL_ALPHA_TRANSPARENT = 0;
enum {
SDL_PIXELTYPE_UNKNOWN,
SDL_PIXELTYPE_INDEX1,
SDL_PIXELTYPE_INDEX4,
SDL_PIXELTYPE_INDEX8,
SDL_PIXELTYPE_PACKED8,
SDL_PIXELTYPE_PACKED16,
SDL_PIXELTYPE_PACKED32,
SDL_PIXELTYPE_ARRAYU8,
SDL_PIXELTYPE_ARRAYU16,
SDL_PIXELTYPE_ARRAYU32,
SDL_PIXELTYPE_ARRAYF16,
SDL_PIXELTYPE_ARRAYF32
}
enum {
SDL_BITMAPORDER_NONE,
SDL_BITMAPORDER_4321,
SDL_BITMAPORDER_1234
}
enum {
SDL_PACKEDORDER_NONE,
SDL_PACKEDORDER_XRGB,
SDL_PACKEDORDER_RGBX,
SDL_PACKEDORDER_ARGB,
SDL_PACKEDORDER_RGBA,
SDL_PACKEDORDER_XBGR,
SDL_PACKEDORDER_BGRX,
SDL_PACKEDORDER_ABGR,
SDL_PACKEDORDER_BGRA
}
enum {
SDL_ARRAYORDER_NONE,
SDL_ARRAYORDER_RGB,
SDL_ARRAYORDER_RGBA,
SDL_ARRAYORDER_ARGB,
SDL_ARRAYORDER_BGR,
SDL_ARRAYORDER_BGRA,
SDL_ARRAYORDER_ABGR
}
enum {
SDL_PACKEDLAYOUT_NONE,
SDL_PACKEDLAYOUT_332,
SDL_PACKEDLAYOUT_4444,
SDL_PACKEDLAYOUT_1555,
SDL_PACKEDLAYOUT_5551,
SDL_PACKEDLAYOUT_565,
SDL_PACKEDLAYOUT_8888,
SDL_PACKEDLAYOUT_2101010,
SDL_PACKEDLAYOUT_1010102
}
alias SDL_DEFINE_PIXELFOURCC = SDL_FOURCC;
enum uint SDL_DEFINE_PIXELFORMAT(int type, int order, int layout, int bits, int bytes) =
(1 << 28) | (type << 24) | (order << 20) | (layout << 16) | (bits << 8) | (bytes << 0);
enum uint SDL_PIXELFLAG(uint x) = (x >> 28) & 0x0F;
enum uint SDL_PIXELTYPE(uint x) = (x >> 24) & 0x0F;
enum uint SDL_PIXELORDER(uint x) = (x >> 20) & 0x0F;
enum uint SDL_PIXELLAYOUT(uint x) = (x >> 16) & 0x0F;
enum uint SDL_BITSPERPIXEL(uint x) = (x >> 8) & 0xFF;
template SDL_BYTESPERPIXEL(uint x) {
static if(SDL_ISPIXELFORMAT_FOURCC!x) {
static if(x == SDL_PIXELFORMAT_YUY2 || x == SDL_PIXELFORMAT_UYVY || x == SDL_PIXELFORMAT_YVYU)
enum SDL_BYTESPERPIXEL = 2;
else enum SDL_BYTESPERPIXEL = 1;
}
else enum SDL_BYTESPERPIXEL = (x >> 0) & 0xFF;
}
template SDL_ISPIXELFORMAT_INDEXED(uint format) {
static if(SDL_ISPIXELFORMAT_FOURCC!format) {
enum SDL_ISPIXELFORMAT_INDEXED = SDL_PIXELTYPE!format == SDL_PIXELTYPE_INDEX1 || SDL_PIXELTYPE!format == SDL_PIXELTYPE_INDEX4 ||
SDL_PIXELTYPE!format == SDL_PIXELTYPE_INDEX8;
}
else enum SDL_ISPIXELFORMAT_INDEXED = false;
}
template SDL_ISPIXELFORMAT_PACKED(uint format) {
static if(SDL_ISPIXELFORMAT_FOURCC!format) {
enum SDL_ISPIXELFORMAT_PACKED = SDL_PIXELTYPE!format == SDL_PIXELTYPE_PACKED8 || SDL_PIXELTYPE!format == SDL_PIXELTYPE_PACKED16 ||
SDL_PIXELTYPE!format == SDL_PIXELTYPE_PACKED32;
}
else enum SDL_ISPIXELFORMAT_PACKED = false;
}
static if(sdlSupport >= SDLSupport.sdl204) {
template SDL_ISPIXELFORMAT_ARRAY(uint format) {
static if(SDL_ISPIXELFORMAT_FOURCC!format) {
enum SDL_ISPIXELFORMAT_ARRAY = SDL_PIXELTYPE!format == SDL_PIXELTYPE_ARRAYU8 || SDL_PIXELTYPE!format == SDL_PIXELTYPE_ARRAYU16 ||
SDL_PIXELTYPE!format == SDL_PIXELTYPE_ARRAYU32 || SDL_PIXELTYPE!format == SDL_PIXELTYPE_ARRAYF16 ||
SDL_PIXELTYPE!format == SDL_PIXELTYPE_ARRAYF32;
}
else enum SDL_ISPIXELFORMAT_ARRAY = false;
}
}
template SDL_ISPIXELFORMAT_ALPHA(uint format) {
static if(SDL_ISPIXELFORMAT_PACKED!format) {
enum SDL_ISPIXELFORMAT_ALPHA = (SDL_PIXELORDER!format == SDL_PACKEDORDER_ARGB || SDL_PIXELORDER!format == SDL_PACKEDORDER_RGBA ||
SDL_PIXELORDER!format == SDL_PACKEDORDER_ABGR || SDL_PIXELORDER!format == SDL_PACKEDORDER_BGRA);
}
else static if(sdlSupport >= SDLSupport.sdl204 && SDL_ISPIXELFORMAT_ARRAY!format) {
enum SDL_ISPIXELFORMAT_ALPHA = (SDL_PIXELORDER!format == SDL_ARRAYORDER_ARGB || SDL_PIXELORDER!format == SDL_ARRAYORDER_RGBA ||
SDL_PIXELORDER!format == SDL_ARRAYORDER_ABGR || SDL_PIXELORDER!format == SDL_ARRAYORDER_BGRA);
}
else enum SDL_ISPIXELFORMAT_ALPHA = false;
}
enum SDL_ISPIXELFORMAT_FOURCC(uint format) = format && !(format & 0x80000000);
enum SDL_PIXELFORMAT_UNKNOWN = 0;
enum SDL_PIXELFORMAT_INDEX1LSB = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_4321, 0, 1, 0);
enum SDL_PIXELFORMAT_INDEX1MSB = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_INDEX1, SDL_BITMAPORDER_1234, 0, 1, 0);
enum SDL_PIXELFORMAT_INDEX4LSB = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_4321, 0, 4, 0);
enum SDL_PIXELFORMAT_INDEX4MSB = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_INDEX4, SDL_BITMAPORDER_1234, 0, 4, 0);
enum SDL_PIXELFORMAT_INDEX8 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1);
enum SDL_PIXELFORMAT_RGB332 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED8, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_332, 8, 1);
enum SDL_PIXELFORMAT_RGB444 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_4444, 12, 2);
enum SDL_PIXELFORMAT_RGB555 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_1555, 15, 2);
enum SDL_PIXELFORMAT_BGR555 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_1555, 15, 2);
enum SDL_PIXELFORMAT_ARGB4444 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_4444, 16, 2);
enum SDL_PIXELFORMAT_RGBA4444 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_4444, 16, 2);
enum SDL_PIXELFORMAT_ABGR4444 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_4444, 16, 2);
enum SDL_PIXELFORMAT_BGRA4444 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_4444, 16, 2);
enum SDL_PIXELFORMAT_ARGB1555 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_1555, 16, 2);
enum SDL_PIXELFORMAT_RGBA5551 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_5551, 16, 2);
enum SDL_PIXELFORMAT_ABGR1555 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_1555, 16, 2);
enum SDL_PIXELFORMAT_BGRA5551 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_5551, 16, 2);
enum SDL_PIXELFORMAT_RGB565 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_565, 16, 2);
enum SDL_PIXELFORMAT_BGR565 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED16, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_565, 16, 2);
enum SDL_PIXELFORMAT_RGB24 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_RGB, 0, 24, 3);
enum SDL_PIXELFORMAT_BGR24 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_ARRAYU8, SDL_ARRAYORDER_BGR, 0, 24, 3);
enum SDL_PIXELFORMAT_RGB888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XRGB, SDL_PACKEDLAYOUT_8888, 24, 4);
enum SDL_PIXELFORMAT_RGBX8888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBX, SDL_PACKEDLAYOUT_8888, 24, 4);
enum SDL_PIXELFORMAT_BGR888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_XBGR, SDL_PACKEDLAYOUT_8888, 24, 4);
enum SDL_PIXELFORMAT_BGRX8888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRX, SDL_PACKEDLAYOUT_8888, 24, 4);
enum SDL_PIXELFORMAT_ARGB8888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_8888, 32, 4);
enum SDL_PIXELFORMAT_RGBA8888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_RGBA, SDL_PACKEDLAYOUT_8888, 32, 4);
enum SDL_PIXELFORMAT_ABGR8888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ABGR, SDL_PACKEDLAYOUT_8888, 32, 4);
enum SDL_PIXELFORMAT_BGRA8888 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_BGRA, SDL_PACKEDLAYOUT_8888, 32, 4);
enum SDL_PIXELFORMAT_ARGB2101010 = SDL_DEFINE_PIXELFORMAT!(SDL_PIXELTYPE_PACKED32, SDL_PACKEDORDER_ARGB, SDL_PACKEDLAYOUT_2101010, 32, 4);
enum SDL_PIXELFORMAT_YV12 = SDL_DEFINE_PIXELFOURCC!('Y', 'V', '1', '2');
enum SDL_PIXELFORMAT_IYUV = SDL_DEFINE_PIXELFOURCC!('I', 'Y', 'U', 'V');
enum SDL_PIXELFORMAT_YUY2 = SDL_DEFINE_PIXELFOURCC!('Y', 'U', 'Y', '2');
enum SDL_PIXELFORMAT_UYVY = SDL_DEFINE_PIXELFOURCC!('U', 'Y', 'V', 'Y');
enum SDL_PIXELFORMAT_YVYU = SDL_DEFINE_PIXELFOURCC!('Y', 'V', 'Y', 'U');
static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_PIXELFORMAT_NV12 = SDL_DEFINE_PIXELFOURCC!('N', 'V', '1', '2');
enum SDL_PIXELFORMAT_NV21 = SDL_DEFINE_PIXELFOURCC!('N', 'V', '2', '1');
}
static if(sdlSupport >= SDLSupport.sdl208) {
enum SDL_PIXELFORMAT_EXTERNAL_OES = SDL_DEFINE_PIXELFOURCC!('O', 'E', 'S', ' ');
}
static assert(SDL_PIXELFORMAT_BGRX8888 == 0x16661804);
// Added in SDL 2.0.5, but doesn't hurt to make available for every version.
version(BigEndian) {
alias SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_RGBA8888;
alias SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_ARGB8888;
alias SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_BGRA8888;
alias SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_ABGR8888;
}
else {
alias SDL_PIXELFORMAT_RGBA32 = SDL_PIXELFORMAT_ABGR8888;
alias SDL_PIXELFORMAT_ARGB32 = SDL_PIXELFORMAT_BGRA8888;
alias SDL_PIXELFORMAT_BGRA32 = SDL_PIXELFORMAT_ARGB8888;
alias SDL_PIXELFORMAT_ABGR32 = SDL_PIXELFORMAT_RGBA8888;
}
struct SDL_Color {
ubyte r;
ubyte g;
ubyte b;
ubyte a;
}
alias SDL_Colour = SDL_Color;
struct SDL_Palette {
int ncolors;
SDL_Color* colors;
uint version_; // NOTE: original was named 'version'
int refcount;
}
struct SDL_PixelFormat {
uint format;
SDL_Palette *palette;
ubyte BitsPerPixel;
ubyte BytesPerPixel;
ubyte[2] padding;
uint Rmask;
uint Gmask;
uint Bmask;
uint Amask;
ubyte Rloss;
ubyte Gloss;
ubyte Bloss;
ubyte Aloss;
ubyte Rshift;
ubyte Gshift;
ubyte Bshift;
ubyte Ashift;
int refcount;
SDL_PixelFormat* next;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
const(char)* SDL_GetPixelFormatName(uint);
SDL_bool SDL_PixelFormatEnumToMasks(uint,int*,uint*,uint*,uint*,uint*);
uint SDL_MasksToPixelFormatEnum(int,uint,uint,uint,uint);
SDL_PixelFormat* SDL_AllocFormat(uint);
void SDL_FreeFormat(SDL_PixelFormat*);
SDL_Palette* SDL_AllocPalette(int);
int SDL_SetPixelFormatPalette(SDL_PixelFormat*,SDL_Palette*);
int SDL_SetPaletteColors(SDL_Palette*,const(SDL_Color)*,int,int);
void SDL_FreePalette(SDL_Palette*);
uint SDL_MapRGB(const(SDL_PixelFormat)*,ubyte,ubyte,ubyte);
uint SDL_MapRGBA(const(SDL_PixelFormat)*,ubyte,ubyte,ubyte,ubyte);
void SDL_GetRGB(uint,const(SDL_PixelFormat)*,ubyte*,ubyte*,ubyte*);
void SDL_GetRGBA(uint,const(SDL_PixelFormat)*,ubyte*,ubyte*,ubyte*,ubyte*);
void SDL_CalculateGammaRamp(float,ushort*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetPixelFormatName = const(char)* function(uint);
alias pSDL_PixelFormatEnumToMasks = SDL_bool function(uint,int*,uint*,uint*,uint*,uint*);
alias pSDL_MasksToPixelFormatEnum = uint function(int,uint,uint,uint,uint);
alias pSDL_AllocFormat = SDL_PixelFormat* function(uint);
alias pSDL_FreeFormat = void function(SDL_PixelFormat*);
alias pSDL_AllocPalette = SDL_Palette* function(int);
alias pSDL_SetPixelFormatPalette = int function(SDL_PixelFormat*,SDL_Palette*);
alias pSDL_SetPaletteColors = int function(SDL_Palette*,const(SDL_Color)*,int,int);
alias pSDL_FreePalette = void function(SDL_Palette*);
alias pSDL_MapRGB = uint function(const(SDL_PixelFormat)*,ubyte,ubyte,ubyte);
alias pSDL_MapRGBA = uint function(const(SDL_PixelFormat)*,ubyte,ubyte,ubyte,ubyte);
alias pSDL_GetRGB = void function(uint,const(SDL_PixelFormat)*,ubyte*,ubyte*,ubyte*);
alias pSDL_GetRGBA = void function(uint,const(SDL_PixelFormat)*,ubyte*,ubyte*,ubyte*,ubyte*);
alias pSDL_CalculateGammaRamp = void function(float,ushort*);
}
__gshared {
pSDL_GetPixelFormatName SDL_GetPixelFormatName;
pSDL_PixelFormatEnumToMasks SDL_PixelFormatEnumToMasks;
pSDL_MasksToPixelFormatEnum SDL_MasksToPixelFormatEnum;
pSDL_AllocFormat SDL_AllocFormat;
pSDL_FreeFormat SDL_FreeFormat;
pSDL_AllocPalette SDL_AllocPalette;
pSDL_SetPixelFormatPalette SDL_SetPixelFormatPalette;
pSDL_SetPaletteColors SDL_SetPaletteColors;
pSDL_FreePalette SDL_FreePalette;
pSDL_MapRGB SDL_MapRGB;
pSDL_MapRGBA SDL_MapRGBA;
pSDL_GetRGB SDL_GetRGB;
pSDL_GetRGBA SDL_GetRGBA;
pSDL_CalculateGammaRamp SDL_CalculateGammaRamp;
}
}

22
demos/external/imports/bindbc/sdl/bind/sdlplatform.d vendored Normal file
View file

@ -0,0 +1,22 @@
// 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.bind.sdlplatform;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
const(char)* SDL_GetPlatform();
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetPlatform = const(char)* function();
}
__gshared {
pSDL_GetPlatform SDL_GetPlatform;
}
}

33
demos/external/imports/bindbc/sdl/bind/sdlpower.d vendored Normal file
View file

@ -0,0 +1,33 @@
// 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.bind.sdlpower;
import bindbc.sdl.config;
enum SDL_PowerState {
SDL_POWERSTATE_UNKNOWN,
SDL_POWERSTATE_ON_BATTERY,
SDL_POWERSTATE_NO_BATTERY,
SDL_POWERSTATE_CHARGING,
SDL_POWERSTATE_CHARGED
}
mixin(expandEnum!SDL_PowerState);
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_PowerState SDL_GetPowerInfo(int*,int*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetPowerInfo = SDL_PowerState function(int*,int*);
}
__gshared {
pSDL_GetPowerInfo SDL_GetPowerInfo;
}
}

80
demos/external/imports/bindbc/sdl/bind/sdlrect.d vendored Normal file
View file

@ -0,0 +1,80 @@
// 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.bind.sdlrect;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
struct SDL_Point {
int x;
int y;
}
struct SDL_Rect {
int x, y;
int w, h;
}
static if(sdlSupport >= SDLSupport.sdl2010) {
struct SDL_FPoint {
float x, y;
}
struct SDL_FRect {
float x, y;
float w, h;
}
}
@nogc nothrow pure {
// This macro was added to SDL_rect.h in 2.0.4, but hurts nothing to implement for
// all versions.
bool SDL_PointInRect(const SDL_Point *p, const SDL_Rect *r) {
pragma(inline, true);
return ((p.x >= r.x) && (p.x < (r.x + r.w)) &&
(p.y >= r.y) && (p.y < (r.y + r.h)));
}
bool SDL_RectEmpty(const(SDL_Rect)* X) {
pragma(inline, true);
return !X || (X.w <= 0) || (X.h <= 0);
}
bool SDL_RectEquals(const(SDL_Rect)* A, const(SDL_Rect)* B) {
pragma(inline, true);
return A && B &&
(A.x == B.x) && (A.y == B.y) &&
(A.w == B.w) && (A.h == B.h);
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_bool SDL_HasIntersection(const(SDL_Rect)*,const(SDL_Rect)*);
SDL_bool SDL_IntersectRect(const(SDL_Rect)*,const(SDL_Rect)*,SDL_Rect*);
void SDL_UnionRect(const(SDL_Rect)*,const(SDL_Rect)*,SDL_Rect*);
SDL_bool SDL_EnclosePoints(const(SDL_Point)*,int,const(SDL_Rect)*,SDL_Rect*);
SDL_bool SDL_IntersectRectAndLine(const(SDL_Rect)*,int*,int*,int*,int*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_HasIntersection = SDL_bool function(const(SDL_Rect)*,const(SDL_Rect)*);
alias pSDL_IntersectRect = SDL_bool function(const(SDL_Rect)*,const(SDL_Rect)*,SDL_Rect*);
alias pSDL_UnionRect = void function(const(SDL_Rect)*,const(SDL_Rect)*,SDL_Rect*);
alias pSDL_EnclosePoints = SDL_bool function(const(SDL_Point)*,int,const(SDL_Rect)*,SDL_Rect*);
alias pSDL_IntersectRectAndLine = SDL_bool function(const(SDL_Rect)*,int*,int*,int*,int*);
}
__gshared {
pSDL_HasIntersection SDL_HasIntersection;
pSDL_IntersectRect SDL_IntersectRect;
pSDL_UnionRect SDL_UnionRect;
pSDL_EnclosePoints SDL_EnclosePoints;
pSDL_IntersectRectAndLine SDL_IntersectRectAndLine;
}
}

316
demos/external/imports/bindbc/sdl/bind/sdlrender.d vendored Normal file
View file

@ -0,0 +1,316 @@
// 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.bind.sdlrender;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlblendmode : SDL_BlendMode;
import bindbc.sdl.bind.sdlrect;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlsurface : SDL_Surface;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
enum SDL_RendererFlags : uint {
SDL_RENDERER_SOFTWARE = 0x00000001,
SDL_RENDERER_ACCELERATED = 0x00000002,
SDL_RENDERER_PRESENTVSYNC = 0x00000004,
SDL_RENDERER_TARGETTEXTURE = 0x00000008,
}
mixin(expandEnum!SDL_RendererFlags);
struct SDL_RendererInfo {
const(char)* name;
SDL_RendererFlags flags;
uint num_texture_formats;
uint[16] texture_formats;
int max_texture_width;
int max_texture_height;
}
enum SDL_TextureAccess {
SDL_TEXTUREACCESS_STATIC,
SDL_TEXTUREACCESS_STREAMING,
SDL_TEXTUREACCESS_TARGET,
}
mixin(expandEnum!SDL_TextureAccess);
enum SDL_TextureModulate {
SDL_TEXTUREMODULATE_NONE = 0x00000000,
SDL_TEXTUREMODULATE_COLOR = 0x00000001,
SDL_TEXTUREMODULATE_ALPHA = 0x00000002
}
mixin(expandEnum!SDL_TextureModulate);
enum SDL_RendererFlip {
SDL_FLIP_NONE = 0x00000000,
SDL_FLIP_HORIZONTAL = 0x00000001,
SDL_FLIP_VERTICAL = 0x00000002,
}
mixin(expandEnum!SDL_RendererFlip);
struct SDL_Renderer;
struct SDL_Texture;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_GetNumRenderDrivers();
int SDL_GetRenderDriverInfo(int,SDL_RendererInfo*);
int SDL_CreateWindowAndRenderer(int,int,uint,SDL_Window**,SDL_Renderer**);
SDL_Renderer* SDL_CreateRenderer(SDL_Window*,int,SDL_RendererFlags);
SDL_Renderer* SDL_CreateSoftwareRenderer(SDL_Surface*);
SDL_Renderer* SDL_GetRenderer(SDL_Window*);
int SDL_GetRendererInfo(SDL_Renderer*,SDL_RendererInfo*);
int SDL_GetRendererOutputSize(SDL_Renderer*,int*,int*);
SDL_Texture* SDL_CreateTexture(SDL_Renderer*,uint,SDL_TextureAccess,int,int);
SDL_Texture* SDL_CreateTextureFromSurface(SDL_Renderer*,SDL_Surface*);
int SDL_QueryTexture(SDL_Texture*,uint*,int*,int*,int*);
int SDL_SetTextureColorMod(SDL_Texture*,ubyte,ubyte,ubyte);
int SDL_GetTextureColorMod(SDL_Texture*,ubyte*,ubyte*,ubyte*);
int SDL_SetTextureAlphaMod(SDL_Texture*,ubyte);
int SDL_GetTextureAlphaMod(SDL_Texture*,ubyte*);
int SDL_SetTextureBlendMode(SDL_Texture*,SDL_BlendMode);
int SDL_GetTextureBlendMode(SDL_Texture*,SDL_BlendMode*);
int SDL_UpdateTexture(SDL_Texture*,const(SDL_Rect)*,const(void)*,int);
int SDL_LockTexture(SDL_Texture*,const(SDL_Rect)*,void**,int*);
void SDL_UnlockTexture(SDL_Texture*);
SDL_bool SDL_RenderTargetSupported(SDL_Renderer*);
int SDL_SetRenderTarget(SDL_Renderer*,SDL_Texture*);
SDL_Texture* SDL_GetRenderTarget(SDL_Renderer*);
int SDL_RenderSetClipRect(SDL_Renderer*,const(SDL_Rect)*);
void SDL_RenderGetClipRect(SDL_Renderer* renderer,SDL_Rect*);
int SDL_RenderSetLogicalSize(SDL_Renderer*,int,int);
void SDL_RenderGetLogicalSize(SDL_Renderer*,int*,int*);
int SDL_RenderSetViewport(SDL_Renderer*,const(SDL_Rect)*);
void SDL_RenderGetViewport(SDL_Renderer*,SDL_Rect*);
int SDL_RenderSetScale(SDL_Renderer*,float,float);
int SDL_RenderGetScale(SDL_Renderer*,float*,float*);
int SDL_SetRenderDrawColor(SDL_Renderer*,ubyte,ubyte,ubyte,ubyte);
int SDL_GetRenderDrawColor(SDL_Renderer*,ubyte*,ubyte*,ubyte*,ubyte*);
int SDL_SetRenderDrawBlendMode(SDL_Renderer*,SDL_BlendMode);
int SDL_GetRenderDrawBlendMode(SDL_Renderer*,SDL_BlendMode*);
int SDL_RenderClear(SDL_Renderer*);
int SDL_RenderDrawPoint(SDL_Renderer*,int,int);
int SDL_RenderDrawPoints(SDL_Renderer*,const(SDL_Point)*,int);
int SDL_RenderDrawLine(SDL_Renderer*,int,int,int,int);
int SDL_RenderDrawLines(SDL_Renderer*,const(SDL_Point)*,int);
int SDL_RenderDrawRect(SDL_Renderer*,const(SDL_Rect)*);
int SDL_RenderDrawRects(SDL_Renderer*,const(SDL_Rect)*,int);
int SDL_RenderFillRect(SDL_Renderer*,const(SDL_Rect)*);
int SDL_RenderFillRects(SDL_Renderer*,const(SDL_Rect)*,int);
int SDL_RenderCopy(SDL_Renderer*,SDL_Texture*,const(SDL_Rect)*,const(SDL_Rect*));
int SDL_RenderCopyEx(SDL_Renderer*,SDL_Texture*,const(SDL_Rect)*,const(SDL_Rect)*,const(double),const(SDL_Point)*,const(SDL_RendererFlip));
int SDL_RenderReadPixels(SDL_Renderer*,const(SDL_Rect)*,uint,void*,int);
void SDL_RenderPresent(SDL_Renderer*);
void SDL_DestroyTexture(SDL_Texture*);
void SDL_DestroyRenderer(SDL_Renderer*);
int SDL_GL_BindTexture(SDL_Texture*,float*,float*);
int SDL_GL_UnbindTexture(SDL_Texture*);
static if(sdlSupport >= SDLSupport.sdl201) {
int SDL_UpdateYUVTexture(SDL_Texture*,const(SDL_Rect)*,const(ubyte)*,int,const(ubyte)*,int,const(ubyte)*,int);
}
static if(sdlSupport >= SDLSupport.sdl204) {
SDL_bool SDL_RenderIsClipEnabled(SDL_Renderer*);
}
static if(sdlSupport >= SDLSupport.sdl205) {
SDL_bool SDL_RenderGetIntegerScale(SDL_Renderer*);
int SDL_RenderSetIntegerScale(SDL_Renderer*,SDL_bool);
}
static if(sdlSupport >= SDLSupport.sdl208) {
void* SDL_RenderGetMetalLayer(SDL_Renderer*);
void* SDL_RenderGetMetalCommandEncoder(SDL_Renderer*);
}
static if(sdlSupport >= SDLSupport.sdl2010) {
int SDL_RenderDrawPointF(SDL_Renderer*,float,float);
int SDL_RenderDrawPointsF(SDL_Renderer*,const(SDL_FPoint)*,int);
int SDL_RenderDrawLineF(SDL_Renderer*,float,float,float,float);
int SDL_RenderDrawLinesF(SDL_Renderer*,const(SDL_FPoint)*,int);
int SDL_RenderDrawRectF(SDL_Renderer*,const(SDL_FRect)*);
int SDL_RenderDrawRectsF(SDL_Renderer*,const(SDL_FRect)*,int);
int SDL_RenderFillRectF(SDL_Renderer*,const(SDL_FRect)*);
int SDL_RenderFillRectsF(SDL_Renderer*,const(SDL_FRect)*,int);
int SDL_RenderCopyF(SDL_Renderer*,SDL_Texture*,const(SDL_FRect)*,const(SDL_FRect)*);
int SDL_RenderCopyExF(SDL_Renderer*,SDL_Texture*,const(SDL_FRect)*,const(SDL_FRect)*,const(double),const(SDL_FPoint)*,const(SDL_RendererFlip));
int SDL_RenderFlush(SDL_Renderer*);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetNumRenderDrivers = int function();
alias pSDL_GetRenderDriverInfo = int function(int,SDL_RendererInfo*);
alias pSDL_CreateWindowAndRenderer = int function(int,int,uint,SDL_Window**,SDL_Renderer**);
alias pSDL_CreateRenderer = SDL_Renderer* function(SDL_Window*,int,SDL_RendererFlags);
alias pSDL_CreateSoftwareRenderer = SDL_Renderer* function(SDL_Surface*);
alias pSDL_GetRenderer = SDL_Renderer* function(SDL_Window*);
alias pSDL_GetRendererInfo = int function(SDL_Renderer*,SDL_RendererInfo*);
alias pSDL_GetRendererOutputSize = int function(SDL_Renderer*,int*,int*);
alias pSDL_CreateTexture = SDL_Texture* function(SDL_Renderer*,uint,SDL_TextureAccess,int,int);
alias pSDL_CreateTextureFromSurface = SDL_Texture* function(SDL_Renderer*,SDL_Surface*);
alias pSDL_QueryTexture = int function(SDL_Texture*,uint*,int*,int*,int*);
alias pSDL_SetTextureColorMod = int function(SDL_Texture*,ubyte,ubyte,ubyte);
alias pSDL_GetTextureColorMod = int function(SDL_Texture*,ubyte*,ubyte*,ubyte*);
alias pSDL_SetTextureAlphaMod = int function(SDL_Texture*,ubyte);
alias pSDL_GetTextureAlphaMod = int function(SDL_Texture*,ubyte*);
alias pSDL_SetTextureBlendMode = int function(SDL_Texture*,SDL_BlendMode);
alias pSDL_GetTextureBlendMode = int function(SDL_Texture*,SDL_BlendMode*);
alias pSDL_UpdateTexture = int function(SDL_Texture*,const(SDL_Rect)*,const(void)*,int);
alias pSDL_LockTexture = int function(SDL_Texture*,const(SDL_Rect)*,void**,int*);
alias pSDL_UnlockTexture = void function(SDL_Texture*);
alias pSDL_RenderTargetSupported = SDL_bool function(SDL_Renderer*);
alias pSDL_SetRenderTarget = int function(SDL_Renderer*,SDL_Texture*);
alias pSDL_GetRenderTarget = SDL_Texture* function(SDL_Renderer*);
alias pSDL_RenderSetClipRect = int function(SDL_Renderer*,const(SDL_Rect)*);
alias pSDL_RenderGetClipRect = void function(SDL_Renderer* renderer,SDL_Rect*);
alias pSDL_RenderSetLogicalSize = int function(SDL_Renderer*,int,int);
alias pSDL_RenderGetLogicalSize = void function(SDL_Renderer*,int*,int*);
alias pSDL_RenderSetViewport = int function(SDL_Renderer*,const(SDL_Rect)*);
alias pSDL_RenderGetViewport = void function(SDL_Renderer*,SDL_Rect*);
alias pSDL_RenderSetScale = int function(SDL_Renderer*,float,float);
alias pSDL_RenderGetScale = int function(SDL_Renderer*,float*,float*);
alias pSDL_SetRenderDrawColor = int function(SDL_Renderer*,ubyte,ubyte,ubyte,ubyte);
alias pSDL_GetRenderDrawColor = int function(SDL_Renderer*,ubyte*,ubyte*,ubyte*,ubyte*);
alias pSDL_SetRenderDrawBlendMode = int function(SDL_Renderer*,SDL_BlendMode);
alias pSDL_GetRenderDrawBlendMode = int function(SDL_Renderer*,SDL_BlendMode*);
alias pSDL_RenderClear = int function(SDL_Renderer*);
alias pSDL_RenderDrawPoint = int function(SDL_Renderer*,int,int);
alias pSDL_RenderDrawPoints = int function(SDL_Renderer*,const(SDL_Point)*,int);
alias pSDL_RenderDrawLine = int function(SDL_Renderer*,int,int,int,int);
alias pSDL_RenderDrawLines = int function(SDL_Renderer*,const(SDL_Point)*,int);
alias pSDL_RenderDrawRect = int function(SDL_Renderer*,const(SDL_Rect)*);
alias pSDL_RenderDrawRects = int function(SDL_Renderer*,const(SDL_Rect)*,int);
alias pSDL_RenderFillRect = int function(SDL_Renderer*,const(SDL_Rect)*);
alias pSDL_RenderFillRects = int function(SDL_Renderer*,const(SDL_Rect)*,int);
alias pSDL_RenderCopy = int function(SDL_Renderer*,SDL_Texture*,const(SDL_Rect)*,const(SDL_Rect*));
alias pSDL_RenderCopyEx = int function(SDL_Renderer*,SDL_Texture*,const(SDL_Rect)*,const(SDL_Rect)*,const(double),const(SDL_Point)*,const(SDL_RendererFlip));
alias pSDL_RenderReadPixels = int function(SDL_Renderer*,const(SDL_Rect)*,uint,void*,int);
alias pSDL_RenderPresent = void function(SDL_Renderer*);
alias pSDL_DestroyTexture = void function(SDL_Texture*);
alias pSDL_DestroyRenderer = void function(SDL_Renderer*);
alias pSDL_GL_BindTexture = int function(SDL_Texture*,float*,float*);
alias pSDL_GL_UnbindTexture = int function(SDL_Texture*);
}
__gshared {
pSDL_GetNumRenderDrivers SDL_GetNumRenderDrivers;
pSDL_GetRenderDriverInfo SDL_GetRenderDriverInfo;
pSDL_CreateWindowAndRenderer SDL_CreateWindowAndRenderer;
pSDL_CreateRenderer SDL_CreateRenderer;
pSDL_CreateSoftwareRenderer SDL_CreateSoftwareRenderer;
pSDL_GetRenderer SDL_GetRenderer;
pSDL_GetRendererInfo SDL_GetRendererInfo;
pSDL_GetRendererOutputSize SDL_GetRendererOutputSize;
pSDL_CreateTexture SDL_CreateTexture;
pSDL_CreateTextureFromSurface SDL_CreateTextureFromSurface;
pSDL_QueryTexture SDL_QueryTexture;
pSDL_SetTextureColorMod SDL_SetTextureColorMod;
pSDL_GetTextureColorMod SDL_GetTextureColorMod;
pSDL_SetTextureAlphaMod SDL_SetTextureAlphaMod;
pSDL_GetTextureAlphaMod SDL_GetTextureAlphaMod;
pSDL_SetTextureBlendMode SDL_SetTextureBlendMode;
pSDL_GetTextureBlendMode SDL_GetTextureBlendMode;
pSDL_UpdateTexture SDL_UpdateTexture;
pSDL_LockTexture SDL_LockTexture;
pSDL_UnlockTexture SDL_UnlockTexture;
pSDL_RenderTargetSupported SDL_RenderTargetSupported;
pSDL_SetRenderTarget SDL_SetRenderTarget;
pSDL_GetRenderTarget SDL_GetRenderTarget;
pSDL_RenderSetClipRect SDL_RenderSetClipRect;
pSDL_RenderGetClipRect SDL_RenderGetClipRect;
pSDL_RenderSetLogicalSize SDL_RenderSetLogicalSize;
pSDL_RenderGetLogicalSize SDL_RenderGetLogicalSize;
pSDL_RenderSetViewport SDL_RenderSetViewport;
pSDL_RenderGetViewport SDL_RenderGetViewport;
pSDL_RenderSetScale SDL_RenderSetScale;
pSDL_RenderGetScale SDL_RenderGetScale;
pSDL_SetRenderDrawColor SDL_SetRenderDrawColor;
pSDL_GetRenderDrawColor SDL_GetRenderDrawColor;
pSDL_SetRenderDrawBlendMode SDL_SetRenderDrawBlendMode;
pSDL_GetRenderDrawBlendMode SDL_GetRenderDrawBlendMode;
pSDL_RenderClear SDL_RenderClear;
pSDL_RenderDrawPoint SDL_RenderDrawPoint;
pSDL_RenderDrawPoints SDL_RenderDrawPoints;
pSDL_RenderDrawLine SDL_RenderDrawLine;
pSDL_RenderDrawLines SDL_RenderDrawLines;
pSDL_RenderDrawRect SDL_RenderDrawRect;
pSDL_RenderDrawRects SDL_RenderDrawRects;
pSDL_RenderFillRect SDL_RenderFillRect;
pSDL_RenderFillRects SDL_RenderFillRects;
pSDL_RenderCopy SDL_RenderCopy;
pSDL_RenderCopyEx SDL_RenderCopyEx;
pSDL_RenderReadPixels SDL_RenderReadPixels;
pSDL_RenderPresent SDL_RenderPresent;
pSDL_DestroyTexture SDL_DestroyTexture;
pSDL_DestroyRenderer SDL_DestroyRenderer;
pSDL_GL_BindTexture SDL_GL_BindTexture;
pSDL_GL_UnbindTexture SDL_GL_UnbindTexture;
}
static if(sdlSupport >= SDLSupport.sdl201) {
extern(C) @nogc nothrow {
alias pSDL_UpdateYUVTexture = int function(SDL_Texture*,const(SDL_Rect)*,const(ubyte)*,int,const(ubyte)*,int,const(ubyte)*,int);
}
__gshared {
pSDL_UpdateYUVTexture SDL_UpdateYUVTexture;
}
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_RenderIsClipEnabled = SDL_bool function(SDL_Renderer*);
}
__gshared {
pSDL_RenderIsClipEnabled SDL_RenderIsClipEnabled;
}
}
static if(sdlSupport >= SDLSupport.sdl205) {
extern(C) @nogc nothrow {
alias pSDL_RenderGetIntegerScale = SDL_bool function(SDL_Renderer*);
alias pSDL_RenderSetIntegerScale = int function(SDL_Renderer*,SDL_bool);
}
__gshared {
pSDL_RenderGetIntegerScale SDL_RenderGetIntegerScale;
pSDL_RenderSetIntegerScale SDL_RenderSetIntegerScale;
}
}
static if(sdlSupport >= SDLSupport.sdl208) {
extern(C) @nogc nothrow {
alias pSDL_RenderGetMetalLayer = void* function(SDL_Renderer*);
alias pSDL_RenderGetMetalCommandEncoder = void* function(SDL_Renderer*);
}
__gshared {
pSDL_RenderGetMetalLayer SDL_RenderGetMetalLayer;
pSDL_RenderGetMetalCommandEncoder SDL_RenderGetMetalCommandEncoder;
}
}
static if(sdlSupport >= SDLSupport.sdl2010) {
extern(C) @nogc nothrow {
alias pSDL_RenderDrawPointF = int function(SDL_Renderer*,float,float);
alias pSDL_RenderDrawPointsF = int function(SDL_Renderer*,const(SDL_FPoint)*,int);
alias pSDL_RenderDrawLineF = int function(SDL_Renderer*,float,float,float,float);
alias pSDL_RenderDrawLinesF = int function(SDL_Renderer*,const(SDL_FPoint)*,int);
alias pSDL_RenderDrawRectF = int function(SDL_Renderer*,const(SDL_FRect)*);
alias pSDL_RenderDrawRectsF = int function(SDL_Renderer*,const(SDL_FRect)*,int);
alias pSDL_RenderFillRectF = int function(SDL_Renderer*,const(SDL_FRect)*);
alias pSDL_RenderFillRectsF = int function(SDL_Renderer*,const(SDL_FRect)*,int);
alias pSDL_RenderCopyF = int function(SDL_Renderer*,SDL_Texture*,const(SDL_FRect)*,const(SDL_FRect)*);
alias pSDL_RenderCopyExF = int function(SDL_Renderer*,SDL_Texture*,const(SDL_FRect)*,const(SDL_FRect)*,const(double),const(SDL_FPoint)*,const(SDL_RendererFlip));
alias pSDL_RenderFlush = int function(SDL_Renderer*);
}
__gshared {
pSDL_RenderDrawPointF SDL_RenderDrawPointF;
pSDL_RenderDrawPointsF SDL_RenderDrawPointsF;
pSDL_RenderDrawLineF SDL_RenderDrawLineF;
pSDL_RenderDrawLinesF SDL_RenderDrawLinesF;
pSDL_RenderDrawRectF SDL_RenderDrawRectF;
pSDL_RenderDrawRectsF SDL_RenderDrawRectsF;
pSDL_RenderFillRectF SDL_RenderFillRectF;
pSDL_RenderFillRectsF SDL_RenderFillRectsF;
pSDL_RenderCopyF SDL_RenderCopyF;
pSDL_RenderCopyExF SDL_RenderCopyExF;
pSDL_RenderFlush SDL_RenderFlush;
}
}
}

208
demos/external/imports/bindbc/sdl/bind/sdlrwops.d vendored Normal file
View file

@ -0,0 +1,208 @@
// 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.bind.sdlrwops;
//import core.stdc.stdio : FILE;
struct FILE
{
}
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
enum : uint {
SDL_RWOPS_UNKNOWN = 0,
SDL_RWOPS_WINFILE = 1,
SDL_RWOPS_STDFILE = 2,
SDL_RWOPS_JNIFILE = 3,
SDL_RWOPS_MEMORY = 4,
SDL_RWOPS_MEMORY_RO = 5,
}
struct SDL_RWops {
extern(C) @nogc nothrow {
long function(SDL_RWops*) size;
long function(SDL_RWops*, long, int) seek;
size_t function(SDL_RWops*, void*, size_t, size_t) read;
size_t function(SDL_RWops*, const(void)*, size_t, size_t) write;
int function(SDL_RWops*) close;
}
uint type;
union Hidden {
// version(Android)
version(Windows) {
struct Windowsio {
int append;
void* h;
struct Buffer {
void* data;
size_t size;
size_t left;
}
Buffer buffer;
}
Windowsio windowsio;
}
struct Stdio {
int autoclose;
FILE* fp;
}
Stdio stdio;
struct Mem {
ubyte* base;
ubyte* here;
ubyte* stop;
}
Mem mem;
struct Unknown {
void* data1;
void* data2;
}
Unknown unknown;
}
Hidden hidden;
}
enum {
RW_SEEK_SET = 0,
RW_SEEK_CUR = 1,
RW_SEEK_END = 2,
}
static if(sdlSupport < SDLSupport.sdl2010) {
@nogc nothrow {
long SDL_RWsize(SDL_RWops* ctx) { return ctx.size(ctx); }
long SDL_RWseek(SDL_RWops* ctx, long offset, int whence) { return ctx.seek(ctx, offset, whence); }
long SDL_RWtell(SDL_RWops* ctx) { return ctx.seek(ctx, 0, RW_SEEK_CUR); }
size_t SDL_RWread(SDL_RWops* ctx, void* ptr, size_t size, size_t n) { return ctx.read(ctx, ptr, size, n); }
size_t SDL_RWwrite(SDL_RWops* ctx, const(void)* ptr, size_t size, size_t n) { return ctx.write(ctx, ptr, size, n); }
int SDL_RWclose(SDL_RWops* ctx) { return ctx.close(ctx); }
}
}
static if(sdlSupport >= SDLSupport.sdl206) {
@nogc nothrow
void* SDL_LoadFile(const(char)* filename, size_t datasize) {
pragma(inline, true);
return SDL_LoadFile_RW(SDL_RWFromFile(filename, "rb"), datasize, 1);
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_RWops* SDL_RWFromFile(const(char)*,const(char)*);
SDL_RWops* SDL_RWFromFP(FILE*,SDL_bool);
SDL_RWops* SDL_RWFromMem(void*,int);
SDL_RWops* SDL_RWFromConstMem(const(void)*,int);
SDL_RWops* SDL_AllocRW();
void SDL_FreeRW(SDL_RWops*);
ubyte SDL_ReadU8(SDL_RWops*);
ushort SDL_ReadLE16(SDL_RWops*);
ushort SDL_ReadBE16(SDL_RWops*);
uint SDL_ReadLE32(SDL_RWops*);
uint SDL_ReadBE32(SDL_RWops*);
ulong SDL_ReadLE64(SDL_RWops*);
ulong SDL_ReadBE64(SDL_RWops*);
size_t SDL_WriteU8(SDL_RWops*,ubyte);
size_t SDL_WriteLE16(SDL_RWops*,ushort);
size_t SDL_WriteBE16(SDL_RWops*,ushort);
size_t SDL_WriteLE32(SDL_RWops*,uint);
size_t SDL_WriteBE32(SDL_RWops*,uint);
size_t SDL_WriteLE64(SDL_RWops*,ulong);
size_t SDL_WriteBE64(SDL_RWops*,ulong);
static if(sdlSupport >= SDLSupport.sdl206) {
void* SDL_LoadFile_RW(SDL_RWops*,size_t,int);
}
static if(sdlSupport >= SDLSupport.sdl2010) {
long SDL_RWsize(SDL_RWops*);
long SDL_RWseek(SDL_RWops*,long,int);
long SDL_RWtell(SDL_RWops*);
size_t SDL_RWread(SDL_RWops*,void*,size_t,size_t);
size_t SDL_RWwrite(SDL_RWops*,const(void)*,size_t,size_t);
int SDL_RWclose(SDL_RWops*);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_RWFromFile = SDL_RWops* function(const(char)*,const(char)*);
alias pSDL_RWFromFP = SDL_RWops* function(FILE*,SDL_bool);
alias pSDL_RWFromMem = SDL_RWops* function(void*,int);
alias pSDL_RWFromConstMem = SDL_RWops* function(const(void)*,int);
alias pSDL_AllocRW = SDL_RWops* function();
alias pSDL_FreeRW = void function(SDL_RWops*);
alias pSDL_ReadU8 = ubyte function(SDL_RWops*);
alias pSDL_ReadLE16 = ushort function(SDL_RWops*);
alias pSDL_ReadBE16 = ushort function(SDL_RWops*);
alias pSDL_ReadLE32 = uint function(SDL_RWops*);
alias pSDL_ReadBE32 = uint function(SDL_RWops*);
alias pSDL_ReadLE64 = ulong function(SDL_RWops*);
alias pSDL_ReadBE64 = ulong function(SDL_RWops*);
alias pSDL_WriteU8 = size_t function(SDL_RWops*,ubyte);
alias pSDL_WriteLE16 = size_t function(SDL_RWops*,ushort);
alias pSDL_WriteBE16 = size_t function(SDL_RWops*,ushort);
alias pSDL_WriteLE32 = size_t function(SDL_RWops*,uint);
alias pSDL_WriteBE32 = size_t function(SDL_RWops*,uint);
alias pSDL_WriteLE64 = size_t function(SDL_RWops*,ulong);
alias pSDL_WriteBE64 = size_t function(SDL_RWops*,ulong);
}
__gshared {
pSDL_RWFromFile SDL_RWFromFile;
pSDL_RWFromFP SDL_RWFromFP;
pSDL_RWFromMem SDL_RWFromMem;
pSDL_RWFromConstMem SDL_RWFromConstMem;
pSDL_AllocRW SDL_AllocRW;
pSDL_FreeRW SDL_FreeRW;
pSDL_ReadU8 SDL_ReadU8;
pSDL_ReadLE16 SDL_ReadLE16;
pSDL_ReadBE16 SDL_ReadBE16;
pSDL_ReadLE32 SDL_ReadLE32;
pSDL_ReadBE32 SDL_ReadBE32;
pSDL_ReadLE64 SDL_ReadLE64;
pSDL_ReadBE64 SDL_ReadBE64;
pSDL_WriteU8 SDL_WriteU8;
pSDL_WriteLE16 SDL_WriteLE16;
pSDL_WriteBE16 SDL_WriteBE16;
pSDL_WriteLE32 SDL_WriteLE32;
pSDL_WriteBE32 SDL_WriteBE32;
pSDL_WriteLE64 SDL_WriteLE64;
pSDL_WriteBE64 SDL_WriteBE64;
}
static if(sdlSupport >= SDLSupport.sdl206) {
extern(C) @nogc nothrow {
alias pSDL_LoadFile_RW = void* function(SDL_RWops*,size_t,int);
}
__gshared {
pSDL_LoadFile_RW SDL_LoadFile_RW;
}
}
static if(sdlSupport >= SDLSupport.sdl2010) {
extern(C) @nogc nothrow {
alias pSDL_RWsize = long function(SDL_RWops*);
alias pSDL_RWseek = long function(SDL_RWops*,long,int);
alias pSDL_RWtell = long function(SDL_RWops*);
alias pSDL_RWread = size_t function(SDL_RWops*,void*,size_t,size_t);
alias pSDL_RWwrite = size_t function(SDL_RWops*,const(void)*,size_t,size_t);
alias pSDL_RWclose = int function(SDL_RWops*);
}
__gshared {
pSDL_RWsize SDL_RWsize;
pSDL_RWseek SDL_RWseek;
pSDL_RWtell SDL_RWtell;
pSDL_RWread SDL_RWread;
pSDL_RWwrite SDL_RWwrite;
pSDL_RWclose SDL_RWclose;
}
}
}

542
demos/external/imports/bindbc/sdl/bind/sdlscancode.d vendored Normal file
View file

@ -0,0 +1,542 @@
// 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.bind.sdlscancode;
import bindbc.sdl.config;
static if(sdlSupport >= SDLSupport.sdl206) {
enum SDL_Scancode {
SDL_SCANCODE_UNKNOWN = 0,
SDL_SCANCODE_A = 4,
SDL_SCANCODE_B = 5,
SDL_SCANCODE_C = 6,
SDL_SCANCODE_D = 7,
SDL_SCANCODE_E = 8,
SDL_SCANCODE_F = 9,
SDL_SCANCODE_G = 10,
SDL_SCANCODE_H = 11,
SDL_SCANCODE_I = 12,
SDL_SCANCODE_J = 13,
SDL_SCANCODE_K = 14,
SDL_SCANCODE_L = 15,
SDL_SCANCODE_M = 16,
SDL_SCANCODE_N = 17,
SDL_SCANCODE_O = 18,
SDL_SCANCODE_P = 19,
SDL_SCANCODE_Q = 20,
SDL_SCANCODE_R = 21,
SDL_SCANCODE_S = 22,
SDL_SCANCODE_T = 23,
SDL_SCANCODE_U = 24,
SDL_SCANCODE_V = 25,
SDL_SCANCODE_W = 26,
SDL_SCANCODE_X = 27,
SDL_SCANCODE_Y = 28,
SDL_SCANCODE_Z = 29,
SDL_SCANCODE_1 = 30,
SDL_SCANCODE_2 = 31,
SDL_SCANCODE_3 = 32,
SDL_SCANCODE_4 = 33,
SDL_SCANCODE_5 = 34,
SDL_SCANCODE_6 = 35,
SDL_SCANCODE_7 = 36,
SDL_SCANCODE_8 = 37,
SDL_SCANCODE_9 = 38,
SDL_SCANCODE_0 = 39,
SDL_SCANCODE_RETURN = 40,
SDL_SCANCODE_ESCAPE = 41,
SDL_SCANCODE_BACKSPACE = 42,
SDL_SCANCODE_TAB = 43,
SDL_SCANCODE_SPACE = 44,
SDL_SCANCODE_MINUS = 45,
SDL_SCANCODE_EQUALS = 46,
SDL_SCANCODE_LEFTBRACKET = 47,
SDL_SCANCODE_RIGHTBRACKET = 48,
SDL_SCANCODE_BACKSLASH = 49,
SDL_SCANCODE_NONUSHASH = 50,
SDL_SCANCODE_SEMICOLON = 51,
SDL_SCANCODE_APOSTROPHE = 52,
SDL_SCANCODE_GRAVE = 53,
SDL_SCANCODE_COMMA = 54,
SDL_SCANCODE_PERIOD = 55,
SDL_SCANCODE_SLASH = 56,
SDL_SCANCODE_CAPSLOCK = 57,
SDL_SCANCODE_F1 = 58,
SDL_SCANCODE_F2 = 59,
SDL_SCANCODE_F3 = 60,
SDL_SCANCODE_F4 = 61,
SDL_SCANCODE_F5 = 62,
SDL_SCANCODE_F6 = 63,
SDL_SCANCODE_F7 = 64,
SDL_SCANCODE_F8 = 65,
SDL_SCANCODE_F9 = 66,
SDL_SCANCODE_F10 = 67,
SDL_SCANCODE_F11 = 68,
SDL_SCANCODE_F12 = 69,
SDL_SCANCODE_PRINTSCREEN = 70,
SDL_SCANCODE_SCROLLLOCK = 71,
SDL_SCANCODE_PAUSE = 72,
SDL_SCANCODE_INSERT = 73,
SDL_SCANCODE_HOME = 74,
SDL_SCANCODE_PAGEUP = 75,
SDL_SCANCODE_DELETE = 76,
SDL_SCANCODE_END = 77,
SDL_SCANCODE_PAGEDOWN = 78,
SDL_SCANCODE_RIGHT = 79,
SDL_SCANCODE_LEFT = 80,
SDL_SCANCODE_DOWN = 81,
SDL_SCANCODE_UP = 82,
SDL_SCANCODE_NUMLOCKCLEAR = 83,
SDL_SCANCODE_KP_DIVIDE = 84,
SDL_SCANCODE_KP_MULTIPLY = 85,
SDL_SCANCODE_KP_MINUS = 86,
SDL_SCANCODE_KP_PLUS = 87,
SDL_SCANCODE_KP_ENTER = 88,
SDL_SCANCODE_KP_1 = 89,
SDL_SCANCODE_KP_2 = 90,
SDL_SCANCODE_KP_3 = 91,
SDL_SCANCODE_KP_4 = 92,
SDL_SCANCODE_KP_5 = 93,
SDL_SCANCODE_KP_6 = 94,
SDL_SCANCODE_KP_7 = 95,
SDL_SCANCODE_KP_8 = 96,
SDL_SCANCODE_KP_9 = 97,
SDL_SCANCODE_KP_0 = 98,
SDL_SCANCODE_KP_PERIOD = 99,
SDL_SCANCODE_NONUSBACKSLASH = 100,
SDL_SCANCODE_APPLICATION = 101,
SDL_SCANCODE_POWER = 102,
SDL_SCANCODE_KP_EQUALS = 103,
SDL_SCANCODE_F13 = 104,
SDL_SCANCODE_F14 = 105,
SDL_SCANCODE_F15 = 106,
SDL_SCANCODE_F16 = 107,
SDL_SCANCODE_F17 = 108,
SDL_SCANCODE_F18 = 109,
SDL_SCANCODE_F19 = 110,
SDL_SCANCODE_F20 = 111,
SDL_SCANCODE_F21 = 112,
SDL_SCANCODE_F22 = 113,
SDL_SCANCODE_F23 = 114,
SDL_SCANCODE_F24 = 115,
SDL_SCANCODE_EXECUTE = 116,
SDL_SCANCODE_HELP = 117,
SDL_SCANCODE_MENU = 118,
SDL_SCANCODE_SELECT = 119,
SDL_SCANCODE_STOP = 120,
SDL_SCANCODE_AGAIN = 121,
SDL_SCANCODE_UNDO = 122,
SDL_SCANCODE_CUT = 123,
SDL_SCANCODE_COPY = 124,
SDL_SCANCODE_PASTE = 125,
SDL_SCANCODE_FIND = 126,
SDL_SCANCODE_MUTE = 127,
SDL_SCANCODE_VOLUMEUP = 128,
SDL_SCANCODE_VOLUMEDOWN = 129,
SDL_SCANCODE_KP_COMMA = 133,
SDL_SCANCODE_KP_EQUALSAS400 = 134,
SDL_SCANCODE_INTERNATIONAL1 = 135,
SDL_SCANCODE_INTERNATIONAL2 = 136,
SDL_SCANCODE_INTERNATIONAL3 = 137,
SDL_SCANCODE_INTERNATIONAL4 = 138,
SDL_SCANCODE_INTERNATIONAL5 = 139,
SDL_SCANCODE_INTERNATIONAL6 = 140,
SDL_SCANCODE_INTERNATIONAL7 = 141,
SDL_SCANCODE_INTERNATIONAL8 = 142,
SDL_SCANCODE_INTERNATIONAL9 = 143,
SDL_SCANCODE_LANG1 = 144,
SDL_SCANCODE_LANG2 = 145,
SDL_SCANCODE_LANG3 = 146,
SDL_SCANCODE_LANG4 = 147,
SDL_SCANCODE_LANG5 = 148,
SDL_SCANCODE_LANG6 = 149,
SDL_SCANCODE_LANG7 = 150,
SDL_SCANCODE_LANG8 = 151,
SDL_SCANCODE_LANG9 = 152,
SDL_SCANCODE_ALTERASE = 153,
SDL_SCANCODE_SYSREQ = 154,
SDL_SCANCODE_CANCEL = 155,
SDL_SCANCODE_CLEAR = 156,
SDL_SCANCODE_PRIOR = 157,
SDL_SCANCODE_RETURN2 = 158,
SDL_SCANCODE_SEPARATOR = 159,
SDL_SCANCODE_OUT = 160,
SDL_SCANCODE_OPER = 161,
SDL_SCANCODE_CLEARAGAIN = 162,
SDL_SCANCODE_CRSEL = 163,
SDL_SCANCODE_EXSEL = 164,
SDL_SCANCODE_KP_00 = 176,
SDL_SCANCODE_KP_000 = 177,
SDL_SCANCODE_THOUSANDSSEPARATOR = 178,
SDL_SCANCODE_DECIMALSEPARATOR = 179,
SDL_SCANCODE_CURRENCYUNIT = 180,
SDL_SCANCODE_CURRENCYSUBUNIT = 181,
SDL_SCANCODE_KP_LEFTPAREN = 182,
SDL_SCANCODE_KP_RIGHTPAREN = 183,
SDL_SCANCODE_KP_LEFTBRACE = 184,
SDL_SCANCODE_KP_RIGHTBRACE = 185,
SDL_SCANCODE_KP_TAB = 186,
SDL_SCANCODE_KP_BACKSPACE = 187,
SDL_SCANCODE_KP_A = 188,
SDL_SCANCODE_KP_B = 189,
SDL_SCANCODE_KP_C = 190,
SDL_SCANCODE_KP_D = 191,
SDL_SCANCODE_KP_E = 192,
SDL_SCANCODE_KP_F = 193,
SDL_SCANCODE_KP_XOR = 194,
SDL_SCANCODE_KP_POWER = 195,
SDL_SCANCODE_KP_PERCENT = 196,
SDL_SCANCODE_KP_LESS = 197,
SDL_SCANCODE_KP_GREATER = 198,
SDL_SCANCODE_KP_AMPERSAND = 199,
SDL_SCANCODE_KP_DBLAMPERSAND = 200,
SDL_SCANCODE_KP_VERTICALBAR = 201,
SDL_SCANCODE_KP_DBLVERTICALBAR = 202,
SDL_SCANCODE_KP_COLON = 203,
SDL_SCANCODE_KP_HASH = 204,
SDL_SCANCODE_KP_SPACE = 205,
SDL_SCANCODE_KP_AT = 206,
SDL_SCANCODE_KP_EXCLAM = 207,
SDL_SCANCODE_KP_MEMSTORE = 208,
SDL_SCANCODE_KP_MEMRECALL = 209,
SDL_SCANCODE_KP_MEMCLEAR = 210,
SDL_SCANCODE_KP_MEMADD = 211,
SDL_SCANCODE_KP_MEMSUBTRACT = 212,
SDL_SCANCODE_KP_MEMMULTIPLY = 213,
SDL_SCANCODE_KP_MEMDIVIDE = 214,
SDL_SCANCODE_KP_PLUSMINUS = 215,
SDL_SCANCODE_KP_CLEAR = 216,
SDL_SCANCODE_KP_CLEARENTRY = 217,
SDL_SCANCODE_KP_BINARY = 218,
SDL_SCANCODE_KP_OCTAL = 219,
SDL_SCANCODE_KP_DECIMAL = 220,
SDL_SCANCODE_KP_HEXADECIMAL = 221,
SDL_SCANCODE_LCTRL = 224,
SDL_SCANCODE_LSHIFT = 225,
SDL_SCANCODE_LALT = 226,
SDL_SCANCODE_LGUI = 227,
SDL_SCANCODE_RCTRL = 228,
SDL_SCANCODE_RSHIFT = 229,
SDL_SCANCODE_RALT = 230,
SDL_SCANCODE_RGUI = 231,
SDL_SCANCODE_MODE = 257,
SDL_SCANCODE_AUDIONEXT = 258,
SDL_SCANCODE_AUDIOPREV = 259,
SDL_SCANCODE_AUDIOSTOP = 260,
SDL_SCANCODE_AUDIOPLAY = 261,
SDL_SCANCODE_AUDIOMUTE = 262,
SDL_SCANCODE_MEDIASELECT = 263,
SDL_SCANCODE_WWW = 264,
SDL_SCANCODE_MAIL = 265,
SDL_SCANCODE_CALCULATOR = 266,
SDL_SCANCODE_COMPUTER = 267,
SDL_SCANCODE_AC_SEARCH = 268,
SDL_SCANCODE_AC_HOME = 269,
SDL_SCANCODE_AC_BACK = 270,
SDL_SCANCODE_AC_FORWARD = 271,
SDL_SCANCODE_AC_STOP = 272,
SDL_SCANCODE_AC_REFRESH = 273,
SDL_SCANCODE_AC_BOOKMARKS = 274,
SDL_SCANCODE_BRIGHTNESSDOWN = 275,
SDL_SCANCODE_BRIGHTNESSUP = 276,
SDL_SCANCODE_DISPLAYSWITCH = 277,
SDL_SCANCODE_KBDILLUMTOGGLE = 278,
SDL_SCANCODE_KBDILLUMDOWN = 279,
SDL_SCANCODE_KBDILLUMUP = 280,
SDL_SCANCODE_EJECT = 281,
SDL_SCANCODE_SLEEP = 282,
SDL_SCANCODE_APP1 = 283,
SDL_SCANCODE_APP2 = 284,
SDL_SCANCODE_AUDIOREWIND = 285,
SDL_SCANCODE_AUDIOFASTFORWARD = 286,
SDL_NUM_SCANCODES = 512
}
}
else {
enum SDL_Scancode {
SDL_SCANCODE_UNKNOWN = 0,
SDL_SCANCODE_A = 4,
SDL_SCANCODE_B = 5,
SDL_SCANCODE_C = 6,
SDL_SCANCODE_D = 7,
SDL_SCANCODE_E = 8,
SDL_SCANCODE_F = 9,
SDL_SCANCODE_G = 10,
SDL_SCANCODE_H = 11,
SDL_SCANCODE_I = 12,
SDL_SCANCODE_J = 13,
SDL_SCANCODE_K = 14,
SDL_SCANCODE_L = 15,
SDL_SCANCODE_M = 16,
SDL_SCANCODE_N = 17,
SDL_SCANCODE_O = 18,
SDL_SCANCODE_P = 19,
SDL_SCANCODE_Q = 20,
SDL_SCANCODE_R = 21,
SDL_SCANCODE_S = 22,
SDL_SCANCODE_T = 23,
SDL_SCANCODE_U = 24,
SDL_SCANCODE_V = 25,
SDL_SCANCODE_W = 26,
SDL_SCANCODE_X = 27,
SDL_SCANCODE_Y = 28,
SDL_SCANCODE_Z = 29,
SDL_SCANCODE_1 = 30,
SDL_SCANCODE_2 = 31,
SDL_SCANCODE_3 = 32,
SDL_SCANCODE_4 = 33,
SDL_SCANCODE_5 = 34,
SDL_SCANCODE_6 = 35,
SDL_SCANCODE_7 = 36,
SDL_SCANCODE_8 = 37,
SDL_SCANCODE_9 = 38,
SDL_SCANCODE_0 = 39,
SDL_SCANCODE_RETURN = 40,
SDL_SCANCODE_ESCAPE = 41,
SDL_SCANCODE_BACKSPACE = 42,
SDL_SCANCODE_TAB = 43,
SDL_SCANCODE_SPACE = 44,
SDL_SCANCODE_MINUS = 45,
SDL_SCANCODE_EQUALS = 46,
SDL_SCANCODE_LEFTBRACKET = 47,
SDL_SCANCODE_RIGHTBRACKET = 48,
SDL_SCANCODE_BACKSLASH = 49,
SDL_SCANCODE_NONUSHASH = 50,
SDL_SCANCODE_SEMICOLON = 51,
SDL_SCANCODE_APOSTROPHE = 52,
SDL_SCANCODE_GRAVE = 53,
SDL_SCANCODE_COMMA = 54,
SDL_SCANCODE_PERIOD = 55,
SDL_SCANCODE_SLASH = 56,
SDL_SCANCODE_CAPSLOCK = 57,
SDL_SCANCODE_F1 = 58,
SDL_SCANCODE_F2 = 59,
SDL_SCANCODE_F3 = 60,
SDL_SCANCODE_F4 = 61,
SDL_SCANCODE_F5 = 62,
SDL_SCANCODE_F6 = 63,
SDL_SCANCODE_F7 = 64,
SDL_SCANCODE_F8 = 65,
SDL_SCANCODE_F9 = 66,
SDL_SCANCODE_F10 = 67,
SDL_SCANCODE_F11 = 68,
SDL_SCANCODE_F12 = 69,
SDL_SCANCODE_PRINTSCREEN = 70,
SDL_SCANCODE_SCROLLLOCK = 71,
SDL_SCANCODE_PAUSE = 72,
SDL_SCANCODE_INSERT = 73,
SDL_SCANCODE_HOME = 74,
SDL_SCANCODE_PAGEUP = 75,
SDL_SCANCODE_DELETE = 76,
SDL_SCANCODE_END = 77,
SDL_SCANCODE_PAGEDOWN = 78,
SDL_SCANCODE_RIGHT = 79,
SDL_SCANCODE_LEFT = 80,
SDL_SCANCODE_DOWN = 81,
SDL_SCANCODE_UP = 82,
SDL_SCANCODE_NUMLOCKCLEAR = 83,
SDL_SCANCODE_KP_DIVIDE = 84,
SDL_SCANCODE_KP_MULTIPLY = 85,
SDL_SCANCODE_KP_MINUS = 86,
SDL_SCANCODE_KP_PLUS = 87,
SDL_SCANCODE_KP_ENTER = 88,
SDL_SCANCODE_KP_1 = 89,
SDL_SCANCODE_KP_2 = 90,
SDL_SCANCODE_KP_3 = 91,
SDL_SCANCODE_KP_4 = 92,
SDL_SCANCODE_KP_5 = 93,
SDL_SCANCODE_KP_6 = 94,
SDL_SCANCODE_KP_7 = 95,
SDL_SCANCODE_KP_8 = 96,
SDL_SCANCODE_KP_9 = 97,
SDL_SCANCODE_KP_0 = 98,
SDL_SCANCODE_KP_PERIOD = 99,
SDL_SCANCODE_NONUSBACKSLASH = 100,
SDL_SCANCODE_APPLICATION = 101,
SDL_SCANCODE_POWER = 102,
SDL_SCANCODE_KP_EQUALS = 103,
SDL_SCANCODE_F13 = 104,
SDL_SCANCODE_F14 = 105,
SDL_SCANCODE_F15 = 106,
SDL_SCANCODE_F16 = 107,
SDL_SCANCODE_F17 = 108,
SDL_SCANCODE_F18 = 109,
SDL_SCANCODE_F19 = 110,
SDL_SCANCODE_F20 = 111,
SDL_SCANCODE_F21 = 112,
SDL_SCANCODE_F22 = 113,
SDL_SCANCODE_F23 = 114,
SDL_SCANCODE_F24 = 115,
SDL_SCANCODE_EXECUTE = 116,
SDL_SCANCODE_HELP = 117,
SDL_SCANCODE_MENU = 118,
SDL_SCANCODE_SELECT = 119,
SDL_SCANCODE_STOP = 120,
SDL_SCANCODE_AGAIN = 121,
SDL_SCANCODE_UNDO = 122,
SDL_SCANCODE_CUT = 123,
SDL_SCANCODE_COPY = 124,
SDL_SCANCODE_PASTE = 125,
SDL_SCANCODE_FIND = 126,
SDL_SCANCODE_MUTE = 127,
SDL_SCANCODE_VOLUMEUP = 128,
SDL_SCANCODE_VOLUMEDOWN = 129,
SDL_SCANCODE_KP_COMMA = 133,
SDL_SCANCODE_KP_EQUALSAS400 = 134,
SDL_SCANCODE_INTERNATIONAL1 = 135,
SDL_SCANCODE_INTERNATIONAL2 = 136,
SDL_SCANCODE_INTERNATIONAL3 = 137,
SDL_SCANCODE_INTERNATIONAL4 = 138,
SDL_SCANCODE_INTERNATIONAL5 = 139,
SDL_SCANCODE_INTERNATIONAL6 = 140,
SDL_SCANCODE_INTERNATIONAL7 = 141,
SDL_SCANCODE_INTERNATIONAL8 = 142,
SDL_SCANCODE_INTERNATIONAL9 = 143,
SDL_SCANCODE_LANG1 = 144,
SDL_SCANCODE_LANG2 = 145,
SDL_SCANCODE_LANG3 = 146,
SDL_SCANCODE_LANG4 = 147,
SDL_SCANCODE_LANG5 = 148,
SDL_SCANCODE_LANG6 = 149,
SDL_SCANCODE_LANG7 = 150,
SDL_SCANCODE_LANG8 = 151,
SDL_SCANCODE_LANG9 = 152,
SDL_SCANCODE_ALTERASE = 153,
SDL_SCANCODE_SYSREQ = 154,
SDL_SCANCODE_CANCEL = 155,
SDL_SCANCODE_CLEAR = 156,
SDL_SCANCODE_PRIOR = 157,
SDL_SCANCODE_RETURN2 = 158,
SDL_SCANCODE_SEPARATOR = 159,
SDL_SCANCODE_OUT = 160,
SDL_SCANCODE_OPER = 161,
SDL_SCANCODE_CLEARAGAIN = 162,
SDL_SCANCODE_CRSEL = 163,
SDL_SCANCODE_EXSEL = 164,
SDL_SCANCODE_KP_00 = 176,
SDL_SCANCODE_KP_000 = 177,
SDL_SCANCODE_THOUSANDSSEPARATOR = 178,
SDL_SCANCODE_DECIMALSEPARATOR = 179,
SDL_SCANCODE_CURRENCYUNIT = 180,
SDL_SCANCODE_CURRENCYSUBUNIT = 181,
SDL_SCANCODE_KP_LEFTPAREN = 182,
SDL_SCANCODE_KP_RIGHTPAREN = 183,
SDL_SCANCODE_KP_LEFTBRACE = 184,
SDL_SCANCODE_KP_RIGHTBRACE = 185,
SDL_SCANCODE_KP_TAB = 186,
SDL_SCANCODE_KP_BACKSPACE = 187,
SDL_SCANCODE_KP_A = 188,
SDL_SCANCODE_KP_B = 189,
SDL_SCANCODE_KP_C = 190,
SDL_SCANCODE_KP_D = 191,
SDL_SCANCODE_KP_E = 192,
SDL_SCANCODE_KP_F = 193,
SDL_SCANCODE_KP_XOR = 194,
SDL_SCANCODE_KP_POWER = 195,
SDL_SCANCODE_KP_PERCENT = 196,
SDL_SCANCODE_KP_LESS = 197,
SDL_SCANCODE_KP_GREATER = 198,
SDL_SCANCODE_KP_AMPERSAND = 199,
SDL_SCANCODE_KP_DBLAMPERSAND = 200,
SDL_SCANCODE_KP_VERTICALBAR = 201,
SDL_SCANCODE_KP_DBLVERTICALBAR = 202,
SDL_SCANCODE_KP_COLON = 203,
SDL_SCANCODE_KP_HASH = 204,
SDL_SCANCODE_KP_SPACE = 205,
SDL_SCANCODE_KP_AT = 206,
SDL_SCANCODE_KP_EXCLAM = 207,
SDL_SCANCODE_KP_MEMSTORE = 208,
SDL_SCANCODE_KP_MEMRECALL = 209,
SDL_SCANCODE_KP_MEMCLEAR = 210,
SDL_SCANCODE_KP_MEMADD = 211,
SDL_SCANCODE_KP_MEMSUBTRACT = 212,
SDL_SCANCODE_KP_MEMMULTIPLY = 213,
SDL_SCANCODE_KP_MEMDIVIDE = 214,
SDL_SCANCODE_KP_PLUSMINUS = 215,
SDL_SCANCODE_KP_CLEAR = 216,
SDL_SCANCODE_KP_CLEARENTRY = 217,
SDL_SCANCODE_KP_BINARY = 218,
SDL_SCANCODE_KP_OCTAL = 219,
SDL_SCANCODE_KP_DECIMAL = 220,
SDL_SCANCODE_KP_HEXADECIMAL = 221,
SDL_SCANCODE_LCTRL = 224,
SDL_SCANCODE_LSHIFT = 225,
SDL_SCANCODE_LALT = 226,
SDL_SCANCODE_LGUI = 227,
SDL_SCANCODE_RCTRL = 228,
SDL_SCANCODE_RSHIFT = 229,
SDL_SCANCODE_RALT = 230,
SDL_SCANCODE_RGUI = 231,
SDL_SCANCODE_MODE = 257,
SDL_SCANCODE_AUDIONEXT = 258,
SDL_SCANCODE_AUDIOPREV = 259,
SDL_SCANCODE_AUDIOSTOP = 260,
SDL_SCANCODE_AUDIOPLAY = 261,
SDL_SCANCODE_AUDIOMUTE = 262,
SDL_SCANCODE_MEDIASELECT = 263,
SDL_SCANCODE_WWW = 264,
SDL_SCANCODE_MAIL = 265,
SDL_SCANCODE_CALCULATOR = 266,
SDL_SCANCODE_COMPUTER = 267,
SDL_SCANCODE_AC_SEARCH = 268,
SDL_SCANCODE_AC_HOME = 269,
SDL_SCANCODE_AC_BACK = 270,
SDL_SCANCODE_AC_FORWARD = 271,
SDL_SCANCODE_AC_STOP = 272,
SDL_SCANCODE_AC_REFRESH = 273,
SDL_SCANCODE_AC_BOOKMARKS = 274,
SDL_SCANCODE_BRIGHTNESSDOWN = 275,
SDL_SCANCODE_BRIGHTNESSUP = 276,
SDL_SCANCODE_DISPLAYSWITCH = 277,
SDL_SCANCODE_KBDILLUMTOGGLE = 278,
SDL_SCANCODE_KBDILLUMDOWN = 279,
SDL_SCANCODE_KBDILLUMUP = 280,
SDL_SCANCODE_EJECT = 281,
SDL_SCANCODE_SLEEP = 282,
SDL_SCANCODE_APP1 = 283,
SDL_SCANCODE_APP2 = 284,
SDL_NUM_SCANCODES = 512
}
}
mixin(expandEnum!SDL_Scancode);

63
demos/external/imports/bindbc/sdl/bind/sdlshape.d vendored Normal file
View file

@ -0,0 +1,63 @@
// 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.bind.sdlshape;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlpixels : SDL_Color;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlsurface : SDL_Surface;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
enum {
SDL_NONSHAPEABLE_WINDOW = -1,
SDL_INVALID_SHAPE_ARGUMENT = -2,
SDL_WINDOW_LACKS_SHAPE = -3,
}
enum WindowShapeMode {
ShapeModeDefault,
ShapeModeBinarizeAlpha,
ShapeModeReverseBinarizeAlpha,
ShapeModeColorKey
}
mixin(expandEnum!WindowShapeMode);
enum SDL_SHAPEMODEALPHA(WindowShapeMode mode) = (mode == ShapeModeDefault || mode == ShapeModeBinarizeAlpha || mode == ShapeModeReverseBinarizeAlpha);
union SDL_WindowShapeParams {
ubyte binarizationCutoff;
SDL_Color colorKey;
}
struct SDL_WindowShapeMode {
WindowShapeMode mode;
SDL_WindowShapeParams parameters;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_Window* SDL_CreateShapedWindow(const(char)*,uint,uint,uint,uint,uint);
SDL_bool SDL_IsShapedWindow(const(SDL_Window)*);
int SDL_SetWindowShape(SDL_Window*,SDL_Surface*,SDL_WindowShapeMode*);
int SDL_GetShapedWindowMode(SDL_Window*,SDL_WindowShapeMode*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_CreateShapedWindow = SDL_Window* function(const(char)*,uint,uint,uint,uint,uint);
alias pSDL_IsShapedWindow = SDL_bool function(const(SDL_Window)*);
alias pSDL_SetWindowShape = int function(SDL_Window*,SDL_Surface*,SDL_WindowShapeMode*);
alias pSDL_GetShapedWindowMode = int function(SDL_Window*,SDL_WindowShapeMode*);
}
__gshared {
pSDL_CreateShapedWindow SDL_CreateShapedWindow;
pSDL_IsShapedWindow SDL_IsShapedWindow;
pSDL_SetWindowShape SDL_SetWindowShape;
pSDL_GetShapedWindowMode SDL_GetShapedWindowMode;
}
}

42
demos/external/imports/bindbc/sdl/bind/sdlstdinc.d vendored Normal file
View file

@ -0,0 +1,42 @@
// 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.bind.sdlstdinc;
import bindbc.sdl.config;
enum SDL_bool {
SDL_FALSE = 0,
SDL_TRUE = 1
}
mixin(expandEnum!SDL_bool);
alias Sint8 = byte;
alias Uint8 = ubyte;
alias Sint16 = short;
alias Uint16 = ushort;
alias Sint32 = int;
alias Uint32 = uint;
alias Sint64 = long;
alias Uint64 = ulong;
enum SDL_FOURCC(char A, char B, char C, char D) = ((A << 0) | (B << 8) | (C << 16) | (D << 24));
version(BindSDL_Static) {
extern(C) @nogc nothrow {
void SDL_free(void* mem);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_free = void function(void* mem);
}
__gshared {
pSDL_free SDL_free;
}
}

230
demos/external/imports/bindbc/sdl/bind/sdlsurface.d vendored Normal file
View file

@ -0,0 +1,230 @@
// 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.bind.sdlsurface;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlblendmode : SDL_BlendMode;
import bindbc.sdl.bind.sdlrect : SDL_Rect;
import bindbc.sdl.bind.sdlrwops;
import bindbc.sdl.bind.sdlpixels : SDL_Palette, SDL_PixelFormat;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
enum {
SDL_SWSURFACE = 0,
SDL_PREALLOC = 0x00000001,
SDL_RLEACCEL = 0x00000002,
SDL_DONTFREE = 0x00000004,
}
@nogc nothrow pure
bool SDL_MUSTLOCK(const(SDL_Surface)* S)
{
pragma(inline, true);
return (S.flags & SDL_RLEACCEL) != 0;
}
struct SDL_BlitMap;
struct SDL_Surface {
int flags;
SDL_PixelFormat* format;
int w, h;
int pitch;
void* pixels;
void* userdata;
int locked;
void* lock_data;
SDL_Rect clip_rect;
SDL_BlitMap* map;
int refcount;
}
extern(C) nothrow alias SDL_blit = int function(SDL_Surface* src, SDL_Rect* srcrect, SDL_Surface* dst, SDL_Rect* dstrect);
@nogc nothrow {
SDL_Surface* SDL_LoadBMP(const(char)* file) {
pragma(inline, true);
return SDL_LoadBMP_RW(SDL_RWFromFile(file,"rb"),1);
}
int SDL_SaveBMP(SDL_Surface* surface,const(char)* file) {
pragma(inline, true);
return SDL_SaveBMP_RW(surface,SDL_RWFromFile(file,"wb"),1);
}
}
alias SDL_BlitSurface = SDL_UpperBlit;
alias SDL_BlitScaled = SDL_UpperBlitScaled;
static if(sdlSupport >= SDLSupport.sdl208) {
enum SDL_YUV_CONVERSION_MODE {
SDL_YUV_CONVERSION_JPEG,
SDL_YUV_CONVERSION_BT601,
SDL_YUV_CONVERSION_BT709,
SDL_YUV_CONVERSION_AUTOMATIC,
}
mixin(expandEnum!SDL_YUV_CONVERSION_MODE);
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_Surface* SDL_CreateRGBSurface(uint,int,int,int,uint,uint,uint,uint);
SDL_Surface* SDL_CreateRGBSurfaceFrom(void*,int,int,int,int,uint,uint,uint,uint);
void SDL_FreeSurface(SDL_Surface*);
int SDL_SetSurfacePalette(SDL_Surface*,SDL_Palette*);
int SDL_LockSurface(SDL_Surface*);
int SDL_UnlockSurface(SDL_Surface*);
SDL_Surface* SDL_LoadBMP_RW(SDL_RWops*,int);
int SDL_SaveBMP_RW(SDL_Surface*,SDL_RWops*,int);
int SDL_SetSurfaceRLE(SDL_Surface*,int);
int SDL_SetColorKey(SDL_Surface*,int,uint);
int SDL_GetColorKey(SDL_Surface*,uint*);
int SDL_SetSurfaceColorMod(SDL_Surface*,ubyte,ubyte,ubyte);
int SDL_GetSurfaceColorMod(SDL_Surface*,ubyte*,ubyte*,ubyte*);
int SDL_SetSurfaceAlphaMod(SDL_Surface*,ubyte);
int SDL_GetSurfaceAlphaMod(SDL_Surface*,ubyte*);
int SDL_SetSurfaceBlendMode(SDL_Surface*,SDL_BlendMode);
int SDL_GetSurfaceBlendMode(SDL_Surface*,SDL_BlendMode*);
SDL_bool SDL_SetClipRect(SDL_Surface*,const(SDL_Rect)*);
void SDL_GetClipRect(SDL_Surface*,SDL_Rect*);
SDL_Surface* SDL_ConvertSurface(SDL_Surface*,const(SDL_PixelFormat)*,uint);
SDL_Surface* SDL_ConvertSurfaceFormat(SDL_Surface*,uint,uint);
int SDL_ConvertPixels(int,int,uint,const(void)*,int,uint,void*,int);
int SDL_FillRect(SDL_Surface*,const(SDL_Rect)*,uint);
int SDL_FillRects(SDL_Surface*,const(SDL_Rect)*,int,uint);
int SDL_UpperBlit(SDL_Surface*,const(SDL_Rect)*,SDL_Surface*,SDL_Rect*);
int SDL_LowerBlit(SDL_Surface*,SDL_Rect*,SDL_Surface*,SDL_Rect*);
int SDL_SoftStretch(SDL_Surface*,const(SDL_Rect)*,SDL_Surface*,const(SDL_Rect)*);
int SDL_UpperBlitScaled(SDL_Surface*,const(SDL_Rect)*,SDL_Surface*,SDL_Rect*);
int SDL_LowerBlitScaled(SDL_Surface*,SDL_Rect*,SDL_Surface*,SDL_Rect*);
static if(sdlSupport >= SDLSupport.sdl205) {
SDL_Surface* SDL_CreateRGBSurfaceWithFormat(uint,int,int,int,uint);
SDL_Surface* SDL_CreateRGBSurfaceWithFormatFrom(void*,int,int,int,int,uint);
}
static if(sdlSupport >= SDLSupport.sdl205) {
SDL_Surface* SDL_DuplicateSurface(SDL_Surface*);
}
static if(sdlSupport >= SDLSupport.sdl208) {
void SDL_SetYUVConversionMode(SDL_YUV_CONVERSION_MODE);
SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionMode();
SDL_YUV_CONVERSION_MODE SDL_GetYUVConversionModeForResolution(int,int);
}
static if(sdlSupport >= SDLSupport.sdl209) {
SDL_bool SDL_HasColorKey(SDL_Surface*);
}
}
}
else {
extern(C) @nogc nothrow {alias pSDL_CreateRGBSurface = SDL_Surface* function(uint,int,int,int,uint,uint,uint,uint);
alias pSDL_CreateRGBSurfaceFrom = SDL_Surface* function(void*,int,int,int,int,uint,uint,uint,uint);
alias pSDL_FreeSurface = void function(SDL_Surface*);
alias pSDL_SetSurfacePalette = int function(SDL_Surface*,SDL_Palette*);
alias pSDL_LockSurface = int function(SDL_Surface*);
alias pSDL_UnlockSurface = int function(SDL_Surface*);
alias pSDL_LoadBMP_RW = SDL_Surface* function(SDL_RWops*,int);
alias pSDL_SaveBMP_RW = int function(SDL_Surface*,SDL_RWops*,int);
alias pSDL_SetSurfaceRLE = int function(SDL_Surface*,int);
alias pSDL_SetColorKey = int function(SDL_Surface*,int,uint);
alias pSDL_GetColorKey = int function(SDL_Surface*,uint*);
alias pSDL_SetSurfaceColorMod = int function(SDL_Surface*,ubyte,ubyte,ubyte);
alias pSDL_GetSurfaceColorMod = int function(SDL_Surface*,ubyte*,ubyte*,ubyte*);
alias pSDL_SetSurfaceAlphaMod = int function(SDL_Surface*,ubyte);
alias pSDL_GetSurfaceAlphaMod = int function(SDL_Surface*,ubyte*);
alias pSDL_SetSurfaceBlendMode = int function(SDL_Surface*,SDL_BlendMode);
alias pSDL_GetSurfaceBlendMode = int function(SDL_Surface*,SDL_BlendMode*);
alias pSDL_SetClipRect = SDL_bool function(SDL_Surface*,const(SDL_Rect)*);
alias pSDL_GetClipRect = void function(SDL_Surface*,SDL_Rect*);
alias pSDL_ConvertSurface = SDL_Surface* function(SDL_Surface*,const(SDL_PixelFormat)*,uint);
alias pSDL_ConvertSurfaceFormat = SDL_Surface* function(SDL_Surface*,uint,uint);
alias pSDL_ConvertPixels = int function(int,int,uint,const(void)*,int,uint,void*,int);
alias pSDL_FillRect = int function(SDL_Surface*,const(SDL_Rect)*,uint);
alias pSDL_FillRects = int function(SDL_Surface*,const(SDL_Rect)*,int,uint);
alias pSDL_UpperBlit = int function(SDL_Surface*,const(SDL_Rect)*,SDL_Surface*,SDL_Rect*);
alias pSDL_LowerBlit = int function(SDL_Surface*,SDL_Rect*,SDL_Surface*,SDL_Rect*);
alias pSDL_SoftStretch = int function(SDL_Surface*,const(SDL_Rect)*,SDL_Surface*,const(SDL_Rect)*);
alias pSDL_UpperBlitScaled = int function(SDL_Surface*,const(SDL_Rect)*,SDL_Surface*,SDL_Rect*);
alias pSDL_LowerBlitScaled = int function(SDL_Surface*,SDL_Rect*,SDL_Surface*,SDL_Rect*);
}
__gshared {
pSDL_CreateRGBSurface SDL_CreateRGBSurface;
pSDL_CreateRGBSurfaceFrom SDL_CreateRGBSurfaceFrom;
pSDL_FreeSurface SDL_FreeSurface;
pSDL_SetSurfacePalette SDL_SetSurfacePalette;
pSDL_LockSurface SDL_LockSurface;
pSDL_UnlockSurface SDL_UnlockSurface;
pSDL_LoadBMP_RW SDL_LoadBMP_RW;
pSDL_SaveBMP_RW SDL_SaveBMP_RW;
pSDL_SetSurfaceRLE SDL_SetSurfaceRLE;
pSDL_SetColorKey SDL_SetColorKey;
pSDL_GetColorKey SDL_GetColorKey;
pSDL_SetSurfaceColorMod SDL_SetSurfaceColorMod;
pSDL_GetSurfaceColorMod SDL_GetSurfaceColorMod;
pSDL_SetSurfaceAlphaMod SDL_SetSurfaceAlphaMod;
pSDL_GetSurfaceAlphaMod SDL_GetSurfaceAlphaMod;
pSDL_SetSurfaceBlendMode SDL_SetSurfaceBlendMode;
pSDL_GetSurfaceBlendMode SDL_GetSurfaceBlendMode;
pSDL_SetClipRect SDL_SetClipRect;
pSDL_GetClipRect SDL_GetClipRect;
pSDL_ConvertSurface SDL_ConvertSurface;
pSDL_ConvertSurfaceFormat SDL_ConvertSurfaceFormat;
pSDL_ConvertPixels SDL_ConvertPixels;
pSDL_FillRect SDL_FillRect;
pSDL_FillRects SDL_FillRects;
pSDL_UpperBlit SDL_UpperBlit;
pSDL_LowerBlit SDL_LowerBlit;
pSDL_SoftStretch SDL_SoftStretch;
pSDL_UpperBlitScaled SDL_UpperBlitScaled;
pSDL_LowerBlitScaled SDL_LowerBlitScaled;
}
static if(sdlSupport >= SDLSupport.sdl205) {
extern(C) @nogc nothrow {
alias pSDL_CreateRGBSurfaceWithFormat = SDL_Surface* function(uint,int,int,int,uint);
alias pSDL_CreateRGBSurfaceWithFormatFrom = SDL_Surface* function(void*,int,int,int,int,uint);
}
__gshared {
pSDL_CreateRGBSurfaceWithFormat SDL_CreateRGBSurfaceWithFormat;
pSDL_CreateRGBSurfaceWithFormatFrom SDL_CreateRGBSurfaceWithFormatFrom;
}
}
static if(sdlSupport >= SDLSupport.sdl205) {
extern(C) @nogc nothrow {
alias pSDL_DuplicateSurface = SDL_Surface* function(SDL_Surface*);
}
__gshared {
pSDL_DuplicateSurface SDL_DuplicateSurface;
}
}
static if(sdlSupport >= SDLSupport.sdl208) {
extern(C) @nogc nothrow {
alias pSDL_SetYUVConversionMode = void function(SDL_YUV_CONVERSION_MODE);
alias pSDL_GetYUVConversionMode = SDL_YUV_CONVERSION_MODE function();
alias pSDL_GetYUVConversionModeForResolution = SDL_YUV_CONVERSION_MODE function(int,int);
}
__gshared {
pSDL_SetYUVConversionMode SDL_SetYUVConversionMode;
pSDL_GetYUVConversionMode SDL_GetYUVConversionMode;
pSDL_GetYUVConversionModeForResolution SDL_GetYUVConversionModeForResolution;
}
}
static if(sdlSupport >= SDLSupport.sdl209) {
extern(C) @nogc nothrow {
alias pSDL_HasColorKey = SDL_bool function(SDL_Surface*);
}
__gshared {
pSDL_HasColorKey SDL_HasColorKey;
}
}
}

152
demos/external/imports/bindbc/sdl/bind/sdlsystem.d vendored Normal file
View file

@ -0,0 +1,152 @@
// 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.bind.sdlsystem;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlrender : SDL_Renderer;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
version(Android) {
enum int SDL_ANDROID_EXTERNAL_STORAGE_READ = 0x01;
enum int SDL_ANDROID_EXTERNAL_STORAGE_WRITE = 0x02;
}
static if(sdlSupport >= SDLSupport.sdl201) {
version(Windows) struct IDirect3DDevice9;
}
static if(sdlSupport >= SDLSupport.sdl204) {
version(Windows) {
extern(C) nothrow alias SDL_WindowsMessageHook = void function(void*,void*,uint,ulong,long);
}
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
version(Android) {
void* SDL_AndroidGetJNIEnv();
void* SDL_AndroidGetActivity();
const(char)* SDL_AndroidGetInternalStoragePath();
int SDL_AndroidGetInternalStorageState();
const(char)* SDL_AndroidGetExternalStoragePath();
static if(sdlSupport >= SDLSupport.sdl208) {
SDL_bool SDL_IsAndroidTV();
}
static if(sdlSupport >= SDLSupport.sdl209) {
SDL_bool SDL_IsChromebook();
SDL_bool SDL_IsDeXMode();
void SDL_AndroidBackButton();
}
}
else version(Windows) {
static if(sdlSupport >= SDLSupport.sdl201) {
int SDL_Direct3D9GetAdapterIndex(int);
IDirect3DDevice9* SDL_RenderGetD3D9Device(SDL_Renderer*);
}
static if(sdlSupport >= SDLSupport.sdl202) {
SDL_bool SDL_DXGIGetOutputInfo(int,int*,int*);
}
static if(sdlSupport >= SDLSupport.sdl204) {
void SDL_SetWindowsMessageHook(SDL_WindowsMessageHook,void*);
}
}
else version(linux) {
static if(sdlSupport >= SDLSupport.sdl209) {
int SDL_LinuxSetThreadPriority(long,int);
}
}
}
}
else {
version(Android) {
extern(C) @nogc nothrow {
alias pSDL_AndroidGetJNIEnv = void* function();
alias pSDL_AndroidGetActivity = void* function();
alias pSDL_AndroidGetInternalStoragePath = const(char)* function();
alias pSDL_AndroidGetInternalStorageState = int function();
alias pSDL_AndroidGetExternalStoragePath = const(char)* function();
}
__gshared {
pSDL_AndroidGetJNIEnv SDL_AndroidGetJNIEnv;
pSDL_AndroidGetActivity SDL_AndroidGetActivity;
pSDL_AndroidGetInternalStoragePath SDL_AndroidGetInternalStoragePath;
pSDL_AndroidGetInternalStorageState SDL_AndroidGetInternalStorageState;
pSDL_AndroidGetExternalStoragePath SDL_AndroidGetExternalStoragePath;
}
static if(sdlSupport >= SDLSupport.sdl208) {
extern(C) @nogc nothrow {
alias pSDL_IsAndroidTV = SDL_bool function();
}
__gshared {
pSDL_IsAndroidTV SDL_IsAndroidTV;
}
}
static if(sdlSupport >= SDLSupport.sdl209) {
extern(C) @nogc nothrow {
alias pSDL_IsChromebook = SDL_bool function();
alias pSDL_IsDeXMode = SDL_bool function();
alias pSDL_AndroidBackButton = void function();
}
__gshared {
pSDL_IsChromebook SDL_IsChromebook;
pSDL_IsDeXMode SDL_IsDeXMode;
pSDL_AndroidBackButton SDL_AndroidBackButton;
}
}
}
else version(Windows) {
static if(sdlSupport >= SDLSupport.sdl201) {
extern(C) @nogc nothrow {
alias pSDL_Direct3D9GetAdapterIndex = int function(int);
alias pSDL_RenderGetD3D9Device = IDirect3DDevice9* function(SDL_Renderer*);
}
__gshared {
pSDL_Direct3D9GetAdapterIndex SDL_Direct3D9GetAdapterIndex ;
pSDL_RenderGetD3D9Device SDL_RenderGetD3D9Device;
}
}
static if(sdlSupport >= SDLSupport.sdl202) {
extern(C) @nogc nothrow {
alias pSDL_DXGIGetOutputInfo = SDL_bool function(int,int*,int*);
}
__gshared {
pSDL_DXGIGetOutputInfo SDL_DXGIGetOutputInfo;
}
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_SetWindowsMessageHook = void function(SDL_WindowsMessageHook,void*);
}
__gshared {
pSDL_SetWindowsMessageHook SDL_SetWindowsMessageHook;
}
}
}
else version(linux) {
static if(sdlSupport >= SDLSupport.sdl209) {
extern(C) @nogc nothrow {
alias pSDL_LinuxSetThreadPriority = int function(long,int);
}
__gshared {
pSDL_LinuxSetThreadPriority SDL_LinuxSetThreadPriority;
}
}
}
}

240
demos/external/imports/bindbc/sdl/bind/sdlsyswm.d vendored Normal file
View file

@ -0,0 +1,240 @@
// 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.bind.sdlsyswm;
//import core.stdc.config : c_long;
alias int c_long;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlversion : SDL_version;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
static if(sdlSupport >= SDLSupport.sdl205) {
enum SDL_SYSWM_TYPE {
SDL_SYSWM_UNKNOWN,
SDL_SYSWM_WINDOWS,
SDL_SYSWM_X11,
SDL_SYSWM_DIRECTFB,
SDL_SYSWM_COCOA,
SDL_SYSWM_UIKIT,
SDL_SYSWM_WAYLAND,
SDL_SYSWM_MIR,
SDL_SYSWM_WINRT,
SDL_SYSWM_ANDROID,
SDL_SYSWM_VIVANTE,
SDL_SYSWM_OS2,
}
}
else static if(sdlSupport >= SDLSupport.sdl205) {
enum SDL_SYSWM_TYPE {
SDL_SYSWM_UNKNOWN,
SDL_SYSWM_WINDOWS,
SDL_SYSWM_X11,
SDL_SYSWM_DIRECTFB,
SDL_SYSWM_COCOA,
SDL_SYSWM_UIKIT,
SDL_SYSWM_WAYLAND,
SDL_SYSWM_MIR,
SDL_SYSWM_WINRT,
SDL_SYSWM_ANDROID,
SDL_SYSWM_VIVANTE,
}
}
else static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_SYSWM_TYPE {
SDL_SYSWM_UNKNOWN,
SDL_SYSWM_WINDOWS,
SDL_SYSWM_X11,
SDL_SYSWM_DIRECTFB,
SDL_SYSWM_COCOA,
SDL_SYSWM_UIKIT,
SDL_SYSWM_WAYLAND,
SDL_SYSWM_MIR,
SDL_SYSWM_WINRT,
SDL_SYSWM_ANDROID,
}
}
else static if(sdlSupport >= SDLSupport.sdl203) {
enum SDL_SYSWM_TYPE {
SDL_SYSWM_UNKNOWN,
SDL_SYSWM_WINDOWS,
SDL_SYSWM_X11,
SDL_SYSWM_DIRECTFB,
SDL_SYSWM_COCOA,
SDL_SYSWM_UIKIT,
SDL_SYSWM_WAYLAND,
SDL_SYSWM_MIR,
SDL_SYSWM_WINRT,
}
}
else static if(sdlSupport >= SDLSupport.sdl202) {
enum SDL_SYSWM_TYPE {
SDL_SYSWM_UNKNOWN,
SDL_SYSWM_WINDOWS,
SDL_SYSWM_X11,
SDL_SYSWM_DIRECTFB,
SDL_SYSWM_COCOA,
SDL_SYSWM_UIKIT,
SDL_SYSWM_WAYLAND,
SDL_SYSWM_MIR,
}
}
else {
enum SDL_SYSWM_TYPE {
SDL_SYSWM_UNKNOWN,
SDL_SYSWM_WINDOWS,
SDL_SYSWM_X11,
SDL_SYSWM_DIRECTFB,
SDL_SYSWM_COCOA,
SDL_SYSWM_UIKIT,
}
}
mixin(expandEnum!SDL_SYSWM_TYPE);
version(Windows) {
// I don't want to import core.sys.windows.windows just for these
version(Win64) {
alias wparam = ulong;
alias lparam = long;
}else {
alias wparam = uint;
alias lparam = int;
}
}
struct SDL_SysWMmsg {
SDL_version version_;
SDL_SYSWM_TYPE subsystem;
union msg_ {
version(Windows) {
struct win_ {
void* hwnd;
uint msg;
wparam wParam;
lparam lParam;
}
win_ win;
}
else version(OSX) {
struct cocoa_ {
int dummy;
}
cocoa_ cocoa;
}
else version(linux) {
struct dfb_ {
void* event;
}
dfb_ dfb;
}
version(Posix) {
struct x11_ {
c_long[24] pad; // sufficient size for any X11 event
}
x11_ x11;
}
static if(sdlSupport >= SDLSupport.sdl205) {
struct vivante_ {
int dummy;
}
vivante_ vivante;
}
int dummy;
}
msg_ msg;
}
struct SDL_SysWMinfo {
SDL_version version_;
SDL_SYSWM_TYPE subsystem;
union info_ {
version(Windows) {
struct win_ {
void* window;
static if(sdlSupport >= SDLSupport.sdl204) void* hdc;
static if(sdlSupport >= SDLSupport.sdl206) void* hinstance;
}
win_ win;
}
else version(OSX) {
struct cocoa_ {
void* window;
}
cocoa_ cocoa;
struct uikit_ {
void *window;
}
uikit_ uikit;
}
else version(linux) {
struct dfb_ {
void *dfb;
void *window;
void *surface;
}
dfb_ dfb;
static if(sdlSupport >= SDLSupport.sdl202) {
struct wl_ {
void *display;
void *surface;
void *shell_surface;
}
wl_ wl;
struct mir_ {
void *connection;
void *surface;
}
mir_ mir;
}
}
version(Posix) {
struct x11_ {
void* display;
uint window;
}
x11_ x11;
}
static if(sdlSupport >= SDLSupport.sdl204) {
version(Android) {
struct android_ {
void* window;
void* surface;
}
android_ android;
}
}
static if(sdlSupport >= SDLSupport.sdl206) ubyte[64] dummy;
else int dummy;
}
info_ info;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
SDL_bool SDL_GetWindowWMInfo(SDL_Window*,SDL_SysWMinfo*);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetWindowWMInfo = SDL_bool function(SDL_Window*,SDL_SysWMinfo*);
}
__gshared {
pSDL_GetWindowWMInfo SDL_GetWindowWMInfo;
}
}

51
demos/external/imports/bindbc/sdl/bind/sdltimer.d vendored Normal file
View file

@ -0,0 +1,51 @@
// 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.bind.sdltimer;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
extern(C) nothrow alias SDL_TimerCallback = uint function(uint interval, void* param);
alias SDL_TimerID = int;
// This was added to SDL 2.0.1 as a macro, but it's
// useful & has no dependency on the library version,
// so it's here for 2.0.0 as well.
@nogc nothrow pure
bool SDL_TICKS_PASSED(uint A, uint B) {
pragma(inline, true);
return cast(int)(B - A) <= 0;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
uint SDL_GetTicks();
ulong SDL_GetPerformanceCounter();
ulong SDL_GetPerformanceFrequency();
void SDL_Delay(uint);
SDL_TimerID SDL_AddTimer(uint,SDL_TimerCallback,void*);
SDL_bool SDL_RemoveTimer(SDL_TimerID);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetTicks = uint function();
alias pSDL_GetPerformanceCounter = ulong function();
alias pSDL_GetPerformanceFrequency = ulong function();
alias pSDL_Delay = void function(uint);
alias pSDL_AddTimer = SDL_TimerID function(uint,SDL_TimerCallback,void*);
alias pSDL_RemoveTimer = SDL_bool function(SDL_TimerID);
}
__gshared {
pSDL_GetTicks SDL_GetTicks;
pSDL_GetPerformanceCounter SDL_GetPerformanceCounter;
pSDL_GetPerformanceFrequency SDL_GetPerformanceFrequency;
pSDL_Delay SDL_Delay;
pSDL_AddTimer SDL_AddTimer;
pSDL_RemoveTimer SDL_RemoveTimer;
}
}

67
demos/external/imports/bindbc/sdl/bind/sdltouch.d vendored Normal file
View file

@ -0,0 +1,67 @@
// 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.bind.sdltouch;
import bindbc.sdl.config;
alias SDL_TouchID = long;
alias SDL_FingerID = long;
struct SDL_Finger {
SDL_FingerID id;
float x;
float y;
float pressure;
}
enum DL_TOUCH_MOUSEID = cast(uint)-1;
static if(sdlSupport >= SDLSupport.sdl2010) {
enum SDL_TouchDeviceType {
SDL_TOUCH_DEVICE_INVALID = -1,
SDL_TOUCH_DEVICE_DIRECT,
SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE,
SDL_TOUCH_DEVICE_INDIRECT_RELATIVE,
}
mixin(expandEnum!SDL_TouchDeviceType);
enum SDL_MOUSE_TOUCHID = -1L;
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_GetNumTouchDevices();
SDL_TouchID SDL_GetTouchDevice(int);
int SDL_GetNumTouchFingers(SDL_TouchID);
SDL_Finger* SDL_GetTouchFinger(SDL_TouchID,int);
}
static if(sdlSupport >= SDLSupport.sdl2010) {
SDL_TouchDeviceType SDL_GetTouchDeviceType(SDL_TouchID);
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetNumTouchDevices = int function();
alias pSDL_GetTouchDevice = SDL_TouchID function(int);
alias pSDL_GetNumTouchFingers = int function(SDL_TouchID);
alias pSDL_GetTouchFinger = SDL_Finger* function(SDL_TouchID,int);
}
__gshared {
pSDL_GetNumTouchDevices SDL_GetNumTouchDevices;
pSDL_GetTouchDevice SDL_GetTouchDevice;
pSDL_GetNumTouchFingers SDL_GetNumTouchFingers;
pSDL_GetTouchFinger SDL_GetTouchFinger;
}
static if(sdlSupport >= SDLSupport.sdl2010) {
extern(C) @nogc nothrow {
alias pSDL_GetTouchDeviceType = SDL_TouchDeviceType function(SDL_TouchID);
}
__gshared {
pSDL_GetTouchDeviceType SDL_GetTouchDeviceType;
}
}
}

83
demos/external/imports/bindbc/sdl/bind/sdlversion.d vendored Normal file
View file

@ -0,0 +1,83 @@
// 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.bind.sdlversion;
struct SDL_version {
ubyte major;
ubyte minor;
ubyte patch;
}
enum SDL_MAJOR_VERSION = 2;
enum SDL_MINOR_VERSION = 0;
version(SDL_201) {
enum ubyte SDL_PATCHLEVEL = 1;
}
else version(SDL_202) {
enum ubyte SDL_PATCHLEVEL = 2;
}
else version(SDL_203) {
enum ubyte SDL_PATCHLEVEL = 3;
}
else version(SDL_204) {
enum ubyte SDL_PATCHLEVEL = 4;
}
else version(SDL_205) {
enum ubyte SDL_PATCHLEVEL = 5;
}
else version(SDL_206) {
enum ubyte SDL_PATCHLEVEL = 6;
}
else version(SDL_207) {
enum ubyte SDL_PATCHLEVEL = 7;
}
else version(SDL_208) {
enum ubyte SDL_PATCHLEVEL = 8;
}
else version(SDL_209) {
enum ubyte SDL_PATCHLEVEL = 9;
}
else version(SDL_2010) {
enum ubyte SDL_PATCHLEVEL = 10;
}
else {
enum ubyte SDL_PATCHLEVEL = 0;
}
@nogc nothrow pure
void SDL_VERSION(SDL_version* x) {
pragma(inline, true);
x.major = SDL_MAJOR_VERSION;
x.minor = SDL_MINOR_VERSION;
x.patch = SDL_PATCHLEVEL;
}
enum SDL_VERSIONNUM(ubyte X, ubyte Y, ubyte Z) = X*1000 + Y*100 + Z;
enum SDL_COMPILEDVERSION = SDL_VERSIONNUM!(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL);
enum SDL_VERSION_ATLEAST(ubyte X, ubyte Y, ubyte Z) = SDL_COMPILEDVERSION >= SDL_VERSIONNUM!(X, Y, Z);
version(BindSDL_Static) {
extern(C) @nogc nothrow {
void SDL_GetVersion(SDL_version*);
const(char)* SDL_GetRevision();
int SDL_GetRevisionNumber();
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetVersion = void function(SDL_version*);
alias pSDL_GetRevision = const(char)* function();
alias pSDL_GetRevisionNumber = int function();
}
__gshared {
pSDL_GetVersion SDL_GetVersion;
pSDL_GetRevision SDL_GetRevision;
pSDL_GetRevisionNumber SDL_GetRevisionNumber;
}
}

677
demos/external/imports/bindbc/sdl/bind/sdlvideo.d vendored Normal file
View file

@ -0,0 +1,677 @@
// 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.bind.sdlvideo;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlrect : SDL_Rect;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlsurface : SDL_Surface;
struct SDL_DisplayMode {
uint format;
int w;
int h;
int refresh_rate;
void* driverdata;
}
struct SDL_Window;
static if(sdlSupport >= SDLSupport.sdl206) {
enum SDL_WindowFlags {
SDL_WINDOW_FULLSCREEN = 0x00000001,
SDL_WINDOW_OPENGL = 0x00000002,
SDL_WINDOW_SHOWN = 0x00000004,
SDL_WINDOW_HIDDEN = 0x00000008,
SDL_WINDOW_BORDERLESS = 0x00000010,
SDL_WINDOW_RESIZABLE = 0x00000020,
SDL_WINDOW_MINIMIZED = 0x00000040,
SDL_WINDOW_MAXIMIZED = 0x00000080,
SDL_WINDOW_INPUT_GRABBED = 0x00000100,
SDL_WINDOW_INPUT_FOCUS = 0x00000200,
SDL_WINDOW_MOUSE_FOCUS = 0x00000400,
SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN | 0x00001000,
SDL_WINDOW_FOREIGN = 0x00000800,
SDL_WINDOW_ALLOW_HIGHDPI = 0x00002000,
SDL_WINDOW_MOUSE_CAPTURE = 0x00004000,
SDL_WINDOW_ALWAYS_ON_TOP = 0x00008000,
SDL_WINDOW_SKIP_TASKBAR = 0x00010000,
SDL_WINDOW_UTILITY = 0x00020000,
SDL_WINDOW_TOOLTIP = 0x00040000,
SDL_WINDOW_POPUP_MENU = 0x00080000,
SDL_WINDOW_VULKAN = 0x10000000,
}
}
else static if(sdlSupport >= SDLSupport.sdl205) {
enum SDL_WindowFlags {
SDL_WINDOW_FULLSCREEN = 0x00000001,
SDL_WINDOW_OPENGL = 0x00000002,
SDL_WINDOW_SHOWN = 0x00000004,
SDL_WINDOW_HIDDEN = 0x00000008,
SDL_WINDOW_BORDERLESS = 0x00000010,
SDL_WINDOW_RESIZABLE = 0x00000020,
SDL_WINDOW_MINIMIZED = 0x00000040,
SDL_WINDOW_MAXIMIZED = 0x00000080,
SDL_WINDOW_INPUT_GRABBED = 0x00000100,
SDL_WINDOW_INPUT_FOCUS = 0x00000200,
SDL_WINDOW_MOUSE_FOCUS = 0x00000400,
SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN | 0x00001000,
SDL_WINDOW_FOREIGN = 0x00000800,
SDL_WINDOW_ALLOW_HIGHDPI = 0x00002000,
SDL_WINDOW_MOUSE_CAPTURE = 0x00004000,
SDL_WINDOW_ALWAYS_ON_TOP = 0x00008000,
SDL_WINDOW_SKIP_TASKBAR = 0x00010000,
SDL_WINDOW_UTILITY = 0x00020000,
SDL_WINDOW_TOOLTIP = 0x00040000,
SDL_WINDOW_POPUP_MENU = 0x00080000,
}
}
else static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_WindowFlags {
SDL_WINDOW_FULLSCREEN = 0x00000001,
SDL_WINDOW_OPENGL = 0x00000002,
SDL_WINDOW_SHOWN = 0x00000004,
SDL_WINDOW_HIDDEN = 0x00000008,
SDL_WINDOW_BORDERLESS = 0x00000010,
SDL_WINDOW_RESIZABLE = 0x00000020,
SDL_WINDOW_MINIMIZED = 0x00000040,
SDL_WINDOW_MAXIMIZED = 0x00000080,
SDL_WINDOW_INPUT_GRABBED = 0x00000100,
SDL_WINDOW_INPUT_FOCUS = 0x00000200,
SDL_WINDOW_MOUSE_FOCUS = 0x00000400,
SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN | 0x00001000,
SDL_WINDOW_FOREIGN = 0x00000800,
SDL_WINDOW_ALLOW_HIGHDPI = 0x00002000,
SDL_WINDOW_MOUSE_CAPTURE = 0x00004000,
}
}
else static if(sdlSupport >= SDLSupport.sdl201) {
enum SDL_WindowFlags {
SDL_WINDOW_FULLSCREEN = 0x00000001,
SDL_WINDOW_OPENGL = 0x00000002,
SDL_WINDOW_SHOWN = 0x00000004,
SDL_WINDOW_HIDDEN = 0x00000008,
SDL_WINDOW_BORDERLESS = 0x00000010,
SDL_WINDOW_RESIZABLE = 0x00000020,
SDL_WINDOW_MINIMIZED = 0x00000040,
SDL_WINDOW_MAXIMIZED = 0x00000080,
SDL_WINDOW_INPUT_GRABBED = 0x00000100,
SDL_WINDOW_INPUT_FOCUS = 0x00000200,
SDL_WINDOW_MOUSE_FOCUS = 0x00000400,
SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN | 0x00001000,
SDL_WINDOW_FOREIGN = 0x00000800,
SDL_WINDOW_ALLOW_HIGHDPI = 0x00002000,
}
}
else {
enum SDL_WindowFlags {
SDL_WINDOW_FULLSCREEN = 0x00000001,
SDL_WINDOW_OPENGL = 0x00000002,
SDL_WINDOW_SHOWN = 0x00000004,
SDL_WINDOW_HIDDEN = 0x00000008,
SDL_WINDOW_BORDERLESS = 0x00000010,
SDL_WINDOW_RESIZABLE = 0x00000020,
SDL_WINDOW_MINIMIZED = 0x00000040,
SDL_WINDOW_MAXIMIZED = 0x00000080,
SDL_WINDOW_INPUT_GRABBED = 0x00000100,
SDL_WINDOW_INPUT_FOCUS = 0x00000200,
SDL_WINDOW_MOUSE_FOCUS = 0x00000400,
SDL_WINDOW_FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN | 0x00001000,
SDL_WINDOW_FOREIGN = 0x00000800,
}
}
mixin(expandEnum!SDL_WindowFlags);
enum uint SDL_WINDOWPOS_UNDEFINED_MASK = 0x1FFF0000;
enum uint SDL_WINDOWPOS_UNDEFINED_DISPLAY(uint x) = SDL_WINDOWPOS_UNDEFINED_MASK | x;
enum uint SDL_WINDOWPOS_UNDEFINED = SDL_WINDOWPOS_UNDEFINED_DISPLAY!(0);
enum uint SDL_WINDOWPOS_ISUNDEFINED(uint x) = (x & 0xFFFF0000) == SDL_WINDOWPOS_UNDEFINED_MASK;
enum uint SDL_WINDOWPOS_CENTERED_MASK = 0x2FFF0000;
enum uint SDL_WINDOWPOS_CENTERED_DISPLAY(uint x) = SDL_WINDOWPOS_CENTERED_MASK | x;
enum uint SDL_WINDOWPOS_CENTERED = SDL_WINDOWPOS_CENTERED_DISPLAY!(0);
enum uint SDL_WINDOWPOS_ISCENTERED(uint x) = (x & 0xFFFF0000) == SDL_WINDOWPOS_CENTERED_MASK;
static if(sdlSupport >= SDLSupport.sdl205) {
enum SDL_WindowEventID : ubyte {
SDL_WINDOWEVENT_NONE,
SDL_WINDOWEVENT_SHOWN,
SDL_WINDOWEVENT_HIDDEN,
SDL_WINDOWEVENT_EXPOSED,
SDL_WINDOWEVENT_MOVED,
SDL_WINDOWEVENT_RESIZED,
SDL_WINDOWEVENT_SIZE_CHANGED,
SDL_WINDOWEVENT_MINIMIZED,
SDL_WINDOWEVENT_MAXIMIZED,
SDL_WINDOWEVENT_RESTORED,
SDL_WINDOWEVENT_ENTER,
SDL_WINDOWEVENT_LEAVE,
SDL_WINDOWEVENT_FOCUS_GAINED,
SDL_WINDOWEVENT_FOCUS_LOST,
SDL_WINDOWEVENT_CLOSE,
SDL_WINDOWEVENT_TAKE_FOCUS,
SDL_WINDOWEVENT_HIT_TEST,
}
}
else {
enum SDL_WindowEventID : ubyte {
SDL_WINDOWEVENT_NONE,
SDL_WINDOWEVENT_SHOWN,
SDL_WINDOWEVENT_HIDDEN,
SDL_WINDOWEVENT_EXPOSED,
SDL_WINDOWEVENT_MOVED,
SDL_WINDOWEVENT_RESIZED,
SDL_WINDOWEVENT_SIZE_CHANGED,
SDL_WINDOWEVENT_MINIMIZED,
SDL_WINDOWEVENT_MAXIMIZED,
SDL_WINDOWEVENT_RESTORED,
SDL_WINDOWEVENT_ENTER,
SDL_WINDOWEVENT_LEAVE,
SDL_WINDOWEVENT_FOCUS_GAINED,
SDL_WINDOWEVENT_FOCUS_LOST,
SDL_WINDOWEVENT_CLOSE,
}
}
mixin(expandEnum!SDL_WindowEventID);
static if(sdlSupport >= SDLSupport.sdl209) {
enum SDL_DisplayEventID {
SDL_DISPLAYEVENT_NONE,
SDL_DISPLAYEVENT_ORIENTATION,
}
mixin(expandEnum!SDL_DisplayEventID);
enum SDL_DisplayOrientation {
SDL_ORIENTATION_UNKNOWN,
SDL_ORIENTATION_LANDSCAPE,
SDL_ORIENTATION_LANDSCAPE_FLIPPED,
SDL_ORIENTATION_PORTRAIT,
SDL_ORIENTATION_PORTRAIT_FLIPPED,
}
mixin(expandEnum!SDL_DisplayOrientation);
}
alias SDL_GLContext = void*;
static if(sdlSupport >= SDLSupport.sdl206) {
enum SDL_GLattr {
SDL_GL_RED_SIZE,
SDL_GL_GREEN_SIZE,
SDL_GL_BLUE_SIZE,
SDL_GL_ALPHA_SIZE,
SDL_GL_BUFFER_SIZE,
SDL_GL_DOUBLEBUFFER,
SDL_GL_DEPTH_SIZE,
SDL_GL_STENCIL_SIZE,
SDL_GL_ACCUM_RED_SIZE,
SDL_GL_ACCUM_GREEN_SIZE,
SDL_GL_ACCUM_BLUE_SIZE,
SDL_GL_ACCUM_ALPHA_SIZE,
SDL_GL_STEREO,
SDL_GL_MULTISAMPLEBUFFERS,
SDL_GL_MULTISAMPLESAMPLES,
SDL_GL_ACCELERATED_VISUAL,
SDL_GL_RETAINED_BACKING,
SDL_GL_CONTEXT_MAJOR_VERSION,
SDL_GL_CONTEXT_MINOR_VERSION,
SDL_GL_CONTEXT_EGL,
SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_SHARE_WITH_CURRENT_CONTEXT,
SDL_GL_FRAMEBUFFER_SRGB_CAPABLE,
SDL_GL_RELEASE_BEHAVIOR,
SDL_GL_CONTEXT_RESET_NOTIFICATION,
SDL_GL_CONTEXT_NO_ERROR,
}
}
else static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_GLattr {
SDL_GL_RED_SIZE,
SDL_GL_GREEN_SIZE,
SDL_GL_BLUE_SIZE,
SDL_GL_ALPHA_SIZE,
SDL_GL_BUFFER_SIZE,
SDL_GL_DOUBLEBUFFER,
SDL_GL_DEPTH_SIZE,
SDL_GL_STENCIL_SIZE,
SDL_GL_ACCUM_RED_SIZE,
SDL_GL_ACCUM_GREEN_SIZE,
SDL_GL_ACCUM_BLUE_SIZE,
SDL_GL_ACCUM_ALPHA_SIZE,
SDL_GL_STEREO,
SDL_GL_MULTISAMPLEBUFFERS,
SDL_GL_MULTISAMPLESAMPLES,
SDL_GL_ACCELERATED_VISUAL,
SDL_GL_RETAINED_BACKING,
SDL_GL_CONTEXT_MAJOR_VERSION,
SDL_GL_CONTEXT_MINOR_VERSION,
SDL_GL_CONTEXT_EGL,
SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_SHARE_WITH_CURRENT_CONTEXT,
SDL_GL_FRAMEBUFFER_SRGB_CAPABLE,
SDL_GL_RELEASE_BEHAVIOR,
}
}
else static if(sdlSupport >= SDLSupport.sdl201) {
enum SDL_GLattr {
SDL_GL_RED_SIZE,
SDL_GL_GREEN_SIZE,
SDL_GL_BLUE_SIZE,
SDL_GL_ALPHA_SIZE,
SDL_GL_BUFFER_SIZE,
SDL_GL_DOUBLEBUFFER,
SDL_GL_DEPTH_SIZE,
SDL_GL_STENCIL_SIZE,
SDL_GL_ACCUM_RED_SIZE,
SDL_GL_ACCUM_GREEN_SIZE,
SDL_GL_ACCUM_BLUE_SIZE,
SDL_GL_ACCUM_ALPHA_SIZE,
SDL_GL_STEREO,
SDL_GL_MULTISAMPLEBUFFERS,
SDL_GL_MULTISAMPLESAMPLES,
SDL_GL_ACCELERATED_VISUAL,
SDL_GL_RETAINED_BACKING,
SDL_GL_CONTEXT_MAJOR_VERSION,
SDL_GL_CONTEXT_MINOR_VERSION,
SDL_GL_CONTEXT_EGL,
SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_SHARE_WITH_CURRENT_CONTEXT,
SDL_GL_FRAMEBUFFER_SRGB_CAPABLE,
}
}
else {
enum SDL_GLattr {
SDL_GL_RED_SIZE,
SDL_GL_GREEN_SIZE,
SDL_GL_BLUE_SIZE,
SDL_GL_ALPHA_SIZE,
SDL_GL_BUFFER_SIZE,
SDL_GL_DOUBLEBUFFER,
SDL_GL_DEPTH_SIZE,
SDL_GL_STENCIL_SIZE,
SDL_GL_ACCUM_RED_SIZE,
SDL_GL_ACCUM_GREEN_SIZE,
SDL_GL_ACCUM_BLUE_SIZE,
SDL_GL_ACCUM_ALPHA_SIZE,
SDL_GL_STEREO,
SDL_GL_MULTISAMPLEBUFFERS,
SDL_GL_MULTISAMPLESAMPLES,
SDL_GL_ACCELERATED_VISUAL,
SDL_GL_RETAINED_BACKING,
SDL_GL_CONTEXT_MAJOR_VERSION,
SDL_GL_CONTEXT_MINOR_VERSION,
SDL_GL_CONTEXT_EGL,
SDL_GL_CONTEXT_FLAGS,
SDL_GL_CONTEXT_PROFILE_MASK,
SDL_GL_SHARE_WITH_CURRENT_CONTEXT,
}
}
mixin(expandEnum!SDL_GLattr);
enum SDL_GLprofile {
SDL_GL_CONTEXT_PROFILE_CORE = 0x0001,
SDL_GL_CONTEXT_PROFILE_COMPATIBILITY = 0x0002,
SDL_GL_CONTEXT_PROFILE_ES = 0x0004,
}
mixin(expandEnum!SDL_GLprofile);
enum SDL_GLcontextFlag {
SDL_GL_CONTEXT_DEBUG_FLAG = 0x0001,
SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = 0x0002,
SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG = 0x0004,
SDL_GL_CONTEXT_RESET_ISOLATION_FLAG = 0x0008,
}
mixin(expandEnum!SDL_GLcontextFlag);
static if(sdlSupport >= SDLSupport.sdl204) {
enum SDL_GLcontextReleaseFlag {
SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE = 0x0000,
SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x0001,
}
mixin(expandEnum!SDL_GLcontextReleaseFlag);
enum SDL_HitTestResult {
SDL_HITTEST_NORMAL,
SDL_HITTEST_DRAGGABLE,
SDL_HITTEST_RESIZE_TOPLEFT,
SDL_HITTEST_RESIZE_TOP,
SDL_HITTEST_RESIZE_TOPRIGHT,
SDL_HITTEST_RESIZE_RIGHT,
SDL_HITTEST_RESIZE_BOTTOMRIGHT,
SDL_HITTEST_RESIZE_BOTTOM,
SDL_HITTEST_RESIZE_BOTTOMLEFT,
SDL_HITTEST_RESIZE_LEFT,
}
mixin(expandEnum!SDL_HitTestResult);
import bindbc.sdl.bind.sdlrect : SDL_Point;
extern(C) nothrow alias SDL_HitTest = SDL_HitTestResult function(SDL_Window*,const(SDL_Point)*,void*);
}
static if(sdlSupport >= SDLSupport.sdl206) {
enum SDL_GLContextResetNotification {
SDL_GL_CONTEXT_RESET_NO_NOTIFICATION = 0x0000,
SDL_GL_CONTEXT_RESET_LOSE_CONTEXT = 0x0001,
}
mixin(expandEnum!SDL_GLContextResetNotification);
}
version(BindSDL_Static) {
extern(C) @nogc nothrow {
int SDL_GetNumVideoDrivers();
const(char)* SDL_GetVideoDriver(int);
int SDL_VideoInit(const(char)*);
void SDL_VideoQuit();
const(char)* SDL_GetCurrentVideoDriver();
int SDL_GetNumVideoDisplays();
const(char)* SDL_GetDisplayName(int);
int SDL_GetDisplayBounds(int,SDL_Rect*);
int SDL_GetNumDisplayModes(int);
int SDL_GetDisplayMode(int,int,SDL_DisplayMode*);
int SDL_GetDesktopDisplayMode(int,SDL_DisplayMode*);
int SDL_GetCurrentDisplayMode(int,SDL_DisplayMode*);
SDL_DisplayMode* SDL_GetClosestDisplayMode(int,const(SDL_DisplayMode)*,SDL_DisplayMode*);
int SDL_GetWindowDisplayIndex(SDL_Window*);
int SDL_SetWindowDisplayMode(SDL_Window*,const(SDL_DisplayMode)*);
int SDL_GetWindowDisplayMode(SDL_Window*,SDL_DisplayMode*);
uint SDL_GetWindowPixelFormat(SDL_Window*);
SDL_Window* SDL_CreateWindow(const(char)*,int,int,int,int,SDL_WindowFlags);
SDL_Window* SDL_CreateWindowFrom(const(void)*);
uint SDL_GetWindowID(SDL_Window*);
SDL_Window* SDL_GetWindowFromID(uint);
SDL_WindowFlags SDL_GetWindowFlags(SDL_Window*);
void SDL_SetWindowTitle(SDL_Window*,const(char)*);
const(char)* SDL_GetWindowTitle(SDL_Window*);
void SDL_SetWindowIcon(SDL_Window*,SDL_Surface*);
void* SDL_SetWindowData(SDL_Window*,const(char)*,void*);
void* SDL_GetWindowData(SDL_Window*,const(char)*);
void SDL_SetWindowPosition(SDL_Window*,int,int);
void SDL_GetWindowPosition(SDL_Window*,int*,int*);
void SDL_SetWindowSize(SDL_Window*,int,int);
void SDL_GetWindowSize(SDL_Window*,int*,int*);
void SDL_SetWindowMinimumSize(SDL_Window*,int,int);
void SDL_GetWindowMinimumSize(SDL_Window*,int*,int*);
void SDL_SetWindowMaximumSize(SDL_Window*,int,int);
void SDL_GetWindowMaximumSize(SDL_Window*,int*,int*);
void SDL_SetWindowBordered(SDL_Window*,SDL_bool);
void SDL_ShowWindow(SDL_Window*);
void SDL_HideWindow(SDL_Window*);
void SDL_RaiseWindow(SDL_Window*);
void SDL_MaximizeWindow(SDL_Window*);
void SDL_MinimizeWindow(SDL_Window*);
void SDL_RestoreWindow(SDL_Window*);
int SDL_SetWindowFullscreen(SDL_Window*,uint);
SDL_Surface* SDL_GetWindowSurface(SDL_Window*);
int SDL_UpdateWindowSurface(SDL_Window*);
int SDL_UpdateWindowSurfaceRects(SDL_Window*,SDL_Rect*,int);
void SDL_SetWindowGrab(SDL_Window*,SDL_bool);
SDL_bool SDL_GetWindowGrab(SDL_Window*);
int SDL_SetWindowBrightness(SDL_Window*,float);
float SDL_GetWindowBrightness(SDL_Window*);
int SDL_SetWindowGammaRamp(SDL_Window*,const(ushort)*,const(ushort)*,const(ushort)*);
int SDL_GetWindowGammaRamp(SDL_Window*,ushort*,ushort*,ushort*);
void SDL_DestroyWindow(SDL_Window*);
SDL_bool SDL_IsScreenSaverEnabled();
void SDL_EnableScreenSaver();
void SDL_DisableScreenSaver();
int SDL_GL_LoadLibrary(const(char)*);
void* SDL_GL_GetProcAddress(const(char)*);
void SDL_GL_UnloadLibrary();
SDL_bool SDL_GL_ExtensionSupported(const(char)*);
int SDL_GL_SetAttribute(SDL_GLattr,int);
int SDL_GL_GetAttribute(SDL_GLattr,int*);
SDL_GLContext SDL_GL_CreateContext(SDL_Window*);
int SDL_GL_MakeCurrent(SDL_Window*,SDL_GLContext);
SDL_Window* SDL_GL_GetCurrentWindow();
SDL_GLContext SDL_GL_GetCurrentContext();
int SDL_GL_SetSwapInterval(int);
int SDL_GL_GetSwapInterval();
void SDL_GL_SwapWindow(SDL_Window*);
void SDL_GL_DeleteContext(SDL_GLContext);
static if(sdlSupport >= SDLSupport.sdl201) {
void SDL_GL_GetDrawableSize(SDL_Window*,int*,int*);
}
static if(sdlSupport >= SDLSupport.sdl202) {
void SDL_GL_ResetAttributes();
}
static if(sdlSupport >= SDLSupport.sdl204) {
int SDL_GetDisplayDPI(int,float*,float*,float*);
SDL_Window* SDL_GetGrabbedWindow();
int SDL_SetWindowHitTest(SDL_Window*,SDL_HitTest,void*);
}
static if(sdlSupport >= SDLSupport.sdl205) {
int SDL_GetDisplayUsableBounds(int,SDL_Rect*);
int SDL_GetWindowBordersSize(SDL_Window*,int*,int*,int*,int*);
int SDL_GetWindowOpacity(SDL_Window*,float*);
int SDL_SetWindowInputFocus(SDL_Window*);
int SDL_SetWindowModalFor(SDL_Window*,SDL_Window*);
int SDL_SetWindowOpacity(SDL_Window*,float);
void SDL_SetWindowResizable(SDL_Window*,SDL_bool);
}
static if(sdlSupport >= SDLSupport.sdl209) {
SDL_DisplayOrientation SDL_GetDisplayOrientation(int);
}
}
}
else {
extern(C) @nogc nothrow {
alias pSDL_GetNumVideoDrivers = int function();
alias pSDL_GetVideoDriver = const(char)* function(int);
alias pSDL_VideoInit = int function(const(char)*);
alias pSDL_VideoQuit = void function();
alias pSDL_GetCurrentVideoDriver = const(char)* function();
alias pSDL_GetNumVideoDisplays = int function();
alias pSDL_GetDisplayName = const(char)* function(int);
alias pSDL_GetDisplayBounds = int function(int,SDL_Rect*);
alias pSDL_GetNumDisplayModes = int function(int);
alias pSDL_GetDisplayMode = int function(int,int,SDL_DisplayMode*);
alias pSDL_GetDesktopDisplayMode = int function(int,SDL_DisplayMode*);
alias pSDL_GetCurrentDisplayMode = int function(int,SDL_DisplayMode*);
alias pSDL_GetClosestDisplayMode = SDL_DisplayMode* function(int,const(SDL_DisplayMode)*,SDL_DisplayMode*);
alias pSDL_GetWindowDisplayIndex = int function(SDL_Window*);
alias pSDL_SetWindowDisplayMode = int function(SDL_Window*,const(SDL_DisplayMode)*);
alias pSDL_GetWindowDisplayMode = int function(SDL_Window*,SDL_DisplayMode*);
alias pSDL_GetWindowPixelFormat = uint function(SDL_Window*);
alias pSDL_CreateWindow = SDL_Window* function(const(char)*,int,int,int,int,SDL_WindowFlags);
alias pSDL_CreateWindowFrom = SDL_Window* function(const(void)*);
alias pSDL_GetWindowID = uint function(SDL_Window*);
alias pSDL_GetWindowFromID = SDL_Window* function(uint);
alias pSDL_GetWindowFlags = SDL_WindowFlags function(SDL_Window*);
alias pSDL_SetWindowTitle = void function(SDL_Window*,const(char)*);
alias pSDL_GetWindowTitle = const(char)* function(SDL_Window*);
alias pSDL_SetWindowIcon = void function(SDL_Window*,SDL_Surface*);
alias pSDL_SetWindowData = void* function(SDL_Window*,const(char)*,void*);
alias pSDL_GetWindowData = void* function(SDL_Window*,const(char)*);
alias pSDL_SetWindowPosition = void function(SDL_Window*,int,int);
alias pSDL_GetWindowPosition = void function(SDL_Window*,int*,int*);
alias pSDL_SetWindowSize = void function(SDL_Window*,int,int);
alias pSDL_GetWindowSize = void function(SDL_Window*,int*,int*);
alias pSDL_SetWindowMinimumSize = void function(SDL_Window*,int,int);
alias pSDL_GetWindowMinimumSize = void function(SDL_Window*,int*,int*);
alias pSDL_SetWindowMaximumSize = void function(SDL_Window*,int,int);
alias pSDL_GetWindowMaximumSize = void function(SDL_Window*,int*,int*);
alias pSDL_SetWindowBordered = void function(SDL_Window*,SDL_bool);
alias pSDL_ShowWindow = void function(SDL_Window*);
alias pSDL_HideWindow = void function(SDL_Window*);
alias pSDL_RaiseWindow = void function(SDL_Window*);
alias pSDL_MaximizeWindow = void function(SDL_Window*);
alias pSDL_MinimizeWindow = void function(SDL_Window*);
alias pSDL_RestoreWindow = void function(SDL_Window*);
alias pSDL_SetWindowFullscreen = int function(SDL_Window*,uint);
alias pSDL_GetWindowSurface = SDL_Surface* function(SDL_Window*);
alias pSDL_UpdateWindowSurface = int function(SDL_Window*);
alias pSDL_UpdateWindowSurfaceRects = int function(SDL_Window*,SDL_Rect*,int);
alias pSDL_SetWindowGrab = void function(SDL_Window*,SDL_bool);
alias pSDL_GetWindowGrab = SDL_bool function(SDL_Window*);
alias pSDL_SetWindowBrightness = int function(SDL_Window*,float);
alias pSDL_GetWindowBrightness = float function(SDL_Window*);
alias pSDL_SetWindowGammaRamp = int function(SDL_Window*,const(ushort)*,const(ushort)*,const(ushort)*);
alias pSDL_GetWindowGammaRamp = int function(SDL_Window*,ushort*,ushort*,ushort*);
alias pSDL_DestroyWindow = void function(SDL_Window*);
alias pSDL_IsScreenSaverEnabled = SDL_bool function();
alias pSDL_EnableScreenSaver = void function();
alias pSDL_DisableScreenSaver = void function();
alias pSDL_GL_LoadLibrary = int function(const(char)*);
alias pSDL_GL_GetProcAddress = void* function(const(char)*);
alias pSDL_GL_UnloadLibrary = void function();
alias pSDL_GL_ExtensionSupported = SDL_bool function(const(char)*);
alias pSDL_GL_SetAttribute = int function(SDL_GLattr,int);
alias pSDL_GL_GetAttribute = int function(SDL_GLattr,int*);
alias pSDL_GL_CreateContext = SDL_GLContext function(SDL_Window*);
alias pSDL_GL_MakeCurrent = int function(SDL_Window*,SDL_GLContext);
alias pSDL_GL_GetCurrentWindow = SDL_Window* function();
alias pSDL_GL_GetCurrentContext = SDL_GLContext function();
alias pSDL_GL_SetSwapInterval = int function(int);
alias pSDL_GL_GetSwapInterval = int function();
alias pSDL_GL_SwapWindow = void function(SDL_Window*);
alias pSDL_GL_DeleteContext = void function(SDL_GLContext);
}
__gshared {
pSDL_GetNumVideoDrivers SDL_GetNumVideoDrivers;
pSDL_GetVideoDriver SDL_GetVideoDriver;
pSDL_VideoInit SDL_VideoInit;
pSDL_VideoQuit SDL_VideoQuit;
pSDL_GetCurrentVideoDriver SDL_GetCurrentVideoDriver;
pSDL_GetNumVideoDisplays SDL_GetNumVideoDisplays;
pSDL_GetDisplayName SDL_GetDisplayName;
pSDL_GetDisplayBounds SDL_GetDisplayBounds;
pSDL_GetNumDisplayModes SDL_GetNumDisplayModes;
pSDL_GetDisplayMode SDL_GetDisplayMode;
pSDL_GetDesktopDisplayMode SDL_GetDesktopDisplayMode;
pSDL_GetCurrentDisplayMode SDL_GetCurrentDisplayMode;
pSDL_GetClosestDisplayMode SDL_GetClosestDisplayMode;
pSDL_GetWindowDisplayIndex SDL_GetWindowDisplayIndex;
pSDL_SetWindowDisplayMode SDL_SetWindowDisplayMode;
pSDL_GetWindowDisplayMode SDL_GetWindowDisplayMode;
pSDL_GetWindowPixelFormat SDL_GetWindowPixelFormat;
pSDL_CreateWindow SDL_CreateWindow;
pSDL_CreateWindowFrom SDL_CreateWindowFrom;
pSDL_GetWindowID SDL_GetWindowID;
pSDL_GetWindowFromID SDL_GetWindowFromID;
pSDL_GetWindowFlags SDL_GetWindowFlags;
pSDL_SetWindowTitle SDL_SetWindowTitle;
pSDL_GetWindowTitle SDL_GetWindowTitle;
pSDL_SetWindowIcon SDL_SetWindowIcon;
pSDL_SetWindowData SDL_SetWindowData;
pSDL_GetWindowData SDL_GetWindowData;
pSDL_SetWindowPosition SDL_SetWindowPosition;
pSDL_GetWindowPosition SDL_GetWindowPosition;
pSDL_SetWindowSize SDL_SetWindowSize;
pSDL_GetWindowSize SDL_GetWindowSize;
pSDL_SetWindowMinimumSize SDL_SetWindowMinimumSize;
pSDL_GetWindowMinimumSize SDL_GetWindowMinimumSize;
pSDL_SetWindowMaximumSize SDL_SetWindowMaximumSize;
pSDL_GetWindowMaximumSize SDL_GetWindowMaximumSize;
pSDL_SetWindowBordered SDL_SetWindowBordered;
pSDL_ShowWindow SDL_ShowWindow;
pSDL_HideWindow SDL_HideWindow;
pSDL_RaiseWindow SDL_RaiseWindow;
pSDL_MaximizeWindow SDL_MaximizeWindow;
pSDL_MinimizeWindow SDL_MinimizeWindow;
pSDL_RestoreWindow SDL_RestoreWindow;
pSDL_SetWindowFullscreen SDL_SetWindowFullscreen;
pSDL_GetWindowSurface SDL_GetWindowSurface;
pSDL_UpdateWindowSurface SDL_UpdateWindowSurface;
pSDL_UpdateWindowSurfaceRects SDL_UpdateWindowSurfaceRects;
pSDL_SetWindowGrab SDL_SetWindowGrab;
pSDL_GetWindowGrab SDL_GetWindowGrab;
pSDL_SetWindowBrightness SDL_SetWindowBrightness;
pSDL_GetWindowBrightness SDL_GetWindowBrightness;
pSDL_SetWindowGammaRamp SDL_SetWindowGammaRamp;
pSDL_GetWindowGammaRamp SDL_GetWindowGammaRamp;
pSDL_DestroyWindow SDL_DestroyWindow;
pSDL_IsScreenSaverEnabled SDL_IsScreenSaverEnabled;
pSDL_EnableScreenSaver SDL_EnableScreenSaver;
pSDL_DisableScreenSaver SDL_DisableScreenSaver;
pSDL_GL_LoadLibrary SDL_GL_LoadLibrary;
pSDL_GL_GetProcAddress SDL_GL_GetProcAddress;
pSDL_GL_UnloadLibrary SDL_GL_UnloadLibrary;
pSDL_GL_ExtensionSupported SDL_GL_ExtensionSupported;
pSDL_GL_SetAttribute SDL_GL_SetAttribute;
pSDL_GL_GetAttribute SDL_GL_GetAttribute;
pSDL_GL_CreateContext SDL_GL_CreateContext;
pSDL_GL_MakeCurrent SDL_GL_MakeCurrent;
pSDL_GL_GetCurrentWindow SDL_GL_GetCurrentWindow;
pSDL_GL_GetCurrentContext SDL_GL_GetCurrentContext;
pSDL_GL_SetSwapInterval SDL_GL_SetSwapInterval;
pSDL_GL_GetSwapInterval SDL_GL_GetSwapInterval;
pSDL_GL_SwapWindow SDL_GL_SwapWindow;
pSDL_GL_DeleteContext SDL_GL_DeleteContext;
}
static if(sdlSupport >= SDLSupport.sdl201) {
extern(C) @nogc nothrow {
alias pSDL_GL_GetDrawableSize = void function(SDL_Window*,int*,int*);
}
__gshared {
pSDL_GL_GetDrawableSize SDL_GL_GetDrawableSize;
}
}
static if(sdlSupport >= SDLSupport.sdl202) {
extern(C) @nogc nothrow {
alias pSDL_GL_ResetAttributes = void function();
}
__gshared {
pSDL_GL_ResetAttributes SDL_GL_ResetAttributes;
}
}
static if(sdlSupport >= SDLSupport.sdl204) {
extern(C) @nogc nothrow {
alias pSDL_GetDisplayDPI = int function(int,float*,float*,float*);
alias pSDL_GetGrabbedWindow = SDL_Window* function();
alias pSDL_SetWindowHitTest = int function(SDL_Window*,SDL_HitTest,void*);
}
__gshared {
pSDL_GetDisplayDPI SDL_GetDisplayDPI;
pSDL_GetGrabbedWindow SDL_GetGrabbedWindow;
pSDL_SetWindowHitTest SDL_SetWindowHitTest;
}
}
static if(sdlSupport >= SDLSupport.sdl205) {
extern(C) @nogc nothrow {
alias pSDL_GetDisplayUsableBounds = int function(int,SDL_Rect*);
alias pSDL_GetWindowBordersSize = int function(SDL_Window*,int*,int*,int*,int*);
alias pSDL_GetWindowOpacity = int function(SDL_Window*,float*);
alias pSDL_SetWindowInputFocus = int function(SDL_Window*);
alias pSDL_SetWindowModalFor = int function(SDL_Window*,SDL_Window*);
alias pSDL_SetWindowOpacity = int function(SDL_Window*,float);
alias pSDL_SetWindowResizable = void function(SDL_Window*,SDL_bool);
}
__gshared {
pSDL_GetDisplayUsableBounds SDL_GetDisplayUsableBounds;
pSDL_GetWindowBordersSize SDL_GetWindowBordersSize;
pSDL_GetWindowOpacity SDL_GetWindowOpacity;
pSDL_SetWindowInputFocus SDL_SetWindowInputFocus;
pSDL_SetWindowModalFor SDL_SetWindowModalFor;
pSDL_SetWindowOpacity SDL_SetWindowOpacity;
pSDL_SetWindowResizable SDL_SetWindowResizable;
}
}
static if(sdlSupport >= SDLSupport.sdl209) {
extern(C) @nogc nothrow {
alias pSDL_GetDisplayOrientation = SDL_DisplayOrientation function(int);
}
__gshared {
pSDL_GetDisplayOrientation SDL_GetDisplayOrientation;
}
}
}

45
demos/external/imports/bindbc/sdl/bind/sdlvulkan.d vendored Normal file
View file

@ -0,0 +1,45 @@
// 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.bind.sdlvulkan;
import bindbc.sdl.config;
import bindbc.sdl.bind.sdlstdinc : SDL_bool;
import bindbc.sdl.bind.sdlvideo : SDL_Window;
version(BindSDL_Static) {
extern(C) @nogc nothrow {
static if(sdlSupport >= SDLSupport.sdl206) {
SDL_bool SDL_Vulkan_CreateSurface(SDL_Window*,void*,void*);
void SDL_Vulkan_GetDrawableSize(SDL_Window*,int*,int*);
SDL_bool SDL_Vulkan_GetInstanceExtensions(SDL_Window*,uint*,const(char)**);
void* SDL_Vulkan_GetVkGetInstanceProcAddr();
int SDL_Vulkan_LoadLibrary(const(char)*);
void SDL_Vulkan_UnloadLibrary();
}
}
}
else {
static if(sdlSupport >= SDLSupport.sdl206) {
extern(C) @nogc nothrow {
alias pSDL_Vulkan_CreateSurface = SDL_bool function(SDL_Window*,void*,void*);
alias pSDL_Vulkan_GetDrawableSize = void function(SDL_Window*,int*,int*);
alias pSDL_Vulkan_GetInstanceExtensions = SDL_bool function(SDL_Window*,uint*,const(char)**);
alias pSDL_Vulkan_GetVkGetInstanceProcAddr = void* function();
alias pSDL_Vulkan_LoadLibrary = int function(const(char)*);
alias pSDL_Vulkan_UnloadLibrary = void function();
}
__gshared {
pSDL_Vulkan_CreateSurface SDL_Vulkan_CreateSurface;
pSDL_Vulkan_GetDrawableSize SDL_Vulkan_GetDrawableSize;
pSDL_Vulkan_GetInstanceExtensions SDL_Vulkan_GetInstanceExtensions;
pSDL_Vulkan_GetVkGetInstanceProcAddr SDL_Vulkan_GetVkGetInstanceProcAddr;
pSDL_Vulkan_LoadLibrary SDL_Vulkan_LoadLibrary;
pSDL_Vulkan_UnloadLibrary SDL_Vulkan_UnloadLibrary;
}
}
}