rray 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f03f9a2499958c6af45796be767ad0f40142f8a149bcef505d4e0fcb920956b8
-  data.tar.gz: fe1bc6387e3dd6b3515fe143177c48ad73b1e49135a96d192c0ac22d71e1714f
+  metadata.gz: c1f6b0d451c5f0098de3d1aaf967766038c58b622dab31a26b3d4400a28c72bd
+  data.tar.gz: 97a44a8efa2be4a28e81b6dcf10de54646bb034787326787e3d6925fe79afab8
 SHA512:
-  metadata.gz: 6317e23620a5113b9ed5e34e0e5ffd8a92dd1dd2ceca3852145bee24f6f611a6c8a07516bb53a4d1bb57e3c4623ba6f53b2e488510b6d38fc14ff45a5537e00d
-  data.tar.gz: ba1af605e9ccd88cae8602c8f4353b51aa3a5584a0504e82e10153466941b289989153310aa300464f53982228c598ca1c340182cc482662deb513b40783b54f
+  metadata.gz: 50d401573d8e62609cd940451580269fe0f153d086217153f9a3ca9ec571e1ddb0c28a456adb0ae9c55661b67c5733dab4e4b81817290b950618ca475c4d9ed9
+  data.tar.gz: 0d46651fc158a7cef699a2b4371a0a5892df107c1f0f5c8a93778b7f03fd76a63706a175d4775a6ebc28b55ad428ae601463802a1519b33e42ef9392f190d508

data/lib/rray/aabb.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative './interval'
+
+module Rray
+  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
+    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(a, b)
+      new(
+        a.x < b.x ? Interval.new(a.x, b.x) : Interval.new(b.x, a.x),
+        a.y < b.y ? Interval.new(a.y, b.y) : Interval.new(b.y, a.y),
+        a.z < b.z ? Interval.new(a.z, b.z) : Interval.new(b.z, a.z)
+      )
+    end
+
+    def self.from_aabbs(box0, box1)
+      new(
+        Interval.from_intervals(box0.x, box1.x),
+        Interval.from_intervals(box0.y, box1.y),
+        Interval.from_intervals(box0.z, box1.z)
+      )
+    end
+
+    def [](n)
+      case n
+      when 0 then x
+      when 1 then y
+      when 2 then z
+      end
+    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
+
+    EMPTY = new(Interval::EMPTY, Interval::EMPTY, Interval::EMPTY)
+    UNIVERSE = new(Interval::UNIVERSE, Interval::UNIVERSE, Interval::UNIVERSE)
+  end
+end

data/lib/rray/camera.rb

@@ -66,15 +66,27 @@ module Rray
     # 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 = Util.sample_square
+      offset = Vec3.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.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

data/lib/rray/hit.rb

@@ -2,14 +2,14 @@
 
 module Rray
   class Hit
-    attr_accessor :point, :normal, :t, :mat, :front_face
+    attr_accessor :point, :normal, :t, :material, :front_face
 
-    def initialize(point, r, outward_normal, t, mat)
+    def initialize(point, r, outward_normal, t, material)
       @point = point
       @t = t
-      @mat = mat
+      @material = material
 
-      # Sets the hit record normal vector.
+      # Sets the hit's normal vector.
       # NOTE: the parameter `outward_normal` is assumed to have unit length.
 
       @front_face = r.direction.dot(outward_normal) < 0

data/lib/rray/interval.rb

@@ -4,11 +4,24 @@ module Rray
   class Interval
     attr_accessor :min, :max
 
