sdl3 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 37621cbf33f558e5e6186e54b27d6e0e73cf6bc4ebb90ed74cc98ba8f2436960
+  data.tar.gz: a336c2744b580b22deab6235f135c71560a3122a333f85ba76d325a83f89fc62
+SHA512:
+  metadata.gz: 433ba48b7ee208d06d47784bb9a4d43faa9915755fa34c33b407f253b1c57b9cbc0f05f25125b22817e7038090e7b5dc1de7f04df91d622d9cce77c524ce535f
+  data.tar.gz: fed5b92c22a1465276b9e139da79bd7d32efe99e02298e1fc4ff154ffb1bee6488236eee7f5b800f77ca2d91f5e36af5dfcff91b6073981135e6f7095fcb4348

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0 - 2026-01-05
+
+- Initial release.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,188 @@
+# SDL3 Ruby
+
+Ruby FFI bindings for [SDL3](https://www.libsdl.org/) (Simple DirectMedia Layer 3).
+
+## Features
+
+- Complete FFI bindings for SDL3
+- Two-layer API design:
+  - Low-level API (`SDL3::Raw`) - Direct 1:1 mapping to SDL3 C functions
+  - High-level API (`SDL3`) - Idiomatic Ruby wrappers with automatic resource management
+- No native compilation required (pure FFI)
+- Cross-platform support (Linux, macOS, Windows)
+- Compatible with CRuby, JRuby, and TruffleRuby
+
+## Requirements
+
+- Ruby >= 3.1.0
+- SDL3 library installed on your system
+
+### Installing SDL3
+
+macOS (Homebrew):
+
+```bash
+brew install sdl3
+```
+
+Ubuntu/Debian:
+
+```bash
+# SDL3 may need to be built from source or installed from a PPA
+# Check https://github.com/libsdl-org/SDL for instructions
+```
+
+Windows:
+
+Download SDL3 from https://github.com/libsdl-org/SDL/releases and add to your PATH.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sdl3'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install sdl3
+```
+
+## Usage
+
+### High-Level API
+
+The high-level API provides idiomatic Ruby wrappers with automatic resource management:
+
+```ruby
+require 'sdl3'
+
+SDL3.init(SDL3::INIT_VIDEO)
+
+SDL3::Window.open("Hello SDL3!", 800, 600) do |window|
+  SDL3::Renderer.create(window) do |renderer|
+    running = true
+
+    while running
+      SDL3::Event.each do |event|
+        running = false if event.quit?
+      end
+
+      renderer.draw_color = [30, 30, 30, 255]
+      renderer.clear
+
+      renderer.draw_color = [255, 100, 100, 255]
+      renderer.fill_rect(100, 100, 50, 50)
+
+      renderer.present
+
+      SDL3::Raw.SDL_Delay(16)
+    end
+  end
+end
+
+SDL3.quit
+```
+
+### Low-Level API
+
+For direct access to SDL3 functions, use the `SDL3::Raw` module:
+
+```ruby
+require 'sdl3'
+
+SDL3::Raw.SDL_Init(SDL3::Raw::SDL_INIT_VIDEO)
+
+window = SDL3::Raw.SDL_CreateWindow("Low-level Example", 800, 600, 0)
+renderer = SDL3::Raw.SDL_CreateRenderer(window, nil)
+
+# ... your code ...
+
+SDL3::Raw.SDL_DestroyRenderer(renderer)
+SDL3::Raw.SDL_DestroyWindow(window)
+SDL3::Raw.SDL_Quit
+```
+
+### Keyboard and Mouse Input
+
+```ruby
+SDL3::Event.each do |event|
+  case
+  when event.quit?
+    running = false
+  when event.key_down?
+    puts "Key pressed: #{event.key_scancode}"
+  when event.mouse_button_down?
+    puts "Mouse clicked at: #{event.mouse_x}, #{event.mouse_y}"
+  end
+end
+```
+
+### Gamepad Input
+
+```ruby
+SDL3.init(SDL3::INIT_VIDEO | SDL3::INIT_GAMEPAD)
+
+if SDL3::Gamepad.available?
+  gamepad_list = SDL3::Gamepad.list
+
+  SDL3::Gamepad.open(gamepad_list.first) do |gamepad|
+    puts "Gamepad: #{gamepad.name}"
+
+    left_x = gamepad.axis(:SDL_GAMEPAD_AXIS_LEFTX)
+    a_button = gamepad.button?(:SDL_GAMEPAD_BUTTON_SOUTH)
+
+    gamepad.rumble(0xFFFF, 0xFFFF, 500)
+  end
+end
+```
+
+## API Coverage
+
+This gem provides bindings for all SDL3 subsystems:
+
+- Video - Window, display, and OpenGL/Vulkan/Metal context management
+- Render - 2D hardware-accelerated rendering
+- Audio - Audio playback and recording
+- Input - Keyboard, mouse, joystick, gamepad, touch, pen, and sensor
+- Events - Event handling
+- Haptic - Force feedback
+- GPU - Low-level GPU/3D rendering
+- Timer - Timer and performance counter
+- Filesystem - File and directory operations
+- Clipboard - Clipboard access
+- Camera - Camera capture
+- HID - Human Interface Device access
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+```bash
+git clone https://github.com/ydah/sdl3-ruby.git
+cd sdl3-ruby
+bundle install
+rake test
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ydah/sdl3-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## See Also
+
+- [SDL3 Documentation](https://wiki.libsdl.org/SDL3/)
+- [SDL3 API Reference](https://wiki.libsdl.org/SDL3/APIByCategory)
+- [Ruby FFI](https://github.com/ffi/ffi)

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/examples/01_hello_window.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/sdl3"
+
+SDL3.init(SDL3::INIT_VIDEO)
+
+SDL3::Window.open("Hello SDL3!", 800, 600) do |window|
+  running = true
+
+  while running
+    SDL3::Event.each do |event|
+      running = false if event.quit?
+    end
+
+    surface = window.surface
+    surface.fill_rect(nil, 0xFF6B8E23)
+    window.update_surface
+
+    SDL3::Raw.SDL_Delay(16)
+  end
+end
+
+SDL3.quit

data/examples/02_basic_rendering.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/sdl3"
+
+SDL3.init(SDL3::INIT_VIDEO)
+
+SDL3::Window.open("Basic Rendering", 800, 600) do |window|
+  SDL3::Renderer.create(window) do |renderer|
+    running = true
+    x = 100
+    y = 100
+    dx = 2
+    dy = 2
+
+    while running
+      SDL3::Event.each do |event|
+        running = false if event.quit?
+      end
+
+      renderer.draw_color = [30, 30, 30, 255]
+      renderer.clear
+
+      renderer.draw_color = [255, 100, 100, 255]
+      renderer.fill_rect(x, y, 50, 50)
+
+      renderer.draw_color = [100, 255, 100, 255]
+      renderer.draw_rect(200, 200, 100, 100)
+
+      renderer.draw_color = [100, 100, 255, 255]
+      renderer.draw_line(400, 100, 600, 300)
+
+      x += dx
+      y += dy
+      dx = -dx if x <= 0 || x >= 750
+      dy = -dy if y <= 0 || y >= 550
+
+      renderer.present
+
+      SDL3::Raw.SDL_Delay(16)
+    end
+  end
+end
+
+SDL3.quit

data/examples/03_keyboard_input.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/sdl3"
+
+SDL3.init(SDL3::INIT_VIDEO)
+
+SDL3::Window.open("Keyboard Input", 800, 600) do |window|
+  SDL3::Renderer.create(window) do |renderer|
+    running = true
+    x = 375.0
+    y = 275.0
+    speed = 5.0
+
+    while running
+      SDL3::Event.each do |event|
+        case event.type
+        when SDL3::Raw::SDL_EVENT_QUIT
+          running = false
+        when SDL3::Raw::SDL_EVENT_KEY_DOWN
+          case event.scancode
+          when SDL3::Raw::SDL_SCANCODE_ESCAPE
+            running = false
+          when SDL3::Raw::SDL_SCANCODE_UP, SDL3::Raw::SDL_SCANCODE_W
+            y -= speed
+          when SDL3::Raw::SDL_SCANCODE_DOWN, SDL3::Raw::SDL_SCANCODE_S
+            y += speed
+          when SDL3::Raw::SDL_SCANCODE_LEFT, SDL3::Raw::SDL_SCANCODE_A
+            x -= speed
+          when SDL3::Raw::SDL_SCANCODE_RIGHT, SDL3::Raw::SDL_SCANCODE_D
+            x += speed
+          end
+        end
+      end
+
+      x = [[x, 0].max, 750].min
+      y = [[y, 0].max, 550].min
+
+      renderer.draw_color = [20, 20, 40, 255]
+      renderer.clear
+
+      renderer.draw_color = [0, 200, 255, 255]
+      renderer.fill_rect(x, y, 50, 50)
+
+      renderer.present
+
+      SDL3::Raw.SDL_Delay(16)
+    end
+  end
+end
+
+SDL3.quit

data/examples/04_mouse_input.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/sdl3"
+
+SDL3.init(SDL3::INIT_VIDEO)
+
+SDL3::Window.open("Mouse Input", 800, 600) do |window|
+  SDL3::Renderer.create(window) do |renderer|
+    running = true
+    circles = []
+
+    while running
+      SDL3::Event.each do |event|
+        case event.type
+        when SDL3::Raw::SDL_EVENT_QUIT
+          running = false
+        when SDL3::Raw::SDL_EVENT_KEY_DOWN
+          running = false if event.scancode == SDL3::Raw::SDL_SCANCODE_ESCAPE
+          circles.clear if event.scancode == SDL3::Raw::SDL_SCANCODE_C
+        when SDL3::Raw::SDL_EVENT_MOUSE_BUTTON_DOWN
+          circles << {
+            x: event.x,
+            y: event.y,
+            r: rand(128..255),
+            g: rand(128..255),
+            b: rand(128..255)
+          }
+        end
+      end
+
+      renderer.draw_color = [10, 10, 20, 255]
+      renderer.clear
+
+      circles.each do |circle|
+        renderer.draw_color = [circle[:r], circle[:g], circle[:b], 255]
+        renderer.fill_rect(circle[:x] - 10, circle[:y] - 10, 20, 20)
+      end
+
+      mouse_x_ptr = FFI::MemoryPointer.new(:float)
+      mouse_y_ptr = FFI::MemoryPointer.new(:float)
+      SDL3::Raw.SDL_GetMouseState(mouse_x_ptr, mouse_y_ptr)
+      mouse_x = mouse_x_ptr.read_float
+      mouse_y = mouse_y_ptr.read_float
+
+      renderer.draw_color = [255, 255, 255, 255]
+      renderer.draw_rect(mouse_x - 5, mouse_y - 5, 10, 10)
+
+      renderer.present
+
+      SDL3::Raw.SDL_Delay(16)
+    end
+  end
+end
+
+SDL3.quit

data/examples/05_simple_game.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/sdl3"
+
+class Player
+  attr_accessor :x, :y, :vx, :vy, :width, :height
+
+  def initialize(x, y)
+    @x = x
+    @y = y
+    @vx = 0
+    @vy = 0
+    @width = 40
+    @height = 40
+    @speed = 300
+    @gravity = 800
+    @jump_force = -400
+    @on_ground = false
+  end
+
+  def update(dt, keys)
+    @vx = 0
+    @vx = -@speed if keys[:left]
+    @vx = @speed if keys[:right]
+
+    @vy += @gravity * dt
+
+    if keys[:jump] && @on_ground
+      @vy = @jump_force
+      @on_ground = false
+    end
+
+    @x += @vx * dt
+    @y += @vy * dt
+
+    @x = [[@x, 0].max, 800 - @width].min
+
+    if @y >= 560 - @height
+      @y = 560 - @height
+      @vy = 0
+      @on_ground = true
+    end
+  end
+
+  def draw(renderer)
+    renderer.draw_color = [100, 200, 255, 255]
+    renderer.fill_rect(@x, @y, @width, @height)
+  end
+end
+
+SDL3.init(SDL3::INIT_VIDEO)
+
+SDL3::Window.open("Simple Game", 800, 600) do |window|
+  SDL3::Renderer.create(window) do |renderer|
+    running = true
+    player = Player.new(380, 400)
+    keys = { left: false, right: false, jump: false }
+    last_time = SDL3::Raw.SDL_GetTicks / 1000.0
+
+    while running
+      current_time = SDL3::Raw.SDL_GetTicks / 1000.0
+      dt = current_time - last_time
+      last_time = current_time
+
+      SDL3::Event.each do |event|
+        case event.type
+        when SDL3::Raw::SDL_EVENT_QUIT
+          running = false
+        when SDL3::Raw::SDL_EVENT_KEY_DOWN
+          running = false if event.scancode == SDL3::Raw::SDL_SCANCODE_ESCAPE
+          keys[:left] = true if event.scancode == SDL3::Raw::SDL_SCANCODE_LEFT ||
+                                event.scancode == SDL3::Raw::SDL_SCANCODE_A
+          keys[:right] = true if event.scancode == SDL3::Raw::SDL_SCANCODE_RIGHT ||
+                                 event.scancode == SDL3::Raw::SDL_SCANCODE_D
+          keys[:jump] = true if event.scancode == SDL3::Raw::SDL_SCANCODE_SPACE ||
+                                event.scancode == SDL3::Raw::SDL_SCANCODE_UP ||
+                                event.scancode == SDL3::Raw::SDL_SCANCODE_W
+        when SDL3::Raw::SDL_EVENT_KEY_UP
+          keys[:left] = false if event.scancode == SDL3::Raw::SDL_SCANCODE_LEFT ||
+                                 event.scancode == SDL3::Raw::SDL_SCANCODE_A
+          keys[:right] = false if event.scancode == SDL3::Raw::SDL_SCANCODE_RIGHT ||
+                                  event.scancode == SDL3::Raw::SDL_SCANCODE_D
+          keys[:jump] = false if event.scancode == SDL3::Raw::SDL_SCANCODE_SPACE ||
+                                 event.scancode == SDL3::Raw::SDL_SCANCODE_UP ||
+                                 event.scancode == SDL3::Raw::SDL_SCANCODE_W
+        end
+      end
+
+      player.update(dt, keys)
+
+      renderer.draw_color = [30, 30, 50, 255]
+      renderer.clear
+
+      renderer.draw_color = [80, 80, 80, 255]
+      renderer.fill_rect(0, 560, 800, 40)
+
+      player.draw(renderer)
+
+      renderer.present
+
+      SDL3::Raw.SDL_Delay(1)
+    end
+  end
+end
+
+SDL3.quit