raysetta 0.1.0

data/lib/raysetta/interval.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Interval
+    attr_accessor :min, :max
+
+    # Default interval is empty
+    def initialize(min = Float::INFINITY, max = -Float::INFINITY)
+      @min = min
+      @max = max
+    end
+
+    def self.from_range(r)
+      new(r.min, r.max)
+    end
+
+    # Create the interval tightly enclosing the two input intervals.
+    def self.from_intervals(a, b)
+      new(
+        a.min <= b.min ? a.min : b.min,
+        a.max >= b.max ? a.max : b.max
+      )
+    end
+
+    def size = max - min
+    def include?(x) = min <= x && x <= max
+    def surround?(x) = min < x && x < max
+
+    def clamp(x)
+      return min if x < min
+      return max if x > max
+      x
+    end
+
+    def expand(delta)
+      padding = delta / 2.0
+      Interval.new(min - padding, max + padding)
+    end
+
+    def expand!(delta)
+      padding = delta / 2.0
+      self.min -= padding
+      self.max += padding
+      self
+    end
+
+    def dup
+      Interval.new(min, max)
+    end
+
+    def ==(i)
+      min == i.min && max == i.max
+    end
+    alias :eql? :==
+    
+    def hash
+      [min, max].hash
+    end
+
+    EMPTY = new(Float::INFINITY, -Float::INFINITY)
+    UNIVERSE = new(-Float::INFINITY, Float::INFINITY)
+  end
+end

data/lib/raysetta/material/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Material
+    class Base < EntityBase
+      def emitted(uv, point)
+        return Vec3.new
+      end
+
+      def scatter(r_in, rec)
+        nil
+      end
+
+      def textures
+        []
+      end
+    end
+  end
+end

data/lib/raysetta/material/dielectric.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Material
+    class Dielectric < Base
+      # Refractive index in vacuum or air, or the ratio of the material's refractive index over
+      # the refractive index of the enclosing media
+      attr_accessor :refraction_index
+
+      def initialize(refraction_index)
+        @refraction_index = refraction_index
+      end
+
+      def scatter(r_in, rec)
+        attenuation = Vec3.new(1.0)
+        ri = rec.front_face? ? 1.0/refraction_index : refraction_index
+
+        unit_direction = r_in.direction.unit
+        cos_theta = [(-unit_direction).dot(rec.normal), 1.0].min
+        sin_theta = Math.sqrt(1.0 - cos_theta**2)
+
+        cannot_refract = ri * sin_theta > 1.0
+        direction = if cannot_refract || reflectance(cos_theta, ri) > rand
+          unit_direction.reflect(rec.normal)
+        else
+          unit_direction.refract(rec.normal, ri)
+        end
+
+        scattered = Ray.new(rec.point, direction, r_in.time)
+
+        Scatter.new(scattered, attenuation)
+      end
+
+      def export
+        {
+          **super,
+          refraction_index: refraction_index
+        }
+      end
+
+      def ==(mat)
+        return false unless mat.is_a?(Dielectric)
+
+        refraction_index == mat.refraction_index
+      end
+
+      def hash
+        [type, refraction_index].hash
+      end
+
+      private
+
+        def reflectance(cosine, ri)
+          # Use Schlick's approximation for reflectance.
+          r0 = ((1.0 - ri) / (1.0 + ri))**2
+          r0 + (1.0-r0)*(1.0-cosine)**5
+        end
+    end
+  end
+end

data/lib/raysetta/material/diffuse_light.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Material
+    class DiffuseLight < Base
+      attr_accessor :texture
+
+      def initialize(texture)
+        @texture = texture
+      end
+
+      def self.solid(albedo)
+        new(Texture::SolidColor.new(albedo))
+      end
+
+      def emitted(uv, point)
+        texture.sample(uv, point)
+      end
+
+      def ==(mat)
+        return false unless mat.is_a?(DiffuseLight)
+
+        texture == mat.texture
+      end
+
+      def hash
+        [type, texture].hash
+      end
+
+      def export
+        {
+          **super,
+          texture: texture.id,
+        }
+      end
+
+      def textures
+        [texture]
+      end
+    end
+  end
+end

