sdl3 1.0.0

data/lib/sdl3/high_level/audio_device.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module SDL3
+  class AudioDevice
+    attr_reader :id
+
+    def initialize(device_id, spec = nil)
+      @id = Raw.SDL_OpenAudioDevice(device_id, spec)
+      raise AudioError, Raw.SDL_GetError if @id.zero?
+
+      ObjectSpace.define_finalizer(self, self.class.releasing(@id))
+    end
+
+    def self.releasing(id)
+      prevented_id = id
+      proc { Raw.SDL_CloseAudioDevice(prevented_id) unless prevented_id.zero? }
+    end
+
+    def self.open(device_id, spec = nil)
+      device = new(device_id, spec)
+      return device unless block_given?
+
+      begin
+        yield device
+      ensure
+        device.close
+      end
+    end
+
+    def self.playback_devices
+      count_ptr = FFI::MemoryPointer.new(:int)
+      devices_ptr = Raw.SDL_GetAudioPlaybackDevices(count_ptr)
+      return [] if devices_ptr.null?
+
+      count = count_ptr.read_int
+      devices_ptr.read_array_of_uint32(count)
+    end
+
+    def self.recording_devices
+      count_ptr = FFI::MemoryPointer.new(:int)
+      devices_ptr = Raw.SDL_GetAudioRecordingDevices(count_ptr)
+      return [] if devices_ptr.null?
+
+      count = count_ptr.read_int
+      devices_ptr.read_array_of_uint32(count)
+    end
+
+    def self.device_name(device_id)
+      Raw.SDL_GetAudioDeviceName(device_id)
+    end
+
+    def close
+      return if @id.zero?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_CloseAudioDevice(@id)
+      @id = 0
+    end
+
+    def name
+      Raw.SDL_GetAudioDeviceName(@id)
+    end
+
+    def pause
+      Raw.SDL_PauseAudioDevice(@id)
+    end
+
+    def resume
+      Raw.SDL_ResumeAudioDevice(@id)
+    end
+
+    def paused?
+      Raw.SDL_AudioDevicePaused(@id)
+    end
+
+    def gain
+      Raw.SDL_GetAudioDeviceGain(@id)
+    end
+
+    def gain=(value)
+      raise AudioError, Raw.SDL_GetError unless Raw.SDL_SetAudioDeviceGain(@id, value)
+
+      value
+    end
+
+    def physical?
+      Raw.SDL_IsAudioDevicePhysical(@id)
+    end
+
+    def playback?
+      Raw.SDL_IsAudioDevicePlayback(@id)
+    end
+  end
+
+  class AudioStream
+    attr_reader :ptr
+
+    def initialize(src_spec, dst_spec)
+      @ptr = Raw.SDL_CreateAudioStream(src_spec, dst_spec)
+      raise AudioError, 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_DestroyAudioStream(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.open(src_spec, dst_spec)
+      stream = new(src_spec, dst_spec)
+      return stream unless block_given?
+
+      begin
+        yield stream
+      ensure
+        stream.destroy
+      end
+    end
+
+    def destroy
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_DestroyAudioStream(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def bind(device)
+      device_id = device.is_a?(AudioDevice) ? device.id : device
+      raise AudioError, Raw.SDL_GetError unless Raw.SDL_BindAudioStream(device_id, @ptr)
+
+      true
+    end
+
+    def unbind
+      Raw.SDL_UnbindAudioStream(@ptr)
+    end
+
+    def put(data, length)
+      raise AudioError, Raw.SDL_GetError unless Raw.SDL_PutAudioStreamData(@ptr, data, length)
+
+      true
+    end
+
+    def get(buffer, length)
+      Raw.SDL_GetAudioStreamData(@ptr, buffer, length)
+    end
+
+    def available
+      Raw.SDL_GetAudioStreamAvailable(@ptr)
+    end
+
+    def queued
+      Raw.SDL_GetAudioStreamQueued(@ptr)
+    end
+
+    def flush
+      raise AudioError, Raw.SDL_GetError unless Raw.SDL_FlushAudioStream(@ptr)
+
+      true
+    end
+
+    def clear
+      raise AudioError, Raw.SDL_GetError unless Raw.SDL_ClearAudioStream(@ptr)
+
+      true
+    end
+
+    def frequency_ratio
+      Raw.SDL_GetAudioStreamFrequencyRatio(@ptr)
+    end
+
+    def frequency_ratio=(value)
+      raise AudioError, Raw.SDL_GetError unless Raw.SDL_SetAudioStreamFrequencyRatio(@ptr, value)
+
+      value
+    end
+
+    def gain
+      Raw.SDL_GetAudioStreamGain(@ptr)
+    end
+
+    def gain=(value)
+      raise AudioError, Raw.SDL_GetError unless Raw.SDL_SetAudioStreamGain(@ptr, value)
+
+      value
+    end
+
+    def lock
+      Raw.SDL_LockAudioStream(@ptr)
+    end
+
+    def unlock
+      Raw.SDL_UnlockAudioStream(@ptr)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/sdl3/high_level/camera.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Camera
+    attr_reader :ptr
+
+    POSITION_UNKNOWN = :SDL_CAMERA_POSITION_UNKNOWN
+    POSITION_FRONT_FACING = :SDL_CAMERA_POSITION_FRONT_FACING
+    POSITION_BACK_FACING = :SDL_CAMERA_POSITION_BACK_FACING
+
+    def initialize(camera_id, spec = nil)
+      @ptr = Raw.SDL_OpenCamera(camera_id, spec)
+      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_CloseCamera(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.open(camera_id, spec = nil)
+      camera = new(camera_id, spec)
+      return camera unless block_given?
+
+      begin
+        yield camera
+      ensure
+        camera.close
+      end
+    end
+
+    def self.num_drivers
+      Raw.SDL_GetNumCameraDrivers
+    end
+
+    def self.driver(index)
+      Raw.SDL_GetCameraDriver(index)
+    end
+
+    def self.current_driver
+      Raw.SDL_GetCurrentCameraDriver
+    end
+
+    def self.list
+      count_ptr = FFI::MemoryPointer.new(:int)
+      cameras_ptr = Raw.SDL_GetCameras(count_ptr)
+      return [] if cameras_ptr.null?
+
+      count = count_ptr.read_int
+      cameras_ptr.read_array_of_uint32(count)
+    end
+
+    def self.name_for_id(camera_id)
+      Raw.SDL_GetCameraName(camera_id)
+    end
+
+    def self.position_for_id(camera_id)
+      Raw.SDL_GetCameraPosition(camera_id)
+    end
+
+    def self.supported_formats(camera_id)
+      count_ptr = FFI::MemoryPointer.new(:int)
+      formats_ptr = Raw.SDL_GetCameraSupportedFormats(camera_id, count_ptr)
+      return [] if formats_ptr.null?
+
+      count = count_ptr.read_int
+      count.times.map do |i|
+        spec_ptr = formats_ptr.get_pointer(i * FFI::Pointer.size)
+        Raw::SDL_CameraSpec.new(spec_ptr)
+      end
+    end
+
+    def close
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_CloseCamera(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def id
+      Raw.SDL_GetCameraID(@ptr)
+    end
+
+    def properties
+      Raw.SDL_GetCameraProperties(@ptr)
+    end
+
+    def permission_state
+      Raw.SDL_GetCameraPermissionState(@ptr)
+    end
+
+    def format
+      spec = Raw::SDL_CameraSpec.new
+      return nil unless Raw.SDL_GetCameraFormat(@ptr, spec)
+
+      spec
+    end
+
+    def acquire_frame
+      timestamp_ptr = FFI::MemoryPointer.new(:uint64)
+      surface_ptr = Raw.SDL_AcquireCameraFrame(@ptr, timestamp_ptr)
+      return nil if surface_ptr.null?
+
+      [surface_ptr, timestamp_ptr.read_uint64]
+    end
+
+    def release_frame(surface_ptr)
+      Raw.SDL_ReleaseCameraFrame(@ptr, surface_ptr)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/sdl3/high_level/clipboard.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SDL3
+  module Clipboard
+    class << self
+      def text
+        Raw.SDL_GetClipboardText
+      end
+
+      def text=(value)
+        Raw.SDL_SetClipboardText(value)
+      end
+
+      def has_text?
+        Raw.SDL_HasClipboardText
+      end
+
+      def primary_selection_text
+        Raw.SDL_GetPrimarySelectionText
+      end
+
+      def primary_selection_text=(value)
+        Raw.SDL_SetPrimarySelectionText(value)
+      end
+
+      def has_primary_selection_text?
+        Raw.SDL_HasPrimarySelectionText
+      end
+
+      def clear
+        Raw.SDL_ClearClipboardData
+      end
+
+      def has_data?(mime_type)
+        Raw.SDL_HasClipboardData(mime_type)
+      end
+
+      def data(mime_type)
+        size_ptr = FFI::MemoryPointer.new(:size_t)
+        data_ptr = Raw.SDL_GetClipboardData(mime_type, size_ptr)
+        return nil if data_ptr.null?
+
+        size = size_ptr.read(:size_t)
+        data_ptr.read_bytes(size)
+      end
+
+      def mime_types
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        types_ptr = Raw.SDL_GetClipboardMimeTypes(count_ptr)
+        return [] if types_ptr.null?
+
+        count = count_ptr.read(:size_t)
+        count.times.map do |i|
+          types_ptr.get_pointer(i * FFI::Pointer.size).read_string
+        end
+      end
+    end
+  end
+end

data/lib/sdl3/high_level/event.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Event
+    attr_reader :raw
+
+    def initialize(raw_event)
+      @raw = raw_event
+    end
+
+    def type
+      @raw[:type]
+    end
+
+    def timestamp
+      @raw[:common][:timestamp]
+    end
+
+    def self.poll
+      event = Raw::SDL_Event.new
+      return nil unless Raw.SDL_PollEvent(event)
+
+      wrap(event)
+    end
+
+    def self.wait(timeout = nil)
+      event = Raw::SDL_Event.new
+      result = if timeout
+                 Raw.SDL_WaitEventTimeout(event, timeout)
+               else
+                 Raw.SDL_WaitEvent(event)
+               end
+      return nil unless result
+
+      wrap(event)
+    end
+
+    def self.each
+      return enum_for(:each) unless block_given?
+
+      while (event = poll)
+        yield event
+      end
+    end
+
+    def self.pump
+      Raw.SDL_PumpEvents
+    end
+
+    def self.push(event)
+      Raw.SDL_PushEvent(event.raw)
+    end
+
+    def self.wrap(raw_event)
+      case raw_event[:type]
+      when Raw::SDL_EVENT_QUIT
+        QuitEvent.new(raw_event)
+      when Raw::SDL_EVENT_KEY_DOWN, Raw::SDL_EVENT_KEY_UP
+        KeyboardEvent.new(raw_event)
+      when Raw::SDL_EVENT_MOUSE_MOTION
+        MouseMotionEvent.new(raw_event)
+      when Raw::SDL_EVENT_MOUSE_BUTTON_DOWN, Raw::SDL_EVENT_MOUSE_BUTTON_UP
+        MouseButtonEvent.new(raw_event)
+      when Raw::SDL_EVENT_MOUSE_WHEEL
+        MouseWheelEvent.new(raw_event)
+      when Raw::SDL_EVENT_WINDOW_CLOSE_REQUESTED,
+           Raw::SDL_EVENT_WINDOW_RESIZED,
+           Raw::SDL_EVENT_WINDOW_MOVED,
+           Raw::SDL_EVENT_WINDOW_SHOWN,
+           Raw::SDL_EVENT_WINDOW_HIDDEN,
+           Raw::SDL_EVENT_WINDOW_EXPOSED,
+           Raw::SDL_EVENT_WINDOW_MINIMIZED,
+           Raw::SDL_EVENT_WINDOW_MAXIMIZED,
+           Raw::SDL_EVENT_WINDOW_RESTORED,
+           Raw::SDL_EVENT_WINDOW_FOCUS_GAINED,
+           Raw::SDL_EVENT_WINDOW_FOCUS_LOST
+        WindowEvent.new(raw_event)
+      else
+        new(raw_event)
+      end
+    end
+
+    def quit?
+      type == Raw::SDL_EVENT_QUIT
+    end
+
+    def key_down?
+      type == Raw::SDL_EVENT_KEY_DOWN
+    end
+
+    def key_up?
+      type == Raw::SDL_EVENT_KEY_UP
+    end
+
+    def mouse_motion?
+      type == Raw::SDL_EVENT_MOUSE_MOTION
+    end
+
+    def mouse_button_down?
+      type == Raw::SDL_EVENT_MOUSE_BUTTON_DOWN
+    end
+
+    def mouse_button_up?
+      type == Raw::SDL_EVENT_MOUSE_BUTTON_UP
+    end
+  end
+
+  class QuitEvent < Event
+  end
+
+  class KeyboardEvent < Event
+    def window_id
+      @raw[:key][:windowID]
+    end
+
+    def scancode
+      @raw[:key][:scancode]
+    end
+
+    def key
+      @raw[:key][:key]
+    end
+
+    def mod
+      @raw[:key][:mod]
+    end
+
+    def down?
+      @raw[:key][:down]
+    end
+
+    def up?
+      !down?
+    end
+
+    def repeat?
+      @raw[:key][:repeat]
+    end
+  end
+
+  class MouseMotionEvent < Event
+    def window_id
+      @raw[:motion][:windowID]
+    end
+
+    def x
+      @raw[:motion][:x]
+    end
+
+    def y
+      @raw[:motion][:y]
+    end
+
+    def xrel
+      @raw[:motion][:xrel]
+    end
+
+    def yrel
+      @raw[:motion][:yrel]
+    end
+
+    def state
+      @raw[:motion][:state]
+    end
+  end
+
+  class MouseButtonEvent < Event
+    def window_id
+      @raw[:button][:windowID]
+    end
+
+    def button
+      @raw[:button][:button]
+    end
+
+    def down?
+      @raw[:button][:down]
+    end
+
+    def up?
+      !down?
+    end
+
+    def clicks
+      @raw[:button][:clicks]
+    end
+
+    def x
+      @raw[:button][:x]
+    end
+
+    def y
+      @raw[:button][:y]
+    end
+  end
+
+  class MouseWheelEvent < Event
+    def window_id
+      @raw[:wheel][:windowID]
+    end
+
+    def x
+      @raw[:wheel][:x]
+    end
+
+    def y
+      @raw[:wheel][:y]
+    end
+
+    def direction
+      @raw[:wheel][:direction]
+    end
+  end
+
+  class WindowEvent < Event
+    def window_id
+      @raw[:window][:windowID]
+    end
+
+    def data1
+      @raw[:window][:data1]
+    end
+
+    def data2
+      @raw[:window][:data2]
+    end
+
+    def close_requested?
+      type == Raw::SDL_EVENT_WINDOW_CLOSE_REQUESTED
+    end
+
+    def resized?
+      type == Raw::SDL_EVENT_WINDOW_RESIZED
+    end
+
+    def moved?
+      type == Raw::SDL_EVENT_WINDOW_MOVED
+    end
+  end
+end