rbgl 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ff09c0ce9d51c2c28146dbcfdb9eecbe2a9982e45a43fbb81cd8bc1de4b96fb
-  data.tar.gz: e58db1f718d9e8a8e1fb7cac8e3acffc026eedfc18e64d427f1669e95e7674be
+  metadata.gz: ed4b8652d75f87149d87fa786b7736bec5be6cdf4be1f9ec807e874f473c55ee
+  data.tar.gz: 71e77ebb64fea763007b1ab140eceb4119e3ebec7fdca5a216c677aaa51253c1
 SHA512:
-  metadata.gz: b6f662d84ba8b4f44063d9d09e3ce7154bea6547ea3a53ad383b06cf719edb62d0e79ae5b85046b408d1ffa7125100d80a2414dc3213c509d41d9d89cb2e0f2c
-  data.tar.gz: a04b7ce7b7c20502af090e26fcdf0514cfe37850266bfce5a5ad27885999c3bababe0c6089e8cf2f9f31921cdf5c27c2a1e523e03a07b31f40469e048625c3bd
+  metadata.gz: e208d53d00554a54cd18e9e566f952b6dbce80bf222e9a390571b8a6c1a7516042ae8cab702a1fb1b2e72d8b2fbeed283a4777a5902b3d7a515a9124904bde4e
+  data.tar.gz: cf698a98c5c90ccaf00aa77d12da808a6ee170be8bbc8ef8bd845a7e9930ae8eda2deffc79611866ca1870f9b6018a2940ccae01324cde46726b93e8388c5aac

data/.rubocop.yml

@@ -0,0 +1,3 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.1

data/CHANGELOG.md

@@ -1,7 +1,25 @@
 # Changelog
 
-## Unreleased
+## 1.0.1 - 2026-09-25
+
+- Add PNG output and frame-limited file rendering.
+- Add a non-blocking window frame step API.
+- Fixed perspective depth interpolation, shared-edge coverage, NPOT mipmaps, repeat filtering, and shader numeric edge cases.
+- Fixed native window resize, close, and Wayland disconnect handling, including internal size synchronization during raw event polling.
+- Tightened vertex layout, index, draw-range, and texture data mutation contracts, and skipped unnecessary clipping and expired frame deadlines.
+
+## 1.0.0 - 2026-04-05
+
+- Removed the legacy `Window#on_key`, `Window#on_mouse`, and `Window#on_resize` aliases. Register handlers with `window.on(:key_press)`, `window.on(:mouse_move)`, `window.on(:resize)`, and the other event types directly.
+- Removed the legacy `backend: :native` alias. Use `backend: :auto` for automatic native backend selection.
+- Changed file backend binary PPM output to `format: :ppm, ppm_mode: :binary`. The old `format: :ppm_binary` option is no longer accepted.
+- Added a runtime dependency on `rlsl`, so existing applications need it resolved during install and bundle steps.
+- Added binary (`P6`) and text (`P3`) PPM texture loading via `RBGL::Engine::Texture.from_ppm`, and added ASCII or binary PPM output selection for the file backend.
+- Added `RBGL::GUI::Window#dropped_frames` so applications can detect failed presents, including Wayland backpressure cases.
+- Improved automatic native backend selection on Linux: RBGL now prefers Wayland when available, falls back to X11 when needed, and raises clearer `BackendUnavailable` errors when no display server can be used.
+- Improved rendering correctness with view-frustum clipping for triangles, lines, and points, perspective-correct interpolation, point rasterization fixes, and pipeline render-state handling.
+- Tightened validation across pipelines, shaders, vertex buffers, textures, sampler settings, mipmaps, and texture writes so invalid rendering inputs fail earlier with explicit errors.
 
 ## 0.1.0 - 2026-01-04
 
-- Initial release.
+- Initial release.

data/README.md

@@ -1,123 +1,179 @@
-# RBGL
+<h1 align="center">RBGL</h1>
 
-RuBy Graphics Library - A pure Ruby graphics library with software rendering engine and cross-platform GUI support.
+<p align="center">A pure Ruby software renderer with Cocoa, Wayland, X11, and headless file backends.</p>
 
