raysetta 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 81bfef72146fa74b652618060ed392bcba82b47d4abe0b5f614b562ce5990eea
+  data.tar.gz: a79b00b4f6eee82d6b2820abbeab125c88af5cef8f3b605ec8af77b9afacd31e
+SHA512:
+  metadata.gz: 62136d552f0fc48578c1f0e6079ed9b9ee5f1b57ee3dda05834f63fee7d91d6adbf2f0981795bb53d42bc371fa3b9b8445a39b5de14c168539f93fb2dff0ef27
+  data.tar.gz: a62389f792764154a40c43529229f319da34f4a0545d59d12839efcfaf17b130660f1f93df5823e94148ae67f91611ef335a40fbaced0f61e610b6ea2816efdc

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Danielle Smith
+
+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,72 @@
+# Raysetta Ruby
+
+A raytracer written in Ruby. Part of the Raysetta project. Based on [Ray Tracing in One Weekend](https://raytracing.github.io/).
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add raysetta
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install raysetta
+
+## Usage
+
+### CLI
+
+```
+$ raysetta scene.json --width 800 --height 600 --samples 50 --depth 100 --format ppm -o output.ppm
+```
+
+### Gem
+
+#### Raytracer
+
+```ruby
+require "raysetta"
+
+scene = Raysetta::Scene.parse(File.read("scene.json"))
+tracer = Raysetta::Tracer.new(scene, width: 800, height: 600, samples_per_pixel: 50, max_depth: 100)
+
+output = Array.new(tracer.height) { Array.new(tracer.width) { [0, 0, 0] } }
+output.each.with_index do |row, i|
+  row.each.with_index do |pixel, j|
+    r, g, b = tracer.call(j, i)
+
+    pixel[0] = r
+    pixel[1] = g
+    pixel[2] = b
+  end
+end
+
+# store output as an image
+```
+
+#### Runner
+
+```ruby
+require "raysetta/runner"
+
+scene = Raysetta::Scene.parse(File.read("scene.json"))
+tracer = Raysetta::Tracer.new(scene, width: 800, height: 600, samples_per_pixel: 50, max_depth: 100)
+runner = Raysetta::Runner::Sync.new(tracer)
+runner.call
+out = Raysetta::Output::PPM.new(runner.output, width: tracer.width, height: tracer.height)
+out.save("output.ppm")
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/danini-the-panini/raysetta-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+task default: :test

data/Steepfile

@@ -0,0 +1,15 @@
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+
+  check "lib"
+
+  configure_code_diagnostics(D::Ruby.strict)
+end
+
+# target :test do
+#   signature "sig", "sig-private"
+
+#   check "test"
+# end

data/exe/raysetta

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require "raysetta/exe"

data/lib/raysetta/aabb.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative './interval'
+
+module Raysetta
+  class AABB
+    attr_accessor :x, :y, :z
+
+    # The default AABB is empty, since intervals are empty by default.
+    def initialize(x = Interval.new, y = Interval.new, z = Interval.new)
+      @x = x
+      @y = y
+      @z = z
+      pad_to_minimums
+    end
+
+    # Treat the two points a and b as extrema for the bounding box, so we don't require a
+    # particular minimum/maximum coordinate order.
+    def self.from_points(*points)
+      x = points.map(&:x).minmax #: [Float, Float]
+      y = points.map(&:y).minmax #: [Float, Float]
+      z = points.map(&:z).minmax #: [Float, Float]
+      new(Interval.new(x[0], x[1]), Interval.new(y[0], y[1]), Interval.new(z[0], z[1]))
+    end
+
+    def self.from_aabbs(box0, box1=nil, *rest)
+      return box0 if box1.nil?
+
+      self.from_aabbs(box0 + box1, *rest)
+    end
+
+    def [](n)
+      case n
+      when 0 then x
+      when 1 then y
+      else z
+      end
+    end
+
+    def []=(n, v)
+      case n
+      when 0 then self.x = v
+      when 1 then self.y = v
+      when 2 then self.z = v
+      end
+    end
+
+    def +(other)
+      AABB.new(
+        Interval.from_intervals(x, other.x),
+        Interval.from_intervals(y, other.y),
+        Interval.from_intervals(z, other.z)
+      )
+    end
+
+    def hit(r, ray_t)
+      t = Interval.from_range(ray_t)
+
+      (0...3).each do |axis|
+        ax = self[axis]
+        adinv = 1.0 / r.direction[axis]
+
+        t0 = (ax.min - r.origin[axis]) * adinv
+        t1 = (ax.max - r.origin[axis]) * adinv
+
+        if t0 < t1
+          t.min = t0 if t0 > t.min
+          t.max = t1 if t1 < t.max
+        else
+          t.min = t1 if t1 > t.min
+          t.max = t0 if t0 < t.max
+        end
+
+        return false if t.max <= t.min
+      end
+
+      true
+    end
+
+    # Returns the index of the longest axis of the bounding box.
+    def longest_axis
+      if x.size > y.size
+        x.size > z.size ? 0 : 2
+      else
+        y.size > z.size ? 1 : 2
+      end
+    end
+
+    def dup
+      AABB.new(x.dup, y.dup, z.dup)
+    end
+
+    def ==(box)
+      x == box.x && y == box.y && z == box.z
+    end
+    alias :eql? :==
+
+    def hash
+      [x, y, z].hash
+    end
+
+    private
+
+      # Adjust the AABB so that no side is narrower than some delta, padding if necessary.
+      def pad_to_minimums
+        delta = 0.0001
+        x.expand!(delta) if x.size < delta
+        y.expand!(delta) if y.size < delta
+        z.expand!(delta) if z.size < delta
+      end
+
+    EMPTY = new(Interval::EMPTY, Interval::EMPTY, Interval::EMPTY)
+    UNIVERSE = new(Interval::UNIVERSE, Interval::UNIVERSE, Interval::UNIVERSE)
+
+  end
+end

data/lib/raysetta/background/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Background
+    class Base < EntityBase
+      def sample(r)
+        raise NotImplementedError, "Implement #{self.class.name}#sample"
+      end
+
+      def textures
+        []
+      end
+
+      def images
+        []
+      end
+    end
+  end
+end

data/lib/raysetta/background/cube_map.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Background
+    class CubeMap < Base
+      attr_accessor :textures
+
+      def initialize(*textures)
+        @textures = textures
+      end
+
+      def sample(r)
+        v = r.direction
+        v_abs = v.abs
+        if(v_abs.z >= v_abs.x && v_abs.z >= v_abs.y)
+          # front/back
+          face_index = v.z < 0.0 ? 5 : 4
+          ma = 0.5 / v_abs.z
+          uv = Vec2.new(v.z < 0.0 ? -v.x : v.x, v.y)
+        elsif(v_abs.y >= v_abs.x)
+          # top/bottom
+          face_index = v.y < 0.0 ? 3 : 2
+          ma = 0.5 / v_abs.y
+          uv = Vec2.new(v.x, v.y < 0.0 ? v.z : -v.z)
+        else
+          # left/right
+          face_index = v.x < 0.0 ? 1 : 0
+          ma = 0.5 / v_abs.x
+          uv = Vec2.new(v.x < 0.0 ? v.z : -v.z, v.y)
+        end
+
+        uv = uv * ma + Vec2.new(0.5, 0.5)
+        textures[face_index].sample(uv, v.unit)
+      end
+
+      def export
+        {
+          **super,
+          textures: textures.map(&:id)
+        }
+      end
+    end
+  end
+end

data/lib/raysetta/background/gradient.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Background
+    class Gradient < Base
+      attr_accessor :top, :bottom
+
+      def initialize(top, bottom)
+        @top = top
+        @bottom = bottom
+      end
+
+      def sample(r)
+        unit_direction = r.direction.unit
+        a = 0.5 * (unit_direction.y + 1.0)
+        bottom * (1.0 - a) + top * a
+      end
+
+      def export
+        {
+          **super,
+          top: top.to_a,
+          bottom: bottom.to_a
+        }
+      end
+    end
+  end
+end

data/lib/raysetta/background/solid.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Background
+    class Solid < Base
+      attr_accessor :albedo
+
+      def initialize(albedo)
+        @albedo = albedo
+      end
+
+      def sample(r)
+        albedo
+      end
+
+      def export
+        {
+          **super,
+          albedo: albedo.to_a
+        }
+      end
+    end
+  end
+end

data/lib/raysetta/background/sphere_map.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Background
+    class SphereMap < Base
+      attr_accessor :texture
+
+      def initialize(texture)
+        @texture = texture
+      end
+
+      def sample(r)
+        unit_direction = r.direction.unit
+        uv = Util.sphere_uv(unit_direction)
+        texture.sample(uv, unit_direction)
+      end
+
+      def textures
+        [texture]
+      end
+
+      def export
+        {
+          **super,
+          texture: texture.id
+        }
+      end
+    end
+  end
+end

data/lib/raysetta/camera.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Camera
+    attr_reader \
+      :vfov,     # Vertical view angle (field of view)
+      :lookfrom, # Point camera is looking from
+      :lookat,   # Point camera is looking at
+      :vup,      # Camera-relative "up" direction
+
+      :defocus_angle, # Variation angle of rays through each pixel
+      :focus_dist     # Distance from camera lookfrom point to plane of perfect focus
+
+    def initialize(
+      vfov: 90.0,
+      lookfrom: Vec3.new(0.0, 0.0, 0.0),
+      lookat: Vec3.new(0.0, 0.0, -1.0),
+      vup: Vec3.new(0.0, 1.0, 0.0),
+      defocus_angle: 0.0,
+      focus_dist: 10.0
+    )
+      @vfov = vfov
+      @lookfrom = lookfrom
+      @lookat = lookat
+      @vup = vup
+      @defocus_angle = defocus_angle
+      @focus_dist = focus_dist
+    end
+
+    def viewport(image_width, image_height)
+      @image_height = image_height
+      aspect_ratio = image_width.to_f / image_height.to_f
+
+      @center = lookfrom
+
+      # Determine viewport dimensions.
+      theta = Util.degrees_to_radians(vfov)
+      h = Math.tan(theta / 2.0)
+      viewport_height = 2.0 * h * focus_dist
+      viewport_width = viewport_height * aspect_ratio
+
+      # Calculate the u,v,w unit basis vectors for the camera coordinate frame.
+      @w = (lookfrom - lookat).normalize
+      @u = vup.cross(w).normalize
+      @v = w.cross(u)
+
+      # Calculate the vectors across the horizontal and down the vertical viewport edges.
+      viewport_u = u * viewport_width   # Vector across viewport horizontal edge
+      viewport_v = -v * viewport_height # Vector down viewport vertical edge
+
+      # Calculate the horizontal and vertical delta vectors from pixel to pixel.
+      @pixel_delta_u = viewport_u / image_width.to_f
+      @pixel_delta_v = viewport_v / image_height.to_f
+
+      # Calculate the location of the upper left pixel.
+      viewport_upper_left =
+          center - (w*focus_dist) - viewport_u.div(2.0) - viewport_v.div(2.0)
+      @pixel00_loc = viewport_upper_left.add((pixel_delta_u + pixel_delta_v).mul(0.5))
+
+      # Calculate the camera defocus disk basis vectors.
+      defocus_radius = focus_dist * Math.tan(Util.degrees_to_radians(defocus_angle / 2.0))
+      @defocus_disk_u = u * defocus_radius
+      @defocus_disk_v = v * defocus_radius
+    end
+
+    # Construct a camera ray originating from the defocus disk and directed at a randomly
+    # sampled point around the pixel location x, y.
+    def ray(x, y)
+      offset = Vec2.sample_square
+      pixel_sample = pixel00_loc +
+                        (pixel_delta_u * (x + offset.x)) +
+                        (pixel_delta_v * (y + offset.y))
+
+      ray_origin = defocus_angle <= 0 ? center : defocus_disk_sample
+      ray_direction = pixel_sample - ray_origin
+      ray_time = rand
+
+      Ray.new(ray_origin, ray_direction, ray_time)
+    end
+
+    def export
+      {
+        vfov: vfov,
+        lookfrom: lookfrom.to_a,
+        lookat: lookat.to_a,
+        vup: vup.to_a,
+        defocus_angle: defocus_angle,
+        focus_dist: focus_dist
+      }
+    end
+
+    private
+      attr_reader \
+        :image_height,   # Rendered image height
+        :center,         # Camera center
+        :pixel00_loc,    # Location of pixel 0, 0
+        :pixel_delta_u,  # Offset to pixel to the right
+        :pixel_delta_v,  # Offset to pixel below
+        :u, :v, :w,      # Camera frame basis vectors
+        :defocus_disk_u, # Defocus disk horizontal radius
+        :defocus_disk_v  # Defocus disk vertical radius
+
+      # Returns a random point in the camera defocus disk.
+      def defocus_disk_sample
+        v = Vec3.random_in_unit_disk
+        center + (defocus_disk_u * v.x) + (defocus_disk_v * v.y)
+      end
+  end
+end

data/lib/raysetta/entity_base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class EntityBase
+    def id
+      "#{type.downcase}-#{object_id.to_s(16)}"
+    end
+
+    def type
+      self.class.name.split('::').last
+    end
+
+    def ==(other)
+      other.class == self.class && id == other.id
+    end
+    alias :eql? :==
+
+    def hash
+      id.hash
+    end
+
+    def export
+      {
+        type: type
+      }
+    end
+  end
+end

data/lib/raysetta/exe.rb

@@ -0,0 +1,75 @@
+require 'optparse'
+require 'etc'
+
+format_opt = :ppm
+runner_opt = :sync
+concurrency_opt = nil
+output_path = nil
+options = {} #: Hash[Symbol, untyped]
+opts_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: raysetta FILE [options]"
+
+  opts.on("-w", "--width WIDTH", Integer, "Image width (default 256)") do |w|
+    options[:width] = w
+  end
+  opts.on("-h", "--height HEIGHT", Integer, "Image height (default 256)") do |h|
+    options[:height] = h
+  end
+  opts.on("-s", "--samples SAMPLES", Integer, "Samples per pixel (default 10)") do |s|
+    options[:samples_per_pixel] = s
+  end
+  opts.on("-d", "--depth DEPTH", Integer, "Max depth (default 10)") do |d|
+    options[:max_depth] = d
+  end
+
+  opts.on("-f", "--format FORMAT", %i[ppm png], "Output format (ppm, png; default ppm)") do |f|
+    format_opt = f
+  end
+  opts.on("-r", "--runner RUNNER", %i[sync threads ractors processes], "Runner (sync, threads, ractors, processes; default sync)") do |r|
+    runner_opt = r
+  end
+  opts.on("-c", "--concurrency CONCURRENCY", Integer, "Concurrency (threads and ractor only; default 4)") do |c|
+    concurrency_opt = c
+  end
+  opts.on("-o", "--output FILE", "Output file (default STDOUT)") do |o|
+    output_path = o
+  end
+
+  opts.on_tail("--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    puts Raysetta::VERSION
+    exit
+  end
+end
+opts_parser.parse!
+
+require "raysetta"
+require "raysetta/runner"
+
+if ARGV.size < 1
+  warn "*** Missing FILE_OR_URL argument ***"
+  puts opts_parser
+  exit
+end
+
+file_or_url = ARGV.first
+
+warn "WARN: Ignoring concurrency argument" if concurrency_opt && runner_opt == :sync
+concurrency = concurrency_opt || Etc.nprocessors
+
+if output_path.nil? && format_opt == :png
+  warn "*** Refusing to output PNG to STDOUT ***"
+  exit
+end
+
+Raysetta::Runner.parse_scene(file_or_url,
+  output_path:,
+  runner: runner_opt,
+  format: format_opt,
+  concurrency:,
+  **options
+)

data/lib/raysetta/hit.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Hit
+    attr_accessor :point, :normal, :t, :material, :uv
+    attr_writer :front_face
+
+    def initialize(
+      t:,
+      normal:,
+      material:,
+      r:,
+      point:,
+      uv: Vec2.new
+    )
+      @point = point
+      @t = t
+      @material = material
+      @uv = uv
+      @normal = normal
+      @front_face = true
+
+      set_face_normal(r) if r
+    end
+
+    def front_face? = @front_face
+
+    private
+
+      # Sets the hit's normal vector.
+      # NOTE: `@normal` is assumed to have unit length.
+      def set_face_normal(r)
+        @front_face = r.direction.dot(@normal) < 0
+        @normal = @front_face ? @normal : -@normal
+      end
+
+  end
+end

data/lib/raysetta/image.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'chunky_png'
+
+module Raysetta
+  class Image < EntityBase
+    attr_reader :image
+
+    def initialize(path: nil, data_url: nil)
+      @image = if path
+        ChunkyPNG::Image.from_file(path)
+      elsif data_url
+        ChunkyPNG::Image.from_data_url(data_url)
+      else
+        raise ArgumentError, "missing path or data_url"
+      end
+    end
+  
+    def width = image.width
+    def height = image.height
+
+    def [](x, y)
+      pixel = image.get_pixel(x.clamp(0, width-1), y.clamp(0, height-1))
+      Vec3.new(ChunkyPNG::Color.r(pixel)/255.0, ChunkyPNG::Color.g(pixel)/255.0, ChunkyPNG::Color.b(pixel)/255.0).tap do |c|
+        c.r = Util.gamma_to_linear(c.r)
+        c.g = Util.gamma_to_linear(c.g)
+        c.b = Util.gamma_to_linear(c.b)
+      end
+    end
+
+    def ==(img)
+      image == img.image
+    end
+
+    def hash
+      [type, image].hash
+    end
+
+    def export
+      {
+        **super,
+        data: image.to_data_url
+      }
+    end
+  end
+end