-    def initialize(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
@@ -19,6 +32,15 @@ module Rray
       x
     end
 
+    def expand(delta)
+      padding = delta / 2.0
+      Interval.new(min - padding, max + padding)
+    end
+
+    def dup
+      Interval.new(min, max)
+    end
+
     EMPTY = new(Float::INFINITY, -Float::INFINITY)
     UNIVERSE = new(-Float::INFINITY, Float::INFINITY)
   end

data/lib/rray/material/base.rb

@@ -3,9 +3,21 @@
 module Rray
   module Material
     class Base
+      def id
+        "#{type.downcase}-#{object_id.to_s(16)}"
+      end
+
+      def type
+        self.class.name.split('::').last
+      end
+
       def scatter(r_in, rec)
         raise NotImplementedError, "Implement #{self.class}#scatter"
       end
+
+      def export
+        raise NotImplementedError, "Implement #{self.class.name}#export"
+      end
     end
   end
 end

data/lib/rray/material/dielectric.rb

@@ -26,17 +26,24 @@ module Rray
           unit_direction.refract(rec.normal, ri)
         end
 
-        scattered = Ray.new(rec.point, direction)
+        scattered = Ray.new(rec.point, direction, r_in.time)
 
         Scatter.new(scattered, attenuation)
       end
 
+      def export
+        {
+          type: "Dielectric",
+          refraction_index: refraction_index
+        }
+      end
+
       private
 
         def reflectance(cosine, ri)
           # Use Schlick's approximation for reflectance.
           r0 = ((1.0 - ri) / (1.0 + ri))**2
-          r0 + (1-r0)*(1.0-cosine)**5
+          r0 + (1.0-r0)*(1.0-cosine)**5
         end
     end
   end

data/lib/rray/material/lambertian.rb

@@ -11,13 +11,20 @@ module Rray
 
       def scatter(r_in, rec)
         scatter_direction = rec.normal + Vec3.random_unit_vector
-        scattered = Ray.new(rec.point, scatter_direction)
+        scattered = Ray.new(rec.point, scatter_direction, r_in.time)
 
         # Catch degenerate scatter direction
         scatter_direction = rec.normal if scatter_direction.zero?
 
         Scatter.new(scattered, albedo)
       end
+
+      def export
+        {
+          type: "Lambertian",
+          albedo: albedo.to_a
+        }
+      end
     end
   end
 end

data/lib/rray/material/metal.rb

@@ -13,11 +13,19 @@ module Rray
       def scatter(r_in, rec)
         reflected = r_in.direction.reflect(rec.normal)
         reflected = reflected.normalize.add(Vec3.random_unit_vector.mul(fuzz))
-        scattered = Ray.new(rec.point, reflected)
+        scattered = Ray.new(rec.point, reflected, r_in.time)
         return nil if scattered.direction.dot(rec.normal) <= 0
 
         Scatter.new(scattered, albedo)
       end
+
+      def export
+        {
+          type: "Metal",
+          albedo: albedo.to_a,
+          fuzz: fuzz
+        }
+      end
     end
   end
 end

data/lib/rray/object/base.rb

@@ -3,9 +3,25 @@
 module Rray
   module Object
     class Base
+      def id
+        "#{type.downcase}-#{object_id.to_s(16)}"
+      end
+
+      def type
+        self.class.name.split('::').last
+      end
+
       def hit(r, ray_t)
         raise NotImplementedError, "Implement #{self.class.name}#hit"
       end
+
+      def export
+        raise NotImplementedError, "Implement #{self.class.name}#export"
+      end
+
+      def bounding_box
+        raise NotImplementedError, "Implement #{self.class.name}#bounding_box"
+      end
     end
   end
 end

data/lib/rray/object/bvh.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rray
+  module Object
+    class BVH < Base
+      attr_reader :bounding_box
+
+      def initialize(objects)
+        @bounding_box = AABB::EMPTY
+        objects.each do |object|
+          @bounding_box = AABB.from_aabbs(@bounding_box, object.bounding_box)
+        end
+
+        axis = @bounding_box.longest_axis
+
+        case objects.length
+        when 1
+          @left = @right = objects[0]
+        when 2
+          @left = objects[0]
+          @right = objects[1]
+        else
+          objects.sort_by! { _1.bounding_box[axis].min }
+          mid = objects.length / 2
+          @left = BVH.new(objects[0...mid])
+          @right = BVH.new(objects[mid..])
+        end
+      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
+        raise NotImplementedError, "Cannot export BVH, perhaps you meant to use a group?"
+      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
+    end
+  end
+end

data/lib/rray/object/group.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative './bvh'
+
 module Rray
   module Object
     class Group < Base
@@ -7,25 +9,35 @@ module Rray
 
       def initialize(objects = [])
         @objects = objects
+        @bvh = BVH.new(objects)
       end
 
       def <<(object)
         objects << object
+        @bvh = BVH.new(objects)
+        object
       end
 
       def hit(r, ray_t)
-        rec = nil
-        closest_so_far = ray_t.end
+        @bvh.hit(r, ray_t)
+      end
 
-        objects.each do |object|
-          temp_rec = object.hit(r, ray_t.begin..closest_so_far)
-          next unless temp_rec
+      def bounding_box
+        @bvh.bounding_box
+      end
 
-          rec = temp_rec
-          closest_so_far = rec.t
-        end
+      def export
+        {
+          type: "Group",
+          objects: objects.map(&:export)
+        }
+      end
 
-        rec
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}Group {\n" +
+        objects.map { "#{indent}  #{_1.to_s(depth+1)}\n" } +
+        "#{indent}}"
       end
     end
   end

data/lib/rray/object/moving_sphere.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Rray
+  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)
+        super(r, ray_t, center_at(r.time))
+      end
+
+      def export
+        {
+          type: "MovingSphere",
+          center1: center.to_a,
+          center2: center_at(1.0).to_a,
+          radius: radius,
+          material: material.id
+        }
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}MovingSphere { radius=#{radius}, center=#{center}, vec=#{center_vec} }"
+      end
+    end
+  end
+end

data/lib/rray/object/sphere.rb

@@ -3,15 +3,19 @@
 module Rray
   module Object
     class Sphere < Base
-      attr_accessor :center, :radius, :mat
+      attr_accessor :center, :radius, :material
 
-      def initialize(center, radius, mat)
+      attr_reader :bounding_box
+
+      def initialize(center, radius, material)
         @center = center
         @radius = radius
-        @mat = mat
+        @material = material
+        rvec = Vec3.new(radius, radius, radius)
+        @bounding_box = AABB.from_points(center - rvec, center + rvec)
       end
 
-      def hit(r, ray_t)
+      def hit(r, ray_t, center = @center)
         oc = center - r.origin
         a = r.direction.length_squared
         h = r.direction.dot(oc)
@@ -36,9 +40,23 @@ module Rray
           r,
           (point - center).div(radius),
           root,
-          mat
+          material
         )
       end
