sdl3 1.0.0

data/lib/sdl3/high_level/gamepad.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Gamepad
+    attr_reader :ptr
+
+    def initialize(instance_id)
+      @ptr = Raw.SDL_OpenGamepad(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_CloseGamepad(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.open(instance_id)
+      gamepad = new(instance_id)
+      return gamepad unless block_given?
+
+      begin
+        yield gamepad
+      ensure
+        gamepad.close
+      end
+    end
+
+    def self.available?
+      Raw.SDL_HasGamepad
+    end
+
+    def self.list
+      count_ptr = FFI::MemoryPointer.new(:int)
+      gamepads_ptr = Raw.SDL_GetGamepads(count_ptr)
+      return [] if gamepads_ptr.null?
+
+      count = count_ptr.read_int
+      gamepads_ptr.read_array_of_uint32(count)
+    end
+
+    def self.name_for_id(instance_id)
+      Raw.SDL_GetGamepadNameForID(instance_id)
+    end
+
+    def self.type_for_id(instance_id)
+      Raw.SDL_GetGamepadTypeForID(instance_id)
+    end
+
+    def self.is_gamepad?(joystick_id)
+      Raw.SDL_IsGamepad(joystick_id)
+    end
+
+    def self.add_mapping(mapping)
+      Raw.SDL_AddGamepadMapping(mapping)
+    end
+
+    def self.add_mappings_from_file(file)
+      Raw.SDL_AddGamepadMappingsFromFile(file)
+    end
+
+    def close
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_CloseGamepad(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def id
+      Raw.SDL_GetGamepadID(@ptr)
+    end
+
+    def name
+      Raw.SDL_GetGamepadName(@ptr)
+    end
+
+    def path
+      Raw.SDL_GetGamepadPath(@ptr)
+    end
+
+    def type
+      Raw.SDL_GetGamepadType(@ptr)
+    end
+
+    def real_type
+      Raw.SDL_GetRealGamepadType(@ptr)
+    end
+
+    def vendor
+      Raw.SDL_GetGamepadVendor(@ptr)
+    end
+
+    def product
+      Raw.SDL_GetGamepadProduct(@ptr)
+    end
+
+    def product_version
+      Raw.SDL_GetGamepadProductVersion(@ptr)
+    end
+
+    def firmware_version
+      Raw.SDL_GetGamepadFirmwareVersion(@ptr)
+    end
+
+    def serial
+      Raw.SDL_GetGamepadSerial(@ptr)
+    end
+
+    def connected?
+      Raw.SDL_GamepadConnected(@ptr)
+    end
+
+    def joystick
+      ptr = Raw.SDL_GetGamepadJoystick(@ptr)
+      return nil if ptr.null?
+
+      ptr
+    end
+
+    def axis(axis_id)
+      Raw.SDL_GetGamepadAxis(@ptr, axis_id)
+    end
+
+    def button(button_id)
+      Raw.SDL_GetGamepadButton(@ptr, button_id)
+    end
+
+    def button?(button_id)
+      Raw.SDL_GetGamepadButton(@ptr, button_id)
+    end
+
+    def has_axis?(axis_id)
+      Raw.SDL_GamepadHasAxis(@ptr, axis_id)
+    end
+
+    def has_button?(button_id)
+      Raw.SDL_GamepadHasButton(@ptr, button_id)
+    end
+
+    def rumble(low_frequency, high_frequency, duration_ms)
+      Raw.SDL_RumbleGamepad(@ptr, low_frequency, high_frequency, duration_ms)
+    end
+
+    def rumble_triggers(left, right, duration_ms)
+      Raw.SDL_RumbleGamepadTriggers(@ptr, left, right, duration_ms)
+    end
+
+    def set_led(red, green, blue)
+      Raw.SDL_SetGamepadLED(@ptr, red, green, blue)
+    end
+
+    def player_index
+      Raw.SDL_GetGamepadPlayerIndex(@ptr)
+    end
+
+    def player_index=(index)
+      Raw.SDL_SetGamepadPlayerIndex(@ptr, index)
+    end
+
+    def connection_state
+      Raw.SDL_GetGamepadConnectionState(@ptr)
+    end
+
+    def num_touchpads
+      Raw.SDL_GetNumGamepadTouchpads(@ptr)
+    end
+
+    def has_sensor?(sensor_type)
+      Raw.SDL_GamepadHasSensor(@ptr, sensor_type)
+    end
+
+    def set_sensor_enabled(sensor_type, enabled)
+      Raw.SDL_SetGamepadSensorEnabled(@ptr, sensor_type, enabled)
+    end
+
+    def sensor_enabled?(sensor_type)
+      Raw.SDL_GamepadSensorEnabled(@ptr, sensor_type)
+    end
+
+    def mapping
+      Raw.SDL_GetGamepadMapping(@ptr)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end

data/lib/sdl3/high_level/gpu.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module SDL3
+  class GPUDevice
+    attr_reader :ptr
+
+    def initialize(shader_formats, debug_mode = false, name = nil)
+      @ptr = Raw.SDL_CreateGPUDevice(shader_formats, debug_mode, 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_DestroyGPUDevice(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.create(shader_formats, debug_mode: false, name: nil)
+      device = new(shader_formats, debug_mode, name)
+      return device unless block_given?
+
+      begin
+        yield device
+      ensure
+        device.destroy
+      end
+    end
+
+    def self.create_with_properties(properties_id)
+      ptr = Raw.SDL_CreateGPUDeviceWithProperties(properties_id)
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      device = allocate
+      device.instance_variable_set(:@ptr, ptr)
+      ObjectSpace.define_finalizer(device, releasing(ptr))
+      device
+    end
+
+    def self.num_drivers
+      Raw.SDL_GetNumGPUDrivers
+    end
+
+    def self.driver(index)
+      Raw.SDL_GetGPUDriver(index)
+    end
+
+    def self.supports_shader_formats?(formats, name = nil)
+      Raw.SDL_GPUSupportsShaderFormats(formats, name)
+    end
+
+    def self.supports_properties?(properties_id)
+      Raw.SDL_GPUSupportsProperties(properties_id)
+    end
+
+    def destroy
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_DestroyGPUDevice(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def driver
+      Raw.SDL_GetGPUDeviceDriver(@ptr)
+    end
+
+    def shader_formats
+      Raw.SDL_GetGPUShaderFormats(@ptr)
+    end
+
+    def create_compute_pipeline(create_info)
+      Raw.SDL_CreateGPUComputePipeline(@ptr, create_info)
+    end
+
+    def create_graphics_pipeline(create_info)
+      Raw.SDL_CreateGPUGraphicsPipeline(@ptr, create_info)
+    end
+
+    def create_sampler(create_info)
+      Raw.SDL_CreateGPUSampler(@ptr, create_info)
+    end
+
+    def create_shader(create_info)
+      Raw.SDL_CreateGPUShader(@ptr, create_info)
+    end
+
+    def create_texture(create_info)
+      Raw.SDL_CreateGPUTexture(@ptr, create_info)
+    end
+
+    def create_buffer(create_info)
+      Raw.SDL_CreateGPUBuffer(@ptr, create_info)
+    end
+
+    def create_transfer_buffer(create_info)
+      Raw.SDL_CreateGPUTransferBuffer(@ptr, create_info)
+    end
+
+    def release_texture(texture)
+      Raw.SDL_ReleaseGPUTexture(@ptr, texture)
+    end
+
+    def release_sampler(sampler)
+      Raw.SDL_ReleaseGPUSampler(@ptr, sampler)
+    end
+
+    def release_buffer(buffer)
+      Raw.SDL_ReleaseGPUBuffer(@ptr, buffer)
+    end
+
+    def release_transfer_buffer(transfer_buffer)
+      Raw.SDL_ReleaseGPUTransferBuffer(@ptr, transfer_buffer)
+    end
+
+    def release_compute_pipeline(pipeline)
+      Raw.SDL_ReleaseGPUComputePipeline(@ptr, pipeline)
+    end
+
+    def release_shader(shader)
+      Raw.SDL_ReleaseGPUShader(@ptr, shader)
+    end
+
+    def release_graphics_pipeline(pipeline)
+      Raw.SDL_ReleaseGPUGraphicsPipeline(@ptr, pipeline)
+    end
+
+    def acquire_command_buffer
+      Raw.SDL_AcquireGPUCommandBuffer(@ptr)
+    end
+
+    def claim_window(window)
+      Raw.SDL_ClaimWindowForGPUDevice(@ptr, window.to_ptr)
+    end
+
+    def release_window(window)
+      Raw.SDL_ReleaseWindowFromGPUDevice(@ptr, window.to_ptr)
+    end
+
+    def set_swapchain_parameters(window, composition, present_mode)
+      Raw.SDL_SetGPUSwapchainParameters(@ptr, window.to_ptr, composition, present_mode)
+    end
+
+    def set_allowed_frames_in_flight(count)
+      Raw.SDL_SetGPUAllowedFramesInFlight(@ptr, count)
+    end
+
+    def swapchain_texture_format(window)
+      Raw.SDL_GetGPUSwapchainTextureFormat(@ptr, window.to_ptr)
+    end
+
+    def wait_for_idle
+      Raw.SDL_WaitForGPUIdle(@ptr)
+    end
+
+    def wait_for_fences(wait_all, fences)
+      fences_ptr = FFI::MemoryPointer.new(:pointer, fences.size)
+      fences.each_with_index { |f, i| fences_ptr.put_pointer(i * FFI::Pointer.size, f) }
+      Raw.SDL_WaitForGPUFences(@ptr, wait_all, fences_ptr, fences.size)
+    end
+
+    def query_fence(fence)
+      Raw.SDL_QueryGPUFence(@ptr, fence)
+    end
+
+    def release_fence(fence)
+      Raw.SDL_ReleaseGPUFence(@ptr, fence)
+    end
+
+    def texture_supports_format?(format, type, usage)
+      Raw.SDL_GPUTextureSupportsFormat(@ptr, format, type, usage)
+    end
+
+    def texture_supports_sample_count?(format, sample_count)
+      Raw.SDL_GPUTextureSupportsSampleCount(@ptr, format, sample_count)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+
+  module GPU
+    class << self
+      def texture_format_texel_block_size(format)
+        Raw.SDL_GPUTextureFormatTexelBlockSize(format)
+      end
+
+      def calculate_texture_format_size(format, width, height, depth)
+        Raw.SDL_CalculateGPUTextureFormatSize(format, width, height, depth)
+      end
+    end
+  end
+end

data/lib/sdl3/high_level/haptic.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module SDL3
+  class Haptic
+    attr_reader :ptr
+
+    CONSTANT = Raw::SDL_HAPTIC_CONSTANT
+    SINE = Raw::SDL_HAPTIC_SINE
+    SQUARE = Raw::SDL_HAPTIC_SQUARE
+    TRIANGLE = Raw::SDL_HAPTIC_TRIANGLE
+    SAWTOOTHUP = Raw::SDL_HAPTIC_SAWTOOTHUP
+    SAWTOOTHDOWN = Raw::SDL_HAPTIC_SAWTOOTHDOWN
+    RAMP = Raw::SDL_HAPTIC_RAMP
+    SPRING = Raw::SDL_HAPTIC_SPRING
+    DAMPER = Raw::SDL_HAPTIC_DAMPER
+    INERTIA = Raw::SDL_HAPTIC_INERTIA
+    FRICTION = Raw::SDL_HAPTIC_FRICTION
+    LEFTRIGHT = Raw::SDL_HAPTIC_LEFTRIGHT
+    CUSTOM = Raw::SDL_HAPTIC_CUSTOM
+    GAIN = Raw::SDL_HAPTIC_GAIN
+    AUTOCENTER = Raw::SDL_HAPTIC_AUTOCENTER
+    STATUS = Raw::SDL_HAPTIC_STATUS
+    PAUSE = Raw::SDL_HAPTIC_PAUSE
+
+    POLAR = Raw::SDL_HAPTIC_POLAR
+    CARTESIAN = Raw::SDL_HAPTIC_CARTESIAN
+    SPHERICAL = Raw::SDL_HAPTIC_SPHERICAL
+    STEERING_AXIS = Raw::SDL_HAPTIC_STEERING_AXIS
+
+    INFINITY = Raw::SDL_HAPTIC_INFINITY
+
+    def initialize(haptic_id)
+      @ptr = Raw.SDL_OpenHaptic(haptic_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_CloseHaptic(prevented_ptr) unless prevented_ptr.null? }
+    end
+
+    def self.open(haptic_id)
+      haptic = new(haptic_id)
+      return haptic unless block_given?
+
+      begin
+        yield haptic
+      ensure
+        haptic.close
+      end
+    end
+
+    def self.open_from_mouse
+      ptr = Raw.SDL_OpenHapticFromMouse
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      haptic = allocate
+      haptic.instance_variable_set(:@ptr, ptr)
+      ObjectSpace.define_finalizer(haptic, releasing(ptr))
+
+      return haptic unless block_given?
+
+      begin
+        yield haptic
+      ensure
+        haptic.close
+      end
+    end
+
+    def self.open_from_joystick(joystick)
+      ptr = Raw.SDL_OpenHapticFromJoystick(joystick.to_ptr)
+      raise Error, Raw.SDL_GetError if ptr.null?
+
+      haptic = allocate
+      haptic.instance_variable_set(:@ptr, ptr)
+      ObjectSpace.define_finalizer(haptic, releasing(ptr))
+
+      return haptic unless block_given?
+
+      begin
+        yield haptic
+      ensure
+        haptic.close
+      end
+    end
+
+    def self.list
+      count_ptr = FFI::MemoryPointer.new(:int)
+      haptics_ptr = Raw.SDL_GetHaptics(count_ptr)
+      return [] if haptics_ptr.null?
+
+      count = count_ptr.read_int
+      haptics_ptr.read_array_of_uint32(count)
+    end
+
+    def self.name_for_id(haptic_id)
+      Raw.SDL_GetHapticNameForID(haptic_id)
+    end
+
+    def self.mouse_haptic?
+      Raw.SDL_IsMouseHaptic
+    end
+
+    def self.joystick_haptic?(joystick)
+      Raw.SDL_IsJoystickHaptic(joystick.to_ptr)
+    end
+
+    def close
+      return if @ptr.null?
+
+      ObjectSpace.undefine_finalizer(self)
+      Raw.SDL_CloseHaptic(@ptr)
+      @ptr = FFI::Pointer::NULL
+    end
+
+    def id
+      Raw.SDL_GetHapticID(@ptr)
+    end
+
+    def name
+      Raw.SDL_GetHapticName(@ptr)
+    end
+
+    def max_effects
+      Raw.SDL_GetMaxHapticEffects(@ptr)
+    end
+
+    def max_effects_playing
+      Raw.SDL_GetMaxHapticEffectsPlaying(@ptr)
+    end
+
+    def features
+      Raw.SDL_GetHapticFeatures(@ptr)
+    end
+
+    def num_axes
+      Raw.SDL_GetNumHapticAxes(@ptr)
+    end
+
+    def effect_supported?(effect)
+      Raw.SDL_HapticEffectSupported(@ptr, effect)
+    end
+
+    def create_effect(effect)
+      result = Raw.SDL_CreateHapticEffect(@ptr, effect)
+      raise Error, Raw.SDL_GetError if result < 0
+
+      result
+    end
+
+    def update_effect(effect_id, effect)
+      Raw.SDL_UpdateHapticEffect(@ptr, effect_id, effect)
+    end
+
+    def run_effect(effect_id, iterations = 1)
+      Raw.SDL_RunHapticEffect(@ptr, effect_id, iterations)
+    end
+
+    def stop_effect(effect_id)
+      Raw.SDL_StopHapticEffect(@ptr, effect_id)
+    end
+
+    def destroy_effect(effect_id)
+      Raw.SDL_DestroyHapticEffect(@ptr, effect_id)
+    end
+
+    def effect_status(effect_id)
+      Raw.SDL_GetHapticEffectStatus(@ptr, effect_id)
+    end
+
+    def gain=(value)
+      Raw.SDL_SetHapticGain(@ptr, value)
+    end
+
+    def autocenter=(value)
+      Raw.SDL_SetHapticAutocenter(@ptr, value)
+    end
+
+    def pause
+      Raw.SDL_PauseHaptic(@ptr)
+    end
+
+    def resume
+      Raw.SDL_ResumeHaptic(@ptr)
+    end
+
+    def stop_all
+      Raw.SDL_StopHapticEffects(@ptr)
+    end
+
+    def rumble_supported?
+      Raw.SDL_HapticRumbleSupported(@ptr)
+    end
+
+    def init_rumble
+      Raw.SDL_InitHapticRumble(@ptr)
+    end
+
+    def play_rumble(strength, duration_ms)
+      Raw.SDL_PlayHapticRumble(@ptr, strength, duration_ms)
+    end
+
+    def stop_rumble
+      Raw.SDL_StopHapticRumble(@ptr)
+    end
+
+    def to_ptr
+      @ptr
+    end
+  end
+end