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

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
```
### With Warnings
```
Resolving dependencies...
✓ Found SDL_Window in SDL_video.h
⚠ Warning: Could not find definition for type: SDL_Unknown
```
### With Errors
```
Error: 5 syntax errors detected in generated code
Line 10: expected_comma_after_field
Line 12: expected_type_expr
...
```
File is still written, but may need manual fixes.
## Type Conversion Reference
@ -311,40 +294,8 @@ File is still written, but may need manual fixes.
## Examples
### Example 1: Simple Header
**Input** (simple.h):
```c
typedef struct SDL_Thing SDL_Thing;
typedef Uint32 SDL_ThingID;
extern SDL_DECLSPEC SDL_ThingID SDLCALL SDL_CreateThing(void);
extern SDL_DECLSPEC void SDLCALL SDL_DestroyThing(SDL_Thing *thing);
```
**Command**:
```bash
zig build run -- simple.h --output=thing.zig
```
**Output** (thing.zig):
```zig
pub const c = @import("c.zig").c;
pub const ThingID = u32;
pub const Thing = opaque {
pub inline fn destroyThing(thing: *Thing) void {
return c.SDL_DestroyThing(thing);
}
};
pub inline fn createThing() ThingID {
return c.SDL_CreateThing();
}
```
### Example 2: With Dependencies
### Example
**Input** (depends.h):
```c
@ -375,7 +326,7 @@ pub inline fn useRect(rect: *Rect) void {
}
```
### Example 3: With Mocks
### Mocks example
**Command**:
```bash
@ -395,65 +346,3 @@ void SDL_DestroyThing(SDL_Thing *thing) {
}
```
## Performance Characteristics
### Timing
| Operation | Time (SDL_gpu.h) |
|-----------|------------------|
| Parse primary header | ~50ms |
| Analyze dependencies | ~10ms |
| Extract dependencies | ~300ms |
| Generate code | ~150ms |
| **Total** | **~520ms** |
### Memory
| Component | Memory |
|-----------|--------|
| Source files | ~150KB |
| Declarations | ~2MB |
| Output | ~53KB |
| **Peak Total** | **~2.2MB** |
### Scaling
- **Time**: O(n + h×d) where n=lines, h=headers, d=declarations
- **Memory**: O(d) where d=total declarations
- **Linear scaling** with input size
## Advanced Usage
### Batch Processing
```bash
for header in SDL/include/SDL3/SDL_*.h; do
name=$(basename "$header" .h)
zig build run -- "$header" --output="bindings/${name}.zig"
done
```
### CI/CD Integration
```yaml
- name: Generate SDL bindings
run: |
cd lib/sdl3
zig build regenerate-zig
git diff --exit-code v2/*.zig || echo "Bindings updated"
```
### Validation
```bash
# Generate and validate
zig build run -- header.h --output=test.zig
zig ast-check test.zig
```
---
**See Also**:
- [Getting Started](GETTING_STARTED.md) - Basic usage tutorial
- [Architecture](ARCHITECTURE.md) - How it works internally
- [Known Issues](KNOWN_ISSUES.md) - Current limitations

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

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

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

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

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

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

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) {
audioS16,
audioS32,
audioF32,
audioUnknown, //Unspecified audio format
audioU8, //Unsigned 8-bit samples
audioS8, //Signed 8-bit samples
audioS16le, //Signed 16-bit samples
audioS16be, //As above, but big-endian byte order
audioS32le, //32-bit integer samples
audioS32be, //As above, but big-endian byte order
audioF32le, //32-bit floating point samples
audioF32be, //As above, but big-endian byte order
};
pub const AudioDeviceID = u32;

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 BlendOperation = enum(c_int) {
blendoperationAdd, //dst + src: supported by all renderers
blendoperationSubtract, //src - dst : supported by D3D, OpenGL, OpenGLES, and Vulkan
blendoperationRevSubtract, //dst - src : supported by D3D, OpenGL, OpenGLES, and Vulkan
blendoperationMinimum, //min(dst, src) : supported by D3D, OpenGL, OpenGLES, and Vulkan
blendoperationMaximum,
};
pub const BlendFactor = enum(c_int) {
blendfactorZero, //0, 0, 0, 0
blendfactorOne, //1, 1, 1, 1
blendfactorSrcColor, //srcR, srcG, srcB, srcA
blendfactorOneMinusSrcColor, //1-srcR, 1-srcG, 1-srcB, 1-srcA
blendfactorSrcAlpha, //srcA, srcA, srcA, srcA
blendfactorOneMinusSrcAlpha, //1-srcA, 1-srcA, 1-srcA, 1-srcA
blendfactorDstColor, //dstR, dstG, dstB, dstA
blendfactorOneMinusDstColor, //1-dstR, 1-dstG, 1-dstB, 1-dstA
blendfactorDstAlpha, //dstA, dstA, dstA, dstA
blendfactorOneMinusDstAlpha,
};
pub inline fn composeCustomBlendMode(srcColorFactor: BlendFactor, dstColorFactor: BlendFactor, colorOperation: BlendOperation, srcAlphaFactor: BlendFactor, dstAlphaFactor: BlendFactor, alphaOperation: BlendOperation) BlendMode {
return @intFromEnum(c.SDL_ComposeCustomBlendMode(srcColorFactor, dstColorFactor, @intFromEnum(colorOperation), srcAlphaFactor, dstAlphaFactor, @intFromEnum(alphaOperation)));
}

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 PixelFormat = enum(c_int) {
pixelformatUnknown,
pixelformatIndex1lsb,
pixelformatIndex1msb,
pixelformatIndex2lsb,
pixelformatIndex2msb,
pixelformatIndex4lsb,
pixelformatIndex4msb,
pixelformatIndex8,
pixelformatRgb332,
pixelformatXrgb4444,
pixelformatXbgr4444,
pixelformatXrgb1555,
pixelformatXbgr1555,
pixelformatArgb4444,
pixelformatRgba4444,
pixelformatAbgr4444,
pixelformatBgra4444,
pixelformatArgb1555,
pixelformatRgba5551,
pixelformatAbgr1555,
pixelformatBgra5551,
pixelformatRgb565,
pixelformatBgr565,
pixelformatRgb24,
pixelformatBgr24,
pixelformatXrgb8888,
pixelformatRgbx8888,
pixelformatXbgr8888,
pixelformatBgrx8888,
pixelformatArgb8888,
pixelformatRgba8888,
pixelformatAbgr8888,
pixelformatBgra8888,
pixelformatXrgb2101010,
pixelformatXbgr2101010,
pixelformatArgb2101010,
pixelformatAbgr2101010,
pixelformatRgb48,
pixelformatBgr48,
pixelformatRgba64,
pixelformatArgb64,
pixelformatBgra64,
pixelformatAbgr64,
pixelformatRgb48Float,
pixelformatBgr48Float,
pixelformatRgba64Float,
pixelformatArgb64Float,
pixelformatBgra64Float,
pixelformatAbgr64Float,
pixelformatRgb96Float,
pixelformatBgr96Float,
pixelformatRgba128Float,
pixelformatArgb128Float,
pixelformatBgra128Float,
pixelformatAbgr128Float,
pixelformatRgba32,
pixelformatArgb32,
pixelformatBgra32,
pixelformatAbgr32,
pixelformatRgbx32,
pixelformatXrgb32,
pixelformatBgrx32,
pixelformatXbgr32,
pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatExternalOes, //Android video texture format
pixelformatMjpg, //Motion JPEG
};
pub const Surface = opaque {};
pub const Colorspace = enum(c_int) {
colorspaceUnknown,
colorspaceSrgb, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
colorRangeFull,
colorPrimariesBt709,
transferCharacteristicsSrgb,
matrixCoefficientsIdentity,
colorspaceSrgbLinear, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
transferCharacteristicsLinear,
colorspaceHdr10, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020
colorPrimariesBt2020,
transferCharacteristicsPq,
colorspaceJpeg, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601
transferCharacteristicsBt601,
matrixCoefficientsBt601,
colorspaceBt601Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
colorRangeLimited,
colorPrimariesBt601,
colorspaceBt601Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
colorspaceBt709Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
transferCharacteristicsBt709,
matrixCoefficientsBt709,
colorspaceBt709Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
colorspaceBt2020Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020
matrixCoefficientsBt2020Ncl,
colorspaceBt2020Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020
colorspaceRgbDefault, //The default colorspace for RGB surfaces if no colorspace is specified
colorspaceYuvDefault, //The default colorspace for YUV surfaces if no colorspace is specified
};
pub const PropertiesID = u32;

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,
};
pub inline fn showFileDialogWithProperties(type: FileDialogType, callback: DialogFileCallback, userdata: ?*anyopaque, props: PropertiesID) void {
return c.SDL_ShowFileDialogWithProperties(@intFromEnum(type), callback, userdata, props);
pub inline fn showFileDialogWithProperties(_type: FileDialogType, callback: DialogFileCallback, userdata: ?*anyopaque, props: PropertiesID) void {
return c.SDL_ShowFileDialogWithProperties(@intFromEnum(_type), callback, userdata, props);
}

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);
}
pub const Folder = enum(c_int) {
folderHome, //The folder which contains all of the current user's data, preferences, and documents. It usually contains most of the other folders. If a requested folder does not exist, the home folder can be considered a safe fallback to store a user's documents.
folderDesktop, //The folder of files that are displayed on the desktop. Note that the existence of a desktop folder does not guarantee that the system does show icons on its desktop; certain GNU/Linux distros with a graphical environment may not have desktop icons.
folderDocuments, //User document files, possibly application-specific. This is a good place to save a user's projects.
folderDownloads, //Standard folder for user files downloaded from the internet.
folderMusic, //Music files that can be played using a standard music player (mp3, ogg...).
folderPictures, //Image files that can be displayed using a standard viewer (png, jpg...).
folderPublicshare, //Files that are meant to be shared with other users on the same computer.
folderSavedgames, //Save files for games.
folderScreenshots, //Application screenshots.
folderTemplates, //Template files to be used when the user requests the desktop environment to create a new file in a certain folder, such as "New Text File.txt". Any file in the Templates folder can be used as a starting point for a new file.
folderVideos, //Video files that can be played using a standard video player (mp4, webm...).
folderCount,
};
pub inline fn getUserFolder(folder: Folder) [*c]const u8 {
return c.SDL_GetUserFolder(folder);
}
pub const PathType = enum(c_int) {
pathtypeNone, //path does not exist
pathtypeFile, //a normal file
pathtypeDirectory, //a directory
pathtypeOther,
};
pub const PathInfo = extern struct {
type: PathType, // the path type
_type: PathType, // the path type
size: u64, // the file size in bytes
create_time: Time, // the time when the path was created
modify_time: Time, // the last time the path was modified
@ -33,6 +55,12 @@ pub inline fn createDirectory(path: [*c]const u8) bool {
return c.SDL_CreateDirectory(path);
}
pub const EnumerationResult = enum(c_int) {
enumContinue, //Value that requests that enumeration continue.
enumSuccess, //Value that requests that enumeration stop, successfully.
enumFailure,
};
pub const EnumerateDirectoryCallback = *const fn (userdata: ?*anyopaque, dirname: [*c]const u8, fname: [*c]const u8) callconv(.C) EnumerationResult;
pub inline fn enumerateDirectory(path: [*c]const u8, callback: EnumerateDirectoryCallback, userdata: ?*anyopaque) bool {

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 JoystickConnectionState = enum(c_int) {
joystickConnectionInvalid,
joystickConnectionUnknown,
joystickConnectionWired,
joystickConnectionWireless,
@ -22,6 +21,26 @@ pub const IOStream = opaque {
pub const JoystickID = u32;
pub const SensorType = enum(c_int) {
sensorInvalid, //Returned for an invalid sensor
sensorUnknown, //Unknown sensor type
sensorAccel, //Accelerometer
sensorGyro, //Gyroscope
sensorAccelL, //Accelerometer for left Joy-Con controller and Wii nunchuk
sensorGyroL, //Gyroscope for left Joy-Con controller
sensorAccelR, //Accelerometer for right Joy-Con controller
sensorGyroR, //Gyroscope for right Joy-Con controller
};
pub const PowerState = enum(c_int) {
powerstateError, //error determining power status
powerstateUnknown, //cannot determine power status
powerstateOnBattery, //Not plugged in, running on the battery
powerstateNoBattery, //Plugged in, no battery available
powerstateCharging, //Plugged in, charging battery
powerstateCharged,
};
pub const Joystick = opaque {};
pub const Gamepad = opaque {
@ -137,24 +156,24 @@ pub const Gamepad = opaque {
return c.SDL_GetGamepadTouchpadFinger(gamepad, touchpad, finger, @ptrCast(down), @ptrCast(x), @ptrCast(y), @ptrCast(pressure));
}
pub inline fn gamepadHasSensor(gamepad: *Gamepad, type: SensorType) bool {
return c.SDL_GamepadHasSensor(gamepad, @intFromEnum(type));
pub inline fn gamepadHasSensor(gamepad: *Gamepad, _type: SensorType) bool {
return c.SDL_GamepadHasSensor(gamepad, @intFromEnum(_type));
}
pub inline fn setGamepadSensorEnabled(gamepad: *Gamepad, type: SensorType, enabled: bool) bool {
return c.SDL_SetGamepadSensorEnabled(gamepad, @intFromEnum(type), enabled);
pub inline fn setGamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType, enabled: bool) bool {
return c.SDL_SetGamepadSensorEnabled(gamepad, @intFromEnum(_type), enabled);
}
pub inline fn gamepadSensorEnabled(gamepad: *Gamepad, type: SensorType) bool {
return c.SDL_GamepadSensorEnabled(gamepad, @intFromEnum(type));
pub inline fn gamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType) bool {
return c.SDL_GamepadSensorEnabled(gamepad, @intFromEnum(_type));
}
pub inline fn getGamepadSensorDataRate(gamepad: *Gamepad, type: SensorType) f32 {
return c.SDL_GetGamepadSensorDataRate(gamepad, @intFromEnum(type));
pub inline fn getGamepadSensorDataRate(gamepad: *Gamepad, _type: SensorType) f32 {
return c.SDL_GetGamepadSensorDataRate(gamepad, @intFromEnum(_type));
}
pub inline fn getGamepadSensorData(gamepad: *Gamepad, type: SensorType, data: *f32, num_values: c_int) bool {
return c.SDL_GetGamepadSensorData(gamepad, @intFromEnum(type), @ptrCast(data), num_values);
pub inline fn getGamepadSensorData(gamepad: *Gamepad, _type: SensorType, data: *f32, num_values: c_int) bool {
return c.SDL_GetGamepadSensorData(gamepad, @intFromEnum(_type), @ptrCast(data), num_values);
}
pub inline fn rumbleGamepad(gamepad: *Gamepad, low_frequency_rumble: u16, high_frequency_rumble: u16, duration_ms: u32) bool {
@ -187,7 +206,6 @@ pub const Gamepad = opaque {
};
pub const GamepadType = enum(c_int) {
gamepadTypeUnknown,
gamepadTypeStandard,
gamepadTypeXbox360,
gamepadTypeXboxone,
@ -202,7 +220,10 @@ pub const GamepadType = enum(c_int) {
};
pub const GamepadButton = enum(c_int) {
gamepadButtonInvalid,
gamepadButtonSouth, //Bottom face button (e.g. Xbox A button)
gamepadButtonEast, //Right face button (e.g. Xbox B button)
gamepadButtonWest, //Left face button (e.g. Xbox X button)
gamepadButtonNorth, //Top face button (e.g. Xbox Y button)
gamepadButtonBack,
gamepadButtonGuide,
gamepadButtonStart,
@ -214,6 +235,17 @@ pub const GamepadButton = enum(c_int) {
gamepadButtonDpadDown,
gamepadButtonDpadLeft,
gamepadButtonDpadRight,
gamepadButtonMisc1, //Additional button (e.g. Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button, Amazon Luna microphone button, Google Stadia capture button)
gamepadButtonRightPaddle1, //Upper or primary paddle, under your right hand (e.g. Xbox Elite paddle P1)
gamepadButtonLeftPaddle1, //Upper or primary paddle, under your left hand (e.g. Xbox Elite paddle P3)
gamepadButtonRightPaddle2, //Lower or secondary paddle, under your right hand (e.g. Xbox Elite paddle P2)
gamepadButtonLeftPaddle2, //Lower or secondary paddle, under your left hand (e.g. Xbox Elite paddle P4)
gamepadButtonTouchpad, //PS4/PS5 touchpad button
gamepadButtonMisc2, //Additional button
gamepadButtonMisc3, //Additional button
gamepadButtonMisc4, //Additional button
gamepadButtonMisc5, //Additional button
gamepadButtonMisc6, //Additional button
gamepadButtonCount,
};
@ -230,7 +262,6 @@ pub const GamepadButtonLabel = enum(c_int) {
};
pub const GamepadAxis = enum(c_int) {
gamepadAxisInvalid,
gamepadAxisLeftx,
gamepadAxisLefty,
gamepadAxisRightx,
@ -241,7 +272,6 @@ pub const GamepadAxis = enum(c_int) {
};
pub const GamepadBindingType = enum(c_int) {
gamepadBindtypeNone,
gamepadBindtypeButton,
gamepadBindtypeAxis,
gamepadBindtypeHat,
@ -366,8 +396,8 @@ pub inline fn getGamepadTypeFromString(str: [*c]const u8) GamepadType {
return @intFromEnum(c.SDL_GetGamepadTypeFromString(str));
}
pub inline fn getGamepadStringForType(type: GamepadType) [*c]const u8 {
return c.SDL_GetGamepadStringForType(@intFromEnum(type));
pub inline fn getGamepadStringForType(_type: GamepadType) [*c]const u8 {
return c.SDL_GetGamepadStringForType(@intFromEnum(_type));
}
pub inline fn getGamepadAxisFromString(str: [*c]const u8) GamepadAxis {
@ -386,6 +416,6 @@ pub inline fn getGamepadStringForButton(button: GamepadButton) [*c]const u8 {
return c.SDL_GetGamepadStringForButton(button);
}
pub inline fn getGamepadButtonLabelForType(type: GamepadType, button: GamepadButton) GamepadButtonLabel {
return c.SDL_GetGamepadButtonLabelForType(@intFromEnum(type), button);
pub inline fn getGamepadButtonLabelForType(_type: GamepadType, button: GamepadButton) GamepadButtonLabel {
return c.SDL_GetGamepadButtonLabelForType(@intFromEnum(_type), button);
}

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

@ -19,6 +19,12 @@ pub const Rect = extern struct {
pub const Window = opaque {};
pub const FlipMode = enum(c_int) {
flipNone, //Do not flip
flipHorizontal, //flip horizontally
flipVertical, //flip vertically
};
pub const GPUDevice = opaque {
pub inline fn destroyGPUDevice(gpudevice: *GPUDevice) void {
return c.SDL_DestroyGPUDevice(gpudevice);
@ -156,8 +162,8 @@ pub const GPUDevice = opaque {
return c.SDL_ReleaseGPUFence(gpudevice, fence);
}
pub inline fn gpuTextureSupportsFormat(gpudevice: *GPUDevice, format: GPUTextureFormat, type: GPUTextureType, usage: GPUTextureUsageFlags) bool {
return c.SDL_GPUTextureSupportsFormat(gpudevice, @bitCast(format), @intFromEnum(type), @bitCast(usage));
pub inline fn gpuTextureSupportsFormat(gpudevice: *GPUDevice, format: GPUTextureFormat, _type: GPUTextureType, usage: GPUTextureUsageFlags) bool {
return c.SDL_GPUTextureSupportsFormat(gpudevice, @bitCast(format), @intFromEnum(_type), @bitCast(usage));
}
pub inline fn gpuTextureSupportsSampleCount(gpudevice: *GPUDevice, format: GPUTextureFormat, sample_count: GPUSampleCount) bool {
@ -389,6 +395,32 @@ pub const GPUCopyPass = opaque {
pub const GPUFence = opaque {};
pub const GPUPrimitiveType = enum(c_int) {
primitivetypeTrianglelist, //A series of separate triangles.
primitivetypeTrianglestrip, //A series of connected triangles.
primitivetypeLinelist, //A series of separate lines.
primitivetypeLinestrip, //A series of connected lines.
primitivetypePointlist, //A series of separate points.
};
pub const GPULoadOp = enum(c_int) {
loadopLoad, //The previous contents of the texture will be preserved.
loadopClear, //The contents of the texture will be cleared to a color.
loadopDontCare, //The previous contents of the texture need not be preserved. The contents will be undefined.
};
pub const GPUStoreOp = enum(c_int) {
storeopStore, //The contents generated during the render pass will be written to memory.
storeopDontCare, //The contents generated during the render pass are not needed and may be discarded. The contents will be undefined.
storeopResolve, //The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture may then be discarded and will be undefined.
storeopResolveAndStore, //The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture will be written to memory.
};
pub const GPUIndexElementSize = enum(c_int) {
indexelementsize16bit, //The index elements are 16-bit.
indexelementsize32bit, //The index elements are 32-bit.
};
pub const GPUTextureFormat = enum(c_int) {
textureformatInvalid,
textureformatA8Unorm,
@ -509,6 +541,21 @@ pub const GPUTextureUsageFlags = packed struct(u32) {
rsvd: bool = false,
};
pub const GPUTextureType = enum(c_int) {
texturetype2d, //The texture is a 2-dimensional image.
texturetype2dArray, //The texture is a 2-dimensional array image.
texturetype3d, //The texture is a 3-dimensional image.
texturetypeCube, //The texture is a cube image.
texturetypeCubeArray, //The texture is a cube array image.
};
pub const GPUSampleCount = enum(c_int) {
samplecount1, //No multisampling.
samplecount2, //MSAA 2x
samplecount4, //MSAA 4x
samplecount8, //MSAA 8x
};
pub const GPUCubeMapFace = enum(c_int) {
cubemapfacePositivex,
cubemapfaceNegativex,
@ -575,20 +622,75 @@ pub const GPUVertexElementFormat = enum(c_int) {
vertexelementformatHalf4,
};
pub const GPUVertexInputRate = enum(c_int) {
vertexinputrateVertex, //Attribute addressing is a function of the vertex index.
vertexinputrateInstance, //Attribute addressing is a function of the instance index.
};
pub const GPUFillMode = enum(c_int) {
fillmodeFill, //Polygons will be rendered via rasterization.
fillmodeLine, //Polygon edges will be drawn as line segments.
};
pub const GPUCullMode = enum(c_int) {
cullmodeNone, //No triangles are culled.
cullmodeFront, //Front-facing triangles are culled.
cullmodeBack, //Back-facing triangles are culled.
};
pub const GPUFrontFace = enum(c_int) {
frontfaceCounterClockwise, //A triangle with counter-clockwise vertex winding will be considered front-facing.
frontfaceClockwise, //A triangle with clockwise vertex winding will be considered front-facing.
};
pub const GPUCompareOp = enum(c_int) {
compareopInvalid,
compareopNever, //The comparison always evaluates false.
compareopLess, //The comparison evaluates reference < test.
compareopEqual, //The comparison evaluates reference == test.
compareopLessOrEqual, //The comparison evaluates reference <= test.
compareopGreater, //The comparison evaluates reference > test.
compareopNotEqual, //The comparison evaluates reference != test.
compareopGreaterOrEqual, //The comparison evalutes reference >= test.
compareopAlways, //The comparison always evaluates true.
};
pub const GPUStencilOp = enum(c_int) {
stencilopInvalid,
stencilopKeep, //Keeps the current value.
stencilopZero, //Sets the value to 0.
stencilopReplace, //Sets the value to reference.
stencilopIncrementAndClamp, //Increments the current value and clamps to the maximum value.
stencilopDecrementAndClamp, //Decrements the current value and clamps to 0.
stencilopInvert, //Bitwise-inverts the current value.
stencilopIncrementAndWrap, //Increments the current value and wraps back to 0.
stencilopDecrementAndWrap, //Decrements the current value and wraps to the maximum value.
};
pub const GPUBlendOp = enum(c_int) {
blendopInvalid,
blendopAdd, //(source * source_factor) + (destination * destination_factor)
blendopSubtract, //(source * source_factor) - (destination * destination_factor)
blendopReverseSubtract, //(destination * destination_factor) - (source * source_factor)
blendopMin, //min(source, destination)
blendopMax,
};
pub const GPUBlendFactor = enum(c_int) {
blendfactorInvalid,
blendfactorZero, //0
blendfactorOne, //1
blendfactorSrcColor, //source color
blendfactorOneMinusSrcColor, //1 - source color
blendfactorDstColor, //destination color
blendfactorOneMinusDstColor, //1 - destination color
blendfactorSrcAlpha, //source alpha
blendfactorOneMinusSrcAlpha, //1 - source alpha
blendfactorDstAlpha, //destination alpha
blendfactorOneMinusDstAlpha, //1 - destination alpha
blendfactorConstantColor, //blend constant
blendfactorOneMinusConstantColor, //1 - blend constant
blendfactorSrcAlphaSaturate,
};
pub const GPUColorComponentFlags = packed struct(u8) {
@ -600,6 +702,22 @@ pub const GPUColorComponentFlags = packed struct(u8) {
rsvd: bool = false,
};
pub const GPUFilter = enum(c_int) {
filterNearest, //Point filtering.
filterLinear, //Linear filtering.
};
pub const GPUSamplerMipmapMode = enum(c_int) {
samplermipmapmodeNearest, //Point filtering.
samplermipmapmodeLinear, //Linear filtering.
};
pub const GPUSamplerAddressMode = enum(c_int) {
sampleraddressmodeRepeat, //Specifies that the coordinates will wrap around.
sampleraddressmodeMirroredRepeat, //Specifies that the coordinates will wrap around mirrored.
sampleraddressmodeClampToEdge, //Specifies that the coordinates will clamp to the 0-1 range.
};
pub const GPUPresentMode = enum(c_int) {
presentmodeVsync,
presentmodeImmediate,
@ -772,7 +890,7 @@ pub const GPUShaderCreateInfo = extern struct {
};
pub const GPUTextureCreateInfo = extern struct {
type: GPUTextureType, // The base dimensionality of the texture.
_type: GPUTextureType, // The base dimensionality of the texture.
format: GPUTextureFormat, // The pixel format of the texture.
usage: GPUTextureUsageFlags, // How the texture is intended to be used by the client.
width: u32, // The width of the texture.

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

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 Event = extern union {
type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration
_type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration
common: CommonEvent, // Common event data
display: DisplayEvent, // Display event data
window: WindowEvent, // Window event data
@ -56,6 +56,12 @@ pub const InitFlags = packed struct(u32) {
rsvd: bool = false,
};
pub const AppResult = enum(c_int) {
appContinue, //Value that requests that the app continue from the main callbacks.
appSuccess, //Value that requests termination with success from the main callbacks.
appFailure, //Value that requests termination with error from the main callbacks.
};
pub const AppInit_func = *const fn (appstate: [*c]?*anyopaque, argc: c_int, argv: [*c][*c]u8) callconv(.C) AppResult;
pub const AppIterate_func = *const fn (appstate: ?*anyopaque) callconv(.C) AppResult;

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 SensorType = enum(c_int) {
sensorInvalid, //Returned for an invalid sensor
sensorUnknown, //Unknown sensor type
sensorAccel, //Accelerometer
sensorGyro, //Gyroscope
sensorAccelL, //Accelerometer for left Joy-Con controller and Wii nunchuk
sensorGyroL, //Gyroscope for left Joy-Con controller
sensorAccelR, //Accelerometer for right Joy-Con controller
sensorGyroR, //Gyroscope for right Joy-Con controller
};
pub const GUID = extern struct {
data: [16]u8,
};
pub const PowerState = enum(c_int) {
powerstateError, //error determining power status
powerstateUnknown, //cannot determine power status
powerstateOnBattery, //Not plugged in, running on the battery
powerstateNoBattery, //Plugged in, no battery available
powerstateCharging, //Plugged in, charging battery
powerstateCharged,
};
pub const Joystick = opaque {
pub inline fn setJoystickVirtualAxis(joystick: *Joystick, axis: c_int, value: i16) bool {
return c.SDL_SetJoystickVirtualAxis(joystick, axis, value);
@ -28,8 +48,8 @@ pub const Joystick = opaque {
return c.SDL_SetJoystickVirtualTouchpad(joystick, touchpad, finger, down, x, y, pressure);
}
pub inline fn sendJoystickVirtualSensorData(joystick: *Joystick, type: SensorType, sensor_timestamp: u64, data: *const f32, num_values: c_int) bool {
return c.SDL_SendJoystickVirtualSensorData(joystick, @intFromEnum(type), sensor_timestamp, @ptrCast(data), num_values);
pub inline fn sendJoystickVirtualSensorData(joystick: *Joystick, _type: SensorType, sensor_timestamp: u64, data: *const f32, num_values: c_int) bool {
return c.SDL_SendJoystickVirtualSensorData(joystick, @intFromEnum(_type), sensor_timestamp, @ptrCast(data), num_values);
}
pub inline fn getJoystickProperties(joystick: *Joystick) PropertiesID {
@ -170,7 +190,6 @@ pub const JoystickType = enum(c_int) {
};
pub const JoystickConnectionState = enum(c_int) {
joystickConnectionInvalid,
joystickConnectionUnknown,
joystickConnectionWired,
joystickConnectionWireless,
@ -242,13 +261,13 @@ pub const VirtualJoystickTouchpadDesc = extern struct {
};
pub const VirtualJoystickSensorDesc = extern struct {
type: SensorType, // the type of this sensor
_type: SensorType, // the type of this sensor
rate: f32, // the update frequency of this sensor, may be 0.0f
};
pub const VirtualJoystickDesc = extern struct {
version: u32, // the version of this interface
type: u16, // `SDL_JoystickType`
_type: u16, // `SDL_JoystickType`
padding: u16, // unused
vendor_id: u16, // the USB vendor ID of this joystick
product_id: u16, // the USB product ID of this joystick

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,
messageboxColorButtonBackground,
messageboxColorButtonSelected,
messageboxColorCount, //Size of the colors array of SDL_MessageBoxColorScheme.
};
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) {
systemCursorDefault, //Default cursor. Usually an arrow.
systemCursorText, //Text selection. Usually an I-beam.
systemCursorWait, //Wait. Usually an hourglass or watch or spinning ball.
systemCursorCrosshair, //Crosshair.
systemCursorProgress, //Program is busy but still interactive. Usually it's WAIT with an arrow.
systemCursorNwseResize, //Double arrow pointing northwest and southeast.
systemCursorNeswResize, //Double arrow pointing northeast and southwest.
systemCursorEwResize, //Double arrow pointing west and east.
systemCursorNsResize, //Double arrow pointing north and south.
systemCursorMove, //Four pointed arrow pointing north, south, east, and west.
systemCursorNotAllowed, //Not permitted. Usually a slashed circle or crossbones.
systemCursorPointer, //Pointer that indicates a link. Usually a pointing hand.
systemCursorNwResize, //Window resize top-left. This may be a single arrow or a double arrow like NWSE_RESIZE.
systemCursorNResize, //Window resize top. May be NS_RESIZE.
systemCursorNeResize, //Window resize top-right. May be NESW_RESIZE.
systemCursorEResize, //Window resize right. May be EW_RESIZE.
systemCursorSeResize, //Window resize bottom-right. May be NWSE_RESIZE.
systemCursorSResize, //Window resize bottom. May be NS_RESIZE.
systemCursorSwResize, //Window resize bottom-left. May be NESW_RESIZE.
systemCursorWResize, //Window resize left. May be EW_RESIZE.
systemCursorCount,
};
pub const MouseWheelDirection = enum(c_int) {
mousewheelNormal, //The scroll direction is normal
mousewheelFlipped, //The scroll direction is flipped / natural
};
pub const MouseButtonFlags = packed struct(u32) {
buttonLeft: bool = false,
buttonMiddle: bool = false,

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) {
pixelformatUnknown,
pixelformatIndex1lsb,
pixelformatIndex1msb,
pixelformatIndex2lsb,
pixelformatIndex2msb,
pixelformatIndex4lsb,
pixelformatIndex4msb,
pixelformatIndex8,
pixelformatRgb332,
pixelformatXrgb4444,
pixelformatXbgr4444,
pixelformatXrgb1555,
pixelformatXbgr1555,
pixelformatArgb4444,
pixelformatRgba4444,
pixelformatAbgr4444,
pixelformatBgra4444,
pixelformatArgb1555,
pixelformatRgba5551,
pixelformatAbgr1555,
pixelformatBgra5551,
pixelformatRgb565,
pixelformatBgr565,
pixelformatRgb24,
pixelformatBgr24,
pixelformatXrgb8888,
pixelformatRgbx8888,
pixelformatXbgr8888,
pixelformatBgrx8888,
pixelformatArgb8888,
pixelformatRgba8888,
pixelformatAbgr8888,
pixelformatBgra8888,
pixelformatXrgb2101010,
pixelformatXbgr2101010,
pixelformatArgb2101010,
pixelformatAbgr2101010,
pixelformatRgb48,
pixelformatBgr48,
pixelformatRgba64,
pixelformatArgb64,
pixelformatBgra64,
pixelformatAbgr64,
pixelformatRgb48Float,
pixelformatBgr48Float,
pixelformatRgba64Float,
pixelformatArgb64Float,
pixelformatBgra64Float,
pixelformatAbgr64Float,
pixelformatRgb96Float,
pixelformatBgr96Float,
pixelformatRgba128Float,
pixelformatArgb128Float,
pixelformatBgra128Float,
pixelformatAbgr128Float,
pixelformatRgba32,
pixelformatArgb32,
pixelformatBgra32,
pixelformatAbgr32,
pixelformatRgbx32,
pixelformatXrgb32,
pixelformatBgrx32,
pixelformatXbgr32,
};
pub const ColorType = enum(c_int) {
colorTypeUnknown,
colorTypeRgb,
colorTypeYcbcr,
pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatExternalOes, //Android video texture format
pixelformatMjpg, //Motion JPEG
};
pub const ColorRange = enum(c_int) {
colorRangeUnknown,
colorRangeLimited, //Narrow range, e.g. 16-235 for 8-bit RGB and luma, and 16-240 for 8-bit chroma
colorRangeFull,
};
pub const ColorPrimaries = enum(c_int) {
colorPrimariesUnknown,
colorPrimariesUnspecified,
colorPrimariesCustom,
colorPrimariesBt709, //ITU-R BT.709-6
colorPrimariesBt470m, //ITU-R BT.470-6 System M
colorPrimariesBt470bg, //ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625
colorPrimariesBt601, //ITU-R BT.601-7 525, SMPTE 170M
colorPrimariesSmpte240, //SMPTE 240M, functionally the same as SDL_COLOR_PRIMARIES_BT601
colorPrimariesGenericFilm, //Generic film (color filters using Illuminant C)
colorPrimariesBt2020, //ITU-R BT.2020-2 / ITU-R BT.2100-0
colorPrimariesXyz, //SMPTE ST 428-1
colorPrimariesSmpte431, //SMPTE RP 431-2
colorPrimariesSmpte432, //SMPTE EG 432-1 / DCI P3
colorPrimariesEbu3213, //EBU Tech. 3213-E
};
pub const TransferCharacteristics = enum(c_int) {
transferCharacteristicsUnknown,
transferCharacteristicsUnspecified,
transferCharacteristicsLinear,
transferCharacteristicsLog100,
transferCharacteristicsLog100Sqrt10,
transferCharacteristicsCustom,
transferCharacteristicsBt709, //Rec. ITU-R BT.709-6 / ITU-R BT1361
transferCharacteristicsGamma22, //ITU-R BT.470-6 System M / ITU-R BT1700 625 PAL & SECAM
transferCharacteristicsGamma28, //ITU-R BT.470-6 System B, G
transferCharacteristicsBt601, //SMPTE ST 170M / ITU-R BT.601-7 525 or 625
transferCharacteristicsSmpte240, //SMPTE ST 240M
transferCharacteristicsIec61966, //IEC 61966-2-4
transferCharacteristicsBt1361, //ITU-R BT1361 Extended Colour Gamut
transferCharacteristicsSrgb, //IEC 61966-2-1 (sRGB or sYCC)
transferCharacteristicsBt202010bit, //ITU-R BT2020 for 10-bit system
transferCharacteristicsBt202012bit, //ITU-R BT2020 for 12-bit system
transferCharacteristicsPq, //SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems
transferCharacteristicsSmpte428, //SMPTE ST 428-1
transferCharacteristicsHlg, //ARIB STD-B67, known as "hybrid log-gamma" (HLG)
};
pub const MatrixCoefficients = enum(c_int) {
matrixCoefficientsIdentity,
matrixCoefficientsUnspecified,
matrixCoefficientsYcgco,
matrixCoefficientsChromaDerivedNcl,
matrixCoefficientsChromaDerivedCl,
matrixCoefficientsCustom,
matrixCoefficientsBt709, //ITU-R BT.709-6
matrixCoefficientsFcc, //US FCC Title 47
matrixCoefficientsBt470bg, //ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625, functionally the same as SDL_MATRIX_COEFFICIENTS_BT601
matrixCoefficientsBt601, //ITU-R BT.601-7 525
matrixCoefficientsSmpte240, //SMPTE 240M
matrixCoefficientsBt2020Ncl, //ITU-R BT.2020-2 non-constant luminance
matrixCoefficientsBt2020Cl, //ITU-R BT.2020-2 constant luminance
matrixCoefficientsSmpte2085, //SMPTE ST 2085
matrixCoefficientsIctcp, //ITU-R BT.2100-0 ICTCP
};
pub const ChromaLocation = enum(c_int) {
chromaLocationNone, //RGB, no chroma sampling
chromaLocationLeft, //In MPEG-2, MPEG-4, and AVC, Cb and Cr are taken on midpoint of the left-edge of the 2x2 square. In other words, they have the same horizontal location as the top-left pixel, but is shifted one-half pixel down vertically.
chromaLocationCenter, //In JPEG/JFIF, H.261, and MPEG-1, Cb and Cr are taken at the center of the 2x2 square. In other words, they are offset one-half pixel to the right and one-half pixel down compared to the top-left pixel.
chromaLocationTopleft,
};
pub const Colorspace = enum(c_int) {
colorspaceUnknown,
colorspaceSrgb, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
colorRangeFull,
colorPrimariesBt709,
transferCharacteristicsSrgb,
matrixCoefficientsIdentity,
colorspaceSrgbLinear, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
transferCharacteristicsLinear,
colorspaceHdr10, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020
colorPrimariesBt2020,
transferCharacteristicsPq,
colorspaceJpeg, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601
transferCharacteristicsBt601,
matrixCoefficientsBt601,
colorspaceBt601Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
colorRangeLimited,
colorPrimariesBt601,
colorspaceBt601Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
colorspaceBt709Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
transferCharacteristicsBt709,
matrixCoefficientsBt709,
colorspaceBt709Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
colorspaceBt2020Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020
matrixCoefficientsBt2020Ncl,
colorspaceBt2020Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020
colorspaceRgbDefault, //The default colorspace for RGB surfaces if no colorspace is specified
colorspaceYuvDefault, //The default colorspace for YUV surfaces if no colorspace is specified
};
pub const Color = extern struct {

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) {
pixelformatUnknown,
pixelformatIndex1lsb,
pixelformatIndex1msb,
pixelformatIndex2lsb,
pixelformatIndex2msb,
pixelformatIndex4lsb,
pixelformatIndex4msb,
pixelformatIndex8,
pixelformatRgb332,
pixelformatXrgb4444,
pixelformatXbgr4444,
pixelformatXrgb1555,
pixelformatXbgr1555,
pixelformatArgb4444,
pixelformatRgba4444,
pixelformatAbgr4444,
pixelformatBgra4444,
pixelformatArgb1555,
pixelformatRgba5551,
pixelformatAbgr1555,
pixelformatBgra5551,
pixelformatRgb565,
pixelformatBgr565,
pixelformatRgb24,
pixelformatBgr24,
pixelformatXrgb8888,
pixelformatRgbx8888,
pixelformatXbgr8888,
pixelformatBgrx8888,
pixelformatArgb8888,
pixelformatRgba8888,
pixelformatAbgr8888,
pixelformatBgra8888,
pixelformatXrgb2101010,
pixelformatXbgr2101010,
pixelformatArgb2101010,
pixelformatAbgr2101010,
pixelformatRgb48,
pixelformatBgr48,
pixelformatRgba64,
pixelformatArgb64,
pixelformatBgra64,
pixelformatAbgr64,
pixelformatRgb48Float,
pixelformatBgr48Float,
pixelformatRgba64Float,
pixelformatArgb64Float,
pixelformatBgra64Float,
pixelformatAbgr64Float,
pixelformatRgb96Float,
pixelformatBgr96Float,
pixelformatRgba128Float,
pixelformatArgb128Float,
pixelformatBgra128Float,
pixelformatAbgr128Float,
pixelformatRgba32,
pixelformatArgb32,
pixelformatBgra32,
pixelformatAbgr32,
pixelformatRgbx32,
pixelformatXrgb32,
pixelformatBgrx32,
pixelformatXbgr32,
pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatExternalOes, //Android video texture format
pixelformatMjpg, //Motion JPEG
};
pub const FColor = extern struct {
@ -86,7 +33,8 @@ pub const Surface = opaque {
};
pub const ScaleMode = enum(c_int) {
scalemodeInvalid,
scalemodeNearest, //nearest pixel sampling
scalemodeLinear, //linear filtering
};
pub const PropertiesID = u32;
@ -111,7 +59,7 @@ pub const FRect = extern struct {
};
pub const Event = extern union {
type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration
_type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration
common: CommonEvent, // Common event data
display: DisplayEvent, // Display event data
window: WindowEvent, // Window event data
@ -152,6 +100,12 @@ pub const Event = extern union {
padding: [128]u8,
};
pub const FlipMode = enum(c_int) {
flipNone, //Do not flip
flipHorizontal, //flip horizontally
flipVertical, //flip vertically
};
pub const Rect = extern struct {
x: c_int,
y: c_int,
@ -195,6 +149,20 @@ pub const Vertex = extern struct {
tex_coord: FPoint, // Normalized texture coordinates, if needed
};
pub const TextureAccess = enum(c_int) {
textureaccessStatic, //Changes rarely, not lockable
textureaccessStreaming, //Changes frequently, lockable
textureaccessTarget, //Texture can be used as a render target
};
pub const RendererLogicalPresentation = enum(c_int) {
logicalPresentationDisabled, //There is no logical size in effect
logicalPresentationStretch, //The rendered content is stretched to the output resolution
logicalPresentationLetterbox, //The rendered content is fit to the largest dimension and the other dimension is letterboxed with black bars
logicalPresentationOverscan, //The rendered content is fit to the smallest dimension and the other dimension extends beyond the output bounds
logicalPresentationIntegerScale, //The rendered content is scaled up by integer multiples to fit the output resolution
};
pub const Renderer = opaque {
pub inline fn getRenderWindow(renderer: *Renderer) ?*Window {
return c.SDL_GetRenderWindow(renderer);

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 SensorType = enum(c_int) {
sensorInvalid, //Returned for an invalid sensor
sensorUnknown, //Unknown sensor type
sensorAccel, //Accelerometer
sensorGyro, //Gyroscope
sensorAccelL, //Accelerometer for left Joy-Con controller and Wii nunchuk
sensorGyroL, //Gyroscope for left Joy-Con controller
sensorAccelR, //Accelerometer for right Joy-Con controller
sensorGyroR, //Gyroscope for right Joy-Con controller
};
pub inline fn getSensors(count: *c_int) ?*SensorID {
return c.SDL_GetSensors(@ptrCast(count));
}

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 PathInfo = extern struct {
type: PathType, // the path type
_type: PathType, // the path type
size: u64, // the file size in bytes
create_time: Time, // the time when the path was created
modify_time: Time, // the last time the path was modified

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 PixelFormat = enum(c_int) {
pixelformatUnknown,
pixelformatIndex1lsb,
pixelformatIndex1msb,
pixelformatIndex2lsb,
pixelformatIndex2msb,
pixelformatIndex4lsb,
pixelformatIndex4msb,
pixelformatIndex8,
pixelformatRgb332,
pixelformatXrgb4444,
pixelformatXbgr4444,
pixelformatXrgb1555,
pixelformatXbgr1555,
pixelformatArgb4444,
pixelformatRgba4444,
pixelformatAbgr4444,
pixelformatBgra4444,
pixelformatArgb1555,
pixelformatRgba5551,
pixelformatAbgr1555,
pixelformatBgra5551,
pixelformatRgb565,
pixelformatBgr565,
pixelformatRgb24,
pixelformatBgr24,
pixelformatXrgb8888,
pixelformatRgbx8888,
pixelformatXbgr8888,
pixelformatBgrx8888,
pixelformatArgb8888,
pixelformatRgba8888,
pixelformatAbgr8888,
pixelformatBgra8888,
pixelformatXrgb2101010,
pixelformatXbgr2101010,
pixelformatArgb2101010,
pixelformatAbgr2101010,
pixelformatRgb48,
pixelformatBgr48,
pixelformatRgba64,
pixelformatArgb64,
pixelformatBgra64,
pixelformatAbgr64,
pixelformatRgb48Float,
pixelformatBgr48Float,
pixelformatRgba64Float,
pixelformatArgb64Float,
pixelformatBgra64Float,
pixelformatAbgr64Float,
pixelformatRgb96Float,
pixelformatBgr96Float,
pixelformatRgba128Float,
pixelformatArgb128Float,
pixelformatBgra128Float,
pixelformatAbgr128Float,
pixelformatRgba32,
pixelformatArgb32,
pixelformatBgra32,
pixelformatAbgr32,
pixelformatRgbx32,
pixelformatXrgb32,
pixelformatBgrx32,
pixelformatXbgr32,
pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatExternalOes, //Android video texture format
pixelformatMjpg, //Motion JPEG
};
pub const BlendMode = u32;
@ -90,7 +37,32 @@ pub const Palette = extern struct {
};
pub const Colorspace = enum(c_int) {
colorspaceUnknown,
colorspaceSrgb, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
colorRangeFull,
colorPrimariesBt709,
transferCharacteristicsSrgb,
matrixCoefficientsIdentity,
colorspaceSrgbLinear, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
transferCharacteristicsLinear,
colorspaceHdr10, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020
colorPrimariesBt2020,
transferCharacteristicsPq,
colorspaceJpeg, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601
transferCharacteristicsBt601,
matrixCoefficientsBt601,
colorspaceBt601Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
colorRangeLimited,
colorPrimariesBt601,
colorspaceBt601Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
colorspaceBt709Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
transferCharacteristicsBt709,
matrixCoefficientsBt709,
colorspaceBt709Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
colorspaceBt2020Limited, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020
matrixCoefficientsBt2020Ncl,
colorspaceBt2020Full, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020
colorspaceRgbDefault, //The default colorspace for RGB surfaces if no colorspace is specified
colorspaceYuvDefault, //The default colorspace for YUV surfaces if no colorspace is specified
};
pub const PropertiesID = u32;
@ -105,7 +77,14 @@ pub const SurfaceFlags = packed struct(u32) {
};
pub const ScaleMode = enum(c_int) {
scalemodeInvalid,
scalemodeNearest, //nearest pixel sampling
scalemodeLinear, //linear filtering
};
pub const FlipMode = enum(c_int) {
flipNone, //Do not flip
flipHorizontal, //flip horizontally
flipVertical, //flip vertically
};
pub const Surface = opaque {

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

@ -108,7 +108,6 @@ pub inline fn isTV() bool {
}
pub const Sandbox = enum(c_int) {
sandboxNone,
sandboxUnknownContainer,
sandboxFlatpak,
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
};
pub const DateFormat = enum(c_int) {
dateFormatYyyymmdd, //Year/Month/Day
dateFormatDdmmyyyy, //Day/Month/Year
dateFormatMmddyyyy, //Month/Day/Year
};
pub const TimeFormat = enum(c_int) {
timeFormat24hr, //24 hour time
timeFormat12hr, //12 hour time
};
pub inline fn getDateTimeLocalePreferences(dateFormat: ?*DateFormat, timeFormat: ?*TimeFormat) bool {
return c.SDL_GetDateTimeLocalePreferences(@bitCast(dateFormat), @bitCast(timeFormat));
}

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

@ -6,7 +6,9 @@ pub const TouchID = u64;
pub const FingerID = u64;
pub const TouchDeviceType = enum(c_int) {
touchDeviceInvalid,
touchDeviceDirect, //touch screen with window-relative coordinates
touchDeviceIndirectAbsolute, //trackpad with absolute device coordinates
touchDeviceIndirectRelative, //trackpad with screen cursor-relative coordinates
};
pub const Finger = extern struct {

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 PixelFormat = enum(c_int) {
pixelformatUnknown,
pixelformatIndex1lsb,
pixelformatIndex1msb,
pixelformatIndex2lsb,
pixelformatIndex2msb,
pixelformatIndex4lsb,
pixelformatIndex4msb,
pixelformatIndex8,
pixelformatRgb332,
pixelformatXrgb4444,
pixelformatXbgr4444,
pixelformatXrgb1555,
pixelformatXbgr1555,
pixelformatArgb4444,
pixelformatRgba4444,
pixelformatAbgr4444,
pixelformatBgra4444,
pixelformatArgb1555,
pixelformatRgba5551,
pixelformatAbgr1555,
pixelformatBgra5551,
pixelformatRgb565,
pixelformatBgr565,
pixelformatRgb24,
pixelformatBgr24,
pixelformatXrgb8888,
pixelformatRgbx8888,
pixelformatXbgr8888,
pixelformatBgrx8888,
pixelformatArgb8888,
pixelformatRgba8888,
pixelformatAbgr8888,
pixelformatBgra8888,
pixelformatXrgb2101010,
pixelformatXbgr2101010,
pixelformatArgb2101010,
pixelformatAbgr2101010,
pixelformatRgb48,
pixelformatBgr48,
pixelformatRgba64,
pixelformatArgb64,
pixelformatBgra64,
pixelformatAbgr64,
pixelformatRgb48Float,
pixelformatBgr48Float,
pixelformatRgba64Float,
pixelformatArgb64Float,
pixelformatBgra64Float,
pixelformatAbgr64Float,
pixelformatRgb96Float,
pixelformatBgr96Float,
pixelformatRgba128Float,
pixelformatArgb128Float,
pixelformatBgra128Float,
pixelformatAbgr128Float,
pixelformatRgba32,
pixelformatArgb32,
pixelformatBgra32,
pixelformatAbgr32,
pixelformatRgbx32,
pixelformatXrgb32,
pixelformatBgrx32,
pixelformatXbgr32,
pixelformatYv12, //Planar mode: Y + V + U (3 planes)
pixelformatIyuv, //Planar mode: Y + U + V (3 planes)
pixelformatYuy2, //Packed mode: Y0+U0+Y1+V0 (1 plane)
pixelformatUyvy, //Packed mode: U0+Y0+V0+Y1 (1 plane)
pixelformatYvyu, //Packed mode: Y0+V0+Y1+U0 (1 plane)
pixelformatNv12, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatNv21, //Planar mode: Y + V/U interleaved (2 planes)
pixelformatP010, //Planar mode: Y + U/V interleaved (2 planes)
pixelformatExternalOes, //Android video texture format
pixelformatMjpg, //Motion JPEG
};
pub const Point = extern struct {
@ -89,6 +36,12 @@ pub const DisplayID = u32;
pub const WindowID = u32;
pub const SystemTheme = enum(c_int) {
systemThemeUnknown, //Unknown system theme
systemThemeLight, //Light colored system theme
systemThemeDark, //Dark colored system theme
};
pub const DisplayModeData = opaque {};
pub const DisplayMode = extern struct {
@ -103,6 +56,14 @@ pub const DisplayMode = extern struct {
internal: ?*DisplayModeData, // Private
};
pub const DisplayOrientation = enum(c_int) {
orientationUnknown, //The display orientation can't be determined
orientationLandscape, //The display is in landscape mode, with the right side up, relative to portrait mode
orientationLandscapeFlipped, //The display is in landscape mode, with the left side up, relative to portrait mode
orientationPortrait, //The display is in portrait mode
orientationPortraitFlipped,
};
pub const Window = opaque {
pub inline fn getDisplayForWindow(window: *Window) DisplayID {
return c.SDL_GetDisplayForWindow(window);
@ -399,6 +360,12 @@ pub const WindowFlags = packed struct(u64) {
rsvd: bool = false,
};
pub const FlashOperation = enum(c_int) {
flashCancel, //Cancel any window flash state
flashBriefly, //Flash the window briefly to get attention
flashUntilFocused, //Flash the window until it gets focus
};
pub const GLContext = *anyopaque;
pub const EGLDisplay = ?*anyopaque;
@ -416,6 +383,31 @@ pub const EGLAttribArrayCallback = *const fn (userdata: ?*anyopaque) callconv(.C
pub const EGLIntArrayCallback = *const fn (userdata: ?*anyopaque, display: EGLDisplay, config: EGLConfig) callconv(.C) ?*EGLint;
pub const GLAttr = enum(c_int) {
glRedSize, //the minimum number of bits for the red channel of the color buffer; defaults to 3.
glGreenSize, //the minimum number of bits for the green channel of the color buffer; defaults to 3.
glBlueSize, //the minimum number of bits for the blue channel of the color buffer; defaults to 2.
glAlphaSize, //the minimum number of bits for the alpha channel of the color buffer; defaults to 0.
glBufferSize, //the minimum number of bits for frame buffer size; defaults to 0.
glDoublebuffer, //whether the output is single or double buffered; defaults to double buffering on.
glDepthSize, //the minimum number of bits in the depth buffer; defaults to 16.
glStencilSize, //the minimum number of bits in the stencil buffer; defaults to 0.
glAccumRedSize, //the minimum number of bits for the red channel of the accumulation buffer; defaults to 0.
glAccumGreenSize, //the minimum number of bits for the green channel of the accumulation buffer; defaults to 0.
glAccumBlueSize, //the minimum number of bits for the blue channel of the accumulation buffer; defaults to 0.
glAccumAlphaSize, //the minimum number of bits for the alpha channel of the accumulation buffer; defaults to 0.
glStereo, //whether the output is stereo 3D; defaults to off.
glMultisamplebuffers, //the number of buffers used for multisample anti-aliasing; defaults to 0.
glMultisamplesamples, //the number of samples used around the current pixel used for multisample anti-aliasing.
glAcceleratedVisual, //set to 1 to require hardware acceleration, set to 0 to force software rendering; defaults to allow either.
glRetainedBacking, //not used (deprecated).
glContextMajorVersion, //OpenGL context major version.
glContextMinorVersion, //OpenGL context minor version.
glContextFlags, //some combination of 0 or more of elements of the SDL_GLContextFlag enumeration; defaults to 0.
glContextProfileMask, //type of GL context (Core, Compatibility, ES). See SDL_GLProfile; default value depends on platform.
glShareWithCurrentContext, //OpenGL context sharing; defaults to 0.
glFramebufferSrgbCapable, //requests sRGB capable visual; defaults to 0.
glContextReleaseBehavior, //sets context the release behavior. See SDL_GLContextReleaseFlag; defaults to FLUSH.
glContextResetNotification, //set context reset notification. See SDL_GLContextResetNotification; defaults to NO_NOTIFICATION.
glContextNoError,
glFloatbuffers,
glEglPlatform,
@ -525,6 +517,19 @@ pub inline fn getGrabbedWindow() ?*Window {
return c.SDL_GetGrabbedWindow();
}
pub const HitTestResult = enum(c_int) {
hittestNormal, //Region is normal. No special properties.
hittestDraggable, //Region can drag entire window.
hittestResizeTopleft, //Region is the resizable top-left corner border.
hittestResizeTop, //Region is the resizable top border.
hittestResizeTopright, //Region is the resizable top-right corner border.
hittestResizeRight, //Region is the resizable right border.
hittestResizeBottomright, //Region is the resizable bottom-right corner border.
hittestResizeBottom, //Region is the resizable bottom border.
hittestResizeBottomleft, //Region is the resizable bottom-left corner border.
hittestResizeLeft, //Region is the resizable left border.
};
pub inline fn screenSaverEnabled() bool {
return c.SDL_ScreenSaverEnabled();
}

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