+
+      def export
+        {
+          type: "Sphere",
+          center: center.to_a,
+          radius: radius,
+          material: material.id
+        }
+      end
+
+      def to_s(depth=0)
+        indent = "  "*depth
+        "#{indent}Sphere { radius=#{radius}, center=#{center} }"
+      end
     end
   end
 end

data/lib/rray/ray.rb

@@ -2,15 +2,16 @@
 
 module Rray
   class Ray
-    attr_accessor :origin, :direction
+    attr_accessor :origin, :direction, :time
 
-    def initialize(origin, direction)
+    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, direction)
+    def dup = self.class.new(origin, direction, time)
   end
 end

data/lib/rray/scene.rb

@@ -17,6 +17,31 @@ module Rray
       Parser.new(json).parse
     end
 
+    def export
+      {
+        world: world.export,
+        camera: camera.export,
+        materials: export_materials
+      }
+    end
+
+    private
+
+      def export_materials
+        materials = {}
+        traverse do |object|
+          materials[object.material.id] ||= object.material.export
+        end
+        materials
+      end
+
+      def traverse(object = world, &block)
+        case object
+        when Object::Group then object.objects.each(&block)
+        else yield object
+        end
+      end
+
     class Parser
       class Error < Rray::Error; end
 
@@ -38,21 +63,34 @@ module Rray
         case mat["type"]
         when "Lambertian" then Material::Lambertian.new(Color.new(*mat["albedo"]))
         when "Metal" then Material::Metal.new(Color.new(*mat["albedo"]), mat["fuzz"])
-        when "Dielectric" then Material::Dielectric.new(mat["refractive_index"])
-        else raise ParserError, "unknown material type #{mat["type"]}"
+        when "Dielectric" then Material::Dielectric.new(mat["refraction_index"])
+        else raise Error, "unknown material type #{mat["type"]}"
         end
       end
 
       def parse_object(obj)
         case obj["type"]
-        when "Group" then Object::Group.new(obj["objects"].map { parse_object(_1) })
-        when "Sphere" then Object::Sphere.new(Point3.new(*obj["center"]), obj["radius"], material(obj["material"]))
-        else raise ParserError, "unknown object type #{obj["type"]}"
+        when "Group" then parse_group(obj)
+        when "Sphere" then parse_sphere(obj)
+        when "MovingSphere" then parse_moving_sphere(obj)
+        else raise Error, "unknown object type #{obj["type"]}"
         end
       end
 
+      def parse_group(obj)
+        Object::Group.new(obj["objects"].map { parse_object(_1) })
+      end
+
+      def parse_sphere(obj)
+        Object::Sphere.new(Point3.new(*obj["center"]), obj["radius"], material(obj["material"]))
+      end
+
+      def parse_moving_sphere(obj)
+        Object::MovingSphere.new(Point3.new(*obj["center1"]), Point3.new(*obj["center2"]), obj["radius"], material(obj["material"]))
+      end
+
       def material(name)
