rbgl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ff09c0ce9d51c2c28146dbcfdb9eecbe2a9982e45a43fbb81cd8bc1de4b96fb
+  data.tar.gz: e58db1f718d9e8a8e1fb7cac8e3acffc026eedfc18e64d427f1669e95e7674be
+SHA512:
+  metadata.gz: b6f662d84ba8b4f44063d9d09e3ce7154bea6547ea3a53ad383b06cf719edb62d0e79ae5b85046b408d1ffa7125100d80a2414dc3213c509d41d9d89cb2e0f2c
+  data.tar.gz: a04b7ce7b7c20502af090e26fcdf0514cfe37850266bfce5a5ad27885999c3bababe0c6089e8cf2f9f31921cdf5c27c2a1e523e03a07b31f40469e048625c3bd

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0 - 2026-01-04
+
+- 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,123 @@
+# RBGL
+
+RuBy Graphics Library - A pure Ruby graphics library with software rendering engine and cross-platform GUI support.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rbgl'
+```
+
+And then execute:
+
+```
+$ bundle install
+```
+
+Or install it yourself as:
+
+```
+$ gem install rbgl
+```
+
+## Requirements
+
+- Ruby 3.1.0 or higher
+
+## Usage
+
+### Basic Window
+
+```ruby
+require "rbgl"
+
+window = RBGL::GUI::Window.new(width: 800, height: 600, title: "Hello RBGL")
+
+window.run do |context, delta_time|
+  context.clear(color: Larb::Color.new(0.1, 0.1, 0.1, 1.0))
+end
+```
+
+### Rendering with Pipeline
+
+```ruby
+require "rbgl"
+
+# Create a window with rendering context
+window = RBGL::GUI::Window.new(width: 800, height: 600, title: "Triangle")
+
+# Define vertex shader
+vertex_shader = RBGL::Engine::Shader.new do |input, uniforms|
+  { position: input[:position], color: input[:color] }
+end
+
+# Define fragment shader
+fragment_shader = RBGL::Engine::Shader.new do |input, uniforms|
+  input[:color]
+end
+
+# Create pipeline
+pipeline = RBGL::Engine::Pipeline.new(
+  vertex_shader: vertex_shader,
+  fragment_shader: fragment_shader
+)
+
+# Create vertex buffer
+vertices = [
+  { position: Larb::Vec4.new(0.0, 0.5, 0.0, 1.0), color: Larb::Color.red },
+  { position: Larb::Vec4.new(-0.5, -0.5, 0.0, 1.0), color: Larb::Color.green },
+  { position: Larb::Vec4.new(0.5, -0.5, 0.0, 1.0), color: Larb::Color.blue }
+]
+vertex_buffer = RBGL::Engine::VertexBuffer.new(vertices)
+
+window.run do |context, delta_time|
+  context.clear
+  context.bind_pipeline(pipeline)
+  context.bind_vertex_buffer(vertex_buffer)
+  context.draw_arrays(:triangles, 0, 3)
+end
+```
+
+### Event Handling
+
+```ruby
+window.on_key do |event|
+  case event.key
+  when :escape
+    window.stop
+  end
+end
+
+window.on_mouse do |event|
+  puts "Mouse: #{event.x}, #{event.y}"
+end
+```
+
+### Backend Selection
+
+RBGL automatically detects the appropriate backend for your platform:
+
+- macOS: Cocoa (requires `metaco` gem)
+- Linux: Wayland or X11 (based on environment)
+
+To use the Cocoa backend on macOS, install the `metaco` gem:
+
+```
+$ gem install metaco
+```
+
+You can also specify a backend explicitly:
+
+```ruby
+# Use specific backend
+window = RBGL::GUI::Window.new(width: 800, height: 600, backend: :x11)
+
+# Use file backend for headless rendering
+window = RBGL::GUI::Window.new(width: 800, height: 600, backend: :file, output_path: "output.png")
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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/array_test.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Array Test Shader
+# Tests the Ruby-mode array support in RLSL
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+require "rlsl"
+
+WIDTH = 640
+HEIGHT = 480
+
+shader = RLSL.define(:array_test) do
+  uniforms do
+    float :time
+  end
+
+  functions do
+    define :get_color, returns: :vec3, params: { i: :int }
+  end
+
+  # Helper functions in Ruby mode with arrays
+  helpers do
+    # Color palette as an array
+    COLORS = [
+      vec3(1.0, 0.0, 0.0),  # Red
+      vec3(0.0, 1.0, 0.0),  # Green
+      vec3(0.0, 0.0, 1.0),  # Blue
+      vec3(1.0, 1.0, 0.0)   # Yellow
+    ]
+
+    def get_color(i)
+      COLORS[i]
+    end
+  end
+
+  fragment do |frag_coord, resolution, u|
+    uv = vec2(frag_coord.x / resolution.x, frag_coord.y / resolution.y)
+
+    # Pick color based on quadrant
+    qx = 0
+    qy = 0
+    if uv.x > 0.5
+      qx = 1
+    end
+    if uv.y > 0.5
+      qy = 2
+    end
+
+    idx = qx + qy
+    color = get_color(idx)
+
+    # Add some animation
+    t = sin(u.time) * 0.5 + 0.5
+    vec3(color.x * t + 0.2, color.y * t + 0.2, color.z * t + 0.2)
+  end
+end
+
+# Initialize display
+window = RBGL::GUI::Window.new(width: WIDTH, height: HEIGHT, title: "Array Test")
+
+puts "Array Test Shader"
+puts "Tests Ruby-mode array support"
+puts "Press 'q' or Escape to quit"
+
+start_time = Time.now
+frame_count = 0
+last_fps_time = start_time
+running = true
+
+buffer = "\x00" * (WIDTH * HEIGHT * 4)
+
+while running && !window.should_close?
+  time = Time.now - start_time
+
+  shader.render(buffer, WIDTH, HEIGHT, { time: time })
+
+  window.set_pixels(buffer)
+
+  events = window.poll_events_raw
+  events.each do |e|
+    case e[:type]
+    when :key_press
+      running = false if e[:key] == 12 || e[:key] == "q"
+    end
+  end
+
+  frame_count += 1
+  now = Time.now
+  if now - last_fps_time >= 1.0
+    fps = frame_count / (now - last_fps_time)
+    puts "FPS: #{fps.round(1)}"
+    frame_count = 0
+    last_fps_time = now
+  end
+end
+
+window.close