data/lib/raysetta/material/lambertian.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Material
+    class Lambertian < Base
+      attr_accessor :texture
+
+      def initialize(texture)
+        @texture = texture
+      end
+
+      def self.solid(albedo)
+        new(Texture::SolidColor.new(albedo))
+      end
+
+      def scatter(r_in, rec)
+        scatter_direction = rec.normal + Vec3.random_unit
+
+        # Catch degenerate scatter direction
+        scatter_direction = rec.normal if scatter_direction.zero?
+
+        scattered = Ray.new(rec.point, scatter_direction, r_in.time)
+        Scatter.new(scattered, texture.sample(rec.uv, rec.point))
+      end
+
+      def ==(mat)
+        return false unless mat.is_a?(Lambertian)
+
+        texture == mat.texture
+      end
+
+      def hash
+        [type, texture].hash
+      end
+
+      def export
+        {
+          **super,
+          texture: texture.id,
+        }
+      end
+
+      def textures
+        [texture]
+      end
+    end
+  end
+end

data/lib/raysetta/material/metal.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Material
+    class Metal < Base
+      attr_accessor :texture, :fuzz
+
+      def initialize(texture, fuzz)
+        @texture = texture
+        @fuzz = fuzz
+      end
+
+      def self.solid(albedo, fuzz)
+        new(Texture::SolidColor.new(albedo), fuzz)
+      end
+
+      def scatter(r_in, rec)
+        reflected = r_in.direction.reflect(rec.normal)
+        reflected = reflected.normalize.add(Vec3.random_unit.mul(fuzz))
+        scattered = Ray.new(rec.point, reflected, r_in.time)
+        return nil if scattered.direction.dot(rec.normal) <= 0.0
+
+        Scatter.new(scattered, texture.sample(rec.uv, rec.point))
+      end
+
+      def ==(mat)
+        return false unless mat.is_a?(Metal)
+
+        texture == mat.texture && fuzz == mat.fuzz
+      end
+
+      def hash
+        [type, texture, fuzz].hash
+      end
+
+      def export
+        {
+          **super,
+          texture: texture.id,
+          fuzz: fuzz,
+        }
+      end
+
+      def textures
+        [texture]
+      end
+    end
+  end
+end

data/lib/raysetta/object/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class Base < EntityBase
+      def hit(r, ray_t)
+        raise NotImplementedError, "Implement #{self.class.name}#hit"
+      end
+
+      def bounding_box
+        raise NotImplementedError, "Implement #{self.class.name}#bounding_box"
+      end
+
+      def materials
+        []
+      end
+
+      def objects
+        [self]
+      end
+    end
+  end
+end

