big fixes

api/audio.zig

@@ -0,0 +1,267 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const iostream_api = @import("iostream.zig");
+const properties_api = @import("properties.zig");
+
+pub const IOStream = iostream_api.IOStream;
+pub const PropertiesID = properties_api.PropertiesID;
+
+pub const AudioFormat = enum(c_int) {
+    audioUnknown = 0x0000, //Unspecified audio format
+    audioU8 = 0x0008, //Unsigned 8-bit samples
+    audioS8 = 0x8008, //Signed 8-bit samples
+    audioS16le = 0x8010, //Signed 16-bit samples
+    audioS16be = 0x9010, //As above, but big-endian byte order
+    audioS32le = 0x8020, //32-bit integer samples
+    audioS32be = 0x9020, //As above, but big-endian byte order
+    audioF32le = 0x8120, //32-bit floating point samples
+    audioF32be = 0x9120, //As above, but big-endian byte order
+};
+
+pub const AudioDeviceID = u32;
+
+pub const AudioSpec = extern struct {
+    format: AudioFormat, // Audio data format
+    channels: c_int, // Number of channels: 1 mono, 2 stereo, etc
+    freq: c_int, // sample rate: sample frames per second
+};
+
+pub const AudioStream = opaque {
+    pub inline fn unbindAudioStream(audiostream: *AudioStream) void {
+        return c.SDL_UnbindAudioStream(@ptrCast(audiostream));
+    }
+
+    pub inline fn getAudioStreamDevice(audiostream: *AudioStream) AudioDeviceID {
+        return c.SDL_GetAudioStreamDevice(@ptrCast(audiostream));
+    }
+
+    pub inline fn getAudioStreamProperties(audiostream: *AudioStream) PropertiesID {
+        return c.SDL_GetAudioStreamProperties(@ptrCast(audiostream));
+    }
+
+    pub inline fn getAudioStreamFormat(audiostream: *AudioStream, src_spec: ?*AudioSpec, dst_spec: ?*AudioSpec) bool {
+        return @bitCast(c.SDL_GetAudioStreamFormat(@ptrCast(audiostream), @ptrCast(src_spec), @ptrCast(dst_spec)));
+    }
+
+    pub inline fn setAudioStreamFormat(audiostream: *AudioStream, src_spec: ?*const AudioSpec, dst_spec: ?*const AudioSpec) bool {
+        return @bitCast(c.SDL_SetAudioStreamFormat(@ptrCast(audiostream), @ptrCast(src_spec), @ptrCast(dst_spec)));
+    }
+
+    pub inline fn getAudioStreamFrequencyRatio(audiostream: *AudioStream) f32 {
+        return c.SDL_GetAudioStreamFrequencyRatio(@ptrCast(audiostream));
+    }
+
+    pub inline fn setAudioStreamFrequencyRatio(audiostream: *AudioStream, ratio: f32) bool {
+        return @bitCast(c.SDL_SetAudioStreamFrequencyRatio(@ptrCast(audiostream), ratio));
+    }
+
+    pub inline fn getAudioStreamGain(audiostream: *AudioStream) f32 {
+        return c.SDL_GetAudioStreamGain(@ptrCast(audiostream));
+    }
+
+    pub inline fn setAudioStreamGain(audiostream: *AudioStream, gain: f32) bool {
+        return @bitCast(c.SDL_SetAudioStreamGain(@ptrCast(audiostream), gain));
+    }
+
+    pub inline fn getAudioStreamInputChannelMap(audiostream: *AudioStream, count: *c_int) *c_int {
+        return @ptrCast(c.SDL_GetAudioStreamInputChannelMap(@ptrCast(audiostream), @ptrCast(count)));
+    }
+
+    pub inline fn getAudioStreamOutputChannelMap(audiostream: *AudioStream, count: *c_int) *c_int {
+        return @ptrCast(c.SDL_GetAudioStreamOutputChannelMap(@ptrCast(audiostream), @ptrCast(count)));
+    }
+
+    pub inline fn setAudioStreamInputChannelMap(audiostream: *AudioStream, chmap: [*c]const c_int, count: c_int) bool {
+        return @bitCast(c.SDL_SetAudioStreamInputChannelMap(@ptrCast(audiostream), chmap, count));
+    }
+
+    pub inline fn setAudioStreamOutputChannelMap(audiostream: *AudioStream, chmap: [*c]const c_int, count: c_int) bool {
+        return @bitCast(c.SDL_SetAudioStreamOutputChannelMap(@ptrCast(audiostream), chmap, count));
+    }
+
+    pub inline fn putAudioStreamData(audiostream: *AudioStream, buf: ?*const anyopaque, len: c_int) bool {
+        return @bitCast(c.SDL_PutAudioStreamData(@ptrCast(audiostream), buf, len));
+    }
+
+    pub inline fn putAudioStreamDataNoCopy(audiostream: *AudioStream, buf: ?*const anyopaque, len: c_int, callback: AudioStreamDataCompleteCallback, userdata: ?*anyopaque) bool {
+        return @bitCast(c.SDL_PutAudioStreamDataNoCopy(@ptrCast(audiostream), buf, len, callback, userdata));
+    }
+
+    pub inline fn putAudioStreamPlanarData(audiostream: *AudioStream, channel_buffers: [*c]const *anyopaque, num_channels: c_int, num_samples: c_int) bool {
+        return @bitCast(c.SDL_PutAudioStreamPlanarData(@ptrCast(audiostream), channel_buffers, num_channels, num_samples));
+    }
+
+    pub inline fn getAudioStreamData(audiostream: *AudioStream, buf: ?*anyopaque, len: c_int) c_int {
+        return c.SDL_GetAudioStreamData(@ptrCast(audiostream), buf, len);
+    }
+
+    pub inline fn getAudioStreamAvailable(audiostream: *AudioStream) c_int {
+        return c.SDL_GetAudioStreamAvailable(@ptrCast(audiostream));
+    }
+
+    pub inline fn getAudioStreamQueued(audiostream: *AudioStream) c_int {
+        return c.SDL_GetAudioStreamQueued(@ptrCast(audiostream));
+    }
+
+    pub inline fn flushAudioStream(audiostream: *AudioStream) bool {
+        return @bitCast(c.SDL_FlushAudioStream(@ptrCast(audiostream)));
+    }
+
+    pub inline fn clearAudioStream(audiostream: *AudioStream) bool {
+        return @bitCast(c.SDL_ClearAudioStream(@ptrCast(audiostream)));
+    }
+
+    pub inline fn pauseAudioStreamDevice(audiostream: *AudioStream) bool {
+        return @bitCast(c.SDL_PauseAudioStreamDevice(@ptrCast(audiostream)));
+    }
+
+    pub inline fn resumeAudioStreamDevice(audiostream: *AudioStream) bool {
+        return @bitCast(c.SDL_ResumeAudioStreamDevice(@ptrCast(audiostream)));
+    }
+
+    pub inline fn audioStreamDevicePaused(audiostream: *AudioStream) bool {
+        return @bitCast(c.SDL_AudioStreamDevicePaused(@ptrCast(audiostream)));
+    }
+
+    pub inline fn lockAudioStream(audiostream: *AudioStream) bool {
+        return @bitCast(c.SDL_LockAudioStream(@ptrCast(audiostream)));
+    }
+
+    pub inline fn unlockAudioStream(audiostream: *AudioStream) bool {
+        return @bitCast(c.SDL_UnlockAudioStream(@ptrCast(audiostream)));
+    }
+
+    pub inline fn setAudioStreamGetCallback(audiostream: *AudioStream, callback: AudioStreamCallback, userdata: ?*anyopaque) bool {
+        return @bitCast(c.SDL_SetAudioStreamGetCallback(@ptrCast(audiostream), callback, userdata));
+    }
+
+    pub inline fn setAudioStreamPutCallback(audiostream: *AudioStream, callback: AudioStreamCallback, userdata: ?*anyopaque) bool {
+        return @bitCast(c.SDL_SetAudioStreamPutCallback(@ptrCast(audiostream), callback, userdata));
+    }
+
+    pub inline fn destroyAudioStream(audiostream: *AudioStream) void {
+        return c.SDL_DestroyAudioStream(@ptrCast(audiostream));
+    }
+};
+
+pub inline fn getNumAudioDrivers() c_int {
+    return c.SDL_GetNumAudioDrivers();
+}
+
+pub inline fn getAudioDriver(index: c_int) [*c]const u8 {
+    return c.SDL_GetAudioDriver(index);
+}
+
+pub inline fn getCurrentAudioDriver() [*c]const u8 {
+    return c.SDL_GetCurrentAudioDriver();
+}
+
+pub inline fn getAudioPlaybackDevices(count: *c_int) ?*AudioDeviceID {
+    return @ptrCast(c.SDL_GetAudioPlaybackDevices(@ptrCast(count)));
+}
+
+pub inline fn getAudioRecordingDevices(count: *c_int) ?*AudioDeviceID {
+    return @ptrCast(c.SDL_GetAudioRecordingDevices(@ptrCast(count)));
+}
+
+pub inline fn getAudioDeviceName(devid: AudioDeviceID) [*c]const u8 {
+    return c.SDL_GetAudioDeviceName(devid);
+}
+
+pub inline fn getAudioDeviceFormat(devid: AudioDeviceID, spec: ?*AudioSpec, sample_frames: *c_int) bool {
+    return @bitCast(c.SDL_GetAudioDeviceFormat(devid, @ptrCast(spec), @ptrCast(sample_frames)));
+}
+
+pub inline fn getAudioDeviceChannelMap(devid: AudioDeviceID, count: *c_int) *c_int {
+    return @ptrCast(c.SDL_GetAudioDeviceChannelMap(devid, @ptrCast(count)));
+}
+
+pub inline fn openAudioDevice(devid: AudioDeviceID, spec: ?*const AudioSpec) AudioDeviceID {
+    return c.SDL_OpenAudioDevice(devid, @ptrCast(spec));
+}
+
+pub inline fn isAudioDevicePhysical(devid: AudioDeviceID) bool {
+    return @bitCast(c.SDL_IsAudioDevicePhysical(devid));
+}
+
+pub inline fn isAudioDevicePlayback(devid: AudioDeviceID) bool {
+    return @bitCast(c.SDL_IsAudioDevicePlayback(devid));
+}
+
+pub inline fn pauseAudioDevice(devid: AudioDeviceID) bool {
+    return @bitCast(c.SDL_PauseAudioDevice(devid));
+}
+
+pub inline fn resumeAudioDevice(devid: AudioDeviceID) bool {
+    return @bitCast(c.SDL_ResumeAudioDevice(devid));
+}
+
+pub inline fn audioDevicePaused(devid: AudioDeviceID) bool {
+    return @bitCast(c.SDL_AudioDevicePaused(devid));
+}
+
+pub inline fn getAudioDeviceGain(devid: AudioDeviceID) f32 {
+    return c.SDL_GetAudioDeviceGain(devid);
+}
+
+pub inline fn setAudioDeviceGain(devid: AudioDeviceID, gain: f32) bool {
+    return @bitCast(c.SDL_SetAudioDeviceGain(devid, gain));
+}
+
+pub inline fn closeAudioDevice(devid: AudioDeviceID) void {
+    return c.SDL_CloseAudioDevice(devid);
+}
+
+pub inline fn bindAudioStreams(devid: AudioDeviceID, streams: [*c]?*const AudioStream, num_streams: c_int) bool {
+    return @bitCast(c.SDL_BindAudioStreams(devid, streams, num_streams));
+}
+
+pub inline fn bindAudioStream(devid: AudioDeviceID, stream: ?*AudioStream) bool {
+    return @bitCast(c.SDL_BindAudioStream(devid, @ptrCast(stream)));
+}
+
+pub inline fn unbindAudioStreams(streams: [*c]?*const AudioStream, num_streams: c_int) void {
+    return c.SDL_UnbindAudioStreams(streams, num_streams);
+}
+
+pub inline fn createAudioStream(src_spec: ?*const AudioSpec, dst_spec: ?*const AudioSpec) ?*AudioStream {
+    return @ptrCast(c.SDL_CreateAudioStream(@ptrCast(src_spec), @ptrCast(dst_spec)));
+}
+
+pub const AudioStreamDataCompleteCallback = c.SDL_AudioStreamDataCompleteCallback;
+
+pub const AudioStreamCallback = c.SDL_AudioStreamCallback;
+
+pub inline fn openAudioDeviceStream(devid: AudioDeviceID, spec: ?*const AudioSpec, callback: AudioStreamCallback, userdata: ?*anyopaque) ?*AudioStream {
+    return @ptrCast(c.SDL_OpenAudioDeviceStream(devid, @ptrCast(spec), callback, userdata));
+}
+
+pub const AudioPostmixCallback = c.SDL_AudioPostmixCallback;
+
+pub inline fn setAudioPostmixCallback(devid: AudioDeviceID, callback: AudioPostmixCallback, userdata: ?*anyopaque) bool {
+    return @bitCast(c.SDL_SetAudioPostmixCallback(devid, callback, userdata));
+}
+
+pub inline fn loadWAV_IO(src: ?*IOStream, closeio: bool, spec: ?*AudioSpec, audio_buf: [*c][*c]u8, audio_len: *u32) bool {
+    return @bitCast(c.SDL_LoadWAV_IO(@ptrCast(src), @bitCast(closeio), @ptrCast(spec), audio_buf, @ptrCast(audio_len)));
+}
+
+pub inline fn loadWAV(path: [*c]const u8, spec: ?*AudioSpec, audio_buf: [*c][*c]u8, audio_len: *u32) bool {
+    return @bitCast(c.SDL_LoadWAV(path, @ptrCast(spec), audio_buf, @ptrCast(audio_len)));
+}
+
+pub inline fn mixAudio(dst: [*c]u8, src: [*c]const u8, format: AudioFormat, len: u32, volume: f32) bool {
+    return @bitCast(c.SDL_MixAudio(dst, src, @bitCast(format), len, volume));
+}
+
+pub inline fn convertAudioSamples(src_spec: ?*const AudioSpec, src_data: [*c]const u8, src_len: c_int, dst_spec: ?*const AudioSpec, dst_data: [*c][*c]u8, dst_len: *c_int) bool {
+    return @bitCast(c.SDL_ConvertAudioSamples(@ptrCast(src_spec), src_data, src_len, @ptrCast(dst_spec), dst_data, @ptrCast(dst_len)));
+}
+
+pub inline fn getAudioFormatName(format: AudioFormat) [*c]const u8 {
+    return c.SDL_GetAudioFormatName(@bitCast(format));
+}
+
+pub inline fn getSilenceValueForFormat(format: AudioFormat) c_int {
+    return c.SDL_GetSilenceValueForFormat(@bitCast(format));
+}

api/blendmode.zig

@@ -0,0 +1,28 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const BlendMode = u32;
+
+pub const BlendOperation = enum(c_int) {
+    blendoperationAdd = 0x1, //dst + src: supported by all renderers
+    blendoperationSubtract = 0x2, //src - dst : supported by D3D, OpenGL, OpenGLES, and Vulkan
+    blendoperationRevSubtract = 0x3, //dst - src : supported by D3D, OpenGL, OpenGLES, and Vulkan
+    blendoperationMinimum = 0x4, //min(dst, src) : supported by D3D, OpenGL, OpenGLES, and Vulkan
+    blendoperationMaximum = 0x5,
+};
+
+pub const BlendFactor = enum(c_int) {
+    blendfactorZero = 0x1, //0, 0, 0, 0
+    blendfactorOne = 0x2, //1, 1, 1, 1
+    blendfactorSrcColor = 0x3, //srcR, srcG, srcB, srcA
+    blendfactorOneMinusSrcColor = 0x4, //1-srcR, 1-srcG, 1-srcB, 1-srcA
+    blendfactorSrcAlpha = 0x5, //srcA, srcA, srcA, srcA
+    blendfactorOneMinusSrcAlpha = 0x6, //1-srcA, 1-srcA, 1-srcA, 1-srcA
+    blendfactorDstColor = 0x7, //dstR, dstG, dstB, dstA
+    blendfactorOneMinusDstColor = 0x8, //1-dstR, 1-dstG, 1-dstB, 1-dstA
+    blendfactorDstAlpha = 0x9, //dstA, dstA, dstA, dstA
+    blendfactorOneMinusDstAlpha = 0xA,
+};
+
+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)));
+}

api/camera.zig

@@ -0,0 +1,94 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const pixels_api = @import("pixels.zig");
+const surface_api = @import("surface.zig");
+const properties_api = @import("properties.zig");
+
+pub const PixelFormat = pixels_api.PixelFormat;
+pub const Surface = surface_api.Surface;
+pub const Colorspace = pixels_api.Colorspace;
+pub const PropertiesID = properties_api.PropertiesID;
+
+pub const CameraID = u32;
+
+pub const Camera = opaque {
+    pub inline fn getCameraPermissionState(camera: *Camera) CameraPermissionState {
+        return c.SDL_GetCameraPermissionState(@ptrCast(camera));
+    }
+
+    pub inline fn getCameraID(camera: *Camera) CameraID {
+        return c.SDL_GetCameraID(@ptrCast(camera));
+    }
+
+    pub inline fn getCameraProperties(camera: *Camera) PropertiesID {
+        return c.SDL_GetCameraProperties(@ptrCast(camera));
+    }
+
+    pub inline fn getCameraFormat(camera: *Camera, spec: ?*CameraSpec) bool {
+        return @bitCast(c.SDL_GetCameraFormat(@ptrCast(camera), @ptrCast(spec)));
+    }
+
+    pub inline fn acquireCameraFrame(camera: *Camera, timestampNS: *u64) ?*Surface {
+        return @ptrCast(c.SDL_AcquireCameraFrame(@ptrCast(camera), @ptrCast(timestampNS)));
+    }
+
+    pub inline fn releaseCameraFrame(camera: *Camera, frame: ?*Surface) void {
+        return c.SDL_ReleaseCameraFrame(@ptrCast(camera), @ptrCast(frame));
+    }
+
+    pub inline fn closeCamera(camera: *Camera) void {
+        return c.SDL_CloseCamera(@ptrCast(camera));
+    }
+};
+
+pub const CameraSpec = extern struct {
+    format: PixelFormat, // Frame format
+    colorspace: Colorspace, // Frame colorspace
+    width: c_int, // Frame width
+    height: c_int, // Frame height
+    framerate_numerator: c_int, // Frame rate numerator ((num / denom) == FPS, (denom / num) == duration in seconds)
+    framerate_denominator: c_int, // Frame rate denominator ((num / denom) == FPS, (denom / num) == duration in seconds)
+};
+
+pub const CameraPosition = enum(c_int) {
+    cameraPositionUnknown,
+    cameraPositionFrontFacing,
+    cameraPositionBackFacing,
+};
+
+pub const CameraPermissionState = enum(c_int) {
+    cameraPermissionStatePending,
+    cameraPermissionStateApproved,
+};
+
+pub inline fn getNumCameraDrivers() c_int {
+    return c.SDL_GetNumCameraDrivers();
+}
+
+pub inline fn getCameraDriver(index: c_int) [*c]const u8 {
+    return c.SDL_GetCameraDriver(index);
+}
+
+pub inline fn getCurrentCameraDriver() [*c]const u8 {
+    return c.SDL_GetCurrentCameraDriver();
+}
+
+pub inline fn getCameras(count: *c_int) ?*CameraID {
+    return @ptrCast(c.SDL_GetCameras(@ptrCast(count)));
+}
+
+pub inline fn getCameraSupportedFormats(instance_id: CameraID, count: *c_int) [*c]?*CameraSpec {
+    return c.SDL_GetCameraSupportedFormats(instance_id, @ptrCast(count));
+}
+
+pub inline fn getCameraName(instance_id: CameraID) [*c]const u8 {
+    return c.SDL_GetCameraName(instance_id);
+}
+
+pub inline fn getCameraPosition(instance_id: CameraID) CameraPosition {
+    return c.SDL_GetCameraPosition(instance_id);
+}
+
+pub inline fn openCamera(instance_id: CameraID, spec: ?*const CameraSpec) ?*Camera {
+    return @ptrCast(c.SDL_OpenCamera(instance_id, @ptrCast(spec)));
+}

api/clipboard.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub inline fn setClipboardText(text: [*c]const u8) bool {
+    return @bitCast(c.SDL_SetClipboardText(text));
+}
+
+pub inline fn getClipboardText() [*c]u8 {
+    return c.SDL_GetClipboardText();
+}
+
+pub inline fn hasClipboardText() bool {
+    return @bitCast(c.SDL_HasClipboardText());
+}
+
+pub inline fn setPrimarySelectionText(text: [*c]const u8) bool {
+    return @bitCast(c.SDL_SetPrimarySelectionText(text));
+}
+
+pub inline fn getPrimarySelectionText() [*c]u8 {
+    return c.SDL_GetPrimarySelectionText();
+}
+
+pub inline fn hasPrimarySelectionText() bool {
+    return @bitCast(c.SDL_HasPrimarySelectionText());
+}
+
+pub const ClipboardDataCallback = c.SDL_ClipboardDataCallback;
+
+pub const ClipboardCleanupCallback = c.SDL_ClipboardCleanupCallback;
+
+pub inline fn setClipboardData(callback: ClipboardDataCallback, cleanup: ClipboardCleanupCallback, userdata: ?*anyopaque, mime_types: [*c][*c]const u8, num_mime_types: usize) bool {
+    return @bitCast(c.SDL_SetClipboardData(callback, cleanup, userdata, mime_types, num_mime_types));
+}
+
+pub inline fn clearClipboardData() bool {
+    return @bitCast(c.SDL_ClearClipboardData());
+}
+
+pub inline fn getClipboardData(mime_type: [*c]const u8, size: *usize) ?*anyopaque {
+    return c.SDL_GetClipboardData(mime_type, @ptrCast(size));
+}
+
+pub inline fn hasClipboardData(mime_type: [*c]const u8) bool {
+    return @bitCast(c.SDL_HasClipboardData(mime_type));
+}
+
+pub inline fn getClipboardMimeTypes(num_mime_types: *usize) [*c][*c]u8 {
+    return c.SDL_GetClipboardMimeTypes(@ptrCast(num_mime_types));
+}

api/dialog.zig

@@ -0,0 +1,36 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const video_api = @import("video.zig");
+const properties_api = @import("properties.zig");
+
+pub const Window = video_api.Window;
+pub const PropertiesID = properties_api.PropertiesID;
+
+pub const DialogFileFilter = extern struct {
+    name: [*c]const u8,
+    pattern: [*c]const u8,
+};
+
+pub const DialogFileCallback = c.SDL_DialogFileCallback;
+
+pub inline fn showOpenFileDialog(callback: DialogFileCallback, userdata: ?*anyopaque, window: ?*Window, filters: ?*const DialogFileFilter, nfilters: c_int, default_location: [*c]const u8, allow_many: bool) void {
+    return c.SDL_ShowOpenFileDialog(callback, userdata, @ptrCast(window), @ptrCast(filters), nfilters, default_location, @bitCast(allow_many));
+}
+
+pub inline fn showSaveFileDialog(callback: DialogFileCallback, userdata: ?*anyopaque, window: ?*Window, filters: ?*const DialogFileFilter, nfilters: c_int, default_location: [*c]const u8) void {
+    return c.SDL_ShowSaveFileDialog(callback, userdata, @ptrCast(window), @ptrCast(filters), nfilters, default_location);
+}
+
+pub inline fn showOpenFolderDialog(callback: DialogFileCallback, userdata: ?*anyopaque, window: ?*Window, default_location: [*c]const u8, allow_many: bool) void {
+    return c.SDL_ShowOpenFolderDialog(callback, userdata, @ptrCast(window), default_location, @bitCast(allow_many));
+}
+
+pub const FileDialogType = enum(c_int) {
+    filedialogOpenfile,
+    filedialogSavefile,
+    filedialogOpenfolder,
+};
+
+pub inline fn showFileDialogWithProperties(_type: FileDialogType, callback: DialogFileCallback, userdata: ?*anyopaque, props: PropertiesID) void {
+    return c.SDL_ShowFileDialogWithProperties(@intFromEnum(_type), callback, userdata, props);
+}

api/endian.zig

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

api/error.zig

@@ -0,0 +1,13 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub inline fn outOfMemory() bool {
+    return @bitCast(c.SDL_OutOfMemory());
+}
+
+pub inline fn getError() [*c]const u8 {
+    return c.SDL_GetError();
+}
+
+pub inline fn clearError() bool {
+    return @bitCast(c.SDL_ClearError());
+}

api/events.zig

