From 724b5e1a05a65f5de2067491721f3797e1dc6396 Mon Sep 17 00:00:00 2001 From: Peterino2 Date: Thu, 22 Jan 2026 18:16:49 -0800 Subject: [PATCH] feat: add JSON export and regenerate multiple SDL headers - Implemented --generate-json flag to export parsed API as JSON - Added proper JSON formatting using std.json - Fixed memory leaks in JSON generation - Updated build.zig to generate 15 different SDL headers - Successfully parsing 13/15 headers (init and iostream have issues) Working headers: - SDL_gpu, SDL_video, SDL_events, SDL_keyboard - SDL_mouse, SDL_scancode, SDL_keycode, SDL_pixels - SDL_rect, SDL_surface, SDL_blendmode, SDL_timer - SDL_error Known issues: - SDL_init.h: array syntax in function pointer params (argv[]) - SDL_iostream.h: function pointer fields in structs not supported --- lib/sdl3/build.zig | 11 + lib/sdl3/v2/blendmode.zig | 15 ++ lib/sdl3/v2/error.zig | 24 ++ lib/sdl3/v2/events.zig | 491 ++++++++++++++++++++++++++++++++++++- lib/sdl3/v2/gpu.zig | 301 +++++++++++++++++++---- lib/sdl3/v2/init.zig | 100 ++++++++ lib/sdl3/v2/iostream.zig | 210 ++++++++++++++++ lib/sdl3/v2/keyboard.zig | 4 - lib/sdl3/v2/keycode.zig | 6 + lib/sdl3/v2/mouse.zig | 117 +++++++++ lib/sdl3/v2/pixels.zig | 292 ++++++++++++++++++++++ lib/sdl3/v2/rect.zig | 88 +++++++ lib/sdl3/v2/scancode.zig | 184 ++++++++++++++ lib/sdl3/v2/surface.zig | 499 ++++++++++++++++++++++++++++++++++++++ lib/sdl3/v2/timer.zig | 48 ++++ lib/sdl3/v2/video.zig | 20 +- 16 files changed, 2338 insertions(+), 72 deletions(-) create mode 100644 lib/sdl3/v2/blendmode.zig create mode 100644 lib/sdl3/v2/error.zig create mode 100644 lib/sdl3/v2/init.zig create mode 100644 lib/sdl3/v2/iostream.zig create mode 100644 lib/sdl3/v2/keycode.zig create mode 100644 lib/sdl3/v2/mouse.zig create mode 100644 lib/sdl3/v2/pixels.zig create mode 100644 lib/sdl3/v2/rect.zig create mode 100644 lib/sdl3/v2/scancode.zig create mode 100644 lib/sdl3/v2/surface.zig create mode 100644 lib/sdl3/v2/timer.zig diff --git a/lib/sdl3/build.zig b/lib/sdl3/build.zig index b8235de..225a6a0 100644 --- a/lib/sdl3/build.zig +++ b/lib/sdl3/build.zig @@ -148,6 +148,17 @@ pub fn build(b: *std.Build) void { .{ .header = "SDL/include/SDL3/SDL_video.h", .output = "v2/video.zig" }, .{ .header = "SDL/include/SDL3/SDL_events.h", .output = "v2/events.zig" }, .{ .header = "SDL/include/SDL3/SDL_keyboard.h", .output = "v2/keyboard.zig" }, + .{ .header = "SDL/include/SDL3/SDL_mouse.h", .output = "v2/mouse.zig" }, + .{ .header = "SDL/include/SDL3/SDL_scancode.h", .output = "v2/scancode.zig" }, + .{ .header = "SDL/include/SDL3/SDL_keycode.h", .output = "v2/keycode.zig" }, + .{ .header = "SDL/include/SDL3/SDL_pixels.h", .output = "v2/pixels.zig" }, + .{ .header = "SDL/include/SDL3/SDL_rect.h", .output = "v2/rect.zig" }, + .{ .header = "SDL/include/SDL3/SDL_surface.h", .output = "v2/surface.zig" }, + .{ .header = "SDL/include/SDL3/SDL_blendmode.h", .output = "v2/blendmode.zig" }, + .{ .header = "SDL/include/SDL3/SDL_init.h", .output = "v2/init.zig" }, + .{ .header = "SDL/include/SDL3/SDL_timer.h", .output = "v2/timer.zig" }, + .{ .header = "SDL/include/SDL3/SDL_error.h", .output = "v2/error.zig" }, + .{ .header = "SDL/include/SDL3/SDL_iostream.h", .output = "v2/iostream.zig" }, }; const regenerate_step = b.step("regenerate-zig", "Regenerate bindings from SDL headers"); diff --git a/lib/sdl3/v2/blendmode.zig b/lib/sdl3/v2/blendmode.zig new file mode 100644 index 0000000..8f4f0ed --- /dev/null +++ b/lib/sdl3/v2/blendmode.zig @@ -0,0 +1,15 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const BlendMode = u32; + +pub inline fn composeCustomBlendMode( + srcColorFactor: BlendFactor, + dstColorFactor: BlendFactor, + colorOperation: BlendOperation, + srcAlphaFactor: BlendFactor, + dstAlphaFactor: BlendFactor, + alphaOperation: BlendOperation, +) BlendMode { + return @intFromEnum(c.SDL_ComposeCustomBlendMode(srcColorFactor, dstColorFactor, @intFromEnum(colorOperation), srcAlphaFactor, dstAlphaFactor, @intFromEnum(alphaOperation))); +} diff --git a/lib/sdl3/v2/error.zig b/lib/sdl3/v2/error.zig new file mode 100644 index 0000000..91ba5bd --- /dev/null +++ b/lib/sdl3/v2/error.zig @@ -0,0 +1,24 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub inline fn setError(fmt: [*c]const u8, ...) bool { + return c.SDL_SetError( + fmt, + ); +} + +pub inline fn setErrorV(fmt: [*c]const u8, ap: std.builtin.VaList) bool { + return c.SDL_SetErrorV(fmt, ap); +} + +pub inline fn outOfMemory() bool { + return c.SDL_OutOfMemory(); +} + +pub inline fn getError() [*c]const u8 { + return c.SDL_GetError(); +} + +pub inline fn clearError() bool { + return c.SDL_ClearError(); +} diff --git a/lib/sdl3/v2/events.zig b/lib/sdl3/v2/events.zig index 665164c..6456377 100644 --- a/lib/sdl3/v2/events.zig +++ b/lib/sdl3/v2/events.zig @@ -1,10 +1,236 @@ const std = @import("std"); pub const c = @import("c.zig").c; +pub const PenID = u32; + +pub const WindowID = u32; + +pub const AudioDeviceID = u32; + +pub const DisplayID = u32; + +pub const CameraID = u32; + +pub const PenInputFlags = packed struct(u32) { + penInputDown: bool = false, // pen is pressed down + penInputButton1: bool = false, // button 1 is pressed + penInputButton2: bool = false, // button 2 is pressed + penInputButton3: bool = false, // button 3 is pressed + penInputButton4: bool = false, // button 4 is pressed + penInputButton5: bool = false, // button 5 is pressed + penInputEraserTip: bool = false, // eraser tip is used + pad0: u24 = 0, + rsvd: bool = false, +}; + +pub const MouseButtonFlags = packed struct(u32) { + buttonLeft: bool = false, + buttonMiddle: bool = false, + buttonX1: bool = false, + pad0: u28 = 0, + rsvd: bool = false, +}; + +pub const Scancode = enum(c_int) { + scancodeUnknown, + scancodeA, + scancodeB, + scancodeC, + scancodeD, + scancodeE, + scancodeF, + scancodeG, + scancodeH, + scancodeI, + scancodeJ, + scancodeK, + scancodeL, + scancodeM, + scancodeN, + scancodeO, + scancodeP, + scancodeQ, + scancodeR, + scancodeS, + scancodeT, + scancodeU, + scancodeV, + scancodeW, + scancodeX, + scancodeY, + scancodeZ, + scancode1, + scancode2, + scancode3, + scancode4, + scancode5, + scancode6, + scancode7, + scancode8, + scancode9, + scancode0, + scancodeReturn, + scancodeEscape, + scancodeBackspace, + scancodeTab, + scancodeSpace, + scancodeMinus, + scancodeEquals, + scancodeLeftbracket, + scancodeRightbracket, + scancodeSemicolon, + scancodeApostrophe, + scancodeComma, + scancodePeriod, + scancodeSlash, + scancodeCapslock, + scancodeF1, + scancodeF2, + scancodeF3, + scancodeF4, + scancodeF5, + scancodeF6, + scancodeF7, + scancodeF8, + scancodeF9, + scancodeF10, + scancodeF11, + scancodeF12, + scancodePrintscreen, + scancodeScrolllock, + scancodePause, + scancodeHome, + scancodePageup, + scancodeDelete, + scancodeEnd, + scancodePagedown, + scancodeRight, + scancodeLeft, + scancodeDown, + scancodeUp, + scancodeKpDivide, + scancodeKpMultiply, + scancodeKpMinus, + scancodeKpPlus, + scancodeKpEnter, + scancodeKp1, + scancodeKp2, + scancodeKp3, + scancodeKp4, + scancodeKp5, + scancodeKp6, + scancodeKp7, + scancodeKp8, + scancodeKp9, + scancodeKp0, + scancodeKpPeriod, + scancodeKpEquals, + scancodeF13, + scancodeF14, + scancodeF15, + scancodeF16, + scancodeF17, + scancodeF18, + scancodeF19, + scancodeF20, + scancodeF21, + scancodeF22, + scancodeF23, + scancodeF24, + scancodeExecute, + scancodeSelect, + scancodeMute, + scancodeVolumeup, + scancodeVolumedown, + scancodeKpComma, + scancodeKpEqualsas400, + scancodeInternational2, + scancodeInternational4, + scancodeInternational5, + scancodeInternational6, + scancodeInternational7, + scancodeInternational8, + scancodeInternational9, + scancodeSysreq, + scancodeClear, + scancodePrior, + scancodeReturn2, + scancodeSeparator, + scancodeOut, + scancodeOper, + scancodeClearagain, + scancodeCrsel, + scancodeExsel, + scancodeKp00, + scancodeKp000, + scancodeThousandsseparator, + scancodeDecimalseparator, + scancodeCurrencyunit, + scancodeCurrencysubunit, + scancodeKpLeftparen, + scancodeKpRightparen, + scancodeKpLeftbrace, + scancodeKpRightbrace, + scancodeKpTab, + scancodeKpBackspace, + scancodeKpA, + scancodeKpB, + scancodeKpC, + scancodeKpD, + scancodeKpE, + scancodeKpF, + scancodeKpXor, + scancodeKpPower, + scancodeKpPercent, + scancodeKpLess, + scancodeKpGreater, + scancodeKpAmpersand, + scancodeKpDblampersand, + scancodeKpVerticalbar, + scancodeKpDblverticalbar, + scancodeKpColon, + scancodeKpHash, + scancodeKpSpace, + scancodeKpAt, + scancodeKpExclam, + scancodeKpMemstore, + scancodeKpMemrecall, + scancodeKpMemclear, + scancodeKpMemadd, + scancodeKpMemsubtract, + scancodeKpMemmultiply, + scancodeKpMemdivide, + scancodeKpPlusminus, + scancodeKpClear, + scancodeKpClearentry, + scancodeKpBinary, + scancodeKpOctal, + scancodeKpDecimal, + scancodeKpHexadecimal, + scancodeLctrl, + scancodeLshift, + scancodeRctrl, + scancodeRshift, +}; + +pub const TouchID = u64; + +pub const KeyboardID = u32; + +pub const MouseID = u32; + pub const Window = opaque {}; pub const FingerID = u64; +pub const Keycode = u32; + +pub const SensorID = u32; + +pub const JoystickID = u32; + +pub const Keymod = u16; + pub const EventType = enum(c_int) { eventDisplayFirst, eventDisplayLast, @@ -24,188 +250,440 @@ pub const EventType = enum(c_int) { }; pub const CommonEvent = extern struct { + type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() }; pub const DisplayEvent = extern struct { + type: EventType, // SDL_DISPLAYEVENT_* reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + displayID: DisplayID, // The associated display + data1: i32, // event dependent data + data2: i32, // event dependent data }; pub const WindowEvent = extern struct { + type: EventType, // SDL_EVENT_WINDOW_* reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The associated window + data1: i32, // event dependent data + data2: i32, // event dependent data }; pub const KeyboardDeviceEvent = extern struct { + type: EventType, // SDL_EVENT_KEYBOARD_ADDED or SDL_EVENT_KEYBOARD_REMOVED reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: KeyboardID, // The keyboard instance id }; pub const KeyboardEvent = extern struct { + type: EventType, // SDL_EVENT_KEY_DOWN or SDL_EVENT_KEY_UP reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with keyboard focus, if any + which: KeyboardID, // The keyboard instance id, or 0 if unknown or virtual + scancode: Scancode, // SDL physical key code + key: Keycode, // SDL virtual key code + mod: Keymod, // current key modifiers + raw: u16, // The platform dependent scancode for this event + down: bool, // true if the key is pressed + repeat: bool, // true if this is a key repeat }; pub const TextEditingEvent = extern struct { + type: EventType, // SDL_EVENT_TEXT_EDITING reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with keyboard focus, if any + text: [*c]const u8, // The editing text + start: i32, // The start cursor of selected editing text, or -1 if not set + length: i32, // The length of selected editing text, or -1 if not set }; pub const TextEditingCandidatesEvent = extern struct { + type: EventType, // SDL_EVENT_TEXT_EDITING_CANDIDATES reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with keyboard focus, if any + candidates: [*c]const [*c]const u8, // The list of candidates, or NULL if there are no candidates available + num_candidates: i32, // The number of strings in `candidates` + selected_candidate: i32, // The index of the selected candidate, or -1 if no candidate is selected + horizontal: bool, // true if the list is horizontal, false if it's vertical padding1: u8, padding2: u8, padding3: u8, }; pub const TextInputEvent = extern struct { + type: EventType, // SDL_EVENT_TEXT_INPUT reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with keyboard focus, if any + text: [*c]const u8, // The input text, UTF-8 encoded }; pub const MouseDeviceEvent = extern struct { + type: EventType, // SDL_EVENT_MOUSE_ADDED or SDL_EVENT_MOUSE_REMOVED reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: MouseID, // The mouse instance id }; pub const MouseMotionEvent = extern struct { + type: EventType, // SDL_EVENT_MOUSE_MOTION reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with mouse focus, if any + which: MouseID, // The mouse instance id in relative mode, SDL_TOUCH_MOUSEID for touch events, or 0 + state: MouseButtonFlags, // The current button state + x: f32, // X coordinate, relative to window + y: f32, // Y coordinate, relative to window + xrel: f32, // The relative motion in the X direction + yrel: f32, // The relative motion in the Y direction }; pub const MouseButtonEvent = extern struct { + type: EventType, // SDL_EVENT_MOUSE_BUTTON_DOWN or SDL_EVENT_MOUSE_BUTTON_UP reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with mouse focus, if any + which: MouseID, // The mouse instance id in relative mode, SDL_TOUCH_MOUSEID for touch events, or 0 + button: u8, // The mouse button index + down: bool, // true if the button is pressed + clicks: u8, // 1 for single-click, 2 for double-click, etc. padding: u8, + x: f32, // X coordinate, relative to window + y: f32, // Y coordinate, relative to window }; pub const MouseWheelEvent = extern struct { + type: EventType, // SDL_EVENT_MOUSE_WHEEL reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with mouse focus, if any + which: MouseID, // The mouse instance id in relative mode or 0 + x: f32, // The amount scrolled horizontally, positive to the right and negative to the left + y: f32, // The amount scrolled vertically, positive away from the user and negative toward the user + direction: MouseWheelDirection, // Set to one of the SDL_MOUSEWHEEL_* defines. When FLIPPED the values in X and Y will be opposite. Multiply by -1 to change them back + mouse_x: f32, // X coordinate, relative to window + mouse_y: f32, // Y coordinate, relative to window }; pub const JoyAxisEvent = extern struct { + type: EventType, // SDL_EVENT_JOYSTICK_AXIS_MOTION reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + axis: u8, // The joystick axis index padding1: u8, padding2: u8, padding3: u8, + value: i16, // The axis value (range: -32768 to 32767) padding4: u16, }; pub const JoyBallEvent = extern struct { + type: EventType, // SDL_EVENT_JOYSTICK_BALL_MOTION reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + ball: u8, // The joystick trackball index padding1: u8, padding2: u8, padding3: u8, + xrel: i16, // The relative motion in the X direction + yrel: i16, // The relative motion in the Y direction }; pub const JoyHatEvent = extern struct { + type: EventType, // SDL_EVENT_JOYSTICK_HAT_MOTION reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + hat: u8, // The joystick hat index padding1: u8, padding2: u8, }; pub const JoyButtonEvent = extern struct { + type: EventType, // SDL_EVENT_JOYSTICK_BUTTON_DOWN or SDL_EVENT_JOYSTICK_BUTTON_UP reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + button: u8, // The joystick button index + down: bool, // true if the button is pressed padding1: u8, padding2: u8, }; pub const JoyDeviceEvent = extern struct { + type: EventType, // SDL_EVENT_JOYSTICK_ADDED or SDL_EVENT_JOYSTICK_REMOVED or SDL_EVENT_JOYSTICK_UPDATE_COMPLETE reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id }; pub const JoyBatteryEvent = extern struct { + type: EventType, // SDL_EVENT_JOYSTICK_BATTERY_UPDATED reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + state: PowerState, // The joystick battery state + percent: c_int, // The joystick battery percent charge remaining }; pub const GamepadAxisEvent = extern struct { + type: EventType, // SDL_EVENT_GAMEPAD_AXIS_MOTION reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + axis: u8, // The gamepad axis (SDL_GamepadAxis) padding1: u8, padding2: u8, padding3: u8, + value: i16, // The axis value (range: -32768 to 32767) padding4: u16, }; pub const GamepadButtonEvent = extern struct { + type: EventType, // SDL_EVENT_GAMEPAD_BUTTON_DOWN or SDL_EVENT_GAMEPAD_BUTTON_UP reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + button: u8, // The gamepad button (SDL_GamepadButton) + down: bool, // true if the button is pressed padding1: u8, padding2: u8, }; pub const GamepadDeviceEvent = extern struct { + type: EventType, // SDL_EVENT_GAMEPAD_ADDED, SDL_EVENT_GAMEPAD_REMOVED, or SDL_EVENT_GAMEPAD_REMAPPED, SDL_EVENT_GAMEPAD_UPDATE_COMPLETE or SDL_EVENT_GAMEPAD_STEAM_HANDLE_UPDATED reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id }; pub const GamepadTouchpadEvent = extern struct { + type: EventType, // SDL_EVENT_GAMEPAD_TOUCHPAD_DOWN or SDL_EVENT_GAMEPAD_TOUCHPAD_MOTION or SDL_EVENT_GAMEPAD_TOUCHPAD_UP reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + touchpad: i32, // The index of the touchpad + finger: i32, // The index of the finger on the touchpad + x: f32, // Normalized in the range 0...1 with 0 being on the left + y: f32, // Normalized in the range 0...1 with 0 being at the top + pressure: f32, // Normalized in the range 0...1 }; pub const GamepadSensorEvent = extern struct { + type: EventType, // SDL_EVENT_GAMEPAD_SENSOR_UPDATE reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: JoystickID, // The joystick instance id + sensor: i32, // The type of the sensor, one of the values of SDL_SensorType + data: [3]f32, // Up to 3 values from the sensor, as defined in SDL_sensor.h + sensor_timestamp: u64, // The timestamp of the sensor reading in nanoseconds, not necessarily synchronized with the system clock }; pub const AudioDeviceEvent = extern struct { + type: EventType, // SDL_EVENT_AUDIO_DEVICE_ADDED, or SDL_EVENT_AUDIO_DEVICE_REMOVED, or SDL_EVENT_AUDIO_DEVICE_FORMAT_CHANGED reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: AudioDeviceID, // SDL_AudioDeviceID for the device being added or removed or changing + recording: bool, // false if a playback device, true if a recording device. padding1: u8, padding2: u8, padding3: u8, }; pub const CameraDeviceEvent = extern struct { + type: EventType, // SDL_EVENT_CAMERA_DEVICE_ADDED, SDL_EVENT_CAMERA_DEVICE_REMOVED, SDL_EVENT_CAMERA_DEVICE_APPROVED, SDL_EVENT_CAMERA_DEVICE_DENIED reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: CameraID, // SDL_CameraID for the device being added or removed or changing }; pub const RenderEvent = extern struct { + type: EventType, // SDL_EVENT_RENDER_TARGETS_RESET, SDL_EVENT_RENDER_DEVICE_RESET, SDL_EVENT_RENDER_DEVICE_LOST reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window containing the renderer in question. }; pub const TouchFingerEvent = extern struct { + type: EventType, // SDL_EVENT_FINGER_DOWN, SDL_EVENT_FINGER_UP, SDL_EVENT_FINGER_MOTION, or SDL_EVENT_FINGER_CANCELED reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + touchID: TouchID, // The touch device id fingerID: FingerID, + x: f32, // Normalized in the range 0...1 + y: f32, // Normalized in the range 0...1 + dx: f32, // Normalized in the range -1...1 + dy: f32, // Normalized in the range -1...1 + pressure: f32, // Normalized in the range 0...1 + windowID: WindowID, // The window underneath the finger, if any }; pub const PenProximityEvent = extern struct { + type: EventType, // SDL_EVENT_PEN_PROXIMITY_IN or SDL_EVENT_PEN_PROXIMITY_OUT reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with pen focus, if any + which: PenID, // The pen instance id }; pub const PenMotionEvent = extern struct { + type: EventType, // SDL_EVENT_PEN_MOTION reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with pen focus, if any + which: PenID, // The pen instance id + pen_state: PenInputFlags, // Complete pen input state at time of event + x: f32, // X coordinate, relative to window + y: f32, // Y coordinate, relative to window }; pub const PenTouchEvent = extern struct { + type: EventType, // SDL_EVENT_PEN_DOWN or SDL_EVENT_PEN_UP reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with pen focus, if any + which: PenID, // The pen instance id + pen_state: PenInputFlags, // Complete pen input state at time of event + x: f32, // X coordinate, relative to window + y: f32, // Y coordinate, relative to window + eraser: bool, // true if eraser end is used (not all pens support this). + down: bool, // true if the pen is touching or false if the pen is lifted off }; pub const PenButtonEvent = extern struct { + type: EventType, // SDL_EVENT_PEN_BUTTON_DOWN or SDL_EVENT_PEN_BUTTON_UP reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with mouse focus, if any + which: PenID, // The pen instance id + pen_state: PenInputFlags, // Complete pen input state at time of event + x: f32, // X coordinate, relative to window + y: f32, // Y coordinate, relative to window + button: u8, // The pen button index (first button is 1). + down: bool, // true if the button is pressed }; pub const PenAxisEvent = extern struct { + type: EventType, // SDL_EVENT_PEN_AXIS reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window with pen focus, if any + which: PenID, // The pen instance id + pen_state: PenInputFlags, // Complete pen input state at time of event + x: f32, // X coordinate, relative to window + y: f32, // Y coordinate, relative to window + axis: PenAxis, // Axis that has changed + value: f32, // New value of axis }; pub const DropEvent = extern struct { + type: EventType, // SDL_EVENT_DROP_BEGIN or SDL_EVENT_DROP_FILE or SDL_EVENT_DROP_TEXT or SDL_EVENT_DROP_COMPLETE or SDL_EVENT_DROP_POSITION reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The window that was dropped on, if any + x: f32, // X coordinate, relative to window (not on begin) + y: f32, // Y coordinate, relative to window (not on begin) + source: [*c]const u8, // The source app that sent this drop event, or NULL if that isn't available + data: [*c]const u8, // The text for SDL_EVENT_DROP_TEXT and the file name for SDL_EVENT_DROP_FILE, NULL for other events }; pub const ClipboardEvent = extern struct { + type: EventType, // SDL_EVENT_CLIPBOARD_UPDATE reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + owner: bool, // are we owning the clipboard (internal update) + num_mime_types: i32, // number of mime types + mime_types: [*c][*c]const u8, // current mime types }; pub const SensorEvent = extern struct { + type: EventType, // SDL_EVENT_SENSOR_UPDATE reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + which: SensorID, // The instance ID of the sensor + data: [6]f32, // Up to 6 values from the sensor - additional values can be queried using SDL_GetSensorData() + sensor_timestamp: u64, // The timestamp of the sensor reading in nanoseconds, not necessarily synchronized with the system clock }; pub const QuitEvent = extern struct { + type: EventType, // SDL_EVENT_QUIT reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() }; pub const UserEvent = extern struct { + type: u32, // SDL_EVENT_USER through SDL_EVENT_LAST-1, Uint32 because these are not in the SDL_EventType enumeration reserved: u32, + timestamp: u64, // In nanoseconds, populated using SDL_GetTicksNS() + windowID: WindowID, // The associated window if any + code: i32, // User defined event code + data1: ?*anyopaque, // User defined data pointer + data2: ?*anyopaque, // User defined data pointer }; -pub const Event = union; +pub const Event = extern union { + type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration + common: CommonEvent, // Common event data + display: DisplayEvent, // Display event data + window: WindowEvent, // Window event data + kdevice: KeyboardDeviceEvent, // Keyboard device change event data + key: KeyboardEvent, // Keyboard event data + edit: TextEditingEvent, // Text editing event data + edit_candidates: TextEditingCandidatesEvent, // Text editing candidates event data + text: TextInputEvent, // Text input event data + mdevice: MouseDeviceEvent, // Mouse device change event data + motion: MouseMotionEvent, // Mouse motion event data + button: MouseButtonEvent, // Mouse button event data + wheel: MouseWheelEvent, // Mouse wheel event data + jdevice: JoyDeviceEvent, // Joystick device change event data + jaxis: JoyAxisEvent, // Joystick axis event data + jball: JoyBallEvent, // Joystick ball event data + jhat: JoyHatEvent, // Joystick hat event data + jbutton: JoyButtonEvent, // Joystick button event data + jbattery: JoyBatteryEvent, // Joystick battery event data + gdevice: GamepadDeviceEvent, // Gamepad device event data + gaxis: GamepadAxisEvent, // Gamepad axis event data + gbutton: GamepadButtonEvent, // Gamepad button event data + gtouchpad: GamepadTouchpadEvent, // Gamepad touchpad event data + gsensor: GamepadSensorEvent, // Gamepad sensor event data + adevice: AudioDeviceEvent, // Audio device event data + cdevice: CameraDeviceEvent, // Camera device event data + sensor: SensorEvent, // Sensor event data + quit: QuitEvent, // Quit request event data + user: UserEvent, // Custom event data + tfinger: TouchFingerEvent, // Touch finger event data + pproximity: PenProximityEvent, // Pen proximity event data + ptouch: PenTouchEvent, // Pen tip touching event data + pmotion: PenMotionEvent, // Pen motion event data + pbutton: PenButtonEvent, // Pen button event data + paxis: PenAxisEvent, // Pen axis event data + render: RenderEvent, // Render event data + drop: DropEvent, // Drag and drop event data + clipboard: ClipboardEvent, // Clipboard event data + padding: [128]u8, +}; pub inline fn pumpEvents() void { return c.SDL_PumpEvents(); } -pub const EventAction = enum(c_int) { -}; - -pub inline fn peepEvents(events: ?*Event, numevents: c_int, action: EventAction, minType: u32, maxType: u32,) c_int { +pub inline fn peepEvents( + events: ?*Event, + numevents: c_int, + action: EventAction, + minType: u32, + maxType: u32, +) c_int { return c.SDL_PeepEvents(events, numevents, action, minType, maxType); } @@ -241,7 +719,7 @@ pub inline fn pushEvent(event: ?*Event) bool { return c.SDL_PushEvent(event); } -pub const EventFilter = *const fn(userdata: ?*anyopaque, event: ?*Event) callconv(.C) bool; +pub const EventFilter = *const fn (userdata: ?*anyopaque, event: ?*Event) callconv(.C) bool; pub inline fn setEventFilter(filter: EventFilter, userdata: ?*anyopaque) void { return c.SDL_SetEventFilter(filter, userdata); @@ -278,4 +756,3 @@ pub inline fn registerEvents(numevents: c_int) u32 { pub inline fn getWindowFromEvent(event: *const Event) ?*Window { return c.SDL_GetWindowFromEvent(@ptrCast(event)); } - diff --git a/lib/sdl3/v2/gpu.zig b/lib/sdl3/v2/gpu.zig index 54e479b..262029c 100644 --- a/lib/sdl3/v2/gpu.zig +++ b/lib/sdl3/v2/gpu.zig @@ -10,8 +10,6 @@ pub const FColor = extern struct { pub const PropertiesID = u32; -pub const Window = opaque {}; - pub const Rect = extern struct { x: c_int, y: c_int, @@ -19,6 +17,8 @@ pub const Rect = extern struct { h: c_int, }; +pub const Window = opaque {}; + pub const GPUDevice = opaque { pub inline fn destroyGPUDevice(gpudevice: *GPUDevice) void { return c.SDL_DestroyGPUDevice(gpudevice); @@ -544,14 +544,6 @@ pub const GPUCopyPass = opaque { pub const GPUFence = opaque {}; -pub const GPUPrimitiveType = enum(c_int) {}; - -pub const GPULoadOp = enum(c_int) {}; - -pub const GPUStoreOp = enum(c_int) {}; - -pub const GPUIndexElementSize = enum(c_int) {}; - pub const GPUTextureFormat = enum(c_int) { textureformatInvalid, textureformatA8Unorm, @@ -672,10 +664,6 @@ pub const GPUTextureUsageFlags = packed struct(u32) { rsvd: bool = false, }; -pub const GPUTextureType = enum(c_int) {}; - -pub const GPUSampleCount = enum(c_int) {}; - pub const GPUCubeMapFace = enum(c_int) { cubemapfacePositivex, cubemapfaceNegativex, @@ -742,14 +730,6 @@ pub const GPUVertexElementFormat = enum(c_int) { vertexelementformatHalf4, }; -pub const GPUVertexInputRate = enum(c_int) {}; - -pub const GPUFillMode = enum(c_int) {}; - -pub const GPUCullMode = enum(c_int) {}; - -pub const GPUFrontFace = enum(c_int) {}; - pub const GPUCompareOp = enum(c_int) { compareopInvalid, }; @@ -775,12 +755,6 @@ pub const GPUColorComponentFlags = packed struct(u8) { rsvd: bool = false, }; -pub const GPUFilter = enum(c_int) {}; - -pub const GPUSamplerMipmapMode = enum(c_int) {}; - -pub const GPUSamplerAddressMode = enum(c_int) {}; - pub const GPUPresentMode = enum(c_int) { presentmodeVsync, presentmodeImmediate, @@ -794,110 +768,333 @@ pub const GPUSwapchainComposition = enum(c_int) { swapchaincompositionHdr10St2084, }; -pub const GPUViewport = extern struct {}; +pub const GPUViewport = extern struct { + x: f32, // The left offset of the viewport. + y: f32, // The top offset of the viewport. + w: f32, // The width of the viewport. + h: f32, // The height of the viewport. + min_depth: f32, // The minimum depth of the viewport. + max_depth: f32, // The maximum depth of the viewport. +}; -pub const GPUTextureTransferInfo = extern struct {}; +pub const GPUTextureTransferInfo = extern struct { + transfer_buffer: ?*GPUTransferBuffer, // The transfer buffer used in the transfer operation. + offset: u32, // The starting byte of the image data in the transfer buffer. + pixels_per_row: u32, // The number of pixels from one row to the next. + rows_per_layer: u32, // The number of rows from one layer/depth-slice to the next. +}; -pub const GPUTransferBufferLocation = extern struct {}; +pub const GPUTransferBufferLocation = extern struct { + transfer_buffer: ?*GPUTransferBuffer, // The transfer buffer used in the transfer operation. + offset: u32, // The starting byte of the buffer data in the transfer buffer. +}; -pub const GPUTextureLocation = extern struct {}; +pub const GPUTextureLocation = extern struct { + texture: ?*GPUTexture, // The texture used in the copy operation. + mip_level: u32, // The mip level index of the location. + layer: u32, // The layer index of the location. + x: u32, // The left offset of the location. + y: u32, // The top offset of the location. + z: u32, // The front offset of the location. +}; -pub const GPUTextureRegion = extern struct {}; +pub const GPUTextureRegion = extern struct { + texture: ?*GPUTexture, // The texture used in the copy operation. + mip_level: u32, // The mip level index to transfer. + layer: u32, // The layer index to transfer. + x: u32, // The left offset of the region. + y: u32, // The top offset of the region. + z: u32, // The front offset of the region. + w: u32, // The width of the region. + h: u32, // The height of the region. + d: u32, // The depth of the region. +}; -pub const GPUBlitRegion = extern struct {}; +pub const GPUBlitRegion = extern struct { + texture: ?*GPUTexture, // The texture. + mip_level: u32, // The mip level index of the region. + layer_or_depth_plane: u32, // The layer index or depth plane of the region. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. + x: u32, // The left offset of the region. + y: u32, // The top offset of the region. + w: u32, // The width of the region. + h: u32, // The height of the region. +}; -pub const GPUBufferLocation = extern struct {}; +pub const GPUBufferLocation = extern struct { + buffer: ?*GPUBuffer, // The buffer. + offset: u32, // The starting byte within the buffer. +}; -pub const GPUBufferRegion = extern struct {}; +pub const GPUBufferRegion = extern struct { + buffer: ?*GPUBuffer, // The buffer. + offset: u32, // The starting byte within the buffer. + size: u32, // The size in bytes of the region. +}; -pub const GPUIndirectDrawCommand = extern struct {}; +pub const GPUIndirectDrawCommand = extern struct { + num_vertices: u32, // The number of vertices to draw. + num_instances: u32, // The number of instances to draw. + first_vertex: u32, // The index of the first vertex to draw. + first_instance: u32, // The ID of the first instance to draw. +}; -pub const GPUIndexedIndirectDrawCommand = extern struct {}; +pub const GPUIndexedIndirectDrawCommand = extern struct { + num_indices: u32, // The number of indices to draw per instance. + num_instances: u32, // The number of instances to draw. + first_index: u32, // The base index within the index buffer. + vertex_offset: i32, // The value added to the vertex index before indexing into the vertex buffer. + first_instance: u32, // The ID of the first instance to draw. +}; -pub const GPUIndirectDispatchCommand = extern struct {}; +pub const GPUIndirectDispatchCommand = extern struct { + groupcount_x: u32, // The number of local workgroups to dispatch in the X dimension. + groupcount_y: u32, // The number of local workgroups to dispatch in the Y dimension. + groupcount_z: u32, // The number of local workgroups to dispatch in the Z dimension. +}; pub const GPUSamplerCreateInfo = extern struct { + min_filter: GPUFilter, // The minification filter to apply to lookups. + mag_filter: GPUFilter, // The magnification filter to apply to lookups. + mipmap_mode: GPUSamplerMipmapMode, // The mipmap filter to apply to lookups. + address_mode_u: GPUSamplerAddressMode, // The addressing mode for U coordinates outside [0, 1). + address_mode_v: GPUSamplerAddressMode, // The addressing mode for V coordinates outside [0, 1). + address_mode_w: GPUSamplerAddressMode, // The addressing mode for W coordinates outside [0, 1). + mip_lod_bias: f32, // The bias to be added to mipmap LOD calculation. + max_anisotropy: f32, // The anisotropy value clamp used by the sampler. If enable_anisotropy is false, this is ignored. + compare_op: GPUCompareOp, // The comparison operator to apply to fetched data before filtering. + min_lod: f32, // Clamps the minimum of the computed LOD value. + max_lod: f32, // Clamps the maximum of the computed LOD value. + enable_anisotropy: bool, // true to enable anisotropic filtering. + enable_compare: bool, // true to enable comparison against a reference value during lookups. padding1: u8, padding2: u8, + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. }; -pub const GPUVertexBufferDescription = extern struct {}; +pub const GPUVertexBufferDescription = extern struct { + slot: u32, // The binding slot of the vertex buffer. + pitch: u32, // The byte pitch between consecutive elements of the vertex buffer. + input_rate: GPUVertexInputRate, // Whether attribute addressing is a function of the vertex index or instance index. + instance_step_rate: u32, // Reserved for future use. Must be set to 0. +}; -pub const GPUVertexAttribute = extern struct {}; +pub const GPUVertexAttribute = extern struct { + location: u32, // The shader input location index. + buffer_slot: u32, // The binding slot of the associated vertex buffer. + format: GPUVertexElementFormat, // The size and type of the attribute data. + offset: u32, // The byte offset of this attribute relative to the start of the vertex element. +}; -pub const GPUVertexInputState = extern struct {}; +pub const GPUVertexInputState = extern struct { + vertex_buffer_descriptions: *const GPUVertexBufferDescription, // A pointer to an array of vertex buffer descriptions. + num_vertex_buffers: u32, // The number of vertex buffer descriptions in the above array. + vertex_attributes: *const GPUVertexAttribute, // A pointer to an array of vertex attribute descriptions. + num_vertex_attributes: u32, // The number of vertex attribute descriptions in the above array. +}; -pub const GPUStencilOpState = extern struct {}; +pub const GPUStencilOpState = extern struct { + fail_op: GPUStencilOp, // The action performed on samples that fail the stencil test. + pass_op: GPUStencilOp, // The action performed on samples that pass the depth and stencil tests. + depth_fail_op: GPUStencilOp, // The action performed on samples that pass the stencil test and fail the depth test. + compare_op: GPUCompareOp, // The comparison operator used in the stencil test. +}; pub const GPUColorTargetBlendState = extern struct { + src_color_blendfactor: GPUBlendFactor, // The value to be multiplied by the source RGB value. + dst_color_blendfactor: GPUBlendFactor, // The value to be multiplied by the destination RGB value. + color_blend_op: GPUBlendOp, // The blend operation for the RGB components. + src_alpha_blendfactor: GPUBlendFactor, // The value to be multiplied by the source alpha. + dst_alpha_blendfactor: GPUBlendFactor, // The value to be multiplied by the destination alpha. + alpha_blend_op: GPUBlendOp, // The blend operation for the alpha component. + color_write_mask: GPUColorComponentFlags, // A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false. + enable_blend: bool, // Whether blending is enabled for the color target. + enable_color_write_mask: bool, // Whether the color write mask is enabled. padding1: u8, padding2: u8, }; -pub const GPUShaderCreateInfo = extern struct {}; +pub const GPUShaderCreateInfo = extern struct { + code_size: usize, // The size in bytes of the code pointed to. + code: [*c]const u8, // A pointer to shader code. + entrypoint: [*c]const u8, // A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. + format: GPUShaderFormat, // The format of the shader code. + stage: GPUShaderStage, // The stage the shader program corresponds to. + num_samplers: u32, // The number of samplers defined in the shader. + num_storage_textures: u32, // The number of storage textures defined in the shader. + num_storage_buffers: u32, // The number of storage buffers defined in the shader. + num_uniform_buffers: u32, // The number of uniform buffers defined in the shader. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; -pub const GPUTextureCreateInfo = extern struct {}; +pub const GPUTextureCreateInfo = extern struct { + type: GPUTextureType, // The base dimensionality of the texture. + format: GPUTextureFormat, // The pixel format of the texture. + usage: GPUTextureUsageFlags, // How the texture is intended to be used by the client. + width: u32, // The width of the texture. + height: u32, // The height of the texture. + layer_count_or_depth: u32, // The layer count or depth of the texture. This value is treated as a layer count on 2D array textures, and as a depth value on 3D textures. + num_levels: u32, // The number of mip levels in the texture. + sample_count: GPUSampleCount, // The number of samples per texel. Only applies if the texture is used as a render target. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; -pub const GPUBufferCreateInfo = extern struct {}; +pub const GPUBufferCreateInfo = extern struct { + usage: GPUBufferUsageFlags, // How the buffer is intended to be used by the client. + size: u32, // The size in bytes of the buffer. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; -pub const GPUTransferBufferCreateInfo = extern struct {}; +pub const GPUTransferBufferCreateInfo = extern struct { + usage: GPUTransferBufferUsage, // How the transfer buffer is intended to be used by the client. + size: u32, // The size in bytes of the transfer buffer. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; pub const GPURasterizerState = extern struct { + fill_mode: GPUFillMode, // Whether polygons will be filled in or drawn as lines. + cull_mode: GPUCullMode, // The facing direction in which triangles will be culled. + front_face: GPUFrontFace, // The vertex winding that will cause a triangle to be determined as front-facing. + depth_bias_constant_factor: f32, // A scalar factor controlling the depth value added to each fragment. + depth_bias_clamp: f32, // The maximum depth bias of a fragment. + depth_bias_slope_factor: f32, // A scalar factor applied to a fragment's slope in depth calculations. + enable_depth_bias: bool, // true to bias fragment depth values. + enable_depth_clip: bool, // true to enable depth clip, false to enable depth clamp. padding1: u8, padding2: u8, }; pub const GPUMultisampleState = extern struct { + sample_count: GPUSampleCount, // The number of samples to be used in rasterization. + sample_mask: u32, // Reserved for future use. Must be set to 0. + enable_mask: bool, // Reserved for future use. Must be set to false. padding1: u8, padding2: u8, padding3: u8, }; pub const GPUDepthStencilState = extern struct { + compare_op: GPUCompareOp, // The comparison operator used for depth testing. + back_stencil_state: GPUStencilOpState, // The stencil op state for back-facing triangles. + front_stencil_state: GPUStencilOpState, // The stencil op state for front-facing triangles. + compare_mask: u8, // Selects the bits of the stencil values participating in the stencil test. + write_mask: u8, // Selects the bits of the stencil values updated by the stencil test. + enable_depth_test: bool, // true enables the depth test. + enable_depth_write: bool, // true enables depth writes. Depth writes are always disabled when enable_depth_test is false. + enable_stencil_test: bool, // true enables the stencil test. padding1: u8, padding2: u8, padding3: u8, }; -pub const GPUColorTargetDescription = extern struct {}; +pub const GPUColorTargetDescription = extern struct { + format: GPUTextureFormat, // The pixel format of the texture to be used as a color target. + blend_state: GPUColorTargetBlendState, // The blend state to be used for the color target. +}; pub const GPUGraphicsPipelineTargetInfo = extern struct { + color_target_descriptions: *const GPUColorTargetDescription, // A pointer to an array of color target descriptions. + num_color_targets: u32, // The number of color target descriptions in the above array. + depth_stencil_format: GPUTextureFormat, // The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is false. + has_depth_stencil_target: bool, // true specifies that the pipeline uses a depth-stencil target. padding1: u8, padding2: u8, padding3: u8, }; -pub const GPUGraphicsPipelineCreateInfo = extern struct {}; +pub const GPUGraphicsPipelineCreateInfo = extern struct { + vertex_shader: ?*GPUShader, // The vertex shader used by the graphics pipeline. + fragment_shader: ?*GPUShader, // The fragment shader used by the graphics pipeline. + vertex_input_state: GPUVertexInputState, // The vertex layout of the graphics pipeline. + primitive_type: GPUPrimitiveType, // The primitive topology of the graphics pipeline. + rasterizer_state: GPURasterizerState, // The rasterizer state of the graphics pipeline. + multisample_state: GPUMultisampleState, // The multisample state of the graphics pipeline. + depth_stencil_state: GPUDepthStencilState, // The depth-stencil state of the graphics pipeline. + target_info: GPUGraphicsPipelineTargetInfo, // Formats and blend modes for the render targets of the graphics pipeline. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; -pub const GPUComputePipelineCreateInfo = extern struct {}; +pub const GPUComputePipelineCreateInfo = extern struct { + code_size: usize, // The size in bytes of the compute shader code pointed to. + code: [*c]const u8, // A pointer to compute shader code. + entrypoint: [*c]const u8, // A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. + format: GPUShaderFormat, // The format of the compute shader code. + num_samplers: u32, // The number of samplers defined in the shader. + num_readonly_storage_textures: u32, // The number of readonly storage textures defined in the shader. + num_readonly_storage_buffers: u32, // The number of readonly storage buffers defined in the shader. + num_readwrite_storage_textures: u32, // The number of read-write storage textures defined in the shader. + num_readwrite_storage_buffers: u32, // The number of read-write storage buffers defined in the shader. + num_uniform_buffers: u32, // The number of uniform buffers defined in the shader. + threadcount_x: u32, // The number of threads in the X dimension. This should match the value in the shader. + threadcount_y: u32, // The number of threads in the Y dimension. This should match the value in the shader. + threadcount_z: u32, // The number of threads in the Z dimension. This should match the value in the shader. + props: PropertiesID, // A properties ID for extensions. Should be 0 if no extensions are needed. +}; pub const GPUColorTargetInfo = extern struct { + texture: ?*GPUTexture, // The texture that will be used as a color target by a render pass. + mip_level: u32, // The mip level to use as a color target. + layer_or_depth_plane: u32, // The layer index or depth plane to use as a color target. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. + clear_color: FColor, // The color to clear the color target to at the start of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + load_op: GPULoadOp, // What is done with the contents of the color target at the beginning of the render pass. + store_op: GPUStoreOp, // What is done with the results of the render pass. + resolve_texture: ?*GPUTexture, // The texture that will receive the results of a multisample resolve operation. Ignored if a RESOLVE* store_op is not used. + resolve_mip_level: u32, // The mip level of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. + resolve_layer: u32, // The layer index of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. + cycle: bool, // true cycles the texture if the texture is bound and load_op is not LOAD + cycle_resolve_texture: bool, // true cycles the resolve texture if the resolve texture is bound. Ignored if a RESOLVE* store_op is not used. padding1: u8, padding2: u8, }; pub const GPUDepthStencilTargetInfo = extern struct { + texture: ?*GPUTexture, // The texture that will be used as the depth stencil target by the render pass. + clear_depth: f32, // The value to clear the depth component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. + load_op: GPULoadOp, // What is done with the depth contents at the beginning of the render pass. + store_op: GPUStoreOp, // What is done with the depth results of the render pass. + stencil_load_op: GPULoadOp, // What is done with the stencil contents at the beginning of the render pass. + stencil_store_op: GPUStoreOp, // What is done with the stencil results of the render pass. + cycle: bool, // true cycles the texture if the texture is bound and any load ops are not LOAD + clear_stencil: u8, // The value to clear the stencil component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. padding1: u8, padding2: u8, }; pub const GPUBlitInfo = extern struct { + source: GPUBlitRegion, // The source region for the blit. + destination: GPUBlitRegion, // The destination region for the blit. + load_op: GPULoadOp, // What is done with the contents of the destination before the blit. + clear_color: FColor, // The color to clear the destination region to before the blit. Ignored if load_op is not SDL_GPU_LOADOP_CLEAR. + flip_mode: FlipMode, // The flip mode for the source region. + filter: GPUFilter, // The filter mode used when blitting. + cycle: bool, // true cycles the destination texture if it is already bound. padding1: u8, padding2: u8, padding3: u8, }; -pub const GPUBufferBinding = extern struct {}; +pub const GPUBufferBinding = extern struct { + buffer: ?*GPUBuffer, // The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_VERTEX for SDL_BindGPUVertexBuffers, or SDL_GPU_BUFFERUSAGE_INDEX for SDL_BindGPUIndexBuffer. + offset: u32, // The starting byte of the data to bind in the buffer. +}; -pub const GPUTextureSamplerBinding = extern struct {}; +pub const GPUTextureSamplerBinding = extern struct { + texture: ?*GPUTexture, // The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. + sampler: ?*GPUSampler, // The sampler to bind. +}; pub const GPUStorageBufferReadWriteBinding = extern struct { + buffer: ?*GPUBuffer, // The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE. + cycle: bool, // true cycles the buffer if it is already bound. padding1: u8, padding2: u8, padding3: u8, }; pub const GPUStorageTextureReadWriteBinding = extern struct { + texture: ?*GPUTexture, // The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE or SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE. + mip_level: u32, // The mip level index to bind. + layer: u32, // The layer index to bind. + cycle: bool, // true cycles the texture if it is already bound. padding1: u8, padding2: u8, padding3: u8, diff --git a/lib/sdl3/v2/init.zig b/lib/sdl3/v2/init.zig new file mode 100644 index 0000000..fe42b68 --- /dev/null +++ b/lib/sdl3/v2/init.zig @@ -0,0 +1,100 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Event = extern union { + type: u32, // Event type, shared with all events, Uint32 to cover user events which are not in the SDL_EventType enumeration + common: CommonEvent, // Common event data + display: DisplayEvent, // Display event data + window: WindowEvent, // Window event data + kdevice: KeyboardDeviceEvent, // Keyboard device change event data + key: KeyboardEvent, // Keyboard event data + edit: TextEditingEvent, // Text editing event data + edit_candidates: TextEditingCandidatesEvent, // Text editing candidates event data + text: TextInputEvent, // Text input event data + mdevice: MouseDeviceEvent, // Mouse device change event data + motion: MouseMotionEvent, // Mouse motion event data + button: MouseButtonEvent, // Mouse button event data + wheel: MouseWheelEvent, // Mouse wheel event data + jdevice: JoyDeviceEvent, // Joystick device change event data + jaxis: JoyAxisEvent, // Joystick axis event data + jball: JoyBallEvent, // Joystick ball event data + jhat: JoyHatEvent, // Joystick hat event data + jbutton: JoyButtonEvent, // Joystick button event data + jbattery: JoyBatteryEvent, // Joystick battery event data + gdevice: GamepadDeviceEvent, // Gamepad device event data + gaxis: GamepadAxisEvent, // Gamepad axis event data + gbutton: GamepadButtonEvent, // Gamepad button event data + gtouchpad: GamepadTouchpadEvent, // Gamepad touchpad event data + gsensor: GamepadSensorEvent, // Gamepad sensor event data + adevice: AudioDeviceEvent, // Audio device event data + cdevice: CameraDeviceEvent, // Camera device event data + sensor: SensorEvent, // Sensor event data + quit: QuitEvent, // Quit request event data + user: UserEvent, // Custom event data + tfinger: TouchFingerEvent, // Touch finger event data + pproximity: PenProximityEvent, // Pen proximity event data + ptouch: PenTouchEvent, // Pen tip touching event data + pmotion: PenMotionEvent, // Pen motion event data + pbutton: PenButtonEvent, // Pen button event data + paxis: PenAxisEvent, // Pen axis event data + render: RenderEvent, // Render event data + drop: DropEvent, // Drag and drop event data + clipboard: ClipboardEvent, // Clipboard event data + padding: [128]u8, +}; + +pub const InitFlags = packed struct(u32) { + pad0: u31 = 0, + rsvd: bool = false, +}; + +pub const AppInit_func = *const fn(appstate: [*c]?*anyopaque, argc: c_int, argv[]: [*c]u8) callconv(.C) AppResult; + +pub const AppIterate_func = *const fn(appstate: ?*anyopaque) callconv(.C) AppResult; + +pub const AppEvent_func = *const fn(appstate: ?*anyopaque, event: ?*Event) callconv(.C) AppResult; + +pub const AppQuit_func = *const fn(appstate: ?*anyopaque, result: AppResult) callconv(.C) void; + +pub inline fn init(flags: InitFlags) bool { + return c.SDL_Init(@bitCast(flags)); +} + +pub inline fn initSubSystem(flags: InitFlags) bool { + return c.SDL_InitSubSystem(@bitCast(flags)); +} + +pub inline fn quitSubSystem(flags: InitFlags) void { + return c.SDL_QuitSubSystem(@bitCast(flags)); +} + +pub inline fn wasInit(flags: InitFlags) InitFlags { + return @bitCast(c.SDL_WasInit(@bitCast(flags))); +} + +pub inline fn quit() void { + return c.SDL_Quit(); +} + +pub inline fn isMainThread() bool { + return c.SDL_IsMainThread(); +} + +pub const MainThreadCallback = *const fn(userdata: ?*anyopaque) callconv(.C) void; + +pub inline fn runOnMainThread(callback: MainThreadCallback, userdata: ?*anyopaque, wait_complete: bool) bool { + return c.SDL_RunOnMainThread(callback, userdata, wait_complete); +} + +pub inline fn setAppMetadata(appname: [*c]const u8, appversion: [*c]const u8, appidentifier: [*c]const u8) bool { + return c.SDL_SetAppMetadata(appname, appversion, appidentifier); +} + +pub inline fn setAppMetadataProperty(name: [*c]const u8, value: [*c]const u8) bool { + return c.SDL_SetAppMetadataProperty(name, value); +} + +pub inline fn getAppMetadataProperty(name: [*c]const u8) [*c]const u8 { + return c.SDL_GetAppMetadataProperty(name); +} + diff --git a/lib/sdl3/v2/iostream.zig b/lib/sdl3/v2/iostream.zig new file mode 100644 index 0000000..60fd72c --- /dev/null +++ b/lib/sdl3/v2/iostream.zig @@ -0,0 +1,210 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PropertiesID = u32; + +pub const IOStreamInterface = extern struct { + version: u32, + userdata: Sint64 (SDLCALL *size)(void *, + whence: Sint64 (SDLCALL *seek)(void *userdata, Sint64 offset, SDL_IOWhence, + status: size_t (SDLCALL *read)(void *userdata, void *ptr, size_t size, SDL_IOStatus *, + status: size_t (SDLCALL *write)(void *userdata, const void *ptr, size_t size, SDL_IOStatus *, + status: bool (SDLCALL *flush)(void *userdata, SDL_IOStatus *, + userdata: bool (SDLCALL *close)(void *, +}; + +pub const IOStream = opaque { + pub inline fn closeIO(iostream: *IOStream) bool { + return c.SDL_CloseIO(iostream); + } + + pub inline fn getIOProperties(iostream: *IOStream) PropertiesID { + return c.SDL_GetIOProperties(iostream); + } + + pub inline fn getIOStatus(iostream: *IOStream) IOStatus { + return c.SDL_GetIOStatus(iostream); + } + + pub inline fn getIOSize(iostream: *IOStream) i64 { + return c.SDL_GetIOSize(iostream); + } + + pub inline fn seekIO(iostream: *IOStream, offset: i64, whence: IOWhence) i64 { + return c.SDL_SeekIO(iostream, offset, whence); + } + + pub inline fn tellIO(iostream: *IOStream) i64 { + return c.SDL_TellIO(iostream); + } + + pub inline fn readIO(iostream: *IOStream, ptr: ?*anyopaque, size: usize) usize { + return c.SDL_ReadIO(iostream, ptr, size); + } + + pub inline fn writeIO(iostream: *IOStream, ptr: ?*const anyopaque, size: usize) usize { + return c.SDL_WriteIO(iostream, ptr, size); + } + + pub inline fn iOprintf(iostream: *IOStream, fmt: [*c]const u8, ...) usize { + return c.SDL_IOprintf(iostream, fmt, ); + } + + pub inline fn iOvprintf(iostream: *IOStream, fmt: [*c]const u8, ap: std.builtin.VaList) usize { + return c.SDL_IOvprintf(iostream, fmt, ap); + } + + pub inline fn flushIO(iostream: *IOStream) bool { + return c.SDL_FlushIO(iostream); + } + + pub inline fn loadFile_IO(iostream: *IOStream, datasize: *usize, closeio: bool) ?*anyopaque { + return c.SDL_LoadFile_IO(iostream, @ptrCast(datasize), closeio); + } + + pub inline fn saveFile_IO(iostream: *IOStream, data: ?*const anyopaque, datasize: usize, closeio: bool,) bool { + return c.SDL_SaveFile_IO(iostream, data, datasize, closeio); + } + + pub inline fn readU8(iostream: *IOStream, value: [*c]u8) bool { + return c.SDL_ReadU8(iostream, value); + } + + pub inline fn readS8(iostream: *IOStream, value: Sint8 *) bool { + return c.SDL_ReadS8(iostream, value); + } + + pub inline fn readU16LE(iostream: *IOStream, value: Uint16 *) bool { + return c.SDL_ReadU16LE(iostream, value); + } + + pub inline fn readS16LE(iostream: *IOStream, value: Sint16 *) bool { + return c.SDL_ReadS16LE(iostream, value); + } + + pub inline fn readU16BE(iostream: *IOStream, value: Uint16 *) bool { + return c.SDL_ReadU16BE(iostream, value); + } + + pub inline fn readS16BE(iostream: *IOStream, value: Sint16 *) bool { + return c.SDL_ReadS16BE(iostream, value); + } + + pub inline fn readU32LE(iostream: *IOStream, value: *u32) bool { + return c.SDL_ReadU32LE(iostream, @ptrCast(value)); + } + + pub inline fn readS32LE(iostream: *IOStream, value: *i32) bool { + return c.SDL_ReadS32LE(iostream, @ptrCast(value)); + } + + pub inline fn readU32BE(iostream: *IOStream, value: *u32) bool { + return c.SDL_ReadU32BE(iostream, @ptrCast(value)); + } + + pub inline fn readS32BE(iostream: *IOStream, value: *i32) bool { + return c.SDL_ReadS32BE(iostream, @ptrCast(value)); + } + + pub inline fn readU64LE(iostream: *IOStream, value: *u64) bool { + return c.SDL_ReadU64LE(iostream, @ptrCast(value)); + } + + pub inline fn readS64LE(iostream: *IOStream, value: Sint64 *) bool { + return c.SDL_ReadS64LE(iostream, value); + } + + pub inline fn readU64BE(iostream: *IOStream, value: *u64) bool { + return c.SDL_ReadU64BE(iostream, @ptrCast(value)); + } + + pub inline fn readS64BE(iostream: *IOStream, value: Sint64 *) bool { + return c.SDL_ReadS64BE(iostream, value); + } + + pub inline fn writeU8(iostream: *IOStream, value: u8) bool { + return c.SDL_WriteU8(iostream, value); + } + + pub inline fn writeS8(iostream: *IOStream, value: i8) bool { + return c.SDL_WriteS8(iostream, value); + } + + pub inline fn writeU16LE(iostream: *IOStream, value: u16) bool { + return c.SDL_WriteU16LE(iostream, value); + } + + pub inline fn writeS16LE(iostream: *IOStream, value: i16) bool { + return c.SDL_WriteS16LE(iostream, value); + } + + pub inline fn writeU16BE(iostream: *IOStream, value: u16) bool { + return c.SDL_WriteU16BE(iostream, value); + } + + pub inline fn writeS16BE(iostream: *IOStream, value: i16) bool { + return c.SDL_WriteS16BE(iostream, value); + } + + pub inline fn writeU32LE(iostream: *IOStream, value: u32) bool { + return c.SDL_WriteU32LE(iostream, value); + } + + pub inline fn writeS32LE(iostream: *IOStream, value: i32) bool { + return c.SDL_WriteS32LE(iostream, value); + } + + pub inline fn writeU32BE(iostream: *IOStream, value: u32) bool { + return c.SDL_WriteU32BE(iostream, value); + } + + pub inline fn writeS32BE(iostream: *IOStream, value: i32) bool { + return c.SDL_WriteS32BE(iostream, value); + } + + pub inline fn writeU64LE(iostream: *IOStream, value: u64) bool { + return c.SDL_WriteU64LE(iostream, value); + } + + pub inline fn writeS64LE(iostream: *IOStream, value: i64) bool { + return c.SDL_WriteS64LE(iostream, value); + } + + pub inline fn writeU64BE(iostream: *IOStream, value: u64) bool { + return c.SDL_WriteU64BE(iostream, value); + } + + pub inline fn writeS64BE(iostream: *IOStream, value: i64) bool { + return c.SDL_WriteS64BE(iostream, value); + } + +}; + +pub inline fn ioFromFile(file: [*c]const u8, mode: [*c]const u8) ?*IOStream { + return c.SDL_IOFromFile(file, mode); +} + +pub inline fn ioFromMem(mem: ?*anyopaque, size: usize) ?*IOStream { + return c.SDL_IOFromMem(mem, size); +} + +pub inline fn ioFromConstMem(mem: ?*const anyopaque, size: usize) ?*IOStream { + return c.SDL_IOFromConstMem(mem, size); +} + +pub inline fn ioFromDynamicMem() ?*IOStream { + return c.SDL_IOFromDynamicMem(); +} + +pub inline fn openIO(iface: *const IOStreamInterface, userdata: ?*anyopaque) ?*IOStream { + return c.SDL_OpenIO(@ptrCast(iface), userdata); +} + +pub inline fn loadFile(file: [*c]const u8, datasize: *usize) ?*anyopaque { + return c.SDL_LoadFile(file, @ptrCast(datasize)); +} + +pub inline fn saveFile(file: [*c]const u8, data: ?*const anyopaque, datasize: usize) bool { + return c.SDL_SaveFile(file, data, datasize); +} + diff --git a/lib/sdl3/v2/keyboard.zig b/lib/sdl3/v2/keyboard.zig index f7c7b78..63bc1ee 100644 --- a/lib/sdl3/v2/keyboard.zig +++ b/lib/sdl3/v2/keyboard.zig @@ -292,10 +292,6 @@ pub inline fn getKeyFromName(name: [*c]const u8) Keycode { return c.SDL_GetKeyFromName(name); } -pub const TextInputType = enum(c_int) {}; - -pub const Capitalization = enum(c_int) {}; - pub inline fn hasScreenKeyboardSupport() bool { return c.SDL_HasScreenKeyboardSupport(); } diff --git a/lib/sdl3/v2/keycode.zig b/lib/sdl3/v2/keycode.zig new file mode 100644 index 0000000..d0aaa55 --- /dev/null +++ b/lib/sdl3/v2/keycode.zig @@ -0,0 +1,6 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Keycode = u32; + +pub const Keymod = u16; diff --git a/lib/sdl3/v2/mouse.zig b/lib/sdl3/v2/mouse.zig new file mode 100644 index 0000000..dfd7863 --- /dev/null +++ b/lib/sdl3/v2/mouse.zig @@ -0,0 +1,117 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Window = opaque { + pub inline fn warpMouseInWindow(window: *Window, x: f32, y: f32) void { + return c.SDL_WarpMouseInWindow(window, x, y); + } + + pub inline fn setWindowRelativeMouseMode(window: *Window, enabled: bool) bool { + return c.SDL_SetWindowRelativeMouseMode(window, enabled); + } + + pub inline fn getWindowRelativeMouseMode(window: *Window) bool { + return c.SDL_GetWindowRelativeMouseMode(window); + } +}; + +pub const Surface = opaque { + pub inline fn createColorCursor(surface: *Surface, hot_x: c_int, hot_y: c_int) ?*Cursor { + return c.SDL_CreateColorCursor(surface, hot_x, hot_y); + } +}; + +pub const MouseID = u32; + +pub const Cursor = opaque { + pub inline fn setCursor(cursor: *Cursor) bool { + return c.SDL_SetCursor(cursor); + } + + pub inline fn destroyCursor(cursor: *Cursor) void { + return c.SDL_DestroyCursor(cursor); + } +}; + +pub const SystemCursor = enum(c_int) { + systemCursorCount, +}; + +pub const MouseButtonFlags = packed struct(u32) { + buttonLeft: bool = false, + buttonMiddle: bool = false, + buttonX1: bool = false, + pad0: u28 = 0, + rsvd: bool = false, +}; + +pub inline fn hasMouse() bool { + return c.SDL_HasMouse(); +} + +pub inline fn getMice(count: *c_int) ?*MouseID { + return c.SDL_GetMice(@ptrCast(count)); +} + +pub inline fn getMouseNameForID(instance_id: MouseID) [*c]const u8 { + return c.SDL_GetMouseNameForID(instance_id); +} + +pub inline fn getMouseFocus() ?*Window { + return c.SDL_GetMouseFocus(); +} + +pub inline fn getMouseState(x: *f32, y: *f32) MouseButtonFlags { + return @bitCast(c.SDL_GetMouseState(@ptrCast(x), @ptrCast(y))); +} + +pub inline fn getGlobalMouseState(x: *f32, y: *f32) MouseButtonFlags { + return @bitCast(c.SDL_GetGlobalMouseState(@ptrCast(x), @ptrCast(y))); +} + +pub inline fn getRelativeMouseState(x: *f32, y: *f32) MouseButtonFlags { + return @bitCast(c.SDL_GetRelativeMouseState(@ptrCast(x), @ptrCast(y))); +} + +pub inline fn warpMouseGlobal(x: f32, y: f32) bool { + return c.SDL_WarpMouseGlobal(x, y); +} + +pub inline fn captureMouse(enabled: bool) bool { + return c.SDL_CaptureMouse(enabled); +} + +pub inline fn createCursor( + data: [*c]const u8, + mask: [*c]const u8, + w: c_int, + h: c_int, + hot_x: c_int, + hot_y: c_int, +) ?*Cursor { + return c.SDL_CreateCursor(data, mask, w, h, hot_x, hot_y); +} + +pub inline fn createSystemCursor(id: SystemCursor) ?*Cursor { + return c.SDL_CreateSystemCursor(id); +} + +pub inline fn getCursor() ?*Cursor { + return c.SDL_GetCursor(); +} + +pub inline fn getDefaultCursor() ?*Cursor { + return c.SDL_GetDefaultCursor(); +} + +pub inline fn showCursor() bool { + return c.SDL_ShowCursor(); +} + +pub inline fn hideCursor() bool { + return c.SDL_HideCursor(); +} + +pub inline fn cursorVisible() bool { + return c.SDL_CursorVisible(); +} diff --git a/lib/sdl3/v2/pixels.zig b/lib/sdl3/v2/pixels.zig new file mode 100644 index 0000000..722f0c0 --- /dev/null +++ b/lib/sdl3/v2/pixels.zig @@ -0,0 +1,292 @@ +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) { + pixelformatUnknown, + pixelformatIndex1lsb, + pixelformatIndex1msb, + pixelformatIndex2lsb, + pixelformatIndex2msb, + pixelformatIndex4lsb, + pixelformatIndex4msb, + pixelformatIndex8, + pixelformatRgb332, + pixelformatXrgb4444, + pixelformatXbgr4444, + pixelformatXrgb1555, + pixelformatXbgr1555, + pixelformatArgb4444, + pixelformatRgba4444, + pixelformatAbgr4444, + pixelformatBgra4444, + pixelformatArgb1555, + pixelformatRgba5551, + pixelformatAbgr1555, + pixelformatBgra5551, + pixelformatRgb565, + pixelformatBgr565, + pixelformatRgb24, + pixelformatBgr24, + pixelformatXrgb8888, + pixelformatRgbx8888, + pixelformatXbgr8888, + pixelformatBgrx8888, + pixelformatArgb8888, + pixelformatRgba8888, + pixelformatAbgr8888, + pixelformatBgra8888, + pixelformatXrgb2101010, + pixelformatXbgr2101010, + pixelformatArgb2101010, + pixelformatAbgr2101010, + pixelformatRgb48, + pixelformatBgr48, + pixelformatRgba64, + pixelformatArgb64, + pixelformatBgra64, + pixelformatAbgr64, + pixelformatRgb48Float, + pixelformatBgr48Float, + pixelformatRgba64Float, + pixelformatArgb64Float, + pixelformatBgra64Float, + pixelformatAbgr64Float, + pixelformatRgb96Float, + pixelformatBgr96Float, + pixelformatRgba128Float, + pixelformatArgb128Float, + pixelformatBgra128Float, + pixelformatAbgr128Float, + pixelformatRgba32, + pixelformatArgb32, + pixelformatBgra32, + pixelformatAbgr32, + pixelformatRgbx32, + pixelformatXrgb32, + pixelformatBgrx32, + pixelformatXbgr32, +}; + +pub const ColorType = enum(c_int) { + colorTypeUnknown, + colorTypeRgb, + colorTypeYcbcr, +}; + +pub const ColorRange = enum(c_int) { + colorRangeUnknown, +}; + +pub const ColorPrimaries = enum(c_int) { + colorPrimariesUnknown, + colorPrimariesUnspecified, + colorPrimariesCustom, +}; + +pub const TransferCharacteristics = enum(c_int) { + transferCharacteristicsUnknown, + transferCharacteristicsUnspecified, + transferCharacteristicsLinear, + transferCharacteristicsLog100, + transferCharacteristicsLog100Sqrt10, + transferCharacteristicsCustom, +}; + +pub const MatrixCoefficients = enum(c_int) { + matrixCoefficientsIdentity, + matrixCoefficientsUnspecified, + matrixCoefficientsYcgco, + matrixCoefficientsChromaDerivedNcl, + matrixCoefficientsChromaDerivedCl, + matrixCoefficientsCustom, +}; + +pub const Colorspace = enum(c_int) { + colorspaceUnknown, +}; + +pub const Color = extern struct { + r: u8, + g: u8, + b: u8, + a: u8, +}; + +pub const FColor = extern struct { + r: f32, + g: f32, + b: f32, + a: f32, +}; + +pub const Palette = extern struct { + ncolors: c_int, // number of elements in `colors`. + colors: ?*Color, // an array of colors, `ncolors` long. + version: u32, // internal use only, do not touch. + refcount: c_int, // internal use only, do not touch. +}; + +pub const PixelFormatDetails = extern struct { + format: PixelFormat, + bits_per_pixel: u8, + bytes_per_pixel: u8, + padding: [2]u8, + Rmask: u32, + Gmask: u32, + Bmask: u32, + Amask: u32, + Rbits: u8, + Gbits: u8, + Bbits: u8, + Abits: u8, + Rshift: u8, + Gshift: u8, + Bshift: u8, + Ashift: u8, +}; + +pub inline fn getPixelFormatName(format: PixelFormat) [*c]const u8 { + return c.SDL_GetPixelFormatName(@bitCast(format)); +} + +pub inline fn getMasksForPixelFormat( + format: PixelFormat, + bpp: *c_int, + Rmask: *u32, + Gmask: *u32, + Bmask: *u32, + Amask: *u32, +) bool { + return c.SDL_GetMasksForPixelFormat(@bitCast(format), @ptrCast(bpp), @ptrCast(Rmask), @ptrCast(Gmask), @ptrCast(Bmask), @ptrCast(Amask)); +} + +pub inline fn getPixelFormatForMasks( + bpp: c_int, + Rmask: u32, + Gmask: u32, + Bmask: u32, + Amask: u32, +) PixelFormat { + return @bitCast(c.SDL_GetPixelFormatForMasks(bpp, Rmask, Gmask, Bmask, Amask)); +} + +pub inline fn getPixelFormatDetails(format: PixelFormat) *const PixelFormatDetails { + return @ptrCast(c.SDL_GetPixelFormatDetails(@bitCast(format))); +} + +pub inline fn createPalette(ncolors: c_int) ?*Palette { + return c.SDL_CreatePalette(ncolors); +} + +pub inline fn setPaletteColors( + palette: ?*Palette, + colors: *const Color, + firstcolor: c_int, + ncolors: c_int, +) bool { + return c.SDL_SetPaletteColors(palette, @ptrCast(colors), firstcolor, ncolors); +} + +pub inline fn destroyPalette(palette: ?*Palette) void { + return c.SDL_DestroyPalette(palette); +} + +pub inline fn mapRGB( + format: *const PixelFormatDetails, + palette: *const Palette, + r: u8, + g: u8, + b: u8, +) u32 { + return c.SDL_MapRGB(@ptrCast(format), @ptrCast(palette), r, g, b); +} + +pub inline fn mapRGBA( + format: *const PixelFormatDetails, + palette: *const Palette, + r: u8, + g: u8, + b: u8, + a: u8, +) u32 { + return c.SDL_MapRGBA(@ptrCast(format), @ptrCast(palette), r, g, b, a); +} + +pub inline fn getRGB( + pixel: u32, + format: *const PixelFormatDetails, + palette: *const Palette, + r: [*c]u8, + g: [*c]u8, + b: [*c]u8, +) void { + return c.SDL_GetRGB(pixel, @ptrCast(format), @ptrCast(palette), r, g, b); +} + +pub inline fn getRGBA( + pixel: u32, + format: *const PixelFormatDetails, + palette: *const Palette, + r: [*c]u8, + g: [*c]u8, + b: [*c]u8, + a: [*c]u8, +) void { + return c.SDL_GetRGBA(pixel, @ptrCast(format), @ptrCast(palette), r, g, b, a); +} diff --git a/lib/sdl3/v2/rect.zig b/lib/sdl3/v2/rect.zig new file mode 100644 index 0000000..fe751eb --- /dev/null +++ b/lib/sdl3/v2/rect.zig @@ -0,0 +1,88 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Point = extern struct { + x: c_int, + y: c_int, +}; + +pub const FPoint = extern struct { + x: f32, + y: f32, +}; + +pub const Rect = extern struct { + x: c_int, + y: c_int, + w: c_int, + h: c_int, +}; + +pub const FRect = extern struct { + x: f32, + y: f32, + w: f32, + h: f32, +}; + +pub inline fn hasRectIntersection(A: *const Rect, B: *const Rect) bool { + return c.SDL_HasRectIntersection(@ptrCast(A), @ptrCast(B)); +} + +pub inline fn getRectIntersection(A: *const Rect, B: *const Rect, result: ?*Rect) bool { + return c.SDL_GetRectIntersection(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectUnion(A: *const Rect, B: *const Rect, result: ?*Rect) bool { + return c.SDL_GetRectUnion(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectEnclosingPoints( + points: *const Point, + count: c_int, + clip: *const Rect, + result: ?*Rect, +) bool { + return c.SDL_GetRectEnclosingPoints(@ptrCast(points), count, @ptrCast(clip), result); +} + +pub inline fn getRectAndLineIntersection( + rect: *const Rect, + X1: *c_int, + Y1: *c_int, + X2: *c_int, + Y2: *c_int, +) bool { + return c.SDL_GetRectAndLineIntersection(@ptrCast(rect), @ptrCast(X1), @ptrCast(Y1), @ptrCast(X2), @ptrCast(Y2)); +} + +pub inline fn hasRectIntersectionFloat(A: *const FRect, B: *const FRect) bool { + return c.SDL_HasRectIntersectionFloat(@ptrCast(A), @ptrCast(B)); +} + +pub inline fn getRectIntersectionFloat(A: *const FRect, B: *const FRect, result: ?*FRect) bool { + return c.SDL_GetRectIntersectionFloat(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectUnionFloat(A: *const FRect, B: *const FRect, result: ?*FRect) bool { + return c.SDL_GetRectUnionFloat(@ptrCast(A), @ptrCast(B), result); +} + +pub inline fn getRectEnclosingPointsFloat( + points: *const FPoint, + count: c_int, + clip: *const FRect, + result: ?*FRect, +) bool { + return c.SDL_GetRectEnclosingPointsFloat(@ptrCast(points), count, @ptrCast(clip), result); +} + +pub inline fn getRectAndLineIntersectionFloat( + rect: *const FRect, + X1: *f32, + Y1: *f32, + X2: *f32, + Y2: *f32, +) bool { + return c.SDL_GetRectAndLineIntersectionFloat(@ptrCast(rect), @ptrCast(X1), @ptrCast(Y1), @ptrCast(X2), @ptrCast(Y2)); +} diff --git a/lib/sdl3/v2/scancode.zig b/lib/sdl3/v2/scancode.zig new file mode 100644 index 0000000..b98d773 --- /dev/null +++ b/lib/sdl3/v2/scancode.zig @@ -0,0 +1,184 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const Scancode = enum(c_int) { + scancodeUnknown, + scancodeA, + scancodeB, + scancodeC, + scancodeD, + scancodeE, + scancodeF, + scancodeG, + scancodeH, + scancodeI, + scancodeJ, + scancodeK, + scancodeL, + scancodeM, + scancodeN, + scancodeO, + scancodeP, + scancodeQ, + scancodeR, + scancodeS, + scancodeT, + scancodeU, + scancodeV, + scancodeW, + scancodeX, + scancodeY, + scancodeZ, + scancode1, + scancode2, + scancode3, + scancode4, + scancode5, + scancode6, + scancode7, + scancode8, + scancode9, + scancode0, + scancodeReturn, + scancodeEscape, + scancodeBackspace, + scancodeTab, + scancodeSpace, + scancodeMinus, + scancodeEquals, + scancodeLeftbracket, + scancodeRightbracket, + scancodeSemicolon, + scancodeApostrophe, + scancodeComma, + scancodePeriod, + scancodeSlash, + scancodeCapslock, + scancodeF1, + scancodeF2, + scancodeF3, + scancodeF4, + scancodeF5, + scancodeF6, + scancodeF7, + scancodeF8, + scancodeF9, + scancodeF10, + scancodeF11, + scancodeF12, + scancodePrintscreen, + scancodeScrolllock, + scancodePause, + scancodeHome, + scancodePageup, + scancodeDelete, + scancodeEnd, + scancodePagedown, + scancodeRight, + scancodeLeft, + scancodeDown, + scancodeUp, + scancodeKpDivide, + scancodeKpMultiply, + scancodeKpMinus, + scancodeKpPlus, + scancodeKpEnter, + scancodeKp1, + scancodeKp2, + scancodeKp3, + scancodeKp4, + scancodeKp5, + scancodeKp6, + scancodeKp7, + scancodeKp8, + scancodeKp9, + scancodeKp0, + scancodeKpPeriod, + scancodeKpEquals, + scancodeF13, + scancodeF14, + scancodeF15, + scancodeF16, + scancodeF17, + scancodeF18, + scancodeF19, + scancodeF20, + scancodeF21, + scancodeF22, + scancodeF23, + scancodeF24, + scancodeExecute, + scancodeSelect, + scancodeMute, + scancodeVolumeup, + scancodeVolumedown, + scancodeKpComma, + scancodeKpEqualsas400, + scancodeInternational2, + scancodeInternational4, + scancodeInternational5, + scancodeInternational6, + scancodeInternational7, + scancodeInternational8, + scancodeInternational9, + scancodeSysreq, + scancodeClear, + scancodePrior, + scancodeReturn2, + scancodeSeparator, + scancodeOut, + scancodeOper, + scancodeClearagain, + scancodeCrsel, + scancodeExsel, + scancodeKp00, + scancodeKp000, + scancodeThousandsseparator, + scancodeDecimalseparator, + scancodeCurrencyunit, + scancodeCurrencysubunit, + scancodeKpLeftparen, + scancodeKpRightparen, + scancodeKpLeftbrace, + scancodeKpRightbrace, + scancodeKpTab, + scancodeKpBackspace, + scancodeKpA, + scancodeKpB, + scancodeKpC, + scancodeKpD, + scancodeKpE, + scancodeKpF, + scancodeKpXor, + scancodeKpPower, + scancodeKpPercent, + scancodeKpLess, + scancodeKpGreater, + scancodeKpAmpersand, + scancodeKpDblampersand, + scancodeKpVerticalbar, + scancodeKpDblverticalbar, + scancodeKpColon, + scancodeKpHash, + scancodeKpSpace, + scancodeKpAt, + scancodeKpExclam, + scancodeKpMemstore, + scancodeKpMemrecall, + scancodeKpMemclear, + scancodeKpMemadd, + scancodeKpMemsubtract, + scancodeKpMemmultiply, + scancodeKpMemdivide, + scancodeKpPlusminus, + scancodeKpClear, + scancodeKpClearentry, + scancodeKpBinary, + scancodeKpOctal, + scancodeKpDecimal, + scancodeKpHexadecimal, + scancodeLctrl, + scancodeLshift, + scancodeRctrl, + scancodeRshift, +}; diff --git a/lib/sdl3/v2/surface.zig b/lib/sdl3/v2/surface.zig new file mode 100644 index 0000000..36aeeb8 --- /dev/null +++ b/lib/sdl3/v2/surface.zig @@ -0,0 +1,499 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub const PixelFormat = enum(c_int) { + pixelformatUnknown, + pixelformatIndex1lsb, + pixelformatIndex1msb, + pixelformatIndex2lsb, + pixelformatIndex2msb, + pixelformatIndex4lsb, + pixelformatIndex4msb, + pixelformatIndex8, + pixelformatRgb332, + pixelformatXrgb4444, + pixelformatXbgr4444, + pixelformatXrgb1555, + pixelformatXbgr1555, + pixelformatArgb4444, + pixelformatRgba4444, + pixelformatAbgr4444, + pixelformatBgra4444, + pixelformatArgb1555, + pixelformatRgba5551, + pixelformatAbgr1555, + pixelformatBgra5551, + pixelformatRgb565, + pixelformatBgr565, + pixelformatRgb24, + pixelformatBgr24, + pixelformatXrgb8888, + pixelformatRgbx8888, + pixelformatXbgr8888, + pixelformatBgrx8888, + pixelformatArgb8888, + pixelformatRgba8888, + pixelformatAbgr8888, + pixelformatBgra8888, + pixelformatXrgb2101010, + pixelformatXbgr2101010, + pixelformatArgb2101010, + pixelformatAbgr2101010, + pixelformatRgb48, + pixelformatBgr48, + pixelformatRgba64, + pixelformatArgb64, + pixelformatBgra64, + pixelformatAbgr64, + pixelformatRgb48Float, + pixelformatBgr48Float, + pixelformatRgba64Float, + pixelformatArgb64Float, + pixelformatBgra64Float, + pixelformatAbgr64Float, + pixelformatRgb96Float, + pixelformatBgr96Float, + pixelformatRgba128Float, + pixelformatArgb128Float, + pixelformatBgra128Float, + pixelformatAbgr128Float, + pixelformatRgba32, + pixelformatArgb32, + pixelformatBgra32, + pixelformatAbgr32, + pixelformatRgbx32, + pixelformatXrgb32, + pixelformatBgrx32, + pixelformatXbgr32, +}; + +pub const BlendMode = u32; + +pub const IOStream = opaque { + pub inline fn loadBMP_IO(iostream: *IOStream, closeio: bool) ?*Surface { + return c.SDL_LoadBMP_IO(iostream, closeio); + } +}; + +pub const Rect = extern struct { + x: c_int, + y: c_int, + w: c_int, + h: c_int, +}; + +pub const Palette = extern struct { + ncolors: c_int, // number of elements in `colors`. + colors: ?*Color, // an array of colors, `ncolors` long. + version: u32, // internal use only, do not touch. + refcount: c_int, // internal use only, do not touch. +}; + +pub const Colorspace = enum(c_int) { + colorspaceUnknown, +}; + +pub const PropertiesID = u32; + +pub const SurfaceFlags = packed struct(u32) { + pad0: u31 = 0, + rsvd: bool = false, +}; + +pub const ScaleMode = enum(c_int) { + scalemodeInvalid, +}; + +pub const Surface = opaque { + pub inline fn destroySurface(surface: *Surface) void { + return c.SDL_DestroySurface(surface); + } + + pub inline fn getSurfaceProperties(surface: *Surface) PropertiesID { + return c.SDL_GetSurfaceProperties(surface); + } + + pub inline fn setSurfaceColorspace(surface: *Surface, colorspace: Colorspace) bool { + return c.SDL_SetSurfaceColorspace(surface, colorspace); + } + + pub inline fn getSurfaceColorspace(surface: *Surface) Colorspace { + return c.SDL_GetSurfaceColorspace(surface); + } + + pub inline fn createSurfacePalette(surface: *Surface) ?*Palette { + return c.SDL_CreateSurfacePalette(surface); + } + + pub inline fn setSurfacePalette(surface: *Surface, palette: ?*Palette) bool { + return c.SDL_SetSurfacePalette(surface, palette); + } + + pub inline fn getSurfacePalette(surface: *Surface) ?*Palette { + return c.SDL_GetSurfacePalette(surface); + } + + pub inline fn addSurfaceAlternateImage(surface: *Surface, image: ?*Surface) bool { + return c.SDL_AddSurfaceAlternateImage(surface, image); + } + + pub inline fn surfaceHasAlternateImages(surface: *Surface) bool { + return c.SDL_SurfaceHasAlternateImages(surface); + } + + pub inline fn getSurfaceImages(surface: *Surface, count: *c_int) ?*?*Surface { + return c.SDL_GetSurfaceImages(surface, @ptrCast(count)); + } + + pub inline fn removeSurfaceAlternateImages(surface: *Surface) void { + return c.SDL_RemoveSurfaceAlternateImages(surface); + } + + pub inline fn lockSurface(surface: *Surface) bool { + return c.SDL_LockSurface(surface); + } + + pub inline fn unlockSurface(surface: *Surface) void { + return c.SDL_UnlockSurface(surface); + } + + pub inline fn saveBMP_IO(surface: *Surface, dst: ?*IOStream, closeio: bool) bool { + return c.SDL_SaveBMP_IO(surface, dst, closeio); + } + + pub inline fn saveBMP(surface: *Surface, file: [*c]const u8) bool { + return c.SDL_SaveBMP(surface, file); + } + + pub inline fn setSurfaceRLE(surface: *Surface, enabled: bool) bool { + return c.SDL_SetSurfaceRLE(surface, enabled); + } + + pub inline fn surfaceHasRLE(surface: *Surface) bool { + return c.SDL_SurfaceHasRLE(surface); + } + + pub inline fn setSurfaceColorKey(surface: *Surface, enabled: bool, key: u32) bool { + return c.SDL_SetSurfaceColorKey(surface, enabled, key); + } + + pub inline fn surfaceHasColorKey(surface: *Surface) bool { + return c.SDL_SurfaceHasColorKey(surface); + } + + pub inline fn getSurfaceColorKey(surface: *Surface, key: *u32) bool { + return c.SDL_GetSurfaceColorKey(surface, @ptrCast(key)); + } + + pub inline fn setSurfaceColorMod( + surface: *Surface, + r: u8, + g: u8, + b: u8, + ) bool { + return c.SDL_SetSurfaceColorMod(surface, r, g, b); + } + + pub inline fn getSurfaceColorMod( + surface: *Surface, + r: [*c]u8, + g: [*c]u8, + b: [*c]u8, + ) bool { + return c.SDL_GetSurfaceColorMod(surface, r, g, b); + } + + pub inline fn setSurfaceAlphaMod(surface: *Surface, alpha: u8) bool { + return c.SDL_SetSurfaceAlphaMod(surface, alpha); + } + + pub inline fn getSurfaceAlphaMod(surface: *Surface, alpha: [*c]u8) bool { + return c.SDL_GetSurfaceAlphaMod(surface, alpha); + } + + pub inline fn setSurfaceBlendMode(surface: *Surface, blendMode: BlendMode) bool { + return c.SDL_SetSurfaceBlendMode(surface, @intFromEnum(blendMode)); + } + + pub inline fn getSurfaceBlendMode(surface: *Surface, blendMode: ?*BlendMode) bool { + return c.SDL_GetSurfaceBlendMode(surface, @intFromEnum(blendMode)); + } + + pub inline fn setSurfaceClipRect(surface: *Surface, rect: *const Rect) bool { + return c.SDL_SetSurfaceClipRect(surface, @ptrCast(rect)); + } + + pub inline fn getSurfaceClipRect(surface: *Surface, rect: ?*Rect) bool { + return c.SDL_GetSurfaceClipRect(surface, rect); + } + + pub inline fn flipSurface(surface: *Surface, flip: FlipMode) bool { + return c.SDL_FlipSurface(surface, @intFromEnum(flip)); + } + + pub inline fn duplicateSurface(surface: *Surface) ?*Surface { + return c.SDL_DuplicateSurface(surface); + } + + pub inline fn scaleSurface( + surface: *Surface, + width: c_int, + height: c_int, + scaleMode: ScaleMode, + ) ?*Surface { + return c.SDL_ScaleSurface(surface, width, height, @intFromEnum(scaleMode)); + } + + pub inline fn convertSurface(surface: *Surface, format: PixelFormat) ?*Surface { + return c.SDL_ConvertSurface(surface, @bitCast(format)); + } + + pub inline fn convertSurfaceAndColorspace( + surface: *Surface, + format: PixelFormat, + palette: ?*Palette, + colorspace: Colorspace, + props: PropertiesID, + ) ?*Surface { + return c.SDL_ConvertSurfaceAndColorspace(surface, @bitCast(format), palette, colorspace, props); + } + + pub inline fn premultiplySurfaceAlpha(surface: *Surface, linear: bool) bool { + return c.SDL_PremultiplySurfaceAlpha(surface, linear); + } + + pub inline fn clearSurface( + surface: *Surface, + r: f32, + g: f32, + b: f32, + a: f32, + ) bool { + return c.SDL_ClearSurface(surface, r, g, b, a); + } + + pub inline fn fillSurfaceRect(surface: *Surface, rect: *const Rect, color: u32) bool { + return c.SDL_FillSurfaceRect(surface, @ptrCast(rect), color); + } + + pub inline fn fillSurfaceRects( + surface: *Surface, + rects: *const Rect, + count: c_int, + color: u32, + ) bool { + return c.SDL_FillSurfaceRects(surface, @ptrCast(rects), count, color); + } + + pub inline fn blitSurface( + surface: *Surface, + srcrect: *const Rect, + dst: ?*Surface, + dstrect: *const Rect, + ) bool { + return c.SDL_BlitSurface(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurfaceUnchecked( + surface: *Surface, + srcrect: *const Rect, + dst: ?*Surface, + dstrect: *const Rect, + ) bool { + return c.SDL_BlitSurfaceUnchecked(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurfaceScaled( + surface: *Surface, + srcrect: *const Rect, + dst: ?*Surface, + dstrect: *const Rect, + scaleMode: ScaleMode, + ) bool { + return c.SDL_BlitSurfaceScaled(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect), @intFromEnum(scaleMode)); + } + + pub inline fn blitSurfaceUncheckedScaled( + surface: *Surface, + srcrect: *const Rect, + dst: ?*Surface, + dstrect: *const Rect, + scaleMode: ScaleMode, + ) bool { + return c.SDL_BlitSurfaceUncheckedScaled(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect), @intFromEnum(scaleMode)); + } + + pub inline fn stretchSurface( + surface: *Surface, + srcrect: *const Rect, + dst: ?*Surface, + dstrect: *const Rect, + scaleMode: ScaleMode, + ) bool { + return c.SDL_StretchSurface(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect), @intFromEnum(scaleMode)); + } + + pub inline fn blitSurfaceTiled( + surface: *Surface, + srcrect: *const Rect, + dst: ?*Surface, + dstrect: *const Rect, + ) bool { + return c.SDL_BlitSurfaceTiled(surface, @ptrCast(srcrect), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurfaceTiledWithScale( + surface: *Surface, + srcrect: *const Rect, + scale: f32, + scaleMode: ScaleMode, + dst: ?*Surface, + dstrect: *const Rect, + ) bool { + return c.SDL_BlitSurfaceTiledWithScale(surface, @ptrCast(srcrect), scale, @intFromEnum(scaleMode), dst, @ptrCast(dstrect)); + } + + pub inline fn blitSurface9Grid( + surface: *Surface, + srcrect: *const Rect, + left_width: c_int, + right_width: c_int, + top_height: c_int, + bottom_height: c_int, + scale: f32, + scaleMode: ScaleMode, + dst: ?*Surface, + dstrect: *const Rect, + ) bool { + return c.SDL_BlitSurface9Grid(surface, @ptrCast(srcrect), left_width, right_width, top_height, bottom_height, scale, @intFromEnum(scaleMode), dst, @ptrCast(dstrect)); + } + + pub inline fn mapSurfaceRGB( + surface: *Surface, + r: u8, + g: u8, + b: u8, + ) u32 { + return c.SDL_MapSurfaceRGB(surface, r, g, b); + } + + pub inline fn mapSurfaceRGBA( + surface: *Surface, + r: u8, + g: u8, + b: u8, + a: u8, + ) u32 { + return c.SDL_MapSurfaceRGBA(surface, r, g, b, a); + } + + pub inline fn readSurfacePixel( + surface: *Surface, + x: c_int, + y: c_int, + r: [*c]u8, + g: [*c]u8, + b: [*c]u8, + a: [*c]u8, + ) bool { + return c.SDL_ReadSurfacePixel(surface, x, y, r, g, b, a); + } + + pub inline fn readSurfacePixelFloat( + surface: *Surface, + x: c_int, + y: c_int, + r: *f32, + g: *f32, + b: *f32, + a: *f32, + ) bool { + return c.SDL_ReadSurfacePixelFloat(surface, x, y, @ptrCast(r), @ptrCast(g), @ptrCast(b), @ptrCast(a)); + } + + pub inline fn writeSurfacePixel( + surface: *Surface, + x: c_int, + y: c_int, + r: u8, + g: u8, + b: u8, + a: u8, + ) bool { + return c.SDL_WriteSurfacePixel(surface, x, y, r, g, b, a); + } + + pub inline fn writeSurfacePixelFloat( + surface: *Surface, + x: c_int, + y: c_int, + r: f32, + g: f32, + b: f32, + a: f32, + ) bool { + return c.SDL_WriteSurfacePixelFloat(surface, x, y, r, g, b, a); + } +}; + +pub inline fn createSurface(width: c_int, height: c_int, format: PixelFormat) ?*Surface { + return c.SDL_CreateSurface(width, height, @bitCast(format)); +} + +pub inline fn createSurfaceFrom( + width: c_int, + height: c_int, + format: PixelFormat, + pixels: ?*anyopaque, + pitch: c_int, +) ?*Surface { + return c.SDL_CreateSurfaceFrom(width, height, @bitCast(format), pixels, pitch); +} + +pub inline fn loadBMP(file: [*c]const u8) ?*Surface { + return c.SDL_LoadBMP(file); +} + +pub inline fn convertPixels( + width: c_int, + height: c_int, + src_format: PixelFormat, + src: ?*const anyopaque, + src_pitch: c_int, + dst_format: PixelFormat, + dst: ?*anyopaque, + dst_pitch: c_int, +) bool { + return c.SDL_ConvertPixels(width, height, @bitCast(src_format), src, src_pitch, @bitCast(dst_format), dst, dst_pitch); +} + +pub inline fn convertPixelsAndColorspace( + width: c_int, + height: c_int, + src_format: PixelFormat, + src_colorspace: Colorspace, + src_properties: PropertiesID, + src: ?*const anyopaque, + src_pitch: c_int, + dst_format: PixelFormat, + dst_colorspace: Colorspace, + dst_properties: PropertiesID, + dst: ?*anyopaque, + dst_pitch: c_int, +) bool { + return c.SDL_ConvertPixelsAndColorspace(width, height, @bitCast(src_format), src_colorspace, src_properties, src, src_pitch, @bitCast(dst_format), dst_colorspace, dst_properties, dst, dst_pitch); +} + +pub inline fn premultiplyAlpha( + width: c_int, + height: c_int, + src_format: PixelFormat, + src: ?*const anyopaque, + src_pitch: c_int, + dst_format: PixelFormat, + dst: ?*anyopaque, + dst_pitch: c_int, + linear: bool, +) bool { + return c.SDL_PremultiplyAlpha(width, height, @bitCast(src_format), src, src_pitch, @bitCast(dst_format), dst, dst_pitch, linear); +} diff --git a/lib/sdl3/v2/timer.zig b/lib/sdl3/v2/timer.zig new file mode 100644 index 0000000..cd38e6a --- /dev/null +++ b/lib/sdl3/v2/timer.zig @@ -0,0 +1,48 @@ +const std = @import("std"); +pub const c = @import("c.zig").c; + +pub inline fn getTicks() u64 { + return c.SDL_GetTicks(); +} + +pub inline fn getTicksNS() u64 { + return c.SDL_GetTicksNS(); +} + +pub inline fn getPerformanceCounter() u64 { + return c.SDL_GetPerformanceCounter(); +} + +pub inline fn getPerformanceFrequency() u64 { + return c.SDL_GetPerformanceFrequency(); +} + +pub inline fn delay(ms: u32) void { + return c.SDL_Delay(ms); +} + +pub inline fn delayNS(ns: u64) void { + return c.SDL_DelayNS(ns); +} + +pub inline fn delayPrecise(ns: u64) void { + return c.SDL_DelayPrecise(ns); +} + +pub const TimerID = u32; + +pub const TimerCallback = *const fn (userdata: ?*anyopaque, timerID: TimerID, interval: u32) callconv(.C) u32; + +pub inline fn addTimer(interval: u32, callback: TimerCallback, userdata: ?*anyopaque) TimerID { + return c.SDL_AddTimer(interval, callback, userdata); +} + +pub const NSTimerCallback = *const fn (userdata: ?*anyopaque, timerID: TimerID, interval: u64) callconv(.C) u64; + +pub inline fn addTimerNS(interval: u64, callback: NSTimerCallback, userdata: ?*anyopaque) TimerID { + return c.SDL_AddTimerNS(interval, callback, userdata); +} + +pub inline fn removeTimer(id: TimerID) bool { + return c.SDL_RemoveTimer(id); +} diff --git a/lib/sdl3/v2/video.zig b/lib/sdl3/v2/video.zig index 2847792..6f41e3a 100644 --- a/lib/sdl3/v2/video.zig +++ b/lib/sdl3/v2/video.zig @@ -87,13 +87,19 @@ pub const DisplayID = u32; pub const WindowID = u32; -pub const SystemTheme = enum(c_int) {}; - pub const DisplayModeData = opaque {}; -pub const DisplayMode = extern struct {}; - -pub const DisplayOrientation = enum(c_int) {}; +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 Window = opaque { pub inline fn getDisplayForWindow(window: *Window) DisplayID { @@ -404,8 +410,6 @@ pub const WindowFlags = packed struct(u64) { rsvd: bool = false, }; -pub const FlashOperation = enum(c_int) {}; - pub const GLContextState = extern struct {}; pub const GLProfile = u32; @@ -524,8 +528,6 @@ pub inline fn getGrabbedWindow() ?*Window { return c.SDL_GetGrabbedWindow(); } -pub const HitTestResult = enum(c_int) {}; - pub inline fn screenSaverEnabled() bool { return c.SDL_ScreenSaverEnabled(); }