glaze 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59e34d1077ab8534452db27b99282791ab2926a4804a14e78d24171d95925b72
+  data.tar.gz: 295b3479c2d06dec5e24db6320c55958d47f7a79f14ac08c266dbd4d449c43c0
+SHA512:
+  metadata.gz: 9aab13dcda3d98a0aa6489cda4275e5f29dba5285344955f87df64df550d3162e5b11a0b3a18cb697591b66d97fe0e5602ce1a177c760db9b8d7a64abaa8d066
+  data.tar.gz: 906add6ec06430f52fa2388fc58edc7b0f35748f9863ef3fa5b556bbec9570b5d6373bbd1c4917403616cc4168c834842add4dea90bc048fc30c091342a9cf84

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2026-09-23
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 ydah
+
+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,95 @@
+# Glaze
+
+[![Gem version](https://badge.fury.io/rb/glaze.svg)](https://rubygems.org/gems/glaze)
+[![Downloads](https://img.shields.io/gem/dt/glaze?label=downloads)](https://rubygems.org/gems/glaze)
+[![CI](https://github.com/rbgfx/glaze/actions/workflows/ci.yml/badge.svg)](https://github.com/rbgfx/glaze/actions/workflows/ci.yml)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D3.1-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org/)
+[![License](https://img.shields.io/badge/license-MIT-750014.svg)](LICENSE.txt)
+
+> Live shader coding for Ruby, from a saved file to a window, PNG, or WebGPU page.
+
+Glaze loads shader definitions written in Ruby, compiles them through rlsl, and
+renders them with rbgl. It supports live reload, headless output, parameter
+metadata, and WebGPU export.
+
+**[Features](#features) · [Installation](#installation) · [Quick start](#quick-start) · [Shader files](#shader-files) · [Development](#development)**
+
+## Features
+
+- Live reload for shader files without losing the current frame on a bad edit.
+- CPU rendering for portable and headless workflows.
+- Metal rendering and GPU pixel capture on supported macOS hosts.
+- PNG screenshots, frame sequences, and standalone WebGPU HTML export.
+- Typed parameters with defaults, ranges, steps, and an optional Twiddle panel.
+- Built-in uniforms for time, frame, mouse, resolution, and fragment position.
+
+## Installation
+
+Add Glaze to your Gemfile:
+
+~~~ruby
+gem "glaze"
+~~~
+
+Then run:
+
+~~~sh
+bundle install
+~~~
+
+Or install the released gem:
+
+~~~sh
+gem install glaze
+~~~
+
+The CPU renderer and screenshot commands require a C compiler. Metal rendering
+is available on macOS with a Metal-capable device.
+
+## Quick start
+
+Run the included examples:
+
+~~~sh
+glaze run examples/plasma.rb
+glaze shot examples/plasma.rb --time 1.5 --size 640x360 -o shot.png
+glaze record examples/plasma.rb --seconds 2 --fps 30 -o frames
+glaze export examples/plasma.rb plasma.html
+~~~
+
+Run a fixed number of headless CPU frames:
+
+~~~sh
+glaze run examples/plasma.rb --renderer cpu --backend file --frames 2 --output-dir frames
+~~~
+
+## Shader files
+
+A shader file contains one <code>Glaze.shader</code> definition:
+
+~~~ruby
+Glaze.shader(:gradient) do
+  params do
+    float :speed, default: 1.0, range: 0.0..4.0
+  end
+
+  fragment do |point, resolution, uniforms|
+    value = point[0] / resolution[0] + uniforms.time * uniforms.speed
+    [value % 1.0, 0.2, 0.4, 1.0]
+  end
+end
+~~~
+
+Fragments use rlsl syntax. Texture parameters are supported by the Metal
+runner; the WebGPU exporter embeds the referenced PNG bytes in its HTML.
+
+## Development
+
+~~~sh
+bundle install
+bundle exec rake verify
+~~~
+
+## License
+
+[MIT](LICENSE.txt)

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.ruby_opts = %w[-I../tessel/lib -I../rlsl/lib -I../rbgl/lib -I../larb/lib -I../twiddle/lib -I../metaco/lib]
+end
+
+task default: :spec
+task verify: :spec

data/docs/spikes.md

@@ -0,0 +1,15 @@
+# Glaze implementation checks
+
+These checks record the results of the design spikes that can run without a
+browser or a Metal device.
+
+| Check | Result | Evidence |
+|---|---|---|
+| Forward a fragment block through another object | Pass | `spec/glaze_spec.rb` covers `Definition#rlsl_builder` and helper/function forwarding. |
+| Load the same file twice after editing it | Pass | `Loader` uses `load(path, true)` and clears the definition registry; `Watcher` hashes Ruby tokens. |
+| Pack integer and vector uniforms | Pass for CPU and source generation | CPU rendering and RLSL MSL/WGSL generation are covered by the Glaze and RLSL suites. GPU execution requires a Metal session. |
+| Resolve WGSL integer and boolean layout | Pass | `Export::UniformLayout` uses 4-byte scalar slots and 16-byte vector alignment; export specs cover generated bindings. |
+| Use a Cocoa native handle with the Metal runner | Wired, GPU validation pending | `Runners::Metal` calls `build_metal_shader`, `prepare`, and `render_metal`; the mandatory GPU workflow is `run_metal`. |
+
+The last check must be repeated on a logged-in macOS session with a Metal
+device. Headless CI intentionally omits it.

data/examples/gradient.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Glaze.shader :gradient do
+  fragment do |frag_coord, resolution, _u|
+    uv = frag_coord / resolution
+    vec3(uv.x, uv.y, 0.25)
+  end
+end

data/examples/plasma.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Glaze.shader :plasma do
+  params { float :speed, default: 1.0, range: 0.0..4.0, step: 0.1 }
+
+  fragment do |frag_coord, resolution, u|
+    uv = frag_coord / resolution
+    r = sin(u.time * u.speed + uv.x * 6.28) * 0.5 + 0.5
+    g = sin(u.time * u.speed + uv.y * 6.28) * 0.5 + 0.5
+    b = sin(u.time * u.speed + (uv.x + uv.y) * 6.28) * 0.5 + 0.5
+    vec3(r, g, b)
+  end
+end

data/examples/textured.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Glaze.shader :textured do
+  params { texture :noise, file: "noise.png" }
+  fragment do |frag_coord, resolution, u|
+    texture(u.noise, frag_coord / resolution).xyz
+  end
+end

data/exe/glaze

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "tempfile"
+require "glaze"
+
+command = ARGV.shift
+case command
+when "new"
+  name = ARGV.shift || "shader"
+  raise ArgumentError, "shader name must contain only letters, digits and underscores" unless name.match?(/\A[a-zA-Z][a-zA-Z0-9_]*\z/)
+  path = File.join("shaders", "#{name}.rb")
+  FileUtils.mkdir_p(File.dirname(path))
+  File.write(path, "Glaze.shader :#{name} do\n  fragment do |frag_coord, resolution, u|\n    uv = frag_coord / resolution\n    vec3(uv.x, uv.y, 0.2)\n  end\nend\n")
+  puts path
+when "run"
+  path = ARGV.first&.start_with?("-") ? nil : ARGV.shift
+  size = [640, 360]
+  backend = :auto
+  renderer = :auto
+  fps = 60
+  frames = nil
+  output_dir = "."
+  from_png = nil
+  panel = false
+  OptionParser.new do |opts|
+    opts.on("--size SIZE") { |value| size = value.split("x").map(&:to_i) }
+    opts.on("--backend NAME") { |value| backend = value.to_sym }
+    opts.on("--renderer NAME") { |value| renderer = value.to_sym }
+    opts.on("--fps N", Integer) { |value| fps = value }
+    opts.on("--frames N", Integer) { |value| frames = value }
+    opts.on("--output-dir PATH") { |value| output_dir = value }
+    opts.on("--from-png PATH") { |value| from_png = value }
+    opts.on("--panel") { panel = true }
+  end.parse!(ARGV)
+  path ||= ARGV.shift
+  raise ArgumentError, "size must be WIDTHxHEIGHT" unless size.length == 2 && size.all?(&:positive?)
+  options = { width: size[0], height: size[1], backend: backend, renderer: renderer, fps: fps, frames: frames, output_dir: output_dir, panel: panel }
+  if from_png
+    source = Tessel.read(from_png).metadata.fetch("glaze:source")
+    Tempfile.create(["glaze-recovered-", ".rb"]) do |file|
+      file.write(source)
+      file.flush
+      Glaze.run_file(file.path, **options)
+    end
+  else
+    raise ArgumentError, "shader file is required" unless path
+    Glaze.run_file(path, **options)
+  end
+when "shot"
+  path = ARGV.shift
+  output = "shot.png"
+  time = 0.0
+  size = [640, 360]
+  OptionParser.new do |opts|
+    opts.on("-o PATH") { |value| output = value }
+    opts.on("--time SECONDS", Float) { |value| time = value }
+    opts.on("--size SIZE") { |value| size = value.split("x").map(&:to_i) }
+  end.parse!(ARGV)
+  Glaze.capture(Glaze.load_file(path), output, time: time, size: size)
+  puts output
+when "record"
+  path = ARGV.shift
+  output_dir = "frames"
+  fps = 30
+  seconds = 1.0
+  size = [640, 360]
+  OptionParser.new do |opts|
+    opts.on("-o DIR") { |value| output_dir = value }
+    opts.on("--fps N", Integer) { |value| fps = value }
+    opts.on("--seconds N", Float) { |value| seconds = value }
+    opts.on("--size SIZE") { |value| size = value.split("x").map(&:to_i) }
+  end.parse!(ARGV)
+  raise ArgumentError, "fps, seconds and dimensions must be positive" unless fps.positive? && seconds.positive? && size.length == 2 && size.all?(&:positive?)
+  definition = Glaze.load_file(path)
+  runner = Glaze::Runners::CPU.new(definition)
+  FileUtils.mkdir_p(output_dir)
+  (seconds * fps).ceil.times do |frame|
+    image = runner.render(width: size[0], height: size[1], time: frame.to_f / fps, frame: frame)
+    Glaze.save_capture(image, definition, File.join(output_dir, format("frame_%05d.png", frame)))
+  end
+  puts output_dir
+when "export"
+  path = ARGV.shift
+  output = ARGV.shift || "#{File.basename(path, ".rb")}.html"
+  Glaze.export_webgpu(Glaze.load_file(path), output)
+  puts output
+else
+  warn "usage: glaze new NAME | run FILE [--backend NAME] [--renderer NAME] [--panel] [--size WxH] | shot FILE [-o PATH] | record FILE [-o DIR] | export FILE [PATH]"
+  exit 1
+end

data/lib/glaze/clock.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../glaze"

data/lib/glaze/dsl.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../glaze"

data/lib/glaze/export/uniform_layout.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../../glaze"

data/lib/glaze/loader.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "../glaze"

data/lib/glaze/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Glaze
+  VERSION = "0.1.0"
+end

data/lib/glaze.rb

@@ -0,0 +1,654 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require "fileutils"
+require "cgi"
+require "ripper"
+require "tessel"
+
+require_relative "glaze/version"
+
+module Glaze
+  class Error < StandardError; end
+  BUILT_INS = %i[time frame mouse resolution frag_coord u].freeze
+  TYPE_SIZES = { float: [4, 4], int: [4, 4], bool: [4, 4], vec2: [8, 8], vec3: [12, 16], vec4: [16, 16] }.freeze
+
+  Param = Struct.new(:name, :type, :default, :range, :step, :file, keyword_init: true)
+
+  class ParamsContext
+    attr_reader :params
+
+    def initialize
+      @params = []
+    end
+
+    TYPE_SIZES.keys.each do |type|
+      define_method(type) do |name, default: nil, range: nil, step: nil|
+        name = name.to_sym
+        raise ArgumentError, "uniform name is reserved: #{name}" if BUILT_INS.include?(name)
+        raise ArgumentError, "duplicate uniform: #{name}" if @params.any? { |param| param.name == name }
+        default = default_for(type, default)
+        validate(type, default, range, step)
+        @params << Param.new(name: name, type: type, default: default, range: range, step: step)
+      end
+    end
+
+    def texture(name, file:)
+      name = name.to_sym
+      raise ArgumentError, "uniform name is reserved: #{name}" if BUILT_INS.include?(name)
+      raise ArgumentError, "duplicate uniform: #{name}" if @params.any? { |param| param.name == name }
+      raise ArgumentError, "texture file is required" if file.to_s.empty?
+      @params << Param.new(name: name, type: :sampler2D, file: file.to_s)
+    end
+
+    def uniforms(&block)
+      params(&block)
+    end
+
+    private
+
+    def default_for(type, value)
+      return value unless value.nil?
+      type == :bool ? false : type == :int ? 0 : type.to_s.start_with?("vec") ? Array.new(type.to_s.delete_prefix("vec").to_i, 0.0) : 0.0
+    end
+
+    def validate(type, default, range, step)
+      case type
+      when :float
+        raise TypeError, "float uniform default must be numeric" unless default.is_a?(Numeric)
+      when :int
+        raise TypeError, "int uniform default must be an integer" unless default.is_a?(Integer)
+      when :bool
+        raise TypeError, "bool uniform default must be true or false" unless [true, false].include?(default)
+      else
+        size = type.to_s.delete_prefix("vec").to_i
+        raise TypeError, "vector uniform default must be an array" unless default.is_a?(Array)
+        raise ArgumentError, "vector uniform default has the wrong length" unless default.length == size
+        raise TypeError, "vector uniform default must be numeric" unless default.all? { |value| value.is_a?(Numeric) }
+      end
+      if range
+        raise ArgumentError, "uniform range is only valid for numeric uniforms" unless %i[float int].include?(type)
+        raise TypeError, "uniform range must be a Range" unless range.is_a?(Range)
+        raise TypeError, "uniform range endpoints must be numeric" unless range.begin.is_a?(Numeric) && range.end.is_a?(Numeric)
+        raise ArgumentError, "uniform range must increase" unless range.begin < range.end
+        raise ArgumentError, "uniform range must be finite" unless range.begin.to_f.finite? && range.end.to_f.finite?
+        raise ArgumentError, "uniform default is outside its range" unless range.cover?(default)
+      end
+      if step
+        raise ArgumentError, "uniform step is only valid for numeric uniforms" unless %i[float int].include?(type)
+        raise TypeError, "uniform step must be numeric" unless step.is_a?(Numeric)
+        raise ArgumentError, "uniform step must be positive and finite" unless step.positive? && step.to_f.finite?
+        raise TypeError, "int uniform step must be an integer" if type == :int && !step.is_a?(Integer)
+      end
+    end
+  end
+
+  class Definition
+    attr_reader :name, :params, :fragment_block, :helper_blocks, :function_blocks, :source
+
+    def initialize(name)
+      @name = name.to_sym
+      @params = []
+      @helper_blocks = []
+      @function_blocks = []
+    end
+
+    def params(&block)
+      return @params unless block
+
+      context = ParamsContext.new
+      context.instance_eval(&block)
+      duplicate = context.params.find { |param| @params.any? { |existing| existing.name == param.name } }
+      raise ArgumentError, "duplicate uniform: #{duplicate.name}" if duplicate
+      @params.concat(context.params)
+    end
+
+    alias uniforms params
+
+    def fragment(&block)
+      @fragment_block = block
+      @source = block&.source_location
+    end
+
+    def helpers(&block) = @helper_blocks << block
+    def functions(&block) = @function_blocks << block
+
+    def param(name)
+      @params.find { |param| param.name == name.to_sym }
+    end
+
+    def rlsl_builder
+      require "rlsl"
+      definition = self
+      builder = RLSL::ShaderBuilder.new(@name)
+      builder.uniforms do
+        float :time
+        int :frame
+        vec4 :mouse
+        definition.params.each { |param| public_send(param.type, param.name) }
+      end
+      @function_blocks.each { |block| builder.functions(&block) }
+      @helper_blocks.each { |block| builder.helpers(&block) }
+      raise Error, "shader #{@name} has no fragment" unless @fragment_block
+      builder.fragment(&@fragment_block)
+      builder
+    end
+  end
+
+  class Loader
+    Result = Struct.new(:definition, :error, :location, keyword_init: true) do
+      def ok? = !definition.nil? && error.nil?
+    end
+
+    def load(path)
+      Result.new(definition: Glaze.load_file(path))
+    rescue SyntaxError, StandardError => e
+      Result.new(error: e, location: e.backtrace&.first)
+    end
+  end
+
+  module Runners
+    class ParamPanel
+      attr_reader :ui
+
+      def initialize(definition)
+        require "twiddle"
+        @definition = definition
+        @ui = Twiddle::Context.new
+      end
+
+      def render(image, events:, values:)
+        @ui.frame(events: events) do |ui|
+          ui.window("Parameters") do
+            @definition.params.each do |param|
+              if param.range && %i[float int].include?(param.type)
+                maximum = param.range.exclude_end? ? param.range.end - (param.type == :int ? 1 : Float::EPSILON) : param.range.end
+                values[param.name] = ui.slider(param.name.to_s, values[param.name], param.range.begin..maximum)
+              else
+                ui.label("#{param.name}: #{values[param.name].inspect}")
+              end
+            end
+          end
+        end
+        @ui.render(image)
+      end
+    end
+
+    class CPU
+      attr_reader :definition
+
+      def initialize(definition)
+        raise Error, "texture params require the Metal runner" if definition.params.any? { |param| param.type == :sampler2D }
+        @definition = definition
+        @shader = definition.rlsl_builder.compile_and_load
+      end
+
+      def render(width:, height:, time: 0.0, frame: 0, mouse: [0.0, 0.0, 0.0, 0.0], params: {})
+        buffer = "\0".b * (width * height * 4)
+        uniforms = @definition.params.to_h { |param| [param.name, params.fetch(param.name, param.default)] }
+        @shader.render(buffer, width, height, uniforms.merge(time: time, frame: frame, mouse: mouse))
+        # rlsl's C renderer writes top-down BGRA; Tessel uses top-down RGBA.
+        rgba = buffer.unpack("L<*").map { |pixel| (pixel & 0xff00_ff00) | ((pixel & 0xff) << 16) | ((pixel >> 16) & 0xff) }.pack("L<*")
+        Tessel::Image.from_rgba(width, height, rgba)
+      end
+    end
+
+    class Metal
+      attr_reader :definition
+
+      def initialize(definition, handle)
+        @definition = definition
+        @handle = handle
+        @textures = {}
+        begin
+          base = File.dirname(File.expand_path(definition.instance_variable_get(:@file) || "."))
+          definition.params.each do |param|
+            next unless param.type == :sampler2D
+            image = Tessel.read(File.expand_path(param.file, base))
+            @textures[param.name] = Metaco.texture_create(handle, image.width, image.height, image.bytes)
+          end
+          @shader = definition.rlsl_builder.build_metal_shader
+          @shader.prepare(handle)
+        rescue Exception
+          close
+          raise
+        end
+      end
+
+      def render(width:, height:, time: 0.0, frame: 0, mouse: [0.0, 0.0, 0.0, 0.0], params: {})
+        uniforms = @definition.params.reject { |param| param.type == :sampler2D }.to_h { |param| [param.name, params.fetch(param.name, param.default)] }
+        @shader.render_metal(@handle, width, height, uniforms.merge(time: time, frame: frame, mouse: mouse), textures: @textures)
+      end
+
+      def read_image(width, height)
+        Tessel::Image.from_rgba(width, height, Metaco.read_pixels(@handle))
+      end
+
+      def close
+        @textures.each_value { |texture| Metaco.texture_destroy(texture) }
+        @textures.clear
+      end
+    end
+
+    class Window
+      def initialize(path, width:, height:, backend: :auto, renderer: :auto, fps: 60, frames: nil, output_dir: ".", panel: false)
+        requested_backend = backend.to_sym
+        @renderer = renderer.to_sym
+        if @renderer == :auto && %i[cpu metal].include?(requested_backend)
+          @renderer = requested_backend
+          requested_backend = requested_backend == :metal ? :cocoa : :auto
+        end
+        @path, @width, @height, @backend, @fps, @frames, @output_dir, @panel = path, width, height, requested_backend, fps, frames, output_dir, panel
+        raise ArgumentError, "unknown RBGL backend: #{@backend}" unless %i[auto file cocoa x11 wayland].include?(@backend)
+        raise ArgumentError, "renderer must be :auto, :cpu, or :metal" unless %i[auto cpu metal].include?(@renderer)
+        raise ArgumentError, "fps must be positive" unless @fps.positive?
+      end
+
+      def run
+        require "rbgl"
+        loaded = Loader.new.load(@path)
+        raise loaded.error unless loaded.ok?
+        params = ParamState.new(loaded.definition)
+        watcher = Watcher.new(@path)
+        watcher.changed?
+        options = @backend == :file ? { format: :ppm, output_dir: @output_dir, max_frames: @frames || 1 } : {}
+        window = RBGL::GUI::Window.new(width: @width, height: @height, title: "glaze: #{loaded.definition.name}", backend: @backend, **options)
+        metal = @renderer == :metal || (@renderer == :auto && window.metal_available?)
+        raise LoadError, "Metal backend is unavailable" if metal && !window.metal_available?
+        renderer = metal ? Metal : CPU
+        runner = renderer == Metal ? Metal.new(loaded.definition, window.native_handle) : CPU.new(loaded.definition)
+        panel = @panel && renderer == CPU ? ParamPanel.new(loaded.definition) : nil
+        input = InputState.new(width: @width, height: @height)
+        clock = Clock.new
+        show_hud = true
+        reload_error = nil
+        until window.should_close?
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          save_shot = false
+          events = Array(window.poll_events_raw)
+          events.each do |event|
+            case event[:type]
+            when :mouse_move then input.mouse_move(event[:x], event[:y])
+            when :mouse_press then input.mouse_press(event[:x], event[:y])
+            when :mouse_release then input.mouse_release(event[:x], event[:y])
+            when :key_press
+              key = event[:key]
+              key = key.to_sym if key.respond_to?(:to_sym)
+              save_shot = true if key == :s || event[:char] == "s"
+              clock.paused? ? clock.resume : clock.pause if key == :space
+              clock.reset if key == :r
+              show_hud = !show_hud if key == :h || event[:char] == "h"
+              params.select(params.selected + 1) if %i[tab down].include?(key)
+              params.select(params.selected - 1) if key == :up
+              params.adjust(1) if key == :right
+              params.adjust(-1) if key == :left
+            when :resize
+              @width, @height = event[:width], event[:height]
+              input = InputState.new(width: @width, height: @height)
+            end
+          end
+          if watcher.changed?
+            candidate = Loader.new.load(@path)
+            begin
+              raise candidate.error unless candidate.ok?
+              next_runner = renderer == Metal ? Metal.new(candidate.definition, window.native_handle) : CPU.new(candidate.definition)
+              previous_runner = runner
+              runner = next_runner
+              previous_runner.close if previous_runner.is_a?(Metal)
+              params = ParamState.new(candidate.definition)
+              panel = ParamPanel.new(candidate.definition) if panel
+              reload_error = nil
+              warn "reloaded #{@path}"
+            rescue StandardError => e
+              reload_error = e.message
+              warn "reload failed: #{e.message}"
+            end
+          end
+          clock.tick
+          image = runner.render(width: @width, height: @height, time: clock.time, frame: clock.frame, mouse: input.mouse, params: params.values)
+          draw_hud(image, runner.definition, params, reload_error) if show_hud && image
+          panel&.render(image, events: events, values: params.values)
+          window.set_pixels(image.bytes) if image
+          if save_shot
+            FileUtils.mkdir_p("shots")
+            destination = File.join("shots", "#{runner.definition.name}-#{Time.now.strftime('%Y%m%d-%H%M%S')}.png")
+            if runner.is_a?(Metal)
+              Glaze.save_capture(runner.read_image(@width, @height), runner.definition, destination, params: params.values)
+            else
+              Glaze.capture(runner.definition, destination, time: clock.time, params: params.values, size: [@width, @height])
+            end
+          end
+          delay = 1.0 / @fps - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)
+          sleep(delay) if delay.positive? && @backend != :file
+        end
+      ensure
+        runner.close if runner.is_a?(Metal)
+        window&.close
+      end
+
+      private
+
+      def draw_hud(image, definition, params, reload_error)
+        require "glyphic"
+        parameter = definition.params[params.selected]
+        text = if reload_error
+          "reload failed: #{reload_error}"
+        elsif parameter
+          "#{parameter.name}: #{params.values[parameter.name].inspect}"
+        end
+        return unless text
+
+        image.fill_rect(0, 0, image.width, [20, image.height].min, [0, 0, 0, 190], blend: :alpha)
+        Glyphic.default.draw(image, 4, 3, text.slice(0, [image.width / 6, 1].max), color: [255, 255, 255, 255])
+      rescue LoadError
+        nil
+      end
+    end
+  end
+
+  class Clock
+    attr_reader :time, :frame
+
+    def initialize(clock: Process.method(:clock_gettime))
+      @clock = clock
+      @started = now
+      @time = 0.0
+      @frame = 0
+      @paused = false
+    end
+
+    def tick
+      @time = now - @started unless @paused
+      @frame += 1
+      self
+    end
+
+    def pause = (@paused = true)
+    def resume = (@started = now - @time; @paused = false)
+    def paused? = @paused
+    def reset = (@started = now; @time = 0.0; @frame = 0)
+    def seek(seconds) = (@started = now - seconds.to_f; @time = seconds.to_f)
+
+    private
+
+    def now
+      @clock.call(Process::CLOCK_MONOTONIC)
+    end
+  end
+
+  class InputState
+    attr_reader :mouse, :keys
+
+    def initialize(width: 1, height: 1)
+      @width = width
+      @height = height
+      @mouse = [0.0, 0.0, 0.0, 0.0]
+      @keys = {}
+    end
+
+    def mouse_move(x, y)
+      @mouse[0] = x
+      @mouse[1] = @height - 1 - y
+    end
+
+    def mouse_press(x, y)
+      mouse_move(x, y)
+      @mouse[2] = @mouse[0]
+      @mouse[3] = @mouse[1]
+    end
+
+    def mouse_release(x, y)
+      mouse_move(x, y)
+      @mouse[2] = -@mouse[2].abs
+      @mouse[3] = -@mouse[3].abs
+    end
+
+    def key(key, down: true)
+      @keys[key.to_sym] = down
+    end
+  end
+
+  class ParamState
+    attr_reader :values, :selected
+
+    def initialize(definition)
+      @values = definition.params.to_h { |param| [param.name, param.default] }
+      @params = definition.params
+      @selected = 0
+    end
+
+    def select(index)
+      @selected = @params.empty? ? 0 : [[index.to_i, 0].max, @params.length - 1].min
+    end
+
+    def adjust(amount)
+      param = @params[@selected]
+      return unless param && %i[float int].include?(param.type)
+      step = param.step || (param.type == :int ? 1 : 0.01)
+      value = @values[param.name] + amount.to_f * step
+      if param.range
+        maximum = param.range.exclude_end? ? param.range.end - (param.type == :int ? 1 : Float::EPSILON) : param.range.end
+        value = [[value, param.range.begin].max, maximum].min
+      end
+      @values[param.name] = param.type == :int ? value.round : value
+    end
+  end
+
+  class Watcher
+    def initialize(path)
+      @path = path
+      @signature = nil
+    end
+
+    def changed?
+      signature = normalized_signature
+      changed = signature != @signature
+      @signature = signature
+      changed
+    rescue Errno::ENOENT
+      false
+    end
+
+    private
+
+    def normalized_signature
+      tokens = Ripper.lex(File.read(@path)).reject { |(_, type, _, _)| %i[on_sp on_nl on_ignored_nl on_comment].include?(type) }
+      Digest::SHA256.hexdigest(tokens.map { |(_, type, text, _)| "#{type}:#{text}" }.join)
+    rescue SyntaxError, EncodingError
+      Digest::SHA256.file(@path).hexdigest
+    end
+  end
+
+  module Export
+    module UniformLayout
+      module_function
+
+      def build(params)
+        offset = 0
+        result = {}
+        params.each do |param|
+          size, alignment = TYPE_SIZES.fetch(param.type)
+          offset = align(offset, alignment)
+          result[param.name] = { offset: offset, type: param.type }
+          offset += size
+        end
+        { fields: result, size: align(offset, 16) }
+      end
+
+      def align(value, alignment)
+        (value + alignment - 1) / alignment * alignment
+      end
+      private_class_method :align
+    end
+
+    module WebGPU
+      module_function
+
+      def write(definition, path)
+        value_params = definition.params.reject { |param| param.type == :sampler2D }
+        texture_params = definition.params.select { |param| param.type == :sampler2D }
+        base = File.dirname(File.expand_path(definition.instance_variable_get(:@file) || "."))
+        images = texture_params.map do |param|
+          image = Tessel.read(File.expand_path(param.file, base))
+          { name: param.name, data: "data:image/png;base64,#{[Tessel::PNG.encode(image)].pack('m0')}" }
+        end
+        layout = UniformLayout.build([
+          Param.new(name: :resolution, type: :vec2),
+          Param.new(name: :time, type: :float),
+          Param.new(name: :frame, type: :int),
+          Param.new(name: :mouse, type: :vec4),
+          *value_params
+        ])
+        source = definition.rlsl_builder.build_wgsl_shader
+        params = value_params.map do |param|
+          { name: param.name, type: param.type, default: param.default,
+            range: param.range && [param.range.begin, param.range.end], exclude_end: param.range&.exclude_end?, step: param.step }
+        end
+        html = <<~HTML
+          <!doctype html><meta charset="utf-8"><title>#{CGI.escapeHTML(definition.name.to_s)}</title>
+          <style>html,body{margin:0;width:100%;height:100%;background:#111;color:#fff;font:14px sans-serif}canvas{width:100%;height:100%;display:block}#panel{position:fixed;top:12px;left:12px;background:#000a;padding:12px}label{display:block}</style>
+          <canvas></canvas><div id="panel"><div id="status"></div><div id="params"></div></div>
+          <script>
+          const shaderSource = #{JSON.generate(source).gsub("</", "<\\/")};
+          const layout = #{JSON.generate(layout)};
+          const params = #{JSON.generate(params)};
+          const images = #{JSON.generate(images)};
+          const canvas = document.querySelector('canvas');
+          const status = document.querySelector('#status');
+          const values = Object.fromEntries(params.map(p => [p.name, p.default]));
+          for (const p of params) {
+            if (!p.range || !['float', 'int'].includes(p.type)) continue;
+            const label = document.createElement('label');
+            const input = document.createElement('input');
+            input.type = 'range'; input.min = p.range[0]; input.max = p.exclude_end ? (p.type === 'int' ? p.range[1] - 1 : p.range[1] - Number.EPSILON) : p.range[1];
+            input.step = p.step ?? (p.type === 'int' ? 1 : 'any'); input.value = p.default;
+            const caption = document.createElement('span');
+            input.oninput = () => { values[p.name] = Number(input.value); caption.textContent = `${p.name}: ${input.value}`; };
+            input.oninput(); label.append(caption, input); document.querySelector('#params').append(label);
+          }
+          const mouse = [0, 0, 0, 0];
+          function move(e) { const r = canvas.getBoundingClientRect(); mouse[0] = (e.clientX-r.left)*canvas.width/r.width; mouse[1] = canvas.height-(e.clientY-r.top)*canvas.height/r.height; }
+          canvas.onpointermove = move;
+          canvas.onpointerdown = e => { move(e); mouse[2] = mouse[0]; mouse[3] = mouse[1]; };
+          canvas.onpointerup = e => { move(e); mouse[2] = -Math.abs(mouse[2]); mouse[3] = -Math.abs(mouse[3]); };
+          async function start() {
+            if (!navigator.gpu) throw new Error('WebGPU is not available');
+            const adapter = await navigator.gpu.requestAdapter();
+            if (!adapter) throw new Error('No WebGPU adapter');
+            const device = await adapter.requestDevice();
+            const context = canvas.getContext('webgpu');
+            const format = navigator.gpu.getPreferredCanvasFormat();
+            context.configure({device, format, alphaMode: 'opaque'});
+            const compute = device.createComputePipeline({layout:'auto',compute:{module:device.createShaderModule({code:shaderSource}),entryPoint:'main'}});
+            const imageBindings = [];
+            for (const [index, image] of images.entries()) {
+              const bitmap = await createImageBitmap(await (await fetch(image.data)).blob());
+              const texture = device.createTexture({size:[bitmap.width,bitmap.height],format:'rgba8unorm',usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST});
+              device.queue.copyExternalImageToTexture({source:bitmap},{texture},[bitmap.width,bitmap.height]);
+              imageBindings.push({binding:2+index*2,resource:texture.createView()},
+                                 {binding:3+index*2,resource:device.createSampler({magFilter:'linear',minFilter:'linear',addressModeU:'clamp-to-edge',addressModeV:'clamp-to-edge'})});
+              bitmap.close();
+            }
+            const presentSource = `@group(0) @binding(0) var image: texture_2d<f32>;
+              @vertex fn vs(@builtin(vertex_index) i:u32)->@builtin(position) vec4<f32>{var p=array<vec2<f32>,3>(vec2(-1.0,-1.0),vec2(3.0,-1.0),vec2(-1.0,3.0));return vec4(p[i],0.0,1.0);}
+              @fragment fn fs(@builtin(position) p:vec4<f32>)->@location(0) vec4<f32>{return textureLoad(image,vec2<i32>(p.xy),0);}`;
+            const present = device.createRenderPipeline({layout:'auto',vertex:{module:device.createShaderModule({code:presentSource}),entryPoint:'vs'},fragment:{module:device.createShaderModule({code:presentSource}),entryPoint:'fs',targets:[{format}]},primitive:{topology:'triangle-list'}});
+            const uniform = device.createBuffer({size:layout.size,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});
+            let texture, computeGroup, presentGroup, frame = 0;
+            function resize() {
+              const width = Math.max(1, Math.round(canvas.clientWidth * devicePixelRatio));
+              const height = Math.max(1, Math.round(canvas.clientHeight * devicePixelRatio));
+              if (canvas.width === width && canvas.height === height && texture) return;
+              canvas.width = width; canvas.height = height; texture?.destroy();
+              texture = device.createTexture({size:[width,height],format:'rgba8unorm',usage:GPUTextureUsage.STORAGE_BINDING|GPUTextureUsage.TEXTURE_BINDING});
+              const view = texture.createView();
+              computeGroup = device.createBindGroup({layout:compute.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:uniform}},{binding:1,resource:view},...imageBindings]});
+              presentGroup = device.createBindGroup({layout:present.getBindGroupLayout(0),entries:[{binding:0,resource:view}]});
+            }
+            function draw(now) {
+              resize();
+              const data = new ArrayBuffer(layout.size), view = new DataView(data);
+              const put = (name, value) => { const field=layout.fields[name]; if(!field)return; const values=Array.isArray(value)?value:[value]; values.forEach((v,i)=>{const offset=field.offset+i*4; if(field.type==='int'||field.type==='bool')view.setInt32(offset,Number(v),true);else view.setFloat32(offset,Number(v),true);}); };
+              put('resolution',[canvas.width,canvas.height]); put('time',now/1000); put('frame',frame++); put('mouse',mouse);
+              for (const p of params) put(p.name,values[p.name]);
+              device.queue.writeBuffer(uniform,0,data);
+              const encoder=device.createCommandEncoder(), pass=encoder.beginComputePass();
+              pass.setPipeline(compute);pass.setBindGroup(0,computeGroup);pass.dispatchWorkgroups(Math.ceil(canvas.width/8),Math.ceil(canvas.height/8));pass.end();
+              const render=encoder.beginRenderPass({colorAttachments:[{view:context.getCurrentTexture().createView(),loadOp:'clear',storeOp:'store'}]});
+              render.setPipeline(present);render.setBindGroup(0,presentGroup);render.draw(3);render.end();
+              device.queue.submit([encoder.finish()]);requestAnimationFrame(draw);
+            }
+            status.textContent=''; requestAnimationFrame(draw);
+          }
+          start().catch(error => {status.textContent=error.message; console.error(error);});
+          </script>
+        HTML
+        File.write(path, html)
+        path
+      end
+    end
+  end
+
+  module_function
+
+  def shader(name, &block)
+    definition = Definition.new(name)
+    definition.instance_eval(&block) if block
+    definitions << definition
+    definition
+  end
+
+  def definitions
+    @definitions ||= []
+  end
+
+  def load_file(path)
+    definitions.clear
+    File.read(path)
+    load(path, true)
+    raise Error, "expected one Glaze.shader in #{path}, found #{definitions.length}" unless definitions.length == 1
+    definitions.first.tap { |definition| definition.instance_variable_set(:@file, path) }
+  rescue SyntaxError, StandardError => e
+    raise Error, "#{path}: #{e.message}"
+  end
+
+  def render(definition, width:, height:, time: 0.0, params: {})
+    image = Tessel::Image.new(width, height)
+    return image unless definition.fragment_block
+    uniforms = definition.params.to_h { |param| [param.name, params.fetch(param.name, param.default)] }
+    (0...height).each do |y|
+      (0...width).each do |x|
+        value = definition.fragment_block.call([x + 0.5, y + 0.5], [width, height], uniforms.merge(time: time, resolution: [width, height], frag_coord: [x + 0.5, y + 0.5]))
+        rgba = value.is_a?(Array) ? value : [value, value, value, 1.0]
+        rgba = rgba.first(4).map { |channel| [[(channel.to_f <= 1 ? channel.to_f * 255 : channel.to_f).round, 0].max, 255].min }
+        rgba << 255 if rgba.length == 3
+        image[x, y] = rgba
+      end
+    end
+    image
+  end
+
+  def export_webgpu(definition, path)
+    Export::WebGPU.write(definition, path)
+  end
+
+  def run_file(path, **options)
+    Runners::Window.new(path, **options).run
+  end
+
+  def capture(definition, path, time: 0.0, params: {}, size: [640, 360])
+    image = if definition.instance_variable_get(:@file)
+      Runners::CPU.new(definition).render(width: size[0], height: size[1], time: time, params: params)
+    else
+      render(definition, width: size[0], height: size[1], time: time, params: params)
+    end
+    save_capture(image, definition, path, params: params)
+  end
+
+  def save_capture(image, definition, path, params: {})
+    source = definition.instance_variable_get(:@file) && File.read(definition.instance_variable_get(:@file))
+    image.instance_variable_get(:@metadata).merge!("glaze:source" => source.to_s, "glaze:uniforms" => JSON.generate(params), "Software" => "glaze")
+    image.write(path)
+  end
+end

data/sig/glaze.rbs

@@ -0,0 +1,4 @@
+module Glaze
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: glaze
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ydah
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tessel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rlsl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rbgl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Shader definitions, parameter metadata, CPU rendering, and WebGPU export.
+email:
+- t.yudai92@gmail.com
+executables:
+- glaze
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- docs/spikes.md
+- examples/gradient.rb
+- examples/noise.png
+- examples/plasma.rb
+- examples/textured.rb
+- exe/glaze
+- lib/glaze.rb
+- lib/glaze/clock.rb
+- lib/glaze/dsl.rb
+- lib/glaze/export/uniform_layout.rb
+- lib/glaze/loader.rb
+- lib/glaze/version.rb
+- sig/glaze.rbs
+homepage: https://github.com/rbgfx/glaze
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rbgfx/glaze
+  source_code_uri: https://github.com/rbgfx/glaze/tree/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Live coding tools for Ruby shaders
+test_files: []