gesso 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8870e15d24fbbc45d4f17e9f9311b6b16927857d1bbe95b557e8a2225080d86e
+  data.tar.gz: 0f1c0ae36c4a67a1556a5963fd567254949522159f49f0e340fcd09392108d39
+SHA512:
+  metadata.gz: f9db6ac499d2c5c5240742ff29b371a18bbbe3f6183af2cc2d8f95aa58f1d42d7c7d949d48806058820216a39ff80d06f70bc1ebdb39138218d23ba92cfe5152
+  data.tar.gz: e88716ed0d0d65e048abde230c90cfdffd25c6c16583a8ca8ccb7336a6a8fe30ac08ef9fe8cf2ecc26c68444d9f3e709c91d3c0ad812a2eedcc46af7071d60fd

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,94 @@
+# Gesso
+
+[![Gem version](https://badge.fury.io/rb/gesso.svg)](https://rubygems.org/gems/gesso)
+[![Downloads](https://img.shields.io/gem/dt/gesso?label=downloads)](https://rubygems.org/gems/gesso)
+[![CI](https://github.com/rbgfx/gesso/actions/workflows/ci.yml/badge.svg)](https://github.com/rbgfx/gesso/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)
+
+> Processing-style 2D drawing for Ruby, backed by Tessel and rbgl.
+
+Gesso is a small creative coding DSL for sketches that can run in an rbgl
+window or render deterministic PNG frames without a window.
+
+**[Features](#features) · [Installation](#installation) · [Quick start](#quick-start) · [CLI](#cli) · [Development](#development)**
+
+## Features
+
+- Immediate-mode setup and draw callbacks.
+- Lines, shapes, images, transforms, text, and configurable stroke styles.
+- RGB and HSB color modes with corner, center, and radius shape modes.
+- Seeded random values and deterministic smooth noise.
+- Optional rlsl shader backgrounds and Twiddle control panels.
+- Interactive windows and headless frame rendering.
+
+## Installation
+
+Add Gesso to your Gemfile:
+
+~~~ruby
+gem "gesso"
+~~~
+
+Then run:
+
+~~~sh
+bundle install
+~~~
+
+Or install the released gem:
+
+~~~sh
+gem install gesso
+~~~
+
+## Quick start
+
+~~~ruby
+require "gesso"
+
+sketch = Gesso.run(width: 320, height: 200) do
+  setup { background 16, 24, 39 }
+
+  draw do
+    fill 240, 120, 80
+    circle width / 2, height / 2, 30
+  end
+end
+
+sketch.canvas.write("shot.png")
+~~~
+
+For a top-level sketch file, load the automatic DSL:
+
+~~~ruby
+require "gesso/auto"
+
+size 320, 200
+draw do
+  background "#101827"
+  fill "#f07850"
+  circle 160, 100, 30
+end
+~~~
+
+## CLI
+
+~~~sh
+gesso run examples/bubbles.rb
+gesso render examples/bubbles.rb --frames 3 -o frames
+~~~
+
+Use <code>--backend file</code> for a headless window run. The
+<code>examples/gui_sketch.rb</code> example shows the optional Twiddle panel.
+
+## 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../glyphic/lib -I../twiddle/lib -I../rbgl/lib -I../larb/lib -I../rlsl/lib]
+end
+
+task default: :spec
+task verify: :spec

data/examples/bubbles.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+size 64, 48
+setup { background "#101827" }
+draw do
+  background "#101827"
+  no_stroke
+  fill "#f07850"
+  circle(20 + frame_count * 2, 24, 8)
+end

data/examples/gui_sketch.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "gesso/auto"
+
+size 320, 200
+speed = 1.0
+
+draw do
+  background "#101827"
+  fill "#f07850"
+  circle 160 + Math.sin(frame_count * 0.05 * speed) * 80, 100, 24
+end
+
+gui do |ui|
+  ui.window("Controls") do
+    speed = ui.slider("Speed", speed, 0.0..4.0)
+  end
+end

data/exe/gesso

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "fileutils"
+require "gesso/auto"
+
+command = ARGV.shift
+case command
+when "render"
+  path = ARGV.shift
+  frames = 1
+  output = "out"
+  OptionParser.new do |opts|
+    opts.on("--frames N", Integer) { |value| frames = value }
+    opts.on("-o DIR") { |value| output = value }
+  end.parse!(ARGV)
+  load path
+  Gesso::Auto.sync!
+  FileUtils.mkdir_p(output)
+  sketch = Gesso::Auto.sketch
+  frames.times { |index| sketch.frame.write(File.join(output, format("frame_%05d.png", index))) }
+when "run"
+  path = ARGV.shift
+  backend = :auto
+  frames = nil
+  output_dir = "."
+  OptionParser.new do |opts|
+    opts.on("--backend NAME") { |value| backend = value.to_sym }
+    opts.on("--frames N", Integer) { |value| frames = value }
+    opts.on("-o DIR") { |value| output_dir = value }
+  end.parse!(ARGV)
+  load path
+  Gesso::Auto.sync!
+  Gesso::Runner::Window.run(Gesso::Auto.sketch, backend: backend, frames: frames, output_dir: output_dir)
+else
+  warn "usage: gesso render FILE [--frames N] [-o DIR] | run FILE [--backend NAME]"
+  exit 1
+end

data/lib/gesso/auto.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../gesso"
+
+module Gesso
+  module Auto
+    @sketch = Sketch.new
+    class << self
+      attr_reader :sketch
+
+      def sync!
+        target = TOPLEVEL_BINDING.eval("self")
+        %i[setup draw].each do |name|
+          next unless @sketch.instance_variable_get(:"@#{name}_block").nil?
+
+          method = target.method(name)
+          next if method.owner == Gesso::Auto
+
+          @sketch.public_send(name) { target.__send__(name) }
+        rescue NameError
+          nil
+        end
+        @sketch
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      sketch = Gesso::Auto.sketch
+      return super unless sketch.respond_to?(name)
+      sketch.public_send(name, *args, &block)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      Gesso::Auto.sketch.respond_to?(name) || super
+    end
+  end
+end
+
+TOPLEVEL_BINDING.eval("self").extend(Gesso::Auto)

data/lib/gesso/version.rb

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

data/lib/gesso.rb

@@ -0,0 +1,490 @@
+# frozen_string_literal: true
+
+require "tessel"
+
+require_relative "gesso/version"
+
+module Gesso
+  class Error < StandardError; end
+
+  class Sketch
+    attr_reader :canvas, :width, :height, :frame_count, :mouse_x, :mouse_y, :key
+
+    def initialize(width: 640, height: 480, seed: Random.new_seed)
+      @width = width
+      @height = height
+      @canvas = Tessel::Image.new(width, height)
+      @random = Random.new(seed)
+      @noise_seed = seed
+      @frame_count = 0
+      @mouse_x = @mouse_y = 0
+      @pmouse_x = @pmouse_y = 0
+      @pressed = false
+      @fill = Tessel::Color.pack([255, 255, 255, 255])
+      @stroke = Tessel::Color.pack([0, 0, 0, 255])
+      @color_mode = :rgb
+      @color_ranges = [255.0, 255.0, 255.0, 255.0]
+      @rect_mode = :corner
+      @ellipse_mode = :corner
+      @fill_enabled = true
+      @stroke_enabled = true
+      @stroke_weight = 1
+      @stroke_cap = :round
+      @stroke_join = :round
+      @text_align = [:left, :top]
+      @matrix = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+      @matrices = []
+      @draw_block = nil
+      @setup_block = nil
+      @setup_ran = false
+      @handlers = Hash.new { |hash, key| hash[key] = [] }
+      @ui_events = []
+      @shader_cache = {}
+    end
+
+    def size(width, height)
+      width = Integer(width)
+      height = Integer(height)
+      raise ArgumentError, "size must be positive" unless width.positive? && height.positive?
+      @width, @height = width, height
+      @canvas = Tessel::Image.new(width, height)
+    end
+
+    def setup(&block) = (@setup_block = block)
+    def draw(&block) = (@draw_block = block)
+    def gui(&block) = (@gui_block = block)
+
+    def prepare!
+      return self if @setup_ran
+
+      @setup_ran = true
+      @setup_block&.call
+      self
+    end
+    def shader_background(name = nil, &block)
+      raise ArgumentError, "shader_background requires a block" unless block
+
+      require "rlsl"
+      key = name || block.source_location
+      shader = (@shader_cache[key] ||= begin
+        builder = RLSL::ShaderBuilder.new(:"gesso_#{@shader_cache.length}")
+        builder.uniforms { float :time; vec4 :mouse }
+        builder.fragment(&block)
+        builder.compile_and_load
+      end)
+      buffer = "\0".b * (@width * @height * 4)
+      shader.render(buffer, @width, @height, time: millis / 1000.0, mouse: [@mouse_x.to_f, (@height - @mouse_y).to_f, 0.0, 0.0])
+      rgba = buffer.bytes.each_slice(4).flat_map { |blue, green, red, alpha| [red, green, blue, alpha] }.pack("C*")
+      @canvas = Tessel::Image.from_rgba(@width, @height, rgba)
+    end
+    def key_pressed(&block) = @handlers[:key_pressed] << block
+    def key_released(&block) = @handlers[:key_released] << block
+    def mouse_pressed(&block) = @handlers[:mouse_pressed] << block
+    def mouse_released(&block) = @handlers[:mouse_released] << block
+    def mouse_moved(&block) = @handlers[:mouse_moved] << block
+    def mouse_dragged(&block) = @handlers[:mouse_dragged] << block
+
+    def frame
+      prepare!
+      @draw_block&.call
+      if @gui_block
+        require "twiddle"
+        require "glyphic"
+        @ui ||= Twiddle::Context.new(font: Glyphic.default)
+        @ui.frame(events: @ui_events) { |context| @gui_block.call(context) }
+        @ui.render(@canvas)
+        @ui_events.clear
+      end
+      @frame_count += 1
+      @canvas
+    end
+
+    def handle(event)
+      @ui_events << event if @gui_block
+      case event[:type]&.to_sym
+      when :mouse_move
+        @pmouse_x, @pmouse_y, @mouse_x, @mouse_y = @mouse_x, @mouse_y, event[:x], event[:y]
+        @handlers[:mouse_moved].each(&:call)
+        @handlers[:mouse_dragged].each(&:call) if @pressed
+      when :mouse_press then @pressed = true; @handlers[:mouse_pressed].each(&:call)
+      when :mouse_release then @pressed = false; @handlers[:mouse_released].each(&:call)
+      when :key_press then @key = event[:key]; @handlers[:key_pressed].each(&:call)
+      when :key_release then @key = event[:key]; @handlers[:key_released].each(&:call)
+      end
+    end
+
+    def background(*args)
+      @canvas.clear(color(*args))
+    end
+
+    def color_mode(mode = :rgb, max1 = 255, max2 = max1, max3 = max1, max_alpha = 255)
+      mode = mode.to_sym
+      raise ArgumentError, "color mode must be :rgb or :hsb" unless %i[rgb hsb].include?(mode)
+      ranges = [max1, max2, max3, max_alpha].map(&:to_f)
+      raise ArgumentError, "color ranges must be positive" unless ranges.all?(&:positive?)
+      @color_mode = mode
+      @color_ranges = ranges
+    end
+
+    def fill(*args) = (@fill_enabled = true; @fill = color(*args))
+    def no_fill = (@fill_enabled = false)
+    def stroke(*args) = (@stroke_enabled = true; @stroke = color(*args))
+    def no_stroke = (@stroke_enabled = false)
+    def stroke_weight(value) = (@stroke_weight = [value.to_f, 1].max)
+    def stroke_cap(mode)
+      mode = mode.to_sym
+      raise ArgumentError, "stroke cap must be :round or :square" unless %i[round square].include?(mode)
+      @stroke_cap = mode
+    end
+    def stroke_join(mode)
+      mode = mode.to_sym
+      raise ArgumentError, "stroke join must be :round or :square" unless %i[round square].include?(mode)
+      @stroke_join = mode
+    end
+    def mouse_pressed? = @pressed
+    def pmouse_x = @pmouse_x
+    def pmouse_y = @pmouse_y
+    def frame_rate(value = nil)
+      return (@frame_rate || 60.0) unless value
+      value = value.to_f
+      raise ArgumentError, "frame rate must be positive" unless value.positive?
+      @frame_rate = value
+    end
+    def millis = (@frame_count * 1000.0 / frame_rate).round
+
+    def point(x, y)
+      draw_line(x, y, x, y, @stroke) if @stroke_enabled
+    end
+
+    def line(x1, y1, x2, y2)
+      draw_line(x1, y1, x2, y2, @stroke) if @stroke_enabled
+    end
+
+    def rect(x, y, width, height)
+      x, y = x - width / 2.0, y - height / 2.0 if @rect_mode == :center
+      polygon([[x, y], [x + width, y], [x + width, y + height], [x, y + height]])
+    end
+
+    def rect_mode(mode)
+      mode = mode.to_sym
+      raise ArgumentError, "rect mode must be :corner or :center" unless %i[corner center].include?(mode)
+      @rect_mode = mode
+    end
+
+    def square(x, y, size) = rect(x, y, size, size)
+
+    def ellipse(x, y, width, height)
+      case @ellipse_mode
+      when :center then x, y = x - width / 2.0, y - height / 2.0
+      when :radius then width, height = width * 2.0, height * 2.0; x, y = x - width / 2.0, y - height / 2.0
+      end
+      cx = x + width / 2.0
+      cy = y + height / 2.0
+      rx = width / 2.0
+      ry = height / 2.0
+      return if rx <= 0 || ry <= 0
+      unless @matrix == [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+        count = [((2 * Math::PI * [rx, ry].max) / 2).ceil, 16].max
+        return polygon(count.times.map { |index| angle = index * 2 * Math::PI / count; [cx + Math.cos(angle) * rx, cy + Math.sin(angle) * ry] })
+      end
+      ([(y).floor, 0].max..[(y + height).ceil, @height - 1].min).each do |row|
+        dy = (row + 0.5 - cy) / ry
+        next if dy.abs > 1
+        half = (rx * Math.sqrt(1 - dy * dy)).floor
+        @canvas.hspan((cx - half).floor, (cx + half).floor, row, @fill, blend: @fill.getbyte(3) == 255 ? :copy : :alpha) if @fill_enabled
+      end
+      ellipse_outline(cx, cy, rx, ry) if @stroke_enabled
+    end
+
+    def circle(x, y, radius)
+      case @ellipse_mode
+      when :corner then ellipse(x - radius, y - radius, radius * 2, radius * 2)
+      when :center then ellipse(x, y, radius * 2, radius * 2)
+      when :radius then ellipse(x, y, radius, radius)
+      end
+    end
+
+    def ellipse_mode(mode)
+      mode = mode.to_sym
+      raise ArgumentError, "ellipse mode must be :corner, :center, or :radius" unless %i[corner center radius].include?(mode)
+      @ellipse_mode = mode
+    end
+
+    def triangle(*points) = polygon(points.each_slice(2).to_a)
+    def quad(*points) = polygon(points.each_slice(2).to_a)
+
+    def begin_shape
+      @shape = []
+    end
+
+    def vertex(x, y)
+      @shape << [x, y]
+    end
+
+    def end_shape(close: true)
+      points = @shape
+      if close
+        polygon(points)
+      elsif @stroke_enabled
+        points.each_cons(2) { |first, second| draw_line(*first, *second, @stroke) }
+      end
+      @shape = nil
+    end
+
+    def arc(x, y, width, height, start_angle, stop_angle)
+      count = [(stop_angle - start_angle).abs * [width, height].max / 4, 8].max.to_i
+      points = (0..count).map do |index|
+        angle = start_angle + (stop_angle - start_angle) * index / count
+        [x + Math.cos(angle) * width / 2, y + Math.sin(angle) * height / 2]
+      end
+      polygon(points)
+    end
+
+    def push = @matrices << @matrix.dup
+    def pop
+      raise RuntimeError, "transform stack is empty" if @matrices.empty?
+      @matrix = @matrices.pop
+    end
+    def reset_matrix = (@matrix = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0])
+    def translate(x, y) = multiply_matrix([1, 0, 0, 1, x, y])
+    def scale(x, y = x) = multiply_matrix([x, 0, 0, y, 0, 0])
+    def rotate(angle) = multiply_matrix([Math.cos(angle), Math.sin(angle), -Math.sin(angle), Math.cos(angle), 0, 0])
+
+    def random_seed(seed) = (@random = Random.new(seed))
+    def random(maximum = 1, maximum2 = nil) = maximum2 ? @random.rand(maximum.to_f...maximum2.to_f) : @random.rand(maximum.to_f)
+    def noise_seed(seed) = (@noise_seed = Integer(seed))
+    def noise(x, y = 0, z = 0)
+      coordinates = [x, y, z].map(&:to_f)
+      base = coordinates.map(&:floor)
+      fraction = coordinates.each_with_index.map { |value, index| smooth(value - base[index]) }
+      layers = [0, 1].product([0, 1], [0, 1]).map do |offsets|
+        noise_value(*base.zip(offsets).map { |value, offset| value + offset })
+      end
+      x0 = interpolate(layers[0], layers[4], fraction[0])
+      x1 = interpolate(layers[1], layers[5], fraction[0])
+      x2 = interpolate(layers[2], layers[6], fraction[0])
+      x3 = interpolate(layers[3], layers[7], fraction[0])
+      y0 = interpolate(x0, x2, fraction[1])
+      y1 = interpolate(x1, x3, fraction[1])
+      interpolate(y0, y1, fraction[2])
+    end
+    def map(value, start1, stop1, start2, stop2) = start2 + (value - start1).to_f / (stop1 - start1) * (stop2 - start2)
+    def lerp(start, stop, amount) = start + (stop - start) * amount
+    def constrain(value, minimum, maximum) = [[value, minimum].max, maximum].min
+    def dist(x1, y1, x2, y2) = Math.hypot(x2 - x1, y2 - y1)
+    def degrees(radians) = radians * 180 / Math::PI
+    def radians(degrees) = degrees * Math::PI / 180
+
+    def image(source, x, y, width = nil, height = nil)
+      source = source.scale_nearest(width, height) if width && height
+      @canvas.blit(source, x, y, blend: :alpha)
+    end
+
+    def load_image(path) = Tessel.read(path)
+    def save(path) = @canvas.write(path)
+    def get(x, y) = @canvas[x, y]
+    def set(x, y, value) = @canvas[x, y] = value
+
+    def text(value, x, y, color: @fill)
+      require "glyphic"
+      font = @font || Glyphic.default
+      value = value.to_s
+      scale = @font_size ? @font_size.to_f / font.line_height : 1.0
+      if scale == 1.0 && @text_align == [:left, :top]
+        font.draw(@canvas, x, y, value, color: color)
+        return
+      end
+      image = font.render(value, color: color)
+      image = image.scale_nearest([(image.width * scale).round, 1].max, [(image.height * scale).round, 1].max) if scale != 1.0
+      draw_x = x - (@text_align[0] == :center ? image.width / 2.0 : @text_align[0] == :right ? image.width : 0)
+      draw_y = case @text_align[1]
+      when :center then y - image.height / 2.0
+      when :bottom then y - image.height
+      when :baseline then y - (@font || Glyphic.default).ascent * scale
+      else y
+      end
+      @canvas.blit(image, draw_x.round, draw_y.round, blend: :alpha)
+    end
+    def text_font(path, size: nil)
+      require "glyphic"
+      @font_size = size.to_f if size
+      @font = Glyphic.load(path, size: size || 16)
+    end
+    def text_align(horizontal = :left, vertical = :top)
+      horizontal = horizontal.to_sym
+      vertical = vertical.to_sym
+      raise ArgumentError, "text horizontal alignment must be :left, :center, or :right" unless %i[left center right].include?(horizontal)
+      raise ArgumentError, "text vertical alignment must be :top, :center, :bottom, or :baseline" unless %i[top center bottom baseline].include?(vertical)
+      @text_align = [horizontal, vertical]
+    end
+    def text_size(size)
+      size = Float(size)
+      raise ArgumentError, "text size must be positive" unless size.positive?
+      @font_size = size
+    end
+    def text_width(value)
+      require "glyphic"
+      font = @font || Glyphic.default
+      width = font.text_width(value.to_s)
+      @font_size ? (width * @font_size / font.line_height).round : width
+    end
+
+    private
+
+    def color(*args)
+      args = args.first if args.length == 1 && args.first.is_a?(Array)
+      return Tessel::Color.pack(args) if args.is_a?(String)
+      args = [args] if args.is_a?(Numeric)
+      args = Array(args)
+      return Tessel::Color.pack(args.first) if args.length == 1 && args.first.is_a?(String)
+      raise ArgumentError, "color needs 1 to 4 channels" unless (1..4).cover?(args.length)
+      alpha = args.length == 2 ? args[1] : (args.length == 4 ? args.pop : @color_ranges[3])
+      channels = args.length <= 2 ? [args[0]] * 3 : args
+      channels = if @color_mode == :hsb
+        hsb_to_rgb(channels).map { |value| (value * 255.0).round }
+      else
+        channels.each_with_index.map { |value, index| scale_color(value, @color_ranges[index]) }
+      end
+      channels << scale_color(alpha, @color_ranges[3])
+      Tessel::Color.pack(channels)
+    end
+
+    def multiply_matrix(other)
+      a, b, c, d, e, f = @matrix
+      oa, ob, oc, od, oe, of = other
+      @matrix = [a * oa + c * ob, b * oa + d * ob, a * oc + c * od, b * oc + d * od, a * oe + c * of + e, b * oe + d * of + f]
+    end
+
+    def smooth(value) = value * value * (3 - 2 * value)
+
+    def interpolate(first, second, amount) = first + (second - first) * amount
+
+    def noise_value(x, y, z)
+      value = Math.sin(x * 12.9898 + y * 78.233 + z * 37.719 + @noise_seed * 0.12345) * 43_758.5453
+      value - value.floor
+    end
+
+    def scale_color(value, maximum)
+      [[Float(value) / maximum * 255.0, 0.0].max, 255.0].min.round
+    end
+
+    def hsb_to_rgb(channels)
+      hue, saturation, brightness = channels.map.with_index { |value, index| Float(value) / @color_ranges[index] }
+      saturation = [[saturation, 0.0].max, 1.0].min
+      brightness = [[brightness, 0.0].max, 1.0].min
+      return [brightness, brightness, brightness] if saturation.zero?
+
+      hue = (hue % 1.0) * 6.0
+      sector = hue.floor
+      fraction = hue - sector
+      low = brightness * (1.0 - saturation)
+      down = brightness * (1.0 - saturation * fraction)
+      up = brightness * (1.0 - saturation * (1.0 - fraction))
+      case sector
+      when 0 then [brightness, up, low]
+      when 1 then [down, brightness, low]
+      when 2 then [low, brightness, up]
+      when 3 then [low, down, brightness]
+      when 4 then [up, low, brightness]
+      else [brightness, low, down]
+      end
+    end
+
+    def transform(point)
+      a, b, c, d, e, f = @matrix
+      [a * point[0] + c * point[1] + e, b * point[0] + d * point[1] + f]
+    end
+
+    def polygon(points)
+      return if points.length < 3
+      points = points.map { |point| transform(point) }
+      min_y = [[points.map(&:last).min.floor, 0].max, @height - 1].min
+      max_y = [[points.map(&:last).max.ceil, 0].max, @height - 1].min
+      edges = points.each_cons(2).to_a + [[points[-1], points[0]]]
+      (min_y..max_y).each do |y|
+        intersections = edges.filter_map do |first, second|
+          next if first[1] == second[1] || y + 0.5 < [first[1], second[1]].min || y + 0.5 >= [first[1], second[1]].max
+          first[0] + (y + 0.5 - first[1]) * (second[0] - first[0]) / (second[1] - first[1])
+        end.sort
+        intersections.each_slice(2) { |left, right| @canvas.hspan(left.ceil, right.floor - 1, y, @fill, blend: @fill.getbyte(3) == 255 ? :copy : :alpha) if @fill_enabled && right }
+      end
+      edges.each { |first, second| draw_line(*first, *second, @stroke, transformed: true) if @stroke_enabled }
+    end
+
+    def draw_line(x1, y1, x2, y2, color, transformed: false)
+      first = transformed ? [x1, y1] : transform([x1, y1])
+      last = transformed ? [x2, y2] : transform([x2, y2])
+      if @stroke_cap == :square && first != last
+        radius = @stroke_weight / 2.0
+        length = Math.hypot(last[0] - first[0], last[1] - first[1])
+        unit = [(last[0] - first[0]) / length, (last[1] - first[1]) / length]
+        first = [first[0] - unit[0] * radius, first[1] - unit[1] * radius]
+        last = [last[0] + unit[0] * radius, last[1] + unit[1] * radius]
+      end
+      x, y = first.map(&:round)
+      target_x, target_y = last.map(&:round)
+      dx = (target_x - x).abs
+      sx = x < target_x ? 1 : -1
+      dy = -(target_y - y).abs
+      sy = y < target_y ? 1 : -1
+      error = dx + dy
+      loop do
+        if @stroke_weight <= 1
+          @canvas[x, y] = color if x.between?(0, @width - 1) && y.between?(0, @height - 1)
+        else
+          radius = @stroke_weight / 2.0
+          ((y - radius).ceil..(y + radius).floor).each do |row|
+            distance = @stroke_join == :square ? radius : Math.sqrt([radius * radius - (row - y) ** 2, 0].max)
+            @canvas.hspan((x - distance).ceil, (x + distance).floor, row, color, blend: color.getbyte(3) == 255 ? :copy : :alpha)
+          end
+        end
+        break if x == target_x && y == target_y
+        twice = 2 * error
+        if twice >= dy then error += dy; x += sx end
+        if twice <= dx then error += dx; y += sy end
+      end
+    end
+
+    def ellipse_outline(cx, cy, rx, ry)
+      points = 32.times.map { |index| angle = index * 2 * Math::PI / 32; [cx + Math.cos(angle) * rx, cy + Math.sin(angle) * ry] }
+      points.each_cons(2) { |first, second| draw_line(*first, *second, @stroke) }
+      draw_line(*points[-1], *points[0], @stroke)
+    end
+  end
+
+  module Runner
+    class Headless
+      def self.run(sketch, frames: 1)
+        sketch.prepare!
+        Array.new(frames) { sketch.frame.dup }
+      end
+    end
+
+    class Window
+      def self.run(sketch, backend: :auto, frames: nil, output_dir: ".")
+        require "rbgl"
+        sketch.prepare!
+        options = backend.to_sym == :file ? { format: :ppm, max_frames: frames || 1, output_dir: output_dir } : {}
+        window = RBGL::GUI::Window.new(width: sketch.width, height: sketch.height, title: "gesso", backend: backend, **options)
+        until window.should_close?
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          Array(window.poll_events_raw).each { |event| sketch.handle(event) }
+          window.set_pixels(sketch.frame.bytes)
+          delay = 1.0 / sketch.frame_rate - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)
+          sleep(delay) if delay.positive? && backend.to_sym != :file
+        end
+      ensure
+        window&.close
+      end
+    end
+  end
+
+  module_function
+
+  def run(width: 640, height: 480, seed: Random.new_seed, &block)
+    sketch = Sketch.new(width: width, height: height, seed: seed)
+    sketch.instance_eval(&block)
+    Runner::Headless.run(sketch, frames: 1).first
+    sketch
+  end
+end

data/sig/gesso.rbs

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

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: gesso
+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: glyphic
+  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: 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
+- !ruby/object:Gem::Dependency
+  name: larb
+  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: A small creative coding DSL backed by Tessel RGBA8 images.
+email:
+- t.yudai92@gmail.com
+executables:
+- gesso
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/bubbles.rb
+- examples/gui_sketch.rb
+- exe/gesso
+- lib/gesso.rb
+- lib/gesso/auto.rb
+- lib/gesso/version.rb
+- sig/gesso.rbs
+homepage: https://github.com/rbgfx/gesso
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rbgfx/gesso
+  source_code_uri: https://github.com/rbgfx/gesso/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: Processing style 2D drawing for Ruby
+test_files: []