-## Installation
+<p align="center">
+  <a href="https://rubygems.org/gems/rbgl"><img src="https://badge.fury.io/rb/rbgl.svg" alt="Gem Version"></a>
+  <a href="https://rubygems.org/gems/rbgl"><img src="https://img.shields.io/gem/dt/rbgl?label=downloads" alt="Downloads"></a>
+  <a href="https://www.ruby-lang.org/"><img src="https://img.shields.io/badge/ruby-%3E%3D3.1-CC342D?logo=ruby&amp;logoColor=white" alt="Ruby Version"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-750014.svg" alt="License"></a>
+</p>
 
-Add this line to your application's Gemfile:
+[Features](#features) · [Installation](#installation) · [Quick Start](#quick-start) · [Events](#events) · [File Backend](#file-backend)
 
-```ruby
-gem 'rbgl'
-```
+***
 
-And then execute:
+RBGL (Ruby Graphics Library) is a pure Ruby software renderer with Cocoa, Wayland, X11, and headless file backends.
 
-```
-$ bundle install
-```
+## Features
 
-Or install it yourself as:
+- Ruby-defined vertex and fragment stages with typed vertex layouts.
+- Software rasterization for triangles, lines, and points, with depth and alpha blending.
+- Cocoa, Wayland, X11, and headless file backends.
 
-```
-$ gem install rbgl
-```
+## Installation
 
-## Requirements
+Add RBGL to your Gemfile:
 
-- Ruby 3.1.0 or higher
+```ruby
+gem "rbgl"
+```
 
-## Usage
+Then run `bundle install`, or install it directly with `gem install rbgl`.
 
-### Basic Window
+### Requirements
 
-```ruby
-require "rbgl"
+- Ruby 3.1 or newer
+- macOS: the `metaco` gem for Cocoa windows
+- Linux: a Wayland compositor or X11 server
 
-window = RBGL::GUI::Window.new(width: 800, height: 600, title: "Hello RBGL")
+## Quick Start
 
-window.run do |context, delta_time|
-  context.clear(color: Larb::Color.new(0.1, 0.1, 0.1, 1.0))
-end
-```
-
-### Rendering with Pipeline
+This complete example renders one triangle to `frames/frame_00000.ppm`. The file backend is useful for CI, image generation, and environments without a display server.
 
+<!-- rbgl-doctest: file-triangle -->
 ```ruby
 require "rbgl"
 
-# Create a window with rendering context
-window = RBGL::GUI::Window.new(width: 800, height: 600, title: "Triangle")
+include Larb
+include RBGL::Engine
+
+window = RBGL::GUI::Window.new(
+  width: 160,
+  height: 120,
+  backend: :file,
+  output_dir: "frames",
+  format: :ppm,
+  max_frames: 1,
+  target_fps: nil
+)
 
-# Define vertex shader
-vertex_shader = RBGL::Engine::Shader.new do |input, uniforms|
-  { position: input[:position], color: input[:color] }
-end
+pipeline = Pipeline.create do
+  vertex do |input, _uniforms, output|
+    output.position = input.position.to_vec4
+    output.color = input.color
+  end
 
-# Define fragment shader
-fragment_shader = RBGL::Engine::Shader.new do |input, uniforms|
-  input[:color]
+  fragment do |input, _uniforms, output|
+    output.color = input.color
+  end
 end
-
-# Create pipeline
-pipeline = RBGL::Engine::Pipeline.new(
-  vertex_shader: vertex_shader,
-  fragment_shader: fragment_shader
+pipeline.cull_mode = :none
+
+vertices = VertexBuffer.from_array(
+  VertexLayout.position_color,
+  [
+    { position: Vec3[0.0, 0.7, 0.0], color: Color.red },
+    { position: Vec3[-0.7, -0.7, 0.0], color: Color.green },
+    { position: Vec3[0.7, -0.7, 0.0], color: Color.blue }
+  ]
 )
 
-# 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
+window.run do |context, _delta_time|
+  context.clear(color: Color.from_hex("#101827"))
   context.bind_pipeline(pipeline)
-  context.bind_vertex_buffer(vertex_buffer)
+  context.bind_vertex_buffer(vertices)
   context.draw_arrays(:triangles, 0, 3)
 end
 ```
 
-### Event Handling
+The same rendering code works in a native window by omitting the file-only options:
 
 ```ruby
-window.on_key do |event|
-  case event.key
-  when :escape
-    window.stop
-  end
+window = RBGL::GUI::Window.new(
+  width: 800,
+  height: 600,
+  title: "RBGL Triangle",
+  backend: :auto
+)
+```
+
+`:auto` chooses Cocoa on macOS and prefers Wayland before X11 on Linux. You can select `:cocoa`, `:wayland`, or `:x11` explicitly.
+
+## Events
+
+Register portable event handlers with `Window#on`. Keyboard events use symbols on every native backend.
+
+```ruby
+window.on(:key_press) do |event|
+  window.stop if %i[escape q].include?(event.key)
 end
 
-window.on_mouse do |event|
+window.on(:mouse_move) do |event|
   puts "Mouse: #{event.x}, #{event.y}"
 end
+
+window.on(:resize) do |event|
+  puts "Size: #{event.width}x#{event.height}"
+end
 ```
 
-### Backend Selection
+Supported portable event types include `:key_press`, `:key_release`, `:mouse_press`, `:mouse_release`, `:mouse_move`, `:scroll`, `:focus`, `:blur`, `:resize`, and `:close`. Mouse coordinates use a top-left origin. On Cocoa, key and mouse events include `modifiers`; scroll events provide pixel `dx` and `dy`.
 
-RBGL automatically detects the appropriate backend for your platform:
+`Window#poll_events_raw` returns these normalized events as hashes when a manual loop is more convenient. Resize events
+update the window, context, and backend dimensions without invoking registered event handlers.
 
-- macOS: Cocoa (requires `metaco` gem)
-- Linux: Wayland or X11 (based on environment)
+## Raw RGBA pixels
 
-To use the Cocoa backend on macOS, install the `metaco` gem:
+`Window#set_pixels` accepts exactly `width * height * 4` bytes in RGBA order and works with Cocoa, Wayland, X11, and the file backend:
 
-```
-$ gem install metaco
+```ruby
+rgba = "\xFF\x00\x00\xFF" * (window.width * window.height)
+window.set_pixels(rgba)
 ```
 
-You can also specify a backend explicitly:
+Metal compute support is an optional Cocoa capability. Check `window.metal_available?` before using `window.native_handle`; other backends return `false` and `nil` through the window facade.
 
-```ruby
-# Use specific backend
-window = RBGL::GUI::Window.new(width: 800, height: 600, backend: :x11)
+## Render loop
+
+The native render loop is capped at 60 fps by default. Set `target_fps: 30` to choose another limit or `target_fps: nil` to disable throttling. `window.fps` reports a moving one-second average, while `window.dropped_frames` counts rejected presents.
 
-# Use file backend for headless rendering
-window = RBGL::GUI::Window.new(width: 800, height: 600, backend: :file, output_path: "output.png")
+`Window#run` is intentionally one-shot: it closes its backend when the loop exits or raises. Create a new `Window` instead of calling `run` twice.
+
+## File backend
+
+The file backend creates `output_dir` automatically and stops after one frame by default.
+
+```ruby
+window = RBGL::GUI::Window.new(
+  width: 320,
+  height: 240,
+  backend: :file,
+  output_dir: "renders",
+  format: :bmp,
+  max_frames: 10
+)
 ```
 
+Supported formats are `:ppm`, `:bmp`, and optional `:png`. For PPM, select `ppm_mode: :ascii` or `ppm_mode: :binary`. PNG output requires the `tessel` gem. Set `max_frames: nil` only when an unlimited output sequence is intentional.
+
+## Examples and development
+
+- `ruby examples/triangle_basic.rb` renders a PPM without opening a window.
+- `ruby examples/triangle_window.rb` opens the portable native triangle demo.
+- `ruby examples/cube_spinning.rb` renders an indexed 3D-style scene.
+- `bundle exec rake test` runs the test suite and README doctest.
+- `bundle exec rake lint` runs RuboCop correctness checks.
+- `RBGL_BENCH_ITERATIONS=10 bundle exec ruby bench/renderer_bench.rb` runs renderer benchmarks.
+
+Use `rbgl doctor` or `rbgl doctor --json` to inspect native backend availability.
+
+## Contributing
+
+Bug reports and pull requests are welcome at [rbgfx/rbgl](https://github.com/rbgfx/rbgl).
+
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+RBGL and the examples distributed in this repository are available under the [MIT License](LICENSE).
+The file backend writes PPM and BMP directly, and delegates PNG output to the
+optional `tessel` gem when `format: :png` is selected.

data/Rakefile

@@ -10,3 +10,10 @@ Rake::TestTask.new(:test) do |t|
 end
 
 task default: :test
+
+desc "Run RuboCop correctness checks"
+task :lint do
+  sh "bundle exec rubocop --cache false --lint lib rbgl.gemspec Rakefile test/integration"
+end
+
+task verify: %i[lint test]

data/bench/renderer_bench.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+# Minimal renderer benchmarks for RBGL core paths.
+# Usage: ruby bench/renderer_bench.rb
+
+require "benchmark"
+require "rbgl"
+
+include Larb
+include RBGL::Engine
+
+WIDTH = Integer(ENV.fetch("RBGL_BENCH_WIDTH", "320"))
+HEIGHT = Integer(ENV.fetch("RBGL_BENCH_HEIGHT", "240"))
+ITERATIONS = Integer(ENV.fetch("RBGL_BENCH_ITERATIONS", "10"))
+
+def build_context
+  Context.new(width: WIDTH, height: HEIGHT)
+end
+
+def triangle_pipeline
+  Pipeline.create do
+    vertex do |input, _uniforms, output|
+      output.position = input.position.to_vec4
+      output.color = input.color
+    end
+
+    fragment do |input, _uniforms, output|
+      output.color = input.color
+    end
+  end.tap { |pipeline| pipeline.cull_mode = :none }
+end
+
+def depth_pipeline
+  Pipeline.create do
+    vertex do |input, _uniforms, output|
+      output.position = input.position.to_vec4
+      output.color = input.color
+    end
+
+    fragment do |input, _uniforms, output|
+      output.color = input.color
+    end
+  end.tap do |pipeline|
+    pipeline.cull_mode = :none
+    pipeline.depth_test = true
+    pipeline.depth_write = true
+  end
+end
+
+def line_pipeline
+  Pipeline.create do
+    vertex do |input, _uniforms, output|
+      output.position = input.position.to_vec4
+      output.color = input.color
+    end
+
+    fragment do |input, _uniforms, output|
+      output.color = input.color
+    end
+  end.tap { |pipeline| pipeline.cull_mode = :none }
+end
+
+def vertex_layout
+  VertexLayout.position_color
+end
+
+def clear_case
+  context = build_context
+  color = Color.from_hex("#123456")
+
+  Benchmark.measure do
+    ITERATIONS.times { context.clear(color: color) }
+  end
+end
+
+def triangle_case
+  context = build_context
+  context.clear(color: Color.black)
+
+  pipeline = triangle_pipeline
+  context.bind_pipeline(pipeline)
+  context.bind_vertex_buffer(triangle_vertices)
+
+  Benchmark.measure do
+    ITERATIONS.times { context.draw_arrays(:triangles, 0, 3) }
+  end
+end
+
+def line_case
+  context = build_context
+  context.clear(color: Color.black)
+  context.bind_pipeline(line_pipeline)
+  context.bind_vertex_buffer(line_vertices)
+
+  Benchmark.measure do
+    ITERATIONS.times { context.draw_arrays(:lines, 0, 2) }
+  end
+end
+
+def depth_case
+  context = build_context
+  context.clear(color: Color.black)
+  context.bind_pipeline(depth_pipeline)
+  context.bind_vertex_buffer(depth_vertices_far)
+  context.draw_arrays(:triangles, 0, 3)
+  context.bind_vertex_buffer(depth_vertices_near)
+
+  Benchmark.measure do
+    ITERATIONS.times do
+      context.draw_arrays(:triangles, 0, 3)
+      context.draw_arrays(:triangles, 0, 3)
+    end
+  end
+end
+
+def texture_case
+  context = build_context
+  context.clear(color: Color.black)
+
+  texture = Texture.solid(8, 8, Color.red)
+  pipeline = Pipeline.create do
+    vertex do |input, _uniforms, output|
+      output.position = input.position.to_vec4
+      output.uv = Larb::Vec2.new((input.position.x + 1.0) * 0.5, (input.position.y + 1.0) * 0.5)
+    end
+
+    fragment do |input, uniforms, output|
+      output.color = texture(uniforms.texture, input.uv)
+    end
+  end
+
+  pipeline.cull_mode = :none
+  context.bind_pipeline(pipeline)
+  context.bind_vertex_buffer(uv_vertices)
+  context.set_uniform(:texture, texture)
+
+  Benchmark.measure do
+    ITERATIONS.times { context.draw_arrays(:triangle_strip, 0, 4) }
+  end
+end
+
+def shader_call_overhead_case
+  context = build_context
+  pipeline = Pipeline.create do
+    vertex do |input, uniforms, output|
+      output.position = input.position.to_vec4
+      output.color = Color.new(
+        uniforms.ramp % 1.0,
+        (uniforms.ramp + 0.25) % 1.0,
+        (uniforms.ramp + 0.5) % 1.0,
+        1.0
+      )
+    end
+
+    fragment do |input, _uniforms, output|
+      output.color = input.color
+    end
+  end
+
+  context.bind_pipeline(pipeline)
+  context.bind_vertex_buffer(shaded_vertices)
+
+  t = 0.0
+  Benchmark.measure do
+    ITERATIONS.times do
+      context.set_uniform(:ramp, Math.sin(t))
+      context.draw_arrays(:triangles, 0, 3)
+      t += 0.01
+    end
+  end
+end
+
+def gc_alloc_case
+  context = build_context
+  context.bind_pipeline(triangle_pipeline)
+  context.bind_vertex_buffer(triangle_vertices)
+
+  iterations = ITERATIONS
+  GC.start
+  before = GC.stat(:total_allocated_objects)
+
+  iterations.times do
+    context.draw_arrays(:triangles, 0, 3)
+  end
+
+  after = GC.stat(:total_allocated_objects)
+  allocations_per_op = (after - before).fdiv(iterations)
+  puts "GC allocation (objects/op): #{allocations_per_op.round(2)}"
+end
+
+def triangle_vertices
+  VertexBuffer.from_array(
+    vertex_layout,
+    [
+      { position: Vec3[-0.5, 0.6, 0.0], color: Color.red },
+      { position: Vec3[-0.7, -0.4, 0.0], color: Color.green },
+      { position: Vec3[0.6, -0.4, 0.0], color: Color.blue }
+    ]
+  )
+end
+
+def line_vertices
+  VertexBuffer.from_array(
+    vertex_layout,
+    [
+      { position: Vec3[-0.8, 0.0, 0.0], color: Color.red },
+      { position: Vec3[0.8, 0.0, 0.0], color: Color.green }
+    ]
+  )
+end
+
+def depth_vertices_far
+  VertexBuffer.from_array(
+    vertex_layout,
+    [
+      { position: Vec3[-0.8, 0.6, 0.9], color: Color.red },
+      { position: Vec3[-0.6, -0.6, 0.9], color: Color.red },
+      { position: Vec3[0.8, -0.6, 0.9], color: Color.red }
+    ]
+  )
+end
+
+def depth_vertices_near
+  VertexBuffer.from_array(
+    vertex_layout,
+    [
+      { position: Vec3[-0.2, 0.6, 0.1], color: Color.green },
+      { position: Vec3[-0.4, -0.6, 0.1], color: Color.green },
+      { position: Vec3[0.5, -0.6, 0.1], color: Color.green }
+    ]
+  )
+end
+
+def uv_vertices
+  VertexBuffer.from_array(
+    VertexLayout.new do
+      attribute :position, 3
+      attribute :uv, 2
+      attribute :color, 4
+    end,
+    [
+      { position: Vec3[-0.8, -0.8, 0], uv: Vec2[0, 1], color: Color.white },
+      { position: Vec3[-0.8, 0.8, 0], uv: Vec2[0, 0], color: Color.white },
+      { position: Vec3[0.8, -0.8, 0], uv: Vec2[1, 1], color: Color.white },
+      { position: Vec3[0.8, 0.8, 0], uv: Vec2[1, 0], color: Color.white }
+    ]
+  )
+end
+
+def shaded_vertices
+  VertexBuffer.from_array(
+    vertex_layout,
+    [
+      { position: Vec3[-0.5, -0.5, 0.0], color: Color.red },
+      { position: Vec3[0.0, 0.8, 0.0], color: Color.green },
+      { position: Vec3[0.5, -0.5, 0.0], color: Color.blue }
+    ]
+  )
+end
+
+def report
+  cases = {
+    "framebuffer clear" => -> { clear_case },
+    "triangle draw" => -> { triangle_case },
+    "line draw" => -> { line_case },
+    "depth test" => -> { depth_case },
+    "texture sampling" => -> { texture_case },
+    "shader call overhead" => -> { shader_call_overhead_case }
+  }
+
+  puts "Ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})"
+  puts "Iterations: #{ITERATIONS}"
+
+  Benchmark.bm(22) do |bench|
+    cases.each do |name, runner|
+      bench.report(name) { runner.call }
+    end
+  end
+
+  gc_alloc_case
+end
+
+report

data/docs/.nojekyll

@@ -0,0 +1 @@
+

data/docs/index.html

@@ -0,0 +1,38 @@
+<!doctype html>
+<html lang="en"><head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="theme-color" content="#020617"><meta name="description" content="Define a graphics pipeline in Ruby, rasterize it in software, and present native or headless frames.">
+<meta property="og:title" content="RBGL — A graphics pipeline you can read."><meta property="og:description" content="Define a graphics pipeline in Ruby, rasterize it in software, and present native or headless frames."><meta property="og:type" content="website"><meta property="og:url" content="https://rbgfx.github.io/rbgl/">
+<meta name="twitter:card" content="summary"><link rel="canonical" href="https://rbgfx.github.io/rbgl/"><title>RBGL — A graphics pipeline you can read.</title>
+<style>
+:root{color-scheme:dark;--bg:#020617;--panel:#0f172a;--line:#334155;--ink:#e2e8f0;--muted:#94a3b8;--a:#38bdf8;--mono:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;--sans:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;--w:min(100% - 2.5rem,76rem)}
+*{box-sizing:border-box}html{scroll-behavior:smooth}body{margin:0;background:var(--bg);color:var(--ink);font:16px/1.65 var(--sans)}a{color:inherit;text-underline-offset:.22em}a:hover{color:var(--a)}a:focus-visible{outline:3px solid var(--a);outline-offset:4px}h1,h2,h3,p,figure,pre{margin:0}h1,h2,h3{line-height:1.08;text-wrap:balance}p{text-wrap:pretty}code,pre,.mono{font-family:var(--mono);font-variant-numeric:tabular-nums}.wrap{width:var(--w);margin:auto}.skip{position:fixed;left:1rem;top:1rem;z-index:1;transform:translateY(-160%);padding:.7rem 1rem;background:var(--ink);color:var(--bg)}.skip:focus{transform:none}
+header{height:4.75rem;border-bottom:1px solid var(--line);display:flex;align-items:center;justify-content:space-between}.brand{display:flex;align-items:center;gap:.7rem;font-weight:750;text-decoration:none}.mark{width:2rem;height:2rem;display:grid;place-items:center;border:1px solid var(--a);color:var(--a);font:.85rem var(--mono)}nav{display:flex;gap:1.5rem;font-size:.9rem}nav a{text-decoration:none;color:var(--muted)}nav a:last-child{color:var(--ink)}
+.hero{display:grid;grid-template-columns:.88fr 1.12fr;align-items:center;gap:clamp(2rem,6vw,6rem);padding-block:clamp(4rem,9vw,8rem)}.kicker,.visual figcaption,.num{font:.76rem/1.4 var(--mono);color:var(--a)}h1{max-width:11ch;margin-top:1rem;font-size:clamp(3rem,7.5vw,6.5rem);letter-spacing:-.065em}.lede{max-width:40rem;margin-top:1.5rem;color:var(--muted);font-size:1.15rem}.actions{display:flex;flex-wrap:wrap;gap:.8rem;margin-top:2rem}.button{min-height:2.8rem;padding:.65rem 1rem;border:1px solid var(--line);display:inline-flex;align-items:center;text-decoration:none;font-weight:650}.button.primary{background:var(--a);border-color:var(--a);color:var(--bg)}.install{margin-top:1.4rem;color:var(--muted);font:.86rem var(--mono)}.install code{color:var(--ink)}
+.visual{border:1px solid var(--line);background:var(--panel)}.art{min-height:18rem;padding:1.25rem;display:grid;place-items:center;overflow:hidden}.art svg{width:100%;max-height:23rem}.visual figcaption{display:flex;justify-content:space-between;gap:1rem;padding:.75rem 1rem;border-top:1px solid var(--line);color:var(--muted)}.visual figcaption span:last-child{color:var(--a)}
+section.info{padding-block:4.5rem;border-top:1px solid var(--line)}.section-head{display:grid;grid-template-columns:.72fr 1.28fr;gap:2rem;align-items:end;margin-bottom:2rem}h2{font-size:clamp(2rem,4vw,3.25rem);letter-spacing:-.045em}.section-head p,.feature p,.try-copy p{color:var(--muted)}.features{display:grid;grid-template-columns:repeat(3,1fr);border-top:1px solid var(--line)}.feature{padding:1.25rem 1.2rem 1.4rem 0;border-bottom:1px solid var(--line)}.feature+.feature{padding-left:1.2rem;border-left:1px solid var(--line)}.feature h3{margin-top:.8rem;font-size:1.1rem}.feature p{margin-top:.5rem;font-size:.94rem}.try{display:grid;grid-template-columns:.75fr 1.25fr;align-items:center;gap:clamp(2rem,7vw,7rem)}.try-copy p{margin-top:1rem}.try-copy a{color:var(--ink)}pre{overflow-x:auto;padding:1.25rem;border:1px solid var(--line);background:var(--panel);font-size:.82rem;line-height:1.8;tab-size:2}
+footer{display:flex;justify-content:space-between;gap:1rem;padding-block:1.6rem;border-top:1px solid var(--line);color:var(--muted);font-size:.85rem}footer div{display:flex;gap:1.25rem}
+@media(max-width:800px){.hero{grid-template-columns:1fr;gap:2.5rem}.hero-copy{max-width:42rem}.section-head,.try{grid-template-columns:1fr;gap:1rem}}@media(max-width:560px){:root{--w:min(100% - 1.5rem,76rem)}header{height:4.2rem}nav{gap:.8rem;font-size:.8rem}nav a:first-child{display:none}h1{font-size:clamp(3rem,15vw,5rem)}.features{grid-template-columns:1fr}.feature,.feature+.feature{padding:1.1rem 0;border-left:0}.num{display:inline-block}footer{flex-direction:column}.art{min-height:14rem}section.info{padding-block:3.5rem}pre{font-size:.75rem;padding:1rem}}
+@media(prefers-reduced-motion:reduce){html{scroll-behavior:auto}}
+
+</style>
+</head><body style="--a:#38bdf8"><a class="skip" href="#main">Skip to content</a><div class="wrap">
+<header><a class="brand" href="#top" aria-label="RBGL home"><span class="mark" aria-hidden="true">R</span><span>RBGL</span></a><nav aria-label="Primary navigation"><a href="#features">Overview</a><a href="#quick-start">Quick start</a><a href="https://github.com/rbgfx/rbgl">Source ↗</a></nav></header>
+<main id="main"><section class="hero" id="top" aria-labelledby="title"><div class="hero-copy"><p class="kicker">Pure Ruby software renderer</p><h1 id="title">A graphics pipeline you can read.</h1><p class="lede">Define a graphics pipeline in Ruby, rasterize it in software, and present native or headless frames.</p><div class="actions"><a class="button primary" href="#quick-start">Get started</a><a class="button" href="https://rubygems.org/gems/rbgl">RubyGems ↗</a></div><p class="install"><span aria-hidden="true">$</span> <code>gem install rbgl</code></p></div>
+<figure class="visual" aria-labelledby="cap-rbgl"><div class="art"><svg viewBox="0 0 640 360" aria-hidden="true"><rect width="640" height="360" fill="#0b1224"/><path d="M320 46L554 292H86Z" fill="#082f49" stroke="#38bdf8" stroke-width="2"/><path d="M320 46L320 292M86 292L437 169M554 292L203 169" stroke="#164e63"/><circle cx="320" cy="46" r="7" fill="#e0f2fe"/><circle cx="86" cy="292" r="7" fill="#34d399"/><circle cx="554" cy="292" r="7" fill="#fb7185"/></svg></div><figcaption id="cap-rbgl"><span>Frame 00000 · PPM</span><span>vertex → fragment → raster</span></figcaption></figure></section>
+<section class="info" id="features" aria-labelledby="feat"><div class="section-head"><h2 id="feat">Keep every stage in view.</h2><p>Connect typed vertex data, Ruby shader blocks, rasterization, and portable output.</p></div><div class="features"><article class="feature"><span class="num">01</span><h3>Shape the pipeline</h3><p>Describe layouts and shader stages with Ruby blocks.</p></article><article class="feature"><span class="num">02</span><h3>Rasterize in software</h3><p>Draw triangles, lines, and points with depth and alpha blending.</p></article><article class="feature"><span class="num">03</span><h3>Present anywhere</h3><p>Use Cocoa, Wayland, X11, or headless file output.</p></article></div></section>
+<section class="info try" id="quick-start" aria-labelledby="quick"><div class="try-copy"><p class="kicker">A small first step</p><h2 id="quick">Start with one example.</h2><p>Install the gem, then follow the project guide for platform requirements and the full API.</p><p><a href="https://github.com/rbgfx/rbgl#installation">Read the installation guide ↗</a></p></div><pre><code>require &quot;rbgl&quot;
+
+window = RBGL::GUI::Window.new(
+  width: 160, height: 120, backend: :file,
+  output_dir: &quot;frames&quot;, format: :ppm,
+  max_frames: 1, target_fps: nil
+)
+
+# Define pipeline and vertices as shown in the guide.
+window.run do |context, _delta_time|
+  context.bind_pipeline(pipeline)
+  context.bind_vertex_buffer(vertices)
+  context.draw_arrays(:triangles, 0, 3)
+end</code></pre></section></main>
+<footer><span>RBGL · Ruby 3.1+ · MIT</span><div><a href="https://github.com/rbgfx/rbgl">GitHub</a><a href="https://github.com/rbgfx/rbgl/blob/main/LICENSE">License</a></div></footer></div></body></html>

data/examples/array_test.rb

@@ -82,7 +82,7 @@ while running && !window.should_close?
   events.each do |e|
     case e[:type]
     when :key_press
-      running = false if e[:key] == 12 || e[:key] == "q"
+      running = false if %i[escape q].include?(e[:key])
     end
   end
 

data/examples/color_test.rb

@@ -52,7 +52,7 @@ while running && !window.should_close?
 
   events = window.poll_events_raw
   events.each do |e|
-    if e[:type] == :key_press && (e[:key] == 12 || e[:key] == "q")
+    if e[:type] == :key_press && %i[escape q].include?(e[:key])
       running = false
     end
   end