raysetta 0.1.0

data/lib/raysetta/object/tri.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class Tri < Quad
+      def initialize(a, b, c, material)
+        super(a, b - a, c - a, material)
+        # TODO: uv coordinates
+        # TODO: front face based on clockwizeness of points
+      end
+
+      def export
+        {
+          **super,
+          a: q.to_a,
+          b: (q + u).to_a,
+          c: (q + v).to_a,
+          material: material.id
+        }
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}Triangle { a=#{q}, b=#{q + u}, c=#{q + v} }"
+      end
+
+      private
+
+        def interior?(a, b)
+          # Given the hit point in plane coordinates, return nil if it is outside the
+          # primitive, otherwise return the UV coordinates.
+
+          return unless a > 0.0 && b > 0.0 && a + b < 1.0
+
+          # TODO: uv coordinates
+          Vec2.new(a, b)
+        end
+
+        def compute_bounding_box
+          # Compute the bounding box of all three vertices.
+          @bounding_box = AABB.from_points(q, q + u, q + v);
+        end
+
+    end
+  end
+end

data/lib/raysetta/output/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Output
+    class Base
+      attr_reader :pixels, :width, :height
+
+      def initialize(pixels, width:, height:)
+        @pixels = pixels
+        @width = width
+        @height = height
+      end
+
+      def call
+        raise NotImplementedError, "Implement #{self.class}#call"
+      end
+
+      def save(file)
+        File.write(file, call)
+      end
+    end
+  end
+end

data/lib/raysetta/output/png.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'chunky_png'
+
+module Raysetta
+  module Output
+    class PNG < Base
+      def call
+        image = ChunkyPNG::Image.new(width, height)
+
+        pixels.each.with_index do |row, y|
+          row.each.with_index do |pixel, x|
+            image.set_pixel(x, y, ChunkyPNG::Color.rgb(pixel[0], pixel[1], pixel[2]))
+          end
+        end
+
+        image
+      end
+
+      def save(file)
+        image = call
+        image.save(file, :fast_rgb)
+      end
+    end
+  end
+end

data/lib/raysetta/output/ppm.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Output
+    class PPM < Base
+      def call
+        buffer = "P3\n#{width} #{height}\n255\n"
+
+        pixels.each do |row|
+          row.each do |pixel|
+            buffer << pixel.join(' ') << "\n"
+          end
+        end
+
+        buffer
+      end
+    end
+  end
+end

data/lib/raysetta/perlin.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Perlin < EntityBase
+    POINT_COUNT = 256
+
+    attr_accessor :randvec, :perm_x, :perm_y, :perm_z
+
+    def initialize(
+      randvec = Array.new(POINT_COUNT) { Vec3.random(-1.0, 1.0).normalize },
+      perm_x = (0...POINT_COUNT).to_a.shuffle!,
+      perm_y = (0...POINT_COUNT).to_a.shuffle!,
+      perm_z = (0...POINT_COUNT).to_a.shuffle!
+    )
+      @randvec = randvec
+      @perm_x = perm_x
+      @perm_y = perm_y
+      @perm_z = perm_z
+    end
+
+    def noise(point)
+      ivec = point.to_a.map(&:floor) #: [Integer, Integer, Integer]
+      i = ivec[0]
+      j = ivec[1]
+      k = ivec[2]
+      vec = point - Vec3.new(i.to_f, j.to_f, k.to_f)
+
+      c = Array.new(2) { Array.new(2) { Array.new(2) } }
+
+      CUBE.each do |di, dj, dk|
+        c[di][dj][dk] = @randvec[
+          @perm_x[(i + di) & 255] ^
+          @perm_y[(j + dj) & 255] ^
+          @perm_z[(k + dk) & 255]
+        ]
+      end
+
+      Perlin.perlin_interp(c, vec)
+    end
+
+    def turb(point, depth)
+      accum = 0.0
+      temp_p = point
+      weight = 1.0
+
+      (0...depth).each do
+        accum += weight * noise(temp_p)
+        weight *= 0.5
+        temp_p *= 2.0
+      end
+
+      accum.abs
+    end
+
+    def ==(perlin)
+      randvec == perlin.randvec &&
+      perm_x == perlin.perm_x &&
+      perm_y == perlin.perm_y &&
+      perm_z == perlin.perm_z
+    end
+
+    alias :eql? :==
+
+    def hash
+      [randvec, perm_x, perm_y, perm_z].hash
+    end
+
+    def export
+      {
+        **super,
+        randvec: randvec.map(&:to_a),
+        perm_x: perm_x,
+        perm_y: perm_y,
+        perm_z: perm_z,
+      }
+    end
+
+    def self.perlin_interp(c, vec)
+      v = vec.smoothstep
+      CUBE.sum do |i, j, k|
+        weight = vec - Vec3.new(i.to_f, j.to_f, k.to_f)
+        (i * v.x + (1 - i) * (1 - v.x)) *
+        (j * v.y + (1 - j) * (1 - v.y)) *
+        (k * v.z + (1 - k) * (1 - v.z)) *
+        c[i][j][k].dot(weight)
+      end
+    end
+
+    CUBE = [0, 1].product([0, 1],[0, 1])
+  end
+end

data/lib/raysetta/ray.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Ray
+    attr_accessor :origin, :direction, :time
+
+    def initialize(origin, direction, time = 0.0)
+      @origin = origin
+      @direction = direction
+      @time = time
+    end
+
+    def at(t) = (direction*t).add(origin)
+
+    def dup = self.class.new(origin.dup, direction.dup, time)
+
+    def ==(r)
+      origin == r.origin &&
+      direction == r.direction &&
+      (time- r.time).abs < Util::EPSILON
+    end
+    alias :eql? :==
+
+    def hash
+      [origin, direction, time].hash
+    end
+  end
+end

data/lib/raysetta/runner/base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'progress'
+
+module Raysetta
+  module Runner
+    class Base
+      attr_reader :tracer
+
+      def initialize(tracer)
+        @tracer = tracer
+        Progress.start("Tracing", tracer.height)
+      end
+
+      def call
+        raise NotImplementedError, "Implement #{self.class}#call"
+      end
+
+      def progress
+        Progress.step
+      end
+
+      def finish
+        Progress.stop
+      end
+    end
+  end
+end

data/lib/raysetta/runner/concurrent.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'parallel'
+require 'etc'
+
+module Raysetta
+  module Runner
+    class Concurrent < Base
+      attr_reader :count, :output
+
+      def initialize(tracer, count: Etc.nprocessors)
+        super(tracer)
+        @count = count
+      end
+    end
+  end
+end

data/lib/raysetta/runner/processes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'parallel'
+
+module Raysetta
+  module Runner
+    class Processes < Concurrent
+      attr_reader :output
+
+      def call
+        @output = Parallel.map(tracer.height.times.to_a, in_processes: count, finish: proc { progress }) do |y|
+          row = Array.new(tracer.width) { [0, 0, 0] } #: Array[[Integer, Integer, Integer]]
+          row.each.with_index do |pixel, x|
+            r, g, b = tracer.call(x, y)
+                  
+            pixel[0] = r
+            pixel[1] = g
+            pixel[2] = b
+          end
+          row
+        end
+        finish
+      end
+    end
+  end
+end

data/lib/raysetta/runner/ractors.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'parallel'
+
+module Raysetta
+  module Runner
+    class Ractors < Concurrent
+      attr_reader :output
+
+      def call
+        Ractor.make_shareable(tracer)
+        @output = Parallel.map(tracer.height.times.map { [_1, tracer] }, in_ractors: count, ractor: [self.class, :run], finish: proc { progress })
+        finish
+      end
+
+      def self.run(args)
+        y = args[0] #: Integer
+        tracer = args[1] #: Tracer
+
+        row = Array.new(tracer.width) { [0, 0, 0] } #: Array[[Integer, Integer, Integer]]
+        row.each.with_index do |pixel, x|
+          r, g, b = tracer.call(x, y)
+
+          pixel[0] = r
+          pixel[1] = g
+          pixel[2] = b
+        end
+        row
+      end
+    end
+  end
+end

data/lib/raysetta/runner/sync.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Runner
+    class Sync < Base
+      attr_reader :output
+
+      def initialize(tracer)
+        super
+        @output = Array.new(tracer.height) { Array.new(tracer.width) { [0, 0, 0] } }
+      end
+
+      def call
+        @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
+          progress
+        end
+        finish
+      end
+    end
+  end
+end

data/lib/raysetta/runner/threads.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'parallel'
+
+module Raysetta
+  module Runner
+    class Threads < Concurrent
+      attr_reader :output
+
+      def call
+        @output = Parallel.map(tracer.height.times.to_a, in_threads: count, finish: proc { progress }) do |y|
+          row = Array.new(tracer.width) { [0, 0, 0] } #: Array[[Integer, Integer, Integer]]
+          row.each.with_index do |pixel, x|
+            r, g, b = tracer.call(x, y)
+
+            pixel[0] = r
+            pixel[1] = g
+            pixel[2] = b
+          end
+          row
+        end
+        finish
+      end
+    end
+  end
+end

data/lib/raysetta/runner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "etc"
+
+require_relative "runner/base"
+require_relative "runner/concurrent"
+require_relative "runner/sync"
+require_relative "runner/threads"
+require_relative "runner/ractors"
+require_relative "runner/processes"
+require_relative "output/base"
+require_relative "output/ppm"
+require_relative "output/png"
+
+module Raysetta
+  module Runner
+    def self.parse_scene(input_path, output_path: nil, runner: :sync, format: :ppm, concurrency: Etc.nprocessors, **options)
+      scene = Raysetta::Scene.parse(JSON.parse(File.read(input_path)))
+
+      tracer = Raysetta::Tracer.new(scene, **options)
+      runner = case runner
+      when :sync then Raysetta::Runner::Sync.new(tracer)
+      when :threads then Raysetta::Runner::Threads.new(tracer, count: concurrency)
+      when :ractors then Raysetta::Runner::Ractors.new(tracer, count: concurrency)
+      when :processes then Raysetta::Runner::Processes.new(tracer, count: concurrency)
+      else
+        warn "*** Unknown runner #{runner} ***"
+        exit
+      end
+      runner.call
+      out = case format
+      when :ppm then Raysetta::Output::PPM.new(runner.output, width: tracer.width, height: tracer.height)
+      when :png then Raysetta::Output::PNG.new(runner.output, width: tracer.width, height: tracer.height)
+      else
+        warn "*** Unknown format #{format} ***"
+        exit
+      end
+      if output_path
+        out.save(output_path)
+      else
+        puts out.call
+      end
+    end
+  end
+end

data/lib/raysetta/scatter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Scatter
+    attr_accessor :ray, :attenuation
+
+    def initialize(ray, attenuation)
+      @ray = ray
+      @attenuation = attenuation
+    end
+  end
+end

data/lib/raysetta/scene.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Raysetta
+  class Scene
+    attr_accessor :world, :camera, :background
+
+    def initialize(world, camera, background)
+      @world = world
+      @camera = camera
+      @background = background
+    end
+
+    def self.parse(json)
+      Parser.new(json).parse
+    end
+
+    def export
+      all_materials = world.materials
+      all_textures = [*all_materials, background].flat_map(&:textures).uniq
+      all_images = all_textures.flat_map(&:images).uniq
+      all_noises = all_textures.flat_map(&:noises).uniq
+      {
+        world: world.export,
+        camera: camera.export,
+        background: background.export,
+        materials: export_by_id(all_materials),
+        textures: export_by_id(all_textures),
+        images: export_by_id(all_images),
+        noises: export_by_id(all_noises)
+      }
+    end
+
+    private
+
+    def export_by_id(entities)
+      exported = {} #: Hash[String, Hash[Symbol, untyped]]
+      entities.each do |entity|
+        exported[entity.id] = entity.export
+      end
+      exported
+    end
+
+    class Parser
+      class Error < Raysetta::Error; end
+
+      attr_reader :json
+
+      def initialize(json)
+        @json = json
+      end
+
+      def parse
+        @noises = json["noises"].transform_values { parse_noise(_1) }
+        @images = json["images"].transform_values { parse_image(_1) }
+        @textures = json["textures"].transform_values { parse_texture(_1) }
+        @materials = json["materials"].transform_values { parse_material(_1) }
+        world = parse_world(json["world"])
+        camera = parse_camera(json["camera"])
+        background = parse_background(json["background"])
+
+        Scene.new(world, camera, background)
+      end
+
+      def parse_noise(noise)
+        Perlin.new(
+          noise["randvec"].map { |v| vec3(v) },
+          noise["perm_x"],
+          noise["perm_y"],
+          noise["perm_z"]
+        )
+      end
+
+      def parse_image(img)
+        Image.new(data_url: img["data"])
+      end
+
+      def parse_texture(tex)
+        case tex["type"]
+        when "SolidColor" then Texture::SolidColor.new(rgb(tex["albedo"]))
+        when "Checker" then Texture::Checker.new(tex["scale"], parse_texture(tex["even"]), parse_texture(tex["odd"]))
+        when "Image" then Texture::Image.new(image(tex["image"]))
+        when "Noise" then Texture::Noise.new(tex["scale"], tex["depth"], tex["marble_axis"]&.to_sym, noise(tex["noise"]))
+        else raise Error, "unknown texture type #{tex["type"]}"
+        end
+      end
+
+      def parse_material(mat)
+        case mat["type"]
+        when "Lambertian" then Material::Lambertian.new(texture(mat["texture"]))
+        when "Metal" then Material::Metal.new(texture(mat["texture"]), mat["fuzz"])
+        when "Dielectric" then Material::Dielectric.new(mat["refraction_index"])
+        when "DiffuseLight" then Material::DiffuseLight.new(texture(mat["texture"]))
+        else raise Error, "unknown material type #{mat["type"]}"
+        end
+      end
+
+      def parse_world(json)
+        Object::BVH.new(json.map { |_, v| parse_object(v) })
+      end
+
+      def parse_object(obj)
+        case obj["type"]
+        when "Sphere" then parse_sphere(obj)
+        when "MovingSphere" then parse_moving_sphere(obj)
+        when "Quad" then parse_quad(obj)
+        when "Tri" then parse_tri(obj)
+        when "Box" then parse_box(obj)
+        else raise Error, "unknown object type #{obj["type"]}"
+        end
+      end
+
+      def parse_sphere(obj)
+        Object::Sphere.new(vec3(obj["center"]), obj["radius"], material(obj["material"]))
+      end
+
+      def parse_moving_sphere(obj)
+        Object::MovingSphere.new(vec3(obj["center1"]), vec3(obj["center2"]), obj["radius"], material(obj["material"]))
+      end
+
+      def parse_quad(obj)
+        Object::Quad.new(vec3(obj["q"]), vec3(obj["u"]), vec3(obj["v"]), material(obj["material"]))
+      end
+
+      def parse_tri(obj)
+        Object::Tri.new(vec3(obj["a"]), vec3(obj["b"]), vec3(obj["c"]), material(obj["material"]))
+      end
+
+      def parse_box(obj)
+        Object::Box.new(vec3(obj["a"]), vec3(obj["b"]), material(obj["material"]))
+      end
+
+      def material(name)
+        raise Error, "unknown material #{name}" unless @materials.key?(name)
+
+        @materials[name]
+      end
+
+      def texture(name)
+        raise Error, "unknown texture #{name}" unless @textures.key?(name)
+
+        @textures[name]
+      end
+
+      def image(name)
+        raise Error, "unknown image #{name}" unless @images.key?(name)
+
+        @images[name]
+      end
+
+      def noise(name)
+        raise Error, "unknown noise #{name}" unless @noises.key?(name)
+
+        @noises[name]
+      end
+
+      def parse_camera(cam)
+        args = {} #: Hash[Symbol, untyped]
+        args[:vfov] = cam["vfov"] if cam.key?("vfov")
+        args[:lookfrom] = vec3(cam["lookfrom"]) if cam.key?("lookfrom")
+        args[:lookat] = vec3(cam["lookat"]) if cam.key?("lookat")
+        args[:vup] = vec3(cam["vup"]) if cam.key?("vup")
+        args[:defocus_angle] = cam["defocus_angle"] if cam.key?("defocus_angle")
+        args[:focus_dist] = cam["focus_dist"] if cam.key?("focus_dist")
+        Camera.new(**args)
+      end
+
+      def parse_background(bg)
+        case bg["type"]
+        when "Solid" then parse_solid_bg(bg)
+        when "Gradient" then parse_gradient_bg(bg)
+        when "SphereMap" then parse_sphere_map(bg)
+        when "CubeMap" then parse_cube_map(bg)
+        else raise Error, "unknown background type #{bg["type"]}"
+        end
+      end
+
+      def parse_solid_bg(bg)
+        Background::Solid.new(rgb(bg["albedo"]))
+      end
+
+      def parse_gradient_bg(bg)
+        Background::Gradient.new(rgb(bg["top"]), rgb(bg["bottom"]))
+      end
+
+      def parse_sphere_map(bg)
+        Background::SphereMap.new(texture(bg["texture"]))
+      end
+
+      def parse_cube_map(bg)
+        Background::CubeMap.new(*bg["textures"].map { texture(_1) })
+      end
+
+      def vec3(e)
+        Vec3.new(e[0], e[1], e[2])
+      end
+      alias :rgb :vec3
+
+      def vec2(e)
+        Vec2.new(e[0], e[1])
+      end
+    end
+  end
+end

data/lib/raysetta/texture/base.rb

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