data/examples/chemical_heartbeat.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# chemical heartbeat
+# Original: https://www.shadertoy.com/view/lXtXD4
+# License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0
+# https://creativecommons.org/licenses/by-nc-sa/3.0/deed.en
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+require "rlsl"
+
+WIDTH = 640
+HEIGHT = 480
+
+# Define shader using pure Ruby DSL
+shader = RLSL.define(:chemical_heartbeat) do
+  uniforms do
+    float :time
+    float :camera_x
+    float :camera_y
+  end
+
+  fragment do |frag_coord, resolution, u|
+    uv = frag_coord / resolution.y
+
+    # Constants
+    inv_hex_size = 50.0
+    sqrt3_div3 = 0.5773502691896257
+    one_div3 = 0.3333333333333333
+    two_div3 = 0.6666666666666666
+    inv_warp_grid = 5.0
+    warp_clamp = 1.7
+    warp_scale = 4.4
+    warp_amplitude = 0.015
+    warp_speed = 1.5
+    time_dilation = 0.2
+
+    # Colors
+    color_a = vec3(58.0 / 255.0, 1.0 / 255.0, 92.0 / 255.0)
+    color_b = vec3(201.0 / 255.0, 100.0 / 255.0, 128.0 / 255.0)
+    color_c = vec3(59.0 / 255.0, 206.0 / 255.0, 172.0 / 255.0)
+    color_d = vec3(17.0 / 255.0, 0.0 / 255.0, 28.0 / 255.0)
+
+    # Apply camera offset
+    base_ux = uv.x - 0.5 + u.camera_x
+    base_uy = uv.y - 0.5 + u.camera_y
+
+    # Zoomy warp
+    pos_x = base_ux * inv_warp_grid
+    pos_y = base_uy * inv_warp_grid
+    ax = floor(pos_x)
+    ay = floor(pos_y)
+
+    hash_a = hash21(vec2(ax, ay))
+    hash_b = hash21(vec2(ax + 1.0, ay))
+    hash_c = hash21(vec2(ax, ay + 1.0))
+    hash_d = hash21(vec2(ax + 1.0, ay + 1.0))
+
+    diff_x = pos_x - ax
+    diff_y = pos_y - ay
+
+    warp = hash_a + (hash_b - hash_a) * diff_x
+    warp = warp + ((hash_c + (hash_d - hash_c) * diff_x) - warp) * diff_y
+    warp = warp + u.time * warp_speed
+
+    smoothed = (1.0 + cos(warp * TAU)) * 0.5
+    clamped = smoothed * warp_scale - warp_clamp
+    clamped = clamp(clamped, 0.0, 1.0)
+
+    ux = base_ux + cos(clamped) * warp_amplitude
+    uy = base_uy + sin(clamped) * warp_amplitude
+
+    # Axial from pixel
+    axial_q = (sqrt3_div3 * ux - one_div3 * uy) * inv_hex_size
+    axial_r = two_div3 * uy * inv_hex_size
+    axial_s = 0.0 - axial_q - axial_r
+
+    # Axial round
+    q = floor(axial_q)
+    r = floor(axial_r)
+    s = floor(axial_s)
+
+    q_diff = abs(q - axial_q)
+    r_diff = abs(r - axial_r)
+    s_diff = abs(s - axial_s)
+
+    if q_diff > r_diff && q_diff > s_diff
+      q = 0.0 - r - s
+    elsif r_diff > s_diff
+      r = 0.0 - q - s
+    end
+
+    # Hash for hex cell
+    hash_val = hash21(vec2(q, r))
+
+    # Animated color value
+    value = fract(hash_val + u.time * time_dilation)
+    value = smoothstep(0.0, 1.0, value)
+    value = (1.0 + cos(value * TAU)) * 0.5
+
+    # Color mixing
+    ab = mix(color_a, color_b, value)
+    bc = mix(color_b, color_c, value)
+    cd = mix(color_c, color_d, value)
+
+    left = mix(ab, bc, value)
+    right = mix(bc, cd, value)
+
+    mix(left, right, value)
+  end
+end
+
+# Initialize display
+window = RBGL::GUI::Window.new(width: WIDTH, height: HEIGHT, title: "Chemical Heartbeat")
+
+puts "Chemical Heartbeat"
+puts "Original: https://www.shadertoy.com/view/lXtXD4"
+puts "License: Creative Commons Attribution-NonCommercial-ShareAlike 3.0"
+puts "https://creativecommons.org/licenses/by-nc-sa/3.0/deed.en"
+puts "Press 'q' or Escape to quit"
+
+start_time = Time.now
+frame_count = 0
+last_fps_time = start_time
+running = true
+
+buffer = "\x00" * (WIDTH * HEIGHT * 4)
+
+while running && !window.should_close?
+  time = Time.now - start_time
+
+  # Camera movement
+  circle_value = time * 0.1
+  wave_value = time * 0.33
+  radius = 1.0 + Math.cos(wave_value) * 0.25
+  camera_x = Math.cos(circle_value) * radius
+  camera_y = Math.sin(circle_value) * radius
+
+  # Render using compiled shader
+  shader.render(buffer, WIDTH, HEIGHT, {
+    time: time,
+    camera_x: camera_x,
+    camera_y: camera_y
+  })
+
+  window.set_pixels(buffer)
+
+  events = window.poll_events_raw
+  events.each do |e|
+    if e[:type] == :key_press && (e[:key] == 12 || e[:key] == "q")
+      running = false
+    end
+  end
+
+  frame_count += 1
+  now = Time.now
+  if now - last_fps_time >= 1.0
+    fps = frame_count / (now - last_fps_time)
+    puts "FPS: #{fps.round(1)}"
+    frame_count = 0
+    last_fps_time = now
+  end
+end
+
+window.close

