sdl3 1.0.0

data/lib/sdl3/high_level/timer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Timer
+    attr_reader :id
+
+    def initialize(interval_ms, &callback)
+      raise ArgumentError, "block required" unless callback
+
+      @callback = callback
+      @prevent_gc = proc do |userdata, timer_id, interval|
+        @callback.call(timer_id, interval)
+      end
+      @id = Raw.SDL_AddTimer(interval_ms, @prevent_gc, nil)
+      raise Error, Raw.SDL_GetError if @id.zero?
+    end
+
+    def self.create(interval_ms, &callback)
+      timer = new(interval_ms, &callback)
+      return timer unless block_given?
+
+      begin
+        yield timer
+      ensure
+        timer.remove
+      end
+    end
+
+    def self.create_ns(interval_ns, &callback)
+      raise ArgumentError, "block required" unless callback
+
+      timer = allocate
+      timer.instance_variable_set(:@callback, callback)
+      prevent_gc = proc do |userdata, timer_id, interval|
+        callback.call(timer_id, interval)
+      end
+      timer.instance_variable_set(:@prevent_gc, prevent_gc)
+      timer_id = Raw.SDL_AddTimerNS(interval_ns, prevent_gc, nil)
+      raise Error, Raw.SDL_GetError if timer_id.zero?
+
+      timer.instance_variable_set(:@id, timer_id)
+
+      return timer unless block_given?
+
+      begin
+        yield timer
+      ensure
+        timer.remove
+      end
+    end
+
+    def remove
+      return false if @id.zero?
+
+      result = Raw.SDL_RemoveTimer(@id)
+      @id = 0 if result
+      result
+    end
+
+    def self.ticks
+      Raw.SDL_GetTicks
+    end
+
+    def self.ticks_ns
+      Raw.SDL_GetTicksNS
+    end
+
+    def self.performance_counter
+      Raw.SDL_GetPerformanceCounter
+    end
+
+    def self.performance_frequency
+      Raw.SDL_GetPerformanceFrequency
+    end
+
+    def self.delay(ms)
+      Raw.SDL_Delay(ms)
+    end
+
+    def self.delay_ns(ns)
+      Raw.SDL_DelayNS(ns)
+    end
+
+    def self.delay_precise(ns)
+      Raw.SDL_DelayPrecise(ns)
+    end
+  end
+end

