peterino
/
Backlog
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

3 hours of vibe coding or just having a real programmer step in for 20 minutes...

This commit is contained in:
Peterino2 2026-01-22 21:19:21 -08:00
parent 0725bcdd2a
commit fbc49f1596
79 changed files with 18429 additions and 3173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
lib/sdl3/build.zig vendored
View File

@ -146,67 +146,72 @@ pub fn build(b: *std.Build) void {
// All public SDL3 API headers (53 total) // All public SDL3 API headers (53 total)
// Skipped: assert, thread, hidapi, mutex, tray (not core APIs or problematic) // Skipped: assert, thread, hidapi, mutex, tray (not core APIs or problematic)
const headers_to_generate = [_]struct { header: []const u8, output: []const u8 }{ 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_asyncio.h", .output = "asyncio" },
.{ .header = "SDL/include/SDL3/SDL_atomic.h", .output = "v2/atomic.zig" }, // .{ .header = "SDL/include/SDL3/SDL_atomic.h", .output = "atomic" },
.{ .header = "SDL/include/SDL3/SDL_audio.h", .output = "v2/audio.zig" }, .{ .header = "SDL/include/SDL3/SDL_audio.h", .output = "audio" },
.{ .header = "SDL/include/SDL3/SDL_blendmode.h", .output = "v2/blendmode.zig" }, .{ .header = "SDL/include/SDL3/SDL_blendmode.h", .output = "blendmode" },
.{ .header = "SDL/include/SDL3/SDL_camera.h", .output = "v2/camera.zig" }, .{ .header = "SDL/include/SDL3/SDL_camera.h", .output = "camera" },
.{ .header = "SDL/include/SDL3/SDL_clipboard.h", .output = "v2/clipboard.zig" }, .{ .header = "SDL/include/SDL3/SDL_clipboard.h", .output = "clipboard" },
.{ .header = "SDL/include/SDL3/SDL_cpuinfo.h", .output = "v2/cpuinfo.zig" }, // .{ .header = "SDL/include/SDL3/SDL_cpuinfo.h", .output = "cpuinfo" },
.{ .header = "SDL/include/SDL3/SDL_dialog.h", .output = "v2/dialog.zig" }, .{ .header = "SDL/include/SDL3/SDL_dialog.h", .output = "dialog" },
.{ .header = "SDL/include/SDL3/SDL_endian.h", .output = "v2/endian.zig" }, .{ .header = "SDL/include/SDL3/SDL_endian.h", .output = "endian" },
.{ .header = "SDL/include/SDL3/SDL_error.h", .output = "v2/error.zig" }, .{ .header = "SDL/include/SDL3/SDL_error.h", .output = "error" },
.{ .header = "SDL/include/SDL3/SDL_events.h", .output = "v2/events.zig" }, // .{ .header = "SDL/include/SDL3/SDL_events.h", .output = "events" },
.{ .header = "SDL/include/SDL3/SDL_filesystem.h", .output = "v2/filesystem.zig" }, .{ .header = "SDL/include/SDL3/SDL_filesystem.h", .output = "filesystem" },
.{ .header = "SDL/include/SDL3/SDL_gamepad.h", .output = "v2/gamepad.zig" }, .{ .header = "SDL/include/SDL3/SDL_gamepad.h", .output = "gamepad" },
.{ .header = "SDL/include/SDL3/SDL_gpu.h", .output = "v2/gpu.zig" }, .{ .header = "SDL/include/SDL3/SDL_gpu.h", .output = "gpu" },
.{ .header = "SDL/include/SDL3/SDL_guid.h", .output = "v2/guid.zig" }, // .{ .header = "SDL/include/SDL3/SDL_guid.h", .output = "guid" },
.{ .header = "SDL/include/SDL3/SDL_haptic.h", .output = "v2/haptic.zig" }, .{ .header = "SDL/include/SDL3/SDL_haptic.h", .output = "haptic" },
// .{ .header = "SDL/include/SDL3/SDL_hidapi.h", .output = "v2/hidapi.zig" }, // Skipped: not core API // .{ .header = "SDL/include/SDL3/SDL_hidapi.h", .output = "hidapi" }, // Skipped: not core API
.{ .header = "SDL/include/SDL3/SDL_hints.h", .output = "v2/hints.zig" }, .{ .header = "SDL/include/SDL3/SDL_hints.h", .output = "hints" },
.{ .header = "SDL/include/SDL3/SDL_init.h", .output = "v2/init.zig" }, .{ .header = "SDL/include/SDL3/SDL_init.h", .output = "init" },
// .{ .header = "SDL/include/SDL3/SDL_iostream.h", .output = "v2/iostream.zig" }, // Skipped: complex I/O API // .{ .header = "SDL/include/SDL3/SDL_iostream.h", .output = "iostream" }, // Skipped: complex I/O API
.{ .header = "SDL/include/SDL3/SDL_joystick.h", .output = "v2/joystick.zig" }, .{ .header = "SDL/include/SDL3/SDL_joystick.h", .output = "joystick" },
.{ .header = "SDL/include/SDL3/SDL_keyboard.h", .output = "v2/keyboard.zig" }, // .{ .header = "SDL/include/SDL3/SDL_keyboard.h", .output = "keyboard" },
.{ .header = "SDL/include/SDL3/SDL_keycode.h", .output = "v2/keycode.zig" }, .{ .header = "SDL/include/SDL3/SDL_keycode.h", .output = "keycode" },
.{ .header = "SDL/include/SDL3/SDL_loadso.h", .output = "v2/loadso.zig" }, .{ .header = "SDL/include/SDL3/SDL_loadso.h", .output = "loadso" },
.{ .header = "SDL/include/SDL3/SDL_locale.h", .output = "v2/locale.zig" }, // .{ .header = "SDL/include/SDL3/SDL_locale.h", .output = "locale" },
.{ .header = "SDL/include/SDL3/SDL_log.h", .output = "v2/log.zig" }, // .{ .header = "SDL/include/SDL3/SDL_log.h", .output = "log" },
.{ .header = "SDL/include/SDL3/SDL_messagebox.h", .output = "v2/messagebox.zig" }, .{ .header = "SDL/include/SDL3/SDL_messagebox.h", .output = "messagebox" },
.{ .header = "SDL/include/SDL3/SDL_metal.h", .output = "v2/metal.zig" }, // .{ .header = "SDL/include/SDL3/SDL_metal.h", .output = "metal" },
.{ .header = "SDL/include/SDL3/SDL_misc.h", .output = "v2/misc.zig" }, .{ .header = "SDL/include/SDL3/SDL_misc.h", .output = "misc" },
.{ .header = "SDL/include/SDL3/SDL_mouse.h", .output = "v2/mouse.zig" }, .{ .header = "SDL/include/SDL3/SDL_mouse.h", .output = "mouse" },
// .{ .header = "SDL/include/SDL3/SDL_mutex.h", .output = "v2/mutex.zig" }, // Skipped: not core API // .{ .header = "SDL/include/SDL3/SDL_mutex.h", .output = "mutex" }, // Skipped: not core API
.{ .header = "SDL/include/SDL3/SDL_opengl.h", .output = "v2/opengl.zig" }, // .{ .header = "SDL/include/SDL3/SDL_opengl.h", .output = "opengl" },
.{ .header = "SDL/include/SDL3/SDL_pen.h", .output = "v2/pen.zig" }, // .{ .header = "SDL/include/SDL3/SDL_pen.h", .output = "pen" },
.{ .header = "SDL/include/SDL3/SDL_pixels.h", .output = "v2/pixels.zig" }, .{ .header = "SDL/include/SDL3/SDL_pixels.h", .output = "pixels" },
.{ .header = "SDL/include/SDL3/SDL_power.h", .output = "v2/power.zig" }, // .{ .header = "SDL/include/SDL3/SDL_power.h", .output = "power" },
.{ .header = "SDL/include/SDL3/SDL_process.h", .output = "v2/process.zig" }, // .{ .header = "SDL/include/SDL3/SDL_process.h", .output = "process" },
.{ .header = "SDL/include/SDL3/SDL_properties.h", .output = "v2/properties.zig" }, .{ .header = "SDL/include/SDL3/SDL_properties.h", .output = "properties" },
.{ .header = "SDL/include/SDL3/SDL_rect.h", .output = "v2/rect.zig" }, .{ .header = "SDL/include/SDL3/SDL_rect.h", .output = "rect" },
.{ .header = "SDL/include/SDL3/SDL_render.h", .output = "v2/render.zig" }, .{ .header = "SDL/include/SDL3/SDL_render.h", .output = "render" },
.{ .header = "SDL/include/SDL3/SDL_scancode.h", .output = "v2/scancode.zig" }, // .{ .header = "SDL/include/SDL3/SDL_scancode.h", .output = "scancode" },
.{ .header = "SDL/include/SDL3/SDL_sensor.h", .output = "v2/sensor.zig" }, .{ .header = "SDL/include/SDL3/SDL_sensor.h", .output = "sensor" },
.{ .header = "SDL/include/SDL3/SDL_storage.h", .output = "v2/storage.zig" }, .{ .header = "SDL/include/SDL3/SDL_storage.h", .output = "storage" },
.{ .header = "SDL/include/SDL3/SDL_surface.h", .output = "v2/surface.zig" }, .{ .header = "SDL/include/SDL3/SDL_surface.h", .output = "surface" },
.{ .header = "SDL/include/SDL3/SDL_system.h", .output = "v2/system.zig" }, .{ .header = "SDL/include/SDL3/SDL_system.h", .output = "system" },
// .{ .header = "SDL/include/SDL3/SDL_thread.h", .output = "v2/thread.zig" }, // Skipped: not core API // .{ .header = "SDL/include/SDL3/SDL_thread.h", .output = "thread" }, // Skipped: not core API
.{ .header = "SDL/include/SDL3/SDL_time.h", .output = "v2/time.zig" }, .{ .header = "SDL/include/SDL3/SDL_time.h", .output = "time" },
.{ .header = "SDL/include/SDL3/SDL_timer.h", .output = "v2/timer.zig" }, .{ .header = "SDL/include/SDL3/SDL_timer.h", .output = "timer" },
.{ .header = "SDL/include/SDL3/SDL_touch.h", .output = "v2/touch.zig" }, .{ .header = "SDL/include/SDL3/SDL_touch.h", .output = "touch" },
// .{ .header = "SDL/include/SDL3/SDL_tray.h", .output = "v2/tray.zig" }, // Skipped: not core API // .{ .header = "SDL/include/SDL3/SDL_tray.h", .output = "tray" }, // Skipped: not core API
.{ .header = "SDL/include/SDL3/SDL_version.h", .output = "v2/version.zig" }, .{ .header = "SDL/include/SDL3/SDL_version.h", .output = "version" },
.{ .header = "SDL/include/SDL3/SDL_video.h", .output = "v2/video.zig" }, .{ .header = "SDL/include/SDL3/SDL_video.h", .output = "video" },
// .{ .header = "SDL/include/SDL3/SDL_vulkan.h", .output = "v2/vulkan.zig" }, // Skipped: Vulkan interop // .{ .header = "SDL/include/SDL3/SDL_vulkan.h", .output = "vulkan" }, // Skipped: Vulkan interop
}; };
const regenerate_step = b.step("regenerate-zig", "Regenerate bindings from SDL headers"); const regenerate_step = b.step("regenerate-zig", "Regenerate bindings from SDL headers");
for (headers_to_generate) |header_info| { for (headers_to_generate) |header_info| {
const regenerate = b.addRunArtifact(parser_exe); const regenerate = b.addRunArtifact(parser_exe);
regenerate.addFileArg(b.path(header_info.header)); 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(&regenerate.step); regenerate_step.dependOn(&regenerate.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(&regenerateJson.step);
} }
// Regenerate test mocks step - using SDL_gpu.h for comprehensive testing // 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"), .root_source_file = b.path("parser/test/import_test.zig"),
}), }),
}); });
const run_import_test = b.addRunArtifact(import_test); const run_import_test = b.addRunArtifact(import_test);
const import_test_step = b.step("test-import-issue", "Test demonstrating missing dependency types"); const import_test_step = b.step("test-import-issue", "Test demonstrating missing dependency types");
import_test_step.dependOn(&run_import_test.step); import_test_step.dependOn(&run_import_test.step);

892
lib/sdl3/json/audio.json vendored Normal file
View File

@ -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"
}
]
}
]
}

131
lib/sdl3/json/blendmode.json vendored Normal file
View File

@ -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"
}
]
}
]
}

232
lib/sdl3/json/camera.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

146
lib/sdl3/json/clipboard.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