data/lib/raysetta/object/box.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class Box < Group
+      def initialize(a, b, material)
+        @a = a
+        @b = b
+        @material = material
+
+        # Returns the 3D box (six sides) that contains the two opposite vertices a & b.
+
+        # Construct the two opposite vertices with the minimum and maximum coordinates.
+        min = Vec3.new([a.x, b.x].min, [a.y, b.y].min, [a.z, b.z].min);
+        max = Vec3.new([a.x, b.x].max, [a.y, b.y].max, [a.z, b.z].max);
+    
+        dx = Vec3.new(max.x - min.x, 0.0, 0.0)
+        dy = Vec3.new(0.0, max.y - min.y, 0.0)
+        dz = Vec3.new(0.0, 0.0, max.z - min.z)
+    
+        super(
+          Quad.new(Vec3.new(min.x, min.y, max.z),  dx,  dy, material), # front
+          Quad.new(Vec3.new(max.x, min.y, max.z), -dz,  dy, material), # right
+          Quad.new(Vec3.new(max.x, min.y, min.z), -dx,  dy, material), # back
+          Quad.new(Vec3.new(min.x, min.y, min.z),  dz,  dy, material), # left
+          Quad.new(Vec3.new(min.x, max.y, max.z),  dx, -dz, material), # top
+          Quad.new(Vec3.new(min.x, min.y, min.z),  dx,  dz, material)  # bottom
+        )
+      end
+
+      def export
+        {
+          type: "Box",
+          a: @a.to_a,
+          b: @b.to_a,
+          material: @material.id
+        }
+      end
+
+      def materials
+        [@material]
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}Box { a=#{@a}, b=#{@b} }"
+      end
+    end
+  end
+end

data/lib/raysetta/object/bvh.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class BVH < Base
+      attr_reader :bounding_box
+
+      def initialize(objects)
+        self.objects = objects
+      end
+
+      def hit(r, ray_t)
+        return nil unless bounding_box.hit(r, ray_t)
+
+        hit_left = @left.hit(r, ray_t)
+        hit_right = @right.hit(r, ray_t.min..(hit_left&.t || ray_t.max))
+
+        hit_right || hit_left
+      end
+
+      def export
+        { **export_bvh(@left), **export_bvh(@right) }
+      end
+
+      def materials
+        [*@left.materials, *@right.materials].uniq
+      end
+
+      def objects
+        @left.objects | @right.objects
+      end
+
+      def objects=(objs)
+        @bounding_box = AABB::EMPTY
+        objs.each do |object|
+          @bounding_box = AABB.from_aabbs(@bounding_box, object.bounding_box)
+        end
+
+        axis = @bounding_box.longest_axis
+
+        case objs.length
+        when 1
+          @left = @right = objs[0]
+        when 2
+          @left = objs[0]
+          @right = objs[1]
+        else
+          objs.sort_by! { _1.bounding_box[axis].min }
+          mid = objs.length / 2
+          left_objs = objs[0...mid] #: Array[Object::Base]
+          right_objs = objs[mid..] #: Array[Object::Base]
+          @left = BVH.new(left_objs)
+          @right = BVH.new(right_objs)
+        end
+      end
+
+      def add(object)
+        self.objects = objects + [object]
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}BVH {\n" +
+        "#{indent}  left=\n"+
+        "#{@left.to_s(depth+2)}\n"+
+        "#{indent}  right=\n"+
+        "#{@right.to_s(depth+2)}\n"+
+        "#{indent}}"
+      end
+
+      private
+
+        def export_bvh(obj)
+          case obj
+          when BVH then obj.export
+          else { obj.id => obj.export }
+          end
+        end
+    end
+  end
+end

data/lib/raysetta/object/group.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class Group < Base
+      attr_reader :objects, :bounding_box
+
+      def initialize(*objects)
+        self.objects = objects
+      end
+
+      def objects=(objs)
+        @objects = objs
+        @bounding_box = AABB.from_aabbs(*objs.map(&:bounding_box))
+      end
+
+      def add(obj)
+        @objects << obj
+        @bounding_box = AABB.from_aabbs(@bounding_box, obj.bounding_box)
+      end
+
+      def hit(r, ray_t)
+        hit = nil #: Hit?
+        closest_so_far = ray_t.max
+
+        @objects.each do |object|
+          if tmp = object.hit(r, ray_t.min..closest_so_far)
+            hit = tmp
+            # @type var hit: Hit
+            closest_so_far = hit.t
+          end
+        end
+
+        hit
+      end
+
+      def export
+        {
+          **super,
+          objects: objects.map { [_1.id, _1.export] }.to_h
+        }
+      end
+
+      def materials
+        @objects.flat_map(&:materials).uniq
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}Group {\n" +
+        "#{indent}  objects = {" +
+        "#{@objects.map { _1.to_s(depth+2)+"\n" } }" +
+        "#{indent}  }\n" +
+        "#{indent}}"
+      end
+
+    end
+  end
+end

data/lib/raysetta/object/moving_sphere.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class MovingSphere < Sphere
+      attr_accessor :center_vec
+
+      def initialize(center1, center2, radius, material)
+        super(center1, radius, material)
+        @center_vec = center2 - center1
+        rvec = Vec3.new(radius, radius, radius)
+        box1 = AABB.from_points(center1 - rvec, center1 + rvec)
+        box2 = AABB.from_points(center2 - rvec, center2 + rvec)
+        @bounding_box = AABB.from_aabbs(box1, box2)
+      end
+
+      # Linearly interpolate from center1 to center2 according to time, where t=0 yields
+      # center1, and t=1 yields center2.
+      def center_at(time = 0.0)
+        center + center_vec * time
+      end
+
+      def hit(r, ray_t, center = center_at(r.time))
+        super(r, ray_t, center)
+      end
+
+      def export
+        {
+          **super.except(:center),
+          center1: center.to_a,
+          center2: center_at(1.0).to_a
+        }
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}MovingSphere { radius=#{radius}, center=#{center}, vec=#{center_vec} }"
+      end
+    end
+  end
+end

data/lib/raysetta/object/quad.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class Quad < Base
+      attr_accessor :q, :u, :v, :material
+
+      attr_reader :bounding_box
+
+      def initialize(q, u, v, material)
+        @q = q
+        @u = u
+        @v = v
+        @material = material
+
+        n = u.cross(v)
+        @normal = n.unit
+        @d = @normal.dot(q)
+        @w = n / n.dot(n)
+
+        compute_bounding_box
+      end
+
+      def hit(r, ray_t)
+        denom = normal.dot(r.direction)
+
+        # No hit if the ray is parallel to the plane.
+        return if denom.abs < 1e-8
+
+        # Return if the hit point parameter t is outside the ray interval.
+        t = (d - normal.dot(r.origin)) / denom
+        return unless ray_t.cover?(t)
+
+        # Determine the hit point lies within the planar shape using its plane coordinates.
+        intersection = r.at(t)
+        planar_hitpt_vector = intersection - q
+        alpha = w.dot(planar_hitpt_vector.cross(v))
+        beta = w.dot(u.cross(planar_hitpt_vector))
+
+        uv = interior?(alpha, beta)
+        return unless uv
+
+        # Ray hits the 2D shape
+        Hit.new(point: intersection, t:, normal:, material:, r:, uv:)
+      end
+
+      def export
+        {
+          **super,
+          q: q.to_a,
+          u: u.to_a,
+          v: v.to_a,
+          material: material.id
+        }
+      end
+
+      def materials
+        [material]
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}Quad { q=#{q}, u=#{u}, v=#{v} }"
+      end
+
+      private
+        attr_accessor :normal, :d, :w
+
+        def interior?(a, b)
+          unit_interval = Interval.new(0.0, 1.0)
+          # Given the hit point in plane coordinates, return nil if it is outside the
+          # primitive, otherwise return the UV coordinates.
+
+          return unless unit_interval.include?(a) && unit_interval.include?(b)
+
+          Vec2.new(a, b)
+        end
+
+        def compute_bounding_box
+          # Compute the bounding box of all four vertices.
+          bbox_diagonal1 = AABB.from_points(q, q + u + v)
+          bbox_diagonal2 = AABB.from_points(q + u, q + v)
+          @bounding_box = AABB.from_aabbs(bbox_diagonal1, bbox_diagonal2)
+        end
+
+    end
+  end
+end

data/lib/raysetta/object/sphere.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Object
+    class Sphere < Base
+      attr_accessor :center, :radius, :material
+
+      attr_reader :bounding_box
+
+      def initialize(center, radius, material)
+        @center = center
+        @radius = radius
+        @material = material
+        rvec = Vec3.new(radius, radius, radius)
+        @bounding_box = AABB.from_points(center - rvec, center + rvec)
+      end
+
+      def hit(r, ray_t, center = @center)
+        oc = center - r.origin
+        a = r.direction.length_squared
+        h = r.direction.dot(oc)
+        c = oc.length_squared - radius**2
+
+        discriminant = h**2 - a*c
+        return nil if discriminant < 0
+
+        sqrtd = Math.sqrt(discriminant)
+
+        # Find the nearest root that lies in the acceptable range.
+        root = (h - sqrtd) / a
+        unless ray_t.cover?(root)
+          root = (h + sqrtd) / a
+          return nil unless ray_t.cover?(root)
+        end
+
+        point = r.at(root)
+        normal = (point - center).div(radius)
+
+        Hit.new(
+          point:,
+          r:,
+          normal:,
+          t: root,
+          material:,
+          uv: Util.sphere_uv(normal)
+        )
+      end
+
+      def export
+        {
+          **super,
+          center: center.to_a,
+          radius: radius,
+          material: material.id
+        }
+      end
+
+      def materials
+        [material]
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}Sphere { radius=#{radius}, center=#{center} }"
+      end
+    end
+  end
+end