-        raise ParserError, "unknown material #{name}" unless @materials.key?(name)
+        raise Error, "unknown material #{name}" unless @materials.key?(name)
 
         @materials[name]
       end

data/lib/rray/tracer.rb

@@ -29,7 +29,7 @@ module Rray
 
       rec = scene.world.hit(r, 0.001..Float::INFINITY)
       if rec
-        scattered = rec.mat.scatter(r, rec)
+        scattered = rec.material.scatter(r, rec)
         return Color.new(0.0, 0.0, 0.0) unless scattered
 
         return ray_color(scattered.ray, depth-1).multiply(scattered.attenuation)

data/lib/rray/util.rb

@@ -6,7 +6,6 @@ module Rray
 
     # Returns a random real in [min,max).
     def self.random(min, max) = min + (max-min)*rand
-    def self.sample_square = Vec3.new(rand - 0.5, rand - 0.5, 0.0)
 
     def self.linear_to_gamma(linear_component)
       return 0 unless linear_component > 0

data/lib/rray/vec3.rb

@@ -6,6 +6,10 @@ module Rray
       @e = [x, y, z]
     end
 
+    def to_a
+      @e.dup
+    end
+
     def x = @e[0]
     def y = @e[1]
     def z = @e[2]
@@ -22,10 +26,15 @@ module Rray
       @e[2] = v
     end
 
-    def -@ = self.class.new(-x, -y, -z)
-    def [](i) = @e[i]
+    def -@
+      self.class.new(-x, -y, -z)
+    end
+
+    def [](i)
+      @e[i]
+    end
 
-      def []=(i, v)
+    def []=(i, v)
       @e[i] = v
     end
 
@@ -104,13 +113,17 @@ module Rray
       r_out_perp.add(r_out_parallel)
     end
 
+    def to_s
+      "(#{x},#{y},#{z})"
+    end
+
     def self.random(min = 0.0, max = 1.0)
-      Vec3.new(Util.random(min, max), Util.random(min, max), Util.random(min, max))
+      new(Util.random(min, max), Util.random(min, max), Util.random(min, max))
     end
 
     def self.random_in_unit_sphere
       loop do
-        v = Vec3.random(-1.0, 1.0)
+        v = random(-1.0, 1.0)
         return v if v.length_squared < 1
       end
     end
@@ -128,9 +141,11 @@ module Rray
 
     def self.random_in_unit_disk
       loop do
-        v = Vec3.new(Util.random(-1.0, 1.0), Util.random(-1.0, 1.0), 0.0)
+        v = new(Util.random(-1.0, 1.0), Util.random(-1.0, 1.0), 0.0)
         return v if v.length_squared < 1
       end
     end
+
+    def self.sample_square = new(rand - 0.5, rand - 0.5, 0.0)
   end
 end

data/lib/rray/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rray
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/rray.rb

@@ -11,11 +11,14 @@ require_relative "rray/point3"
 require_relative "rray/color"
 require_relative "rray/ray"
 require_relative "rray/interval"
+require_relative "rray/aabb"
 require_relative "rray/hit"
 require_relative "rray/scatter"
 require_relative "rray/object/base"
 require_relative "rray/object/sphere"
+require_relative "rray/object/moving_sphere"
 require_relative "rray/object/group"
+require_relative "rray/object/bvh"
 require_relative "rray/material/base"
 require_relative "rray/material/lambertian"
 require_relative "rray/material/metal"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rray
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Danielle Smith
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-15 00:00:00.000000000 Z
+date: 2024-05-01 00:00:00.000000000 Z
 dependencies: []
 description: Simple raytracer written in ruby. Can be used a CLI tool or library.
 email:
@@ -21,6 +21,7 @@ files:
 - README.md
 - Rakefile
 - lib/rray.rb
+- lib/rray/aabb.rb
 - lib/rray/camera.rb
 - lib/rray/color.rb
 - lib/rray/hit.rb
@@ -30,7 +31,9 @@ files:
 - lib/rray/material/lambertian.rb
 - lib/rray/material/metal.rb
 - lib/rray/object/base.rb
+- lib/rray/object/bvh.rb
 - lib/rray/object/group.rb
+- lib/rray/object/moving_sphere.rb
 - lib/rray/object/sphere.rb
 - lib/rray/point3.rb
 - lib/rray/ray.rb