172
lib/sdl3/json/dialog.json vendored Normal file
View File

@ -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"
}
]
}
]
}

11
lib/sdl3/json/endian.json vendored Normal file
View File

@ -0,0 +1,11 @@
{
"header": "SDL_endian.h",
"opaque_types": [],
"typedefs": [],
"function_pointers": [],
"enums": [],
"structs": [],
"unions": [],
"flags": [],
"functions": []
}

55
lib/sdl3/json/error.json vendored Normal file
View File

@ -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": []
}
]
}

298
lib/sdl3/json/filesystem.json vendored Normal file
View File

@ -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": []
}
]
}

1148
lib/sdl3/json/gamepad.json vendored Normal file
View File

File diff suppressed because it is too large Load Diff

3881
lib/sdl3/json/gpu.json vendored Normal file
View File

File diff suppressed because it is too large Load Diff

785
lib/sdl3/json/haptic.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

157
lib/sdl3/json/hints.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

252
lib/sdl3/json/init.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

960
lib/sdl3/json/joystick.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

20
lib/sdl3/json/keycode.json vendored Normal file
View File

@ -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": []
}

50
lib/sdl3/json/loadso.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

204
lib/sdl3/json/messagebox.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

22
lib/sdl3/json/misc.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

391
lib/sdl3/json/mouse.json vendored Normal file
View File

@ -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": []
}
]
}

920
lib/sdl3/json/pixels.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

394
lib/sdl3/json/properties.json vendored Normal file
View File

@ -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"
}
]
}
]
}

277
lib/sdl3/json/rect.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

1668
lib/sdl3/json/render.json vendored Normal file
View File

File diff suppressed because it is too large Load Diff

203
lib/sdl3/json/sensor.json vendored Normal file
View File

@ -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": []
}
]
}

348
lib/sdl3/json/storage.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

1218
lib/sdl3/json/surface.json vendored Normal file
View File

File diff suppressed because it is too large Load Diff

398
lib/sdl3/json/system.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

237
lib/sdl3/json/time.json vendored Normal file
View File

@ -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"
}
]
}
]
}

150
lib/sdl3/json/timer.json vendored Normal file
View File

@ -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"
}
]
}
]
}

109
lib/sdl3/json/touch.json vendored Normal file
View File

@ -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 *"
}
]
}
]
}

22
lib/sdl3/json/version.json vendored Normal file
View File

@ -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": []
}
]
}

1814
lib/sdl3/json/video.json vendored Normal file
View File

File diff suppressed because it is too large Load Diff

115
lib/sdl3/parser/docs/API_REFERENCE.md vendored
View File

