From 4a313c1a4c1783ccb43b4fa57bf1e35ee58f6661 Mon Sep 17 00:00:00 2001 From: Peter Li Date: Fri, 23 Jan 2026 18:17:36 -0800 Subject: [PATCH] pushing outputs as well --- json/audio.json | 892 ++++++++++ json/blendmode.json | 131 ++ json/camera.json | 232 +++ json/clipboard.json | 146 ++ json/dialog.json | 172 ++ json/endian.json | 11 + json/error.json | 55 + json/filesystem.json | 298 ++++ json/gamepad.json | 1148 +++++++++++++ json/gpu.json | 3881 ++++++++++++++++++++++++++++++++++++++++++ json/haptic.json | 785 +++++++++ json/hints.json | 157 ++ json/init.json | 252 +++ json/joystick.json | 960 +++++++++++ json/keycode.json | 20 + json/loadso.json | 50 + json/messagebox.json | 204 +++ json/misc.json | 22 + json/mouse.json | 391 +++++ json/pixels.json | 920 ++++++++++ json/properties.json | 394 +++++ json/rect.json | 277 +++ json/render.json | 1668 ++++++++++++++++++ json/sensor.json | 203 +++ json/storage.json | 348 ++++ json/surface.json | 1218 +++++++++++++ json/system.json | 398 +++++ json/time.json | 237 +++ json/timer.json | 150 ++ json/touch.json | 109 ++ json/version.json | 22 + json/video.json | 1814 ++++++++++++++++++++ v2/audio.zig | 256 +++ v2/blendmode.zig | 29 + v2/camera.zig | 127 ++ v2/clipboard.zig | 50 + v2/dialog.zig | 35 + v2/endian.zig | 2 + v2/error.zig | 24 + v2/filesystem.zig | 92 + v2/gamepad.zig | 421 +++++ v2/gpu.zig | 1096 ++++++++++++ v2/haptic.zig | 230 +++ v2/hints.zig | 42 + v2/init.zig | 113 ++ v2/joystick.zig | 321 ++++ v2/keycode.zig | 6 + v2/loadso.zig | 18 + v2/messagebox.zig | 64 + v2/misc.zig | 6 + v2/mouse.zig | 135 ++ v2/pixels.zig | 238 +++ v2/properties.zig | 101 ++ v2/rect.zig | 66 + v2/render.zig | 517 ++++++ v2/sensor.zig | 75 + v2/storage.zig | 103 ++ v2/surface.zig | 318 ++++ v2/system.zig | 159 ++ v2/time.zig | 63 + v2/timer.zig | 48 + v2/touch.zig | 35 + v2/version.zig | 10 + v2/video.zig | 607 +++++++ 64 files changed, 22972 insertions(+) create mode 100644 json/audio.json create mode 100644 json/blendmode.json create mode 100644 json/camera.json create mode 100644 json/clipboard.json create mode 100644 json/dialog.json create mode 100644 json/endian.json create mode 100644 json/error.json create mode 100644 json/filesystem.json create mode 100644 json/gamepad.json create mode 100644 json/gpu.json create mode 100644 json/haptic.json create mode 100644 json/hints.json create mode 100644 json/init.json create mode 100644 json/joystick.json create mode 100644 json/keycode.json create mode 100644 json/loadso.json create mode 100644 json/messagebox.json create mode 100644 json/misc.json create mode 100644 json/mouse.json create mode 100644 json/pixels.json create mode 100644 json/properties.json create mode 100644 json/rect.json create mode 100644 json/render.json create mode 100644 json/sensor.json create mode 100644 json/storage.json create mode 100644 json/surface.json create mode 100644 json/system.json create mode 100644 json/time.json create mode 100644 json/timer.json create mode 100644 json/touch.json create mode 100644 json/version.json create mode 100644 json/video.json create mode 100644 v2/audio.zig create mode 100644 v2/blendmode.zig create mode 100644 v2/camera.zig create mode 100644 v2/clipboard.zig create mode 100644 v2/dialog.zig create mode 100644 v2/endian.zig create mode 100644 v2/error.zig create mode 100644 v2/filesystem.zig create mode 100644 v2/gamepad.zig create mode 100644 v2/gpu.zig create mode 100644 v2/haptic.zig create mode 100644 v2/hints.zig create mode 100644 v2/init.zig create mode 100644 v2/joystick.zig create mode 100644 v2/keycode.zig create mode 100644 v2/loadso.zig create mode 100644 v2/messagebox.zig create mode 100644 v2/misc.zig create mode 100644 v2/mouse.zig create mode 100644 v2/pixels.zig create mode 100644 v2/properties.zig create mode 100644 v2/rect.zig create mode 100644 v2/render.zig create mode 100644 v2/sensor.zig create mode 100644 v2/storage.zig create mode 100644 v2/surface.zig create mode 100644 v2/system.zig create mode 100644 v2/time.zig create mode 100644 v2/timer.zig create mode 100644 v2/touch.zig create mode 100644 v2/version.zig create mode 100644 v2/video.zig diff --git a/json/audio.json b/json/audio.json new file mode 100644 index 0000000..69dbecd --- /dev/null +++ b/json/audio.json @@ -0,0 +1,892 @@ +{ + "header": "SDL_audio.h", + "opaque_types": [ + { + "name": "SDL_AudioStream" + } + ], + "typedefs": [ + { + "name": "SDL_AudioDeviceID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [ + { + "name": "SDL_AudioStreamCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "additional_amount", + "type": "int" + }, + { + "name": "total_amount", + "type": "int" + } + ] + }, + { + "name": "SDL_AudioPostmixCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "spec", + "type": "const SDL_AudioSpec *" + }, + { + "name": "buffer", + "type": "float *" + }, + { + "name": "buflen", + "type": "int" + } + ] + } + ], + "enums": [ + { + "name": "SDL_AudioFormat", + "values": [ + { + "name": "SDL_AUDIO_UNKNOWN", + "value": "0x0000u", + "comment": "Unspecified audio format" + }, + { + "name": "SDL_AUDIO_U8", + "value": "0x0008u", + "comment": "Unsigned 8-bit samples" + }, + { + "name": "SDL_AUDIO_S8", + "value": "0x8008u", + "comment": "Signed 8-bit samples" + }, + { + "name": "SDL_AUDIO_S16LE", + "value": "0x8010u", + "comment": "Signed 16-bit samples" + }, + { + "name": "SDL_AUDIO_S16BE", + "value": "0x9010u", + "comment": "As above, but big-endian byte order" + }, + { + "name": "SDL_AUDIO_S32LE", + "value": "0x8020u", + "comment": "32-bit integer samples" + }, + { + "name": "SDL_AUDIO_S32BE", + "value": "0x9020u", + "comment": "As above, but big-endian byte order" + }, + { + "name": "SDL_AUDIO_F32LE", + "value": "0x8120u", + "comment": "32-bit floating point samples" + }, + { + "name": "SDL_AUDIO_F32BE", + "value": "0x9120u", + "comment": "As above, but big-endian byte order" + } + ] + } + ], + "structs": [ + { + "name": "SDL_AudioSpec", + "fields": [ + { + "name": "format", + "type": "SDL_AudioFormat", + "comment": "Audio data format" + }, + { + "name": "channels", + "type": "int", + "comment": "Number of channels: 1 mono, 2 stereo, etc" + }, + { + "name": "freq", + "type": "int", + "comment": "sample rate: sample frames per second" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetNumAudioDrivers", + "return_type": "int", + "parameters": [] + }, + { + "name": "SDL_GetAudioDriver", + "return_type": "const char *", + "parameters": [ + { + "name": "index", + "type": "int" + } + ] + }, + { + "name": "SDL_GetCurrentAudioDriver", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_GetAudioPlaybackDevices", + "return_type": "SDL_AudioDeviceID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetAudioRecordingDevices", + "return_type": "SDL_AudioDeviceID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetAudioDeviceName", + "return_type": "const char *", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_GetAudioDeviceFormat", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "spec", + "type": "SDL_AudioSpec *" + }, + { + "name": "sample_frames", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetAudioDeviceChannelMap", + "return_type": "int *", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_OpenAudioDevice", + "return_type": "SDL_AudioDeviceID", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "spec", + "type": "const SDL_AudioSpec *" + } + ] + }, + { + "name": "SDL_IsAudioDevicePhysical", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_IsAudioDevicePlayback", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_PauseAudioDevice", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_ResumeAudioDevice", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_AudioDevicePaused", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_GetAudioDeviceGain", + "return_type": "float", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_SetAudioDeviceGain", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "gain", + "type": "float" + } + ] + }, + { + "name": "SDL_CloseAudioDevice", + "return_type": "void", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + } + ] + }, + { + "name": "SDL_BindAudioStreams", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "streams", + "type": "SDL_AudioStream * const *" + }, + { + "name": "num_streams", + "type": "int" + } + ] + }, + { + "name": "SDL_BindAudioStream", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_UnbindAudioStreams", + "return_type": "void", + "parameters": [ + { + "name": "streams", + "type": "SDL_AudioStream * const *" + }, + { + "name": "num_streams", + "type": "int" + } + ] + }, + { + "name": "SDL_UnbindAudioStream", + "return_type": "void", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_GetAudioStreamDevice", + "return_type": "SDL_AudioDeviceID", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_CreateAudioStream", + "return_type": "SDL_AudioStream *", + "parameters": [ + { + "name": "src_spec", + "type": "const SDL_AudioSpec *" + }, + { + "name": "dst_spec", + "type": "const SDL_AudioSpec *" + } + ] + }, + { + "name": "SDL_GetAudioStreamProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_GetAudioStreamFormat", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "src_spec", + "type": "SDL_AudioSpec *" + }, + { + "name": "dst_spec", + "type": "SDL_AudioSpec *" + } + ] + }, + { + "name": "SDL_SetAudioStreamFormat", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "src_spec", + "type": "const SDL_AudioSpec *" + }, + { + "name": "dst_spec", + "type": "const SDL_AudioSpec *" + } + ] + }, + { + "name": "SDL_GetAudioStreamFrequencyRatio", + "return_type": "float", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_SetAudioStreamFrequencyRatio", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "ratio", + "type": "float" + } + ] + }, + { + "name": "SDL_GetAudioStreamGain", + "return_type": "float", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_SetAudioStreamGain", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "gain", + "type": "float" + } + ] + }, + { + "name": "SDL_GetAudioStreamInputChannelMap", + "return_type": "int *", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetAudioStreamOutputChannelMap", + "return_type": "int *", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_SetAudioStreamInputChannelMap", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "chmap", + "type": "const int *" + }, + { + "name": "count", + "type": "int" + } + ] + }, + { + "name": "SDL_SetAudioStreamOutputChannelMap", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "chmap", + "type": "const int *" + }, + { + "name": "count", + "type": "int" + } + ] + }, + { + "name": "SDL_PutAudioStreamData", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "buf", + "type": "const void *" + }, + { + "name": "len", + "type": "int" + } + ] + }, + { + "name": "SDL_GetAudioStreamData", + "return_type": "int", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "buf", + "type": "void *" + }, + { + "name": "len", + "type": "int" + } + ] + }, + { + "name": "SDL_GetAudioStreamAvailable", + "return_type": "int", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_GetAudioStreamQueued", + "return_type": "int", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_FlushAudioStream", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_ClearAudioStream", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_PauseAudioStreamDevice", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_ResumeAudioStreamDevice", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_AudioStreamDevicePaused", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_LockAudioStream", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_UnlockAudioStream", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_SetAudioStreamGetCallback", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "callback", + "type": "SDL_AudioStreamCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_SetAudioStreamPutCallback", + "return_type": "bool", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + }, + { + "name": "callback", + "type": "SDL_AudioStreamCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_DestroyAudioStream", + "return_type": "void", + "parameters": [ + { + "name": "stream", + "type": "SDL_AudioStream *" + } + ] + }, + { + "name": "SDL_OpenAudioDeviceStream", + "return_type": "SDL_AudioStream *", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "spec", + "type": "const SDL_AudioSpec *" + }, + { + "name": "callback", + "type": "SDL_AudioStreamCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_SetAudioPostmixCallback", + "return_type": "bool", + "parameters": [ + { + "name": "devid", + "type": "SDL_AudioDeviceID" + }, + { + "name": "callback", + "type": "SDL_AudioPostmixCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_LoadWAV_IO", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_IOStream *" + }, + { + "name": "closeio", + "type": "bool" + }, + { + "name": "spec", + "type": "SDL_AudioSpec *" + }, + { + "name": "audio_buf", + "type": "Uint8 **" + }, + { + "name": "audio_len", + "type": "Uint32 *" + } + ] + }, + { + "name": "SDL_LoadWAV", + "return_type": "bool", + "parameters": [ + { + "name": "path", + "type": "const char *" + }, + { + "name": "spec", + "type": "SDL_AudioSpec *" + }, + { + "name": "audio_buf", + "type": "Uint8 **" + }, + { + "name": "audio_len", + "type": "Uint32 *" + } + ] + }, + { + "name": "SDL_MixAudio", + "return_type": "bool", + "parameters": [ + { + "name": "dst", + "type": "Uint8 *" + }, + { + "name": "src", + "type": "const Uint8 *" + }, + { + "name": "format", + "type": "SDL_AudioFormat" + }, + { + "name": "len", + "type": "Uint32" + }, + { + "name": "volume", + "type": "float" + } + ] + }, + { + "name": "SDL_ConvertAudioSamples", + "return_type": "bool", + "parameters": [ + { + "name": "src_spec", + "type": "const SDL_AudioSpec *" + }, + { + "name": "src_data", + "type": "const Uint8 *" + }, + { + "name": "src_len", + "type": "int" + }, + { + "name": "dst_spec", + "type": "const SDL_AudioSpec *" + }, + { + "name": "dst_data", + "type": "Uint8 **" + }, + { + "name": "dst_len", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetAudioFormatName", + "return_type": "const char *", + "parameters": [ + { + "name": "format", + "type": "SDL_AudioFormat" + } + ] + }, + { + "name": "SDL_GetSilenceValueForFormat", + "return_type": "int", + "parameters": [ + { + "name": "format", + "type": "SDL_AudioFormat" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/blendmode.json b/json/blendmode.json new file mode 100644 index 0000000..61109ed --- /dev/null +++ b/json/blendmode.json @@ -0,0 +1,131 @@ +{ + "header": "SDL_blendmode.h", + "opaque_types": [], + "typedefs": [ + { + "name": "SDL_BlendMode", + "underlying_type": "Uint32" + } + ], + "function_pointers": [], + "enums": [ + { + "name": "SDL_BlendOperation", + "values": [ + { + "name": "SDL_BLENDOPERATION_ADD", + "value": "0x1", + "comment": "dst + src: supported by all renderers" + }, + { + "name": "SDL_BLENDOPERATION_SUBTRACT", + "value": "0x2", + "comment": "src - dst : supported by D3D, OpenGL, OpenGLES, and Vulkan" + }, + { + "name": "SDL_BLENDOPERATION_REV_SUBTRACT", + "value": "0x3", + "comment": "dst - src : supported by D3D, OpenGL, OpenGLES, and Vulkan" + }, + { + "name": "SDL_BLENDOPERATION_MINIMUM", + "value": "0x4", + "comment": "min(dst, src) : supported by D3D, OpenGL, OpenGLES, and Vulkan" + }, + { + "name": "SDL_BLENDOPERATION_MAXIMUM", + "value": "0x5" + } + ] + }, + { + "name": "SDL_BlendFactor", + "values": [ + { + "name": "SDL_BLENDFACTOR_ZERO", + "value": "0x1", + "comment": "0, 0, 0, 0" + }, + { + "name": "SDL_BLENDFACTOR_ONE", + "value": "0x2", + "comment": "1, 1, 1, 1" + }, + { + "name": "SDL_BLENDFACTOR_SRC_COLOR", + "value": "0x3", + "comment": "srcR, srcG, srcB, srcA" + }, + { + "name": "SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR", + "value": "0x4", + "comment": "1-srcR, 1-srcG, 1-srcB, 1-srcA" + }, + { + "name": "SDL_BLENDFACTOR_SRC_ALPHA", + "value": "0x5", + "comment": "srcA, srcA, srcA, srcA" + }, + { + "name": "SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA", + "value": "0x6", + "comment": "1-srcA, 1-srcA, 1-srcA, 1-srcA" + }, + { + "name": "SDL_BLENDFACTOR_DST_COLOR", + "value": "0x7", + "comment": "dstR, dstG, dstB, dstA" + }, + { + "name": "SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR", + "value": "0x8", + "comment": "1-dstR, 1-dstG, 1-dstB, 1-dstA" + }, + { + "name": "SDL_BLENDFACTOR_DST_ALPHA", + "value": "0x9", + "comment": "dstA, dstA, dstA, dstA" + }, + { + "name": "SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA", + "value": "0xA" + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_ComposeCustomBlendMode", + "return_type": "SDL_BlendMode", + "parameters": [ + { + "name": "srcColorFactor", + "type": "SDL_BlendFactor" + }, + { + "name": "dstColorFactor", + "type": "SDL_BlendFactor" + }, + { + "name": "colorOperation", + "type": "SDL_BlendOperation" + }, + { + "name": "srcAlphaFactor", + "type": "SDL_BlendFactor" + }, + { + "name": "dstAlphaFactor", + "type": "SDL_BlendFactor" + }, + { + "name": "alphaOperation", + "type": "SDL_BlendOperation" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/camera.json b/json/camera.json new file mode 100644 index 0000000..c225cca --- /dev/null +++ b/json/camera.json @@ -0,0 +1,232 @@ +{ + "header": "SDL_camera.h", + "opaque_types": [ + { + "name": "SDL_Camera" + } + ], + "typedefs": [ + { + "name": "SDL_CameraID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [], + "enums": [ + { + "name": "SDL_CameraPosition", + "values": [ + { + "name": "SDL_CAMERA_POSITION_UNKNOWN" + }, + { + "name": "SDL_CAMERA_POSITION_FRONT_FACING" + }, + { + "name": "SDL_CAMERA_POSITION_BACK_FACING" + } + ] + } + ], + "structs": [ + { + "name": "SDL_CameraSpec", + "fields": [ + { + "name": "format", + "type": "SDL_PixelFormat", + "comment": "Frame format" + }, + { + "name": "colorspace", + "type": "SDL_Colorspace", + "comment": "Frame colorspace" + }, + { + "name": "width", + "type": "int", + "comment": "Frame width" + }, + { + "name": "height", + "type": "int", + "comment": "Frame height" + }, + { + "name": "framerate_numerator", + "type": "int", + "comment": "Frame rate numerator ((num / denom) == FPS, (denom / num) == duration in seconds)" + }, + { + "name": "framerate_denominator", + "type": "int", + "comment": "Frame rate demoninator ((num / denom) == FPS, (denom / num) == duration in seconds)" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetNumCameraDrivers", + "return_type": "int", + "parameters": [] + }, + { + "name": "SDL_GetCameraDriver", + "return_type": "const char *", + "parameters": [ + { + "name": "index", + "type": "int" + } + ] + }, + { + "name": "SDL_GetCurrentCameraDriver", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_GetCameras", + "return_type": "SDL_CameraID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetCameraSupportedFormats", + "return_type": "SDL_CameraSpec **", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_CameraID" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetCameraName", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_CameraID" + } + ] + }, + { + "name": "SDL_GetCameraPosition", + "return_type": "SDL_CameraPosition", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_CameraID" + } + ] + }, + { + "name": "SDL_OpenCamera", + "return_type": "SDL_Camera *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_CameraID" + }, + { + "name": "spec", + "type": "const SDL_CameraSpec *" + } + ] + }, + { + "name": "SDL_GetCameraPermissionState", + "return_type": "int", + "parameters": [ + { + "name": "camera", + "type": "SDL_Camera *" + } + ] + }, + { + "name": "SDL_GetCameraID", + "return_type": "SDL_CameraID", + "parameters": [ + { + "name": "camera", + "type": "SDL_Camera *" + } + ] + }, + { + "name": "SDL_GetCameraProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "camera", + "type": "SDL_Camera *" + } + ] + }, + { + "name": "SDL_GetCameraFormat", + "return_type": "bool", + "parameters": [ + { + "name": "camera", + "type": "SDL_Camera *" + }, + { + "name": "spec", + "type": "SDL_CameraSpec *" + } + ] + }, + { + "name": "SDL_AcquireCameraFrame", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "camera", + "type": "SDL_Camera *" + }, + { + "name": "timestampNS", + "type": "Uint64 *" + } + ] + }, + { + "name": "SDL_ReleaseCameraFrame", + "return_type": "void", + "parameters": [ + { + "name": "camera", + "type": "SDL_Camera *" + }, + { + "name": "frame", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_CloseCamera", + "return_type": "void", + "parameters": [ + { + "name": "camera", + "type": "SDL_Camera *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/clipboard.json b/json/clipboard.json new file mode 100644 index 0000000..8bb4c54 --- /dev/null +++ b/json/clipboard.json @@ -0,0 +1,146 @@ +{ + "header": "SDL_clipboard.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [ + { + "name": "SDL_ClipboardDataCallback", + "return_type": "const void *", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "mime_type", + "type": "const char *" + }, + { + "name": "size", + "type": "size_t *" + } + ] + }, + { + "name": "SDL_ClipboardCleanupCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + } + ] + } + ], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_SetClipboardText", + "return_type": "bool", + "parameters": [ + { + "name": "text", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetClipboardText", + "return_type": "char *", + "parameters": [] + }, + { + "name": "SDL_HasClipboardText", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_SetPrimarySelectionText", + "return_type": "bool", + "parameters": [ + { + "name": "text", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetPrimarySelectionText", + "return_type": "char *", + "parameters": [] + }, + { + "name": "SDL_HasPrimarySelectionText", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_SetClipboardData", + "return_type": "bool", + "parameters": [ + { + "name": "callback", + "type": "SDL_ClipboardDataCallback" + }, + { + "name": "cleanup", + "type": "SDL_ClipboardCleanupCallback" + }, + { + "name": "userdata", + "type": "void *" + }, + { + "name": "mime_types", + "type": "const char **" + }, + { + "name": "num_mime_types", + "type": "size_t" + } + ] + }, + { + "name": "SDL_ClearClipboardData", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetClipboardData", + "return_type": "void *", + "parameters": [ + { + "name": "mime_type", + "type": "const char *" + }, + { + "name": "size", + "type": "size_t *" + } + ] + }, + { + "name": "SDL_HasClipboardData", + "return_type": "bool", + "parameters": [ + { + "name": "mime_type", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetClipboardMimeTypes", + "return_type": "char **", + "parameters": [ + { + "name": "num_mime_types", + "type": "size_t *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/dialog.json b/json/dialog.json new file mode 100644 index 0000000..19d1205 --- /dev/null +++ b/json/dialog.json @@ -0,0 +1,172 @@ +{ + "header": "SDL_dialog.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [ + { + "name": "SDL_DialogFileCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "filelist", + "type": "const char * const *" + }, + { + "name": "filter", + "type": "int" + } + ] + } + ], + "enums": [ + { + "name": "SDL_FileDialogType", + "values": [ + { + "name": "SDL_FILEDIALOG_OPENFILE" + }, + { + "name": "SDL_FILEDIALOG_SAVEFILE" + }, + { + "name": "SDL_FILEDIALOG_OPENFOLDER" + } + ] + } + ], + "structs": [ + { + "name": "SDL_DialogFileFilter", + "fields": [ + { + "name": "name", + "type": "const char *" + }, + { + "name": "pattern", + "type": "const char *" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_ShowOpenFileDialog", + "return_type": "void", + "parameters": [ + { + "name": "callback", + "type": "SDL_DialogFileCallback" + }, + { + "name": "userdata", + "type": "void *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "filters", + "type": "const SDL_DialogFileFilter *" + }, + { + "name": "nfilters", + "type": "int" + }, + { + "name": "default_location", + "type": "const char *" + }, + { + "name": "allow_many", + "type": "bool" + } + ] + }, + { + "name": "SDL_ShowSaveFileDialog", + "return_type": "void", + "parameters": [ + { + "name": "callback", + "type": "SDL_DialogFileCallback" + }, + { + "name": "userdata", + "type": "void *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "filters", + "type": "const SDL_DialogFileFilter *" + }, + { + "name": "nfilters", + "type": "int" + }, + { + "name": "default_location", + "type": "const char *" + } + ] + }, + { + "name": "SDL_ShowOpenFolderDialog", + "return_type": "void", + "parameters": [ + { + "name": "callback", + "type": "SDL_DialogFileCallback" + }, + { + "name": "userdata", + "type": "void *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "default_location", + "type": "const char *" + }, + { + "name": "allow_many", + "type": "bool" + } + ] + }, + { + "name": "SDL_ShowFileDialogWithProperties", + "return_type": "void", + "parameters": [ + { + "name": "_type", + "type": "SDL_FileDialogType" + }, + { + "name": "callback", + "type": "SDL_DialogFileCallback" + }, + { + "name": "userdata", + "type": "void *" + }, + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/endian.json b/json/endian.json new file mode 100644 index 0000000..aa539d1 --- /dev/null +++ b/json/endian.json @@ -0,0 +1,11 @@ +{ + "header": "SDL_endian.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [] +} \ No newline at end of file diff --git a/json/error.json b/json/error.json new file mode 100644 index 0000000..65f3fad --- /dev/null +++ b/json/error.json @@ -0,0 +1,55 @@ +{ + "header": "SDL_error.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_SetError", + "return_type": "bool", + "parameters": [ + { + "name": "fmt", + "type": "const char *" + }, + { + "name": "", + "type": "..." + } + ] + }, + { + "name": "SDL_SetErrorV", + "return_type": "bool", + "parameters": [ + { + "name": "fmt", + "type": "const char *" + }, + { + "name": "ap", + "type": "va_list" + } + ] + }, + { + "name": "SDL_OutOfMemory", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetError", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_ClearError", + "return_type": "bool", + "parameters": [] + } + ] +} \ No newline at end of file diff --git a/json/filesystem.json b/json/filesystem.json new file mode 100644 index 0000000..b382839 --- /dev/null +++ b/json/filesystem.json @@ -0,0 +1,298 @@ +{ + "header": "SDL_filesystem.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [ + { + "name": "SDL_EnumerateDirectoryCallback", + "return_type": "SDL_EnumerationResult", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "dirname", + "type": "const char *" + }, + { + "name": "fname", + "type": "const char *" + } + ] + } + ], + "enums": [ + { + "name": "SDL_Folder", + "values": [ + { + "name": "SDL_FOLDER_HOME", + "comment": "The folder which contains all of the current user's data, preferences, and documents. It usually contains most of the other folders. If a requested folder does not exist, the home folder can be considered a safe fallback to store a user's documents." + }, + { + "name": "SDL_FOLDER_DESKTOP", + "comment": "The folder of files that are displayed on the desktop. Note that the existence of a desktop folder does not guarantee that the system does show icons on its desktop; certain GNU/Linux distros with a graphical environment may not have desktop icons." + }, + { + "name": "SDL_FOLDER_DOCUMENTS", + "comment": "User document files, possibly application-specific. This is a good place to save a user's projects." + }, + { + "name": "SDL_FOLDER_DOWNLOADS", + "comment": "Standard folder for user files downloaded from the internet." + }, + { + "name": "SDL_FOLDER_MUSIC", + "comment": "Music files that can be played using a standard music player (mp3, ogg...)." + }, + { + "name": "SDL_FOLDER_PICTURES", + "comment": "Image files that can be displayed using a standard viewer (png, jpg...)." + }, + { + "name": "SDL_FOLDER_PUBLICSHARE", + "comment": "Files that are meant to be shared with other users on the same computer." + }, + { + "name": "SDL_FOLDER_SAVEDGAMES", + "comment": "Save files for games." + }, + { + "name": "SDL_FOLDER_SCREENSHOTS", + "comment": "Application screenshots." + }, + { + "name": "SDL_FOLDER_TEMPLATES", + "comment": "Template files to be used when the user requests the desktop environment to create a new file in a certain folder, such as \"New Text File.txt\". Any file in the Templates folder can be used as a starting point for a new file." + }, + { + "name": "SDL_FOLDER_VIDEOS", + "comment": "Video files that can be played using a standard video player (mp4, webm...)." + }, + { + "name": "SDL_FOLDER_COUNT" + } + ] + }, + { + "name": "SDL_PathType", + "values": [ + { + "name": "SDL_PATHTYPE_NONE", + "comment": "path does not exist" + }, + { + "name": "SDL_PATHTYPE_FILE", + "comment": "a normal file" + }, + { + "name": "SDL_PATHTYPE_DIRECTORY", + "comment": "a directory" + }, + { + "name": "SDL_PATHTYPE_OTHER" + } + ] + }, + { + "name": "SDL_EnumerationResult", + "values": [ + { + "name": "SDL_ENUM_CONTINUE", + "comment": "Value that requests that enumeration continue." + }, + { + "name": "SDL_ENUM_SUCCESS", + "comment": "Value that requests that enumeration stop, successfully." + }, + { + "name": "SDL_ENUM_FAILURE" + } + ] + } + ], + "structs": [ + { + "name": "SDL_PathInfo", + "fields": [ + { + "name": "_type", + "type": "SDL_PathType", + "comment": "the path type" + }, + { + "name": "size", + "type": "Uint64", + "comment": "the file size in bytes" + }, + { + "name": "create_time", + "type": "SDL_Time", + "comment": "the time when the path was created" + }, + { + "name": "modify_time", + "type": "SDL_Time", + "comment": "the last time the path was modified" + }, + { + "name": "access_time", + "type": "SDL_Time", + "comment": "the last time the path was read" + } + ] + } + ], + "unions": [], + "flags": [ + { + "name": "SDL_GlobFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_GLOB_CASEINSENSITIVE", + "value": "(1u << 0)" + } + ] + } + ], + "functions": [ + { + "name": "SDL_GetBasePath", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_GetPrefPath", + "return_type": "char *", + "parameters": [ + { + "name": "org", + "type": "const char *" + }, + { + "name": "app", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetUserFolder", + "return_type": "const char *", + "parameters": [ + { + "name": "folder", + "type": "SDL_Folder" + } + ] + }, + { + "name": "SDL_CreateDirectory", + "return_type": "bool", + "parameters": [ + { + "name": "path", + "type": "const char *" + } + ] + }, + { + "name": "SDL_EnumerateDirectory", + "return_type": "bool", + "parameters": [ + { + "name": "path", + "type": "const char *" + }, + { + "name": "callback", + "type": "SDL_EnumerateDirectoryCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_RemovePath", + "return_type": "bool", + "parameters": [ + { + "name": "path", + "type": "const char *" + } + ] + }, + { + "name": "SDL_RenamePath", + "return_type": "bool", + "parameters": [ + { + "name": "oldpath", + "type": "const char *" + }, + { + "name": "newpath", + "type": "const char *" + } + ] + }, + { + "name": "SDL_CopyFile", + "return_type": "bool", + "parameters": [ + { + "name": "oldpath", + "type": "const char *" + }, + { + "name": "newpath", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetPathInfo", + "return_type": "bool", + "parameters": [ + { + "name": "path", + "type": "const char *" + }, + { + "name": "info", + "type": "SDL_PathInfo *" + } + ] + }, + { + "name": "SDL_GlobDirectory", + "return_type": "char **", + "parameters": [ + { + "name": "path", + "type": "const char *" + }, + { + "name": "pattern", + "type": "const char *" + }, + { + "name": "flags", + "type": "SDL_GlobFlags" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetCurrentDirectory", + "return_type": "char *", + "parameters": [] + } + ] +} \ No newline at end of file diff --git a/json/gamepad.json b/json/gamepad.json new file mode 100644 index 0000000..c2d376a --- /dev/null +++ b/json/gamepad.json @@ -0,0 +1,1148 @@ +{ + "header": "SDL_gamepad.h", + "opaque_types": [ + { + "name": "SDL_Gamepad" + } + ], + "typedefs": [], + "function_pointers": [], + "enums": [ + { + "name": "SDL_GamepadType", + "values": [ + { + "name": "SDL_GAMEPAD_TYPE_STANDARD" + }, + { + "name": "SDL_GAMEPAD_TYPE_XBOX360" + }, + { + "name": "SDL_GAMEPAD_TYPE_XBOXONE" + }, + { + "name": "SDL_GAMEPAD_TYPE_PS3" + }, + { + "name": "SDL_GAMEPAD_TYPE_PS4" + }, + { + "name": "SDL_GAMEPAD_TYPE_PS5" + }, + { + "name": "SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_PRO" + }, + { + "name": "SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_LEFT" + }, + { + "name": "SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT" + }, + { + "name": "SDL_GAMEPAD_TYPE_NINTENDO_SWITCH_JOYCON_PAIR" + }, + { + "name": "SDL_GAMEPAD_TYPE_COUNT" + } + ] + }, + { + "name": "SDL_GamepadButton", + "values": [ + { + "name": "SDL_GAMEPAD_BUTTON_SOUTH", + "comment": "Bottom face button (e.g. Xbox A button)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_EAST", + "comment": "Right face button (e.g. Xbox B button)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_WEST", + "comment": "Left face button (e.g. Xbox X button)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_NORTH", + "comment": "Top face button (e.g. Xbox Y button)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_BACK" + }, + { + "name": "SDL_GAMEPAD_BUTTON_GUIDE" + }, + { + "name": "SDL_GAMEPAD_BUTTON_START" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LEFT_STICK" + }, + { + "name": "SDL_GAMEPAD_BUTTON_RIGHT_STICK" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LEFT_SHOULDER" + }, + { + "name": "SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER" + }, + { + "name": "SDL_GAMEPAD_BUTTON_DPAD_UP" + }, + { + "name": "SDL_GAMEPAD_BUTTON_DPAD_DOWN" + }, + { + "name": "SDL_GAMEPAD_BUTTON_DPAD_LEFT" + }, + { + "name": "SDL_GAMEPAD_BUTTON_DPAD_RIGHT" + }, + { + "name": "SDL_GAMEPAD_BUTTON_MISC1", + "comment": "Additional button (e.g. Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button, Amazon Luna microphone button, Google Stadia capture button)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_RIGHT_PADDLE1", + "comment": "Upper or primary paddle, under your right hand (e.g. Xbox Elite paddle P1)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LEFT_PADDLE1", + "comment": "Upper or primary paddle, under your left hand (e.g. Xbox Elite paddle P3)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_RIGHT_PADDLE2", + "comment": "Lower or secondary paddle, under your right hand (e.g. Xbox Elite paddle P2)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LEFT_PADDLE2", + "comment": "Lower or secondary paddle, under your left hand (e.g. Xbox Elite paddle P4)" + }, + { + "name": "SDL_GAMEPAD_BUTTON_TOUCHPAD", + "comment": "PS4/PS5 touchpad button" + }, + { + "name": "SDL_GAMEPAD_BUTTON_MISC2", + "comment": "Additional button" + }, + { + "name": "SDL_GAMEPAD_BUTTON_MISC3", + "comment": "Additional button" + }, + { + "name": "SDL_GAMEPAD_BUTTON_MISC4", + "comment": "Additional button" + }, + { + "name": "SDL_GAMEPAD_BUTTON_MISC5", + "comment": "Additional button" + }, + { + "name": "SDL_GAMEPAD_BUTTON_MISC6", + "comment": "Additional button" + }, + { + "name": "SDL_GAMEPAD_BUTTON_COUNT" + } + ] + }, + { + "name": "SDL_GamepadButtonLabel", + "values": [ + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_UNKNOWN" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_A" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_B" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_X" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_Y" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_CROSS" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_CIRCLE" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_SQUARE" + }, + { + "name": "SDL_GAMEPAD_BUTTON_LABEL_TRIANGLE" + } + ] + }, + { + "name": "SDL_GamepadAxis", + "values": [ + { + "name": "SDL_GAMEPAD_AXIS_LEFTX" + }, + { + "name": "SDL_GAMEPAD_AXIS_LEFTY" + }, + { + "name": "SDL_GAMEPAD_AXIS_RIGHTX" + }, + { + "name": "SDL_GAMEPAD_AXIS_RIGHTY" + }, + { + "name": "SDL_GAMEPAD_AXIS_LEFT_TRIGGER" + }, + { + "name": "SDL_GAMEPAD_AXIS_RIGHT_TRIGGER" + }, + { + "name": "SDL_GAMEPAD_AXIS_COUNT" + } + ] + }, + { + "name": "SDL_GamepadBindingType", + "values": [ + { + "name": "SDL_GAMEPAD_BINDTYPE_BUTTON" + }, + { + "name": "SDL_GAMEPAD_BINDTYPE_AXIS" + }, + { + "name": "SDL_GAMEPAD_BINDTYPE_HAT" + } + ] + } + ], + "structs": [ + { + "name": "SDL_GamepadBinding", + "fields": [ + { + "name": "input_type", + "type": "SDL_GamepadBindingType" + }, + { + "name": "button", + "type": "int" + }, + { + "name": "axis", + "type": "int" + }, + { + "name": "axis_min", + "type": "int" + }, + { + "name": "axis_max", + "type": "int" + }, + { + "name": "hat", + "type": "int" + }, + { + "name": "hat_mask", + "type": "int" + }, + { + "name": "output_type", + "type": "SDL_GamepadBindingType" + }, + { + "name": "button", + "type": "SDL_GamepadButton" + }, + { + "name": "axis", + "type": "SDL_GamepadAxis" + }, + { + "name": "axis_min", + "type": "int" + }, + { + "name": "axis_max", + "type": "int" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_AddGamepadMapping", + "return_type": "int", + "parameters": [ + { + "name": "mapping", + "type": "const char *" + } + ] + }, + { + "name": "SDL_AddGamepadMappingsFromIO", + "return_type": "int", + "parameters": [ + { + "name": "src", + "type": "SDL_IOStream *" + }, + { + "name": "closeio", + "type": "bool" + } + ] + }, + { + "name": "SDL_AddGamepadMappingsFromFile", + "return_type": "int", + "parameters": [ + { + "name": "file", + "type": "const char *" + } + ] + }, + { + "name": "SDL_ReloadGamepadMappings", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetGamepadMappings", + "return_type": "char **", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetGamepadMappingForGUID", + "return_type": "char *", + "parameters": [ + { + "name": "guid", + "type": "SDL_GUID" + } + ] + }, + { + "name": "SDL_GetGamepadMapping", + "return_type": "char *", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_SetGamepadMapping", + "return_type": "bool", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + }, + { + "name": "mapping", + "type": "const char *" + } + ] + }, + { + "name": "SDL_HasGamepad", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetGamepads", + "return_type": "SDL_JoystickID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_IsGamepad", + "return_type": "bool", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadNameForID", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadPathForID", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadPlayerIndexForID", + "return_type": "int", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadGUIDForID", + "return_type": "SDL_GUID", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadVendorForID", + "return_type": "Uint16", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadProductForID", + "return_type": "Uint16", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadProductVersionForID", + "return_type": "Uint16", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadTypeForID", + "return_type": "SDL_GamepadType", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetRealGamepadTypeForID", + "return_type": "SDL_GamepadType", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadMappingForID", + "return_type": "char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_OpenGamepad", + "return_type": "SDL_Gamepad *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadFromID", + "return_type": "SDL_Gamepad *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetGamepadFromPlayerIndex", + "return_type": "SDL_Gamepad *", + "parameters": [ + { + "name": "player_index", + "type": "int" + } + ] + }, + { + "name": "SDL_GetGamepadProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadID", + "return_type": "SDL_JoystickID", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadName", + "return_type": "const char *", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadPath", + "return_type": "const char *", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadType", + "return_type": "SDL_GamepadType", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetRealGamepadType", + "return_type": "SDL_GamepadType", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadPlayerIndex", + "return_type": "int", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_SetGamepadPlayerIndex", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "player_index", + "type": "int" + } + ] + }, + { + "name": "SDL_GetGamepadVendor", + "return_type": "Uint16", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadProduct", + "return_type": "Uint16", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadProductVersion", + "return_type": "Uint16", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadFirmwareVersion", + "return_type": "Uint16", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadSerial", + "return_type": "const char *", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadSteamHandle", + "return_type": "Uint64", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadConnectionState", + "return_type": "SDL_JoystickConnectionState", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadPowerInfo", + "return_type": "SDL_PowerState", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "percent", + "type": "int *" + } + ] + }, + { + "name": "SDL_GamepadConnected", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadJoystick", + "return_type": "SDL_Joystick *", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_SetGamepadEventsEnabled", + "return_type": "void", + "parameters": [ + { + "name": "enabled", + "type": "bool" + } + ] + }, + { + "name": "SDL_GamepadEventsEnabled", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetGamepadBindings", + "return_type": "SDL_GamepadBinding **", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_UpdateGamepads", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_GetGamepadTypeFromString", + "return_type": "SDL_GamepadType", + "parameters": [ + { + "name": "str", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetGamepadStringForType", + "return_type": "const char *", + "parameters": [ + { + "name": "_type", + "type": "SDL_GamepadType" + } + ] + }, + { + "name": "SDL_GetGamepadAxisFromString", + "return_type": "SDL_GamepadAxis", + "parameters": [ + { + "name": "str", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetGamepadStringForAxis", + "return_type": "const char *", + "parameters": [ + { + "name": "axis", + "type": "SDL_GamepadAxis" + } + ] + }, + { + "name": "SDL_GamepadHasAxis", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "axis", + "type": "SDL_GamepadAxis" + } + ] + }, + { + "name": "SDL_GetGamepadAxis", + "return_type": "Sint16", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "axis", + "type": "SDL_GamepadAxis" + } + ] + }, + { + "name": "SDL_GetGamepadButtonFromString", + "return_type": "SDL_GamepadButton", + "parameters": [ + { + "name": "str", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetGamepadStringForButton", + "return_type": "const char *", + "parameters": [ + { + "name": "button", + "type": "SDL_GamepadButton" + } + ] + }, + { + "name": "SDL_GamepadHasButton", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "button", + "type": "SDL_GamepadButton" + } + ] + }, + { + "name": "SDL_GetGamepadButton", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "button", + "type": "SDL_GamepadButton" + } + ] + }, + { + "name": "SDL_GetGamepadButtonLabelForType", + "return_type": "SDL_GamepadButtonLabel", + "parameters": [ + { + "name": "_type", + "type": "SDL_GamepadType" + }, + { + "name": "button", + "type": "SDL_GamepadButton" + } + ] + }, + { + "name": "SDL_GetGamepadButtonLabel", + "return_type": "SDL_GamepadButtonLabel", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "button", + "type": "SDL_GamepadButton" + } + ] + }, + { + "name": "SDL_GetNumGamepadTouchpads", + "return_type": "int", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetNumGamepadTouchpadFingers", + "return_type": "int", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "touchpad", + "type": "int" + } + ] + }, + { + "name": "SDL_GetGamepadTouchpadFinger", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "touchpad", + "type": "int" + }, + { + "name": "finger", + "type": "int" + }, + { + "name": "down", + "type": "bool *" + }, + { + "name": "x", + "type": "float *" + }, + { + "name": "y", + "type": "float *" + }, + { + "name": "pressure", + "type": "float *" + } + ] + }, + { + "name": "SDL_GamepadHasSensor", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "_type", + "type": "SDL_SensorType" + } + ] + }, + { + "name": "SDL_SetGamepadSensorEnabled", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "_type", + "type": "SDL_SensorType" + }, + { + "name": "enabled", + "type": "bool" + } + ] + }, + { + "name": "SDL_GamepadSensorEnabled", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "_type", + "type": "SDL_SensorType" + } + ] + }, + { + "name": "SDL_GetGamepadSensorDataRate", + "return_type": "float", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "_type", + "type": "SDL_SensorType" + } + ] + }, + { + "name": "SDL_GetGamepadSensorData", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "_type", + "type": "SDL_SensorType" + }, + { + "name": "data", + "type": "float *" + }, + { + "name": "num_values", + "type": "int" + } + ] + }, + { + "name": "SDL_RumbleGamepad", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "low_frequency_rumble", + "type": "Uint16" + }, + { + "name": "high_frequency_rumble", + "type": "Uint16" + }, + { + "name": "duration_ms", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_RumbleGamepadTriggers", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "left_rumble", + "type": "Uint16" + }, + { + "name": "right_rumble", + "type": "Uint16" + }, + { + "name": "duration_ms", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_SetGamepadLED", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "red", + "type": "Uint8" + }, + { + "name": "green", + "type": "Uint8" + }, + { + "name": "blue", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_SendGamepadEffect", + "return_type": "bool", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "data", + "type": "const void *" + }, + { + "name": "size", + "type": "int" + } + ] + }, + { + "name": "SDL_CloseGamepad", + "return_type": "void", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + } + ] + }, + { + "name": "SDL_GetGamepadAppleSFSymbolsNameForButton", + "return_type": "const char *", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "button", + "type": "SDL_GamepadButton" + } + ] + }, + { + "name": "SDL_GetGamepadAppleSFSymbolsNameForAxis", + "return_type": "const char *", + "parameters": [ + { + "name": "gamepad", + "type": "SDL_Gamepad *" + }, + { + "name": "axis", + "type": "SDL_GamepadAxis" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/gpu.json b/json/gpu.json new file mode 100644 index 0000000..6b4ff5d --- /dev/null +++ b/json/gpu.json @@ -0,0 +1,3881 @@ +{ + "header": "SDL_gpu.h", + "opaque_types": [ + { + "name": "SDL_GPUDevice" + }, + { + "name": "SDL_GPUBuffer" + }, + { + "name": "SDL_GPUTransferBuffer" + }, + { + "name": "SDL_GPUTexture" + }, + { + "name": "SDL_GPUSampler" + }, + { + "name": "SDL_GPUShader" + }, + { + "name": "SDL_GPUComputePipeline" + }, + { + "name": "SDL_GPUGraphicsPipeline" + }, + { + "name": "SDL_GPUCommandBuffer" + }, + { + "name": "SDL_GPURenderPass" + }, + { + "name": "SDL_GPUComputePass" + }, + { + "name": "SDL_GPUCopyPass" + }, + { + "name": "SDL_GPUFence" + } + ], + "typedefs": [ + { + "name": "SDL_GPUShaderFormat", + "underlying_type": "Uint32" + } + ], + "function_pointers": [], + "enums": [ + { + "name": "SDL_GPUPrimitiveType", + "values": [ + { + "name": "SDL_GPU_PRIMITIVETYPE_TRIANGLELIST", + "comment": "A series of separate triangles." + }, + { + "name": "SDL_GPU_PRIMITIVETYPE_TRIANGLESTRIP", + "comment": "A series of connected triangles." + }, + { + "name": "SDL_GPU_PRIMITIVETYPE_LINELIST", + "comment": "A series of separate lines." + }, + { + "name": "SDL_GPU_PRIMITIVETYPE_LINESTRIP", + "comment": "A series of connected lines." + }, + { + "name": "SDL_GPU_PRIMITIVETYPE_POINTLIST", + "comment": "A series of separate points." + } + ] + }, + { + "name": "SDL_GPULoadOp", + "values": [ + { + "name": "SDL_GPU_LOADOP_LOAD", + "comment": "The previous contents of the texture will be preserved." + }, + { + "name": "SDL_GPU_LOADOP_CLEAR", + "comment": "The contents of the texture will be cleared to a color." + }, + { + "name": "SDL_GPU_LOADOP_DONT_CARE", + "comment": "The previous contents of the texture need not be preserved. The contents will be undefined." + } + ] + }, + { + "name": "SDL_GPUStoreOp", + "values": [ + { + "name": "SDL_GPU_STOREOP_STORE", + "comment": "The contents generated during the render pass will be written to memory." + }, + { + "name": "SDL_GPU_STOREOP_DONT_CARE", + "comment": "The contents generated during the render pass are not needed and may be discarded. The contents will be undefined." + }, + { + "name": "SDL_GPU_STOREOP_RESOLVE", + "comment": "The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture may then be discarded and will be undefined." + }, + { + "name": "SDL_GPU_STOREOP_RESOLVE_AND_STORE", + "comment": "The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture will be written to memory." + } + ] + }, + { + "name": "SDL_GPUIndexElementSize", + "values": [ + { + "name": "SDL_GPU_INDEXELEMENTSIZE_16BIT", + "comment": "The index elements are 16-bit." + }, + { + "name": "SDL_GPU_INDEXELEMENTSIZE_32BIT", + "comment": "The index elements are 32-bit." + } + ] + }, + { + "name": "SDL_GPUTextureFormat", + "values": [ + { + "name": "SDL_GPU_TEXTUREFORMAT_INVALID" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_A8_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_B5G6R5_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_B5G5R5A1_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC4_R_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC5_RG_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC7_RGBA_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC6H_RGB_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC6H_RGB_UFLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8_SNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8_SNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8B8A8_SNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16_SNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16_SNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16B16A16_SNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32G32_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R11G11B10_UFLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32G32_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32G32B32A32_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8B8A8_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R16G16B16A16_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32G32_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R32G32B32A32_INT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_BC7_RGBA_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_D16_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_D24_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_D32_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM_SRGB" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_4x4_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_5x4_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_5x5_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_6x5_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_6x6_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x5_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x6_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_8x8_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x5_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x6_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x8_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_10x10_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_12x10_FLOAT" + }, + { + "name": "SDL_GPU_TEXTUREFORMAT_ASTC_12x12_FLOAT" + } + ] + }, + { + "name": "SDL_GPUTextureType", + "values": [ + { + "name": "SDL_GPU_TEXTURETYPE_2D", + "comment": "The texture is a 2-dimensional image." + }, + { + "name": "SDL_GPU_TEXTURETYPE_2D_ARRAY", + "comment": "The texture is a 2-dimensional array image." + }, + { + "name": "SDL_GPU_TEXTURETYPE_3D", + "comment": "The texture is a 3-dimensional image." + }, + { + "name": "SDL_GPU_TEXTURETYPE_CUBE", + "comment": "The texture is a cube image." + }, + { + "name": "SDL_GPU_TEXTURETYPE_CUBE_ARRAY", + "comment": "The texture is a cube array image." + } + ] + }, + { + "name": "SDL_GPUSampleCount", + "values": [ + { + "name": "SDL_GPU_SAMPLECOUNT_1", + "comment": "No multisampling." + }, + { + "name": "SDL_GPU_SAMPLECOUNT_2", + "comment": "MSAA 2x" + }, + { + "name": "SDL_GPU_SAMPLECOUNT_4", + "comment": "MSAA 4x" + }, + { + "name": "SDL_GPU_SAMPLECOUNT_8", + "comment": "MSAA 8x" + } + ] + }, + { + "name": "SDL_GPUCubeMapFace", + "values": [ + { + "name": "SDL_GPU_CUBEMAPFACE_POSITIVEX" + }, + { + "name": "SDL_GPU_CUBEMAPFACE_NEGATIVEX" + }, + { + "name": "SDL_GPU_CUBEMAPFACE_POSITIVEY" + }, + { + "name": "SDL_GPU_CUBEMAPFACE_NEGATIVEY" + }, + { + "name": "SDL_GPU_CUBEMAPFACE_POSITIVEZ" + }, + { + "name": "SDL_GPU_CUBEMAPFACE_NEGATIVEZ" + } + ] + }, + { + "name": "SDL_GPUTransferBufferUsage", + "values": [ + { + "name": "SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD" + }, + { + "name": "SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD" + } + ] + }, + { + "name": "SDL_GPUShaderStage", + "values": [ + { + "name": "SDL_GPU_SHADERSTAGE_VERTEX" + }, + { + "name": "SDL_GPU_SHADERSTAGE_FRAGMENT" + } + ] + }, + { + "name": "SDL_GPUVertexElementFormat", + "values": [ + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_INVALID" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_INT" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_INT2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_INT3" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_INT4" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UINT" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UINT2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UINT3" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UINT4" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_FLOAT" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_BYTE2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_BYTE4" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_BYTE2_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_BYTE4_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_SHORT2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_SHORT4" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_USHORT2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_USHORT4" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_SHORT2_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_SHORT4_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_USHORT2_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_USHORT4_NORM" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_HALF2" + }, + { + "name": "SDL_GPU_VERTEXELEMENTFORMAT_HALF4" + } + ] + }, + { + "name": "SDL_GPUVertexInputRate", + "values": [ + { + "name": "SDL_GPU_VERTEXINPUTRATE_VERTEX", + "comment": "Attribute addressing is a function of the vertex index." + }, + { + "name": "SDL_GPU_VERTEXINPUTRATE_INSTANCE", + "comment": "Attribute addressing is a function of the instance index." + } + ] + }, + { + "name": "SDL_GPUFillMode", + "values": [ + { + "name": "SDL_GPU_FILLMODE_FILL", + "comment": "Polygons will be rendered via rasterization." + }, + { + "name": "SDL_GPU_FILLMODE_LINE", + "comment": "Polygon edges will be drawn as line segments." + } + ] + }, + { + "name": "SDL_GPUCullMode", + "values": [ + { + "name": "SDL_GPU_CULLMODE_NONE", + "comment": "No triangles are culled." + }, + { + "name": "SDL_GPU_CULLMODE_FRONT", + "comment": "Front-facing triangles are culled." + }, + { + "name": "SDL_GPU_CULLMODE_BACK", + "comment": "Back-facing triangles are culled." + } + ] + }, + { + "name": "SDL_GPUFrontFace", + "values": [ + { + "name": "SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE", + "comment": "A triangle with counter-clockwise vertex winding will be considered front-facing." + }, + { + "name": "SDL_GPU_FRONTFACE_CLOCKWISE", + "comment": "A triangle with clockwise vertex winding will be considered front-facing." + } + ] + }, + { + "name": "SDL_GPUCompareOp", + "values": [ + { + "name": "SDL_GPU_COMPAREOP_INVALID" + }, + { + "name": "SDL_GPU_COMPAREOP_NEVER", + "comment": "The comparison always evaluates false." + }, + { + "name": "SDL_GPU_COMPAREOP_LESS", + "comment": "The comparison evaluates reference < test." + }, + { + "name": "SDL_GPU_COMPAREOP_EQUAL", + "comment": "The comparison evaluates reference == test." + }, + { + "name": "SDL_GPU_COMPAREOP_LESS_OR_EQUAL", + "comment": "The comparison evaluates reference <= test." + }, + { + "name": "SDL_GPU_COMPAREOP_GREATER", + "comment": "The comparison evaluates reference > test." + }, + { + "name": "SDL_GPU_COMPAREOP_NOT_EQUAL", + "comment": "The comparison evaluates reference != test." + }, + { + "name": "SDL_GPU_COMPAREOP_GREATER_OR_EQUAL", + "comment": "The comparison evalutes reference >= test." + }, + { + "name": "SDL_GPU_COMPAREOP_ALWAYS", + "comment": "The comparison always evaluates true." + } + ] + }, + { + "name": "SDL_GPUStencilOp", + "values": [ + { + "name": "SDL_GPU_STENCILOP_INVALID" + }, + { + "name": "SDL_GPU_STENCILOP_KEEP", + "comment": "Keeps the current value." + }, + { + "name": "SDL_GPU_STENCILOP_ZERO", + "comment": "Sets the value to 0." + }, + { + "name": "SDL_GPU_STENCILOP_REPLACE", + "comment": "Sets the value to reference." + }, + { + "name": "SDL_GPU_STENCILOP_INCREMENT_AND_CLAMP", + "comment": "Increments the current value and clamps to the maximum value." + }, + { + "name": "SDL_GPU_STENCILOP_DECREMENT_AND_CLAMP", + "comment": "Decrements the current value and clamps to 0." + }, + { + "name": "SDL_GPU_STENCILOP_INVERT", + "comment": "Bitwise-inverts the current value." + }, + { + "name": "SDL_GPU_STENCILOP_INCREMENT_AND_WRAP", + "comment": "Increments the current value and wraps back to 0." + }, + { + "name": "SDL_GPU_STENCILOP_DECREMENT_AND_WRAP", + "comment": "Decrements the current value and wraps to the maximum value." + } + ] + }, + { + "name": "SDL_GPUBlendOp", + "values": [ + { + "name": "SDL_GPU_BLENDOP_INVALID" + }, + { + "name": "SDL_GPU_BLENDOP_ADD", + "comment": "(source * source_factor) + (destination * destination_factor)" + }, + { + "name": "SDL_GPU_BLENDOP_SUBTRACT", + "comment": "(source * source_factor) - (destination * destination_factor)" + }, + { + "name": "SDL_GPU_BLENDOP_REVERSE_SUBTRACT", + "comment": "(destination * destination_factor) - (source * source_factor)" + }, + { + "name": "SDL_GPU_BLENDOP_MIN", + "comment": "min(source, destination)" + }, + { + "name": "SDL_GPU_BLENDOP_MAX" + } + ] + }, + { + "name": "SDL_GPUBlendFactor", + "values": [ + { + "name": "SDL_GPU_BLENDFACTOR_INVALID" + }, + { + "name": "SDL_GPU_BLENDFACTOR_ZERO", + "comment": "0" + }, + { + "name": "SDL_GPU_BLENDFACTOR_ONE", + "comment": "1" + }, + { + "name": "SDL_GPU_BLENDFACTOR_SRC_COLOR", + "comment": "source color" + }, + { + "name": "SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_COLOR", + "comment": "1 - source color" + }, + { + "name": "SDL_GPU_BLENDFACTOR_DST_COLOR", + "comment": "destination color" + }, + { + "name": "SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_COLOR", + "comment": "1 - destination color" + }, + { + "name": "SDL_GPU_BLENDFACTOR_SRC_ALPHA", + "comment": "source alpha" + }, + { + "name": "SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA", + "comment": "1 - source alpha" + }, + { + "name": "SDL_GPU_BLENDFACTOR_DST_ALPHA", + "comment": "destination alpha" + }, + { + "name": "SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_ALPHA", + "comment": "1 - destination alpha" + }, + { + "name": "SDL_GPU_BLENDFACTOR_CONSTANT_COLOR", + "comment": "blend constant" + }, + { + "name": "SDL_GPU_BLENDFACTOR_ONE_MINUS_CONSTANT_COLOR", + "comment": "1 - blend constant" + }, + { + "name": "SDL_GPU_BLENDFACTOR_SRC_ALPHA_SATURATE" + } + ] + }, + { + "name": "SDL_GPUFilter", + "values": [ + { + "name": "SDL_GPU_FILTER_NEAREST", + "comment": "Point filtering." + }, + { + "name": "SDL_GPU_FILTER_LINEAR", + "comment": "Linear filtering." + } + ] + }, + { + "name": "SDL_GPUSamplerMipmapMode", + "values": [ + { + "name": "SDL_GPU_SAMPLERMIPMAPMODE_NEAREST", + "comment": "Point filtering." + }, + { + "name": "SDL_GPU_SAMPLERMIPMAPMODE_LINEAR", + "comment": "Linear filtering." + } + ] + }, + { + "name": "SDL_GPUSamplerAddressMode", + "values": [ + { + "name": "SDL_GPU_SAMPLERADDRESSMODE_REPEAT", + "comment": "Specifies that the coordinates will wrap around." + }, + { + "name": "SDL_GPU_SAMPLERADDRESSMODE_MIRRORED_REPEAT", + "comment": "Specifies that the coordinates will wrap around mirrored." + }, + { + "name": "SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE", + "comment": "Specifies that the coordinates will clamp to the 0-1 range." + } + ] + }, + { + "name": "SDL_GPUPresentMode", + "values": [ + { + "name": "SDL_GPU_PRESENTMODE_VSYNC" + }, + { + "name": "SDL_GPU_PRESENTMODE_IMMEDIATE" + }, + { + "name": "SDL_GPU_PRESENTMODE_MAILBOX" + } + ] + }, + { + "name": "SDL_GPUSwapchainComposition", + "values": [ + { + "name": "SDL_GPU_SWAPCHAINCOMPOSITION_SDR" + }, + { + "name": "SDL_GPU_SWAPCHAINCOMPOSITION_SDR_LINEAR" + }, + { + "name": "SDL_GPU_SWAPCHAINCOMPOSITION_HDR_EXTENDED_LINEAR" + }, + { + "name": "SDL_GPU_SWAPCHAINCOMPOSITION_HDR10_ST2084" + } + ] + } + ], + "structs": [ + { + "name": "SDL_GPUViewport", + "fields": [ + { + "name": "x", + "type": "float", + "comment": "The left offset of the viewport." + }, + { + "name": "y", + "type": "float", + "comment": "The top offset of the viewport." + }, + { + "name": "w", + "type": "float", + "comment": "The width of the viewport." + }, + { + "name": "h", + "type": "float", + "comment": "The height of the viewport." + }, + { + "name": "min_depth", + "type": "float", + "comment": "The minimum depth of the viewport." + }, + { + "name": "max_depth", + "type": "float", + "comment": "The maximum depth of the viewport." + } + ] + }, + { + "name": "SDL_GPUTextureTransferInfo", + "fields": [ + { + "name": "transfer_buffer", + "type": "SDL_GPUTransferBuffer *", + "comment": "The transfer buffer used in the transfer operation." + }, + { + "name": "offset", + "type": "Uint32", + "comment": "The starting byte of the image data in the transfer buffer." + }, + { + "name": "pixels_per_row", + "type": "Uint32", + "comment": "The number of pixels from one row to the next." + }, + { + "name": "rows_per_layer", + "type": "Uint32", + "comment": "The number of rows from one layer/depth-slice to the next." + } + ] + }, + { + "name": "SDL_GPUTransferBufferLocation", + "fields": [ + { + "name": "transfer_buffer", + "type": "SDL_GPUTransferBuffer *", + "comment": "The transfer buffer used in the transfer operation." + }, + { + "name": "offset", + "type": "Uint32", + "comment": "The starting byte of the buffer data in the transfer buffer." + } + ] + }, + { + "name": "SDL_GPUTextureLocation", + "fields": [ + { + "name": "texture", + "type": "SDL_GPUTexture *", + "comment": "The texture used in the copy operation." + }, + { + "name": "mip_level", + "type": "Uint32", + "comment": "The mip level index of the location." + }, + { + "name": "layer", + "type": "Uint32", + "comment": "The layer index of the location." + }, + { + "name": "x", + "type": "Uint32", + "comment": "The left offset of the location." + }, + { + "name": "y", + "type": "Uint32", + "comment": "The top offset of the location." + }, + { + "name": "z", + "type": "Uint32", + "comment": "The front offset of the location." + } + ] + }, + { + "name": "SDL_GPUTextureRegion", + "fields": [ + { + "name": "texture", + "type": "SDL_GPUTexture *", + "comment": "The texture used in the copy operation." + }, + { + "name": "mip_level", + "type": "Uint32", + "comment": "The mip level index to transfer." + }, + { + "name": "layer", + "type": "Uint32", + "comment": "The layer index to transfer." + }, + { + "name": "x", + "type": "Uint32", + "comment": "The left offset of the region." + }, + { + "name": "y", + "type": "Uint32", + "comment": "The top offset of the region." + }, + { + "name": "z", + "type": "Uint32", + "comment": "The front offset of the region." + }, + { + "name": "w", + "type": "Uint32", + "comment": "The width of the region." + }, + { + "name": "h", + "type": "Uint32", + "comment": "The height of the region." + }, + { + "name": "d", + "type": "Uint32", + "comment": "The depth of the region." + } + ] + }, + { + "name": "SDL_GPUBlitRegion", + "fields": [ + { + "name": "texture", + "type": "SDL_GPUTexture *", + "comment": "The texture." + }, + { + "name": "mip_level", + "type": "Uint32", + "comment": "The mip level index of the region." + }, + { + "name": "layer_or_depth_plane", + "type": "Uint32", + "comment": "The layer index or depth plane of the region. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures." + }, + { + "name": "x", + "type": "Uint32", + "comment": "The left offset of the region." + }, + { + "name": "y", + "type": "Uint32", + "comment": "The top offset of the region." + }, + { + "name": "w", + "type": "Uint32", + "comment": "The width of the region." + }, + { + "name": "h", + "type": "Uint32", + "comment": "The height of the region." + } + ] + }, + { + "name": "SDL_GPUBufferLocation", + "fields": [ + { + "name": "buffer", + "type": "SDL_GPUBuffer *", + "comment": "The buffer." + }, + { + "name": "offset", + "type": "Uint32", + "comment": "The starting byte within the buffer." + } + ] + }, + { + "name": "SDL_GPUBufferRegion", + "fields": [ + { + "name": "buffer", + "type": "SDL_GPUBuffer *", + "comment": "The buffer." + }, + { + "name": "offset", + "type": "Uint32", + "comment": "The starting byte within the buffer." + }, + { + "name": "size", + "type": "Uint32", + "comment": "The size in bytes of the region." + } + ] + }, + { + "name": "SDL_GPUIndirectDrawCommand", + "fields": [ + { + "name": "num_vertices", + "type": "Uint32", + "comment": "The number of vertices to draw." + }, + { + "name": "num_instances", + "type": "Uint32", + "comment": "The number of instances to draw." + }, + { + "name": "first_vertex", + "type": "Uint32", + "comment": "The index of the first vertex to draw." + }, + { + "name": "first_instance", + "type": "Uint32", + "comment": "The ID of the first instance to draw." + } + ] + }, + { + "name": "SDL_GPUIndexedIndirectDrawCommand", + "fields": [ + { + "name": "num_indices", + "type": "Uint32", + "comment": "The number of indices to draw per instance." + }, + { + "name": "num_instances", + "type": "Uint32", + "comment": "The number of instances to draw." + }, + { + "name": "first_index", + "type": "Uint32", + "comment": "The base index within the index buffer." + }, + { + "name": "vertex_offset", + "type": "Sint32", + "comment": "The value added to the vertex index before indexing into the vertex buffer." + }, + { + "name": "first_instance", + "type": "Uint32", + "comment": "The ID of the first instance to draw." + } + ] + }, + { + "name": "SDL_GPUIndirectDispatchCommand", + "fields": [ + { + "name": "groupcount_x", + "type": "Uint32", + "comment": "The number of local workgroups to dispatch in the X dimension." + }, + { + "name": "groupcount_y", + "type": "Uint32", + "comment": "The number of local workgroups to dispatch in the Y dimension." + }, + { + "name": "groupcount_z", + "type": "Uint32", + "comment": "The number of local workgroups to dispatch in the Z dimension." + } + ] + }, + { + "name": "SDL_GPUSamplerCreateInfo", + "fields": [ + { + "name": "min_filter", + "type": "SDL_GPUFilter", + "comment": "The minification filter to apply to lookups." + }, + { + "name": "mag_filter", + "type": "SDL_GPUFilter", + "comment": "The magnification filter to apply to lookups." + }, + { + "name": "mipmap_mode", + "type": "SDL_GPUSamplerMipmapMode", + "comment": "The mipmap filter to apply to lookups." + }, + { + "name": "address_mode_u", + "type": "SDL_GPUSamplerAddressMode", + "comment": "The addressing mode for U coordinates outside [0, 1)." + }, + { + "name": "address_mode_v", + "type": "SDL_GPUSamplerAddressMode", + "comment": "The addressing mode for V coordinates outside [0, 1)." + }, + { + "name": "address_mode_w", + "type": "SDL_GPUSamplerAddressMode", + "comment": "The addressing mode for W coordinates outside [0, 1)." + }, + { + "name": "mip_lod_bias", + "type": "float", + "comment": "The bias to be added to mipmap LOD calculation." + }, + { + "name": "max_anisotropy", + "type": "float", + "comment": "The anisotropy value clamp used by the sampler. If enable_anisotropy is false, this is ignored." + }, + { + "name": "compare_op", + "type": "SDL_GPUCompareOp", + "comment": "The comparison operator to apply to fetched data before filtering." + }, + { + "name": "min_lod", + "type": "float", + "comment": "Clamps the minimum of the computed LOD value." + }, + { + "name": "max_lod", + "type": "float", + "comment": "Clamps the maximum of the computed LOD value." + }, + { + "name": "enable_anisotropy", + "type": "bool", + "comment": "true to enable anisotropic filtering." + }, + { + "name": "enable_compare", + "type": "bool", + "comment": "true to enable comparison against a reference value during lookups." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + }, + { + "name": "props", + "type": "SDL_PropertiesID", + "comment": "A properties ID for extensions. Should be 0 if no extensions are needed." + } + ] + }, + { + "name": "SDL_GPUVertexBufferDescription", + "fields": [ + { + "name": "slot", + "type": "Uint32", + "comment": "The binding slot of the vertex buffer." + }, + { + "name": "pitch", + "type": "Uint32", + "comment": "The byte pitch between consecutive elements of the vertex buffer." + }, + { + "name": "input_rate", + "type": "SDL_GPUVertexInputRate", + "comment": "Whether attribute addressing is a function of the vertex index or instance index." + }, + { + "name": "instance_step_rate", + "type": "Uint32", + "comment": "Reserved for future use. Must be set to 0." + } + ] + }, + { + "name": "SDL_GPUVertexAttribute", + "fields": [ + { + "name": "location", + "type": "Uint32", + "comment": "The shader input location index." + }, + { + "name": "buffer_slot", + "type": "Uint32", + "comment": "The binding slot of the associated vertex buffer." + }, + { + "name": "format", + "type": "SDL_GPUVertexElementFormat", + "comment": "The size and type of the attribute data." + }, + { + "name": "offset", + "type": "Uint32", + "comment": "The byte offset of this attribute relative to the start of the vertex element." + } + ] + }, + { + "name": "SDL_GPUVertexInputState", + "fields": [ + { + "name": "vertex_buffer_descriptions", + "type": "const SDL_GPUVertexBufferDescription *", + "comment": "A pointer to an array of vertex buffer descriptions." + }, + { + "name": "num_vertex_buffers", + "type": "Uint32", + "comment": "The number of vertex buffer descriptions in the above array." + }, + { + "name": "vertex_attributes", + "type": "const SDL_GPUVertexAttribute *", + "comment": "A pointer to an array of vertex attribute descriptions." + }, + { + "name": "num_vertex_attributes", + "type": "Uint32", + "comment": "The number of vertex attribute descriptions in the above array." + } + ] + }, + { + "name": "SDL_GPUStencilOpState", + "fields": [ + { + "name": "fail_op", + "type": "SDL_GPUStencilOp", + "comment": "The action performed on samples that fail the stencil test." + }, + { + "name": "pass_op", + "type": "SDL_GPUStencilOp", + "comment": "The action performed on samples that pass the depth and stencil tests." + }, + { + "name": "depth_fail_op", + "type": "SDL_GPUStencilOp", + "comment": "The action performed on samples that pass the stencil test and fail the depth test." + }, + { + "name": "compare_op", + "type": "SDL_GPUCompareOp", + "comment": "The comparison operator used in the stencil test." + } + ] + }, + { + "name": "SDL_GPUColorTargetBlendState", + "fields": [ + { + "name": "src_color_blendfactor", + "type": "SDL_GPUBlendFactor", + "comment": "The value to be multiplied by the source RGB value." + }, + { + "name": "dst_color_blendfactor", + "type": "SDL_GPUBlendFactor", + "comment": "The value to be multiplied by the destination RGB value." + }, + { + "name": "color_blend_op", + "type": "SDL_GPUBlendOp", + "comment": "The blend operation for the RGB components." + }, + { + "name": "src_alpha_blendfactor", + "type": "SDL_GPUBlendFactor", + "comment": "The value to be multiplied by the source alpha." + }, + { + "name": "dst_alpha_blendfactor", + "type": "SDL_GPUBlendFactor", + "comment": "The value to be multiplied by the destination alpha." + }, + { + "name": "alpha_blend_op", + "type": "SDL_GPUBlendOp", + "comment": "The blend operation for the alpha component." + }, + { + "name": "color_write_mask", + "type": "SDL_GPUColorComponentFlags", + "comment": "A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false." + }, + { + "name": "enable_blend", + "type": "bool", + "comment": "Whether blending is enabled for the color target." + }, + { + "name": "enable_color_write_mask", + "type": "bool", + "comment": "Whether the color write mask is enabled." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUShaderCreateInfo", + "fields": [ + { + "name": "code_size", + "type": "size_t", + "comment": "The size in bytes of the code pointed to." + }, + { + "name": "code", + "type": "const Uint8 *", + "comment": "A pointer to shader code." + }, + { + "name": "entrypoint", + "type": "const char *", + "comment": "A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader." + }, + { + "name": "format", + "type": "SDL_GPUShaderFormat", + "comment": "The format of the shader code." + }, + { + "name": "stage", + "type": "SDL_GPUShaderStage", + "comment": "The stage the shader program corresponds to." + }, + { + "name": "num_samplers", + "type": "Uint32", + "comment": "The number of samplers defined in the shader." + }, + { + "name": "num_storage_textures", + "type": "Uint32", + "comment": "The number of storage textures defined in the shader." + }, + { + "name": "num_storage_buffers", + "type": "Uint32", + "comment": "The number of storage buffers defined in the shader." + }, + { + "name": "num_uniform_buffers", + "type": "Uint32", + "comment": "The number of uniform buffers defined in the shader." + }, + { + "name": "props", + "type": "SDL_PropertiesID", + "comment": "A properties ID for extensions. Should be 0 if no extensions are needed." + } + ] + }, + { + "name": "SDL_GPUTextureCreateInfo", + "fields": [ + { + "name": "_type", + "type": "SDL_GPUTextureType", + "comment": "The base dimensionality of the texture." + }, + { + "name": "format", + "type": "SDL_GPUTextureFormat", + "comment": "The pixel format of the texture." + }, + { + "name": "usage", + "type": "SDL_GPUTextureUsageFlags", + "comment": "How the texture is intended to be used by the client." + }, + { + "name": "width", + "type": "Uint32", + "comment": "The width of the texture." + }, + { + "name": "height", + "type": "Uint32", + "comment": "The height of the texture." + }, + { + "name": "layer_count_or_depth", + "type": "Uint32", + "comment": "The layer count or depth of the texture. This value is treated as a layer count on 2D array textures, and as a depth value on 3D textures." + }, + { + "name": "num_levels", + "type": "Uint32", + "comment": "The number of mip levels in the texture." + }, + { + "name": "sample_count", + "type": "SDL_GPUSampleCount", + "comment": "The number of samples per texel. Only applies if the texture is used as a render target." + }, + { + "name": "props", + "type": "SDL_PropertiesID", + "comment": "A properties ID for extensions. Should be 0 if no extensions are needed." + } + ] + }, + { + "name": "SDL_GPUBufferCreateInfo", + "fields": [ + { + "name": "usage", + "type": "SDL_GPUBufferUsageFlags", + "comment": "How the buffer is intended to be used by the client." + }, + { + "name": "size", + "type": "Uint32", + "comment": "The size in bytes of the buffer." + }, + { + "name": "props", + "type": "SDL_PropertiesID", + "comment": "A properties ID for extensions. Should be 0 if no extensions are needed." + } + ] + }, + { + "name": "SDL_GPUTransferBufferCreateInfo", + "fields": [ + { + "name": "usage", + "type": "SDL_GPUTransferBufferUsage", + "comment": "How the transfer buffer is intended to be used by the client." + }, + { + "name": "size", + "type": "Uint32", + "comment": "The size in bytes of the transfer buffer." + }, + { + "name": "props", + "type": "SDL_PropertiesID", + "comment": "A properties ID for extensions. Should be 0 if no extensions are needed." + } + ] + }, + { + "name": "SDL_GPURasterizerState", + "fields": [ + { + "name": "fill_mode", + "type": "SDL_GPUFillMode", + "comment": "Whether polygons will be filled in or drawn as lines." + }, + { + "name": "cull_mode", + "type": "SDL_GPUCullMode", + "comment": "The facing direction in which triangles will be culled." + }, + { + "name": "front_face", + "type": "SDL_GPUFrontFace", + "comment": "The vertex winding that will cause a triangle to be determined as front-facing." + }, + { + "name": "depth_bias_constant_factor", + "type": "float", + "comment": "A scalar factor controlling the depth value added to each fragment." + }, + { + "name": "depth_bias_clamp", + "type": "float", + "comment": "The maximum depth bias of a fragment." + }, + { + "name": "depth_bias_slope_factor", + "type": "float", + "comment": "A scalar factor applied to a fragment's slope in depth calculations." + }, + { + "name": "enable_depth_bias", + "type": "bool", + "comment": "true to bias fragment depth values." + }, + { + "name": "enable_depth_clip", + "type": "bool", + "comment": "true to enable depth clip, false to enable depth clamp." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUMultisampleState", + "fields": [ + { + "name": "sample_count", + "type": "SDL_GPUSampleCount", + "comment": "The number of samples to be used in rasterization." + }, + { + "name": "sample_mask", + "type": "Uint32", + "comment": "Reserved for future use. Must be set to 0." + }, + { + "name": "enable_mask", + "type": "bool", + "comment": "Reserved for future use. Must be set to false." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + }, + { + "name": "padding3", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUDepthStencilState", + "fields": [ + { + "name": "compare_op", + "type": "SDL_GPUCompareOp", + "comment": "The comparison operator used for depth testing." + }, + { + "name": "back_stencil_state", + "type": "SDL_GPUStencilOpState", + "comment": "The stencil op state for back-facing triangles." + }, + { + "name": "front_stencil_state", + "type": "SDL_GPUStencilOpState", + "comment": "The stencil op state for front-facing triangles." + }, + { + "name": "compare_mask", + "type": "Uint8", + "comment": "Selects the bits of the stencil values participating in the stencil test." + }, + { + "name": "write_mask", + "type": "Uint8", + "comment": "Selects the bits of the stencil values updated by the stencil test." + }, + { + "name": "enable_depth_test", + "type": "bool", + "comment": "true enables the depth test." + }, + { + "name": "enable_depth_write", + "type": "bool", + "comment": "true enables depth writes. Depth writes are always disabled when enable_depth_test is false." + }, + { + "name": "enable_stencil_test", + "type": "bool", + "comment": "true enables the stencil test." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + }, + { + "name": "padding3", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUColorTargetDescription", + "fields": [ + { + "name": "format", + "type": "SDL_GPUTextureFormat", + "comment": "The pixel format of the texture to be used as a color target." + }, + { + "name": "blend_state", + "type": "SDL_GPUColorTargetBlendState", + "comment": "The blend state to be used for the color target." + } + ] + }, + { + "name": "SDL_GPUGraphicsPipelineTargetInfo", + "fields": [ + { + "name": "color_target_descriptions", + "type": "const SDL_GPUColorTargetDescription *", + "comment": "A pointer to an array of color target descriptions." + }, + { + "name": "num_color_targets", + "type": "Uint32", + "comment": "The number of color target descriptions in the above array." + }, + { + "name": "depth_stencil_format", + "type": "SDL_GPUTextureFormat", + "comment": "The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is false." + }, + { + "name": "has_depth_stencil_target", + "type": "bool", + "comment": "true specifies that the pipeline uses a depth-stencil target." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + }, + { + "name": "padding3", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUGraphicsPipelineCreateInfo", + "fields": [ + { + "name": "vertex_shader", + "type": "SDL_GPUShader *", + "comment": "The vertex shader used by the graphics pipeline." + }, + { + "name": "fragment_shader", + "type": "SDL_GPUShader *", + "comment": "The fragment shader used by the graphics pipeline." + }, + { + "name": "vertex_input_state", + "type": "SDL_GPUVertexInputState", + "comment": "The vertex layout of the graphics pipeline." + }, + { + "name": "primitive_type", + "type": "SDL_GPUPrimitiveType", + "comment": "The primitive topology of the graphics pipeline." + }, + { + "name": "rasterizer_state", + "type": "SDL_GPURasterizerState", + "comment": "The rasterizer state of the graphics pipeline." + }, + { + "name": "multisample_state", + "type": "SDL_GPUMultisampleState", + "comment": "The multisample state of the graphics pipeline." + }, + { + "name": "depth_stencil_state", + "type": "SDL_GPUDepthStencilState", + "comment": "The depth-stencil state of the graphics pipeline." + }, + { + "name": "target_info", + "type": "SDL_GPUGraphicsPipelineTargetInfo", + "comment": "Formats and blend modes for the render targets of the graphics pipeline." + }, + { + "name": "props", + "type": "SDL_PropertiesID", + "comment": "A properties ID for extensions. Should be 0 if no extensions are needed." + } + ] + }, + { + "name": "SDL_GPUComputePipelineCreateInfo", + "fields": [ + { + "name": "code_size", + "type": "size_t", + "comment": "The size in bytes of the compute shader code pointed to." + }, + { + "name": "code", + "type": "const Uint8 *", + "comment": "A pointer to compute shader code." + }, + { + "name": "entrypoint", + "type": "const char *", + "comment": "A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader." + }, + { + "name": "format", + "type": "SDL_GPUShaderFormat", + "comment": "The format of the compute shader code." + }, + { + "name": "num_samplers", + "type": "Uint32", + "comment": "The number of samplers defined in the shader." + }, + { + "name": "num_readonly_storage_textures", + "type": "Uint32", + "comment": "The number of readonly storage textures defined in the shader." + }, + { + "name": "num_readonly_storage_buffers", + "type": "Uint32", + "comment": "The number of readonly storage buffers defined in the shader." + }, + { + "name": "num_readwrite_storage_textures", + "type": "Uint32", + "comment": "The number of read-write storage textures defined in the shader." + }, + { + "name": "num_readwrite_storage_buffers", + "type": "Uint32", + "comment": "The number of read-write storage buffers defined in the shader." + }, + { + "name": "num_uniform_buffers", + "type": "Uint32", + "comment": "The number of uniform buffers defined in the shader." + }, + { + "name": "threadcount_x", + "type": "Uint32", + "comment": "The number of threads in the X dimension. This should match the value in the shader." + }, + { + "name": "threadcount_y", + "type": "Uint32", + "comment": "The number of threads in the Y dimension. This should match the value in the shader." + }, + { + "name": "threadcount_z", + "type": "Uint32", + "comment": "The number of threads in the Z dimension. This should match the value in the shader." + }, + { + "name": "props", + "type": "SDL_PropertiesID", + "comment": "A properties ID for extensions. Should be 0 if no extensions are needed." + } + ] + }, + { + "name": "SDL_GPUColorTargetInfo", + "fields": [ + { + "name": "texture", + "type": "SDL_GPUTexture *", + "comment": "The texture that will be used as a color target by a render pass." + }, + { + "name": "mip_level", + "type": "Uint32", + "comment": "The mip level to use as a color target." + }, + { + "name": "layer_or_depth_plane", + "type": "Uint32", + "comment": "The layer index or depth plane to use as a color target. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures." + }, + { + "name": "clear_color", + "type": "SDL_FColor", + "comment": "The color to clear the color target to at the start of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used." + }, + { + "name": "load_op", + "type": "SDL_GPULoadOp", + "comment": "What is done with the contents of the color target at the beginning of the render pass." + }, + { + "name": "store_op", + "type": "SDL_GPUStoreOp", + "comment": "What is done with the results of the render pass." + }, + { + "name": "resolve_texture", + "type": "SDL_GPUTexture *", + "comment": "The texture that will receive the results of a multisample resolve operation. Ignored if a RESOLVE* store_op is not used." + }, + { + "name": "resolve_mip_level", + "type": "Uint32", + "comment": "The mip level of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used." + }, + { + "name": "resolve_layer", + "type": "Uint32", + "comment": "The layer index of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used." + }, + { + "name": "cycle", + "type": "bool", + "comment": "true cycles the texture if the texture is bound and load_op is not LOAD" + }, + { + "name": "cycle_resolve_texture", + "type": "bool", + "comment": "true cycles the resolve texture if the resolve texture is bound. Ignored if a RESOLVE* store_op is not used." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUDepthStencilTargetInfo", + "fields": [ + { + "name": "texture", + "type": "SDL_GPUTexture *", + "comment": "The texture that will be used as the depth stencil target by the render pass." + }, + { + "name": "clear_depth", + "type": "float", + "comment": "The value to clear the depth component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used." + }, + { + "name": "load_op", + "type": "SDL_GPULoadOp", + "comment": "What is done with the depth contents at the beginning of the render pass." + }, + { + "name": "store_op", + "type": "SDL_GPUStoreOp", + "comment": "What is done with the depth results of the render pass." + }, + { + "name": "stencil_load_op", + "type": "SDL_GPULoadOp", + "comment": "What is done with the stencil contents at the beginning of the render pass." + }, + { + "name": "stencil_store_op", + "type": "SDL_GPUStoreOp", + "comment": "What is done with the stencil results of the render pass." + }, + { + "name": "cycle", + "type": "bool", + "comment": "true cycles the texture if the texture is bound and any load ops are not LOAD" + }, + { + "name": "clear_stencil", + "type": "Uint8", + "comment": "The value to clear the stencil component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUBlitInfo", + "fields": [ + { + "name": "source", + "type": "SDL_GPUBlitRegion", + "comment": "The source region for the blit." + }, + { + "name": "destination", + "type": "SDL_GPUBlitRegion", + "comment": "The destination region for the blit." + }, + { + "name": "load_op", + "type": "SDL_GPULoadOp", + "comment": "What is done with the contents of the destination before the blit." + }, + { + "name": "clear_color", + "type": "SDL_FColor", + "comment": "The color to clear the destination region to before the blit. Ignored if load_op is not SDL_GPU_LOADOP_CLEAR." + }, + { + "name": "flip_mode", + "type": "SDL_FlipMode", + "comment": "The flip mode for the source region." + }, + { + "name": "filter", + "type": "SDL_GPUFilter", + "comment": "The filter mode used when blitting." + }, + { + "name": "cycle", + "type": "bool", + "comment": "true cycles the destination texture if it is already bound." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + }, + { + "name": "padding3", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUBufferBinding", + "fields": [ + { + "name": "buffer", + "type": "SDL_GPUBuffer *", + "comment": "The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_VERTEX for SDL_BindGPUVertexBuffers, or SDL_GPU_BUFFERUSAGE_INDEX for SDL_BindGPUIndexBuffer." + }, + { + "name": "offset", + "type": "Uint32", + "comment": "The starting byte of the data to bind in the buffer." + } + ] + }, + { + "name": "SDL_GPUTextureSamplerBinding", + "fields": [ + { + "name": "texture", + "type": "SDL_GPUTexture *", + "comment": "The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER." + }, + { + "name": "sampler", + "type": "SDL_GPUSampler *", + "comment": "The sampler to bind." + } + ] + }, + { + "name": "SDL_GPUStorageBufferReadWriteBinding", + "fields": [ + { + "name": "buffer", + "type": "SDL_GPUBuffer *", + "comment": "The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE." + }, + { + "name": "cycle", + "type": "bool", + "comment": "true cycles the buffer if it is already bound." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + }, + { + "name": "padding3", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GPUStorageTextureReadWriteBinding", + "fields": [ + { + "name": "texture", + "type": "SDL_GPUTexture *", + "comment": "The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE or SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE." + }, + { + "name": "mip_level", + "type": "Uint32", + "comment": "The mip level index to bind." + }, + { + "name": "layer", + "type": "Uint32", + "comment": "The layer index to bind." + }, + { + "name": "cycle", + "type": "bool", + "comment": "true cycles the texture if it is already bound." + }, + { + "name": "padding1", + "type": "Uint8" + }, + { + "name": "padding2", + "type": "Uint8" + }, + { + "name": "padding3", + "type": "Uint8" + } + ] + } + ], + "unions": [], + "flags": [ + { + "name": "SDL_GPUTextureUsageFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_GPU_TEXTUREUSAGE_SAMPLER", + "value": "(1u << 0)", + "comment": "Texture supports sampling." + }, + { + "name": "SDL_GPU_TEXTUREUSAGE_COLOR_TARGET", + "value": "(1u << 1)", + "comment": "Texture is a color render target." + }, + { + "name": "SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET", + "value": "(1u << 2)", + "comment": "Texture is a depth stencil target." + }, + { + "name": "SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ", + "value": "(1u << 3)", + "comment": "Texture supports storage reads in graphics stages." + }, + { + "name": "SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ", + "value": "(1u << 4)", + "comment": "Texture supports storage reads in the compute stage." + }, + { + "name": "SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE", + "value": "(1u << 5)", + "comment": "Texture supports storage writes in the compute stage." + }, + { + "name": "SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE", + "value": "(1u << 6)", + "comment": "Texture supports reads and writes in the same compute shader. This is NOT equivalent to READ | WRITE." + } + ] + }, + { + "name": "SDL_GPUBufferUsageFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_GPU_BUFFERUSAGE_VERTEX", + "value": "(1u << 0)", + "comment": "Buffer is a vertex buffer." + }, + { + "name": "SDL_GPU_BUFFERUSAGE_INDEX", + "value": "(1u << 1)", + "comment": "Buffer is an index buffer." + }, + { + "name": "SDL_GPU_BUFFERUSAGE_INDIRECT", + "value": "(1u << 2)", + "comment": "Buffer is an indirect buffer." + }, + { + "name": "SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ", + "value": "(1u << 3)", + "comment": "Buffer supports storage reads in graphics stages." + }, + { + "name": "SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ", + "value": "(1u << 4)", + "comment": "Buffer supports storage reads in the compute stage." + }, + { + "name": "SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE", + "value": "(1u << 5)", + "comment": "Buffer supports storage writes in the compute stage." + } + ] + }, + { + "name": "SDL_GPUColorComponentFlags", + "underlying_type": "Uint8", + "values": [ + { + "name": "SDL_GPU_COLORCOMPONENT_R", + "value": "(1u << 0)", + "comment": "the red component" + }, + { + "name": "SDL_GPU_COLORCOMPONENT_G", + "value": "(1u << 1)", + "comment": "the green component" + }, + { + "name": "SDL_GPU_COLORCOMPONENT_B", + "value": "(1u << 2)", + "comment": "the blue component" + }, + { + "name": "SDL_GPU_COLORCOMPONENT_A", + "value": "(1u << 3)", + "comment": "the alpha component" + } + ] + } + ], + "functions": [ + { + "name": "SDL_GPUSupportsShaderFormats", + "return_type": "bool", + "parameters": [ + { + "name": "format_flags", + "type": "SDL_GPUShaderFormat" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GPUSupportsProperties", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_CreateGPUDevice", + "return_type": "SDL_GPUDevice *", + "parameters": [ + { + "name": "format_flags", + "type": "SDL_GPUShaderFormat" + }, + { + "name": "debug_mode", + "type": "bool" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_CreateGPUDeviceWithProperties", + "return_type": "SDL_GPUDevice *", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_DestroyGPUDevice", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + } + ] + }, + { + "name": "SDL_GetNumGPUDrivers", + "return_type": "int", + "parameters": [] + }, + { + "name": "SDL_GetGPUDriver", + "return_type": "const char *", + "parameters": [ + { + "name": "index", + "type": "int" + } + ] + }, + { + "name": "SDL_GetGPUDeviceDriver", + "return_type": "const char *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + } + ] + }, + { + "name": "SDL_GetGPUShaderFormats", + "return_type": "SDL_GPUShaderFormat", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + } + ] + }, + { + "name": "SDL_CreateGPUComputePipeline", + "return_type": "SDL_GPUComputePipeline *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "createinfo", + "type": "const SDL_GPUComputePipelineCreateInfo *" + } + ] + }, + { + "name": "SDL_CreateGPUGraphicsPipeline", + "return_type": "SDL_GPUGraphicsPipeline *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "createinfo", + "type": "const SDL_GPUGraphicsPipelineCreateInfo *" + } + ] + }, + { + "name": "SDL_CreateGPUSampler", + "return_type": "SDL_GPUSampler *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "createinfo", + "type": "const SDL_GPUSamplerCreateInfo *" + } + ] + }, + { + "name": "SDL_CreateGPUShader", + "return_type": "SDL_GPUShader *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "createinfo", + "type": "const SDL_GPUShaderCreateInfo *" + } + ] + }, + { + "name": "SDL_CreateGPUTexture", + "return_type": "SDL_GPUTexture *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "createinfo", + "type": "const SDL_GPUTextureCreateInfo *" + } + ] + }, + { + "name": "SDL_CreateGPUBuffer", + "return_type": "SDL_GPUBuffer *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "createinfo", + "type": "const SDL_GPUBufferCreateInfo *" + } + ] + }, + { + "name": "SDL_CreateGPUTransferBuffer", + "return_type": "SDL_GPUTransferBuffer *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "createinfo", + "type": "const SDL_GPUTransferBufferCreateInfo *" + } + ] + }, + { + "name": "SDL_SetGPUBufferName", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "buffer", + "type": "SDL_GPUBuffer *" + }, + { + "name": "text", + "type": "const char *" + } + ] + }, + { + "name": "SDL_SetGPUTextureName", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "texture", + "type": "SDL_GPUTexture *" + }, + { + "name": "text", + "type": "const char *" + } + ] + }, + { + "name": "SDL_InsertGPUDebugLabel", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "text", + "type": "const char *" + } + ] + }, + { + "name": "SDL_PushGPUDebugGroup", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_PopGPUDebugGroup", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + } + ] + }, + { + "name": "SDL_ReleaseGPUTexture", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "texture", + "type": "SDL_GPUTexture *" + } + ] + }, + { + "name": "SDL_ReleaseGPUSampler", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "sampler", + "type": "SDL_GPUSampler *" + } + ] + }, + { + "name": "SDL_ReleaseGPUBuffer", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "buffer", + "type": "SDL_GPUBuffer *" + } + ] + }, + { + "name": "SDL_ReleaseGPUTransferBuffer", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "transfer_buffer", + "type": "SDL_GPUTransferBuffer *" + } + ] + }, + { + "name": "SDL_ReleaseGPUComputePipeline", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "compute_pipeline", + "type": "SDL_GPUComputePipeline *" + } + ] + }, + { + "name": "SDL_ReleaseGPUShader", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "shader", + "type": "SDL_GPUShader *" + } + ] + }, + { + "name": "SDL_ReleaseGPUGraphicsPipeline", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "graphics_pipeline", + "type": "SDL_GPUGraphicsPipeline *" + } + ] + }, + { + "name": "SDL_AcquireGPUCommandBuffer", + "return_type": "SDL_GPUCommandBuffer *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + } + ] + }, + { + "name": "SDL_PushGPUVertexUniformData", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "slot_index", + "type": "Uint32" + }, + { + "name": "data", + "type": "const void *" + }, + { + "name": "length", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_PushGPUFragmentUniformData", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "slot_index", + "type": "Uint32" + }, + { + "name": "data", + "type": "const void *" + }, + { + "name": "length", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_PushGPUComputeUniformData", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "slot_index", + "type": "Uint32" + }, + { + "name": "data", + "type": "const void *" + }, + { + "name": "length", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BeginGPURenderPass", + "return_type": "SDL_GPURenderPass *", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "color_target_infos", + "type": "const SDL_GPUColorTargetInfo *" + }, + { + "name": "num_color_targets", + "type": "Uint32" + }, + { + "name": "depth_stencil_target_info", + "type": "const SDL_GPUDepthStencilTargetInfo *" + } + ] + }, + { + "name": "SDL_BindGPUGraphicsPipeline", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "graphics_pipeline", + "type": "SDL_GPUGraphicsPipeline *" + } + ] + }, + { + "name": "SDL_SetGPUViewport", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "viewport", + "type": "const SDL_GPUViewport *" + } + ] + }, + { + "name": "SDL_SetGPUScissor", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "scissor", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_SetGPUBlendConstants", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "blend_constants", + "type": "SDL_FColor" + } + ] + }, + { + "name": "SDL_SetGPUStencilReference", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "reference", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_BindGPUVertexBuffers", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "bindings", + "type": "const SDL_GPUBufferBinding *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUIndexBuffer", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "binding", + "type": "const SDL_GPUBufferBinding *" + }, + { + "name": "index_element_size", + "type": "SDL_GPUIndexElementSize" + } + ] + }, + { + "name": "SDL_BindGPUVertexSamplers", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "texture_sampler_bindings", + "type": "const SDL_GPUTextureSamplerBinding *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUVertexStorageTextures", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "storage_textures", + "type": "SDL_GPUTexture *const *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUVertexStorageBuffers", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "storage_buffers", + "type": "SDL_GPUBuffer *const *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUFragmentSamplers", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "texture_sampler_bindings", + "type": "const SDL_GPUTextureSamplerBinding *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUFragmentStorageTextures", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "storage_textures", + "type": "SDL_GPUTexture *const *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUFragmentStorageBuffers", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "storage_buffers", + "type": "SDL_GPUBuffer *const *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_DrawGPUIndexedPrimitives", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "num_indices", + "type": "Uint32" + }, + { + "name": "num_instances", + "type": "Uint32" + }, + { + "name": "first_index", + "type": "Uint32" + }, + { + "name": "vertex_offset", + "type": "Sint32" + }, + { + "name": "first_instance", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_DrawGPUPrimitives", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "num_vertices", + "type": "Uint32" + }, + { + "name": "num_instances", + "type": "Uint32" + }, + { + "name": "first_vertex", + "type": "Uint32" + }, + { + "name": "first_instance", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_DrawGPUPrimitivesIndirect", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "buffer", + "type": "SDL_GPUBuffer *" + }, + { + "name": "offset", + "type": "Uint32" + }, + { + "name": "draw_count", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_DrawGPUIndexedPrimitivesIndirect", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + }, + { + "name": "buffer", + "type": "SDL_GPUBuffer *" + }, + { + "name": "offset", + "type": "Uint32" + }, + { + "name": "draw_count", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_EndGPURenderPass", + "return_type": "void", + "parameters": [ + { + "name": "render_pass", + "type": "SDL_GPURenderPass *" + } + ] + }, + { + "name": "SDL_BeginGPUComputePass", + "return_type": "SDL_GPUComputePass *", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "storage_texture_bindings", + "type": "const SDL_GPUStorageTextureReadWriteBinding *" + }, + { + "name": "num_storage_texture_bindings", + "type": "Uint32" + }, + { + "name": "storage_buffer_bindings", + "type": "const SDL_GPUStorageBufferReadWriteBinding *" + }, + { + "name": "num_storage_buffer_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUComputePipeline", + "return_type": "void", + "parameters": [ + { + "name": "compute_pass", + "type": "SDL_GPUComputePass *" + }, + { + "name": "compute_pipeline", + "type": "SDL_GPUComputePipeline *" + } + ] + }, + { + "name": "SDL_BindGPUComputeSamplers", + "return_type": "void", + "parameters": [ + { + "name": "compute_pass", + "type": "SDL_GPUComputePass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "texture_sampler_bindings", + "type": "const SDL_GPUTextureSamplerBinding *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUComputeStorageTextures", + "return_type": "void", + "parameters": [ + { + "name": "compute_pass", + "type": "SDL_GPUComputePass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "storage_textures", + "type": "SDL_GPUTexture *const *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BindGPUComputeStorageBuffers", + "return_type": "void", + "parameters": [ + { + "name": "compute_pass", + "type": "SDL_GPUComputePass *" + }, + { + "name": "first_slot", + "type": "Uint32" + }, + { + "name": "storage_buffers", + "type": "SDL_GPUBuffer *const *" + }, + { + "name": "num_bindings", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_DispatchGPUCompute", + "return_type": "void", + "parameters": [ + { + "name": "compute_pass", + "type": "SDL_GPUComputePass *" + }, + { + "name": "groupcount_x", + "type": "Uint32" + }, + { + "name": "groupcount_y", + "type": "Uint32" + }, + { + "name": "groupcount_z", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_DispatchGPUComputeIndirect", + "return_type": "void", + "parameters": [ + { + "name": "compute_pass", + "type": "SDL_GPUComputePass *" + }, + { + "name": "buffer", + "type": "SDL_GPUBuffer *" + }, + { + "name": "offset", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_EndGPUComputePass", + "return_type": "void", + "parameters": [ + { + "name": "compute_pass", + "type": "SDL_GPUComputePass *" + } + ] + }, + { + "name": "SDL_MapGPUTransferBuffer", + "return_type": "void *", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "transfer_buffer", + "type": "SDL_GPUTransferBuffer *" + }, + { + "name": "cycle", + "type": "bool" + } + ] + }, + { + "name": "SDL_UnmapGPUTransferBuffer", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "transfer_buffer", + "type": "SDL_GPUTransferBuffer *" + } + ] + }, + { + "name": "SDL_BeginGPUCopyPass", + "return_type": "SDL_GPUCopyPass *", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + } + ] + }, + { + "name": "SDL_UploadToGPUTexture", + "return_type": "void", + "parameters": [ + { + "name": "copy_pass", + "type": "SDL_GPUCopyPass *" + }, + { + "name": "source", + "type": "const SDL_GPUTextureTransferInfo *" + }, + { + "name": "destination", + "type": "const SDL_GPUTextureRegion *" + }, + { + "name": "cycle", + "type": "bool" + } + ] + }, + { + "name": "SDL_UploadToGPUBuffer", + "return_type": "void", + "parameters": [ + { + "name": "copy_pass", + "type": "SDL_GPUCopyPass *" + }, + { + "name": "source", + "type": "const SDL_GPUTransferBufferLocation *" + }, + { + "name": "destination", + "type": "const SDL_GPUBufferRegion *" + }, + { + "name": "cycle", + "type": "bool" + } + ] + }, + { + "name": "SDL_CopyGPUTextureToTexture", + "return_type": "void", + "parameters": [ + { + "name": "copy_pass", + "type": "SDL_GPUCopyPass *" + }, + { + "name": "source", + "type": "const SDL_GPUTextureLocation *" + }, + { + "name": "destination", + "type": "const SDL_GPUTextureLocation *" + }, + { + "name": "w", + "type": "Uint32" + }, + { + "name": "h", + "type": "Uint32" + }, + { + "name": "d", + "type": "Uint32" + }, + { + "name": "cycle", + "type": "bool" + } + ] + }, + { + "name": "SDL_CopyGPUBufferToBuffer", + "return_type": "void", + "parameters": [ + { + "name": "copy_pass", + "type": "SDL_GPUCopyPass *" + }, + { + "name": "source", + "type": "const SDL_GPUBufferLocation *" + }, + { + "name": "destination", + "type": "const SDL_GPUBufferLocation *" + }, + { + "name": "size", + "type": "Uint32" + }, + { + "name": "cycle", + "type": "bool" + } + ] + }, + { + "name": "SDL_DownloadFromGPUTexture", + "return_type": "void", + "parameters": [ + { + "name": "copy_pass", + "type": "SDL_GPUCopyPass *" + }, + { + "name": "source", + "type": "const SDL_GPUTextureRegion *" + }, + { + "name": "destination", + "type": "const SDL_GPUTextureTransferInfo *" + } + ] + }, + { + "name": "SDL_DownloadFromGPUBuffer", + "return_type": "void", + "parameters": [ + { + "name": "copy_pass", + "type": "SDL_GPUCopyPass *" + }, + { + "name": "source", + "type": "const SDL_GPUBufferRegion *" + }, + { + "name": "destination", + "type": "const SDL_GPUTransferBufferLocation *" + } + ] + }, + { + "name": "SDL_EndGPUCopyPass", + "return_type": "void", + "parameters": [ + { + "name": "copy_pass", + "type": "SDL_GPUCopyPass *" + } + ] + }, + { + "name": "SDL_GenerateMipmapsForGPUTexture", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "texture", + "type": "SDL_GPUTexture *" + } + ] + }, + { + "name": "SDL_BlitGPUTexture", + "return_type": "void", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "info", + "type": "const SDL_GPUBlitInfo *" + } + ] + }, + { + "name": "SDL_WindowSupportsGPUSwapchainComposition", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "swapchain_composition", + "type": "SDL_GPUSwapchainComposition" + } + ] + }, + { + "name": "SDL_WindowSupportsGPUPresentMode", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "present_mode", + "type": "SDL_GPUPresentMode" + } + ] + }, + { + "name": "SDL_ClaimWindowForGPUDevice", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_ReleaseWindowFromGPUDevice", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetGPUSwapchainParameters", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "swapchain_composition", + "type": "SDL_GPUSwapchainComposition" + }, + { + "name": "present_mode", + "type": "SDL_GPUPresentMode" + } + ] + }, + { + "name": "SDL_SetGPUAllowedFramesInFlight", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "allowed_frames_in_flight", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_GetGPUSwapchainTextureFormat", + "return_type": "SDL_GPUTextureFormat", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_AcquireGPUSwapchainTexture", + "return_type": "bool", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "swapchain_texture", + "type": "SDL_GPUTexture **" + }, + { + "name": "swapchain_texture_width", + "type": "Uint32 *" + }, + { + "name": "swapchain_texture_height", + "type": "Uint32 *" + } + ] + }, + { + "name": "SDL_WaitForGPUSwapchain", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_WaitAndAcquireGPUSwapchainTexture", + "return_type": "bool", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + }, + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "swapchain_texture", + "type": "SDL_GPUTexture **" + }, + { + "name": "swapchain_texture_width", + "type": "Uint32 *" + }, + { + "name": "swapchain_texture_height", + "type": "Uint32 *" + } + ] + }, + { + "name": "SDL_SubmitGPUCommandBuffer", + "return_type": "bool", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + } + ] + }, + { + "name": "SDL_SubmitGPUCommandBufferAndAcquireFence", + "return_type": "SDL_GPUFence *", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + } + ] + }, + { + "name": "SDL_CancelGPUCommandBuffer", + "return_type": "bool", + "parameters": [ + { + "name": "command_buffer", + "type": "SDL_GPUCommandBuffer *" + } + ] + }, + { + "name": "SDL_WaitForGPUIdle", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + } + ] + }, + { + "name": "SDL_WaitForGPUFences", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "wait_all", + "type": "bool" + }, + { + "name": "fences", + "type": "SDL_GPUFence *const *" + }, + { + "name": "num_fences", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_QueryGPUFence", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "fence", + "type": "SDL_GPUFence *" + } + ] + }, + { + "name": "SDL_ReleaseGPUFence", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "fence", + "type": "SDL_GPUFence *" + } + ] + }, + { + "name": "SDL_GPUTextureFormatTexelBlockSize", + "return_type": "Uint32", + "parameters": [ + { + "name": "format", + "type": "SDL_GPUTextureFormat" + } + ] + }, + { + "name": "SDL_GPUTextureSupportsFormat", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "format", + "type": "SDL_GPUTextureFormat" + }, + { + "name": "_type", + "type": "SDL_GPUTextureType" + }, + { + "name": "usage", + "type": "SDL_GPUTextureUsageFlags" + } + ] + }, + { + "name": "SDL_GPUTextureSupportsSampleCount", + "return_type": "bool", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + }, + { + "name": "format", + "type": "SDL_GPUTextureFormat" + }, + { + "name": "sample_count", + "type": "SDL_GPUSampleCount" + } + ] + }, + { + "name": "SDL_CalculateGPUTextureFormatSize", + "return_type": "Uint32", + "parameters": [ + { + "name": "format", + "type": "SDL_GPUTextureFormat" + }, + { + "name": "width", + "type": "Uint32" + }, + { + "name": "height", + "type": "Uint32" + }, + { + "name": "depth_or_layer_count", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_GDKSuspendGPU", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + } + ] + }, + { + "name": "SDL_GDKResumeGPU", + "return_type": "void", + "parameters": [ + { + "name": "device", + "type": "SDL_GPUDevice *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/haptic.json b/json/haptic.json new file mode 100644 index 0000000..3d404cc --- /dev/null +++ b/json/haptic.json @@ -0,0 +1,785 @@ +{ + "header": "SDL_haptic.h", + "opaque_types": [ + { + "name": "SDL_Haptic" + } + ], + "typedefs": [ + { + "name": "SDL_HapticID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [], + "enums": [], + "structs": [ + { + "name": "SDL_HapticDirection", + "fields": [ + { + "name": "_type", + "type": "Uint8", + "comment": "The type of encoding." + }, + { + "name": "dir", + "type": "Sint32[3]", + "comment": "The encoded direction." + } + ] + }, + { + "name": "SDL_HapticConstant", + "fields": [ + { + "name": "_type", + "type": "Uint16", + "comment": "SDL_HAPTIC_CONSTANT" + }, + { + "name": "direction", + "type": "SDL_HapticDirection", + "comment": "Direction of the effect." + }, + { + "name": "length", + "type": "Uint32", + "comment": "Duration of the effect." + }, + { + "name": "delay", + "type": "Uint16", + "comment": "Delay before starting the effect." + }, + { + "name": "button", + "type": "Uint16", + "comment": "Button that triggers the effect." + }, + { + "name": "interval", + "type": "Uint16", + "comment": "How soon it can be triggered again after button." + }, + { + "name": "level", + "type": "Sint16", + "comment": "Strength of the constant effect." + }, + { + "name": "attack_length", + "type": "Uint16", + "comment": "Duration of the attack." + }, + { + "name": "attack_level", + "type": "Uint16", + "comment": "Level at the start of the attack." + }, + { + "name": "fade_length", + "type": "Uint16", + "comment": "Duration of the fade." + }, + { + "name": "fade_level", + "type": "Uint16", + "comment": "Level at the end of the fade." + } + ] + }, + { + "name": "SDL_HapticPeriodic", + "fields": [ + { + "name": "direction", + "type": "SDL_HapticDirection", + "comment": "Direction of the effect." + }, + { + "name": "length", + "type": "Uint32", + "comment": "Duration of the effect." + }, + { + "name": "delay", + "type": "Uint16", + "comment": "Delay before starting the effect." + }, + { + "name": "button", + "type": "Uint16", + "comment": "Button that triggers the effect." + }, + { + "name": "interval", + "type": "Uint16", + "comment": "How soon it can be triggered again after button." + }, + { + "name": "period", + "type": "Uint16", + "comment": "Period of the wave." + }, + { + "name": "magnitude", + "type": "Sint16", + "comment": "Peak value; if negative, equivalent to 180 degrees extra phase shift." + }, + { + "name": "offset", + "type": "Sint16", + "comment": "Mean value of the wave." + }, + { + "name": "phase", + "type": "Uint16", + "comment": "Positive phase shift given by hundredth of a degree." + }, + { + "name": "attack_length", + "type": "Uint16", + "comment": "Duration of the attack." + }, + { + "name": "attack_level", + "type": "Uint16", + "comment": "Level at the start of the attack." + }, + { + "name": "fade_length", + "type": "Uint16", + "comment": "Duration of the fade." + }, + { + "name": "fade_level", + "type": "Uint16", + "comment": "Level at the end of the fade." + } + ] + }, + { + "name": "SDL_HapticCondition", + "fields": [ + { + "name": "direction", + "type": "SDL_HapticDirection", + "comment": "Direction of the effect." + }, + { + "name": "length", + "type": "Uint32", + "comment": "Duration of the effect." + }, + { + "name": "delay", + "type": "Uint16", + "comment": "Delay before starting the effect." + }, + { + "name": "button", + "type": "Uint16", + "comment": "Button that triggers the effect." + }, + { + "name": "interval", + "type": "Uint16", + "comment": "How soon it can be triggered again after button." + }, + { + "name": "right_sat", + "type": "Uint16[3]", + "comment": "Level when joystick is to the positive side; max 0xFFFF." + }, + { + "name": "left_sat", + "type": "Uint16[3]", + "comment": "Level when joystick is to the negative side; max 0xFFFF." + }, + { + "name": "right_coeff", + "type": "Sint16[3]", + "comment": "How fast to increase the force towards the positive side." + }, + { + "name": "left_coeff", + "type": "Sint16[3]", + "comment": "How fast to increase the force towards the negative side." + }, + { + "name": "deadband", + "type": "Uint16[3]", + "comment": "Size of the dead zone; max 0xFFFF: whole axis-range when 0-centered." + }, + { + "name": "center", + "type": "Sint16[3]", + "comment": "Position of the dead zone." + } + ] + }, + { + "name": "SDL_HapticRamp", + "fields": [ + { + "name": "_type", + "type": "Uint16", + "comment": "SDL_HAPTIC_RAMP" + }, + { + "name": "direction", + "type": "SDL_HapticDirection", + "comment": "Direction of the effect." + }, + { + "name": "length", + "type": "Uint32", + "comment": "Duration of the effect." + }, + { + "name": "delay", + "type": "Uint16", + "comment": "Delay before starting the effect." + }, + { + "name": "button", + "type": "Uint16", + "comment": "Button that triggers the effect." + }, + { + "name": "interval", + "type": "Uint16", + "comment": "How soon it can be triggered again after button." + }, + { + "name": "start", + "type": "Sint16", + "comment": "Beginning strength level." + }, + { + "name": "end", + "type": "Sint16", + "comment": "Ending strength level." + }, + { + "name": "attack_length", + "type": "Uint16", + "comment": "Duration of the attack." + }, + { + "name": "attack_level", + "type": "Uint16", + "comment": "Level at the start of the attack." + }, + { + "name": "fade_length", + "type": "Uint16", + "comment": "Duration of the fade." + }, + { + "name": "fade_level", + "type": "Uint16", + "comment": "Level at the end of the fade." + } + ] + }, + { + "name": "SDL_HapticLeftRight", + "fields": [ + { + "name": "_type", + "type": "Uint16", + "comment": "SDL_HAPTIC_LEFTRIGHT" + }, + { + "name": "length", + "type": "Uint32", + "comment": "Duration of the effect in milliseconds." + }, + { + "name": "large_magnitude", + "type": "Uint16", + "comment": "Control of the large controller motor." + }, + { + "name": "small_magnitude", + "type": "Uint16", + "comment": "Control of the small controller motor." + } + ] + }, + { + "name": "SDL_HapticCustom", + "fields": [ + { + "name": "_type", + "type": "Uint16", + "comment": "SDL_HAPTIC_CUSTOM" + }, + { + "name": "direction", + "type": "SDL_HapticDirection", + "comment": "Direction of the effect." + }, + { + "name": "length", + "type": "Uint32", + "comment": "Duration of the effect." + }, + { + "name": "delay", + "type": "Uint16", + "comment": "Delay before starting the effect." + }, + { + "name": "button", + "type": "Uint16", + "comment": "Button that triggers the effect." + }, + { + "name": "interval", + "type": "Uint16", + "comment": "How soon it can be triggered again after button." + }, + { + "name": "channels", + "type": "Uint8", + "comment": "Axes to use, minimum of one." + }, + { + "name": "period", + "type": "Uint16", + "comment": "Sample periods." + }, + { + "name": "samples", + "type": "Uint16", + "comment": "Amount of samples." + }, + { + "name": "data", + "type": "Uint16 *", + "comment": "Should contain channels*samples items." + }, + { + "name": "attack_length", + "type": "Uint16", + "comment": "Duration of the attack." + }, + { + "name": "attack_level", + "type": "Uint16", + "comment": "Level at the start of the attack." + }, + { + "name": "fade_length", + "type": "Uint16", + "comment": "Duration of the fade." + }, + { + "name": "fade_level", + "type": "Uint16", + "comment": "Level at the end of the fade." + } + ] + } + ], + "unions": [ + { + "name": "SDL_HapticEffect", + "fields": [ + { + "name": "_type", + "type": "Uint16", + "comment": "Effect type." + }, + { + "name": "constant", + "type": "SDL_HapticConstant", + "comment": "Constant effect." + }, + { + "name": "periodic", + "type": "SDL_HapticPeriodic", + "comment": "Periodic effect." + }, + { + "name": "condition", + "type": "SDL_HapticCondition", + "comment": "Condition effect." + }, + { + "name": "ramp", + "type": "SDL_HapticRamp", + "comment": "Ramp effect." + }, + { + "name": "leftright", + "type": "SDL_HapticLeftRight", + "comment": "Left/Right effect." + }, + { + "name": "custom", + "type": "SDL_HapticCustom", + "comment": "Custom effect." + } + ] + } + ], + "flags": [], + "functions": [ + { + "name": "SDL_GetHaptics", + "return_type": "SDL_HapticID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetHapticNameForID", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_HapticID" + } + ] + }, + { + "name": "SDL_OpenHaptic", + "return_type": "SDL_Haptic *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_HapticID" + } + ] + }, + { + "name": "SDL_GetHapticFromID", + "return_type": "SDL_Haptic *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_HapticID" + } + ] + }, + { + "name": "SDL_GetHapticID", + "return_type": "SDL_HapticID", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_GetHapticName", + "return_type": "const char *", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_IsMouseHaptic", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_OpenHapticFromMouse", + "return_type": "SDL_Haptic *", + "parameters": [] + }, + { + "name": "SDL_IsJoystickHaptic", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_OpenHapticFromJoystick", + "return_type": "SDL_Haptic *", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_CloseHaptic", + "return_type": "void", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_GetMaxHapticEffects", + "return_type": "int", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_GetMaxHapticEffectsPlaying", + "return_type": "int", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_GetHapticFeatures", + "return_type": "Uint32", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_GetNumHapticAxes", + "return_type": "int", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_HapticEffectSupported", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "effect", + "type": "const SDL_HapticEffect *" + } + ] + }, + { + "name": "SDL_CreateHapticEffect", + "return_type": "int", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "effect", + "type": "const SDL_HapticEffect *" + } + ] + }, + { + "name": "SDL_UpdateHapticEffect", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "effect", + "type": "int" + }, + { + "name": "data", + "type": "const SDL_HapticEffect *" + } + ] + }, + { + "name": "SDL_RunHapticEffect", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "effect", + "type": "int" + }, + { + "name": "iterations", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_StopHapticEffect", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "effect", + "type": "int" + } + ] + }, + { + "name": "SDL_DestroyHapticEffect", + "return_type": "void", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "effect", + "type": "int" + } + ] + }, + { + "name": "SDL_GetHapticEffectStatus", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "effect", + "type": "int" + } + ] + }, + { + "name": "SDL_SetHapticGain", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "gain", + "type": "int" + } + ] + }, + { + "name": "SDL_SetHapticAutocenter", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "autocenter", + "type": "int" + } + ] + }, + { + "name": "SDL_PauseHaptic", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_ResumeHaptic", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_StopHapticEffects", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_HapticRumbleSupported", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_InitHapticRumble", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + }, + { + "name": "SDL_PlayHapticRumble", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + }, + { + "name": "strength", + "type": "float" + }, + { + "name": "length", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_StopHapticRumble", + "return_type": "bool", + "parameters": [ + { + "name": "haptic", + "type": "SDL_Haptic *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/hints.json b/json/hints.json new file mode 100644 index 0000000..8cbe45d --- /dev/null +++ b/json/hints.json @@ -0,0 +1,157 @@ +{ + "header": "SDL_hints.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [ + { + "name": "SDL_HintCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "oldValue", + "type": "const char *" + }, + { + "name": "newValue", + "type": "const char *" + } + ] + } + ], + "enums": [ + { + "name": "SDL_HintPriority", + "values": [ + { + "name": "SDL_HINT_DEFAULT" + }, + { + "name": "SDL_HINT_NORMAL" + }, + { + "name": "SDL_HINT_OVERRIDE" + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_SetHintWithPriority", + "return_type": "bool", + "parameters": [ + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "const char *" + }, + { + "name": "priority", + "type": "SDL_HintPriority" + } + ] + }, + { + "name": "SDL_SetHint", + "return_type": "bool", + "parameters": [ + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "const char *" + } + ] + }, + { + "name": "SDL_ResetHint", + "return_type": "bool", + "parameters": [ + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_ResetHints", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_GetHint", + "return_type": "const char *", + "parameters": [ + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetHintBoolean", + "return_type": "bool", + "parameters": [ + { + "name": "name", + "type": "const char *" + }, + { + "name": "default_value", + "type": "bool" + } + ] + }, + { + "name": "SDL_AddHintCallback", + "return_type": "bool", + "parameters": [ + { + "name": "name", + "type": "const char *" + }, + { + "name": "callback", + "type": "SDL_HintCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_RemoveHintCallback", + "return_type": "void", + "parameters": [ + { + "name": "name", + "type": "const char *" + }, + { + "name": "callback", + "type": "SDL_HintCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/init.json b/json/init.json new file mode 100644 index 0000000..77e0a81 --- /dev/null +++ b/json/init.json @@ -0,0 +1,252 @@ +{ + "header": "SDL_init.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [ + { + "name": "SDL_AppInit_func", + "return_type": "SDL_AppResult", + "parameters": [ + { + "name": "appstate", + "type": "void **" + }, + { + "name": "argc", + "type": "int" + }, + { + "name": "argv", + "type": "char **" + } + ] + }, + { + "name": "SDL_AppIterate_func", + "return_type": "SDL_AppResult", + "parameters": [ + { + "name": "appstate", + "type": "void *" + } + ] + }, + { + "name": "SDL_AppEvent_func", + "return_type": "SDL_AppResult", + "parameters": [ + { + "name": "appstate", + "type": "void *" + }, + { + "name": "event", + "type": "SDL_Event *" + } + ] + }, + { + "name": "SDL_AppQuit_func", + "return_type": "void", + "parameters": [ + { + "name": "appstate", + "type": "void *" + }, + { + "name": "result", + "type": "SDL_AppResult" + } + ] + }, + { + "name": "SDL_MainThreadCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + } + ] + } + ], + "enums": [ + { + "name": "SDL_AppResult", + "values": [ + { + "name": "SDL_APP_CONTINUE", + "comment": "Value that requests that the app continue from the main callbacks." + }, + { + "name": "SDL_APP_SUCCESS", + "comment": "Value that requests termination with success from the main callbacks." + }, + { + "name": "SDL_APP_FAILURE", + "comment": "Value that requests termination with error from the main callbacks." + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [ + { + "name": "SDL_InitFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_INIT_AUDIO", + "value": "0x00000010u", + "comment": "`SDL_INIT_AUDIO` implies `SDL_INIT_EVENTS`" + }, + { + "name": "SDL_INIT_VIDEO", + "value": "0x00000020u", + "comment": "`SDL_INIT_VIDEO` implies `SDL_INIT_EVENTS`, should be initialized on the main thread" + }, + { + "name": "SDL_INIT_JOYSTICK", + "value": "0x00000200u", + "comment": "`SDL_INIT_JOYSTICK` implies `SDL_INIT_EVENTS`, should be initialized on the same thread as SDL_INIT_VIDEO on Windows if you don't set SDL_HINT_JOYSTICK_THREAD" + }, + { + "name": "SDL_INIT_HAPTIC", + "value": "0x00001000u" + }, + { + "name": "SDL_INIT_GAMEPAD", + "value": "0x00002000u", + "comment": "`SDL_INIT_GAMEPAD` implies `SDL_INIT_JOYSTICK`" + }, + { + "name": "SDL_INIT_EVENTS", + "value": "0x00004000u" + }, + { + "name": "SDL_INIT_SENSOR", + "value": "0x00008000u", + "comment": "`SDL_INIT_SENSOR` implies `SDL_INIT_EVENTS`" + }, + { + "name": "SDL_INIT_CAMERA", + "value": "0x00010000u", + "comment": "`SDL_INIT_CAMERA` implies `SDL_INIT_EVENTS`" + } + ] + } + ], + "functions": [ + { + "name": "SDL_Init", + "return_type": "bool", + "parameters": [ + { + "name": "flags", + "type": "SDL_InitFlags" + } + ] + }, + { + "name": "SDL_InitSubSystem", + "return_type": "bool", + "parameters": [ + { + "name": "flags", + "type": "SDL_InitFlags" + } + ] + }, + { + "name": "SDL_QuitSubSystem", + "return_type": "void", + "parameters": [ + { + "name": "flags", + "type": "SDL_InitFlags" + } + ] + }, + { + "name": "SDL_WasInit", + "return_type": "SDL_InitFlags", + "parameters": [ + { + "name": "flags", + "type": "SDL_InitFlags" + } + ] + }, + { + "name": "SDL_Quit", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_IsMainThread", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_RunOnMainThread", + "return_type": "bool", + "parameters": [ + { + "name": "callback", + "type": "SDL_MainThreadCallback" + }, + { + "name": "userdata", + "type": "void *" + }, + { + "name": "wait_complete", + "type": "bool" + } + ] + }, + { + "name": "SDL_SetAppMetadata", + "return_type": "bool", + "parameters": [ + { + "name": "appname", + "type": "const char *" + }, + { + "name": "appversion", + "type": "const char *" + }, + { + "name": "appidentifier", + "type": "const char *" + } + ] + }, + { + "name": "SDL_SetAppMetadataProperty", + "return_type": "bool", + "parameters": [ + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetAppMetadataProperty", + "return_type": "const char *", + "parameters": [ + { + "name": "name", + "type": "const char *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/joystick.json b/json/joystick.json new file mode 100644 index 0000000..0182800 --- /dev/null +++ b/json/joystick.json @@ -0,0 +1,960 @@ +{ + "header": "SDL_joystick.h", + "opaque_types": [ + { + "name": "SDL_Joystick" + } + ], + "typedefs": [ + { + "name": "SDL_JoystickID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [], + "enums": [ + { + "name": "SDL_JoystickType", + "values": [ + { + "name": "SDL_JOYSTICK_TYPE_UNKNOWN" + }, + { + "name": "SDL_JOYSTICK_TYPE_GAMEPAD" + }, + { + "name": "SDL_JOYSTICK_TYPE_WHEEL" + }, + { + "name": "SDL_JOYSTICK_TYPE_ARCADE_STICK" + }, + { + "name": "SDL_JOYSTICK_TYPE_FLIGHT_STICK" + }, + { + "name": "SDL_JOYSTICK_TYPE_DANCE_PAD" + }, + { + "name": "SDL_JOYSTICK_TYPE_GUITAR" + }, + { + "name": "SDL_JOYSTICK_TYPE_DRUM_KIT" + }, + { + "name": "SDL_JOYSTICK_TYPE_ARCADE_PAD" + }, + { + "name": "SDL_JOYSTICK_TYPE_THROTTLE" + }, + { + "name": "SDL_JOYSTICK_TYPE_COUNT" + } + ] + }, + { + "name": "SDL_JoystickConnectionState", + "values": [ + { + "name": "SDL_JOYSTICK_CONNECTION_UNKNOWN" + }, + { + "name": "SDL_JOYSTICK_CONNECTION_WIRED" + }, + { + "name": "SDL_JOYSTICK_CONNECTION_WIRELESS" + } + ] + } + ], + "structs": [ + { + "name": "SDL_VirtualJoystickTouchpadDesc", + "fields": [ + { + "name": "nfingers", + "type": "Uint16", + "comment": "the number of simultaneous fingers on this touchpad" + }, + { + "name": "padding", + "type": "Uint16[3]" + } + ] + }, + { + "name": "SDL_VirtualJoystickSensorDesc", + "fields": [ + { + "name": "_type", + "type": "SDL_SensorType", + "comment": "the type of this sensor" + }, + { + "name": "rate", + "type": "float", + "comment": "the update frequency of this sensor, may be 0.0f" + } + ] + }, + { + "name": "SDL_VirtualJoystickDesc", + "fields": [ + { + "name": "version", + "type": "Uint32", + "comment": "the version of this interface" + }, + { + "name": "_type", + "type": "Uint16", + "comment": "`SDL_JoystickType`" + }, + { + "name": "padding", + "type": "Uint16", + "comment": "unused" + }, + { + "name": "vendor_id", + "type": "Uint16", + "comment": "the USB vendor ID of this joystick" + }, + { + "name": "product_id", + "type": "Uint16", + "comment": "the USB product ID of this joystick" + }, + { + "name": "naxes", + "type": "Uint16", + "comment": "the number of axes on this joystick" + }, + { + "name": "nbuttons", + "type": "Uint16", + "comment": "the number of buttons on this joystick" + }, + { + "name": "nballs", + "type": "Uint16", + "comment": "the number of balls on this joystick" + }, + { + "name": "nhats", + "type": "Uint16", + "comment": "the number of hats on this joystick" + }, + { + "name": "ntouchpads", + "type": "Uint16", + "comment": "the number of touchpads on this joystick, requires `touchpads` to point at valid descriptions" + }, + { + "name": "nsensors", + "type": "Uint16", + "comment": "the number of sensors on this joystick, requires `sensors` to point at valid descriptions" + }, + { + "name": "padding2", + "type": "Uint16[2]", + "comment": "unused" + }, + { + "name": "name", + "type": "const char *", + "comment": "the name of the joystick" + }, + { + "name": "touchpads", + "type": "const SDL_VirtualJoystickTouchpadDesc *", + "comment": "A pointer to an array of touchpad descriptions, required if `ntouchpads` is > 0" + }, + { + "name": "sensors", + "type": "const SDL_VirtualJoystickSensorDesc *", + "comment": "A pointer to an array of sensor descriptions, required if `nsensors` is > 0" + }, + { + "name": "userdata", + "type": "void *", + "comment": "User data pointer passed to callbacks" + }, + { + "name": "Update", + "type": "void (SDLCALL *Update)(void *userdata)", + "comment": "Called when the joystick state should be updated" + }, + { + "name": "SetPlayerIndex", + "type": "void (SDLCALL *SetPlayerIndex)(void *userdata, int player_index)", + "comment": "Called when the player index is set" + }, + { + "name": "Rumble", + "type": "bool (SDLCALL *Rumble)(void *userdata, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)", + "comment": "Implements SDL_RumbleJoystick()" + }, + { + "name": "RumbleTriggers", + "type": "bool (SDLCALL *RumbleTriggers)(void *userdata, Uint16 left_rumble, Uint16 right_rumble)", + "comment": "Implements SDL_RumbleJoystickTriggers()" + }, + { + "name": "SetLED", + "type": "bool (SDLCALL *SetLED)(void *userdata, Uint8 red, Uint8 green, Uint8 blue)", + "comment": "Implements SDL_SetJoystickLED()" + }, + { + "name": "SendEffect", + "type": "bool (SDLCALL *SendEffect)(void *userdata, const void *data, int size)", + "comment": "Implements SDL_SendJoystickEffect()" + }, + { + "name": "SetSensorsEnabled", + "type": "bool (SDLCALL *SetSensorsEnabled)(void *userdata, bool enabled)", + "comment": "Implements SDL_SetGamepadSensorEnabled()" + }, + { + "name": "Cleanup", + "type": "void (SDLCALL *Cleanup)(void *userdata)", + "comment": "Cleans up the userdata when the joystick is detached" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_LockJoysticks", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_UnlockJoysticks", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_HasJoystick", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetJoysticks", + "return_type": "SDL_JoystickID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetJoystickNameForID", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickPathForID", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickPlayerIndexForID", + "return_type": "int", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickGUIDForID", + "return_type": "SDL_GUID", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickVendorForID", + "return_type": "Uint16", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickProductForID", + "return_type": "Uint16", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickProductVersionForID", + "return_type": "Uint16", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickTypeForID", + "return_type": "SDL_JoystickType", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_OpenJoystick", + "return_type": "SDL_Joystick *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickFromID", + "return_type": "SDL_Joystick *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_GetJoystickFromPlayerIndex", + "return_type": "SDL_Joystick *", + "parameters": [ + { + "name": "player_index", + "type": "int" + } + ] + }, + { + "name": "SDL_AttachVirtualJoystick", + "return_type": "SDL_JoystickID", + "parameters": [ + { + "name": "desc", + "type": "const SDL_VirtualJoystickDesc *" + } + ] + }, + { + "name": "SDL_DetachVirtualJoystick", + "return_type": "bool", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_IsJoystickVirtual", + "return_type": "bool", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_JoystickID" + } + ] + }, + { + "name": "SDL_SetJoystickVirtualAxis", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "axis", + "type": "int" + }, + { + "name": "value", + "type": "Sint16" + } + ] + }, + { + "name": "SDL_SetJoystickVirtualBall", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "ball", + "type": "int" + }, + { + "name": "xrel", + "type": "Sint16" + }, + { + "name": "yrel", + "type": "Sint16" + } + ] + }, + { + "name": "SDL_SetJoystickVirtualButton", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "button", + "type": "int" + }, + { + "name": "down", + "type": "bool" + } + ] + }, + { + "name": "SDL_SetJoystickVirtualHat", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "hat", + "type": "int" + }, + { + "name": "value", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_SetJoystickVirtualTouchpad", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "touchpad", + "type": "int" + }, + { + "name": "finger", + "type": "int" + }, + { + "name": "down", + "type": "bool" + }, + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + }, + { + "name": "pressure", + "type": "float" + } + ] + }, + { + "name": "SDL_SendJoystickVirtualSensorData", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "_type", + "type": "SDL_SensorType" + }, + { + "name": "sensor_timestamp", + "type": "Uint64" + }, + { + "name": "data", + "type": "const float *" + }, + { + "name": "num_values", + "type": "int" + } + ] + }, + { + "name": "SDL_GetJoystickProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickName", + "return_type": "const char *", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickPath", + "return_type": "const char *", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickPlayerIndex", + "return_type": "int", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_SetJoystickPlayerIndex", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "player_index", + "type": "int" + } + ] + }, + { + "name": "SDL_GetJoystickGUID", + "return_type": "SDL_GUID", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickVendor", + "return_type": "Uint16", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickProduct", + "return_type": "Uint16", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickProductVersion", + "return_type": "Uint16", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickFirmwareVersion", + "return_type": "Uint16", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickSerial", + "return_type": "const char *", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickType", + "return_type": "SDL_JoystickType", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickGUIDInfo", + "return_type": "void", + "parameters": [ + { + "name": "guid", + "type": "SDL_GUID" + }, + { + "name": "vendor", + "type": "Uint16 *" + }, + { + "name": "product", + "type": "Uint16 *" + }, + { + "name": "version", + "type": "Uint16 *" + }, + { + "name": "crc16", + "type": "Uint16 *" + } + ] + }, + { + "name": "SDL_JoystickConnected", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickID", + "return_type": "SDL_JoystickID", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetNumJoystickAxes", + "return_type": "int", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetNumJoystickBalls", + "return_type": "int", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetNumJoystickHats", + "return_type": "int", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetNumJoystickButtons", + "return_type": "int", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_SetJoystickEventsEnabled", + "return_type": "void", + "parameters": [ + { + "name": "enabled", + "type": "bool" + } + ] + }, + { + "name": "SDL_JoystickEventsEnabled", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_UpdateJoysticks", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_GetJoystickAxis", + "return_type": "Sint16", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "axis", + "type": "int" + } + ] + }, + { + "name": "SDL_GetJoystickAxisInitialState", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "axis", + "type": "int" + }, + { + "name": "state", + "type": "Sint16 *" + } + ] + }, + { + "name": "SDL_GetJoystickBall", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "ball", + "type": "int" + }, + { + "name": "dx", + "type": "int *" + }, + { + "name": "dy", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetJoystickHat", + "return_type": "Uint8", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "hat", + "type": "int" + } + ] + }, + { + "name": "SDL_GetJoystickButton", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "button", + "type": "int" + } + ] + }, + { + "name": "SDL_RumbleJoystick", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "low_frequency_rumble", + "type": "Uint16" + }, + { + "name": "high_frequency_rumble", + "type": "Uint16" + }, + { + "name": "duration_ms", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_RumbleJoystickTriggers", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "left_rumble", + "type": "Uint16" + }, + { + "name": "right_rumble", + "type": "Uint16" + }, + { + "name": "duration_ms", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_SetJoystickLED", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "red", + "type": "Uint8" + }, + { + "name": "green", + "type": "Uint8" + }, + { + "name": "blue", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_SendJoystickEffect", + "return_type": "bool", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "data", + "type": "const void *" + }, + { + "name": "size", + "type": "int" + } + ] + }, + { + "name": "SDL_CloseJoystick", + "return_type": "void", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickConnectionState", + "return_type": "SDL_JoystickConnectionState", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + } + ] + }, + { + "name": "SDL_GetJoystickPowerInfo", + "return_type": "SDL_PowerState", + "parameters": [ + { + "name": "joystick", + "type": "SDL_Joystick *" + }, + { + "name": "percent", + "type": "int *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/keycode.json b/json/keycode.json new file mode 100644 index 0000000..0be6af3 --- /dev/null +++ b/json/keycode.json @@ -0,0 +1,20 @@ +{ + "header": "SDL_keycode.h", + "opaque_types": [], + "typedefs": [ + { + "name": "SDL_Keycode", + "underlying_type": "Uint32" + }, + { + "name": "SDL_Keymod", + "underlying_type": "Uint16" + } + ], + "function_pointers": [], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [] +} \ No newline at end of file diff --git a/json/loadso.json b/json/loadso.json new file mode 100644 index 0000000..a8d639e --- /dev/null +++ b/json/loadso.json @@ -0,0 +1,50 @@ +{ + "header": "SDL_loadso.h", + "opaque_types": [ + { + "name": "SDL_SharedObject" + } + ], + "typedefs": [], + "function_pointers": [], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_LoadObject", + "return_type": "SDL_SharedObject *", + "parameters": [ + { + "name": "sofile", + "type": "const char *" + } + ] + }, + { + "name": "SDL_LoadFunction", + "return_type": "SDL_FunctionPointer", + "parameters": [ + { + "name": "handle", + "type": "SDL_SharedObject *" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_UnloadObject", + "return_type": "void", + "parameters": [ + { + "name": "handle", + "type": "SDL_SharedObject *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/messagebox.json b/json/messagebox.json new file mode 100644 index 0000000..11650cd --- /dev/null +++ b/json/messagebox.json @@ -0,0 +1,204 @@ +{ + "header": "SDL_messagebox.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [ + { + "name": "SDL_MessageBoxColorType", + "values": [ + { + "name": "SDL_MESSAGEBOX_COLOR_BACKGROUND" + }, + { + "name": "SDL_MESSAGEBOX_COLOR_TEXT" + }, + { + "name": "SDL_MESSAGEBOX_COLOR_BUTTON_BORDER" + }, + { + "name": "SDL_MESSAGEBOX_COLOR_BUTTON_BACKGROUND" + }, + { + "name": "SDL_MESSAGEBOX_COLOR_BUTTON_SELECTED" + }, + { + "name": "SDL_MESSAGEBOX_COLOR_COUNT", + "comment": "Size of the colors array of SDL_MessageBoxColorScheme." + } + ] + } + ], + "structs": [ + { + "name": "SDL_MessageBoxButtonData", + "fields": [ + { + "name": "flags", + "type": "SDL_MessageBoxButtonFlags" + }, + { + "name": "buttonID", + "type": "int", + "comment": "User defined button id (value returned via SDL_ShowMessageBox)" + }, + { + "name": "text", + "type": "const char *", + "comment": "The UTF-8 button text" + } + ] + }, + { + "name": "SDL_MessageBoxColor", + "fields": [ + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_MessageBoxColorScheme", + "fields": [ + { + "name": "colors", + "type": "SDL_MessageBoxColor[SDL_MESSAGEBOX_COLOR_COUNT]" + } + ] + }, + { + "name": "SDL_MessageBoxData", + "fields": [ + { + "name": "flags", + "type": "SDL_MessageBoxFlags" + }, + { + "name": "window", + "type": "SDL_Window *", + "comment": "Parent window, can be NULL" + }, + { + "name": "title", + "type": "const char *", + "comment": "UTF-8 title" + }, + { + "name": "message", + "type": "const char *", + "comment": "UTF-8 message text" + }, + { + "name": "numbuttons", + "type": "int" + }, + { + "name": "buttons", + "type": "const SDL_MessageBoxButtonData *" + }, + { + "name": "colorScheme", + "type": "const SDL_MessageBoxColorScheme *", + "comment": "SDL_MessageBoxColorScheme, can be NULL to use system settings" + } + ] + } + ], + "unions": [], + "flags": [ + { + "name": "SDL_MessageBoxFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_MESSAGEBOX_ERROR", + "value": "0x00000010u", + "comment": "error dialog" + }, + { + "name": "SDL_MESSAGEBOX_WARNING", + "value": "0x00000020u", + "comment": "warning dialog" + }, + { + "name": "SDL_MESSAGEBOX_INFORMATION", + "value": "0x00000040u", + "comment": "informational dialog" + }, + { + "name": "SDL_MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT", + "value": "0x00000080u", + "comment": "buttons placed left to right" + }, + { + "name": "SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT", + "value": "0x00000100u", + "comment": "buttons placed right to left" + } + ] + }, + { + "name": "SDL_MessageBoxButtonFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT", + "value": "0x00000001u", + "comment": "Marks the default button when return is hit" + }, + { + "name": "SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT", + "value": "0x00000002u", + "comment": "Marks the default button when escape is hit" + } + ] + } + ], + "functions": [ + { + "name": "SDL_ShowMessageBox", + "return_type": "bool", + "parameters": [ + { + "name": "messageboxdata", + "type": "const SDL_MessageBoxData *" + }, + { + "name": "buttonid", + "type": "int *" + } + ] + }, + { + "name": "SDL_ShowSimpleMessageBox", + "return_type": "bool", + "parameters": [ + { + "name": "flags", + "type": "SDL_MessageBoxFlags" + }, + { + "name": "title", + "type": "const char *" + }, + { + "name": "message", + "type": "const char *" + }, + { + "name": "window", + "type": "SDL_Window *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/misc.json b/json/misc.json new file mode 100644 index 0000000..0af9d7b --- /dev/null +++ b/json/misc.json @@ -0,0 +1,22 @@ +{ + "header": "SDL_misc.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_OpenURL", + "return_type": "bool", + "parameters": [ + { + "name": "url", + "type": "const char *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/mouse.json b/json/mouse.json new file mode 100644 index 0000000..d6633ac --- /dev/null +++ b/json/mouse.json @@ -0,0 +1,391 @@ +{ + "header": "SDL_mouse.h", + "opaque_types": [ + { + "name": "SDL_Cursor" + } + ], + "typedefs": [ + { + "name": "SDL_MouseID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [], + "enums": [ + { + "name": "SDL_SystemCursor", + "values": [ + { + "name": "SDL_SYSTEM_CURSOR_DEFAULT", + "comment": "Default cursor. Usually an arrow." + }, + { + "name": "SDL_SYSTEM_CURSOR_TEXT", + "comment": "Text selection. Usually an I-beam." + }, + { + "name": "SDL_SYSTEM_CURSOR_WAIT", + "comment": "Wait. Usually an hourglass or watch or spinning ball." + }, + { + "name": "SDL_SYSTEM_CURSOR_CROSSHAIR", + "comment": "Crosshair." + }, + { + "name": "SDL_SYSTEM_CURSOR_PROGRESS", + "comment": "Program is busy but still interactive. Usually it's WAIT with an arrow." + }, + { + "name": "SDL_SYSTEM_CURSOR_NWSE_RESIZE", + "comment": "Double arrow pointing northwest and southeast." + }, + { + "name": "SDL_SYSTEM_CURSOR_NESW_RESIZE", + "comment": "Double arrow pointing northeast and southwest." + }, + { + "name": "SDL_SYSTEM_CURSOR_EW_RESIZE", + "comment": "Double arrow pointing west and east." + }, + { + "name": "SDL_SYSTEM_CURSOR_NS_RESIZE", + "comment": "Double arrow pointing north and south." + }, + { + "name": "SDL_SYSTEM_CURSOR_MOVE", + "comment": "Four pointed arrow pointing north, south, east, and west." + }, + { + "name": "SDL_SYSTEM_CURSOR_NOT_ALLOWED", + "comment": "Not permitted. Usually a slashed circle or crossbones." + }, + { + "name": "SDL_SYSTEM_CURSOR_POINTER", + "comment": "Pointer that indicates a link. Usually a pointing hand." + }, + { + "name": "SDL_SYSTEM_CURSOR_NW_RESIZE", + "comment": "Window resize top-left. This may be a single arrow or a double arrow like NWSE_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_N_RESIZE", + "comment": "Window resize top. May be NS_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_NE_RESIZE", + "comment": "Window resize top-right. May be NESW_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_E_RESIZE", + "comment": "Window resize right. May be EW_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_SE_RESIZE", + "comment": "Window resize bottom-right. May be NWSE_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_S_RESIZE", + "comment": "Window resize bottom. May be NS_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_SW_RESIZE", + "comment": "Window resize bottom-left. May be NESW_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_W_RESIZE", + "comment": "Window resize left. May be EW_RESIZE." + }, + { + "name": "SDL_SYSTEM_CURSOR_COUNT" + } + ] + }, + { + "name": "SDL_MouseWheelDirection", + "values": [ + { + "name": "SDL_MOUSEWHEEL_NORMAL", + "comment": "The scroll direction is normal" + }, + { + "name": "SDL_MOUSEWHEEL_FLIPPED", + "comment": "The scroll direction is flipped / natural" + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [ + { + "name": "SDL_MouseButtonFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_BUTTON_LEFT", + "value": "1" + }, + { + "name": "SDL_BUTTON_MIDDLE", + "value": "2" + }, + { + "name": "SDL_BUTTON_RIGHT", + "value": "3" + }, + { + "name": "SDL_BUTTON_X1", + "value": "4" + }, + { + "name": "SDL_BUTTON_X2", + "value": "5" + } + ] + } + ], + "functions": [ + { + "name": "SDL_HasMouse", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetMice", + "return_type": "SDL_MouseID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetMouseNameForID", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_MouseID" + } + ] + }, + { + "name": "SDL_GetMouseFocus", + "return_type": "SDL_Window *", + "parameters": [] + }, + { + "name": "SDL_GetMouseState", + "return_type": "SDL_MouseButtonFlags", + "parameters": [ + { + "name": "x", + "type": "float *" + }, + { + "name": "y", + "type": "float *" + } + ] + }, + { + "name": "SDL_GetGlobalMouseState", + "return_type": "SDL_MouseButtonFlags", + "parameters": [ + { + "name": "x", + "type": "float *" + }, + { + "name": "y", + "type": "float *" + } + ] + }, + { + "name": "SDL_GetRelativeMouseState", + "return_type": "SDL_MouseButtonFlags", + "parameters": [ + { + "name": "x", + "type": "float *" + }, + { + "name": "y", + "type": "float *" + } + ] + }, + { + "name": "SDL_WarpMouseInWindow", + "return_type": "void", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + } + ] + }, + { + "name": "SDL_WarpMouseGlobal", + "return_type": "bool", + "parameters": [ + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + } + ] + }, + { + "name": "SDL_SetWindowRelativeMouseMode", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "enabled", + "type": "bool" + } + ] + }, + { + "name": "SDL_GetWindowRelativeMouseMode", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_CaptureMouse", + "return_type": "bool", + "parameters": [ + { + "name": "enabled", + "type": "bool" + } + ] + }, + { + "name": "SDL_CreateCursor", + "return_type": "SDL_Cursor *", + "parameters": [ + { + "name": "data", + "type": "const Uint8 *" + }, + { + "name": "mask", + "type": "const Uint8 *" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + }, + { + "name": "hot_x", + "type": "int" + }, + { + "name": "hot_y", + "type": "int" + } + ] + }, + { + "name": "SDL_CreateColorCursor", + "return_type": "SDL_Cursor *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "hot_x", + "type": "int" + }, + { + "name": "hot_y", + "type": "int" + } + ] + }, + { + "name": "SDL_CreateSystemCursor", + "return_type": "SDL_Cursor *", + "parameters": [ + { + "name": "id", + "type": "SDL_SystemCursor" + } + ] + }, + { + "name": "SDL_SetCursor", + "return_type": "bool", + "parameters": [ + { + "name": "cursor", + "type": "SDL_Cursor *" + } + ] + }, + { + "name": "SDL_GetCursor", + "return_type": "SDL_Cursor *", + "parameters": [] + }, + { + "name": "SDL_GetDefaultCursor", + "return_type": "SDL_Cursor *", + "parameters": [] + }, + { + "name": "SDL_DestroyCursor", + "return_type": "void", + "parameters": [ + { + "name": "cursor", + "type": "SDL_Cursor *" + } + ] + }, + { + "name": "SDL_ShowCursor", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_HideCursor", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_CursorVisible", + "return_type": "bool", + "parameters": [] + } + ] +} \ No newline at end of file diff --git a/json/pixels.json b/json/pixels.json new file mode 100644 index 0000000..fcc710e --- /dev/null +++ b/json/pixels.json @@ -0,0 +1,920 @@ +{ + "header": "SDL_pixels.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [ + { + "name": "SDL_PixelType", + "values": [ + { + "name": "SDL_PIXELTYPE_UNKNOWN" + }, + { + "name": "SDL_PIXELTYPE_INDEX1" + }, + { + "name": "SDL_PIXELTYPE_INDEX4" + }, + { + "name": "SDL_PIXELTYPE_INDEX8" + }, + { + "name": "SDL_PIXELTYPE_PACKED8" + }, + { + "name": "SDL_PIXELTYPE_PACKED16" + }, + { + "name": "SDL_PIXELTYPE_PACKED32" + }, + { + "name": "SDL_PIXELTYPE_ARRAYU8" + }, + { + "name": "SDL_PIXELTYPE_ARRAYU16" + }, + { + "name": "SDL_PIXELTYPE_ARRAYU32" + }, + { + "name": "SDL_PIXELTYPE_ARRAYF16" + }, + { + "name": "SDL_PIXELTYPE_ARRAYF32" + }, + { + "name": "SDL_PIXELTYPE_INDEX2" + } + ] + }, + { + "name": "SDL_BitmapOrder", + "values": [ + { + "name": "SDL_BITMAPORDER_NONE" + }, + { + "name": "SDL_BITMAPORDER_4321" + }, + { + "name": "SDL_BITMAPORDER_1234" + } + ] + }, + { + "name": "SDL_PackedOrder", + "values": [ + { + "name": "SDL_PACKEDORDER_NONE" + }, + { + "name": "SDL_PACKEDORDER_XRGB" + }, + { + "name": "SDL_PACKEDORDER_RGBX" + }, + { + "name": "SDL_PACKEDORDER_ARGB" + }, + { + "name": "SDL_PACKEDORDER_RGBA" + }, + { + "name": "SDL_PACKEDORDER_XBGR" + }, + { + "name": "SDL_PACKEDORDER_BGRX" + }, + { + "name": "SDL_PACKEDORDER_ABGR" + }, + { + "name": "SDL_PACKEDORDER_BGRA" + } + ] + }, + { + "name": "SDL_ArrayOrder", + "values": [ + { + "name": "SDL_ARRAYORDER_NONE" + }, + { + "name": "SDL_ARRAYORDER_RGB" + }, + { + "name": "SDL_ARRAYORDER_RGBA" + }, + { + "name": "SDL_ARRAYORDER_ARGB" + }, + { + "name": "SDL_ARRAYORDER_BGR" + }, + { + "name": "SDL_ARRAYORDER_BGRA" + }, + { + "name": "SDL_ARRAYORDER_ABGR" + } + ] + }, + { + "name": "SDL_PackedLayout", + "values": [ + { + "name": "SDL_PACKEDLAYOUT_NONE" + }, + { + "name": "SDL_PACKEDLAYOUT_332" + }, + { + "name": "SDL_PACKEDLAYOUT_4444" + }, + { + "name": "SDL_PACKEDLAYOUT_1555" + }, + { + "name": "SDL_PACKEDLAYOUT_5551" + }, + { + "name": "SDL_PACKEDLAYOUT_565" + }, + { + "name": "SDL_PACKEDLAYOUT_8888" + }, + { + "name": "SDL_PACKEDLAYOUT_2101010" + }, + { + "name": "SDL_PACKEDLAYOUT_1010102" + } + ] + }, + { + "name": "SDL_PixelFormat", + "values": [ + { + "name": "SDL_PIXELFORMAT_YV12", + "value": "0x32315659u", + "comment": "Planar mode: Y + V + U (3 planes)" + }, + { + "name": "SDL_PIXELFORMAT_IYUV", + "value": "0x56555949u", + "comment": "Planar mode: Y + U + V (3 planes)" + }, + { + "name": "SDL_PIXELFORMAT_YUY2", + "value": "0x32595559u", + "comment": "Packed mode: Y0+U0+Y1+V0 (1 plane)" + }, + { + "name": "SDL_PIXELFORMAT_UYVY", + "value": "0x59565955u", + "comment": "Packed mode: U0+Y0+V0+Y1 (1 plane)" + }, + { + "name": "SDL_PIXELFORMAT_YVYU", + "value": "0x55595659u", + "comment": "Packed mode: Y0+V0+Y1+U0 (1 plane)" + }, + { + "name": "SDL_PIXELFORMAT_NV12", + "value": "0x3231564eu", + "comment": "Planar mode: Y + U/V interleaved (2 planes)" + }, + { + "name": "SDL_PIXELFORMAT_NV21", + "value": "0x3132564eu", + "comment": "Planar mode: Y + V/U interleaved (2 planes)" + }, + { + "name": "SDL_PIXELFORMAT_P010", + "value": "0x30313050u", + "comment": "Planar mode: Y + U/V interleaved (2 planes)" + }, + { + "name": "SDL_PIXELFORMAT_EXTERNAL_OES", + "value": "0x2053454fu", + "comment": "Android video texture format" + }, + { + "name": "SDL_PIXELFORMAT_MJPG", + "value": "0x47504a4du", + "comment": "Motion JPEG" + } + ] + }, + { + "name": "SDL_ColorType", + "values": [] + }, + { + "name": "SDL_ColorRange", + "values": [ + { + "name": "SDL_COLOR_RANGE_LIMITED", + "value": "1", + "comment": "Narrow range, e.g. 16-235 for 8-bit RGB and luma, and 16-240 for 8-bit chroma" + }, + { + "name": "SDL_COLOR_RANGE_FULL", + "value": "2" + } + ] + }, + { + "name": "SDL_ColorPrimaries", + "values": [ + { + "name": "SDL_COLOR_PRIMARIES_BT709", + "value": "1", + "comment": "ITU-R BT.709-6" + }, + { + "name": "SDL_COLOR_PRIMARIES_BT470M", + "value": "4", + "comment": "ITU-R BT.470-6 System M" + }, + { + "name": "SDL_COLOR_PRIMARIES_BT470BG", + "value": "5", + "comment": "ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625" + }, + { + "name": "SDL_COLOR_PRIMARIES_BT601", + "value": "6", + "comment": "ITU-R BT.601-7 525, SMPTE 170M" + }, + { + "name": "SDL_COLOR_PRIMARIES_SMPTE240", + "value": "7", + "comment": "SMPTE 240M, functionally the same as SDL_COLOR_PRIMARIES_BT601" + }, + { + "name": "SDL_COLOR_PRIMARIES_GENERIC_FILM", + "value": "8", + "comment": "Generic film (color filters using Illuminant C)" + }, + { + "name": "SDL_COLOR_PRIMARIES_BT2020", + "value": "9", + "comment": "ITU-R BT.2020-2 / ITU-R BT.2100-0" + }, + { + "name": "SDL_COLOR_PRIMARIES_XYZ", + "value": "10", + "comment": "SMPTE ST 428-1" + }, + { + "name": "SDL_COLOR_PRIMARIES_SMPTE431", + "value": "11", + "comment": "SMPTE RP 431-2" + }, + { + "name": "SDL_COLOR_PRIMARIES_SMPTE432", + "value": "12", + "comment": "SMPTE EG 432-1 / DCI P3" + }, + { + "name": "SDL_COLOR_PRIMARIES_EBU3213", + "value": "22", + "comment": "EBU Tech. 3213-E" + } + ] + }, + { + "name": "SDL_TransferCharacteristics", + "values": [ + { + "name": "SDL_TRANSFER_CHARACTERISTICS_BT709", + "value": "1", + "comment": "Rec. ITU-R BT.709-6 / ITU-R BT1361" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_GAMMA22", + "value": "4", + "comment": "ITU-R BT.470-6 System M / ITU-R BT1700 625 PAL & SECAM" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_GAMMA28", + "value": "5", + "comment": "ITU-R BT.470-6 System B, G" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_BT601", + "value": "6", + "comment": "SMPTE ST 170M / ITU-R BT.601-7 525 or 625" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_SMPTE240", + "value": "7", + "comment": "SMPTE ST 240M" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_IEC61966", + "value": "11", + "comment": "IEC 61966-2-4" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_BT1361", + "value": "12", + "comment": "ITU-R BT1361 Extended Colour Gamut" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_SRGB", + "value": "13", + "comment": "IEC 61966-2-1 (sRGB or sYCC)" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_BT2020_10BIT", + "value": "14", + "comment": "ITU-R BT2020 for 10-bit system" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_BT2020_12BIT", + "value": "15", + "comment": "ITU-R BT2020 for 12-bit system" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_PQ", + "value": "16", + "comment": "SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_SMPTE428", + "value": "17", + "comment": "SMPTE ST 428-1" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_HLG", + "value": "18", + "comment": "ARIB STD-B67, known as \"hybrid log-gamma\" (HLG)" + } + ] + }, + { + "name": "SDL_MatrixCoefficients", + "values": [ + { + "name": "SDL_MATRIX_COEFFICIENTS_BT709", + "value": "1", + "comment": "ITU-R BT.709-6" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_FCC", + "value": "4", + "comment": "US FCC Title 47" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_BT470BG", + "value": "5", + "comment": "ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625, functionally the same as SDL_MATRIX_COEFFICIENTS_BT601" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_BT601", + "value": "6", + "comment": "ITU-R BT.601-7 525" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_SMPTE240", + "value": "7", + "comment": "SMPTE 240M" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_BT2020_NCL", + "value": "9", + "comment": "ITU-R BT.2020-2 non-constant luminance" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_BT2020_CL", + "value": "10", + "comment": "ITU-R BT.2020-2 constant luminance" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_SMPTE2085", + "value": "11", + "comment": "SMPTE ST 2085" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_ICTCP", + "value": "14", + "comment": "ITU-R BT.2100-0 ICTCP" + } + ] + }, + { + "name": "SDL_ChromaLocation", + "values": [ + { + "name": "SDL_CHROMA_LOCATION_NONE", + "value": "0", + "comment": "RGB, no chroma sampling" + }, + { + "name": "SDL_CHROMA_LOCATION_LEFT", + "value": "1", + "comment": "In MPEG-2, MPEG-4, and AVC, Cb and Cr are taken on midpoint of the left-edge of the 2x2 square. In other words, they have the same horizontal location as the top-left pixel, but is shifted one-half pixel down vertically." + }, + { + "name": "SDL_CHROMA_LOCATION_CENTER", + "value": "2", + "comment": "In JPEG/JFIF, H.261, and MPEG-1, Cb and Cr are taken at the center of the 2x2 square. In other words, they are offset one-half pixel to the right and one-half pixel down compared to the top-left pixel." + }, + { + "name": "SDL_CHROMA_LOCATION_TOPLEFT", + "value": "3" + } + ] + }, + { + "name": "SDL_Colorspace", + "values": [ + { + "name": "SDL_COLORSPACE_SRGB", + "value": "0x120005a0u", + "comment": "Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709" + }, + { + "name": "SDL_COLOR_RANGE_FULL" + }, + { + "name": "SDL_COLOR_PRIMARIES_BT709" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_SRGB" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_IDENTITY" + }, + { + "name": "SDL_COLORSPACE_SRGB_LINEAR", + "value": "0x12000500u", + "comment": "Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_LINEAR" + }, + { + "name": "SDL_COLORSPACE_HDR10", + "value": "0x12002600u", + "comment": "Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020" + }, + { + "name": "SDL_COLOR_PRIMARIES_BT2020" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_PQ" + }, + { + "name": "SDL_COLORSPACE_JPEG", + "value": "0x220004c6u", + "comment": "Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_BT601" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_BT601" + }, + { + "name": "SDL_COLORSPACE_BT601_LIMITED", + "value": "0x211018c6u", + "comment": "Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601" + }, + { + "name": "SDL_COLOR_RANGE_LIMITED" + }, + { + "name": "SDL_COLOR_PRIMARIES_BT601" + }, + { + "name": "SDL_COLORSPACE_BT601_FULL", + "value": "0x221018c6u", + "comment": "Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601" + }, + { + "name": "SDL_COLORSPACE_BT709_LIMITED", + "value": "0x21100421u", + "comment": "Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709" + }, + { + "name": "SDL_TRANSFER_CHARACTERISTICS_BT709" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_BT709" + }, + { + "name": "SDL_COLORSPACE_BT709_FULL", + "value": "0x22100421u", + "comment": "Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709" + }, + { + "name": "SDL_COLORSPACE_BT2020_LIMITED", + "value": "0x21102609u", + "comment": "Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020" + }, + { + "name": "SDL_MATRIX_COEFFICIENTS_BT2020_NCL" + }, + { + "name": "SDL_COLORSPACE_BT2020_FULL", + "value": "0x22102609u", + "comment": "Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020" + }, + { + "name": "SDL_COLORSPACE_RGB_DEFAULT", + "value": "SDL_COLORSPACE_SRGB", + "comment": "The default colorspace for RGB surfaces if no colorspace is specified" + }, + { + "name": "SDL_COLORSPACE_YUV_DEFAULT", + "value": "SDL_COLORSPACE_JPEG", + "comment": "The default colorspace for YUV surfaces if no colorspace is specified" + } + ] + } + ], + "structs": [ + { + "name": "SDL_Color", + "fields": [ + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + }, + { + "name": "a", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_FColor", + "fields": [ + { + "name": "r", + "type": "float" + }, + { + "name": "g", + "type": "float" + }, + { + "name": "b", + "type": "float" + }, + { + "name": "a", + "type": "float" + } + ] + }, + { + "name": "SDL_Palette", + "fields": [ + { + "name": "ncolors", + "type": "int", + "comment": "number of elements in `colors`." + }, + { + "name": "colors", + "type": "SDL_Color *", + "comment": "an array of colors, `ncolors` long." + }, + { + "name": "version", + "type": "Uint32", + "comment": "internal use only, do not touch." + }, + { + "name": "refcount", + "type": "int", + "comment": "internal use only, do not touch." + } + ] + }, + { + "name": "SDL_PixelFormatDetails", + "fields": [ + { + "name": "format", + "type": "SDL_PixelFormat" + }, + { + "name": "bits_per_pixel", + "type": "Uint8" + }, + { + "name": "bytes_per_pixel", + "type": "Uint8" + }, + { + "name": "padding", + "type": "Uint8[2]" + }, + { + "name": "Rmask", + "type": "Uint32" + }, + { + "name": "Gmask", + "type": "Uint32" + }, + { + "name": "Bmask", + "type": "Uint32" + }, + { + "name": "Amask", + "type": "Uint32" + }, + { + "name": "Rbits", + "type": "Uint8" + }, + { + "name": "Gbits", + "type": "Uint8" + }, + { + "name": "Bbits", + "type": "Uint8" + }, + { + "name": "Abits", + "type": "Uint8" + }, + { + "name": "Rshift", + "type": "Uint8" + }, + { + "name": "Gshift", + "type": "Uint8" + }, + { + "name": "Bshift", + "type": "Uint8" + }, + { + "name": "Ashift", + "type": "Uint8" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetPixelFormatName", + "return_type": "const char *", + "parameters": [ + { + "name": "format", + "type": "SDL_PixelFormat" + } + ] + }, + { + "name": "SDL_GetMasksForPixelFormat", + "return_type": "bool", + "parameters": [ + { + "name": "format", + "type": "SDL_PixelFormat" + }, + { + "name": "bpp", + "type": "int *" + }, + { + "name": "Rmask", + "type": "Uint32 *" + }, + { + "name": "Gmask", + "type": "Uint32 *" + }, + { + "name": "Bmask", + "type": "Uint32 *" + }, + { + "name": "Amask", + "type": "Uint32 *" + } + ] + }, + { + "name": "SDL_GetPixelFormatForMasks", + "return_type": "SDL_PixelFormat", + "parameters": [ + { + "name": "bpp", + "type": "int" + }, + { + "name": "Rmask", + "type": "Uint32" + }, + { + "name": "Gmask", + "type": "Uint32" + }, + { + "name": "Bmask", + "type": "Uint32" + }, + { + "name": "Amask", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_GetPixelFormatDetails", + "return_type": "const SDL_PixelFormatDetails *", + "parameters": [ + { + "name": "format", + "type": "SDL_PixelFormat" + } + ] + }, + { + "name": "SDL_CreatePalette", + "return_type": "SDL_Palette *", + "parameters": [ + { + "name": "ncolors", + "type": "int" + } + ] + }, + { + "name": "SDL_SetPaletteColors", + "return_type": "bool", + "parameters": [ + { + "name": "palette", + "type": "SDL_Palette *" + }, + { + "name": "colors", + "type": "const SDL_Color *" + }, + { + "name": "firstcolor", + "type": "int" + }, + { + "name": "ncolors", + "type": "int" + } + ] + }, + { + "name": "SDL_DestroyPalette", + "return_type": "void", + "parameters": [ + { + "name": "palette", + "type": "SDL_Palette *" + } + ] + }, + { + "name": "SDL_MapRGB", + "return_type": "Uint32", + "parameters": [ + { + "name": "format", + "type": "const SDL_PixelFormatDetails *" + }, + { + "name": "palette", + "type": "const SDL_Palette *" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_MapRGBA", + "return_type": "Uint32", + "parameters": [ + { + "name": "format", + "type": "const SDL_PixelFormatDetails *" + }, + { + "name": "palette", + "type": "const SDL_Palette *" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + }, + { + "name": "a", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GetRGB", + "return_type": "void", + "parameters": [ + { + "name": "pixel", + "type": "Uint32" + }, + { + "name": "format", + "type": "const SDL_PixelFormatDetails *" + }, + { + "name": "palette", + "type": "const SDL_Palette *" + }, + { + "name": "r", + "type": "Uint8 *" + }, + { + "name": "g", + "type": "Uint8 *" + }, + { + "name": "b", + "type": "Uint8 *" + } + ] + }, + { + "name": "SDL_GetRGBA", + "return_type": "void", + "parameters": [ + { + "name": "pixel", + "type": "Uint32" + }, + { + "name": "format", + "type": "const SDL_PixelFormatDetails *" + }, + { + "name": "palette", + "type": "const SDL_Palette *" + }, + { + "name": "r", + "type": "Uint8 *" + }, + { + "name": "g", + "type": "Uint8 *" + }, + { + "name": "b", + "type": "Uint8 *" + }, + { + "name": "a", + "type": "Uint8 *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/properties.json b/json/properties.json new file mode 100644 index 0000000..3ddd925 --- /dev/null +++ b/json/properties.json @@ -0,0 +1,394 @@ +{ + "header": "SDL_properties.h", + "opaque_types": [], + "typedefs": [ + { + "name": "SDL_PropertiesID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [ + { + "name": "SDL_CleanupPropertyCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "value", + "type": "void *" + } + ] + }, + { + "name": "SDL_EnumeratePropertiesCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + } + ] + } + ], + "enums": [ + { + "name": "SDL_PropertyType", + "values": [ + { + "name": "SDL_PROPERTY_TYPE_INVALID" + }, + { + "name": "SDL_PROPERTY_TYPE_POINTER" + }, + { + "name": "SDL_PROPERTY_TYPE_STRING" + }, + { + "name": "SDL_PROPERTY_TYPE_NUMBER" + }, + { + "name": "SDL_PROPERTY_TYPE_FLOAT" + }, + { + "name": "SDL_PROPERTY_TYPE_BOOLEAN" + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetGlobalProperties", + "return_type": "SDL_PropertiesID", + "parameters": [] + }, + { + "name": "SDL_CreateProperties", + "return_type": "SDL_PropertiesID", + "parameters": [] + }, + { + "name": "SDL_CopyProperties", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_PropertiesID" + }, + { + "name": "dst", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_LockProperties", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_UnlockProperties", + "return_type": "void", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_SetPointerPropertyWithCleanup", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "void *" + }, + { + "name": "cleanup", + "type": "SDL_CleanupPropertyCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_SetPointerProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "void *" + } + ] + }, + { + "name": "SDL_SetStringProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "const char *" + } + ] + }, + { + "name": "SDL_SetNumberProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "Sint64" + } + ] + }, + { + "name": "SDL_SetFloatProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "float" + } + ] + }, + { + "name": "SDL_SetBooleanProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "value", + "type": "bool" + } + ] + }, + { + "name": "SDL_HasProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetPropertyType", + "return_type": "SDL_PropertyType", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetPointerProperty", + "return_type": "void *", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "default_value", + "type": "void *" + } + ] + }, + { + "name": "SDL_GetStringProperty", + "return_type": "const char *", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "default_value", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetNumberProperty", + "return_type": "Sint64", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "default_value", + "type": "Sint64" + } + ] + }, + { + "name": "SDL_GetFloatProperty", + "return_type": "float", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "default_value", + "type": "float" + } + ] + }, + { + "name": "SDL_GetBooleanProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + }, + { + "name": "default_value", + "type": "bool" + } + ] + }, + { + "name": "SDL_ClearProperty", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_EnumerateProperties", + "return_type": "bool", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + }, + { + "name": "callback", + "type": "SDL_EnumeratePropertiesCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_DestroyProperties", + "return_type": "void", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/rect.json b/json/rect.json new file mode 100644 index 0000000..af56505 --- /dev/null +++ b/json/rect.json @@ -0,0 +1,277 @@ +{ + "header": "SDL_rect.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [], + "structs": [ + { + "name": "SDL_Point", + "fields": [ + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + } + ] + }, + { + "name": "SDL_FPoint", + "fields": [ + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + } + ] + }, + { + "name": "SDL_Rect", + "fields": [ + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + } + ] + }, + { + "name": "SDL_FRect", + "fields": [ + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + }, + { + "name": "w", + "type": "float" + }, + { + "name": "h", + "type": "float" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_HasRectIntersection", + "return_type": "bool", + "parameters": [ + { + "name": "A", + "type": "const SDL_Rect *" + }, + { + "name": "B", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetRectIntersection", + "return_type": "bool", + "parameters": [ + { + "name": "A", + "type": "const SDL_Rect *" + }, + { + "name": "B", + "type": "const SDL_Rect *" + }, + { + "name": "result", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetRectUnion", + "return_type": "bool", + "parameters": [ + { + "name": "A", + "type": "const SDL_Rect *" + }, + { + "name": "B", + "type": "const SDL_Rect *" + }, + { + "name": "result", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetRectEnclosingPoints", + "return_type": "bool", + "parameters": [ + { + "name": "points", + "type": "const SDL_Point *" + }, + { + "name": "count", + "type": "int" + }, + { + "name": "clip", + "type": "const SDL_Rect *" + }, + { + "name": "result", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetRectAndLineIntersection", + "return_type": "bool", + "parameters": [ + { + "name": "rect", + "type": "const SDL_Rect *" + }, + { + "name": "X1", + "type": "int *" + }, + { + "name": "Y1", + "type": "int *" + }, + { + "name": "X2", + "type": "int *" + }, + { + "name": "Y2", + "type": "int *" + } + ] + }, + { + "name": "SDL_HasRectIntersectionFloat", + "return_type": "bool", + "parameters": [ + { + "name": "A", + "type": "const SDL_FRect *" + }, + { + "name": "B", + "type": "const SDL_FRect *" + } + ] + }, + { + "name": "SDL_GetRectIntersectionFloat", + "return_type": "bool", + "parameters": [ + { + "name": "A", + "type": "const SDL_FRect *" + }, + { + "name": "B", + "type": "const SDL_FRect *" + }, + { + "name": "result", + "type": "SDL_FRect *" + } + ] + }, + { + "name": "SDL_GetRectUnionFloat", + "return_type": "bool", + "parameters": [ + { + "name": "A", + "type": "const SDL_FRect *" + }, + { + "name": "B", + "type": "const SDL_FRect *" + }, + { + "name": "result", + "type": "SDL_FRect *" + } + ] + }, + { + "name": "SDL_GetRectEnclosingPointsFloat", + "return_type": "bool", + "parameters": [ + { + "name": "points", + "type": "const SDL_FPoint *" + }, + { + "name": "count", + "type": "int" + }, + { + "name": "clip", + "type": "const SDL_FRect *" + }, + { + "name": "result", + "type": "SDL_FRect *" + } + ] + }, + { + "name": "SDL_GetRectAndLineIntersectionFloat", + "return_type": "bool", + "parameters": [ + { + "name": "rect", + "type": "const SDL_FRect *" + }, + { + "name": "X1", + "type": "float *" + }, + { + "name": "Y1", + "type": "float *" + }, + { + "name": "X2", + "type": "float *" + }, + { + "name": "Y2", + "type": "float *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/render.json b/json/render.json new file mode 100644 index 0000000..12e14e1 --- /dev/null +++ b/json/render.json @@ -0,0 +1,1668 @@ +{ + "header": "SDL_render.h", + "opaque_types": [ + { + "name": "SDL_Renderer" + }, + { + "name": "SDL_Texture" + } + ], + "typedefs": [], + "function_pointers": [], + "enums": [ + { + "name": "SDL_TextureAccess", + "values": [ + { + "name": "SDL_TEXTUREACCESS_STATIC", + "comment": "Changes rarely, not lockable" + }, + { + "name": "SDL_TEXTUREACCESS_STREAMING", + "comment": "Changes frequently, lockable" + }, + { + "name": "SDL_TEXTUREACCESS_TARGET", + "comment": "Texture can be used as a render target" + } + ] + }, + { + "name": "SDL_RendererLogicalPresentation", + "values": [ + { + "name": "SDL_LOGICAL_PRESENTATION_DISABLED", + "comment": "There is no logical size in effect" + }, + { + "name": "SDL_LOGICAL_PRESENTATION_STRETCH", + "comment": "The rendered content is stretched to the output resolution" + }, + { + "name": "SDL_LOGICAL_PRESENTATION_LETTERBOX", + "comment": "The rendered content is fit to the largest dimension and the other dimension is letterboxed with black bars" + }, + { + "name": "SDL_LOGICAL_PRESENTATION_OVERSCAN", + "comment": "The rendered content is fit to the smallest dimension and the other dimension extends beyond the output bounds" + }, + { + "name": "SDL_LOGICAL_PRESENTATION_INTEGER_SCALE", + "comment": "The rendered content is scaled up by integer multiples to fit the output resolution" + } + ] + } + ], + "structs": [ + { + "name": "SDL_Vertex", + "fields": [ + { + "name": "position", + "type": "SDL_FPoint", + "comment": "Vertex position, in SDL_Renderer coordinates" + }, + { + "name": "color", + "type": "SDL_FColor", + "comment": "Vertex color" + }, + { + "name": "tex_coord", + "type": "SDL_FPoint", + "comment": "Normalized texture coordinates, if needed" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetNumRenderDrivers", + "return_type": "int", + "parameters": [] + }, + { + "name": "SDL_GetRenderDriver", + "return_type": "const char *", + "parameters": [ + { + "name": "index", + "type": "int" + } + ] + }, + { + "name": "SDL_CreateWindowAndRenderer", + "return_type": "bool", + "parameters": [ + { + "name": "title", + "type": "const char *" + }, + { + "name": "width", + "type": "int" + }, + { + "name": "height", + "type": "int" + }, + { + "name": "window_flags", + "type": "SDL_WindowFlags" + }, + { + "name": "window", + "type": "SDL_Window **" + }, + { + "name": "renderer", + "type": "SDL_Renderer **" + } + ] + }, + { + "name": "SDL_CreateRenderer", + "return_type": "SDL_Renderer *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "name", + "type": "const char *" + } + ] + }, + { + "name": "SDL_CreateRendererWithProperties", + "return_type": "SDL_Renderer *", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_CreateSoftwareRenderer", + "return_type": "SDL_Renderer *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_GetRenderer", + "return_type": "SDL_Renderer *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetRenderWindow", + "return_type": "SDL_Window *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_GetRendererName", + "return_type": "const char *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_GetRendererProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_GetRenderOutputSize", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "w", + "type": "int *" + }, + { + "name": "h", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetCurrentRenderOutputSize", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "w", + "type": "int *" + }, + { + "name": "h", + "type": "int *" + } + ] + }, + { + "name": "SDL_CreateTexture", + "return_type": "SDL_Texture *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "format", + "type": "SDL_PixelFormat" + }, + { + "name": "access", + "type": "SDL_TextureAccess" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + } + ] + }, + { + "name": "SDL_CreateTextureFromSurface", + "return_type": "SDL_Texture *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_CreateTextureWithProperties", + "return_type": "SDL_Texture *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_GetTextureProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + } + ] + }, + { + "name": "SDL_GetRendererFromTexture", + "return_type": "SDL_Renderer *", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + } + ] + }, + { + "name": "SDL_GetTextureSize", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "w", + "type": "float *" + }, + { + "name": "h", + "type": "float *" + } + ] + }, + { + "name": "SDL_SetTextureColorMod", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_SetTextureColorModFloat", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "r", + "type": "float" + }, + { + "name": "g", + "type": "float" + }, + { + "name": "b", + "type": "float" + } + ] + }, + { + "name": "SDL_GetTextureColorMod", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "r", + "type": "Uint8 *" + }, + { + "name": "g", + "type": "Uint8 *" + }, + { + "name": "b", + "type": "Uint8 *" + } + ] + }, + { + "name": "SDL_GetTextureColorModFloat", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "r", + "type": "float *" + }, + { + "name": "g", + "type": "float *" + }, + { + "name": "b", + "type": "float *" + } + ] + }, + { + "name": "SDL_SetTextureAlphaMod", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "alpha", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_SetTextureAlphaModFloat", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "alpha", + "type": "float" + } + ] + }, + { + "name": "SDL_GetTextureAlphaMod", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "alpha", + "type": "Uint8 *" + } + ] + }, + { + "name": "SDL_GetTextureAlphaModFloat", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "alpha", + "type": "float *" + } + ] + }, + { + "name": "SDL_SetTextureBlendMode", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "blendMode", + "type": "SDL_BlendMode" + } + ] + }, + { + "name": "SDL_GetTextureBlendMode", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "blendMode", + "type": "SDL_BlendMode *" + } + ] + }, + { + "name": "SDL_SetTextureScaleMode", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode" + } + ] + }, + { + "name": "SDL_GetTextureScaleMode", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode *" + } + ] + }, + { + "name": "SDL_UpdateTexture", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + }, + { + "name": "pixels", + "type": "const void *" + }, + { + "name": "pitch", + "type": "int" + } + ] + }, + { + "name": "SDL_UpdateYUVTexture", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + }, + { + "name": "Yplane", + "type": "const Uint8 *" + }, + { + "name": "Ypitch", + "type": "int" + }, + { + "name": "Uplane", + "type": "const Uint8 *" + }, + { + "name": "Upitch", + "type": "int" + }, + { + "name": "Vplane", + "type": "const Uint8 *" + }, + { + "name": "Vpitch", + "type": "int" + } + ] + }, + { + "name": "SDL_UpdateNVTexture", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + }, + { + "name": "Yplane", + "type": "const Uint8 *" + }, + { + "name": "Ypitch", + "type": "int" + }, + { + "name": "UVplane", + "type": "const Uint8 *" + }, + { + "name": "UVpitch", + "type": "int" + } + ] + }, + { + "name": "SDL_LockTexture", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + }, + { + "name": "pixels", + "type": "void **" + }, + { + "name": "pitch", + "type": "int *" + } + ] + }, + { + "name": "SDL_LockTextureToSurface", + "return_type": "bool", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + }, + { + "name": "surface", + "type": "SDL_Surface **" + } + ] + }, + { + "name": "SDL_UnlockTexture", + "return_type": "void", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + } + ] + }, + { + "name": "SDL_SetRenderTarget", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + } + ] + }, + { + "name": "SDL_GetRenderTarget", + "return_type": "SDL_Texture *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_SetRenderLogicalPresentation", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + }, + { + "name": "mode", + "type": "SDL_RendererLogicalPresentation" + } + ] + }, + { + "name": "SDL_GetRenderLogicalPresentation", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "w", + "type": "int *" + }, + { + "name": "h", + "type": "int *" + }, + { + "name": "mode", + "type": "SDL_RendererLogicalPresentation *" + } + ] + }, + { + "name": "SDL_GetRenderLogicalPresentationRect", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "SDL_FRect *" + } + ] + }, + { + "name": "SDL_RenderCoordinatesFromWindow", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "window_x", + "type": "float" + }, + { + "name": "window_y", + "type": "float" + }, + { + "name": "x", + "type": "float *" + }, + { + "name": "y", + "type": "float *" + } + ] + }, + { + "name": "SDL_RenderCoordinatesToWindow", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + }, + { + "name": "window_x", + "type": "float *" + }, + { + "name": "window_y", + "type": "float *" + } + ] + }, + { + "name": "SDL_ConvertEventToRenderCoordinates", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "event", + "type": "SDL_Event *" + } + ] + }, + { + "name": "SDL_SetRenderViewport", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetRenderViewport", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_RenderViewportSet", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_GetRenderSafeArea", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_SetRenderClipRect", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetRenderClipRect", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_RenderClipEnabled", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_SetRenderScale", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "scaleX", + "type": "float" + }, + { + "name": "scaleY", + "type": "float" + } + ] + }, + { + "name": "SDL_GetRenderScale", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "scaleX", + "type": "float *" + }, + { + "name": "scaleY", + "type": "float *" + } + ] + }, + { + "name": "SDL_SetRenderDrawColor", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + }, + { + "name": "a", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_SetRenderDrawColorFloat", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "r", + "type": "float" + }, + { + "name": "g", + "type": "float" + }, + { + "name": "b", + "type": "float" + }, + { + "name": "a", + "type": "float" + } + ] + }, + { + "name": "SDL_GetRenderDrawColor", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "r", + "type": "Uint8 *" + }, + { + "name": "g", + "type": "Uint8 *" + }, + { + "name": "b", + "type": "Uint8 *" + }, + { + "name": "a", + "type": "Uint8 *" + } + ] + }, + { + "name": "SDL_GetRenderDrawColorFloat", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "r", + "type": "float *" + }, + { + "name": "g", + "type": "float *" + }, + { + "name": "b", + "type": "float *" + }, + { + "name": "a", + "type": "float *" + } + ] + }, + { + "name": "SDL_SetRenderColorScale", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "scale", + "type": "float" + } + ] + }, + { + "name": "SDL_GetRenderColorScale", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "scale", + "type": "float *" + } + ] + }, + { + "name": "SDL_SetRenderDrawBlendMode", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "blendMode", + "type": "SDL_BlendMode" + } + ] + }, + { + "name": "SDL_GetRenderDrawBlendMode", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "blendMode", + "type": "SDL_BlendMode *" + } + ] + }, + { + "name": "SDL_RenderClear", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_RenderPoint", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + } + ] + }, + { + "name": "SDL_RenderPoints", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "points", + "type": "const SDL_FPoint *" + }, + { + "name": "count", + "type": "int" + } + ] + }, + { + "name": "SDL_RenderLine", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "x1", + "type": "float" + }, + { + "name": "y1", + "type": "float" + }, + { + "name": "x2", + "type": "float" + }, + { + "name": "y2", + "type": "float" + } + ] + }, + { + "name": "SDL_RenderLines", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "points", + "type": "const SDL_FPoint *" + }, + { + "name": "count", + "type": "int" + } + ] + }, + { + "name": "SDL_RenderRect", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "const SDL_FRect *" + } + ] + }, + { + "name": "SDL_RenderRects", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rects", + "type": "const SDL_FRect *" + }, + { + "name": "count", + "type": "int" + } + ] + }, + { + "name": "SDL_RenderFillRect", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "const SDL_FRect *" + } + ] + }, + { + "name": "SDL_RenderFillRects", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rects", + "type": "const SDL_FRect *" + }, + { + "name": "count", + "type": "int" + } + ] + }, + { + "name": "SDL_RenderTexture", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "srcrect", + "type": "const SDL_FRect *" + }, + { + "name": "dstrect", + "type": "const SDL_FRect *" + } + ] + }, + { + "name": "SDL_RenderTextureRotated", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "srcrect", + "type": "const SDL_FRect *" + }, + { + "name": "dstrect", + "type": "const SDL_FRect *" + }, + { + "name": "angle", + "type": "double" + }, + { + "name": "center", + "type": "const SDL_FPoint *" + }, + { + "name": "flip", + "type": "SDL_FlipMode" + } + ] + }, + { + "name": "SDL_RenderTextureAffine", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "srcrect", + "type": "const SDL_FRect *" + }, + { + "name": "origin", + "type": "const SDL_FPoint *" + }, + { + "name": "right", + "type": "const SDL_FPoint *" + }, + { + "name": "down", + "type": "const SDL_FPoint *" + } + ] + }, + { + "name": "SDL_RenderTextureTiled", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "srcrect", + "type": "const SDL_FRect *" + }, + { + "name": "scale", + "type": "float" + }, + { + "name": "dstrect", + "type": "const SDL_FRect *" + } + ] + }, + { + "name": "SDL_RenderTexture9Grid", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "srcrect", + "type": "const SDL_FRect *" + }, + { + "name": "left_width", + "type": "float" + }, + { + "name": "right_width", + "type": "float" + }, + { + "name": "top_height", + "type": "float" + }, + { + "name": "bottom_height", + "type": "float" + }, + { + "name": "scale", + "type": "float" + }, + { + "name": "dstrect", + "type": "const SDL_FRect *" + } + ] + }, + { + "name": "SDL_RenderGeometry", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "vertices", + "type": "const SDL_Vertex *" + }, + { + "name": "num_vertices", + "type": "int" + }, + { + "name": "indices", + "type": "const int *" + }, + { + "name": "num_indices", + "type": "int" + } + ] + }, + { + "name": "SDL_RenderGeometryRaw", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "texture", + "type": "SDL_Texture *" + }, + { + "name": "xy", + "type": "const float *" + }, + { + "name": "xy_stride", + "type": "int" + }, + { + "name": "color", + "type": "const SDL_FColor *" + }, + { + "name": "color_stride", + "type": "int" + }, + { + "name": "uv", + "type": "const float *" + }, + { + "name": "uv_stride", + "type": "int" + }, + { + "name": "num_vertices", + "type": "int" + }, + { + "name": "indices", + "type": "const void *" + }, + { + "name": "num_indices", + "type": "int" + }, + { + "name": "size_indices", + "type": "int" + } + ] + }, + { + "name": "SDL_RenderReadPixels", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_RenderPresent", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_DestroyTexture", + "return_type": "void", + "parameters": [ + { + "name": "texture", + "type": "SDL_Texture *" + } + ] + }, + { + "name": "SDL_DestroyRenderer", + "return_type": "void", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_FlushRenderer", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_GetRenderMetalLayer", + "return_type": "void *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_GetRenderMetalCommandEncoder", + "return_type": "void *", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + } + ] + }, + { + "name": "SDL_AddVulkanRenderSemaphores", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "wait_stage_mask", + "type": "Uint32" + }, + { + "name": "wait_semaphore", + "type": "Sint64" + }, + { + "name": "signal_semaphore", + "type": "Sint64" + } + ] + }, + { + "name": "SDL_SetRenderVSync", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "vsync", + "type": "int" + } + ] + }, + { + "name": "SDL_GetRenderVSync", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "vsync", + "type": "int *" + } + ] + }, + { + "name": "SDL_RenderDebugText", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + }, + { + "name": "str", + "type": "const char *" + } + ] + }, + { + "name": "SDL_RenderDebugTextFormat", + "return_type": "bool", + "parameters": [ + { + "name": "renderer", + "type": "SDL_Renderer *" + }, + { + "name": "x", + "type": "float" + }, + { + "name": "y", + "type": "float" + }, + { + "name": "fmt", + "type": "const char *" + }, + { + "name": "", + "type": "..." + } + ] + } + ] +} \ No newline at end of file diff --git a/json/sensor.json b/json/sensor.json new file mode 100644 index 0000000..cd93b11 --- /dev/null +++ b/json/sensor.json @@ -0,0 +1,203 @@ +{ + "header": "SDL_sensor.h", + "opaque_types": [ + { + "name": "SDL_Sensor" + } + ], + "typedefs": [ + { + "name": "SDL_SensorID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [], + "enums": [ + { + "name": "SDL_SensorType", + "values": [ + { + "name": "SDL_SENSOR_INVALID", + "value": "-1", + "comment": "Returned for an invalid sensor" + }, + { + "name": "SDL_SENSOR_UNKNOWN", + "comment": "Unknown sensor type" + }, + { + "name": "SDL_SENSOR_ACCEL", + "comment": "Accelerometer" + }, + { + "name": "SDL_SENSOR_GYRO", + "comment": "Gyroscope" + }, + { + "name": "SDL_SENSOR_ACCEL_L", + "comment": "Accelerometer for left Joy-Con controller and Wii nunchuk" + }, + { + "name": "SDL_SENSOR_GYRO_L", + "comment": "Gyroscope for left Joy-Con controller" + }, + { + "name": "SDL_SENSOR_ACCEL_R", + "comment": "Accelerometer for right Joy-Con controller" + }, + { + "name": "SDL_SENSOR_GYRO_R", + "comment": "Gyroscope for right Joy-Con controller" + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetSensors", + "return_type": "SDL_SensorID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetSensorNameForID", + "return_type": "const char *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_SensorID" + } + ] + }, + { + "name": "SDL_GetSensorTypeForID", + "return_type": "SDL_SensorType", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_SensorID" + } + ] + }, + { + "name": "SDL_GetSensorNonPortableTypeForID", + "return_type": "int", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_SensorID" + } + ] + }, + { + "name": "SDL_OpenSensor", + "return_type": "SDL_Sensor *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_SensorID" + } + ] + }, + { + "name": "SDL_GetSensorFromID", + "return_type": "SDL_Sensor *", + "parameters": [ + { + "name": "instance_id", + "type": "SDL_SensorID" + } + ] + }, + { + "name": "SDL_GetSensorProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "sensor", + "type": "SDL_Sensor *" + } + ] + }, + { + "name": "SDL_GetSensorName", + "return_type": "const char *", + "parameters": [ + { + "name": "sensor", + "type": "SDL_Sensor *" + } + ] + }, + { + "name": "SDL_GetSensorType", + "return_type": "SDL_SensorType", + "parameters": [ + { + "name": "sensor", + "type": "SDL_Sensor *" + } + ] + }, + { + "name": "SDL_GetSensorNonPortableType", + "return_type": "int", + "parameters": [ + { + "name": "sensor", + "type": "SDL_Sensor *" + } + ] + }, + { + "name": "SDL_GetSensorID", + "return_type": "SDL_SensorID", + "parameters": [ + { + "name": "sensor", + "type": "SDL_Sensor *" + } + ] + }, + { + "name": "SDL_GetSensorData", + "return_type": "bool", + "parameters": [ + { + "name": "sensor", + "type": "SDL_Sensor *" + }, + { + "name": "data", + "type": "float *" + }, + { + "name": "num_values", + "type": "int" + } + ] + }, + { + "name": "SDL_CloseSensor", + "return_type": "void", + "parameters": [ + { + "name": "sensor", + "type": "SDL_Sensor *" + } + ] + }, + { + "name": "SDL_UpdateSensors", + "return_type": "void", + "parameters": [] + } + ] +} \ No newline at end of file diff --git a/json/storage.json b/json/storage.json new file mode 100644 index 0000000..6b9b94b --- /dev/null +++ b/json/storage.json @@ -0,0 +1,348 @@ +{ + "header": "SDL_storage.h", + "opaque_types": [ + { + "name": "SDL_Storage" + } + ], + "typedefs": [], + "function_pointers": [], + "enums": [], + "structs": [ + { + "name": "SDL_StorageInterface", + "fields": [ + { + "name": "version", + "type": "Uint32" + }, + { + "name": "close", + "type": "bool (SDLCALL *close)(void *userdata)" + }, + { + "name": "ready", + "type": "bool (SDLCALL *ready)(void *userdata)" + }, + { + "name": "enumerate", + "type": "bool (SDLCALL *enumerate)(void *userdata, const char *path, SDL_EnumerateDirectoryCallback callback, void *callback_userdata)" + }, + { + "name": "info", + "type": "bool (SDLCALL *info)(void *userdata, const char *path, SDL_PathInfo *info)" + }, + { + "name": "read_file", + "type": "bool (SDLCALL *read_file)(void *userdata, const char *path, void *destination, Uint64 length)" + }, + { + "name": "write_file", + "type": "bool (SDLCALL *write_file)(void *userdata, const char *path, const void *source, Uint64 length)" + }, + { + "name": "mkdir", + "type": "bool (SDLCALL *mkdir)(void *userdata, const char *path)" + }, + { + "name": "remove", + "type": "bool (SDLCALL *remove)(void *userdata, const char *path)" + }, + { + "name": "rename", + "type": "bool (SDLCALL *rename)(void *userdata, const char *oldpath, const char *newpath)" + }, + { + "name": "copy", + "type": "bool (SDLCALL *copy)(void *userdata, const char *oldpath, const char *newpath)" + }, + { + "name": "space_remaining", + "type": "Uint64 (SDLCALL *space_remaining)(void *userdata)" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_OpenTitleStorage", + "return_type": "SDL_Storage *", + "parameters": [ + { + "name": "override", + "type": "const char *" + }, + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_OpenUserStorage", + "return_type": "SDL_Storage *", + "parameters": [ + { + "name": "org", + "type": "const char *" + }, + { + "name": "app", + "type": "const char *" + }, + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_OpenFileStorage", + "return_type": "SDL_Storage *", + "parameters": [ + { + "name": "path", + "type": "const char *" + } + ] + }, + { + "name": "SDL_OpenStorage", + "return_type": "SDL_Storage *", + "parameters": [ + { + "name": "iface", + "type": "const SDL_StorageInterface *" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_CloseStorage", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + } + ] + }, + { + "name": "SDL_StorageReady", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + } + ] + }, + { + "name": "SDL_GetStorageFileSize", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + }, + { + "name": "length", + "type": "Uint64 *" + } + ] + }, + { + "name": "SDL_ReadStorageFile", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + }, + { + "name": "destination", + "type": "void *" + }, + { + "name": "length", + "type": "Uint64" + } + ] + }, + { + "name": "SDL_WriteStorageFile", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + }, + { + "name": "source", + "type": "const void *" + }, + { + "name": "length", + "type": "Uint64" + } + ] + }, + { + "name": "SDL_CreateStorageDirectory", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + } + ] + }, + { + "name": "SDL_EnumerateStorageDirectory", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + }, + { + "name": "callback", + "type": "SDL_EnumerateDirectoryCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_RemoveStoragePath", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + } + ] + }, + { + "name": "SDL_RenameStoragePath", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "oldpath", + "type": "const char *" + }, + { + "name": "newpath", + "type": "const char *" + } + ] + }, + { + "name": "SDL_CopyStorageFile", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "oldpath", + "type": "const char *" + }, + { + "name": "newpath", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetStoragePathInfo", + "return_type": "bool", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + }, + { + "name": "info", + "type": "SDL_PathInfo *" + } + ] + }, + { + "name": "SDL_GetStorageSpaceRemaining", + "return_type": "Uint64", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + } + ] + }, + { + "name": "SDL_GlobStorageDirectory", + "return_type": "char **", + "parameters": [ + { + "name": "storage", + "type": "SDL_Storage *" + }, + { + "name": "path", + "type": "const char *" + }, + { + "name": "pattern", + "type": "const char *" + }, + { + "name": "flags", + "type": "SDL_GlobFlags" + }, + { + "name": "count", + "type": "int *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/surface.json b/json/surface.json new file mode 100644 index 0000000..979d740 --- /dev/null +++ b/json/surface.json @@ -0,0 +1,1218 @@ +{ + "header": "SDL_surface.h", + "opaque_types": [ + { + "name": "SDL_Surface" + } + ], + "typedefs": [], + "function_pointers": [], + "enums": [ + { + "name": "SDL_ScaleMode", + "values": [ + { + "name": "SDL_SCALEMODE_NEAREST", + "comment": "nearest pixel sampling" + }, + { + "name": "SDL_SCALEMODE_LINEAR", + "comment": "linear filtering" + } + ] + }, + { + "name": "SDL_FlipMode", + "values": [ + { + "name": "SDL_FLIP_NONE", + "comment": "Do not flip" + }, + { + "name": "SDL_FLIP_HORIZONTAL", + "comment": "flip horizontally" + }, + { + "name": "SDL_FLIP_VERTICAL", + "comment": "flip vertically" + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [ + { + "name": "SDL_SurfaceFlags", + "underlying_type": "Uint32", + "values": [ + { + "name": "SDL_SURFACE_PREALLOCATED", + "value": "0x00000001u", + "comment": "Surface uses preallocated pixel memory" + }, + { + "name": "SDL_SURFACE_LOCK_NEEDED", + "value": "0x00000002u", + "comment": "Surface needs to be locked to access pixels" + }, + { + "name": "SDL_SURFACE_LOCKED", + "value": "0x00000004u", + "comment": "Surface is currently locked" + }, + { + "name": "SDL_SURFACE_SIMD_ALIGNED", + "value": "0x00000008u", + "comment": "Surface uses pixel memory allocated with SDL_aligned_alloc()" + } + ] + } + ], + "functions": [ + { + "name": "SDL_CreateSurface", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "width", + "type": "int" + }, + { + "name": "height", + "type": "int" + }, + { + "name": "format", + "type": "SDL_PixelFormat" + } + ] + }, + { + "name": "SDL_CreateSurfaceFrom", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "width", + "type": "int" + }, + { + "name": "height", + "type": "int" + }, + { + "name": "format", + "type": "SDL_PixelFormat" + }, + { + "name": "pixels", + "type": "void *" + }, + { + "name": "pitch", + "type": "int" + } + ] + }, + { + "name": "SDL_DestroySurface", + "return_type": "void", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_GetSurfaceProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_SetSurfaceColorspace", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "colorspace", + "type": "SDL_Colorspace" + } + ] + }, + { + "name": "SDL_GetSurfaceColorspace", + "return_type": "SDL_Colorspace", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_CreateSurfacePalette", + "return_type": "SDL_Palette *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_SetSurfacePalette", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "palette", + "type": "SDL_Palette *" + } + ] + }, + { + "name": "SDL_GetSurfacePalette", + "return_type": "SDL_Palette *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_AddSurfaceAlternateImage", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "image", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_SurfaceHasAlternateImages", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_GetSurfaceImages", + "return_type": "SDL_Surface **", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_RemoveSurfaceAlternateImages", + "return_type": "void", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_LockSurface", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_UnlockSurface", + "return_type": "void", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_LoadBMP_IO", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "src", + "type": "SDL_IOStream *" + }, + { + "name": "closeio", + "type": "bool" + } + ] + }, + { + "name": "SDL_LoadBMP", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "file", + "type": "const char *" + } + ] + }, + { + "name": "SDL_SaveBMP_IO", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "dst", + "type": "SDL_IOStream *" + }, + { + "name": "closeio", + "type": "bool" + } + ] + }, + { + "name": "SDL_SaveBMP", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "file", + "type": "const char *" + } + ] + }, + { + "name": "SDL_SetSurfaceRLE", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "enabled", + "type": "bool" + } + ] + }, + { + "name": "SDL_SurfaceHasRLE", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_SetSurfaceColorKey", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "enabled", + "type": "bool" + }, + { + "name": "key", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_SurfaceHasColorKey", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_GetSurfaceColorKey", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "key", + "type": "Uint32 *" + } + ] + }, + { + "name": "SDL_SetSurfaceColorMod", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GetSurfaceColorMod", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "r", + "type": "Uint8 *" + }, + { + "name": "g", + "type": "Uint8 *" + }, + { + "name": "b", + "type": "Uint8 *" + } + ] + }, + { + "name": "SDL_SetSurfaceAlphaMod", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "alpha", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_GetSurfaceAlphaMod", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "alpha", + "type": "Uint8 *" + } + ] + }, + { + "name": "SDL_SetSurfaceBlendMode", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "blendMode", + "type": "SDL_BlendMode" + } + ] + }, + { + "name": "SDL_GetSurfaceBlendMode", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "blendMode", + "type": "SDL_BlendMode *" + } + ] + }, + { + "name": "SDL_SetSurfaceClipRect", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetSurfaceClipRect", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "rect", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_FlipSurface", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "flip", + "type": "SDL_FlipMode" + } + ] + }, + { + "name": "SDL_DuplicateSurface", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_ScaleSurface", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "width", + "type": "int" + }, + { + "name": "height", + "type": "int" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode" + } + ] + }, + { + "name": "SDL_ConvertSurface", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "format", + "type": "SDL_PixelFormat" + } + ] + }, + { + "name": "SDL_ConvertSurfaceAndColorspace", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "format", + "type": "SDL_PixelFormat" + }, + { + "name": "palette", + "type": "SDL_Palette *" + }, + { + "name": "colorspace", + "type": "SDL_Colorspace" + }, + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_ConvertPixels", + "return_type": "bool", + "parameters": [ + { + "name": "width", + "type": "int" + }, + { + "name": "height", + "type": "int" + }, + { + "name": "src_format", + "type": "SDL_PixelFormat" + }, + { + "name": "src", + "type": "const void *" + }, + { + "name": "src_pitch", + "type": "int" + }, + { + "name": "dst_format", + "type": "SDL_PixelFormat" + }, + { + "name": "dst", + "type": "void *" + }, + { + "name": "dst_pitch", + "type": "int" + } + ] + }, + { + "name": "SDL_ConvertPixelsAndColorspace", + "return_type": "bool", + "parameters": [ + { + "name": "width", + "type": "int" + }, + { + "name": "height", + "type": "int" + }, + { + "name": "src_format", + "type": "SDL_PixelFormat" + }, + { + "name": "src_colorspace", + "type": "SDL_Colorspace" + }, + { + "name": "src_properties", + "type": "SDL_PropertiesID" + }, + { + "name": "src", + "type": "const void *" + }, + { + "name": "src_pitch", + "type": "int" + }, + { + "name": "dst_format", + "type": "SDL_PixelFormat" + }, + { + "name": "dst_colorspace", + "type": "SDL_Colorspace" + }, + { + "name": "dst_properties", + "type": "SDL_PropertiesID" + }, + { + "name": "dst", + "type": "void *" + }, + { + "name": "dst_pitch", + "type": "int" + } + ] + }, + { + "name": "SDL_PremultiplyAlpha", + "return_type": "bool", + "parameters": [ + { + "name": "width", + "type": "int" + }, + { + "name": "height", + "type": "int" + }, + { + "name": "src_format", + "type": "SDL_PixelFormat" + }, + { + "name": "src", + "type": "const void *" + }, + { + "name": "src_pitch", + "type": "int" + }, + { + "name": "dst_format", + "type": "SDL_PixelFormat" + }, + { + "name": "dst", + "type": "void *" + }, + { + "name": "dst_pitch", + "type": "int" + }, + { + "name": "linear", + "type": "bool" + } + ] + }, + { + "name": "SDL_PremultiplySurfaceAlpha", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "linear", + "type": "bool" + } + ] + }, + { + "name": "SDL_ClearSurface", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "r", + "type": "float" + }, + { + "name": "g", + "type": "float" + }, + { + "name": "b", + "type": "float" + }, + { + "name": "a", + "type": "float" + } + ] + }, + { + "name": "SDL_FillSurfaceRect", + "return_type": "bool", + "parameters": [ + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + }, + { + "name": "color", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_FillSurfaceRects", + "return_type": "bool", + "parameters": [ + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "rects", + "type": "const SDL_Rect *" + }, + { + "name": "count", + "type": "int" + }, + { + "name": "color", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_BlitSurface", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_BlitSurfaceUnchecked", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_BlitSurfaceScaled", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode" + } + ] + }, + { + "name": "SDL_BlitSurfaceUncheckedScaled", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode" + } + ] + }, + { + "name": "SDL_StretchSurface", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode" + } + ] + }, + { + "name": "SDL_BlitSurfaceTiled", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_BlitSurfaceTiledWithScale", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "scale", + "type": "float" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_BlitSurface9Grid", + "return_type": "bool", + "parameters": [ + { + "name": "src", + "type": "SDL_Surface *" + }, + { + "name": "srcrect", + "type": "const SDL_Rect *" + }, + { + "name": "left_width", + "type": "int" + }, + { + "name": "right_width", + "type": "int" + }, + { + "name": "top_height", + "type": "int" + }, + { + "name": "bottom_height", + "type": "int" + }, + { + "name": "scale", + "type": "float" + }, + { + "name": "scaleMode", + "type": "SDL_ScaleMode" + }, + { + "name": "dst", + "type": "SDL_Surface *" + }, + { + "name": "dstrect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_MapSurfaceRGB", + "return_type": "Uint32", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_MapSurfaceRGBA", + "return_type": "Uint32", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + }, + { + "name": "a", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_ReadSurfacePixel", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + }, + { + "name": "r", + "type": "Uint8 *" + }, + { + "name": "g", + "type": "Uint8 *" + }, + { + "name": "b", + "type": "Uint8 *" + }, + { + "name": "a", + "type": "Uint8 *" + } + ] + }, + { + "name": "SDL_ReadSurfacePixelFloat", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + }, + { + "name": "r", + "type": "float *" + }, + { + "name": "g", + "type": "float *" + }, + { + "name": "b", + "type": "float *" + }, + { + "name": "a", + "type": "float *" + } + ] + }, + { + "name": "SDL_WriteSurfacePixel", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + }, + { + "name": "r", + "type": "Uint8" + }, + { + "name": "g", + "type": "Uint8" + }, + { + "name": "b", + "type": "Uint8" + }, + { + "name": "a", + "type": "Uint8" + } + ] + }, + { + "name": "SDL_WriteSurfacePixelFloat", + "return_type": "bool", + "parameters": [ + { + "name": "surface", + "type": "SDL_Surface *" + }, + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + }, + { + "name": "r", + "type": "float" + }, + { + "name": "g", + "type": "float" + }, + { + "name": "b", + "type": "float" + }, + { + "name": "a", + "type": "float" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/system.json b/json/system.json new file mode 100644 index 0000000..c295bb8 --- /dev/null +++ b/json/system.json @@ -0,0 +1,398 @@ +{ + "header": "SDL_system.h", + "opaque_types": [ + { + "name": "MSG" + } + ], + "typedefs": [ + { + "name": "XTaskQueueHandle", + "underlying_type": "struct XTaskQueueObject *" + }, + { + "name": "XUserHandle", + "underlying_type": "struct XUser *" + } + ], + "function_pointers": [ + { + "name": "SDL_WindowsMessageHook", + "return_type": "bool", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "msg", + "type": "MSG *" + } + ] + }, + { + "name": "SDL_X11EventHook", + "return_type": "bool", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "xevent", + "type": "XEvent *" + } + ] + }, + { + "name": "SDL_iOSAnimationCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_RequestAndroidPermissionCallback", + "return_type": "void", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "permission", + "type": "const char *" + }, + { + "name": "granted", + "type": "bool" + } + ] + } + ], + "enums": [ + { + "name": "SDL_Sandbox", + "values": [ + { + "name": "SDL_SANDBOX_UNKNOWN_CONTAINER" + }, + { + "name": "SDL_SANDBOX_FLATPAK" + }, + { + "name": "SDL_SANDBOX_SNAP" + }, + { + "name": "SDL_SANDBOX_MACOS" + } + ] + } + ], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_SetWindowsMessageHook", + "return_type": "void", + "parameters": [ + { + "name": "callback", + "type": "SDL_WindowsMessageHook" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_GetDirect3D9AdapterIndex", + "return_type": "int", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetDXGIOutputInfo", + "return_type": "bool", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + }, + { + "name": "adapterIndex", + "type": "int *" + }, + { + "name": "outputIndex", + "type": "int *" + } + ] + }, + { + "name": "SDL_SetX11EventHook", + "return_type": "void", + "parameters": [ + { + "name": "callback", + "type": "SDL_X11EventHook" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_SetLinuxThreadPriority", + "return_type": "bool", + "parameters": [ + { + "name": "threadID", + "type": "Sint64" + }, + { + "name": "priority", + "type": "int" + } + ] + }, + { + "name": "SDL_SetLinuxThreadPriorityAndPolicy", + "return_type": "bool", + "parameters": [ + { + "name": "threadID", + "type": "Sint64" + }, + { + "name": "sdlPriority", + "type": "int" + }, + { + "name": "schedPolicy", + "type": "int" + } + ] + }, + { + "name": "SDL_SetiOSAnimationCallback", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "interval", + "type": "int" + }, + { + "name": "callback", + "type": "SDL_iOSAnimationCallback" + }, + { + "name": "callbackParam", + "type": "void *" + } + ] + }, + { + "name": "SDL_SetiOSEventPump", + "return_type": "void", + "parameters": [ + { + "name": "enabled", + "type": "bool" + } + ] + }, + { + "name": "SDL_GetAndroidJNIEnv", + "return_type": "void *", + "parameters": [] + }, + { + "name": "SDL_GetAndroidActivity", + "return_type": "void *", + "parameters": [] + }, + { + "name": "SDL_GetAndroidSDKVersion", + "return_type": "int", + "parameters": [] + }, + { + "name": "SDL_IsChromebook", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_IsDeXMode", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_SendAndroidBackButton", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_GetAndroidInternalStoragePath", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_GetAndroidExternalStorageState", + "return_type": "Uint32", + "parameters": [] + }, + { + "name": "SDL_GetAndroidExternalStoragePath", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_GetAndroidCachePath", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_RequestAndroidPermission", + "return_type": "bool", + "parameters": [ + { + "name": "permission", + "type": "const char *" + }, + { + "name": "cb", + "type": "SDL_RequestAndroidPermissionCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_ShowAndroidToast", + "return_type": "bool", + "parameters": [ + { + "name": "message", + "type": "const char *" + }, + { + "name": "duration", + "type": "int" + }, + { + "name": "gravity", + "type": "int" + }, + { + "name": "xoffset", + "type": "int" + }, + { + "name": "yoffset", + "type": "int" + } + ] + }, + { + "name": "SDL_SendAndroidMessage", + "return_type": "bool", + "parameters": [ + { + "name": "command", + "type": "Uint32" + }, + { + "name": "param", + "type": "int" + } + ] + }, + { + "name": "SDL_IsTablet", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_IsTV", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GetSandbox", + "return_type": "SDL_Sandbox", + "parameters": [] + }, + { + "name": "SDL_OnApplicationWillTerminate", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_OnApplicationDidReceiveMemoryWarning", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_OnApplicationWillEnterBackground", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_OnApplicationDidEnterBackground", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_OnApplicationWillEnterForeground", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_OnApplicationDidEnterForeground", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_OnApplicationDidChangeStatusBarOrientation", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_GetGDKTaskQueue", + "return_type": "bool", + "parameters": [ + { + "name": "outTaskQueue", + "type": "XTaskQueueHandle *" + } + ] + }, + { + "name": "SDL_GetGDKDefaultUser", + "return_type": "bool", + "parameters": [ + { + "name": "outUserHandle", + "type": "XUserHandle *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/time.json b/json/time.json new file mode 100644 index 0000000..fa8e422 --- /dev/null +++ b/json/time.json @@ -0,0 +1,237 @@ +{ + "header": "SDL_time.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [ + { + "name": "SDL_DateFormat", + "values": [ + { + "name": "SDL_DATE_FORMAT_YYYYMMDD", + "value": "0", + "comment": "Year/Month/Day" + }, + { + "name": "SDL_DATE_FORMAT_DDMMYYYY", + "value": "1", + "comment": "Day/Month/Year" + }, + { + "name": "SDL_DATE_FORMAT_MMDDYYYY", + "value": "2", + "comment": "Month/Day/Year" + } + ] + }, + { + "name": "SDL_TimeFormat", + "values": [ + { + "name": "SDL_TIME_FORMAT_24HR", + "value": "0", + "comment": "24 hour time" + }, + { + "name": "SDL_TIME_FORMAT_12HR", + "value": "1", + "comment": "12 hour time" + } + ] + } + ], + "structs": [ + { + "name": "SDL_DateTime", + "fields": [ + { + "name": "year", + "type": "int", + "comment": "Year" + }, + { + "name": "month", + "type": "int", + "comment": "Month [01-12]" + }, + { + "name": "day", + "type": "int", + "comment": "Day of the month [01-31]" + }, + { + "name": "hour", + "type": "int", + "comment": "Hour [0-23]" + }, + { + "name": "minute", + "type": "int", + "comment": "Minute [0-59]" + }, + { + "name": "second", + "type": "int", + "comment": "Seconds [0-60]" + }, + { + "name": "nanosecond", + "type": "int", + "comment": "Nanoseconds [0-999999999]" + }, + { + "name": "day_of_week", + "type": "int", + "comment": "Day of the week [0-6] (0 being Sunday)" + }, + { + "name": "utc_offset", + "type": "int", + "comment": "Seconds east of UTC" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetDateTimeLocalePreferences", + "return_type": "bool", + "parameters": [ + { + "name": "dateFormat", + "type": "SDL_DateFormat *" + }, + { + "name": "timeFormat", + "type": "SDL_TimeFormat *" + } + ] + }, + { + "name": "SDL_GetCurrentTime", + "return_type": "bool", + "parameters": [ + { + "name": "ticks", + "type": "SDL_Time *" + } + ] + }, + { + "name": "SDL_TimeToDateTime", + "return_type": "bool", + "parameters": [ + { + "name": "ticks", + "type": "SDL_Time" + }, + { + "name": "dt", + "type": "SDL_DateTime *" + }, + { + "name": "localTime", + "type": "bool" + } + ] + }, + { + "name": "SDL_DateTimeToTime", + "return_type": "bool", + "parameters": [ + { + "name": "dt", + "type": "const SDL_DateTime *" + }, + { + "name": "ticks", + "type": "SDL_Time *" + } + ] + }, + { + "name": "SDL_TimeToWindows", + "return_type": "void", + "parameters": [ + { + "name": "ticks", + "type": "SDL_Time" + }, + { + "name": "dwLowDateTime", + "type": "Uint32 *" + }, + { + "name": "dwHighDateTime", + "type": "Uint32 *" + } + ] + }, + { + "name": "SDL_TimeFromWindows", + "return_type": "SDL_Time", + "parameters": [ + { + "name": "dwLowDateTime", + "type": "Uint32" + }, + { + "name": "dwHighDateTime", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_GetDaysInMonth", + "return_type": "int", + "parameters": [ + { + "name": "year", + "type": "int" + }, + { + "name": "month", + "type": "int" + } + ] + }, + { + "name": "SDL_GetDayOfYear", + "return_type": "int", + "parameters": [ + { + "name": "year", + "type": "int" + }, + { + "name": "month", + "type": "int" + }, + { + "name": "day", + "type": "int" + } + ] + }, + { + "name": "SDL_GetDayOfWeek", + "return_type": "int", + "parameters": [ + { + "name": "year", + "type": "int" + }, + { + "name": "month", + "type": "int" + }, + { + "name": "day", + "type": "int" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/timer.json b/json/timer.json new file mode 100644 index 0000000..09372ac --- /dev/null +++ b/json/timer.json @@ -0,0 +1,150 @@ +{ + "header": "SDL_timer.h", + "opaque_types": [], + "typedefs": [ + { + "name": "SDL_TimerID", + "underlying_type": "Uint32" + } + ], + "function_pointers": [ + { + "name": "SDL_TimerCallback", + "return_type": "Uint32", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "timerID", + "type": "SDL_TimerID" + }, + { + "name": "interval", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_NSTimerCallback", + "return_type": "Uint64", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "timerID", + "type": "SDL_TimerID" + }, + { + "name": "interval", + "type": "Uint64" + } + ] + } + ], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetTicks", + "return_type": "Uint64", + "parameters": [] + }, + { + "name": "SDL_GetTicksNS", + "return_type": "Uint64", + "parameters": [] + }, + { + "name": "SDL_GetPerformanceCounter", + "return_type": "Uint64", + "parameters": [] + }, + { + "name": "SDL_GetPerformanceFrequency", + "return_type": "Uint64", + "parameters": [] + }, + { + "name": "SDL_Delay", + "return_type": "void", + "parameters": [ + { + "name": "ms", + "type": "Uint32" + } + ] + }, + { + "name": "SDL_DelayNS", + "return_type": "void", + "parameters": [ + { + "name": "ns", + "type": "Uint64" + } + ] + }, + { + "name": "SDL_DelayPrecise", + "return_type": "void", + "parameters": [ + { + "name": "ns", + "type": "Uint64" + } + ] + }, + { + "name": "SDL_AddTimer", + "return_type": "SDL_TimerID", + "parameters": [ + { + "name": "interval", + "type": "Uint32" + }, + { + "name": "callback", + "type": "SDL_TimerCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_AddTimerNS", + "return_type": "SDL_TimerID", + "parameters": [ + { + "name": "interval", + "type": "Uint64" + }, + { + "name": "callback", + "type": "SDL_NSTimerCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_RemoveTimer", + "return_type": "bool", + "parameters": [ + { + "name": "id", + "type": "SDL_TimerID" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/touch.json b/json/touch.json new file mode 100644 index 0000000..c44d327 --- /dev/null +++ b/json/touch.json @@ -0,0 +1,109 @@ +{ + "header": "SDL_touch.h", + "opaque_types": [], + "typedefs": [ + { + "name": "SDL_TouchID", + "underlying_type": "Uint64" + }, + { + "name": "SDL_FingerID", + "underlying_type": "Uint64" + } + ], + "function_pointers": [], + "enums": [ + { + "name": "SDL_TouchDeviceType", + "values": [ + { + "name": "SDL_TOUCH_DEVICE_DIRECT", + "comment": "touch screen with window-relative coordinates" + }, + { + "name": "SDL_TOUCH_DEVICE_INDIRECT_ABSOLUTE", + "comment": "trackpad with absolute device coordinates" + }, + { + "name": "SDL_TOUCH_DEVICE_INDIRECT_RELATIVE", + "comment": "trackpad with screen cursor-relative coordinates" + } + ] + } + ], + "structs": [ + { + "name": "SDL_Finger", + "fields": [ + { + "name": "id", + "type": "SDL_FingerID", + "comment": "the finger ID" + }, + { + "name": "x", + "type": "float", + "comment": "the x-axis location of the touch event, normalized (0...1)" + }, + { + "name": "y", + "type": "float", + "comment": "the y-axis location of the touch event, normalized (0...1)" + }, + { + "name": "pressure", + "type": "float", + "comment": "the quantity of pressure applied, normalized (0...1)" + } + ] + } + ], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetTouchDevices", + "return_type": "SDL_TouchID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetTouchDeviceName", + "return_type": "const char *", + "parameters": [ + { + "name": "touchID", + "type": "SDL_TouchID" + } + ] + }, + { + "name": "SDL_GetTouchDeviceType", + "return_type": "SDL_TouchDeviceType", + "parameters": [ + { + "name": "touchID", + "type": "SDL_TouchID" + } + ] + }, + { + "name": "SDL_GetTouchFingers", + "return_type": "SDL_Finger **", + "parameters": [ + { + "name": "touchID", + "type": "SDL_TouchID" + }, + { + "name": "count", + "type": "int *" + } + ] + } + ] +} \ No newline at end of file diff --git a/json/version.json b/json/version.json new file mode 100644 index 0000000..8c0e3a7 --- /dev/null +++ b/json/version.json @@ -0,0 +1,22 @@ +{ + "header": "SDL_version.h", + "opaque_types": [], + "typedefs": [], + "function_pointers": [], + "enums": [], + "structs": [], + "unions": [], + "flags": [], + "functions": [ + { + "name": "SDL_GetVersion", + "return_type": "int", + "parameters": [] + }, + { + "name": "SDL_GetRevision", + "return_type": "const char *", + "parameters": [] + } + ] +} \ No newline at end of file diff --git a/json/video.json b/json/video.json new file mode 100644 index 0000000..f3cefb3 --- /dev/null +++ b/json/video.json @@ -0,0 +1,1814 @@ +{ + "header": "SDL_video.h", + "opaque_types": [ + { + "name": "SDL_DisplayModeData" + }, + { + "name": "SDL_Window" + } + ], + "typedefs": [ + { + "name": "SDL_DisplayID", + "underlying_type": "Uint32" + }, + { + "name": "SDL_WindowID", + "underlying_type": "Uint32" + }, + { + "name": "SDL_GLContext", + "underlying_type": "struct SDL_GLContextState *" + }, + { + "name": "SDL_EGLDisplay", + "underlying_type": "void *" + }, + { + "name": "SDL_EGLConfig", + "underlying_type": "void *" + }, + { + "name": "SDL_EGLSurface", + "underlying_type": "void *" + }, + { + "name": "SDL_EGLAttrib", + "underlying_type": "intptr_t" + }, + { + "name": "SDL_EGLint", + "underlying_type": "int" + }, + { + "name": "SDL_GLProfile", + "underlying_type": "Uint32" + }, + { + "name": "SDL_GLContextFlag", + "underlying_type": "Uint32" + }, + { + "name": "SDL_GLContextReleaseFlag", + "underlying_type": "Uint32" + }, + { + "name": "SDL_GLContextResetNotification", + "underlying_type": "Uint32" + } + ], + "function_pointers": [ + { + "name": "SDL_EGLAttribArrayCallback", + "return_type": "SDL_EGLAttrib *", + "parameters": [ + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_EGLIntArrayCallback", + "return_type": "SDL_EGLint *", + "parameters": [ + { + "name": "userdata", + "type": "void *" + }, + { + "name": "display", + "type": "SDL_EGLDisplay" + }, + { + "name": "config", + "type": "SDL_EGLConfig" + } + ] + } + ], + "enums": [ + { + "name": "SDL_SystemTheme", + "values": [ + { + "name": "SDL_SYSTEM_THEME_UNKNOWN", + "comment": "Unknown system theme" + }, + { + "name": "SDL_SYSTEM_THEME_LIGHT", + "comment": "Light colored system theme" + }, + { + "name": "SDL_SYSTEM_THEME_DARK", + "comment": "Dark colored system theme" + } + ] + }, + { + "name": "SDL_DisplayOrientation", + "values": [ + { + "name": "SDL_ORIENTATION_UNKNOWN", + "comment": "The display orientation can't be determined" + }, + { + "name": "SDL_ORIENTATION_LANDSCAPE", + "comment": "The display is in landscape mode, with the right side up, relative to portrait mode" + }, + { + "name": "SDL_ORIENTATION_LANDSCAPE_FLIPPED", + "comment": "The display is in landscape mode, with the left side up, relative to portrait mode" + }, + { + "name": "SDL_ORIENTATION_PORTRAIT", + "comment": "The display is in portrait mode" + }, + { + "name": "SDL_ORIENTATION_PORTRAIT_FLIPPED" + } + ] + }, + { + "name": "SDL_FlashOperation", + "values": [ + { + "name": "SDL_FLASH_CANCEL", + "comment": "Cancel any window flash state" + }, + { + "name": "SDL_FLASH_BRIEFLY", + "comment": "Flash the window briefly to get attention" + }, + { + "name": "SDL_FLASH_UNTIL_FOCUSED", + "comment": "Flash the window until it gets focus" + } + ] + }, + { + "name": "SDL_GLAttr", + "values": [ + { + "name": "SDL_GL_RED_SIZE", + "comment": "the minimum number of bits for the red channel of the color buffer; defaults to 3." + }, + { + "name": "SDL_GL_GREEN_SIZE", + "comment": "the minimum number of bits for the green channel of the color buffer; defaults to 3." + }, + { + "name": "SDL_GL_BLUE_SIZE", + "comment": "the minimum number of bits for the blue channel of the color buffer; defaults to 2." + }, + { + "name": "SDL_GL_ALPHA_SIZE", + "comment": "the minimum number of bits for the alpha channel of the color buffer; defaults to 0." + }, + { + "name": "SDL_GL_BUFFER_SIZE", + "comment": "the minimum number of bits for frame buffer size; defaults to 0." + }, + { + "name": "SDL_GL_DOUBLEBUFFER", + "comment": "whether the output is single or double buffered; defaults to double buffering on." + }, + { + "name": "SDL_GL_DEPTH_SIZE", + "comment": "the minimum number of bits in the depth buffer; defaults to 16." + }, + { + "name": "SDL_GL_STENCIL_SIZE", + "comment": "the minimum number of bits in the stencil buffer; defaults to 0." + }, + { + "name": "SDL_GL_ACCUM_RED_SIZE", + "comment": "the minimum number of bits for the red channel of the accumulation buffer; defaults to 0." + }, + { + "name": "SDL_GL_ACCUM_GREEN_SIZE", + "comment": "the minimum number of bits for the green channel of the accumulation buffer; defaults to 0." + }, + { + "name": "SDL_GL_ACCUM_BLUE_SIZE", + "comment": "the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0." + }, + { + "name": "SDL_GL_ACCUM_ALPHA_SIZE", + "comment": "the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0." + }, + { + "name": "SDL_GL_STEREO", + "comment": "whether the output is stereo 3D; defaults to off." + }, + { + "name": "SDL_GL_MULTISAMPLEBUFFERS", + "comment": "the number of buffers used for multisample anti-aliasing; defaults to 0." + }, + { + "name": "SDL_GL_MULTISAMPLESAMPLES", + "comment": "the number of samples used around the current pixel used for multisample anti-aliasing." + }, + { + "name": "SDL_GL_ACCELERATED_VISUAL", + "comment": "set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either." + }, + { + "name": "SDL_GL_RETAINED_BACKING", + "comment": "not used (deprecated)." + }, + { + "name": "SDL_GL_CONTEXT_MAJOR_VERSION", + "comment": "OpenGL context major version." + }, + { + "name": "SDL_GL_CONTEXT_MINOR_VERSION", + "comment": "OpenGL context minor version." + }, + { + "name": "SDL_GL_CONTEXT_FLAGS", + "comment": "some combination of 0 or more of elements of the SDL_GLContextFlag enumeration; defaults to 0." + }, + { + "name": "SDL_GL_CONTEXT_PROFILE_MASK", + "comment": "type of GL context (Core, Compatibility, ES). See SDL_GLProfile; default value depends on platform." + }, + { + "name": "SDL_GL_SHARE_WITH_CURRENT_CONTEXT", + "comment": "OpenGL context sharing; defaults to 0." + }, + { + "name": "SDL_GL_FRAMEBUFFER_SRGB_CAPABLE", + "comment": "requests sRGB capable visual; defaults to 0." + }, + { + "name": "SDL_GL_CONTEXT_RELEASE_BEHAVIOR", + "comment": "sets context the release behavior. See SDL_GLContextReleaseFlag; defaults to FLUSH." + }, + { + "name": "SDL_GL_CONTEXT_RESET_NOTIFICATION", + "comment": "set context reset notification. See SDL_GLContextResetNotification; defaults to NO_NOTIFICATION." + }, + { + "name": "SDL_GL_CONTEXT_NO_ERROR" + }, + { + "name": "SDL_GL_FLOATBUFFERS" + }, + { + "name": "SDL_GL_EGL_PLATFORM" + } + ] + }, + { + "name": "SDL_HitTestResult", + "values": [ + { + "name": "SDL_HITTEST_NORMAL", + "comment": "Region is normal. No special properties." + }, + { + "name": "SDL_HITTEST_DRAGGABLE", + "comment": "Region can drag entire window." + }, + { + "name": "SDL_HITTEST_RESIZE_TOPLEFT", + "comment": "Region is the resizable top-left corner border." + }, + { + "name": "SDL_HITTEST_RESIZE_TOP", + "comment": "Region is the resizable top border." + }, + { + "name": "SDL_HITTEST_RESIZE_TOPRIGHT", + "comment": "Region is the resizable top-right corner border." + }, + { + "name": "SDL_HITTEST_RESIZE_RIGHT", + "comment": "Region is the resizable right border." + }, + { + "name": "SDL_HITTEST_RESIZE_BOTTOMRIGHT", + "comment": "Region is the resizable bottom-right corner border." + }, + { + "name": "SDL_HITTEST_RESIZE_BOTTOM", + "comment": "Region is the resizable bottom border." + }, + { + "name": "SDL_HITTEST_RESIZE_BOTTOMLEFT", + "comment": "Region is the resizable bottom-left corner border." + }, + { + "name": "SDL_HITTEST_RESIZE_LEFT", + "comment": "Region is the resizable left border." + } + ] + } + ], + "structs": [ + { + "name": "SDL_DisplayMode", + "fields": [ + { + "name": "displayID", + "type": "SDL_DisplayID", + "comment": "the display this mode is associated with" + }, + { + "name": "format", + "type": "SDL_PixelFormat", + "comment": "pixel format" + }, + { + "name": "w", + "type": "int", + "comment": "width" + }, + { + "name": "h", + "type": "int", + "comment": "height" + }, + { + "name": "pixel_density", + "type": "float", + "comment": "scale converting size to pixels (e.g. a 1920x1080 mode with 2.0 scale would have 3840x2160 pixels)" + }, + { + "name": "refresh_rate", + "type": "float", + "comment": "refresh rate (or 0.0f for unspecified)" + }, + { + "name": "refresh_rate_numerator", + "type": "int", + "comment": "precise refresh rate numerator (or 0 for unspecified)" + }, + { + "name": "refresh_rate_denominator", + "type": "int", + "comment": "precise refresh rate denominator" + }, + { + "name": "internal", + "type": "SDL_DisplayModeData *", + "comment": "Private" + } + ] + } + ], + "unions": [], + "flags": [ + { + "name": "SDL_WindowFlags", + "underlying_type": "Uint64", + "values": [ + { + "name": "SDL_WINDOW_FULLSCREEN", + "value": "SDL_UINT64_C(0x0000000000000001)", + "comment": "window is in fullscreen mode" + }, + { + "name": "SDL_WINDOW_OPENGL", + "value": "SDL_UINT64_C(0x0000000000000002)", + "comment": "window usable with OpenGL context" + }, + { + "name": "SDL_WINDOW_OCCLUDED", + "value": "SDL_UINT64_C(0x0000000000000004)", + "comment": "window is occluded" + }, + { + "name": "SDL_WINDOW_HIDDEN", + "value": "SDL_UINT64_C(0x0000000000000008)", + "comment": "window is neither mapped onto the desktop nor shown in the taskbar/dock/window list; SDL_ShowWindow() is required for it to become visible" + }, + { + "name": "SDL_WINDOW_BORDERLESS", + "value": "SDL_UINT64_C(0x0000000000000010)", + "comment": "no window decoration" + }, + { + "name": "SDL_WINDOW_RESIZABLE", + "value": "SDL_UINT64_C(0x0000000000000020)", + "comment": "window can be resized" + }, + { + "name": "SDL_WINDOW_MINIMIZED", + "value": "SDL_UINT64_C(0x0000000000000040)", + "comment": "window is minimized" + }, + { + "name": "SDL_WINDOW_MAXIMIZED", + "value": "SDL_UINT64_C(0x0000000000000080)", + "comment": "window is maximized" + }, + { + "name": "SDL_WINDOW_MOUSE_GRABBED", + "value": "SDL_UINT64_C(0x0000000000000100)", + "comment": "window has grabbed mouse input" + }, + { + "name": "SDL_WINDOW_INPUT_FOCUS", + "value": "SDL_UINT64_C(0x0000000000000200)", + "comment": "window has input focus" + }, + { + "name": "SDL_WINDOW_MOUSE_FOCUS", + "value": "SDL_UINT64_C(0x0000000000000400)", + "comment": "window has mouse focus" + }, + { + "name": "SDL_WINDOW_EXTERNAL", + "value": "SDL_UINT64_C(0x0000000000000800)", + "comment": "window not created by SDL" + }, + { + "name": "SDL_WINDOW_MODAL", + "value": "SDL_UINT64_C(0x0000000000001000)", + "comment": "window is modal" + }, + { + "name": "SDL_WINDOW_HIGH_PIXEL_DENSITY", + "value": "SDL_UINT64_C(0x0000000000002000)", + "comment": "window uses high pixel density back buffer if possible" + }, + { + "name": "SDL_WINDOW_MOUSE_CAPTURE", + "value": "SDL_UINT64_C(0x0000000000004000)", + "comment": "window has mouse captured (unrelated to MOUSE_GRABBED)" + }, + { + "name": "SDL_WINDOW_MOUSE_RELATIVE_MODE", + "value": "SDL_UINT64_C(0x0000000000008000)", + "comment": "window has relative mode enabled" + }, + { + "name": "SDL_WINDOW_ALWAYS_ON_TOP", + "value": "SDL_UINT64_C(0x0000000000010000)", + "comment": "window should always be above others" + }, + { + "name": "SDL_WINDOW_UTILITY", + "value": "SDL_UINT64_C(0x0000000000020000)", + "comment": "window should be treated as a utility window, not showing in the task bar and window list" + }, + { + "name": "SDL_WINDOW_TOOLTIP", + "value": "SDL_UINT64_C(0x0000000000040000)", + "comment": "window should be treated as a tooltip and does not get mouse or keyboard focus, requires a parent window" + }, + { + "name": "SDL_WINDOW_POPUP_MENU", + "value": "SDL_UINT64_C(0x0000000000080000)", + "comment": "window should be treated as a popup menu, requires a parent window" + }, + { + "name": "SDL_WINDOW_KEYBOARD_GRABBED", + "value": "SDL_UINT64_C(0x0000000000100000)", + "comment": "window has grabbed keyboard input" + }, + { + "name": "SDL_WINDOW_VULKAN", + "value": "SDL_UINT64_C(0x0000000010000000)", + "comment": "window usable for Vulkan surface" + }, + { + "name": "SDL_WINDOW_METAL", + "value": "SDL_UINT64_C(0x0000000020000000)", + "comment": "window usable for Metal view" + }, + { + "name": "SDL_WINDOW_TRANSPARENT", + "value": "SDL_UINT64_C(0x0000000040000000)", + "comment": "window with transparent buffer" + }, + { + "name": "SDL_WINDOW_NOT_FOCUSABLE", + "value": "SDL_UINT64_C(0x0000000080000000)", + "comment": "window should not be focusable" + } + ] + } + ], + "functions": [ + { + "name": "SDL_GetNumVideoDrivers", + "return_type": "int", + "parameters": [] + }, + { + "name": "SDL_GetVideoDriver", + "return_type": "const char *", + "parameters": [ + { + "name": "index", + "type": "int" + } + ] + }, + { + "name": "SDL_GetCurrentVideoDriver", + "return_type": "const char *", + "parameters": [] + }, + { + "name": "SDL_GetSystemTheme", + "return_type": "SDL_SystemTheme", + "parameters": [] + }, + { + "name": "SDL_GetDisplays", + "return_type": "SDL_DisplayID *", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetPrimaryDisplay", + "return_type": "SDL_DisplayID", + "parameters": [] + }, + { + "name": "SDL_GetDisplayProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetDisplayName", + "return_type": "const char *", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetDisplayBounds", + "return_type": "bool", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + }, + { + "name": "rect", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetDisplayUsableBounds", + "return_type": "bool", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + }, + { + "name": "rect", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetNaturalDisplayOrientation", + "return_type": "SDL_DisplayOrientation", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetCurrentDisplayOrientation", + "return_type": "SDL_DisplayOrientation", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetDisplayContentScale", + "return_type": "float", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetFullscreenDisplayModes", + "return_type": "SDL_DisplayMode **", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + }, + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetClosestFullscreenDisplayMode", + "return_type": "bool", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + }, + { + "name": "refresh_rate", + "type": "float" + }, + { + "name": "include_high_density_modes", + "type": "bool" + }, + { + "name": "closest", + "type": "SDL_DisplayMode *" + } + ] + }, + { + "name": "SDL_GetDesktopDisplayMode", + "return_type": "const SDL_DisplayMode *", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetCurrentDisplayMode", + "return_type": "const SDL_DisplayMode *", + "parameters": [ + { + "name": "displayID", + "type": "SDL_DisplayID" + } + ] + }, + { + "name": "SDL_GetDisplayForPoint", + "return_type": "SDL_DisplayID", + "parameters": [ + { + "name": "point", + "type": "const SDL_Point *" + } + ] + }, + { + "name": "SDL_GetDisplayForRect", + "return_type": "SDL_DisplayID", + "parameters": [ + { + "name": "rect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetDisplayForWindow", + "return_type": "SDL_DisplayID", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowPixelDensity", + "return_type": "float", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowDisplayScale", + "return_type": "float", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowFullscreenMode", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "mode", + "type": "const SDL_DisplayMode *" + } + ] + }, + { + "name": "SDL_GetWindowFullscreenMode", + "return_type": "const SDL_DisplayMode *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowICCProfile", + "return_type": "void *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "size", + "type": "size_t *" + } + ] + }, + { + "name": "SDL_GetWindowPixelFormat", + "return_type": "SDL_PixelFormat", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindows", + "return_type": "SDL_Window **", + "parameters": [ + { + "name": "count", + "type": "int *" + } + ] + }, + { + "name": "SDL_CreateWindow", + "return_type": "SDL_Window *", + "parameters": [ + { + "name": "title", + "type": "const char *" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + }, + { + "name": "flags", + "type": "SDL_WindowFlags" + } + ] + }, + { + "name": "SDL_CreatePopupWindow", + "return_type": "SDL_Window *", + "parameters": [ + { + "name": "parent", + "type": "SDL_Window *" + }, + { + "name": "offset_x", + "type": "int" + }, + { + "name": "offset_y", + "type": "int" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + }, + { + "name": "flags", + "type": "SDL_WindowFlags" + } + ] + }, + { + "name": "SDL_CreateWindowWithProperties", + "return_type": "SDL_Window *", + "parameters": [ + { + "name": "props", + "type": "SDL_PropertiesID" + } + ] + }, + { + "name": "SDL_GetWindowID", + "return_type": "SDL_WindowID", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowFromID", + "return_type": "SDL_Window *", + "parameters": [ + { + "name": "id", + "type": "SDL_WindowID" + } + ] + }, + { + "name": "SDL_GetWindowParent", + "return_type": "SDL_Window *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowProperties", + "return_type": "SDL_PropertiesID", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowFlags", + "return_type": "SDL_WindowFlags", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowTitle", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "title", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GetWindowTitle", + "return_type": "const char *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowIcon", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "icon", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_SetWindowPosition", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + } + ] + }, + { + "name": "SDL_GetWindowPosition", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "x", + "type": "int *" + }, + { + "name": "y", + "type": "int *" + } + ] + }, + { + "name": "SDL_SetWindowSize", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "w", + "type": "int" + }, + { + "name": "h", + "type": "int" + } + ] + }, + { + "name": "SDL_GetWindowSize", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "w", + "type": "int *" + }, + { + "name": "h", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetWindowSafeArea", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "rect", + "type": "SDL_Rect *" + } + ] + }, + { + "name": "SDL_SetWindowAspectRatio", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "min_aspect", + "type": "float" + }, + { + "name": "max_aspect", + "type": "float" + } + ] + }, + { + "name": "SDL_GetWindowAspectRatio", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "min_aspect", + "type": "float *" + }, + { + "name": "max_aspect", + "type": "float *" + } + ] + }, + { + "name": "SDL_GetWindowBordersSize", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "top", + "type": "int *" + }, + { + "name": "left", + "type": "int *" + }, + { + "name": "bottom", + "type": "int *" + }, + { + "name": "right", + "type": "int *" + } + ] + }, + { + "name": "SDL_GetWindowSizeInPixels", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "w", + "type": "int *" + }, + { + "name": "h", + "type": "int *" + } + ] + }, + { + "name": "SDL_SetWindowMinimumSize", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "min_w", + "type": "int" + }, + { + "name": "min_h", + "type": "int" + } + ] + }, + { + "name": "SDL_GetWindowMinimumSize", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "w", + "type": "int *" + }, + { + "name": "h", + "type": "int *" + } + ] + }, + { + "name": "SDL_SetWindowMaximumSize", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "max_w", + "type": "int" + }, + { + "name": "max_h", + "type": "int" + } + ] + }, + { + "name": "SDL_GetWindowMaximumSize", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "w", + "type": "int *" + }, + { + "name": "h", + "type": "int *" + } + ] + }, + { + "name": "SDL_SetWindowBordered", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "bordered", + "type": "bool" + } + ] + }, + { + "name": "SDL_SetWindowResizable", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "resizable", + "type": "bool" + } + ] + }, + { + "name": "SDL_SetWindowAlwaysOnTop", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "on_top", + "type": "bool" + } + ] + }, + { + "name": "SDL_ShowWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_HideWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_RaiseWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_MaximizeWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_MinimizeWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_RestoreWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowFullscreen", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "fullscreen", + "type": "bool" + } + ] + }, + { + "name": "SDL_SyncWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_WindowHasSurface", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowSurface", + "return_type": "SDL_Surface *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowSurfaceVSync", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "vsync", + "type": "int" + } + ] + }, + { + "name": "SDL_GetWindowSurfaceVSync", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "vsync", + "type": "int *" + } + ] + }, + { + "name": "SDL_UpdateWindowSurface", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_UpdateWindowSurfaceRects", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "rects", + "type": "const SDL_Rect *" + }, + { + "name": "numrects", + "type": "int" + } + ] + }, + { + "name": "SDL_DestroyWindowSurface", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowKeyboardGrab", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "grabbed", + "type": "bool" + } + ] + }, + { + "name": "SDL_SetWindowMouseGrab", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "grabbed", + "type": "bool" + } + ] + }, + { + "name": "SDL_GetWindowKeyboardGrab", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetWindowMouseGrab", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GetGrabbedWindow", + "return_type": "SDL_Window *", + "parameters": [] + }, + { + "name": "SDL_SetWindowMouseRect", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "rect", + "type": "const SDL_Rect *" + } + ] + }, + { + "name": "SDL_GetWindowMouseRect", + "return_type": "const SDL_Rect *", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowOpacity", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "opacity", + "type": "float" + } + ] + }, + { + "name": "SDL_GetWindowOpacity", + "return_type": "float", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowParent", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "parent", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_SetWindowModal", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "modal", + "type": "bool" + } + ] + }, + { + "name": "SDL_SetWindowFocusable", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "focusable", + "type": "bool" + } + ] + }, + { + "name": "SDL_ShowWindowSystemMenu", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "x", + "type": "int" + }, + { + "name": "y", + "type": "int" + } + ] + }, + { + "name": "SDL_SetWindowHitTest", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "callback", + "type": "SDL_HitTest" + }, + { + "name": "callback_data", + "type": "void *" + } + ] + }, + { + "name": "SDL_SetWindowShape", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "shape", + "type": "SDL_Surface *" + } + ] + }, + { + "name": "SDL_FlashWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "operation", + "type": "SDL_FlashOperation" + } + ] + }, + { + "name": "SDL_DestroyWindow", + "return_type": "void", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_ScreenSaverEnabled", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_EnableScreenSaver", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_DisableScreenSaver", + "return_type": "bool", + "parameters": [] + }, + { + "name": "SDL_GL_LoadLibrary", + "return_type": "bool", + "parameters": [ + { + "name": "path", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GL_GetProcAddress", + "return_type": "SDL_FunctionPointer", + "parameters": [ + { + "name": "proc", + "type": "const char *" + } + ] + }, + { + "name": "SDL_EGL_GetProcAddress", + "return_type": "SDL_FunctionPointer", + "parameters": [ + { + "name": "proc", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GL_UnloadLibrary", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_GL_ExtensionSupported", + "return_type": "bool", + "parameters": [ + { + "name": "extension", + "type": "const char *" + } + ] + }, + { + "name": "SDL_GL_ResetAttributes", + "return_type": "void", + "parameters": [] + }, + { + "name": "SDL_GL_SetAttribute", + "return_type": "bool", + "parameters": [ + { + "name": "attr", + "type": "SDL_GLAttr" + }, + { + "name": "value", + "type": "int" + } + ] + }, + { + "name": "SDL_GL_GetAttribute", + "return_type": "bool", + "parameters": [ + { + "name": "attr", + "type": "SDL_GLAttr" + }, + { + "name": "value", + "type": "int *" + } + ] + }, + { + "name": "SDL_GL_CreateContext", + "return_type": "SDL_GLContext", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GL_MakeCurrent", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + }, + { + "name": "context", + "type": "SDL_GLContext" + } + ] + }, + { + "name": "SDL_GL_GetCurrentWindow", + "return_type": "SDL_Window *", + "parameters": [] + }, + { + "name": "SDL_GL_GetCurrentContext", + "return_type": "SDL_GLContext", + "parameters": [] + }, + { + "name": "SDL_EGL_GetCurrentDisplay", + "return_type": "SDL_EGLDisplay", + "parameters": [] + }, + { + "name": "SDL_EGL_GetCurrentConfig", + "return_type": "SDL_EGLConfig", + "parameters": [] + }, + { + "name": "SDL_EGL_GetWindowSurface", + "return_type": "SDL_EGLSurface", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_EGL_SetAttributeCallbacks", + "return_type": "void", + "parameters": [ + { + "name": "platformAttribCallback", + "type": "SDL_EGLAttribArrayCallback" + }, + { + "name": "surfaceAttribCallback", + "type": "SDL_EGLIntArrayCallback" + }, + { + "name": "contextAttribCallback", + "type": "SDL_EGLIntArrayCallback" + }, + { + "name": "userdata", + "type": "void *" + } + ] + }, + { + "name": "SDL_GL_SetSwapInterval", + "return_type": "bool", + "parameters": [ + { + "name": "interval", + "type": "int" + } + ] + }, + { + "name": "SDL_GL_GetSwapInterval", + "return_type": "bool", + "parameters": [ + { + "name": "interval", + "type": "int *" + } + ] + }, + { + "name": "SDL_GL_SwapWindow", + "return_type": "bool", + "parameters": [ + { + "name": "window", + "type": "SDL_Window *" + } + ] + }, + { + "name": "SDL_GL_DestroyContext", + "return_type": "bool", + "parameters": [ + { + "name": "context", + "type": "SDL_GLContext" + } + ] + } + ] +} \ No newline at end of file diff --git a/v2/audio.zig b/v2/audio.zig new file mode 100644 index 0000000..460a299 --- /dev/null +++ b/v2/audio.zig @@ -0,0 +1,256 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PropertiesID = u32; + +pub const IOStream = opaque { + pub inline fn loadWAV_IO(iostream: *IOStream, closeio: bool, spec: ?*AudioSpec, audio_buf: [*c][*c]u8, audio_len: *u32) bool { + return c.SDL_LoadWAV_IO(iostream, closeio, spec, audio_buf, @ptrCast(audio_len)); + } +}; + +pub const AudioFormat = enum(c_int) { + audioUnknown, //Unspecified audio format + audioU8, //Unsigned 8-bit samples + audioS8, //Signed 8-bit samples + audioS16le, //Signed 16-bit samples + audioS16be, //As above, but big-endian byte order + audioS32le, //32-bit integer samples + audioS32be, //As above, but big-endian byte order + audioF32le, //32-bit floating point samples + audioF32be, //As above, but big-endian byte order +}; + +pub const AudioDeviceID = u32; + +pub const AudioSpec = extern struct { + format: AudioFormat, // Audio data format + channels: c_int, // Number of channels: 1 mono, 2 stereo, etc + freq: c_int, // sample rate: sample frames per second +}; + +pub const AudioStream = opaque { + pub inline fn unbindAudioStream(audiostream: *AudioStream) void { + return c.SDL_UnbindAudioStream(audiostream); + } + + pub inline fn getAudioStreamDevice(audiostream: *AudioStream) AudioDeviceID { + return c.SDL_GetAudioStreamDevice(audiostream); + } + + pub inline fn getAudioStreamProperties(audiostream: *AudioStream) PropertiesID { + return c.SDL_GetAudioStreamProperties(audiostream); + } + + pub inline fn getAudioStreamFormat(audiostream: *AudioStream, src_spec: ?*AudioSpec, dst_spec: ?*AudioSpec) bool { + return c.SDL_GetAudioStreamFormat(audiostream, src_spec, dst_spec); + } + + pub inline fn setAudioStreamFormat(audiostream: *AudioStream, src_spec: *const AudioSpec, dst_spec: *const AudioSpec) bool { + return c.SDL_SetAudioStreamFormat(audiostream, @ptrCast(src_spec), @ptrCast(dst_spec)); + } + + pub inline fn getAudioStreamFrequencyRatio(audiostream: *AudioStream) f32 { + return c.SDL_GetAudioStreamFrequencyRatio(audiostream); + } + + pub inline fn setAudioStreamFrequencyRatio(audiostream: *AudioStream, ratio: f32) bool { + return c.SDL_SetAudioStreamFrequencyRatio(audiostream, ratio); + } + + pub inline fn getAudioStreamGain(audiostream: *AudioStream) f32 { + return c.SDL_GetAudioStreamGain(audiostream); + } + + pub inline fn setAudioStreamGain(audiostream: *AudioStream, gain: f32) bool { + return c.SDL_SetAudioStreamGain(audiostream, gain); + } + + pub inline fn getAudioStreamInputChannelMap(audiostream: *AudioStream, count: *c_int) *c_int { + return @ptrCast(c.SDL_GetAudioStreamInputChannelMap(audiostream, @ptrCast(count))); + } + + pub inline fn getAudioStreamOutputChannelMap(audiostream: *AudioStream, count: *c_int) *c_int { + return @ptrCast(c.SDL_GetAudioStreamOutputChannelMap(audiostream, @ptrCast(count))); + } + + pub inline fn setAudioStreamInputChannelMap(audiostream: *AudioStream, chmap: [*c]const c_int, count: c_int) bool { + return c.SDL_SetAudioStreamInputChannelMap(audiostream, chmap, count); + } + + pub inline fn setAudioStreamOutputChannelMap(audiostream: *AudioStream, chmap: [*c]const c_int, count: c_int) bool { + return c.SDL_SetAudioStreamOutputChannelMap(audiostream, chmap, count); + } + + pub inline fn putAudioStreamData(audiostream: *AudioStream, buf: ?*const anyopaque, len: c_int) bool { + return c.SDL_PutAudioStreamData(audiostream, buf, len); + } + + pub inline fn getAudioStreamData(audiostream: *AudioStream, buf: ?*anyopaque, len: c_int) c_int { + return c.SDL_GetAudioStreamData(audiostream, buf, len); + } + + pub inline fn getAudioStreamAvailable(audiostream: *AudioStream) c_int { + return c.SDL_GetAudioStreamAvailable(audiostream); + } + + pub inline fn getAudioStreamQueued(audiostream: *AudioStream) c_int { + return c.SDL_GetAudioStreamQueued(audiostream); + } + + pub inline fn flushAudioStream(audiostream: *AudioStream) bool { + return c.SDL_FlushAudioStream(audiostream); + } + + pub inline fn clearAudioStream(audiostream: *AudioStream) bool { + return c.SDL_ClearAudioStream(audiostream); + } + + pub inline fn pauseAudioStreamDevice(audiostream: *AudioStream) bool { + return c.SDL_PauseAudioStreamDevice(audiostream); + } + + pub inline fn resumeAudioStreamDevice(audiostream: *AudioStream) bool { + return c.SDL_ResumeAudioStreamDevice(audiostream); + } + + pub inline fn audioStreamDevicePaused(audiostream: *AudioStream) bool { + return c.SDL_AudioStreamDevicePaused(audiostream); + } + + pub inline fn lockAudioStream(audiostream: *AudioStream) bool { + return c.SDL_LockAudioStream(audiostream); + } + + pub inline fn unlockAudioStream(audiostream: *AudioStream) bool { + return c.SDL_UnlockAudioStream(audiostream); + } + + pub inline fn setAudioStreamGetCallback(audiostream: *AudioStream, callback: AudioStreamCallback, userdata: ?*anyopaque) bool { + return c.SDL_SetAudioStreamGetCallback(audiostream, callback, userdata); + } + + pub inline fn setAudioStreamPutCallback(audiostream: *AudioStream, callback: AudioStreamCallback, userdata: ?*anyopaque) bool { + return c.SDL_SetAudioStreamPutCallback(audiostream, callback, userdata); + } + + pub inline fn destroyAudioStream(audiostream: *AudioStream) void { + return c.SDL_DestroyAudioStream(audiostream); + } +}; + +pub inline fn getNumAudioDrivers() c_int { + return c.SDL_GetNumAudioDrivers(); +} + +pub inline fn getAudioDriver(index: c_int) [*c]const u8 { + return c.SDL_GetAudioDriver(index); +} + +pub inline fn getCurrentAudioDriver() [*c]const u8 { + return c.SDL_GetCurrentAudioDriver(); +} + +pub inline fn getAudioPlaybackDevices(count: *c_int) ?*AudioDeviceID { + return c.SDL_GetAudioPlaybackDevices(@ptrCast(count)); +} + +pub inline fn getAudioRecordingDevices(count: *c_int) ?*AudioDeviceID { + return c.SDL_GetAudioRecordingDevices(@ptrCast(count)); +} + +pub inline fn getAudioDeviceName(devid: AudioDeviceID) [*c]const u8 { + return c.SDL_GetAudioDeviceName(devid); +} + +pub inline fn getAudioDeviceFormat(devid: AudioDeviceID, spec: ?*AudioSpec, sample_frames: *c_int) bool { + return c.SDL_GetAudioDeviceFormat(devid, spec, @ptrCast(sample_frames)); +} + +pub inline fn getAudioDeviceChannelMap(devid: AudioDeviceID, count: *c_int) *c_int { + return @ptrCast(c.SDL_GetAudioDeviceChannelMap(devid, @ptrCast(count))); +} + +pub inline fn openAudioDevice(devid: AudioDeviceID, spec: *const AudioSpec) AudioDeviceID { + return c.SDL_OpenAudioDevice(devid, @ptrCast(spec)); +} + +pub inline fn isAudioDevicePhysical(devid: AudioDeviceID) bool { + return c.SDL_IsAudioDevicePhysical(devid); +} + +pub inline fn isAudioDevicePlayback(devid: AudioDeviceID) bool { + return c.SDL_IsAudioDevicePlayback(devid); +} + +pub inline fn pauseAudioDevice(devid: AudioDeviceID) bool { + return c.SDL_PauseAudioDevice(devid); +} + +pub inline fn resumeAudioDevice(devid: AudioDeviceID) bool { + return c.SDL_ResumeAudioDevice(devid); +} + +pub inline fn audioDevicePaused(devid: AudioDeviceID) bool { + return c.SDL_AudioDevicePaused(devid); +} + +pub inline fn getAudioDeviceGain(devid: AudioDeviceID) f32 { + return c.SDL_GetAudioDeviceGain(devid); +} + +pub inline fn setAudioDeviceGain(devid: AudioDeviceID, gain: f32) bool { + return c.SDL_SetAudioDeviceGain(devid, gain); +} + +pub inline fn closeAudioDevice(devid: AudioDeviceID) void { + return c.SDL_CloseAudioDevice(devid); +} + +pub inline fn bindAudioStreams(devid: AudioDeviceID, streams: [*c]*const AudioStream, num_streams: c_int) bool { + return c.SDL_BindAudioStreams(devid, streams, num_streams); +} + +pub inline fn bindAudioStream(devid: AudioDeviceID, stream: ?*AudioStream) bool { + return c.SDL_BindAudioStream(devid, stream); +} + +pub inline fn unbindAudioStreams(streams: [*c]*const AudioStream, num_streams: c_int) void { + return c.SDL_UnbindAudioStreams(streams, num_streams); +} + +pub inline fn createAudioStream(src_spec: *const AudioSpec, dst_spec: *const AudioSpec) ?*AudioStream { + return c.SDL_CreateAudioStream(@ptrCast(src_spec), @ptrCast(dst_spec)); +} + +pub const AudioStreamCallback = *const fn (userdata: ?*anyopaque, stream: ?*AudioStream, additional_amount: c_int, total_amount: c_int) callconv(.C) void; + +pub inline fn openAudioDeviceStream(devid: AudioDeviceID, spec: *const AudioSpec, callback: AudioStreamCallback, userdata: ?*anyopaque) ?*AudioStream { + return c.SDL_OpenAudioDeviceStream(devid, @ptrCast(spec), callback, userdata); +} + +pub const AudioPostmixCallback = *const fn (userdata: ?*anyopaque, spec: *const AudioSpec, buffer: *f32, buflen: c_int) callconv(.C) void; + +pub inline fn setAudioPostmixCallback(devid: AudioDeviceID, callback: AudioPostmixCallback, userdata: ?*anyopaque) bool { + return c.SDL_SetAudioPostmixCallback(devid, callback, userdata); +} + +pub inline fn loadWAV(path: [*c]const u8, spec: ?*AudioSpec, audio_buf: [*c][*c]u8, audio_len: *u32) bool { + return c.SDL_LoadWAV(path, spec, audio_buf, @ptrCast(audio_len)); +} + +pub inline fn mixAudio(dst: [*c]u8, src: [*c]const u8, format: AudioFormat, len: u32, volume: f32) bool { + return c.SDL_MixAudio(dst, src, @bitCast(format), len, volume); +} + +pub inline fn convertAudioSamples(src_spec: *const AudioSpec, src_data: [*c]const u8, src_len: c_int, dst_spec: *const AudioSpec, dst_data: [*c][*c]u8, dst_len: *c_int) bool { + return c.SDL_ConvertAudioSamples(@ptrCast(src_spec), src_data, src_len, @ptrCast(dst_spec), dst_data, @ptrCast(dst_len)); +} + +pub inline fn getAudioFormatName(format: AudioFormat) [*c]const u8 { + return c.SDL_GetAudioFormatName(@bitCast(format)); +} + +pub inline fn getSilenceValueForFormat(format: AudioFormat) c_int { + return c.SDL_GetSilenceValueForFormat(@bitCast(format)); +} diff --git a/v2/blendmode.zig b/v2/blendmode.zig new file mode 100644 index 0000000..b2a88d3 --- /dev/null +++ b/v2/blendmode.zig @@ -0,0 +1,29 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const BlendMode = u32; + +pub const BlendOperation = enum(c_int) { + blendoperationAdd, //dst + src: supported by all renderers + blendoperationSubtract, //src - dst : supported by D3D, OpenGL, OpenGLES, and Vulkan + blendoperationRevSubtract, //dst - src : supported by D3D, OpenGL, OpenGLES, and Vulkan + blendoperationMinimum, //min(dst, src) : supported by D3D, OpenGL, OpenGLES, and Vulkan + blendoperationMaximum, +}; + +pub const BlendFactor = enum(c_int) { + blendfactorZero, //0, 0, 0, 0 + blendfactorOne, //1, 1, 1, 1 + blendfactorSrcColor, //srcR, srcG, srcB, srcA + blendfactorOneMinusSrcColor, //1-srcR, 1-srcG, 1-srcB, 1-srcA + blendfactorSrcAlpha, //srcA, srcA, srcA, srcA + blendfactorOneMinusSrcAlpha, //1-srcA, 1-srcA, 1-srcA, 1-srcA + blendfactorDstColor, //dstR, dstG, dstB, dstA + blendfactorOneMinusDstColor, //1-dstR, 1-dstG, 1-dstB, 1-dstA + blendfactorDstAlpha, //dstA, dstA, dstA, dstA + blendfactorOneMinusDstAlpha, +}; + +pub inline fn composeCustomBlendMode(srcColorFactor: BlendFactor, dstColorFactor: BlendFactor, colorOperation: BlendOperation, srcAlphaFactor: BlendFactor, dstAlphaFactor: BlendFactor, alphaOperation: BlendOperation) BlendMode { + return @intFromEnum(c.SDL_ComposeCustomBlendMode(srcColorFactor, dstColorFactor, @intFromEnum(colorOperation), srcAlphaFactor, dstAlphaFactor, @intFromEnum(alphaOperation))); +} diff --git a/v2/camera.zig b/v2/camera.zig new file mode 100644 index 0000000..38d2192 --- /dev/null +++ b/v2/camera.zig @@ -0,0 +1,127 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PixelFormat = enum(c_int) { + pixelformatYv12, //Planar mode: Y + V + U (3 planes) + pixelformatIyuv, //Planar mode: Y + U + V (3 planes) + pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane) + pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane) + pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane) + pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes) + pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatExternalOes, //Android video texture format + pixelformatMjpg, //Motion JPEG +}; + +pub const Surface = opaque {}; + +pub const Colorspace = enum(c_int) { + colorspaceSrgb, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 + colorRangeFull, + colorPrimariesBt709, + transferCharacteristicsSrgb, + matrixCoefficientsIdentity, + colorspaceSrgbLinear, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 + transferCharacteristicsLinear, + colorspaceHdr10, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 + colorPrimariesBt2020, + transferCharacteristicsPq, + colorspaceJpeg, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 + transferCharacteristicsBt601, + matrixCoefficientsBt601, + colorspaceBt601Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 + colorRangeLimited, + colorPrimariesBt601, + colorspaceBt601Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 + colorspaceBt709Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 + transferCharacteristicsBt709, + matrixCoefficientsBt709, + colorspaceBt709Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 + colorspaceBt2020Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 + matrixCoefficientsBt2020Ncl, + colorspaceBt2020Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 + colorspaceRgbDefault, //The default colorspace for RGB surfaces if no colorspace is specified + colorspaceYuvDefault, //The default colorspace for YUV surfaces if no colorspace is specified +}; + +pub const PropertiesID = u32; + +pub const CameraID = u32; + +pub const Camera = opaque { + pub inline fn getCameraPermissionState(camera: *Camera) c_int { + return c.SDL_GetCameraPermissionState(camera); + } + + pub inline fn getCameraID(camera: *Camera) CameraID { + return c.SDL_GetCameraID(camera); + } + + pub inline fn getCameraProperties(camera: *Camera) PropertiesID { + return c.SDL_GetCameraProperties(camera); + } + + pub inline fn getCameraFormat(camera: *Camera, spec: ?*CameraSpec) bool { + return c.SDL_GetCameraFormat(camera, spec); + } + + pub inline fn acquireCameraFrame(camera: *Camera, timestampNS: *u64) ?*Surface { + return c.SDL_AcquireCameraFrame(camera, @ptrCast(timestampNS)); + } + + pub inline fn releaseCameraFrame(camera: *Camera, frame: ?*Surface) void { + return c.SDL_ReleaseCameraFrame(camera, frame); + } + + pub inline fn closeCamera(camera: *Camera) void { + return c.SDL_CloseCamera(camera); + } +}; + +pub const CameraSpec = extern struct { + format: PixelFormat, // Frame format + colorspace: Colorspace, // Frame colorspace + width: c_int, // Frame width + height: c_int, // Frame height + framerate_numerator: c_int, // Frame rate numerator ((num / denom) == FPS, (denom / num) == duration in seconds) + framerate_denominator: c_int, // Frame rate demoninator ((num / denom) == FPS, (denom / num) == duration in seconds) +}; + +pub const CameraPosition = enum(c_int) { + cameraPositionUnknown, + cameraPositionFrontFacing, + cameraPositionBackFacing, +}; + +pub inline fn getNumCameraDrivers() c_int { + return c.SDL_GetNumCameraDrivers(); +} + +pub inline fn getCameraDriver(index: c_int) [*c]const u8 { + return c.SDL_GetCameraDriver(index); +} + +pub inline fn getCurrentCameraDriver() [*c]const u8 { + return c.SDL_GetCurrentCameraDriver(); +} + +pub inline fn getCameras(count: *c_int) ?*CameraID { + return c.SDL_GetCameras(@ptrCast(count)); +} + +pub inline fn getCameraSupportedFormats(instance_id: CameraID, count: *c_int) [*c][*c]CameraSpec { + return c.SDL_GetCameraSupportedFormats(instance_id, @ptrCast(count)); +} + +pub inline fn getCameraName(instance_id: CameraID) [*c]const u8 { + return c.SDL_GetCameraName(instance_id); +} + +pub inline fn getCameraPosition(instance_id: CameraID) CameraPosition { + return c.SDL_GetCameraPosition(instance_id); +} + +pub inline fn openCamera(instance_id: CameraID, spec: *const CameraSpec) ?*Camera { + return c.SDL_OpenCamera(instance_id, @ptrCast(spec)); +} diff --git a/v2/clipboard.zig b/v2/clipboard.zig new file mode 100644 index 0000000..3ef3600 --- /dev/null +++ b/v2/clipboard.zig @@ -0,0 +1,50 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub inline fn setClipboardText(text: [*c]const u8) bool { + return c.SDL_SetClipboardText(text); +} + +pub inline fn getClipboardText() [*c]u8 { + return c.SDL_GetClipboardText(); +} + +pub inline fn hasClipboardText() bool { + return c.SDL_HasClipboardText(); +} + +pub inline fn setPrimarySelectionText(text: [*c]const u8) bool { + return c.SDL_SetPrimarySelectionText(text); +} + +pub inline fn getPrimarySelectionText() [*c]u8 { + return c.SDL_GetPrimarySelectionText(); +} + +pub inline fn hasPrimarySelectionText() bool { + return c.SDL_HasPrimarySelectionText(); +} + +pub const ClipboardDataCallback = *const fn (userdata: ?*anyopaque, mime_type: [*c]const u8, size: *usize) callconv(.C) ?*const anyopaque; + +pub const ClipboardCleanupCallback = *const fn (userdata: ?*anyopaque) callconv(.C) void; + +pub inline fn setClipboardData(callback: ClipboardDataCallback, cleanup: ClipboardCleanupCallback, userdata: ?*anyopaque, mime_types: [*c][*c]const u8, num_mime_types: usize) bool { + return c.SDL_SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types); +} + +pub inline fn clearClipboardData() bool { + return c.SDL_ClearClipboardData(); +} + +pub inline fn getClipboardData(mime_type: [*c]const u8, size: *usize) ?*anyopaque { + return c.SDL_GetClipboardData(mime_type, @ptrCast(size)); +} + +pub inline fn hasClipboardData(mime_type: [*c]const u8) bool { + return c.SDL_HasClipboardData(mime_type); +} + +pub inline fn getClipboardMimeTypes(num_mime_types: *usize) [*c][*c]u8 { + return c.SDL_GetClipboardMimeTypes(@ptrCast(num_mime_types)); +} diff --git a/v2/dialog.zig b/v2/dialog.zig new file mode 100644 index 0000000..9ea659b --- /dev/null +++ b/v2/dialog.zig @@ -0,0 +1,35 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Window = opaque {}; + +pub const PropertiesID = u32; + +pub const DialogFileFilter = extern struct { + name: [*c]const u8, + pattern: [*c]const u8, +}; + +pub const DialogFileCallback = *const fn (userdata: ?*anyopaque, filelist: [*c]const [*c]const u8, filter: c_int) callconv(.C) void; + +pub inline fn showOpenFileDialog(callback: DialogFileCallback, userdata: ?*anyopaque, window: ?*Window, filters: *const DialogFileFilter, nfilters: c_int, default_location: [*c]const u8, allow_many: bool) void { + return c.SDL_ShowOpenFileDialog(callback, userdata, window, @ptrCast(filters), nfilters, default_location, allow_many); +} + +pub inline fn showSaveFileDialog(callback: DialogFileCallback, userdata: ?*anyopaque, window: ?*Window, filters: *const DialogFileFilter, nfilters: c_int, default_location: [*c]const u8) void { + return c.SDL_ShowSaveFileDialog(callback, userdata, window, @ptrCast(filters), nfilters, default_location); +} + +pub inline fn showOpenFolderDialog(callback: DialogFileCallback, userdata: ?*anyopaque, window: ?*Window, default_location: [*c]const u8, allow_many: bool) void { + return c.SDL_ShowOpenFolderDialog(callback, userdata, window, default_location, allow_many); +} + +pub const FileDialogType = enum(c_int) { + filedialogOpenfile, + filedialogSavefile, + filedialogOpenfolder, +}; + +pub inline fn showFileDialogWithProperties(_type: FileDialogType, callback: DialogFileCallback, userdata: ?*anyopaque, props: PropertiesID) void { + return c.SDL_ShowFileDialogWithProperties(@intFromEnum(_type), callback, userdata, props); +} diff --git a/v2/endian.zig b/v2/endian.zig new file mode 100644 index 0000000..c1f53b9 --- /dev/null +++ b/v2/endian.zig @@ -0,0 +1,2 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; diff --git a/v2/error.zig b/v2/error.zig new file mode 100644 index 0000000..91ba5bd --- /dev/null +++ b/v2/error.zig @@ -0,0 +1,24 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub inline fn setError(fmt: [*c]const u8, ...) bool { + return c.SDL_SetError( + fmt, + ); +} + +pub inline fn setErrorV(fmt: [*c]const u8, ap: std.builtin.VaList) bool { + return c.SDL_SetErrorV(fmt, ap); +} + +pub inline fn outOfMemory() bool { + return c.SDL_OutOfMemory(); +} + +pub inline fn getError() [*c]const u8 { + return c.SDL_GetError(); +} + +pub inline fn clearError() bool { + return c.SDL_ClearError(); +} diff --git a/v2/filesystem.zig b/v2/filesystem.zig new file mode 100644 index 0000000..ed0e731 --- /dev/null +++ b/v2/filesystem.zig @@ -0,0 +1,92 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Time = i64; + +pub inline fn getBasePath() [*c]const u8 { + return c.SDL_GetBasePath(); +} + +pub inline fn getPrefPath(org: [*c]const u8, app: [*c]const u8) [*c]u8 { + return c.SDL_GetPrefPath(org, app); +} + +pub const Folder = enum(c_int) { + folderHome, //The folder which contains all of the current user's data, preferences, and documents. It usually contains most of the other folders. If a requested folder does not exist, the home folder can be considered a safe fallback to store a user's documents. + folderDesktop, //The folder of files that are displayed on the desktop. Note that the existence of a desktop folder does not guarantee that the system does show icons on its desktop; certain GNU/Linux distros with a graphical environment may not have desktop icons. + folderDocuments, //User document files, possibly application-specific. This is a good place to save a user's projects. + folderDownloads, //Standard folder for user files downloaded from the internet. + folderMusic, //Music files that can be played using a standard music player (mp3, ogg...). + folderPictures, //Image files that can be displayed using a standard viewer (png, jpg...). + folderPublicshare, //Files that are meant to be shared with other users on the same computer. + folderSavedgames, //Save files for games. + folderScreenshots, //Application screenshots. + folderTemplates, //Template files to be used when the user requests the desktop environment to create a new file in a certain folder, such as "New Text File.txt". Any file in the Templates folder can be used as a starting point for a new file. + folderVideos, //Video files that can be played using a standard video player (mp4, webm...). + folderCount, +}; + +pub inline fn getUserFolder(folder: Folder) [*c]const u8 { + return c.SDL_GetUserFolder(folder); +} + +pub const PathType = enum(c_int) { + pathtypeNone, //path does not exist + pathtypeFile, //a normal file + pathtypeDirectory, //a directory + pathtypeOther, +}; + +pub const PathInfo = extern struct { + _type: PathType, // the path type + size: u64, // the file size in bytes + create_time: Time, // the time when the path was created + modify_time: Time, // the last time the path was modified + access_time: Time, // the last time the path was read +}; + +pub const GlobFlags = packed struct(u32) { + globCaseinsensitive: bool = false, + pad0: u30 = 0, + rsvd: bool = false, +}; + +pub inline fn createDirectory(path: [*c]const u8) bool { + return c.SDL_CreateDirectory(path); +} + +pub const EnumerationResult = enum(c_int) { + enumContinue, //Value that requests that enumeration continue. + enumSuccess, //Value that requests that enumeration stop, successfully. + enumFailure, +}; + +pub const EnumerateDirectoryCallback = *const fn (userdata: ?*anyopaque, dirname: [*c]const u8, fname: [*c]const u8) callconv(.C) EnumerationResult; + +pub inline fn enumerateDirectory(path: [*c]const u8, callback: EnumerateDirectoryCallback, userdata: ?*anyopaque) bool { + return c.SDL_EnumerateDirectory(path, callback, userdata); +} + +pub inline fn removePath(path: [*c]const u8) bool { + return c.SDL_RemovePath(path); +} + +pub inline fn renamePath(oldpath: [*c]const u8, newpath: [*c]const u8) bool { + return c.SDL_RenamePath(oldpath, newpath); +} + +pub inline fn copyFile(oldpath: [*c]const u8, newpath: [*c]const u8) bool { + return c.SDL_CopyFile(oldpath, newpath); +} + +pub inline fn getPathInfo(path: [*c]const u8, info: ?*PathInfo) bool { + return c.SDL_GetPathInfo(path, info); +} + +pub inline fn globDirectory(path: [*c]const u8, pattern: [*c]const u8, flags: GlobFlags, count: *c_int) [*c][*c]u8 { + return c.SDL_GlobDirectory(path, pattern, @bitCast(flags), @ptrCast(count)); +} + +pub inline fn getCurrentDirectory() [*c]u8 { + return c.SDL_GetCurrentDirectory(); +} diff --git a/v2/gamepad.zig b/v2/gamepad.zig new file mode 100644 index 0000000..91b8750 --- /dev/null +++ b/v2/gamepad.zig @@ -0,0 +1,421 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const JoystickConnectionState = enum(c_int) { + joystickConnectionUnknown, + joystickConnectionWired, + joystickConnectionWireless, +}; + +pub const GUID = extern struct { + data: [16]u8, +}; + +pub const PropertiesID = u32; + +pub const IOStream = opaque { + pub inline fn addGamepadMappingsFromIO(iostream: *IOStream, closeio: bool) c_int { + return c.SDL_AddGamepadMappingsFromIO(iostream, closeio); + } +}; + +pub const JoystickID = u32; + +pub const SensorType = enum(c_int) { + sensorInvalid, //Returned for an invalid sensor + sensorUnknown, //Unknown sensor type + sensorAccel, //Accelerometer + sensorGyro, //Gyroscope + sensorAccelL, //Accelerometer for left Joy-Con controller and Wii nunchuk + sensorGyroL, //Gyroscope for left Joy-Con controller + sensorAccelR, //Accelerometer for right Joy-Con controller + sensorGyroR, //Gyroscope for right Joy-Con controller +}; + +pub const PowerState = enum(c_int) { + powerstateError, //error determining power status + powerstateUnknown, //cannot determine power status + powerstateOnBattery, //Not plugged in, running on the battery + powerstateNoBattery, //Plugged in, no battery available + powerstateCharging, //Plugged in, charging battery + powerstateCharged, +}; + +pub const Joystick = opaque {}; + +pub const Gamepad = opaque { + pub inline fn getGamepadMapping(gamepad: *Gamepad) [*c]u8 { + return c.SDL_GetGamepadMapping(gamepad); + } + + pub inline fn getGamepadProperties(gamepad: *Gamepad) PropertiesID { + return c.SDL_GetGamepadProperties(gamepad); + } + + pub inline fn getGamepadID(gamepad: *Gamepad) JoystickID { + return c.SDL_GetGamepadID(gamepad); + } + + pub inline fn getGamepadName(gamepad: *Gamepad) [*c]const u8 { + return c.SDL_GetGamepadName(gamepad); + } + + pub inline fn getGamepadPath(gamepad: *Gamepad) [*c]const u8 { + return c.SDL_GetGamepadPath(gamepad); + } + + pub inline fn getGamepadType(gamepad: *Gamepad) GamepadType { + return @intFromEnum(c.SDL_GetGamepadType(gamepad)); + } + + pub inline fn getRealGamepadType(gamepad: *Gamepad) GamepadType { + return @intFromEnum(c.SDL_GetRealGamepadType(gamepad)); + } + + pub inline fn getGamepadPlayerIndex(gamepad: *Gamepad) c_int { + return c.SDL_GetGamepadPlayerIndex(gamepad); + } + + pub inline fn setGamepadPlayerIndex(gamepad: *Gamepad, player_index: c_int) bool { + return c.SDL_SetGamepadPlayerIndex(gamepad, player_index); + } + + pub inline fn getGamepadVendor(gamepad: *Gamepad) u16 { + return c.SDL_GetGamepadVendor(gamepad); + } + + pub inline fn getGamepadProduct(gamepad: *Gamepad) u16 { + return c.SDL_GetGamepadProduct(gamepad); + } + + pub inline fn getGamepadProductVersion(gamepad: *Gamepad) u16 { + return c.SDL_GetGamepadProductVersion(gamepad); + } + + pub inline fn getGamepadFirmwareVersion(gamepad: *Gamepad) u16 { + return c.SDL_GetGamepadFirmwareVersion(gamepad); + } + + pub inline fn getGamepadSerial(gamepad: *Gamepad) [*c]const u8 { + return c.SDL_GetGamepadSerial(gamepad); + } + + pub inline fn getGamepadSteamHandle(gamepad: *Gamepad) u64 { + return c.SDL_GetGamepadSteamHandle(gamepad); + } + + pub inline fn getGamepadConnectionState(gamepad: *Gamepad) JoystickConnectionState { + return c.SDL_GetGamepadConnectionState(gamepad); + } + + pub inline fn getGamepadPowerInfo(gamepad: *Gamepad, percent: *c_int) PowerState { + return c.SDL_GetGamepadPowerInfo(gamepad, @ptrCast(percent)); + } + + pub inline fn gamepadConnected(gamepad: *Gamepad) bool { + return c.SDL_GamepadConnected(gamepad); + } + + pub inline fn getGamepadJoystick(gamepad: *Gamepad) ?*Joystick { + return c.SDL_GetGamepadJoystick(gamepad); + } + + pub inline fn getGamepadBindings(gamepad: *Gamepad, count: *c_int) [*c][*c]GamepadBinding { + return c.SDL_GetGamepadBindings(gamepad, @ptrCast(count)); + } + + pub inline fn gamepadHasAxis(gamepad: *Gamepad, axis: GamepadAxis) bool { + return c.SDL_GamepadHasAxis(gamepad, axis); + } + + pub inline fn getGamepadAxis(gamepad: *Gamepad, axis: GamepadAxis) i16 { + return c.SDL_GetGamepadAxis(gamepad, axis); + } + + pub inline fn gamepadHasButton(gamepad: *Gamepad, button: GamepadButton) bool { + return c.SDL_GamepadHasButton(gamepad, button); + } + + pub inline fn getGamepadButton(gamepad: *Gamepad, button: GamepadButton) bool { + return c.SDL_GetGamepadButton(gamepad, button); + } + + pub inline fn getGamepadButtonLabel(gamepad: *Gamepad, button: GamepadButton) GamepadButtonLabel { + return c.SDL_GetGamepadButtonLabel(gamepad, button); + } + + pub inline fn getNumGamepadTouchpads(gamepad: *Gamepad) c_int { + return c.SDL_GetNumGamepadTouchpads(gamepad); + } + + pub inline fn getNumGamepadTouchpadFingers(gamepad: *Gamepad, touchpad: c_int) c_int { + return c.SDL_GetNumGamepadTouchpadFingers(gamepad, touchpad); + } + + pub inline fn getGamepadTouchpadFinger(gamepad: *Gamepad, touchpad: c_int, finger: c_int, down: *bool, x: *f32, y: *f32, pressure: *f32) bool { + return c.SDL_GetGamepadTouchpadFinger(gamepad, touchpad, finger, @ptrCast(down), @ptrCast(x), @ptrCast(y), @ptrCast(pressure)); + } + + pub inline fn gamepadHasSensor(gamepad: *Gamepad, _type: SensorType) bool { + return c.SDL_GamepadHasSensor(gamepad, @intFromEnum(_type)); + } + + pub inline fn setGamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType, enabled: bool) bool { + return c.SDL_SetGamepadSensorEnabled(gamepad, @intFromEnum(_type), enabled); + } + + pub inline fn gamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType) bool { + return c.SDL_GamepadSensorEnabled(gamepad, @intFromEnum(_type)); + } + + pub inline fn getGamepadSensorDataRate(gamepad: *Gamepad, _type: SensorType) f32 { + return c.SDL_GetGamepadSensorDataRate(gamepad, @intFromEnum(_type)); + } + + pub inline fn getGamepadSensorData(gamepad: *Gamepad, _type: SensorType, data: *f32, num_values: c_int) bool { + return c.SDL_GetGamepadSensorData(gamepad, @intFromEnum(_type), @ptrCast(data), num_values); + } + + pub inline fn rumbleGamepad(gamepad: *Gamepad, low_frequency_rumble: u16, high_frequency_rumble: u16, duration_ms: u32) bool { + return c.SDL_RumbleGamepad(gamepad, low_frequency_rumble, high_frequency_rumble, duration_ms); + } + + pub inline fn rumbleGamepadTriggers(gamepad: *Gamepad, left_rumble: u16, right_rumble: u16, duration_ms: u32) bool { + return c.SDL_RumbleGamepadTriggers(gamepad, left_rumble, right_rumble, duration_ms); + } + + pub inline fn setGamepadLED(gamepad: *Gamepad, red: u8, green: u8, blue: u8) bool { + return c.SDL_SetGamepadLED(gamepad, red, green, blue); + } + + pub inline fn sendGamepadEffect(gamepad: *Gamepad, data: ?*const anyopaque, size: c_int) bool { + return c.SDL_SendGamepadEffect(gamepad, data, size); + } + + pub inline fn closeGamepad(gamepad: *Gamepad) void { + return c.SDL_CloseGamepad(gamepad); + } + + pub inline fn getGamepadAppleSFSymbolsNameForButton(gamepad: *Gamepad, button: GamepadButton) [*c]const u8 { + return c.SDL_GetGamepadAppleSFSymbolsNameForButton(gamepad, button); + } + + pub inline fn getGamepadAppleSFSymbolsNameForAxis(gamepad: *Gamepad, axis: GamepadAxis) [*c]const u8 { + return c.SDL_GetGamepadAppleSFSymbolsNameForAxis(gamepad, axis); + } +}; + +pub const GamepadType = enum(c_int) { + gamepadTypeStandard, + gamepadTypeXbox360, + gamepadTypeXboxone, + gamepadTypePs3, + gamepadTypePs4, + gamepadTypePs5, + gamepadTypeNintendoSwitchPro, + gamepadTypeNintendoSwitchJoyconLeft, + gamepadTypeNintendoSwitchJoyconRight, + gamepadTypeNintendoSwitchJoyconPair, + gamepadTypeCount, +}; + +pub const GamepadButton = enum(c_int) { + gamepadButtonSouth, //Bottom face button (e.g. Xbox A button) + gamepadButtonEast, //Right face button (e.g. Xbox B button) + gamepadButtonWest, //Left face button (e.g. Xbox X button) + gamepadButtonNorth, //Top face button (e.g. Xbox Y button) + gamepadButtonBack, + gamepadButtonGuide, + gamepadButtonStart, + gamepadButtonLeftStick, + gamepadButtonRightStick, + gamepadButtonLeftShoulder, + gamepadButtonRightShoulder, + gamepadButtonDpadUp, + gamepadButtonDpadDown, + gamepadButtonDpadLeft, + gamepadButtonDpadRight, + gamepadButtonMisc1, //Additional button (e.g. Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button, Amazon Luna microphone button, Google Stadia capture button) + gamepadButtonRightPaddle1, //Upper or primary paddle, under your right hand (e.g. Xbox Elite paddle P1) + gamepadButtonLeftPaddle1, //Upper or primary paddle, under your left hand (e.g. Xbox Elite paddle P3) + gamepadButtonRightPaddle2, //Lower or secondary paddle, under your right hand (e.g. Xbox Elite paddle P2) + gamepadButtonLeftPaddle2, //Lower or secondary paddle, under your left hand (e.g. Xbox Elite paddle P4) + gamepadButtonTouchpad, //PS4/PS5 touchpad button + gamepadButtonMisc2, //Additional button + gamepadButtonMisc3, //Additional button + gamepadButtonMisc4, //Additional button + gamepadButtonMisc5, //Additional button + gamepadButtonMisc6, //Additional button + gamepadButtonCount, +}; + +pub const GamepadButtonLabel = enum(c_int) { + gamepadButtonLabelUnknown, + gamepadButtonLabelA, + gamepadButtonLabelB, + gamepadButtonLabelX, + gamepadButtonLabelY, + gamepadButtonLabelCross, + gamepadButtonLabelCircle, + gamepadButtonLabelSquare, + gamepadButtonLabelTriangle, +}; + +pub const GamepadAxis = enum(c_int) { + gamepadAxisLeftx, + gamepadAxisLefty, + gamepadAxisRightx, + gamepadAxisRighty, + gamepadAxisLeftTrigger, + gamepadAxisRightTrigger, + gamepadAxisCount, +}; + +pub const GamepadBindingType = enum(c_int) { + gamepadBindtypeButton, + gamepadBindtypeAxis, + gamepadBindtypeHat, +}; + +pub const GamepadBinding = extern struct { + input_type: GamepadBindingType, + button: c_int, + axis: c_int, + axis_min: c_int, + axis_max: c_int, + hat: c_int, + hat_mask: c_int, + output_type: GamepadBindingType, + button: GamepadButton, + axis: GamepadAxis, + axis_min: c_int, + axis_max: c_int, +}; + +pub inline fn addGamepadMapping(mapping: [*c]const u8) c_int { + return c.SDL_AddGamepadMapping(mapping); +} + +pub inline fn addGamepadMappingsFromFile(file: [*c]const u8) c_int { + return c.SDL_AddGamepadMappingsFromFile(file); +} + +pub inline fn reloadGamepadMappings() bool { + return c.SDL_ReloadGamepadMappings(); +} + +pub inline fn getGamepadMappings(count: *c_int) [*c][*c]u8 { + return c.SDL_GetGamepadMappings(@ptrCast(count)); +} + +pub inline fn getGamepadMappingForGUID(guid: GUID) [*c]u8 { + return c.SDL_GetGamepadMappingForGUID(guid); +} + +pub inline fn setGamepadMapping(instance_id: JoystickID, mapping: [*c]const u8) bool { + return c.SDL_SetGamepadMapping(instance_id, mapping); +} + +pub inline fn hasGamepad() bool { + return c.SDL_HasGamepad(); +} + +pub inline fn getGamepads(count: *c_int) ?*JoystickID { + return c.SDL_GetGamepads(@ptrCast(count)); +} + +pub inline fn isGamepad(instance_id: JoystickID) bool { + return c.SDL_IsGamepad(instance_id); +} + +pub inline fn getGamepadNameForID(instance_id: JoystickID) [*c]const u8 { + return c.SDL_GetGamepadNameForID(instance_id); +} + +pub inline fn getGamepadPathForID(instance_id: JoystickID) [*c]const u8 { + return c.SDL_GetGamepadPathForID(instance_id); +} + +pub inline fn getGamepadPlayerIndexForID(instance_id: JoystickID) c_int { + return c.SDL_GetGamepadPlayerIndexForID(instance_id); +} + +pub inline fn getGamepadGUIDForID(instance_id: JoystickID) GUID { + return c.SDL_GetGamepadGUIDForID(instance_id); +} + +pub inline fn getGamepadVendorForID(instance_id: JoystickID) u16 { + return c.SDL_GetGamepadVendorForID(instance_id); +} + +pub inline fn getGamepadProductForID(instance_id: JoystickID) u16 { + return c.SDL_GetGamepadProductForID(instance_id); +} + +pub inline fn getGamepadProductVersionForID(instance_id: JoystickID) u16 { + return c.SDL_GetGamepadProductVersionForID(instance_id); +} + +pub inline fn getGamepadTypeForID(instance_id: JoystickID) GamepadType { + return @intFromEnum(c.SDL_GetGamepadTypeForID(instance_id)); +} + +pub inline fn getRealGamepadTypeForID(instance_id: JoystickID) GamepadType { + return @intFromEnum(c.SDL_GetRealGamepadTypeForID(instance_id)); +} + +pub inline fn getGamepadMappingForID(instance_id: JoystickID) [*c]u8 { + return c.SDL_GetGamepadMappingForID(instance_id); +} + +pub inline fn openGamepad(instance_id: JoystickID) ?*Gamepad { + return c.SDL_OpenGamepad(instance_id); +} + +pub inline fn getGamepadFromID(instance_id: JoystickID) ?*Gamepad { + return c.SDL_GetGamepadFromID(instance_id); +} + +pub inline fn getGamepadFromPlayerIndex(player_index: c_int) ?*Gamepad { + return c.SDL_GetGamepadFromPlayerIndex(player_index); +} + +pub inline fn setGamepadEventsEnabled(enabled: bool) void { + return c.SDL_SetGamepadEventsEnabled(enabled); +} + +pub inline fn gamepadEventsEnabled() bool { + return c.SDL_GamepadEventsEnabled(); +} + +pub inline fn updateGamepads() void { + return c.SDL_UpdateGamepads(); +} + +pub inline fn getGamepadTypeFromString(str: [*c]const u8) GamepadType { + return @intFromEnum(c.SDL_GetGamepadTypeFromString(str)); +} + +pub inline fn getGamepadStringForType(_type: GamepadType) [*c]const u8 { + return c.SDL_GetGamepadStringForType(@intFromEnum(_type)); +} + +pub inline fn getGamepadAxisFromString(str: [*c]const u8) GamepadAxis { + return c.SDL_GetGamepadAxisFromString(str); +} + +pub inline fn getGamepadStringForAxis(axis: GamepadAxis) [*c]const u8 { + return c.SDL_GetGamepadStringForAxis(axis); +} + +pub inline fn getGamepadButtonFromString(str: [*c]const u8) GamepadButton { + return c.SDL_GetGamepadButtonFromString(str); +} + +pub inline fn getGamepadStringForButton(button: GamepadButton) [*c]const u8 { + return c.SDL_GetGamepadStringForButton(button); +} + +pub inline fn getGamepadButtonLabelForType(_type: GamepadType, button: GamepadButton) GamepadButtonLabel { + return c.SDL_GetGamepadButtonLabelForType(@intFromEnum(_type), button); +} diff --git a/v2/gpu.zig b/v2/gpu.zig new file mode 100644 index 0000000..0013650 --- /dev/null +++ b/v2/gpu.zig @@ -0,0 +1,1096 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const FColor = extern struct { + r: f32, + g: f32, + b: f32, + a: f32, +}; + +pub const PropertiesID = u32; + +pub const Rect = extern struct { + x: c_int, + y: c_int, + w: c_int, + h: c_int, +}; + +pub const Window = opaque {}; + +pub const FlipMode = enum(c_int) { + flipNone, //Do not flip + flipHorizontal, //flip horizontally + flipVertical, //flip vertically +}; + +pub const GPUDevice = opaque { + pub inline fn destroyGPUDevice(gpudevice: *GPUDevice) void { + return c.SDL_DestroyGPUDevice(gpudevice); + } + + pub inline fn getGPUDeviceDriver(gpudevice: *GPUDevice) [*c]const u8 { + return c.SDL_GetGPUDeviceDriver(gpudevice); + } + + pub inline fn getGPUShaderFormats(gpudevice: *GPUDevice) GPUShaderFormat { + return @bitCast(c.SDL_GetGPUShaderFormats(gpudevice)); + } + + pub inline fn createGPUComputePipeline(gpudevice: *GPUDevice, createinfo: *const GPUComputePipelineCreateInfo) ?*GPUComputePipeline { + return c.SDL_CreateGPUComputePipeline(gpudevice, @ptrCast(createinfo)); + } + + pub inline fn createGPUGraphicsPipeline(gpudevice: *GPUDevice, createinfo: *const GPUGraphicsPipelineCreateInfo) ?*GPUGraphicsPipeline { + return c.SDL_CreateGPUGraphicsPipeline(gpudevice, @ptrCast(createinfo)); + } + + pub inline fn createGPUSampler(gpudevice: *GPUDevice, createinfo: *const GPUSamplerCreateInfo) ?*GPUSampler { + return c.SDL_CreateGPUSampler(gpudevice, @ptrCast(createinfo)); + } + + pub inline fn createGPUShader(gpudevice: *GPUDevice, createinfo: *const GPUShaderCreateInfo) ?*GPUShader { + return c.SDL_CreateGPUShader(gpudevice, @ptrCast(createinfo)); + } + + pub inline fn createGPUTexture(gpudevice: *GPUDevice, createinfo: *const GPUTextureCreateInfo) ?*GPUTexture { + return c.SDL_CreateGPUTexture(gpudevice, @ptrCast(createinfo)); + } + + pub inline fn createGPUBuffer(gpudevice: *GPUDevice, createinfo: *const GPUBufferCreateInfo) ?*GPUBuffer { + return c.SDL_CreateGPUBuffer(gpudevice, @ptrCast(createinfo)); + } + + pub inline fn createGPUTransferBuffer(gpudevice: *GPUDevice, createinfo: *const GPUTransferBufferCreateInfo) ?*GPUTransferBuffer { + return c.SDL_CreateGPUTransferBuffer(gpudevice, @ptrCast(createinfo)); + } + + pub inline fn setGPUBufferName(gpudevice: *GPUDevice, buffer: ?*GPUBuffer, text: [*c]const u8) void { + return c.SDL_SetGPUBufferName(gpudevice, buffer, text); + } + + pub inline fn setGPUTextureName(gpudevice: *GPUDevice, texture: ?*GPUTexture, text: [*c]const u8) void { + return c.SDL_SetGPUTextureName(gpudevice, texture, text); + } + + pub inline fn releaseGPUTexture(gpudevice: *GPUDevice, texture: ?*GPUTexture) void { + return c.SDL_ReleaseGPUTexture(gpudevice, texture); + } + + pub inline fn releaseGPUSampler(gpudevice: *GPUDevice, sampler: ?*GPUSampler) void { + return c.SDL_ReleaseGPUSampler(gpudevice, sampler); + } + + pub inline fn releaseGPUBuffer(gpudevice: *GPUDevice, buffer: ?*GPUBuffer) void { + return c.SDL_ReleaseGPUBuffer(gpudevice, buffer); + } + + pub inline fn releaseGPUTransferBuffer(gpudevice: *GPUDevice, transfer_buffer: ?*GPUTransferBuffer) void { + return c.SDL_ReleaseGPUTransferBuffer(gpudevice, transfer_buffer); + } + + pub inline fn releaseGPUComputePipeline(gpudevice: *GPUDevice, compute_pipeline: ?*GPUComputePipeline) void { + return c.SDL_ReleaseGPUComputePipeline(gpudevice, compute_pipeline); + } + + pub inline fn releaseGPUShader(gpudevice: *GPUDevice, shader: ?*GPUShader) void { + return c.SDL_ReleaseGPUShader(gpudevice, shader); + } + + pub inline fn releaseGPUGraphicsPipeline(gpudevice: *GPUDevice, graphics_pipeline: ?*GPUGraphicsPipeline) void { + return c.SDL_ReleaseGPUGraphicsPipeline(gpudevice, graphics_pipeline); + } + + pub inline fn acquireGPUCommandBuffer(gpudevice: *GPUDevice) ?*GPUCommandBuffer { + return c.SDL_AcquireGPUCommandBuffer(gpudevice); + } + + pub inline fn mapGPUTransferBuffer(gpudevice: *GPUDevice, transfer_buffer: ?*GPUTransferBuffer, cycle: bool) ?*anyopaque { + return c.SDL_MapGPUTransferBuffer(gpudevice, transfer_buffer, cycle); + } + + pub inline fn unmapGPUTransferBuffer(gpudevice: *GPUDevice, transfer_buffer: ?*GPUTransferBuffer) void { + return c.SDL_UnmapGPUTransferBuffer(gpudevice, transfer_buffer); + } + + pub inline fn windowSupportsGPUSwapchainComposition(gpudevice: *GPUDevice, window: ?*Window, swapchain_composition: GPUSwapchainComposition) bool { + return c.SDL_WindowSupportsGPUSwapchainComposition(gpudevice, window, swapchain_composition); + } + + pub inline fn windowSupportsGPUPresentMode(gpudevice: *GPUDevice, window: ?*Window, present_mode: GPUPresentMode) bool { + return c.SDL_WindowSupportsGPUPresentMode(gpudevice, window, @intFromEnum(present_mode)); + } + + pub inline fn claimWindowForGPUDevice(gpudevice: *GPUDevice, window: ?*Window) bool { + return c.SDL_ClaimWindowForGPUDevice(gpudevice, window); + } + + pub inline fn releaseWindowFromGPUDevice(gpudevice: *GPUDevice, window: ?*Window) void { + return c.SDL_ReleaseWindowFromGPUDevice(gpudevice, window); + } + + pub inline fn setGPUSwapchainParameters(gpudevice: *GPUDevice, window: ?*Window, swapchain_composition: GPUSwapchainComposition, present_mode: GPUPresentMode) bool { + return c.SDL_SetGPUSwapchainParameters(gpudevice, window, swapchain_composition, @intFromEnum(present_mode)); + } + + pub inline fn setGPUAllowedFramesInFlight(gpudevice: *GPUDevice, allowed_frames_in_flight: u32) bool { + return c.SDL_SetGPUAllowedFramesInFlight(gpudevice, allowed_frames_in_flight); + } + + pub inline fn getGPUSwapchainTextureFormat(gpudevice: *GPUDevice, window: ?*Window) GPUTextureFormat { + return @bitCast(c.SDL_GetGPUSwapchainTextureFormat(gpudevice, window)); + } + + pub inline fn waitForGPUSwapchain(gpudevice: *GPUDevice, window: ?*Window) bool { + return c.SDL_WaitForGPUSwapchain(gpudevice, window); + } + + pub inline fn waitForGPUIdle(gpudevice: *GPUDevice) bool { + return c.SDL_WaitForGPUIdle(gpudevice); + } + + pub inline fn waitForGPUFences(gpudevice: *GPUDevice, wait_all: bool, fences: [*c]*const GPUFence, num_fences: u32) bool { + return c.SDL_WaitForGPUFences(gpudevice, wait_all, fences, num_fences); + } + + pub inline fn queryGPUFence(gpudevice: *GPUDevice, fence: ?*GPUFence) bool { + return c.SDL_QueryGPUFence(gpudevice, fence); + } + + pub inline fn releaseGPUFence(gpudevice: *GPUDevice, fence: ?*GPUFence) void { + return c.SDL_ReleaseGPUFence(gpudevice, fence); + } + + pub inline fn gpuTextureSupportsFormat(gpudevice: *GPUDevice, format: GPUTextureFormat, _type: GPUTextureType, usage: GPUTextureUsageFlags) bool { + return c.SDL_GPUTextureSupportsFormat(gpudevice, @bitCast(format), @intFromEnum(_type), @bitCast(usage)); + } + + pub inline fn gpuTextureSupportsSampleCount(gpudevice: *GPUDevice, format: GPUTextureFormat, sample_count: GPUSampleCount) bool { + return c.SDL_GPUTextureSupportsSampleCount(gpudevice, @bitCast(format), sample_count); + } + + pub inline fn gdkSuspendGPU(gpudevice: *GPUDevice) void { + return c.SDL_GDKSuspendGPU(gpudevice); + } + + pub inline fn gdkResumeGPU(gpudevice: *GPUDevice) void { + return c.SDL_GDKResumeGPU(gpudevice); + } +}; + +pub const GPUBuffer = opaque {}; + +pub const GPUTransferBuffer = opaque {}; + +pub const GPUTexture = opaque {}; + +pub const GPUSampler = opaque {}; + +pub const GPUShader = opaque {}; + +pub const GPUComputePipeline = opaque {}; + +pub const GPUGraphicsPipeline = opaque {}; + +pub const GPUCommandBuffer = opaque { + pub inline fn insertGPUDebugLabel(gpucommandbuffer: *GPUCommandBuffer, text: [*c]const u8) void { + return c.SDL_InsertGPUDebugLabel(gpucommandbuffer, text); + } + + pub inline fn pushGPUDebugGroup(gpucommandbuffer: *GPUCommandBuffer, name: [*c]const u8) void { + return c.SDL_PushGPUDebugGroup(gpucommandbuffer, name); + } + + pub inline fn popGPUDebugGroup(gpucommandbuffer: *GPUCommandBuffer) void { + return c.SDL_PopGPUDebugGroup(gpucommandbuffer); + } + + pub inline fn pushGPUVertexUniformData(gpucommandbuffer: *GPUCommandBuffer, slot_index: u32, data: ?*const anyopaque, length: u32) void { + return c.SDL_PushGPUVertexUniformData(gpucommandbuffer, slot_index, data, length); + } + + pub inline fn pushGPUFragmentUniformData(gpucommandbuffer: *GPUCommandBuffer, slot_index: u32, data: ?*const anyopaque, length: u32) void { + return c.SDL_PushGPUFragmentUniformData(gpucommandbuffer, slot_index, data, length); + } + + pub inline fn pushGPUComputeUniformData(gpucommandbuffer: *GPUCommandBuffer, slot_index: u32, data: ?*const anyopaque, length: u32) void { + return c.SDL_PushGPUComputeUniformData(gpucommandbuffer, slot_index, data, length); + } + + pub inline fn beginGPURenderPass(gpucommandbuffer: *GPUCommandBuffer, color_target_infos: *const GPUColorTargetInfo, num_color_targets: u32, depth_stencil_target_info: *const GPUDepthStencilTargetInfo) ?*GPURenderPass { + return c.SDL_BeginGPURenderPass(gpucommandbuffer, @ptrCast(color_target_infos), num_color_targets, @ptrCast(depth_stencil_target_info)); + } + + pub inline fn beginGPUComputePass(gpucommandbuffer: *GPUCommandBuffer, storage_texture_bindings: *const GPUStorageTextureReadWriteBinding, num_storage_texture_bindings: u32, storage_buffer_bindings: *const GPUStorageBufferReadWriteBinding, num_storage_buffer_bindings: u32) ?*GPUComputePass { + return c.SDL_BeginGPUComputePass(gpucommandbuffer, @ptrCast(storage_texture_bindings), num_storage_texture_bindings, @ptrCast(storage_buffer_bindings), num_storage_buffer_bindings); + } + + pub inline fn beginGPUCopyPass(gpucommandbuffer: *GPUCommandBuffer) ?*GPUCopyPass { + return c.SDL_BeginGPUCopyPass(gpucommandbuffer); + } + + pub inline fn generateMipmapsForGPUTexture(gpucommandbuffer: *GPUCommandBuffer, texture: ?*GPUTexture) void { + return c.SDL_GenerateMipmapsForGPUTexture(gpucommandbuffer, texture); + } + + pub inline fn blitGPUTexture(gpucommandbuffer: *GPUCommandBuffer, info: *const GPUBlitInfo) void { + return c.SDL_BlitGPUTexture(gpucommandbuffer, @ptrCast(info)); + } + + pub inline fn acquireGPUSwapchainTexture(gpucommandbuffer: *GPUCommandBuffer, window: ?*Window, swapchain_texture: [*c][*c]GPUTexture, swapchain_texture_width: *u32, swapchain_texture_height: *u32) bool { + return c.SDL_AcquireGPUSwapchainTexture(gpucommandbuffer, window, swapchain_texture, @ptrCast(swapchain_texture_width), @ptrCast(swapchain_texture_height)); + } + + pub inline fn waitAndAcquireGPUSwapchainTexture(gpucommandbuffer: *GPUCommandBuffer, window: ?*Window, swapchain_texture: [*c][*c]GPUTexture, swapchain_texture_width: *u32, swapchain_texture_height: *u32) bool { + return c.SDL_WaitAndAcquireGPUSwapchainTexture(gpucommandbuffer, window, swapchain_texture, @ptrCast(swapchain_texture_width), @ptrCast(swapchain_texture_height)); + } + + pub inline fn submitGPUCommandBuffer(gpucommandbuffer: *GPUCommandBuffer) bool { + return c.SDL_SubmitGPUCommandBuffer(gpucommandbuffer); + } + + pub inline fn submitGPUCommandBufferAndAcquireFence(gpucommandbuffer: *GPUCommandBuffer) ?*GPUFence { + return c.SDL_SubmitGPUCommandBufferAndAcquireFence(gpucommandbuffer); + } + + pub inline fn cancelGPUCommandBuffer(gpucommandbuffer: *GPUCommandBuffer) bool { + return c.SDL_CancelGPUCommandBuffer(gpucommandbuffer); + } +}; + +pub const GPURenderPass = opaque { + pub inline fn bindGPUGraphicsPipeline(gpurenderpass: *GPURenderPass, graphics_pipeline: ?*GPUGraphicsPipeline) void { + return c.SDL_BindGPUGraphicsPipeline(gpurenderpass, graphics_pipeline); + } + + pub inline fn setGPUViewport(gpurenderpass: *GPURenderPass, viewport: *const GPUViewport) void { + return c.SDL_SetGPUViewport(gpurenderpass, @ptrCast(viewport)); + } + + pub inline fn setGPUScissor(gpurenderpass: *GPURenderPass, scissor: *const Rect) void { + return c.SDL_SetGPUScissor(gpurenderpass, @ptrCast(scissor)); + } + + pub inline fn setGPUBlendConstants(gpurenderpass: *GPURenderPass, blend_constants: FColor) void { + return c.SDL_SetGPUBlendConstants(gpurenderpass, blend_constants); + } + + pub inline fn setGPUStencilReference(gpurenderpass: *GPURenderPass, reference: u8) void { + return c.SDL_SetGPUStencilReference(gpurenderpass, reference); + } + + pub inline fn bindGPUVertexBuffers(gpurenderpass: *GPURenderPass, first_slot: u32, bindings: *const GPUBufferBinding, num_bindings: u32) void { + return c.SDL_BindGPUVertexBuffers(gpurenderpass, first_slot, @ptrCast(bindings), num_bindings); + } + + pub inline fn bindGPUIndexBuffer(gpurenderpass: *GPURenderPass, binding: *const GPUBufferBinding, index_element_size: GPUIndexElementSize) void { + return c.SDL_BindGPUIndexBuffer(gpurenderpass, @ptrCast(binding), index_element_size); + } + + pub inline fn bindGPUVertexSamplers(gpurenderpass: *GPURenderPass, first_slot: u32, texture_sampler_bindings: *const GPUTextureSamplerBinding, num_bindings: u32) void { + return c.SDL_BindGPUVertexSamplers(gpurenderpass, first_slot, @ptrCast(texture_sampler_bindings), num_bindings); + } + + pub inline fn bindGPUVertexStorageTextures(gpurenderpass: *GPURenderPass, first_slot: u32, storage_textures: [*c]*const GPUTexture, num_bindings: u32) void { + return c.SDL_BindGPUVertexStorageTextures(gpurenderpass, first_slot, storage_textures, num_bindings); + } + + pub inline fn bindGPUVertexStorageBuffers(gpurenderpass: *GPURenderPass, first_slot: u32, storage_buffers: [*c]*const GPUBuffer, num_bindings: u32) void { + return c.SDL_BindGPUVertexStorageBuffers(gpurenderpass, first_slot, storage_buffers, num_bindings); + } + + pub inline fn bindGPUFragmentSamplers(gpurenderpass: *GPURenderPass, first_slot: u32, texture_sampler_bindings: *const GPUTextureSamplerBinding, num_bindings: u32) void { + return c.SDL_BindGPUFragmentSamplers(gpurenderpass, first_slot, @ptrCast(texture_sampler_bindings), num_bindings); + } + + pub inline fn bindGPUFragmentStorageTextures(gpurenderpass: *GPURenderPass, first_slot: u32, storage_textures: [*c]*const GPUTexture, num_bindings: u32) void { + return c.SDL_BindGPUFragmentStorageTextures(gpurenderpass, first_slot, storage_textures, num_bindings); + } + + pub inline fn bindGPUFragmentStorageBuffers(gpurenderpass: *GPURenderPass, first_slot: u32, storage_buffers: [*c]*const GPUBuffer, num_bindings: u32) void { + return c.SDL_BindGPUFragmentStorageBuffers(gpurenderpass, first_slot, storage_buffers, num_bindings); + } + + pub inline fn drawGPUIndexedPrimitives(gpurenderpass: *GPURenderPass, num_indices: u32, num_instances: u32, first_index: u32, vertex_offset: i32, first_instance: u32) void { + return c.SDL_DrawGPUIndexedPrimitives(gpurenderpass, num_indices, num_instances, first_index, vertex_offset, first_instance); + } + + pub inline fn drawGPUPrimitives(gpurenderpass: *GPURenderPass, num_vertices: u32, num_instances: u32, first_vertex: u32, first_instance: u32) void { + return c.SDL_DrawGPUPrimitives(gpurenderpass, num_vertices, num_instances, first_vertex, first_instance); + } + + pub inline fn drawGPUPrimitivesIndirect(gpurenderpass: *GPURenderPass, buffer: ?*GPUBuffer, offset: u32, draw_count: u32) void { + return c.SDL_DrawGPUPrimitivesIndirect(gpurenderpass, buffer, offset, draw_count); + } + + pub inline fn drawGPUIndexedPrimitivesIndirect(gpurenderpass: *GPURenderPass, buffer: ?*GPUBuffer, offset: u32, draw_count: u32) void { + return c.SDL_DrawGPUIndexedPrimitivesIndirect(gpurenderpass, buffer, offset, draw_count); + } + + pub inline fn endGPURenderPass(gpurenderpass: *GPURenderPass) void { + return c.SDL_EndGPURenderPass(gpurenderpass); + } +}; + +pub const GPUComputePass = opaque { + pub inline fn bindGPUComputePipeline(gpucomputepass: *GPUComputePass, compute_pipeline: ?*GPUComputePipeline) void { + return c.SDL_BindGPUComputePipeline(gpucomputepass, compute_pipeline); + } + + pub inline fn bindGPUComputeSamplers(gpucomputepass: *GPUComputePass, first_slot: u32, texture_sampler_bindings: *const GPUTextureSamplerBinding, num_bindings: u32) void { + return c.SDL_BindGPUComputeSamplers(gpucomputepass, first_slot, @ptrCast(texture_sampler_bindings), num_bindings); + } + + pub inline fn bindGPUComputeStorageTextures(gpucomputepass: *GPUComputePass, first_slot: u32, storage_textures: [*c]*const GPUTexture, num_bindings: u32) void { + return c.SDL_BindGPUComputeStorageTextures(gpucomputepass, first_slot, storage_textures, num_bindings); + } + + pub inline fn bindGPUComputeStorageBuffers(gpucomputepass: *GPUComputePass, first_slot: u32, storage_buffers: [*c]*const GPUBuffer, num_bindings: u32) void { + return c.SDL_BindGPUComputeStorageBuffers(gpucomputepass, first_slot, storage_buffers, num_bindings); + } + + pub inline fn dispatchGPUCompute(gpucomputepass: *GPUComputePass, groupcount_x: u32, groupcount_y: u32, groupcount_z: u32) void { + return c.SDL_DispatchGPUCompute(gpucomputepass, groupcount_x, groupcount_y, groupcount_z); + } + + pub inline fn dispatchGPUComputeIndirect(gpucomputepass: *GPUComputePass, buffer: ?*GPUBuffer, offset: u32) void { + return c.SDL_DispatchGPUComputeIndirect(gpucomputepass, buffer, offset); + } + + pub inline fn endGPUComputePass(gpucomputepass: *GPUComputePass) void { + return c.SDL_EndGPUComputePass(gpucomputepass); + } +}; + +pub const GPUCopyPass = opaque { + pub inline fn uploadToGPUTexture(gpucopypass: *GPUCopyPass, source: *const GPUTextureTransferInfo, destination: *const GPUTextureRegion, cycle: bool) void { + return c.SDL_UploadToGPUTexture(gpucopypass, @ptrCast(source), @ptrCast(destination), cycle); + } + + pub inline fn uploadToGPUBuffer(gpucopypass: *GPUCopyPass, source: *const GPUTransferBufferLocation, destination: *const GPUBufferRegion, cycle: bool) void { + return c.SDL_UploadToGPUBuffer(gpucopypass, @ptrCast(source), @ptrCast(destination), cycle); + } + + pub inline fn copyGPUTextureToTexture(gpucopypass: *GPUCopyPass, source: *const GPUTextureLocation, destination: *const GPUTextureLocation, w: u32, h: u32, d: u32, cycle: bool) void { + return c.SDL_CopyGPUTextureToTexture(gpucopypass, @ptrCast(source), @ptrCast(destination), w, h, d, cycle); + } + + pub inline fn copyGPUBufferToBuffer(gpucopypass: *GPUCopyPass, source: *const GPUBufferLocation, destination: *const GPUBufferLocation, size: u32, cycle: bool) void { + return c.SDL_CopyGPUBufferToBuffer(gpucopypass, @ptrCast(source), @ptrCast(destination), size, cycle); + } + + pub inline fn downloadFromGPUTexture(gpucopypass: *GPUCopyPass, source: *const GPUTextureRegion, destination: *const GPUTextureTransferInfo) void { + return c.SDL_DownloadFromGPUTexture(gpucopypass, @ptrCast(source), @ptrCast(destination)); + } + + pub inline fn downloadFromGPUBuffer(gpucopypass: *GPUCopyPass, source: *const GPUBufferRegion, destination: *const GPUTransferBufferLocation) void { + return c.SDL_DownloadFromGPUBuffer(gpucopypass, @ptrCast(source), @ptrCast(destination)); + } + + pub inline fn endGPUCopyPass(gpucopypass: *GPUCopyPass) void { + return c.SDL_EndGPUCopyPass(gpucopypass); + } +}; + +pub const GPUFence = opaque {}; + +pub const GPUPrimitiveType = enum(c_int) { + primitivetypeTrianglelist, //A series of separate triangles. + primitivetypeTrianglestrip, //A series of connected triangles. + primitivetypeLinelist, //A series of separate lines. + primitivetypeLinestrip, //A series of connected lines. + primitivetypePointlist, //A series of separate points. +}; + +pub const GPULoadOp = enum(c_int) { + loadopLoad, //The previous contents of the texture will be preserved. + loadopClear, //The contents of the texture will be cleared to a color. + loadopDontCare, //The previous contents of the texture need not be preserved. The contents will be undefined. +}; + +pub const GPUStoreOp = enum(c_int) { + storeopStore, //The contents generated during the render pass will be written to memory. + storeopDontCare, //The contents generated during the render pass are not needed and may be discarded. The contents will be undefined. + storeopResolve, //The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture may then be discarded and will be undefined. + storeopResolveAndStore, //The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture will be written to memory. +}; + +pub const GPUIndexElementSize = enum(c_int) { + indexelementsize16bit, //The index elements are 16-bit. + indexelementsize32bit, //The index elements are 32-bit. +}; + +pub const GPUTextureFormat = enum(c_int) { + textureformatInvalid, + textureformatA8Unorm, + textureformatR8Unorm, + textureformatR8g8Unorm, + textureformatR8g8b8a8Unorm, + textureformatR16Unorm, + textureformatR16g16Unorm, + textureformatR16g16b16a16Unorm, + textureformatR10g10b10a2Unorm, + textureformatB5g6r5Unorm, + textureformatB5g5r5a1Unorm, + textureformatB4g4r4a4Unorm, + textureformatB8g8r8a8Unorm, + textureformatBc1RgbaUnorm, + textureformatBc2RgbaUnorm, + textureformatBc3RgbaUnorm, + textureformatBc4RUnorm, + textureformatBc5RgUnorm, + textureformatBc7RgbaUnorm, + textureformatBc6hRgbFloat, + textureformatBc6hRgbUfloat, + textureformatR8Snorm, + textureformatR8g8Snorm, + textureformatR8g8b8a8Snorm, + textureformatR16Snorm, + textureformatR16g16Snorm, + textureformatR16g16b16a16Snorm, + textureformatR16Float, + textureformatR16g16Float, + textureformatR16g16b16a16Float, + textureformatR32Float, + textureformatR32g32Float, + textureformatR32g32b32a32Float, + textureformatR11g11b10Ufloat, + textureformatR8Uint, + textureformatR8g8Uint, + textureformatR8g8b8a8Uint, + textureformatR16Uint, + textureformatR16g16Uint, + textureformatR16g16b16a16Uint, + textureformatR32Uint, + textureformatR32g32Uint, + textureformatR32g32b32a32Uint, + textureformatR8Int, + textureformatR8g8Int, + textureformatR8g8b8a8Int, + textureformatR16Int, + textureformatR16g16Int, + textureformatR16g16b16a16Int, + textureformatR32Int, + textureformatR32g32Int, + textureformatR32g32b32a32Int, + textureformatR8g8b8a8UnormSrgb, + textureformatB8g8r8a8UnormSrgb, + textureformatBc1RgbaUnormSrgb, + textureformatBc2RgbaUnormSrgb, + textureformatBc3RgbaUnormSrgb, + textureformatBc7RgbaUnormSrgb, + textureformatD16Unorm, + textureformatD24Unorm, + textureformatD32Float, + textureformatD24UnormS8Uint, + textureformatD32FloatS8Uint, + textureformatAstc4x4Unorm, + textureformatAstc5x4Unorm, + textureformatAstc5x5Unorm, + textureformatAstc6x5Unorm, + textureformatAstc6x6Unorm, + textureformatAstc8x5Unorm, + textureformatAstc8x6Unorm, + textureformatAstc8x8Unorm, + textureformatAstc10x5Unorm, + textureformatAstc10x6Unorm, + textureformatAstc10x8Unorm, + textureformatAstc10x10Unorm, + textureformatAstc12x10Unorm, + textureformatAstc12x12Unorm, + textureformatAstc4x4UnormSrgb, + textureformatAstc5x4UnormSrgb, + textureformatAstc5x5UnormSrgb, + textureformatAstc6x5UnormSrgb, + textureformatAstc6x6UnormSrgb, + textureformatAstc8x5UnormSrgb, + textureformatAstc8x6UnormSrgb, + textureformatAstc8x8UnormSrgb, + textureformatAstc10x5UnormSrgb, + textureformatAstc10x6UnormSrgb, + textureformatAstc10x8UnormSrgb, + textureformatAstc10x10UnormSrgb, + textureformatAstc12x10UnormSrgb, + textureformatAstc12x12UnormSrgb, + textureformatAstc4x4Float, + textureformatAstc5x4Float, + textureformatAstc5x5Float, + textureformatAstc6x5Float, + textureformatAstc6x6Float, + textureformatAstc8x5Float, + textureformatAstc8x6Float, + textureformatAstc8x8Float, + textureformatAstc10x5Float, + textureformatAstc10x6Float, + textureformatAstc10x8Float, + textureformatAstc10x10Float, + textureformatAstc12x10Float, + textureformatAstc12x12Float, +}; + +pub const GPUTextureUsageFlags = packed struct(u32) { + textureusageSampler: bool = false, // Texture supports sampling. + textureusageColorTarget: bool = false, // Texture is a color render target. + textureusageDepthStencilTarget: bool = false, // Texture is a depth stencil target. + textureusageGraphicsStorageRead: bool = false, // Texture supports storage reads in graphics stages. + textureusageComputeStorageRead: bool = false, // Texture supports storage reads in the compute stage. + textureusageComputeStorageWrite: bool = false, // Texture supports storage writes in the compute stage. + textureusageComputeStorageSimultaneousReadWrite: bool = false, // Texture supports reads and writes in the same compute shader. This is NOT equivalent to READ | WRITE. + pad0: u24 = 0, + rsvd: bool = false, +}; + +pub const GPUTextureType = enum(c_int) { + texturetype2d, //The texture is a 2-dimensional image. + texturetype2dArray, //The texture is a 2-dimensional array image. + texturetype3d, //The texture is a 3-dimensional image. + texturetypeCube, //The texture is a cube image. + texturetypeCubeArray, //The texture is a cube array image. +}; + +pub const GPUSampleCount = enum(c_int) { + samplecount1, //No multisampling. + samplecount2, //MSAA 2x + samplecount4, //MSAA 4x + samplecount8, //MSAA 8x +}; + +pub const GPUCubeMapFace = enum(c_int) { + cubemapfacePositivex, + cubemapfaceNegativex, + cubemapfacePositivey, + cubemapfaceNegativey, + cubemapfacePositivez, + cubemapfaceNegativez, +}; + +pub const GPUBufferUsageFlags = packed struct(u32) { + bufferusageVertex: bool = false, // Buffer is a vertex buffer. + bufferusageIndex: bool = false, // Buffer is an index buffer. + bufferusageIndirect: bool = false, // Buffer is an indirect buffer. + bufferusageGraphicsStorageRead: bool = false, // Buffer supports storage reads in graphics stages. + bufferusageComputeStorageRead: bool = false, // Buffer supports storage reads in the compute stage. + bufferusageComputeStorageWrite: bool = false, // Buffer supports storage writes in the compute stage. + pad0: u25 = 0, + rsvd: bool = false, +}; + +pub const GPUTransferBufferUsage = enum(c_int) { + transferbufferusageUpload, + transferbufferusageDownload, +}; + +pub const GPUShaderStage = enum(c_int) { + shaderstageVertex, + shaderstageFragment, +}; + +pub const GPUShaderFormat = u32; + +pub const GPUVertexElementFormat = enum(c_int) { + vertexelementformatInvalid, + vertexelementformatInt, + vertexelementformatInt2, + vertexelementformatInt3, + vertexelementformatInt4, + vertexelementformatUint, + vertexelementformatUint2, + vertexelementformatUint3, + vertexelementformatUint4, + vertexelementformatFloat, + vertexelementformatFloat2, + vertexelementformatFloat3, + vertexelementformatFloat4, + vertexelementformatByte2, + vertexelementformatByte4, + vertexelementformatUbyte2, + vertexelementformatUbyte4, + vertexelementformatByte2Norm, + vertexelementformatByte4Norm, + vertexelementformatUbyte2Norm, + vertexelementformatUbyte4Norm, + vertexelementformatShort2, + vertexelementformatShort4, + vertexelementformatUshort2, + vertexelementformatUshort4, + vertexelementformatShort2Norm, + vertexelementformatShort4Norm, + vertexelementformatUshort2Norm, + vertexelementformatUshort4Norm, + vertexelementformatHalf2, + vertexelementformatHalf4, +}; + +pub const GPUVertexInputRate = enum(c_int) { + vertexinputrateVertex, //Attribute addressing is a function of the vertex index. + vertexinputrateInstance, //Attribute addressing is a function of the instance index. +}; + +pub const GPUFillMode = enum(c_int) { + fillmodeFill, //Polygons will be rendered via rasterization. + fillmodeLine, //Polygon edges will be drawn as line segments. +}; + +pub const GPUCullMode = enum(c_int) { + cullmodeNone, //No triangles are culled. + cullmodeFront, //Front-facing triangles are culled. + cullmodeBack, //Back-facing triangles are culled. +}; + +pub const GPUFrontFace = enum(c_int) { + frontfaceCounterClockwise, //A triangle with counter-clockwise vertex winding will be considered front-facing. + frontfaceClockwise, //A triangle with clockwise vertex winding will be considered front-facing. +}; + +pub const GPUCompareOp = enum(c_int) { + compareopInvalid, + compareopNever, //The comparison always evaluates false. + compareopLess, //The comparison evaluates reference < test. + compareopEqual, //The comparison evaluates reference == test. + compareopLessOrEqual, //The comparison evaluates reference <= test. + compareopGreater, //The comparison evaluates reference > test. + compareopNotEqual, //The comparison evaluates reference != test. + compareopGreaterOrEqual, //The comparison evalutes reference >= test. + compareopAlways, //The comparison always evaluates true. +}; + +pub const GPUStencilOp = enum(c_int) { + stencilopInvalid, + stencilopKeep, //Keeps the current value. + stencilopZero, //Sets the value to 0. + stencilopReplace, //Sets the value to reference. + stencilopIncrementAndClamp, //Increments the current value and clamps to the maximum value. + stencilopDecrementAndClamp, //Decrements the current value and clamps to 0. + stencilopInvert, //Bitwise-inverts the current value. + stencilopIncrementAndWrap, //Increments the current value and wraps back to 0. + stencilopDecrementAndWrap, //Decrements the current value and wraps to the maximum value. +}; + +pub const GPUBlendOp = enum(c_int) { + blendopInvalid, + blendopAdd, //(source * source_factor) + (destination * destination_factor) + blendopSubtract, //(source * source_factor) - (destination * destination_factor) + blendopReverseSubtract, //(destination * destination_factor) - (source * source_factor) + blendopMin, //min(source, destination) + blendopMax, +}; + +pub const GPUBlendFactor = enum(c_int) { + blendfactorInvalid, + blendfactorZero, //0 + blendfactorOne, //1 + blendfactorSrcColor, //source color + blendfactorOneMinusSrcColor, //1 - source color + blendfactorDstColor, //destination color + blendfactorOneMinusDstColor, //1 - destination color + blendfactorSrcAlpha, //source alpha + blendfactorOneMinusSrcAlpha, //1 - source alpha + blendfactorDstAlpha, //destination alpha + blendfactorOneMinusDstAlpha, //1 - destination alpha + blendfactorConstantColor, //blend constant + blendfactorOneMinusConstantColor, //1 - blend constant + blendfactorSrcAlphaSaturate, +}; + +pub const GPUColorComponentFlags = packed struct(u8) { + colorcomponentR: bool = false, // the red component + colorcomponentG: bool = false, // the green component + colorcomponentB: bool = false, // the blue component + colorcomponentA: bool = false, // the alpha component + pad0: u3 = 0, + rsvd: bool = false, +}; + +pub const GPUFilter = enum(c_int) { + filterNearest, //Point filtering. + filterLinear, //Linear filtering. +}; + +pub const GPUSamplerMipmapMode = enum(c_int) { + samplermipmapmodeNearest, //Point filtering. + samplermipmapmodeLinear, //Linear filtering. +}; + +pub const GPUSamplerAddressMode = enum(c_int) { + sampleraddressmodeRepeat, //Specifies that the coordinates will wrap around. + sampleraddressmodeMirroredRepeat, //Specifies that the coordinates will wrap around mirrored. + sampleraddressmodeClampToEdge, //Specifies that the coordinates will clamp to the 0-1 range. +}; + +pub const GPUPresentMode = enum(c_int) { + presentmodeVsync, + presentmodeImmediate, + presentmodeMailbox, +}; + +pub const GPUSwapchainComposition = enum(c_int) { + swapchaincompositionSdr, + swapchaincompositionSdrLinear, + swapchaincompositionHdrExtendedLinear, + swapchaincompositionHdr10St2084, +}; + +pub const GPUViewport = extern struct { + x: f32, // The left offset of the viewport. + y: f32, // The top offset of the viewport. + w: f32, // The width of the viewport. + h: f32, // The height of the viewport. + min_depth: f32, // The minimum depth of the viewport. + max_depth: f32, // The maximum depth of the viewport. +}; + +pub const GPUTextureTransferInfo = extern struct { + transfer_buffer: ?*GPUTransferBuffer, // The transfer buffer used in the transfer operation. + offset: u32, // The starting byte of the image data in the transfer buffer. + pixels_per_row: u32, // The number of pixels from one row to the next. + rows_per_layer: u32, // The number of rows from one layer/depth-slice to the next. +}; + +pub const GPUTransferBufferLocation = extern struct { + transfer_buffer: ?*GPUTransferBuffer, // The transfer buffer used in the transfer operation. + offset: u32, // The starting byte of the buffer data in the transfer buffer. +}; + +pub const GPUTextureLocation = extern struct { + texture: ?*GPUTexture, // The texture used in the copy operation. + mip_level: u32, // The mip level index of the location. + layer: u32, // The layer index of the location. + x: u32, // The left offset of the location. + y: u32, // The top offset of the location. + z: u32, // The front offset of the location. +}; + +pub const GPUTextureRegion = extern struct { + texture: ?*GPUTexture, // The texture used in the copy operation. + mip_level: u32, // The mip level index to transfer. + layer: u32, // The layer index to transfer. + x: u32, // The left offset of the region. + y: u32, // The top offset of the region. + z: u32, // The front offset of the region. + w: u32, // The width of the region. + h: u32, // The height of the region. + d: u32, // The depth of the region. +}; + +pub const GPUBlitRegion = extern struct { + texture: ?*GPUTexture, // The texture. + mip_level: u32, // The mip level index of the region. + layer_or_depth_plane: u32, // The layer index or depth plane of the region. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. + x: u32, // The left offset of the region. + y: u32, // The top offset of the region. + w: u32, // The width of the region. + h: u32, // The height of the region. +}; + +pub const GPUBufferLocation = extern struct { + buffer: ?*GPUBuffer, // The buffer. + offset: u32, // The starting byte within the buffer. +}; + +pub const GPUBufferRegion = extern struct { + buffer: ?*GPUBuffer, // The buffer. + offset: u32, // The starting byte within the buffer. + size: u32, // The size in bytes of the region. +}; + +pub const GPUIndirectDrawCommand = extern struct { + num_vertices: u32, // The number of vertices to draw. + num_instances: u32, // The number of instances to draw. + first_vertex: u32, // The index of the first vertex to draw. + first_instance: u32, // The ID of the first instance to draw. +}; + +pub const GPUIndexedIndirectDrawCommand = extern struct { + num_indices: u32, // The number of indices to draw per instance. + num_instances: u32, // The number of instances to draw. + first_index: u32, // The base index within the index buffer. + vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer. + first_instance: u32, // The ID of the first instance to draw. +}; + +pub const GPUIndirectDispatchCommand = extern struct { + groupcount_x: u32, // The number of local workgroups to dispatch in the X dimension. + groupcount_y: u32, // The number of local workgroups to dispatch in the Y dimension. + groupcount_z: u32, // The number of local workgroups to dispatch in the Z dimension. +}; + +pub const GPUSamplerCreateInfo = extern struct { + min_filter: GPUFilter, // The minification filter to apply to lookups. + mag_filter: GPUFilter, // The magnification filter to apply to lookups. + mipmap_mode: GPUSamplerMipmapMode, // The mipmap filter to apply to lookups. + address_mode_u: GPUSamplerAddressMode, // The addressing mode for U coordinates outside [0, 1). + address_mode_v: GPUSamplerAddressMode, // The addressing mode for V coordinates outside [0, 1). + address_mode_w: GPUSamplerAddressMode, // The addressing mode for W coordinates outside [0, 1). + mip_lod_bias: f32, // The bias to be added to mipmap LOD calculation. + max_anisotropy: f32, // The anisotropy value clamp used by the sampler. If enable_anisotropy is false, this is ignored. + compare_op: GPUCompareOp, // The comparison operator to apply to fetched data before filtering. + min_lod: f32, // Clamps the minimum of the computed LOD value. + max_lod: f32, // Clamps the maximum of the computed LOD value. + enable_anisotropy: bool, // true to enable anisotropic filtering. + enable_compare: bool, // true to enable comparison against a reference value during lookups. + padding1: u8, + padding2: u8, + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUVertexBufferDescription = extern struct { + slot: u32, // The binding slot of the vertex buffer. + pitch: u32, // The byte pitch between consecutive elements of the vertex buffer. + input_rate: GPUVertexInputRate, // Whether attribute addressing is a function of the vertex index or instance index. + instance_step_rate: u32, // Reserved for future use. Must be set to 0. +}; + +pub const GPUVertexAttribute = extern struct { + location: u32, // The shader input location index. + buffer_slot: u32, // The binding slot of the associated vertex buffer. + format: GPUVertexElementFormat, // The size and type of the attribute data. + offset: u32, // The byte offset of this attribute relative to the start of the vertex element. +}; + +pub const GPUVertexInputState = extern struct { + vertex_buffer_descriptions: *const GPUVertexBufferDescription, // A pointer to an array of vertex buffer descriptions. + num_vertex_buffers: u32, // The number of vertex buffer descriptions in the above array. + vertex_attributes: *const GPUVertexAttribute, // A pointer to an array of vertex attribute descriptions. + num_vertex_attributes: u32, // The number of vertex attribute descriptions in the above array. +}; + +pub const GPUStencilOpState = extern struct { + fail_op: GPUStencilOp, // The action performed on samples that fail the stencil test. + pass_op: GPUStencilOp, // The action performed on samples that pass the depth and stencil tests. + depth_fail_op: GPUStencilOp, // The action performed on samples that pass the stencil test and fail the depth test. + compare_op: GPUCompareOp, // The comparison operator used in the stencil test. +}; + +pub const GPUColorTargetBlendState = extern struct { + src_color_blendfactor: GPUBlendFactor, // The value to be multiplied by the source RGB value. + dst_color_blendfactor: GPUBlendFactor, // The value to be multiplied by the destination RGB value. + color_blend_op: GPUBlendOp, // The blend operation for the RGB components. + src_alpha_blendfactor: GPUBlendFactor, // The value to be multiplied by the source alpha. + dst_alpha_blendfactor: GPUBlendFactor, // The value to be multiplied by the destination alpha. + alpha_blend_op: GPUBlendOp, // The blend operation for the alpha component. + color_write_mask: GPUColorComponentFlags, // A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false. + enable_blend: bool, // Whether blending is enabled for the color target. + enable_color_write_mask: bool, // Whether the color write mask is enabled. + padding1: u8, + padding2: u8, +}; + +pub const GPUShaderCreateInfo = extern struct { + code_size: usize, // The size in bytes of the code pointed to. + code: [*c]const u8, // A pointer to shader code. + entrypoint: [*c]const u8, // A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. + format: GPUShaderFormat, // The format of the shader code. + stage: GPUShaderStage, // The stage the shader program corresponds to. + num_samplers: u32, // The number of samplers defined in the shader. + num_storage_textures: u32, // The number of storage textures defined in the shader. + num_storage_buffers: u32, // The number of storage buffers defined in the shader. + num_uniform_buffers: u32, // The number of uniform buffers defined in the shader. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUTextureCreateInfo = extern struct { + _type: GPUTextureType, // The base dimensionality of the texture. + format: GPUTextureFormat, // The pixel format of the texture. + usage: GPUTextureUsageFlags, // How the texture is intended to be used by the client. + width: u32, // The width of the texture. + height: u32, // The height of the texture. + layer_count_or_depth: u32, // The layer count or depth of the texture. This value is treated as a layer count on 2D array textures, and as a depth value on 3D textures. + num_levels: u32, // The number of mip levels in the texture. + sample_count: GPUSampleCount, // The number of samples per texel. Only applies if the texture is used as a render target. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUBufferCreateInfo = extern struct { + usage: GPUBufferUsageFlags, // How the buffer is intended to be used by the client. + size: u32, // The size in bytes of the buffer. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUTransferBufferCreateInfo = extern struct { + usage: GPUTransferBufferUsage, // How the transfer buffer is intended to be used by the client. + size: u32, // The size in bytes of the transfer buffer. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPURasterizerState = extern struct { + fill_mode: GPUFillMode, // Whether polygons will be filled in or drawn as lines. + cull_mode: GPUCullMode, // The facing direction in which triangles will be culled. + front_face: GPUFrontFace, // The vertex winding that will cause a triangle to be determined as front-facing. + depth_bias_constant_factor: f32, // A scalar factor controlling the depth value added to each fragment. + depth_bias_clamp: f32, // The maximum depth bias of a fragment. + depth_bias_slope_factor: f32, // A scalar factor applied to a fragment's slope in depth calculations. + enable_depth_bias: bool, // true to bias fragment depth values. + enable_depth_clip: bool, // true to enable depth clip, false to enable depth clamp. + padding1: u8, + padding2: u8, +}; + +pub const GPUMultisampleState = extern struct { + sample_count: GPUSampleCount, // The number of samples to be used in rasterization. + sample_mask: u32, // Reserved for future use. Must be set to 0. + enable_mask: bool, // Reserved for future use. Must be set to false. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUDepthStencilState = extern struct { + compare_op: GPUCompareOp, // The comparison operator used for depth testing. + back_stencil_state: GPUStencilOpState, // The stencil op state for back-facing triangles. + front_stencil_state: GPUStencilOpState, // The stencil op state for front-facing triangles. + compare_mask: u8, // Selects the bits of the stencil values participating in the stencil test. + write_mask: u8, // Selects the bits of the stencil values updated by the stencil test. + enable_depth_test: bool, // true enables the depth test. + enable_depth_write: bool, // true enables depth writes. Depth writes are always disabled when enable_depth_test is false. + enable_stencil_test: bool, // true enables the stencil test. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUColorTargetDescription = extern struct { + format: GPUTextureFormat, // The pixel format of the texture to be used as a color target. + blend_state: GPUColorTargetBlendState, // The blend state to be used for the color target. +}; + +pub const GPUGraphicsPipelineTargetInfo = extern struct { + color_target_descriptions: *const GPUColorTargetDescription, // A pointer to an array of color target descriptions. + num_color_targets: u32, // The number of color target descriptions in the above array. + depth_stencil_format: GPUTextureFormat, // The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is false. + has_depth_stencil_target: bool, // true specifies that the pipeline uses a depth-stencil target. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUGraphicsPipelineCreateInfo = extern struct { + vertex_shader: ?*GPUShader, // The vertex shader used by the graphics pipeline. + fragment_shader: ?*GPUShader, // The fragment shader used by the graphics pipeline. + vertex_input_state: GPUVertexInputState, // The vertex layout of the graphics pipeline. + primitive_type: GPUPrimitiveType, // The primitive topology of the graphics pipeline. + rasterizer_state: GPURasterizerState, // The rasterizer state of the graphics pipeline. + multisample_state: GPUMultisampleState, // The multisample state of the graphics pipeline. + depth_stencil_state: GPUDepthStencilState, // The depth-stencil state of the graphics pipeline. + target_info: GPUGraphicsPipelineTargetInfo, // Formats and blend modes for the render targets of the graphics pipeline. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUComputePipelineCreateInfo = extern struct { + code_size: usize, // The size in bytes of the compute shader code pointed to. + code: [*c]const u8, // A pointer to compute shader code. + entrypoint: [*c]const u8, // A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. + format: GPUShaderFormat, // The format of the compute shader code. + num_samplers: u32, // The number of samplers defined in the shader. + num_readonly_storage_textures: u32, // The number of readonly storage textures defined in the shader. + num_readonly_storage_buffers: u32, // The number of readonly storage buffers defined in the shader. + num_readwrite_storage_textures: u32, // The number of read-write storage textures defined in the shader. + num_readwrite_storage_buffers: u32, // The number of read-write storage buffers defined in the shader. + num_uniform_buffers: u32, // The number of uniform buffers defined in the shader. + threadcount_x: u32, // The number of threads in the X dimension. This should match the value in the shader. + threadcount_y: u32, // The number of threads in the Y dimension. This should match the value in the shader. + threadcount_z: u32, // The number of threads in the Z dimension. This should match the value in the shader. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; + +pub const GPUColorTargetInfo = extern struct { + texture: ?*GPUTexture, // The texture that will be used as a color target by a render pass. + mip_level: u32, // The mip level to use as a color target. + layer_or_depth_plane: u32, // The layer index or depth plane to use as a color target. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. + clear_color: FColor, // The color to clear the color target to at the start of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + load_op: GPULoadOp, // What is done with the contents of the color target at the beginning of the render pass. + store_op: GPUStoreOp, // What is done with the results of the render pass. + resolve_texture: ?*GPUTexture, // The texture that will receive the results of a multisample resolve operation. Ignored if a RESOLVE* store_op is not used. + resolve_mip_level: u32, // The mip level of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. + resolve_layer: u32, // The layer index of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. + cycle: bool, // true cycles the texture if the texture is bound and load_op is not LOAD + cycle_resolve_texture: bool, // true cycles the resolve texture if the resolve texture is bound. Ignored if a RESOLVE* store_op is not used. + padding1: u8, + padding2: u8, +}; + +pub const GPUDepthStencilTargetInfo = extern struct { + texture: ?*GPUTexture, // The texture that will be used as the depth stencil target by the render pass. + clear_depth: f32, // The value to clear the depth component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + load_op: GPULoadOp, // What is done with the depth contents at the beginning of the render pass. + store_op: GPUStoreOp, // What is done with the depth results of the render pass. + stencil_load_op: GPULoadOp, // What is done with the stencil contents at the beginning of the render pass. + stencil_store_op: GPUStoreOp, // What is done with the stencil results of the render pass. + cycle: bool, // true cycles the texture if the texture is bound and any load ops are not LOAD + clear_stencil: u8, // The value to clear the stencil component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + padding1: u8, + padding2: u8, +}; + +pub const GPUBlitInfo = extern struct { + source: GPUBlitRegion, // The source region for the blit. + destination: GPUBlitRegion, // The destination region for the blit. + load_op: GPULoadOp, // What is done with the contents of the destination before the blit. + clear_color: FColor, // The color to clear the destination region to before the blit. Ignored if load_op is not SDL_GPU_LOADOP_CLEAR. + flip_mode: FlipMode, // The flip mode for the source region. + filter: GPUFilter, // The filter mode used when blitting. + cycle: bool, // true cycles the destination texture if it is already bound. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUBufferBinding = extern struct { + buffer: ?*GPUBuffer, // The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_VERTEX for SDL_BindGPUVertexBuffers, or SDL_GPU_BUFFERUSAGE_INDEX for SDL_BindGPUIndexBuffer. + offset: u32, // The starting byte of the data to bind in the buffer. +}; + +pub const GPUTextureSamplerBinding = extern struct { + texture: ?*GPUTexture, // The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. + sampler: ?*GPUSampler, // The sampler to bind. +}; + +pub const GPUStorageBufferReadWriteBinding = extern struct { + buffer: ?*GPUBuffer, // The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE. + cycle: bool, // true cycles the buffer if it is already bound. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub const GPUStorageTextureReadWriteBinding = extern struct { + texture: ?*GPUTexture, // The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE or SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE. + mip_level: u32, // The mip level index to bind. + layer: u32, // The layer index to bind. + cycle: bool, // true cycles the texture if it is already bound. + padding1: u8, + padding2: u8, + padding3: u8, +}; + +pub inline fn gpuSupportsShaderFormats(format_flags: GPUShaderFormat, name: [*c]const u8) bool { + return c.SDL_GPUSupportsShaderFormats(@bitCast(format_flags), name); +} + +pub inline fn gpuSupportsProperties(props: PropertiesID) bool { + return c.SDL_GPUSupportsProperties(props); +} + +pub inline fn createGPUDevice(format_flags: GPUShaderFormat, debug_mode: bool, name: [*c]const u8) ?*GPUDevice { + return c.SDL_CreateGPUDevice(@bitCast(format_flags), debug_mode, name); +} + +pub inline fn createGPUDeviceWithProperties(props: PropertiesID) ?*GPUDevice { + return c.SDL_CreateGPUDeviceWithProperties(props); +} + +pub inline fn getNumGPUDrivers() c_int { + return c.SDL_GetNumGPUDrivers(); +} + +pub inline fn getGPUDriver(index: c_int) [*c]const u8 { + return c.SDL_GetGPUDriver(index); +} + +pub inline fn gpuTextureFormatTexelBlockSize(format: GPUTextureFormat) u32 { + return c.SDL_GPUTextureFormatTexelBlockSize(@bitCast(format)); +} + +pub inline fn calculateGPUTextureFormatSize(format: GPUTextureFormat, width: u32, height: u32, depth_or_layer_count: u32) u32 { + return c.SDL_CalculateGPUTextureFormatSize(@bitCast(format), width, height, depth_or_layer_count); +} diff --git a/v2/haptic.zig b/v2/haptic.zig new file mode 100644 index 0000000..bbf2b3d --- /dev/null +++ b/v2/haptic.zig @@ -0,0 +1,230 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Joystick = opaque { + pub inline fn isJoystickHaptic(joystick: *Joystick) bool { + return c.SDL_IsJoystickHaptic(joystick); + } + + pub inline fn openHapticFromJoystick(joystick: *Joystick) ?*Haptic { + return c.SDL_OpenHapticFromJoystick(joystick); + } +}; + +pub const Haptic = opaque { + pub inline fn getHapticID(haptic: *Haptic) HapticID { + return c.SDL_GetHapticID(haptic); + } + + pub inline fn getHapticName(haptic: *Haptic) [*c]const u8 { + return c.SDL_GetHapticName(haptic); + } + + pub inline fn closeHaptic(haptic: *Haptic) void { + return c.SDL_CloseHaptic(haptic); + } + + pub inline fn getMaxHapticEffects(haptic: *Haptic) c_int { + return c.SDL_GetMaxHapticEffects(haptic); + } + + pub inline fn getMaxHapticEffectsPlaying(haptic: *Haptic) c_int { + return c.SDL_GetMaxHapticEffectsPlaying(haptic); + } + + pub inline fn getHapticFeatures(haptic: *Haptic) u32 { + return c.SDL_GetHapticFeatures(haptic); + } + + pub inline fn getNumHapticAxes(haptic: *Haptic) c_int { + return c.SDL_GetNumHapticAxes(haptic); + } + + pub inline fn hapticEffectSupported(haptic: *Haptic, effect: *const HapticEffect) bool { + return c.SDL_HapticEffectSupported(haptic, @ptrCast(effect)); + } + + pub inline fn createHapticEffect(haptic: *Haptic, effect: *const HapticEffect) c_int { + return c.SDL_CreateHapticEffect(haptic, @ptrCast(effect)); + } + + pub inline fn updateHapticEffect(haptic: *Haptic, effect: c_int, data: *const HapticEffect) bool { + return c.SDL_UpdateHapticEffect(haptic, effect, @ptrCast(data)); + } + + pub inline fn runHapticEffect(haptic: *Haptic, effect: c_int, iterations: u32) bool { + return c.SDL_RunHapticEffect(haptic, effect, iterations); + } + + pub inline fn stopHapticEffect(haptic: *Haptic, effect: c_int) bool { + return c.SDL_StopHapticEffect(haptic, effect); + } + + pub inline fn destroyHapticEffect(haptic: *Haptic, effect: c_int) void { + return c.SDL_DestroyHapticEffect(haptic, effect); + } + + pub inline fn getHapticEffectStatus(haptic: *Haptic, effect: c_int) bool { + return c.SDL_GetHapticEffectStatus(haptic, effect); + } + + pub inline fn setHapticGain(haptic: *Haptic, gain: c_int) bool { + return c.SDL_SetHapticGain(haptic, gain); + } + + pub inline fn setHapticAutocenter(haptic: *Haptic, autocenter: c_int) bool { + return c.SDL_SetHapticAutocenter(haptic, autocenter); + } + + pub inline fn pauseHaptic(haptic: *Haptic) bool { + return c.SDL_PauseHaptic(haptic); + } + + pub inline fn resumeHaptic(haptic: *Haptic) bool { + return c.SDL_ResumeHaptic(haptic); + } + + pub inline fn stopHapticEffects(haptic: *Haptic) bool { + return c.SDL_StopHapticEffects(haptic); + } + + pub inline fn hapticRumbleSupported(haptic: *Haptic) bool { + return c.SDL_HapticRumbleSupported(haptic); + } + + pub inline fn initHapticRumble(haptic: *Haptic) bool { + return c.SDL_InitHapticRumble(haptic); + } + + pub inline fn playHapticRumble(haptic: *Haptic, strength: f32, length: u32) bool { + return c.SDL_PlayHapticRumble(haptic, strength, length); + } + + pub inline fn stopHapticRumble(haptic: *Haptic) bool { + return c.SDL_StopHapticRumble(haptic); + } +}; + +pub const HapticDirection = extern struct { + _type: u8, // The type of encoding. + dir: [3]i32, // The encoded direction. +}; + +pub const HapticConstant = extern struct { + _type: u16, // SDL_HAPTIC_CONSTANT + direction: HapticDirection, // Direction of the effect. + length: u32, // Duration of the effect. + delay: u16, // Delay before starting the effect. + button: u16, // Button that triggers the effect. + interval: u16, // How soon it can be triggered again after button. + level: i16, // Strength of the constant effect. + attack_length: u16, // Duration of the attack. + attack_level: u16, // Level at the start of the attack. + fade_length: u16, // Duration of the fade. + fade_level: u16, // Level at the end of the fade. +}; + +pub const HapticPeriodic = extern struct { + direction: HapticDirection, // Direction of the effect. + length: u32, // Duration of the effect. + delay: u16, // Delay before starting the effect. + button: u16, // Button that triggers the effect. + interval: u16, // How soon it can be triggered again after button. + period: u16, // Period of the wave. + magnitude: i16, // Peak value; if negative, equivalent to 180 degrees extra phase shift. + offset: i16, // Mean value of the wave. + phase: u16, // Positive phase shift given by hundredth of a degree. + attack_length: u16, // Duration of the attack. + attack_level: u16, // Level at the start of the attack. + fade_length: u16, // Duration of the fade. + fade_level: u16, // Level at the end of the fade. +}; + +pub const HapticCondition = extern struct { + direction: HapticDirection, // Direction of the effect. + length: u32, // Duration of the effect. + delay: u16, // Delay before starting the effect. + button: u16, // Button that triggers the effect. + interval: u16, // How soon it can be triggered again after button. + right_sat: [3]u16, // Level when joystick is to the positive side; max 0xFFFF. + left_sat: [3]u16, // Level when joystick is to the negative side; max 0xFFFF. + right_coeff: [3]i16, // How fast to increase the force towards the positive side. + left_coeff: [3]i16, // How fast to increase the force towards the negative side. + deadband: [3]u16, // Size of the dead zone; max 0xFFFF: whole axis-range when 0-centered. + center: [3]i16, // Position of the dead zone. +}; + +pub const HapticRamp = extern struct { + _type: u16, // SDL_HAPTIC_RAMP + direction: HapticDirection, // Direction of the effect. + length: u32, // Duration of the effect. + delay: u16, // Delay before starting the effect. + button: u16, // Button that triggers the effect. + interval: u16, // How soon it can be triggered again after button. + start: i16, // Beginning strength level. + end: i16, // Ending strength level. + attack_length: u16, // Duration of the attack. + attack_level: u16, // Level at the start of the attack. + fade_length: u16, // Duration of the fade. + fade_level: u16, // Level at the end of the fade. +}; + +pub const HapticLeftRight = extern struct { + _type: u16, // SDL_HAPTIC_LEFTRIGHT + length: u32, // Duration of the effect in milliseconds. + large_magnitude: u16, // Control of the large controller motor. + small_magnitude: u16, // Control of the small controller motor. +}; + +pub const HapticCustom = extern struct { + _type: u16, // SDL_HAPTIC_CUSTOM + direction: HapticDirection, // Direction of the effect. + length: u32, // Duration of the effect. + delay: u16, // Delay before starting the effect. + button: u16, // Button that triggers the effect. + interval: u16, // How soon it can be triggered again after button. + channels: u8, // Axes to use, minimum of one. + period: u16, // Sample periods. + samples: u16, // Amount of samples. + data: *u16, // Should contain channels*samples items. + attack_length: u16, // Duration of the attack. + attack_level: u16, // Level at the start of the attack. + fade_length: u16, // Duration of the fade. + fade_level: u16, // Level at the end of the fade. +}; + +pub const HapticEffect = extern union { + _type: u16, // Effect type. + constant: HapticConstant, // Constant effect. + periodic: HapticPeriodic, // Periodic effect. + condition: HapticCondition, // Condition effect. + ramp: HapticRamp, // Ramp effect. + leftright: HapticLeftRight, // Left/Right effect. + custom: HapticCustom, // Custom effect. +}; + +pub const HapticID = u32; + +pub inline fn getHaptics(count: *c_int) ?*HapticID { + return c.SDL_GetHaptics(@ptrCast(count)); +} + +pub inline fn getHapticNameForID(instance_id: HapticID) [*c]const u8 { + return c.SDL_GetHapticNameForID(instance_id); +} + +pub inline fn openHaptic(instance_id: HapticID) ?*Haptic { + return c.SDL_OpenHaptic(instance_id); +} + +pub inline fn getHapticFromID(instance_id: HapticID) ?*Haptic { + return c.SDL_GetHapticFromID(instance_id); +} + +pub inline fn isMouseHaptic() bool { + return c.SDL_IsMouseHaptic(); +} + +pub inline fn openHapticFromMouse() ?*Haptic { + return c.SDL_OpenHapticFromMouse(); +} diff --git a/v2/hints.zig b/v2/hints.zig new file mode 100644 index 0000000..0c207a5 --- /dev/null +++ b/v2/hints.zig @@ -0,0 +1,42 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const HintPriority = enum(c_int) { + hintDefault, + hintNormal, + hintOverride, +}; + +pub inline fn setHintWithPriority(name: [*c]const u8, value: [*c]const u8, priority: HintPriority) bool { + return c.SDL_SetHintWithPriority(name, value, priority); +} + +pub inline fn setHint(name: [*c]const u8, value: [*c]const u8) bool { + return c.SDL_SetHint(name, value); +} + +pub inline fn resetHint(name: [*c]const u8) bool { + return c.SDL_ResetHint(name); +} + +pub inline fn resetHints() void { + return c.SDL_ResetHints(); +} + +pub inline fn getHint(name: [*c]const u8) [*c]const u8 { + return c.SDL_GetHint(name); +} + +pub inline fn getHintBoolean(name: [*c]const u8, default_value: bool) bool { + return c.SDL_GetHintBoolean(name, default_value); +} + +pub const HintCallback = *const fn (userdata: ?*anyopaque, name: [*c]const u8, oldValue: [*c]const u8, newValue: [*c]const u8) callconv(.C) void; + +pub inline fn addHintCallback(name: [*c]const u8, callback: HintCallback, userdata: ?*anyopaque) bool { + return c.SDL_AddHintCallback(name, callback, userdata); +} + +pub inline fn removeHintCallback(name: [*c]const u8, callback: HintCallback, userdata: ?*anyopaque) void { + return c.SDL_RemoveHintCallback(name, callback, userdata); +} diff --git a/v2/init.zig b/v2/init.zig new file mode 100644 index 0000000..a1cecc2 --- /dev/null +++ b/v2/init.zig @@ -0,0 +1,113 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Event = extern union { + _type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration + common: CommonEvent, // Common event data + display: DisplayEvent, // Display event data + window: WindowEvent, // Window event data + kdevice: KeyboardDeviceEvent, // Keyboard device change event data + key: KeyboardEvent, // Keyboard event data + edit: TextEditingEvent, // Text editing event data + edit_candidates: TextEditingCandidatesEvent, // Text editing candidates event data + text: TextInputEvent, // Text input event data + mdevice: MouseDeviceEvent, // Mouse device change event data + motion: MouseMotionEvent, // Mouse motion event data + button: MouseButtonEvent, // Mouse button event data + wheel: MouseWheelEvent, // Mouse wheel event data + jdevice: JoyDeviceEvent, // Joystick device change event data + jaxis: JoyAxisEvent, // Joystick axis event data + jball: JoyBallEvent, // Joystick ball event data + jhat: JoyHatEvent, // Joystick hat event data + jbutton: JoyButtonEvent, // Joystick button event data + jbattery: JoyBatteryEvent, // Joystick battery event data + gdevice: GamepadDeviceEvent, // Gamepad device event data + gaxis: GamepadAxisEvent, // Gamepad axis event data + gbutton: GamepadButtonEvent, // Gamepad button event data + gtouchpad: GamepadTouchpadEvent, // Gamepad touchpad event data + gsensor: GamepadSensorEvent, // Gamepad sensor event data + adevice: AudioDeviceEvent, // Audio device event data + cdevice: CameraDeviceEvent, // Camera device event data + sensor: SensorEvent, // Sensor event data + quit: QuitEvent, // Quit request event data + user: UserEvent, // Custom event data + tfinger: TouchFingerEvent, // Touch finger event data + pproximity: PenProximityEvent, // Pen proximity event data + ptouch: PenTouchEvent, // Pen tip touching event data + pmotion: PenMotionEvent, // Pen motion event data + pbutton: PenButtonEvent, // Pen button event data + paxis: PenAxisEvent, // Pen axis event data + render: RenderEvent, // Render event data + drop: DropEvent, // Drag and drop event data + clipboard: ClipboardEvent, // Clipboard event data + padding: [128]u8, +}; + +pub const InitFlags = packed struct(u32) { + initAudio: bool = false, // `SDL_INIT_AUDIO` implies `SDL_INIT_EVENTS` + initVideo: bool = false, // `SDL_INIT_VIDEO` implies `SDL_INIT_EVENTS`, should be initialized on the main thread + initJoystick: bool = false, // `SDL_INIT_JOYSTICK` implies `SDL_INIT_EVENTS`, should be initialized on the same thread as SDL_INIT_VIDEO on Windows if you don't set SDL_HINT_JOYSTICK_THREAD + initHaptic: bool = false, + initGamepad: bool = false, // `SDL_INIT_GAMEPAD` implies `SDL_INIT_JOYSTICK` + initEvents: bool = false, + initSensor: bool = false, // `SDL_INIT_SENSOR` implies `SDL_INIT_EVENTS` + initCamera: bool = false, // `SDL_INIT_CAMERA` implies `SDL_INIT_EVENTS` + pad0: u23 = 0, + rsvd: bool = false, +}; + +pub const AppResult = enum(c_int) { + appContinue, //Value that requests that the app continue from the main callbacks. + appSuccess, //Value that requests termination with success from the main callbacks. + appFailure, //Value that requests termination with error from the main callbacks. +}; + +pub const AppInit_func = *const fn (appstate: [*c]?*anyopaque, argc: c_int, argv: [*c][*c]u8) callconv(.C) AppResult; + +pub const AppIterate_func = *const fn (appstate: ?*anyopaque) callconv(.C) AppResult; + +pub const AppEvent_func = *const fn (appstate: ?*anyopaque, event: ?*Event) callconv(.C) AppResult; + +pub const AppQuit_func = *const fn (appstate: ?*anyopaque, result: AppResult) callconv(.C) void; + +pub inline fn init(flags: InitFlags) bool { + return c.SDL_Init(@bitCast(flags)); +} + +pub inline fn initSubSystem(flags: InitFlags) bool { + return c.SDL_InitSubSystem(@bitCast(flags)); +} + +pub inline fn quitSubSystem(flags: InitFlags) void { + return c.SDL_QuitSubSystem(@bitCast(flags)); +} + +pub inline fn wasInit(flags: InitFlags) InitFlags { + return @bitCast(c.SDL_WasInit(@bitCast(flags))); +} + +pub inline fn quit() void { + return c.SDL_Quit(); +} + +pub inline fn isMainThread() bool { + return c.SDL_IsMainThread(); +} + +pub const MainThreadCallback = *const fn (userdata: ?*anyopaque) callconv(.C) void; + +pub inline fn runOnMainThread(callback: MainThreadCallback, userdata: ?*anyopaque, wait_complete: bool) bool { + return c.SDL_RunOnMainThread(callback, userdata, wait_complete); +} + +pub inline fn setAppMetadata(appname: [*c]const u8, appversion: [*c]const u8, appidentifier: [*c]const u8) bool { + return c.SDL_SetAppMetadata(appname, appversion, appidentifier); +} + +pub inline fn setAppMetadataProperty(name: [*c]const u8, value: [*c]const u8) bool { + return c.SDL_SetAppMetadataProperty(name, value); +} + +pub inline fn getAppMetadataProperty(name: [*c]const u8) [*c]const u8 { + return c.SDL_GetAppMetadataProperty(name); +} diff --git a/v2/joystick.zig b/v2/joystick.zig new file mode 100644 index 0000000..7ed7d56 --- /dev/null +++ b/v2/joystick.zig @@ -0,0 +1,321 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PropertiesID = u32; + +pub const SensorType = enum(c_int) { + sensorInvalid, //Returned for an invalid sensor + sensorUnknown, //Unknown sensor type + sensorAccel, //Accelerometer + sensorGyro, //Gyroscope + sensorAccelL, //Accelerometer for left Joy-Con controller and Wii nunchuk + sensorGyroL, //Gyroscope for left Joy-Con controller + sensorAccelR, //Accelerometer for right Joy-Con controller + sensorGyroR, //Gyroscope for right Joy-Con controller +}; + +pub const GUID = extern struct { + data: [16]u8, +}; + +pub const PowerState = enum(c_int) { + powerstateError, //error determining power status + powerstateUnknown, //cannot determine power status + powerstateOnBattery, //Not plugged in, running on the battery + powerstateNoBattery, //Plugged in, no battery available + powerstateCharging, //Plugged in, charging battery + powerstateCharged, +}; + +pub const Joystick = opaque { + pub inline fn setJoystickVirtualAxis(joystick: *Joystick, axis: c_int, value: i16) bool { + return c.SDL_SetJoystickVirtualAxis(joystick, axis, value); + } + + pub inline fn setJoystickVirtualBall(joystick: *Joystick, ball: c_int, xrel: i16, yrel: i16) bool { + return c.SDL_SetJoystickVirtualBall(joystick, ball, xrel, yrel); + } + + pub inline fn setJoystickVirtualButton(joystick: *Joystick, button: c_int, down: bool) bool { + return c.SDL_SetJoystickVirtualButton(joystick, button, down); + } + + pub inline fn setJoystickVirtualHat(joystick: *Joystick, hat: c_int, value: u8) bool { + return c.SDL_SetJoystickVirtualHat(joystick, hat, value); + } + + pub inline fn setJoystickVirtualTouchpad(joystick: *Joystick, touchpad: c_int, finger: c_int, down: bool, x: f32, y: f32, pressure: f32) bool { + return c.SDL_SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure); + } + + pub inline fn sendJoystickVirtualSensorData(joystick: *Joystick, _type: SensorType, sensor_timestamp: u64, data: *const f32, num_values: c_int) bool { + return c.SDL_SendJoystickVirtualSensorData(joystick, @intFromEnum(_type), sensor_timestamp, @ptrCast(data), num_values); + } + + pub inline fn getJoystickProperties(joystick: *Joystick) PropertiesID { + return c.SDL_GetJoystickProperties(joystick); + } + + pub inline fn getJoystickName(joystick: *Joystick) [*c]const u8 { + return c.SDL_GetJoystickName(joystick); + } + + pub inline fn getJoystickPath(joystick: *Joystick) [*c]const u8 { + return c.SDL_GetJoystickPath(joystick); + } + + pub inline fn getJoystickPlayerIndex(joystick: *Joystick) c_int { + return c.SDL_GetJoystickPlayerIndex(joystick); + } + + pub inline fn setJoystickPlayerIndex(joystick: *Joystick, player_index: c_int) bool { + return c.SDL_SetJoystickPlayerIndex(joystick, player_index); + } + + pub inline fn getJoystickGUID(joystick: *Joystick) GUID { + return c.SDL_GetJoystickGUID(joystick); + } + + pub inline fn getJoystickVendor(joystick: *Joystick) u16 { + return c.SDL_GetJoystickVendor(joystick); + } + + pub inline fn getJoystickProduct(joystick: *Joystick) u16 { + return c.SDL_GetJoystickProduct(joystick); + } + + pub inline fn getJoystickProductVersion(joystick: *Joystick) u16 { + return c.SDL_GetJoystickProductVersion(joystick); + } + + pub inline fn getJoystickFirmwareVersion(joystick: *Joystick) u16 { + return c.SDL_GetJoystickFirmwareVersion(joystick); + } + + pub inline fn getJoystickSerial(joystick: *Joystick) [*c]const u8 { + return c.SDL_GetJoystickSerial(joystick); + } + + pub inline fn getJoystickType(joystick: *Joystick) JoystickType { + return @intFromEnum(c.SDL_GetJoystickType(joystick)); + } + + pub inline fn joystickConnected(joystick: *Joystick) bool { + return c.SDL_JoystickConnected(joystick); + } + + pub inline fn getJoystickID(joystick: *Joystick) JoystickID { + return c.SDL_GetJoystickID(joystick); + } + + pub inline fn getNumJoystickAxes(joystick: *Joystick) c_int { + return c.SDL_GetNumJoystickAxes(joystick); + } + + pub inline fn getNumJoystickBalls(joystick: *Joystick) c_int { + return c.SDL_GetNumJoystickBalls(joystick); + } + + pub inline fn getNumJoystickHats(joystick: *Joystick) c_int { + return c.SDL_GetNumJoystickHats(joystick); + } + + pub inline fn getNumJoystickButtons(joystick: *Joystick) c_int { + return c.SDL_GetNumJoystickButtons(joystick); + } + + pub inline fn getJoystickAxis(joystick: *Joystick, axis: c_int) i16 { + return c.SDL_GetJoystickAxis(joystick, axis); + } + + pub inline fn getJoystickAxisInitialState(joystick: *Joystick, axis: c_int, state: *i16) bool { + return c.SDL_GetJoystickAxisInitialState(joystick, axis, @ptrCast(state)); + } + + pub inline fn getJoystickBall(joystick: *Joystick, ball: c_int, dx: *c_int, dy: *c_int) bool { + return c.SDL_GetJoystickBall(joystick, ball, @ptrCast(dx), @ptrCast(dy)); + } + + pub inline fn getJoystickHat(joystick: *Joystick, hat: c_int) u8 { + return c.SDL_GetJoystickHat(joystick, hat); + } + + pub inline fn getJoystickButton(joystick: *Joystick, button: c_int) bool { + return c.SDL_GetJoystickButton(joystick, button); + } + + pub inline fn rumbleJoystick(joystick: *Joystick, low_frequency_rumble: u16, high_frequency_rumble: u16, duration_ms: u32) bool { + return c.SDL_RumbleJoystick(joystick, low_frequency_rumble, high_frequency_rumble, duration_ms); + } + + pub inline fn rumbleJoystickTriggers(joystick: *Joystick, left_rumble: u16, right_rumble: u16, duration_ms: u32) bool { + return c.SDL_RumbleJoystickTriggers(joystick, left_rumble, right_rumble, duration_ms); + } + + pub inline fn setJoystickLED(joystick: *Joystick, red: u8, green: u8, blue: u8) bool { + return c.SDL_SetJoystickLED(joystick, red, green, blue); + } + + pub inline fn sendJoystickEffect(joystick: *Joystick, data: ?*const anyopaque, size: c_int) bool { + return c.SDL_SendJoystickEffect(joystick, data, size); + } + + pub inline fn closeJoystick(joystick: *Joystick) void { + return c.SDL_CloseJoystick(joystick); + } + + pub inline fn getJoystickConnectionState(joystick: *Joystick) JoystickConnectionState { + return c.SDL_GetJoystickConnectionState(joystick); + } + + pub inline fn getJoystickPowerInfo(joystick: *Joystick, percent: *c_int) PowerState { + return c.SDL_GetJoystickPowerInfo(joystick, @ptrCast(percent)); + } +}; + +pub const JoystickID = u32; + +pub const JoystickType = enum(c_int) { + joystickTypeUnknown, + joystickTypeGamepad, + joystickTypeWheel, + joystickTypeArcadeStick, + joystickTypeFlightStick, + joystickTypeDancePad, + joystickTypeGuitar, + joystickTypeDrumKit, + joystickTypeArcadePad, + joystickTypeThrottle, + joystickTypeCount, +}; + +pub const JoystickConnectionState = enum(c_int) { + joystickConnectionUnknown, + joystickConnectionWired, + joystickConnectionWireless, +}; + +pub inline fn lockJoysticks() void { + return c.SDL_LockJoysticks(); +} + +pub inline fn unlockJoysticks() void { + return c.SDL_UnlockJoysticks(); +} + +pub inline fn hasJoystick() bool { + return c.SDL_HasJoystick(); +} + +pub inline fn getJoysticks(count: *c_int) ?*JoystickID { + return c.SDL_GetJoysticks(@ptrCast(count)); +} + +pub inline fn getJoystickNameForID(instance_id: JoystickID) [*c]const u8 { + return c.SDL_GetJoystickNameForID(instance_id); +} + +pub inline fn getJoystickPathForID(instance_id: JoystickID) [*c]const u8 { + return c.SDL_GetJoystickPathForID(instance_id); +} + +pub inline fn getJoystickPlayerIndexForID(instance_id: JoystickID) c_int { + return c.SDL_GetJoystickPlayerIndexForID(instance_id); +} + +pub inline fn getJoystickGUIDForID(instance_id: JoystickID) GUID { + return c.SDL_GetJoystickGUIDForID(instance_id); +} + +pub inline fn getJoystickVendorForID(instance_id: JoystickID) u16 { + return c.SDL_GetJoystickVendorForID(instance_id); +} + +pub inline fn getJoystickProductForID(instance_id: JoystickID) u16 { + return c.SDL_GetJoystickProductForID(instance_id); +} + +pub inline fn getJoystickProductVersionForID(instance_id: JoystickID) u16 { + return c.SDL_GetJoystickProductVersionForID(instance_id); +} + +pub inline fn getJoystickTypeForID(instance_id: JoystickID) JoystickType { + return @intFromEnum(c.SDL_GetJoystickTypeForID(instance_id)); +} + +pub inline fn openJoystick(instance_id: JoystickID) ?*Joystick { + return c.SDL_OpenJoystick(instance_id); +} + +pub inline fn getJoystickFromID(instance_id: JoystickID) ?*Joystick { + return c.SDL_GetJoystickFromID(instance_id); +} + +pub inline fn getJoystickFromPlayerIndex(player_index: c_int) ?*Joystick { + return c.SDL_GetJoystickFromPlayerIndex(player_index); +} + +pub const VirtualJoystickTouchpadDesc = extern struct { + nfingers: u16, // the number of simultaneous fingers on this touchpad + padding: [3]u16, +}; + +pub const VirtualJoystickSensorDesc = extern struct { + _type: SensorType, // the type of this sensor + rate: f32, // the update frequency of this sensor, may be 0.0f +}; + +pub const VirtualJoystickDesc = extern struct { + version: u32, // the version of this interface + _type: u16, // `SDL_JoystickType` + padding: u16, // unused + vendor_id: u16, // the USB vendor ID of this joystick + product_id: u16, // the USB product ID of this joystick + naxes: u16, // the number of axes on this joystick + nbuttons: u16, // the number of buttons on this joystick + nballs: u16, // the number of balls on this joystick + nhats: u16, // the number of hats on this joystick + ntouchpads: u16, // the number of touchpads on this joystick, requires `touchpads` to point at valid descriptions + nsensors: u16, // the number of sensors on this joystick, requires `sensors` to point at valid descriptions + padding2: [2]u16, // unused + name: [*c]const u8, // the name of the joystick + touchpads: *const VirtualJoystickTouchpadDesc, // A pointer to an array of touchpad descriptions, required if `ntouchpads` is > 0 + sensors: *const VirtualJoystickSensorDesc, // A pointer to an array of sensor descriptions, required if `nsensors` is > 0 + userdata: ?*anyopaque, // User data pointer passed to callbacks + Update: ?*const anyopaque, // Called when the joystick state should be updated + SetPlayerIndex: ?*const anyopaque, // Called when the player index is set + Rumble: ?*const anyopaque, // Implements SDL_RumbleJoystick() + RumbleTriggers: ?*const anyopaque, // Implements SDL_RumbleJoystickTriggers() + SetLED: ?*const anyopaque, // Implements SDL_SetJoystickLED() + SendEffect: ?*const anyopaque, // Implements SDL_SendJoystickEffect() + SetSensorsEnabled: ?*const anyopaque, // Implements SDL_SetGamepadSensorEnabled() + Cleanup: ?*const anyopaque, // Cleans up the userdata when the joystick is detached +}; + +pub inline fn attachVirtualJoystick(desc: *const VirtualJoystickDesc) JoystickID { + return c.SDL_AttachVirtualJoystick(@ptrCast(desc)); +} + +pub inline fn detachVirtualJoystick(instance_id: JoystickID) bool { + return c.SDL_DetachVirtualJoystick(instance_id); +} + +pub inline fn isJoystickVirtual(instance_id: JoystickID) bool { + return c.SDL_IsJoystickVirtual(instance_id); +} + +pub inline fn getJoystickGUIDInfo(guid: GUID, vendor: *u16, product: *u16, version: *u16, crc16: *u16) void { + return c.SDL_GetJoystickGUIDInfo(guid, @ptrCast(vendor), @ptrCast(product), @ptrCast(version), @ptrCast(crc16)); +} + +pub inline fn setJoystickEventsEnabled(enabled: bool) void { + return c.SDL_SetJoystickEventsEnabled(enabled); +} + +pub inline fn joystickEventsEnabled() bool { + return c.SDL_JoystickEventsEnabled(); +} + +pub inline fn updateJoysticks() void { + return c.SDL_UpdateJoysticks(); +} diff --git a/v2/keycode.zig b/v2/keycode.zig new file mode 100644 index 0000000..d0aaa55 --- /dev/null +++ b/v2/keycode.zig @@ -0,0 +1,6 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Keycode = u32; + +pub const Keymod = u16; diff --git a/v2/loadso.zig b/v2/loadso.zig new file mode 100644 index 0000000..b59c408 --- /dev/null +++ b/v2/loadso.zig @@ -0,0 +1,18 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const FunctionPointer = ?*anyopaque; + +pub const SharedObject = opaque { + pub inline fn loadFunction(sharedobject: *SharedObject, name: [*c]const u8) FunctionPointer { + return c.SDL_LoadFunction(sharedobject, name); + } + + pub inline fn unloadObject(sharedobject: *SharedObject) void { + return c.SDL_UnloadObject(sharedobject); + } +}; + +pub inline fn loadObject(sofile: [*c]const u8) ?*SharedObject { + return c.SDL_LoadObject(sofile); +} diff --git a/v2/messagebox.zig b/v2/messagebox.zig new file mode 100644 index 0000000..09fa96c --- /dev/null +++ b/v2/messagebox.zig @@ -0,0 +1,64 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Window = opaque {}; + +pub const MessageBoxFlags = packed struct(u32) { + messageboxError: bool = false, // error dialog + messageboxWarning: bool = false, // warning dialog + messageboxInformation: bool = false, // informational dialog + messageboxButtonsLeftToRight: bool = false, // buttons placed left to right + messageboxButtonsRightToLeft: bool = false, // buttons placed right to left + pad0: u26 = 0, + rsvd: bool = false, +}; + +pub const MessageBoxButtonFlags = packed struct(u32) { + messageboxButtonReturnkeyDefault: bool = false, // Marks the default button when return is hit + messageboxButtonEscapekeyDefault: bool = false, // Marks the default button when escape is hit + pad0: u29 = 0, + rsvd: bool = false, +}; + +pub const MessageBoxButtonData = extern struct { + flags: MessageBoxButtonFlags, + buttonID: c_int, // User defined button id (value returned via SDL_ShowMessageBox) + text: [*c]const u8, // The UTF-8 button text +}; + +pub const MessageBoxColor = extern struct { + r: u8, + g: u8, + b: u8, +}; + +pub const MessageBoxColorType = enum(c_int) { + messageboxColorBackground, + messageboxColorText, + messageboxColorButtonBorder, + messageboxColorButtonBackground, + messageboxColorButtonSelected, + messageboxColorCount, //Size of the colors array of SDL_MessageBoxColorScheme. +}; + +pub const MessageBoxColorScheme = extern struct { + colors: [SDL_MESSAGEBOX_COLOR_COUNT]MessageBoxColor, +}; + +pub const MessageBoxData = extern struct { + flags: MessageBoxFlags, + window: ?*Window, // Parent window, can be NULL + title: [*c]const u8, // UTF-8 title + message: [*c]const u8, // UTF-8 message text + numbuttons: c_int, + buttons: *const MessageBoxButtonData, + colorScheme: *const MessageBoxColorScheme, // SDL_MessageBoxColorScheme, can be NULL to use system settings +}; + +pub inline fn showMessageBox(messageboxdata: *const MessageBoxData, buttonid: *c_int) bool { + return c.SDL_ShowMessageBox(@ptrCast(messageboxdata), @ptrCast(buttonid)); +} + +pub inline fn showSimpleMessageBox(flags: MessageBoxFlags, title: [*c]const u8, message: [*c]const u8, window: ?*Window) bool { + return c.SDL_ShowSimpleMessageBox(@bitCast(flags), title, message, window); +} diff --git a/v2/misc.zig b/v2/misc.zig new file mode 100644 index 0000000..2bcc6d5 --- /dev/null +++ b/v2/misc.zig @@ -0,0 +1,6 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub inline fn openURL(url: [*c]const u8) bool { + return c.SDL_OpenURL(url); +} diff --git a/v2/mouse.zig b/v2/mouse.zig new file mode 100644 index 0000000..2939c4f --- /dev/null +++ b/v2/mouse.zig @@ -0,0 +1,135 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Window = opaque { + pub inline fn warpMouseInWindow(window: *Window, x: f32, y: f32) void { + return c.SDL_WarpMouseInWindow(window, x, y); + } + + pub inline fn setWindowRelativeMouseMode(window: *Window, enabled: bool) bool { + return c.SDL_SetWindowRelativeMouseMode(window, enabled); + } + + pub inline fn getWindowRelativeMouseMode(window: *Window) bool { + return c.SDL_GetWindowRelativeMouseMode(window); + } +}; + +pub const Surface = opaque { + pub inline fn createColorCursor(surface: *Surface, hot_x: c_int, hot_y: c_int) ?*Cursor { + return c.SDL_CreateColorCursor(surface, hot_x, hot_y); + } +}; + +pub const MouseID = u32; + +pub const Cursor = opaque { + pub inline fn setCursor(cursor: *Cursor) bool { + return c.SDL_SetCursor(cursor); + } + + pub inline fn destroyCursor(cursor: *Cursor) void { + return c.SDL_DestroyCursor(cursor); + } +}; + +pub const SystemCursor = enum(c_int) { + systemCursorDefault, //Default cursor. Usually an arrow. + systemCursorText, //Text selection. Usually an I-beam. + systemCursorWait, //Wait. Usually an hourglass or watch or spinning ball. + systemCursorCrosshair, //Crosshair. + systemCursorProgress, //Program is busy but still interactive. Usually it's WAIT with an arrow. + systemCursorNwseResize, //Double arrow pointing northwest and southeast. + systemCursorNeswResize, //Double arrow pointing northeast and southwest. + systemCursorEwResize, //Double arrow pointing west and east. + systemCursorNsResize, //Double arrow pointing north and south. + systemCursorMove, //Four pointed arrow pointing north, south, east, and west. + systemCursorNotAllowed, //Not permitted. Usually a slashed circle or crossbones. + systemCursorPointer, //Pointer that indicates a link. Usually a pointing hand. + systemCursorNwResize, //Window resize top-left. This may be a single arrow or a double arrow like NWSE_RESIZE. + systemCursorNResize, //Window resize top. May be NS_RESIZE. + systemCursorNeResize, //Window resize top-right. May be NESW_RESIZE. + systemCursorEResize, //Window resize right. May be EW_RESIZE. + systemCursorSeResize, //Window resize bottom-right. May be NWSE_RESIZE. + systemCursorSResize, //Window resize bottom. May be NS_RESIZE. + systemCursorSwResize, //Window resize bottom-left. May be NESW_RESIZE. + systemCursorWResize, //Window resize left. May be EW_RESIZE. + systemCursorCount, +}; + +pub const MouseWheelDirection = enum(c_int) { + mousewheelNormal, //The scroll direction is normal + mousewheelFlipped, //The scroll direction is flipped / natural +}; + +pub const MouseButtonFlags = packed struct(u32) { + buttonLeft: bool = false, + buttonMiddle: bool = false, + buttonX1: bool = false, + pad0: u28 = 0, + rsvd: bool = false, +}; + +pub inline fn hasMouse() bool { + return c.SDL_HasMouse(); +} + +pub inline fn getMice(count: *c_int) ?*MouseID { + return c.SDL_GetMice(@ptrCast(count)); +} + +pub inline fn getMouseNameForID(instance_id: MouseID) [*c]const u8 { + return c.SDL_GetMouseNameForID(instance_id); +} + +pub inline fn getMouseFocus() ?*Window { + return c.SDL_GetMouseFocus(); +} + +pub inline fn getMouseState(x: *f32, y: *f32) MouseButtonFlags { + return @bitCast(c.SDL_GetMouseState(@ptrCast(x), @ptrCast(y))); +} + +pub inline fn getGlobalMouseState(x: *f32, y: *f32) MouseButtonFlags { + return @bitCast(c.SDL_GetGlobalMouseState(@ptrCast(x), @ptrCast(y))); +} + +pub inline fn getRelativeMouseState(x: *f32, y: *f32) MouseButtonFlags { + return @bitCast(c.SDL_GetRelativeMouseState(@ptrCast(x), @ptrCast(y))); +} + +pub inline fn warpMouseGlobal(x: f32, y: f32) bool { + return c.SDL_WarpMouseGlobal(x, y); +} + +pub inline fn captureMouse(enabled: bool) bool { + return c.SDL_CaptureMouse(enabled); +} + +pub inline fn createCursor(data: [*c]const u8, mask: [*c]const u8, w: c_int, h: c_int, hot_x: c_int, hot_y: c_int) ?*Cursor { + return c.SDL_CreateCursor(data, mask, w, h, hot_x, hot_y); +} + +pub inline fn createSystemCursor(id: SystemCursor) ?*Cursor { + return c.SDL_CreateSystemCursor(id); +} + +pub inline fn getCursor() ?*Cursor { + return c.SDL_GetCursor(); +} + +pub inline fn getDefaultCursor() ?*Cursor { + return c.SDL_GetDefaultCursor(); +} + +pub inline fn showCursor() bool { + return c.SDL_ShowCursor(); +} + +pub inline fn hideCursor() bool { + return c.SDL_HideCursor(); +} + +pub inline fn cursorVisible() bool { + return c.SDL_CursorVisible(); +} diff --git a/v2/pixels.zig b/v2/pixels.zig new file mode 100644 index 0000000..5b11ed0 --- /dev/null +++ b/v2/pixels.zig @@ -0,0 +1,238 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PixelType = enum(c_int) { + pixeltypeUnknown, + pixeltypeIndex1, + pixeltypeIndex4, + pixeltypeIndex8, + pixeltypePacked8, + pixeltypePacked16, + pixeltypePacked32, + pixeltypeArrayu8, + pixeltypeArrayu16, + pixeltypeArrayu32, + pixeltypeArrayf16, + pixeltypeArrayf32, + pixeltypeIndex2, +}; + +pub const BitmapOrder = enum(c_int) { + bitmaporderNone, + bitmaporder4321, + bitmaporder1234, +}; + +pub const PackedOrder = enum(c_int) { + packedorderNone, + packedorderXrgb, + packedorderRgbx, + packedorderArgb, + packedorderRgba, + packedorderXbgr, + packedorderBgrx, + packedorderAbgr, + packedorderBgra, +}; + +pub const ArrayOrder = enum(c_int) { + arrayorderNone, + arrayorderRgb, + arrayorderRgba, + arrayorderArgb, + arrayorderBgr, + arrayorderBgra, + arrayorderAbgr, +}; + +pub const PackedLayout = enum(c_int) { + packedlayoutNone, + packedlayout332, + packedlayout4444, + packedlayout1555, + packedlayout5551, + packedlayout565, + packedlayout8888, + packedlayout2101010, + packedlayout1010102, +}; + +pub const PixelFormat = enum(c_int) { + pixelformatYv12, //Planar mode: Y + V + U (3 planes) + pixelformatIyuv, //Planar mode: Y + U + V (3 planes) + pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane) + pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane) + pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane) + pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes) + pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatExternalOes, //Android video texture format + pixelformatMjpg, //Motion JPEG +}; + +pub const ColorRange = enum(c_int) { + colorRangeLimited, //Narrow range, e.g. 16-235 for 8-bit RGB and luma, and 16-240 for 8-bit chroma + colorRangeFull, +}; + +pub const ColorPrimaries = enum(c_int) { + colorPrimariesBt709, //ITU-R BT.709-6 + colorPrimariesBt470m, //ITU-R BT.470-6 System M + colorPrimariesBt470bg, //ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625 + colorPrimariesBt601, //ITU-R BT.601-7 525, SMPTE 170M + colorPrimariesSmpte240, //SMPTE 240M, functionally the same as SDL_COLOR_PRIMARIES_BT601 + colorPrimariesGenericFilm, //Generic film (color filters using Illuminant C) + colorPrimariesBt2020, //ITU-R BT.2020-2 / ITU-R BT.2100-0 + colorPrimariesXyz, //SMPTE ST 428-1 + colorPrimariesSmpte431, //SMPTE RP 431-2 + colorPrimariesSmpte432, //SMPTE EG 432-1 / DCI P3 + colorPrimariesEbu3213, //EBU Tech. 3213-E +}; + +pub const TransferCharacteristics = enum(c_int) { + transferCharacteristicsBt709, //Rec. ITU-R BT.709-6 / ITU-R BT1361 + transferCharacteristicsGamma22, //ITU-R BT.470-6 System M / ITU-R BT1700 625 PAL & SECAM + transferCharacteristicsGamma28, //ITU-R BT.470-6 System B, G + transferCharacteristicsBt601, //SMPTE ST 170M / ITU-R BT.601-7 525 or 625 + transferCharacteristicsSmpte240, //SMPTE ST 240M + transferCharacteristicsIec61966, //IEC 61966-2-4 + transferCharacteristicsBt1361, //ITU-R BT1361 Extended Colour Gamut + transferCharacteristicsSrgb, //IEC 61966-2-1 (sRGB or sYCC) + transferCharacteristicsBt202010bit, //ITU-R BT2020 for 10-bit system + transferCharacteristicsBt202012bit, //ITU-R BT2020 for 12-bit system + transferCharacteristicsPq, //SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems + transferCharacteristicsSmpte428, //SMPTE ST 428-1 + transferCharacteristicsHlg, //ARIB STD-B67, known as "hybrid log-gamma" (HLG) +}; + +pub const MatrixCoefficients = enum(c_int) { + matrixCoefficientsBt709, //ITU-R BT.709-6 + matrixCoefficientsFcc, //US FCC Title 47 + matrixCoefficientsBt470bg, //ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625, functionally the same as SDL_MATRIX_COEFFICIENTS_BT601 + matrixCoefficientsBt601, //ITU-R BT.601-7 525 + matrixCoefficientsSmpte240, //SMPTE 240M + matrixCoefficientsBt2020Ncl, //ITU-R BT.2020-2 non-constant luminance + matrixCoefficientsBt2020Cl, //ITU-R BT.2020-2 constant luminance + matrixCoefficientsSmpte2085, //SMPTE ST 2085 + matrixCoefficientsIctcp, //ITU-R BT.2100-0 ICTCP +}; + +pub const ChromaLocation = enum(c_int) { + chromaLocationNone, //RGB, no chroma sampling + chromaLocationLeft, //In MPEG-2, MPEG-4, and AVC, Cb and Cr are taken on midpoint of the left-edge of the 2x2 square. In other words, they have the same horizontal location as the top-left pixel, but is shifted one-half pixel down vertically. + chromaLocationCenter, //In JPEG/JFIF, H.261, and MPEG-1, Cb and Cr are taken at the center of the 2x2 square. In other words, they are offset one-half pixel to the right and one-half pixel down compared to the top-left pixel. + chromaLocationTopleft, +}; + +pub const Colorspace = enum(c_int) { + colorspaceSrgb, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 + colorRangeFull, + colorPrimariesBt709, + transferCharacteristicsSrgb, + matrixCoefficientsIdentity, + colorspaceSrgbLinear, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 + transferCharacteristicsLinear, + colorspaceHdr10, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 + colorPrimariesBt2020, + transferCharacteristicsPq, + colorspaceJpeg, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 + transferCharacteristicsBt601, + matrixCoefficientsBt601, + colorspaceBt601Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 + colorRangeLimited, + colorPrimariesBt601, + colorspaceBt601Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 + colorspaceBt709Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 + transferCharacteristicsBt709, + matrixCoefficientsBt709, + colorspaceBt709Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 + colorspaceBt2020Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 + matrixCoefficientsBt2020Ncl, + colorspaceBt2020Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 + colorspaceRgbDefault, //The default colorspace for RGB surfaces if no colorspace is specified + colorspaceYuvDefault, //The default colorspace for YUV surfaces if no colorspace is specified +}; + +pub const Color = extern struct { + r: u8, + g: u8, + b: u8, + a: u8, +}; + +pub const FColor = extern struct { + r: f32, + g: f32, + b: f32, + a: f32, +}; + +pub const Palette = extern struct { + ncolors: c_int, // number of elements in `colors`. + colors: ?*Color, // an array of colors, `ncolors` long. + version: u32, // internal use only, do not touch. + refcount: c_int, // internal use only, do not touch. +}; + +pub const PixelFormatDetails = extern struct { + format: PixelFormat, + bits_per_pixel: u8, + bytes_per_pixel: u8, + padding: [2]u8, + Rmask: u32, + Gmask: u32, + Bmask: u32, + Amask: u32, + Rbits: u8, + Gbits: u8, + Bbits: u8, + Abits: u8, + Rshift: u8, + Gshift: u8, + Bshift: u8, + Ashift: u8, +}; + +pub inline fn getPixelFormatName(format: PixelFormat) [*c]const u8 { + return c.SDL_GetPixelFormatName(@bitCast(format)); +} + +pub inline fn getMasksForPixelFormat(format: PixelFormat, bpp: *c_int, Rmask: *u32, Gmask: *u32, Bmask: *u32, Amask: *u32) bool { + return c.SDL_GetMasksForPixelFormat(@bitCast(format), @ptrCast(bpp), @ptrCast(Rmask), @ptrCast(Gmask), @ptrCast(Bmask), @ptrCast(Amask)); +} + +pub inline fn getPixelFormatForMasks(bpp: c_int, Rmask: u32, Gmask: u32, Bmask: u32, Amask: u32) PixelFormat { + return @bitCast(c.SDL_GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask)); +} + +pub inline fn getPixelFormatDetails(format: PixelFormat) *const PixelFormatDetails { + return @ptrCast(c.SDL_GetPixelFormatDetails(@bitCast(format))); +} + +pub inline fn createPalette(ncolors: c_int) ?*Palette { + return c.SDL_CreatePalette(ncolors); +} + +pub inline fn setPaletteColors(palette: ?*Palette, colors: *const Color, firstcolor: c_int, ncolors: c_int) bool { + return c.SDL_SetPaletteColors(palette, @ptrCast(colors), firstcolor, ncolors); +} + +pub inline fn destroyPalette(palette: ?*Palette) void { + return c.SDL_DestroyPalette(palette); +} + +pub inline fn mapRGB(format: *const PixelFormatDetails, palette: *const Palette, r: u8, g: u8, b: u8) u32 { + return c.SDL_MapRGB(@ptrCast(format), @ptrCast(palette), r, g, b); +} + +pub inline fn mapRGBA(format: *const PixelFormatDetails, palette: *const Palette, r: u8, g: u8, b: u8, a: u8) u32 { + return c.SDL_MapRGBA(@ptrCast(format), @ptrCast(palette), r, g, b, a); +} + +pub inline fn getRGB(pixel: u32, format: *const PixelFormatDetails, palette: *const Palette, r: [*c]u8, g: [*c]u8, b: [*c]u8) void { + return c.SDL_GetRGB(pixel, @ptrCast(format), @ptrCast(palette), r, g, b); +} + +pub inline fn getRGBA(pixel: u32, format: *const PixelFormatDetails, palette: *const Palette, r: [*c]u8, g: [*c]u8, b: [*c]u8, a: [*c]u8) void { + return c.SDL_GetRGBA(pixel, @ptrCast(format), @ptrCast(palette), r, g, b, a); +} diff --git a/v2/properties.zig b/v2/properties.zig new file mode 100644 index 0000000..1104ffb --- /dev/null +++ b/v2/properties.zig @@ -0,0 +1,101 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PropertiesID = u32; + +pub const PropertyType = enum(c_int) { + propertyTypeInvalid, + propertyTypePointer, + propertyTypeString, + propertyTypeNumber, + propertyTypeFloat, + propertyTypeBoolean, +}; + +pub inline fn getGlobalProperties() PropertiesID { + return c.SDL_GetGlobalProperties(); +} + +pub inline fn createProperties() PropertiesID { + return c.SDL_CreateProperties(); +} + +pub inline fn copyProperties(src: PropertiesID, dst: PropertiesID) bool { + return c.SDL_CopyProperties(src, dst); +} + +pub inline fn lockProperties(props: PropertiesID) bool { + return c.SDL_LockProperties(props); +} + +pub inline fn unlockProperties(props: PropertiesID) void { + return c.SDL_UnlockProperties(props); +} + +pub const CleanupPropertyCallback = *const fn (userdata: ?*anyopaque, value: ?*anyopaque) callconv(.C) void; + +pub inline fn setPointerPropertyWithCleanup(props: PropertiesID, name: [*c]const u8, value: ?*anyopaque, cleanup: CleanupPropertyCallback, userdata: ?*anyopaque) bool { + return c.SDL_SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata); +} + +pub inline fn setPointerProperty(props: PropertiesID, name: [*c]const u8, value: ?*anyopaque) bool { + return c.SDL_SetPointerProperty(props, name, value); +} + +pub inline fn setStringProperty(props: PropertiesID, name: [*c]const u8, value: [*c]const u8) bool { + return c.SDL_SetStringProperty(props, name, value); +} + +pub inline fn setNumberProperty(props: PropertiesID, name: [*c]const u8, value: i64) bool { + return c.SDL_SetNumberProperty(props, name, value); +} + +pub inline fn setFloatProperty(props: PropertiesID, name: [*c]const u8, value: f32) bool { + return c.SDL_SetFloatProperty(props, name, value); +} + +pub inline fn setBooleanProperty(props: PropertiesID, name: [*c]const u8, value: bool) bool { + return c.SDL_SetBooleanProperty(props, name, value); +} + +pub inline fn hasProperty(props: PropertiesID, name: [*c]const u8) bool { + return c.SDL_HasProperty(props, name); +} + +pub inline fn getPropertyType(props: PropertiesID, name: [*c]const u8) PropertyType { + return @intFromEnum(c.SDL_GetPropertyType(props, name)); +} + +pub inline fn getPointerProperty(props: PropertiesID, name: [*c]const u8, default_value: ?*anyopaque) ?*anyopaque { + return c.SDL_GetPointerProperty(props, name, default_value); +} + +pub inline fn getStringProperty(props: PropertiesID, name: [*c]const u8, default_value: [*c]const u8) [*c]const u8 { + return c.SDL_GetStringProperty(props, name, default_value); +} + +pub inline fn getNumberProperty(props: PropertiesID, name: [*c]const u8, default_value: i64) i64 { + return c.SDL_GetNumberProperty(props, name, default_value); +} + +pub inline fn getFloatProperty(props: PropertiesID, name: [*c]const u8, default_value: f32) f32 { + return c.SDL_GetFloatProperty(props, name, default_value); +} + +pub inline fn getBooleanProperty(props: PropertiesID, name: [*c]const u8, default_value: bool) bool { + return c.SDL_GetBooleanProperty(props, name, default_value); +} + +pub inline fn clearProperty(props: PropertiesID, name: [*c]const u8) bool { + return c.SDL_ClearProperty(props, name); +} + +pub const EnumeratePropertiesCallback = *const fn (userdata: ?*anyopaque, props: PropertiesID, name: [*c]const u8) callconv(.C) void; + +pub inline fn enumerateProperties(props: PropertiesID, callback: EnumeratePropertiesCallback, userdata: ?*anyopaque) bool { + return c.SDL_EnumerateProperties(props, callback, userdata); +} + +pub inline fn destroyProperties(props: PropertiesID) void { + return c.SDL_DestroyProperties(props); +} diff --git a/v2/rect.zig b/v2/rect.zig new file mode 100644 index 0000000..ab3d595 --- /dev/null +++ b/v2/rect.zig @@ -0,0 +1,66 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Point = extern struct { + x: c_int, + y: c_int, +}; + +pub const FPoint = extern struct { + x: f32, + y: f32, +}; + +pub const Rect = extern struct { + x: c_int, + y: c_int, + w: c_int, + h: c_int, +}; + +pub const FRect = extern struct { + x: f32, + y: f32, + w: f32, + h: f32, +}; + +pub inline fn hasRectIntersection(A: *const Rect, B: *const Rect) bool { + return c.SDL_HasRectIntersection(@ptrCast(A), @ptrCast(B)); +} + +pub inline fn getRectIntersection(A: *const Rect, B: *const Rect, result: ?*Rect) bool { + return c.SDL_GetRectIntersection(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectUnion(A: *const Rect, B: *const Rect, result: ?*Rect) bool { + return c.SDL_GetRectUnion(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectEnclosingPoints(points: *const Point, count: c_int, clip: *const Rect, result: ?*Rect) bool { + return c.SDL_GetRectEnclosingPoints(@ptrCast(points), count, @ptrCast(clip), result); +} + +pub inline fn getRectAndLineIntersection(rect: *const Rect, X1: *c_int, Y1: *c_int, X2: *c_int, Y2: *c_int) bool { + return c.SDL_GetRectAndLineIntersection(@ptrCast(rect), @ptrCast(X1), @ptrCast(Y1), @ptrCast(X2), @ptrCast(Y2)); +} + +pub inline fn hasRectIntersectionFloat(A: *const FRect, B: *const FRect) bool { + return c.SDL_HasRectIntersectionFloat(@ptrCast(A), @ptrCast(B)); +} + +pub inline fn getRectIntersectionFloat(A: *const FRect, B: *const FRect, result: ?*FRect) bool { + return c.SDL_GetRectIntersectionFloat(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectUnionFloat(A: *const FRect, B: *const FRect, result: ?*FRect) bool { + return c.SDL_GetRectUnionFloat(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectEnclosingPointsFloat(points: *const FPoint, count: c_int, clip: *const FRect, result: ?*FRect) bool { + return c.SDL_GetRectEnclosingPointsFloat(@ptrCast(points), count, @ptrCast(clip), result); +} + +pub inline fn getRectAndLineIntersectionFloat(rect: *const FRect, X1: *f32, Y1: *f32, X2: *f32, Y2: *f32) bool { + return c.SDL_GetRectAndLineIntersectionFloat(@ptrCast(rect), @ptrCast(X1), @ptrCast(Y1), @ptrCast(X2), @ptrCast(Y2)); +} diff --git a/v2/render.zig b/v2/render.zig new file mode 100644 index 0000000..68258df --- /dev/null +++ b/v2/render.zig @@ -0,0 +1,517 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const FPoint = extern struct { + x: f32, + y: f32, +}; + +pub const PixelFormat = enum(c_int) { + pixelformatYv12, //Planar mode: Y + V + U (3 planes) + pixelformatIyuv, //Planar mode: Y + U + V (3 planes) + pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane) + pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane) + pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane) + pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes) + pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatExternalOes, //Android video texture format + pixelformatMjpg, //Motion JPEG +}; + +pub const FColor = extern struct { + r: f32, + g: f32, + b: f32, + a: f32, +}; + +pub const Surface = opaque { + pub inline fn createSoftwareRenderer(surface: *Surface) ?*Renderer { + return c.SDL_CreateSoftwareRenderer(surface); + } +}; + +pub const ScaleMode = enum(c_int) { + scalemodeNearest, //nearest pixel sampling + scalemodeLinear, //linear filtering +}; + +pub const PropertiesID = u32; + +pub const BlendMode = u32; + +pub const Window = opaque { + pub inline fn createRenderer(window: *Window, name: [*c]const u8) ?*Renderer { + return c.SDL_CreateRenderer(window, name); + } + + pub inline fn getRenderer(window: *Window) ?*Renderer { + return c.SDL_GetRenderer(window); + } +}; + +pub const FRect = extern struct { + x: f32, + y: f32, + w: f32, + h: f32, +}; + +pub const Event = extern union { + _type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration + common: CommonEvent, // Common event data + display: DisplayEvent, // Display event data + window: WindowEvent, // Window event data + kdevice: KeyboardDeviceEvent, // Keyboard device change event data + key: KeyboardEvent, // Keyboard event data + edit: TextEditingEvent, // Text editing event data + edit_candidates: TextEditingCandidatesEvent, // Text editing candidates event data + text: TextInputEvent, // Text input event data + mdevice: MouseDeviceEvent, // Mouse device change event data + motion: MouseMotionEvent, // Mouse motion event data + button: MouseButtonEvent, // Mouse button event data + wheel: MouseWheelEvent, // Mouse wheel event data + jdevice: JoyDeviceEvent, // Joystick device change event data + jaxis: JoyAxisEvent, // Joystick axis event data + jball: JoyBallEvent, // Joystick ball event data + jhat: JoyHatEvent, // Joystick hat event data + jbutton: JoyButtonEvent, // Joystick button event data + jbattery: JoyBatteryEvent, // Joystick battery event data + gdevice: GamepadDeviceEvent, // Gamepad device event data + gaxis: GamepadAxisEvent, // Gamepad axis event data + gbutton: GamepadButtonEvent, // Gamepad button event data + gtouchpad: GamepadTouchpadEvent, // Gamepad touchpad event data + gsensor: GamepadSensorEvent, // Gamepad sensor event data + adevice: AudioDeviceEvent, // Audio device event data + cdevice: CameraDeviceEvent, // Camera device event data + sensor: SensorEvent, // Sensor event data + quit: QuitEvent, // Quit request event data + user: UserEvent, // Custom event data + tfinger: TouchFingerEvent, // Touch finger event data + pproximity: PenProximityEvent, // Pen proximity event data + ptouch: PenTouchEvent, // Pen tip touching event data + pmotion: PenMotionEvent, // Pen motion event data + pbutton: PenButtonEvent, // Pen button event data + paxis: PenAxisEvent, // Pen axis event data + render: RenderEvent, // Render event data + drop: DropEvent, // Drag and drop event data + clipboard: ClipboardEvent, // Clipboard event data + padding: [128]u8, +}; + +pub const FlipMode = enum(c_int) { + flipNone, //Do not flip + flipHorizontal, //flip horizontally + flipVertical, //flip vertically +}; + +pub const Rect = extern struct { + x: c_int, + y: c_int, + w: c_int, + h: c_int, +}; + +pub const WindowFlags = packed struct(u64) { + windowFullscreen: bool = false, // window is in fullscreen mode + windowOpengl: bool = false, // window usable with OpenGL context + windowOccluded: bool = false, // window is occluded + windowHidden: bool = false, // window is neither mapped onto the desktop nor shown in the taskbar/dock/window list; SDL_ShowWindow() is required for it to become visible + windowBorderless: bool = false, // no window decoration + windowResizable: bool = false, // window can be resized + windowMinimized: bool = false, // window is minimized + windowMaximized: bool = false, // window is maximized + windowMouseGrabbed: bool = false, // window has grabbed mouse input + windowInputFocus: bool = false, // window has input focus + windowMouseFocus: bool = false, // window has mouse focus + windowExternal: bool = false, // window not created by SDL + windowModal: bool = false, // window is modal + windowHighPixelDensity: bool = false, // window uses high pixel density back buffer if possible + windowMouseCapture: bool = false, // window has mouse captured (unrelated to MOUSE_GRABBED) + windowMouseRelativeMode: bool = false, // window has relative mode enabled + windowAlwaysOnTop: bool = false, // window should always be above others + windowUtility: bool = false, // window should be treated as a utility window, not showing in the task bar and window list + windowTooltip: bool = false, // window should be treated as a tooltip and does not get mouse or keyboard focus, requires a parent window + windowPopupMenu: bool = false, // window should be treated as a popup menu, requires a parent window + windowKeyboardGrabbed: bool = false, // window has grabbed keyboard input + windowVulkan: bool = false, // window usable for Vulkan surface + windowMetal: bool = false, // window usable for Metal view + windowTransparent: bool = false, // window with transparent buffer + windowNotFocusable: bool = false, // window should not be focusable + pad0: u38 = 0, + rsvd: bool = false, +}; + +pub const Vertex = extern struct { + position: FPoint, // Vertex position, in SDL_Renderer coordinates + color: FColor, // Vertex color + tex_coord: FPoint, // Normalized texture coordinates, if needed +}; + +pub const TextureAccess = enum(c_int) { + textureaccessStatic, //Changes rarely, not lockable + textureaccessStreaming, //Changes frequently, lockable + textureaccessTarget, //Texture can be used as a render target +}; + +pub const RendererLogicalPresentation = enum(c_int) { + logicalPresentationDisabled, //There is no logical size in effect + logicalPresentationStretch, //The rendered content is stretched to the output resolution + logicalPresentationLetterbox, //The rendered content is fit to the largest dimension and the other dimension is letterboxed with black bars + logicalPresentationOverscan, //The rendered content is fit to the smallest dimension and the other dimension extends beyond the output bounds + logicalPresentationIntegerScale, //The rendered content is scaled up by integer multiples to fit the output resolution +}; + +pub const Renderer = opaque { + pub inline fn getRenderWindow(renderer: *Renderer) ?*Window { + return c.SDL_GetRenderWindow(renderer); + } + + pub inline fn getRendererName(renderer: *Renderer) [*c]const u8 { + return c.SDL_GetRendererName(renderer); + } + + pub inline fn getRendererProperties(renderer: *Renderer) PropertiesID { + return c.SDL_GetRendererProperties(renderer); + } + + pub inline fn getRenderOutputSize(renderer: *Renderer, w: *c_int, h: *c_int) bool { + return c.SDL_GetRenderOutputSize(renderer, @ptrCast(w), @ptrCast(h)); + } + + pub inline fn getCurrentRenderOutputSize(renderer: *Renderer, w: *c_int, h: *c_int) bool { + return c.SDL_GetCurrentRenderOutputSize(renderer, @ptrCast(w), @ptrCast(h)); + } + + pub inline fn createTexture(renderer: *Renderer, format: PixelFormat, access: TextureAccess, w: c_int, h: c_int) ?*Texture { + return c.SDL_CreateTexture(renderer, @bitCast(format), access, w, h); + } + + pub inline fn createTextureFromSurface(renderer: *Renderer, surface: ?*Surface) ?*Texture { + return c.SDL_CreateTextureFromSurface(renderer, surface); + } + + pub inline fn createTextureWithProperties(renderer: *Renderer, props: PropertiesID) ?*Texture { + return c.SDL_CreateTextureWithProperties(renderer, props); + } + + pub inline fn setRenderTarget(renderer: *Renderer, texture: ?*Texture) bool { + return c.SDL_SetRenderTarget(renderer, texture); + } + + pub inline fn getRenderTarget(renderer: *Renderer) ?*Texture { + return c.SDL_GetRenderTarget(renderer); + } + + pub inline fn setRenderLogicalPresentation(renderer: *Renderer, w: c_int, h: c_int, mode: RendererLogicalPresentation) bool { + return c.SDL_SetRenderLogicalPresentation(renderer, w, h, mode); + } + + pub inline fn getRenderLogicalPresentation(renderer: *Renderer, w: *c_int, h: *c_int, mode: ?*RendererLogicalPresentation) bool { + return c.SDL_GetRenderLogicalPresentation(renderer, @ptrCast(w), @ptrCast(h), mode); + } + + pub inline fn getRenderLogicalPresentationRect(renderer: *Renderer, rect: ?*FRect) bool { + return c.SDL_GetRenderLogicalPresentationRect(renderer, rect); + } + + pub inline fn renderCoordinatesFromWindow(renderer: *Renderer, window_x: f32, window_y: f32, x: *f32, y: *f32) bool { + return c.SDL_RenderCoordinatesFromWindow(renderer, window_x, window_y, @ptrCast(x), @ptrCast(y)); + } + + pub inline fn renderCoordinatesToWindow(renderer: *Renderer, x: f32, y: f32, window_x: *f32, window_y: *f32) bool { + return c.SDL_RenderCoordinatesToWindow(renderer, x, y, @ptrCast(window_x), @ptrCast(window_y)); + } + + pub inline fn convertEventToRenderCoordinates(renderer: *Renderer, event: ?*Event) bool { + return c.SDL_ConvertEventToRenderCoordinates(renderer, event); + } + + pub inline fn setRenderViewport(renderer: *Renderer, rect: *const Rect) bool { + return c.SDL_SetRenderViewport(renderer, @ptrCast(rect)); + } + + pub inline fn getRenderViewport(renderer: *Renderer, rect: ?*Rect) bool { + return c.SDL_GetRenderViewport(renderer, rect); + } + + pub inline fn renderViewportSet(renderer: *Renderer) bool { + return c.SDL_RenderViewportSet(renderer); + } + + pub inline fn getRenderSafeArea(renderer: *Renderer, rect: ?*Rect) bool { + return c.SDL_GetRenderSafeArea(renderer, rect); + } + + pub inline fn setRenderClipRect(renderer: *Renderer, rect: *const Rect) bool { + return c.SDL_SetRenderClipRect(renderer, @ptrCast(rect)); + } + + pub inline fn getRenderClipRect(renderer: *Renderer, rect: ?*Rect) bool { + return c.SDL_GetRenderClipRect(renderer, rect); + } + + pub inline fn renderClipEnabled(renderer: *Renderer) bool { + return c.SDL_RenderClipEnabled(renderer); + } + + pub inline fn setRenderScale(renderer: *Renderer, scaleX: f32, scaleY: f32) bool { + return c.SDL_SetRenderScale(renderer, scaleX, scaleY); + } + + pub inline fn getRenderScale(renderer: *Renderer, scaleX: *f32, scaleY: *f32) bool { + return c.SDL_GetRenderScale(renderer, @ptrCast(scaleX), @ptrCast(scaleY)); + } + + pub inline fn setRenderDrawColor(renderer: *Renderer, r: u8, g: u8, b: u8, a: u8) bool { + return c.SDL_SetRenderDrawColor(renderer, r, g, b, a); + } + + pub inline fn setRenderDrawColorFloat(renderer: *Renderer, r: f32, g: f32, b: f32, a: f32) bool { + return c.SDL_SetRenderDrawColorFloat(renderer, r, g, b, a); + } + + pub inline fn getRenderDrawColor(renderer: *Renderer, r: [*c]u8, g: [*c]u8, b: [*c]u8, a: [*c]u8) bool { + return c.SDL_GetRenderDrawColor(renderer, r, g, b, a); + } + + pub inline fn getRenderDrawColorFloat(renderer: *Renderer, r: *f32, g: *f32, b: *f32, a: *f32) bool { + return c.SDL_GetRenderDrawColorFloat(renderer, @ptrCast(r), @ptrCast(g), @ptrCast(b), @ptrCast(a)); + } + + pub inline fn setRenderColorScale(renderer: *Renderer, scale: f32) bool { + return c.SDL_SetRenderColorScale(renderer, scale); + } + + pub inline fn getRenderColorScale(renderer: *Renderer, scale: *f32) bool { + return c.SDL_GetRenderColorScale(renderer, @ptrCast(scale)); + } + + pub inline fn setRenderDrawBlendMode(renderer: *Renderer, blendMode: BlendMode) bool { + return c.SDL_SetRenderDrawBlendMode(renderer, @intFromEnum(blendMode)); + } + + pub inline fn getRenderDrawBlendMode(renderer: *Renderer, blendMode: ?*BlendMode) bool { + return c.SDL_GetRenderDrawBlendMode(renderer, @intFromEnum(blendMode)); + } + + pub inline fn renderClear(renderer: *Renderer) bool { + return c.SDL_RenderClear(renderer); + } + + pub inline fn renderPoint(renderer: *Renderer, x: f32, y: f32) bool { + return c.SDL_RenderPoint(renderer, x, y); + } + + pub inline fn renderPoints(renderer: *Renderer, points: *const FPoint, count: c_int) bool { + return c.SDL_RenderPoints(renderer, @ptrCast(points), count); + } + + pub inline fn renderLine(renderer: *Renderer, x1: f32, y1: f32, x2: f32, y2: f32) bool { + return c.SDL_RenderLine(renderer, x1, y1, x2, y2); + } + + pub inline fn renderLines(renderer: *Renderer, points: *const FPoint, count: c_int) bool { + return c.SDL_RenderLines(renderer, @ptrCast(points), count); + } + + pub inline fn renderRect(renderer: *Renderer, rect: *const FRect) bool { + return c.SDL_RenderRect(renderer, @ptrCast(rect)); + } + + pub inline fn renderRects(renderer: *Renderer, rects: *const FRect, count: c_int) bool { + return c.SDL_RenderRects(renderer, @ptrCast(rects), count); + } + + pub inline fn renderFillRect(renderer: *Renderer, rect: *const FRect) bool { + return c.SDL_RenderFillRect(renderer, @ptrCast(rect)); + } + + pub inline fn renderFillRects(renderer: *Renderer, rects: *const FRect, count: c_int) bool { + return c.SDL_RenderFillRects(renderer, @ptrCast(rects), count); + } + + pub inline fn renderTexture(renderer: *Renderer, texture: ?*Texture, srcrect: *const FRect, dstrect: *const FRect) bool { + return c.SDL_RenderTexture(renderer, texture, @ptrCast(srcrect), @ptrCast(dstrect)); + } + + pub inline fn renderTextureRotated(renderer: *Renderer, texture: ?*Texture, srcrect: *const FRect, dstrect: *const FRect, angle: f64, center: *const FPoint, flip: FlipMode) bool { + return c.SDL_RenderTextureRotated(renderer, texture, @ptrCast(srcrect), @ptrCast(dstrect), angle, @ptrCast(center), @intFromEnum(flip)); + } + + pub inline fn renderTextureAffine(renderer: *Renderer, texture: ?*Texture, srcrect: *const FRect, origin: *const FPoint, right: *const FPoint, down: *const FPoint) bool { + return c.SDL_RenderTextureAffine(renderer, texture, @ptrCast(srcrect), @ptrCast(origin), @ptrCast(right), @ptrCast(down)); + } + + pub inline fn renderTextureTiled(renderer: *Renderer, texture: ?*Texture, srcrect: *const FRect, scale: f32, dstrect: *const FRect) bool { + return c.SDL_RenderTextureTiled(renderer, texture, @ptrCast(srcrect), scale, @ptrCast(dstrect)); + } + + pub inline fn renderTexture9Grid(renderer: *Renderer, texture: ?*Texture, srcrect: *const FRect, left_width: f32, right_width: f32, top_height: f32, bottom_height: f32, scale: f32, dstrect: *const FRect) bool { + return c.SDL_RenderTexture9Grid(renderer, texture, @ptrCast(srcrect), left_width, right_width, top_height, bottom_height, scale, @ptrCast(dstrect)); + } + + pub inline fn renderGeometry(renderer: *Renderer, texture: ?*Texture, vertices: *const Vertex, num_vertices: c_int, indices: [*c]const c_int, num_indices: c_int) bool { + return c.SDL_RenderGeometry(renderer, texture, @ptrCast(vertices), num_vertices, indices, num_indices); + } + + pub inline fn renderGeometryRaw(renderer: *Renderer, texture: ?*Texture, xy: *const f32, xy_stride: c_int, color: *const FColor, color_stride: c_int, uv: *const f32, uv_stride: c_int, num_vertices: c_int, indices: ?*const anyopaque, num_indices: c_int, size_indices: c_int) bool { + return c.SDL_RenderGeometryRaw(renderer, texture, @ptrCast(xy), xy_stride, @ptrCast(color), color_stride, @ptrCast(uv), uv_stride, num_vertices, indices, num_indices, size_indices); + } + + pub inline fn renderReadPixels(renderer: *Renderer, rect: *const Rect) ?*Surface { + return c.SDL_RenderReadPixels(renderer, @ptrCast(rect)); + } + + pub inline fn renderPresent(renderer: *Renderer) bool { + return c.SDL_RenderPresent(renderer); + } + + pub inline fn destroyRenderer(renderer: *Renderer) void { + return c.SDL_DestroyRenderer(renderer); + } + + pub inline fn flushRenderer(renderer: *Renderer) bool { + return c.SDL_FlushRenderer(renderer); + } + + pub inline fn getRenderMetalLayer(renderer: *Renderer) ?*anyopaque { + return c.SDL_GetRenderMetalLayer(renderer); + } + + pub inline fn getRenderMetalCommandEncoder(renderer: *Renderer) ?*anyopaque { + return c.SDL_GetRenderMetalCommandEncoder(renderer); + } + + pub inline fn addVulkanRenderSemaphores(renderer: *Renderer, wait_stage_mask: u32, wait_semaphore: i64, signal_semaphore: i64) bool { + return c.SDL_AddVulkanRenderSemaphores(renderer, wait_stage_mask, wait_semaphore, signal_semaphore); + } + + pub inline fn setRenderVSync(renderer: *Renderer, vsync: c_int) bool { + return c.SDL_SetRenderVSync(renderer, vsync); + } + + pub inline fn getRenderVSync(renderer: *Renderer, vsync: *c_int) bool { + return c.SDL_GetRenderVSync(renderer, @ptrCast(vsync)); + } + + pub inline fn renderDebugText(renderer: *Renderer, x: f32, y: f32, str: [*c]const u8) bool { + return c.SDL_RenderDebugText(renderer, x, y, str); + } + + pub inline fn renderDebugTextFormat(renderer: *Renderer, x: f32, y: f32, fmt: [*c]const u8, ...) bool { + return c.SDL_RenderDebugTextFormat( + renderer, + x, + y, + fmt, + ); + } +}; + +pub const Texture = opaque { + pub inline fn getTextureProperties(texture: *Texture) PropertiesID { + return c.SDL_GetTextureProperties(texture); + } + + pub inline fn getRendererFromTexture(texture: *Texture) ?*Renderer { + return c.SDL_GetRendererFromTexture(texture); + } + + pub inline fn getTextureSize(texture: *Texture, w: *f32, h: *f32) bool { + return c.SDL_GetTextureSize(texture, @ptrCast(w), @ptrCast(h)); + } + + pub inline fn setTextureColorMod(texture: *Texture, r: u8, g: u8, b: u8) bool { + return c.SDL_SetTextureColorMod(texture, r, g, b); + } + + pub inline fn setTextureColorModFloat(texture: *Texture, r: f32, g: f32, b: f32) bool { + return c.SDL_SetTextureColorModFloat(texture, r, g, b); + } + + pub inline fn getTextureColorMod(texture: *Texture, r: [*c]u8, g: [*c]u8, b: [*c]u8) bool { + return c.SDL_GetTextureColorMod(texture, r, g, b); + } + + pub inline fn getTextureColorModFloat(texture: *Texture, r: *f32, g: *f32, b: *f32) bool { + return c.SDL_GetTextureColorModFloat(texture, @ptrCast(r), @ptrCast(g), @ptrCast(b)); + } + + pub inline fn setTextureAlphaMod(texture: *Texture, alpha: u8) bool { + return c.SDL_SetTextureAlphaMod(texture, alpha); + } + + pub inline fn setTextureAlphaModFloat(texture: *Texture, alpha: f32) bool { + return c.SDL_SetTextureAlphaModFloat(texture, alpha); + } + + pub inline fn getTextureAlphaMod(texture: *Texture, alpha: [*c]u8) bool { + return c.SDL_GetTextureAlphaMod(texture, alpha); + } + + pub inline fn getTextureAlphaModFloat(texture: *Texture, alpha: *f32) bool { + return c.SDL_GetTextureAlphaModFloat(texture, @ptrCast(alpha)); + } + + pub inline fn setTextureBlendMode(texture: *Texture, blendMode: BlendMode) bool { + return c.SDL_SetTextureBlendMode(texture, @intFromEnum(blendMode)); + } + + pub inline fn getTextureBlendMode(texture: *Texture, blendMode: ?*BlendMode) bool { + return c.SDL_GetTextureBlendMode(texture, @intFromEnum(blendMode)); + } + + pub inline fn setTextureScaleMode(texture: *Texture, scaleMode: ScaleMode) bool { + return c.SDL_SetTextureScaleMode(texture, @intFromEnum(scaleMode)); + } + + pub inline fn getTextureScaleMode(texture: *Texture, scaleMode: ?*ScaleMode) bool { + return c.SDL_GetTextureScaleMode(texture, @intFromEnum(scaleMode)); + } + + pub inline fn updateTexture(texture: *Texture, rect: *const Rect, pixels: ?*const anyopaque, pitch: c_int) bool { + return c.SDL_UpdateTexture(texture, @ptrCast(rect), pixels, pitch); + } + + pub inline fn updateYUVTexture(texture: *Texture, rect: *const Rect, Yplane: [*c]const u8, Ypitch: c_int, Uplane: [*c]const u8, Upitch: c_int, Vplane: [*c]const u8, Vpitch: c_int) bool { + return c.SDL_UpdateYUVTexture(texture, @ptrCast(rect), Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch); + } + + pub inline fn updateNVTexture(texture: *Texture, rect: *const Rect, Yplane: [*c]const u8, Ypitch: c_int, UVplane: [*c]const u8, UVpitch: c_int) bool { + return c.SDL_UpdateNVTexture(texture, @ptrCast(rect), Yplane, Ypitch, UVplane, UVpitch); + } + + pub inline fn lockTexture(texture: *Texture, rect: *const Rect, pixels: [*c]?*anyopaque, pitch: *c_int) bool { + return c.SDL_LockTexture(texture, @ptrCast(rect), pixels, @ptrCast(pitch)); + } + + pub inline fn lockTextureToSurface(texture: *Texture, rect: *const Rect, surface: [*c][*c]Surface) bool { + return c.SDL_LockTextureToSurface(texture, @ptrCast(rect), surface); + } + + pub inline fn unlockTexture(texture: *Texture) void { + return c.SDL_UnlockTexture(texture); + } + + pub inline fn destroyTexture(texture: *Texture) void { + return c.SDL_DestroyTexture(texture); + } +}; + +pub inline fn getNumRenderDrivers() c_int { + return c.SDL_GetNumRenderDrivers(); +} + +pub inline fn getRenderDriver(index: c_int) [*c]const u8 { + return c.SDL_GetRenderDriver(index); +} + +pub inline fn createWindowAndRenderer(title: [*c]const u8, width: c_int, height: c_int, window_flags: WindowFlags, window: [*c][*c]Window, renderer: [*c][*c]Renderer) bool { + return c.SDL_CreateWindowAndRenderer(title, width, height, @bitCast(window_flags), window, renderer); +} + +pub inline fn createRendererWithProperties(props: PropertiesID) ?*Renderer { + return c.SDL_CreateRendererWithProperties(props); +} diff --git a/v2/sensor.zig b/v2/sensor.zig new file mode 100644 index 0000000..e32152e --- /dev/null +++ b/v2/sensor.zig @@ -0,0 +1,75 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PropertiesID = u32; + +pub const Sensor = opaque { + pub inline fn getSensorProperties(sensor: *Sensor) PropertiesID { + return c.SDL_GetSensorProperties(sensor); + } + + pub inline fn getSensorName(sensor: *Sensor) [*c]const u8 { + return c.SDL_GetSensorName(sensor); + } + + pub inline fn getSensorType(sensor: *Sensor) SensorType { + return @intFromEnum(c.SDL_GetSensorType(sensor)); + } + + pub inline fn getSensorNonPortableType(sensor: *Sensor) c_int { + return c.SDL_GetSensorNonPortableType(sensor); + } + + pub inline fn getSensorID(sensor: *Sensor) SensorID { + return c.SDL_GetSensorID(sensor); + } + + pub inline fn getSensorData(sensor: *Sensor, data: *f32, num_values: c_int) bool { + return c.SDL_GetSensorData(sensor, @ptrCast(data), num_values); + } + + pub inline fn closeSensor(sensor: *Sensor) void { + return c.SDL_CloseSensor(sensor); + } +}; + +pub const SensorID = u32; + +pub const SensorType = enum(c_int) { + sensorInvalid, //Returned for an invalid sensor + sensorUnknown, //Unknown sensor type + sensorAccel, //Accelerometer + sensorGyro, //Gyroscope + sensorAccelL, //Accelerometer for left Joy-Con controller and Wii nunchuk + sensorGyroL, //Gyroscope for left Joy-Con controller + sensorAccelR, //Accelerometer for right Joy-Con controller + sensorGyroR, //Gyroscope for right Joy-Con controller +}; + +pub inline fn getSensors(count: *c_int) ?*SensorID { + return c.SDL_GetSensors(@ptrCast(count)); +} + +pub inline fn getSensorNameForID(instance_id: SensorID) [*c]const u8 { + return c.SDL_GetSensorNameForID(instance_id); +} + +pub inline fn getSensorTypeForID(instance_id: SensorID) SensorType { + return @intFromEnum(c.SDL_GetSensorTypeForID(instance_id)); +} + +pub inline fn getSensorNonPortableTypeForID(instance_id: SensorID) c_int { + return c.SDL_GetSensorNonPortableTypeForID(instance_id); +} + +pub inline fn openSensor(instance_id: SensorID) ?*Sensor { + return c.SDL_OpenSensor(instance_id); +} + +pub inline fn getSensorFromID(instance_id: SensorID) ?*Sensor { + return c.SDL_GetSensorFromID(instance_id); +} + +pub inline fn updateSensors() void { + return c.SDL_UpdateSensors(); +} diff --git a/v2/storage.zig b/v2/storage.zig new file mode 100644 index 0000000..77fc474 --- /dev/null +++ b/v2/storage.zig @@ -0,0 +1,103 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PathInfo = extern struct { + _type: PathType, // the path type + size: u64, // the file size in bytes + create_time: Time, // the time when the path was created + modify_time: Time, // the last time the path was modified + access_time: Time, // the last time the path was read +}; + +pub const GlobFlags = packed struct(u32) { + globCaseinsensitive: bool = false, + pad0: u30 = 0, + rsvd: bool = false, +}; + +pub const PropertiesID = u32; + +pub const StorageInterface = extern struct { + version: u32, + close: ?*const anyopaque, + ready: ?*const anyopaque, + enumerate: ?*const anyopaque, + info: ?*const anyopaque, + read_file: ?*const anyopaque, + write_file: ?*const anyopaque, + mkdir: ?*const anyopaque, + remove: ?*const anyopaque, + rename: ?*const anyopaque, + copy: ?*const anyopaque, + space_remaining: ?*const anyopaque, +}; + +pub const Storage = opaque { + pub inline fn closeStorage(storage: *Storage) bool { + return c.SDL_CloseStorage(storage); + } + + pub inline fn storageReady(storage: *Storage) bool { + return c.SDL_StorageReady(storage); + } + + pub inline fn getStorageFileSize(storage: *Storage, path: [*c]const u8, length: *u64) bool { + return c.SDL_GetStorageFileSize(storage, path, @ptrCast(length)); + } + + pub inline fn readStorageFile(storage: *Storage, path: [*c]const u8, destination: ?*anyopaque, length: u64) bool { + return c.SDL_ReadStorageFile(storage, path, destination, length); + } + + pub inline fn writeStorageFile(storage: *Storage, path: [*c]const u8, source: ?*const anyopaque, length: u64) bool { + return c.SDL_WriteStorageFile(storage, path, source, length); + } + + pub inline fn createStorageDirectory(storage: *Storage, path: [*c]const u8) bool { + return c.SDL_CreateStorageDirectory(storage, path); + } + + pub inline fn enumerateStorageDirectory(storage: *Storage, path: [*c]const u8, callback: EnumerateDirectoryCallback, userdata: ?*anyopaque) bool { + return c.SDL_EnumerateStorageDirectory(storage, path, callback, userdata); + } + + pub inline fn removeStoragePath(storage: *Storage, path: [*c]const u8) bool { + return c.SDL_RemoveStoragePath(storage, path); + } + + pub inline fn renameStoragePath(storage: *Storage, oldpath: [*c]const u8, newpath: [*c]const u8) bool { + return c.SDL_RenameStoragePath(storage, oldpath, newpath); + } + + pub inline fn copyStorageFile(storage: *Storage, oldpath: [*c]const u8, newpath: [*c]const u8) bool { + return c.SDL_CopyStorageFile(storage, oldpath, newpath); + } + + pub inline fn getStoragePathInfo(storage: *Storage, path: [*c]const u8, info: ?*PathInfo) bool { + return c.SDL_GetStoragePathInfo(storage, path, info); + } + + pub inline fn getStorageSpaceRemaining(storage: *Storage) u64 { + return c.SDL_GetStorageSpaceRemaining(storage); + } + + pub inline fn globStorageDirectory(storage: *Storage, path: [*c]const u8, pattern: [*c]const u8, flags: GlobFlags, count: *c_int) [*c][*c]u8 { + return c.SDL_GlobStorageDirectory(storage, path, pattern, @bitCast(flags), @ptrCast(count)); + } +}; + +pub inline fn openTitleStorage(override: [*c]const u8, props: PropertiesID) ?*Storage { + return c.SDL_OpenTitleStorage(override, props); +} + +pub inline fn openUserStorage(org: [*c]const u8, app: [*c]const u8, props: PropertiesID) ?*Storage { + return c.SDL_OpenUserStorage(org, app, props); +} + +pub inline fn openFileStorage(path: [*c]const u8) ?*Storage { + return c.SDL_OpenFileStorage(path); +} + +pub inline fn openStorage(iface: *const StorageInterface, userdata: ?*anyopaque) ?*Storage { + return c.SDL_OpenStorage(@ptrCast(iface), userdata); +} diff --git a/v2/surface.zig b/v2/surface.zig new file mode 100644 index 0000000..cb69071 --- /dev/null +++ b/v2/surface.zig @@ -0,0 +1,318 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PixelFormat = enum(c_int) { + pixelformatYv12, //Planar mode: Y + V + U (3 planes) + pixelformatIyuv, //Planar mode: Y + U + V (3 planes) + pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane) + pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane) + pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane) + pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes) + pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatExternalOes, //Android video texture format + pixelformatMjpg, //Motion JPEG +}; + +pub const BlendMode = u32; + +pub const IOStream = opaque { + pub inline fn loadBMP_IO(iostream: *IOStream, closeio: bool) ?*Surface { + return c.SDL_LoadBMP_IO(iostream, closeio); + } +}; + +pub const Rect = extern struct { + x: c_int, + y: c_int, + w: c_int, + h: c_int, +}; + +pub const Palette = extern struct { + ncolors: c_int, // number of elements in `colors`. + colors: ?*Color, // an array of colors, `ncolors` long. + version: u32, // internal use only, do not touch. + refcount: c_int, // internal use only, do not touch. +}; + +pub const Colorspace = enum(c_int) { + colorspaceSrgb, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 + colorRangeFull, + colorPrimariesBt709, + transferCharacteristicsSrgb, + matrixCoefficientsIdentity, + colorspaceSrgbLinear, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 + transferCharacteristicsLinear, + colorspaceHdr10, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 + colorPrimariesBt2020, + transferCharacteristicsPq, + colorspaceJpeg, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 + transferCharacteristicsBt601, + matrixCoefficientsBt601, + colorspaceBt601Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 + colorRangeLimited, + colorPrimariesBt601, + colorspaceBt601Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 + colorspaceBt709Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 + transferCharacteristicsBt709, + matrixCoefficientsBt709, + colorspaceBt709Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 + colorspaceBt2020Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 + matrixCoefficientsBt2020Ncl, + colorspaceBt2020Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 + colorspaceRgbDefault, //The default colorspace for RGB surfaces if no colorspace is specified + colorspaceYuvDefault, //The default colorspace for YUV surfaces if no colorspace is specified +}; + +pub const PropertiesID = u32; + +pub const SurfaceFlags = packed struct(u32) { + surfacePreallocated: bool = false, // Surface uses preallocated pixel memory + surfaceLockNeeded: bool = false, // Surface needs to be locked to access pixels + surfaceLocked: bool = false, // Surface is currently locked + surfaceSimdAligned: bool = false, // Surface uses pixel memory allocated with SDL_aligned_alloc() + pad0: u27 = 0, + rsvd: bool = false, +}; + +pub const ScaleMode = enum(c_int) { + scalemodeNearest, //nearest pixel sampling + scalemodeLinear, //linear filtering +}; + +pub const FlipMode = enum(c_int) { + flipNone, //Do not flip + flipHorizontal, //flip horizontally + flipVertical, //flip vertically +}; + +pub const Surface = opaque { + pub inline fn destroySurface(surface: *Surface) void { + return c.SDL_DestroySurface(surface); + } + + pub inline fn getSurfaceProperties(surface: *Surface) PropertiesID { + return c.SDL_GetSurfaceProperties(surface); + } + + pub inline fn setSurfaceColorspace(surface: *Surface, colorspace: Colorspace) bool { + return c.SDL_SetSurfaceColorspace(surface, colorspace); + } + + pub inline fn getSurfaceColorspace(surface: *Surface) Colorspace { + return c.SDL_GetSurfaceColorspace(surface); + } + + pub inline fn createSurfacePalette(surface: *Surface) ?*Palette { + return c.SDL_CreateSurfacePalette(surface); + } + + pub inline fn setSurfacePalette(surface: *Surface, palette: ?*Palette) bool { + return c.SDL_SetSurfacePalette(surface, palette); + } + + pub inline fn getSurfacePalette(surface: *Surface) ?*Palette { + return c.SDL_GetSurfacePalette(surface); + } + + pub inline fn addSurfaceAlternateImage(surface: *Surface, image: ?*Surface) bool { + return c.SDL_AddSurfaceAlternateImage(surface, image); + } + + pub inline fn surfaceHasAlternateImages(surface: *Surface) bool { + return c.SDL_SurfaceHasAlternateImages(surface); + } + + pub inline fn getSurfaceImages(surface: *Surface, count: *c_int) [*c][*c]Surface { + return c.SDL_GetSurfaceImages(surface, @ptrCast(count)); + } + + pub inline fn removeSurfaceAlternateImages(surface: *Surface) void { + return c.SDL_RemoveSurfaceAlternateImages(surface); + } + + pub inline fn lockSurface(surface: *Surface) bool { + return c.SDL_LockSurface(surface); + } + + pub inline fn unlockSurface(surface: *Surface) void { + return c.SDL_UnlockSurface(surface); + } + + pub inline fn saveBMP_IO(surface: *Surface, dst: ?*IOStream, closeio: bool) bool { + return c.SDL_SaveBMP_IO(surface, dst, closeio); + } + + pub inline fn saveBMP(surface: *Surface, file: [*c]const u8) bool { + return c.SDL_SaveBMP(surface, file); + } + + pub inline fn setSurfaceRLE(surface: *Surface, enabled: bool) bool { + return c.SDL_SetSurfaceRLE(surface, enabled); + } + + pub inline fn surfaceHasRLE(surface: *Surface) bool { + return c.SDL_SurfaceHasRLE(surface); + } + + pub inline fn setSurfaceColorKey(surface: *Surface, enabled: bool, key: u32) bool { + return c.SDL_SetSurfaceColorKey(surface, enabled, key); + } + + pub inline fn surfaceHasColorKey(surface: *Surface) bool { + return c.SDL_SurfaceHasColorKey(surface); + } + + pub inline fn getSurfaceColorKey(surface: *Surface, key: *u32) bool { + return c.SDL_GetSurfaceColorKey(surface, @ptrCast(key)); + } + + pub inline fn setSurfaceColorMod(surface: *Surface, r: u8, g: u8, b: u8) bool { + return c.SDL_SetSurfaceColorMod(surface, r, g, b); + } + + pub inline fn getSurfaceColorMod(surface: *Surface, r: [*c]u8, g: [*c]u8, b: [*c]u8) bool { + return c.SDL_GetSurfaceColorMod(surface, r, g, b); + } + + pub inline fn setSurfaceAlphaMod(surface: *Surface, alpha: u8) bool { + return c.SDL_SetSurfaceAlphaMod(surface, alpha); + } + + pub inline fn getSurfaceAlphaMod(surface: *Surface, alpha: [*c]u8) bool { + return c.SDL_GetSurfaceAlphaMod(surface, alpha); + } + + pub inline fn setSurfaceBlendMode(surface: *Surface, blendMode: BlendMode) bool { + return c.SDL_SetSurfaceBlendMode(surface, @intFromEnum(blendMode)); + } + + pub inline fn getSurfaceBlendMode(surface: *Surface, blendMode: ?*BlendMode) bool { + return c.SDL_GetSurfaceBlendMode(surface, @intFromEnum(blendMode)); + } + + pub inline fn setSurfaceClipRect(surface: *Surface, rect: *const Rect) bool { + return c.SDL_SetSurfaceClipRect(surface, @ptrCast(rect)); + } + + pub inline fn getSurfaceClipRect(surface: *Surface, rect: ?*Rect) bool { + return c.SDL_GetSurfaceClipRect(surface, rect); + } + + pub inline fn flipSurface(surface: *Surface, flip: FlipMode) bool { + return c.SDL_FlipSurface(surface, @intFromEnum(flip)); + } + + pub inline fn duplicateSurface(surface: *Surface) ?*Surface { + return c.SDL_DuplicateSurface(surface); + } + + pub inline fn scaleSurface(surface: *Surface, width: c_int, height: c_int, scaleMode: ScaleMode) ?*Surface { + return c.SDL_ScaleSurface(surface, width, height, @intFromEnum(scaleMode)); + } + + pub inline fn convertSurface(surface: *Surface, format: PixelFormat) ?*Surface { + return c.SDL_ConvertSurface(surface, @bitCast(format)); + } + + pub inline fn convertSurfaceAndColorspace(surface: *Surface, format: PixelFormat, palette: ?*Palette, colorspace: Colorspace, props: PropertiesID) ?*Surface { + return c.SDL_ConvertSurfaceAndColorspace(surface, @bitCast(format), palette, colorspace, props); + } + + pub inline fn premultiplySurfaceAlpha(surface: *Surface, linear: bool) bool { + return c.SDL_PremultiplySurfaceAlpha(surface, linear); + } + + pub inline fn clearSurface(surface: *Surface, r: f32, g: f32, b: f32, a: f32) bool { + return c.SDL_ClearSurface(surface, r, g, b, a); + } + + pub inline fn fillSurfaceRect(surface: *Surface, rect: *const Rect, color: u32) bool { + return c.SDL_FillSurfaceRect(surface, @ptrCast(rect), color); + } + + pub inline fn fillSurfaceRects(surface: *Surface, rects: *const Rect, count: c_int, color: u32) bool { + return c.SDL_FillSurfaceRects(surface, @ptrCast(rects), count, color); + } + + pub inline fn blitSurface(surface: *Surface, srcrect: *const Rect, dst: ?*Surface, dstrect: *const Rect) bool { + return c.SDL_BlitSurface(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurfaceUnchecked(surface: *Surface, srcrect: *const Rect, dst: ?*Surface, dstrect: *const Rect) bool { + return c.SDL_BlitSurfaceUnchecked(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurfaceScaled(surface: *Surface, srcrect: *const Rect, dst: ?*Surface, dstrect: *const Rect, scaleMode: ScaleMode) bool { + return c.SDL_BlitSurfaceScaled(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect), @intFromEnum(scaleMode)); + } + + pub inline fn blitSurfaceUncheckedScaled(surface: *Surface, srcrect: *const Rect, dst: ?*Surface, dstrect: *const Rect, scaleMode: ScaleMode) bool { + return c.SDL_BlitSurfaceUncheckedScaled(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect), @intFromEnum(scaleMode)); + } + + pub inline fn stretchSurface(surface: *Surface, srcrect: *const Rect, dst: ?*Surface, dstrect: *const Rect, scaleMode: ScaleMode) bool { + return c.SDL_StretchSurface(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect), @intFromEnum(scaleMode)); + } + + pub inline fn blitSurfaceTiled(surface: *Surface, srcrect: *const Rect, dst: ?*Surface, dstrect: *const Rect) bool { + return c.SDL_BlitSurfaceTiled(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurfaceTiledWithScale(surface: *Surface, srcrect: *const Rect, scale: f32, scaleMode: ScaleMode, dst: ?*Surface, dstrect: *const Rect) bool { + return c.SDL_BlitSurfaceTiledWithScale(surface, @ptrCast(srcrect), scale, @intFromEnum(scaleMode), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurface9Grid(surface: *Surface, srcrect: *const Rect, left_width: c_int, right_width: c_int, top_height: c_int, bottom_height: c_int, scale: f32, scaleMode: ScaleMode, dst: ?*Surface, dstrect: *const Rect) bool { + return c.SDL_BlitSurface9Grid(surface, @ptrCast(srcrect), left_width, right_width, top_height, bottom_height, scale, @intFromEnum(scaleMode), dst, @ptrCast(dstrect)); + } + + pub inline fn mapSurfaceRGB(surface: *Surface, r: u8, g: u8, b: u8) u32 { + return c.SDL_MapSurfaceRGB(surface, r, g, b); + } + + pub inline fn mapSurfaceRGBA(surface: *Surface, r: u8, g: u8, b: u8, a: u8) u32 { + return c.SDL_MapSurfaceRGBA(surface, r, g, b, a); + } + + pub inline fn readSurfacePixel(surface: *Surface, x: c_int, y: c_int, r: [*c]u8, g: [*c]u8, b: [*c]u8, a: [*c]u8) bool { + return c.SDL_ReadSurfacePixel(surface, x, y, r, g, b, a); + } + + pub inline fn readSurfacePixelFloat(surface: *Surface, x: c_int, y: c_int, r: *f32, g: *f32, b: *f32, a: *f32) bool { + return c.SDL_ReadSurfacePixelFloat(surface, x, y, @ptrCast(r), @ptrCast(g), @ptrCast(b), @ptrCast(a)); + } + + pub inline fn writeSurfacePixel(surface: *Surface, x: c_int, y: c_int, r: u8, g: u8, b: u8, a: u8) bool { + return c.SDL_WriteSurfacePixel(surface, x, y, r, g, b, a); + } + + pub inline fn writeSurfacePixelFloat(surface: *Surface, x: c_int, y: c_int, r: f32, g: f32, b: f32, a: f32) bool { + return c.SDL_WriteSurfacePixelFloat(surface, x, y, r, g, b, a); + } +}; + +pub inline fn createSurface(width: c_int, height: c_int, format: PixelFormat) ?*Surface { + return c.SDL_CreateSurface(width, height, @bitCast(format)); +} + +pub inline fn createSurfaceFrom(width: c_int, height: c_int, format: PixelFormat, pixels: ?*anyopaque, pitch: c_int) ?*Surface { + return c.SDL_CreateSurfaceFrom(width, height, @bitCast(format), pixels, pitch); +} + +pub inline fn loadBMP(file: [*c]const u8) ?*Surface { + return c.SDL_LoadBMP(file); +} + +pub inline fn convertPixels(width: c_int, height: c_int, src_format: PixelFormat, src: ?*const anyopaque, src_pitch: c_int, dst_format: PixelFormat, dst: ?*anyopaque, dst_pitch: c_int) bool { + return c.SDL_ConvertPixels(width, height, @bitCast(src_format), src, src_pitch, @bitCast(dst_format), dst, dst_pitch); +} + +pub inline fn convertPixelsAndColorspace(width: c_int, height: c_int, src_format: PixelFormat, src_colorspace: Colorspace, src_properties: PropertiesID, src: ?*const anyopaque, src_pitch: c_int, dst_format: PixelFormat, dst_colorspace: Colorspace, dst_properties: PropertiesID, dst: ?*anyopaque, dst_pitch: c_int) bool { + return c.SDL_ConvertPixelsAndColorspace(width, height, @bitCast(src_format), src_colorspace, src_properties, src, src_pitch, @bitCast(dst_format), dst_colorspace, dst_properties, dst, dst_pitch); +} + +pub inline fn premultiplyAlpha(width: c_int, height: c_int, src_format: PixelFormat, src: ?*const anyopaque, src_pitch: c_int, dst_format: PixelFormat, dst: ?*anyopaque, dst_pitch: c_int, linear: bool) bool { + return c.SDL_PremultiplyAlpha(width, height, @bitCast(src_format), src, src_pitch, @bitCast(dst_format), dst, dst_pitch, linear); +} diff --git a/v2/system.zig b/v2/system.zig new file mode 100644 index 0000000..3e0d99c --- /dev/null +++ b/v2/system.zig @@ -0,0 +1,159 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const DisplayID = u32; + +pub const Window = opaque { + pub inline fn setiOSAnimationCallback(window: *Window, interval: c_int, callback: iOSAnimationCallback, callbackParam: ?*anyopaque) bool { + return c.SDL_SetiOSAnimationCallback(window, interval, callback, callbackParam); + } +}; + +pub const MSG = opaque {}; + +pub const WindowsMessageHook = *const fn (userdata: ?*anyopaque, msg: [*c]MSG) callconv(.C) bool; + +pub inline fn setWindowsMessageHook(callback: WindowsMessageHook, userdata: ?*anyopaque) void { + return c.SDL_SetWindowsMessageHook(callback, userdata); +} + +pub inline fn getDirect3D9AdapterIndex(displayID: DisplayID) c_int { + return c.SDL_GetDirect3D9AdapterIndex(displayID); +} + +pub inline fn getDXGIOutputInfo(displayID: DisplayID, adapterIndex: *c_int, outputIndex: *c_int) bool { + return c.SDL_GetDXGIOutputInfo(displayID, @ptrCast(adapterIndex), @ptrCast(outputIndex)); +} + +pub const X11EventHook = *const fn (userdata: ?*anyopaque, xevent: [*c]XEvent) callconv(.C) bool; + +pub inline fn setX11EventHook(callback: X11EventHook, userdata: ?*anyopaque) void { + return c.SDL_SetX11EventHook(callback, userdata); +} + +pub inline fn setLinuxThreadPriority(threadID: i64, priority: c_int) bool { + return c.SDL_SetLinuxThreadPriority(threadID, priority); +} + +pub inline fn setLinuxThreadPriorityAndPolicy(threadID: i64, sdlPriority: c_int, schedPolicy: c_int) bool { + return c.SDL_SetLinuxThreadPriorityAndPolicy(threadID, sdlPriority, schedPolicy); +} + +pub const iOSAnimationCallback = *const fn (userdata: ?*anyopaque) callconv(.C) void; + +pub inline fn setiOSEventPump(enabled: bool) void { + return c.SDL_SetiOSEventPump(enabled); +} + +pub inline fn getAndroidJNIEnv() ?*anyopaque { + return c.SDL_GetAndroidJNIEnv(); +} + +pub inline fn getAndroidActivity() ?*anyopaque { + return c.SDL_GetAndroidActivity(); +} + +pub inline fn getAndroidSDKVersion() c_int { + return c.SDL_GetAndroidSDKVersion(); +} + +pub inline fn isChromebook() bool { + return c.SDL_IsChromebook(); +} + +pub inline fn isDeXMode() bool { + return c.SDL_IsDeXMode(); +} + +pub inline fn sendAndroidBackButton() void { + return c.SDL_SendAndroidBackButton(); +} + +pub inline fn getAndroidInternalStoragePath() [*c]const u8 { + return c.SDL_GetAndroidInternalStoragePath(); +} + +pub inline fn getAndroidExternalStorageState() u32 { + return c.SDL_GetAndroidExternalStorageState(); +} + +pub inline fn getAndroidExternalStoragePath() [*c]const u8 { + return c.SDL_GetAndroidExternalStoragePath(); +} + +pub inline fn getAndroidCachePath() [*c]const u8 { + return c.SDL_GetAndroidCachePath(); +} + +pub const RequestAndroidPermissionCallback = *const fn (userdata: ?*anyopaque, permission: [*c]const u8, granted: bool) callconv(.C) void; + +pub inline fn requestAndroidPermission(permission: [*c]const u8, cb: RequestAndroidPermissionCallback, userdata: ?*anyopaque) bool { + return c.SDL_RequestAndroidPermission(permission, cb, userdata); +} + +pub inline fn showAndroidToast(message: [*c]const u8, duration: c_int, gravity: c_int, xoffset: c_int, yoffset: c_int) bool { + return c.SDL_ShowAndroidToast(message, duration, gravity, xoffset, yoffset); +} + +pub inline fn sendAndroidMessage(command: u32, param: c_int) bool { + return c.SDL_SendAndroidMessage(command, param); +} + +pub inline fn isTablet() bool { + return c.SDL_IsTablet(); +} + +pub inline fn isTV() bool { + return c.SDL_IsTV(); +} + +pub const Sandbox = enum(c_int) { + sandboxUnknownContainer, + sandboxFlatpak, + sandboxSnap, + sandboxMacos, +}; + +pub inline fn getSandbox() Sandbox { + return c.SDL_GetSandbox(); +} + +pub inline fn onApplicationWillTerminate() void { + return c.SDL_OnApplicationWillTerminate(); +} + +pub inline fn onApplicationDidReceiveMemoryWarning() void { + return c.SDL_OnApplicationDidReceiveMemoryWarning(); +} + +pub inline fn onApplicationWillEnterBackground() void { + return c.SDL_OnApplicationWillEnterBackground(); +} + +pub inline fn onApplicationDidEnterBackground() void { + return c.SDL_OnApplicationDidEnterBackground(); +} + +pub inline fn onApplicationWillEnterForeground() void { + return c.SDL_OnApplicationWillEnterForeground(); +} + +pub inline fn onApplicationDidEnterForeground() void { + return c.SDL_OnApplicationDidEnterForeground(); +} + +pub inline fn onApplicationDidChangeStatusBarOrientation() void { + return c.SDL_OnApplicationDidChangeStatusBarOrientation(); +} + +pub const XTaskQueueHandle = *anyopaque; + +pub const XUserHandle = *anyopaque; + +pub inline fn getGDKTaskQueue(outTaskQueue: [*c]XTaskQueueHandle) bool { + return c.SDL_GetGDKTaskQueue(outTaskQueue); +} + +pub inline fn getGDKDefaultUser(outUserHandle: [*c]XUserHandle) bool { + return c.SDL_GetGDKDefaultUser(outUserHandle); +} diff --git a/v2/time.zig b/v2/time.zig new file mode 100644 index 0000000..5b93219 --- /dev/null +++ b/v2/time.zig @@ -0,0 +1,63 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Time = i64; + +pub const DateTime = extern struct { + year: c_int, // Year + month: c_int, // Month [01-12] + day: c_int, // Day of the month [01-31] + hour: c_int, // Hour [0-23] + minute: c_int, // Minute [0-59] + second: c_int, // Seconds [0-60] + nanosecond: c_int, // Nanoseconds [0-999999999] + day_of_week: c_int, // Day of the week [0-6] (0 being Sunday) + utc_offset: c_int, // Seconds east of UTC +}; + +pub const DateFormat = enum(c_int) { + dateFormatYyyymmdd, //Year/Month/Day + dateFormatDdmmyyyy, //Day/Month/Year + dateFormatMmddyyyy, //Month/Day/Year +}; + +pub const TimeFormat = enum(c_int) { + timeFormat24hr, //24 hour time + timeFormat12hr, //12 hour time +}; + +pub inline fn getDateTimeLocalePreferences(dateFormat: ?*DateFormat, timeFormat: ?*TimeFormat) bool { + return c.SDL_GetDateTimeLocalePreferences(@bitCast(dateFormat), @bitCast(timeFormat)); +} + +pub inline fn getCurrentTime(ticks: ?*Time) bool { + return c.SDL_GetCurrentTime(ticks); +} + +pub inline fn timeToDateTime(ticks: Time, dt: ?*DateTime, localTime: bool) bool { + return c.SDL_TimeToDateTime(ticks, dt, localTime); +} + +pub inline fn dateTimeToTime(dt: *const DateTime, ticks: ?*Time) bool { + return c.SDL_DateTimeToTime(@ptrCast(dt), ticks); +} + +pub inline fn timeToWindows(ticks: Time, dwLowDateTime: *u32, dwHighDateTime: *u32) void { + return c.SDL_TimeToWindows(ticks, @ptrCast(dwLowDateTime), @ptrCast(dwHighDateTime)); +} + +pub inline fn timeFromWindows(dwLowDateTime: u32, dwHighDateTime: u32) Time { + return c.SDL_TimeFromWindows(dwLowDateTime, dwHighDateTime); +} + +pub inline fn getDaysInMonth(year: c_int, month: c_int) c_int { + return c.SDL_GetDaysInMonth(year, month); +} + +pub inline fn getDayOfYear(year: c_int, month: c_int, day: c_int) c_int { + return c.SDL_GetDayOfYear(year, month, day); +} + +pub inline fn getDayOfWeek(year: c_int, month: c_int, day: c_int) c_int { + return c.SDL_GetDayOfWeek(year, month, day); +} diff --git a/v2/timer.zig b/v2/timer.zig new file mode 100644 index 0000000..cd38e6a --- /dev/null +++ b/v2/timer.zig @@ -0,0 +1,48 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub inline fn getTicks() u64 { + return c.SDL_GetTicks(); +} + +pub inline fn getTicksNS() u64 { + return c.SDL_GetTicksNS(); +} + +pub inline fn getPerformanceCounter() u64 { + return c.SDL_GetPerformanceCounter(); +} + +pub inline fn getPerformanceFrequency() u64 { + return c.SDL_GetPerformanceFrequency(); +} + +pub inline fn delay(ms: u32) void { + return c.SDL_Delay(ms); +} + +pub inline fn delayNS(ns: u64) void { + return c.SDL_DelayNS(ns); +} + +pub inline fn delayPrecise(ns: u64) void { + return c.SDL_DelayPrecise(ns); +} + +pub const TimerID = u32; + +pub const TimerCallback = *const fn (userdata: ?*anyopaque, timerID: TimerID, interval: u32) callconv(.C) u32; + +pub inline fn addTimer(interval: u32, callback: TimerCallback, userdata: ?*anyopaque) TimerID { + return c.SDL_AddTimer(interval, callback, userdata); +} + +pub const NSTimerCallback = *const fn (userdata: ?*anyopaque, timerID: TimerID, interval: u64) callconv(.C) u64; + +pub inline fn addTimerNS(interval: u64, callback: NSTimerCallback, userdata: ?*anyopaque) TimerID { + return c.SDL_AddTimerNS(interval, callback, userdata); +} + +pub inline fn removeTimer(id: TimerID) bool { + return c.SDL_RemoveTimer(id); +} diff --git a/v2/touch.zig b/v2/touch.zig new file mode 100644 index 0000000..2394cdc --- /dev/null +++ b/v2/touch.zig @@ -0,0 +1,35 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const TouchID = u64; + +pub const FingerID = u64; + +pub const TouchDeviceType = enum(c_int) { + touchDeviceDirect, //touch screen with window-relative coordinates + touchDeviceIndirectAbsolute, //trackpad with absolute device coordinates + touchDeviceIndirectRelative, //trackpad with screen cursor-relative coordinates +}; + +pub const Finger = extern struct { + id: FingerID, // the finger ID + x: f32, // the x-axis location of the touch event, normalized (0...1) + y: f32, // the y-axis location of the touch event, normalized (0...1) + pressure: f32, // the quantity of pressure applied, normalized (0...1) +}; + +pub inline fn getTouchDevices(count: *c_int) ?*TouchID { + return c.SDL_GetTouchDevices(@ptrCast(count)); +} + +pub inline fn getTouchDeviceName(touchID: TouchID) [*c]const u8 { + return c.SDL_GetTouchDeviceName(touchID); +} + +pub inline fn getTouchDeviceType(touchID: TouchID) TouchDeviceType { + return @intFromEnum(c.SDL_GetTouchDeviceType(touchID)); +} + +pub inline fn getTouchFingers(touchID: TouchID, count: *c_int) [*c][*c]Finger { + return c.SDL_GetTouchFingers(touchID, @ptrCast(count)); +} diff --git a/v2/version.zig b/v2/version.zig new file mode 100644 index 0000000..8cef3e8 --- /dev/null +++ b/v2/version.zig @@ -0,0 +1,10 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub inline fn getVersion() c_int { + return c.SDL_GetVersion(); +} + +pub inline fn getRevision() [*c]const u8 { + return c.SDL_GetRevision(); +} diff --git a/v2/video.zig b/v2/video.zig new file mode 100644 index 0000000..1ed6fbf --- /dev/null +++ b/v2/video.zig @@ -0,0 +1,607 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PixelFormat = enum(c_int) { + pixelformatYv12, //Planar mode: Y + V + U (3 planes) + pixelformatIyuv, //Planar mode: Y + U + V (3 planes) + pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane) + pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane) + pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane) + pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes) + pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes) + pixelformatExternalOes, //Android video texture format + pixelformatMjpg, //Motion JPEG +}; + +pub const Point = extern struct { + x: c_int, + y: c_int, +}; + +pub const Surface = opaque {}; + +pub const PropertiesID = u32; + +pub const Rect = extern struct { + x: c_int, + y: c_int, + w: c_int, + h: c_int, +}; + +pub const FunctionPointer = ?*anyopaque; + +pub const DisplayID = u32; + +pub const WindowID = u32; + +pub const SystemTheme = enum(c_int) { + systemThemeUnknown, //Unknown system theme + systemThemeLight, //Light colored system theme + systemThemeDark, //Dark colored system theme +}; + +pub const DisplayModeData = opaque {}; + +pub const DisplayMode = extern struct { + displayID: DisplayID, // the display this mode is associated with + format: PixelFormat, // pixel format + w: c_int, // width + h: c_int, // height + pixel_density: f32, // scale converting size to pixels (e.g. a 1920x1080 mode with 2.0 scale would have 3840x2160 pixels) + refresh_rate: f32, // refresh rate (or 0.0f for unspecified) + refresh_rate_numerator: c_int, // precise refresh rate numerator (or 0 for unspecified) + refresh_rate_denominator: c_int, // precise refresh rate denominator + internal: ?*DisplayModeData, // Private +}; + +pub const DisplayOrientation = enum(c_int) { + orientationUnknown, //The display orientation can't be determined + orientationLandscape, //The display is in landscape mode, with the right side up, relative to portrait mode + orientationLandscapeFlipped, //The display is in landscape mode, with the left side up, relative to portrait mode + orientationPortrait, //The display is in portrait mode + orientationPortraitFlipped, +}; + +pub const Window = opaque { + pub inline fn getDisplayForWindow(window: *Window) DisplayID { + return c.SDL_GetDisplayForWindow(window); + } + + pub inline fn getWindowPixelDensity(window: *Window) f32 { + return c.SDL_GetWindowPixelDensity(window); + } + + pub inline fn getWindowDisplayScale(window: *Window) f32 { + return c.SDL_GetWindowDisplayScale(window); + } + + pub inline fn setWindowFullscreenMode(window: *Window, mode: *const DisplayMode) bool { + return c.SDL_SetWindowFullscreenMode(window, @ptrCast(mode)); + } + + pub inline fn getWindowFullscreenMode(window: *Window) *const DisplayMode { + return @ptrCast(c.SDL_GetWindowFullscreenMode(window)); + } + + pub inline fn getWindowICCProfile(window: *Window, size: *usize) ?*anyopaque { + return c.SDL_GetWindowICCProfile(window, @ptrCast(size)); + } + + pub inline fn getWindowPixelFormat(window: *Window) PixelFormat { + return @bitCast(c.SDL_GetWindowPixelFormat(window)); + } + + pub inline fn createPopupWindow(window: *Window, offset_x: c_int, offset_y: c_int, w: c_int, h: c_int, flags: WindowFlags) ?*Window { + return c.SDL_CreatePopupWindow(window, offset_x, offset_y, w, h, @bitCast(flags)); + } + + pub inline fn getWindowID(window: *Window) WindowID { + return c.SDL_GetWindowID(window); + } + + pub inline fn getWindowParent(window: *Window) ?*Window { + return c.SDL_GetWindowParent(window); + } + + pub inline fn getWindowProperties(window: *Window) PropertiesID { + return c.SDL_GetWindowProperties(window); + } + + pub inline fn getWindowFlags(window: *Window) WindowFlags { + return @bitCast(c.SDL_GetWindowFlags(window)); + } + + pub inline fn setWindowTitle(window: *Window, title: [*c]const u8) bool { + return c.SDL_SetWindowTitle(window, title); + } + + pub inline fn getWindowTitle(window: *Window) [*c]const u8 { + return c.SDL_GetWindowTitle(window); + } + + pub inline fn setWindowIcon(window: *Window, icon: ?*Surface) bool { + return c.SDL_SetWindowIcon(window, icon); + } + + pub inline fn setWindowPosition(window: *Window, x: c_int, y: c_int) bool { + return c.SDL_SetWindowPosition(window, x, y); + } + + pub inline fn getWindowPosition(window: *Window, x: *c_int, y: *c_int) bool { + return c.SDL_GetWindowPosition(window, @ptrCast(x), @ptrCast(y)); + } + + pub inline fn setWindowSize(window: *Window, w: c_int, h: c_int) bool { + return c.SDL_SetWindowSize(window, w, h); + } + + pub inline fn getWindowSize(window: *Window, w: *c_int, h: *c_int) bool { + return c.SDL_GetWindowSize(window, @ptrCast(w), @ptrCast(h)); + } + + pub inline fn getWindowSafeArea(window: *Window, rect: ?*Rect) bool { + return c.SDL_GetWindowSafeArea(window, rect); + } + + pub inline fn setWindowAspectRatio(window: *Window, min_aspect: f32, max_aspect: f32) bool { + return c.SDL_SetWindowAspectRatio(window, min_aspect, max_aspect); + } + + pub inline fn getWindowAspectRatio(window: *Window, min_aspect: *f32, max_aspect: *f32) bool { + return c.SDL_GetWindowAspectRatio(window, @ptrCast(min_aspect), @ptrCast(max_aspect)); + } + + pub inline fn getWindowBordersSize(window: *Window, top: *c_int, left: *c_int, bottom: *c_int, right: *c_int) bool { + return c.SDL_GetWindowBordersSize(window, @ptrCast(top), @ptrCast(left), @ptrCast(bottom), @ptrCast(right)); + } + + pub inline fn getWindowSizeInPixels(window: *Window, w: *c_int, h: *c_int) bool { + return c.SDL_GetWindowSizeInPixels(window, @ptrCast(w), @ptrCast(h)); + } + + pub inline fn setWindowMinimumSize(window: *Window, min_w: c_int, min_h: c_int) bool { + return c.SDL_SetWindowMinimumSize(window, min_w, min_h); + } + + pub inline fn getWindowMinimumSize(window: *Window, w: *c_int, h: *c_int) bool { + return c.SDL_GetWindowMinimumSize(window, @ptrCast(w), @ptrCast(h)); + } + + pub inline fn setWindowMaximumSize(window: *Window, max_w: c_int, max_h: c_int) bool { + return c.SDL_SetWindowMaximumSize(window, max_w, max_h); + } + + pub inline fn getWindowMaximumSize(window: *Window, w: *c_int, h: *c_int) bool { + return c.SDL_GetWindowMaximumSize(window, @ptrCast(w), @ptrCast(h)); + } + + pub inline fn setWindowBordered(window: *Window, bordered: bool) bool { + return c.SDL_SetWindowBordered(window, bordered); + } + + pub inline fn setWindowResizable(window: *Window, resizable: bool) bool { + return c.SDL_SetWindowResizable(window, resizable); + } + + pub inline fn setWindowAlwaysOnTop(window: *Window, on_top: bool) bool { + return c.SDL_SetWindowAlwaysOnTop(window, on_top); + } + + pub inline fn showWindow(window: *Window) bool { + return c.SDL_ShowWindow(window); + } + + pub inline fn hideWindow(window: *Window) bool { + return c.SDL_HideWindow(window); + } + + pub inline fn raiseWindow(window: *Window) bool { + return c.SDL_RaiseWindow(window); + } + + pub inline fn maximizeWindow(window: *Window) bool { + return c.SDL_MaximizeWindow(window); + } + + pub inline fn minimizeWindow(window: *Window) bool { + return c.SDL_MinimizeWindow(window); + } + + pub inline fn restoreWindow(window: *Window) bool { + return c.SDL_RestoreWindow(window); + } + + pub inline fn setWindowFullscreen(window: *Window, fullscreen: bool) bool { + return c.SDL_SetWindowFullscreen(window, fullscreen); + } + + pub inline fn syncWindow(window: *Window) bool { + return c.SDL_SyncWindow(window); + } + + pub inline fn windowHasSurface(window: *Window) bool { + return c.SDL_WindowHasSurface(window); + } + + pub inline fn getWindowSurface(window: *Window) ?*Surface { + return c.SDL_GetWindowSurface(window); + } + + pub inline fn setWindowSurfaceVSync(window: *Window, vsync: c_int) bool { + return c.SDL_SetWindowSurfaceVSync(window, vsync); + } + + pub inline fn getWindowSurfaceVSync(window: *Window, vsync: *c_int) bool { + return c.SDL_GetWindowSurfaceVSync(window, @ptrCast(vsync)); + } + + pub inline fn updateWindowSurface(window: *Window) bool { + return c.SDL_UpdateWindowSurface(window); + } + + pub inline fn updateWindowSurfaceRects(window: *Window, rects: *const Rect, numrects: c_int) bool { + return c.SDL_UpdateWindowSurfaceRects(window, @ptrCast(rects), numrects); + } + + pub inline fn destroyWindowSurface(window: *Window) bool { + return c.SDL_DestroyWindowSurface(window); + } + + pub inline fn setWindowKeyboardGrab(window: *Window, grabbed: bool) bool { + return c.SDL_SetWindowKeyboardGrab(window, grabbed); + } + + pub inline fn setWindowMouseGrab(window: *Window, grabbed: bool) bool { + return c.SDL_SetWindowMouseGrab(window, grabbed); + } + + pub inline fn getWindowKeyboardGrab(window: *Window) bool { + return c.SDL_GetWindowKeyboardGrab(window); + } + + pub inline fn getWindowMouseGrab(window: *Window) bool { + return c.SDL_GetWindowMouseGrab(window); + } + + pub inline fn setWindowMouseRect(window: *Window, rect: *const Rect) bool { + return c.SDL_SetWindowMouseRect(window, @ptrCast(rect)); + } + + pub inline fn getWindowMouseRect(window: *Window) *const Rect { + return @ptrCast(c.SDL_GetWindowMouseRect(window)); + } + + pub inline fn setWindowOpacity(window: *Window, opacity: f32) bool { + return c.SDL_SetWindowOpacity(window, opacity); + } + + pub inline fn getWindowOpacity(window: *Window) f32 { + return c.SDL_GetWindowOpacity(window); + } + + pub inline fn setWindowParent(window: *Window, parent: ?*Window) bool { + return c.SDL_SetWindowParent(window, parent); + } + + pub inline fn setWindowModal(window: *Window, modal: bool) bool { + return c.SDL_SetWindowModal(window, modal); + } + + pub inline fn setWindowFocusable(window: *Window, focusable: bool) bool { + return c.SDL_SetWindowFocusable(window, focusable); + } + + pub inline fn showWindowSystemMenu(window: *Window, x: c_int, y: c_int) bool { + return c.SDL_ShowWindowSystemMenu(window, x, y); + } + + pub inline fn setWindowHitTest(window: *Window, callback: HitTest, callback_data: ?*anyopaque) bool { + return c.SDL_SetWindowHitTest(window, callback, callback_data); + } + + pub inline fn setWindowShape(window: *Window, shape: ?*Surface) bool { + return c.SDL_SetWindowShape(window, shape); + } + + pub inline fn flashWindow(window: *Window, operation: FlashOperation) bool { + return c.SDL_FlashWindow(window, @intFromEnum(operation)); + } + + pub inline fn destroyWindow(window: *Window) void { + return c.SDL_DestroyWindow(window); + } + + pub inline fn gl_CreateContext(window: *Window) GLContext { + return c.SDL_GL_CreateContext(window); + } + + pub inline fn gl_MakeCurrent(window: *Window, context: GLContext) bool { + return c.SDL_GL_MakeCurrent(window, context); + } + + pub inline fn egl_GetWindowSurface(window: *Window) EGLSurface { + return c.SDL_EGL_GetWindowSurface(window); + } + + pub inline fn gl_SwapWindow(window: *Window) bool { + return c.SDL_GL_SwapWindow(window); + } +}; + +pub const WindowFlags = packed struct(u64) { + windowFullscreen: bool = false, // window is in fullscreen mode + windowOpengl: bool = false, // window usable with OpenGL context + windowOccluded: bool = false, // window is occluded + windowHidden: bool = false, // window is neither mapped onto the desktop nor shown in the taskbar/dock/window list; SDL_ShowWindow() is required for it to become visible + windowBorderless: bool = false, // no window decoration + windowResizable: bool = false, // window can be resized + windowMinimized: bool = false, // window is minimized + windowMaximized: bool = false, // window is maximized + windowMouseGrabbed: bool = false, // window has grabbed mouse input + windowInputFocus: bool = false, // window has input focus + windowMouseFocus: bool = false, // window has mouse focus + windowExternal: bool = false, // window not created by SDL + windowModal: bool = false, // window is modal + windowHighPixelDensity: bool = false, // window uses high pixel density back buffer if possible + windowMouseCapture: bool = false, // window has mouse captured (unrelated to MOUSE_GRABBED) + windowMouseRelativeMode: bool = false, // window has relative mode enabled + windowAlwaysOnTop: bool = false, // window should always be above others + windowUtility: bool = false, // window should be treated as a utility window, not showing in the task bar and window list + windowTooltip: bool = false, // window should be treated as a tooltip and does not get mouse or keyboard focus, requires a parent window + windowPopupMenu: bool = false, // window should be treated as a popup menu, requires a parent window + windowKeyboardGrabbed: bool = false, // window has grabbed keyboard input + windowVulkan: bool = false, // window usable for Vulkan surface + windowMetal: bool = false, // window usable for Metal view + windowTransparent: bool = false, // window with transparent buffer + windowNotFocusable: bool = false, // window should not be focusable + pad0: u38 = 0, + rsvd: bool = false, +}; + +pub const FlashOperation = enum(c_int) { + flashCancel, //Cancel any window flash state + flashBriefly, //Flash the window briefly to get attention + flashUntilFocused, //Flash the window until it gets focus +}; + +pub const GLContext = *anyopaque; + +pub const EGLDisplay = ?*anyopaque; + +pub const EGLConfig = ?*anyopaque; + +pub const EGLSurface = ?*anyopaque; + +pub const EGLAttrib = intptr_t; + +pub const EGLint = c_int; + +pub const EGLAttribArrayCallback = *const fn (userdata: ?*anyopaque) callconv(.C) ?*EGLAttrib; + +pub const EGLIntArrayCallback = *const fn (userdata: ?*anyopaque, display: EGLDisplay, config: EGLConfig) callconv(.C) ?*EGLint; + +pub const GLAttr = enum(c_int) { + glRedSize, //the minimum number of bits for the red channel of the color buffer; defaults to 3. + glGreenSize, //the minimum number of bits for the green channel of the color buffer; defaults to 3. + glBlueSize, //the minimum number of bits for the blue channel of the color buffer; defaults to 2. + glAlphaSize, //the minimum number of bits for the alpha channel of the color buffer; defaults to 0. + glBufferSize, //the minimum number of bits for frame buffer size; defaults to 0. + glDoublebuffer, //whether the output is single or double buffered; defaults to double buffering on. + glDepthSize, //the minimum number of bits in the depth buffer; defaults to 16. + glStencilSize, //the minimum number of bits in the stencil buffer; defaults to 0. + glAccumRedSize, //the minimum number of bits for the red channel of the accumulation buffer; defaults to 0. + glAccumGreenSize, //the minimum number of bits for the green channel of the accumulation buffer; defaults to 0. + glAccumBlueSize, //the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0. + glAccumAlphaSize, //the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0. + glStereo, //whether the output is stereo 3D; defaults to off. + glMultisamplebuffers, //the number of buffers used for multisample anti-aliasing; defaults to 0. + glMultisamplesamples, //the number of samples used around the current pixel used for multisample anti-aliasing. + glAcceleratedVisual, //set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either. + glRetainedBacking, //not used (deprecated). + glContextMajorVersion, //OpenGL context major version. + glContextMinorVersion, //OpenGL context minor version. + glContextFlags, //some combination of 0 or more of elements of the SDL_GLContextFlag enumeration; defaults to 0. + glContextProfileMask, //type of GL context (Core, Compatibility, ES). See SDL_GLProfile; default value depends on platform. + glShareWithCurrentContext, //OpenGL context sharing; defaults to 0. + glFramebufferSrgbCapable, //requests sRGB capable visual; defaults to 0. + glContextReleaseBehavior, //sets context the release behavior. See SDL_GLContextReleaseFlag; defaults to FLUSH. + glContextResetNotification, //set context reset notification. See SDL_GLContextResetNotification; defaults to NO_NOTIFICATION. + glContextNoError, + glFloatbuffers, + glEglPlatform, +}; + +pub const GLProfile = u32; + +pub const GLContextFlag = u32; + +pub const GLContextReleaseFlag = u32; + +pub const GLContextResetNotification = u32; + +pub inline fn getNumVideoDrivers() c_int { + return c.SDL_GetNumVideoDrivers(); +} + +pub inline fn getVideoDriver(index: c_int) [*c]const u8 { + return c.SDL_GetVideoDriver(index); +} + +pub inline fn getCurrentVideoDriver() [*c]const u8 { + return c.SDL_GetCurrentVideoDriver(); +} + +pub inline fn getSystemTheme() SystemTheme { + return c.SDL_GetSystemTheme(); +} + +pub inline fn getDisplays(count: *c_int) ?*DisplayID { + return c.SDL_GetDisplays(@ptrCast(count)); +} + +pub inline fn getPrimaryDisplay() DisplayID { + return c.SDL_GetPrimaryDisplay(); +} + +pub inline fn getDisplayProperties(displayID: DisplayID) PropertiesID { + return c.SDL_GetDisplayProperties(displayID); +} + +pub inline fn getDisplayName(displayID: DisplayID) [*c]const u8 { + return c.SDL_GetDisplayName(displayID); +} + +pub inline fn getDisplayBounds(displayID: DisplayID, rect: ?*Rect) bool { + return c.SDL_GetDisplayBounds(displayID, rect); +} + +pub inline fn getDisplayUsableBounds(displayID: DisplayID, rect: ?*Rect) bool { + return c.SDL_GetDisplayUsableBounds(displayID, rect); +} + +pub inline fn getNaturalDisplayOrientation(displayID: DisplayID) DisplayOrientation { + return c.SDL_GetNaturalDisplayOrientation(displayID); +} + +pub inline fn getCurrentDisplayOrientation(displayID: DisplayID) DisplayOrientation { + return c.SDL_GetCurrentDisplayOrientation(displayID); +} + +pub inline fn getDisplayContentScale(displayID: DisplayID) f32 { + return c.SDL_GetDisplayContentScale(displayID); +} + +pub inline fn getFullscreenDisplayModes(displayID: DisplayID, count: *c_int) [*c][*c]DisplayMode { + return @intFromEnum(c.SDL_GetFullscreenDisplayModes(displayID, @ptrCast(count))); +} + +pub inline fn getClosestFullscreenDisplayMode(displayID: DisplayID, w: c_int, h: c_int, refresh_rate: f32, include_high_density_modes: bool, closest: ?*DisplayMode) bool { + return c.SDL_GetClosestFullscreenDisplayMode(displayID, w, h, refresh_rate, include_high_density_modes, @intFromEnum(closest)); +} + +pub inline fn getDesktopDisplayMode(displayID: DisplayID) *const DisplayMode { + return @ptrCast(c.SDL_GetDesktopDisplayMode(displayID)); +} + +pub inline fn getCurrentDisplayMode(displayID: DisplayID) *const DisplayMode { + return @ptrCast(c.SDL_GetCurrentDisplayMode(displayID)); +} + +pub inline fn getDisplayForPoint(point: *const Point) DisplayID { + return c.SDL_GetDisplayForPoint(@ptrCast(point)); +} + +pub inline fn getDisplayForRect(rect: *const Rect) DisplayID { + return c.SDL_GetDisplayForRect(@ptrCast(rect)); +} + +pub inline fn getWindows(count: *c_int) [*c][*c]Window { + return c.SDL_GetWindows(@ptrCast(count)); +} + +pub inline fn createWindow(title: [*c]const u8, w: c_int, h: c_int, flags: WindowFlags) ?*Window { + return c.SDL_CreateWindow(title, w, h, @bitCast(flags)); +} + +pub inline fn createWindowWithProperties(props: PropertiesID) ?*Window { + return c.SDL_CreateWindowWithProperties(props); +} + +pub inline fn getWindowFromID(id: WindowID) ?*Window { + return c.SDL_GetWindowFromID(id); +} + +pub inline fn getGrabbedWindow() ?*Window { + return c.SDL_GetGrabbedWindow(); +} + +pub const HitTestResult = enum(c_int) { + hittestNormal, //Region is normal. No special properties. + hittestDraggable, //Region can drag entire window. + hittestResizeTopleft, //Region is the resizable top-left corner border. + hittestResizeTop, //Region is the resizable top border. + hittestResizeTopright, //Region is the resizable top-right corner border. + hittestResizeRight, //Region is the resizable right border. + hittestResizeBottomright, //Region is the resizable bottom-right corner border. + hittestResizeBottom, //Region is the resizable bottom border. + hittestResizeBottomleft, //Region is the resizable bottom-left corner border. + hittestResizeLeft, //Region is the resizable left border. +}; + +pub inline fn screenSaverEnabled() bool { + return c.SDL_ScreenSaverEnabled(); +} + +pub inline fn enableScreenSaver() bool { + return c.SDL_EnableScreenSaver(); +} + +pub inline fn disableScreenSaver() bool { + return c.SDL_DisableScreenSaver(); +} + +pub inline fn gl_LoadLibrary(path: [*c]const u8) bool { + return c.SDL_GL_LoadLibrary(path); +} + +pub inline fn gl_GetProcAddress(proc: [*c]const u8) FunctionPointer { + return c.SDL_GL_GetProcAddress(proc); +} + +pub inline fn egl_GetProcAddress(proc: [*c]const u8) FunctionPointer { + return c.SDL_EGL_GetProcAddress(proc); +} + +pub inline fn gl_UnloadLibrary() void { + return c.SDL_GL_UnloadLibrary(); +} + +pub inline fn gl_ExtensionSupported(extension: [*c]const u8) bool { + return c.SDL_GL_ExtensionSupported(extension); +} + +pub inline fn gl_ResetAttributes() void { + return c.SDL_GL_ResetAttributes(); +} + +pub inline fn gl_SetAttribute(attr: GLAttr, value: c_int) bool { + return c.SDL_GL_SetAttribute(attr, value); +} + +pub inline fn gl_GetAttribute(attr: GLAttr, value: *c_int) bool { + return c.SDL_GL_GetAttribute(attr, @ptrCast(value)); +} + +pub inline fn gl_GetCurrentWindow() ?*Window { + return c.SDL_GL_GetCurrentWindow(); +} + +pub inline fn gl_GetCurrentContext() GLContext { + return c.SDL_GL_GetCurrentContext(); +} + +pub inline fn egl_GetCurrentDisplay() EGLDisplay { + return c.SDL_EGL_GetCurrentDisplay(); +} + +pub inline fn egl_GetCurrentConfig() EGLConfig { + return c.SDL_EGL_GetCurrentConfig(); +} + +pub inline fn egl_SetAttributeCallbacks(platformAttribCallback: EGLAttribArrayCallback, surfaceAttribCallback: EGLIntArrayCallback, contextAttribCallback: EGLIntArrayCallback, userdata: ?*anyopaque) void { + return c.SDL_EGL_SetAttributeCallbacks(platformAttribCallback, surfaceAttribCallback, contextAttribCallback, userdata); +} + +pub inline fn gl_SetSwapInterval(interval: c_int) bool { + return c.SDL_GL_SetSwapInterval(interval); +} + +pub inline fn gl_GetSwapInterval(interval: *c_int) bool { + return c.SDL_GL_GetSwapInterval(@ptrCast(interval)); +} + +pub inline fn gl_DestroyContext(context: GLContext) bool { + return c.SDL_GL_DestroyContext(context); +}