data/examples/color_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Color Test - RGB verification
+# Displays red, green, blue, and yellow squares
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+require "rlsl"
+
+WIDTH = 640
+HEIGHT = 480
+
+shader = RLSL.define(:color_test) do
+  uniforms do
+    float :time
+  end
+
+  # Pure Ruby DSL fragment shader
+  # 4 quadrants: Top-left Red, Top-right Green, Bottom-left Blue, Bottom-right Yellow
+  fragment do |frag_coord, resolution, _u|
+    x = frag_coord.x / resolution.y
+    y = frag_coord.y / resolution.y
+
+    if x < 0.5 && y >= 0.5
+      vec3(1.0, 0.0, 0.0)
+    elsif x >= 0.5 && y >= 0.5
+      vec3(0.0, 1.0, 0.0)
+    elsif x < 0.5 && y < 0.5
+      vec3(0.0, 0.0, 1.0)
+    else
+      vec3(1.0, 1.0, 0.0)
+    end
+  end
+end
+
+# Initialize display
+window = RBGL::GUI::Window.new(width: WIDTH, height: HEIGHT, title: "Color Test")
+
+puts "Color Test"
+puts "Top-left: Red, Top-right: Green"
+puts "Bottom-left: Blue, Bottom-right: Yellow"
+puts "Press 'q' or Escape to quit"
+
+running = true
+buffer = "\x00" * (WIDTH * HEIGHT * 4)
+
+while running && !window.should_close?
+  shader.render(buffer, WIDTH, HEIGHT, { time: 0.0 })
+
+  window.set_pixels(buffer)
+
+  events = window.poll_events_raw
+  events.each do |e|
+    if e[:type] == :key_press && (e[:key] == 12 || e[:key] == "q")
+      running = false
+    end
+  end
+end
+
+window.close