@ -252,23 +252,6 @@ Analyzing dependencies...
Generated: output.zig 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. File is still written, but may need manual fixes.
## Type Conversion Reference ## Type Conversion Reference
@ -311,40 +294,8 @@ File is still written, but may need manual fixes.
## Examples ## Examples
### Example 1: Simple Header
**Input** (simple.h): ### Example
```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
**Input** (depends.h): **Input** (depends.h):
```c ```c
@ -375,7 +326,7 @@ pub inline fn useRect(rect: *Rect) void {
} }
``` ```
### Example 3: With Mocks ### Mocks example
**Command**: **Command**:
```bash ```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

65
lib/sdl3/parser/src/codegen.zig vendored
View File

@ -38,12 +38,12 @@ pub const CodeGen = struct {
return try gen.output.toOwnedSlice(allocator); return try gen.output.toOwnedSlice(allocator);
} }
fn categorizeDeclarations(self: *CodeGen) !void { fn categorizeDeclarations(self: *CodeGen) !void {
// First, collect all opaque type names // First, collect all opaque type names
var opaque_names = std.ArrayList([]const u8){}; var opaque_names = std.ArrayList([]const u8){};
defer opaque_names.deinit(self.allocator); defer opaque_names.deinit(self.allocator);
for (self.decls) |decl| { for (self.decls) |decl| {
if (decl == .opaque_type) { if (decl == .opaque_type) {
const zig_name = naming.typeNameToZig(decl.opaque_type.name); 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){}); try self.opaque_methods.put(zig_name, std.ArrayList(patterns.FunctionDecl){});
} }
} }
// Then, categorize functions // Then, categorize functions
for (self.decls) |decl| { for (self.decls) |decl| {
if (decl == .function_decl) { if (decl == .function_decl) {
@ -61,14 +61,14 @@ pub const CodeGen = struct {
// Check if first param is a pointer to an opaque type // 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); const first_param_type = try types.convertType(func.params[0].type_name, self.allocator);
defer self.allocator.free(first_param_type); defer self.allocator.free(first_param_type);
// Check if it's ?*TypeName or *TypeName // Check if it's ?*TypeName or *TypeName
for (opaque_names.items) |opaque_name| { for (opaque_names.items) |opaque_name| {
const opt_ptr = try std.fmt.allocPrint(self.allocator, "?*{s}", .{opaque_name}); const opt_ptr = try std.fmt.allocPrint(self.allocator, "?*{s}", .{opaque_name});
defer self.allocator.free(opt_ptr); defer self.allocator.free(opt_ptr);
const ptr = try std.fmt.allocPrint(self.allocator, "*{s}", .{opaque_name}); const ptr = try std.fmt.allocPrint(self.allocator, "*{s}", .{opaque_name});
defer self.allocator.free(ptr); defer self.allocator.free(ptr);
if (std.mem.eql(u8, first_param_type, opt_ptr) or std.mem.eql(u8, first_param_type, 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).?; var methods = self.opaque_methods.getPtr(opaque_name).?;
try methods.append(self.allocator, func); try methods.append(self.allocator, func);
@ -110,28 +110,28 @@ pub const CodeGen = struct {
} }
} }
} }
fn isStandaloneFunction(self: *CodeGen, func: patterns.FunctionDecl) !bool { fn isStandaloneFunction(self: *CodeGen, func: patterns.FunctionDecl) !bool {
if (func.params.len == 0) return true; if (func.params.len == 0) return true;
const first_param_type = try types.convertType(func.params[0].type_name, self.allocator); const first_param_type = try types.convertType(func.params[0].type_name, self.allocator);
defer self.allocator.free(first_param_type); defer self.allocator.free(first_param_type);
var it = self.opaque_methods.keyIterator(); var it = self.opaque_methods.keyIterator();
while (it.next()) |opaque_name| { while (it.next()) |opaque_name| {
const opt_ptr = try std.fmt.allocPrint(self.allocator, "?*{s}", .{opaque_name.*}); const opt_ptr = try std.fmt.allocPrint(self.allocator, "?*{s}", .{opaque_name.*});
defer self.allocator.free(opt_ptr); defer self.allocator.free(opt_ptr);
const ptr = try std.fmt.allocPrint(self.allocator, "*{s}", .{opaque_name.*}); const ptr = try std.fmt.allocPrint(self.allocator, "*{s}", .{opaque_name.*});
defer self.allocator.free(ptr); defer self.allocator.free(ptr);
if (std.mem.eql(u8, first_param_type, opt_ptr) or std.mem.eql(u8, first_param_type, 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 false; // It's a method
} }
} }
return true; // It's standalone return true; // It's standalone
} }
fn writeOpaqueWithMethods(self: *CodeGen, opaque_type: OpaqueType) !void { fn writeOpaqueWithMethods(self: *CodeGen, opaque_type: OpaqueType) !void {
const zig_name = naming.typeNameToZig(opaque_type.name); const zig_name = naming.typeNameToZig(opaque_type.name);
@ -142,36 +142,36 @@ pub const CodeGen = struct {
// Check if we have methods for this type // Check if we have methods for this type
const methods = self.opaque_methods.get(zig_name); const methods = self.opaque_methods.get(zig_name);
if (methods) |method_list| { if (methods) |method_list| {
if (method_list.items.len > 0) { if (method_list.items.len > 0) {
// pub const GPUDevice = opaque { // pub const GPUDevice = opaque {
try self.output.writer(self.allocator).print("pub const {s} = opaque {{\n", .{zig_name}); try self.output.writer(self.allocator).print("pub const {s} = opaque {{\n", .{zig_name});
// Write methods // Write methods
for (method_list.items) |func| { for (method_list.items) |func| {
try self.writeFunctionAsMethod(func, zig_name); try self.writeFunctionAsMethod(func, zig_name);
} }
try self.output.appendSlice(self.allocator, "};\n\n"); try self.output.appendSlice(self.allocator, "};\n\n");
return; return;
} }
} }
// No methods, write as simple opaque // No methods, write as simple opaque
try self.output.writer(self.allocator).print("pub const {s} = opaque {{}};\n\n", .{zig_name}); try self.output.writer(self.allocator).print("pub const {s} = opaque {{}};\n\n", .{zig_name});
} }
fn writeTypedef(self: *CodeGen, typedef_decl: patterns.TypedefDecl) !void { fn writeTypedef(self: *CodeGen, typedef_decl: patterns.TypedefDecl) !void {
// Write doc comment if present // Write doc comment if present
if (typedef_decl.doc_comment) |doc| { if (typedef_decl.doc_comment) |doc| {
try self.writeDocComment(doc); try self.writeDocComment(doc);
} }
const zig_name = naming.typeNameToZig(typedef_decl.name); const zig_name = naming.typeNameToZig(typedef_decl.name);
const zig_type = try types.convertType(typedef_decl.underlying_type, self.allocator); const zig_type = try types.convertType(typedef_decl.underlying_type, self.allocator);
defer self.allocator.free(zig_type); defer self.allocator.free(zig_type);
try self.output.appendSlice(self.allocator, "pub const "); try self.output.appendSlice(self.allocator, "pub const ");
try self.output.appendSlice(self.allocator, zig_name); try self.output.appendSlice(self.allocator, zig_name);
try self.output.appendSlice(self.allocator, " = "); try self.output.appendSlice(self.allocator, " = ");
@ -184,29 +184,30 @@ pub const CodeGen = struct {
if (func_ptr_decl.doc_comment) |doc| { if (func_ptr_decl.doc_comment) |doc| {
try self.writeDocComment(doc); try self.writeDocComment(doc);
} }
const zig_name = naming.typeNameToZig(func_ptr_decl.name); const zig_name = naming.typeNameToZig(func_ptr_decl.name);
const return_type = try types.convertType(func_ptr_decl.return_type, self.allocator); const return_type = try types.convertType(func_ptr_decl.return_type, self.allocator);
defer self.allocator.free(return_type); defer self.allocator.free(return_type);
// Generate: pub const TimerCallback = *const fn(param1: Type1, ...) callconv(.C) RetType; // 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}); try self.output.writer(self.allocator).print("pub const {s} = *const fn(", .{zig_name});
// Write parameters // Write parameters
for (func_ptr_decl.params, 0..) |param, i| { for (func_ptr_decl.params, 0..) |param, i| {
if (i > 0) try self.output.appendSlice(self.allocator, ", "); if (i > 0) try self.output.appendSlice(self.allocator, ", ");
const param_type = try types.convertType(param.type_name, self.allocator); const param_type = try types.convertType(param.type_name, self.allocator);
defer self.allocator.free(param_type); 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 // Close with calling convention and return type
try self.output.writer(self.allocator).print(") callconv(.C) {s};\n\n", .{return_type}); try self.output.writer(self.allocator).print(") callconv(.C) {s};\n\n", .{return_type});
} }
fn writeEnum(self: *CodeGen, enum_decl: EnumDecl) !void { 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 // Skip empty enums
if (enum_decl.values.len == 0) { if (enum_decl.values.len == 0) {
return; return;
@ -359,7 +360,7 @@ pub const CodeGen = struct {
// Parse bit position from value like "(1u << 0)" // Parse bit position from value like "(1u << 0)"
const bit_pos = self.parseBitPosition(flag.value) catch |err| { const bit_pos = self.parseBitPosition(flag.value) catch |err| {
// Skip flags we can't parse (like non-bitfield constants) // 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; continue;
}; };
used_bits.set(bit_pos); used_bits.set(bit_pos);
@ -610,22 +611,22 @@ pub const CodeGen = struct {
const hex_str = trimmed[2..]; const hex_str = trimmed[2..];
const val = try std.fmt.parseInt(u64, hex_str, 16); const val = try std.fmt.parseInt(u64, hex_str, 16);
// Find the bit position (count trailing zeros) // 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) { while (bit < 64) : (bit += 1) {
if (val == (@as(u64, 1) << @as(u6, @intCast(bit)))) return @intCast(bit); if (val == (@as(u64, 1) << @as(u6, @intCast(bit)))) return @intCast(bit);
} }
} }
// Raw decimal value like "1" or "2" or "4" // Raw decimal value like "1" or "2" or "4"
if (std.fmt.parseInt(u64, trimmed, 10)) |val| { if (std.fmt.parseInt(u64, trimmed, 10)) |val| {
// Find bit position for powers of 2 // Find bit position for powers of 2
if (val == 0) return 0; // Special case if (val == 0) return 0; // Special case
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) { while (bit < 64) : (bit += 1) {
if (val == (@as(u64, 1) << @as(u6, @intCast(bit)))) return @intCast(bit); 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) // Not a power of 2 - might be a simple constant (like button numbers)
// Just skip this flag value by returning error // Just skip this flag value by returning error
return error.InvalidBitPosition; return error.InvalidBitPosition;

92
lib/sdl3/parser/src/parser.zig vendored
View File

@ -20,11 +20,11 @@ pub fn main() !void {
} }
const header_path = args[1]; const header_path = args[1];
var output_file: ?[]const u8 = null; var output_file: ?[]const u8 = null;
var mock_output_file: ?[]const u8 = null; var mock_output_file: ?[]const u8 = null;
var json_output_file: ?[]const u8 = null; var json_output_file: ?[]const u8 = null;
// Parse additional flags // Parse additional flags
for (args[2..]) |arg| { for (args[2..]) |arg| {
const output_prefix = "--output="; const output_prefix = "--output=";
@ -169,30 +169,30 @@ pub fn main() !void {
// Generate JSON if requested // Generate JSON if requested
if (json_output_file) |json_path| { if (json_output_file) |json_path| {
std.debug.print("Generating JSON output...\n", .{}); std.debug.print("Generating JSON output...\n", .{});
var serializer = json_serializer.JsonSerializer.init(allocator, std.fs.path.basename(header_path)); var serializer = json_serializer.JsonSerializer.init(allocator, std.fs.path.basename(header_path));
try serializer.addDeclarations(decls); try serializer.addDeclarations(decls);
const json_output = try serializer.finalize(); const json_output = try serializer.finalize();
// json_output is owned by serializer // json_output is owned by serializer
// Parse and re-format JSON with proper indentation // Parse and re-format JSON with proper indentation
const parsed = try std.json.parseFromSlice(std.json.Value, allocator, json_output, .{}); const parsed = try std.json.parseFromSlice(std.json.Value, allocator, json_output, .{});
defer parsed.deinit(); defer parsed.deinit();
var formatted_output = std.ArrayList(u8){}; var formatted_output = std.ArrayList(u8){};
defer formatted_output.deinit(allocator); defer formatted_output.deinit(allocator);
const formatter = std.json.fmt(parsed.value, .{ .whitespace = .indent_2 }); const formatter = std.json.fmt(parsed.value, .{ .whitespace = .indent_2 });
try std.fmt.format(formatted_output.writer(allocator), "{f}", .{formatter}); try std.fmt.format(formatted_output.writer(allocator), "{f}", .{formatter});
try std.fs.cwd().writeFile(.{ try std.fs.cwd().writeFile(.{
.sub_path = json_path, .sub_path = json_path,
.data = formatted_output.items, .data = formatted_output.items,
}); });
serializer.deinit(); serializer.deinit();
std.debug.print("Generated JSON: {s}\n", .{json_path}); std.debug.print("Generated JSON: {s}\n", .{json_path});
// If only JSON was requested, we're done // If only JSON was requested, we're done
if (output_file == null and mock_output_file == null) { if (output_file == null and mock_output_file == null) {
return; return;
@ -203,21 +203,21 @@ pub fn main() !void {
std.debug.print("Analyzing dependencies...\n", .{}); std.debug.print("Analyzing dependencies...\n", .{});
var resolver = dependency_resolver.DependencyResolver.init(allocator); var resolver = dependency_resolver.DependencyResolver.init(allocator);
defer resolver.deinit(); defer resolver.deinit();
try resolver.analyze(decls); try resolver.analyze(decls);
const missing_types = try resolver.getMissingTypes(allocator); const missing_types = try resolver.getMissingTypes(allocator);
defer { defer {
for (missing_types) |t| allocator.free(t); for (missing_types) |t| allocator.free(t);
allocator.free(missing_types); allocator.free(missing_types);
} }
if (missing_types.len > 0) { if (missing_types.len > 0) {
std.debug.print("Found {d} missing types:\n", .{missing_types.len}); std.debug.print("Found {d} missing types:\n", .{missing_types.len});
for (missing_types) |missing| { for (missing_types) |missing| {
std.debug.print(" - {s}\n", .{missing}); std.debug.print(" - {s}\n", .{missing});
} }
std.debug.print("\n", .{}); std.debug.print("\n", .{});
// Extract missing types from included headers // Extract missing types from included headers
std.debug.print("Resolving dependencies from included headers...\n", .{}); std.debug.print("Resolving dependencies from included headers...\n", .{});
const includes = try dependency_resolver.parseIncludes(allocator, source); const includes = try dependency_resolver.parseIncludes(allocator, source);
@ -225,9 +225,9 @@ pub fn main() !void {
for (includes) |inc| allocator.free(inc); for (includes) |inc| allocator.free(inc);
allocator.free(includes); allocator.free(includes);
} }
const header_dir = std.fs.path.dirname(header_path) orelse "."; const header_dir = std.fs.path.dirname(header_path) orelse ".";
var dependency_decls = std.ArrayList(patterns.Declaration){}; var dependency_decls = std.ArrayList(patterns.Declaration){};
defer { defer {
for (dependency_decls.items) |dep_decl| { for (dependency_decls.items) |dep_decl| {
@ -235,64 +235,58 @@ pub fn main() !void {
} }
dependency_decls.deinit(allocator); dependency_decls.deinit(allocator);
} }
for (missing_types) |missing_type| { for (missing_types) |missing_type| {
var found = false; var found = false;
for (includes) |include| { for (includes) |include| {
const dep_path = try std.fs.path.join( const dep_path = try std.fs.path.join(allocator, &[_][]const u8{ header_dir, include });
allocator,
&[_][]const u8{ header_dir, include }
);
defer allocator.free(dep_path); defer allocator.free(dep_path);
const dep_source = std.fs.cwd().readFileAlloc( const dep_source = std.fs.cwd().readFileAlloc(allocator, dep_path, 10 * 1024 * 1024) catch continue;
allocator,
dep_path,
10 * 1024 * 1024
) catch continue;
defer allocator.free(dep_source); defer allocator.free(dep_source);
if (try dependency_resolver.extractTypeFromHeader(allocator, dep_source, missing_type)) |dep_decl| { if (try dependency_resolver.extractTypeFromHeader(allocator, dep_source, missing_type)) |dep_decl| {
try dependency_decls.append(allocator, 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; found = true;
break; break;
} }
} }
if (!found) { if (!found) {
std.debug.print(" ⚠ Warning: Could not find definition for type: {s}\n", .{missing_type}); std.debug.print(" ⚠ Warning: Could not find definition for type: {s}\n", .{missing_type});
} }
} }
// Combine declarations (dependencies first!) // Combine declarations (dependencies first!)
std.debug.print("\nCombining {d} dependency declarations with primary declarations...\n", .{dependency_decls.items.len}); std.debug.print("\nCombining {d} dependency declarations with primary declarations...\n", .{dependency_decls.items.len});
var all_decls = std.ArrayList(patterns.Declaration){}; var all_decls = std.ArrayList(patterns.Declaration){};
defer all_decls.deinit(allocator); defer all_decls.deinit(allocator);
try all_decls.appendSlice(allocator, dependency_decls.items); try all_decls.appendSlice(allocator, dependency_decls.items);
try all_decls.appendSlice(allocator, decls); try all_decls.appendSlice(allocator, decls);
// Generate code with all declarations // Generate code with all declarations
const output = try codegen.CodeGen.generate(allocator, all_decls.items); const output = try codegen.CodeGen.generate(allocator, all_decls.items);
defer allocator.free(output); defer allocator.free(output);
// Parse and format the AST for validation // Parse and format the AST for validation
const output_z = try allocator.dupeZ(u8, output); const output_z = try allocator.dupeZ(u8, output);
defer allocator.free(output_z); defer allocator.free(output_z);
var ast = try std.zig.Ast.parse(allocator, output_z, .zig); var ast = try std.zig.Ast.parse(allocator, output_z, .zig);
defer ast.deinit(allocator); defer ast.deinit(allocator);
// Check for parse errors // Check for parse errors
if (ast.errors.len > 0) { 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}); std.debug.print("\nError: {d} syntax errors detected in generated code\n", .{ast.errors.len});
for (ast.errors) |err| { for (ast.errors) |err| {
const loc = ast.tokenLocation(0, err.token); const loc = ast.tokenLocation(0, err.token);
std.debug.print(" Line {d}: {s}\n", .{ loc.line + 1, @tagName(err.tag) }); std.debug.print(" Line {d}: {s}\n", .{ loc.line + 1, @tagName(err.tag) });
} }
// Write unformatted output for debugging // Write unformatted output for debugging
if (output_file) |file_path| { if (output_file) |file_path| {
try std.fs.cwd().writeFile(.{ try std.fs.cwd().writeFile(.{
@ -301,10 +295,10 @@ pub fn main() !void {
}); });
std.debug.print("\nGenerated (with errors): {s}\n", .{file_path}); std.debug.print("\nGenerated (with errors): {s}\n", .{file_path});
} }
return error.InvalidSyntax; return error.InvalidSyntax;
} }
// Render formatted output from AST // Render formatted output from AST
const formatted_output = try ast.renderAlloc(allocator); const formatted_output = try ast.renderAlloc(allocator);
defer allocator.free(formatted_output); defer allocator.free(formatted_output);
@ -319,13 +313,13 @@ pub fn main() !void {
} else { } else {
_ = try std.posix.write(std.posix.STDOUT_FILENO, formatted_output); _ = try std.posix.write(std.posix.STDOUT_FILENO, formatted_output);
} }
// Generate C mocks if requested (with all declarations) // Generate C mocks if requested (with all declarations)
if (mock_output_file) |mock_path| { if (mock_output_file) |mock_path| {
const mock_codegen = @import("mock_codegen.zig"); const mock_codegen = @import("mock_codegen.zig");
const mock_output = try mock_codegen.MockCodeGen.generate(allocator, all_decls.items); const mock_output = try mock_codegen.MockCodeGen.generate(allocator, all_decls.items);
defer allocator.free(mock_output); defer allocator.free(mock_output);
try std.fs.cwd().writeFile(.{ try std.fs.cwd().writeFile(.{
.sub_path = mock_path, .sub_path = mock_path,
.data = mock_output, .data = mock_output,
@ -334,18 +328,18 @@ pub fn main() !void {
} }
} else { } else {
std.debug.print("No missing dependencies found!\n\n", .{}); std.debug.print("No missing dependencies found!\n\n", .{});
// Generate code without dependencies // Generate code without dependencies
const output = try codegen.CodeGen.generate(allocator, decls); const output = try codegen.CodeGen.generate(allocator, decls);
defer allocator.free(output); defer allocator.free(output);
// Parse and format the AST for validation // Parse and format the AST for validation
const output_z = try allocator.dupeZ(u8, output); const output_z = try allocator.dupeZ(u8, output);
defer allocator.free(output_z); defer allocator.free(output_z);
var ast = try std.zig.Ast.parse(allocator, output_z, .zig); var ast = try std.zig.Ast.parse(allocator, output_z, .zig);
defer ast.deinit(allocator); defer ast.deinit(allocator);
// Check for parse errors // Check for parse errors
if (ast.errors.len > 0) { if (ast.errors.len > 0) {
std.debug.print("\nError: {d} syntax errors detected in generated code\n", .{ast.errors.len}); 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); const loc = ast.tokenLocation(0, err.token);
std.debug.print(" Line {d}: {s}\n", .{ loc.line + 1, @tagName(err.tag) }); std.debug.print(" Line {d}: {s}\n", .{ loc.line + 1, @tagName(err.tag) });
} }
// Write unformatted output for debugging // Write unformatted output for debugging
if (output_file) |file_path| { if (output_file) |file_path| {
try std.fs.cwd().writeFile(.{ try std.fs.cwd().writeFile(.{
@ -362,10 +356,10 @@ pub fn main() !void {
}); });
std.debug.print("\nGenerated (with errors): {s}\n", .{file_path}); std.debug.print("\nGenerated (with errors): {s}\n", .{file_path});
} }
return error.InvalidSyntax; return error.InvalidSyntax;
} }
// Render formatted output from AST // Render formatted output from AST
const formatted_output = try ast.renderAlloc(allocator); const formatted_output = try ast.renderAlloc(allocator);
defer allocator.free(formatted_output); defer allocator.free(formatted_output);
@ -380,13 +374,13 @@ pub fn main() !void {
} else { } else {
_ = try std.posix.write(std.posix.STDOUT_FILENO, formatted_output); _ = try std.posix.write(std.posix.STDOUT_FILENO, formatted_output);
} }
// Generate C mocks if requested // Generate C mocks if requested
if (mock_output_file) |mock_path| { if (mock_output_file) |mock_path| {
const mock_codegen = @import("mock_codegen.zig"); const mock_codegen = @import("mock_codegen.zig");
const mock_output = try mock_codegen.MockCodeGen.generate(allocator, decls); const mock_output = try mock_codegen.MockCodeGen.generate(allocator, decls);
defer allocator.free(mock_output); defer allocator.free(mock_output);
try std.fs.cwd().writeFile(.{ try std.fs.cwd().writeFile(.{
.sub_path = mock_path, .sub_path = mock_path,
.data = mock_output, .data = mock_output,

253
lib/sdl3/parser/src/patterns.zig vendored
View File

@ -1,6 +1,15 @@
const std = @import("std"); const std = @import("std");
const Allocator = std.mem.Allocator; 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 // Simple data structures to hold extracted declarations
pub const Declaration = union(enum) { pub const Declaration = union(enum) {
opaque_type: OpaqueType, 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;) // 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 // But reject pointer typedefs (e.g., typedef struct X *Y;) - those should be handled by scanTypedef
const name2_clean = std.mem.trimRight(u8, name2, ";"); const name2_clean = std.mem.trimRight(u8, name2, ";");
// Check if it's a pointer typedef - if either name starts with *, reject it // 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, "*")) { if (std.mem.startsWith(u8, name1, "*") or std.mem.startsWith(u8, name2_clean, "*")) {
self.pos = start; self.pos = start;
return null; return null;
} }
const use_name = if (std.mem.eql(u8, name1, name2_clean)) 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, ";")) 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 { else {
// Not a valid opaque typedef // Not a valid opaque typedef
self.pos = start; self.pos = start;
@ -207,47 +216,47 @@ pub const Scanner = struct {
.doc_comment = doc, .doc_comment = doc,
}; };
} }
// Pattern: typedef RetType (SDLCALL *FuncName)(Param1Type param1, ...); // Pattern: typedef RetType (SDLCALL *FuncName)(Param1Type param1, ...);
fn scanFunctionPointer(self: *Scanner) !?FunctionPointerDecl { fn scanFunctionPointer(self: *Scanner) !?FunctionPointerDecl {
const start = self.pos; const start = self.pos;
const line = try self.readLine(); const line = try self.readLine();
defer self.allocator.free(line); defer self.allocator.free(line);
// Must start with typedef // Must start with typedef
if (!std.mem.startsWith(u8, line, "typedef ")) { if (!std.mem.startsWith(u8, line, "typedef ")) {
self.pos = start; self.pos = start;
return null; return null;
} }
// Must contain * pattern with SDL prefix (function pointer typedef) // Must contain * pattern with SDL prefix (function pointer typedef)
// Pattern: typedef RetType (SDLCALL *SDL_Name)(Params); // Pattern: typedef RetType (SDLCALL *SDL_Name)(Params);
const has_sdl_ptr = std.mem.indexOf(u8, line, " *SDL_") != null or const has_sdl_ptr = std.mem.indexOf(u8, line, " *SDL_") != null or
std.mem.indexOf(u8, line, "(*SDL_") != null; std.mem.indexOf(u8, line, "(*SDL_") != null;
if (!has_sdl_ptr) { if (!has_sdl_ptr) {
self.pos = start; self.pos = start;
return null; return null;
} }
// Parse: typedef RetType (SDLCALL *FuncName)(Params); // Parse: typedef RetType (SDLCALL *FuncName)(Params);
const trimmed = std.mem.trim(u8, line, " \t\r\n"); const trimmed = std.mem.trim(u8, line, " \t\r\n");
const no_semi = std.mem.trimRight(u8, trimmed, ";"); const no_semi = std.mem.trimRight(u8, trimmed, ";");
// Skip "typedef " // Skip "typedef "
const after_typedef = std.mem.trimLeft(u8, no_semi["typedef ".len..], " \t"); const after_typedef = std.mem.trimLeft(u8, no_semi["typedef ".len..], " \t");
// Find the *SDL_ marker (function pointer name) // Find the *SDL_ marker (function pointer name)
const ptr_marker = 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 { std.mem.indexOf(u8, after_typedef, "(*SDL_") orelse {
self.pos = start; self.pos = start;
return null; return null;
}; };
// Return type is everything before the pointer marker // Return type is everything before the pointer marker
// It may include (SDLCALL or just be the plain type // It may include (SDLCALL or just be the plain type
const return_type_section = std.mem.trim(u8, after_typedef[0..ptr_marker], " \t"); const return_type_section = std.mem.trim(u8, after_typedef[0..ptr_marker], " \t");
// Extract return type (remove SDLCALL if present) // Extract return type (remove SDLCALL if present)
const return_type = if (std.mem.indexOf(u8, return_type_section, "(SDLCALL")) |sdlcall_pos| 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") 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") std.mem.trim(u8, return_type_section[0..sdlcall_pos], " \t")
else else
return_type_section; return_type_section;
// Find function name: starts after *SDL_ and ends at ) // Find function name: starts after *SDL_ and ends at )
const after_star = std.mem.trimLeft(u8, after_typedef[ptr_marker..], " *("); const after_star = std.mem.trimLeft(u8, after_typedef[ptr_marker..], " *(");
const name_end = std.mem.indexOfScalar(u8, after_star, ')') orelse { const name_end = std.mem.indexOfScalar(u8, after_star, ')') orelse {
@ -263,9 +272,9 @@ pub const Scanner = struct {
return null; return null;
}; };
const func_name = std.mem.trim(u8, after_star[0..name_end], " \t"); const func_name = std.mem.trim(u8, after_star[0..name_end], " \t");
// Find parameters (between the closing ) of name and final ) // 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 { const params_start = std.mem.indexOfScalar(u8, after_name, '(') orelse {
self.pos = start; self.pos = start;
return null; return null;
@ -274,12 +283,12 @@ pub const Scanner = struct {
self.pos = start; self.pos = start;
return null; 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 // Parse parameters
const params = try self.parseParams(params_str); const params = try self.parseParams(params_str);
const doc = self.consumePendingDocComment(); const doc = self.consumePendingDocComment();
return FunctionPointerDecl{ return FunctionPointerDecl{
.name = try self.allocator.dupe(u8, func_name), .name = try self.allocator.dupe(u8, func_name),
.return_type = try self.allocator.dupe(u8, return_type), .return_type = try self.allocator.dupe(u8, return_type),
@ -287,26 +296,26 @@ pub const Scanner = struct {
.doc_comment = doc, .doc_comment = doc,
}; };
} }
// Pattern: typedef Type SDL_Name; // Pattern: typedef Type SDL_Name;
fn scanTypedef(self: *Scanner) !?TypedefDecl { fn scanTypedef(self: *Scanner) !?TypedefDecl {
const start = self.pos; const start = self.pos;
const line = try self.readLine(); const line = try self.readLine();
defer self.allocator.free(line); defer self.allocator.free(line);
// Check if it matches: typedef <type> <name>; // Check if it matches: typedef <type> <name>;
if (!std.mem.startsWith(u8, line, "typedef ")) { if (!std.mem.startsWith(u8, line, "typedef ")) {
self.pos = start; self.pos = start;
return null; return null;
} }
// Skip lines with braces (those are struct/enum typedefs, handled elsewhere) // Skip lines with braces (those are struct/enum typedefs, handled elsewhere)
if (std.mem.indexOf(u8, line, "{") != null) { if (std.mem.indexOf(u8, line, "{") != null) {
self.pos = start; self.pos = start;
return null; return null;
} }
// Skip lines with "struct" or "enum" keywords UNLESS it's a pointer typedef like: // Skip lines with "struct" or "enum" keywords UNLESS it's a pointer typedef like:
// typedef struct X *Y; // typedef struct X *Y;
const has_struct_or_enum = std.mem.indexOf(u8, line, "struct ") != null or std.mem.indexOf(u8, line, "enum ") != null; 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 // It's a pointer typedef like "typedef struct X *Y", continue parsing
} }
// Skip function pointer typedefs (contain parentheses) // Skip function pointer typedefs (contain parentheses)
if (std.mem.indexOf(u8, line, "(") != null) { if (std.mem.indexOf(u8, line, "(") != null) {
self.pos = start; self.pos = start;
return null; return null;
} }
// Parse: typedef Type Name; or typedef struct X *Name; // Parse: typedef Type Name; or typedef struct X *Name;
const trimmed = std.mem.trim(u8, line, " \t\r\n"); const trimmed = std.mem.trim(u8, line, " \t\r\n");
const no_semi = std.mem.trimRight(u8, trimmed, ";"); const no_semi = std.mem.trimRight(u8, trimmed, ";");
// Find the last token as the name // Find the last token as the name
var tokens = std.mem.tokenizeScalar(u8, no_semi, ' '); var tokens = std.mem.tokenizeScalar(u8, no_semi, ' ');
_ = tokens.next(); // Skip "typedef" _ = tokens.next(); // Skip "typedef"
// Collect all remaining tokens // Collect all remaining tokens
var token_list = std.ArrayList([]const u8).initCapacity(self.allocator, 4) catch { var token_list = std.ArrayList([]const u8).initCapacity(self.allocator, 4) catch {
self.pos = start; self.pos = start;
@ -345,12 +354,12 @@ pub const Scanner = struct {
while (tokens.next()) |token| { while (tokens.next()) |token| {
try token_list.append(self.allocator, token); try token_list.append(self.allocator, token);
} }
if (token_list.items.len < 2) { if (token_list.items.len < 2) {
self.pos = start; self.pos = start;
return null; return null;
} }
// Last token is the name (may have * prefix for pointer typedefs) // Last token is the name (may have * prefix for pointer typedefs)
var name_raw = token_list.items[token_list.items.len - 1]; var name_raw = token_list.items[token_list.items.len - 1];
// Strip leading * if present and track it // Strip leading * if present and track it
@ -359,7 +368,7 @@ pub const Scanner = struct {
name_raw[1..] name_raw[1..]
else else
name_raw; name_raw;
// Everything before the name is the underlying type // Everything before the name is the underlying type
// For "struct XTaskQueueObject *XTaskQueueHandle", we want "struct XTaskQueueObject *" // For "struct XTaskQueueObject *XTaskQueueHandle", we want "struct XTaskQueueObject *"
var type_buf = std.ArrayList(u8).initCapacity(self.allocator, 64) catch { var type_buf = std.ArrayList(u8).initCapacity(self.allocator, 64) catch {
@ -367,7 +376,7 @@ pub const Scanner = struct {
return null; return null;
}; };
defer type_buf.deinit(self.allocator); 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, ' '); if (i > 0) try type_buf.append(self.allocator, ' ');
try type_buf.appendSlice(self.allocator, token); try type_buf.appendSlice(self.allocator, token);
} }
@ -377,16 +386,17 @@ pub const Scanner = struct {
try type_buf.append(self.allocator, '*'); try type_buf.append(self.allocator, '*');
} }
const underlying_type = try type_buf.toOwnedSlice(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 // Make sure it's an SDL type or one of the known Windows types
if (!std.mem.startsWith(u8, name, "SDL_") and if (!std.mem.startsWith(u8, name, "SDL_") and
!std.mem.eql(u8, name, "XTaskQueueHandle") and !std.mem.eql(u8, name, "XTaskQueueHandle") and
!std.mem.eql(u8, name, "XUserHandle")) { !std.mem.eql(u8, name, "XUserHandle"))
{
self.allocator.free(underlying_type); self.allocator.free(underlying_type);
self.pos = start; self.pos = start;
return null; return null;
} }
return TypedefDecl{ return TypedefDecl{
.name = try self.allocator.dupe(u8, name), .name = try self.allocator.dupe(u8, name),
.underlying_type = try self.allocator.dupe(u8, underlying_type), .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; // Pattern: typedef enum SDL_Foo { ... } SDL_Foo;
fn scanEnum(self: *Scanner) !?EnumDecl { fn scanEnum(self: *Scanner) !?EnumDecl {
const start = self.pos; const start = self.pos;
@ -442,25 +462,46 @@ pub const Scanner = struct {
} }
seen_names.deinit(); seen_names.deinit();
} }
var lines = std.mem.splitScalar(u8, body, '\n'); var lines = std.mem.splitScalar(u8, body, '\n');
var in_multiline_comment = false; var in_multiline_comment = false;
while (lines.next()) |line| { 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 (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) // Track multi-line comments (both /** and /* styles)
if (std.mem.indexOf(u8, trimmed, "/*")) |_| { if (std.mem.indexOf(u8, trimmed, "/*")) |_| {
in_multiline_comment = true; in_multiline_comment = true;
} }
if (in_multiline_comment) { if (in_multiline_comment) {
if (std.mem.indexOf(u8, trimmed, "*/")) |_| { if (std.mem.indexOf(u8, trimmed, "*/")) |_| {
in_multiline_comment = false; 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 // Skip various comment/bracket/preprocessor lines
if (std.mem.startsWith(u8, trimmed, "//")) continue; if (std.mem.startsWith(u8, trimmed, "//")) continue;
if (std.mem.startsWith(u8, trimmed, "*")) continue; // Lines inside comments if (std.mem.startsWith(u8, trimmed, "*")) continue; // Lines inside comments
@ -528,7 +569,7 @@ pub const Scanner = struct {
} }
return EnumValue{ return EnumValue{
.name = try self.allocator.dupe(u8, name), .name = fixupZigName(name),
.value = value, .value = value,
.comment = comment, .comment = comment,
}; };
@ -577,10 +618,10 @@ pub const Scanner = struct {
var fields = try std.ArrayList(FieldDecl).initCapacity(self.allocator, 20); var fields = try std.ArrayList(FieldDecl).initCapacity(self.allocator, 20);
var lines = std.mem.splitScalar(u8, body, '\n'); var lines = std.mem.splitScalar(u8, body, '\n');
var in_multiline_comment = false; var in_multiline_comment = false;
while (lines.next()) |line| { while (lines.next()) |line| {
const trimmed = std.mem.trim(u8, line, " \t\r"); const trimmed = std.mem.trim(u8, line, " \t\r");
// Track multi-line comments (both /** and /*) // Track multi-line comments (both /** and /*)
// Only start tracking if /* appears without */ on the same line // Only start tracking if /* appears without */ on the same line
if (!in_multiline_comment) { if (!in_multiline_comment) {
@ -603,13 +644,13 @@ pub const Scanner = struct {
} }
continue; continue;
} }
// Skip comment/bracket/preprocessor lines // Skip comment/bracket/preprocessor lines
if (trimmed.len == 0) continue; 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; 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 // First try single-field parsing
if (try self.parseStructField(line)) |field| { if (try self.parseStructField(line)) |field| {
try fields.append(self.allocator, 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 fields = try std.ArrayList(FieldDecl).initCapacity(self.allocator, 20);
var lines = std.mem.splitScalar(u8, body, '\n'); var lines = std.mem.splitScalar(u8, body, '\n');
var in_multiline_comment = false; var in_multiline_comment = false;
while (lines.next()) |line| { while (lines.next()) |line| {
const trimmed = std.mem.trim(u8, line, " \t\r"); const trimmed = std.mem.trim(u8, line, " \t\r");
// Track multi-line comments (both /** and /*) // Track multi-line comments (both /** and /*)
// Only start tracking if /* appears without */ on the same line // Only start tracking if /* appears without */ on the same line
if (!in_multiline_comment) { if (!in_multiline_comment) {
@ -702,13 +743,13 @@ pub const Scanner = struct {
} }
continue; continue;
} }
// Skip comment/bracket/preprocessor lines // Skip comment/bracket/preprocessor lines
if (trimmed.len == 0) continue; 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; 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 // Reuse struct field parsing since unions have same field syntax
if (try self.parseStructField(line)) |field| { if (try self.parseStructField(line)) |field| {
try fields.append(self.allocator, field); try fields.append(self.allocator, field);
@ -746,7 +787,7 @@ pub const Scanner = struct {
// Extract inline comment // Extract inline comment
var comment: ?[]const u8 = null; var comment: ?[]const u8 = null;
errdefer if (comment) |c| self.allocator.free(c); errdefer if (comment) |c| self.allocator.free(c);
var field_part = no_semi; var field_part = no_semi;
if (std.mem.indexOf(u8, no_semi, "/**<")) |comment_start| { if (std.mem.indexOf(u8, no_semi, "/**<")) |comment_start| {
field_part = std.mem.trimRight(u8, no_semi[0..comment_start], "; \t"); 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) // Check for function pointer field: RetType (SDLCALL *field_name)(params)
if (std.mem.indexOf(u8, field_part, "(SDLCALL *")) |sdlcall_pos| { if (std.mem.indexOf(u8, field_part, "(SDLCALL *")) |sdlcall_pos| {
// Find the * after SDLCALL // 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| { if (std.mem.indexOf(u8, after_sdlcall, ")")) |close_paren| {
const field_name = std.mem.trim(u8, after_sdlcall[0..close_paren], " \t"); 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) // The entire thing is the type (we'll convert to Zig function pointer syntax later)
return FieldDecl{ 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")), .type_name = try self.allocator.dupe(u8, std.mem.trim(u8, field_part, " \t")),
.comment = comment, .comment = comment,
}; };
} }
} else if (std.mem.indexOf(u8, field_part, "(*")) |star_pos| { } else if (std.mem.indexOf(u8, field_part, "(*")) |star_pos| {
// Handle non-SDLCALL function pointers: RetType (*field_name)(params) // 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| { if (std.mem.indexOf(u8, after_star, ")")) |close_paren| {
const field_name = std.mem.trim(u8, after_star[0..close_paren], " \t"); 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) // The entire thing is the type (we'll convert to Zig function pointer syntax later)
return FieldDecl{ 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")), .type_name = try self.allocator.dupe(u8, std.mem.trim(u8, field_part, " \t")),
.comment = comment, .comment = comment,
}; };
@ -788,12 +829,12 @@ pub const Scanner = struct {
// Check if this line contains multiple comma-separated fields (e.g., "int x, y;") // 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) // Only split on commas that are not inside nested structures (ignore for now)
const field_trimmed = std.mem.trim(u8, field_part, " \t"); 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 // 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_comma = std.mem.indexOf(u8, field_trimmed, ",") != null;
const has_parens = 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; const has_brackets = std.mem.indexOf(u8, field_trimmed, "[") != null;
if (has_comma and !has_parens and !has_brackets) { if (has_comma and !has_parens and !has_brackets) {
// This is a multi-field declaration like "int x, y" // 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 // 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); if (comment) |c| self.allocator.free(c);
return null; return null;
} }
// Parse "type name" or "type name[size]" - handle pointer types and arrays correctly // Parse "type name" or "type name[size]" - handle pointer types and arrays correctly
// Examples: // 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" // "Uint32 offset" -> type:"Uint32" name:"offset"
// "Uint8 padding[2]" -> type:"Uint8[2]" name:"padding" // "Uint8 padding[2]" -> type:"Uint8[2]" name:"padding"
// Check if this is an array field (has brackets) // Check if this is an array field (has brackets)
if (std.mem.indexOf(u8, field_trimmed, "[")) |bracket_pos| { if (std.mem.indexOf(u8, field_trimmed, "[")) |bracket_pos| {
// Extract array size and append to type // Extract array size and append to type
// Pattern: "Uint8 padding[2]" -> parse as type="Uint8[2]" name="padding" // 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 before_bracket = std.mem.trimRight(u8, field_trimmed[0..bracket_pos], " \t");
const bracket_part = field_trimmed[bracket_pos..]; // "[2]" const bracket_part = field_trimmed[bracket_pos..]; // "[2]"
// Split before_bracket into type and name // Split before_bracket into type and name
var tokens = std.mem.tokenizeScalar(u8, before_bracket, ' '); var tokens = std.mem.tokenizeScalar(u8, before_bracket, ' ');
var parts_list: [8][]const u8 = undefined; var parts_list: [8][]const u8 = undefined;
@ -829,15 +870,15 @@ pub const Scanner = struct {
parts_count += 1; parts_count += 1;
} }
} }
if (parts_count < 2) { if (parts_count < 2) {
if (comment) |c| self.allocator.free(c); if (comment) |c| self.allocator.free(c);
return null; // Need at least type and name return null; // Need at least type and name
} }
const name = parts_list[parts_count - 1]; 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 // Reconstruct type with array notation
var type_buf: [128]u8 = undefined; var type_buf: [128]u8 = undefined;
var fbs = std.io.fixedBufferStream(&type_buf); var fbs = std.io.fixedBufferStream(&type_buf);
@ -856,21 +897,21 @@ pub const Scanner = struct {
if (comment) |c| self.allocator.free(c); if (comment) |c| self.allocator.free(c);
return null; return null;
}; };
const type_str = fbs.getWritten(); const type_str = fbs.getWritten();
return FieldDecl{ return FieldDecl{
.name = try self.allocator.dupe(u8, name), .name = fixupZigName(name),
.type_name = try self.allocator.dupe(u8, type_str), .type_name = try self.allocator.dupe(u8, type_str),
.comment = comment, .comment = comment,
}; };
} }
// Find last identifier by scanning backwards for alphanumeric/_ // Find last identifier by scanning backwards for alphanumeric/_
// The field name is the last contiguous sequence of [a-zA-Z0-9_] // The field name is the last contiguous sequence of [a-zA-Z0-9_]
var name_end: usize = field_trimmed.len; var name_end: usize = field_trimmed.len;
var name_start: ?usize = null; var name_start: ?usize = null;
// Scan backwards to find the end of the last identifier (skip trailing whitespace) // Scan backwards to find the end of the last identifier (skip trailing whitespace)
while (name_end > 0) { while (name_end > 0) {
const c = field_trimmed[name_end - 1]; const c = field_trimmed[name_end - 1];
@ -879,7 +920,7 @@ pub const Scanner = struct {
} }
name_end -= 1; name_end -= 1;
} }
// Now scan backwards from name_end to find where the identifier starts // Now scan backwards from name_end to find where the identifier starts
if (name_end > 0) { if (name_end > 0) {
var i: usize = name_end; var i: usize = name_end;
@ -896,14 +937,14 @@ pub const Scanner = struct {
name_start = 0; name_start = 0;
} }
} }
if (name_start) |start| { if (name_start) |start| {
const name = field_trimmed[start..name_end]; const name = field_trimmed[start..name_end];
const type_part = std.mem.trim(u8, field_trimmed[0..start], " \t"); const type_part = std.mem.trim(u8, field_trimmed[0..start], " \t");
if (name.len > 0 and type_part.len > 0) { if (name.len > 0 and type_part.len > 0) {
return FieldDecl{ return FieldDecl{
.name = try self.allocator.dupe(u8, name), .name = fixupZigName(name),
.type_name = try self.allocator.dupe(u8, type_part), .type_name = try self.allocator.dupe(u8, type_part),
.comment = comment, .comment = comment,
}; };
@ -913,7 +954,7 @@ pub const Scanner = struct {
if (comment) |c| self.allocator.free(c); if (comment) |c| self.allocator.free(c);
return null; return null;
} }
// Parse multi-field declaration like "int x, y;" into separate fields // Parse multi-field declaration like "int x, y;" into separate fields
fn parseMultiFieldLine(self: *Scanner, line: []const u8) ![]FieldDecl { fn parseMultiFieldLine(self: *Scanner, line: []const u8) ![]FieldDecl {
const trimmed = std.mem.trim(u8, line, " \t\r"); 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{}; 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 // Remove trailing semicolon
const no_semi = std.mem.trimRight(u8, trimmed, ";"); const no_semi = std.mem.trimRight(u8, trimmed, ";");
// Extract inline comment if present // Extract inline comment if present
var comment: ?[]const u8 = null; var comment: ?[]const u8 = null;
var field_part = no_semi; var field_part = no_semi;
@ -937,19 +978,19 @@ pub const Scanner = struct {
} }
} }
defer if (comment) |c| self.allocator.free(c); defer if (comment) |c| self.allocator.free(c);
const field_trimmed = std.mem.trim(u8, field_part, " \t"); const field_trimmed = std.mem.trim(u8, field_part, " \t");
// Check if this is actually a multi-field line // Check if this is actually a multi-field line
const has_comma = std.mem.indexOf(u8, field_trimmed, ",") != null; const has_comma = std.mem.indexOf(u8, field_trimmed, ",") != null;
if (!has_comma) { if (!has_comma) {
return &[_]FieldDecl{}; return &[_]FieldDecl{};
} }
// Parse pattern: "type name1, name2, name3" // Parse pattern: "type name1, name2, name3"
// Find where the type ends (last space before first comma) // Find where the type ends (last space before first comma)
const first_comma = std.mem.indexOf(u8, field_trimmed, ",") orelse return &[_]FieldDecl{}; const first_comma = std.mem.indexOf(u8, field_trimmed, ",") orelse return &[_]FieldDecl{};
// Everything before the first field name is the type // Everything before the first field name is the type
// Scan backwards from first comma to find where the first name starts // Scan backwards from first comma to find where the first name starts
var type_end: usize = first_comma; var type_end: usize = first_comma;
@ -960,30 +1001,30 @@ pub const Scanner = struct {
} }
type_end -= 1; type_end -= 1;
} }
// Type is everything from start to type_end // Type is everything from start to type_end
const type_part = std.mem.trim(u8, field_trimmed[0..type_end], " \t"); const type_part = std.mem.trim(u8, field_trimmed[0..type_end], " \t");
if (type_part.len == 0) { if (type_part.len == 0) {
return &[_]FieldDecl{}; return &[_]FieldDecl{};
} }
// Now parse the comma-separated field names // Now parse the comma-separated field names
const names_part = field_trimmed[type_end..]; const names_part = field_trimmed[type_end..];
var field_list = std.ArrayList(FieldDecl){}; var field_list = std.ArrayList(FieldDecl){};
var name_iter = std.mem.splitScalar(u8, names_part, ','); var name_iter = std.mem.splitScalar(u8, names_part, ',');
while (name_iter.next()) |name_raw| { while (name_iter.next()) |name_raw| {
const name = std.mem.trim(u8, name_raw, " \t*"); const name = std.mem.trim(u8, name_raw, " \t*");
if (name.len > 0) { if (name.len > 0) {
try field_list.append(self.allocator, FieldDecl{ 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), .type_name = try self.allocator.dupe(u8, type_part),
.comment = if (comment) |c| try self.allocator.dupe(u8, c) else null, .comment = if (comment) |c| try self.allocator.dupe(u8, c) else null,
}); });
} }
} }
return try field_list.toOwnedSlice(self.allocator); return try field_list.toOwnedSlice(self.allocator);
} }
@ -1044,7 +1085,7 @@ pub const Scanner = struct {
const doc = self.consumePendingDocComment(); const doc = self.consumePendingDocComment();
return FlagDecl{ return FlagDecl{
.name = try self.allocator.dupe(u8, clean_name), .name = fixupZigName(clean_name),
.underlying_type = try self.allocator.dupe(u8, underlying), .underlying_type = try self.allocator.dupe(u8, underlying),
.flags = try flags.toOwnedSlice(self.allocator), .flags = try flags.toOwnedSlice(self.allocator),
.doc_comment = doc, .doc_comment = doc,
@ -1111,7 +1152,7 @@ pub const Scanner = struct {
// Parse: ReturnType SDLCALL FunctionName(params); // Parse: ReturnType SDLCALL FunctionName(params);
const doc = self.consumePendingDocComment(); const doc = self.consumePendingDocComment();
var text = func_text.items; var text = func_text.items;
// Strip format string attribute macros // Strip format string attribute macros
const macros_to_strip = [_][]const u8{ const macros_to_strip = [_][]const u8{
"SDL_PRINTF_FORMAT_STRING ", "SDL_PRINTF_FORMAT_STRING ",
@ -1125,14 +1166,14 @@ pub const Scanner = struct {
const after = text[pos + macro.len ..]; const after = text[pos + macro.len ..];
const new_text = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{ before, after }); const new_text = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{ before, after });
defer self.allocator.free(new_text); defer self.allocator.free(new_text);
// Replace func_text content // Replace func_text content
func_text.clearRetainingCapacity(); func_text.clearRetainingCapacity();
try func_text.appendSlice(self.allocator, new_text); try func_text.appendSlice(self.allocator, new_text);
text = func_text.items; text = func_text.items;
} }
} }
// Strip vararg function macros from end (e.g., SDL_PRINTF_VARARG_FUNC(1)) // Strip vararg function macros from end (e.g., SDL_PRINTF_VARARG_FUNC(1))
const vararg_macros = [_][]const u8{ const vararg_macros = [_][]const u8{
"SDL_PRINTF_VARARG_FUNC", "SDL_PRINTF_VARARG_FUNC",
@ -1155,7 +1196,7 @@ pub const Scanner = struct {
const after = text[paren_pos + 1 ..]; const after = text[paren_pos + 1 ..];
const new_text = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{ before, after }); const new_text = try std.fmt.allocPrint(self.allocator, "{s}{s}", .{ before, after });
defer self.allocator.free(new_text); defer self.allocator.free(new_text);
func_text.clearRetainingCapacity(); func_text.clearRetainingCapacity();
try func_text.appendSlice(self.allocator, new_text); try func_text.appendSlice(self.allocator, new_text);
text = func_text.items; text = func_text.items;
@ -1210,7 +1251,7 @@ pub const Scanner = struct {
// Handle array syntax like "char *argv[]" -> type:"char **" name:"argv" // Handle array syntax like "char *argv[]" -> type:"char **" name:"argv"
var working_param = trimmed; var working_param = trimmed;
var is_array = false; var is_array = false;
// Check for array brackets [] and remove them // Check for array brackets [] and remove them
if (std.mem.lastIndexOfScalar(u8, working_param, '[')) |bracket_pos| { if (std.mem.lastIndexOfScalar(u8, working_param, '[')) |bracket_pos| {
// Find matching ] // Find matching ]
@ -1219,13 +1260,13 @@ pub const Scanner = struct {
working_param = std.mem.trimRight(u8, working_param[0..bracket_pos], " \t"); 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 // 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' // Start from the end and find the last word that's not 'const' or 'restrict'
var name_start: usize = 0; var name_start: usize = 0;
var i = working_param.len; var i = working_param.len;
var found_name = false; var found_name = false;
// First, find the last identifier // First, find the last identifier
while (i > 0 and !found_name) { while (i > 0 and !found_name) {
i -= 1; i -= 1;
@ -1243,7 +1284,7 @@ pub const Scanner = struct {
} }
} }
} }
if (!found_name and working_param.len > 0) { if (!found_name and working_param.len > 0) {
// If we never found a separator, the whole thing might be the name // If we never found a separator, the whole thing might be the name
// Check if it's not a type keyword // Check if it's not a type keyword
@ -1261,7 +1302,7 @@ pub const Scanner = struct {
} else { } else {
var param_type = std.mem.trim(u8, working_param[0..name_start], " \t"); 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"); var param_name = std.mem.trim(u8, working_param[name_start..], " \t");
// If param_name starts with *, it belongs to the type // If param_name starts with *, it belongs to the type
// e.g., "SDL_GPUFence *const" and "*fences" should be "SDL_GPUFence *const *" and "fences" // e.g., "SDL_GPUFence *const" and "*fences" should be "SDL_GPUFence *const *" and "fences"
var type_buf: [512]u8 = undefined; var type_buf: [512]u8 = undefined;
@ -1270,7 +1311,7 @@ pub const Scanner = struct {
param_type = new_type; param_type = new_type;
param_name = std.mem.trimLeft(u8, param_name[1..], " \t"); param_name = std.mem.trimLeft(u8, param_name[1..], " \t");
} }
// If this was an array parameter, convert pointer level // If this was an array parameter, convert pointer level
// e.g., "char *" becomes "[*c][*c]char" for argv[] // e.g., "char *" becomes "[*c][*c]char" for argv[]
if (is_array) { if (is_array) {
@ -1291,7 +1332,7 @@ pub const Scanner = struct {
} }
try params_list.append(self.allocator, ParamDecl{ 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), .type_name = try self.allocator.dupe(u8, param_type),
}); });
} }

37
lib/sdl3/v2/assert.zig vendored
View File

@ -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();
}

61
lib/sdl3/v2/asyncio.zig vendored
View File

@ -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);
}

70
lib/sdl3/v2/atomic.zig vendored
View File

@ -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);
}

12
lib/sdl3/v2/audio.zig vendored
View File

@ -10,9 +10,15 @@ pub const IOStream = opaque {
}; };
pub const AudioFormat = enum(c_int) { pub const AudioFormat = enum(c_int) {
audioS16, audioUnknown, //Unspecified audio format
audioS32, audioU8, //Unsigned 8-bit samples
audioF32, audioS8, //Signed 8-bit samples
audioS16le, //Signed 16-bit samples
audioS16be, //As above, but big-endian byte order
audioS32le, //32-bit integer samples
audioS32be, //As above, but big-endian byte order
audioF32le, //32-bit floating point samples
audioF32be, //As above, but big-endian byte order
}; };
pub const AudioDeviceID = u32; pub const AudioDeviceID = u32;

21
lib/sdl3/v2/blendmode.zig vendored
View File

@ -3,6 +3,27 @@ pub const c = @import("c.zig").c;
pub const BlendMode = u32; 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 { 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))); return @intFromEnum(c.SDL_ComposeCustomBlendMode(srcColorFactor, dstColorFactor, @intFromEnum(colorOperation), srcAlphaFactor, dstAlphaFactor, @intFromEnum(alphaOperation)));
} }

100
lib/sdl3/v2/camera.zig vendored
View File

@ -2,75 +2,47 @@ const std = @import("std");
pub const c = @import("c.zig").c; pub const c = @import("c.zig").c;
pub const PixelFormat = enum(c_int) { pub const PixelFormat = enum(c_int) {
pixelformatUnknown, pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIndex1lsb, pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatIndex1msb, pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatIndex2lsb, pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatIndex2msb, pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatIndex4lsb, pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatIndex4msb, pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatIndex8, pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatRgb332, pixelformatExternalOes, //Android video texture format
pixelformatXrgb4444, pixelformatMjpg, //Motion JPEG
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 Surface = opaque {}; pub const Surface = opaque {};
pub const Colorspace = enum(c_int) { 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; pub const PropertiesID = u32;

74
lib/sdl3/v2/cpuinfo.zig vendored
View File

@ -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();
}

4
lib/sdl3/v2/dialog.zig vendored
View File

@ -30,6 +30,6 @@ pub const FileDialogType = enum(c_int) {
filedialogOpenfolder, filedialogOpenfolder,
}; };
pub inline fn showFileDialogWithProperties(type: FileDialogType, callback: DialogFileCallback, userdata: ?*anyopaque, props: PropertiesID) void { pub inline fn showFileDialogWithProperties(_type: FileDialogType, callback: DialogFileCallback, userdata: ?*anyopaque, props: PropertiesID) void {
return c.SDL_ShowFileDialogWithProperties(@intFromEnum(type), callback, userdata, props); return c.SDL_ShowFileDialogWithProperties(@intFromEnum(_type), callback, userdata, props);
} }

752
lib/sdl3/v2/events.zig vendored
View File

@ -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));
}

30
lib/sdl3/v2/filesystem.zig vendored
View File

@ -11,12 +11,34 @@ pub inline fn getPrefPath(org: [*c]const u8, app: [*c]const u8) [*c]u8 {
return c.SDL_GetPrefPath(org, app); 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 { pub inline fn getUserFolder(folder: Folder) [*c]const u8 {
return c.SDL_GetUserFolder(folder); 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 { pub const PathInfo = extern struct {
type: PathType, // the path type _type: PathType, // the path type
size: u64, // the file size in bytes size: u64, // the file size in bytes
create_time: Time, // the time when the path was created create_time: Time, // the time when the path was created
modify_time: Time, // the last time the path was modified 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); 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 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 { pub inline fn enumerateDirectory(path: [*c]const u8, callback: EnumerateDirectoryCallback, userdata: ?*anyopaque) bool {

68
lib/sdl3/v2/gamepad.zig vendored
View File

@ -2,7 +2,6 @@ const std = @import("std");
pub const c = @import("c.zig").c; pub const c = @import("c.zig").c;
pub const JoystickConnectionState = enum(c_int) { pub const JoystickConnectionState = enum(c_int) {
joystickConnectionInvalid,
joystickConnectionUnknown, joystickConnectionUnknown,
joystickConnectionWired, joystickConnectionWired,
joystickConnectionWireless, joystickConnectionWireless,
@ -22,6 +21,26 @@ pub const IOStream = opaque {
pub const JoystickID = u32; 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 Joystick = opaque {};
pub const Gamepad = 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)); return c.SDL_GetGamepadTouchpadFinger(gamepad, touchpad, finger, @ptrCast(down), @ptrCast(x), @ptrCast(y), @ptrCast(pressure));
} }
pub inline fn gamepadHasSensor(gamepad: *Gamepad, type: SensorType) bool { pub inline fn gamepadHasSensor(gamepad: *Gamepad, _type: SensorType) bool {
return c.SDL_GamepadHasSensor(gamepad, @intFromEnum(type)); return c.SDL_GamepadHasSensor(gamepad, @intFromEnum(_type));
} }
pub inline fn setGamepadSensorEnabled(gamepad: *Gamepad, type: SensorType, enabled: bool) bool { pub inline fn setGamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType, enabled: bool) bool {
return c.SDL_SetGamepadSensorEnabled(gamepad, @intFromEnum(type), enabled); return c.SDL_SetGamepadSensorEnabled(gamepad, @intFromEnum(_type), enabled);
} }
pub inline fn gamepadSensorEnabled(gamepad: *Gamepad, type: SensorType) bool { pub inline fn gamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType) bool {
return c.SDL_GamepadSensorEnabled(gamepad, @intFromEnum(type)); return c.SDL_GamepadSensorEnabled(gamepad, @intFromEnum(_type));
} }
pub inline fn getGamepadSensorDataRate(gamepad: *Gamepad, type: SensorType) f32 { pub inline fn getGamepadSensorDataRate(gamepad: *Gamepad, _type: SensorType) f32 {
return c.SDL_GetGamepadSensorDataRate(gamepad, @intFromEnum(type)); return c.SDL_GetGamepadSensorDataRate(gamepad, @intFromEnum(_type));
} }
pub inline fn getGamepadSensorData(gamepad: *Gamepad, type: SensorType, data: *f32, num_values: c_int) bool { 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); 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 { 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) { pub const GamepadType = enum(c_int) {
gamepadTypeUnknown,
gamepadTypeStandard, gamepadTypeStandard,
gamepadTypeXbox360, gamepadTypeXbox360,
gamepadTypeXboxone, gamepadTypeXboxone,
@ -202,7 +220,10 @@ pub const GamepadType = enum(c_int) {
}; };
pub const GamepadButton = 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, gamepadButtonBack,
gamepadButtonGuide, gamepadButtonGuide,
gamepadButtonStart, gamepadButtonStart,
@ -214,6 +235,17 @@ pub const GamepadButton = enum(c_int) {
gamepadButtonDpadDown, gamepadButtonDpadDown,
gamepadButtonDpadLeft, gamepadButtonDpadLeft,
gamepadButtonDpadRight, 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, gamepadButtonCount,
}; };
@ -230,7 +262,6 @@ pub const GamepadButtonLabel = enum(c_int) {
}; };
pub const GamepadAxis = enum(c_int) { pub const GamepadAxis = enum(c_int) {
gamepadAxisInvalid,
gamepadAxisLeftx, gamepadAxisLeftx,
gamepadAxisLefty, gamepadAxisLefty,
gamepadAxisRightx, gamepadAxisRightx,
@ -241,7 +272,6 @@ pub const GamepadAxis = enum(c_int) {
}; };
pub const GamepadBindingType = enum(c_int) { pub const GamepadBindingType = enum(c_int) {
gamepadBindtypeNone,
gamepadBindtypeButton, gamepadBindtypeButton,
gamepadBindtypeAxis, gamepadBindtypeAxis,
gamepadBindtypeHat, gamepadBindtypeHat,
@ -366,8 +396,8 @@ pub inline fn getGamepadTypeFromString(str: [*c]const u8) GamepadType {
return @intFromEnum(c.SDL_GetGamepadTypeFromString(str)); return @intFromEnum(c.SDL_GetGamepadTypeFromString(str));
} }
pub inline fn getGamepadStringForType(type: GamepadType) [*c]const u8 { pub inline fn getGamepadStringForType(_type: GamepadType) [*c]const u8 {
return c.SDL_GetGamepadStringForType(@intFromEnum(type)); return c.SDL_GetGamepadStringForType(@intFromEnum(_type));
} }
pub inline fn getGamepadAxisFromString(str: [*c]const u8) GamepadAxis { 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); return c.SDL_GetGamepadStringForButton(button);
} }
pub inline fn getGamepadButtonLabelForType(type: GamepadType, button: GamepadButton) GamepadButtonLabel { pub inline fn getGamepadButtonLabelForType(_type: GamepadType, button: GamepadButton) GamepadButtonLabel {
return c.SDL_GetGamepadButtonLabelForType(@intFromEnum(type), button); return c.SDL_GetGamepadButtonLabelForType(@intFromEnum(_type), button);
} }

124
lib/sdl3/v2/gpu.zig vendored
View File

@ -19,6 +19,12 @@ pub const Rect = extern struct {
pub const Window = opaque {}; 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 const GPUDevice = opaque {
pub inline fn destroyGPUDevice(gpudevice: *GPUDevice) void { pub inline fn destroyGPUDevice(gpudevice: *GPUDevice) void {
return c.SDL_DestroyGPUDevice(gpudevice); return c.SDL_DestroyGPUDevice(gpudevice);
@ -156,8 +162,8 @@ pub const GPUDevice = opaque {
return c.SDL_ReleaseGPUFence(gpudevice, fence); return c.SDL_ReleaseGPUFence(gpudevice, fence);
} }
pub inline fn gpuTextureSupportsFormat(gpudevice: *GPUDevice, format: GPUTextureFormat, type: GPUTextureType, usage: GPUTextureUsageFlags) bool { pub inline fn gpuTextureSupportsFormat(gpudevice: *GPUDevice, format: GPUTextureFormat, _type: GPUTextureType, usage: GPUTextureUsageFlags) bool {
return c.SDL_GPUTextureSupportsFormat(gpudevice, @bitCast(format), @intFromEnum(type), @bitCast(usage)); return c.SDL_GPUTextureSupportsFormat(gpudevice, @bitCast(format), @intFromEnum(_type), @bitCast(usage));
} }
pub inline fn gpuTextureSupportsSampleCount(gpudevice: *GPUDevice, format: GPUTextureFormat, sample_count: GPUSampleCount) bool { 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 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) { pub const GPUTextureFormat = enum(c_int) {
textureformatInvalid, textureformatInvalid,
textureformatA8Unorm, textureformatA8Unorm,
@ -509,6 +541,21 @@ pub const GPUTextureUsageFlags = packed struct(u32) {
rsvd: bool = false, 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) { pub const GPUCubeMapFace = enum(c_int) {
cubemapfacePositivex, cubemapfacePositivex,
cubemapfaceNegativex, cubemapfaceNegativex,
@ -575,20 +622,75 @@ pub const GPUVertexElementFormat = enum(c_int) {
vertexelementformatHalf4, 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) { pub const GPUCompareOp = enum(c_int) {
compareopInvalid, 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) { pub const GPUStencilOp = enum(c_int) {
stencilopInvalid, 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) { pub const GPUBlendOp = enum(c_int) {
blendopInvalid, 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) { pub const GPUBlendFactor = enum(c_int) {
blendfactorInvalid, 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) { pub const GPUColorComponentFlags = packed struct(u8) {
@ -600,6 +702,22 @@ pub const GPUColorComponentFlags = packed struct(u8) {
rsvd: bool = false, 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) { pub const GPUPresentMode = enum(c_int) {
presentmodeVsync, presentmodeVsync,
presentmodeImmediate, presentmodeImmediate,
@ -772,7 +890,7 @@ pub const GPUShaderCreateInfo = extern struct {
}; };
pub const GPUTextureCreateInfo = 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. format: GPUTextureFormat, // The pixel format of the texture.
usage: GPUTextureUsageFlags, // How the texture is intended to be used by the client. usage: GPUTextureUsageFlags, // How the texture is intended to be used by the client.
width: u32, // The width of the texture. width: u32, // The width of the texture.

14
lib/sdl3/v2/guid.zig vendored
View File

@ -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);
}

12
lib/sdl3/v2/haptic.zig vendored
View File

@ -106,12 +106,12 @@ pub const Haptic = opaque {
}; };
pub const HapticDirection = extern struct { pub const HapticDirection = extern struct {
type: u8, // The type of encoding. _type: u8, // The type of encoding.
dir: [3]i32, // The encoded direction. dir: [3]i32, // The encoded direction.
}; };
pub const HapticConstant = extern struct { pub const HapticConstant = extern struct {
type: u16, // SDL_HAPTIC_CONSTANT _type: u16, // SDL_HAPTIC_CONSTANT
direction: HapticDirection, // Direction of the effect. direction: HapticDirection, // Direction of the effect.
length: u32, // Duration of the effect. length: u32, // Duration of the effect.
delay: u16, // Delay before starting the effect. delay: u16, // Delay before starting the effect.
@ -155,7 +155,7 @@ pub const HapticCondition = extern struct {
}; };
pub const HapticRamp = extern struct { pub const HapticRamp = extern struct {
type: u16, // SDL_HAPTIC_RAMP _type: u16, // SDL_HAPTIC_RAMP
direction: HapticDirection, // Direction of the effect. direction: HapticDirection, // Direction of the effect.
length: u32, // Duration of the effect. length: u32, // Duration of the effect.
delay: u16, // Delay before starting the effect. delay: u16, // Delay before starting the effect.
@ -170,14 +170,14 @@ pub const HapticRamp = extern struct {
}; };
pub const HapticLeftRight = 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. length: u32, // Duration of the effect in milliseconds.
large_magnitude: u16, // Control of the large controller motor. large_magnitude: u16, // Control of the large controller motor.
small_magnitude: u16, // Control of the small controller motor. small_magnitude: u16, // Control of the small controller motor.
}; };
pub const HapticCustom = extern struct { pub const HapticCustom = extern struct {
type: u16, // SDL_HAPTIC_CUSTOM _type: u16, // SDL_HAPTIC_CUSTOM
direction: HapticDirection, // Direction of the effect. direction: HapticDirection, // Direction of the effect.
length: u32, // Duration of the effect. length: u32, // Duration of the effect.
delay: u16, // Delay before starting the effect. delay: u16, // Delay before starting the effect.
@ -194,7 +194,7 @@ pub const HapticCustom = extern struct {
}; };
pub const HapticEffect = extern union { pub const HapticEffect = extern union {
type: u16, // Effect type. _type: u16, // Effect type.
constant: HapticConstant, // Constant effect. constant: HapticConstant, // Constant effect.
periodic: HapticPeriodic, // Periodic effect. periodic: HapticPeriodic, // Periodic effect.
condition: HapticCondition, // Condition effect. condition: HapticCondition, // Condition effect.

120
lib/sdl3/v2/hidapi.zig vendored
View File

@ -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);
}

8
lib/sdl3/v2/init.zig vendored
View File

@ -2,7 +2,7 @@ const std = @import("std");
pub const c = @import("c.zig").c; pub const c = @import("c.zig").c;
pub const Event = extern union { 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 common: CommonEvent, // Common event data
display: DisplayEvent, // Display event data display: DisplayEvent, // Display event data
window: WindowEvent, // Window event data window: WindowEvent, // Window event data
@ -56,6 +56,12 @@ pub const InitFlags = packed struct(u32) {
rsvd: bool = false, 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 AppInit_func = *const fn (appstate: [*c]?*anyopaque, argc: c_int, argv: [*c][*c]u8) callconv(.C) AppResult;
pub const AppIterate_func = *const fn (appstate: ?*anyopaque) callconv(.C) AppResult; pub const AppIterate_func = *const fn (appstate: ?*anyopaque) callconv(.C) AppResult;

211
lib/sdl3/v2/iostream.zig vendored
View File

@ -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);
}

29
lib/sdl3/v2/joystick.zig vendored
View File

@ -3,10 +3,30 @@ pub const c = @import("c.zig").c;
pub const PropertiesID = u32; 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 { pub const GUID = extern struct {
data: [16]u8, 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 const Joystick = opaque {
pub inline fn setJoystickVirtualAxis(joystick: *Joystick, axis: c_int, value: i16) bool { pub inline fn setJoystickVirtualAxis(joystick: *Joystick, axis: c_int, value: i16) bool {
return c.SDL_SetJoystickVirtualAxis(joystick, axis, value); 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); 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 { 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); return c.SDL_SendJoystickVirtualSensorData(joystick, @intFromEnum(_type), sensor_timestamp, @ptrCast(data), num_values);
} }
pub inline fn getJoystickProperties(joystick: *Joystick) PropertiesID { pub inline fn getJoystickProperties(joystick: *Joystick) PropertiesID {
@ -170,7 +190,6 @@ pub const JoystickType = enum(c_int) {
}; };
pub const JoystickConnectionState = enum(c_int) { pub const JoystickConnectionState = enum(c_int) {
joystickConnectionInvalid,
joystickConnectionUnknown, joystickConnectionUnknown,
joystickConnectionWired, joystickConnectionWired,
joystickConnectionWireless, joystickConnectionWireless,
@ -242,13 +261,13 @@ pub const VirtualJoystickTouchpadDesc = extern struct {
}; };
pub const VirtualJoystickSensorDesc = 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 rate: f32, // the update frequency of this sensor, may be 0.0f
}; };
pub const VirtualJoystickDesc = extern struct { pub const VirtualJoystickDesc = extern struct {
version: u32, // the version of this interface version: u32, // the version of this interface
type: u16, // `SDL_JoystickType` _type: u16, // `SDL_JoystickType`
padding: u16, // unused padding: u16, // unused
vendor_id: u16, // the USB vendor ID of this joystick vendor_id: u16, // the USB vendor ID of this joystick
product_id: u16, // the USB product ID of this joystick product_id: u16, // the USB product ID of this joystick

297
lib/sdl3/v2/keyboard.zig vendored
View File

@ -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();
}

11
lib/sdl3/v2/locale.zig vendored
View File

@ -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));
}

138
lib/sdl3/v2/log.zig vendored
View File

@ -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);
}

1
lib/sdl3/v2/messagebox.zig vendored
View File

@ -38,6 +38,7 @@ pub const MessageBoxColorType = enum(c_int) {
messageboxColorButtonBorder, messageboxColorButtonBorder,
messageboxColorButtonBackground, messageboxColorButtonBackground,
messageboxColorButtonSelected, messageboxColorButtonSelected,
messageboxColorCount, //Size of the colors array of SDL_MessageBoxColorScheme.
}; };
pub const MessageBoxColorScheme = extern struct { pub const MessageBoxColorScheme = extern struct {

18
lib/sdl3/v2/metal.zig vendored
View File

@ -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);
}

25
lib/sdl3/v2/mouse.zig vendored
View File

@ -34,9 +34,34 @@ pub const Cursor = opaque {
}; };
pub const SystemCursor = enum(c_int) { 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, 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) { pub const MouseButtonFlags = packed struct(u32) {
buttonLeft: bool = false, buttonLeft: bool = false,
buttonMiddle: bool = false, buttonMiddle: bool = false,

145
lib/sdl3/v2/mutex.zig vendored
View File

@ -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);
}

2
lib/sdl3/v2/opengl.zig vendored
View File

@ -1,2 +0,0 @@
const std = @import("std");
pub const c = @import("c.zig").c;

16
lib/sdl3/v2/pen.zig vendored
View File

@ -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,
};

164
lib/sdl3/v2/pixels.zig vendored
View File

@ -58,107 +58,99 @@ pub const PackedLayout = enum(c_int) {
}; };
pub const PixelFormat = enum(c_int) { pub const PixelFormat = enum(c_int) {
pixelformatUnknown, pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIndex1lsb, pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatIndex1msb, pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatIndex2lsb, pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatIndex2msb, pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatIndex4lsb, pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatIndex4msb, pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatIndex8, pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatRgb332, pixelformatExternalOes, //Android video texture format
pixelformatXrgb4444, pixelformatMjpg, //Motion JPEG
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,
}; };
pub const ColorRange = enum(c_int) { 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) { pub const ColorPrimaries = enum(c_int) {
colorPrimariesUnknown, colorPrimariesBt709, //ITU-R BT.709-6
colorPrimariesUnspecified, colorPrimariesBt470m, //ITU-R BT.470-6 System M
colorPrimariesCustom, 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) { pub const TransferCharacteristics = enum(c_int) {
transferCharacteristicsUnknown, transferCharacteristicsBt709, //Rec. ITU-R BT.709-6 / ITU-R BT1361
transferCharacteristicsUnspecified, transferCharacteristicsGamma22, //ITU-R BT.470-6 System M / ITU-R BT1700 625 PAL & SECAM
transferCharacteristicsLinear, transferCharacteristicsGamma28, //ITU-R BT.470-6 System B, G
transferCharacteristicsLog100, transferCharacteristicsBt601, //SMPTE ST 170M / ITU-R BT.601-7 525 or 625
transferCharacteristicsLog100Sqrt10, transferCharacteristicsSmpte240, //SMPTE ST 240M
transferCharacteristicsCustom, 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) { pub const MatrixCoefficients = enum(c_int) {
matrixCoefficientsIdentity, matrixCoefficientsBt709, //ITU-R BT.709-6
matrixCoefficientsUnspecified, matrixCoefficientsFcc, //US FCC Title 47
matrixCoefficientsYcgco, matrixCoefficientsBt470bg, //ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625, functionally the same as SDL_MATRIX_COEFFICIENTS_BT601
matrixCoefficientsChromaDerivedNcl, matrixCoefficientsBt601, //ITU-R BT.601-7 525
matrixCoefficientsChromaDerivedCl, matrixCoefficientsSmpte240, //SMPTE 240M
matrixCoefficientsCustom, 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) { 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 { pub const Color = extern struct {

6
lib/sdl3/v2/power.zig vendored
View File

@ -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));
}

44
lib/sdl3/v2/process.zig vendored
View File

@ -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);
}

98
lib/sdl3/v2/render.zig vendored
View File

@ -7,69 +7,16 @@ pub const FPoint = extern struct {
}; };
pub const PixelFormat = enum(c_int) { pub const PixelFormat = enum(c_int) {
pixelformatUnknown, pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIndex1lsb, pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatIndex1msb, pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatIndex2lsb, pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatIndex2msb, pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatIndex4lsb, pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatIndex4msb, pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatIndex8, pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatRgb332, pixelformatExternalOes, //Android video texture format
pixelformatXrgb4444, pixelformatMjpg, //Motion JPEG
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 FColor = extern struct { pub const FColor = extern struct {
@ -86,7 +33,8 @@ pub const Surface = opaque {
}; };
pub const ScaleMode = enum(c_int) { pub const ScaleMode = enum(c_int) {
scalemodeInvalid, scalemodeNearest, //nearest pixel sampling
scalemodeLinear, //linear filtering
}; };
pub const PropertiesID = u32; pub const PropertiesID = u32;
@ -111,7 +59,7 @@ pub const FRect = extern struct {
}; };
pub const Event = extern union { 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 common: CommonEvent, // Common event data
display: DisplayEvent, // Display event data display: DisplayEvent, // Display event data
window: WindowEvent, // Window event data window: WindowEvent, // Window event data
@ -152,6 +100,12 @@ pub const Event = extern union {
padding: [128]u8, padding: [128]u8,
}; };
pub const FlipMode = enum(c_int) {
flipNone, //Do not flip
flipHorizontal, //flip horizontally
flipVertical, //flip vertically
};
pub const Rect = extern struct { pub const Rect = extern struct {
x: c_int, x: c_int,
y: c_int, y: c_int,
@ -195,6 +149,20 @@ pub const Vertex = extern struct {
tex_coord: FPoint, // Normalized texture coordinates, if needed 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 const Renderer = opaque {
pub inline fn getRenderWindow(renderer: *Renderer) ?*Window { pub inline fn getRenderWindow(renderer: *Renderer) ?*Window {
return c.SDL_GetRenderWindow(renderer); return c.SDL_GetRenderWindow(renderer);

184
lib/sdl3/v2/scancode.zig vendored
View File

@ -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,
};

11
lib/sdl3/v2/sensor.zig vendored
View File

@ -35,6 +35,17 @@ pub const Sensor = opaque {
pub const SensorID = u32; 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 { pub inline fn getSensors(count: *c_int) ?*SensorID {
return c.SDL_GetSensors(@ptrCast(count)); return c.SDL_GetSensors(@ptrCast(count));
} }

2
lib/sdl3/v2/storage.zig vendored
View File

@ -2,7 +2,7 @@ const std = @import("std");
pub const c = @import("c.zig").c; pub const c = @import("c.zig").c;
pub const PathInfo = extern struct { pub const PathInfo = extern struct {
type: PathType, // the path type _type: PathType, // the path type
size: u64, // the file size in bytes size: u64, // the file size in bytes
create_time: Time, // the time when the path was created create_time: Time, // the time when the path was created
modify_time: Time, // the last time the path was modified modify_time: Time, // the last time the path was modified

109
lib/sdl3/v2/surface.zig vendored
View File

@ -2,69 +2,16 @@ const std = @import("std");
pub const c = @import("c.zig").c; pub const c = @import("c.zig").c;
pub const PixelFormat = enum(c_int) { pub const PixelFormat = enum(c_int) {
pixelformatUnknown, pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIndex1lsb, pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatIndex1msb, pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatIndex2lsb, pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatIndex2msb, pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatIndex4lsb, pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatIndex4msb, pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatIndex8, pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatRgb332, pixelformatExternalOes, //Android video texture format
pixelformatXrgb4444, pixelformatMjpg, //Motion JPEG
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 BlendMode = u32; pub const BlendMode = u32;
@ -90,7 +37,32 @@ pub const Palette = extern struct {
}; };
pub const Colorspace = enum(c_int) { 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; pub const PropertiesID = u32;
@ -105,7 +77,14 @@ pub const SurfaceFlags = packed struct(u32) {
}; };
pub const ScaleMode = enum(c_int) { 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 { pub const Surface = opaque {

1
lib/sdl3/v2/system.zig vendored
View File

@ -108,7 +108,6 @@ pub inline fn isTV() bool {
} }
pub const Sandbox = enum(c_int) { pub const Sandbox = enum(c_int) {
sandboxNone,
sandboxUnknownContainer, sandboxUnknownContainer,
sandboxFlatpak, sandboxFlatpak,
sandboxSnap, sandboxSnap,

79
lib/sdl3/v2/thread.zig vendored
View File

@ -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();
}

11
lib/sdl3/v2/time.zig vendored
View File

@ -15,6 +15,17 @@ pub const DateTime = extern struct {
utc_offset: c_int, // Seconds east of UTC 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 { pub inline fn getDateTimeLocalePreferences(dateFormat: ?*DateFormat, timeFormat: ?*TimeFormat) bool {
return c.SDL_GetDateTimeLocalePreferences(@bitCast(dateFormat), @bitCast(timeFormat)); return c.SDL_GetDateTimeLocalePreferences(@bitCast(dateFormat), @bitCast(timeFormat));
} }

4
lib/sdl3/v2/touch.zig vendored
View File

@ -6,7 +6,9 @@ pub const TouchID = u64;
pub const FingerID = u64; pub const FingerID = u64;
pub const TouchDeviceType = enum(c_int) { 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 { pub const Finger = extern struct {

119
lib/sdl3/v2/tray.zig vendored
View File

@ -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();
}

131
lib/sdl3/v2/video.zig vendored
View File

@ -2,69 +2,16 @@ const std = @import("std");
pub const c = @import("c.zig").c; pub const c = @import("c.zig").c;
pub const PixelFormat = enum(c_int) { pub const PixelFormat = enum(c_int) {
pixelformatUnknown, pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIndex1lsb, pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatIndex1msb, pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatIndex2lsb, pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatIndex2msb, pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatIndex4lsb, pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatIndex4msb, pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatIndex8, pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatRgb332, pixelformatExternalOes, //Android video texture format
pixelformatXrgb4444, pixelformatMjpg, //Motion JPEG
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 Point = extern struct { pub const Point = extern struct {
@ -89,6 +36,12 @@ pub const DisplayID = u32;
pub const WindowID = 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 DisplayModeData = opaque {};
pub const DisplayMode = extern struct { pub const DisplayMode = extern struct {
@ -103,6 +56,14 @@ pub const DisplayMode = extern struct {
internal: ?*DisplayModeData, // Private 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 const Window = opaque {
pub inline fn getDisplayForWindow(window: *Window) DisplayID { pub inline fn getDisplayForWindow(window: *Window) DisplayID {
return c.SDL_GetDisplayForWindow(window); return c.SDL_GetDisplayForWindow(window);
@ -399,6 +360,12 @@ pub const WindowFlags = packed struct(u64) {
rsvd: bool = false, 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 GLContext = *anyopaque;
pub const EGLDisplay = ?*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 EGLIntArrayCallback = *const fn (userdata: ?*anyopaque, display: EGLDisplay, config: EGLConfig) callconv(.C) ?*EGLint;
pub const GLAttr = enum(c_int) { 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, glContextNoError,
glFloatbuffers, glFloatbuffers,
glEglPlatform, glEglPlatform,
@ -525,6 +517,19 @@ pub inline fn getGrabbedWindow() ?*Window {
return c.SDL_GetGrabbedWindow(); 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 { pub inline fn screenSaverEnabled() bool {
return c.SDL_ScreenSaverEnabled(); return c.SDL_ScreenSaverEnabled();
} }

34
lib/sdl3/v2/vulkan.zig vendored
View File

@ -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);
}