data/lib/sdl3/high_level/window.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Window
+    attr_reader :ptr
+
+    FULLSCREEN = Raw::SDL_WINDOW_FULLSCREEN
+    OPENGL = Raw::SDL_WINDOW_OPENGL
+    HIDDEN = Raw::SDL_WINDOW_HIDDEN
+    BORDERLESS = Raw::SDL_WINDOW_BORDERLESS
+    RESIZABLE = Raw::SDL_WINDOW_RESIZABLE
+    MINIMIZED = Raw::SDL_WINDOW_MINIMIZED
+    MAXIMIZED = Raw::SDL_WINDOW_MAXIMIZED
+    VULKAN = Raw::SDL_WINDOW_VULKAN
+    METAL = Raw::SDL_WINDOW_METAL
+
+    def initialize(title, width, height, flags = 0)
+      @ptr = Raw.SDL_CreateWindow(title, width, height, flags)
+      raise Error, Raw.SDL_GetError if @ptr.null?
+
+      ObjectSpace.define_finalizer(self, self.class.releasing(@ptr))
+    end
+
+    def self.releasing(ptr)
+      prevented_ptr = ptr
+      proc { Raw.SDL_DestroyWindow(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.open(title, width, height, flags = 0)
+      window = new(title, width, height, flags)
+      return window unless block_given?
+
+      begin
+        yield window
+      ensure
+        window.destroy
+      end
+    end
+
+    def destroy
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_DestroyWindow(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def id
+      Raw.SDL_GetWindowID(@ptr)
+    end
+
+    def title
+      Raw.SDL_GetWindowTitle(@ptr)
+    end
+
+    def title=(value)
+      Raw.SDL_SetWindowTitle(@ptr, value)
+    end
+
+    def size
+      w = FFI::MemoryPointer.new(:int)
+      h = FFI::MemoryPointer.new(:int)
+      Raw.SDL_GetWindowSize(@ptr, w, h)
+      [w.read_int, h.read_int]
+    end
+
+    def size=(dimensions)
+      Raw.SDL_SetWindowSize(@ptr, dimensions[0], dimensions[1])
+    end
+
+    def width
+      size[0]
+    end
+
+    def height
+      size[1]
+    end
+
+    def position
+      x = FFI::MemoryPointer.new(:int)
+      y = FFI::MemoryPointer.new(:int)
+      Raw.SDL_GetWindowPosition(@ptr, x, y)
+      [x.read_int, y.read_int]
+    end
+
+    def position=(coords)
+      Raw.SDL_SetWindowPosition(@ptr, coords[0], coords[1])
+    end
+
+    def show
+      Raw.SDL_ShowWindow(@ptr)
+    end
+
+    def hide
+      Raw.SDL_HideWindow(@ptr)
+    end
+
+    def raise_window
+      Raw.SDL_RaiseWindow(@ptr)
+    end
+
+    def maximize
+      Raw.SDL_MaximizeWindow(@ptr)
+    end
+
+    def minimize
+      Raw.SDL_MinimizeWindow(@ptr)
+    end
+
+    def restore
+      Raw.SDL_RestoreWindow(@ptr)
+    end
+
+    def fullscreen=(enabled)
+      Raw.SDL_SetWindowFullscreen(@ptr, enabled)
+    end
+
+    def bordered=(enabled)
+      Raw.SDL_SetWindowBordered(@ptr, enabled)
+    end
+
+    def resizable=(enabled)
+      Raw.SDL_SetWindowResizable(@ptr, enabled)
+    end
+
+    def opacity
+      Raw.SDL_GetWindowOpacity(@ptr)
+    end
+
+    def opacity=(value)
+      Raw.SDL_SetWindowOpacity(@ptr, value)
+    end
+
+    def surface
+      ptr = Raw.SDL_GetWindowSurface(@ptr)
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      Surface.from_ptr(ptr, owned: false)
+    end
+
+    def update_surface
+      raise Error, Raw.SDL_GetError unless Raw.SDL_UpdateWindowSurface(@ptr)
+
+      true
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/sdl3/library_loader.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module SDL3
+  module LibraryLoader
+    LIBRARY_NAMES = {
+      "linux" => ["libSDL3.so.0", "libSDL3.so"],
+      "darwin" => ["libSDL3.dylib", "SDL3.framework/SDL3"],
+      "mingw" => ["SDL3.dll"],
+      "mswin" => ["SDL3.dll"]
+    }.freeze
+
+    SEARCH_PATHS = {
+      "linux" => ["/usr/lib", "/usr/local/lib", "/usr/lib/x86_64-linux-gnu"],
+      "darwin" => ["/opt/homebrew/lib", "/usr/local/lib", "/Library/Frameworks"],
+      "mingw" => [],
+      "mswin" => []
+    }.freeze
+
+    class << self
+      def library_name
+        platform = detect_platform
+        names = LIBRARY_NAMES[platform]
+        raise LoadError, "Unsupported platform: #{platform}" unless names
+
+        names.each do |name|
+          return name if library_available?(name)
+        end
+
+        paths = SEARCH_PATHS[platform] || []
+        paths.each do |path|
+          names.each do |name|
+            full_path = File.join(path, name)
+            return full_path if library_available?(full_path)
+          end
+        end
+
+        raise LoadError, "Could not find SDL3 library. Tried: #{names.join(", ")}"
+      end
+
+      private
+
+      def detect_platform
+        case RbConfig::CONFIG["host_os"]
+        when /linux/i then "linux"
+        when /darwin/i then "darwin"
+        when /mingw/i then "mingw"
+        when /mswin/i then "mswin"
+        else "unknown"
+        end
+      end
+
+      def library_available?(name)
+        require "ffi"
+        FFI::DynamicLibrary.open(name, FFI::DynamicLibrary::RTLD_LAZY)
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/sdl3/raw/assert.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    SDL_AssertState = enum :SDL_AssertState, [
+      :SDL_ASSERTION_RETRY, 0,
+      :SDL_ASSERTION_BREAK, 1,
+      :SDL_ASSERTION_ABORT, 2,
+      :SDL_ASSERTION_IGNORE, 3,
+      :SDL_ASSERTION_ALWAYS_IGNORE, 4
+    ]
+
+    class SDL_AssertData < FFI::Struct
+      layout :always_ignore, :bool,
+             :trigger_count, :uint,
+             :condition, :string,
+             :filename, :string,
+             :linenum, :int,
+             :function, :string,
+             :next, :pointer
+    end
+
+    callback :SDL_AssertionHandler, [:pointer, :pointer], :SDL_AssertState
+
+    attach_function :SDL_ReportAssertion, [:pointer, :string, :string, :int], :SDL_AssertState
+    attach_function :SDL_SetAssertionHandler, [:SDL_AssertionHandler, :pointer], :void
+    attach_function :SDL_GetDefaultAssertionHandler, [], :SDL_AssertionHandler
+    attach_function :SDL_GetAssertionHandler, [:pointer], :SDL_AssertionHandler
+    attach_function :SDL_GetAssertionReport, [], :pointer
+    attach_function :SDL_ResetAssertionReport, [], :void
+  end
+end

data/lib/sdl3/raw/asyncio.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    SDL_AsyncIOTaskType = enum :SDL_ASYNCIO_TASK_READ, 0,
+                               :SDL_ASYNCIO_TASK_WRITE,
+                               :SDL_ASYNCIO_TASK_CLOSE
+
+    SDL_AsyncIOResult = enum :SDL_ASYNCIO_COMPLETE, 0,
+                             :SDL_ASYNCIO_FAILURE,
+                             :SDL_ASYNCIO_CANCELED
+
+    class SDL_AsyncIOOutcome < FFI::Struct
+      layout :asyncio, :pointer,
+             :type, SDL_AsyncIOTaskType,
+             :result, SDL_AsyncIOResult,
+             :buffer, :pointer,
+             :offset, :uint64,
+             :bytes_requested, :uint64,
+             :bytes_transferred, :uint64,
+             :userdata, :pointer
+    end
+
+    attach_function :SDL_AsyncIOFromFile, %i[string string], :pointer
+    attach_function :SDL_GetAsyncIOSize, [:pointer], :int64
+    attach_function :SDL_ReadAsyncIO, %i[pointer pointer uint64 uint64 pointer pointer], :bool
+    attach_function :SDL_WriteAsyncIO, %i[pointer pointer uint64 uint64 pointer pointer], :bool
+    attach_function :SDL_CloseAsyncIO, %i[pointer bool pointer pointer], :bool
+    attach_function :SDL_CreateAsyncIOQueue, [], :pointer
+    attach_function :SDL_DestroyAsyncIOQueue, [:pointer], :void
+    attach_function :SDL_GetAsyncIOResult, [:pointer, SDL_AsyncIOOutcome.ptr], :bool
+    attach_function :SDL_WaitAsyncIOResult, [:pointer, SDL_AsyncIOOutcome.ptr, :int32], :bool
+    attach_function :SDL_SignalAsyncIOQueue, [:pointer], :void
+    attach_function :SDL_LoadFileAsync, %i[string pointer pointer], :bool
+  end
+end

data/lib/sdl3/raw/atomic.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    typedef :int, :SDL_SpinLock
+
+    class SDL_AtomicInt < FFI::Struct
+      layout :value, :int
+    end
+
+    class SDL_AtomicU32 < FFI::Struct
+      layout :value, :uint32
+    end
+
+    attach_function :SDL_TryLockSpinlock, [:pointer], :bool
+    attach_function :SDL_LockSpinlock, [:pointer], :void
+    attach_function :SDL_UnlockSpinlock, [:pointer], :void
+
+    attach_function :SDL_MemoryBarrierReleaseFunction, [], :void
+    attach_function :SDL_MemoryBarrierAcquireFunction, [], :void
+
+    attach_function :SDL_CompareAndSwapAtomicInt, [SDL_AtomicInt.ptr, :int, :int], :bool
+    attach_function :SDL_SetAtomicInt, [SDL_AtomicInt.ptr, :int], :int
+    attach_function :SDL_GetAtomicInt, [SDL_AtomicInt.ptr], :int
+    attach_function :SDL_AddAtomicInt, [SDL_AtomicInt.ptr, :int], :int
+
+    attach_function :SDL_CompareAndSwapAtomicU32, [SDL_AtomicU32.ptr, :uint32, :uint32], :bool
+    attach_function :SDL_SetAtomicU32, [SDL_AtomicU32.ptr, :uint32], :uint32
+    attach_function :SDL_GetAtomicU32, [SDL_AtomicU32.ptr], :uint32
+    begin
+      attach_function :SDL_AddAtomicU32, [SDL_AtomicU32.ptr, :int], :uint32
+    rescue FFI::NotFoundError
+      # Added in newer SDL3 versions.
+    end
+
+    attach_function :SDL_CompareAndSwapAtomicPointer, %i[pointer pointer pointer], :bool
+    attach_function :SDL_SetAtomicPointer, %i[pointer pointer], :pointer
+    attach_function :SDL_GetAtomicPointer, [:pointer], :pointer
+  end
+end

data/lib/sdl3/raw/audio.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    SDL_AUDIO_MASK_BITSIZE = 0xFF
+    SDL_AUDIO_MASK_FLOAT = 1 << 8
+    SDL_AUDIO_MASK_BIG_ENDIAN = 1 << 12
+    SDL_AUDIO_MASK_SIGNED = 1 << 15
+
+    SDL_AUDIO_U8 = 0x0008
+    SDL_AUDIO_S8 = 0x8008
+    SDL_AUDIO_S16LE = 0x8010
+    SDL_AUDIO_S16BE = 0x9010
+    SDL_AUDIO_S32LE = 0x8020
+    SDL_AUDIO_S32BE = 0x9020
+    SDL_AUDIO_F32LE = 0x8120
+    SDL_AUDIO_F32BE = 0x9120
+
+    SDL_AUDIO_S16 = SDL_AUDIO_S16LE
+    SDL_AUDIO_S32 = SDL_AUDIO_S32LE
+    SDL_AUDIO_F32 = SDL_AUDIO_F32LE
+
+    class SDL_AudioSpec < FFI::Struct
+      layout :format, :uint16,
+             :channels, :int,
+             :freq, :int
+    end
+
+    attach_function :SDL_GetNumAudioDrivers, [], :int
+    attach_function :SDL_GetAudioDriver, [:int], :string
+    attach_function :SDL_GetCurrentAudioDriver, [], :string
+    attach_function :SDL_GetAudioPlaybackDevices, [:pointer], :pointer
+    attach_function :SDL_GetAudioRecordingDevices, [:pointer], :pointer
+    attach_function :SDL_GetAudioDeviceName, [:SDL_AudioDeviceID], :string
+    attach_function :SDL_GetAudioDeviceFormat, [:SDL_AudioDeviceID, SDL_AudioSpec.ptr, :pointer], :bool
+    attach_function :SDL_GetAudioDeviceChannelMap, [:SDL_AudioDeviceID, :pointer], :pointer
+    attach_function :SDL_OpenAudioDevice, [:SDL_AudioDeviceID, SDL_AudioSpec.ptr], :SDL_AudioDeviceID
+    attach_function :SDL_IsAudioDevicePhysical, [:SDL_AudioDeviceID], :bool
+    attach_function :SDL_IsAudioDevicePlayback, [:SDL_AudioDeviceID], :bool
+    attach_function :SDL_PauseAudioDevice, [:SDL_AudioDeviceID], :bool
+    attach_function :SDL_ResumeAudioDevice, [:SDL_AudioDeviceID], :bool
+    attach_function :SDL_AudioDevicePaused, [:SDL_AudioDeviceID], :bool
+    attach_function :SDL_GetAudioDeviceGain, [:SDL_AudioDeviceID], :float
+    attach_function :SDL_SetAudioDeviceGain, [:SDL_AudioDeviceID, :float], :bool
+    attach_function :SDL_CloseAudioDevice, [:SDL_AudioDeviceID], :void
+    attach_function :SDL_BindAudioStreams, [:SDL_AudioDeviceID, :pointer, :int], :bool
+    attach_function :SDL_BindAudioStream, [:SDL_AudioDeviceID, :pointer], :bool
+    attach_function :SDL_UnbindAudioStreams, %i[pointer int], :void
+    attach_function :SDL_UnbindAudioStream, [:pointer], :void
+    attach_function :SDL_GetAudioStreamDevice, [:pointer], :SDL_AudioDeviceID
+    attach_function :SDL_CreateAudioStream, [SDL_AudioSpec.ptr, SDL_AudioSpec.ptr], :pointer
+    attach_function :SDL_GetAudioStreamProperties, [:pointer], :SDL_PropertiesID
+    attach_function :SDL_GetAudioStreamFormat, [:pointer, SDL_AudioSpec.ptr, SDL_AudioSpec.ptr], :bool
+    attach_function :SDL_SetAudioStreamFormat, [:pointer, SDL_AudioSpec.ptr, SDL_AudioSpec.ptr], :bool
+    attach_function :SDL_GetAudioStreamFrequencyRatio, [:pointer], :float
+    attach_function :SDL_SetAudioStreamFrequencyRatio, %i[pointer float], :bool
+    attach_function :SDL_GetAudioStreamGain, [:pointer], :float
+    attach_function :SDL_SetAudioStreamGain, %i[pointer float], :bool
+    attach_function :SDL_GetAudioStreamInputChannelMap, %i[pointer pointer], :pointer
+    attach_function :SDL_GetAudioStreamOutputChannelMap, %i[pointer pointer], :pointer
+    attach_function :SDL_SetAudioStreamInputChannelMap, %i[pointer pointer int], :bool
+    attach_function :SDL_SetAudioStreamOutputChannelMap, %i[pointer pointer int], :bool
+    attach_function :SDL_PutAudioStreamData, %i[pointer pointer int], :bool
+    begin
+      callback :SDL_AudioStreamDataCompleteCallback, %i[pointer pointer int], :void
+      attach_function :SDL_PutAudioStreamDataNoCopy, %i[pointer pointer int SDL_AudioStreamDataCompleteCallback pointer], :bool
+      attach_function :SDL_PutAudioStreamPlanarData, %i[pointer pointer int int], :bool
+    rescue FFI::NotFoundError
+      # Added in newer SDL3 versions.
+    end
+    attach_function :SDL_GetAudioStreamData, %i[pointer pointer int], :int
+    attach_function :SDL_GetAudioStreamAvailable, [:pointer], :int
+    attach_function :SDL_GetAudioStreamQueued, [:pointer], :int
+    attach_function :SDL_FlushAudioStream, [:pointer], :bool
+    attach_function :SDL_ClearAudioStream, [:pointer], :bool
+    attach_function :SDL_PauseAudioStreamDevice, [:pointer], :bool
+    attach_function :SDL_ResumeAudioStreamDevice, [:pointer], :bool
+    attach_function :SDL_AudioStreamDevicePaused, [:pointer], :bool
+    attach_function :SDL_LockAudioStream, [:pointer], :bool
+    attach_function :SDL_UnlockAudioStream, [:pointer], :bool
+    callback :SDL_AudioStreamCallback, %i[pointer pointer int int], :void
+    attach_function :SDL_SetAudioStreamGetCallback, [:pointer, :SDL_AudioStreamCallback, :pointer], :bool
+    attach_function :SDL_SetAudioStreamPutCallback, [:pointer, :SDL_AudioStreamCallback, :pointer], :bool
+    attach_function :SDL_DestroyAudioStream, [:pointer], :void
+    attach_function :SDL_OpenAudioDeviceStream, [:SDL_AudioDeviceID, SDL_AudioSpec.ptr, :SDL_AudioStreamCallback, :pointer], :pointer
+    callback :SDL_AudioPostmixCallback, [:pointer, SDL_AudioSpec.ptr, :pointer, :int], :void
+    attach_function :SDL_SetAudioPostmixCallback, [:SDL_AudioDeviceID, :SDL_AudioPostmixCallback, :pointer], :bool
+    attach_function :SDL_LoadWAV_IO, [:pointer, :bool, SDL_AudioSpec.ptr, :pointer, :pointer], :bool
+    attach_function :SDL_LoadWAV, [:string, SDL_AudioSpec.ptr, :pointer, :pointer], :bool
+    attach_function :SDL_MixAudio, %i[pointer pointer pointer uint16 int float], :bool
+    attach_function :SDL_ConvertAudioSamples, [SDL_AudioSpec.ptr, :pointer, :int, SDL_AudioSpec.ptr, :pointer, :pointer], :bool
+    attach_function :SDL_GetAudioFormatName, [:uint16], :string
+    attach_function :SDL_GetSilenceValueForFormat, [:uint16], :int
+  end
+end

data/lib/sdl3/raw/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "ffi"
+require_relative "../library_loader"
+
+module SDL3
+  module Raw
+    extend FFI::Library
+
+    ffi_lib LibraryLoader.library_name
+  end
+end

data/lib/sdl3/raw/bits.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    module Bits
+      def self.most_significant_bit_index32(x)
+        return -1 if x == 0
+
+        31 - x.to_s(2).rjust(32, "0").index("1")
+      end
+
+      def self.has_exactly_one_bit_set32(x)
+        x != 0 && (x & (x - 1)) == 0
+      end
+    end
+  end
+end

data/lib/sdl3/raw/blendmode.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    SDL_BLENDMODE_NONE = 0x00000000
+    SDL_BLENDMODE_BLEND = 0x00000001
+    SDL_BLENDMODE_BLEND_PREMULTIPLIED = 0x00000010
+    SDL_BLENDMODE_ADD = 0x00000002
+    SDL_BLENDMODE_ADD_PREMULTIPLIED = 0x00000020
+    SDL_BLENDMODE_MOD = 0x00000004
+    SDL_BLENDMODE_MUL = 0x00000008
+    SDL_BLENDMODE_INVALID = 0x7FFFFFFF
+
+    SDL_BlendOperation = enum :SDL_BLENDOPERATION_ADD, 0x1,
+                              :SDL_BLENDOPERATION_SUBTRACT, 0x2,
+                              :SDL_BLENDOPERATION_REV_SUBTRACT, 0x3,
+                              :SDL_BLENDOPERATION_MINIMUM, 0x4,
+                              :SDL_BLENDOPERATION_MAXIMUM, 0x5
+
+    SDL_BlendFactor = enum :SDL_BLENDFACTOR_ZERO, 0x1,
+                           :SDL_BLENDFACTOR_ONE, 0x2,
+                           :SDL_BLENDFACTOR_SRC_COLOR, 0x3,
+                           :SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR, 0x4,
+                           :SDL_BLENDFACTOR_SRC_ALPHA, 0x5,
+                           :SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, 0x6,
+                           :SDL_BLENDFACTOR_DST_COLOR, 0x7,
+                           :SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR, 0x8,
+                           :SDL_BLENDFACTOR_DST_ALPHA, 0x9,
+                           :SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA, 0xA
+
+    attach_function :SDL_ComposeCustomBlendMode,
+                    [SDL_BlendFactor, SDL_BlendFactor, SDL_BlendOperation,
+                     SDL_BlendFactor, SDL_BlendFactor, SDL_BlendOperation],
+                    :uint32
+  end
+end

data/lib/sdl3/raw/camera.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    SDL_CameraPosition = enum :SDL_CAMERA_POSITION_UNKNOWN, 0,
+                              :SDL_CAMERA_POSITION_FRONT_FACING, 1,
+                              :SDL_CAMERA_POSITION_BACK_FACING, 2
+
+    class SDL_CameraSpec < FFI::Struct
+      layout :format, :uint32,
+             :colorspace, :uint32,
+             :width, :int,
+             :height, :int,
+             :framerate_numerator, :int,
+             :framerate_denominator, :int
+    end
+
+    begin
+      attach_function :SDL_GetNumCameraDrivers, [], :int
+      attach_function :SDL_GetCameraDriver, [:int], :string
+      attach_function :SDL_GetCurrentCameraDriver, [], :string
+      attach_function :SDL_GetCameras, [:pointer], :pointer
+      attach_function :SDL_GetCameraSupportedFormats, [:SDL_CameraID, :pointer], :pointer
+      attach_function :SDL_GetCameraName, [:SDL_CameraID], :string
+      attach_function :SDL_GetCameraPosition, [:SDL_CameraID], SDL_CameraPosition
+      attach_function :SDL_OpenCamera, [:SDL_CameraID, SDL_CameraSpec.ptr], :pointer
+      attach_function :SDL_GetCameraPermissionState, [:pointer], :int
+      attach_function :SDL_GetCameraID, [:pointer], :SDL_CameraID
+      attach_function :SDL_GetCameraProperties, [:pointer], :SDL_PropertiesID
+      attach_function :SDL_GetCameraFormat, [:pointer, SDL_CameraSpec.ptr], :bool
+      attach_function :SDL_AcquireCameraFrame, %i[pointer pointer], :pointer
+      attach_function :SDL_ReleaseCameraFrame, [:pointer, :pointer], :void
+      attach_function :SDL_CloseCamera, [:pointer], :void
+    rescue FFI::NotFoundError
+      # Camera API may not be available in all SDL3 versions
+    end
+  end
+end

data/lib/sdl3/raw/clipboard.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    callback :SDL_ClipboardDataCallback, %i[pointer string pointer], :pointer
+    callback :SDL_ClipboardCleanupCallback, [:pointer], :void
+
+    attach_function :SDL_SetClipboardText, [:string], :bool
+    attach_function :SDL_GetClipboardText, [], :string
+    attach_function :SDL_HasClipboardText, [], :bool
+    attach_function :SDL_SetPrimarySelectionText, [:string], :bool
+    attach_function :SDL_GetPrimarySelectionText, [], :string
+    attach_function :SDL_HasPrimarySelectionText, [], :bool
+    attach_function :SDL_SetClipboardData, [:SDL_ClipboardDataCallback, :SDL_ClipboardCleanupCallback, :pointer, :pointer, :size_t], :bool
+    attach_function :SDL_ClearClipboardData, [], :bool
+    attach_function :SDL_GetClipboardData, %i[string pointer], :pointer
+    attach_function :SDL_HasClipboardData, [:string], :bool
+    attach_function :SDL_GetClipboardMimeTypes, [:pointer], :pointer
+  end
+end

data/lib/sdl3/raw/cpuinfo.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Raw
+    attach_function :SDL_GetNumLogicalCPUCores, [], :int
+    attach_function :SDL_GetCPUCacheLineSize, [], :int
+    attach_function :SDL_HasAltiVec, [], :bool
+    attach_function :SDL_HasMMX, [], :bool
+    attach_function :SDL_HasSSE, [], :bool
+    attach_function :SDL_HasSSE2, [], :bool
+    attach_function :SDL_HasSSE3, [], :bool
+    attach_function :SDL_HasSSE41, [], :bool
+    attach_function :SDL_HasSSE42, [], :bool
+    attach_function :SDL_HasAVX, [], :bool
+    attach_function :SDL_HasAVX2, [], :bool
+    attach_function :SDL_HasAVX512F, [], :bool
+    attach_function :SDL_HasARMSIMD, [], :bool
+    attach_function :SDL_HasNEON, [], :bool
+    attach_function :SDL_HasLSX, [], :bool
+    attach_function :SDL_HasLASX, [], :bool
+    attach_function :SDL_GetSystemRAM, [], :int
+    begin
+      attach_function :SDL_GetSystemPageSize, [], :int
+    rescue FFI::NotFoundError
+      # Added in newer SDL3 versions.
+    end
+    attach_function :SDL_GetSIMDAlignment, [], :size_t
+  end
+end