rray 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8524e60bb5c72619ed588acd7778faf1c4164b93928094d9c75379e3315a1897
+  data.tar.gz: ad9f79b082e057ff74b555672bbc7a11082fda5339353506efa1e004003642a3
+SHA512:
+  metadata.gz: f64cf7f310538afd73185ebc926ad928ee727752160012d6d506149a9e1433d1486579ffb8b51ab8fd6385aafc4d5a8b656d41dadcb59cf95babe97789eccdbd
+  data.tar.gz: 9379ec81d4072e789115fd3534570733d0cd1d29fa5636e4a67e4f0e6f377e5414fa62fe66dc2cbc4872165cc6c78b85c50c2cb611d7f1a6098998b4f48e8b8b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 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,49 @@
+# Rray
+
+Simple raytracer written in ruby.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add rray
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install rray
+
+## Usage
+
+```ruby
+require "rray"
+
+scene = Rray::Scene.parse(File.read("scene.json"))
+tracer = Rray::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
+```
+
+## 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/rray.
+
+## 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/lib/rray/camera.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Rray
+  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: Point3.new(0.0, 0.0, 0.0),
+      lookat: Point3.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 = Util.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.new(ray_origin, ray_direction)
+    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/rray/color.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rray
+  class Color < Vec3
+    def r = x
+    def g = y
+    def b = z
+
+    def r=(v)
+      self.x = v
+    end
+
+    def g=(v)
+      self.y = v
+    end
+
+    def b=(v)
+      self.z = v
+    end
+
+    def multiply(v)
+      self.r *= v.r
+      self.g *= v.g
+      self.b *= v.b
+      self
+    end
+  end
+end

data/lib/rray/hit.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rray
+  class Hit
+    attr_accessor :point, :normal, :t, :mat, :front_face
+
+    def initialize(point, r, outward_normal, t, mat)
+      @point = point
+      @t = t
+      @mat = mat
+
+      # Sets the hit record normal vector.
+      # NOTE: the parameter `outward_normal` is assumed to have unit length.
+
+      @front_face = r.direction.dot(outward_normal) < 0
+      @normal = @front_face ? outward_normal : -outward_normal
+    end
+  end
+end

data/lib/rray/interval.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rray
+  class Interval
+    attr_accessor :min, :max
+
+    def initialize(min, max)
+      @min = min
+      @max = 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
+
+    EMPTY = new(Float::INFINITY, -Float::INFINITY)
+    UNIVERSE = new(-Float::INFINITY, Float::INFINITY)
+  end
+end

data/lib/rray/material/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rray
+  module Material
+    class Base
+      def scatter(r_in, rec)
+        raise NotImplementedError, "Implement #{self.class}#scatter"
+      end
+    end
+  end
+end

data/lib/rray/material/dielectric.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Rray
+  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 = Color.new(1.0, 1.0, 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)
+
+        Scatter.new(scattered, attenuation)
+      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
+        end
+    end
+  end
+end

data/lib/rray/material/lambertian.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rray
+  module Material
+    class Lambertian < Base
+      attr_accessor :albedo
+
+      def initialize(albedo)
+        @albedo = albedo
+      end
+
+      def scatter(r_in, rec)
+        scatter_direction = rec.normal + Vec3.random_unit_vector
+        scattered = Ray.new(rec.point, scatter_direction)
+
+        # Catch degenerate scatter direction
+        scatter_direction = rec.normal if scatter_direction.zero?
+
+        Scatter.new(scattered, albedo)
+      end
+    end
+  end
+end

data/lib/rray/material/metal.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rray
+  module Material
+    class Metal < Base
+      attr_accessor :albedo, :fuzz
+
+      def initialize(albedo, fuzz)
+        @albedo = albedo
+        @fuzz = fuzz
+      end
+
+      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)
+        return nil if scattered.direction.dot(rec.normal) <= 0
+
+        Scatter.new(scattered, albedo)
+      end
+    end
+  end
+end

data/lib/rray/object/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rray
+  module Object
+    class Base
+      def hit(r, ray_t)
+        raise NotImplementedError, "Implement #{self.class.name}#hit"
+      end
+    end
+  end
+end

data/lib/rray/object/group.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rray
+  module Object
+    class Group < Base
+      attr_reader :objects
+
+      def initialize(objects = [])
+        @objects = objects
+      end
+
+      def <<(object)
+        objects << object
+      end
+
+      def hit(r, ray_t)
+        rec = nil
+        closest_so_far = ray_t.end
+
+        objects.each do |object|
+          temp_rec = object.hit(r, ray_t.begin..closest_so_far)
+          next unless temp_rec
+
+          rec = temp_rec
+          closest_so_far = rec.t
+        end
+
+        rec
+      end
+    end
+  end
+end

