sdl3 1.0.0

data/lib/sdl3/high_level/joystick.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Joystick
+    attr_reader :ptr
+
+    HAT_CENTERED = Raw::SDL_HAT_CENTERED
+    HAT_UP = Raw::SDL_HAT_UP
+    HAT_RIGHT = Raw::SDL_HAT_RIGHT
+    HAT_DOWN = Raw::SDL_HAT_DOWN
+    HAT_LEFT = Raw::SDL_HAT_LEFT
+
+    def initialize(instance_id)
+      @ptr = Raw.SDL_OpenJoystick(instance_id)
+      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_CloseJoystick(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.open(instance_id)
+      joystick = new(instance_id)
+      return joystick unless block_given?
+
+      begin
+        yield joystick
+      ensure
+        joystick.close
+      end
+    end
+
+    def self.available?
+      Raw.SDL_HasJoystick
+    end
+
+    def self.list
+      count_ptr = FFI::MemoryPointer.new(:int)
+      joysticks_ptr = Raw.SDL_GetJoysticks(count_ptr)
+      return [] if joysticks_ptr.null?
+
+      count = count_ptr.read_int
+      joysticks_ptr.read_array_of_uint32(count)
+    end
+
+    def self.name_for_id(instance_id)
+      Raw.SDL_GetJoystickNameForID(instance_id)
+    end
+
+    def self.type_for_id(instance_id)
+      Raw.SDL_GetJoystickTypeForID(instance_id)
+    end
+
+    def close
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_CloseJoystick(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def id
+      Raw.SDL_GetJoystickID(@ptr)
+    end
+
+    def name
+      Raw.SDL_GetJoystickName(@ptr)
+    end
+
+    def path
+      Raw.SDL_GetJoystickPath(@ptr)
+    end
+
+    def type
+      Raw.SDL_GetJoystickType(@ptr)
+    end
+
+    def vendor
+      Raw.SDL_GetJoystickVendor(@ptr)
+    end
+
+    def product
+      Raw.SDL_GetJoystickProduct(@ptr)
+    end
+
+    def product_version
+      Raw.SDL_GetJoystickProductVersion(@ptr)
+    end
+
+    def firmware_version
+      Raw.SDL_GetJoystickFirmwareVersion(@ptr)
+    end
+
+    def serial
+      Raw.SDL_GetJoystickSerial(@ptr)
+    end
+
+    def connected?
+      Raw.SDL_JoystickConnected(@ptr)
+    end
+
+    def num_axes
+      Raw.SDL_GetNumJoystickAxes(@ptr)
+    end
+
+    def num_balls
+      Raw.SDL_GetNumJoystickBalls(@ptr)
+    end
+
+    def num_hats
+      Raw.SDL_GetNumJoystickHats(@ptr)
+    end
+
+    def num_buttons
+      Raw.SDL_GetNumJoystickButtons(@ptr)
+    end
+
+    def axis(index)
+      Raw.SDL_GetJoystickAxis(@ptr, index)
+    end
+
+    def hat(index)
+      Raw.SDL_GetJoystickHat(@ptr, index)
+    end
+
+    def button(index)
+      Raw.SDL_GetJoystickButton(@ptr, index)
+    end
+
+    def button?(index)
+      Raw.SDL_GetJoystickButton(@ptr, index)
+    end
+
+    def rumble(low_frequency, high_frequency, duration_ms)
+      Raw.SDL_RumbleJoystick(@ptr, low_frequency, high_frequency, duration_ms)
+    end
+
+    def rumble_triggers(left, right, duration_ms)
+      Raw.SDL_RumbleJoystickTriggers(@ptr, left, right, duration_ms)
+    end
+
+    def set_led(red, green, blue)
+      Raw.SDL_SetJoystickLED(@ptr, red, green, blue)
+    end
+
+    def player_index
+      Raw.SDL_GetJoystickPlayerIndex(@ptr)
+    end
+
+    def player_index=(index)
+      Raw.SDL_SetJoystickPlayerIndex(@ptr, index)
+    end
+
+    def connection_state
+      Raw.SDL_GetJoystickConnectionState(@ptr)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/sdl3/high_level/renderer.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Renderer
+    attr_reader :ptr
+
+    def initialize(window, driver_name = nil)
+      @ptr = Raw.SDL_CreateRenderer(window.to_ptr, driver_name)
+      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_DestroyRenderer(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.create(window, driver_name = nil)
+      renderer = new(window, driver_name)
+      return renderer unless block_given?
+
+      begin
+        yield renderer
+      ensure
+        renderer.destroy
+      end
+    end
+
+    def destroy
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_DestroyRenderer(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def draw_color
+      r = FFI::MemoryPointer.new(:uint8)
+      g = FFI::MemoryPointer.new(:uint8)
+      b = FFI::MemoryPointer.new(:uint8)
+      a = FFI::MemoryPointer.new(:uint8)
+      Raw.SDL_GetRenderDrawColor(@ptr, r, g, b, a)
+      [r.read_uint8, g.read_uint8, b.read_uint8, a.read_uint8]
+    end
+
+    def draw_color=(color)
+      r, g, b, a = color
+      a ||= 255
+      Raw.SDL_SetRenderDrawColor(@ptr, r, g, b, a)
+    end
+
+    def clear
+      raise Error, Raw.SDL_GetError unless Raw.SDL_RenderClear(@ptr)
+
+      true
+    end
+
+    def present
+      raise Error, Raw.SDL_GetError unless Raw.SDL_RenderPresent(@ptr)
+
+      true
+    end
+
+    def draw_point(x, y)
+      Raw.SDL_RenderPoint(@ptr, x.to_f, y.to_f)
+    end
+
+    def draw_line(x1, y1, x2, y2)
+      Raw.SDL_RenderLine(@ptr, x1.to_f, y1.to_f, x2.to_f, y2.to_f)
+    end
+
+    def draw_rect(x, y, w, h)
+      rect = Raw::SDL_FRect.new
+      rect[:x] = x.to_f
+      rect[:y] = y.to_f
+      rect[:w] = w.to_f
+      rect[:h] = h.to_f
+      Raw.SDL_RenderRect(@ptr, rect)
+    end
+
+    def fill_rect(x, y, w, h)
+      rect = Raw::SDL_FRect.new
+      rect[:x] = x.to_f
+      rect[:y] = y.to_f
+      rect[:w] = w.to_f
+      rect[:h] = h.to_f
+      Raw.SDL_RenderFillRect(@ptr, rect)
+    end
+
+    def copy(texture, src_rect = nil, dst_rect = nil)
+      src = rect_to_frect(src_rect)
+      dst = rect_to_frect(dst_rect)
+      Raw.SDL_RenderTexture(@ptr, texture.to_ptr, src, dst)
+    end
+
+    def copy_ex(texture, src_rect, dst_rect, angle, center = nil, flip = :SDL_FLIP_NONE)
+      src = rect_to_frect(src_rect)
+      dst = rect_to_frect(dst_rect)
+      center_ptr = nil
+      if center
+        center_ptr = Raw::SDL_FPoint.new
+        center_ptr[:x] = center[0].to_f
+        center_ptr[:y] = center[1].to_f
+      end
+      Raw.SDL_RenderTextureRotated(@ptr, texture.to_ptr, src, dst, angle.to_f, center_ptr, flip)
+    end
+
+    def target=(texture)
+      ptr = texture ? texture.to_ptr : nil
+      Raw.SDL_SetRenderTarget(@ptr, ptr)
+    end
+
+    def logical_size=(dimensions)
+      Raw.SDL_SetRenderLogicalPresentation(@ptr, dimensions[0], dimensions[1],
+                                           :SDL_LOGICAL_PRESENTATION_LETTERBOX,
+                                           :SDL_SCALEMODE_LINEAR)
+    end
+
+    def scale=(factors)
+      Raw.SDL_SetRenderScale(@ptr, factors[0].to_f, factors[1].to_f)
+    end
+
+    def scale
+      x = FFI::MemoryPointer.new(:float)
+      y = FFI::MemoryPointer.new(:float)
+      Raw.SDL_GetRenderScale(@ptr, x, y)
+      [x.read_float, y.read_float]
+    end
+
+    def create_texture(format, access, width, height)
+      Texture.new(self, format, access, width, height)
+    end
+
+    def create_texture_from_surface(surface)
+      Texture.from_surface(self, surface)
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def rect_to_frect(rect)
+      return nil unless rect
+
+      frect = Raw::SDL_FRect.new
+      if rect.is_a?(Hash)
+        frect[:x] = rect[:x].to_f
+        frect[:y] = rect[:y].to_f
+        frect[:w] = rect[:w].to_f
+        frect[:h] = rect[:h].to_f
+      else
+        frect[:x] = rect[0].to_f
+        frect[:y] = rect[1].to_f
+        frect[:w] = rect[2].to_f
+        frect[:h] = rect[3].to_f
+      end
+      frect
+    end
+  end
+end

data/lib/sdl3/high_level/sensor.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Sensor
+    attr_reader :ptr
+
+    STANDARD_GRAVITY = Raw::SDL_STANDARD_GRAVITY
+
+    TYPE_INVALID = :SDL_SENSOR_INVALID
+    TYPE_UNKNOWN = :SDL_SENSOR_UNKNOWN
+    TYPE_ACCEL = :SDL_SENSOR_ACCEL
+    TYPE_GYRO = :SDL_SENSOR_GYRO
+    TYPE_ACCEL_L = :SDL_SENSOR_ACCEL_L
+    TYPE_GYRO_L = :SDL_SENSOR_GYRO_L
+    TYPE_ACCEL_R = :SDL_SENSOR_ACCEL_R
+    TYPE_GYRO_R = :SDL_SENSOR_GYRO_R
+
+    def initialize(sensor_id)
+      @ptr = Raw.SDL_OpenSensor(sensor_id)
+      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_CloseSensor(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.open(sensor_id)
+      sensor = new(sensor_id)
+      return sensor unless block_given?
+
+      begin
+        yield sensor
+      ensure
+        sensor.close
+      end
+    end
+
+    def self.list
+      count_ptr = FFI::MemoryPointer.new(:int)
+      sensors_ptr = Raw.SDL_GetSensors(count_ptr)
+      return [] if sensors_ptr.null?
+
+      count = count_ptr.read_int
+      sensors_ptr.read_array_of_uint32(count)
+    end
+
+    def self.name_for_id(sensor_id)
+      Raw.SDL_GetSensorNameForID(sensor_id)
+    end
+
+    def self.type_for_id(sensor_id)
+      Raw.SDL_GetSensorTypeForID(sensor_id)
+    end
+
+    def self.non_portable_type_for_id(sensor_id)
+      Raw.SDL_GetSensorNonPortableTypeForID(sensor_id)
+    end
+
+    def self.update_all
+      Raw.SDL_UpdateSensors
+    end
+
+    def close
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_CloseSensor(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def id
+      Raw.SDL_GetSensorID(@ptr)
+    end
+
+    def name
+      Raw.SDL_GetSensorName(@ptr)
+    end
+
+    def type
+      Raw.SDL_GetSensorType(@ptr)
+    end
+
+    def non_portable_type
+      Raw.SDL_GetSensorNonPortableType(@ptr)
+    end
+
+    def properties
+      Raw.SDL_GetSensorProperties(@ptr)
+    end
+
+    def data(num_values = 3)
+      data_ptr = FFI::MemoryPointer.new(:float, num_values)
+      return nil unless Raw.SDL_GetSensorData(@ptr, data_ptr, num_values)
+
+      data_ptr.read_array_of_float(num_values)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/sdl3/high_level/surface.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Surface
+    attr_reader :ptr
+
+    def initialize(width, height, format = Raw::SDL_PIXELFORMAT_RGBA8888)
+      @ptr = Raw.SDL_CreateSurface(width, height, format)
+      raise Error, Raw.SDL_GetError if @ptr.null?
+
+      @owned = true
+      ObjectSpace.define_finalizer(self, self.class.releasing(@ptr))
+    end
+
+    def self.releasing(ptr)
+      prevented_ptr = ptr
+      proc do
+        Raw.SDL_DestroySurface(prevented_ptr) unless prevented_ptr.null?
+      end
+    end
+
+    def self.from_ptr(ptr, owned: true)
+      surface = allocate
+      surface.instance_variable_set(:@ptr, ptr)
+      surface.instance_variable_set(:@owned, owned)
+      ObjectSpace.define_finalizer(surface, releasing(ptr)) if owned
+      surface
+    end
+
+    def self.load_bmp(file)
+      ptr = Raw.SDL_LoadBMP(file)
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      from_ptr(ptr, owned: true)
+    end
+
+    def destroy
+      return if @ptr.null?
+      return unless @owned
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_DestroySurface(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def width
+      struct[:w]
+    end
+
+    def height
+      struct[:h]
+    end
+
+    def size
+      [width, height]
+    end
+
+    def pitch
+      struct[:pitch]
+    end
+
+    def format
+      struct[:format]
+    end
+
+    def pixels
+      struct[:pixels]
+    end
+
+    def lock
+      raise Error, Raw.SDL_GetError unless Raw.SDL_LockSurface(@ptr)
+
+      true
+    end
+
+    def unlock
+      Raw.SDL_UnlockSurface(@ptr)
+    end
+
+    def fill_rect(rect, color)
+      rect_ptr = nil
+      if rect
+        rect_ptr = Raw::SDL_Rect.new
+        rect_ptr[:x] = rect[0]
+        rect_ptr[:y] = rect[1]
+        rect_ptr[:w] = rect[2]
+        rect_ptr[:h] = rect[3]
+      end
+      Raw.SDL_FillSurfaceRect(@ptr, rect_ptr, color)
+    end
+
+    def blit(src_surface, src_rect = nil, dst_rect = nil)
+      src_rect_ptr = nil
+      dst_rect_ptr = nil
+
+      if src_rect
+        src_rect_ptr = Raw::SDL_Rect.new
+        src_rect_ptr[:x] = src_rect[0]
+        src_rect_ptr[:y] = src_rect[1]
+        src_rect_ptr[:w] = src_rect[2]
+        src_rect_ptr[:h] = src_rect[3]
+      end
+
+      if dst_rect
+        dst_rect_ptr = Raw::SDL_Rect.new
+        dst_rect_ptr[:x] = dst_rect[0]
+        dst_rect_ptr[:y] = dst_rect[1]
+        dst_rect_ptr[:w] = dst_rect[2]
+        dst_rect_ptr[:h] = dst_rect[3]
+      end
+
+      Raw.SDL_BlitSurface(src_surface.to_ptr, src_rect_ptr, @ptr, dst_rect_ptr)
+    end
+
+    def convert(format)
+      ptr = Raw.SDL_ConvertSurface(@ptr, format)
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      Surface.from_ptr(ptr, owned: true)
+    end
+
+    def flip(mode)
+      Raw.SDL_FlipSurface(@ptr, mode)
+    end
+
+    def duplicate
+      ptr = Raw.SDL_DuplicateSurface(@ptr)
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      Surface.from_ptr(ptr, owned: true)
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def struct
+      @struct ||= Raw::SDL_Surface.new(@ptr)
+    end
+  end
+end

data/lib/sdl3/high_level/texture.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Texture
+    attr_reader :ptr
+
+    ACCESS_STATIC = :SDL_TEXTUREACCESS_STATIC
+    ACCESS_STREAMING = :SDL_TEXTUREACCESS_STREAMING
+    ACCESS_TARGET = :SDL_TEXTUREACCESS_TARGET
+
+    def initialize(renderer, format, access, width, height)
+      access_value = case access
+                     when Symbol then Raw::SDL_TextureAccess[access]
+                     when Integer then access
+                     else access
+                     end
+      @ptr = Raw.SDL_CreateTexture(renderer.to_ptr, format, access_value, width, height)
+      raise Error, Raw.SDL_GetError if @ptr.null?
+
+      @owned = true
+      ObjectSpace.define_finalizer(self, self.class.releasing(@ptr))
+    end
+
+    def self.releasing(ptr)
+      prevented_ptr = ptr
+      proc { Raw.SDL_DestroyTexture(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.from_surface(renderer, surface)
+      ptr = Raw.SDL_CreateTextureFromSurface(renderer.to_ptr, surface.to_ptr)
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      texture = allocate
+      texture.instance_variable_set(:@ptr, ptr)
+      texture.instance_variable_set(:@owned, true)
+      ObjectSpace.define_finalizer(texture, releasing(ptr))
+      texture
+    end
+
+    def destroy
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_DestroyTexture(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def size
+      w = FFI::MemoryPointer.new(:float)
+      h = FFI::MemoryPointer.new(:float)
+      Raw.SDL_GetTextureSize(@ptr, w, h)
+      [w.read_float.to_i, h.read_float.to_i]
+    end
+
+    def width
+      size[0]
+    end
+
+    def height
+      size[1]
+    end
+
+    def color_mod=(rgb)
+      Raw.SDL_SetTextureColorMod(@ptr, rgb[0], rgb[1], rgb[2])
+    end
+
+    def color_mod
+      r = FFI::MemoryPointer.new(:uint8)
+      g = FFI::MemoryPointer.new(:uint8)
+      b = FFI::MemoryPointer.new(:uint8)
+      Raw.SDL_GetTextureColorMod(@ptr, r, g, b)
+      [r.read_uint8, g.read_uint8, b.read_uint8]
+    end
+
+    def alpha_mod=(alpha)
+      Raw.SDL_SetTextureAlphaMod(@ptr, alpha)
+    end
+
+    def alpha_mod
+      a = FFI::MemoryPointer.new(:uint8)
+      Raw.SDL_GetTextureAlphaMod(@ptr, a)
+      a.read_uint8
+    end
+
+    def blend_mode=(mode)
+      Raw.SDL_SetTextureBlendMode(@ptr, mode)
+    end
+
+    def blend_mode
+      mode = FFI::MemoryPointer.new(:uint32)
+      Raw.SDL_GetTextureBlendMode(@ptr, mode)
+      mode.read_uint32
+    end
+
+    def update(rect, pixels, pitch)
+      rect_ptr = nil
+      if rect
+        rect_ptr = Raw::SDL_Rect.new
+        rect_ptr[:x] = rect[0]
+        rect_ptr[:y] = rect[1]
+        rect_ptr[:w] = rect[2]
+        rect_ptr[:h] = rect[3]
+      end
+      Raw.SDL_UpdateTexture(@ptr, rect_ptr, pixels, pitch)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end