@@ -0,0 +1,676 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const pen_api = @import("pen.zig");
+const video_api = @import("video.zig");
+const audio_api = @import("audio.zig");
+const camera_api = @import("camera.zig");
+const mouse_api = @import("mouse.zig");
+const scancode_api = @import("scancode.zig");
+const touch_api = @import("touch.zig");
+const keyboard_api = @import("keyboard.zig");
+const power_api = @import("power.zig");
+const keycode_api = @import("keycode.zig");
+const sensor_api = @import("sensor.zig");
+const joystick_api = @import("joystick.zig");
+
+pub const PenID = pen_api.PenID;
+pub const WindowID = video_api.WindowID;
+pub const AudioDeviceID = audio_api.AudioDeviceID;
+pub const DisplayID = video_api.DisplayID;
+pub const CameraID = camera_api.CameraID;
+pub const PenInputFlags = pen_api.PenInputFlags;
+pub const MouseButtonFlags = mouse_api.MouseButtonFlags;
+pub const Scancode = scancode_api.Scancode;
+pub const TouchID = touch_api.TouchID;
+pub const KeyboardID = keyboard_api.KeyboardID;
+pub const PenAxis = pen_api.PenAxis;
+pub const MouseID = mouse_api.MouseID;
+pub const MouseWheelDirection = mouse_api.MouseWheelDirection;
+pub const PowerState = power_api.PowerState;
+pub const Window = video_api.Window;
+pub const FingerID = touch_api.FingerID;
+pub const Keycode = keycode_api.Keycode;
+pub const SensorID = sensor_api.SensorID;
+pub const JoystickID = joystick_api.JoystickID;
+pub const Keymod = keycode_api.Keymod;
+
+pub const EventType = enum(c_int) {
+    eventFirst = 0, //Unused (do not remove)
+    eventQuit = 0x100, //User-requested quit
+    eventTerminating,
+    eventLowMemory,
+    eventWillEnterBackground,
+    eventDidEnterBackground,
+    eventWillEnterForeground,
+    eventDidEnterForeground,
+    eventLocaleChanged, //The user's locale preferences have changed.
+    eventSystemThemeChanged, //The system theme changed
+    eventDisplayOrientation = 0x151, //Display orientation has changed to data1
+    eventDisplayAdded, //Display has been added to the system
+    eventDisplayRemoved, //Display has been removed from the system
+    eventDisplayMoved, //Display has changed position
+    eventDisplayDesktopModeChanged, //Display has changed desktop mode
+    eventDisplayCurrentModeChanged, //Display has changed current mode
+    eventDisplayContentScaleChanged, //Display has changed content scale
+    eventDisplayUsableBoundsChanged, //Display has changed usable bounds
+    eventWindowShown = 0x202, //Window has been shown
+    eventWindowHidden, //Window has been hidden
+    eventWindowExposed,
+    eventWindowMoved, //Window has been moved to data1, data2
+    eventWindowResized, //Window has been resized to data1xdata2
+    eventWindowPixelSizeChanged, //The pixel size of the window has changed to data1xdata2
+    eventWindowMetalViewResized, //The pixel size of a Metal view associated with the window has changed
+    eventWindowMinimized, //Window has been minimized
+    eventWindowMaximized, //Window has been maximized
+    eventWindowRestored, //Window has been restored to normal size and position
+    eventWindowMouseEnter, //Window has gained mouse focus
+    eventWindowMouseLeave, //Window has lost mouse focus
+    eventWindowFocusGained, //Window has gained keyboard focus
+    eventWindowFocusLost, //Window has lost keyboard focus
+    eventWindowCloseRequested, //The window manager requests that the window be closed
+    eventWindowHitTest, //Window had a hit test that wasn't SDL_HITTEST_NORMAL
+    eventWindowIccprofChanged, //The ICC profile of the window's display has changed
+    eventWindowDisplayChanged, //Window has been moved to display data1
+    eventWindowDisplayScaleChanged, //Window display scale has been changed
+    eventWindowSafeAreaChanged, //The window safe area has been changed
+    eventWindowOccluded, //The window has been occluded
+    eventWindowEnterFullscreen, //The window has entered fullscreen mode
+    eventWindowLeaveFullscreen, //The window has left fullscreen mode
+    eventWindowDestroyed,
+    eventWindowHdrStateChanged, //Window HDR properties have changed
+    eventKeyDown = 0x300, //Key pressed
+    eventKeyUp, //Key released
+    eventTextEditing, //Keyboard text editing (composition)
+    eventTextInput, //Keyboard text input
+    eventKeymapChanged,
+    eventKeyboardAdded, //A new keyboard has been inserted into the system
+    eventKeyboardRemoved, //A keyboard has been removed
+    eventTextEditingCandidates, //Keyboard text editing candidates
+    eventScreenKeyboardShown, //The on-screen keyboard has been shown
+    eventScreenKeyboardHidden, //The on-screen keyboard has been hidden
+    eventMouseMotion = 0x400, //Mouse moved
+    eventMouseButtonDown, //Mouse button pressed
+    eventMouseButtonUp, //Mouse button released
+    eventMouseWheel, //Mouse wheel motion
+    eventMouseAdded, //A new mouse has been inserted into the system
+    eventMouseRemoved, //A mouse has been removed
+    eventJoystickAxisMotion = 0x600, //Joystick axis motion
+    eventJoystickBallMotion, //Joystick trackball motion
+    eventJoystickHatMotion, //Joystick hat position change
+    eventJoystickButtonDown, //Joystick button pressed
+    eventJoystickButtonUp, //Joystick button released
+    eventJoystickAdded, //A new joystick has been inserted into the system
+    eventJoystickRemoved, //An opened joystick has been removed
+    eventJoystickBatteryUpdated, //Joystick battery level change
+    eventJoystickUpdateComplete, //Joystick update is complete
+    eventGamepadAxisMotion = 0x650, //Gamepad axis motion
+    eventGamepadButtonDown, //Gamepad button pressed
+    eventGamepadButtonUp, //Gamepad button released
+    eventGamepadAdded, //A new gamepad has been inserted into the system
+    eventGamepadRemoved, //A gamepad has been removed
+    eventGamepadRemapped, //The gamepad mapping was updated
+    eventGamepadTouchpadDown, //Gamepad touchpad was touched
+    eventGamepadTouchpadMotion, //Gamepad touchpad finger was moved
+    eventGamepadTouchpadUp, //Gamepad touchpad finger was lifted
+    eventGamepadSensorUpdate, //Gamepad sensor was updated
+    eventGamepadUpdateComplete, //Gamepad update is complete
+    eventGamepadSteamHandleUpdated, //Gamepad Steam handle has changed
+    eventFingerUp,
+    eventFingerMotion,
+    eventFingerCanceled,
+    eventPinchBegin = 0x710, //Pinch gesture started
+    eventPinchUpdate, //Pinch gesture updated
+    eventPinchEnd, //Pinch gesture ended
+    eventClipboardUpdate = 0x900, //The clipboard changed
+    eventDropFile = 0x1000, //The system requests a file open
+    eventDropText, //text/plain drag-and-drop event
+    eventDropBegin, //A new set of drops is beginning (NULL filename)
+    eventDropComplete, //Current set of drops is now complete (NULL filename)
+    eventDropPosition, //Position while moving over the window
+    eventAudioDeviceAdded = 0x1100, //A new audio device is available
+    eventAudioDeviceRemoved, //An audio device has been removed.
+    eventAudioDeviceFormatChanged, //An audio device's format has been changed by the system.
+    eventSensorUpdate = 0x1200, //A sensor was updated
+    eventPenProximityIn = 0x1300, //Pressure-sensitive pen has become available
+    eventPenProximityOut, //Pressure-sensitive pen has become unavailable
+    eventPenDown, //Pressure-sensitive pen touched drawing surface
+    eventPenUp, //Pressure-sensitive pen stopped touching drawing surface
+    eventPenButtonDown, //Pressure-sensitive pen button pressed
+    eventPenButtonUp, //Pressure-sensitive pen button released
+    eventPenMotion, //Pressure-sensitive pen is moving on the tablet
+    eventPenAxis, //Pressure-sensitive pen angle/pressure/etc changed
+    eventCameraDeviceAdded = 0x1400, //A new camera device is available
+    eventCameraDeviceRemoved, //A camera device has been removed.
+    eventCameraDeviceApproved, //A camera device has been approved for use by the user.
+    eventCameraDeviceDenied, //A camera device has been denied for use by the user.
+    eventRenderTargetsReset = 0x2000, //The render targets have been reset and their contents need to be updated
+    eventRenderDeviceReset, //The device has been reset and all textures need to be recreated
+    eventRenderDeviceLost, //The device has been lost and can't be recovered.
+    eventPrivate1,
+    eventPrivate2,
+    eventPrivate3,
+    eventPollSentinel = 0x7F00, //Signals the end of an event poll cycle
+};
+
+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_EVENT_DISPLAY_*
+    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
+    integer_x: i32, // The amount scrolled horizontally, accumulated to whole scroll "ticks" (added in 3.2.12)
+    integer_y: i32, // The amount scrolled vertically, accumulated to whole scroll "ticks" (added in 3.2.12)
+};
+
+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 PinchFingerEvent = extern struct {
+    _type: EventType, // ::SDL_EVENT_PINCH_BEGIN or ::SDL_EVENT_PINCH_UPDATE or ::SDL_EVENT_PINCH_END
+    reserved: u32,
+    timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS()
+    scale: f32, // The scale change since the last SDL_EVENT_PINCH_UPDATE. Scale < 1 is "zoom out". Scale > 1 is "zoom in".
+    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, 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
+    pinch: PinchFingerEvent, // Pinch 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 const EventAction = enum(c_int) {
+    addevent, //Add events to the back of the queue.
+    peekevent, //Check but don't remove events from the queue front.
+    getevent, //Retrieve/remove events from the front of the queue.
+};
+
+pub inline fn peepEvents(events: ?*Event, numevents: c_int, action: EventAction, minType: u32, maxType: u32) c_int {
+    return c.SDL_PeepEvents(@ptrCast(events), numevents, action, minType, maxType);
+}
+
+pub inline fn hasEvent(_type: u32) bool {
+    return @bitCast(c.SDL_HasEvent(_type));
+}
+
+pub inline fn hasEvents(minType: u32, maxType: u32) bool {
+    return @bitCast(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 @bitCast(c.SDL_PollEvent(@ptrCast(event)));
+}
+
+pub inline fn waitEvent(event: ?*Event) bool {
+    return @bitCast(c.SDL_WaitEvent(@ptrCast(event)));
+}
+
+pub inline fn waitEventTimeout(event: ?*Event, timeoutMS: i32) bool {
+    return @bitCast(c.SDL_WaitEventTimeout(@ptrCast(event), timeoutMS));
+}
+
+pub inline fn pushEvent(event: ?*Event) bool {
+    return @bitCast(c.SDL_PushEvent(@ptrCast(event)));
+}
+
+pub const EventFilter = c.SDL_EventFilter;
+
+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 @bitCast(c.SDL_GetEventFilter(@ptrCast(filter), userdata));
+}
+
+pub inline fn addEventWatch(filter: EventFilter, userdata: ?*anyopaque) bool {
+    return @bitCast(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, @bitCast(enabled));
+}
+
+pub inline fn eventEnabled(_type: u32) bool {
+    return @bitCast(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 @ptrCast(c.SDL_GetWindowFromEvent(@ptrCast(event)));
+}
+
+pub inline fn getEventDescription(event: ?*const Event, buf: [*c]u8, buflen: c_int) c_int {
+    return c.SDL_GetEventDescription(@ptrCast(event), buf, buflen);
+}

api/filesystem.zig

@@ -0,0 +1,95 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const stdinc_api = @import("stdinc.zig");
+
+pub const Time = stdinc_api.Time;
+
+pub inline fn getBasePath() [*c]const u8 {
+    return c.SDL_GetBasePath();
+}
+
+pub inline fn getPrefPath(org: [*c]const u8, app: [*c]const u8) [*c]u8 {
+    return c.SDL_GetPrefPath(org, app);
+}
+
+pub const Folder = enum(c_int) {
+    folderHome, //The folder which contains all of the current user's data, preferences, and documents. It usually contains most of the other folders. If a requested folder does not exist, the home folder can be considered a safe fallback to store a user's documents.
+    folderDesktop, //The folder of files that are displayed on the desktop. Note that the existence of a desktop folder does not guarantee that the system does show icons on its desktop; certain GNU/Linux distros with a graphical environment may not have desktop icons.
+    folderDocuments, //User document files, possibly application-specific. This is a good place to save a user's projects.
+    folderDownloads, //Standard folder for user files downloaded from the internet.
+    folderMusic, //Music files that can be played using a standard music player (mp3, ogg...).
+    folderPictures, //Image files that can be displayed using a standard viewer (png, jpg...).
+    folderPublicshare, //Files that are meant to be shared with other users on the same computer.
+    folderSavedgames, //Save files for games.
+    folderScreenshots, //Application screenshots.
+    folderTemplates, //Template files to be used when the user requests the desktop environment to create a new file in a certain folder, such as "New Text File.txt".  Any file in the Templates folder can be used as a starting point for a new file.
+    folderVideos, //Video files that can be played using a standard video player (mp4, webm...).
+    folderCount,
+};
+
+pub inline fn getUserFolder(folder: Folder) [*c]const u8 {
+    return c.SDL_GetUserFolder(folder);
+}
+
+pub const PathType = enum(c_int) {
+    pathtypeNone, //path does not exist
+    pathtypeFile, //a normal file
+    pathtypeDirectory, //a directory
+    pathtypeOther,
+};
+
+pub const PathInfo = extern struct {
+    _type: PathType, // the path type
+    size: u64, // the file size in bytes
+    create_time: Time, // the time when the path was created
+    modify_time: Time, // the last time the path was modified
+    access_time: Time, // the last time the path was read
+};
+
+pub const GlobFlags = packed struct(u32) {
+    globCaseinsensitive: bool = false,
+    pad0: u30 = 0,
+    rsvd: bool = false,
+
+    pub const None = GlobFlags{};
+};
+
+pub inline fn createDirectory(path: [*c]const u8) bool {
+    return @bitCast(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 = c.SDL_EnumerateDirectoryCallback;
+
+pub inline fn enumerateDirectory(path: [*c]const u8, callback: EnumerateDirectoryCallback, userdata: ?*anyopaque) bool {
+    return @bitCast(c.SDL_EnumerateDirectory(path, callback, userdata));
+}
+
+pub inline fn removePath(path: [*c]const u8) bool {
+    return @bitCast(c.SDL_RemovePath(path));
+}
+
+pub inline fn renamePath(oldpath: [*c]const u8, newpath: [*c]const u8) bool {
+    return @bitCast(c.SDL_RenamePath(oldpath, newpath));
+}
+
+pub inline fn copyFile(oldpath: [*c]const u8, newpath: [*c]const u8) bool {
+    return @bitCast(c.SDL_CopyFile(oldpath, newpath));
+}
+
+pub inline fn getPathInfo(path: [*c]const u8, info: ?*PathInfo) bool {
+    return @bitCast(c.SDL_GetPathInfo(path, @ptrCast(info)));
+}
+
+pub inline fn globDirectory(path: [*c]const u8, pattern: [*c]const u8, flags: GlobFlags, count: *c_int) [*c][*c]u8 {
+    return c.SDL_GlobDirectory(path, pattern, @bitCast(flags), @ptrCast(count));
+}
+
+pub inline fn getCurrentDirectory() [*c]u8 {
+    return c.SDL_GetCurrentDirectory();
+}

api/gamepad.zig

@@ -0,0 +1,386 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const joystick_api = @import("joystick.zig");
+const guid_api = @import("guid.zig");
+const properties_api = @import("properties.zig");
+const iostream_api = @import("iostream.zig");
+const sensor_api = @import("sensor.zig");
+const power_api = @import("power.zig");
+
+pub const JoystickConnectionState = joystick_api.JoystickConnectionState;
+pub const GUID = guid_api.GUID;
+pub const PropertiesID = properties_api.PropertiesID;
+pub const IOStream = iostream_api.IOStream;
+pub const JoystickID = joystick_api.JoystickID;
+pub const SensorType = sensor_api.SensorType;
+pub const PowerState = power_api.PowerState;
+pub const Joystick = joystick_api.Joystick;
+
+pub const Gamepad = opaque {
+    pub inline fn getGamepadMapping(gamepad: *Gamepad) [*c]u8 {
+        return c.SDL_GetGamepadMapping(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadProperties(gamepad: *Gamepad) PropertiesID {
+        return c.SDL_GetGamepadProperties(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadID(gamepad: *Gamepad) JoystickID {
+        return c.SDL_GetGamepadID(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadName(gamepad: *Gamepad) [*c]const u8 {
+        return c.SDL_GetGamepadName(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadPath(gamepad: *Gamepad) [*c]const u8 {
+        return c.SDL_GetGamepadPath(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadType(gamepad: *Gamepad) GamepadType {
+        return @intFromEnum(c.SDL_GetGamepadType(@ptrCast(gamepad)));
+    }
+
+    pub inline fn getRealGamepadType(gamepad: *Gamepad) GamepadType {
+        return @intFromEnum(c.SDL_GetRealGamepadType(@ptrCast(gamepad)));
+    }
+
+    pub inline fn getGamepadPlayerIndex(gamepad: *Gamepad) c_int {
+        return c.SDL_GetGamepadPlayerIndex(@ptrCast(gamepad));
+    }
+
+    pub inline fn setGamepadPlayerIndex(gamepad: *Gamepad, player_index: c_int) bool {
+        return @bitCast(c.SDL_SetGamepadPlayerIndex(@ptrCast(gamepad), player_index));
+    }
+
+    pub inline fn getGamepadVendor(gamepad: *Gamepad) u16 {
+        return c.SDL_GetGamepadVendor(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadProduct(gamepad: *Gamepad) u16 {
+        return c.SDL_GetGamepadProduct(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadProductVersion(gamepad: *Gamepad) u16 {
+        return c.SDL_GetGamepadProductVersion(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadFirmwareVersion(gamepad: *Gamepad) u16 {
+        return c.SDL_GetGamepadFirmwareVersion(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadSerial(gamepad: *Gamepad) [*c]const u8 {
+        return c.SDL_GetGamepadSerial(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadSteamHandle(gamepad: *Gamepad) u64 {
+        return c.SDL_GetGamepadSteamHandle(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadConnectionState(gamepad: *Gamepad) JoystickConnectionState {
+        return c.SDL_GetGamepadConnectionState(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadPowerInfo(gamepad: *Gamepad, percent: *c_int) PowerState {
+        return c.SDL_GetGamepadPowerInfo(@ptrCast(gamepad), @ptrCast(percent));
+    }
+
+    pub inline fn gamepadConnected(gamepad: *Gamepad) bool {
+        return @bitCast(c.SDL_GamepadConnected(@ptrCast(gamepad)));
+    }
+
+    pub inline fn getGamepadJoystick(gamepad: *Gamepad) ?*Joystick {
+        return @ptrCast(c.SDL_GetGamepadJoystick(@ptrCast(gamepad)));
+    }
+
+    pub inline fn getGamepadBindings(gamepad: *Gamepad, count: *c_int) [*c]?*GamepadBinding {
+        return c.SDL_GetGamepadBindings(@ptrCast(gamepad), @ptrCast(count));
+    }
+
+    pub inline fn gamepadHasAxis(gamepad: *Gamepad, axis: GamepadAxis) bool {
+        return @bitCast(c.SDL_GamepadHasAxis(@ptrCast(gamepad), axis));
+    }
+
+    pub inline fn getGamepadAxis(gamepad: *Gamepad, axis: GamepadAxis) i16 {
+        return c.SDL_GetGamepadAxis(@ptrCast(gamepad), axis);
+    }
+
+    pub inline fn gamepadHasButton(gamepad: *Gamepad, button: GamepadButton) bool {
+        return @bitCast(c.SDL_GamepadHasButton(@ptrCast(gamepad), button));
+    }
+
+    pub inline fn getGamepadButton(gamepad: *Gamepad, button: GamepadButton) bool {
+        return @bitCast(c.SDL_GetGamepadButton(@ptrCast(gamepad), button));
+    }
+
+    pub inline fn getGamepadButtonLabel(gamepad: *Gamepad, button: GamepadButton) GamepadButtonLabel {
+        return c.SDL_GetGamepadButtonLabel(@ptrCast(gamepad), button);
+    }
+
+    pub inline fn getNumGamepadTouchpads(gamepad: *Gamepad) c_int {
+        return c.SDL_GetNumGamepadTouchpads(@ptrCast(gamepad));
+    }
+
+    pub inline fn getNumGamepadTouchpadFingers(gamepad: *Gamepad, touchpad: c_int) c_int {
+        return c.SDL_GetNumGamepadTouchpadFingers(@ptrCast(gamepad), touchpad);
+    }
+
+    pub inline fn getGamepadTouchpadFinger(gamepad: *Gamepad, touchpad: c_int, finger: c_int, down: *bool, x: *f32, y: *f32, pressure: *f32) bool {
+        return @bitCast(c.SDL_GetGamepadTouchpadFinger(@ptrCast(gamepad), touchpad, finger, @ptrCast(down), @ptrCast(x), @ptrCast(y), @ptrCast(pressure)));
+    }
+
+    pub inline fn gamepadHasSensor(gamepad: *Gamepad, _type: SensorType) bool {
+        return @bitCast(c.SDL_GamepadHasSensor(@ptrCast(gamepad), @intFromEnum(_type)));
+    }
+
+    pub inline fn setGamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType, enabled: bool) bool {
+        return @bitCast(c.SDL_SetGamepadSensorEnabled(@ptrCast(gamepad), @intFromEnum(_type), @bitCast(enabled)));
+    }
+
+    pub inline fn gamepadSensorEnabled(gamepad: *Gamepad, _type: SensorType) bool {
+        return @bitCast(c.SDL_GamepadSensorEnabled(@ptrCast(gamepad), @intFromEnum(_type)));
+    }
+
+    pub inline fn getGamepadSensorDataRate(gamepad: *Gamepad, _type: SensorType) f32 {
+        return c.SDL_GetGamepadSensorDataRate(@ptrCast(gamepad), @intFromEnum(_type));
+    }
+
+    pub inline fn getGamepadSensorData(gamepad: *Gamepad, _type: SensorType, data: *f32, num_values: c_int) bool {
+        return @bitCast(c.SDL_GetGamepadSensorData(@ptrCast(gamepad), @intFromEnum(_type), @ptrCast(data), num_values));
+    }
+
+    pub inline fn rumbleGamepad(gamepad: *Gamepad, low_frequency_rumble: u16, high_frequency_rumble: u16, duration_ms: u32) bool {
+        return @bitCast(c.SDL_RumbleGamepad(@ptrCast(gamepad), low_frequency_rumble, high_frequency_rumble, duration_ms));
+    }
+
+    pub inline fn rumbleGamepadTriggers(gamepad: *Gamepad, left_rumble: u16, right_rumble: u16, duration_ms: u32) bool {
+        return @bitCast(c.SDL_RumbleGamepadTriggers(@ptrCast(gamepad), left_rumble, right_rumble, duration_ms));
+    }
+
+    pub inline fn setGamepadLED(gamepad: *Gamepad, red: u8, green: u8, blue: u8) bool {
+        return @bitCast(c.SDL_SetGamepadLED(@ptrCast(gamepad), red, green, blue));
+    }
+
+    pub inline fn sendGamepadEffect(gamepad: *Gamepad, data: ?*const anyopaque, size: c_int) bool {
+        return @bitCast(c.SDL_SendGamepadEffect(@ptrCast(gamepad), data, size));
+    }
+
+    pub inline fn closeGamepad(gamepad: *Gamepad) void {
+        return c.SDL_CloseGamepad(@ptrCast(gamepad));
+    }
+
+    pub inline fn getGamepadAppleSFSymbolsNameForButton(gamepad: *Gamepad, button: GamepadButton) [*c]const u8 {
+        return c.SDL_GetGamepadAppleSFSymbolsNameForButton(@ptrCast(gamepad), button);
+    }
+
+    pub inline fn getGamepadAppleSFSymbolsNameForAxis(gamepad: *Gamepad, axis: GamepadAxis) [*c]const u8 {
+        return c.SDL_GetGamepadAppleSFSymbolsNameForAxis(@ptrCast(gamepad), axis);
+    }
+};
+
+pub const GamepadType = enum(c_int) {
+    gamepadTypeStandard,
+    gamepadTypeXbox360,
+    gamepadTypeXboxone,
+    gamepadTypePs3,
+    gamepadTypePs4,
+    gamepadTypePs5,
+    gamepadTypeNintendoSwitchPro,
+    gamepadTypeNintendoSwitchJoyconLeft,
+    gamepadTypeNintendoSwitchJoyconRight,
+    gamepadTypeNintendoSwitchJoyconPair,
+    gamepadTypeGamecube,
+    gamepadTypeCount,
+};
+
+pub const GamepadButton = enum(c_int) {
+    gamepadButtonSouth, //Bottom face button (e.g. Xbox A button)
+    gamepadButtonEast, //Right face button (e.g. Xbox B button)
+    gamepadButtonWest, //Left face button (e.g. Xbox X button)
+    gamepadButtonNorth, //Top face button (e.g. Xbox Y button)
+    gamepadButtonBack,
+    gamepadButtonGuide,
+    gamepadButtonStart,
+    gamepadButtonLeftStick,
+    gamepadButtonRightStick,
+    gamepadButtonLeftShoulder,
+    gamepadButtonRightShoulder,
+    gamepadButtonDpadUp,
+    gamepadButtonDpadDown,
+    gamepadButtonDpadLeft,
+    gamepadButtonDpadRight,
+    gamepadButtonMisc1, //Additional button (e.g. Xbox Series X share button, PS5 microphone button, Nintendo Switch Pro capture button, Amazon Luna microphone button, Google Stadia capture button)
+    gamepadButtonRightPaddle1, //Upper or primary paddle, under your right hand (e.g. Xbox Elite paddle P1, DualSense Edge RB button, Right Joy-Con SR button)
+    gamepadButtonLeftPaddle1, //Upper or primary paddle, under your left hand (e.g. Xbox Elite paddle P3, DualSense Edge LB button, Left Joy-Con SL button)
+    gamepadButtonRightPaddle2, //Lower or secondary paddle, under your right hand (e.g. Xbox Elite paddle P2, DualSense Edge right Fn button, Right Joy-Con SL button)
+    gamepadButtonLeftPaddle2, //Lower or secondary paddle, under your left hand (e.g. Xbox Elite paddle P4, DualSense Edge left Fn button, Left Joy-Con SR button)
+    gamepadButtonTouchpad, //PS4/PS5 touchpad button
+    gamepadButtonMisc2, //Additional button
+    gamepadButtonMisc3, //Additional button (e.g. Nintendo GameCube left trigger click)
+    gamepadButtonMisc4, //Additional button (e.g. Nintendo GameCube right trigger click)
+    gamepadButtonMisc5, //Additional button
+    gamepadButtonMisc6, //Additional button
+    gamepadButtonCount,
+};
+
+pub const GamepadButtonLabel = enum(c_int) {
+    gamepadButtonLabelUnknown,
+    gamepadButtonLabelA,
+    gamepadButtonLabelB,
+    gamepadButtonLabelX,
+    gamepadButtonLabelY,
+    gamepadButtonLabelCross,
+    gamepadButtonLabelCircle,
+    gamepadButtonLabelSquare,
+    gamepadButtonLabelTriangle,
+};
+
+pub const GamepadAxis = enum(c_int) {
+    gamepadAxisLeftx,
+    gamepadAxisLefty,
+    gamepadAxisRightx,
+    gamepadAxisRighty,
+    gamepadAxisLeftTrigger,
+    gamepadAxisRightTrigger,
+    gamepadAxisCount,
+};
+
+pub const GamepadBindingType = enum(c_int) {
+    gamepadBindtypeButton,
+    gamepadBindtypeAxis,
+    gamepadBindtypeHat,
+};
+
+pub const GamepadBinding = opaque {};
+
+pub inline fn addGamepadMapping(mapping: [*c]const u8) c_int {
+    return c.SDL_AddGamepadMapping(mapping);
+}
+
+pub inline fn addGamepadMappingsFromIO(src: ?*IOStream, closeio: bool) c_int {
+    return c.SDL_AddGamepadMappingsFromIO(@ptrCast(src), @bitCast(closeio));
+}
+
+pub inline fn addGamepadMappingsFromFile(file: [*c]const u8) c_int {
+    return c.SDL_AddGamepadMappingsFromFile(file);
+}
+
+pub inline fn reloadGamepadMappings() bool {
+    return @bitCast(c.SDL_ReloadGamepadMappings());
+}
+
+pub inline fn getGamepadMappings(count: *c_int) [*c][*c]u8 {
+    return c.SDL_GetGamepadMappings(@ptrCast(count));
+}
+
+pub inline fn getGamepadMappingForGUID(guid: GUID) [*c]u8 {
+    return c.SDL_GetGamepadMappingForGUID(guid);
+}
+
+pub inline fn setGamepadMapping(instance_id: JoystickID, mapping: [*c]const u8) bool {
+    return @bitCast(c.SDL_SetGamepadMapping(instance_id, mapping));
+}
+
+pub inline fn hasGamepad() bool {
+    return @bitCast(c.SDL_HasGamepad());
+}
+
+pub inline fn getGamepads(count: *c_int) ?*JoystickID {
+    return @ptrCast(c.SDL_GetGamepads(@ptrCast(count)));
+}
+
+pub inline fn isGamepad(instance_id: JoystickID) bool {
+    return @bitCast(c.SDL_IsGamepad(instance_id));
+}
+
+pub inline fn getGamepadNameForID(instance_id: JoystickID) [*c]const u8 {
+    return c.SDL_GetGamepadNameForID(instance_id);
+}
+
+pub inline fn getGamepadPathForID(instance_id: JoystickID) [*c]const u8 {
+    return c.SDL_GetGamepadPathForID(instance_id);
+}
+
+pub inline fn getGamepadPlayerIndexForID(instance_id: JoystickID) c_int {
+    return c.SDL_GetGamepadPlayerIndexForID(instance_id);
+}
+
+pub inline fn getGamepadGUIDForID(instance_id: JoystickID) GUID {
+    return c.SDL_GetGamepadGUIDForID(instance_id);
+}
+
+pub inline fn getGamepadVendorForID(instance_id: JoystickID) u16 {
+    return c.SDL_GetGamepadVendorForID(instance_id);
+}
+
+pub inline fn getGamepadProductForID(instance_id: JoystickID) u16 {
+    return c.SDL_GetGamepadProductForID(instance_id);
+}
+
+pub inline fn getGamepadProductVersionForID(instance_id: JoystickID) u16 {
+    return c.SDL_GetGamepadProductVersionForID(instance_id);
+}
+
+pub inline fn getGamepadTypeForID(instance_id: JoystickID) GamepadType {
+    return @intFromEnum(c.SDL_GetGamepadTypeForID(instance_id));
+}
+
+pub inline fn getRealGamepadTypeForID(instance_id: JoystickID) GamepadType {
+    return @intFromEnum(c.SDL_GetRealGamepadTypeForID(instance_id));
+}
+
+pub inline fn getGamepadMappingForID(instance_id: JoystickID) [*c]u8 {
+    return c.SDL_GetGamepadMappingForID(instance_id);
+}
+
+pub inline fn openGamepad(instance_id: JoystickID) ?*Gamepad {
+    return @ptrCast(c.SDL_OpenGamepad(instance_id));
+}
+
+pub inline fn getGamepadFromID(instance_id: JoystickID) ?*Gamepad {
+    return @ptrCast(c.SDL_GetGamepadFromID(instance_id));
+}
+
+pub inline fn getGamepadFromPlayerIndex(player_index: c_int) ?*Gamepad {
+    return @ptrCast(c.SDL_GetGamepadFromPlayerIndex(player_index));
+}
+
+pub inline fn setGamepadEventsEnabled(enabled: bool) void {
+    return c.SDL_SetGamepadEventsEnabled(@bitCast(enabled));
+}
+
+pub inline fn gamepadEventsEnabled() bool {
+    return @bitCast(c.SDL_GamepadEventsEnabled());
+}
+
+pub inline fn updateGamepads() void {
+    return c.SDL_UpdateGamepads();
+}
+
+pub inline fn getGamepadTypeFromString(str: [*c]const u8) GamepadType {
+    return @intFromEnum(c.SDL_GetGamepadTypeFromString(str));
+}
+
+pub inline fn getGamepadStringForType(_type: GamepadType) [*c]const u8 {
+    return c.SDL_GetGamepadStringForType(@intFromEnum(_type));
+}
+
+pub inline fn getGamepadAxisFromString(str: [*c]const u8) GamepadAxis {
+    return c.SDL_GetGamepadAxisFromString(str);
+}
+
+pub inline fn getGamepadStringForAxis(axis: GamepadAxis) [*c]const u8 {
+    return c.SDL_GetGamepadStringForAxis(axis);
+}
+
+pub inline fn getGamepadButtonFromString(str: [*c]const u8) GamepadButton {
+    return c.SDL_GetGamepadButtonFromString(str);
+}
+
+pub inline fn getGamepadStringForButton(button: GamepadButton) [*c]const u8 {
+    return c.SDL_GetGamepadStringForButton(button);
+}
+
+pub inline fn getGamepadButtonLabelForType(_type: GamepadType, button: GamepadButton) GamepadButtonLabel {
+    return c.SDL_GetGamepadButtonLabelForType(@intFromEnum(_type), button);
+}

api/haptic.zig

@@ -0,0 +1,237 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const joystick_api = @import("joystick.zig");
+
+pub const Joystick = joystick_api.Joystick;
+
+pub const Haptic = opaque {
+    pub inline fn getHapticID(haptic: *Haptic) HapticID {
+        return c.SDL_GetHapticID(@ptrCast(haptic));
+    }
+
+    pub inline fn getHapticName(haptic: *Haptic) [*c]const u8 {
+        return c.SDL_GetHapticName(@ptrCast(haptic));
+    }
+
+    pub inline fn closeHaptic(haptic: *Haptic) void {
+        return c.SDL_CloseHaptic(@ptrCast(haptic));
+    }
+
+    pub inline fn getMaxHapticEffects(haptic: *Haptic) c_int {
+        return c.SDL_GetMaxHapticEffects(@ptrCast(haptic));
+    }
+
+    pub inline fn getMaxHapticEffectsPlaying(haptic: *Haptic) c_int {
+        return c.SDL_GetMaxHapticEffectsPlaying(@ptrCast(haptic));
+    }
+
+    pub inline fn getHapticFeatures(haptic: *Haptic) u32 {
+        return c.SDL_GetHapticFeatures(@ptrCast(haptic));
+    }
+
+    pub inline fn getNumHapticAxes(haptic: *Haptic) c_int {
+        return c.SDL_GetNumHapticAxes(@ptrCast(haptic));
+    }
+
+    pub inline fn hapticEffectSupported(haptic: *Haptic, effect: ?*const HapticEffect) bool {
+        return @bitCast(c.SDL_HapticEffectSupported(@ptrCast(haptic), @ptrCast(effect)));
+    }
+
+    pub inline fn createHapticEffect(haptic: *Haptic, effect: ?*const HapticEffect) HapticEffectID {
+        return c.SDL_CreateHapticEffect(@ptrCast(haptic), @ptrCast(effect));
+    }
+
+    pub inline fn updateHapticEffect(haptic: *Haptic, effect: HapticEffectID, data: ?*const HapticEffect) bool {
+        return @bitCast(c.SDL_UpdateHapticEffect(@ptrCast(haptic), effect, @ptrCast(data)));
+    }
+
+    pub inline fn runHapticEffect(haptic: *Haptic, effect: HapticEffectID, iterations: u32) bool {
+        return @bitCast(c.SDL_RunHapticEffect(@ptrCast(haptic), effect, iterations));
+    }
+
+    pub inline fn stopHapticEffect(haptic: *Haptic, effect: HapticEffectID) bool {
+        return @bitCast(c.SDL_StopHapticEffect(@ptrCast(haptic), effect));
+    }
+
+    pub inline fn destroyHapticEffect(haptic: *Haptic, effect: HapticEffectID) void {
+        return c.SDL_DestroyHapticEffect(@ptrCast(haptic), effect);
+    }
+
+    pub inline fn getHapticEffectStatus(haptic: *Haptic, effect: HapticEffectID) bool {
+        return @bitCast(c.SDL_GetHapticEffectStatus(@ptrCast(haptic), effect));
+    }
+
+    pub inline fn setHapticGain(haptic: *Haptic, gain: c_int) bool {
+        return @bitCast(c.SDL_SetHapticGain(@ptrCast(haptic), gain));
+    }
+
+    pub inline fn setHapticAutocenter(haptic: *Haptic, autocenter: c_int) bool {
+        return @bitCast(c.SDL_SetHapticAutocenter(@ptrCast(haptic), autocenter));
+    }
+
+    pub inline fn pauseHaptic(haptic: *Haptic) bool {
+        return @bitCast(c.SDL_PauseHaptic(@ptrCast(haptic)));
+    }
+
+    pub inline fn resumeHaptic(haptic: *Haptic) bool {
+        return @bitCast(c.SDL_ResumeHaptic(@ptrCast(haptic)));
+    }
+
+    pub inline fn stopHapticEffects(haptic: *Haptic) bool {
+        return @bitCast(c.SDL_StopHapticEffects(@ptrCast(haptic)));
+    }
+
+    pub inline fn hapticRumbleSupported(haptic: *Haptic) bool {
+        return @bitCast(c.SDL_HapticRumbleSupported(@ptrCast(haptic)));
+    }
+
+    pub inline fn initHapticRumble(haptic: *Haptic) bool {
+        return @bitCast(c.SDL_InitHapticRumble(@ptrCast(haptic)));
+    }
+
+    pub inline fn playHapticRumble(haptic: *Haptic, strength: f32, length: u32) bool {
+        return @bitCast(c.SDL_PlayHapticRumble(@ptrCast(haptic), strength, length));
+    }
+
+    pub inline fn stopHapticRumble(haptic: *Haptic) bool {
+        return @bitCast(c.SDL_StopHapticRumble(@ptrCast(haptic)));
+    }
+};
+
+pub const HapticEffectType = u16;
+
+pub const HapticDirectionType = u8;
+
+pub const HapticEffectID = c_int;
+
+pub const HapticDirection = extern struct {
+    _type: HapticDirectionType, // The type of encoding.
+    dir: [3]i32, // The encoded direction.
+};
+
+pub const HapticConstant = extern struct {
+    _type: HapticEffectType, // SDL_HAPTIC_CONSTANT
+    direction: HapticDirection, // Direction of the effect.
+    length: u32, // Duration of the effect.
+    delay: u16, // Delay before starting the effect.
+    button: u16, // Button that triggers the effect.
+    interval: u16, // How soon it can be triggered again after button.
+    level: i16, // Strength of the constant effect.
+    attack_length: u16, // Duration of the attack.
+    attack_level: u16, // Level at the start of the attack.
+    fade_length: u16, // Duration of the fade.
+    fade_level: u16, // Level at the end of the fade.
+};
+
+pub const HapticPeriodic = extern struct {
+    direction: HapticDirection, // Direction of the effect.
+    length: u32, // Duration of the effect.
+    delay: u16, // Delay before starting the effect.
+    button: u16, // Button that triggers the effect.
+    interval: u16, // How soon it can be triggered again after button.
+    period: u16, // Period of the wave.
+    magnitude: i16, // Peak value; if negative, equivalent to 180 degrees extra phase shift.
+    offset: i16, // Mean value of the wave.
+    phase: u16, // Positive phase shift given by hundredth of a degree.
+    attack_length: u16, // Duration of the attack.
+    attack_level: u16, // Level at the start of the attack.
+    fade_length: u16, // Duration of the fade.
+    fade_level: u16, // Level at the end of the fade.
+};
+
+pub const HapticCondition = extern struct {
+    direction: HapticDirection, // Direction of the effect.
+    length: u32, // Duration of the effect.
+    delay: u16, // Delay before starting the effect.
+    button: u16, // Button that triggers the effect.
+    interval: u16, // How soon it can be triggered again after button.
+    right_sat: [3]u16, // Level when joystick is to the positive side; max 0xFFFF.
+    left_sat: [3]u16, // Level when joystick is to the negative side; max 0xFFFF.
+    right_coeff: [3]i16, // How fast to increase the force towards the positive side.
+    left_coeff: [3]i16, // How fast to increase the force towards the negative side.
+    deadband: [3]u16, // Size of the dead zone; max 0xFFFF: whole axis-range when 0-centered.
+    center: [3]i16, // Position of the dead zone.
+};
+
+pub const HapticRamp = extern struct {
+    _type: HapticEffectType, // SDL_HAPTIC_RAMP
+    direction: HapticDirection, // Direction of the effect.
+    length: u32, // Duration of the effect.
+    delay: u16, // Delay before starting the effect.
+    button: u16, // Button that triggers the effect.
+    interval: u16, // How soon it can be triggered again after button.
+    start: i16, // Beginning strength level.
+    end: i16, // Ending strength level.
+    attack_length: u16, // Duration of the attack.
+    attack_level: u16, // Level at the start of the attack.
+    fade_length: u16, // Duration of the fade.
+    fade_level: u16, // Level at the end of the fade.
+};
+
+pub const HapticLeftRight = extern struct {
+    _type: HapticEffectType, // 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: HapticEffectType, // SDL_HAPTIC_CUSTOM
+    direction: HapticDirection, // Direction of the effect.
+    length: u32, // Duration of the effect.
+    delay: u16, // Delay before starting the effect.
+    button: u16, // Button that triggers the effect.
+    interval: u16, // How soon it can be triggered again after button.
+    channels: u8, // Axes to use, minimum of one.
+    period: u16, // Sample periods.
+    samples: u16, // Amount of samples.
+    data: *u16, // Should contain channels*samples items.
+    attack_length: u16, // Duration of the attack.
+    attack_level: u16, // Level at the start of the attack.
+    fade_length: u16, // Duration of the fade.
+    fade_level: u16, // Level at the end of the fade.
+};
+
+pub const HapticEffect = extern union {
+    _type: HapticEffectType, // Effect type.
+    constant: HapticConstant, // Constant effect.
+    periodic: HapticPeriodic, // Periodic effect.
+    condition: HapticCondition, // Condition effect.
+    ramp: HapticRamp, // Ramp effect.
+    leftright: HapticLeftRight, // Left/Right effect.
+    custom: HapticCustom, // Custom effect.
+};
+
+pub const HapticID = u32;
+
+pub inline fn getHaptics(count: *c_int) ?*HapticID {
+    return @ptrCast(c.SDL_GetHaptics(@ptrCast(count)));
+}
+
+pub inline fn getHapticNameForID(instance_id: HapticID) [*c]const u8 {
+    return c.SDL_GetHapticNameForID(instance_id);
+}
+
+pub inline fn openHaptic(instance_id: HapticID) ?*Haptic {
+    return @ptrCast(c.SDL_OpenHaptic(instance_id));
+}
+
+pub inline fn getHapticFromID(instance_id: HapticID) ?*Haptic {
+    return @ptrCast(c.SDL_GetHapticFromID(instance_id));
+}
+
+pub inline fn isMouseHaptic() bool {
+    return @bitCast(c.SDL_IsMouseHaptic());
+}
+
+pub inline fn openHapticFromMouse() ?*Haptic {
+    return @ptrCast(c.SDL_OpenHapticFromMouse());
+}
+
+pub inline fn isJoystickHaptic(joystick: ?*Joystick) bool {
+    return @bitCast(c.SDL_IsJoystickHaptic(@ptrCast(joystick)));
+}
+
+pub inline fn openHapticFromJoystick(joystick: ?*Joystick) ?*Haptic {
+    return @ptrCast(c.SDL_OpenHapticFromJoystick(@ptrCast(joystick)));
+}

api/hints.zig

@@ -0,0 +1,41 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const HintPriority = enum(c_int) {
+    hintDefault,
+    hintNormal,
+    hintOverride,
+};
+
+pub inline fn setHintWithPriority(name: [*c]const u8, value: [*c]const u8, priority: HintPriority) bool {
+    return @bitCast(c.SDL_SetHintWithPriority(name, value, priority));
+}
+
+pub inline fn setHint(name: [*c]const u8, value: [*c]const u8) bool {
+    return @bitCast(c.SDL_SetHint(name, value));
+}
+
+pub inline fn resetHint(name: [*c]const u8) bool {
+    return @bitCast(c.SDL_ResetHint(name));
+}
+
+pub inline fn resetHints() void {
+    return c.SDL_ResetHints();
+}
+
+pub inline fn getHint(name: [*c]const u8) [*c]const u8 {
+    return c.SDL_GetHint(name);
+}
+
+pub inline fn getHintBoolean(name: [*c]const u8, default_value: bool) bool {
+    return @bitCast(c.SDL_GetHintBoolean(name, @bitCast(default_value)));
+}
+
+pub const HintCallback = c.SDL_HintCallback;
+
+pub inline fn addHintCallback(name: [*c]const u8, callback: HintCallback, userdata: ?*anyopaque) bool {
+    return @bitCast(c.SDL_AddHintCallback(name, callback, userdata));
+}
+
+pub inline fn removeHintCallback(name: [*c]const u8, callback: HintCallback, userdata: ?*anyopaque) void {
+    return c.SDL_RemoveHintCallback(name, callback, userdata);
+}

api/init.zig

@@ -0,0 +1,72 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const InitFlags = packed struct(u32) {
+    initAudio: bool = false, // `SDL_INIT_AUDIO` implies `SDL_INIT_EVENTS`
+    initVideo: bool = false, // `SDL_INIT_VIDEO` implies `SDL_INIT_EVENTS`, should be initialized on the main thread
+    initJoystick: bool = false, // `SDL_INIT_JOYSTICK` implies `SDL_INIT_EVENTS`
+    initHaptic: bool = false,
+    initGamepad: bool = false, // `SDL_INIT_GAMEPAD` implies `SDL_INIT_JOYSTICK`
+    initEvents: bool = false,
+    initSensor: bool = false, // `SDL_INIT_SENSOR` implies `SDL_INIT_EVENTS`
+    initCamera: bool = false, // `SDL_INIT_CAMERA` implies `SDL_INIT_EVENTS`
+    pad0: u23 = 0,
+    rsvd: bool = false,
+
+    pub const None = InitFlags{};
+};
+
+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 = c.SDL_AppInit_func;
+
+pub const AppIterate_func = c.SDL_AppIterate_func;
+
+pub const AppEvent_func = c.SDL_AppEvent_func;
+
+pub const AppQuit_func = c.SDL_AppQuit_func;
+
+pub inline fn init(flags: InitFlags) bool {
+    return @bitCast(c.SDL_Init(@bitCast(flags)));
+}
+
+pub inline fn initSubSystem(flags: InitFlags) bool {
+    return @bitCast(c.SDL_InitSubSystem(@bitCast(flags)));
+}
+
+pub inline fn quitSubSystem(flags: InitFlags) void {
+    return c.SDL_QuitSubSystem(@bitCast(flags));
+}
+
+pub inline fn wasInit(flags: InitFlags) InitFlags {
+    return @bitCast(c.SDL_WasInit(@bitCast(flags)));
+}
+
+pub inline fn quit() void {
+    return c.SDL_Quit();
+}
+
+pub inline fn isMainThread() bool {
+    return @bitCast(c.SDL_IsMainThread());
+}
+
+pub const MainThreadCallback = c.SDL_MainThreadCallback;
+
+pub inline fn runOnMainThread(callback: MainThreadCallback, userdata: ?*anyopaque, wait_complete: bool) bool {
+    return @bitCast(c.SDL_RunOnMainThread(callback, userdata, @bitCast(wait_complete)));
+}
+
+pub inline fn setAppMetadata(appname: [*c]const u8, appversion: [*c]const u8, appidentifier: [*c]const u8) bool {
+    return @bitCast(c.SDL_SetAppMetadata(appname, appversion, appidentifier));
+}
+
+pub inline fn setAppMetadataProperty(name: [*c]const u8, value: [*c]const u8) bool {
+    return @bitCast(c.SDL_SetAppMetadataProperty(name, value));
+}
+
+pub inline fn getAppMetadataProperty(name: [*c]const u8) [*c]const u8 {
+    return c.SDL_GetAppMetadataProperty(name);
+}

api/joystick.zig

@@ -0,0 +1,304 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const properties_api = @import("properties.zig");
+const sensor_api = @import("sensor.zig");
+const guid_api = @import("guid.zig");
+const power_api = @import("power.zig");
+
+pub const PropertiesID = properties_api.PropertiesID;
+pub const SensorType = sensor_api.SensorType;
+pub const GUID = guid_api.GUID;
+pub const PowerState = power_api.PowerState;
+
+pub const Joystick = opaque {
+    pub inline fn setJoystickVirtualAxis(joystick: *Joystick, axis: c_int, value: i16) bool {
+        return @bitCast(c.SDL_SetJoystickVirtualAxis(@ptrCast(joystick), axis, value));
+    }
+
+    pub inline fn setJoystickVirtualBall(joystick: *Joystick, ball: c_int, xrel: i16, yrel: i16) bool {
+        return @bitCast(c.SDL_SetJoystickVirtualBall(@ptrCast(joystick), ball, xrel, yrel));
+    }
+
+    pub inline fn setJoystickVirtualButton(joystick: *Joystick, button: c_int, down: bool) bool {
+        return @bitCast(c.SDL_SetJoystickVirtualButton(@ptrCast(joystick), button, @bitCast(down)));
+    }
+
+    pub inline fn setJoystickVirtualHat(joystick: *Joystick, hat: c_int, value: u8) bool {
+        return @bitCast(c.SDL_SetJoystickVirtualHat(@ptrCast(joystick), hat, value));
+    }
+
+    pub inline fn setJoystickVirtualTouchpad(joystick: *Joystick, touchpad: c_int, finger: c_int, down: bool, x: f32, y: f32, pressure: f32) bool {
+        return @bitCast(c.SDL_SetJoystickVirtualTouchpad(@ptrCast(joystick), touchpad, finger, @bitCast(down), x, y, pressure));
+    }
+
+    pub inline fn sendJoystickVirtualSensorData(joystick: *Joystick, _type: SensorType, sensor_timestamp: u64, data: *const f32, num_values: c_int) bool {
+        return @bitCast(c.SDL_SendJoystickVirtualSensorData(@ptrCast(joystick), @intFromEnum(_type), sensor_timestamp, @ptrCast(data), num_values));
+    }
+
+    pub inline fn getJoystickProperties(joystick: *Joystick) PropertiesID {
+        return c.SDL_GetJoystickProperties(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickName(joystick: *Joystick) [*c]const u8 {
+        return c.SDL_GetJoystickName(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickPath(joystick: *Joystick) [*c]const u8 {
+        return c.SDL_GetJoystickPath(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickPlayerIndex(joystick: *Joystick) c_int {
+        return c.SDL_GetJoystickPlayerIndex(@ptrCast(joystick));
+    }
+
+    pub inline fn setJoystickPlayerIndex(joystick: *Joystick, player_index: c_int) bool {
+        return @bitCast(c.SDL_SetJoystickPlayerIndex(@ptrCast(joystick), player_index));
+    }
+
+    pub inline fn getJoystickGUID(joystick: *Joystick) GUID {
+        return c.SDL_GetJoystickGUID(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickVendor(joystick: *Joystick) u16 {
+        return c.SDL_GetJoystickVendor(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickProduct(joystick: *Joystick) u16 {
+        return c.SDL_GetJoystickProduct(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickProductVersion(joystick: *Joystick) u16 {
+        return c.SDL_GetJoystickProductVersion(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickFirmwareVersion(joystick: *Joystick) u16 {
+        return c.SDL_GetJoystickFirmwareVersion(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickSerial(joystick: *Joystick) [*c]const u8 {
+        return c.SDL_GetJoystickSerial(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickType(joystick: *Joystick) JoystickType {
+        return @intFromEnum(c.SDL_GetJoystickType(@ptrCast(joystick)));
+    }
+
+    pub inline fn joystickConnected(joystick: *Joystick) bool {
+        return @bitCast(c.SDL_JoystickConnected(@ptrCast(joystick)));
+    }
+
+    pub inline fn getJoystickID(joystick: *Joystick) JoystickID {
+        return c.SDL_GetJoystickID(@ptrCast(joystick));
+    }
+
+    pub inline fn getNumJoystickAxes(joystick: *Joystick) c_int {
+        return c.SDL_GetNumJoystickAxes(@ptrCast(joystick));
+    }
+
+    pub inline fn getNumJoystickBalls(joystick: *Joystick) c_int {
+        return c.SDL_GetNumJoystickBalls(@ptrCast(joystick));
+    }
+
+    pub inline fn getNumJoystickHats(joystick: *Joystick) c_int {
+        return c.SDL_GetNumJoystickHats(@ptrCast(joystick));
+    }
+
+    pub inline fn getNumJoystickButtons(joystick: *Joystick) c_int {
+        return c.SDL_GetNumJoystickButtons(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickAxis(joystick: *Joystick, axis: c_int) i16 {
+        return c.SDL_GetJoystickAxis(@ptrCast(joystick), axis);
+    }
+
+    pub inline fn getJoystickAxisInitialState(joystick: *Joystick, axis: c_int, state: *i16) bool {
+        return @bitCast(c.SDL_GetJoystickAxisInitialState(@ptrCast(joystick), axis, @ptrCast(state)));
+    }
+
+    pub inline fn getJoystickBall(joystick: *Joystick, ball: c_int, dx: *c_int, dy: *c_int) bool {
+        return @bitCast(c.SDL_GetJoystickBall(@ptrCast(joystick), ball, @ptrCast(dx), @ptrCast(dy)));
+    }
+
+    pub inline fn getJoystickHat(joystick: *Joystick, hat: c_int) u8 {
+        return c.SDL_GetJoystickHat(@ptrCast(joystick), hat);
+    }
+
+    pub inline fn getJoystickButton(joystick: *Joystick, button: c_int) bool {
+        return @bitCast(c.SDL_GetJoystickButton(@ptrCast(joystick), button));
+    }
+
+    pub inline fn rumbleJoystick(joystick: *Joystick, low_frequency_rumble: u16, high_frequency_rumble: u16, duration_ms: u32) bool {
+        return @bitCast(c.SDL_RumbleJoystick(@ptrCast(joystick), low_frequency_rumble, high_frequency_rumble, duration_ms));
+    }
+
+    pub inline fn rumbleJoystickTriggers(joystick: *Joystick, left_rumble: u16, right_rumble: u16, duration_ms: u32) bool {
+        return @bitCast(c.SDL_RumbleJoystickTriggers(@ptrCast(joystick), left_rumble, right_rumble, duration_ms));
+    }
+
+    pub inline fn setJoystickLED(joystick: *Joystick, red: u8, green: u8, blue: u8) bool {
+        return @bitCast(c.SDL_SetJoystickLED(@ptrCast(joystick), red, green, blue));
+    }
+
+    pub inline fn sendJoystickEffect(joystick: *Joystick, data: ?*const anyopaque, size: c_int) bool {
+        return @bitCast(c.SDL_SendJoystickEffect(@ptrCast(joystick), data, size));
+    }
+
+    pub inline fn closeJoystick(joystick: *Joystick) void {
+        return c.SDL_CloseJoystick(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickConnectionState(joystick: *Joystick) JoystickConnectionState {
+        return c.SDL_GetJoystickConnectionState(@ptrCast(joystick));
+    }
+
+    pub inline fn getJoystickPowerInfo(joystick: *Joystick, percent: *c_int) PowerState {
+        return c.SDL_GetJoystickPowerInfo(@ptrCast(joystick), @ptrCast(percent));
+    }
+};
+
+pub const JoystickID = u32;
+
+pub const JoystickType = enum(c_int) {
+    joystickTypeUnknown,
+    joystickTypeGamepad,
+    joystickTypeWheel,
+    joystickTypeArcadeStick,
+    joystickTypeFlightStick,
+    joystickTypeDancePad,
+    joystickTypeGuitar,
+    joystickTypeDrumKit,
+    joystickTypeArcadePad,
+    joystickTypeThrottle,
+    joystickTypeCount,
+};
+
+pub const JoystickConnectionState = enum(c_int) {
+    joystickConnectionUnknown,
+    joystickConnectionWired,
+    joystickConnectionWireless,
+};
+
+pub inline fn lockJoysticks() void {
+    return c.SDL_LockJoysticks();
+}
+
+pub inline fn unlockJoysticks() void {
+    return c.SDL_UnlockJoysticks();
+}
+
+pub inline fn hasJoystick() bool {
+    return @bitCast(c.SDL_HasJoystick());
+}
+
+pub inline fn getJoysticks(count: *c_int) ?*JoystickID {
+    return @ptrCast(c.SDL_GetJoysticks(@ptrCast(count)));
+}
+
+pub inline fn getJoystickNameForID(instance_id: JoystickID) [*c]const u8 {
+    return c.SDL_GetJoystickNameForID(instance_id);
+}
+
+pub inline fn getJoystickPathForID(instance_id: JoystickID) [*c]const u8 {
+    return c.SDL_GetJoystickPathForID(instance_id);
+}
+
+pub inline fn getJoystickPlayerIndexForID(instance_id: JoystickID) c_int {
+    return c.SDL_GetJoystickPlayerIndexForID(instance_id);
+}
+
+pub inline fn getJoystickGUIDForID(instance_id: JoystickID) GUID {
+    return c.SDL_GetJoystickGUIDForID(instance_id);
+}
+
+pub inline fn getJoystickVendorForID(instance_id: JoystickID) u16 {
+    return c.SDL_GetJoystickVendorForID(instance_id);
+}
+
+pub inline fn getJoystickProductForID(instance_id: JoystickID) u16 {
+    return c.SDL_GetJoystickProductForID(instance_id);
+}
+
+pub inline fn getJoystickProductVersionForID(instance_id: JoystickID) u16 {
+    return c.SDL_GetJoystickProductVersionForID(instance_id);
+}
+
+pub inline fn getJoystickTypeForID(instance_id: JoystickID) JoystickType {
+    return @intFromEnum(c.SDL_GetJoystickTypeForID(instance_id));
+}
+
+pub inline fn openJoystick(instance_id: JoystickID) ?*Joystick {
+    return @ptrCast(c.SDL_OpenJoystick(instance_id));
+}
+
+pub inline fn getJoystickFromID(instance_id: JoystickID) ?*Joystick {
+    return @ptrCast(c.SDL_GetJoystickFromID(instance_id));
+}
+
+pub inline fn getJoystickFromPlayerIndex(player_index: c_int) ?*Joystick {
+    return @ptrCast(c.SDL_GetJoystickFromPlayerIndex(player_index));
+}
+
+pub const VirtualJoystickTouchpadDesc = extern struct {
+    nfingers: u16, // the number of simultaneous fingers on this touchpad
+    padding: [3]u16,
+};
+
+pub const VirtualJoystickSensorDesc = extern struct {
+    _type: SensorType, // the type of this sensor
+    rate: f32, // the update frequency of this sensor, may be 0.0f
+};
+
+pub const VirtualJoystickDesc = extern struct {
+    version: u32, // the version of this interface
+    _type: u16, // `SDL_JoystickType`
+    padding: u16, // unused
+    vendor_id: u16, // the USB vendor ID of this joystick
+    product_id: u16, // the USB product ID of this joystick
+    naxes: u16, // the number of axes on this joystick
+    nbuttons: u16, // the number of buttons on this joystick
+    nballs: u16, // the number of balls on this joystick
+    nhats: u16, // the number of hats on this joystick
+    ntouchpads: u16, // the number of touchpads on this joystick, requires `touchpads` to point at valid descriptions
+    nsensors: u16, // the number of sensors on this joystick, requires `sensors` to point at valid descriptions
+    padding2: [2]u16, // unused
+    name: [*c]const u8, // the name of the joystick
+    touchpads: ?*const VirtualJoystickTouchpadDesc, // A pointer to an array of touchpad descriptions, required if `ntouchpads` is > 0
+    sensors: ?*const VirtualJoystickSensorDesc, // A pointer to an array of sensor descriptions, required if `nsensors` is > 0
+    userdata: ?*anyopaque, // User data pointer passed to callbacks
+    Update: ?*const anyopaque, // Called when the joystick state should be updated
+    SetPlayerIndex: ?*const anyopaque, // Called when the player index is set
+    Rumble: ?*const anyopaque, // Implements SDL_RumbleJoystick()
+    RumbleTriggers: ?*const anyopaque, // Implements SDL_RumbleJoystickTriggers()
+    SetLED: ?*const anyopaque, // Implements SDL_SetJoystickLED()
+    SendEffect: ?*const anyopaque, // Implements SDL_SendJoystickEffect()
+    SetSensorsEnabled: ?*const anyopaque, // Implements SDL_SetGamepadSensorEnabled()
+    Cleanup: ?*const anyopaque, // Cleans up the userdata when the joystick is detached
+};
+
+pub inline fn attachVirtualJoystick(desc: ?*const VirtualJoystickDesc) JoystickID {
+    return c.SDL_AttachVirtualJoystick(@ptrCast(desc));
+}
+
+pub inline fn detachVirtualJoystick(instance_id: JoystickID) bool {
+    return @bitCast(c.SDL_DetachVirtualJoystick(instance_id));
+}
+
+pub inline fn isJoystickVirtual(instance_id: JoystickID) bool {
+    return @bitCast(c.SDL_IsJoystickVirtual(instance_id));
+}
+
+pub inline fn getJoystickGUIDInfo(guid: GUID, vendor: *u16, product: *u16, version: *u16, crc16: *u16) void {
+    return c.SDL_GetJoystickGUIDInfo(guid, @ptrCast(vendor), @ptrCast(product), @ptrCast(version), @ptrCast(crc16));
+}
+
+pub inline fn setJoystickEventsEnabled(enabled: bool) void {
+    return c.SDL_SetJoystickEventsEnabled(@bitCast(enabled));
+}
+
+pub inline fn joystickEventsEnabled() bool {
+    return @bitCast(c.SDL_JoystickEventsEnabled());
+}
+
+pub inline fn updateJoysticks() void {
+    return c.SDL_UpdateJoysticks();
+}

api/keyboard.zig

@@ -0,0 +1,131 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const scancode_api = @import("scancode.zig");
+const video_api = @import("video.zig");
+const keycode_api = @import("keycode.zig");
+const rect_api = @import("rect.zig");
+const properties_api = @import("properties.zig");
+
+pub const Scancode = scancode_api.Scancode;
+pub const Window = video_api.Window;
+pub const Keymod = keycode_api.Keymod;
+pub const Rect = rect_api.Rect;
+pub const Keycode = keycode_api.Keycode;
+pub const PropertiesID = properties_api.PropertiesID;
+
+pub const KeyboardID = u32;
+
+pub inline fn hasKeyboard() bool {
+    return @bitCast(c.SDL_HasKeyboard());
+}
+
+pub inline fn getKeyboards(count: *c_int) ?*KeyboardID {
+    return @ptrCast(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 @ptrCast(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, @bitCast(key_event));
+}
+
+pub inline fn getScancodeFromKey(key: Keycode, modstate: ?*Keymod) Scancode {
+    return c.SDL_GetScancodeFromKey(key, @ptrCast(modstate));
+}
+
+pub inline fn setScancodeName(scancode: Scancode, name: [*c]const u8) bool {
+    return @bitCast(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 startTextInput(window: ?*Window) bool {
+    return @bitCast(c.SDL_StartTextInput(@ptrCast(window)));
+}
+
+pub const TextInputType = enum(c_int) {
+    textinputTypeText, //The input is text
+    textinputTypeTextName, //The input is a person's name
+    textinputTypeTextEmail, //The input is an e-mail address
+    textinputTypeTextUsername, //The input is a username
+    textinputTypeTextPasswordHidden, //The input is a secure password that is hidden
+    textinputTypeTextPasswordVisible, //The input is a secure password that is visible
+    textinputTypeNumber, //The input is a number
+    textinputTypeNumberPasswordHidden, //The input is a secure PIN that is hidden
+    textinputTypeNumberPasswordVisible, //The input is a secure PIN that is visible
+};
+
+pub const Capitalization = enum(c_int) {
+    capitalizeNone, //No auto-capitalization will be done
+    capitalizeSentences, //The first letter of sentences will be capitalized
+    capitalizeWords, //The first letter of words will be capitalized
+    capitalizeLetters, //All letters will be capitalized
+};
+
+pub inline fn startTextInputWithProperties(window: ?*Window, props: PropertiesID) bool {
+    return @bitCast(c.SDL_StartTextInputWithProperties(@ptrCast(window), props));
+}
+
+pub inline fn textInputActive(window: ?*Window) bool {
+    return @bitCast(c.SDL_TextInputActive(@ptrCast(window)));
+}
+
+pub inline fn stopTextInput(window: ?*Window) bool {
+    return @bitCast(c.SDL_StopTextInput(@ptrCast(window)));
+}
+
+pub inline fn clearComposition(window: ?*Window) bool {
+    return @bitCast(c.SDL_ClearComposition(@ptrCast(window)));
+}
+
+pub inline fn setTextInputArea(window: ?*Window, rect: ?*const Rect, cursor: c_int) bool {
+    return @bitCast(c.SDL_SetTextInputArea(@ptrCast(window), @ptrCast(rect), cursor));
+}
+
+pub inline fn getTextInputArea(window: ?*Window, rect: ?*Rect, cursor: *c_int) bool {
+    return @bitCast(c.SDL_GetTextInputArea(@ptrCast(window), @ptrCast(rect), @ptrCast(cursor)));
+}
+
+pub inline fn hasScreenKeyboardSupport() bool {
+    return @bitCast(c.SDL_HasScreenKeyboardSupport());
+}
+
+pub inline fn screenKeyboardShown(window: ?*Window) bool {
+    return @bitCast(c.SDL_ScreenKeyboardShown(@ptrCast(window)));
+}

api/keycode.zig

@@ -0,0 +1,5 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const Keycode = u32;
+
+pub const Keymod = u16;

api/loadso.zig

@@ -0,0 +1,19 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const stdinc_api = @import("stdinc.zig");
+
+pub const FunctionPointer = stdinc_api.FunctionPointer;
+
+pub const SharedObject = opaque {
+    pub inline fn loadFunction(sharedobject: *SharedObject, name: [*c]const u8) FunctionPointer {
+        return c.SDL_LoadFunction(@ptrCast(sharedobject), name);
+    }
+
+    pub inline fn unloadObject(sharedobject: *SharedObject) void {
+        return c.SDL_UnloadObject(@ptrCast(sharedobject));
+    }
+};
+
+pub inline fn loadObject(sofile: [*c]const u8) ?*SharedObject {
+    return @ptrCast(c.SDL_LoadObject(sofile));
+}

api/messagebox.zig

@@ -0,0 +1,69 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const video_api = @import("video.zig");
+
+pub const Window = video_api.Window;
+
+pub const MessageBoxFlags = packed struct(u32) {
+    messageboxError: bool = false, // error dialog
+    messageboxWarning: bool = false, // warning dialog
+    messageboxInformation: bool = false, // informational dialog
+    messageboxButtonsLeftToRight: bool = false, // buttons placed left to right
+    messageboxButtonsRightToLeft: bool = false, // buttons placed right to left
+    pad0: u26 = 0,
+    rsvd: bool = false,
+
+    pub const None = MessageBoxFlags{};
+};
+
+pub const MessageBoxButtonFlags = packed struct(u32) {
+    messageboxButtonReturnkeyDefault: bool = false, // Marks the default button when return is hit
+    messageboxButtonEscapekeyDefault: bool = false, // Marks the default button when escape is hit
+    pad0: u29 = 0,
+    rsvd: bool = false,
+
+    pub const None = MessageBoxButtonFlags{};
+};
+
+pub const MessageBoxButtonData = extern struct {
+    flags: MessageBoxButtonFlags,
+    buttonID: c_int, // User defined button id (value returned via SDL_ShowMessageBox)
+    text: [*c]const u8, // The UTF-8 button text
+};
+
+pub const MessageBoxColor = extern struct {
+    r: u8,
+    g: u8,
+    b: u8,
+};
+
+pub const MessageBoxColorType = enum(c_int) {
+    messageboxColorBackground,
+    messageboxColorText,
+    messageboxColorButtonBorder,
+    messageboxColorButtonBackground,
+    messageboxColorButtonSelected,
+    messageboxColorCount, //Size of the colors array of SDL_MessageBoxColorScheme.
+};
+
+pub const MessageBoxColorScheme = extern struct {
+    colors: [c.SDL_MESSAGEBOX_COLOR_COUNT]MessageBoxColor,
+};
+
+pub const MessageBoxData = extern struct {
+    flags: MessageBoxFlags,
+    window: ?*Window, // Parent window, can be NULL
+    title: [*c]const u8, // UTF-8 title
+    message: [*c]const u8, // UTF-8 message text
+    numbuttons: c_int,
+    buttons: ?*const MessageBoxButtonData,
+    colorScheme: ?*const MessageBoxColorScheme, // SDL_MessageBoxColorScheme, can be NULL to use system settings
+};
+
+pub inline fn showMessageBox(messageboxdata: ?*const MessageBoxData, buttonid: *c_int) bool {
+    return @bitCast(c.SDL_ShowMessageBox(@ptrCast(messageboxdata), @ptrCast(buttonid)));
+}
+
+pub inline fn showSimpleMessageBox(flags: MessageBoxFlags, title: [*c]const u8, message: [*c]const u8, window: ?*Window) bool {
+    return @bitCast(c.SDL_ShowSimpleMessageBox(@bitCast(flags), title, message, @ptrCast(window)));
+}

api/misc.zig

@@ -0,0 +1,5 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub inline fn openURL(url: [*c]const u8) bool {
+    return @bitCast(c.SDL_OpenURL(url));
+}

api/mouse.zig

@@ -0,0 +1,155 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const video_api = @import("video.zig");
+const surface_api = @import("surface.zig");
+
+pub const Window = video_api.Window;
+pub const Surface = surface_api.Surface;
+
+pub const MouseID = u32;
+
+pub const Cursor = opaque {
+    pub inline fn setCursor(cursor: *Cursor) bool {
+        return @bitCast(c.SDL_SetCursor(@ptrCast(cursor)));
+    }
+
+    pub inline fn destroyCursor(cursor: *Cursor) void {
+        return c.SDL_DestroyCursor(@ptrCast(cursor));
+    }
+};
+
+pub const SystemCursor = enum(c_int) {
+    systemCursorDefault, //Default cursor. Usually an arrow.
+    systemCursorText, //Text selection. Usually an I-beam.
+    systemCursorWait, //Wait. Usually an hourglass or watch or spinning ball.
+    systemCursorCrosshair, //Crosshair.
+    systemCursorProgress, //Program is busy but still interactive. Usually it's WAIT with an arrow.
+    systemCursorNwseResize, //Double arrow pointing northwest and southeast.
+    systemCursorNeswResize, //Double arrow pointing northeast and southwest.
+    systemCursorEwResize, //Double arrow pointing west and east.
+    systemCursorNsResize, //Double arrow pointing north and south.
+    systemCursorMove, //Four pointed arrow pointing north, south, east, and west.
+    systemCursorNotAllowed, //Not permitted. Usually a slashed circle or crossbones.
+    systemCursorPointer, //Pointer that indicates a link. Usually a pointing hand.
+    systemCursorNwResize, //Window resize top-left. This may be a single arrow or a double arrow like NWSE_RESIZE.
+    systemCursorNResize, //Window resize top. May be NS_RESIZE.
+    systemCursorNeResize, //Window resize top-right. May be NESW_RESIZE.
+    systemCursorEResize, //Window resize right. May be EW_RESIZE.
+    systemCursorSeResize, //Window resize bottom-right. May be NWSE_RESIZE.
+    systemCursorSResize, //Window resize bottom. May be NS_RESIZE.
+    systemCursorSwResize, //Window resize bottom-left. May be NESW_RESIZE.
+    systemCursorWResize, //Window resize left. May be EW_RESIZE.
+    systemCursorCount,
+};
+
+pub const MouseWheelDirection = enum(c_int) {
+    mousewheelNormal, //The scroll direction is normal
+    mousewheelFlipped, //The scroll direction is flipped / natural
+};
+
+pub const CursorFrameInfo = extern struct {
+    surface: ?*Surface, // The surface data for this frame
+    duration: u32, // The frame duration in milliseconds (a duration of 0 is infinite)
+};
+
+pub const MouseButtonFlags = packed struct(u32) {
+    buttonLeft: bool = false,
+    buttonMiddle: bool = false,
+    buttonX1: bool = false,
+    pad0: u28 = 0,
+    rsvd: bool = false,
+
+    pub const None = MouseButtonFlags{};
+    pub const ButtonRight: MouseButtonFlags = @bitCast(@as(u32, 3));
+    pub const ButtonX2: MouseButtonFlags = @bitCast(@as(u32, 5));
+};
+
+pub const MouseMotionTransformCallback = c.SDL_MouseMotionTransformCallback;
+
+pub inline fn hasMouse() bool {
+    return @bitCast(c.SDL_HasMouse());
+}
+
+pub inline fn getMice(count: *c_int) ?*MouseID {
+    return @ptrCast(c.SDL_GetMice(@ptrCast(count)));
+}
+
+pub inline fn getMouseNameForID(instance_id: MouseID) [*c]const u8 {
+    return c.SDL_GetMouseNameForID(instance_id);
+}
+
+pub inline fn getMouseFocus() ?*Window {
+    return @ptrCast(c.SDL_GetMouseFocus());
+}
+
+pub inline fn getMouseState(x: *f32, y: *f32) MouseButtonFlags {
+    return @bitCast(c.SDL_GetMouseState(@ptrCast(x), @ptrCast(y)));
+}
+
+pub inline fn getGlobalMouseState(x: *f32, y: *f32) MouseButtonFlags {
+    return @bitCast(c.SDL_GetGlobalMouseState(@ptrCast(x), @ptrCast(y)));
+}
+
+pub inline fn getRelativeMouseState(x: *f32, y: *f32) MouseButtonFlags {
+    return @bitCast(c.SDL_GetRelativeMouseState(@ptrCast(x), @ptrCast(y)));
+}
+
+pub inline fn warpMouseInWindow(window: ?*Window, x: f32, y: f32) void {
+    return c.SDL_WarpMouseInWindow(@ptrCast(window), x, y);
+}
+
+pub inline fn warpMouseGlobal(x: f32, y: f32) bool {
+    return @bitCast(c.SDL_WarpMouseGlobal(x, y));
+}
+
+pub inline fn setRelativeMouseTransform(callback: MouseMotionTransformCallback, userdata: ?*anyopaque) bool {
+    return @bitCast(c.SDL_SetRelativeMouseTransform(callback, userdata));
+}
+
+pub inline fn setWindowRelativeMouseMode(window: ?*Window, enabled: bool) bool {
+    return @bitCast(c.SDL_SetWindowRelativeMouseMode(@ptrCast(window), @bitCast(enabled)));
+}
+
+pub inline fn getWindowRelativeMouseMode(window: ?*Window) bool {
+    return @bitCast(c.SDL_GetWindowRelativeMouseMode(@ptrCast(window)));
+}
+
+pub inline fn captureMouse(enabled: bool) bool {
+    return @bitCast(c.SDL_CaptureMouse(@bitCast(enabled)));
+}
+
+pub inline fn createCursor(data: [*c]const u8, mask: [*c]const u8, w: c_int, h: c_int, hot_x: c_int, hot_y: c_int) ?*Cursor {
+    return @ptrCast(c.SDL_CreateCursor(data, mask, w, h, hot_x, hot_y));
+}
+
+pub inline fn createColorCursor(surface: ?*Surface, hot_x: c_int, hot_y: c_int) ?*Cursor {
+    return @ptrCast(c.SDL_CreateColorCursor(@ptrCast(surface), hot_x, hot_y));
+}
+
+pub inline fn createAnimatedCursor(frames: ?*CursorFrameInfo, frame_count: c_int, hot_x: c_int, hot_y: c_int) ?*Cursor {
+    return @ptrCast(c.SDL_CreateAnimatedCursor(@ptrCast(frames), frame_count, hot_x, hot_y));
+}
+
+pub inline fn createSystemCursor(id: SystemCursor) ?*Cursor {
+    return @ptrCast(c.SDL_CreateSystemCursor(id));
+}
+
+pub inline fn getCursor() ?*Cursor {
+    return @ptrCast(c.SDL_GetCursor());
+}
+
+pub inline fn getDefaultCursor() ?*Cursor {
+    return @ptrCast(c.SDL_GetDefaultCursor());
+}
+
+pub inline fn showCursor() bool {
+    return @bitCast(c.SDL_ShowCursor());
+}
+
+pub inline fn hideCursor() bool {
+    return @bitCast(c.SDL_HideCursor());
+}
+
+pub inline fn cursorVisible() bool {
+    return @bitCast(c.SDL_CursorVisible());
+}

api/opengl.zig

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

api/pixels.zig

@@ -0,0 +1,238 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const PixelType = enum(c_int) {
+    pixeltypeUnknown,
+    pixeltypeIndex1,
+    pixeltypeIndex4,
+    pixeltypeIndex8,
+    pixeltypePacked8,
+    pixeltypePacked16,
+    pixeltypePacked32,
+    pixeltypeArrayu8,
+    pixeltypeArrayu16,
+    pixeltypeArrayu32,
+    pixeltypeArrayf16,
+    pixeltypeArrayf32,
+    pixeltypeIndex2,
+};
+
+pub const BitmapOrder = enum(c_int) {
+    bitmaporderNone,
+    bitmaporder4321,
+    bitmaporder1234,
+};
+
+pub const PackedOrder = enum(c_int) {
+    packedorderNone,
+    packedorderXrgb,
+    packedorderRgbx,
+    packedorderArgb,
+    packedorderRgba,
+    packedorderXbgr,
+    packedorderBgrx,
+    packedorderAbgr,
+    packedorderBgra,
+};
+
+pub const ArrayOrder = enum(c_int) {
+    arrayorderNone,
+    arrayorderRgb,
+    arrayorderRgba,
+    arrayorderArgb,
+    arrayorderBgr,
+    arrayorderBgra,
+    arrayorderAbgr,
+};
+
+pub const PackedLayout = enum(c_int) {
+    packedlayoutNone,
+    packedlayout332,
+    packedlayout4444,
+    packedlayout1555,
+    packedlayout5551,
+    packedlayout565,
+    packedlayout8888,
+    packedlayout2101010,
+    packedlayout1010102,
+};
+
+pub const PixelFormat = enum(c_int) {
+    pixelformatYv12 = 0x32315659, //Planar mode: Y + V + U  (3 planes)
+    pixelformatIyuv = 0x56555949, //Planar mode: Y + U + V  (3 planes)
+    pixelformatYuy2 = 0x32595559, //Packed mode: Y0+U0+Y1+V0 (1 plane)
+    pixelformatUyvy = 0x59565955, //Packed mode: U0+Y0+V0+Y1 (1 plane)
+    pixelformatYvyu = 0x55595659, //Packed mode: Y0+V0+Y1+U0 (1 plane)
+    pixelformatNv12 = 0x3231564e, //Planar mode: Y + U/V interleaved  (2 planes)
+    pixelformatNv21 = 0x3132564e, //Planar mode: Y + V/U interleaved  (2 planes)
+    pixelformatP010 = 0x30313050, //Planar mode: Y + U/V interleaved  (2 planes)
+    pixelformatExternalOes = 0x2053454f, //Android video texture format
+    pixelformatMjpg = 0x47504a4d, //Motion JPEG
+};
+
+pub const ColorRange = enum(c_int) {
+    colorRangeLimited = 1, //Narrow range, e.g. 16-235 for 8-bit RGB and luma, and 16-240 for 8-bit chroma
+    colorRangeFull = 2,
+};
+
+pub const ColorPrimaries = enum(c_int) {
+    colorPrimariesBt709 = 1, //ITU-R BT.709-6
+    colorPrimariesBt470m = 4, //ITU-R BT.470-6 System M
+    colorPrimariesBt470bg = 5, //ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625
+    colorPrimariesBt601 = 6, //ITU-R BT.601-7 525, SMPTE 170M
+    colorPrimariesSmpte240 = 7, //SMPTE 240M, functionally the same as SDL_COLOR_PRIMARIES_BT601
+    colorPrimariesGenericFilm = 8, //Generic film (color filters using Illuminant C)
+    colorPrimariesBt2020 = 9, //ITU-R BT.2020-2 / ITU-R BT.2100-0
+    colorPrimariesXyz = 10, //SMPTE ST 428-1
+    colorPrimariesSmpte431 = 11, //SMPTE RP 431-2
+    colorPrimariesSmpte432 = 12, //SMPTE EG 432-1 / DCI P3
+    colorPrimariesEbu3213 = 22, //EBU Tech. 3213-E
+};
+
+pub const TransferCharacteristics = enum(c_int) {
+    transferCharacteristicsBt709 = 1, //Rec. ITU-R BT.709-6 / ITU-R BT1361
+    transferCharacteristicsGamma22 = 4, //ITU-R BT.470-6 System M / ITU-R BT1700 625 PAL & SECAM
+    transferCharacteristicsGamma28 = 5, //ITU-R BT.470-6 System B, G
+    transferCharacteristicsBt601 = 6, //SMPTE ST 170M / ITU-R BT.601-7 525 or 625
+    transferCharacteristicsSmpte240 = 7, //SMPTE ST 240M
+    transferCharacteristicsIec61966 = 11, //IEC 61966-2-4
+    transferCharacteristicsBt1361 = 12, //ITU-R BT1361 Extended Colour Gamut
+    transferCharacteristicsSrgb = 13, //IEC 61966-2-1 (sRGB or sYCC)
+    transferCharacteristicsBt202010bit = 14, //ITU-R BT2020 for 10-bit system
+    transferCharacteristicsBt202012bit = 15, //ITU-R BT2020 for 12-bit system
+    transferCharacteristicsPq = 16, //SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems
+    transferCharacteristicsSmpte428 = 17, //SMPTE ST 428-1
+    transferCharacteristicsHlg = 18, //ARIB STD-B67, known as "hybrid log-gamma" (HLG)
+};
+
+pub const MatrixCoefficients = enum(c_int) {
+    matrixCoefficientsBt709 = 1, //ITU-R BT.709-6
+    matrixCoefficientsFcc = 4, //US FCC Title 47
+    matrixCoefficientsBt470bg = 5, //ITU-R BT.470-6 System B, G / ITU-R BT.601-7 625, functionally the same as SDL_MATRIX_COEFFICIENTS_BT601
+    matrixCoefficientsBt601 = 6, //ITU-R BT.601-7 525
+    matrixCoefficientsSmpte240 = 7, //SMPTE 240M
+    matrixCoefficientsBt2020Ncl = 9, //ITU-R BT.2020-2 non-constant luminance
+    matrixCoefficientsBt2020Cl = 10, //ITU-R BT.2020-2 constant luminance
+    matrixCoefficientsSmpte2085 = 11, //SMPTE ST 2085
+    matrixCoefficientsIctcp = 14, //ITU-R BT.2100-0 ICTCP
+};
+
+pub const ChromaLocation = enum(c_int) {
+    chromaLocationNone = 0, //RGB, no chroma sampling
+    chromaLocationLeft = 1, //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 = 2, //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 = 3,
+};
+
+pub const Colorspace = enum(c_int) {
+    colorspaceSrgb = 0x120005a0, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709
+    colorRangeFull,
+    colorPrimariesBt709,
+    transferCharacteristicsSrgb,
+    matrixCoefficientsIdentity,
+    colorspaceSrgbLinear = 0x12000500, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709
+    transferCharacteristicsLinear,
+    colorspaceHdr10 = 0x12002600, //Equivalent to DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020
+    colorPrimariesBt2020,
+    transferCharacteristicsPq,
+    colorspaceJpeg = 0x220004c6, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601
+    transferCharacteristicsBt601,
+    matrixCoefficientsBt601,
+    colorspaceBt601Limited = 0x211018c6, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
+    colorRangeLimited,
+    colorPrimariesBt601,
+    colorspaceBt601Full = 0x221018c6, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601
+    colorspaceBt709Limited = 0x21100421, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
+    transferCharacteristicsBt709,
+    matrixCoefficientsBt709,
+    colorspaceBt709Full = 0x22100421, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709
+    colorspaceBt2020Limited = 0x21102609, //Equivalent to DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020
+    matrixCoefficientsBt2020Ncl,
+    colorspaceBt2020Full = 0x22102609, //Equivalent to DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020
+
+    pub const colorspaceRgbDefault = .colorspaceSrgb; //The default colorspace for RGB surfaces if no colorspace is specified
+    pub const colorspaceYuvDefault = .colorspaceBt601Limited; //The default colorspace for YUV surfaces if no colorspace is specified
+};
+
+pub const Color = extern struct {
+    r: u8,
+    g: u8,
+    b: u8,
+    a: u8,
+};
+
+pub const FColor = extern struct {
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+};
+
+pub const Palette = extern struct {
+    ncolors: c_int, // number of elements in `colors`.
+    colors: ?*Color, // an array of colors, `ncolors` long.
+    version: u32, // internal use only, do not touch.
+    refcount: c_int, // internal use only, do not touch.
+};
+
+pub const PixelFormatDetails = extern struct {
+    format: PixelFormat,
+    bits_per_pixel: u8,
+    bytes_per_pixel: u8,
+    padding: [2]u8,
+    Rmask: u32,
+    Gmask: u32,
+    Bmask: u32,
+    Amask: u32,
+    Rbits: u8,
+    Gbits: u8,
+    Bbits: u8,
+    Abits: u8,
+    Rshift: u8,
+    Gshift: u8,
+    Bshift: u8,
+    Ashift: u8,
+};
+
+pub inline fn getPixelFormatName(format: PixelFormat) [*c]const u8 {
+    return c.SDL_GetPixelFormatName(@bitCast(format));
+}
+
+pub inline fn getMasksForPixelFormat(format: PixelFormat, bpp: *c_int, Rmask: *u32, Gmask: *u32, Bmask: *u32, Amask: *u32) bool {
+    return @bitCast(c.SDL_GetMasksForPixelFormat(@bitCast(format), @ptrCast(bpp), @ptrCast(Rmask), @ptrCast(Gmask), @ptrCast(Bmask), @ptrCast(Amask)));
+}
+
+pub inline fn getPixelFormatForMasks(bpp: c_int, Rmask: u32, Gmask: u32, Bmask: u32, Amask: u32) PixelFormat {
+    return @bitCast(c.SDL_GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask));
+}
+
+pub inline fn getPixelFormatDetails(format: PixelFormat) ?*const PixelFormatDetails {
+    return @ptrCast(c.SDL_GetPixelFormatDetails(@bitCast(format)));
+}
+
+pub inline fn createPalette(ncolors: c_int) ?*Palette {
+    return @ptrCast(c.SDL_CreatePalette(ncolors));
+}
+
+pub inline fn setPaletteColors(palette: ?*Palette, colors: ?*const Color, firstcolor: c_int, ncolors: c_int) bool {
+    return @bitCast(c.SDL_SetPaletteColors(@ptrCast(palette), @ptrCast(colors), firstcolor, ncolors));
+}
+
+pub inline fn destroyPalette(palette: ?*Palette) void {
+    return c.SDL_DestroyPalette(@ptrCast(palette));
+}
+
+pub inline fn mapRGB(format: ?*const PixelFormatDetails, palette: ?*const Palette, r: u8, g: u8, b: u8) u32 {
+    return c.SDL_MapRGB(@ptrCast(format), @ptrCast(palette), r, g, b);
+}
+
+pub inline fn mapRGBA(format: ?*const PixelFormatDetails, palette: ?*const Palette, r: u8, g: u8, b: u8, a: u8) u32 {
+    return c.SDL_MapRGBA(@ptrCast(format), @ptrCast(palette), r, g, b, a);
+}
+
+pub inline fn getRGB(pixelvalue: u32, format: ?*const PixelFormatDetails, palette: ?*const Palette, r: [*c]u8, g: [*c]u8, b: [*c]u8) void {
+    return c.SDL_GetRGB(pixelvalue, @ptrCast(format), @ptrCast(palette), r, g, b);
+}
+
+pub inline fn getRGBA(pixelvalue: u32, format: ?*const PixelFormatDetails, palette: ?*const Palette, r: [*c]u8, g: [*c]u8, b: [*c]u8, a: [*c]u8) void {
+    return c.SDL_GetRGBA(pixelvalue, @ptrCast(format), @ptrCast(palette), r, g, b, a);
+}

api/power.zig

@@ -0,0 +1,14 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const PowerState = enum(c_int) {
+    powerstateError = -1, //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 inline fn getPowerInfo(seconds: *c_int, percent: *c_int) PowerState {
+    return c.SDL_GetPowerInfo(@ptrCast(seconds), @ptrCast(percent));
+}

api/process.zig

@@ -0,0 +1,52 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const properties_api = @import("properties.zig");
+const iostream_api = @import("iostream.zig");
+
+pub const PropertiesID = properties_api.PropertiesID;
+pub const IOStream = iostream_api.IOStream;
+
+pub const Process = opaque {
+    pub inline fn getProcessProperties(process: *Process) PropertiesID {
+        return c.SDL_GetProcessProperties(@ptrCast(process));
+    }
+
+    pub inline fn readProcess(process: *Process, datasize: *usize, exitcode: *c_int) ?*anyopaque {
+        return c.SDL_ReadProcess(@ptrCast(process), @ptrCast(datasize), @ptrCast(exitcode));
+    }
+
+    pub inline fn getProcessInput(process: *Process) ?*IOStream {
+        return @ptrCast(c.SDL_GetProcessInput(@ptrCast(process)));
+    }
+
+    pub inline fn getProcessOutput(process: *Process) ?*IOStream {
+        return @ptrCast(c.SDL_GetProcessOutput(@ptrCast(process)));
+    }
+
+    pub inline fn killProcess(process: *Process, force: bool) bool {
+        return @bitCast(c.SDL_KillProcess(@ptrCast(process), @bitCast(force)));
+    }
+
+    pub inline fn waitProcess(process: *Process, block: bool, exitcode: *c_int) bool {
+        return @bitCast(c.SDL_WaitProcess(@ptrCast(process), @bitCast(block), @ptrCast(exitcode)));
+    }
+
+    pub inline fn destroyProcess(process: *Process) void {
+        return c.SDL_DestroyProcess(@ptrCast(process));
+    }
+};
+
+pub inline fn createProcess(args: [*c]const [*c]const u8, pipe_stdio: bool) ?*Process {
+    return @ptrCast(c.SDL_CreateProcess(args, @bitCast(pipe_stdio)));
+}
+
+pub const ProcessIO = enum(c_int) {
+    processStdioInherited, //The I/O stream is inherited from the application.
+    processStdioNull, //The I/O stream is ignored.
+    processStdioApp, //The I/O stream is connected to a new SDL_IOStream that the application can read or write
+    processStdioRedirect, //The I/O stream is redirected to an existing SDL_IOStream.
+};
+
+pub inline fn createProcessWithProperties(props: PropertiesID) ?*Process {
+    return @ptrCast(c.SDL_CreateProcessWithProperties(props));
+}

api/properties.zig

@@ -0,0 +1,100 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const PropertiesID = u32;
+
+pub const PropertyType = enum(c_int) {
+    propertyTypeInvalid,
+    propertyTypePointer,
+    propertyTypeString,
+    propertyTypeNumber,
+    propertyTypeFloat,
+    propertyTypeBoolean,
+};
+
+pub inline fn getGlobalProperties() PropertiesID {
+    return c.SDL_GetGlobalProperties();
+}
+
+pub inline fn createProperties() PropertiesID {
+    return c.SDL_CreateProperties();
+}
+
+pub inline fn copyProperties(src: PropertiesID, dst: PropertiesID) bool {
+    return @bitCast(c.SDL_CopyProperties(src, dst));
+}
+
+pub inline fn lockProperties(props: PropertiesID) bool {
+    return @bitCast(c.SDL_LockProperties(props));
+}
+
+pub inline fn unlockProperties(props: PropertiesID) void {
+    return c.SDL_UnlockProperties(props);
+}
+
+pub const CleanupPropertyCallback = c.SDL_CleanupPropertyCallback;
+
+pub inline fn setPointerPropertyWithCleanup(props: PropertiesID, name: [*c]const u8, value: ?*anyopaque, cleanup: CleanupPropertyCallback, userdata: ?*anyopaque) bool {
+    return @bitCast(c.SDL_SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata));
+}
+
+pub inline fn setPointerProperty(props: PropertiesID, name: [*c]const u8, value: ?*anyopaque) bool {
+    return @bitCast(c.SDL_SetPointerProperty(props, name, value));
+}
+
+pub inline fn setStringProperty(props: PropertiesID, name: [*c]const u8, value: [*c]const u8) bool {
+    return @bitCast(c.SDL_SetStringProperty(props, name, value));
+}
+
+pub inline fn setNumberProperty(props: PropertiesID, name: [*c]const u8, value: i64) bool {
+    return @bitCast(c.SDL_SetNumberProperty(props, name, value));
+}
+
+pub inline fn setFloatProperty(props: PropertiesID, name: [*c]const u8, value: f32) bool {
+    return @bitCast(c.SDL_SetFloatProperty(props, name, value));
+}
+
+pub inline fn setBooleanProperty(props: PropertiesID, name: [*c]const u8, value: bool) bool {
+    return @bitCast(c.SDL_SetBooleanProperty(props, name, @bitCast(value)));
+}
+
+pub inline fn hasProperty(props: PropertiesID, name: [*c]const u8) bool {
+    return @bitCast(c.SDL_HasProperty(props, name));
+}
+
+pub inline fn getPropertyType(props: PropertiesID, name: [*c]const u8) PropertyType {
+    return @intFromEnum(c.SDL_GetPropertyType(props, name));
+}
+
+pub inline fn getPointerProperty(props: PropertiesID, name: [*c]const u8, default_value: ?*anyopaque) ?*anyopaque {
+    return c.SDL_GetPointerProperty(props, name, default_value);
+}
+
+pub inline fn getStringProperty(props: PropertiesID, name: [*c]const u8, default_value: [*c]const u8) [*c]const u8 {
+    return c.SDL_GetStringProperty(props, name, default_value);
+}
+
+pub inline fn getNumberProperty(props: PropertiesID, name: [*c]const u8, default_value: i64) i64 {
+    return c.SDL_GetNumberProperty(props, name, default_value);
+}
+
+pub inline fn getFloatProperty(props: PropertiesID, name: [*c]const u8, default_value: f32) f32 {
+    return c.SDL_GetFloatProperty(props, name, default_value);
+}
+
+pub inline fn getBooleanProperty(props: PropertiesID, name: [*c]const u8, default_value: bool) bool {
+    return @bitCast(c.SDL_GetBooleanProperty(props, name, @bitCast(default_value)));
+}
+
+pub inline fn clearProperty(props: PropertiesID, name: [*c]const u8) bool {
+    return @bitCast(c.SDL_ClearProperty(props, name));
+}
+
+pub const EnumeratePropertiesCallback = c.SDL_EnumeratePropertiesCallback;
+
+pub inline fn enumerateProperties(props: PropertiesID, callback: EnumeratePropertiesCallback, userdata: ?*anyopaque) bool {
+    return @bitCast(c.SDL_EnumerateProperties(props, callback, userdata));
+}
+
+pub inline fn destroyProperties(props: PropertiesID) void {
+    return c.SDL_DestroyProperties(props);
+}

api/rect.zig

@@ -0,0 +1,65 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const Point = extern struct {
+    x: c_int,
+    y: c_int,
+};
+
+pub const FPoint = extern struct {
+    x: f32,
+    y: f32,
+};
+
+pub const Rect = extern struct {
+    x: c_int,
+    y: c_int,
+    w: c_int,
+    h: c_int,
+};
+
+pub const FRect = extern struct {
+    x: f32,
+    y: f32,
+    w: f32,
+    h: f32,
+};
+
+pub inline fn hasRectIntersection(A: ?*const Rect, B: ?*const Rect) bool {
+    return @bitCast(c.SDL_HasRectIntersection(@ptrCast(A), @ptrCast(B)));
+}
+
+pub inline fn getRectIntersection(A: ?*const Rect, B: ?*const Rect, result: ?*Rect) bool {
+    return @bitCast(c.SDL_GetRectIntersection(@ptrCast(A), @ptrCast(B), @ptrCast(result)));
+}
+
+pub inline fn getRectUnion(A: ?*const Rect, B: ?*const Rect, result: ?*Rect) bool {
+    return @bitCast(c.SDL_GetRectUnion(@ptrCast(A), @ptrCast(B), @ptrCast(result)));
+}
+
+pub inline fn getRectEnclosingPoints(points: ?*const Point, count: c_int, clip: ?*const Rect, result: ?*Rect) bool {
+    return @bitCast(c.SDL_GetRectEnclosingPoints(@ptrCast(points), count, @ptrCast(clip), @ptrCast(result)));
+}
+
+pub inline fn getRectAndLineIntersection(rect: ?*const Rect, X1: *c_int, Y1: *c_int, X2: *c_int, Y2: *c_int) bool {
+    return @bitCast(c.SDL_GetRectAndLineIntersection(@ptrCast(rect), @ptrCast(X1), @ptrCast(Y1), @ptrCast(X2), @ptrCast(Y2)));
+}
+
+pub inline fn hasRectIntersectionFloat(A: ?*const FRect, B: ?*const FRect) bool {
+    return @bitCast(c.SDL_HasRectIntersectionFloat(@ptrCast(A), @ptrCast(B)));
+}
+
+pub inline fn getRectIntersectionFloat(A: ?*const FRect, B: ?*const FRect, result: ?*FRect) bool {
+    return @bitCast(c.SDL_GetRectIntersectionFloat(@ptrCast(A), @ptrCast(B), @ptrCast(result)));
+}
+
+pub inline fn getRectUnionFloat(A: ?*const FRect, B: ?*const FRect, result: ?*FRect) bool {
+    return @bitCast(c.SDL_GetRectUnionFloat(@ptrCast(A), @ptrCast(B), @ptrCast(result)));
+}
+
+pub inline fn getRectEnclosingPointsFloat(points: ?*const FPoint, count: c_int, clip: ?*const FRect, result: ?*FRect) bool {
+    return @bitCast(c.SDL_GetRectEnclosingPointsFloat(@ptrCast(points), count, @ptrCast(clip), @ptrCast(result)));
+}
+
+pub inline fn getRectAndLineIntersectionFloat(rect: ?*const FRect, X1: *f32, Y1: *f32, X2: *f32, Y2: *f32) bool {
+    return @bitCast(c.SDL_GetRectAndLineIntersectionFloat(@ptrCast(rect), @ptrCast(X1), @ptrCast(Y1), @ptrCast(X2), @ptrCast(Y2)));
+}

api/render.zig

@@ -0,0 +1,548 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const rect_api = @import("rect.zig");
+const pixels_api = @import("pixels.zig");
+const surface_api = @import("surface.zig");
+const properties_api = @import("properties.zig");
+const video_api = @import("video.zig");
+const gpu_api = @import("gpu.zig");
+const blendmode_api = @import("blendmode.zig");
+const events_api = @import("events.zig");
+const joystick_api = @import("joystick.zig");
+const mouse_api = @import("mouse.zig");
+const pen_api = @import("pen.zig");
+const camera_api = @import("camera.zig");
+const keyboard_api = @import("keyboard.zig");
+const power_api = @import("power.zig");
+const touch_api = @import("touch.zig");
+const sensor_api = @import("sensor.zig");
+const audio_api = @import("audio.zig");
+const scancode_api = @import("scancode.zig");
+const keycode_api = @import("keycode.zig");
+
+pub const FPoint = rect_api.FPoint;
+pub const FColor = pixels_api.FColor;
+pub const Surface = surface_api.Surface;
+pub const PropertiesID = properties_api.PropertiesID;
+pub const Window = video_api.Window;
+pub const FRect = rect_api.FRect;
+pub const GPUTextureSamplerBinding = gpu_api.GPUTextureSamplerBinding;
+pub const GPUSampler = gpu_api.GPUSampler;
+pub const GPUTexture = gpu_api.GPUTexture;
+pub const GPUShader = gpu_api.GPUShader;
+pub const WindowFlags = video_api.WindowFlags;
+pub const PixelFormat = pixels_api.PixelFormat;
+pub const ScaleMode = surface_api.ScaleMode;
+pub const GPUDevice = gpu_api.GPUDevice;
+pub const BlendMode = blendmode_api.BlendMode;
+pub const Event = events_api.Event;
+pub const JoyAxisEvent = events_api.JoyAxisEvent;
+pub const UserEvent = events_api.UserEvent;
+pub const PinchFingerEvent = events_api.PinchFingerEvent;
+pub const MouseMotionEvent = events_api.MouseMotionEvent;
+pub const CommonEvent = events_api.CommonEvent;
+pub const GamepadButtonEvent = events_api.GamepadButtonEvent;
+pub const JoyDeviceEvent = events_api.JoyDeviceEvent;
+pub const GamepadTouchpadEvent = events_api.GamepadTouchpadEvent;
+pub const GamepadSensorEvent = events_api.GamepadSensorEvent;
+pub const RenderEvent = events_api.RenderEvent;
+pub const ClipboardEvent = events_api.ClipboardEvent;
+pub const PenMotionEvent = events_api.PenMotionEvent;
+pub const GamepadAxisEvent = events_api.GamepadAxisEvent;
+pub const DisplayEvent = events_api.DisplayEvent;
+pub const DropEvent = events_api.DropEvent;
+pub const CameraDeviceEvent = events_api.CameraDeviceEvent;
+pub const KeyboardDeviceEvent = events_api.KeyboardDeviceEvent;
+pub const JoyBatteryEvent = events_api.JoyBatteryEvent;
+pub const TouchFingerEvent = events_api.TouchFingerEvent;
+pub const SensorEvent = events_api.SensorEvent;
+pub const TextEditingEvent = events_api.TextEditingEvent;
+pub const JoyHatEvent = events_api.JoyHatEvent;
+pub const QuitEvent = events_api.QuitEvent;
+pub const PenProximityEvent = events_api.PenProximityEvent;
+pub const WindowEvent = events_api.WindowEvent;
+pub const PenTouchEvent = events_api.PenTouchEvent;
+pub const PenButtonEvent = events_api.PenButtonEvent;
+pub const GamepadDeviceEvent = events_api.GamepadDeviceEvent;
+pub const JoyBallEvent = events_api.JoyBallEvent;
+pub const AudioDeviceEvent = events_api.AudioDeviceEvent;
+pub const MouseWheelEvent = events_api.MouseWheelEvent;
+pub const PenAxisEvent = events_api.PenAxisEvent;
+pub const MouseDeviceEvent = events_api.MouseDeviceEvent;
+pub const JoyButtonEvent = events_api.JoyButtonEvent;
+pub const MouseButtonEvent = events_api.MouseButtonEvent;
+pub const KeyboardEvent = events_api.KeyboardEvent;
+pub const TextEditingCandidatesEvent = events_api.TextEditingCandidatesEvent;
+pub const TextInputEvent = events_api.TextInputEvent;
+pub const EventType = events_api.EventType;
+pub const JoystickID = joystick_api.JoystickID;
+pub const WindowID = video_api.WindowID;
+pub const MouseID = mouse_api.MouseID;
+pub const MouseButtonFlags = mouse_api.MouseButtonFlags;
+pub const PenInputFlags = pen_api.PenInputFlags;
+pub const PenID = pen_api.PenID;
+pub const DisplayID = video_api.DisplayID;
+pub const CameraID = camera_api.CameraID;
+pub const KeyboardID = keyboard_api.KeyboardID;
+pub const PowerState = power_api.PowerState;
+pub const TouchID = touch_api.TouchID;
+pub const FingerID = touch_api.FingerID;
+pub const SensorID = sensor_api.SensorID;
+pub const AudioDeviceID = audio_api.AudioDeviceID;
+pub const MouseWheelDirection = mouse_api.MouseWheelDirection;
+pub const PenAxis = pen_api.PenAxis;
+pub const Scancode = scancode_api.Scancode;
+pub const Keymod = keycode_api.Keymod;
+pub const Keycode = keycode_api.Keycode;
+pub const FlipMode = surface_api.FlipMode;
+pub const GPUBuffer = gpu_api.GPUBuffer;
+pub const Rect = rect_api.Rect;
+pub const Palette = pixels_api.Palette;
+pub const Color = pixels_api.Color;
+
+pub const Vertex = extern struct {
+    position: FPoint, // Vertex position, in SDL_Renderer coordinates
+    color: FColor, // Vertex color
+    tex_coord: FPoint, // Normalized texture coordinates, if needed
+};
+
+pub const TextureAccess = enum(c_int) {
+    textureaccessStatic, //Changes rarely, not lockable
+    textureaccessStreaming, //Changes frequently, lockable
+    textureaccessTarget, //Texture can be used as a render target
+};
+
+pub const TextureAddressMode = enum(c_int) {
+    textureAddressAuto, //Wrapping is enabled if texture coordinates are outside [0, 1], this is the default
+    textureAddressClamp, //Texture coordinates are clamped to the [0, 1] range
+    textureAddressWrap, //The texture is repeated (tiled)
+};
+
+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 the clear color
+    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 getGPURendererDevice(renderer: *Renderer) ?*GPUDevice {
+        return @ptrCast(c.SDL_GetGPURendererDevice(@ptrCast(renderer)));
+    }
+
+    pub inline fn getRenderWindow(renderer: *Renderer) ?*Window {
+        return @ptrCast(c.SDL_GetRenderWindow(@ptrCast(renderer)));
+    }
+
+    pub inline fn getRendererName(renderer: *Renderer) [*c]const u8 {
+        return c.SDL_GetRendererName(@ptrCast(renderer));
+    }
+
+    pub inline fn getRendererProperties(renderer: *Renderer) PropertiesID {
+        return c.SDL_GetRendererProperties(@ptrCast(renderer));
+    }
+
+    pub inline fn getRenderOutputSize(renderer: *Renderer, w: *c_int, h: *c_int) bool {
+        return @bitCast(c.SDL_GetRenderOutputSize(@ptrCast(renderer), @ptrCast(w), @ptrCast(h)));
+    }
+
+    pub inline fn getCurrentRenderOutputSize(renderer: *Renderer, w: *c_int, h: *c_int) bool {
+        return @bitCast(c.SDL_GetCurrentRenderOutputSize(@ptrCast(renderer), @ptrCast(w), @ptrCast(h)));
+    }
+
+    pub inline fn createTexture(renderer: *Renderer, format: PixelFormat, access: TextureAccess, w: c_int, h: c_int) ?*Texture {
+        return @ptrCast(c.SDL_CreateTexture(@ptrCast(renderer), @bitCast(format), access, w, h));
+    }
+
+    pub inline fn createTextureFromSurface(renderer: *Renderer, surface: ?*Surface) ?*Texture {
+        return @ptrCast(c.SDL_CreateTextureFromSurface(@ptrCast(renderer), @ptrCast(surface)));
+    }
+
+    pub inline fn createTextureWithProperties(renderer: *Renderer, props: PropertiesID) ?*Texture {
+        return @ptrCast(c.SDL_CreateTextureWithProperties(@ptrCast(renderer), props));
+    }
+
+    pub inline fn setRenderTarget(renderer: *Renderer, texture: ?*Texture) bool {
+        return @bitCast(c.SDL_SetRenderTarget(@ptrCast(renderer), @ptrCast(texture)));
+    }
+
+    pub inline fn getRenderTarget(renderer: *Renderer) ?*Texture {
+        return @ptrCast(c.SDL_GetRenderTarget(@ptrCast(renderer)));
+    }
+
+    pub inline fn setRenderLogicalPresentation(renderer: *Renderer, w: c_int, h: c_int, mode: RendererLogicalPresentation) bool {
+        return @bitCast(c.SDL_SetRenderLogicalPresentation(@ptrCast(renderer), w, h, mode));
+    }
+
+    pub inline fn getRenderLogicalPresentation(renderer: *Renderer, w: *c_int, h: *c_int, mode: ?*RendererLogicalPresentation) bool {
+        return @bitCast(c.SDL_GetRenderLogicalPresentation(@ptrCast(renderer), @ptrCast(w), @ptrCast(h), @ptrCast(mode)));
+    }
+
+    pub inline fn getRenderLogicalPresentationRect(renderer: *Renderer, rect: ?*FRect) bool {
+        return @bitCast(c.SDL_GetRenderLogicalPresentationRect(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn renderCoordinatesFromWindow(renderer: *Renderer, window_x: f32, window_y: f32, x: *f32, y: *f32) bool {
+        return @bitCast(c.SDL_RenderCoordinatesFromWindow(@ptrCast(renderer), window_x, window_y, @ptrCast(x), @ptrCast(y)));
+    }
+
+    pub inline fn renderCoordinatesToWindow(renderer: *Renderer, x: f32, y: f32, window_x: *f32, window_y: *f32) bool {
+        return @bitCast(c.SDL_RenderCoordinatesToWindow(@ptrCast(renderer), x, y, @ptrCast(window_x), @ptrCast(window_y)));
+    }
+
+    pub inline fn convertEventToRenderCoordinates(renderer: *Renderer, event: ?*Event) bool {
+        return @bitCast(c.SDL_ConvertEventToRenderCoordinates(@ptrCast(renderer), @ptrCast(event)));
+    }
+
+    pub inline fn setRenderViewport(renderer: *Renderer, rect: ?*const Rect) bool {
+        return @bitCast(c.SDL_SetRenderViewport(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn getRenderViewport(renderer: *Renderer, rect: ?*Rect) bool {
+        return @bitCast(c.SDL_GetRenderViewport(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn renderViewportSet(renderer: *Renderer) bool {
+        return @bitCast(c.SDL_RenderViewportSet(@ptrCast(renderer)));
+    }
+
+    pub inline fn getRenderSafeArea(renderer: *Renderer, rect: ?*Rect) bool {
+        return @bitCast(c.SDL_GetRenderSafeArea(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn setRenderClipRect(renderer: *Renderer, rect: ?*const Rect) bool {
+        return @bitCast(c.SDL_SetRenderClipRect(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn getRenderClipRect(renderer: *Renderer, rect: ?*Rect) bool {
+        return @bitCast(c.SDL_GetRenderClipRect(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn renderClipEnabled(renderer: *Renderer) bool {
+        return @bitCast(c.SDL_RenderClipEnabled(@ptrCast(renderer)));
+    }
+
+    pub inline fn setRenderScale(renderer: *Renderer, scaleX: f32, scaleY: f32) bool {
+        return @bitCast(c.SDL_SetRenderScale(@ptrCast(renderer), scaleX, scaleY));
+    }
+
+    pub inline fn getRenderScale(renderer: *Renderer, scaleX: *f32, scaleY: *f32) bool {
+        return @bitCast(c.SDL_GetRenderScale(@ptrCast(renderer), @ptrCast(scaleX), @ptrCast(scaleY)));
+    }
+
+    pub inline fn setRenderDrawColor(renderer: *Renderer, r: u8, g: u8, b: u8, a: u8) bool {
+        return @bitCast(c.SDL_SetRenderDrawColor(@ptrCast(renderer), r, g, b, a));
+    }
+
+    pub inline fn setRenderDrawColorFloat(renderer: *Renderer, r: f32, g: f32, b: f32, a: f32) bool {
+        return @bitCast(c.SDL_SetRenderDrawColorFloat(@ptrCast(renderer), r, g, b, a));
+    }
+
+    pub inline fn getRenderDrawColor(renderer: *Renderer, r: [*c]u8, g: [*c]u8, b: [*c]u8, a: [*c]u8) bool {
+        return @bitCast(c.SDL_GetRenderDrawColor(@ptrCast(renderer), r, g, b, a));
+    }
+
+    pub inline fn getRenderDrawColorFloat(renderer: *Renderer, r: *f32, g: *f32, b: *f32, a: *f32) bool {
+        return @bitCast(c.SDL_GetRenderDrawColorFloat(@ptrCast(renderer), @ptrCast(r), @ptrCast(g), @ptrCast(b), @ptrCast(a)));
+    }
+
+    pub inline fn setRenderColorScale(renderer: *Renderer, scale: f32) bool {
+        return @bitCast(c.SDL_SetRenderColorScale(@ptrCast(renderer), scale));
+    }
+
+    pub inline fn getRenderColorScale(renderer: *Renderer, scale: *f32) bool {
+        return @bitCast(c.SDL_GetRenderColorScale(@ptrCast(renderer), @ptrCast(scale)));
+    }
+
+    pub inline fn setRenderDrawBlendMode(renderer: *Renderer, blendMode: BlendMode) bool {
+        return @bitCast(c.SDL_SetRenderDrawBlendMode(@ptrCast(renderer), @intFromEnum(blendMode)));
+    }
+
+    pub inline fn getRenderDrawBlendMode(renderer: *Renderer, blendMode: ?*BlendMode) bool {
+        return @bitCast(c.SDL_GetRenderDrawBlendMode(@ptrCast(renderer), @ptrCast(blendMode)));
+    }
+
+    pub inline fn renderClear(renderer: *Renderer) bool {
+        return @bitCast(c.SDL_RenderClear(@ptrCast(renderer)));
+    }
+
+    pub inline fn renderPoint(renderer: *Renderer, x: f32, y: f32) bool {
+        return @bitCast(c.SDL_RenderPoint(@ptrCast(renderer), x, y));
+    }
+
+    pub inline fn renderPoints(renderer: *Renderer, points: ?*const FPoint, count: c_int) bool {
+        return @bitCast(c.SDL_RenderPoints(@ptrCast(renderer), @ptrCast(points), count));
+    }
+
+    pub inline fn renderLine(renderer: *Renderer, x1: f32, y1: f32, x2: f32, y2: f32) bool {
+        return @bitCast(c.SDL_RenderLine(@ptrCast(renderer), x1, y1, x2, y2));
+    }
+
+    pub inline fn renderLines(renderer: *Renderer, points: ?*const FPoint, count: c_int) bool {
+        return @bitCast(c.SDL_RenderLines(@ptrCast(renderer), @ptrCast(points), count));
+    }
+
+    pub inline fn renderRect(renderer: *Renderer, rect: ?*const FRect) bool {
+        return @bitCast(c.SDL_RenderRect(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn renderRects(renderer: *Renderer, rects: ?*const FRect, count: c_int) bool {
+        return @bitCast(c.SDL_RenderRects(@ptrCast(renderer), @ptrCast(rects), count));
+    }
+
+    pub inline fn renderFillRect(renderer: *Renderer, rect: ?*const FRect) bool {
+        return @bitCast(c.SDL_RenderFillRect(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn renderFillRects(renderer: *Renderer, rects: ?*const FRect, count: c_int) bool {
+        return @bitCast(c.SDL_RenderFillRects(@ptrCast(renderer), @ptrCast(rects), count));
+    }
+
+    pub inline fn renderTexture(renderer: *Renderer, texture: ?*Texture, srcrect: ?*const FRect, dstrect: ?*const FRect) bool {
+        return @bitCast(c.SDL_RenderTexture(@ptrCast(renderer), @ptrCast(texture), @ptrCast(srcrect), @ptrCast(dstrect)));
+    }
+
+    pub inline fn renderTextureRotated(renderer: *Renderer, texture: ?*Texture, srcrect: ?*const FRect, dstrect: ?*const FRect, angle: f64, center: ?*const FPoint, flip: FlipMode) bool {
+        return @bitCast(c.SDL_RenderTextureRotated(@ptrCast(renderer), @ptrCast(texture), @ptrCast(srcrect), @ptrCast(dstrect), angle, @ptrCast(center), @intFromEnum(flip)));
+    }
+
+    pub inline fn renderTextureAffine(renderer: *Renderer, texture: ?*Texture, srcrect: ?*const FRect, origin: ?*const FPoint, right: ?*const FPoint, down: ?*const FPoint) bool {
+        return @bitCast(c.SDL_RenderTextureAffine(@ptrCast(renderer), @ptrCast(texture), @ptrCast(srcrect), @ptrCast(origin), @ptrCast(right), @ptrCast(down)));
+    }
+
+    pub inline fn renderTextureTiled(renderer: *Renderer, texture: ?*Texture, srcrect: ?*const FRect, scale: f32, dstrect: ?*const FRect) bool {
+        return @bitCast(c.SDL_RenderTextureTiled(@ptrCast(renderer), @ptrCast(texture), @ptrCast(srcrect), scale, @ptrCast(dstrect)));
+    }
+
+    pub inline fn renderTexture9Grid(renderer: *Renderer, texture: ?*Texture, srcrect: ?*const FRect, left_width: f32, right_width: f32, top_height: f32, bottom_height: f32, scale: f32, dstrect: ?*const FRect) bool {
+        return @bitCast(c.SDL_RenderTexture9Grid(@ptrCast(renderer), @ptrCast(texture), @ptrCast(srcrect), left_width, right_width, top_height, bottom_height, scale, @ptrCast(dstrect)));
+    }
+
+    pub inline fn renderTexture9GridTiled(renderer: *Renderer, texture: ?*Texture, srcrect: ?*const FRect, left_width: f32, right_width: f32, top_height: f32, bottom_height: f32, scale: f32, dstrect: ?*const FRect, tileScale: f32) bool {
+        return @bitCast(c.SDL_RenderTexture9GridTiled(@ptrCast(renderer), @ptrCast(texture), @ptrCast(srcrect), left_width, right_width, top_height, bottom_height, scale, @ptrCast(dstrect), tileScale));
+    }
+
+    pub inline fn renderGeometry(renderer: *Renderer, texture: ?*Texture, vertices: ?*const Vertex, num_vertices: c_int, indices: [*c]const c_int, num_indices: c_int) bool {
+        return @bitCast(c.SDL_RenderGeometry(@ptrCast(renderer), @ptrCast(texture), @ptrCast(vertices), num_vertices, indices, num_indices));
+    }
+
+    pub inline fn renderGeometryRaw(renderer: *Renderer, texture: ?*Texture, xy: *const f32, xy_stride: c_int, color: ?*const FColor, color_stride: c_int, uv: *const f32, uv_stride: c_int, num_vertices: c_int, indices: ?*const anyopaque, num_indices: c_int, size_indices: c_int) bool {
+        return @bitCast(c.SDL_RenderGeometryRaw(@ptrCast(renderer), @ptrCast(texture), @ptrCast(xy), xy_stride, @ptrCast(color), color_stride, @ptrCast(uv), uv_stride, num_vertices, indices, num_indices, size_indices));
+    }
+
+    pub inline fn setRenderTextureAddressMode(renderer: *Renderer, u_mode: TextureAddressMode, v_mode: TextureAddressMode) bool {
+        return @bitCast(c.SDL_SetRenderTextureAddressMode(@ptrCast(renderer), @intFromEnum(u_mode), @intFromEnum(v_mode)));
+    }
+
+    pub inline fn getRenderTextureAddressMode(renderer: *Renderer, u_mode: ?*TextureAddressMode, v_mode: ?*TextureAddressMode) bool {
+        return @bitCast(c.SDL_GetRenderTextureAddressMode(@ptrCast(renderer), @ptrCast(u_mode), @ptrCast(v_mode)));
+    }
+
+    pub inline fn renderReadPixels(renderer: *Renderer, rect: ?*const Rect) ?*Surface {
+        return @ptrCast(c.SDL_RenderReadPixels(@ptrCast(renderer), @ptrCast(rect)));
+    }
+
+    pub inline fn renderPresent(renderer: *Renderer) bool {
+        return @bitCast(c.SDL_RenderPresent(@ptrCast(renderer)));
+    }
+
+    pub inline fn destroyRenderer(renderer: *Renderer) void {
+        return c.SDL_DestroyRenderer(@ptrCast(renderer));
+    }
+
+    pub inline fn flushRenderer(renderer: *Renderer) bool {
+        return @bitCast(c.SDL_FlushRenderer(@ptrCast(renderer)));
+    }
+
+    pub inline fn getRenderMetalLayer(renderer: *Renderer) ?*anyopaque {
+        return c.SDL_GetRenderMetalLayer(@ptrCast(renderer));
+    }
+
+    pub inline fn getRenderMetalCommandEncoder(renderer: *Renderer) ?*anyopaque {
+        return c.SDL_GetRenderMetalCommandEncoder(@ptrCast(renderer));
+    }
+
+    pub inline fn addVulkanRenderSemaphores(renderer: *Renderer, wait_stage_mask: u32, wait_semaphore: i64, signal_semaphore: i64) bool {
+        return @bitCast(c.SDL_AddVulkanRenderSemaphores(@ptrCast(renderer), wait_stage_mask, wait_semaphore, signal_semaphore));
+    }
+
+    pub inline fn setRenderVSync(renderer: *Renderer, vsync: c_int) bool {
+        return @bitCast(c.SDL_SetRenderVSync(@ptrCast(renderer), vsync));
+    }
+
+    pub inline fn getRenderVSync(renderer: *Renderer, vsync: *c_int) bool {
+        return @bitCast(c.SDL_GetRenderVSync(@ptrCast(renderer), @ptrCast(vsync)));
+    }
+
+    pub inline fn renderDebugText(renderer: *Renderer, x: f32, y: f32, str: [*c]const u8) bool {
+        return @bitCast(c.SDL_RenderDebugText(@ptrCast(renderer), x, y, str));
+    }
+
+    pub inline fn setDefaultTextureScaleMode(renderer: *Renderer, scale_mode: ScaleMode) bool {
+        return @bitCast(c.SDL_SetDefaultTextureScaleMode(@ptrCast(renderer), @intFromEnum(scale_mode)));
+    }
+
+    pub inline fn getDefaultTextureScaleMode(renderer: *Renderer, scale_mode: ?*ScaleMode) bool {
+        return @bitCast(c.SDL_GetDefaultTextureScaleMode(@ptrCast(renderer), @ptrCast(scale_mode)));
+    }
+
+    pub inline fn createGPURenderState(renderer: *Renderer, createinfo: ?*GPURenderStateCreateInfo) ?*GPURenderState {
+        return @ptrCast(c.SDL_CreateGPURenderState(@ptrCast(renderer), @ptrCast(createinfo)));
+    }
+
+    pub inline fn setGPURenderState(renderer: *Renderer, state: ?*GPURenderState) bool {
+        return @bitCast(c.SDL_SetGPURenderState(@ptrCast(renderer), @ptrCast(state)));
+    }
+};
+
+pub const Texture = opaque {
+    pub inline fn getTextureProperties(texture: *Texture) PropertiesID {
+        return c.SDL_GetTextureProperties(@ptrCast(texture));
+    }
+
+    pub inline fn getRendererFromTexture(texture: *Texture) ?*Renderer {
+        return @ptrCast(c.SDL_GetRendererFromTexture(@ptrCast(texture)));
+    }
+
+    pub inline fn getTextureSize(texture: *Texture, w: *f32, h: *f32) bool {
+        return @bitCast(c.SDL_GetTextureSize(@ptrCast(texture), @ptrCast(w), @ptrCast(h)));
+    }
+
+    pub inline fn setTexturePalette(texture: *Texture, palette: ?*Palette) bool {
+        return @bitCast(c.SDL_SetTexturePalette(@ptrCast(texture), @ptrCast(palette)));
+    }
+
+    pub inline fn getTexturePalette(texture: *Texture) ?*Palette {
+        return @ptrCast(c.SDL_GetTexturePalette(@ptrCast(texture)));
+    }
+
+    pub inline fn setTextureColorMod(texture: *Texture, r: u8, g: u8, b: u8) bool {
+        return @bitCast(c.SDL_SetTextureColorMod(@ptrCast(texture), r, g, b));
+    }
+
+    pub inline fn setTextureColorModFloat(texture: *Texture, r: f32, g: f32, b: f32) bool {
+        return @bitCast(c.SDL_SetTextureColorModFloat(@ptrCast(texture), r, g, b));
+    }
+
+    pub inline fn getTextureColorMod(texture: *Texture, r: [*c]u8, g: [*c]u8, b: [*c]u8) bool {
+        return @bitCast(c.SDL_GetTextureColorMod(@ptrCast(texture), r, g, b));
+    }
+
+    pub inline fn getTextureColorModFloat(texture: *Texture, r: *f32, g: *f32, b: *f32) bool {
+        return @bitCast(c.SDL_GetTextureColorModFloat(@ptrCast(texture), @ptrCast(r), @ptrCast(g), @ptrCast(b)));
+    }
+
+    pub inline fn setTextureAlphaMod(texture: *Texture, alpha: u8) bool {
+        return @bitCast(c.SDL_SetTextureAlphaMod(@ptrCast(texture), alpha));
+    }
+
+    pub inline fn setTextureAlphaModFloat(texture: *Texture, alpha: f32) bool {
+        return @bitCast(c.SDL_SetTextureAlphaModFloat(@ptrCast(texture), alpha));
+    }
+
+    pub inline fn getTextureAlphaMod(texture: *Texture, alpha: [*c]u8) bool {
+        return @bitCast(c.SDL_GetTextureAlphaMod(@ptrCast(texture), alpha));
+    }
+
+    pub inline fn getTextureAlphaModFloat(texture: *Texture, alpha: *f32) bool {
+        return @bitCast(c.SDL_GetTextureAlphaModFloat(@ptrCast(texture), @ptrCast(alpha)));
+    }
+
+    pub inline fn setTextureBlendMode(texture: *Texture, blendMode: BlendMode) bool {
+        return @bitCast(c.SDL_SetTextureBlendMode(@ptrCast(texture), @intFromEnum(blendMode)));
+    }
+
+    pub inline fn getTextureBlendMode(texture: *Texture, blendMode: ?*BlendMode) bool {
+        return @bitCast(c.SDL_GetTextureBlendMode(@ptrCast(texture), @ptrCast(blendMode)));
+    }
+
+    pub inline fn setTextureScaleMode(texture: *Texture, scaleMode: ScaleMode) bool {
+        return @bitCast(c.SDL_SetTextureScaleMode(@ptrCast(texture), @intFromEnum(scaleMode)));
+    }
+
+    pub inline fn getTextureScaleMode(texture: *Texture, scaleMode: ?*ScaleMode) bool {
+        return @bitCast(c.SDL_GetTextureScaleMode(@ptrCast(texture), @ptrCast(scaleMode)));
+    }
+
+    pub inline fn updateTexture(texture: *Texture, rect: ?*const Rect, pixels: ?*const anyopaque, pitch: c_int) bool {
+        return @bitCast(c.SDL_UpdateTexture(@ptrCast(texture), @ptrCast(rect), pixels, pitch));
+    }
+
+    pub inline fn updateYUVTexture(texture: *Texture, rect: ?*const Rect, Yplane: [*c]const u8, Ypitch: c_int, Uplane: [*c]const u8, Upitch: c_int, Vplane: [*c]const u8, Vpitch: c_int) bool {
+        return @bitCast(c.SDL_UpdateYUVTexture(@ptrCast(texture), @ptrCast(rect), Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch));
+    }
+
+    pub inline fn updateNVTexture(texture: *Texture, rect: ?*const Rect, Yplane: [*c]const u8, Ypitch: c_int, UVplane: [*c]const u8, UVpitch: c_int) bool {
+        return @bitCast(c.SDL_UpdateNVTexture(@ptrCast(texture), @ptrCast(rect), Yplane, Ypitch, UVplane, UVpitch));
+    }
+
+    pub inline fn lockTexture(texture: *Texture, rect: ?*const Rect, pixels: [*c]?*anyopaque, pitch: *c_int) bool {
+        return @bitCast(c.SDL_LockTexture(@ptrCast(texture), @ptrCast(rect), pixels, @ptrCast(pitch)));
+    }
+
+    pub inline fn lockTextureToSurface(texture: *Texture, rect: ?*const Rect, surface: [*c]?*Surface) bool {
+        return @bitCast(c.SDL_LockTextureToSurface(@ptrCast(texture), @ptrCast(rect), surface));
+    }
+
+    pub inline fn unlockTexture(texture: *Texture) void {
+        return c.SDL_UnlockTexture(@ptrCast(texture));
+    }
+
+    pub inline fn destroyTexture(texture: *Texture) void {
+        return c.SDL_DestroyTexture(@ptrCast(texture));
+    }
+};
+
+pub inline fn getNumRenderDrivers() c_int {
+    return c.SDL_GetNumRenderDrivers();
+}
+
+pub inline fn getRenderDriver(index: c_int) [*c]const u8 {
+    return c.SDL_GetRenderDriver(index);
+}
+
+pub inline fn createWindowAndRenderer(title: [*c]const u8, width: c_int, height: c_int, window_flags: WindowFlags, window: [*c]?*Window, renderer: [*c]?*Renderer) bool {
+    return @bitCast(c.SDL_CreateWindowAndRenderer(title, width, height, @bitCast(window_flags), window, renderer));
+}
+
+pub inline fn createRenderer(window: ?*Window, name: [*c]const u8) ?*Renderer {
+    return @ptrCast(c.SDL_CreateRenderer(@ptrCast(window), name));
+}
+
+pub inline fn createRendererWithProperties(props: PropertiesID) ?*Renderer {
+    return @ptrCast(c.SDL_CreateRendererWithProperties(props));
+}
+
+pub inline fn createGPURenderer(device: ?*GPUDevice, window: ?*Window) ?*Renderer {
+    return @ptrCast(c.SDL_CreateGPURenderer(@ptrCast(device), @ptrCast(window)));
+}
+
+pub inline fn createSoftwareRenderer(surface: ?*Surface) ?*Renderer {
+    return @ptrCast(c.SDL_CreateSoftwareRenderer(@ptrCast(surface)));
+}
+
+pub inline fn getRenderer(window: ?*Window) ?*Renderer {
+    return @ptrCast(c.SDL_GetRenderer(@ptrCast(window)));
+}
+
+pub const GPURenderStateCreateInfo = extern struct {
+    fragment_shader: ?*GPUShader, // The fragment shader to use when this render state is active
+    num_sampler_bindings: i32, // The number of additional fragment samplers to bind when this render state is active
+    sampler_bindings: ?*const GPUTextureSamplerBinding, // Additional fragment samplers to bind when this render state is active
+    num_storage_textures: i32, // The number of storage textures to bind when this render state is active
+    storage_textures: [*c]?*const GPUTexture, // Storage textures to bind when this render state is active
+    num_storage_buffers: i32, // The number of storage buffers to bind when this render state is active
+    storage_buffers: [*c]?*const GPUBuffer, // Storage buffers to bind when this render state is active
+    props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed.
+};
+
+pub const GPURenderState = opaque {
+    pub inline fn setGPURenderStateFragmentUniforms(gpurenderstate: *GPURenderState, slot_index: u32, data: ?*const anyopaque, length: u32) bool {
+        return @bitCast(c.SDL_SetGPURenderStateFragmentUniforms(@ptrCast(gpurenderstate), slot_index, data, length));
+    }
+
+    pub inline fn destroyGPURenderState(gpurenderstate: *GPURenderState) void {
+        return c.SDL_DestroyGPURenderState(@ptrCast(gpurenderstate));
+    }
+};

api/scancode.zig

@@ -0,0 +1,74 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const Scancode = enum(c_int) {
+    scancodeBackslash = 49,
+    scancodeNonushash = 50,
+    scancodeGrave = 53,
+    scancodeInsert = 73,
+    scancodeNumlockclear = 83,
+    scancodeNonusbackslash = 100,
+    scancodeApplication = 101, //windows contextual menu, compose
+    scancodePower = 102,
+    scancodeHelp = 117, //AL Integrated Help Center
+    scancodeMenu = 118, //Menu (show menu)
+    scancodeStop = 120, //AC Stop
+    scancodeAgain = 121, //AC Redo/Repeat
+    scancodeUndo = 122, //AC Undo
+    scancodeCut = 123, //AC Cut
+    scancodeCopy = 124, //AC Copy
+    scancodePaste = 125, //AC Paste
+    scancodeFind = 126, //AC Find
+    scancodeInternational1 = 135,
+    scancodeInternational3 = 137, //Yen
+    scancodeLang1 = 144, //Hangul/English toggle
+    scancodeLang2 = 145, //Hanja conversion
+    scancodeLang3 = 146, //Katakana
+    scancodeLang4 = 147, //Hiragana
+    scancodeLang5 = 148, //Zenkaku/Hankaku
+    scancodeLang6 = 149, //reserved
+    scancodeLang7 = 150, //reserved
+    scancodeLang8 = 151, //reserved
+    scancodeLang9 = 152, //reserved
+    scancodeAlterase = 153, //Erase-Eaze
+    scancodeCancel = 155, //AC Cancel
+    scancodeLalt = 226, //alt, option
+    scancodeLgui = 227, //windows, command (apple), meta
+    scancodeRalt = 230, //alt gr, option
+    scancodeRgui = 231, //windows, command (apple), meta
+    scancodeMode = 257,
+    scancodeSleep = 258, //Sleep
+    scancodeWake = 259, //Wake
+    scancodeChannelIncrement = 260, //Channel Increment
+    scancodeChannelDecrement = 261, //Channel Decrement
+    scancodeMediaPlay = 262, //Play
+    scancodeMediaPause = 263, //Pause
+    scancodeMediaRecord = 264, //Record
+    scancodeMediaFastForward = 265, //Fast Forward
+    scancodeMediaRewind = 266, //Rewind
+    scancodeMediaNextTrack = 267, //Next Track
+    scancodeMediaPreviousTrack = 268, //Previous Track
+    scancodeMediaStop = 269, //Stop
+    scancodeMediaEject = 270, //Eject
+    scancodeMediaPlayPause = 271, //Play / Pause
+    scancodeMediaSelect = 272,
+    scancodeAcNew = 273, //AC New
+    scancodeAcOpen = 274, //AC Open
+    scancodeAcClose = 275, //AC Close
+    scancodeAcExit = 276, //AC Exit
+    scancodeAcSave = 277, //AC Save
+    scancodeAcPrint = 278, //AC Print
+    scancodeAcProperties = 279, //AC Properties
+    scancodeAcSearch = 280, //AC Search
+    scancodeAcHome = 281, //AC Home
+    scancodeAcBack = 282, //AC Back
+    scancodeAcForward = 283, //AC Forward
+    scancodeAcStop = 284, //AC Stop
+    scancodeAcRefresh = 285, //AC Refresh
+    scancodeAcBookmarks = 286, //AC Bookmarks
+    scancodeSoftleft = 287,
+    scancodeSoftright = 288,
+    scancodeCall = 289, //Used for accepting phone calls.
+    scancodeEndcall = 290, //Used for rejecting phone calls.
+    scancodeReserved = 400, //400-500 reserved for dynamic keycodes
+    scancodeCount = 512,
+};

api/sensor.zig

@@ -0,0 +1,77 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const properties_api = @import("properties.zig");
+
+pub const PropertiesID = properties_api.PropertiesID;
+
+pub const Sensor = opaque {
+    pub inline fn getSensorProperties(sensor: *Sensor) PropertiesID {
+        return c.SDL_GetSensorProperties(@ptrCast(sensor));
+    }
+
+    pub inline fn getSensorName(sensor: *Sensor) [*c]const u8 {
+        return c.SDL_GetSensorName(@ptrCast(sensor));
+    }
+
+    pub inline fn getSensorType(sensor: *Sensor) SensorType {
+        return @intFromEnum(c.SDL_GetSensorType(@ptrCast(sensor)));
+    }
+
+    pub inline fn getSensorNonPortableType(sensor: *Sensor) c_int {
+        return c.SDL_GetSensorNonPortableType(@ptrCast(sensor));
+    }
+
+    pub inline fn getSensorID(sensor: *Sensor) SensorID {
+        return c.SDL_GetSensorID(@ptrCast(sensor));
+    }
+
+    pub inline fn getSensorData(sensor: *Sensor, data: *f32, num_values: c_int) bool {
+        return @bitCast(c.SDL_GetSensorData(@ptrCast(sensor), @ptrCast(data), num_values));
+    }
+
+    pub inline fn closeSensor(sensor: *Sensor) void {
+        return c.SDL_CloseSensor(@ptrCast(sensor));
+    }
+};
+
+pub const SensorID = u32;
+
+pub const SensorType = enum(c_int) {
+    sensorInvalid = -1, //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
+    sensorCount,
+};
+
+pub inline fn getSensors(count: *c_int) ?*SensorID {
+    return @ptrCast(c.SDL_GetSensors(@ptrCast(count)));
+}
+
+pub inline fn getSensorNameForID(instance_id: SensorID) [*c]const u8 {
+    return c.SDL_GetSensorNameForID(instance_id);
+}
+
+pub inline fn getSensorTypeForID(instance_id: SensorID) SensorType {
+    return @intFromEnum(c.SDL_GetSensorTypeForID(instance_id));
+}
+
+pub inline fn getSensorNonPortableTypeForID(instance_id: SensorID) c_int {
+    return c.SDL_GetSensorNonPortableTypeForID(instance_id);
+}
+
+pub inline fn openSensor(instance_id: SensorID) ?*Sensor {
+    return @ptrCast(c.SDL_OpenSensor(instance_id));
+}
+
+pub inline fn getSensorFromID(instance_id: SensorID) ?*Sensor {
+    return @ptrCast(c.SDL_GetSensorFromID(instance_id));
+}
+
+pub inline fn updateSensors() void {
+    return c.SDL_UpdateSensors();
+}

api/storage.zig

@@ -0,0 +1,97 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const filesystem_api = @import("filesystem.zig");
+const stdinc_api = @import("stdinc.zig");
+const properties_api = @import("properties.zig");
+
+pub const PathInfo = filesystem_api.PathInfo;
+pub const PathType = filesystem_api.PathType;
+pub const Time = stdinc_api.Time;
+pub const GlobFlags = filesystem_api.GlobFlags;
+pub const EnumerateDirectoryCallback = filesystem_api.EnumerateDirectoryCallback;
+pub const PropertiesID = properties_api.PropertiesID;
+
+pub const StorageInterface = extern struct {
+    version: u32,
+    close: ?*const anyopaque,
+    ready: ?*const anyopaque,
+    enumerate: ?*const anyopaque,
+    info: ?*const anyopaque,
+    read_file: ?*const anyopaque,
+    write_file: ?*const anyopaque,
+    mkdir: ?*const anyopaque,
+    remove: ?*const anyopaque,
+    rename: ?*const anyopaque,
+    copy: ?*const anyopaque,
+    space_remaining: ?*const anyopaque,
+};
+
+pub const Storage = opaque {
+    pub inline fn closeStorage(storage: *Storage) bool {
+        return @bitCast(c.SDL_CloseStorage(@ptrCast(storage)));
+    }
+
+    pub inline fn storageReady(storage: *Storage) bool {
+        return @bitCast(c.SDL_StorageReady(@ptrCast(storage)));
+    }
+
+    pub inline fn getStorageFileSize(storage: *Storage, path: [*c]const u8, length: *u64) bool {
+        return @bitCast(c.SDL_GetStorageFileSize(@ptrCast(storage), path, @ptrCast(length)));
+    }
+
+    pub inline fn readStorageFile(storage: *Storage, path: [*c]const u8, destination: ?*anyopaque, length: u64) bool {
+        return @bitCast(c.SDL_ReadStorageFile(@ptrCast(storage), path, destination, length));
+    }
+
+    pub inline fn writeStorageFile(storage: *Storage, path: [*c]const u8, source: ?*const anyopaque, length: u64) bool {
+        return @bitCast(c.SDL_WriteStorageFile(@ptrCast(storage), path, source, length));
+    }
+
+    pub inline fn createStorageDirectory(storage: *Storage, path: [*c]const u8) bool {
+        return @bitCast(c.SDL_CreateStorageDirectory(@ptrCast(storage), path));
+    }
+
+    pub inline fn enumerateStorageDirectory(storage: *Storage, path: [*c]const u8, callback: EnumerateDirectoryCallback, userdata: ?*anyopaque) bool {
+        return @bitCast(c.SDL_EnumerateStorageDirectory(@ptrCast(storage), path, callback, userdata));
+    }
+
+    pub inline fn removeStoragePath(storage: *Storage, path: [*c]const u8) bool {
+        return @bitCast(c.SDL_RemoveStoragePath(@ptrCast(storage), path));
+    }
+
+    pub inline fn renameStoragePath(storage: *Storage, oldpath: [*c]const u8, newpath: [*c]const u8) bool {
+        return @bitCast(c.SDL_RenameStoragePath(@ptrCast(storage), oldpath, newpath));
+    }
+
+    pub inline fn copyStorageFile(storage: *Storage, oldpath: [*c]const u8, newpath: [*c]const u8) bool {
+        return @bitCast(c.SDL_CopyStorageFile(@ptrCast(storage), oldpath, newpath));
+    }
+
+    pub inline fn getStoragePathInfo(storage: *Storage, path: [*c]const u8, info: ?*PathInfo) bool {
+        return @bitCast(c.SDL_GetStoragePathInfo(@ptrCast(storage), path, @ptrCast(info)));
+    }
+
+    pub inline fn getStorageSpaceRemaining(storage: *Storage) u64 {
+        return c.SDL_GetStorageSpaceRemaining(@ptrCast(storage));
+    }
+
+    pub inline fn globStorageDirectory(storage: *Storage, path: [*c]const u8, pattern: [*c]const u8, flags: GlobFlags, count: *c_int) [*c][*c]u8 {
+        return c.SDL_GlobStorageDirectory(@ptrCast(storage), path, pattern, @bitCast(flags), @ptrCast(count));
+    }
+};
+
+pub inline fn openTitleStorage(override: [*c]const u8, props: PropertiesID) ?*Storage {
+    return @ptrCast(c.SDL_OpenTitleStorage(override, props));
+}
+
+pub inline fn openUserStorage(org: [*c]const u8, app: [*c]const u8, props: PropertiesID) ?*Storage {
+    return @ptrCast(c.SDL_OpenUserStorage(org, app, props));
+}
+
+pub inline fn openFileStorage(path: [*c]const u8) ?*Storage {
+    return @ptrCast(c.SDL_OpenFileStorage(path));
+}
+
+pub inline fn openStorage(iface: ?*const StorageInterface, userdata: ?*anyopaque) ?*Storage {
+    return @ptrCast(c.SDL_OpenStorage(@ptrCast(iface), userdata));
+}

api/surface.zig

@@ -0,0 +1,304 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const pixels_api = @import("pixels.zig");
+const blendmode_api = @import("blendmode.zig");
+const iostream_api = @import("iostream.zig");
+const rect_api = @import("rect.zig");
+const properties_api = @import("properties.zig");
+
+pub const PixelFormat = pixels_api.PixelFormat;
+pub const BlendMode = blendmode_api.BlendMode;
+pub const IOStream = iostream_api.IOStream;
+pub const Rect = rect_api.Rect;
+pub const Palette = pixels_api.Palette;
+pub const Color = pixels_api.Color;
+pub const Colorspace = pixels_api.Colorspace;
+pub const PropertiesID = properties_api.PropertiesID;
+
+pub const SurfaceFlags = packed struct(u32) {
+    surfacePreallocated: bool = false, // Surface uses preallocated pixel memory
+    surfaceLockNeeded: bool = false, // Surface needs to be locked to access pixels
+    surfaceLocked: bool = false, // Surface is currently locked
+    surfaceSimdAligned: bool = false, // Surface uses pixel memory allocated with SDL_aligned_alloc()
+    pad0: u27 = 0,
+    rsvd: bool = false,
+
+    pub const None = SurfaceFlags{};
+};
+
+pub const ScaleMode = enum(c_int) {
+    scalemodeNearest, //nearest pixel sampling
+    scalemodeLinear, //linear filtering
+    scalemodePixelart,
+};
+
+pub const FlipMode = packed struct(u32) {
+    flipHorizontal: bool = false, // flip horizontally
+    flipVertical: bool = false, // flip vertically
+    pad0: u29 = 0,
+    rsvd: bool = false,
+
+    pub const None = FlipMode{};
+};
+
+pub const Surface = opaque {
+    pub inline fn destroySurface(surface: *Surface) void {
+        return c.SDL_DestroySurface(@ptrCast(surface));
+    }
+
+    pub inline fn getSurfaceProperties(surface: *Surface) PropertiesID {
+        return c.SDL_GetSurfaceProperties(@ptrCast(surface));
+    }
+
+    pub inline fn setSurfaceColorspace(surface: *Surface, colorspace: Colorspace) bool {
+        return @bitCast(c.SDL_SetSurfaceColorspace(@ptrCast(surface), colorspace));
+    }
+
+    pub inline fn getSurfaceColorspace(surface: *Surface) Colorspace {
+        return c.SDL_GetSurfaceColorspace(@ptrCast(surface));
+    }
+
+    pub inline fn createSurfacePalette(surface: *Surface) ?*Palette {
+        return @ptrCast(c.SDL_CreateSurfacePalette(@ptrCast(surface)));
+    }
+
+    pub inline fn setSurfacePalette(surface: *Surface, palette: ?*Palette) bool {
+        return @bitCast(c.SDL_SetSurfacePalette(@ptrCast(surface), @ptrCast(palette)));
+    }
+
+    pub inline fn getSurfacePalette(surface: *Surface) ?*Palette {
+        return @ptrCast(c.SDL_GetSurfacePalette(@ptrCast(surface)));
+    }
+
+    pub inline fn addSurfaceAlternateImage(surface: *Surface, image: ?*Surface) bool {
+        return @bitCast(c.SDL_AddSurfaceAlternateImage(@ptrCast(surface), @ptrCast(image)));
+    }
+
+    pub inline fn surfaceHasAlternateImages(surface: *Surface) bool {
+        return @bitCast(c.SDL_SurfaceHasAlternateImages(@ptrCast(surface)));
+    }
+
+    pub inline fn getSurfaceImages(surface: *Surface, count: *c_int) [*c]?*Surface {
+        return c.SDL_GetSurfaceImages(@ptrCast(surface), @ptrCast(count));
+    }
+
+    pub inline fn removeSurfaceAlternateImages(surface: *Surface) void {
+        return c.SDL_RemoveSurfaceAlternateImages(@ptrCast(surface));
+    }
+
+    pub inline fn lockSurface(surface: *Surface) bool {
+        return @bitCast(c.SDL_LockSurface(@ptrCast(surface)));
+    }
+
+    pub inline fn unlockSurface(surface: *Surface) void {
+        return c.SDL_UnlockSurface(@ptrCast(surface));
+    }
+
+    pub inline fn saveBMP_IO(surface: *Surface, dst: ?*IOStream, closeio: bool) bool {
+        return @bitCast(c.SDL_SaveBMP_IO(@ptrCast(surface), @ptrCast(dst), @bitCast(closeio)));
+    }
+
+    pub inline fn saveBMP(surface: *Surface, file: [*c]const u8) bool {
+        return @bitCast(c.SDL_SaveBMP(@ptrCast(surface), file));
+    }
+
+    pub inline fn savePNG_IO(surface: *Surface, dst: ?*IOStream, closeio: bool) bool {
+        return @bitCast(c.SDL_SavePNG_IO(@ptrCast(surface), @ptrCast(dst), @bitCast(closeio)));
+    }
+
+    pub inline fn savePNG(surface: *Surface, file: [*c]const u8) bool {
+        return @bitCast(c.SDL_SavePNG(@ptrCast(surface), file));
+    }
+
+    pub inline fn setSurfaceRLE(surface: *Surface, enabled: bool) bool {
+        return @bitCast(c.SDL_SetSurfaceRLE(@ptrCast(surface), @bitCast(enabled)));
+    }
+
+    pub inline fn surfaceHasRLE(surface: *Surface) bool {
+        return @bitCast(c.SDL_SurfaceHasRLE(@ptrCast(surface)));
+    }
+
+    pub inline fn setSurfaceColorKey(surface: *Surface, enabled: bool, key: u32) bool {
+        return @bitCast(c.SDL_SetSurfaceColorKey(@ptrCast(surface), @bitCast(enabled), key));
+    }
+
+    pub inline fn surfaceHasColorKey(surface: *Surface) bool {
+        return @bitCast(c.SDL_SurfaceHasColorKey(@ptrCast(surface)));
+    }
+
+    pub inline fn getSurfaceColorKey(surface: *Surface, key: *u32) bool {
+        return @bitCast(c.SDL_GetSurfaceColorKey(@ptrCast(surface), @ptrCast(key)));
+    }
+
+    pub inline fn setSurfaceColorMod(surface: *Surface, r: u8, g: u8, b: u8) bool {
+        return @bitCast(c.SDL_SetSurfaceColorMod(@ptrCast(surface), r, g, b));
+    }
+
+    pub inline fn getSurfaceColorMod(surface: *Surface, r: [*c]u8, g: [*c]u8, b: [*c]u8) bool {
+        return @bitCast(c.SDL_GetSurfaceColorMod(@ptrCast(surface), r, g, b));
+    }
+
+    pub inline fn setSurfaceAlphaMod(surface: *Surface, alpha: u8) bool {
+        return @bitCast(c.SDL_SetSurfaceAlphaMod(@ptrCast(surface), alpha));
+    }
+
+    pub inline fn getSurfaceAlphaMod(surface: *Surface, alpha: [*c]u8) bool {
+        return @bitCast(c.SDL_GetSurfaceAlphaMod(@ptrCast(surface), alpha));
+    }
+
+    pub inline fn setSurfaceBlendMode(surface: *Surface, blendMode: BlendMode) bool {
+        return @bitCast(c.SDL_SetSurfaceBlendMode(@ptrCast(surface), @intFromEnum(blendMode)));
+    }
+
+    pub inline fn getSurfaceBlendMode(surface: *Surface, blendMode: ?*BlendMode) bool {
+        return @bitCast(c.SDL_GetSurfaceBlendMode(@ptrCast(surface), @ptrCast(blendMode)));
+    }
+
+    pub inline fn setSurfaceClipRect(surface: *Surface, rect: ?*const Rect) bool {
+        return @bitCast(c.SDL_SetSurfaceClipRect(@ptrCast(surface), @ptrCast(rect)));
+    }
+
+    pub inline fn getSurfaceClipRect(surface: *Surface, rect: ?*Rect) bool {
+        return @bitCast(c.SDL_GetSurfaceClipRect(@ptrCast(surface), @ptrCast(rect)));
+    }
+
+    pub inline fn flipSurface(surface: *Surface, flip: FlipMode) bool {
+        return @bitCast(c.SDL_FlipSurface(@ptrCast(surface), @intFromEnum(flip)));
+    }
+
+    pub inline fn rotateSurface(surface: *Surface, angle: f32) ?*Surface {
+        return @ptrCast(c.SDL_RotateSurface(@ptrCast(surface), angle));
+    }
+
+    pub inline fn duplicateSurface(surface: *Surface) ?*Surface {
+        return @ptrCast(c.SDL_DuplicateSurface(@ptrCast(surface)));
+    }
+
+    pub inline fn scaleSurface(surface: *Surface, width: c_int, height: c_int, scaleMode: ScaleMode) ?*Surface {
+        return @ptrCast(c.SDL_ScaleSurface(@ptrCast(surface), width, height, @intFromEnum(scaleMode)));
+    }
+
+    pub inline fn convertSurface(surface: *Surface, format: PixelFormat) ?*Surface {
+        return @ptrCast(c.SDL_ConvertSurface(@ptrCast(surface), @bitCast(format)));
+    }
+
+    pub inline fn convertSurfaceAndColorspace(surface: *Surface, format: PixelFormat, palette: ?*Palette, colorspace: Colorspace, props: PropertiesID) ?*Surface {
+        return @ptrCast(c.SDL_ConvertSurfaceAndColorspace(@ptrCast(surface), @bitCast(format), @ptrCast(palette), colorspace, props));
+    }
+
+    pub inline fn premultiplySurfaceAlpha(surface: *Surface, linear: bool) bool {
+        return @bitCast(c.SDL_PremultiplySurfaceAlpha(@ptrCast(surface), @bitCast(linear)));
+    }
+
+    pub inline fn clearSurface(surface: *Surface, r: f32, g: f32, b: f32, a: f32) bool {
+        return @bitCast(c.SDL_ClearSurface(@ptrCast(surface), r, g, b, a));
+    }
+
+    pub inline fn fillSurfaceRect(surface: *Surface, rect: ?*const Rect, color: u32) bool {
+        return @bitCast(c.SDL_FillSurfaceRect(@ptrCast(surface), @ptrCast(rect), color));
+    }
+
+    pub inline fn fillSurfaceRects(surface: *Surface, rects: ?*const Rect, count: c_int, color: u32) bool {
+        return @bitCast(c.SDL_FillSurfaceRects(@ptrCast(surface), @ptrCast(rects), count, color));
+    }
+
+    pub inline fn blitSurface(surface: *Surface, srcrect: ?*const Rect, dst: ?*Surface, dstrect: ?*const Rect) bool {
+        return @bitCast(c.SDL_BlitSurface(@ptrCast(surface), @ptrCast(srcrect), @ptrCast(dst), @ptrCast(dstrect)));
+    }
+
+    pub inline fn blitSurfaceUnchecked(surface: *Surface, srcrect: ?*const Rect, dst: ?*Surface, dstrect: ?*const Rect) bool {
+        return @bitCast(c.SDL_BlitSurfaceUnchecked(@ptrCast(surface), @ptrCast(srcrect), @ptrCast(dst), @ptrCast(dstrect)));
+    }
+
+    pub inline fn blitSurfaceScaled(surface: *Surface, srcrect: ?*const Rect, dst: ?*Surface, dstrect: ?*const Rect, scaleMode: ScaleMode) bool {
+        return @bitCast(c.SDL_BlitSurfaceScaled(@ptrCast(surface), @ptrCast(srcrect), @ptrCast(dst), @ptrCast(dstrect), @intFromEnum(scaleMode)));
+    }
+
+    pub inline fn blitSurfaceUncheckedScaled(surface: *Surface, srcrect: ?*const Rect, dst: ?*Surface, dstrect: ?*const Rect, scaleMode: ScaleMode) bool {
+        return @bitCast(c.SDL_BlitSurfaceUncheckedScaled(@ptrCast(surface), @ptrCast(srcrect), @ptrCast(dst), @ptrCast(dstrect), @intFromEnum(scaleMode)));
+    }
+
+    pub inline fn stretchSurface(surface: *Surface, srcrect: ?*const Rect, dst: ?*Surface, dstrect: ?*const Rect, scaleMode: ScaleMode) bool {
+        return @bitCast(c.SDL_StretchSurface(@ptrCast(surface), @ptrCast(srcrect), @ptrCast(dst), @ptrCast(dstrect), @intFromEnum(scaleMode)));
+    }
+
+    pub inline fn blitSurfaceTiled(surface: *Surface, srcrect: ?*const Rect, dst: ?*Surface, dstrect: ?*const Rect) bool {
+        return @bitCast(c.SDL_BlitSurfaceTiled(@ptrCast(surface), @ptrCast(srcrect), @ptrCast(dst), @ptrCast(dstrect)));
+    }
+
+    pub inline fn blitSurfaceTiledWithScale(surface: *Surface, srcrect: ?*const Rect, scale: f32, scaleMode: ScaleMode, dst: ?*Surface, dstrect: ?*const Rect) bool {
+        return @bitCast(c.SDL_BlitSurfaceTiledWithScale(@ptrCast(surface), @ptrCast(srcrect), scale, @intFromEnum(scaleMode), @ptrCast(dst), @ptrCast(dstrect)));
+    }
+
+    pub inline fn blitSurface9Grid(surface: *Surface, srcrect: ?*const Rect, left_width: c_int, right_width: c_int, top_height: c_int, bottom_height: c_int, scale: f32, scaleMode: ScaleMode, dst: ?*Surface, dstrect: ?*const Rect) bool {
+        return @bitCast(c.SDL_BlitSurface9Grid(@ptrCast(surface), @ptrCast(srcrect), left_width, right_width, top_height, bottom_height, scale, @intFromEnum(scaleMode), @ptrCast(dst), @ptrCast(dstrect)));
+    }
+
+    pub inline fn mapSurfaceRGB(surface: *Surface, r: u8, g: u8, b: u8) u32 {
+        return c.SDL_MapSurfaceRGB(@ptrCast(surface), r, g, b);
+    }
+
+    pub inline fn mapSurfaceRGBA(surface: *Surface, r: u8, g: u8, b: u8, a: u8) u32 {
+        return c.SDL_MapSurfaceRGBA(@ptrCast(surface), r, g, b, a);
+    }
+
+    pub inline fn readSurfacePixel(surface: *Surface, x: c_int, y: c_int, r: [*c]u8, g: [*c]u8, b: [*c]u8, a: [*c]u8) bool {
+        return @bitCast(c.SDL_ReadSurfacePixel(@ptrCast(surface), x, y, r, g, b, a));
+    }
+
+    pub inline fn readSurfacePixelFloat(surface: *Surface, x: c_int, y: c_int, r: *f32, g: *f32, b: *f32, a: *f32) bool {
+        return @bitCast(c.SDL_ReadSurfacePixelFloat(@ptrCast(surface), x, y, @ptrCast(r), @ptrCast(g), @ptrCast(b), @ptrCast(a)));
+    }
+
+    pub inline fn writeSurfacePixel(surface: *Surface, x: c_int, y: c_int, r: u8, g: u8, b: u8, a: u8) bool {
+        return @bitCast(c.SDL_WriteSurfacePixel(@ptrCast(surface), x, y, r, g, b, a));
+    }
+
+    pub inline fn writeSurfacePixelFloat(surface: *Surface, x: c_int, y: c_int, r: f32, g: f32, b: f32, a: f32) bool {
+        return @bitCast(c.SDL_WriteSurfacePixelFloat(@ptrCast(surface), x, y, r, g, b, a));
+    }
+};
+
+pub inline fn createSurface(width: c_int, height: c_int, format: PixelFormat) ?*Surface {
+    return @ptrCast(c.SDL_CreateSurface(width, height, @bitCast(format)));
+}
+
+pub inline fn createSurfaceFrom(width: c_int, height: c_int, format: PixelFormat, pixels: ?*anyopaque, pitch: c_int) ?*Surface {
+    return @ptrCast(c.SDL_CreateSurfaceFrom(width, height, @bitCast(format), pixels, pitch));
+}
+
+pub inline fn loadSurface_IO(src: ?*IOStream, closeio: bool) ?*Surface {
+    return @ptrCast(c.SDL_LoadSurface_IO(@ptrCast(src), @bitCast(closeio)));
+}
+
+pub inline fn loadSurface(file: [*c]const u8) ?*Surface {
+    return @ptrCast(c.SDL_LoadSurface(file));
+}
+
+pub inline fn loadBMP_IO(src: ?*IOStream, closeio: bool) ?*Surface {
+    return @ptrCast(c.SDL_LoadBMP_IO(@ptrCast(src), @bitCast(closeio)));
+}
+
+pub inline fn loadBMP(file: [*c]const u8) ?*Surface {
+    return @ptrCast(c.SDL_LoadBMP(file));
+}
+
+pub inline fn loadPNG_IO(src: ?*IOStream, closeio: bool) ?*Surface {
+    return @ptrCast(c.SDL_LoadPNG_IO(@ptrCast(src), @bitCast(closeio)));
+}
+
+pub inline fn loadPNG(file: [*c]const u8) ?*Surface {
+    return @ptrCast(c.SDL_LoadPNG(file));
+}
+
+pub inline fn convertPixels(width: c_int, height: c_int, src_format: PixelFormat, src: ?*const anyopaque, src_pitch: c_int, dst_format: PixelFormat, dst: ?*anyopaque, dst_pitch: c_int) bool {
+    return @bitCast(c.SDL_ConvertPixels(width, height, @bitCast(src_format), src, src_pitch, @bitCast(dst_format), dst, dst_pitch));
+}
+
+pub inline fn convertPixelsAndColorspace(width: c_int, height: c_int, src_format: PixelFormat, src_colorspace: Colorspace, src_properties: PropertiesID, src: ?*const anyopaque, src_pitch: c_int, dst_format: PixelFormat, dst_colorspace: Colorspace, dst_properties: PropertiesID, dst: ?*anyopaque, dst_pitch: c_int) bool {
+    return @bitCast(c.SDL_ConvertPixelsAndColorspace(width, height, @bitCast(src_format), src_colorspace, src_properties, src, src_pitch, @bitCast(dst_format), dst_colorspace, dst_properties, dst, dst_pitch));
+}
+
+pub inline fn premultiplyAlpha(width: c_int, height: c_int, src_format: PixelFormat, src: ?*const anyopaque, src_pitch: c_int, dst_format: PixelFormat, dst: ?*anyopaque, dst_pitch: c_int, linear: bool) bool {
+    return @bitCast(c.SDL_PremultiplyAlpha(width, height, @bitCast(src_format), src, src_pitch, @bitCast(dst_format), dst, dst_pitch, @bitCast(linear)));
+}

api/system.zig

@@ -0,0 +1,159 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const video_api = @import("video.zig");
+
+pub const DisplayID = video_api.DisplayID;
+pub const Window = video_api.Window;
+
+pub const MSG = opaque {};
+
+pub const WindowsMessageHook = c.SDL_WindowsMessageHook;
+
+pub inline fn setWindowsMessageHook(callback: WindowsMessageHook, userdata: ?*anyopaque) void {
+    return c.SDL_SetWindowsMessageHook(callback, userdata);
+}
+
+pub inline fn getDirect3D9AdapterIndex(displayID: DisplayID) c_int {
+    return c.SDL_GetDirect3D9AdapterIndex(displayID);
+}
+
+pub inline fn getDXGIOutputInfo(displayID: DisplayID, adapterIndex: *c_int, outputIndex: *c_int) bool {
+    return @bitCast(c.SDL_GetDXGIOutputInfo(displayID, @ptrCast(adapterIndex), @ptrCast(outputIndex)));
+}
+
+pub const X11EventHook = c.SDL_X11EventHook;
+
+pub inline fn setX11EventHook(callback: X11EventHook, userdata: ?*anyopaque) void {
+    return c.SDL_SetX11EventHook(callback, userdata);
+}
+
+pub inline fn setLinuxThreadPriority(threadID: i64, priority: c_int) bool {
+    return @bitCast(c.SDL_SetLinuxThreadPriority(threadID, priority));
+}
+
+pub inline fn setLinuxThreadPriorityAndPolicy(threadID: i64, sdlPriority: c_int, schedPolicy: c_int) bool {
+    return @bitCast(c.SDL_SetLinuxThreadPriorityAndPolicy(threadID, sdlPriority, schedPolicy));
+}
+
+pub const iOSAnimationCallback = c.SDL_iOSAnimationCallback;
+
+pub inline fn setiOSAnimationCallback(window: ?*Window, interval: c_int, callback: iOSAnimationCallback, callbackParam: ?*anyopaque) bool {
+    return @bitCast(c.SDL_SetiOSAnimationCallback(@ptrCast(window), interval, callback, callbackParam));
+}
+
+pub inline fn setiOSEventPump(enabled: bool) void {
+    return c.SDL_SetiOSEventPump(@bitCast(enabled));
+}
+
+pub inline fn getAndroidJNIEnv() ?*anyopaque {
+    return c.SDL_GetAndroidJNIEnv();
+}
+
+pub inline fn getAndroidActivity() ?*anyopaque {
+    return c.SDL_GetAndroidActivity();
+}
+
+pub inline fn getAndroidSDKVersion() c_int {
+    return c.SDL_GetAndroidSDKVersion();
+}
+
+pub inline fn isChromebook() bool {
+    return @bitCast(c.SDL_IsChromebook());
+}
+
+pub inline fn isDeXMode() bool {
+    return @bitCast(c.SDL_IsDeXMode());
+}
+
+pub inline fn sendAndroidBackButton() void {
+    return c.SDL_SendAndroidBackButton();
+}
+
+pub inline fn getAndroidInternalStoragePath() [*c]const u8 {
+    return c.SDL_GetAndroidInternalStoragePath();
+}
+
+pub inline fn getAndroidExternalStorageState() u32 {
+    return c.SDL_GetAndroidExternalStorageState();
+}
+
+pub inline fn getAndroidExternalStoragePath() [*c]const u8 {
+    return c.SDL_GetAndroidExternalStoragePath();
+}
+
+pub inline fn getAndroidCachePath() [*c]const u8 {
+    return c.SDL_GetAndroidCachePath();
+}
+
+pub const RequestAndroidPermissionCallback = c.SDL_RequestAndroidPermissionCallback;
+
+pub inline fn requestAndroidPermission(permission: [*c]const u8, cb: RequestAndroidPermissionCallback, userdata: ?*anyopaque) bool {
+    return @bitCast(c.SDL_RequestAndroidPermission(permission, cb, userdata));
+}
+
+pub inline fn showAndroidToast(message: [*c]const u8, duration: c_int, gravity: c_int, xoffset: c_int, yoffset: c_int) bool {
+    return @bitCast(c.SDL_ShowAndroidToast(message, duration, gravity, xoffset, yoffset));
+}
+
+pub inline fn sendAndroidMessage(command: u32, param: c_int) bool {
+    return @bitCast(c.SDL_SendAndroidMessage(command, param));
+}
+
+pub inline fn isTablet() bool {
+    return @bitCast(c.SDL_IsTablet());
+}
+
+pub inline fn isTV() bool {
+    return @bitCast(c.SDL_IsTV());
+}
+
+pub const Sandbox = enum(c_int) {
+    sandboxUnknownContainer,
+    sandboxFlatpak,
+    sandboxSnap,
+    sandboxMacos,
+};
+
+pub inline fn getSandbox() Sandbox {
+    return c.SDL_GetSandbox();
+}
+
+pub inline fn onApplicationWillTerminate() void {
+    return c.SDL_OnApplicationWillTerminate();
+}
+
+pub inline fn onApplicationDidReceiveMemoryWarning() void {
+    return c.SDL_OnApplicationDidReceiveMemoryWarning();
+}
+
+pub inline fn onApplicationWillEnterBackground() void {
+    return c.SDL_OnApplicationWillEnterBackground();
+}
+
+pub inline fn onApplicationDidEnterBackground() void {
+    return c.SDL_OnApplicationDidEnterBackground();
+}
+
+pub inline fn onApplicationWillEnterForeground() void {
+    return c.SDL_OnApplicationWillEnterForeground();
+}
+
+pub inline fn onApplicationDidEnterForeground() void {
+    return c.SDL_OnApplicationDidEnterForeground();
+}
+
+pub inline fn onApplicationDidChangeStatusBarOrientation() void {
+    return c.SDL_OnApplicationDidChangeStatusBarOrientation();
+}
+
+pub const XTaskQueueHandle = *anyopaque;
+
+pub const XUserHandle = *anyopaque;
+
+pub inline fn getGDKTaskQueue(outTaskQueue: [*c]XTaskQueueHandle) bool {
+    return @bitCast(c.SDL_GetGDKTaskQueue(outTaskQueue));
+}
+
+pub inline fn getGDKDefaultUser(outUserHandle: [*c]XUserHandle) bool {
+    return @bitCast(c.SDL_GetGDKDefaultUser(outUserHandle));
+}

api/time.zig

@@ -0,0 +1,64 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const stdinc_api = @import("stdinc.zig");
+
+pub const Time = stdinc_api.Time;
+
+pub const DateTime = extern struct {
+    year: c_int, // Year
+    month: c_int, // Month [01-12]
+    day: c_int, // Day of the month [01-31]
+    hour: c_int, // Hour [0-23]
+    minute: c_int, // Minute [0-59]
+    second: c_int, // Seconds [0-60]
+    nanosecond: c_int, // Nanoseconds [0-999999999]
+    day_of_week: c_int, // Day of the week [0-6] (0 being Sunday)
+    utc_offset: c_int, // Seconds east of UTC
+};
+
+pub const DateFormat = enum(c_int) {
+    dateFormatYyyymmdd = 0, //Year/Month/Day
+    dateFormatDdmmyyyy = 1, //Day/Month/Year
+    dateFormatMmddyyyy = 2, //Month/Day/Year
+};
+
+pub const TimeFormat = enum(c_int) {
+    timeFormat24hr = 0, //24 hour time
+    timeFormat12hr = 1, //12 hour time
+};
+
+pub inline fn getDateTimeLocalePreferences(dateFormat: ?*DateFormat, timeFormat: ?*TimeFormat) bool {
+    return @bitCast(c.SDL_GetDateTimeLocalePreferences(@ptrCast(dateFormat), @ptrCast(timeFormat)));
+}
+
+pub inline fn getCurrentTime(ticks: ?*Time) bool {
+    return @bitCast(c.SDL_GetCurrentTime(@ptrCast(ticks)));
+}
+
+pub inline fn timeToDateTime(ticks: Time, dt: ?*DateTime, localTime: bool) bool {
+    return @bitCast(c.SDL_TimeToDateTime(ticks, @ptrCast(dt), @bitCast(localTime)));
+}
+
+pub inline fn dateTimeToTime(dt: ?*const DateTime, ticks: ?*Time) bool {
+    return @bitCast(c.SDL_DateTimeToTime(@ptrCast(dt), @ptrCast(ticks)));
+}
+
+pub inline fn timeToWindows(ticks: Time, dwLowDateTime: *u32, dwHighDateTime: *u32) void {
+    return c.SDL_TimeToWindows(ticks, @ptrCast(dwLowDateTime), @ptrCast(dwHighDateTime));
+}
+
+pub inline fn timeFromWindows(dwLowDateTime: u32, dwHighDateTime: u32) Time {
+    return c.SDL_TimeFromWindows(dwLowDateTime, dwHighDateTime);
+}
+
+pub inline fn getDaysInMonth(year: c_int, month: c_int) c_int {
+    return c.SDL_GetDaysInMonth(year, month);
+}
+
+pub inline fn getDayOfYear(year: c_int, month: c_int, day: c_int) c_int {
+    return c.SDL_GetDayOfYear(year, month, day);
+}
+
+pub inline fn getDayOfWeek(year: c_int, month: c_int, day: c_int) c_int {
+    return c.SDL_GetDayOfWeek(year, month, day);
+}

api/timer.zig

@@ -0,0 +1,47 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub inline fn getTicks() u64 {
+    return c.SDL_GetTicks();
+}
+
+pub inline fn getTicksNS() u64 {
+    return c.SDL_GetTicksNS();
+}
+
+pub inline fn getPerformanceCounter() u64 {
+    return c.SDL_GetPerformanceCounter();
+}
+
+pub inline fn getPerformanceFrequency() u64 {
+    return c.SDL_GetPerformanceFrequency();
+}
+
+pub inline fn delay(ms: u32) void {
+    return c.SDL_Delay(ms);
+}
+
+pub inline fn delayNS(ns: u64) void {
+    return c.SDL_DelayNS(ns);
+}
+
+pub inline fn delayPrecise(ns: u64) void {
+    return c.SDL_DelayPrecise(ns);
+}
+
+pub const TimerID = u32;
+
+pub const TimerCallback = c.SDL_TimerCallback;
+
+pub inline fn addTimer(interval: u32, callback: TimerCallback, userdata: ?*anyopaque) TimerID {
+    return c.SDL_AddTimer(interval, callback, userdata);
+}
+
+pub const NSTimerCallback = c.SDL_NSTimerCallback;
+
+pub inline fn addTimerNS(interval: u64, callback: NSTimerCallback, userdata: ?*anyopaque) TimerID {
+    return c.SDL_AddTimerNS(interval, callback, userdata);
+}
+
+pub inline fn removeTimer(id: TimerID) bool {
+    return @bitCast(c.SDL_RemoveTimer(id));
+}

api/touch.zig

@@ -0,0 +1,34 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub const TouchID = u64;
+
+pub const FingerID = u64;
+
+pub const TouchDeviceType = enum(c_int) {
+    touchDeviceDirect, //touch screen with window-relative coordinates
+    touchDeviceIndirectAbsolute, //trackpad with absolute device coordinates
+    touchDeviceIndirectRelative, //trackpad with screen cursor-relative coordinates
+};
+
+pub const Finger = extern struct {
+    id: FingerID, // the finger ID
+    x: f32, // the x-axis location of the touch event, normalized (0...1)
+    y: f32, // the y-axis location of the touch event, normalized (0...1)
+    pressure: f32, // the quantity of pressure applied, normalized (0...1)
+};
+
+pub inline fn getTouchDevices(count: *c_int) ?*TouchID {
+    return @ptrCast(c.SDL_GetTouchDevices(@ptrCast(count)));
+}
+
+pub inline fn getTouchDeviceName(touchID: TouchID) [*c]const u8 {
+    return c.SDL_GetTouchDeviceName(touchID);
+}
+
+pub inline fn getTouchDeviceType(touchID: TouchID) TouchDeviceType {
+    return @intFromEnum(c.SDL_GetTouchDeviceType(touchID));
+}
+
+pub inline fn getTouchFingers(touchID: TouchID, count: *c_int) [*c]?*Finger {
+    return c.SDL_GetTouchFingers(touchID, @ptrCast(count));
+}

api/tray.zig

@@ -0,0 +1,117 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const surface_api = @import("surface.zig");
+
+pub const Surface = surface_api.Surface;
+
+pub const Tray = opaque {
+    pub inline fn setTrayIcon(tray: *Tray, icon: ?*Surface) void {
+        return c.SDL_SetTrayIcon(@ptrCast(tray), @ptrCast(icon));
+    }
+
+    pub inline fn setTrayTooltip(tray: *Tray, tooltip: [*c]const u8) void {
+        return c.SDL_SetTrayTooltip(@ptrCast(tray), tooltip);
+    }
+
+    pub inline fn createTrayMenu(tray: *Tray) ?*TrayMenu {
+        return @ptrCast(c.SDL_CreateTrayMenu(@ptrCast(tray)));
+    }
+
+    pub inline fn getTrayMenu(tray: *Tray) ?*TrayMenu {
+        return @ptrCast(c.SDL_GetTrayMenu(@ptrCast(tray)));
+    }
+
+    pub inline fn destroyTray(tray: *Tray) void {
+        return c.SDL_DestroyTray(@ptrCast(tray));
+    }
+};
+
+pub const TrayMenu = opaque {
+    pub inline fn getTrayEntries(traymenu: *TrayMenu, count: *c_int) [*c]?*const TrayEntry {
+        return c.SDL_GetTrayEntries(@ptrCast(traymenu), @ptrCast(count));
+    }
+
+    pub inline fn insertTrayEntryAt(traymenu: *TrayMenu, pos: c_int, label: [*c]const u8, flags: TrayEntryFlags) ?*TrayEntry {
+        return @ptrCast(c.SDL_InsertTrayEntryAt(@ptrCast(traymenu), pos, label, @bitCast(flags)));
+    }
+
+    pub inline fn getTrayMenuParentEntry(traymenu: *TrayMenu) ?*TrayEntry {
+        return @ptrCast(c.SDL_GetTrayMenuParentEntry(@ptrCast(traymenu)));
+    }
+
+    pub inline fn getTrayMenuParentTray(traymenu: *TrayMenu) ?*Tray {
+        return @ptrCast(c.SDL_GetTrayMenuParentTray(@ptrCast(traymenu)));
+    }
+};
+
+pub const TrayEntry = opaque {
+    pub inline fn createTraySubmenu(trayentry: *TrayEntry) ?*TrayMenu {
+        return @ptrCast(c.SDL_CreateTraySubmenu(@ptrCast(trayentry)));
+    }
+
+    pub inline fn getTraySubmenu(trayentry: *TrayEntry) ?*TrayMenu {
+        return @ptrCast(c.SDL_GetTraySubmenu(@ptrCast(trayentry)));
+    }
+
+    pub inline fn removeTrayEntry(trayentry: *TrayEntry) void {
+        return c.SDL_RemoveTrayEntry(@ptrCast(trayentry));
+    }
+
+    pub inline fn setTrayEntryLabel(trayentry: *TrayEntry, label: [*c]const u8) void {
+        return c.SDL_SetTrayEntryLabel(@ptrCast(trayentry), label);
+    }
+
+    pub inline fn getTrayEntryLabel(trayentry: *TrayEntry) [*c]const u8 {
+        return c.SDL_GetTrayEntryLabel(@ptrCast(trayentry));
+    }
+
+    pub inline fn setTrayEntryChecked(trayentry: *TrayEntry, checked: bool) void {
+        return c.SDL_SetTrayEntryChecked(@ptrCast(trayentry), @bitCast(checked));
+    }
+
+    pub inline fn getTrayEntryChecked(trayentry: *TrayEntry) bool {
+        return @bitCast(c.SDL_GetTrayEntryChecked(@ptrCast(trayentry)));
+    }
+
+    pub inline fn setTrayEntryEnabled(trayentry: *TrayEntry, enabled: bool) void {
+        return c.SDL_SetTrayEntryEnabled(@ptrCast(trayentry), @bitCast(enabled));
+    }
+
+    pub inline fn getTrayEntryEnabled(trayentry: *TrayEntry) bool {
+        return @bitCast(c.SDL_GetTrayEntryEnabled(@ptrCast(trayentry)));
+    }
+
+    pub inline fn setTrayEntryCallback(trayentry: *TrayEntry, callback: TrayCallback, userdata: ?*anyopaque) void {
+        return c.SDL_SetTrayEntryCallback(@ptrCast(trayentry), callback, userdata);
+    }
+
+    pub inline fn clickTrayEntry(trayentry: *TrayEntry) void {
+        return c.SDL_ClickTrayEntry(@ptrCast(trayentry));
+    }
+
+    pub inline fn getTrayEntryParent(trayentry: *TrayEntry) ?*TrayMenu {
+        return @ptrCast(c.SDL_GetTrayEntryParent(@ptrCast(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 None = TrayEntryFlags{};
+};
+
+pub const TrayCallback = c.SDL_TrayCallback;
+
+pub inline fn createTray(icon: ?*Surface, tooltip: [*c]const u8) ?*Tray {
+    return @ptrCast(c.SDL_CreateTray(@ptrCast(icon), tooltip));
+}
+
+pub inline fn updateTrays() void {
+    return c.SDL_UpdateTrays();
+}

api/version.zig

@@ -0,0 +1,9 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+pub inline fn getVersion() c_int {
+    return c.SDL_GetVersion();
+}
+
+pub inline fn getRevision() [*c]const u8 {
+    return c.SDL_GetRevision();
+}

api/video.zig

@@ -0,0 +1,622 @@
+const std = @import("std");
+pub const c = @import("c.zig").c;
+const pixels_api = @import("pixels.zig");
+const rect_api = @import("rect.zig");
+const surface_api = @import("surface.zig");
+const properties_api = @import("properties.zig");
+const stdinc_api = @import("stdinc.zig");
+
+pub const PixelFormat = pixels_api.PixelFormat;
+pub const Point = rect_api.Point;
+pub const Surface = surface_api.Surface;
+pub const PropertiesID = properties_api.PropertiesID;
+pub const Rect = rect_api.Rect;
+pub const FunctionPointer = stdinc_api.FunctionPointer;
+
+pub const DisplayID = u32;
+
+pub const WindowID = u32;
+
+pub const SystemTheme = enum(c_int) {
+    systemThemeUnknown, //Unknown system theme
+    systemThemeLight, //Light colored system theme
+    systemThemeDark, //Dark colored system theme
+};
+
+pub const DisplayModeData = opaque {};
+
+pub const DisplayMode = extern struct {
+    displayID: DisplayID, // the display this mode is associated with
+    format: PixelFormat, // pixel format
+    w: c_int, // width
+    h: c_int, // height
+    pixel_density: f32, // scale converting size to pixels (e.g. a 1920x1080 mode with 2.0 scale would have 3840x2160 pixels)
+    refresh_rate: f32, // refresh rate (or 0.0f for unspecified)
+    refresh_rate_numerator: c_int, // precise refresh rate numerator (or 0 for unspecified)
+    refresh_rate_denominator: c_int, // precise refresh rate denominator
+    internal: ?*DisplayModeData, // Private
+};
+
+pub const DisplayOrientation = enum(c_int) {
+    orientationUnknown, //The display orientation can't be determined
+    orientationLandscape, //The display is in landscape mode, with the right side up, relative to portrait mode
+    orientationLandscapeFlipped, //The display is in landscape mode, with the left side up, relative to portrait mode
+    orientationPortrait, //The display is in portrait mode
+    orientationPortraitFlipped,
+};
+
+pub const Window = opaque {
+    pub inline fn getDisplayForWindow(window: *Window) DisplayID {
+        return c.SDL_GetDisplayForWindow(@ptrCast(window));
+    }
+
+    pub inline fn getWindowPixelDensity(window: *Window) f32 {
+        return c.SDL_GetWindowPixelDensity(@ptrCast(window));
+    }
+
+    pub inline fn getWindowDisplayScale(window: *Window) f32 {
+        return c.SDL_GetWindowDisplayScale(@ptrCast(window));
+    }
+
+    pub inline fn setWindowFullscreenMode(window: *Window, mode: ?*const DisplayMode) bool {
+        return @bitCast(c.SDL_SetWindowFullscreenMode(@ptrCast(window), @ptrCast(mode)));
+    }
+
+    pub inline fn getWindowFullscreenMode(window: *Window) ?*const DisplayMode {
+        return @ptrCast(c.SDL_GetWindowFullscreenMode(@ptrCast(window)));
+    }
+
+    pub inline fn getWindowICCProfile(window: *Window, size: *usize) ?*anyopaque {
+        return c.SDL_GetWindowICCProfile(@ptrCast(window), @ptrCast(size));
+    }
+
+    pub inline fn getWindowPixelFormat(window: *Window) PixelFormat {
+        return @bitCast(c.SDL_GetWindowPixelFormat(@ptrCast(window)));
+    }
+
+    pub inline fn createPopupWindow(window: *Window, offset_x: c_int, offset_y: c_int, w: c_int, h: c_int, flags: WindowFlags) ?*Window {
+        return @ptrCast(c.SDL_CreatePopupWindow(@ptrCast(window), offset_x, offset_y, w, h, @bitCast(flags)));
+    }
+
+    pub inline fn getWindowID(window: *Window) WindowID {
+        return c.SDL_GetWindowID(@ptrCast(window));
+    }
+
+    pub inline fn getWindowParent(window: *Window) ?*Window {
+        return @ptrCast(c.SDL_GetWindowParent(@ptrCast(window)));
+    }
+
+    pub inline fn getWindowProperties(window: *Window) PropertiesID {
+        return c.SDL_GetWindowProperties(@ptrCast(window));
+    }
+
+    pub inline fn getWindowFlags(window: *Window) WindowFlags {
+        return @bitCast(c.SDL_GetWindowFlags(@ptrCast(window)));
+    }
+
+    pub inline fn setWindowTitle(window: *Window, title: [*c]const u8) bool {
+        return @bitCast(c.SDL_SetWindowTitle(@ptrCast(window), title));
+    }
+
+    pub inline fn getWindowTitle(window: *Window) [*c]const u8 {
+        return c.SDL_GetWindowTitle(@ptrCast(window));
+    }
+
+    pub inline fn setWindowIcon(window: *Window, icon: ?*Surface) bool {
+        return @bitCast(c.SDL_SetWindowIcon(@ptrCast(window), @ptrCast(icon)));
+    }
+
+    pub inline fn setWindowPosition(window: *Window, x: c_int, y: c_int) bool {
+        return @bitCast(c.SDL_SetWindowPosition(@ptrCast(window), x, y));
+    }
+
+    pub inline fn getWindowPosition(window: *Window, x: *c_int, y: *c_int) bool {
+        return @bitCast(c.SDL_GetWindowPosition(@ptrCast(window), @ptrCast(x), @ptrCast(y)));
+    }
+
+    pub inline fn setWindowSize(window: *Window, w: c_int, h: c_int) bool {
+        return @bitCast(c.SDL_SetWindowSize(@ptrCast(window), w, h));
+    }
+
+    pub inline fn getWindowSize(window: *Window, w: *c_int, h: *c_int) bool {
+        return @bitCast(c.SDL_GetWindowSize(@ptrCast(window), @ptrCast(w), @ptrCast(h)));
+    }
+
+    pub inline fn getWindowSafeArea(window: *Window, rect: ?*Rect) bool {
+        return @bitCast(c.SDL_GetWindowSafeArea(@ptrCast(window), @ptrCast(rect)));
+    }
+
+    pub inline fn setWindowAspectRatio(window: *Window, min_aspect: f32, max_aspect: f32) bool {
+        return @bitCast(c.SDL_SetWindowAspectRatio(@ptrCast(window), min_aspect, max_aspect));
+    }
+
+    pub inline fn getWindowAspectRatio(window: *Window, min_aspect: *f32, max_aspect: *f32) bool {
+        return @bitCast(c.SDL_GetWindowAspectRatio(@ptrCast(window), @ptrCast(min_aspect), @ptrCast(max_aspect)));
+    }
+
+    pub inline fn getWindowBordersSize(window: *Window, top: *c_int, left: *c_int, bottom: *c_int, right: *c_int) bool {
+        return @bitCast(c.SDL_GetWindowBordersSize(@ptrCast(window), @ptrCast(top), @ptrCast(left), @ptrCast(bottom), @ptrCast(right)));
+    }
+
+    pub inline fn getWindowSizeInPixels(window: *Window, w: *c_int, h: *c_int) bool {
+        return @bitCast(c.SDL_GetWindowSizeInPixels(@ptrCast(window), @ptrCast(w), @ptrCast(h)));
+    }
+
+    pub inline fn setWindowMinimumSize(window: *Window, min_w: c_int, min_h: c_int) bool {
+        return @bitCast(c.SDL_SetWindowMinimumSize(@ptrCast(window), min_w, min_h));
+    }
+
+    pub inline fn getWindowMinimumSize(window: *Window, w: *c_int, h: *c_int) bool {
+        return @bitCast(c.SDL_GetWindowMinimumSize(@ptrCast(window), @ptrCast(w), @ptrCast(h)));
+    }
+
+    pub inline fn setWindowMaximumSize(window: *Window, max_w: c_int, max_h: c_int) bool {
+        return @bitCast(c.SDL_SetWindowMaximumSize(@ptrCast(window), max_w, max_h));
+    }
+
+    pub inline fn getWindowMaximumSize(window: *Window, w: *c_int, h: *c_int) bool {
+        return @bitCast(c.SDL_GetWindowMaximumSize(@ptrCast(window), @ptrCast(w), @ptrCast(h)));
+    }
+
+    pub inline fn setWindowBordered(window: *Window, bordered: bool) bool {
+        return @bitCast(c.SDL_SetWindowBordered(@ptrCast(window), @bitCast(bordered)));
+    }
+
+    pub inline fn setWindowResizable(window: *Window, resizable: bool) bool {
+        return @bitCast(c.SDL_SetWindowResizable(@ptrCast(window), @bitCast(resizable)));
+    }
+
+    pub inline fn setWindowAlwaysOnTop(window: *Window, on_top: bool) bool {
+        return @bitCast(c.SDL_SetWindowAlwaysOnTop(@ptrCast(window), @bitCast(on_top)));
+    }
+
+    pub inline fn setWindowFillDocument(window: *Window, fill: bool) bool {
+        return @bitCast(c.SDL_SetWindowFillDocument(@ptrCast(window), @bitCast(fill)));
+    }
+
+    pub inline fn showWindow(window: *Window) bool {
+        return @bitCast(c.SDL_ShowWindow(@ptrCast(window)));
+    }
+
+    pub inline fn hideWindow(window: *Window) bool {
+        return @bitCast(c.SDL_HideWindow(@ptrCast(window)));
+    }
+
+    pub inline fn raiseWindow(window: *Window) bool {
+        return @bitCast(c.SDL_RaiseWindow(@ptrCast(window)));
+    }
+
+    pub inline fn maximizeWindow(window: *Window) bool {
+        return @bitCast(c.SDL_MaximizeWindow(@ptrCast(window)));
+    }
+
+    pub inline fn minimizeWindow(window: *Window) bool {
+        return @bitCast(c.SDL_MinimizeWindow(@ptrCast(window)));
+    }
+
+    pub inline fn restoreWindow(window: *Window) bool {
+        return @bitCast(c.SDL_RestoreWindow(@ptrCast(window)));
+    }
+
+    pub inline fn setWindowFullscreen(window: *Window, fullscreen: bool) bool {
+        return @bitCast(c.SDL_SetWindowFullscreen(@ptrCast(window), @bitCast(fullscreen)));
+    }
+
+    pub inline fn syncWindow(window: *Window) bool {
+        return @bitCast(c.SDL_SyncWindow(@ptrCast(window)));
+    }
+
+    pub inline fn windowHasSurface(window: *Window) bool {
+        return @bitCast(c.SDL_WindowHasSurface(@ptrCast(window)));
+    }
+
+    pub inline fn getWindowSurface(window: *Window) ?*Surface {
+        return @ptrCast(c.SDL_GetWindowSurface(@ptrCast(window)));
+    }
+
+    pub inline fn setWindowSurfaceVSync(window: *Window, vsync: c_int) bool {
+        return @bitCast(c.SDL_SetWindowSurfaceVSync(@ptrCast(window), vsync));
+    }
+
+    pub inline fn getWindowSurfaceVSync(window: *Window, vsync: *c_int) bool {
+        return @bitCast(c.SDL_GetWindowSurfaceVSync(@ptrCast(window), @ptrCast(vsync)));
+    }
+
+    pub inline fn updateWindowSurface(window: *Window) bool {
+        return @bitCast(c.SDL_UpdateWindowSurface(@ptrCast(window)));
+    }
+
+    pub inline fn updateWindowSurfaceRects(window: *Window, rects: ?*const Rect, numrects: c_int) bool {
+        return @bitCast(c.SDL_UpdateWindowSurfaceRects(@ptrCast(window), @ptrCast(rects), numrects));
+    }
+
+    pub inline fn destroyWindowSurface(window: *Window) bool {
+        return @bitCast(c.SDL_DestroyWindowSurface(@ptrCast(window)));
+    }
+
+    pub inline fn setWindowKeyboardGrab(window: *Window, grabbed: bool) bool {
+        return @bitCast(c.SDL_SetWindowKeyboardGrab(@ptrCast(window), @bitCast(grabbed)));
+    }
+
+    pub inline fn setWindowMouseGrab(window: *Window, grabbed: bool) bool {
+        return @bitCast(c.SDL_SetWindowMouseGrab(@ptrCast(window), @bitCast(grabbed)));
+    }
+
+    pub inline fn getWindowKeyboardGrab(window: *Window) bool {
+        return @bitCast(c.SDL_GetWindowKeyboardGrab(@ptrCast(window)));
+    }
+
+    pub inline fn getWindowMouseGrab(window: *Window) bool {
+        return @bitCast(c.SDL_GetWindowMouseGrab(@ptrCast(window)));
+    }
+
+    pub inline fn setWindowMouseRect(window: *Window, rect: ?*const Rect) bool {
+        return @bitCast(c.SDL_SetWindowMouseRect(@ptrCast(window), @ptrCast(rect)));
+    }
+
+    pub inline fn getWindowMouseRect(window: *Window) ?*const Rect {
+        return @ptrCast(c.SDL_GetWindowMouseRect(@ptrCast(window)));
+    }
+
+    pub inline fn setWindowOpacity(window: *Window, opacity: f32) bool {
+        return @bitCast(c.SDL_SetWindowOpacity(@ptrCast(window), opacity));
+    }
+
+    pub inline fn getWindowOpacity(window: *Window) f32 {
+        return c.SDL_GetWindowOpacity(@ptrCast(window));
+    }
+
+    pub inline fn setWindowParent(window: *Window, parent: ?*Window) bool {
+        return @bitCast(c.SDL_SetWindowParent(@ptrCast(window), @ptrCast(parent)));
+    }
+
+    pub inline fn setWindowModal(window: *Window, modal: bool) bool {
+        return @bitCast(c.SDL_SetWindowModal(@ptrCast(window), @bitCast(modal)));
+    }
+
+    pub inline fn setWindowFocusable(window: *Window, focusable: bool) bool {
+        return @bitCast(c.SDL_SetWindowFocusable(@ptrCast(window), @bitCast(focusable)));
+    }
+
+    pub inline fn showWindowSystemMenu(window: *Window, x: c_int, y: c_int) bool {
+        return @bitCast(c.SDL_ShowWindowSystemMenu(@ptrCast(window), x, y));
+    }
+
+    pub inline fn setWindowHitTest(window: *Window, callback: HitTest, callback_data: ?*anyopaque) bool {
+        return @bitCast(c.SDL_SetWindowHitTest(@ptrCast(window), callback, callback_data));
+    }
+
+    pub inline fn setWindowShape(window: *Window, shape: ?*Surface) bool {
+        return @bitCast(c.SDL_SetWindowShape(@ptrCast(window), @ptrCast(shape)));
+    }
+
+    pub inline fn flashWindow(window: *Window, operation: FlashOperation) bool {
+        return @bitCast(c.SDL_FlashWindow(@ptrCast(window), @intFromEnum(operation)));
+    }
+
+    pub inline fn setWindowProgressState(window: *Window, state: ProgressState) bool {
+        return @bitCast(c.SDL_SetWindowProgressState(@ptrCast(window), state));
+    }
+
+    pub inline fn getWindowProgressState(window: *Window) ProgressState {
+        return c.SDL_GetWindowProgressState(@ptrCast(window));
+    }
+
+    pub inline fn setWindowProgressValue(window: *Window, value: f32) bool {
+        return @bitCast(c.SDL_SetWindowProgressValue(@ptrCast(window), value));
+    }
+
+    pub inline fn getWindowProgressValue(window: *Window) f32 {
+        return c.SDL_GetWindowProgressValue(@ptrCast(window));
+    }
+
+    pub inline fn destroyWindow(window: *Window) void {
+        return c.SDL_DestroyWindow(@ptrCast(window));
+    }
+
+    pub inline fn gl_CreateContext(window: *Window) GLContext {
+        return c.SDL_GL_CreateContext(@ptrCast(window));
+    }
+
+    pub inline fn gl_MakeCurrent(window: *Window, context: GLContext) bool {
+        return @bitCast(c.SDL_GL_MakeCurrent(@ptrCast(window), context));
+    }
+
+    pub inline fn egl_GetWindowSurface(window: *Window) EGLSurface {
+        return c.SDL_EGL_GetWindowSurface(@ptrCast(window));
+    }
+
+    pub inline fn gl_SwapWindow(window: *Window) bool {
+        return @bitCast(c.SDL_GL_SwapWindow(@ptrCast(window)));
+    }
+};
+
+pub const WindowFlags = packed struct(u64) {
+    windowFullscreen: bool = false, // window is in fullscreen mode
+    windowOpengl: bool = false, // window usable with OpenGL context
+    windowOccluded: bool = false, // window is occluded
+    windowHidden: bool = false, // window is neither mapped onto the desktop nor shown in the taskbar/dock/window list; SDL_ShowWindow() is required for it to become visible
+    windowBorderless: bool = false, // no window decoration
+    windowResizable: bool = false, // window can be resized
+    windowMinimized: bool = false, // window is minimized
+    windowMaximized: bool = false, // window is maximized
+    windowMouseGrabbed: bool = false, // window has grabbed mouse input
+    windowInputFocus: bool = false, // window has input focus
+    windowMouseFocus: bool = false, // window has mouse focus
+    windowExternal: bool = false, // window not created by SDL
+    windowModal: bool = false, // window is modal
+    windowHighPixelDensity: bool = false, // window uses high pixel density back buffer if possible
+    windowMouseCapture: bool = false, // window has mouse captured (unrelated to MOUSE_GRABBED)
+    windowMouseRelativeMode: bool = false, // window has relative mode enabled
+    windowAlwaysOnTop: bool = false, // window should always be above others
+    windowUtility: bool = false, // window should be treated as a utility window, not showing in the task bar and window list
+    windowTooltip: bool = false, // window should be treated as a tooltip and does not get mouse or keyboard focus, requires a parent window
+    windowPopupMenu: bool = false, // window should be treated as a popup menu, requires a parent window
+    windowKeyboardGrabbed: bool = false, // window has grabbed keyboard input
+    windowFillDocument: bool = false, // window is in fill-document mode (Emscripten only), since SDL 3.4.0
+    windowVulkan: bool = false, // window usable for Vulkan surface
+    windowMetal: bool = false, // window usable for Metal view
+    windowTransparent: bool = false, // window with transparent buffer
+    windowNotFocusable: bool = false, // window should not be focusable
+    pad0: u37 = 0,
+    rsvd: bool = false,
+
+    pub const None = WindowFlags{};
+};
+
+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 ProgressState = enum(c_int) {
+    progressStateInvalid = -1, //An invalid progress state indicating an error; check SDL_GetError()
+    progressStateNone, //No progress bar is shown
+    progressStateIndeterminate, //The progress bar is shown in a indeterminate state
+    progressStateNormal, //The progress bar is shown in a normal state
+    progressStatePaused, //The progress bar is shown in a paused state
+    progressStateError, //The progress bar is shown in a state indicating the application had an error
+};
+
+pub const GLContext = *anyopaque;
+
+pub const EGLDisplay = ?*anyopaque;
+
+pub const EGLConfig = ?*anyopaque;
+
+pub const EGLSurface = ?*anyopaque;
+
+pub const EGLAttrib = isize;
+
+pub const EGLint = c_int;
+
+pub const EGLAttribArrayCallback = c.SDL_EGLAttribArrayCallback;
+
+pub const EGLIntArrayCallback = c.SDL_EGLIntArrayCallback;
+
+pub const GLAttr = enum(c_int) {
+    glRedSize, //the minimum number of bits for the red channel of the color buffer; defaults to 8.
+    glGreenSize, //the minimum number of bits for the green channel of the color buffer; defaults to 8.
+    glBlueSize, //the minimum number of bits for the blue channel of the color buffer; defaults to 8.
+    glAlphaSize, //the minimum number of bits for the alpha channel of the color buffer; defaults to 8.
+    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 if 1. Defaults to -1 ("don't care"). This is a request; GL drivers might not comply!
+    glContextReleaseBehavior, //sets context the release behavior. See SDL_GLContextReleaseFlag; defaults to FLUSH.
+    glContextResetNotification, //set context reset notification. See SDL_GLContextResetNotification; defaults to NO_NOTIFICATION.
+    glContextNoError,
+    glFloatbuffers,
+    glEglPlatform,
+};
+
+pub const GLProfile = u32;
+
+pub const GLContextFlag = u32;
+
+pub const GLContextReleaseFlag = u32;
+
+pub const GLContextResetNotification = u32;
+
+pub inline fn getNumVideoDrivers() c_int {
+    return c.SDL_GetNumVideoDrivers();
+}
+
+pub inline fn getVideoDriver(index: c_int) [*c]const u8 {
+    return c.SDL_GetVideoDriver(index);
+}
+
+pub inline fn getCurrentVideoDriver() [*c]const u8 {
+    return c.SDL_GetCurrentVideoDriver();
+}
+
+pub inline fn getSystemTheme() SystemTheme {
+    return c.SDL_GetSystemTheme();
+}
+
+pub inline fn getDisplays(count: *c_int) ?*DisplayID {
+    return @ptrCast(c.SDL_GetDisplays(@ptrCast(count)));
+}
+
+pub inline fn getPrimaryDisplay() DisplayID {
+    return c.SDL_GetPrimaryDisplay();
+}
+
+pub inline fn getDisplayProperties(displayID: DisplayID) PropertiesID {
+    return c.SDL_GetDisplayProperties(displayID);
+}
+
+pub inline fn getDisplayName(displayID: DisplayID) [*c]const u8 {
+    return c.SDL_GetDisplayName(displayID);
+}
+
+pub inline fn getDisplayBounds(displayID: DisplayID, rect: ?*Rect) bool {
+    return @bitCast(c.SDL_GetDisplayBounds(displayID, @ptrCast(rect)));
+}
+
+pub inline fn getDisplayUsableBounds(displayID: DisplayID, rect: ?*Rect) bool {
+    return @bitCast(c.SDL_GetDisplayUsableBounds(displayID, @ptrCast(rect)));
+}
+
+pub inline fn getNaturalDisplayOrientation(displayID: DisplayID) DisplayOrientation {
+    return c.SDL_GetNaturalDisplayOrientation(displayID);
+}
+
+pub inline fn getCurrentDisplayOrientation(displayID: DisplayID) DisplayOrientation {
+    return c.SDL_GetCurrentDisplayOrientation(displayID);
+}
+
+pub inline fn getDisplayContentScale(displayID: DisplayID) f32 {
+    return c.SDL_GetDisplayContentScale(displayID);
+}
+
+pub inline fn getFullscreenDisplayModes(displayID: DisplayID, count: *c_int) [*c]?*DisplayMode {
+    return @intFromEnum(c.SDL_GetFullscreenDisplayModes(displayID, @ptrCast(count)));
+}
+
+pub inline fn getClosestFullscreenDisplayMode(displayID: DisplayID, w: c_int, h: c_int, refresh_rate: f32, include_high_density_modes: bool, closest: ?*DisplayMode) bool {
+    return @bitCast(c.SDL_GetClosestFullscreenDisplayMode(displayID, w, h, refresh_rate, @bitCast(include_high_density_modes), @ptrCast(closest)));
+}
+
+pub inline fn getDesktopDisplayMode(displayID: DisplayID) ?*const DisplayMode {
+    return @ptrCast(c.SDL_GetDesktopDisplayMode(displayID));
+}
+
+pub inline fn getCurrentDisplayMode(displayID: DisplayID) ?*const DisplayMode {
+    return @ptrCast(c.SDL_GetCurrentDisplayMode(displayID));
+}
+
+pub inline fn getDisplayForPoint(point: ?*const Point) DisplayID {
+    return c.SDL_GetDisplayForPoint(@ptrCast(point));
+}
+
+pub inline fn getDisplayForRect(rect: ?*const Rect) DisplayID {
+    return c.SDL_GetDisplayForRect(@ptrCast(rect));
+}
+
+pub inline fn getWindows(count: *c_int) [*c]?*Window {
+    return c.SDL_GetWindows(@ptrCast(count));
+}
+
+pub inline fn createWindow(title: [*c]const u8, w: c_int, h: c_int, flags: WindowFlags) ?*Window {
+    return @ptrCast(c.SDL_CreateWindow(title, w, h, @bitCast(flags)));
+}
+
+pub inline fn createWindowWithProperties(props: PropertiesID) ?*Window {
+    return @ptrCast(c.SDL_CreateWindowWithProperties(props));
+}
+
+pub inline fn getWindowFromID(id: WindowID) ?*Window {
+    return @ptrCast(c.SDL_GetWindowFromID(id));
+}
+
+pub inline fn getGrabbedWindow() ?*Window {
+    return @ptrCast(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 const HitTest = c.SDL_HitTest;
+
+pub inline fn screenSaverEnabled() bool {
+    return @bitCast(c.SDL_ScreenSaverEnabled());
+}
+
+pub inline fn enableScreenSaver() bool {
+    return @bitCast(c.SDL_EnableScreenSaver());
+}
+
+pub inline fn disableScreenSaver() bool {
+    return @bitCast(c.SDL_DisableScreenSaver());
+}
+
+pub inline fn gl_LoadLibrary(path: [*c]const u8) bool {
+    return @bitCast(c.SDL_GL_LoadLibrary(path));
+}
+
+pub inline fn gl_GetProcAddress(proc: [*c]const u8) FunctionPointer {
+    return c.SDL_GL_GetProcAddress(proc);
+}
+
+pub inline fn egl_GetProcAddress(proc: [*c]const u8) FunctionPointer {
+    return c.SDL_EGL_GetProcAddress(proc);
+}
+
+pub inline fn gl_UnloadLibrary() void {
+    return c.SDL_GL_UnloadLibrary();
+}
+
+pub inline fn gl_ExtensionSupported(extension: [*c]const u8) bool {
+    return @bitCast(c.SDL_GL_ExtensionSupported(extension));
+}
+
+pub inline fn gl_ResetAttributes() void {
+    return c.SDL_GL_ResetAttributes();
+}
+
+pub inline fn gl_SetAttribute(attr: GLAttr, value: c_int) bool {
+    return @bitCast(c.SDL_GL_SetAttribute(attr, value));
+}
+
+pub inline fn gl_GetAttribute(attr: GLAttr, value: *c_int) bool {
+    return @bitCast(c.SDL_GL_GetAttribute(attr, @ptrCast(value)));
+}
+
+pub inline fn gl_GetCurrentWindow() ?*Window {
+    return @ptrCast(c.SDL_GL_GetCurrentWindow());
+}
+
+pub inline fn gl_GetCurrentContext() GLContext {
+    return c.SDL_GL_GetCurrentContext();
+}
+
+pub inline fn egl_GetCurrentDisplay() EGLDisplay {
+    return c.SDL_EGL_GetCurrentDisplay();
+}
+
+pub inline fn egl_GetCurrentConfig() EGLConfig {
+    return c.SDL_EGL_GetCurrentConfig();
+}
+
+pub inline fn egl_SetAttributeCallbacks(platformAttribCallback: EGLAttribArrayCallback, surfaceAttribCallback: EGLIntArrayCallback, contextAttribCallback: EGLIntArrayCallback, userdata: ?*anyopaque) void {
+    return c.SDL_EGL_SetAttributeCallbacks(platformAttribCallback, surfaceAttribCallback, contextAttribCallback, userdata);
+}
+
+pub inline fn gl_SetSwapInterval(interval: c_int) bool {
+    return @bitCast(c.SDL_GL_SetSwapInterval(interval));
+}
+
+pub inline fn gl_GetSwapInterval(interval: *c_int) bool {
+    return @bitCast(c.SDL_GL_GetSwapInterval(@ptrCast(interval)));
+}
+
+pub inline fn gl_DestroyContext(context: GLContext) bool {
+    return @bitCast(c.SDL_GL_DestroyContext(context));
+}

build.zig

@@ -159,6 +159,7 @@ pub fn generateApi(b: *std.Build, parser_exe: *std.Build.Step.Compile, fetch_sdl
     const source_dir = b.option([]const u8, "sourceDir", "Parse SDL headers from an existing local directory instead of fetching git");
     const output_dir = b.option([]const u8, "outputDir", "Directory where generated api/ and json/ folders should be written");
     const basedir = b.option([]const u8, "basedir", "Working directory for the parser to execute in");
+    const c_import_path = b.option([]const u8, "cImportPath", "Path used by generated files when importing c.zig");
     const effective_output_dir = output_dir orelse source_dir;
     const header_root_suffix = if (source_dir) |dir| resolveHeaderRoot(b.allocator, dir) catch @panic("OOM") else null;
 
@@ -213,7 +214,7 @@ pub fn generateApi(b: *std.Build, parser_exe: *std.Build.Step.Compile, fetch_sdl
         .{ .header = "SDL_init.h", .output = "init" },
         // .{ .header = "SDL_iostream.h", .output = "iostream" }, // Skipped: complex I/O API
         .{ .header = "SDL_joystick.h", .output = "joystick" },
-        // .{ .header = "SDL_keyboard.h", .output = "keyboard" },
+        .{ .header = "SDL_keyboard.h", .output = "keyboard" },
         .{ .header = "SDL_keycode.h", .output = "keycode" },
         .{ .header = "SDL_loadso.h", .output = "loadso" },
         // .{ .header = "SDL_locale.h", .output = "locale" },
@@ -223,15 +224,15 @@ pub fn generateApi(b: *std.Build, parser_exe: *std.Build.Step.Compile, fetch_sdl
         .{ .header = "SDL_misc.h", .output = "misc" },
         .{ .header = "SDL_mouse.h", .output = "mouse" },
         // .{ .header = "SDL_mutex.h", .output = "mutex" }, // Skipped: not core API
-        // .{ .header = "SDL_opengl.h", .output = "opengl" },
+        .{ .header = "SDL_opengl.h", .output = "opengl" },
         // .{ .header = "SDL_pen.h", .output = "pen" },
         .{ .header = "SDL_pixels.h", .output = "pixels" },
-        // .{ .header = "SDL_power.h", .output = "power" },
-        // .{ .header = "SDL_process.h", .output = "process" },
+        .{ .header = "SDL_power.h", .output = "power" },
+        .{ .header = "SDL_process.h", .output = "process" },
         .{ .header = "SDL_properties.h", .output = "properties" },
         .{ .header = "SDL_rect.h", .output = "rect" },
         .{ .header = "SDL_render.h", .output = "render" },
-        // .{ .header = "SDL_scancode.h", .output = "scancode" },
+        .{ .header = "SDL_scancode.h", .output = "scancode" },
         .{ .header = "SDL_sensor.h", .output = "sensor" },
         .{ .header = "SDL_storage.h", .output = "storage" },
         .{ .header = "SDL_surface.h", .output = "surface" },
@@ -240,7 +241,7 @@ pub fn generateApi(b: *std.Build, parser_exe: *std.Build.Step.Compile, fetch_sdl
         .{ .header = "SDL_time.h", .output = "time" },
         .{ .header = "SDL_timer.h", .output = "timer" },
         .{ .header = "SDL_touch.h", .output = "touch" },
-        // .{ .header = "SDL_tray.h", .output = "tray" }, // Skipped: not core API
+        .{ .header = "SDL_tray.h", .output = "tray" }, // Skipped: not core API
         .{ .header = "SDL_version.h", .output = "version" },
         .{ .header = "SDL_video.h", .output = "video" },
         // .{ .header = "SDL_vulkan.h", .output = "vulkan" }, // Skipped: Vulkan interop
@@ -264,6 +265,9 @@ pub fn generateApi(b: *std.Build, parser_exe: *std.Build.Step.Compile, fetch_sdl
         if (basedir) |dir| {
             regenerate.addArg(b.fmt("--basedir={s}", .{dir}));
         }
+        if (c_import_path) |path| {
+            regenerate.addArg(b.fmt("--c-import={s}", .{path}));
+        }
         // regenerate.addArg(b.fmt("--output=api/{s}.zig --mocks=mocks/{s}.c", .{ header_info.output, header_info.output }));
         regenerate.step.dependOn(path_prep_step);
         regenerate_step.dependOn(&regenerate.step);

json/audio.json

@@ -0,0 +1,906 @@
+{
+  "header": "SDL_audio.h",
+  "opaque_types": [
+    {
+      "name": "SDL_AudioStream"
+    }
+  ],
+  "typedefs": [
+    {
+      "name": "SDL_AudioDeviceID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_AudioStreamDataCompleteCallback"
+    },
+    {
+      "name": "SDL_AudioStreamCallback"
+    },
+    {
+      "name": "SDL_AudioPostmixCallback"
+    }
+  ],
+  "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_PutAudioStreamDataNoCopy",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "stream",
+          "type": "SDL_AudioStream *"
+        },
+        {
+          "name": "buf",
+          "type": "const void *"
+        },
+        {
+          "name": "len",
+          "type": "int"
+        },
+        {
+          "name": "callback",
+          "type": "SDL_AudioStreamDataCompleteCallback"
+        },
+        {
+          "name": "userdata",
+          "type": "void *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_PutAudioStreamPlanarData",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "stream",
+          "type": "SDL_AudioStream *"
+        },
+        {
+          "name": "channel_buffers",
+          "type": "const void * const *"
+        },
+        {
+          "name": "num_channels",
+          "type": "int"
+        },
+        {
+          "name": "num_samples",
+          "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"
+        }
+      ]
+    }
+  ]
+}

json/blendmode.json

@@ -0,0 +1,132 @@
+{
+  "header": "SDL_blendmode.h",
+  "opaque_types": [],
+  "typedefs": [
+    {
+      "name": "SDL_BlendMode",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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"
+        }
+      ]
+    }
+  ]
+}

json/camera.json

@@ -0,0 +1,244 @@
+{
+  "header": "SDL_camera.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Camera"
+    }
+  ],
+  "typedefs": [
+    {
+      "name": "SDL_CameraID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [
+    {
+      "name": "SDL_CameraPosition",
+      "values": [
+        {
+          "name": "SDL_CAMERA_POSITION_UNKNOWN"
+        },
+        {
+          "name": "SDL_CAMERA_POSITION_FRONT_FACING"
+        },
+        {
+          "name": "SDL_CAMERA_POSITION_BACK_FACING"
+        }
+      ]
+    },
+    {
+      "name": "SDL_CameraPermissionState",
+      "values": [
+        {
+          "name": "SDL_CAMERA_PERMISSION_STATE_PENDING"
+        },
+        {
+          "name": "SDL_CAMERA_PERMISSION_STATE_APPROVED"
+        }
+      ]
+    }
+  ],
+  "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 denominator ((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": "SDL_CameraPermissionState",
+      "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 *"
+        }
+      ]
+    }
+  ]
+}

json/clipboard.json

@@ -0,0 +1,125 @@
+{
+  "header": "SDL_clipboard.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_ClipboardDataCallback"
+    },
+    {
+      "name": "SDL_ClipboardCleanupCallback"
+    }
+  ],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/dialog.json

@@ -0,0 +1,158 @@
+{
+  "header": "SDL_dialog.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_DialogFileCallback"
+    }
+  ],
+  "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"
+        }
+      ]
+    }
+  ]
+}

json/endian.json

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

json/error.json

@@ -0,0 +1,28 @@
+{
+  "header": "SDL_error.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": [
+    {
+      "name": "SDL_OutOfMemory",
+      "return_type": "bool",
+      "parameters": []
+    },
+    {
+      "name": "SDL_GetError",
+      "return_type": "const char *",
+      "parameters": []
+    },
+    {
+      "name": "SDL_ClearError",
+      "return_type": "bool",
+      "parameters": []
+    }
+  ]
+}

json/filesystem.json

@@ -0,0 +1,284 @@
+{
+  "header": "SDL_filesystem.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_EnumerateDirectoryCallback"
+    }
+  ],
+  "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": []
+    }
+  ]
+}

json/haptic.json

@@ -0,0 +1,798 @@
+{
+  "header": "SDL_haptic.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Haptic"
+    }
+  ],
+  "typedefs": [
+    {
+      "name": "SDL_HapticEffectType",
+      "underlying_type": "Uint16"
+    },
+    {
+      "name": "SDL_HapticDirectionType",
+      "underlying_type": "Uint8"
+    },
+    {
+      "name": "SDL_HapticEffectID",
+      "underlying_type": "int"
+    },
+    {
+      "name": "SDL_HapticID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [],
+  "structs": [
+    {
+      "name": "SDL_HapticDirection",
+      "fields": [
+        {
+          "name": "_type",
+          "type": "SDL_HapticDirectionType",
+          "comment": "The type of encoding."
+        },
+        {
+          "name": "dir",
+          "type": "Sint32[3]",
+          "comment": "The encoded direction."
+        }
+      ]
+    },
+    {
+      "name": "SDL_HapticConstant",
+      "fields": [
+        {
+          "name": "_type",
+          "type": "SDL_HapticEffectType",
+          "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": "SDL_HapticEffectType",
+          "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": "SDL_HapticEffectType",
+          "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": "SDL_HapticEffectType",
+          "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": "SDL_HapticEffectType",
+          "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": "SDL_HapticEffectID",
+      "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": "SDL_HapticEffectID"
+        },
+        {
+          "name": "data",
+          "type": "const SDL_HapticEffect *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_RunHapticEffect",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "haptic",
+          "type": "SDL_Haptic *"
+        },
+        {
+          "name": "effect",
+          "type": "SDL_HapticEffectID"
+        },
+        {
+          "name": "iterations",
+          "type": "Uint32"
+        }
+      ]
+    },
+    {
+      "name": "SDL_StopHapticEffect",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "haptic",
+          "type": "SDL_Haptic *"
+        },
+        {
+          "name": "effect",
+          "type": "SDL_HapticEffectID"
+        }
+      ]
+    },
+    {
+      "name": "SDL_DestroyHapticEffect",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "haptic",
+          "type": "SDL_Haptic *"
+        },
+        {
+          "name": "effect",
+          "type": "SDL_HapticEffectID"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetHapticEffectStatus",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "haptic",
+          "type": "SDL_Haptic *"
+        },
+        {
+          "name": "effect",
+          "type": "SDL_HapticEffectID"
+        }
+      ]
+    },
+    {
+      "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 *"
+        }
+      ]
+    }
+  ]
+}

json/hints.json

@@ -0,0 +1,139 @@
+{
+  "header": "SDL_hints.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_HintCallback"
+    }
+  ],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/init.json

@@ -0,0 +1,202 @@
+{
+  "header": "SDL_init.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_AppInit_func"
+    },
+    {
+      "name": "SDL_AppIterate_func"
+    },
+    {
+      "name": "SDL_AppEvent_func"
+    },
+    {
+      "name": "SDL_AppQuit_func"
+    },
+    {
+      "name": "SDL_MainThreadCallback"
+    }
+  ],
+  "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": "(1u << 4)",
+          "comment": "`SDL_INIT_AUDIO` implies `SDL_INIT_EVENTS`"
+        },
+        {
+          "name": "SDL_INIT_VIDEO",
+          "value": "(1u << 5)",
+          "comment": "`SDL_INIT_VIDEO` implies `SDL_INIT_EVENTS`, should be initialized on the main thread"
+        },
+        {
+          "name": "SDL_INIT_JOYSTICK",
+          "value": "(1u << 9)",
+          "comment": "`SDL_INIT_JOYSTICK` implies `SDL_INIT_EVENTS`"
+        },
+        {
+          "name": "SDL_INIT_HAPTIC",
+          "value": "(1u << 12)"
+        },
+        {
+          "name": "SDL_INIT_GAMEPAD",
+          "value": "(1u << 13)",
+          "comment": "`SDL_INIT_GAMEPAD` implies `SDL_INIT_JOYSTICK`"
+        },
+        {
+          "name": "SDL_INIT_EVENTS",
+          "value": "(1u << 14)"
+        },
+        {
+          "name": "SDL_INIT_SENSOR",
+          "value": "(1u << 15)",
+          "comment": "`SDL_INIT_SENSOR` implies `SDL_INIT_EVENTS`"
+        },
+        {
+          "name": "SDL_INIT_CAMERA",
+          "value": "(1u << 16)",
+          "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 *"
+        }
+      ]
+    }
+  ]
+}

json/joystick.json

@@ -0,0 +1,961 @@
+{
+  "header": "SDL_joystick.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Joystick"
+    }
+  ],
+  "typedefs": [
+    {
+      "name": "SDL_JoystickID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/keyboard.json

@@ -0,0 +1,332 @@
+{
+  "header": "SDL_keyboard.h",
+  "opaque_types": [],
+  "typedefs": [
+    {
+      "name": "SDL_KeyboardID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [
+    {
+      "name": "SDL_TextInputType",
+      "values": [
+        {
+          "name": "SDL_TEXTINPUT_TYPE_TEXT",
+          "comment": "The input is text"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_TEXT_NAME",
+          "comment": "The input is a person's name"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_TEXT_EMAIL",
+          "comment": "The input is an e-mail address"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_TEXT_USERNAME",
+          "comment": "The input is a username"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_HIDDEN",
+          "comment": "The input is a secure password that is hidden"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_VISIBLE",
+          "comment": "The input is a secure password that is visible"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_NUMBER",
+          "comment": "The input is a number"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_HIDDEN",
+          "comment": "The input is a secure PIN that is hidden"
+        },
+        {
+          "name": "SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_VISIBLE",
+          "comment": "The input is a secure PIN that is visible"
+        }
+      ]
+    },
+    {
+      "name": "SDL_Capitalization",
+      "values": [
+        {
+          "name": "SDL_CAPITALIZE_NONE",
+          "comment": "No auto-capitalization will be done"
+        },
+        {
+          "name": "SDL_CAPITALIZE_SENTENCES",
+          "comment": "The first letter of sentences will be capitalized"
+        },
+        {
+          "name": "SDL_CAPITALIZE_WORDS",
+          "comment": "The first letter of words will be capitalized"
+        },
+        {
+          "name": "SDL_CAPITALIZE_LETTERS",
+          "comment": "All letters will be capitalized"
+        }
+      ]
+    }
+  ],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": [
+    {
+      "name": "SDL_HasKeyboard",
+      "return_type": "bool",
+      "parameters": []
+    },
+    {
+      "name": "SDL_GetKeyboards",
+      "return_type": "SDL_KeyboardID *",
+      "parameters": [
+        {
+          "name": "count",
+          "type": "int *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetKeyboardNameForID",
+      "return_type": "const char *",
+      "parameters": [
+        {
+          "name": "instance_id",
+          "type": "SDL_KeyboardID"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetKeyboardFocus",
+      "return_type": "SDL_Window *",
+      "parameters": []
+    },
+    {
+      "name": "SDL_GetKeyboardState",
+      "return_type": "const bool *",
+      "parameters": [
+        {
+          "name": "numkeys",
+          "type": "int *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_ResetKeyboard",
+      "return_type": "void",
+      "parameters": []
+    },
+    {
+      "name": "SDL_GetModState",
+      "return_type": "SDL_Keymod",
+      "parameters": []
+    },
+    {
+      "name": "SDL_SetModState",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "modstate",
+          "type": "SDL_Keymod"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetKeyFromScancode",
+      "return_type": "SDL_Keycode",
+      "parameters": [
+        {
+          "name": "scancode",
+          "type": "SDL_Scancode"
+        },
+        {
+          "name": "modstate",
+          "type": "SDL_Keymod"
+        },
+        {
+          "name": "key_event",
+          "type": "bool"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetScancodeFromKey",
+      "return_type": "SDL_Scancode",
+      "parameters": [
+        {
+          "name": "key",
+          "type": "SDL_Keycode"
+        },
+        {
+          "name": "modstate",
+          "type": "SDL_Keymod *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetScancodeName",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "scancode",
+          "type": "SDL_Scancode"
+        },
+        {
+          "name": "name",
+          "type": "const char *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetScancodeName",
+      "return_type": "const char *",
+      "parameters": [
+        {
+          "name": "scancode",
+          "type": "SDL_Scancode"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetScancodeFromName",
+      "return_type": "SDL_Scancode",
+      "parameters": [
+        {
+          "name": "name",
+          "type": "const char *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetKeyName",
+      "return_type": "const char *",
+      "parameters": [
+        {
+          "name": "key",
+          "type": "SDL_Keycode"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetKeyFromName",
+      "return_type": "SDL_Keycode",
+      "parameters": [
+        {
+          "name": "name",
+          "type": "const char *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_StartTextInput",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_StartTextInputWithProperties",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        },
+        {
+          "name": "props",
+          "type": "SDL_PropertiesID"
+        }
+      ]
+    },
+    {
+      "name": "SDL_TextInputActive",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_StopTextInput",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_ClearComposition",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetTextInputArea",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        },
+        {
+          "name": "rect",
+          "type": "const SDL_Rect *"
+        },
+        {
+          "name": "cursor",
+          "type": "int"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTextInputArea",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        },
+        {
+          "name": "rect",
+          "type": "SDL_Rect *"
+        },
+        {
+          "name": "cursor",
+          "type": "int *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_HasScreenKeyboardSupport",
+      "return_type": "bool",
+      "parameters": []
+    },
+    {
+      "name": "SDL_ScreenKeyboardShown",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "window",
+          "type": "SDL_Window *"
+        }
+      ]
+    }
+  ]
+}

json/keycode.json

@@ -0,0 +1,21 @@
+{
+  "header": "SDL_keycode.h",
+  "opaque_types": [],
+  "typedefs": [
+    {
+      "name": "SDL_Keycode",
+      "underlying_type": "Uint32"
+    },
+    {
+      "name": "SDL_Keymod",
+      "underlying_type": "Uint16"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": []
+}

json/loadso.json

@@ -0,0 +1,51 @@
+{
+  "header": "SDL_loadso.h",
+  "opaque_types": [
+    {
+      "name": "SDL_SharedObject"
+    }
+  ],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/messagebox.json

@@ -0,0 +1,205 @@
+{
+  "header": "SDL_messagebox.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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": "(1u << 4)",
+          "comment": "error dialog"
+        },
+        {
+          "name": "SDL_MESSAGEBOX_WARNING",
+          "value": "(1u << 5)",
+          "comment": "warning dialog"
+        },
+        {
+          "name": "SDL_MESSAGEBOX_INFORMATION",
+          "value": "(1u << 6)",
+          "comment": "informational dialog"
+        },
+        {
+          "name": "SDL_MESSAGEBOX_BUTTONS_LEFT_TO_RIGHT",
+          "value": "(1u << 7)",
+          "comment": "buttons placed left to right"
+        },
+        {
+          "name": "SDL_MESSAGEBOX_BUTTONS_RIGHT_TO_LEFT",
+          "value": "(1u << 8)",
+          "comment": "buttons placed right to left"
+        }
+      ]
+    },
+    {
+      "name": "SDL_MessageBoxButtonFlags",
+      "underlying_type": "Uint32",
+      "values": [
+        {
+          "name": "SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT",
+          "value": "(1u << 0)",
+          "comment": "Marks the default button when return is hit"
+        },
+        {
+          "name": "SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT",
+          "value": "(1u << 1)",
+          "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 *"
+        }
+      ]
+    }
+  ]
+}

json/misc.json

@@ -0,0 +1,23 @@
+{
+  "header": "SDL_misc.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": [
+    {
+      "name": "SDL_OpenURL",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "url",
+          "type": "const char *"
+        }
+      ]
+    }
+  ]
+}

json/mouse.json

@@ -0,0 +1,440 @@
+{
+  "header": "SDL_mouse.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Cursor"
+    }
+  ],
+  "typedefs": [
+    {
+      "name": "SDL_MouseID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_MouseMotionTransformCallback"
+    }
+  ],
+  "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": [
+    {
+      "name": "SDL_CursorFrameInfo",
+      "fields": [
+        {
+          "name": "surface",
+          "type": "SDL_Surface *",
+          "comment": "The surface data for this frame"
+        },
+        {
+          "name": "duration",
+          "type": "Uint32",
+          "comment": "The frame duration in milliseconds (a duration of 0 is infinite)"
+        }
+      ]
+    }
+  ],
+  "unions": [],
+  "flags": [
+    {
+      "name": "SDL_MouseButtonFlags",
+      "underlying_type": "Uint32",
+      "values": [
+        {
+          "name": "SDL_BUTTON_LEFT",
+          "value": "(1u << 0)"
+        },
+        {
+          "name": "SDL_BUTTON_MIDDLE",
+          "value": "(1u << 1)"
+        },
+        {
+          "name": "SDL_BUTTON_X1",
+          "value": "(1u << 2)"
+        }
+      ]
+    }
+  ],
+  "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_SetRelativeMouseTransform",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "callback",
+          "type": "SDL_MouseMotionTransformCallback"
+        },
+        {
+          "name": "userdata",
+          "type": "void *"
+        }
+      ]
+    },
+    {
+      "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_CreateAnimatedCursor",
+      "return_type": "SDL_Cursor *",
+      "parameters": [
+        {
+          "name": "frames",
+          "type": "SDL_CursorFrameInfo *"
+        },
+        {
+          "name": "frame_count",
+          "type": "int"
+        },
+        {
+          "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": []
+    }
+  ]
+}

json/opengl.json

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

json/pixels.json

@@ -0,0 +1,921 @@
+{
+  "header": "SDL_pixels.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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_BT601_LIMITED",
+          "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": "pixelvalue",
+          "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": "pixelvalue",
+          "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 *"
+        }
+      ]
+    }
+  ]
+}

json/power.json

@@ -0,0 +1,57 @@
+{
+  "header": "SDL_power.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [
+    {
+      "name": "SDL_PowerState",
+      "values": [
+        {
+          "name": "SDL_POWERSTATE_ERROR",
+          "value": "-1",
+          "comment": "error determining power status"
+        },
+        {
+          "name": "SDL_POWERSTATE_UNKNOWN",
+          "comment": "cannot determine power status"
+        },
+        {
+          "name": "SDL_POWERSTATE_ON_BATTERY",
+          "comment": "Not plugged in, running on the battery"
+        },
+        {
+          "name": "SDL_POWERSTATE_NO_BATTERY",
+          "comment": "Plugged in, no battery available"
+        },
+        {
+          "name": "SDL_POWERSTATE_CHARGING",
+          "comment": "Plugged in, charging battery"
+        },
+        {
+          "name": "SDL_POWERSTATE_CHARGED"
+        }
+      ]
+    }
+  ],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": [
+    {
+      "name": "SDL_GetPowerInfo",
+      "return_type": "SDL_PowerState",
+      "parameters": [
+        {
+          "name": "seconds",
+          "type": "int *"
+        },
+        {
+          "name": "percent",
+          "type": "int *"
+        }
+      ]
+    }
+  ]
+}

json/process.json

@@ -0,0 +1,153 @@
+{
+  "header": "SDL_process.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Process"
+    }
+  ],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [
+    {
+      "name": "SDL_ProcessIO",
+      "values": [
+        {
+          "name": "SDL_PROCESS_STDIO_INHERITED",
+          "comment": "The I/O stream is inherited from the application."
+        },
+        {
+          "name": "SDL_PROCESS_STDIO_NULL",
+          "comment": "The I/O stream is ignored."
+        },
+        {
+          "name": "SDL_PROCESS_STDIO_APP",
+          "comment": "The I/O stream is connected to a new SDL_IOStream that the application can read or write"
+        },
+        {
+          "name": "SDL_PROCESS_STDIO_REDIRECT",
+          "comment": "The I/O stream is redirected to an existing SDL_IOStream."
+        }
+      ]
+    }
+  ],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": [
+    {
+      "name": "SDL_CreateProcess",
+      "return_type": "SDL_Process *",
+      "parameters": [
+        {
+          "name": "args",
+          "type": "const char * const *"
+        },
+        {
+          "name": "pipe_stdio",
+          "type": "bool"
+        }
+      ]
+    },
+    {
+      "name": "SDL_CreateProcessWithProperties",
+      "return_type": "SDL_Process *",
+      "parameters": [
+        {
+          "name": "props",
+          "type": "SDL_PropertiesID"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetProcessProperties",
+      "return_type": "SDL_PropertiesID",
+      "parameters": [
+        {
+          "name": "process",
+          "type": "SDL_Process *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_ReadProcess",
+      "return_type": "void *",
+      "parameters": [
+        {
+          "name": "process",
+          "type": "SDL_Process *"
+        },
+        {
+          "name": "datasize",
+          "type": "size_t *"
+        },
+        {
+          "name": "exitcode",
+          "type": "int *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetProcessInput",
+      "return_type": "SDL_IOStream *",
+      "parameters": [
+        {
+          "name": "process",
+          "type": "SDL_Process *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetProcessOutput",
+      "return_type": "SDL_IOStream *",
+      "parameters": [
+        {
+          "name": "process",
+          "type": "SDL_Process *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_KillProcess",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "process",
+          "type": "SDL_Process *"
+        },
+        {
+          "name": "force",
+          "type": "bool"
+        }
+      ]
+    },
+    {
+      "name": "SDL_WaitProcess",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "process",
+          "type": "SDL_Process *"
+        },
+        {
+          "name": "block",
+          "type": "bool"
+        },
+        {
+          "name": "exitcode",
+          "type": "int *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_DestroyProcess",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "process",
+          "type": "SDL_Process *"
+        }
+      ]
+    }
+  ]
+}

json/properties.json

@@ -0,0 +1,369 @@
+{
+  "header": "SDL_properties.h",
+  "opaque_types": [],
+  "typedefs": [
+    {
+      "name": "SDL_PropertiesID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_CleanupPropertyCallback"
+    },
+    {
+      "name": "SDL_EnumeratePropertiesCallback"
+    }
+  ],
+  "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"
+        }
+      ]
+    }
+  ]
+}

json/rect.json

@@ -0,0 +1,278 @@
+{
+  "header": "SDL_rect.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/scancode.json

@@ -0,0 +1,355 @@
+{
+  "header": "SDL_scancode.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [
+    {
+      "name": "SDL_Scancode",
+      "values": [
+        {
+          "name": "SDL_SCANCODE_BACKSLASH",
+          "value": "49"
+        },
+        {
+          "name": "SDL_SCANCODE_NONUSHASH",
+          "value": "50"
+        },
+        {
+          "name": "SDL_SCANCODE_GRAVE",
+          "value": "53"
+        },
+        {
+          "name": "SDL_SCANCODE_INSERT",
+          "value": "73"
+        },
+        {
+          "name": "SDL_SCANCODE_NUMLOCKCLEAR",
+          "value": "83"
+        },
+        {
+          "name": "SDL_SCANCODE_NONUSBACKSLASH",
+          "value": "100"
+        },
+        {
+          "name": "SDL_SCANCODE_APPLICATION",
+          "value": "101",
+          "comment": "windows contextual menu, compose"
+        },
+        {
+          "name": "SDL_SCANCODE_POWER",
+          "value": "102"
+        },
+        {
+          "name": "SDL_SCANCODE_HELP",
+          "value": "117",
+          "comment": "AL Integrated Help Center"
+        },
+        {
+          "name": "SDL_SCANCODE_MENU",
+          "value": "118",
+          "comment": "Menu (show menu)"
+        },
+        {
+          "name": "SDL_SCANCODE_STOP",
+          "value": "120",
+          "comment": "AC Stop"
+        },
+        {
+          "name": "SDL_SCANCODE_AGAIN",
+          "value": "121",
+          "comment": "AC Redo/Repeat"
+        },
+        {
+          "name": "SDL_SCANCODE_UNDO",
+          "value": "122",
+          "comment": "AC Undo"
+        },
+        {
+          "name": "SDL_SCANCODE_CUT",
+          "value": "123",
+          "comment": "AC Cut"
+        },
+        {
+          "name": "SDL_SCANCODE_COPY",
+          "value": "124",
+          "comment": "AC Copy"
+        },
+        {
+          "name": "SDL_SCANCODE_PASTE",
+          "value": "125",
+          "comment": "AC Paste"
+        },
+        {
+          "name": "SDL_SCANCODE_FIND",
+          "value": "126",
+          "comment": "AC Find"
+        },
+        {
+          "name": "SDL_SCANCODE_INTERNATIONAL1",
+          "value": "135"
+        },
+        {
+          "name": "SDL_SCANCODE_INTERNATIONAL3",
+          "value": "137",
+          "comment": "Yen"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG1",
+          "value": "144",
+          "comment": "Hangul/English toggle"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG2",
+          "value": "145",
+          "comment": "Hanja conversion"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG3",
+          "value": "146",
+          "comment": "Katakana"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG4",
+          "value": "147",
+          "comment": "Hiragana"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG5",
+          "value": "148",
+          "comment": "Zenkaku/Hankaku"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG6",
+          "value": "149",
+          "comment": "reserved"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG7",
+          "value": "150",
+          "comment": "reserved"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG8",
+          "value": "151",
+          "comment": "reserved"
+        },
+        {
+          "name": "SDL_SCANCODE_LANG9",
+          "value": "152",
+          "comment": "reserved"
+        },
+        {
+          "name": "SDL_SCANCODE_ALTERASE",
+          "value": "153",
+          "comment": "Erase-Eaze"
+        },
+        {
+          "name": "SDL_SCANCODE_CANCEL",
+          "value": "155",
+          "comment": "AC Cancel"
+        },
+        {
+          "name": "SDL_SCANCODE_LALT",
+          "value": "226",
+          "comment": "alt, option"
+        },
+        {
+          "name": "SDL_SCANCODE_LGUI",
+          "value": "227",
+          "comment": "windows, command (apple), meta"
+        },
+        {
+          "name": "SDL_SCANCODE_RALT",
+          "value": "230",
+          "comment": "alt gr, option"
+        },
+        {
+          "name": "SDL_SCANCODE_RGUI",
+          "value": "231",
+          "comment": "windows, command (apple), meta"
+        },
+        {
+          "name": "SDL_SCANCODE_MODE",
+          "value": "257"
+        },
+        {
+          "name": "SDL_SCANCODE_SLEEP",
+          "value": "258",
+          "comment": "Sleep"
+        },
+        {
+          "name": "SDL_SCANCODE_WAKE",
+          "value": "259",
+          "comment": "Wake"
+        },
+        {
+          "name": "SDL_SCANCODE_CHANNEL_INCREMENT",
+          "value": "260",
+          "comment": "Channel Increment"
+        },
+        {
+          "name": "SDL_SCANCODE_CHANNEL_DECREMENT",
+          "value": "261",
+          "comment": "Channel Decrement"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_PLAY",
+          "value": "262",
+          "comment": "Play"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_PAUSE",
+          "value": "263",
+          "comment": "Pause"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_RECORD",
+          "value": "264",
+          "comment": "Record"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_FAST_FORWARD",
+          "value": "265",
+          "comment": "Fast Forward"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_REWIND",
+          "value": "266",
+          "comment": "Rewind"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_NEXT_TRACK",
+          "value": "267",
+          "comment": "Next Track"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_PREVIOUS_TRACK",
+          "value": "268",
+          "comment": "Previous Track"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_STOP",
+          "value": "269",
+          "comment": "Stop"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_EJECT",
+          "value": "270",
+          "comment": "Eject"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_PLAY_PAUSE",
+          "value": "271",
+          "comment": "Play / Pause"
+        },
+        {
+          "name": "SDL_SCANCODE_MEDIA_SELECT",
+          "value": "272"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_NEW",
+          "value": "273",
+          "comment": "AC New"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_OPEN",
+          "value": "274",
+          "comment": "AC Open"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_CLOSE",
+          "value": "275",
+          "comment": "AC Close"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_EXIT",
+          "value": "276",
+          "comment": "AC Exit"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_SAVE",
+          "value": "277",
+          "comment": "AC Save"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_PRINT",
+          "value": "278",
+          "comment": "AC Print"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_PROPERTIES",
+          "value": "279",
+          "comment": "AC Properties"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_SEARCH",
+          "value": "280",
+          "comment": "AC Search"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_HOME",
+          "value": "281",
+          "comment": "AC Home"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_BACK",
+          "value": "282",
+          "comment": "AC Back"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_FORWARD",
+          "value": "283",
+          "comment": "AC Forward"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_STOP",
+          "value": "284",
+          "comment": "AC Stop"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_REFRESH",
+          "value": "285",
+          "comment": "AC Refresh"
+        },
+        {
+          "name": "SDL_SCANCODE_AC_BOOKMARKS",
+          "value": "286",
+          "comment": "AC Bookmarks"
+        },
+        {
+          "name": "SDL_SCANCODE_SOFTLEFT",
+          "value": "287"
+        },
+        {
+          "name": "SDL_SCANCODE_SOFTRIGHT",
+          "value": "288"
+        },
+        {
+          "name": "SDL_SCANCODE_CALL",
+          "value": "289",
+          "comment": "Used for accepting phone calls."
+        },
+        {
+          "name": "SDL_SCANCODE_ENDCALL",
+          "value": "290",
+          "comment": "Used for rejecting phone calls."
+        },
+        {
+          "name": "SDL_SCANCODE_RESERVED",
+          "value": "400",
+          "comment": "400-500 reserved for dynamic keycodes"
+        },
+        {
+          "name": "SDL_SCANCODE_COUNT",
+          "value": "512"
+        }
+      ]
+    }
+  ],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": []
+}

json/sensor.json

@@ -0,0 +1,207 @@
+{
+  "header": "SDL_sensor.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Sensor"
+    }
+  ],
+  "typedefs": [
+    {
+      "name": "SDL_SensorID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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"
+        },
+        {
+          "name": "SDL_SENSOR_COUNT"
+        }
+      ]
+    }
+  ],
+  "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": []
+    }
+  ]
+}

json/storage.json

@@ -0,0 +1,349 @@
+{
+  "header": "SDL_storage.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Storage"
+    }
+  ],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/system.json

@@ -0,0 +1,355 @@
+{
+  "header": "SDL_system.h",
+  "opaque_types": [
+    {
+      "name": "MSG"
+    }
+  ],
+  "typedefs": [
+    {
+      "name": "XTaskQueueHandle",
+      "underlying_type": "struct XTaskQueueObject *"
+    },
+    {
+      "name": "XUserHandle",
+      "underlying_type": "struct XUser *"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_WindowsMessageHook"
+    },
+    {
+      "name": "SDL_X11EventHook"
+    },
+    {
+      "name": "SDL_iOSAnimationCallback"
+    },
+    {
+      "name": "SDL_RequestAndroidPermissionCallback"
+    }
+  ],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/time.json

@@ -0,0 +1,238 @@
+{
+  "header": "SDL_time.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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"
+        }
+      ]
+    }
+  ]
+}

json/timer.json

@@ -0,0 +1,121 @@
+{
+  "header": "SDL_timer.h",
+  "opaque_types": [],
+  "typedefs": [
+    {
+      "name": "SDL_TimerID",
+      "underlying_type": "Uint32"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_TimerCallback"
+    },
+    {
+      "name": "SDL_NSTimerCallback"
+    }
+  ],
+  "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"
+        }
+      ]
+    }
+  ]
+}

json/touch.json

@@ -0,0 +1,110 @@
+{
+  "header": "SDL_touch.h",
+  "opaque_types": [],
+  "typedefs": [
+    {
+      "name": "SDL_TouchID",
+      "underlying_type": "Uint64"
+    },
+    {
+      "name": "SDL_FingerID",
+      "underlying_type": "Uint64"
+    }
+  ],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "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 *"
+        }
+      ]
+    }
+  ]
+}

json/tray.json

@@ -0,0 +1,332 @@
+{
+  "header": "SDL_tray.h",
+  "opaque_types": [
+    {
+      "name": "SDL_Tray"
+    },
+    {
+      "name": "SDL_TrayMenu"
+    },
+    {
+      "name": "SDL_TrayEntry"
+    }
+  ],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [
+    {
+      "name": "SDL_TrayCallback"
+    }
+  ],
+  "enums": [],
+  "structs": [],
+  "unions": [],
+  "flags": [
+    {
+      "name": "SDL_TrayEntryFlags",
+      "underlying_type": "Uint32",
+      "values": [
+        {
+          "name": "SDL_TRAYENTRY_BUTTON",
+          "value": "(1u << 0)",
+          "comment": "Make the entry a simple button. Required."
+        },
+        {
+          "name": "SDL_TRAYENTRY_CHECKBOX",
+          "value": "(1u << 1)",
+          "comment": "Make the entry a checkbox. Required."
+        },
+        {
+          "name": "SDL_TRAYENTRY_SUBMENU",
+          "value": "(1u << 2)",
+          "comment": "Prepare the entry to have a submenu. Required"
+        },
+        {
+          "name": "SDL_TRAYENTRY_DISABLED",
+          "value": "(1u << 31)",
+          "comment": "Make the entry disabled. Optional."
+        },
+        {
+          "name": "SDL_TRAYENTRY_CHECKED",
+          "value": "(1u << 30)",
+          "comment": "Make the entry checked. This is valid only for checkboxes. Optional."
+        }
+      ]
+    }
+  ],
+  "functions": [
+    {
+      "name": "SDL_CreateTray",
+      "return_type": "SDL_Tray *",
+      "parameters": [
+        {
+          "name": "icon",
+          "type": "SDL_Surface *"
+        },
+        {
+          "name": "tooltip",
+          "type": "const char *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetTrayIcon",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "tray",
+          "type": "SDL_Tray *"
+        },
+        {
+          "name": "icon",
+          "type": "SDL_Surface *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetTrayTooltip",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "tray",
+          "type": "SDL_Tray *"
+        },
+        {
+          "name": "tooltip",
+          "type": "const char *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_CreateTrayMenu",
+      "return_type": "SDL_TrayMenu *",
+      "parameters": [
+        {
+          "name": "tray",
+          "type": "SDL_Tray *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_CreateTraySubmenu",
+      "return_type": "SDL_TrayMenu *",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayMenu",
+      "return_type": "SDL_TrayMenu *",
+      "parameters": [
+        {
+          "name": "tray",
+          "type": "SDL_Tray *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTraySubmenu",
+      "return_type": "SDL_TrayMenu *",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayEntries",
+      "return_type": "const SDL_TrayEntry **",
+      "parameters": [
+        {
+          "name": "menu",
+          "type": "SDL_TrayMenu *"
+        },
+        {
+          "name": "count",
+          "type": "int *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_RemoveTrayEntry",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_InsertTrayEntryAt",
+      "return_type": "SDL_TrayEntry *",
+      "parameters": [
+        {
+          "name": "menu",
+          "type": "SDL_TrayMenu *"
+        },
+        {
+          "name": "pos",
+          "type": "int"
+        },
+        {
+          "name": "label",
+          "type": "const char *"
+        },
+        {
+          "name": "flags",
+          "type": "SDL_TrayEntryFlags"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetTrayEntryLabel",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        },
+        {
+          "name": "label",
+          "type": "const char *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayEntryLabel",
+      "return_type": "const char *",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetTrayEntryChecked",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        },
+        {
+          "name": "checked",
+          "type": "bool"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayEntryChecked",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetTrayEntryEnabled",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        },
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayEntryEnabled",
+      "return_type": "bool",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_SetTrayEntryCallback",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        },
+        {
+          "name": "callback",
+          "type": "SDL_TrayCallback"
+        },
+        {
+          "name": "userdata",
+          "type": "void *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_ClickTrayEntry",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_DestroyTray",
+      "return_type": "void",
+      "parameters": [
+        {
+          "name": "tray",
+          "type": "SDL_Tray *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayEntryParent",
+      "return_type": "SDL_TrayMenu *",
+      "parameters": [
+        {
+          "name": "entry",
+          "type": "SDL_TrayEntry *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayMenuParentEntry",
+      "return_type": "SDL_TrayEntry *",
+      "parameters": [
+        {
+          "name": "menu",
+          "type": "SDL_TrayMenu *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_GetTrayMenuParentTray",
+      "return_type": "SDL_Tray *",
+      "parameters": [
+        {
+          "name": "menu",
+          "type": "SDL_TrayMenu *"
+        }
+      ]
+    },
+    {
+      "name": "SDL_UpdateTrays",
+      "return_type": "void",
+      "parameters": []
+    }
+  ]
+}

json/version.json

@@ -0,0 +1,23 @@
+{
+  "header": "SDL_version.h",
+  "opaque_types": [],
+  "typedefs": [],
+  "function_pointers": [],
+  "c_type_aliases": [],
+  "enums": [],
+  "structs": [],
+  "unions": [],
+  "flags": [],
+  "functions": [
+    {
+      "name": "SDL_GetVersion",
+      "return_type": "int",
+      "parameters": []
+    },
+    {
+      "name": "SDL_GetRevision",
+      "return_type": "const char *",
+      "parameters": []
+    }
+  ]
+}

src/header_cache.zig

@@ -1,37 +1,48 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const patterns = @import("patterns.zig");
+const resolved_decl = @import("resolved_decl.zig");
+
 const Declaration = patterns.Declaration;
+const ResolvedDecl = resolved_decl.ResolvedDecl;
+
+const CachedDecl = struct {
+    decl: Declaration,
+    source_header: []const u8,
+
+    fn deinit(self: CachedDecl, allocator: Allocator) void {
+        switch (self.decl) {
+            inline else => |*d| d.deinit(allocator),
+        }
+        allocator.free(self.source_header);
+    }
+};
 
 pub const HeaderCache = struct {
-    // Map from type name to its declaration
-    type_cache: std.StringHashMap(Declaration),
-    // Track which headers we've already parsed (avoid re-parsing)
+    type_cache: std.StringHashMap(CachedDecl),
     parsed_headers: std.StringHashMap(void),
     allocator: Allocator,
 
     pub fn init(allocator: Allocator) HeaderCache {
         return .{
-            .type_cache = std.StringHashMap(Declaration).init(allocator),
+            .type_cache = std.StringHashMap(CachedDecl).init(allocator),
             .parsed_headers = std.StringHashMap(void).init(allocator),
             .allocator = allocator,
         };
     }
 
     pub fn deinit(self: *HeaderCache) void {
-        // Free type cache keys
         var type_it = self.type_cache.keyIterator();
         while (type_it.next()) |key| {
             self.allocator.free(key.*);
         }
-        // Free cached declarations
+
         var val_it = self.type_cache.valueIterator();
-        while (val_it.next()) |decl| {
-            freeDeclaration(self.allocator, decl.*);
+        while (val_it.next()) |cached_decl| {
+            cached_decl.deinit(self.allocator);
         }
         self.type_cache.deinit();
 
-        // Free parsed headers keys
         var header_it = self.parsed_headers.keyIterator();
         while (header_it.next()) |key| {
             self.allocator.free(key.*);
@@ -45,31 +56,20 @@ pub const HeaderCache = struct {
 
         const header_dir = std.fs.path.dirname(header_path) orelse ".";
         try cache.parseHeaderRecursive(header_dir, std.fs.path.basename(header_path));
-
         return cache;
     }
 
     fn parseHeaderRecursive(self: *HeaderCache, header_dir: []const u8, filename: []const u8) !void {
-        // Skip non-SDL headers (stdlib, system headers, etc)
-        if (!std.mem.startsWith(u8, filename, "SDL_")) {
-            return;
-        }
+        if (!std.mem.startsWith(u8, filename, "SDL_")) return;
+        if (self.parsed_headers.contains(filename)) return;
 
-        // Skip if already parsed
-        if (self.parsed_headers.contains(filename)) {
-            return;
-        }
-
-        // Mark as parsed
         try self.parsed_headers.put(try self.allocator.dupe(u8, filename), {});
 
-        // Build full path
-        const full_path = try std.fs.path.join(self.allocator, &[_][]const u8{ header_dir, filename });
+        const full_path = try std.fs.path.join(self.allocator, &.{ header_dir, filename });
         defer self.allocator.free(full_path);
 
         std.debug.print("  Caching types from: {s}\n", .{filename});
 
-        // Read and parse this header
         const content = std.fs.cwd().readFileAlloc(self.allocator, full_path, 10_000_000) catch |err| {
             std.debug.print("  Warning: Could not read {s}: {}\n", .{ filename, err });
             return;
@@ -83,25 +83,24 @@ pub const HeaderCache = struct {
         };
         defer self.allocator.free(decls);
 
-        // Add all type definitions to cache
         for (decls) |decl| {
-            const type_name = getTypeName(decl);
+            const type_name = resolved_decl.getTypeName(decl);
             if (type_name) |name| {
-                // Don't cache if already present (first occurrence wins)
                 if (!self.type_cache.contains(name)) {
-                    const name_copy = try self.allocator.dupe(u8, name);
-                    const decl_copy = try cloneDeclaration(self.allocator, decl);
-                    try self.type_cache.put(name_copy, decl_copy);
+                    try self.type_cache.put(try self.allocator.dupe(u8, name), .{
+                        .decl = try resolved_decl.cloneDeclaration(self.allocator, decl),
+                        .source_header = try self.allocator.dupe(u8, filename),
+                    });
                 }
             }
         }
 
-        // Free the original declarations (we made copies)
         for (decls) |decl| {
-            freeDeclaration(self.allocator, decl);
+            switch (decl) {
+                inline else => |*d| d.deinit(self.allocator),
+            }
         }
 
-        // Find and recursively parse all #include "SDL_*.h" directives
         const includes = try findSDLIncludes(self.allocator, content);
         defer {
             for (includes) |inc| self.allocator.free(inc);
@@ -114,25 +113,21 @@ pub const HeaderCache = struct {
     }
 
     pub fn lookupType(self: *HeaderCache, type_name: []const u8) ?Declaration {
-        const decl = self.type_cache.get(type_name) orelse return null;
-        // Return a copy so caller owns it
-        return cloneDeclaration(self.allocator, decl) catch null;
+        const cached_decl = self.type_cache.get(type_name) orelse return null;
+        return resolved_decl.cloneDeclaration(self.allocator, cached_decl.decl) catch null;
     }
 
-    /// Lookup a type and recursively resolve all its dependencies
-    /// Returns an array of declarations: [0] is the requested type, [1..] are dependencies
-    pub fn lookupTypeWithDependencies(self: *HeaderCache, type_name: []const u8) ![]Declaration {
+    pub fn lookupTypeWithDependencies(self: *HeaderCache, type_name: []const u8) ![]ResolvedDecl {
         const dependency_resolver = @import("dependency_resolver.zig");
 
-        var result = try std.ArrayList(Declaration).initCapacity(self.allocator, 10);
+        var result = try std.ArrayList(ResolvedDecl).initCapacity(self.allocator, 10);
         errdefer {
             for (result.items) |decl| {
-                freeDeclaration(self.allocator, decl);
+                decl.deinit(self.allocator);
             }
             result.deinit(self.allocator);
         }
 
-        // Track which types we've already processed
         var processed = std.StringHashMap(void).init(self.allocator);
         defer {
             var it = processed.keyIterator();
@@ -142,7 +137,6 @@ pub const HeaderCache = struct {
             processed.deinit();
         }
 
-        // Work queue for types to resolve
         var queue = try std.ArrayList([]const u8).initCapacity(self.allocator, 10);
         defer {
             for (queue.items) |item| {
@@ -151,30 +145,27 @@ pub const HeaderCache = struct {
             queue.deinit(self.allocator);
         }
 
-        // Start with the requested type
         try queue.append(self.allocator, try self.allocator.dupe(u8, type_name));
 
-        // Process queue until empty
         while (queue.items.len > 0) {
             const current_type = queue.orderedRemove(0);
             defer self.allocator.free(current_type);
 
-            // Skip if already processed
             if (processed.contains(current_type)) continue;
             try processed.put(try self.allocator.dupe(u8, current_type), {});
 
-            // Look up the type
-            const decl = self.type_cache.get(current_type) orelse continue;
+            const cached_decl = self.type_cache.get(current_type) orelse continue;
 
-            // Add cloned declaration to result
-            const decl_copy = try cloneDeclaration(self.allocator, decl);
-            try result.append(self.allocator, decl_copy);
+            try result.append(self.allocator, .{
+                .decl = try resolved_decl.cloneDeclaration(self.allocator, cached_decl.decl),
+                .source_header = try self.allocator.dupe(u8, cached_decl.source_header),
+                .is_primary_header_decl = false,
+            });
 
-            // Analyze this declaration to find its dependencies
             var resolver = dependency_resolver.DependencyResolver.init(self.allocator);
             defer resolver.deinit();
 
-            const single_decl = [_]Declaration{decl};
+            const single_decl = [_]Declaration{cached_decl.decl};
             try resolver.analyze(&single_decl);
 
             const missing = try resolver.getMissingTypes(self.allocator);
@@ -183,7 +174,6 @@ pub const HeaderCache = struct {
                 self.allocator.free(missing);
             }
 
-            // Add missing types to queue if not already processed
             for (missing) |missing_type| {
                 if (!processed.contains(missing_type) and self.type_cache.contains(missing_type)) {
                     try queue.append(self.allocator, try self.allocator.dupe(u8, missing_type));
@@ -194,22 +184,8 @@ pub const HeaderCache = struct {
         return try result.toOwnedSlice(self.allocator);
     }
 
-    fn getTypeName(decl: Declaration) ?[]const u8 {
-        return switch (decl) {
-            .opaque_type => |o| o.name,
-            .typedef_decl => |t| t.name,
-            .function_pointer_decl => |fp| fp.name,
-            .c_type_alias => |a| a.name,
-            .enum_decl => |e| e.name,
-            .struct_decl => |s| s.name,
-            .union_decl => |u| u.name,
-            .flag_decl => |f| f.name,
-            .function_decl => null, // Functions don't define types
-        };
-    }
-
     fn findSDLIncludes(allocator: Allocator, source: []const u8) ![][]const u8 {
-        var includes = std.ArrayList([]const u8){};
+        var includes: std.ArrayList([]const u8) = .empty;
         errdefer {
             for (includes.items) |inc| allocator.free(inc);
             includes.deinit(allocator);
@@ -219,7 +195,6 @@ pub const HeaderCache = struct {
         while (lines.next()) |line| {
             const trimmed = std.mem.trim(u8, line, " \t\r");
 
-            // Match: #include <SDL3/SDL_something.h>
             if (std.mem.startsWith(u8, trimmed, "#include <SDL3/")) {
                 const after_open = "#include <SDL3/".len;
                 if (std.mem.indexOf(u8, trimmed[after_open..], ">")) |end| {
@@ -228,9 +203,7 @@ pub const HeaderCache = struct {
                         try includes.append(allocator, try allocator.dupe(u8, header_name));
                     }
                 }
-            }
-            // Also match: #include "SDL_something.h"
-            else if (std.mem.startsWith(u8, trimmed, "#include \"SDL_")) {
+            } else if (std.mem.startsWith(u8, trimmed, "#include \"SDL_")) {
                 const after_open = "#include \"".len;
                 if (std.mem.indexOf(u8, trimmed[after_open..], "\"")) |end| {
                     const header_name = trimmed[after_open..][0..end];
@@ -244,212 +217,3 @@ pub const HeaderCache = struct {
         return try includes.toOwnedSlice(allocator);
     }
 };
-
-fn cloneDeclaration(allocator: Allocator, decl: Declaration) !Declaration {
-    return switch (decl) {
-        .opaque_type => |o| Declaration{
-            .opaque_type = .{
-                .name = try allocator.dupe(u8, o.name),
-                .doc_comment = if (o.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-        .typedef_decl => |t| Declaration{
-            .typedef_decl = .{
-                .name = try allocator.dupe(u8, t.name),
-                .underlying_type = try allocator.dupe(u8, t.underlying_type),
-                .doc_comment = if (t.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-        .enum_decl => |e| Declaration{
-            .enum_decl = .{
-                .name = try allocator.dupe(u8, e.name),
-                .values = try cloneEnumValues(allocator, e.values),
-                .doc_comment = if (e.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-        .struct_decl => |s| Declaration{
-            .struct_decl = .{
-                .name = try allocator.dupe(u8, s.name),
-                .fields = try cloneFields(allocator, s.fields),
-                .doc_comment = if (s.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-                .has_unions = s.has_unions,
-            },
-        },
-        .union_decl => |u| Declaration{
-            .union_decl = .{
-                .name = try allocator.dupe(u8, u.name),
-                .fields = try cloneFields(allocator, u.fields),
-                .doc_comment = if (u.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-        .flag_decl => |f| Declaration{
-            .flag_decl = .{
-                .name = try allocator.dupe(u8, f.name),
-                .underlying_type = try allocator.dupe(u8, f.underlying_type),
-                .flags = try cloneFlagValues(allocator, f.flags),
-                .constants = try cloneConstValues(allocator, f.constants),
-                .doc_comment = if (f.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-        .function_decl => |func| Declaration{
-            .function_decl = .{
-                .name = try allocator.dupe(u8, func.name),
-                .return_type = try allocator.dupe(u8, func.return_type),
-                .params = try cloneParams(allocator, func.params),
-                .doc_comment = if (func.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-        .function_pointer_decl => |fp| Declaration{
-            .function_pointer_decl = .{
-                .name = try allocator.dupe(u8, fp.name),
-                .return_type = try allocator.dupe(u8, fp.return_type),
-                .params = try cloneParams(allocator, fp.params),
-                .doc_comment = if (fp.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-        .c_type_alias => |a| Declaration{
-            .c_type_alias = .{
-                .name = try allocator.dupe(u8, a.name),
-                .doc_comment = if (a.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
-            },
-        },
-    };
-}
-
-fn cloneEnumValues(allocator: Allocator, values: []const patterns.EnumValue) ![]patterns.EnumValue {
-    const new_values = try allocator.alloc(patterns.EnumValue, values.len);
-    for (values, 0..) |val, i| {
-        new_values[i] = .{
-            .name = try allocator.dupe(u8, val.name),
-            .value = if (val.value) |v| try allocator.dupe(u8, v) else null,
-            .comment = if (val.comment) |c| try allocator.dupe(u8, c) else null,
-        };
-    }
-    return new_values;
-}
-
-fn cloneFlagValues(allocator: Allocator, flags: []const patterns.FlagValue) ![]patterns.FlagValue {
-    const new_flags = try allocator.alloc(patterns.FlagValue, flags.len);
-    for (flags, 0..) |flag, i| {
-        new_flags[i] = .{
-            .name = try allocator.dupe(u8, flag.name),
-            .value = try allocator.dupe(u8, flag.value),
-            .comment = if (flag.comment) |c| try allocator.dupe(u8, c) else null,
-        };
-    }
-    return new_flags;
-}
-
-fn cloneConstValues(allocator: Allocator, constants: []const patterns.ConstValue) ![]patterns.ConstValue {
-    const new_constants = try allocator.alloc(patterns.ConstValue, constants.len);
-    for (constants, 0..) |constant, i| {
-        new_constants[i] = .{
-            .name = try allocator.dupe(u8, constant.name),
-            .value = try allocator.dupe(u8, constant.value),
-            .comment = if (constant.comment) |c| try allocator.dupe(u8, c) else null,
-        };
-    }
-    return new_constants;
-}
-
-fn cloneFields(allocator: Allocator, fields: []const patterns.FieldDecl) ![]patterns.FieldDecl {
-    const new_fields = try allocator.alloc(patterns.FieldDecl, fields.len);
-    for (fields, 0..) |field, i| {
-        new_fields[i] = .{
-            .name = try allocator.dupe(u8, field.name),
-            .type_name = try allocator.dupe(u8, field.type_name),
-            .comment = if (field.comment) |c| try allocator.dupe(u8, c) else null,
-        };
-    }
-    return new_fields;
-}
-
-fn cloneParams(allocator: Allocator, params: []const patterns.ParamDecl) ![]patterns.ParamDecl {
-    const new_params = try allocator.alloc(patterns.ParamDecl, params.len);
-    for (params, 0..) |param, i| {
-        new_params[i] = .{
-            .name = try allocator.dupe(u8, param.name),
-            .type_name = try allocator.dupe(u8, param.type_name),
-        };
-    }
-    return new_params;
-}
-
-fn freeDeclaration(allocator: Allocator, decl: Declaration) void {
-    switch (decl) {
-        .opaque_type => |o| {
-            allocator.free(o.name);
-            if (o.doc_comment) |doc| allocator.free(doc);
-        },
-        .typedef_decl => |t| {
-            allocator.free(t.name);
-            allocator.free(t.underlying_type);
-            if (t.doc_comment) |doc| allocator.free(doc);
-        },
-        .enum_decl => |e| {
-            allocator.free(e.name);
-            for (e.values) |val| {
-                allocator.free(val.name);
-                if (val.value) |v| allocator.free(v);
-                if (val.comment) |c| allocator.free(c);
-            }
-            allocator.free(e.values);
-            if (e.doc_comment) |doc| allocator.free(doc);
-        },
-        .struct_decl => |s| {
-            allocator.free(s.name);
-            for (s.fields) |field| {
-                allocator.free(field.name);
-                allocator.free(field.type_name);
-                if (field.comment) |c| allocator.free(c);
-            }
-            allocator.free(s.fields);
-            if (s.doc_comment) |doc| allocator.free(doc);
-        },
-        .union_decl => |u| {
-            allocator.free(u.name);
-            for (u.fields) |field| {
-                allocator.free(field.name);
-                allocator.free(field.type_name);
-                if (field.comment) |c| allocator.free(c);
-            }
-            allocator.free(u.fields);
-            if (u.doc_comment) |doc| allocator.free(doc);
-        },
-        .flag_decl => |f| {
-            allocator.free(f.name);
-            allocator.free(f.underlying_type);
-            for (f.flags) |flag| {
-                allocator.free(flag.name);
-                allocator.free(flag.value);
-                if (flag.comment) |c| allocator.free(c);
-            }
-            allocator.free(f.flags);
-            if (f.doc_comment) |doc| allocator.free(doc);
-        },
-        .function_decl => |func| {
-            allocator.free(func.name);
-            allocator.free(func.return_type);
-            for (func.params) |param| {
-                allocator.free(param.name);
-                allocator.free(param.type_name);
-            }
-            allocator.free(func.params);
-            if (func.doc_comment) |doc| allocator.free(doc);
-        },
-        .function_pointer_decl => |fp| {
-            allocator.free(fp.name);
-            allocator.free(fp.return_type);
-            for (fp.params) |param| {
-                allocator.free(param.name);
-                allocator.free(param.type_name);
-            }
-            allocator.free(fp.params);
-            if (fp.doc_comment) |doc| allocator.free(doc);
-        },
-        .c_type_alias => |a| {
-            allocator.free(a.name);
-            if (a.doc_comment) |doc| allocator.free(doc);
-        },
-    }
-}

src/parser.zig

@@ -5,6 +5,7 @@ const dependency_resolver = @import("dependency_resolver.zig");
 const json_serializer = @import("json_serializer.zig");
 const io = @import("io.zig");
 const header_cache = @import("header_cache.zig");
+const resolved_decl = @import("resolved_decl.zig");
 
 pub fn freeDecls(allocator: std.mem.Allocator, decls: []patterns.Declaration) void {
     for (decls) |decl| {
@@ -36,6 +37,7 @@ pub fn main() !void {
     var json_output_file: ?[]const u8 = null;
     var timestamp: ?i64 = null;
     var basedir: ?[]const u8 = null;
+    var c_import_path: []const u8 = "c.zig";
 
     // Parse additional flags
     for (args[2..]) |arg| {
@@ -44,6 +46,7 @@ pub fn main() !void {
         const json_prefix = "--generate-json=";
         const timestamp_prefix = "--timestamp=";
         const basedir_prefix = "--basedir=";
+        const c_import_prefix = "--c-import=";
         if (std.mem.startsWith(u8, arg, output_prefix)) {
             output_file = arg[output_prefix.len..];
         } else if (std.mem.startsWith(u8, arg, mocks_prefix)) {
@@ -54,6 +57,8 @@ pub fn main() !void {
             timestamp = std.fmt.parseInt(i64, arg[timestamp_prefix.len..], 10) catch null;
         } else if (std.mem.startsWith(u8, arg, basedir_prefix)) {
             basedir = arg[basedir_prefix.len..];
+        } else if (std.mem.startsWith(u8, arg, c_import_prefix)) {
+            c_import_path = arg[c_import_prefix.len..];
         } else {
             std.debug.print("Error: Unknown argument '{s}'\n", .{arg});
             std.debug.print("Usage: {s} <header-file> [--output=<output-file>] [--mocks=<mock-file>] [--generate-json=<json-file>] [--timestamp=<timestamp>] [--basedir=<directory>]\n", .{args[0]});
@@ -134,7 +139,7 @@ pub fn main() !void {
         const parsed = try std.json.parseFromSlice(std.json.Value, allocator, json_output, .{});
         defer parsed.deinit();
 
-        var formatted_output = std.ArrayList(u8){};
+        var formatted_output: std.ArrayList(u8) = .empty;
         defer formatted_output.deinit(allocator);
 
         const formatter = std.json.fmt(parsed.value, .{ .whitespace = .indent_2 });
@@ -179,10 +184,10 @@ pub fn main() !void {
     //     std.debug.print("Adding {d} hardcoded type declarations\n", .{hardcoded_decls.len});
     // }
 
-    var dependency_decls = std.ArrayList(patterns.Declaration){};
+    var dependency_decls: std.ArrayList(resolved_decl.ResolvedDecl) = .empty;
     defer {
         for (dependency_decls.items) |dep_decl| {
-            freeDeclDeep(allocator, dep_decl);
+            dep_decl.deinit(allocator);
         }
         dependency_decls.deinit(allocator);
     }
@@ -224,21 +229,11 @@ pub fn main() !void {
             };
 
             // Add all resolved declarations
-            for (resolved_decls) |resolved_decl| {
-                const decl_type_name = switch (resolved_decl) {
-                    .opaque_type => |o| o.name,
-                    .typedef_decl => |t| t.name,
-                    .function_pointer_decl => |fp| fp.name,
-                    .c_type_alias => |a| a.name,
-                    .enum_decl => |e| e.name,
-                    .struct_decl => |s| s.name,
-                    .union_decl => |u| u.name,
-                    .flag_decl => |f| f.name,
-                    .function_decl => continue, // Skip functions
-                };
+            for (resolved_decls) |resolved| {
+                const decl_type_name = resolved.typeName() orelse continue;
 
                 if (!added_types.contains(decl_type_name)) {
-                    try dependency_decls.append(allocator, resolved_decl);
+                    try dependency_decls.append(allocator, resolved);
                     try added_types.put(try allocator.dupe(u8, decl_type_name), {});
 
                     if (std.mem.eql(u8, decl_type_name, missing_type)) {
@@ -248,7 +243,7 @@ pub fn main() !void {
                     }
                 } else {
                     // Already added, free this duplicate
-                    freeDeclDeep(allocator, resolved_decl);
+                    resolved.deinit(allocator);
                 }
             }
 
@@ -258,18 +253,35 @@ pub fn main() !void {
         std.debug.print("\n", .{});
     }
 
-    // Combine declarations (hardcoded first, then dependencies, then primary!)
     std.debug.print("Combining {d} dependency declarations with primary declarations...\n", .{dependency_decls.items.len});
 
-    var all_decls = std.ArrayList(patterns.Declaration){};
-    defer all_decls.deinit(allocator);
+    var all_resolved_decls: std.ArrayList(resolved_decl.ResolvedDecl) = .empty;
+    defer {
+        for (all_resolved_decls.items) |resolved| {
+            resolved.deinit(allocator);
+        }
+        all_resolved_decls.deinit(allocator);
+    }
 
-    // try all_decls.appendSlice(allocator, hardcoded_decls);
-    try all_decls.appendSlice(allocator, dependency_decls.items);
-    try all_decls.appendSlice(allocator, decls);
+    const primary_header = std.fs.path.basename(header_path);
+    for (decls) |decl| {
+        try all_resolved_decls.append(allocator, .{
+            .decl = try resolved_decl.cloneDeclaration(allocator, decl),
+            .source_header = try allocator.dupe(u8, primary_header),
+            .is_primary_header_decl = true,
+        });
+    }
+    try all_resolved_decls.appendSlice(allocator, dependency_decls.items);
+    dependency_decls.clearRetainingCapacity();
 
-    // Generate code with all declarations
-    const output = try codegen.CodeGen.generate(allocator, all_decls.items);
+    const module_name = try resolved_decl.headerToModuleNameAlloc(allocator, primary_header);
+    defer allocator.free(module_name);
+
+    const output = try codegen.CodeGen.generate(allocator, .{
+        .decls = all_resolved_decls.items,
+        .module_name = module_name,
+        .c_import_path = c_import_path,
+    });
     defer allocator.free(output);
 
     // Parse and format the AST for validation
@@ -318,10 +330,22 @@ pub fn main() !void {
         _ = try io.stdout().write(formatted_output);
     }
 
-    // Generate C mocks if requested (with all declarations)
+    // Generate C mocks if requested (with flat 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);
+        var mock_decls: std.ArrayList(patterns.Declaration) = .empty;
+        defer {
+            for (mock_decls.items) |decl| {
+                freeDeclDeep(allocator, decl);
+            }
+            mock_decls.deinit(allocator);
+        }
+
+        for (all_resolved_decls.items) |resolved| {
+            try mock_decls.append(allocator, try resolved_decl.cloneDeclaration(allocator, resolved.decl));
+        }
+
+        const mock_output = try mock_codegen.MockCodeGen.generate(allocator, mock_decls.items);
         defer allocator.free(mock_output);
 
         try ensureParentDirExists(mock_path);

src/resolved_decl.zig

@@ -0,0 +1,173 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const patterns = @import("patterns.zig");
+
+pub const Declaration = patterns.Declaration;
+
+pub const ResolvedDecl = struct {
+    decl: Declaration,
+    source_header: []const u8,
+    is_primary_header_decl: bool,
+
+    pub fn deinit(self: ResolvedDecl, allocator: Allocator) void {
+        switch (self.decl) {
+            inline else => |*d| d.deinit(allocator),
+        }
+        allocator.free(self.source_header);
+    }
+
+    pub fn typeName(self: ResolvedDecl) ?[]const u8 {
+        return getTypeName(self.decl);
+    }
+};
+
+pub fn getTypeName(decl: Declaration) ?[]const u8 {
+    return switch (decl) {
+        .opaque_type => |o| o.name,
+        .typedef_decl => |t| t.name,
+        .function_pointer_decl => |fp| fp.name,
+        .c_type_alias => |a| a.name,
+        .enum_decl => |e| e.name,
+        .struct_decl => |s| s.name,
+        .union_decl => |u| u.name,
+        .flag_decl => |f| f.name,
+        .function_decl => null,
+    };
+}
+
+pub fn headerToModuleNameAlloc(allocator: Allocator, header_name: []const u8) ![]const u8 {
+    const basename = std.fs.path.basename(header_name);
+    const no_ext = std.fs.path.stem(basename);
+    const trimmed = if (std.mem.startsWith(u8, no_ext, "SDL_")) no_ext["SDL_".len..] else no_ext;
+    return allocator.dupe(u8, trimmed);
+}
+
+pub fn cloneDeclaration(allocator: Allocator, decl: Declaration) !Declaration {
+    return switch (decl) {
+        .opaque_type => |o| .{
+            .opaque_type = .{
+                .name = try allocator.dupe(u8, o.name),
+                .doc_comment = if (o.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+            },
+        },
+        .typedef_decl => |t| .{
+            .typedef_decl = .{
+                .name = try allocator.dupe(u8, t.name),
+                .underlying_type = try allocator.dupe(u8, t.underlying_type),
+                .doc_comment = if (t.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+            },
+        },
+        .function_pointer_decl => |fp| .{
+            .function_pointer_decl = .{
+                .name = try allocator.dupe(u8, fp.name),
+                .return_type = try allocator.dupe(u8, fp.return_type),
+                .doc_comment = if (fp.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+                .params = try cloneParams(allocator, fp.params),
+            },
+        },
+        .c_type_alias => |a| .{
+            .c_type_alias = .{
+                .name = try allocator.dupe(u8, a.name),
+                .doc_comment = if (a.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+            },
+        },
+        .enum_decl => |e| .{
+            .enum_decl = .{
+                .name = try allocator.dupe(u8, e.name),
+                .doc_comment = if (e.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+                .values = try cloneEnumValues(allocator, e.values),
+            },
+        },
+        .struct_decl => |s| .{
+            .struct_decl = .{
+                .name = try allocator.dupe(u8, s.name),
+                .doc_comment = if (s.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+                .fields = try cloneFields(allocator, s.fields),
+                .has_unions = s.has_unions,
+            },
+        },
+        .union_decl => |u| .{
+            .union_decl = .{
+                .name = try allocator.dupe(u8, u.name),
+                .doc_comment = if (u.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+                .fields = try cloneFields(allocator, u.fields),
+            },
+        },
+        .flag_decl => |f| .{
+            .flag_decl = .{
+                .name = try allocator.dupe(u8, f.name),
+                .underlying_type = try allocator.dupe(u8, f.underlying_type),
+                .doc_comment = if (f.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+                .flags = try cloneFlagValues(allocator, f.flags),
+                .constants = try cloneConstValues(allocator, f.constants),
+            },
+        },
+        .function_decl => |func| .{
+            .function_decl = .{
+                .name = try allocator.dupe(u8, func.name),
+                .return_type = try allocator.dupe(u8, func.return_type),
+                .doc_comment = if (func.doc_comment) |doc| try allocator.dupe(u8, doc) else null,
+                .params = try cloneParams(allocator, func.params),
+            },
+        },
+    };
+}
+
+fn cloneEnumValues(allocator: Allocator, values: []const patterns.EnumValue) ![]patterns.EnumValue {
+    const cloned = try allocator.alloc(patterns.EnumValue, values.len);
+    for (values, 0..) |value, i| {
+        cloned[i] = .{
+            .name = try allocator.dupe(u8, value.name),
+            .value = if (value.value) |v| try allocator.dupe(u8, v) else null,
+            .comment = if (value.comment) |c| try allocator.dupe(u8, c) else null,
+        };
+    }
+    return cloned;
+}
+
+fn cloneFields(allocator: Allocator, fields: []const patterns.FieldDecl) ![]patterns.FieldDecl {
+    const cloned = try allocator.alloc(patterns.FieldDecl, fields.len);
+    for (fields, 0..) |field, i| {
+        cloned[i] = .{
+            .name = try allocator.dupe(u8, field.name),
+            .type_name = try allocator.dupe(u8, field.type_name),
+            .comment = if (field.comment) |c| try allocator.dupe(u8, c) else null,
+        };
+    }
+    return cloned;
+}
+
+fn cloneFlagValues(allocator: Allocator, flags: []const patterns.FlagValue) ![]patterns.FlagValue {
+    const cloned = try allocator.alloc(patterns.FlagValue, flags.len);
+    for (flags, 0..) |flag, i| {
+        cloned[i] = .{
+            .name = try allocator.dupe(u8, flag.name),
+            .value = try allocator.dupe(u8, flag.value),
+            .comment = if (flag.comment) |c| try allocator.dupe(u8, c) else null,
+        };
+    }
+    return cloned;
+}
+
+fn cloneConstValues(allocator: Allocator, constants: []const patterns.ConstValue) ![]patterns.ConstValue {
+    const cloned = try allocator.alloc(patterns.ConstValue, constants.len);
+    for (constants, 0..) |constant, i| {
+        cloned[i] = .{
+            .name = try allocator.dupe(u8, constant.name),
+            .value = try allocator.dupe(u8, constant.value),
+            .comment = if (constant.comment) |c| try allocator.dupe(u8, c) else null,
+        };
+    }
+    return cloned;
+}
+
+fn cloneParams(allocator: Allocator, params: []const patterns.ParamDecl) ![]patterns.ParamDecl {
+    const cloned = try allocator.alloc(patterns.ParamDecl, params.len);
+    for (params, 0..) |param, i| {
+        cloned[i] = .{
+            .name = try allocator.dupe(u8, param.name),
+            .type_name = try allocator.dupe(u8, param.type_name),
+        };
+    }
+    return cloned;
+}

src/types.zig

@@ -131,6 +131,41 @@ pub fn convertType(c_type: []const u8, allocator: Allocator) ![]const u8 {
 
     if (std.mem.startsWith(u8, trimmed, "const ")) {
         const rest = trimmed[6..];
+        if (std.mem.startsWith(u8, rest, "SDL_")) {
+            if (std.mem.indexOfScalar(u8, rest, '*')) |star_pos| {
+                const base_type = std.mem.trim(u8, rest[0..star_pos], " \t");
+                const star_count = std.mem.count(u8, rest[star_pos..], "*");
+                if (star_count >= 2) {
+                    const zig_type = base_type[4..];
+                    return std.fmt.allocPrint(allocator, "[*c]?*const {s}", .{zig_type});
+                }
+                if (star_count == 1) {
+                    const zig_type = base_type[4..];
+                    return std.fmt.allocPrint(allocator, "?*const {s}", .{zig_type});
+                }
+            }
+        }
+        if (std.mem.indexOf(u8, rest, " **")) |pos| {
+            const base_type = rest[0..pos];
+            if (std.mem.startsWith(u8, base_type, "SDL_")) {
+                const zig_type = base_type[4..];
+                return std.fmt.allocPrint(allocator, "[*c]?*const {s}", .{zig_type});
+            }
+        }
+        if (std.mem.indexOf(u8, rest, " *const *")) |pos| {
+            const base_type = rest[0..pos];
+            if (std.mem.startsWith(u8, base_type, "SDL_")) {
+                const zig_type = base_type[4..];
+                return std.fmt.allocPrint(allocator, "[*c]?*const {s}", .{zig_type});
+            }
+        }
+        if (std.mem.indexOf(u8, rest, " * const *")) |pos| {
+            const base_type = rest[0..pos];
+            if (std.mem.startsWith(u8, base_type, "SDL_")) {
+                const zig_type = base_type[4..];
+                return std.fmt.allocPrint(allocator, "[*c]?*const {s}", .{zig_type});
+            }
+        }
         if (std.mem.endsWith(u8, rest, " *") or std.mem.endsWith(u8, rest, "*")) {
             const base_type = if (std.mem.endsWith(u8, rest, " *"))
                 rest[0 .. rest.len - 2]
@@ -309,3 +344,11 @@ pub const CastType = enum {
     int_from_enum,
     enum_from_int,
 };
+
+test "convert const SDL double pointer" {
+    const allocator = std.testing.allocator;
+    const zig_type = try convertType("const SDL_TrayEntry **", allocator);
+    defer allocator.free(zig_type);
+
+    try std.testing.expectEqualStrings("[*c]?*const TrayEntry", zig_type);
+}