data/lib/rray/object/sphere.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Rray
+  module Object
+    class Sphere < Base
+      attr_accessor :center, :radius, :mat
+
+      def initialize(center, radius, mat)
+        @center = center
+        @radius = radius
+        @mat = mat
+      end
+
+      def hit(r, ray_t)
+        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)
+
+        Hit.new(
+          point,
+          r,
+          (point - center).div(radius),
+          root,
+          mat
+        )
+      end
+    end
+  end
+end

data/lib/rray/point3.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Rray
+  class Point3 < Vec3
+  end
+end

data/lib/rray/ray.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rray
+  class Ray
+    attr_accessor :origin, :direction
+
+    def initialize(origin, direction)
+      @origin = origin
+      @direction = direction
+    end
+
+    def at(t) = (direction*t).add(origin)
+
+    def dup = self.class.new(origin, direction)
+  end
+end

data/lib/rray/scatter.rb

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

data/lib/rray/scene.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rray
+  class Scene
+    attr_reader :world, :camera
+
+    def initialize(world, camera)
+      @world = world
+      @camera = camera
+    end
+
+    def self.parse(json)
+      return parse(JSON.parse(json)) if json.is_a? String
+
+      Parser.new(json).parse
+    end
+
+    class Parser
+      class Error < Rray::Error; end
+
+      attr_reader :json
+
+      def initialize(json)
+        @json = json
+      end
+
+      def parse
+        @materials = json["materials"].transform_values { parse_material(_1) }
+        world = parse_object(json["world"])
+        camera = parse_camera(json["camera"])
+
+        Scene.new(world, camera)
+      end
+
+      def parse_material(mat)
+        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"]}"
+        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"]}"
+        end
+      end
+
+      def material(name)
+        raise ParserError, "unknown material #{name}" unless @materials.key?(name)
+
+        @materials[name]
+      end
+
+      def parse_camera(cam)
+        args = {}
+        args[:vfov] = cam["vfov"] if cam.key?("vfov")
+        args[:lookfrom] = Point3.new(*cam["lookfrom"]) if cam.key?("lookfrom")
+        args[:lookat] = Point3.new(*cam["lookat"]) if cam.key?("lookat")
+        args[:vup] = Vec3.new(*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
+    end
+  end
+end

data/lib/rray/tracer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Rray
+  class Tracer
+    attr_reader :scene, :width, :height, :samples_per_pixel, :max_depth
+
+    def initialize(scene, width: 256, height: 256, samples_per_pixel: 10, max_depth: 10)
+      @scene = scene
+      @width = width
+      @height = height
+      @samples_per_pixel = samples_per_pixel
+      @max_depth = max_depth
+      @pixel_sample_scale = 1.0 / samples_per_pixel
+
+      scene.camera.viewport(width, height)
+    end
+
+    def call(x, y)
+      pixel_color = Color.new(0.0, 0.0, 0.0)
+      samples_per_pixel.times do
+        pixel_color.add(ray_color(scene.camera.ray(x, y)))
+      end
+      color(pixel_color.mul(@pixel_sample_scale))
+    end
+
+    def ray_color(r, depth = max_depth)
+      # If we've exceeded the ray bounce limit, no more light is gathered.
+      return Color.new(0.0, 0.0, 0.0) unless depth > 0
+
+      rec = scene.world.hit(r, 0.001..Float::INFINITY)
+      if rec
+        scattered = rec.mat.scatter(r, rec)
+        return Color.new(0.0, 0.0, 0.0) unless scattered
+
+        return ray_color(scattered.ray, depth-1).multiply(scattered.attenuation)
+      end
+
+      unit_direction = r.direction.unit
+      a = 0.5*(unit_direction.y + 1.0)
+      Color.new(1.0, 1.0, 1.0).mul(1.0-a).add(Color.new(0.5, 0.7, 1.0).mul(a))
+    end
+
+    def color(pixel_color)
+      r = pixel_color.r
+      g = pixel_color.g
+      b = pixel_color.b
+
+      # Apply a linear to gamma transform for gamma 2
+      r = Util.linear_to_gamma(r)
+      g = Util.linear_to_gamma(g)
+      b = Util.linear_to_gamma(b)
+
+      # Translate the [0,1] component values to the byte range [0,255].
+      intensity = Interval.new(0.000, 0.999)
+      rbyte = (256 * intensity.clamp(r)).to_i
+      gbyte = (256 * intensity.clamp(g)).to_i
+      bbyte = (256 * intensity.clamp(b)).to_i
+
+      # Return the pixel color components.
+      [rbyte, gbyte, bbyte]
+    end
+  end
+end

data/lib/rray/util.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rray
+  module Util
+    def self.degrees_to_radians(degrees) = degrees * Math::PI / 180.0
+
+    # 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
+
+      Math.sqrt(linear_component)
+    end
+  end
+end

data/lib/rray/vec3.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Rray
+  class Vec3
+    def initialize(x = 0.0, y = 0.0, z = 0.0)
+      @e = [x, y, z]
+    end
+
+    def x = @e[0]
+    def y = @e[1]
+    def z = @e[2]
+
+    def x=(v)
+      @e[0] = v
+    end
+
+    def y=(v)
+      @e[1] = v
+    end
+
+    def z=(v)
+      @e[2] = v
+    end
+
+    def -@ = self.class.new(-x, -y, -z)
+    def [](i) = @e[i]
+
+      def []=(i, v)
+      @e[i] = v
+    end
+
+    def +(v) = Vec3.new(x+v.x, y+v.y, z+v.z)
+    def -(v) = Vec3.new(x-v.x, y-v.y, z-v.z)
+    def *(t) = Vec3.new(x*t, y*t, z*t)
+    def /(t) = self * (1.0/t)
+
+    def add(v)
+      self.x += v.x
+      self.y += v.y
+      self.z += v.z
+      self
+    end
+
+    def sub(v)
+      self.x -= v.x
+      self.y -= v.y
+      self.z -= v.z
+      self
+    end
+
+    def mul(t)
+      self.x *= t
+      self.y *= t
+      self.z *= t
+      self
+    end
+
+    def div(t)
+      mul(1.0/t)
+      self
+    end
+
+    def neg
+      self.x = -x
+      self.y = -y
+      self.z = -z
+      self
+    end
+
+    def length = Math.sqrt(length_squared)
+    def length_squared = dot(self)
+
+    def dot(v) = x*v.x + y*v.y + z*v.z
+
+    def cross(v)
+      Vec3.new(
+        y*v.z - z*v.y,
+        z*v.x - x*v.z,
+        x*v.y - y*v.x
+      )
+    end
+
+    def unit = self / length
+
+    def normalize
+      div(length)
+      self
+    end
+
+    def dup = self.class.new(*@e)
+
+    EPSILON = 1e-8
+    # Return true if the vector is close to zero in all dimensions.
+    def zero? = x.abs < EPSILON && y.abs < EPSILON && z.abs < EPSILON
+
+    def reflect(n)
+      self - n*(dot(n)*2.0)
+    end
+
+    def refract(n, etai_over_etat)
+      cos_theta = [(-self).dot(n), 1.0].min
+      r_out_perp = (self + n*cos_theta).mul(etai_over_etat)
+      r_out_parallel = n * -Math.sqrt((1.0 - r_out_perp.length_squared).abs)
+      r_out_perp.add(r_out_parallel)
+    end
+
+    def self.random(min = 0.0, max = 1.0)
+      Vec3.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)
+        return v if v.length_squared < 1
+      end
+    end
+
+    def self.random_unit_vector = random_in_unit_sphere.normalize
+
+    def self.random_on_hemisphere(normal)
+      on_unit_sphere = random_unit_vector
+      if on_unit_sphere.dot(normal) > 0.0 # In the same hemisphere as the normal
+        on_unit_sphere
+      else
+        -on_unit_sphere
+      end
+    end
+
+    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)
+        return v if v.length_squared < 1
+      end
+    end
+  end
+end