data/examples/cube_spinning.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "rbgl"
+
+include Larb
+include RBGL::Engine
+
+window = RBGL::GUI::Window.new(
+  width: 320,
+  height: 240,
+  title: "Spinning Cube",
+  backend: :auto
+)
+
+pipeline = Pipeline.create do
+  vertex do |input, uniforms, output|
+    output.position = uniforms.mvp * input.position.to_vec4
+    output.color = input.color
+  end
+
+  fragment do |input, _uniforms, output|
+    output.color = input.color
+  end
+end
+
+def create_cube
+  layout = VertexLayout.position_color
+  buffer = VertexBuffer.new(layout)
+
+  colors = [Color.red, Color.green, Color.blue, Color.yellow, Color.cyan, Color.magenta]
+
+  faces = [
+    [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]],
+    [[1, -1, -1], [-1, -1, -1], [-1, 1, -1], [1, 1, -1]],
+    [[-1, 1, 1], [1, 1, 1], [1, 1, -1], [-1, 1, -1]],
+    [[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]],
+    [[1, -1, 1], [1, -1, -1], [1, 1, -1], [1, 1, 1]],
+    [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]]
+  ]
+
+  faces.each_with_index do |face, i|
+    color = colors[i]
+    [[0, 1, 2], [0, 2, 3]].each do |tri|
+      tri.each do |vi|
+        pos = face[vi]
+        buffer.add_vertex(
+          position: Vec3[pos[0] * 0.5, pos[1] * 0.5, pos[2] * 0.5],
+          color: color
+        )
+      end
+    end
+  end
+
+  buffer
+end
+
+cube = create_cube
+rotation = 0.0
+
+view = Mat4.look_at(
+  Vec3[0, 1, 3],
+  Vec3[0, 0, 0],
+  Vec3.up
+)
+
+window.on(:key_press) do |event|
+  puts "Key pressed: #{event.key}"
+  window.stop if event.key == 12 || event.key == "q" || event.key == "Escape"
+end
+
+puts "Press 'q' or Escape to quit"
+
+window.run do |ctx, dt|
+  rotation += dt * 1.0
+
+  model = Mat4.rotation_y(rotation) * Mat4.rotation_x(rotation * 0.7)
+  projection = Mat4.perspective(Math::PI / 4, ctx.aspect_ratio, 0.1, 100)
+  mvp = projection * view * model
+
+  ctx.clear(color: Color.from_hex("#0f0f23"))
+  ctx.bind_pipeline(pipeline)
+  ctx.bind_vertex_buffer(cube)
+  ctx.set_uniform(:mvp, mvp)
+  ctx.draw_arrays(:triangles, 0, cube.vertex_count)
+end