From fbc49f159651a40c53e82b715235917b89457868 Mon Sep 17 00:00:00 2001 From: Peterino2 Date: Thu, 22 Jan 2026 21:19:21 -0800 Subject: [PATCH] 3 hours of vibe coding or just having a real programmer step in for 20 minutes... --- lib/sdl3/build.zig | 115 +- lib/sdl3/json/audio.json | 892 ++++++ lib/sdl3/json/blendmode.json | 131 + lib/sdl3/json/camera.json | 232 ++ lib/sdl3/json/clipboard.json | 146 + lib/sdl3/json/dialog.json | 172 ++ lib/sdl3/json/endian.json | 11 + lib/sdl3/json/error.json | 55 + lib/sdl3/json/filesystem.json | 298 ++ lib/sdl3/json/gamepad.json | 1148 ++++++++ lib/sdl3/json/gpu.json | 3881 +++++++++++++++++++++++++ lib/sdl3/json/haptic.json | 785 +++++ lib/sdl3/json/hints.json | 157 + lib/sdl3/json/init.json | 252 ++ lib/sdl3/json/joystick.json | 960 ++++++ lib/sdl3/json/keycode.json | 20 + lib/sdl3/json/loadso.json | 50 + lib/sdl3/json/messagebox.json | 204 ++ lib/sdl3/json/misc.json | 22 + lib/sdl3/json/mouse.json | 391 +++ lib/sdl3/json/pixels.json | 920 ++++++ lib/sdl3/json/properties.json | 394 +++ lib/sdl3/json/rect.json | 277 ++ lib/sdl3/json/render.json | 1668 +++++++++++ lib/sdl3/json/sensor.json | 203 ++ lib/sdl3/json/storage.json | 348 +++ lib/sdl3/json/surface.json | 1218 ++++++++ lib/sdl3/json/system.json | 398 +++ lib/sdl3/json/time.json | 237 ++ lib/sdl3/json/timer.json | 150 + lib/sdl3/json/touch.json | 109 + lib/sdl3/json/version.json | 22 + lib/sdl3/json/video.json | 1814 ++++++++++++ lib/sdl3/parser/docs/API_REFERENCE.md | 115 +- lib/sdl3/parser/src/codegen.zig | 65 +- lib/sdl3/parser/src/parser.zig | 92 +- lib/sdl3/parser/src/patterns.zig | 253 +- lib/sdl3/v2/assert.zig | 37 - lib/sdl3/v2/asyncio.zig | 61 - lib/sdl3/v2/atomic.zig | 70 - lib/sdl3/v2/audio.zig | 12 +- lib/sdl3/v2/blendmode.zig | 21 + lib/sdl3/v2/camera.zig | 100 +- lib/sdl3/v2/cpuinfo.zig | 74 - lib/sdl3/v2/dialog.zig | 4 +- lib/sdl3/v2/events.zig | 752 ----- lib/sdl3/v2/filesystem.zig | 30 +- lib/sdl3/v2/gamepad.zig | 68 +- lib/sdl3/v2/gpu.zig | 124 +- lib/sdl3/v2/guid.zig | 14 - lib/sdl3/v2/haptic.zig | 12 +- lib/sdl3/v2/hidapi.zig | 120 - lib/sdl3/v2/init.zig | 8 +- lib/sdl3/v2/iostream.zig | 211 -- lib/sdl3/v2/joystick.zig | 29 +- lib/sdl3/v2/keyboard.zig | 297 -- lib/sdl3/v2/locale.zig | 11 - lib/sdl3/v2/log.zig | 138 - lib/sdl3/v2/messagebox.zig | 1 + lib/sdl3/v2/metal.zig | 18 - lib/sdl3/v2/mouse.zig | 25 + lib/sdl3/v2/mutex.zig | 145 - lib/sdl3/v2/opengl.zig | 2 - lib/sdl3/v2/pen.zig | 16 - lib/sdl3/v2/pixels.zig | 164 +- lib/sdl3/v2/power.zig | 6 - lib/sdl3/v2/process.zig | 44 - lib/sdl3/v2/render.zig | 98 +- lib/sdl3/v2/scancode.zig | 184 -- lib/sdl3/v2/sensor.zig | 11 + lib/sdl3/v2/storage.zig | 2 +- lib/sdl3/v2/surface.zig | 109 +- lib/sdl3/v2/system.zig | 1 - lib/sdl3/v2/thread.zig | 79 - lib/sdl3/v2/time.zig | 11 + lib/sdl3/v2/touch.zig | 4 +- lib/sdl3/v2/tray.zig | 119 - lib/sdl3/v2/video.zig | 131 +- lib/sdl3/v2/vulkan.zig | 34 - 79 files changed, 18429 insertions(+), 3173 deletions(-) create mode 100644 lib/sdl3/json/audio.json create mode 100644 lib/sdl3/json/blendmode.json create mode 100644 lib/sdl3/json/camera.json create mode 100644 lib/sdl3/json/clipboard.json create mode 100644 lib/sdl3/json/dialog.json create mode 100644 lib/sdl3/json/endian.json create mode 100644 lib/sdl3/json/error.json create mode 100644 lib/sdl3/json/filesystem.json create mode 100644 lib/sdl3/json/gamepad.json create mode 100644 lib/sdl3/json/gpu.json create mode 100644 lib/sdl3/json/haptic.json create mode 100644 lib/sdl3/json/hints.json create mode 100644 lib/sdl3/json/init.json create mode 100644 lib/sdl3/json/joystick.json create mode 100644 lib/sdl3/json/keycode.json create mode 100644 lib/sdl3/json/loadso.json create mode 100644 lib/sdl3/json/messagebox.json create mode 100644 lib/sdl3/json/misc.json create mode 100644 lib/sdl3/json/mouse.json create mode 100644 lib/sdl3/json/pixels.json create mode 100644 lib/sdl3/json/properties.json create mode 100644 lib/sdl3/json/rect.json create mode 100644 lib/sdl3/json/render.json create mode 100644 lib/sdl3/json/sensor.json create mode 100644 lib/sdl3/json/storage.json create mode 100644 lib/sdl3/json/surface.json create mode 100644 lib/sdl3/json/system.json create mode 100644 lib/sdl3/json/time.json create mode 100644 lib/sdl3/json/timer.json create mode 100644 lib/sdl3/json/touch.json create mode 100644 lib/sdl3/json/version.json create mode 100644 lib/sdl3/json/video.json delete mode 100644 lib/sdl3/v2/assert.zig delete mode 100644 lib/sdl3/v2/asyncio.zig delete mode 100644 lib/sdl3/v2/atomic.zig delete mode 100644 lib/sdl3/v2/cpuinfo.zig delete mode 100644 lib/sdl3/v2/events.zig delete mode 100644 lib/sdl3/v2/guid.zig delete mode 100644 lib/sdl3/v2/hidapi.zig delete mode 100644 lib/sdl3/v2/iostream.zig delete mode 100644 lib/sdl3/v2/keyboard.zig delete mode 100644 lib/sdl3/v2/locale.zig delete mode 100644 lib/sdl3/v2/log.zig delete mode 100644 lib/sdl3/v2/metal.zig delete mode 100644 lib/sdl3/v2/mutex.zig delete mode 100644 lib/sdl3/v2/opengl.zig delete mode 100644 lib/sdl3/v2/pen.zig delete mode 100644 lib/sdl3/v2/power.zig delete mode 100644 lib/sdl3/v2/process.zig delete mode 100644 lib/sdl3/v2/scancode.zig delete mode 100644 lib/sdl3/v2/thread.zig delete mode 100644 lib/sdl3/v2/tray.zig delete mode 100644 lib/sdl3/v2/vulkan.zig diff --git a/lib/sdl3/build.zig b/lib/sdl3/build.zig index 3809a65..053972b 100644 --- a/lib/sdl3/build.zig +++ b/lib/sdl3/build.zig @@ -146,67 +146,72 @@ pub fn build(b: *std.Build) void { // All public SDL3 API headers (53 total) // Skipped: assert, thread, hidapi, mutex, tray (not core APIs or problematic) const headers_to_generate = [_]struct { header: []const u8, output: []const u8 }{ - .{ .header = "SDL/include/SDL3/SDL_asyncio.h", .output = "v2/asyncio.zig" }, - .{ .header = "SDL/include/SDL3/SDL_atomic.h", .output = "v2/atomic.zig" }, - .{ .header = "SDL/include/SDL3/SDL_audio.h", .output = "v2/audio.zig" }, - .{ .header = "SDL/include/SDL3/SDL_blendmode.h", .output = "v2/blendmode.zig" }, - .{ .header = "SDL/include/SDL3/SDL_camera.h", .output = "v2/camera.zig" }, - .{ .header = "SDL/include/SDL3/SDL_clipboard.h", .output = "v2/clipboard.zig" }, - .{ .header = "SDL/include/SDL3/SDL_cpuinfo.h", .output = "v2/cpuinfo.zig" }, - .{ .header = "SDL/include/SDL3/SDL_dialog.h", .output = "v2/dialog.zig" }, - .{ .header = "SDL/include/SDL3/SDL_endian.h", .output = "v2/endian.zig" }, - .{ .header = "SDL/include/SDL3/SDL_error.h", .output = "v2/error.zig" }, - .{ .header = "SDL/include/SDL3/SDL_events.h", .output = "v2/events.zig" }, - .{ .header = "SDL/include/SDL3/SDL_filesystem.h", .output = "v2/filesystem.zig" }, - .{ .header = "SDL/include/SDL3/SDL_gamepad.h", .output = "v2/gamepad.zig" }, - .{ .header = "SDL/include/SDL3/SDL_gpu.h", .output = "v2/gpu.zig" }, - .{ .header = "SDL/include/SDL3/SDL_guid.h", .output = "v2/guid.zig" }, - .{ .header = "SDL/include/SDL3/SDL_haptic.h", .output = "v2/haptic.zig" }, - // .{ .header = "SDL/include/SDL3/SDL_hidapi.h", .output = "v2/hidapi.zig" }, // Skipped: not core API - .{ .header = "SDL/include/SDL3/SDL_hints.h", .output = "v2/hints.zig" }, - .{ .header = "SDL/include/SDL3/SDL_init.h", .output = "v2/init.zig" }, - // .{ .header = "SDL/include/SDL3/SDL_iostream.h", .output = "v2/iostream.zig" }, // Skipped: complex I/O API - .{ .header = "SDL/include/SDL3/SDL_joystick.h", .output = "v2/joystick.zig" }, - .{ .header = "SDL/include/SDL3/SDL_keyboard.h", .output = "v2/keyboard.zig" }, - .{ .header = "SDL/include/SDL3/SDL_keycode.h", .output = "v2/keycode.zig" }, - .{ .header = "SDL/include/SDL3/SDL_loadso.h", .output = "v2/loadso.zig" }, - .{ .header = "SDL/include/SDL3/SDL_locale.h", .output = "v2/locale.zig" }, - .{ .header = "SDL/include/SDL3/SDL_log.h", .output = "v2/log.zig" }, - .{ .header = "SDL/include/SDL3/SDL_messagebox.h", .output = "v2/messagebox.zig" }, - .{ .header = "SDL/include/SDL3/SDL_metal.h", .output = "v2/metal.zig" }, - .{ .header = "SDL/include/SDL3/SDL_misc.h", .output = "v2/misc.zig" }, - .{ .header = "SDL/include/SDL3/SDL_mouse.h", .output = "v2/mouse.zig" }, - // .{ .header = "SDL/include/SDL3/SDL_mutex.h", .output = "v2/mutex.zig" }, // Skipped: not core API - .{ .header = "SDL/include/SDL3/SDL_opengl.h", .output = "v2/opengl.zig" }, - .{ .header = "SDL/include/SDL3/SDL_pen.h", .output = "v2/pen.zig" }, - .{ .header = "SDL/include/SDL3/SDL_pixels.h", .output = "v2/pixels.zig" }, - .{ .header = "SDL/include/SDL3/SDL_power.h", .output = "v2/power.zig" }, - .{ .header = "SDL/include/SDL3/SDL_process.h", .output = "v2/process.zig" }, - .{ .header = "SDL/include/SDL3/SDL_properties.h", .output = "v2/properties.zig" }, - .{ .header = "SDL/include/SDL3/SDL_rect.h", .output = "v2/rect.zig" }, - .{ .header = "SDL/include/SDL3/SDL_render.h", .output = "v2/render.zig" }, - .{ .header = "SDL/include/SDL3/SDL_scancode.h", .output = "v2/scancode.zig" }, - .{ .header = "SDL/include/SDL3/SDL_sensor.h", .output = "v2/sensor.zig" }, - .{ .header = "SDL/include/SDL3/SDL_storage.h", .output = "v2/storage.zig" }, - .{ .header = "SDL/include/SDL3/SDL_surface.h", .output = "v2/surface.zig" }, - .{ .header = "SDL/include/SDL3/SDL_system.h", .output = "v2/system.zig" }, - // .{ .header = "SDL/include/SDL3/SDL_thread.h", .output = "v2/thread.zig" }, // Skipped: not core API - .{ .header = "SDL/include/SDL3/SDL_time.h", .output = "v2/time.zig" }, - .{ .header = "SDL/include/SDL3/SDL_timer.h", .output = "v2/timer.zig" }, - .{ .header = "SDL/include/SDL3/SDL_touch.h", .output = "v2/touch.zig" }, - // .{ .header = "SDL/include/SDL3/SDL_tray.h", .output = "v2/tray.zig" }, // Skipped: not core API - .{ .header = "SDL/include/SDL3/SDL_version.h", .output = "v2/version.zig" }, - .{ .header = "SDL/include/SDL3/SDL_video.h", .output = "v2/video.zig" }, - // .{ .header = "SDL/include/SDL3/SDL_vulkan.h", .output = "v2/vulkan.zig" }, // Skipped: Vulkan interop + // .{ .header = "SDL/include/SDL3/SDL_asyncio.h", .output = "asyncio" }, + // .{ .header = "SDL/include/SDL3/SDL_atomic.h", .output = "atomic" }, + .{ .header = "SDL/include/SDL3/SDL_audio.h", .output = "audio" }, + .{ .header = "SDL/include/SDL3/SDL_blendmode.h", .output = "blendmode" }, + .{ .header = "SDL/include/SDL3/SDL_camera.h", .output = "camera" }, + .{ .header = "SDL/include/SDL3/SDL_clipboard.h", .output = "clipboard" }, + // .{ .header = "SDL/include/SDL3/SDL_cpuinfo.h", .output = "cpuinfo" }, + .{ .header = "SDL/include/SDL3/SDL_dialog.h", .output = "dialog" }, + .{ .header = "SDL/include/SDL3/SDL_endian.h", .output = "endian" }, + .{ .header = "SDL/include/SDL3/SDL_error.h", .output = "error" }, + // .{ .header = "SDL/include/SDL3/SDL_events.h", .output = "events" }, + .{ .header = "SDL/include/SDL3/SDL_filesystem.h", .output = "filesystem" }, + .{ .header = "SDL/include/SDL3/SDL_gamepad.h", .output = "gamepad" }, + .{ .header = "SDL/include/SDL3/SDL_gpu.h", .output = "gpu" }, + // .{ .header = "SDL/include/SDL3/SDL_guid.h", .output = "guid" }, + .{ .header = "SDL/include/SDL3/SDL_haptic.h", .output = "haptic" }, + // .{ .header = "SDL/include/SDL3/SDL_hidapi.h", .output = "hidapi" }, // Skipped: not core API + .{ .header = "SDL/include/SDL3/SDL_hints.h", .output = "hints" }, + .{ .header = "SDL/include/SDL3/SDL_init.h", .output = "init" }, + // .{ .header = "SDL/include/SDL3/SDL_iostream.h", .output = "iostream" }, // Skipped: complex I/O API + .{ .header = "SDL/include/SDL3/SDL_joystick.h", .output = "joystick" }, + // .{ .header = "SDL/include/SDL3/SDL_keyboard.h", .output = "keyboard" }, + .{ .header = "SDL/include/SDL3/SDL_keycode.h", .output = "keycode" }, + .{ .header = "SDL/include/SDL3/SDL_loadso.h", .output = "loadso" }, + // .{ .header = "SDL/include/SDL3/SDL_locale.h", .output = "locale" }, + // .{ .header = "SDL/include/SDL3/SDL_log.h", .output = "log" }, + .{ .header = "SDL/include/SDL3/SDL_messagebox.h", .output = "messagebox" }, + // .{ .header = "SDL/include/SDL3/SDL_metal.h", .output = "metal" }, + .{ .header = "SDL/include/SDL3/SDL_misc.h", .output = "misc" }, + .{ .header = "SDL/include/SDL3/SDL_mouse.h", .output = "mouse" }, + // .{ .header = "SDL/include/SDL3/SDL_mutex.h", .output = "mutex" }, // Skipped: not core API + // .{ .header = "SDL/include/SDL3/SDL_opengl.h", .output = "opengl" }, + // .{ .header = "SDL/include/SDL3/SDL_pen.h", .output = "pen" }, + .{ .header = "SDL/include/SDL3/SDL_pixels.h", .output = "pixels" }, + // .{ .header = "SDL/include/SDL3/SDL_power.h", .output = "power" }, + // .{ .header = "SDL/include/SDL3/SDL_process.h", .output = "process" }, + .{ .header = "SDL/include/SDL3/SDL_properties.h", .output = "properties" }, + .{ .header = "SDL/include/SDL3/SDL_rect.h", .output = "rect" }, + .{ .header = "SDL/include/SDL3/SDL_render.h", .output = "render" }, + // .{ .header = "SDL/include/SDL3/SDL_scancode.h", .output = "scancode" }, + .{ .header = "SDL/include/SDL3/SDL_sensor.h", .output = "sensor" }, + .{ .header = "SDL/include/SDL3/SDL_storage.h", .output = "storage" }, + .{ .header = "SDL/include/SDL3/SDL_surface.h", .output = "surface" }, + .{ .header = "SDL/include/SDL3/SDL_system.h", .output = "system" }, + // .{ .header = "SDL/include/SDL3/SDL_thread.h", .output = "thread" }, // Skipped: not core API + .{ .header = "SDL/include/SDL3/SDL_time.h", .output = "time" }, + .{ .header = "SDL/include/SDL3/SDL_timer.h", .output = "timer" }, + .{ .header = "SDL/include/SDL3/SDL_touch.h", .output = "touch" }, + // .{ .header = "SDL/include/SDL3/SDL_tray.h", .output = "tray" }, // Skipped: not core API + .{ .header = "SDL/include/SDL3/SDL_version.h", .output = "version" }, + .{ .header = "SDL/include/SDL3/SDL_video.h", .output = "video" }, + // .{ .header = "SDL/include/SDL3/SDL_vulkan.h", .output = "vulkan" }, // Skipped: Vulkan interop }; const regenerate_step = b.step("regenerate-zig", "Regenerate bindings from SDL headers"); - + for (headers_to_generate) |header_info| { const regenerate = b.addRunArtifact(parser_exe); regenerate.addFileArg(b.path(header_info.header)); - regenerate.addArg(b.fmt("--output={s}", .{header_info.output})); + regenerate.addArg(b.fmt("--output=v2/{s}.zig", .{header_info.output})); regenerate_step.dependOn(®enerate.step); + + const regenerateJson = b.addRunArtifact(parser_exe); + regenerateJson.addFileArg(b.path(header_info.header)); + regenerateJson.addArg(b.fmt("--generate-json=json/{s}.json", .{header_info.output})); + regenerate_step.dependOn(®enerateJson.step); } // Regenerate test mocks step - using SDL_gpu.h for comprehensive testing @@ -278,7 +283,7 @@ pub fn build(b: *std.Build) void { .root_source_file = b.path("parser/test/import_test.zig"), }), }); - + const run_import_test = b.addRunArtifact(import_test); const import_test_step = b.step("test-import-issue", "Test demonstrating missing dependency types"); import_test_step.dependOn(&run_import_test.step); diff --git a/lib/sdl3/json/audio.json b/lib/sdl3/json/audio.json new file mode 100644 index 0000000..69dbecd --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/blendmode.json b/lib/sdl3/json/blendmode.json new file mode 100644 index 0000000..61109ed --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/camera.json b/lib/sdl3/json/camera.json new file mode 100644 index 0000000..c225cca --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/clipboard.json b/lib/sdl3/json/clipboard.json new file mode 100644 index 0000000..8bb4c54 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/dialog.json b/lib/sdl3/json/dialog.json new file mode 100644 index 0000000..19d1205 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/endian.json b/lib/sdl3/json/endian.json new file mode 100644 index 0000000..aa539d1 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/error.json b/lib/sdl3/json/error.json new file mode 100644 index 0000000..65f3fad --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/filesystem.json b/lib/sdl3/json/filesystem.json new file mode 100644 index 0000000..b382839 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/gamepad.json b/lib/sdl3/json/gamepad.json new file mode 100644 index 0000000..c2d376a --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/gpu.json b/lib/sdl3/json/gpu.json new file mode 100644 index 0000000..6b4ff5d --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/haptic.json b/lib/sdl3/json/haptic.json new file mode 100644 index 0000000..3d404cc --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/hints.json b/lib/sdl3/json/hints.json new file mode 100644 index 0000000..8cbe45d --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/init.json b/lib/sdl3/json/init.json new file mode 100644 index 0000000..77e0a81 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/joystick.json b/lib/sdl3/json/joystick.json new file mode 100644 index 0000000..0182800 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/keycode.json b/lib/sdl3/json/keycode.json new file mode 100644 index 0000000..0be6af3 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/loadso.json b/lib/sdl3/json/loadso.json new file mode 100644 index 0000000..a8d639e --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/messagebox.json b/lib/sdl3/json/messagebox.json new file mode 100644 index 0000000..11650cd --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/misc.json b/lib/sdl3/json/misc.json new file mode 100644 index 0000000..0af9d7b --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/mouse.json b/lib/sdl3/json/mouse.json new file mode 100644 index 0000000..d6633ac --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/pixels.json b/lib/sdl3/json/pixels.json new file mode 100644 index 0000000..fcc710e --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/properties.json b/lib/sdl3/json/properties.json new file mode 100644 index 0000000..3ddd925 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/rect.json b/lib/sdl3/json/rect.json new file mode 100644 index 0000000..af56505 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/render.json b/lib/sdl3/json/render.json new file mode 100644 index 0000000..12e14e1 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/sensor.json b/lib/sdl3/json/sensor.json new file mode 100644 index 0000000..cd93b11 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/storage.json b/lib/sdl3/json/storage.json new file mode 100644 index 0000000..6b9b94b --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/surface.json b/lib/sdl3/json/surface.json new file mode 100644 index 0000000..979d740 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/system.json b/lib/sdl3/json/system.json new file mode 100644 index 0000000..c295bb8 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/time.json b/lib/sdl3/json/time.json new file mode 100644 index 0000000..fa8e422 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/timer.json b/lib/sdl3/json/timer.json new file mode 100644 index 0000000..09372ac --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/touch.json b/lib/sdl3/json/touch.json new file mode 100644 index 0000000..c44d327 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/version.json b/lib/sdl3/json/version.json new file mode 100644 index 0000000..8c0e3a7 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/json/video.json b/lib/sdl3/json/video.json new file mode 100644 index 0000000..f3cefb3 --- /dev/null +++ b/lib/sdl3/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/lib/sdl3/parser/docs/API_REFERENCE.md b/lib/sdl3/parser/docs/API_REFERENCE.md index e4ab859..cc2ae72 100644 --- a/lib/sdl3/parser/docs/API_REFERENCE.md +++ b/lib/sdl3/parser/docs/API_REFERENCE.md @@ -252,23 +252,6 @@ Analyzing dependencies... Generated: output.zig ``` -### With Warnings - -``` -Resolving dependencies... - ✓ Found SDL_Window in SDL_video.h - âš  Warning: Could not find definition for type: SDL_Unknown -``` - -### With Errors - -``` -Error: 5 syntax errors detected in generated code - Line 10: expected_comma_after_field - Line 12: expected_type_expr - ... -``` - File is still written, but may need manual fixes. ## Type Conversion Reference @@ -311,40 +294,8 @@ File is still written, but may need manual fixes. ## Examples -### Example 1: Simple Header -**Input** (simple.h): -```c -typedef struct SDL_Thing SDL_Thing; -typedef Uint32 SDL_ThingID; - -extern SDL_DECLSPEC SDL_ThingID SDLCALL SDL_CreateThing(void); -extern SDL_DECLSPEC void SDLCALL SDL_DestroyThing(SDL_Thing *thing); -``` - -**Command**: -```bash -zig build run -- simple.h --output=thing.zig -``` - -**Output** (thing.zig): -```zig -pub const c = @import("c.zig").c; - -pub const ThingID = u32; - -pub const Thing = opaque { - pub inline fn destroyThing(thing: *Thing) void { - return c.SDL_DestroyThing(thing); - } -}; - -pub inline fn createThing() ThingID { - return c.SDL_CreateThing(); -} -``` - -### Example 2: With Dependencies +### Example **Input** (depends.h): ```c @@ -375,7 +326,7 @@ pub inline fn useRect(rect: *Rect) void { } ``` -### Example 3: With Mocks +### Mocks example **Command**: ```bash @@ -395,65 +346,3 @@ void SDL_DestroyThing(SDL_Thing *thing) { } ``` -## Performance Characteristics - -### Timing - -| Operation | Time (SDL_gpu.h) | -|-----------|------------------| -| Parse primary header | ~50ms | -| Analyze dependencies | ~10ms | -| Extract dependencies | ~300ms | -| Generate code | ~150ms | -| **Total** | **~520ms** | - -### Memory - -| Component | Memory | -|-----------|--------| -| Source files | ~150KB | -| Declarations | ~2MB | -| Output | ~53KB | -| **Peak Total** | **~2.2MB** | - -### Scaling - -- **Time**: O(n + h×d) where n=lines, h=headers, d=declarations -- **Memory**: O(d) where d=total declarations -- **Linear scaling** with input size - -## Advanced Usage - -### Batch Processing - -```bash -for header in SDL/include/SDL3/SDL_*.h; do - name=$(basename "$header" .h) - zig build run -- "$header" --output="bindings/${name}.zig" -done -``` - -### CI/CD Integration - -```yaml -- name: Generate SDL bindings - run: | - cd lib/sdl3 - zig build regenerate-zig - git diff --exit-code v2/*.zig || echo "Bindings updated" -``` - -### Validation - -```bash -# Generate and validate -zig build run -- header.h --output=test.zig -zig ast-check test.zig -``` - ---- - -**See Also**: -- [Getting Started](GETTING_STARTED.md) - Basic usage tutorial -- [Architecture](ARCHITECTURE.md) - How it works internally -- [Known Issues](KNOWN_ISSUES.md) - Current limitations diff --git a/lib/sdl3/parser/src/codegen.zig b/lib/sdl3/parser/src/codegen.zig index b49d027..3448bd5 100644 --- a/lib/sdl3/parser/src/codegen.zig +++ b/lib/sdl3/parser/src/codegen.zig @@ -38,12 +38,12 @@ pub const CodeGen = struct { return try gen.output.toOwnedSlice(allocator); } - + fn categorizeDeclarations(self: *CodeGen) !void { // First, collect all opaque type names var opaque_names = std.ArrayList([]const u8){}; defer opaque_names.deinit(self.allocator); - + for (self.decls) |decl| { if (decl == .opaque_type) { const zig_name = naming.typeNameToZig(decl.opaque_type.name); @@ -52,7 +52,7 @@ pub const CodeGen = struct { try self.opaque_methods.put(zig_name, std.ArrayList(patterns.FunctionDecl){}); } } - + // Then, categorize functions for (self.decls) |decl| { if (decl == .function_decl) { @@ -61,14 +61,14 @@ pub const CodeGen = struct { // Check if first param is a pointer to an opaque type const first_param_type = try types.convertType(func.params[0].type_name, self.allocator); defer self.allocator.free(first_param_type); - + // Check if it's ?*TypeName or *TypeName for (opaque_names.items) |opaque_name| { const opt_ptr = try std.fmt.allocPrint(self.allocator, "?*{s}", .{opaque_name}); defer self.allocator.free(opt_ptr); const ptr = try std.fmt.allocPrint(self.allocator, "*{s}", .{opaque_name}); defer self.allocator.free(ptr); - + if (std.mem.eql(u8, first_param_type, opt_ptr) or std.mem.eql(u8, first_param_type, ptr)) { var methods = self.opaque_methods.getPtr(opaque_name).?; try methods.append(self.allocator, func); @@ -110,28 +110,28 @@ pub const CodeGen = struct { } } } - + fn isStandaloneFunction(self: *CodeGen, func: patterns.FunctionDecl) !bool { if (func.params.len == 0) return true; - + const first_param_type = try types.convertType(func.params[0].type_name, self.allocator); defer self.allocator.free(first_param_type); - + var it = self.opaque_methods.keyIterator(); while (it.next()) |opaque_name| { const opt_ptr = try std.fmt.allocPrint(self.allocator, "?*{s}", .{opaque_name.*}); defer self.allocator.free(opt_ptr); const ptr = try std.fmt.allocPrint(self.allocator, "*{s}", .{opaque_name.*}); defer self.allocator.free(ptr); - + if (std.mem.eql(u8, first_param_type, opt_ptr) or std.mem.eql(u8, first_param_type, ptr)) { return false; // It's a method } } - + return true; // It's standalone } - + fn writeOpaqueWithMethods(self: *CodeGen, opaque_type: OpaqueType) !void { const zig_name = naming.typeNameToZig(opaque_type.name); @@ -142,36 +142,36 @@ pub const CodeGen = struct { // Check if we have methods for this type const methods = self.opaque_methods.get(zig_name); - + if (methods) |method_list| { if (method_list.items.len > 0) { // pub const GPUDevice = opaque { try self.output.writer(self.allocator).print("pub const {s} = opaque {{\n", .{zig_name}); - + // Write methods for (method_list.items) |func| { try self.writeFunctionAsMethod(func, zig_name); } - + try self.output.appendSlice(self.allocator, "};\n\n"); return; } } - + // No methods, write as simple opaque try self.output.writer(self.allocator).print("pub const {s} = opaque {{}};\n\n", .{zig_name}); } - + fn writeTypedef(self: *CodeGen, typedef_decl: patterns.TypedefDecl) !void { // Write doc comment if present if (typedef_decl.doc_comment) |doc| { try self.writeDocComment(doc); } - + const zig_name = naming.typeNameToZig(typedef_decl.name); const zig_type = try types.convertType(typedef_decl.underlying_type, self.allocator); defer self.allocator.free(zig_type); - + try self.output.appendSlice(self.allocator, "pub const "); try self.output.appendSlice(self.allocator, zig_name); try self.output.appendSlice(self.allocator, " = "); @@ -184,29 +184,30 @@ pub const CodeGen = struct { if (func_ptr_decl.doc_comment) |doc| { try self.writeDocComment(doc); } - + const zig_name = naming.typeNameToZig(func_ptr_decl.name); const return_type = try types.convertType(func_ptr_decl.return_type, self.allocator); defer self.allocator.free(return_type); - + // Generate: pub const TimerCallback = *const fn(param1: Type1, ...) callconv(.C) RetType; try self.output.writer(self.allocator).print("pub const {s} = *const fn(", .{zig_name}); - + // Write parameters for (func_ptr_decl.params, 0..) |param, i| { if (i > 0) try self.output.appendSlice(self.allocator, ", "); - + const param_type = try types.convertType(param.type_name, self.allocator); defer self.allocator.free(param_type); - - try self.output.writer(self.allocator).print("{s}: {s}", .{param.name, param_type}); + + try self.output.writer(self.allocator).print("{s}: {s}", .{ param.name, param_type }); } - + // Close with calling convention and return type try self.output.writer(self.allocator).print(") callconv(.C) {s};\n\n", .{return_type}); } fn writeEnum(self: *CodeGen, enum_decl: EnumDecl) !void { + std.debug.print("enum {s} values.len = {d}\n", .{ enum_decl.name, enum_decl.values.len }); // Skip empty enums if (enum_decl.values.len == 0) { return; @@ -359,7 +360,7 @@ pub const CodeGen = struct { // Parse bit position from value like "(1u << 0)" const bit_pos = self.parseBitPosition(flag.value) catch |err| { // Skip flags we can't parse (like non-bitfield constants) - std.debug.print("Warning: Skipping flag {s} = {s} ({})\n", .{flag.name, flag.value, err}); + std.debug.print("Warning: Skipping flag {s} = {s} ({})\n", .{ flag.name, flag.value, err }); continue; }; used_bits.set(bit_pos); @@ -610,22 +611,22 @@ pub const CodeGen = struct { const hex_str = trimmed[2..]; const val = try std.fmt.parseInt(u64, hex_str, 16); // Find the bit position (count trailing zeros) - var bit: u7 = 0; // Use u7 to allow checking up to bit 63 + var bit: u7 = 0; // Use u7 to allow checking up to bit 63 while (bit < 64) : (bit += 1) { if (val == (@as(u64, 1) << @as(u6, @intCast(bit)))) return @intCast(bit); } } - + // Raw decimal value like "1" or "2" or "4" if (std.fmt.parseInt(u64, trimmed, 10)) |val| { // Find bit position for powers of 2 - if (val == 0) return 0; // Special case - - var bit: u7 = 0; // Use u7 to allow checking up to bit 63 + if (val == 0) return 0; // Special case + + var bit: u7 = 0; // Use u7 to allow checking up to bit 63 while (bit < 64) : (bit += 1) { if (val == (@as(u64, 1) << @as(u6, @intCast(bit)))) return @intCast(bit); } - + // Not a power of 2 - might be a simple constant (like button numbers) // Just skip this flag value by returning error return error.InvalidBitPosition; diff --git a/lib/sdl3/parser/src/parser.zig b/lib/sdl3/parser/src/parser.zig index 9992ff8..96bf77b 100644 --- a/lib/sdl3/parser/src/parser.zig +++ b/lib/sdl3/parser/src/parser.zig @@ -20,11 +20,11 @@ pub fn main() !void { } const header_path = args[1]; - + var output_file: ?[]const u8 = null; var mock_output_file: ?[]const u8 = null; var json_output_file: ?[]const u8 = null; - + // Parse additional flags for (args[2..]) |arg| { const output_prefix = "--output="; @@ -169,30 +169,30 @@ pub fn main() !void { // Generate JSON if requested if (json_output_file) |json_path| { std.debug.print("Generating JSON output...\n", .{}); - + var serializer = json_serializer.JsonSerializer.init(allocator, std.fs.path.basename(header_path)); - + try serializer.addDeclarations(decls); const json_output = try serializer.finalize(); // json_output is owned by serializer - + // Parse and re-format JSON with proper indentation const parsed = try std.json.parseFromSlice(std.json.Value, allocator, json_output, .{}); defer parsed.deinit(); - + var formatted_output = std.ArrayList(u8){}; defer formatted_output.deinit(allocator); - + const formatter = std.json.fmt(parsed.value, .{ .whitespace = .indent_2 }); try std.fmt.format(formatted_output.writer(allocator), "{f}", .{formatter}); - + try std.fs.cwd().writeFile(.{ .sub_path = json_path, .data = formatted_output.items, }); serializer.deinit(); std.debug.print("Generated JSON: {s}\n", .{json_path}); - + // If only JSON was requested, we're done if (output_file == null and mock_output_file == null) { return; @@ -203,21 +203,21 @@ pub fn main() !void { std.debug.print("Analyzing dependencies...\n", .{}); var resolver = dependency_resolver.DependencyResolver.init(allocator); defer resolver.deinit(); - + try resolver.analyze(decls); const missing_types = try resolver.getMissingTypes(allocator); defer { for (missing_types) |t| allocator.free(t); allocator.free(missing_types); } - + if (missing_types.len > 0) { std.debug.print("Found {d} missing types:\n", .{missing_types.len}); for (missing_types) |missing| { std.debug.print(" - {s}\n", .{missing}); } std.debug.print("\n", .{}); - + // Extract missing types from included headers std.debug.print("Resolving dependencies from included headers...\n", .{}); const includes = try dependency_resolver.parseIncludes(allocator, source); @@ -225,9 +225,9 @@ pub fn main() !void { for (includes) |inc| allocator.free(inc); allocator.free(includes); } - + const header_dir = std.fs.path.dirname(header_path) orelse "."; - + var dependency_decls = std.ArrayList(patterns.Declaration){}; defer { for (dependency_decls.items) |dep_decl| { @@ -235,64 +235,58 @@ pub fn main() !void { } dependency_decls.deinit(allocator); } - + for (missing_types) |missing_type| { var found = false; for (includes) |include| { - const dep_path = try std.fs.path.join( - allocator, - &[_][]const u8{ header_dir, include } - ); + const dep_path = try std.fs.path.join(allocator, &[_][]const u8{ header_dir, include }); defer allocator.free(dep_path); - - const dep_source = std.fs.cwd().readFileAlloc( - allocator, - dep_path, - 10 * 1024 * 1024 - ) catch continue; + + const dep_source = std.fs.cwd().readFileAlloc(allocator, dep_path, 10 * 1024 * 1024) catch continue; defer allocator.free(dep_source); - + if (try dependency_resolver.extractTypeFromHeader(allocator, dep_source, missing_type)) |dep_decl| { try dependency_decls.append(allocator, dep_decl); - std.debug.print(" ✓ Found {s} in {s}\n", .{missing_type, include}); + std.debug.print(" ✓ Found {s} in {s}\n", .{ missing_type, include }); found = true; break; } } - + if (!found) { std.debug.print(" âš  Warning: Could not find definition for type: {s}\n", .{missing_type}); } } - + // Combine declarations (dependencies first!) std.debug.print("\nCombining {d} dependency declarations with primary declarations...\n", .{dependency_decls.items.len}); - + var all_decls = std.ArrayList(patterns.Declaration){}; defer all_decls.deinit(allocator); - + try all_decls.appendSlice(allocator, dependency_decls.items); try all_decls.appendSlice(allocator, decls); - + // Generate code with all declarations const output = try codegen.CodeGen.generate(allocator, all_decls.items); defer allocator.free(output); - + // Parse and format the AST for validation const output_z = try allocator.dupeZ(u8, output); defer allocator.free(output_z); - + var ast = try std.zig.Ast.parse(allocator, output_z, .zig); defer ast.deinit(allocator); - + // Check for parse errors if (ast.errors.len > 0) { + std.debug.print("{s}", .{output_z}); std.debug.print("\nError: {d} syntax errors detected in generated code\n", .{ast.errors.len}); for (ast.errors) |err| { const loc = ast.tokenLocation(0, err.token); std.debug.print(" Line {d}: {s}\n", .{ loc.line + 1, @tagName(err.tag) }); } - + // Write unformatted output for debugging if (output_file) |file_path| { try std.fs.cwd().writeFile(.{ @@ -301,10 +295,10 @@ pub fn main() !void { }); std.debug.print("\nGenerated (with errors): {s}\n", .{file_path}); } - + return error.InvalidSyntax; } - + // Render formatted output from AST const formatted_output = try ast.renderAlloc(allocator); defer allocator.free(formatted_output); @@ -319,13 +313,13 @@ pub fn main() !void { } else { _ = try std.posix.write(std.posix.STDOUT_FILENO, formatted_output); } - + // Generate C mocks if requested (with all declarations) if (mock_output_file) |mock_path| { const mock_codegen = @import("mock_codegen.zig"); const mock_output = try mock_codegen.MockCodeGen.generate(allocator, all_decls.items); defer allocator.free(mock_output); - + try std.fs.cwd().writeFile(.{ .sub_path = mock_path, .data = mock_output, @@ -334,18 +328,18 @@ pub fn main() !void { } } else { std.debug.print("No missing dependencies found!\n\n", .{}); - + // Generate code without dependencies const output = try codegen.CodeGen.generate(allocator, decls); defer allocator.free(output); - + // Parse and format the AST for validation const output_z = try allocator.dupeZ(u8, output); defer allocator.free(output_z); - + var ast = try std.zig.Ast.parse(allocator, output_z, .zig); defer ast.deinit(allocator); - + // Check for parse errors if (ast.errors.len > 0) { std.debug.print("\nError: {d} syntax errors detected in generated code\n", .{ast.errors.len}); @@ -353,7 +347,7 @@ pub fn main() !void { const loc = ast.tokenLocation(0, err.token); std.debug.print(" Line {d}: {s}\n", .{ loc.line + 1, @tagName(err.tag) }); } - + // Write unformatted output for debugging if (output_file) |file_path| { try std.fs.cwd().writeFile(.{ @@ -362,10 +356,10 @@ pub fn main() !void { }); std.debug.print("\nGenerated (with errors): {s}\n", .{file_path}); } - + return error.InvalidSyntax; } - + // Render formatted output from AST const formatted_output = try ast.renderAlloc(allocator); defer allocator.free(formatted_output); @@ -380,13 +374,13 @@ pub fn main() !void { } else { _ = try std.posix.write(std.posix.STDOUT_FILENO, formatted_output); } - + // Generate C mocks if requested if (mock_output_file) |mock_path| { const mock_codegen = @import("mock_codegen.zig"); const mock_output = try mock_codegen.MockCodeGen.generate(allocator, decls); defer allocator.free(mock_output); - + try std.fs.cwd().writeFile(.{ .sub_path = mock_path, .data = mock_output, diff --git a/lib/sdl3/parser/src/patterns.zig b/lib/sdl3/parser/src/patterns.zig index 0dfc222..420e095 100644 --- a/lib/sdl3/parser/src/patterns.zig +++ b/lib/sdl3/parser/src/patterns.zig @@ -1,6 +1,15 @@ const std = @import("std"); const Allocator = std.mem.Allocator; +fn fixupZigName(name: []const u8) []u8 { + const allocator = std.heap.smp_allocator; + if (std.mem.eql(u8, name, "type")) { + return allocator.dupe(u8, "_type") catch unreachable; + } + + return allocator.dupe(u8, name) catch unreachable; +} + // Simple data structures to hold extracted declarations pub const Declaration = union(enum) { opaque_type: OpaqueType, @@ -175,17 +184,17 @@ pub const Scanner = struct { // Or accept mismatched names as long as we have a semicolon (e.g., typedef struct tagMSG MSG;) // But reject pointer typedefs (e.g., typedef struct X *Y;) - those should be handled by scanTypedef const name2_clean = std.mem.trimRight(u8, name2, ";"); - + // Check if it's a pointer typedef - if either name starts with *, reject it if (std.mem.startsWith(u8, name1, "*") or std.mem.startsWith(u8, name2_clean, "*")) { self.pos = start; return null; } - + const use_name = if (std.mem.eql(u8, name1, name2_clean)) - name1 // Names match, use either + name1 // Names match, use either else if (std.mem.endsWith(u8, name2, ";")) - name2_clean // Names don't match but it's a valid forward declaration, use second name + name2_clean // Names don't match but it's a valid forward declaration, use second name else { // Not a valid opaque typedef self.pos = start; @@ -207,47 +216,47 @@ pub const Scanner = struct { .doc_comment = doc, }; } - + // Pattern: typedef RetType (SDLCALL *FuncName)(Param1Type param1, ...); fn scanFunctionPointer(self: *Scanner) !?FunctionPointerDecl { const start = self.pos; - + const line = try self.readLine(); defer self.allocator.free(line); - + // Must start with typedef if (!std.mem.startsWith(u8, line, "typedef ")) { self.pos = start; return null; } - + // Must contain * pattern with SDL prefix (function pointer typedef) // Pattern: typedef RetType (SDLCALL *SDL_Name)(Params); - const has_sdl_ptr = std.mem.indexOf(u8, line, " *SDL_") != null or - std.mem.indexOf(u8, line, "(*SDL_") != null; + const has_sdl_ptr = std.mem.indexOf(u8, line, " *SDL_") != null or + std.mem.indexOf(u8, line, "(*SDL_") != null; if (!has_sdl_ptr) { self.pos = start; return null; } - + // Parse: typedef RetType (SDLCALL *FuncName)(Params); const trimmed = std.mem.trim(u8, line, " \t\r\n"); const no_semi = std.mem.trimRight(u8, trimmed, ";"); - + // Skip "typedef " const after_typedef = std.mem.trimLeft(u8, no_semi["typedef ".len..], " \t"); - + // Find the *SDL_ marker (function pointer name) - const ptr_marker = std.mem.indexOf(u8, after_typedef, " *SDL_") orelse - std.mem.indexOf(u8, after_typedef, "(*SDL_") orelse { + const ptr_marker = std.mem.indexOf(u8, after_typedef, " *SDL_") orelse + std.mem.indexOf(u8, after_typedef, "(*SDL_") orelse { self.pos = start; return null; }; - + // Return type is everything before the pointer marker // It may include (SDLCALL or just be the plain type const return_type_section = std.mem.trim(u8, after_typedef[0..ptr_marker], " \t"); - + // Extract return type (remove SDLCALL if present) const return_type = if (std.mem.indexOf(u8, return_type_section, "(SDLCALL")) |sdlcall_pos| std.mem.trim(u8, return_type_section[0..sdlcall_pos], " \t") @@ -255,7 +264,7 @@ pub const Scanner = struct { std.mem.trim(u8, return_type_section[0..sdlcall_pos], " \t") else return_type_section; - + // Find function name: starts after *SDL_ and ends at ) const after_star = std.mem.trimLeft(u8, after_typedef[ptr_marker..], " *("); const name_end = std.mem.indexOfScalar(u8, after_star, ')') orelse { @@ -263,9 +272,9 @@ pub const Scanner = struct { return null; }; const func_name = std.mem.trim(u8, after_star[0..name_end], " \t"); - + // Find parameters (between the closing ) of name and final ) - const after_name = after_star[name_end + 1..]; // Skip ) + const after_name = after_star[name_end + 1 ..]; // Skip ) const params_start = std.mem.indexOfScalar(u8, after_name, '(') orelse { self.pos = start; return null; @@ -274,12 +283,12 @@ pub const Scanner = struct { self.pos = start; return null; }; - const params_str = std.mem.trim(u8, after_name[params_start + 1..params_end], " \t"); - + const params_str = std.mem.trim(u8, after_name[params_start + 1 .. params_end], " \t"); + // Parse parameters const params = try self.parseParams(params_str); const doc = self.consumePendingDocComment(); - + return FunctionPointerDecl{ .name = try self.allocator.dupe(u8, func_name), .return_type = try self.allocator.dupe(u8, return_type), @@ -287,26 +296,26 @@ pub const Scanner = struct { .doc_comment = doc, }; } - + // Pattern: typedef Type SDL_Name; fn scanTypedef(self: *Scanner) !?TypedefDecl { const start = self.pos; - + const line = try self.readLine(); defer self.allocator.free(line); - + // Check if it matches: typedef ; if (!std.mem.startsWith(u8, line, "typedef ")) { self.pos = start; return null; } - + // Skip lines with braces (those are struct/enum typedefs, handled elsewhere) if (std.mem.indexOf(u8, line, "{") != null) { self.pos = start; return null; } - + // Skip lines with "struct" or "enum" keywords UNLESS it's a pointer typedef like: // typedef struct X *Y; const has_struct_or_enum = std.mem.indexOf(u8, line, "struct ") != null or std.mem.indexOf(u8, line, "enum ") != null; @@ -321,21 +330,21 @@ pub const Scanner = struct { } // It's a pointer typedef like "typedef struct X *Y", continue parsing } - + // Skip function pointer typedefs (contain parentheses) if (std.mem.indexOf(u8, line, "(") != null) { self.pos = start; return null; } - + // Parse: typedef Type Name; or typedef struct X *Name; const trimmed = std.mem.trim(u8, line, " \t\r\n"); const no_semi = std.mem.trimRight(u8, trimmed, ";"); - + // Find the last token as the name var tokens = std.mem.tokenizeScalar(u8, no_semi, ' '); _ = tokens.next(); // Skip "typedef" - + // Collect all remaining tokens var token_list = std.ArrayList([]const u8).initCapacity(self.allocator, 4) catch { self.pos = start; @@ -345,12 +354,12 @@ pub const Scanner = struct { while (tokens.next()) |token| { try token_list.append(self.allocator, token); } - + if (token_list.items.len < 2) { self.pos = start; return null; } - + // Last token is the name (may have * prefix for pointer typedefs) var name_raw = token_list.items[token_list.items.len - 1]; // Strip leading * if present and track it @@ -359,7 +368,7 @@ pub const Scanner = struct { name_raw[1..] else name_raw; - + // Everything before the name is the underlying type // For "struct XTaskQueueObject *XTaskQueueHandle", we want "struct XTaskQueueObject *" var type_buf = std.ArrayList(u8).initCapacity(self.allocator, 64) catch { @@ -367,7 +376,7 @@ pub const Scanner = struct { return null; }; defer type_buf.deinit(self.allocator); - for (token_list.items[0..token_list.items.len - 1], 0..) |token, i| { + for (token_list.items[0 .. token_list.items.len - 1], 0..) |token, i| { if (i > 0) try type_buf.append(self.allocator, ' '); try type_buf.appendSlice(self.allocator, token); } @@ -377,16 +386,17 @@ pub const Scanner = struct { try type_buf.append(self.allocator, '*'); } const underlying_type = try type_buf.toOwnedSlice(self.allocator); - + // Make sure it's an SDL type or one of the known Windows types - if (!std.mem.startsWith(u8, name, "SDL_") and - !std.mem.eql(u8, name, "XTaskQueueHandle") and - !std.mem.eql(u8, name, "XUserHandle")) { + if (!std.mem.startsWith(u8, name, "SDL_") and + !std.mem.eql(u8, name, "XTaskQueueHandle") and + !std.mem.eql(u8, name, "XUserHandle")) + { self.allocator.free(underlying_type); self.pos = start; return null; } - + return TypedefDecl{ .name = try self.allocator.dupe(u8, name), .underlying_type = try self.allocator.dupe(u8, underlying_type), @@ -394,6 +404,16 @@ pub const Scanner = struct { }; } + fn countChar(need: u8, haystack: []const u8) u32 { + var i: u32 = 0; + for (haystack) |h| { + if (h == need) { + i += 1; + } + } + return i; + } + // Pattern: typedef enum SDL_Foo { ... } SDL_Foo; fn scanEnum(self: *Scanner) !?EnumDecl { const start = self.pos; @@ -442,25 +462,46 @@ pub const Scanner = struct { } seen_names.deinit(); } - + var lines = std.mem.splitScalar(u8, body, '\n'); var in_multiline_comment = false; - + while (lines.next()) |line| { - const trimmed = std.mem.trim(u8, line, " \t\r"); + var trimmed = std.mem.trim(u8, line, " \t\r"); if (trimmed.len == 0) continue; - + + if (in_multiline_comment) { + if (std.mem.indexOf(u8, trimmed, "*/")) |x| { + in_multiline_comment = false; + if (trimmed.len == 2) + continue; + trimmed = trimmed[x + 2 ..]; + } + } + // Track multi-line comments (both /** and /* styles) if (std.mem.indexOf(u8, trimmed, "/*")) |_| { in_multiline_comment = true; } + if (in_multiline_comment) { if (std.mem.indexOf(u8, trimmed, "*/")) |_| { in_multiline_comment = false; } - continue; } - + if (std.mem.indexOf(u8, trimmed, "/*")) |x| { + if (x == 0) { + continue; + } + } + + // special case for those weirder multiline comments + if (std.mem.indexOf(u8, trimmed, "/*") == null and std.mem.indexOf(u8, trimmed, "*/") == null) { + if (countChar(' ', trimmed) > 0) { + continue; + } + } + // Skip various comment/bracket/preprocessor lines if (std.mem.startsWith(u8, trimmed, "//")) continue; if (std.mem.startsWith(u8, trimmed, "*")) continue; // Lines inside comments @@ -528,7 +569,7 @@ pub const Scanner = struct { } return EnumValue{ - .name = try self.allocator.dupe(u8, name), + .name = fixupZigName(name), .value = value, .comment = comment, }; @@ -577,10 +618,10 @@ pub const Scanner = struct { var fields = try std.ArrayList(FieldDecl).initCapacity(self.allocator, 20); var lines = std.mem.splitScalar(u8, body, '\n'); var in_multiline_comment = false; - + while (lines.next()) |line| { const trimmed = std.mem.trim(u8, line, " \t\r"); - + // Track multi-line comments (both /** and /*) // Only start tracking if /* appears without */ on the same line if (!in_multiline_comment) { @@ -603,13 +644,13 @@ pub const Scanner = struct { } continue; } - + // Skip comment/bracket/preprocessor lines if (trimmed.len == 0) continue; if (std.mem.startsWith(u8, trimmed, "//")) continue; if (std.mem.startsWith(u8, trimmed, "*")) continue; if (std.mem.startsWith(u8, trimmed, "#")) continue; - + // First try single-field parsing if (try self.parseStructField(line)) |field| { try fields.append(self.allocator, field); @@ -676,10 +717,10 @@ pub const Scanner = struct { var fields = try std.ArrayList(FieldDecl).initCapacity(self.allocator, 20); var lines = std.mem.splitScalar(u8, body, '\n'); var in_multiline_comment = false; - + while (lines.next()) |line| { const trimmed = std.mem.trim(u8, line, " \t\r"); - + // Track multi-line comments (both /** and /*) // Only start tracking if /* appears without */ on the same line if (!in_multiline_comment) { @@ -702,13 +743,13 @@ pub const Scanner = struct { } continue; } - + // Skip comment/bracket/preprocessor lines if (trimmed.len == 0) continue; if (std.mem.startsWith(u8, trimmed, "//")) continue; if (std.mem.startsWith(u8, trimmed, "*")) continue; if (std.mem.startsWith(u8, trimmed, "#")) continue; - + // Reuse struct field parsing since unions have same field syntax if (try self.parseStructField(line)) |field| { try fields.append(self.allocator, field); @@ -746,7 +787,7 @@ pub const Scanner = struct { // Extract inline comment var comment: ?[]const u8 = null; errdefer if (comment) |c| self.allocator.free(c); - + var field_part = no_semi; if (std.mem.indexOf(u8, no_semi, "/**<")) |comment_start| { field_part = std.mem.trimRight(u8, no_semi[0..comment_start], "; \t"); @@ -759,26 +800,26 @@ pub const Scanner = struct { // Check for function pointer field: RetType (SDLCALL *field_name)(params) if (std.mem.indexOf(u8, field_part, "(SDLCALL *")) |sdlcall_pos| { // Find the * after SDLCALL - const after_sdlcall = field_part[sdlcall_pos + 10..]; // Skip "(SDLCALL *" + const after_sdlcall = field_part[sdlcall_pos + 10 ..]; // Skip "(SDLCALL *" if (std.mem.indexOf(u8, after_sdlcall, ")")) |close_paren| { const field_name = std.mem.trim(u8, after_sdlcall[0..close_paren], " \t"); - + // The entire thing is the type (we'll convert to Zig function pointer syntax later) return FieldDecl{ - .name = try self.allocator.dupe(u8, field_name), + .name = fixupZigName(field_name), .type_name = try self.allocator.dupe(u8, std.mem.trim(u8, field_part, " \t")), .comment = comment, }; } } else if (std.mem.indexOf(u8, field_part, "(*")) |star_pos| { // Handle non-SDLCALL function pointers: RetType (*field_name)(params) - const after_star = field_part[star_pos + 2..]; // Skip "(*" + const after_star = field_part[star_pos + 2 ..]; // Skip "(*" if (std.mem.indexOf(u8, after_star, ")")) |close_paren| { const field_name = std.mem.trim(u8, after_star[0..close_paren], " \t"); - + // The entire thing is the type (we'll convert to Zig function pointer syntax later) return FieldDecl{ - .name = try self.allocator.dupe(u8, field_name), + .name = fixupZigName(field_name), .type_name = try self.allocator.dupe(u8, std.mem.trim(u8, field_part, " \t")), .comment = comment, }; @@ -788,12 +829,12 @@ pub const Scanner = struct { // Check if this line contains multiple comma-separated fields (e.g., "int x, y;") // Only split on commas that are not inside nested structures (ignore for now) const field_trimmed = std.mem.trim(u8, field_part, " \t"); - + // Simple heuristic: if there's a comma and no parentheses/brackets, it's multi-field const has_comma = std.mem.indexOf(u8, field_trimmed, ",") != null; const has_parens = std.mem.indexOf(u8, field_trimmed, "(") != null; const has_brackets = std.mem.indexOf(u8, field_trimmed, "[") != null; - + if (has_comma and !has_parens and !has_brackets) { // This is a multi-field declaration like "int x, y" // We'll return just the first field and rely on a helper to get the rest @@ -801,20 +842,20 @@ pub const Scanner = struct { if (comment) |c| self.allocator.free(c); return null; } - + // Parse "type name" or "type name[size]" - handle pointer types and arrays correctly // Examples: - // "SDL_GPUTransferBuffer *transfer_buffer" -> type:"SDL_GPUTransferBuffer *" name:"transfer_buffer" + // "SDL_GPUTransferBuffer *transfer_buffer" -> type:"SDL_GPUTransferBuffer *" name:"transfer_buffer" // "Uint32 offset" -> type:"Uint32" name:"offset" // "Uint8 padding[2]" -> type:"Uint8[2]" name:"padding" - + // Check if this is an array field (has brackets) if (std.mem.indexOf(u8, field_trimmed, "[")) |bracket_pos| { // Extract array size and append to type // Pattern: "Uint8 padding[2]" -> parse as type="Uint8[2]" name="padding" const before_bracket = std.mem.trimRight(u8, field_trimmed[0..bracket_pos], " \t"); const bracket_part = field_trimmed[bracket_pos..]; // "[2]" - + // Split before_bracket into type and name var tokens = std.mem.tokenizeScalar(u8, before_bracket, ' '); var parts_list: [8][]const u8 = undefined; @@ -829,15 +870,15 @@ pub const Scanner = struct { parts_count += 1; } } - + if (parts_count < 2) { if (comment) |c| self.allocator.free(c); return null; // Need at least type and name } - + const name = parts_list[parts_count - 1]; - const type_parts = parts_list[0..parts_count - 1]; - + const type_parts = parts_list[0 .. parts_count - 1]; + // Reconstruct type with array notation var type_buf: [128]u8 = undefined; var fbs = std.io.fixedBufferStream(&type_buf); @@ -856,21 +897,21 @@ pub const Scanner = struct { if (comment) |c| self.allocator.free(c); return null; }; - + const type_str = fbs.getWritten(); - + return FieldDecl{ - .name = try self.allocator.dupe(u8, name), + .name = fixupZigName(name), .type_name = try self.allocator.dupe(u8, type_str), .comment = comment, }; } - + // Find last identifier by scanning backwards for alphanumeric/_ // The field name is the last contiguous sequence of [a-zA-Z0-9_] var name_end: usize = field_trimmed.len; var name_start: ?usize = null; - + // Scan backwards to find the end of the last identifier (skip trailing whitespace) while (name_end > 0) { const c = field_trimmed[name_end - 1]; @@ -879,7 +920,7 @@ pub const Scanner = struct { } name_end -= 1; } - + // Now scan backwards from name_end to find where the identifier starts if (name_end > 0) { var i: usize = name_end; @@ -896,14 +937,14 @@ pub const Scanner = struct { name_start = 0; } } - + if (name_start) |start| { const name = field_trimmed[start..name_end]; const type_part = std.mem.trim(u8, field_trimmed[0..start], " \t"); if (name.len > 0 and type_part.len > 0) { return FieldDecl{ - .name = try self.allocator.dupe(u8, name), + .name = fixupZigName(name), .type_name = try self.allocator.dupe(u8, type_part), .comment = comment, }; @@ -913,7 +954,7 @@ pub const Scanner = struct { if (comment) |c| self.allocator.free(c); return null; } - + // Parse multi-field declaration like "int x, y;" into separate fields fn parseMultiFieldLine(self: *Scanner, line: []const u8) ![]FieldDecl { const trimmed = std.mem.trim(u8, line, " \t\r"); @@ -922,10 +963,10 @@ pub const Scanner = struct { if (std.mem.startsWith(u8, trimmed, "/*")) return &[_]FieldDecl{}; if (std.mem.startsWith(u8, trimmed, "{")) return &[_]FieldDecl{}; if (std.mem.startsWith(u8, trimmed, "}")) return &[_]FieldDecl{}; - + // Remove trailing semicolon const no_semi = std.mem.trimRight(u8, trimmed, ";"); - + // Extract inline comment if present var comment: ?[]const u8 = null; var field_part = no_semi; @@ -937,19 +978,19 @@ pub const Scanner = struct { } } defer if (comment) |c| self.allocator.free(c); - + const field_trimmed = std.mem.trim(u8, field_part, " \t"); - + // Check if this is actually a multi-field line const has_comma = std.mem.indexOf(u8, field_trimmed, ",") != null; if (!has_comma) { return &[_]FieldDecl{}; } - + // Parse pattern: "type name1, name2, name3" // Find where the type ends (last space before first comma) const first_comma = std.mem.indexOf(u8, field_trimmed, ",") orelse return &[_]FieldDecl{}; - + // Everything before the first field name is the type // Scan backwards from first comma to find where the first name starts var type_end: usize = first_comma; @@ -960,30 +1001,30 @@ pub const Scanner = struct { } type_end -= 1; } - + // Type is everything from start to type_end const type_part = std.mem.trim(u8, field_trimmed[0..type_end], " \t"); - + if (type_part.len == 0) { return &[_]FieldDecl{}; } - + // Now parse the comma-separated field names const names_part = field_trimmed[type_end..]; var field_list = std.ArrayList(FieldDecl){}; - + var name_iter = std.mem.splitScalar(u8, names_part, ','); while (name_iter.next()) |name_raw| { const name = std.mem.trim(u8, name_raw, " \t*"); if (name.len > 0) { try field_list.append(self.allocator, FieldDecl{ - .name = try self.allocator.dupe(u8, name), + .name = fixupZigName(name), .type_name = try self.allocator.dupe(u8, type_part), .comment = if (comment) |c| try self.allocator.dupe(u8, c) else null, }); } } - + return try field_list.toOwnedSlice(self.allocator); } @@ -1044,7 +1085,7 @@ pub const Scanner = struct { const doc = self.consumePendingDocComment(); return FlagDecl{ - .name = try self.allocator.dupe(u8, clean_name), + .name = fixupZigName(clean_name), .underlying_type = try self.allocator.dupe(u8, underlying), .flags = try flags.toOwnedSlice(self.allocator), .doc_comment = doc, @@ -1111,7 +1152,7 @@ pub const Scanner = struct { // Parse: ReturnType SDLCALL FunctionName(params); const doc = self.consumePendingDocComment(); var text = func_text.items; - + // Strip format string attribute macros const macros_to_strip = [_][]const u8{ "SDL_PRINTF_FORMAT_STRING ", @@ -1125,14 +1166,14 @@ pub const Scanner = struct { const after = text[pos + macro.len ..]; const new_text = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{ before, after }); defer self.allocator.free(new_text); - + // Replace func_text content func_text.clearRetainingCapacity(); try func_text.appendSlice(self.allocator, new_text); text = func_text.items; } } - + // Strip vararg function macros from end (e.g., SDL_PRINTF_VARARG_FUNC(1)) const vararg_macros = [_][]const u8{ "SDL_PRINTF_VARARG_FUNC", @@ -1155,7 +1196,7 @@ pub const Scanner = struct { const after = text[paren_pos + 1 ..]; const new_text = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{ before, after }); defer self.allocator.free(new_text); - + func_text.clearRetainingCapacity(); try func_text.appendSlice(self.allocator, new_text); text = func_text.items; @@ -1210,7 +1251,7 @@ pub const Scanner = struct { // Handle array syntax like "char *argv[]" -> type:"char **" name:"argv" var working_param = trimmed; var is_array = false; - + // Check for array brackets [] and remove them if (std.mem.lastIndexOfScalar(u8, working_param, '[')) |bracket_pos| { // Find matching ] @@ -1219,13 +1260,13 @@ pub const Scanner = struct { working_param = std.mem.trimRight(u8, working_param[0..bracket_pos], " \t"); } } - + // Find the parameter name - it's the last identifier that's not a keyword // Start from the end and find the last word that's not 'const' or 'restrict' var name_start: usize = 0; var i = working_param.len; var found_name = false; - + // First, find the last identifier while (i > 0 and !found_name) { i -= 1; @@ -1243,7 +1284,7 @@ pub const Scanner = struct { } } } - + if (!found_name and working_param.len > 0) { // If we never found a separator, the whole thing might be the name // Check if it's not a type keyword @@ -1261,7 +1302,7 @@ pub const Scanner = struct { } else { var param_type = std.mem.trim(u8, working_param[0..name_start], " \t"); var param_name = std.mem.trim(u8, working_param[name_start..], " \t"); - + // If param_name starts with *, it belongs to the type // e.g., "SDL_GPUFence *const" and "*fences" should be "SDL_GPUFence *const *" and "fences" var type_buf: [512]u8 = undefined; @@ -1270,7 +1311,7 @@ pub const Scanner = struct { param_type = new_type; param_name = std.mem.trimLeft(u8, param_name[1..], " \t"); } - + // If this was an array parameter, convert pointer level // e.g., "char *" becomes "[*c][*c]char" for argv[] if (is_array) { @@ -1291,7 +1332,7 @@ pub const Scanner = struct { } try params_list.append(self.allocator, ParamDecl{ - .name = try self.allocator.dupe(u8, param_name), + .name = fixupZigName(param_name), .type_name = try self.allocator.dupe(u8, param_type), }); } diff --git a/lib/sdl3/v2/assert.zig b/lib/sdl3/v2/assert.zig deleted file mode 100644 index 25a0fdb..0000000 --- a/lib/sdl3/v2/assert.zig +++ /dev/null @@ -1,37 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const AssertData = extern struct { - always_ignore: bool, // true if app should always continue when assertion is triggered. - trigger_count: unsigned int, // Number of times this assertion has been triggered. - condition: [*c]const u8, // A string of this assert's test code. - filename: [*c]const u8, // The source file where this assert lives. - linenum: c_int, // The line in `filename` where this assert lives. - function: [*c]const u8, // The name of the function where this assert lives. - next: const struct SDL_AssertData *, // next item in the linked list. -}; - -pub inline fn reportAssertion(data: ?*AssertData, func: [*c]const u8, file: [*c]const u8, line: c_int) AssertState { - return c.SDL_ReportAssertion(data, func, file, line); -} - -pub inline fn setAssertionHandler(handler: AssertionHandler, userdata: ?*anyopaque) void { - return c.SDL_SetAssertionHandler(handler, userdata); -} - -pub inline fn getDefaultAssertionHandler() AssertionHandler { - return c.SDL_GetDefaultAssertionHandler(); -} - -pub inline fn getAssertionHandler(puserdata: [*c]?*anyopaque) AssertionHandler { - return c.SDL_GetAssertionHandler(puserdata); -} - -pub inline fn getAssertionReport() *const AssertData { - return @ptrCast(c.SDL_GetAssertionReport()); -} - -pub inline fn resetAssertionReport() void { - return c.SDL_ResetAssertionReport(); -} - diff --git a/lib/sdl3/v2/asyncio.zig b/lib/sdl3/v2/asyncio.zig deleted file mode 100644 index d00b817..0000000 --- a/lib/sdl3/v2/asyncio.zig +++ /dev/null @@ -1,61 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const AsyncIO = opaque { - pub inline fn getAsyncIOSize(asyncio: *AsyncIO) i64 { - return c.SDL_GetAsyncIOSize(asyncio); - } - - pub inline fn readAsyncIO(asyncio: *AsyncIO, ptr: ?*anyopaque, offset: u64, size: u64, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool { - return c.SDL_ReadAsyncIO(asyncio, ptr, offset, size, queue, userdata); - } - - pub inline fn writeAsyncIO(asyncio: *AsyncIO, ptr: ?*anyopaque, offset: u64, size: u64, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool { - return c.SDL_WriteAsyncIO(asyncio, ptr, offset, size, queue, userdata); - } - - pub inline fn closeAsyncIO(asyncio: *AsyncIO, flush: bool, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool { - return c.SDL_CloseAsyncIO(asyncio, flush, queue, userdata); - } -}; - -pub const AsyncIOOutcome = extern struct { - asyncio: ?*AsyncIO, // what generated this task. This pointer will be invalid if it was closed! - type: AsyncIOTaskType, // What sort of task was this? Read, write, etc? - result: AsyncIOResult, // the result of the work (success, failure, cancellation). - buffer: ?*anyopaque, // buffer where data was read/written. - offset: u64, // offset in the SDL_AsyncIO where data was read/written. - bytes_requested: u64, // number of bytes the task was to read/write. - bytes_transferred: u64, // actual number of bytes that were read/written. - userdata: ?*anyopaque, // pointer provided by the app when starting the task -}; - -pub const AsyncIOQueue = opaque { - pub inline fn destroyAsyncIOQueue(asyncioqueue: *AsyncIOQueue) void { - return c.SDL_DestroyAsyncIOQueue(asyncioqueue); - } - - pub inline fn getAsyncIOResult(asyncioqueue: *AsyncIOQueue, outcome: ?*AsyncIOOutcome) bool { - return c.SDL_GetAsyncIOResult(asyncioqueue, outcome); - } - - pub inline fn waitAsyncIOResult(asyncioqueue: *AsyncIOQueue, outcome: ?*AsyncIOOutcome, timeoutMS: i32) bool { - return c.SDL_WaitAsyncIOResult(asyncioqueue, outcome, timeoutMS); - } - - pub inline fn signalAsyncIOQueue(asyncioqueue: *AsyncIOQueue) void { - return c.SDL_SignalAsyncIOQueue(asyncioqueue); - } -}; - -pub inline fn asyncIOFromFile(file: [*c]const u8, mode: [*c]const u8) ?*AsyncIO { - return c.SDL_AsyncIOFromFile(file, mode); -} - -pub inline fn createAsyncIOQueue() ?*AsyncIOQueue { - return c.SDL_CreateAsyncIOQueue(); -} - -pub inline fn loadFileAsync(file: [*c]const u8, queue: ?*AsyncIOQueue, userdata: ?*anyopaque) bool { - return c.SDL_LoadFileAsync(file, queue, userdata); -} diff --git a/lib/sdl3/v2/atomic.zig b/lib/sdl3/v2/atomic.zig deleted file mode 100644 index fb91f6c..0000000 --- a/lib/sdl3/v2/atomic.zig +++ /dev/null @@ -1,70 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const SpinLock = c_int; - -pub inline fn tryLockSpinlock(lock: ?*SpinLock) bool { - return c.SDL_TryLockSpinlock(lock); -} - -pub inline fn lockSpinlock(lock: ?*SpinLock) void { - return c.SDL_LockSpinlock(lock); -} - -pub inline fn unlockSpinlock(lock: ?*SpinLock) void { - return c.SDL_UnlockSpinlock(lock); -} - -pub inline fn memoryBarrierReleaseFunction() void { - return c.SDL_MemoryBarrierReleaseFunction(); -} - -pub inline fn memoryBarrierAcquireFunction() void { - return c.SDL_MemoryBarrierAcquireFunction(); -} - -pub const KernelMemoryBarrierFunc = *const fn () callconv(.C) void; - -pub const AtomicInt = extern struct {}; - -pub inline fn compareAndSwapAtomicInt(a: ?*AtomicInt, oldval: c_int, newval: c_int) bool { - return c.SDL_CompareAndSwapAtomicInt(a, oldval, newval); -} - -pub inline fn setAtomicInt(a: ?*AtomicInt, v: c_int) c_int { - return c.SDL_SetAtomicInt(a, v); -} - -pub inline fn getAtomicInt(a: ?*AtomicInt) c_int { - return c.SDL_GetAtomicInt(a); -} - -pub inline fn addAtomicInt(a: ?*AtomicInt, v: c_int) c_int { - return c.SDL_AddAtomicInt(a, v); -} - -pub const AtomicU32 = extern struct {}; - -pub inline fn compareAndSwapAtomicU32(a: ?*AtomicU32, oldval: u32, newval: u32) bool { - return c.SDL_CompareAndSwapAtomicU32(a, oldval, newval); -} - -pub inline fn setAtomicU32(a: ?*AtomicU32, v: u32) u32 { - return c.SDL_SetAtomicU32(a, v); -} - -pub inline fn getAtomicU32(a: ?*AtomicU32) u32 { - return c.SDL_GetAtomicU32(a); -} - -pub inline fn compareAndSwapAtomicPointer(a: [*c]?*anyopaque, oldval: ?*anyopaque, newval: ?*anyopaque) bool { - return c.SDL_CompareAndSwapAtomicPointer(a, oldval, newval); -} - -pub inline fn setAtomicPointer(a: [*c]?*anyopaque, v: ?*anyopaque) ?*anyopaque { - return c.SDL_SetAtomicPointer(a, v); -} - -pub inline fn getAtomicPointer(a: [*c]?*anyopaque) ?*anyopaque { - return c.SDL_GetAtomicPointer(a); -} diff --git a/lib/sdl3/v2/audio.zig b/lib/sdl3/v2/audio.zig index 89d92a0..460a299 100644 --- a/lib/sdl3/v2/audio.zig +++ b/lib/sdl3/v2/audio.zig @@ -10,9 +10,15 @@ pub const IOStream = opaque { }; pub const AudioFormat = enum(c_int) { - audioS16, - audioS32, - audioF32, + 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; diff --git a/lib/sdl3/v2/blendmode.zig b/lib/sdl3/v2/blendmode.zig index 6e18d90..b2a88d3 100644 --- a/lib/sdl3/v2/blendmode.zig +++ b/lib/sdl3/v2/blendmode.zig @@ -3,6 +3,27 @@ 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/lib/sdl3/v2/camera.zig b/lib/sdl3/v2/camera.zig index 0db398f..38d2192 100644 --- a/lib/sdl3/v2/camera.zig +++ b/lib/sdl3/v2/camera.zig @@ -2,75 +2,47 @@ const std = @import("std"); pub const c = @import("c.zig").c; pub const PixelFormat = enum(c_int) { - pixelformatUnknown, - pixelformatIndex1lsb, - pixelformatIndex1msb, - pixelformatIndex2lsb, - pixelformatIndex2msb, - pixelformatIndex4lsb, - pixelformatIndex4msb, - pixelformatIndex8, - pixelformatRgb332, - pixelformatXrgb4444, - pixelformatXbgr4444, - pixelformatXrgb1555, - pixelformatXbgr1555, - pixelformatArgb4444, - pixelformatRgba4444, - pixelformatAbgr4444, - pixelformatBgra4444, - pixelformatArgb1555, - pixelformatRgba5551, - pixelformatAbgr1555, - pixelformatBgra5551, - pixelformatRgb565, - pixelformatBgr565, - pixelformatRgb24, - pixelformatBgr24, - pixelformatXrgb8888, - pixelformatRgbx8888, - pixelformatXbgr8888, - pixelformatBgrx8888, - pixelformatArgb8888, - pixelformatRgba8888, - pixelformatAbgr8888, - pixelformatBgra8888, - pixelformatXrgb2101010, - pixelformatXbgr2101010, - pixelformatArgb2101010, - pixelformatAbgr2101010, - pixelformatRgb48, - pixelformatBgr48, - pixelformatRgba64, - pixelformatArgb64, - pixelformatBgra64, - pixelformatAbgr64, - pixelformatRgb48Float, - pixelformatBgr48Float, - pixelformatRgba64Float, - pixelformatArgb64Float, - pixelformatBgra64Float, - pixelformatAbgr64Float, - pixelformatRgb96Float, - pixelformatBgr96Float, - pixelformatRgba128Float, - pixelformatArgb128Float, - pixelformatBgra128Float, - pixelformatAbgr128Float, - pixelformatRgba32, - pixelformatArgb32, - pixelformatBgra32, - pixelformatAbgr32, - pixelformatRgbx32, - pixelformatXrgb32, - pixelformatBgrx32, - pixelformatXbgr32, + 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) { - colorspaceUnknown, + 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; diff --git a/lib/sdl3/v2/cpuinfo.zig b/lib/sdl3/v2/cpuinfo.zig deleted file mode 100644 index bdca40f..0000000 --- a/lib/sdl3/v2/cpuinfo.zig +++ /dev/null @@ -1,74 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub inline fn getNumLogicalCPUCores() c_int { - return c.SDL_GetNumLogicalCPUCores(); -} - -pub inline fn getCPUCacheLineSize() c_int { - return c.SDL_GetCPUCacheLineSize(); -} - -pub inline fn hasAltiVec() bool { - return c.SDL_HasAltiVec(); -} - -pub inline fn hasMMX() bool { - return c.SDL_HasMMX(); -} - -pub inline fn hasSSE() bool { - return c.SDL_HasSSE(); -} - -pub inline fn hasSSE2() bool { - return c.SDL_HasSSE2(); -} - -pub inline fn hasSSE3() bool { - return c.SDL_HasSSE3(); -} - -pub inline fn hasSSE41() bool { - return c.SDL_HasSSE41(); -} - -pub inline fn hasSSE42() bool { - return c.SDL_HasSSE42(); -} - -pub inline fn hasAVX() bool { - return c.SDL_HasAVX(); -} - -pub inline fn hasAVX2() bool { - return c.SDL_HasAVX2(); -} - -pub inline fn hasAVX512F() bool { - return c.SDL_HasAVX512F(); -} - -pub inline fn hasARMSIMD() bool { - return c.SDL_HasARMSIMD(); -} - -pub inline fn hasNEON() bool { - return c.SDL_HasNEON(); -} - -pub inline fn hasLSX() bool { - return c.SDL_HasLSX(); -} - -pub inline fn hasLASX() bool { - return c.SDL_HasLASX(); -} - -pub inline fn getSystemRAM() c_int { - return c.SDL_GetSystemRAM(); -} - -pub inline fn getSIMDAlignment() usize { - return c.SDL_GetSIMDAlignment(); -} diff --git a/lib/sdl3/v2/dialog.zig b/lib/sdl3/v2/dialog.zig index 0632313..9ea659b 100644 --- a/lib/sdl3/v2/dialog.zig +++ b/lib/sdl3/v2/dialog.zig @@ -30,6 +30,6 @@ pub const FileDialogType = enum(c_int) { filedialogOpenfolder, }; -pub inline fn showFileDialogWithProperties(type: FileDialogType, callback: DialogFileCallback, userdata: ?*anyopaque, props: PropertiesID) void { - return c.SDL_ShowFileDialogWithProperties(@intFromEnum(type), callback, userdata, props); +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/lib/sdl3/v2/events.zig b/lib/sdl3/v2/events.zig deleted file mode 100644 index d235fd3..0000000 --- a/lib/sdl3/v2/events.zig +++ /dev/null @@ -1,752 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const PenID = u32; - -pub const WindowID = u32; - -pub const AudioDeviceID = u32; - -pub const DisplayID = u32; - -pub const CameraID = u32; - -pub const PenInputFlags = packed struct(u32) { - penInputDown: bool = false, // pen is pressed down - penInputButton1: bool = false, // button 1 is pressed - penInputButton2: bool = false, // button 2 is pressed - penInputButton3: bool = false, // button 3 is pressed - penInputButton4: bool = false, // button 4 is pressed - penInputButton5: bool = false, // button 5 is pressed - penInputEraserTip: bool = false, // eraser tip is used - pad0: u24 = 0, - rsvd: bool = false, -}; - -pub const MouseButtonFlags = packed struct(u32) { - buttonLeft: bool = false, - buttonMiddle: bool = false, - buttonX1: bool = false, - pad0: u28 = 0, - rsvd: bool = false, -}; - -pub const Scancode = enum(c_int) { - scancodeUnknown, - scancodeA, - scancodeB, - scancodeC, - scancodeD, - scancodeE, - scancodeF, - scancodeG, - scancodeH, - scancodeI, - scancodeJ, - scancodeK, - scancodeL, - scancodeM, - scancodeN, - scancodeO, - scancodeP, - scancodeQ, - scancodeR, - scancodeS, - scancodeT, - scancodeU, - scancodeV, - scancodeW, - scancodeX, - scancodeY, - scancodeZ, - scancode1, - scancode2, - scancode3, - scancode4, - scancode5, - scancode6, - scancode7, - scancode8, - scancode9, - scancode0, - scancodeReturn, - scancodeEscape, - scancodeBackspace, - scancodeTab, - scancodeSpace, - scancodeMinus, - scancodeEquals, - scancodeLeftbracket, - scancodeRightbracket, - scancodeSemicolon, - scancodeApostrophe, - scancodeComma, - scancodePeriod, - scancodeSlash, - scancodeCapslock, - scancodeF1, - scancodeF2, - scancodeF3, - scancodeF4, - scancodeF5, - scancodeF6, - scancodeF7, - scancodeF8, - scancodeF9, - scancodeF10, - scancodeF11, - scancodeF12, - scancodePrintscreen, - scancodeScrolllock, - scancodePause, - scancodeHome, - scancodePageup, - scancodeDelete, - scancodeEnd, - scancodePagedown, - scancodeRight, - scancodeLeft, - scancodeDown, - scancodeUp, - scancodeKpDivide, - scancodeKpMultiply, - scancodeKpMinus, - scancodeKpPlus, - scancodeKpEnter, - scancodeKp1, - scancodeKp2, - scancodeKp3, - scancodeKp4, - scancodeKp5, - scancodeKp6, - scancodeKp7, - scancodeKp8, - scancodeKp9, - scancodeKp0, - scancodeKpPeriod, - scancodeKpEquals, - scancodeF13, - scancodeF14, - scancodeF15, - scancodeF16, - scancodeF17, - scancodeF18, - scancodeF19, - scancodeF20, - scancodeF21, - scancodeF22, - scancodeF23, - scancodeF24, - scancodeExecute, - scancodeSelect, - scancodeMute, - scancodeVolumeup, - scancodeVolumedown, - scancodeKpComma, - scancodeKpEqualsas400, - scancodeInternational2, - scancodeInternational4, - scancodeInternational5, - scancodeInternational6, - scancodeInternational7, - scancodeInternational8, - scancodeInternational9, - scancodeSysreq, - scancodeClear, - scancodePrior, - scancodeReturn2, - scancodeSeparator, - scancodeOut, - scancodeOper, - scancodeClearagain, - scancodeCrsel, - scancodeExsel, - scancodeKp00, - scancodeKp000, - scancodeThousandsseparator, - scancodeDecimalseparator, - scancodeCurrencyunit, - scancodeCurrencysubunit, - scancodeKpLeftparen, - scancodeKpRightparen, - scancodeKpLeftbrace, - scancodeKpRightbrace, - scancodeKpTab, - scancodeKpBackspace, - scancodeKpA, - scancodeKpB, - scancodeKpC, - scancodeKpD, - scancodeKpE, - scancodeKpF, - scancodeKpXor, - scancodeKpPower, - scancodeKpPercent, - scancodeKpLess, - scancodeKpGreater, - scancodeKpAmpersand, - scancodeKpDblampersand, - scancodeKpVerticalbar, - scancodeKpDblverticalbar, - scancodeKpColon, - scancodeKpHash, - scancodeKpSpace, - scancodeKpAt, - scancodeKpExclam, - scancodeKpMemstore, - scancodeKpMemrecall, - scancodeKpMemclear, - scancodeKpMemadd, - scancodeKpMemsubtract, - scancodeKpMemmultiply, - scancodeKpMemdivide, - scancodeKpPlusminus, - scancodeKpClear, - scancodeKpClearentry, - scancodeKpBinary, - scancodeKpOctal, - scancodeKpDecimal, - scancodeKpHexadecimal, - scancodeLctrl, - scancodeLshift, - scancodeRctrl, - scancodeRshift, -}; - -pub const TouchID = u64; - -pub const KeyboardID = u32; - -pub const MouseID = u32; - -pub const Window = opaque {}; - -pub const FingerID = u64; - -pub const Keycode = u32; - -pub const SensorID = u32; - -pub const JoystickID = u32; - -pub const Keymod = u16; - -pub const EventType = enum(c_int) { - eventDisplayFirst, - eventDisplayLast, - eventWindowFirst, - eventWindowLast, - eventFingerDown, - eventFingerUp, - eventFingerMotion, - eventFingerCanceled, - eventPrivate0, - eventPrivate1, - eventPrivate2, - eventPrivate3, - eventUser, - eventLast, - eventEnumPadding, -}; - -pub const CommonEvent = extern struct { - type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() -}; - -pub const DisplayEvent = extern struct { - type: EventType, // SDL_DISPLAYEVENT_* - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - displayID: DisplayID, // The associated display - data1: i32, // event dependent data - data2: i32, // event dependent data -}; - -pub const WindowEvent = extern struct { - type: EventType, // SDL_EVENT_WINDOW_* - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The associated window - data1: i32, // event dependent data - data2: i32, // event dependent data -}; - -pub const KeyboardDeviceEvent = extern struct { - type: EventType, // SDL_EVENT_KEYBOARD_ADDED or SDL_EVENT_KEYBOARD_REMOVED - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: KeyboardID, // The keyboard instance id -}; - -pub const KeyboardEvent = extern struct { - type: EventType, // SDL_EVENT_KEY_DOWN or SDL_EVENT_KEY_UP - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with keyboard focus, if any - which: KeyboardID, // The keyboard instance id, or 0 if unknown or virtual - scancode: Scancode, // SDL physical key code - key: Keycode, // SDL virtual key code - mod: Keymod, // current key modifiers - raw: u16, // The platform dependent scancode for this event - down: bool, // true if the key is pressed - repeat: bool, // true if this is a key repeat -}; - -pub const TextEditingEvent = extern struct { - type: EventType, // SDL_EVENT_TEXT_EDITING - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with keyboard focus, if any - text: [*c]const u8, // The editing text - start: i32, // The start cursor of selected editing text, or -1 if not set - length: i32, // The length of selected editing text, or -1 if not set -}; - -pub const TextEditingCandidatesEvent = extern struct { - type: EventType, // SDL_EVENT_TEXT_EDITING_CANDIDATES - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with keyboard focus, if any - candidates: [*c]const [*c]const u8, // The list of candidates, or NULL if there are no candidates available - num_candidates: i32, // The number of strings in `candidates` - selected_candidate: i32, // The index of the selected candidate, or -1 if no candidate is selected - horizontal: bool, // true if the list is horizontal, false if it's vertical - padding1: u8, - padding2: u8, - padding3: u8, -}; - -pub const TextInputEvent = extern struct { - type: EventType, // SDL_EVENT_TEXT_INPUT - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with keyboard focus, if any - text: [*c]const u8, // The input text, UTF-8 encoded -}; - -pub const MouseDeviceEvent = extern struct { - type: EventType, // SDL_EVENT_MOUSE_ADDED or SDL_EVENT_MOUSE_REMOVED - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: MouseID, // The mouse instance id -}; - -pub const MouseMotionEvent = extern struct { - type: EventType, // SDL_EVENT_MOUSE_MOTION - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with mouse focus, if any - which: MouseID, // The mouse instance id in relative mode, SDL_TOUCH_MOUSEID for touch events, or 0 - state: MouseButtonFlags, // The current button state - x: f32, // X coordinate, relative to window - y: f32, // Y coordinate, relative to window - xrel: f32, // The relative motion in the X direction - yrel: f32, // The relative motion in the Y direction -}; - -pub const MouseButtonEvent = extern struct { - type: EventType, // SDL_EVENT_MOUSE_BUTTON_DOWN or SDL_EVENT_MOUSE_BUTTON_UP - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with mouse focus, if any - which: MouseID, // The mouse instance id in relative mode, SDL_TOUCH_MOUSEID for touch events, or 0 - button: u8, // The mouse button index - down: bool, // true if the button is pressed - clicks: u8, // 1 for single-click, 2 for double-click, etc. - padding: u8, - x: f32, // X coordinate, relative to window - y: f32, // Y coordinate, relative to window -}; - -pub const MouseWheelEvent = extern struct { - type: EventType, // SDL_EVENT_MOUSE_WHEEL - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with mouse focus, if any - which: MouseID, // The mouse instance id in relative mode or 0 - x: f32, // The amount scrolled horizontally, positive to the right and negative to the left - y: f32, // The amount scrolled vertically, positive away from the user and negative toward the user - direction: MouseWheelDirection, // Set to one of the SDL_MOUSEWHEEL_* defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back - mouse_x: f32, // X coordinate, relative to window - mouse_y: f32, // Y coordinate, relative to window -}; - -pub const JoyAxisEvent = extern struct { - type: EventType, // SDL_EVENT_JOYSTICK_AXIS_MOTION - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - axis: u8, // The joystick axis index - padding1: u8, - padding2: u8, - padding3: u8, - value: i16, // The axis value (range: -32768 to 32767) - padding4: u16, -}; - -pub const JoyBallEvent = extern struct { - type: EventType, // SDL_EVENT_JOYSTICK_BALL_MOTION - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - ball: u8, // The joystick trackball index - padding1: u8, - padding2: u8, - padding3: u8, - xrel: i16, // The relative motion in the X direction - yrel: i16, // The relative motion in the Y direction -}; - -pub const JoyHatEvent = extern struct { - type: EventType, // SDL_EVENT_JOYSTICK_HAT_MOTION - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - hat: u8, // The joystick hat index - padding1: u8, - padding2: u8, -}; - -pub const JoyButtonEvent = extern struct { - type: EventType, // SDL_EVENT_JOYSTICK_BUTTON_DOWN or SDL_EVENT_JOYSTICK_BUTTON_UP - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - button: u8, // The joystick button index - down: bool, // true if the button is pressed - padding1: u8, - padding2: u8, -}; - -pub const JoyDeviceEvent = extern struct { - type: EventType, // SDL_EVENT_JOYSTICK_ADDED or SDL_EVENT_JOYSTICK_REMOVED or SDL_EVENT_JOYSTICK_UPDATE_COMPLETE - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id -}; - -pub const JoyBatteryEvent = extern struct { - type: EventType, // SDL_EVENT_JOYSTICK_BATTERY_UPDATED - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - state: PowerState, // The joystick battery state - percent: c_int, // The joystick battery percent charge remaining -}; - -pub const GamepadAxisEvent = extern struct { - type: EventType, // SDL_EVENT_GAMEPAD_AXIS_MOTION - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - axis: u8, // The gamepad axis (SDL_GamepadAxis) - padding1: u8, - padding2: u8, - padding3: u8, - value: i16, // The axis value (range: -32768 to 32767) - padding4: u16, -}; - -pub const GamepadButtonEvent = extern struct { - type: EventType, // SDL_EVENT_GAMEPAD_BUTTON_DOWN or SDL_EVENT_GAMEPAD_BUTTON_UP - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - button: u8, // The gamepad button (SDL_GamepadButton) - down: bool, // true if the button is pressed - padding1: u8, - padding2: u8, -}; - -pub const GamepadDeviceEvent = extern struct { - type: EventType, // SDL_EVENT_GAMEPAD_ADDED, SDL_EVENT_GAMEPAD_REMOVED, or SDL_EVENT_GAMEPAD_REMAPPED, SDL_EVENT_GAMEPAD_UPDATE_COMPLETE or SDL_EVENT_GAMEPAD_STEAM_HANDLE_UPDATED - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id -}; - -pub const GamepadTouchpadEvent = extern struct { - type: EventType, // SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN or SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION or SDL_EVENT_GAMEPAD_TOUCHPAD_UP - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - touchpad: i32, // The index of the touchpad - finger: i32, // The index of the finger on the touchpad - x: f32, // Normalized in the range 0...1 with 0 being on the left - y: f32, // Normalized in the range 0...1 with 0 being at the top - pressure: f32, // Normalized in the range 0...1 -}; - -pub const GamepadSensorEvent = extern struct { - type: EventType, // SDL_EVENT_GAMEPAD_SENSOR_UPDATE - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: JoystickID, // The joystick instance id - sensor: i32, // The type of the sensor, one of the values of SDL_SensorType - data: [3]f32, // Up to 3 values from the sensor, as defined in SDL_sensor.h - sensor_timestamp: u64, // The timestamp of the sensor reading in nanoseconds, not necessarily synchronized with the system clock -}; - -pub const AudioDeviceEvent = extern struct { - type: EventType, // SDL_EVENT_AUDIO_DEVICE_ADDED, or SDL_EVENT_AUDIO_DEVICE_REMOVED, or SDL_EVENT_AUDIO_DEVICE_FORMAT_CHANGED - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: AudioDeviceID, // SDL_AudioDeviceID for the device being added or removed or changing - recording: bool, // false if a playback device, true if a recording device. - padding1: u8, - padding2: u8, - padding3: u8, -}; - -pub const CameraDeviceEvent = extern struct { - type: EventType, // SDL_EVENT_CAMERA_DEVICE_ADDED, SDL_EVENT_CAMERA_DEVICE_REMOVED, SDL_EVENT_CAMERA_DEVICE_APPROVED, SDL_EVENT_CAMERA_DEVICE_DENIED - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: CameraID, // SDL_CameraID for the device being added or removed or changing -}; - -pub const RenderEvent = extern struct { - type: EventType, // SDL_EVENT_RENDER_TARGETS_RESET, SDL_EVENT_RENDER_DEVICE_RESET, SDL_EVENT_RENDER_DEVICE_LOST - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window containing the renderer in question. -}; - -pub const TouchFingerEvent = extern struct { - type: EventType, // SDL_EVENT_FINGER_DOWN, SDL_EVENT_FINGER_UP, SDL_EVENT_FINGER_MOTION, or SDL_EVENT_FINGER_CANCELED - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - touchID: TouchID, // The touch device id - fingerID: FingerID, - x: f32, // Normalized in the range 0...1 - y: f32, // Normalized in the range 0...1 - dx: f32, // Normalized in the range -1...1 - dy: f32, // Normalized in the range -1...1 - pressure: f32, // Normalized in the range 0...1 - windowID: WindowID, // The window underneath the finger, if any -}; - -pub const PenProximityEvent = extern struct { - type: EventType, // SDL_EVENT_PEN_PROXIMITY_IN or SDL_EVENT_PEN_PROXIMITY_OUT - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with pen focus, if any - which: PenID, // The pen instance id -}; - -pub const PenMotionEvent = extern struct { - type: EventType, // SDL_EVENT_PEN_MOTION - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with pen focus, if any - which: PenID, // The pen instance id - pen_state: PenInputFlags, // Complete pen input state at time of event - x: f32, // X coordinate, relative to window - y: f32, // Y coordinate, relative to window -}; - -pub const PenTouchEvent = extern struct { - type: EventType, // SDL_EVENT_PEN_DOWN or SDL_EVENT_PEN_UP - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with pen focus, if any - which: PenID, // The pen instance id - pen_state: PenInputFlags, // Complete pen input state at time of event - x: f32, // X coordinate, relative to window - y: f32, // Y coordinate, relative to window - eraser: bool, // true if eraser end is used (not all pens support this). - down: bool, // true if the pen is touching or false if the pen is lifted off -}; - -pub const PenButtonEvent = extern struct { - type: EventType, // SDL_EVENT_PEN_BUTTON_DOWN or SDL_EVENT_PEN_BUTTON_UP - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with mouse focus, if any - which: PenID, // The pen instance id - pen_state: PenInputFlags, // Complete pen input state at time of event - x: f32, // X coordinate, relative to window - y: f32, // Y coordinate, relative to window - button: u8, // The pen button index (first button is 1). - down: bool, // true if the button is pressed -}; - -pub const PenAxisEvent = extern struct { - type: EventType, // SDL_EVENT_PEN_AXIS - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window with pen focus, if any - which: PenID, // The pen instance id - pen_state: PenInputFlags, // Complete pen input state at time of event - x: f32, // X coordinate, relative to window - y: f32, // Y coordinate, relative to window - axis: PenAxis, // Axis that has changed - value: f32, // New value of axis -}; - -pub const DropEvent = extern struct { - type: EventType, // SDL_EVENT_DROP_BEGIN or SDL_EVENT_DROP_FILE or SDL_EVENT_DROP_TEXT or SDL_EVENT_DROP_COMPLETE or SDL_EVENT_DROP_POSITION - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The window that was dropped on, if any - x: f32, // X coordinate, relative to window (not on begin) - y: f32, // Y coordinate, relative to window (not on begin) - source: [*c]const u8, // The source app that sent this drop event, or NULL if that isn't available - data: [*c]const u8, // The text for SDL_EVENT_DROP_TEXT and the file name for SDL_EVENT_DROP_FILE, NULL for other events -}; - -pub const ClipboardEvent = extern struct { - type: EventType, // SDL_EVENT_CLIPBOARD_UPDATE - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - owner: bool, // are we owning the clipboard (internal update) - num_mime_types: i32, // number of mime types - mime_types: [*c][*c]const u8, // current mime types -}; - -pub const SensorEvent = extern struct { - type: EventType, // SDL_EVENT_SENSOR_UPDATE - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - which: SensorID, // The instance ID of the sensor - data: [6]f32, // Up to 6 values from the sensor - additional values can be queried using SDL_GetSensorData() - sensor_timestamp: u64, // The timestamp of the sensor reading in nanoseconds, not necessarily synchronized with the system clock -}; - -pub const QuitEvent = extern struct { - type: EventType, // SDL_EVENT_QUIT - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() -}; - -pub const UserEvent = extern struct { - type: u32, // SDL_EVENT_USER through SDL_EVENT_LAST-1, Uint32 because these are not in the SDL_EventType enumeration - reserved: u32, - timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() - windowID: WindowID, // The associated window if any - code: i32, // User defined event code - data1: ?*anyopaque, // User defined data pointer - data2: ?*anyopaque, // User defined data pointer -}; - -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 inline fn pumpEvents() void { - return c.SDL_PumpEvents(); -} - -pub inline fn peepEvents(events: ?*Event, numevents: c_int, action: EventAction, minType: u32, maxType: u32) c_int { - return c.SDL_PeepEvents(events, numevents, action, minType, maxType); -} - -pub inline fn hasEvent(type: u32) bool { - return c.SDL_HasEvent(type); -} - -pub inline fn hasEvents(minType: u32, maxType: u32) bool { - return c.SDL_HasEvents(minType, maxType); -} - -pub inline fn flushEvent(type: u32) void { - return c.SDL_FlushEvent(type); -} - -pub inline fn flushEvents(minType: u32, maxType: u32) void { - return c.SDL_FlushEvents(minType, maxType); -} - -pub inline fn pollEvent(event: ?*Event) bool { - return c.SDL_PollEvent(event); -} - -pub inline fn waitEvent(event: ?*Event) bool { - return c.SDL_WaitEvent(event); -} - -pub inline fn waitEventTimeout(event: ?*Event, timeoutMS: i32) bool { - return c.SDL_WaitEventTimeout(event, timeoutMS); -} - -pub inline fn pushEvent(event: ?*Event) bool { - return c.SDL_PushEvent(event); -} - -pub const EventFilter = *const fn (userdata: ?*anyopaque, event: ?*Event) callconv(.C) bool; - -pub inline fn setEventFilter(filter: EventFilter, userdata: ?*anyopaque) void { - return c.SDL_SetEventFilter(filter, userdata); -} - -pub inline fn getEventFilter(filter: ?*EventFilter, userdata: [*c]?*anyopaque) bool { - return c.SDL_GetEventFilter(filter, userdata); -} - -pub inline fn addEventWatch(filter: EventFilter, userdata: ?*anyopaque) bool { - return c.SDL_AddEventWatch(filter, userdata); -} - -pub inline fn removeEventWatch(filter: EventFilter, userdata: ?*anyopaque) void { - return c.SDL_RemoveEventWatch(filter, userdata); -} - -pub inline fn filterEvents(filter: EventFilter, userdata: ?*anyopaque) void { - return c.SDL_FilterEvents(filter, userdata); -} - -pub inline fn setEventEnabled(type: u32, enabled: bool) void { - return c.SDL_SetEventEnabled(type, enabled); -} - -pub inline fn eventEnabled(type: u32) bool { - return c.SDL_EventEnabled(type); -} - -pub inline fn registerEvents(numevents: c_int) u32 { - return c.SDL_RegisterEvents(numevents); -} - -pub inline fn getWindowFromEvent(event: *const Event) ?*Window { - return c.SDL_GetWindowFromEvent(@ptrCast(event)); -} diff --git a/lib/sdl3/v2/filesystem.zig b/lib/sdl3/v2/filesystem.zig index 9c71def..ed0e731 100644 --- a/lib/sdl3/v2/filesystem.zig +++ b/lib/sdl3/v2/filesystem.zig @@ -11,12 +11,34 @@ 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 + _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 @@ -33,6 +55,12 @@ 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 { diff --git a/lib/sdl3/v2/gamepad.zig b/lib/sdl3/v2/gamepad.zig index 332e6b1..91b8750 100644 --- a/lib/sdl3/v2/gamepad.zig +++ b/lib/sdl3/v2/gamepad.zig @@ -2,7 +2,6 @@ const std = @import("std"); pub const c = @import("c.zig").c; pub const JoystickConnectionState = enum(c_int) { - joystickConnectionInvalid, joystickConnectionUnknown, joystickConnectionWired, joystickConnectionWireless, @@ -22,6 +21,26 @@ pub const IOStream = opaque { 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 { @@ -137,24 +156,24 @@ pub const Gamepad = opaque { 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 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 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 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 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 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 { @@ -187,7 +206,6 @@ pub const Gamepad = opaque { }; pub const GamepadType = enum(c_int) { - gamepadTypeUnknown, gamepadTypeStandard, gamepadTypeXbox360, gamepadTypeXboxone, @@ -202,7 +220,10 @@ pub const GamepadType = enum(c_int) { }; pub const GamepadButton = enum(c_int) { - gamepadButtonInvalid, + 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, @@ -214,6 +235,17 @@ pub const GamepadButton = enum(c_int) { 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, }; @@ -230,7 +262,6 @@ pub const GamepadButtonLabel = enum(c_int) { }; pub const GamepadAxis = enum(c_int) { - gamepadAxisInvalid, gamepadAxisLeftx, gamepadAxisLefty, gamepadAxisRightx, @@ -241,7 +272,6 @@ pub const GamepadAxis = enum(c_int) { }; pub const GamepadBindingType = enum(c_int) { - gamepadBindtypeNone, gamepadBindtypeButton, gamepadBindtypeAxis, gamepadBindtypeHat, @@ -366,8 +396,8 @@ 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 getGamepadStringForType(_type: GamepadType) [*c]const u8 { + return c.SDL_GetGamepadStringForType(@intFromEnum(_type)); } pub inline fn getGamepadAxisFromString(str: [*c]const u8) GamepadAxis { @@ -386,6 +416,6 @@ 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); +pub inline fn getGamepadButtonLabelForType(_type: GamepadType, button: GamepadButton) GamepadButtonLabel { + return c.SDL_GetGamepadButtonLabelForType(@intFromEnum(_type), button); } diff --git a/lib/sdl3/v2/gpu.zig b/lib/sdl3/v2/gpu.zig index bc628db..0013650 100644 --- a/lib/sdl3/v2/gpu.zig +++ b/lib/sdl3/v2/gpu.zig @@ -19,6 +19,12 @@ pub const Rect = extern struct { 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); @@ -156,8 +162,8 @@ pub const GPUDevice = opaque { 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 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 { @@ -389,6 +395,32 @@ pub const GPUCopyPass = opaque { 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, @@ -509,6 +541,21 @@ pub const GPUTextureUsageFlags = packed struct(u32) { 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, @@ -575,20 +622,75 @@ pub const GPUVertexElementFormat = enum(c_int) { 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) { @@ -600,6 +702,22 @@ pub const GPUColorComponentFlags = packed struct(u8) { 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, @@ -772,7 +890,7 @@ pub const GPUShaderCreateInfo = extern struct { }; pub const GPUTextureCreateInfo = extern struct { - type: GPUTextureType, // The base dimensionality of the texture. + _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. diff --git a/lib/sdl3/v2/guid.zig b/lib/sdl3/v2/guid.zig deleted file mode 100644 index bb1a7a7..0000000 --- a/lib/sdl3/v2/guid.zig +++ /dev/null @@ -1,14 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const GUID = extern struct { - data: [16]u8, -}; - -pub inline fn guidToString(guid: GUID, pszGUID: [*c]u8, cbGUID: c_int) void { - return c.SDL_GUIDToString(guid, pszGUID, cbGUID); -} - -pub inline fn stringToGUID(pchGUID: [*c]const u8) GUID { - return c.SDL_StringToGUID(pchGUID); -} diff --git a/lib/sdl3/v2/haptic.zig b/lib/sdl3/v2/haptic.zig index 9a4468e..bbf2b3d 100644 --- a/lib/sdl3/v2/haptic.zig +++ b/lib/sdl3/v2/haptic.zig @@ -106,12 +106,12 @@ pub const Haptic = opaque { }; pub const HapticDirection = extern struct { - type: u8, // The type of encoding. + _type: u8, // The type of encoding. dir: [3]i32, // The encoded direction. }; pub const HapticConstant = extern struct { - type: u16, // SDL_HAPTIC_CONSTANT + _type: u16, // SDL_HAPTIC_CONSTANT direction: HapticDirection, // Direction of the effect. length: u32, // Duration of the effect. delay: u16, // Delay before starting the effect. @@ -155,7 +155,7 @@ pub const HapticCondition = extern struct { }; pub const HapticRamp = extern struct { - type: u16, // SDL_HAPTIC_RAMP + _type: u16, // SDL_HAPTIC_RAMP direction: HapticDirection, // Direction of the effect. length: u32, // Duration of the effect. delay: u16, // Delay before starting the effect. @@ -170,14 +170,14 @@ pub const HapticRamp = extern struct { }; pub const HapticLeftRight = extern struct { - type: u16, // SDL_HAPTIC_LEFTRIGHT + _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 + _type: u16, // SDL_HAPTIC_CUSTOM direction: HapticDirection, // Direction of the effect. length: u32, // Duration of the effect. delay: u16, // Delay before starting the effect. @@ -194,7 +194,7 @@ pub const HapticCustom = extern struct { }; pub const HapticEffect = extern union { - type: u16, // Effect type. + _type: u16, // Effect type. constant: HapticConstant, // Constant effect. periodic: HapticPeriodic, // Periodic effect. condition: HapticCondition, // Condition effect. diff --git a/lib/sdl3/v2/hidapi.zig b/lib/sdl3/v2/hidapi.zig deleted file mode 100644 index 710db82..0000000 --- a/lib/sdl3/v2/hidapi.zig +++ /dev/null @@ -1,120 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const hid_device = opaque { - pub inline fn hid_write(hid_device: *hid_device, data: const unsigned char *, length: usize) c_int { - return c.SDL_hid_write(hid_device, data, length); - } - - pub inline fn hid_read_timeout(hid_device: *hid_device, data: unsigned char *, length: usize, milliseconds: c_int) c_int { - return c.SDL_hid_read_timeout(hid_device, data, length, milliseconds); - } - - pub inline fn hid_read(hid_device: *hid_device, data: unsigned char *, length: usize) c_int { - return c.SDL_hid_read(hid_device, data, length); - } - - pub inline fn hid_set_nonblocking(hid_device: *hid_device, nonblock: c_int) c_int { - return c.SDL_hid_set_nonblocking(hid_device, nonblock); - } - - pub inline fn hid_send_feature_report(hid_device: *hid_device, data: const unsigned char *, length: usize) c_int { - return c.SDL_hid_send_feature_report(hid_device, data, length); - } - - pub inline fn hid_get_feature_report(hid_device: *hid_device, data: unsigned char *, length: usize) c_int { - return c.SDL_hid_get_feature_report(hid_device, data, length); - } - - pub inline fn hid_get_input_report(hid_device: *hid_device, data: unsigned char *, length: usize) c_int { - return c.SDL_hid_get_input_report(hid_device, data, length); - } - - pub inline fn hid_close(hid_device: *hid_device) c_int { - return c.SDL_hid_close(hid_device); - } - - pub inline fn hid_get_manufacturer_string(hid_device: *hid_device, string: wchar_t *, maxlen: usize) c_int { - return c.SDL_hid_get_manufacturer_string(hid_device, string, maxlen); - } - - pub inline fn hid_get_product_string(hid_device: *hid_device, string: wchar_t *, maxlen: usize) c_int { - return c.SDL_hid_get_product_string(hid_device, string, maxlen); - } - - pub inline fn hid_get_serial_number_string(hid_device: *hid_device, string: wchar_t *, maxlen: usize) c_int { - return c.SDL_hid_get_serial_number_string(hid_device, string, maxlen); - } - - pub inline fn hid_get_indexed_string(hid_device: *hid_device, string_index: c_int, string: wchar_t *, maxlen: usize) c_int { - return c.SDL_hid_get_indexed_string(hid_device, string_index, string, maxlen); - } - - pub inline fn hid_get_device_info(hid_device: *hid_device) ?*hid_device_info { - return c.SDL_hid_get_device_info(hid_device); - } - - pub inline fn hid_get_report_descriptor(hid_device: *hid_device, buf: unsigned char *, buf_size: usize) c_int { - return c.SDL_hid_get_report_descriptor(hid_device, buf, buf_size); - } - -}; - -pub const hid_bus_type = enum(c_int) { - hidApiBusUnknown, - hidApiBusUsb, - hidApiBusBluetooth, - hidApiBusI2c, - hidApiBusSpi, -}; - -pub const hid_device_info = extern struct { - path: [*c]u8, - vendor_id: unsigned short, - product_id: unsigned short, - serial_number: wchar_t *, - release_number: unsigned short, - manufacturer_string: wchar_t *, - product_string: wchar_t *, - usage_page: unsigned short, - usage: unsigned short, - interface_number: c_int, - interface_class: c_int, - interface_subclass: c_int, - interface_protocol: c_int, - bus_type: hid_bus_type, - next: struct SDL_hid_device_info *, -}; - -pub inline fn hid_init() c_int { - return c.SDL_hid_init(); -} - -pub inline fn hid_exit() c_int { - return c.SDL_hid_exit(); -} - -pub inline fn hid_device_change_count() u32 { - return c.SDL_hid_device_change_count(); -} - -pub inline fn hid_enumerate(vendor_id: unsigned short, product_id: unsigned short) ?*hid_device_info { - return c.SDL_hid_enumerate(vendor_id, product_id); -} - -pub inline fn hid_free_enumeration(devs: ?*hid_device_info) void { - return c.SDL_hid_free_enumeration(devs); -} - -pub inline fn hid_open(vendor_id: unsigned short, product_id: unsigned short, serial_number: const wchar_t *) ?*hid_device { - return c.SDL_hid_open(vendor_id, product_id, serial_number); -} - -pub inline fn hid_open_path(path: [*c]const u8) ?*hid_device { - return c.SDL_hid_open_path(path); -} - -pub inline fn hid_ble_scan(active: bool) void { - return c.SDL_hid_ble_scan(active); -} - diff --git a/lib/sdl3/v2/init.zig b/lib/sdl3/v2/init.zig index 1f917b6..a1cecc2 100644 --- a/lib/sdl3/v2/init.zig +++ b/lib/sdl3/v2/init.zig @@ -2,7 +2,7 @@ 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 + _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 @@ -56,6 +56,12 @@ pub const InitFlags = packed struct(u32) { 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; diff --git a/lib/sdl3/v2/iostream.zig b/lib/sdl3/v2/iostream.zig deleted file mode 100644 index 52b54b2..0000000 --- a/lib/sdl3/v2/iostream.zig +++ /dev/null @@ -1,211 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const PropertiesID = u32; - -pub const IOStreamInterface = extern struct { - version: u32, - size: ?*const anyopaque, - seek: ?*const anyopaque, - read: ?*const anyopaque, - write: ?*const anyopaque, - flush: ?*const anyopaque, - close: ?*const anyopaque, -}; - -pub const IOStream = opaque { - pub inline fn closeIO(iostream: *IOStream) bool { - return c.SDL_CloseIO(iostream); - } - - pub inline fn getIOProperties(iostream: *IOStream) PropertiesID { - return c.SDL_GetIOProperties(iostream); - } - - pub inline fn getIOStatus(iostream: *IOStream) IOStatus { - return c.SDL_GetIOStatus(iostream); - } - - pub inline fn getIOSize(iostream: *IOStream) i64 { - return c.SDL_GetIOSize(iostream); - } - - pub inline fn seekIO(iostream: *IOStream, offset: i64, whence: IOWhence) i64 { - return c.SDL_SeekIO(iostream, offset, whence); - } - - pub inline fn tellIO(iostream: *IOStream) i64 { - return c.SDL_TellIO(iostream); - } - - pub inline fn readIO(iostream: *IOStream, ptr: ?*anyopaque, size: usize) usize { - return c.SDL_ReadIO(iostream, ptr, size); - } - - pub inline fn writeIO(iostream: *IOStream, ptr: ?*const anyopaque, size: usize) usize { - return c.SDL_WriteIO(iostream, ptr, size); - } - - pub inline fn iOprintf(iostream: *IOStream, fmt: [*c]const u8, ...) usize { - return c.SDL_IOprintf( - iostream, - fmt, - ); - } - - pub inline fn iOvprintf(iostream: *IOStream, fmt: [*c]const u8, ap: std.builtin.VaList) usize { - return c.SDL_IOvprintf(iostream, fmt, ap); - } - - pub inline fn flushIO(iostream: *IOStream) bool { - return c.SDL_FlushIO(iostream); - } - - pub inline fn loadFile_IO(iostream: *IOStream, datasize: *usize, closeio: bool) ?*anyopaque { - return c.SDL_LoadFile_IO(iostream, @ptrCast(datasize), closeio); - } - - pub inline fn saveFile_IO(iostream: *IOStream, data: ?*const anyopaque, datasize: usize, closeio: bool) bool { - return c.SDL_SaveFile_IO(iostream, data, datasize, closeio); - } - - pub inline fn readU8(iostream: *IOStream, value: [*c]u8) bool { - return c.SDL_ReadU8(iostream, value); - } - - pub inline fn readS8(iostream: *IOStream, value: *i8) bool { - return c.SDL_ReadS8(iostream, @ptrCast(value)); - } - - pub inline fn readU16LE(iostream: *IOStream, value: *u16) bool { - return c.SDL_ReadU16LE(iostream, @ptrCast(value)); - } - - pub inline fn readS16LE(iostream: *IOStream, value: *i16) bool { - return c.SDL_ReadS16LE(iostream, @ptrCast(value)); - } - - pub inline fn readU16BE(iostream: *IOStream, value: *u16) bool { - return c.SDL_ReadU16BE(iostream, @ptrCast(value)); - } - - pub inline fn readS16BE(iostream: *IOStream, value: *i16) bool { - return c.SDL_ReadS16BE(iostream, @ptrCast(value)); - } - - pub inline fn readU32LE(iostream: *IOStream, value: *u32) bool { - return c.SDL_ReadU32LE(iostream, @ptrCast(value)); - } - - pub inline fn readS32LE(iostream: *IOStream, value: *i32) bool { - return c.SDL_ReadS32LE(iostream, @ptrCast(value)); - } - - pub inline fn readU32BE(iostream: *IOStream, value: *u32) bool { - return c.SDL_ReadU32BE(iostream, @ptrCast(value)); - } - - pub inline fn readS32BE(iostream: *IOStream, value: *i32) bool { - return c.SDL_ReadS32BE(iostream, @ptrCast(value)); - } - - pub inline fn readU64LE(iostream: *IOStream, value: *u64) bool { - return c.SDL_ReadU64LE(iostream, @ptrCast(value)); - } - - pub inline fn readS64LE(iostream: *IOStream, value: [*c]Sint64) bool { - return c.SDL_ReadS64LE(iostream, value); - } - - pub inline fn readU64BE(iostream: *IOStream, value: *u64) bool { - return c.SDL_ReadU64BE(iostream, @ptrCast(value)); - } - - pub inline fn readS64BE(iostream: *IOStream, value: [*c]Sint64) bool { - return c.SDL_ReadS64BE(iostream, value); - } - - pub inline fn writeU8(iostream: *IOStream, value: u8) bool { - return c.SDL_WriteU8(iostream, value); - } - - pub inline fn writeS8(iostream: *IOStream, value: i8) bool { - return c.SDL_WriteS8(iostream, value); - } - - pub inline fn writeU16LE(iostream: *IOStream, value: u16) bool { - return c.SDL_WriteU16LE(iostream, value); - } - - pub inline fn writeS16LE(iostream: *IOStream, value: i16) bool { - return c.SDL_WriteS16LE(iostream, value); - } - - pub inline fn writeU16BE(iostream: *IOStream, value: u16) bool { - return c.SDL_WriteU16BE(iostream, value); - } - - pub inline fn writeS16BE(iostream: *IOStream, value: i16) bool { - return c.SDL_WriteS16BE(iostream, value); - } - - pub inline fn writeU32LE(iostream: *IOStream, value: u32) bool { - return c.SDL_WriteU32LE(iostream, value); - } - - pub inline fn writeS32LE(iostream: *IOStream, value: i32) bool { - return c.SDL_WriteS32LE(iostream, value); - } - - pub inline fn writeU32BE(iostream: *IOStream, value: u32) bool { - return c.SDL_WriteU32BE(iostream, value); - } - - pub inline fn writeS32BE(iostream: *IOStream, value: i32) bool { - return c.SDL_WriteS32BE(iostream, value); - } - - pub inline fn writeU64LE(iostream: *IOStream, value: u64) bool { - return c.SDL_WriteU64LE(iostream, value); - } - - pub inline fn writeS64LE(iostream: *IOStream, value: i64) bool { - return c.SDL_WriteS64LE(iostream, value); - } - - pub inline fn writeU64BE(iostream: *IOStream, value: u64) bool { - return c.SDL_WriteU64BE(iostream, value); - } - - pub inline fn writeS64BE(iostream: *IOStream, value: i64) bool { - return c.SDL_WriteS64BE(iostream, value); - } -}; - -pub inline fn ioFromFile(file: [*c]const u8, mode: [*c]const u8) ?*IOStream { - return c.SDL_IOFromFile(file, mode); -} - -pub inline fn ioFromMem(mem: ?*anyopaque, size: usize) ?*IOStream { - return c.SDL_IOFromMem(mem, size); -} - -pub inline fn ioFromConstMem(mem: ?*const anyopaque, size: usize) ?*IOStream { - return c.SDL_IOFromConstMem(mem, size); -} - -pub inline fn ioFromDynamicMem() ?*IOStream { - return c.SDL_IOFromDynamicMem(); -} - -pub inline fn openIO(iface: *const IOStreamInterface, userdata: ?*anyopaque) ?*IOStream { - return c.SDL_OpenIO(@ptrCast(iface), userdata); -} - -pub inline fn loadFile(file: [*c]const u8, datasize: *usize) ?*anyopaque { - return c.SDL_LoadFile(file, @ptrCast(datasize)); -} - -pub inline fn saveFile(file: [*c]const u8, data: ?*const anyopaque, datasize: usize) bool { - return c.SDL_SaveFile(file, data, datasize); -} diff --git a/lib/sdl3/v2/joystick.zig b/lib/sdl3/v2/joystick.zig index 187499c..7ed7d56 100644 --- a/lib/sdl3/v2/joystick.zig +++ b/lib/sdl3/v2/joystick.zig @@ -3,10 +3,30 @@ 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); @@ -28,8 +48,8 @@ pub const Joystick = opaque { 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 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 { @@ -170,7 +190,6 @@ pub const JoystickType = enum(c_int) { }; pub const JoystickConnectionState = enum(c_int) { - joystickConnectionInvalid, joystickConnectionUnknown, joystickConnectionWired, joystickConnectionWireless, @@ -242,13 +261,13 @@ pub const VirtualJoystickTouchpadDesc = extern struct { }; pub const VirtualJoystickSensorDesc = extern struct { - type: SensorType, // the type of this sensor + _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` + _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 diff --git a/lib/sdl3/v2/keyboard.zig b/lib/sdl3/v2/keyboard.zig deleted file mode 100644 index 63bc1ee..0000000 --- a/lib/sdl3/v2/keyboard.zig +++ /dev/null @@ -1,297 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const Scancode = enum(c_int) { - scancodeUnknown, - scancodeA, - scancodeB, - scancodeC, - scancodeD, - scancodeE, - scancodeF, - scancodeG, - scancodeH, - scancodeI, - scancodeJ, - scancodeK, - scancodeL, - scancodeM, - scancodeN, - scancodeO, - scancodeP, - scancodeQ, - scancodeR, - scancodeS, - scancodeT, - scancodeU, - scancodeV, - scancodeW, - scancodeX, - scancodeY, - scancodeZ, - scancode1, - scancode2, - scancode3, - scancode4, - scancode5, - scancode6, - scancode7, - scancode8, - scancode9, - scancode0, - scancodeReturn, - scancodeEscape, - scancodeBackspace, - scancodeTab, - scancodeSpace, - scancodeMinus, - scancodeEquals, - scancodeLeftbracket, - scancodeRightbracket, - scancodeSemicolon, - scancodeApostrophe, - scancodeComma, - scancodePeriod, - scancodeSlash, - scancodeCapslock, - scancodeF1, - scancodeF2, - scancodeF3, - scancodeF4, - scancodeF5, - scancodeF6, - scancodeF7, - scancodeF8, - scancodeF9, - scancodeF10, - scancodeF11, - scancodeF12, - scancodePrintscreen, - scancodeScrolllock, - scancodePause, - scancodeHome, - scancodePageup, - scancodeDelete, - scancodeEnd, - scancodePagedown, - scancodeRight, - scancodeLeft, - scancodeDown, - scancodeUp, - scancodeKpDivide, - scancodeKpMultiply, - scancodeKpMinus, - scancodeKpPlus, - scancodeKpEnter, - scancodeKp1, - scancodeKp2, - scancodeKp3, - scancodeKp4, - scancodeKp5, - scancodeKp6, - scancodeKp7, - scancodeKp8, - scancodeKp9, - scancodeKp0, - scancodeKpPeriod, - scancodeKpEquals, - scancodeF13, - scancodeF14, - scancodeF15, - scancodeF16, - scancodeF17, - scancodeF18, - scancodeF19, - scancodeF20, - scancodeF21, - scancodeF22, - scancodeF23, - scancodeF24, - scancodeExecute, - scancodeSelect, - scancodeMute, - scancodeVolumeup, - scancodeVolumedown, - scancodeKpComma, - scancodeKpEqualsas400, - scancodeInternational2, - scancodeInternational4, - scancodeInternational5, - scancodeInternational6, - scancodeInternational7, - scancodeInternational8, - scancodeInternational9, - scancodeSysreq, - scancodeClear, - scancodePrior, - scancodeReturn2, - scancodeSeparator, - scancodeOut, - scancodeOper, - scancodeClearagain, - scancodeCrsel, - scancodeExsel, - scancodeKp00, - scancodeKp000, - scancodeThousandsseparator, - scancodeDecimalseparator, - scancodeCurrencyunit, - scancodeCurrencysubunit, - scancodeKpLeftparen, - scancodeKpRightparen, - scancodeKpLeftbrace, - scancodeKpRightbrace, - scancodeKpTab, - scancodeKpBackspace, - scancodeKpA, - scancodeKpB, - scancodeKpC, - scancodeKpD, - scancodeKpE, - scancodeKpF, - scancodeKpXor, - scancodeKpPower, - scancodeKpPercent, - scancodeKpLess, - scancodeKpGreater, - scancodeKpAmpersand, - scancodeKpDblampersand, - scancodeKpVerticalbar, - scancodeKpDblverticalbar, - scancodeKpColon, - scancodeKpHash, - scancodeKpSpace, - scancodeKpAt, - scancodeKpExclam, - scancodeKpMemstore, - scancodeKpMemrecall, - scancodeKpMemclear, - scancodeKpMemadd, - scancodeKpMemsubtract, - scancodeKpMemmultiply, - scancodeKpMemdivide, - scancodeKpPlusminus, - scancodeKpClear, - scancodeKpClearentry, - scancodeKpBinary, - scancodeKpOctal, - scancodeKpDecimal, - scancodeKpHexadecimal, - scancodeLctrl, - scancodeLshift, - scancodeRctrl, - scancodeRshift, -}; - -pub const Window = opaque { - pub inline fn startTextInput(window: *Window) bool { - return c.SDL_StartTextInput(window); - } - - pub inline fn startTextInputWithProperties(window: *Window, props: PropertiesID) bool { - return c.SDL_StartTextInputWithProperties(window, props); - } - - pub inline fn textInputActive(window: *Window) bool { - return c.SDL_TextInputActive(window); - } - - pub inline fn stopTextInput(window: *Window) bool { - return c.SDL_StopTextInput(window); - } - - pub inline fn clearComposition(window: *Window) bool { - return c.SDL_ClearComposition(window); - } - - pub inline fn setTextInputArea(window: *Window, rect: *const Rect, cursor: c_int) bool { - return c.SDL_SetTextInputArea(window, @ptrCast(rect), cursor); - } - - pub inline fn getTextInputArea(window: *Window, rect: ?*Rect, cursor: *c_int) bool { - return c.SDL_GetTextInputArea(window, rect, @ptrCast(cursor)); - } - - pub inline fn screenKeyboardShown(window: *Window) bool { - return c.SDL_ScreenKeyboardShown(window); - } -}; - -pub const Keymod = u16; - -pub const Rect = extern struct { - x: c_int, - y: c_int, - w: c_int, - h: c_int, -}; - -pub const Keycode = u32; - -pub const PropertiesID = u32; - -pub const KeyboardID = u32; - -pub inline fn hasKeyboard() bool { - return c.SDL_HasKeyboard(); -} - -pub inline fn getKeyboards(count: *c_int) ?*KeyboardID { - return c.SDL_GetKeyboards(@ptrCast(count)); -} - -pub inline fn getKeyboardNameForID(instance_id: KeyboardID) [*c]const u8 { - return c.SDL_GetKeyboardNameForID(instance_id); -} - -pub inline fn getKeyboardFocus() ?*Window { - return c.SDL_GetKeyboardFocus(); -} - -pub inline fn getKeyboardState(numkeys: *c_int) *const bool { - return @ptrCast(c.SDL_GetKeyboardState(@ptrCast(numkeys))); -} - -pub inline fn resetKeyboard() void { - return c.SDL_ResetKeyboard(); -} - -pub inline fn getModState() Keymod { - return c.SDL_GetModState(); -} - -pub inline fn setModState(modstate: Keymod) void { - return c.SDL_SetModState(modstate); -} - -pub inline fn getKeyFromScancode(scancode: Scancode, modstate: Keymod, key_event: bool) Keycode { - return c.SDL_GetKeyFromScancode(scancode, modstate, key_event); -} - -pub inline fn getScancodeFromKey(key: Keycode, modstate: ?*Keymod) Scancode { - return c.SDL_GetScancodeFromKey(key, modstate); -} - -pub inline fn setScancodeName(scancode: Scancode, name: [*c]const u8) bool { - return c.SDL_SetScancodeName(scancode, name); -} - -pub inline fn getScancodeName(scancode: Scancode) [*c]const u8 { - return c.SDL_GetScancodeName(scancode); -} - -pub inline fn getScancodeFromName(name: [*c]const u8) Scancode { - return c.SDL_GetScancodeFromName(name); -} - -pub inline fn getKeyName(key: Keycode) [*c]const u8 { - return c.SDL_GetKeyName(key); -} - -pub inline fn getKeyFromName(name: [*c]const u8) Keycode { - return c.SDL_GetKeyFromName(name); -} - -pub inline fn hasScreenKeyboardSupport() bool { - return c.SDL_HasScreenKeyboardSupport(); -} diff --git a/lib/sdl3/v2/locale.zig b/lib/sdl3/v2/locale.zig deleted file mode 100644 index 8d43006..0000000 --- a/lib/sdl3/v2/locale.zig +++ /dev/null @@ -1,11 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const Locale = extern struct { - language: [*c]const u8, // A language name, like "en" for English. - country: [*c]const u8, // A country, like "US" for America. Can be NULL. -}; - -pub inline fn getPreferredLocales(count: *c_int) [*c][*c]Locale { - return c.SDL_GetPreferredLocales(@ptrCast(count)); -} diff --git a/lib/sdl3/v2/log.zig b/lib/sdl3/v2/log.zig deleted file mode 100644 index 37e62d2..0000000 --- a/lib/sdl3/v2/log.zig +++ /dev/null @@ -1,138 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const LogCategory = enum(c_int) { - logCategoryApplication, - logCategoryError, - logCategoryAssert, - logCategorySystem, - logCategoryAudio, - logCategoryVideo, - logCategoryRender, - logCategoryInput, - logCategoryTest, - logCategoryGpu, - logCategoryReserved2, - logCategoryReserved3, - logCategoryReserved4, - logCategoryReserved5, - logCategoryReserved6, - logCategoryReserved7, - logCategoryReserved8, - logCategoryReserved9, - logCategoryReserved10, - logCategoryCustom, -}; - -pub const LogPriority = enum(c_int) { - logPriorityInvalid, - logPriorityTrace, - logPriorityVerbose, - logPriorityDebug, - logPriorityInfo, - logPriorityWarn, - logPriorityError, - logPriorityCritical, - logPriorityCount, -}; - -pub inline fn setLogPriorities(priority: LogPriority) void { - return c.SDL_SetLogPriorities(priority); -} - -pub inline fn setLogPriority(category: c_int, priority: LogPriority) void { - return c.SDL_SetLogPriority(category, priority); -} - -pub inline fn getLogPriority(category: c_int) LogPriority { - return c.SDL_GetLogPriority(category); -} - -pub inline fn resetLogPriorities() void { - return c.SDL_ResetLogPriorities(); -} - -pub inline fn setLogPriorityPrefix(priority: LogPriority, prefix: [*c]const u8) bool { - return c.SDL_SetLogPriorityPrefix(priority, prefix); -} - -pub inline fn log(fmt: [*c]const u8, ...) void { - return c.SDL_Log( - fmt, - ); -} - -pub inline fn logTrace(category: c_int, fmt: [*c]const u8, ...) void { - return c.SDL_LogTrace( - category, - fmt, - ); -} - -pub inline fn logVerbose(category: c_int, fmt: [*c]const u8, ...) void { - return c.SDL_LogVerbose( - category, - fmt, - ); -} - -pub inline fn logDebug(category: c_int, fmt: [*c]const u8, ...) void { - return c.SDL_LogDebug( - category, - fmt, - ); -} - -pub inline fn logInfo(category: c_int, fmt: [*c]const u8, ...) void { - return c.SDL_LogInfo( - category, - fmt, - ); -} - -pub inline fn logWarn(category: c_int, fmt: [*c]const u8, ...) void { - return c.SDL_LogWarn( - category, - fmt, - ); -} - -pub inline fn logError(category: c_int, fmt: [*c]const u8, ...) void { - return c.SDL_LogError( - category, - fmt, - ); -} - -pub inline fn logCritical(category: c_int, fmt: [*c]const u8, ...) void { - return c.SDL_LogCritical( - category, - fmt, - ); -} - -pub inline fn logMessage(category: c_int, priority: LogPriority, fmt: [*c]const u8, ...) void { - return c.SDL_LogMessage( - category, - priority, - fmt, - ); -} - -pub inline fn logMessageV(category: c_int, priority: LogPriority, fmt: [*c]const u8, ap: std.builtin.VaList) void { - return c.SDL_LogMessageV(category, priority, fmt, ap); -} - -pub const LogOutputFunction = *const fn (userdata: ?*anyopaque, category: c_int, priority: LogPriority, message: [*c]const u8) callconv(.C) void; - -pub inline fn getDefaultLogOutputFunction() LogOutputFunction { - return c.SDL_GetDefaultLogOutputFunction(); -} - -pub inline fn getLogOutputFunction(callback: ?*LogOutputFunction, userdata: [*c]?*anyopaque) void { - return c.SDL_GetLogOutputFunction(callback, userdata); -} - -pub inline fn setLogOutputFunction(callback: LogOutputFunction, userdata: ?*anyopaque) void { - return c.SDL_SetLogOutputFunction(callback, userdata); -} diff --git a/lib/sdl3/v2/messagebox.zig b/lib/sdl3/v2/messagebox.zig index cb82770..09fa96c 100644 --- a/lib/sdl3/v2/messagebox.zig +++ b/lib/sdl3/v2/messagebox.zig @@ -38,6 +38,7 @@ pub const MessageBoxColorType = enum(c_int) { messageboxColorButtonBorder, messageboxColorButtonBackground, messageboxColorButtonSelected, + messageboxColorCount, //Size of the colors array of SDL_MessageBoxColorScheme. }; pub const MessageBoxColorScheme = extern struct { diff --git a/lib/sdl3/v2/metal.zig b/lib/sdl3/v2/metal.zig deleted file mode 100644 index 2dd490d..0000000 --- a/lib/sdl3/v2/metal.zig +++ /dev/null @@ -1,18 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const Window = opaque { - pub inline fn metal_CreateView(window: *Window) MetalView { - return c.SDL_Metal_CreateView(window); - } -}; - -pub const MetalView = ?*anyopaque; - -pub inline fn metal_DestroyView(view: MetalView) void { - return c.SDL_Metal_DestroyView(view); -} - -pub inline fn metal_GetLayer(view: MetalView) ?*anyopaque { - return c.SDL_Metal_GetLayer(view); -} diff --git a/lib/sdl3/v2/mouse.zig b/lib/sdl3/v2/mouse.zig index f2fb45b..2939c4f 100644 --- a/lib/sdl3/v2/mouse.zig +++ b/lib/sdl3/v2/mouse.zig @@ -34,9 +34,34 @@ pub const Cursor = opaque { }; 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, diff --git a/lib/sdl3/v2/mutex.zig b/lib/sdl3/v2/mutex.zig deleted file mode 100644 index 08dbcb0..0000000 --- a/lib/sdl3/v2/mutex.zig +++ /dev/null @@ -1,145 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const ThreadID = u64; - -pub const AtomicInt = extern struct { -}; - -pub const Mutex = opaque { - pub inline fn lockMutex(mutex: *Mutex) void { - return c.SDL_LockMutex(mutex); - } - - pub inline fn unlockMutex(mutex: *Mutex) void { - return c.SDL_UnlockMutex(mutex); - } - - pub inline fn destroyMutex(mutex: *Mutex) void { - return c.SDL_DestroyMutex(mutex); - } - -}; - -pub inline fn createMutex() ?*Mutex { - return c.SDL_CreateMutex(); -} - -pub inline fn tryLockMutex(SDL_TRY_ACQUIRE(0: Mutex *mutex), mutex) bool { - return c.SDL_TryLockMutex(SDL_TRY_ACQUIRE(0, ); -} - -pub const RWLock = opaque { - pub inline fn lockRWLockForReading(rwlock: *RWLock) void { - return c.SDL_LockRWLockForReading(rwlock); - } - - pub inline fn lockRWLockForWriting(rwlock: *RWLock) void { - return c.SDL_LockRWLockForWriting(rwlock); - } - - pub inline fn unlockRWLock(rwlock: *RWLock) void { - return c.SDL_UnlockRWLock(rwlock); - } - - pub inline fn destroyRWLock(rwlock: *RWLock) void { - return c.SDL_DestroyRWLock(rwlock); - } - -}; - -pub inline fn createRWLock() ?*RWLock { - return c.SDL_CreateRWLock(); -} - -pub inline fn tryLockRWLockForReading(SDL_TRY_ACQUIRE_SHARED(0: RWLock *rwlock), rwlock) bool { - return c.SDL_TryLockRWLockForReading(SDL_TRY_ACQUIRE_SHARED(0, ); -} - -pub inline fn tryLockRWLockForWriting(SDL_TRY_ACQUIRE(0: RWLock *rwlock), rwlock) bool { - return c.SDL_TryLockRWLockForWriting(SDL_TRY_ACQUIRE(0, ); -} - -pub const Semaphore = opaque { - pub inline fn destroySemaphore(semaphore: *Semaphore) void { - return c.SDL_DestroySemaphore(semaphore); - } - - pub inline fn waitSemaphore(semaphore: *Semaphore) void { - return c.SDL_WaitSemaphore(semaphore); - } - - pub inline fn tryWaitSemaphore(semaphore: *Semaphore) bool { - return c.SDL_TryWaitSemaphore(semaphore); - } - - pub inline fn waitSemaphoreTimeout(semaphore: *Semaphore, timeoutMS: i32) bool { - return c.SDL_WaitSemaphoreTimeout(semaphore, timeoutMS); - } - - pub inline fn signalSemaphore(semaphore: *Semaphore) void { - return c.SDL_SignalSemaphore(semaphore); - } - - pub inline fn getSemaphoreValue(semaphore: *Semaphore) u32 { - return c.SDL_GetSemaphoreValue(semaphore); - } - -}; - -pub inline fn createSemaphore(initial_value: u32) ?*Semaphore { - return c.SDL_CreateSemaphore(initial_value); -} - -pub const Condition = opaque { - pub inline fn destroyCondition(condition: *Condition) void { - return c.SDL_DestroyCondition(condition); - } - - pub inline fn signalCondition(condition: *Condition) void { - return c.SDL_SignalCondition(condition); - } - - pub inline fn broadcastCondition(condition: *Condition) void { - return c.SDL_BroadcastCondition(condition); - } - - pub inline fn waitCondition(condition: *Condition, mutex: ?*Mutex) void { - return c.SDL_WaitCondition(condition, mutex); - } - - pub inline fn waitConditionTimeout(condition: *Condition, mutex: ?*Mutex, timeoutMS: i32) bool { - return c.SDL_WaitConditionTimeout(condition, mutex, timeoutMS); - } - -}; - -pub inline fn createCondition() ?*Condition { - return c.SDL_CreateCondition(); -} - -pub const InitStatus = enum(c_int) { - initStatusUninitialized, - initStatusInitializing, - initStatusInitialized, - initStatusUninitializing, -}; - -pub const InitState = extern struct { - status: AtomicInt, - thread: ThreadID, - reserved: ?*anyopaque, -}; - -pub inline fn shouldInit(state: ?*InitState) bool { - return c.SDL_ShouldInit(state); -} - -pub inline fn shouldQuit(state: ?*InitState) bool { - return c.SDL_ShouldQuit(state); -} - -pub inline fn setInitialized(state: ?*InitState, initialized: bool) void { - return c.SDL_SetInitialized(state, initialized); -} - diff --git a/lib/sdl3/v2/opengl.zig b/lib/sdl3/v2/opengl.zig deleted file mode 100644 index c1f53b9..0000000 --- a/lib/sdl3/v2/opengl.zig +++ /dev/null @@ -1,2 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; diff --git a/lib/sdl3/v2/pen.zig b/lib/sdl3/v2/pen.zig deleted file mode 100644 index 21e549f..0000000 --- a/lib/sdl3/v2/pen.zig +++ /dev/null @@ -1,16 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const PenID = u32; - -pub const PenInputFlags = packed struct(u32) { - penInputDown: bool = false, // pen is pressed down - penInputButton1: bool = false, // button 1 is pressed - penInputButton2: bool = false, // button 2 is pressed - penInputButton3: bool = false, // button 3 is pressed - penInputButton4: bool = false, // button 4 is pressed - penInputButton5: bool = false, // button 5 is pressed - penInputEraserTip: bool = false, // eraser tip is used - pad0: u24 = 0, - rsvd: bool = false, -}; diff --git a/lib/sdl3/v2/pixels.zig b/lib/sdl3/v2/pixels.zig index 20dfce2..5b11ed0 100644 --- a/lib/sdl3/v2/pixels.zig +++ b/lib/sdl3/v2/pixels.zig @@ -58,107 +58,99 @@ pub const PackedLayout = enum(c_int) { }; pub const PixelFormat = enum(c_int) { - pixelformatUnknown, - pixelformatIndex1lsb, - pixelformatIndex1msb, - pixelformatIndex2lsb, - pixelformatIndex2msb, - pixelformatIndex4lsb, - pixelformatIndex4msb, - pixelformatIndex8, - pixelformatRgb332, - pixelformatXrgb4444, - pixelformatXbgr4444, - pixelformatXrgb1555, - pixelformatXbgr1555, - pixelformatArgb4444, - pixelformatRgba4444, - pixelformatAbgr4444, - pixelformatBgra4444, - pixelformatArgb1555, - pixelformatRgba5551, - pixelformatAbgr1555, - pixelformatBgra5551, - pixelformatRgb565, - pixelformatBgr565, - pixelformatRgb24, - pixelformatBgr24, - pixelformatXrgb8888, - pixelformatRgbx8888, - pixelformatXbgr8888, - pixelformatBgrx8888, - pixelformatArgb8888, - pixelformatRgba8888, - pixelformatAbgr8888, - pixelformatBgra8888, - pixelformatXrgb2101010, - pixelformatXbgr2101010, - pixelformatArgb2101010, - pixelformatAbgr2101010, - pixelformatRgb48, - pixelformatBgr48, - pixelformatRgba64, - pixelformatArgb64, - pixelformatBgra64, - pixelformatAbgr64, - pixelformatRgb48Float, - pixelformatBgr48Float, - pixelformatRgba64Float, - pixelformatArgb64Float, - pixelformatBgra64Float, - pixelformatAbgr64Float, - pixelformatRgb96Float, - pixelformatBgr96Float, - pixelformatRgba128Float, - pixelformatArgb128Float, - pixelformatBgra128Float, - pixelformatAbgr128Float, - pixelformatRgba32, - pixelformatArgb32, - pixelformatBgra32, - pixelformatAbgr32, - pixelformatRgbx32, - pixelformatXrgb32, - pixelformatBgrx32, - pixelformatXbgr32, -}; - -pub const ColorType = enum(c_int) { - colorTypeUnknown, - colorTypeRgb, - colorTypeYcbcr, + 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) { - colorRangeUnknown, + 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) { - colorPrimariesUnknown, - colorPrimariesUnspecified, - colorPrimariesCustom, + 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) { - transferCharacteristicsUnknown, - transferCharacteristicsUnspecified, - transferCharacteristicsLinear, - transferCharacteristicsLog100, - transferCharacteristicsLog100Sqrt10, - transferCharacteristicsCustom, + 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) { - matrixCoefficientsIdentity, - matrixCoefficientsUnspecified, - matrixCoefficientsYcgco, - matrixCoefficientsChromaDerivedNcl, - matrixCoefficientsChromaDerivedCl, - matrixCoefficientsCustom, + 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) { - colorspaceUnknown, + 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 { diff --git a/lib/sdl3/v2/power.zig b/lib/sdl3/v2/power.zig deleted file mode 100644 index 85b8aa7..0000000 --- a/lib/sdl3/v2/power.zig +++ /dev/null @@ -1,6 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub inline fn getPowerInfo(seconds: *c_int, percent: *c_int) PowerState { - return c.SDL_GetPowerInfo(@ptrCast(seconds), @ptrCast(percent)); -} diff --git a/lib/sdl3/v2/process.zig b/lib/sdl3/v2/process.zig deleted file mode 100644 index aeb3f4e..0000000 --- a/lib/sdl3/v2/process.zig +++ /dev/null @@ -1,44 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const PropertiesID = u32; - -pub const IOStream = opaque {}; - -pub const Process = opaque { - pub inline fn getProcessProperties(process: *Process) PropertiesID { - return c.SDL_GetProcessProperties(process); - } - - pub inline fn readProcess(process: *Process, datasize: *usize, exitcode: *c_int) ?*anyopaque { - return c.SDL_ReadProcess(process, @ptrCast(datasize), @ptrCast(exitcode)); - } - - pub inline fn getProcessInput(process: *Process) ?*IOStream { - return c.SDL_GetProcessInput(process); - } - - pub inline fn getProcessOutput(process: *Process) ?*IOStream { - return c.SDL_GetProcessOutput(process); - } - - pub inline fn killProcess(process: *Process, force: bool) bool { - return c.SDL_KillProcess(process, force); - } - - pub inline fn waitProcess(process: *Process, block: bool, exitcode: *c_int) bool { - return c.SDL_WaitProcess(process, block, @ptrCast(exitcode)); - } - - pub inline fn destroyProcess(process: *Process) void { - return c.SDL_DestroyProcess(process); - } -}; - -pub inline fn createProcess(args: [*c]const [*c]const u8, pipe_stdio: bool) ?*Process { - return c.SDL_CreateProcess(args, pipe_stdio); -} - -pub inline fn createProcessWithProperties(props: PropertiesID) ?*Process { - return c.SDL_CreateProcessWithProperties(props); -} diff --git a/lib/sdl3/v2/render.zig b/lib/sdl3/v2/render.zig index d55ca53..68258df 100644 --- a/lib/sdl3/v2/render.zig +++ b/lib/sdl3/v2/render.zig @@ -7,69 +7,16 @@ pub const FPoint = extern struct { }; pub const PixelFormat = enum(c_int) { - pixelformatUnknown, - pixelformatIndex1lsb, - pixelformatIndex1msb, - pixelformatIndex2lsb, - pixelformatIndex2msb, - pixelformatIndex4lsb, - pixelformatIndex4msb, - pixelformatIndex8, - pixelformatRgb332, - pixelformatXrgb4444, - pixelformatXbgr4444, - pixelformatXrgb1555, - pixelformatXbgr1555, - pixelformatArgb4444, - pixelformatRgba4444, - pixelformatAbgr4444, - pixelformatBgra4444, - pixelformatArgb1555, - pixelformatRgba5551, - pixelformatAbgr1555, - pixelformatBgra5551, - pixelformatRgb565, - pixelformatBgr565, - pixelformatRgb24, - pixelformatBgr24, - pixelformatXrgb8888, - pixelformatRgbx8888, - pixelformatXbgr8888, - pixelformatBgrx8888, - pixelformatArgb8888, - pixelformatRgba8888, - pixelformatAbgr8888, - pixelformatBgra8888, - pixelformatXrgb2101010, - pixelformatXbgr2101010, - pixelformatArgb2101010, - pixelformatAbgr2101010, - pixelformatRgb48, - pixelformatBgr48, - pixelformatRgba64, - pixelformatArgb64, - pixelformatBgra64, - pixelformatAbgr64, - pixelformatRgb48Float, - pixelformatBgr48Float, - pixelformatRgba64Float, - pixelformatArgb64Float, - pixelformatBgra64Float, - pixelformatAbgr64Float, - pixelformatRgb96Float, - pixelformatBgr96Float, - pixelformatRgba128Float, - pixelformatArgb128Float, - pixelformatBgra128Float, - pixelformatAbgr128Float, - pixelformatRgba32, - pixelformatArgb32, - pixelformatBgra32, - pixelformatAbgr32, - pixelformatRgbx32, - pixelformatXrgb32, - pixelformatBgrx32, - pixelformatXbgr32, + 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 { @@ -86,7 +33,8 @@ pub const Surface = opaque { }; pub const ScaleMode = enum(c_int) { - scalemodeInvalid, + scalemodeNearest, //nearest pixel sampling + scalemodeLinear, //linear filtering }; pub const PropertiesID = u32; @@ -111,7 +59,7 @@ pub const FRect = extern struct { }; 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 + _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 @@ -152,6 +100,12 @@ pub const Event = extern union { 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, @@ -195,6 +149,20 @@ pub const Vertex = extern struct { 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); diff --git a/lib/sdl3/v2/scancode.zig b/lib/sdl3/v2/scancode.zig deleted file mode 100644 index b98d773..0000000 --- a/lib/sdl3/v2/scancode.zig +++ /dev/null @@ -1,184 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const Scancode = enum(c_int) { - scancodeUnknown, - scancodeA, - scancodeB, - scancodeC, - scancodeD, - scancodeE, - scancodeF, - scancodeG, - scancodeH, - scancodeI, - scancodeJ, - scancodeK, - scancodeL, - scancodeM, - scancodeN, - scancodeO, - scancodeP, - scancodeQ, - scancodeR, - scancodeS, - scancodeT, - scancodeU, - scancodeV, - scancodeW, - scancodeX, - scancodeY, - scancodeZ, - scancode1, - scancode2, - scancode3, - scancode4, - scancode5, - scancode6, - scancode7, - scancode8, - scancode9, - scancode0, - scancodeReturn, - scancodeEscape, - scancodeBackspace, - scancodeTab, - scancodeSpace, - scancodeMinus, - scancodeEquals, - scancodeLeftbracket, - scancodeRightbracket, - scancodeSemicolon, - scancodeApostrophe, - scancodeComma, - scancodePeriod, - scancodeSlash, - scancodeCapslock, - scancodeF1, - scancodeF2, - scancodeF3, - scancodeF4, - scancodeF5, - scancodeF6, - scancodeF7, - scancodeF8, - scancodeF9, - scancodeF10, - scancodeF11, - scancodeF12, - scancodePrintscreen, - scancodeScrolllock, - scancodePause, - scancodeHome, - scancodePageup, - scancodeDelete, - scancodeEnd, - scancodePagedown, - scancodeRight, - scancodeLeft, - scancodeDown, - scancodeUp, - scancodeKpDivide, - scancodeKpMultiply, - scancodeKpMinus, - scancodeKpPlus, - scancodeKpEnter, - scancodeKp1, - scancodeKp2, - scancodeKp3, - scancodeKp4, - scancodeKp5, - scancodeKp6, - scancodeKp7, - scancodeKp8, - scancodeKp9, - scancodeKp0, - scancodeKpPeriod, - scancodeKpEquals, - scancodeF13, - scancodeF14, - scancodeF15, - scancodeF16, - scancodeF17, - scancodeF18, - scancodeF19, - scancodeF20, - scancodeF21, - scancodeF22, - scancodeF23, - scancodeF24, - scancodeExecute, - scancodeSelect, - scancodeMute, - scancodeVolumeup, - scancodeVolumedown, - scancodeKpComma, - scancodeKpEqualsas400, - scancodeInternational2, - scancodeInternational4, - scancodeInternational5, - scancodeInternational6, - scancodeInternational7, - scancodeInternational8, - scancodeInternational9, - scancodeSysreq, - scancodeClear, - scancodePrior, - scancodeReturn2, - scancodeSeparator, - scancodeOut, - scancodeOper, - scancodeClearagain, - scancodeCrsel, - scancodeExsel, - scancodeKp00, - scancodeKp000, - scancodeThousandsseparator, - scancodeDecimalseparator, - scancodeCurrencyunit, - scancodeCurrencysubunit, - scancodeKpLeftparen, - scancodeKpRightparen, - scancodeKpLeftbrace, - scancodeKpRightbrace, - scancodeKpTab, - scancodeKpBackspace, - scancodeKpA, - scancodeKpB, - scancodeKpC, - scancodeKpD, - scancodeKpE, - scancodeKpF, - scancodeKpXor, - scancodeKpPower, - scancodeKpPercent, - scancodeKpLess, - scancodeKpGreater, - scancodeKpAmpersand, - scancodeKpDblampersand, - scancodeKpVerticalbar, - scancodeKpDblverticalbar, - scancodeKpColon, - scancodeKpHash, - scancodeKpSpace, - scancodeKpAt, - scancodeKpExclam, - scancodeKpMemstore, - scancodeKpMemrecall, - scancodeKpMemclear, - scancodeKpMemadd, - scancodeKpMemsubtract, - scancodeKpMemmultiply, - scancodeKpMemdivide, - scancodeKpPlusminus, - scancodeKpClear, - scancodeKpClearentry, - scancodeKpBinary, - scancodeKpOctal, - scancodeKpDecimal, - scancodeKpHexadecimal, - scancodeLctrl, - scancodeLshift, - scancodeRctrl, - scancodeRshift, -}; diff --git a/lib/sdl3/v2/sensor.zig b/lib/sdl3/v2/sensor.zig index 0bc5018..e32152e 100644 --- a/lib/sdl3/v2/sensor.zig +++ b/lib/sdl3/v2/sensor.zig @@ -35,6 +35,17 @@ pub const Sensor = opaque { 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)); } diff --git a/lib/sdl3/v2/storage.zig b/lib/sdl3/v2/storage.zig index bd84beb..77fc474 100644 --- a/lib/sdl3/v2/storage.zig +++ b/lib/sdl3/v2/storage.zig @@ -2,7 +2,7 @@ const std = @import("std"); pub const c = @import("c.zig").c; pub const PathInfo = extern struct { - type: PathType, // the path type + _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 diff --git a/lib/sdl3/v2/surface.zig b/lib/sdl3/v2/surface.zig index 4803e32..cb69071 100644 --- a/lib/sdl3/v2/surface.zig +++ b/lib/sdl3/v2/surface.zig @@ -2,69 +2,16 @@ const std = @import("std"); pub const c = @import("c.zig").c; pub const PixelFormat = enum(c_int) { - pixelformatUnknown, - pixelformatIndex1lsb, - pixelformatIndex1msb, - pixelformatIndex2lsb, - pixelformatIndex2msb, - pixelformatIndex4lsb, - pixelformatIndex4msb, - pixelformatIndex8, - pixelformatRgb332, - pixelformatXrgb4444, - pixelformatXbgr4444, - pixelformatXrgb1555, - pixelformatXbgr1555, - pixelformatArgb4444, - pixelformatRgba4444, - pixelformatAbgr4444, - pixelformatBgra4444, - pixelformatArgb1555, - pixelformatRgba5551, - pixelformatAbgr1555, - pixelformatBgra5551, - pixelformatRgb565, - pixelformatBgr565, - pixelformatRgb24, - pixelformatBgr24, - pixelformatXrgb8888, - pixelformatRgbx8888, - pixelformatXbgr8888, - pixelformatBgrx8888, - pixelformatArgb8888, - pixelformatRgba8888, - pixelformatAbgr8888, - pixelformatBgra8888, - pixelformatXrgb2101010, - pixelformatXbgr2101010, - pixelformatArgb2101010, - pixelformatAbgr2101010, - pixelformatRgb48, - pixelformatBgr48, - pixelformatRgba64, - pixelformatArgb64, - pixelformatBgra64, - pixelformatAbgr64, - pixelformatRgb48Float, - pixelformatBgr48Float, - pixelformatRgba64Float, - pixelformatArgb64Float, - pixelformatBgra64Float, - pixelformatAbgr64Float, - pixelformatRgb96Float, - pixelformatBgr96Float, - pixelformatRgba128Float, - pixelformatArgb128Float, - pixelformatBgra128Float, - pixelformatAbgr128Float, - pixelformatRgba32, - pixelformatArgb32, - pixelformatBgra32, - pixelformatAbgr32, - pixelformatRgbx32, - pixelformatXrgb32, - pixelformatBgrx32, - pixelformatXbgr32, + 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; @@ -90,7 +37,32 @@ pub const Palette = extern struct { }; pub const Colorspace = enum(c_int) { - colorspaceUnknown, + 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; @@ -105,7 +77,14 @@ pub const SurfaceFlags = packed struct(u32) { }; pub const ScaleMode = enum(c_int) { - scalemodeInvalid, + 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 { diff --git a/lib/sdl3/v2/system.zig b/lib/sdl3/v2/system.zig index 4b5521b..3e0d99c 100644 --- a/lib/sdl3/v2/system.zig +++ b/lib/sdl3/v2/system.zig @@ -108,7 +108,6 @@ pub inline fn isTV() bool { } pub const Sandbox = enum(c_int) { - sandboxNone, sandboxUnknownContainer, sandboxFlatpak, sandboxSnap, diff --git a/lib/sdl3/v2/thread.zig b/lib/sdl3/v2/thread.zig deleted file mode 100644 index f557d41..0000000 --- a/lib/sdl3/v2/thread.zig +++ /dev/null @@ -1,79 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const PropertiesID = u32; - -pub const Thread = opaque { - pub inline fn getThreadName(thread: *Thread) [*c]const u8 { - return c.SDL_GetThreadName(thread); - } - - pub inline fn getThreadID(thread: *Thread) ThreadID { - return c.SDL_GetThreadID(thread); - } - - pub inline fn waitThread(thread: *Thread, status: *c_int) void { - return c.SDL_WaitThread(thread, @ptrCast(status)); - } - - pub inline fn getThreadState(thread: *Thread) ThreadState { - return c.SDL_GetThreadState(thread); - } - - pub inline fn detachThread(thread: *Thread) void { - return c.SDL_DetachThread(thread); - } - -}; - -pub const ThreadID = u64; - -pub const TLSID = AtomicInt; - -pub const ThreadPriority = enum(c_int) { - threadPriorityLow, - threadPriorityNormal, - threadPriorityHigh, - threadPriorityTimeCritical, -}; - -pub const ThreadFunction = *const fn(data: ?*anyopaque) callconv(.C) c_int; - -pub inline fn createThread(fn: ThreadFunction, name: [*c]const u8, data: ?*anyopaque) ?*Thread { - return c.SDL_CreateThread(fn, name, data); -} - -pub inline fn createThreadWithProperties(props: PropertiesID) ?*Thread { - return c.SDL_CreateThreadWithProperties(props); -} - -pub inline fn createThreadRuntime(fn: ThreadFunction, name: [*c]const u8, data: ?*anyopaque, pfnBeginThread: FunctionPointer, pfnEndThread: FunctionPointer) ?*Thread { - return c.SDL_CreateThreadRuntime(fn, name, data, pfnBeginThread, pfnEndThread); -} - -pub inline fn createThreadWithPropertiesRuntime(props: PropertiesID, pfnBeginThread: FunctionPointer, pfnEndThread: FunctionPointer) ?*Thread { - return c.SDL_CreateThreadWithPropertiesRuntime(props, pfnBeginThread, pfnEndThread); -} - -pub inline fn getCurrentThreadID() ThreadID { - return c.SDL_GetCurrentThreadID(); -} - -pub inline fn setCurrentThreadPriority(priority: ThreadPriority) bool { - return c.SDL_SetCurrentThreadPriority(priority); -} - -pub inline fn getTLS(id: ?*TLSID) ?*anyopaque { - return c.SDL_GetTLS(id); -} - -pub const TLSDestructorCallback = *const fn(value: ?*anyopaque) callconv(.C) void; - -pub inline fn setTLS(id: ?*TLSID, value: ?*const anyopaque, destructor: TLSDestructorCallback) bool { - return c.SDL_SetTLS(id, value, destructor); -} - -pub inline fn cleanupTLS() void { - return c.SDL_CleanupTLS(); -} - diff --git a/lib/sdl3/v2/time.zig b/lib/sdl3/v2/time.zig index 51051d0..5b93219 100644 --- a/lib/sdl3/v2/time.zig +++ b/lib/sdl3/v2/time.zig @@ -15,6 +15,17 @@ pub const DateTime = extern struct { 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)); } diff --git a/lib/sdl3/v2/touch.zig b/lib/sdl3/v2/touch.zig index 5e45ccc..2394cdc 100644 --- a/lib/sdl3/v2/touch.zig +++ b/lib/sdl3/v2/touch.zig @@ -6,7 +6,9 @@ pub const TouchID = u64; pub const FingerID = u64; pub const TouchDeviceType = enum(c_int) { - touchDeviceInvalid, + 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 { diff --git a/lib/sdl3/v2/tray.zig b/lib/sdl3/v2/tray.zig deleted file mode 100644 index 783bf8e..0000000 --- a/lib/sdl3/v2/tray.zig +++ /dev/null @@ -1,119 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const Surface = opaque { - pub inline fn createTray(surface: *Surface, tooltip: [*c]const u8) ?*Tray { - return c.SDL_CreateTray(surface, tooltip); - } - -}; - -pub const Tray = opaque { - pub inline fn setTrayIcon(tray: *Tray, icon: ?*Surface) void { - return c.SDL_SetTrayIcon(tray, icon); - } - - pub inline fn setTrayTooltip(tray: *Tray, tooltip: [*c]const u8) void { - return c.SDL_SetTrayTooltip(tray, tooltip); - } - - pub inline fn createTrayMenu(tray: *Tray) ?*TrayMenu { - return c.SDL_CreateTrayMenu(tray); - } - - pub inline fn getTrayMenu(tray: *Tray) ?*TrayMenu { - return c.SDL_GetTrayMenu(tray); - } - - pub inline fn destroyTray(tray: *Tray) void { - return c.SDL_DestroyTray(tray); - } - -}; - -pub const TrayMenu = opaque { - pub inline fn getTrayEntries(traymenu: *TrayMenu, count: *c_int) *const TrayEntry * { - return @ptrCast(c.SDL_GetTrayEntries(traymenu, @ptrCast(count))); - } - - pub inline fn insertTrayEntryAt(traymenu: *TrayMenu, pos: c_int, label: [*c]const u8, flags: TrayEntryFlags) ?*TrayEntry { - return c.SDL_InsertTrayEntryAt(traymenu, pos, label, @bitCast(flags)); - } - - pub inline fn getTrayMenuParentEntry(traymenu: *TrayMenu) ?*TrayEntry { - return c.SDL_GetTrayMenuParentEntry(traymenu); - } - - pub inline fn getTrayMenuParentTray(traymenu: *TrayMenu) ?*Tray { - return c.SDL_GetTrayMenuParentTray(traymenu); - } - -}; - -pub const TrayEntry = opaque { - pub inline fn createTraySubmenu(trayentry: *TrayEntry) ?*TrayMenu { - return c.SDL_CreateTraySubmenu(trayentry); - } - - pub inline fn getTraySubmenu(trayentry: *TrayEntry) ?*TrayMenu { - return c.SDL_GetTraySubmenu(trayentry); - } - - pub inline fn removeTrayEntry(trayentry: *TrayEntry) void { - return c.SDL_RemoveTrayEntry(trayentry); - } - - pub inline fn setTrayEntryLabel(trayentry: *TrayEntry, label: [*c]const u8) void { - return c.SDL_SetTrayEntryLabel(trayentry, label); - } - - pub inline fn getTrayEntryLabel(trayentry: *TrayEntry) [*c]const u8 { - return c.SDL_GetTrayEntryLabel(trayentry); - } - - pub inline fn setTrayEntryChecked(trayentry: *TrayEntry, checked: bool) void { - return c.SDL_SetTrayEntryChecked(trayentry, checked); - } - - pub inline fn getTrayEntryChecked(trayentry: *TrayEntry) bool { - return c.SDL_GetTrayEntryChecked(trayentry); - } - - pub inline fn setTrayEntryEnabled(trayentry: *TrayEntry, enabled: bool) void { - return c.SDL_SetTrayEntryEnabled(trayentry, enabled); - } - - pub inline fn getTrayEntryEnabled(trayentry: *TrayEntry) bool { - return c.SDL_GetTrayEntryEnabled(trayentry); - } - - pub inline fn setTrayEntryCallback(trayentry: *TrayEntry, callback: TrayCallback, userdata: ?*anyopaque) void { - return c.SDL_SetTrayEntryCallback(trayentry, callback, userdata); - } - - pub inline fn clickTrayEntry(trayentry: *TrayEntry) void { - return c.SDL_ClickTrayEntry(trayentry); - } - - pub inline fn getTrayEntryParent(trayentry: *TrayEntry) ?*TrayMenu { - return c.SDL_GetTrayEntryParent(trayentry); - } - -}; - -pub const TrayEntryFlags = packed struct(u32) { - trayentryButton: bool = false, // Make the entry a simple button. Required. - trayentryCheckbox: bool = false, // Make the entry a checkbox. Required. - trayentrySubmenu: bool = false, // Prepare the entry to have a submenu. Required - trayentryDisabled: bool = false, // Make the entry disabled. Optional. - trayentryChecked: bool = false, // Make the entry checked. This is valid only for checkboxes. Optional. - pad0: u26 = 0, - rsvd: bool = false, -}; - -pub const TrayCallback = *const fn(userdata: ?*anyopaque, entry: ?*TrayEntry) callconv(.C) void; - -pub inline fn updateTrays() void { - return c.SDL_UpdateTrays(); -} - diff --git a/lib/sdl3/v2/video.zig b/lib/sdl3/v2/video.zig index 0e1d7f3..1ed6fbf 100644 --- a/lib/sdl3/v2/video.zig +++ b/lib/sdl3/v2/video.zig @@ -2,69 +2,16 @@ const std = @import("std"); pub const c = @import("c.zig").c; pub const PixelFormat = enum(c_int) { - pixelformatUnknown, - pixelformatIndex1lsb, - pixelformatIndex1msb, - pixelformatIndex2lsb, - pixelformatIndex2msb, - pixelformatIndex4lsb, - pixelformatIndex4msb, - pixelformatIndex8, - pixelformatRgb332, - pixelformatXrgb4444, - pixelformatXbgr4444, - pixelformatXrgb1555, - pixelformatXbgr1555, - pixelformatArgb4444, - pixelformatRgba4444, - pixelformatAbgr4444, - pixelformatBgra4444, - pixelformatArgb1555, - pixelformatRgba5551, - pixelformatAbgr1555, - pixelformatBgra5551, - pixelformatRgb565, - pixelformatBgr565, - pixelformatRgb24, - pixelformatBgr24, - pixelformatXrgb8888, - pixelformatRgbx8888, - pixelformatXbgr8888, - pixelformatBgrx8888, - pixelformatArgb8888, - pixelformatRgba8888, - pixelformatAbgr8888, - pixelformatBgra8888, - pixelformatXrgb2101010, - pixelformatXbgr2101010, - pixelformatArgb2101010, - pixelformatAbgr2101010, - pixelformatRgb48, - pixelformatBgr48, - pixelformatRgba64, - pixelformatArgb64, - pixelformatBgra64, - pixelformatAbgr64, - pixelformatRgb48Float, - pixelformatBgr48Float, - pixelformatRgba64Float, - pixelformatArgb64Float, - pixelformatBgra64Float, - pixelformatAbgr64Float, - pixelformatRgb96Float, - pixelformatBgr96Float, - pixelformatRgba128Float, - pixelformatArgb128Float, - pixelformatBgra128Float, - pixelformatAbgr128Float, - pixelformatRgba32, - pixelformatArgb32, - pixelformatBgra32, - pixelformatAbgr32, - pixelformatRgbx32, - pixelformatXrgb32, - pixelformatBgrx32, - pixelformatXbgr32, + 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 { @@ -89,6 +36,12 @@ 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 { @@ -103,6 +56,14 @@ pub const DisplayMode = extern struct { 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); @@ -399,6 +360,12 @@ pub const WindowFlags = packed struct(u64) { 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; @@ -416,6 +383,31 @@ pub const EGLAttribArrayCallback = *const fn (userdata: ?*anyopaque) callconv(.C 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, @@ -525,6 +517,19 @@ 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(); } diff --git a/lib/sdl3/v2/vulkan.zig b/lib/sdl3/v2/vulkan.zig deleted file mode 100644 index 1afa5e1..0000000 --- a/lib/sdl3/v2/vulkan.zig +++ /dev/null @@ -1,34 +0,0 @@ -const std = @import("std"); -pub const c = @import("c.zig").c; - -pub const Window = opaque { - pub inline fn vulkan_CreateSurface(window: *Window, instance: VkInstance, allocator: *const VkAllocationCallbacks, surface: [*c]VkSurfaceKHR) bool { - return c.SDL_Vulkan_CreateSurface(window, instance, @ptrCast(allocator), surface); - } - -}; - -pub inline fn vulkan_LoadLibrary(path: [*c]const u8) bool { - return c.SDL_Vulkan_LoadLibrary(path); -} - -pub inline fn vulkan_GetVkGetInstanceProcAddr() FunctionPointer { - return c.SDL_Vulkan_GetVkGetInstanceProcAddr(); -} - -pub inline fn vulkan_UnloadLibrary() void { - return c.SDL_Vulkan_UnloadLibrary(); -} - -pub inline fn vulkan_GetInstanceExtensions(count: *u32) [*c]char const * const { - return c.SDL_Vulkan_GetInstanceExtensions(@ptrCast(count)); -} - -pub inline fn vulkan_DestroySurface(instance: VkInstance, surface: VkSurfaceKHR, allocator: *const VkAllocationCallbacks) void { - return c.SDL_Vulkan_DestroySurface(instance, surface, @ptrCast(allocator)); -} - -pub inline fn vulkan_GetPresentationSupport(instance: VkInstance, physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32) bool { - return c.SDL_Vulkan_GetPresentationSupport(instance, physicalDevice, queueFamilyIndex); -} -