data/lib/rray/version.rb

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

data/lib/rray.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "rray/version"
+require_relative "rray/util"
+require_relative "rray/vec3"
+require_relative "rray/point3"
+require_relative "rray/color"
+require_relative "rray/ray"
+require_relative "rray/interval"
+require_relative "rray/hit"
+require_relative "rray/scatter"
+require_relative "rray/object/base"
+require_relative "rray/object/sphere"
+require_relative "rray/object/group"
+require_relative "rray/material/base"
+require_relative "rray/material/lambertian"
+require_relative "rray/material/metal"
+require_relative "rray/material/dielectric"
+require_relative "rray/camera"
+require_relative "rray/scene"
+require_relative "rray/tracer"
+
+module Rray
+  class Error < StandardError; end
+end

data/sig/rray.rbs

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

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: rray
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Danielle Smith
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-04-15 00:00:00.000000000 Z
+dependencies: []
+description: Simple raytracer written in ruby. Can be used a CLI tool or library.
+email:
+- code@danini.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rray.rb
+- lib/rray/camera.rb
+- lib/rray/color.rb
+- lib/rray/hit.rb
+- lib/rray/interval.rb
+- lib/rray/material/base.rb
+- lib/rray/material/dielectric.rb
+- lib/rray/material/lambertian.rb
+- lib/rray/material/metal.rb
+- lib/rray/object/base.rb
+- lib/rray/object/group.rb
+- lib/rray/object/sphere.rb
+- lib/rray/point3.rb
+- lib/rray/ray.rb
+- lib/rray/scatter.rb
+- lib/rray/scene.rb
+- lib/rray/tracer.rb
+- lib/rray/util.rb
+- lib/rray/vec3.rb
+- lib/rray/version.rb
+- sig/rray.rbs
+homepage: https://github.com/danini-the-panini/rray
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/danini-the-panini/rray
+  source_code_uri: https://github.com/danini-the-panini/rray
+  changelog_uri: https://github.com/danini-the-panini/rray/releases
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key: 
+specification_version: 4
+summary: Raytracer in Ruby
+test_files: []