raysetta 0.1.0

data/lib/raysetta/texture/checker.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Texture
+    class Checker < Base
+      attr_accessor :inv_scale, :even, :odd
+
+      def initialize(scale, even, odd)
+        self.scale = scale
+        @even = even
+        @odd = odd
+      end
+
+      def self.solid(scale, even, odd)
+        new(scale, SolidColor.new(even), SolidColor.new(odd))
+      end
+
+      def scale=(scale)
+        @inv_scale = 1.0 / scale
+      end
+
+      def scale
+        1.0 / @inv_scale
+      end
+
+      def sample(uv, point)
+        x = (inv_scale * point.x).floor
+        y = (inv_scale * point.y).floor
+        z = (inv_scale * point.z).floor
+
+
+        (x + y + z).even? ? even.sample(uv, point) : odd.sample(uv, point)
+      end
+
+      def ==(tex)
+        inv_scale == tex.inv_scale &&
+        even == tex.even &&
+        odd == tex.odd
+      end
+
+      def hash
+        [inv_scale, even, odd].hash
+      end
+
+      def export
+        {
+          **super,
+          scale: scale,
+          even: even.export,
+          odd: odd.export
+        }
+      end
+    end
+  end
+end

data/lib/raysetta/texture/image.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Texture
+    class Image < Base
+      attr_accessor :image
+
+      def initialize(image)
+        @image = image
+      end
+
+      def sample(uv, point)
+        # Clamp input texture coordinates to [0,1] x [1,0]
+        u = uv.u.clamp(0.0, 1.0)
+        v = 1.0 - uv.v.clamp(0.0, 1.0)
+
+        x = u*image.width + 0.5
+        y = v*image.height + 0.5
+
+        x1 = x.floor
+        y1 = y.floor
+
+        x2 = x.ceil
+        y2 = y.ceil
+
+        x2 = x1+1 if x2 == x1
+        y2 = y1+1 if y2 == y1
+        
+        q11 = image[x1.to_i, y1.to_i]
+        q12 = image[x1.to_i, y2.to_i]
+        q21 = image[x2.to_i, y1.to_i]
+        q22 = image[x2.to_i, y2.to_i]
+
+        (q11*(x2-x)*(y2-y)+q21*(x-x1)*(y2-y)+q12*(x2-x)*(y-y1)+q22*(x-x1)*(y-y1)) / ((x2-x1)*(y2-y1)).to_f
+      end
+
+      def ==(tex)
+        image == tex.image
+      end
+
+      def hash
+        [type, image].hash
+      end
+
+      def export
+        {
+          **super,
+          image: image.id
+        }
+      end
+
+      def images
+        [image]
+      end
+    end
+  end
+end

data/lib/raysetta/texture/noise.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Texture
+    class Noise < Base
+      attr_accessor :scale, :depth, :marble_axis
+
+      def initialize(scale, depth, marble_axis, noise=Perlin.new)
+        @scale = scale
+        @depth = depth
+        @marble_axis = marble_axis
+        @noise = noise
+      end
+
+      def sample(uv, point)
+        if marble_axis
+          Vec3.new(0.5) * (1.0 + Math.sin(scale * point.send(marble_axis) + 10.0 * @noise.turb(point, depth)))
+        else
+          Vec3.new(1.0) * @noise.turb(point, depth)
+        end
+      end
+
+      def ==(tex)
+        scale == tex.scale &&
+        depth == tex.depth &&
+        marble_axis == tex.marble_axis &&
+        noise == tex.noise
+      end
+
+      def hash
+        [scale, depth, marble_axis, noise].hash
+      end
+
+      def export
+        { **super, scale:, depth:, marble_axis: marble_axis.to_s, noise: @noise.id }
+      end
+
+      def noises
+        [@noise]
+      end
+
+      protected
+      attr_reader :noise
+    end
+  end
+end

data/lib/raysetta/texture/solid_color.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Texture
+    class SolidColor < Base
+      attr_accessor :albedo
+
+      def initialize(albedo)
+        @albedo = albedo
+      end
+
+      def self.rgb(r, g, b)
+        new(Vec3.new(r, g, b))
+      end
+
+      def sample(uv, point)
+        albedo
+      end
+
+      def ==(tex)
+        albedo == tex.albedo
+      end
+
+      def hash
+        [type, albedo].hash
+      end
+
+      def export
+        {
+          **super,
+          albedo: albedo.to_a
+        }
+      end
+    end
+  end
+end

data/lib/raysetta/tracer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Raysetta
+  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 = Vec3.new
+      samples_per_pixel.times do
+        pixel_color.add(ray_color(scene.camera.ray(x, y)))
+      end
+      pixel_color.mul(@pixel_sample_scale).to_pixel
+    end
+
+    def ray_color(r, depth = max_depth)
+      # If we've exceeded the ray bounce limit, no more light is gathered.
+      return Vec3.new unless depth > 0
+
+      rec = scene.world.hit(r, 0.001..Float::INFINITY)
+      # If the ray hits nothing, return the background color.
+      return scene.background.sample(r) unless rec
+
+      emitted = rec.material.emitted(rec.uv, rec.point)
+      scatter = rec.material.scatter(r, rec)
+      return emitted unless scatter
+
+      scattered = ray_color(scatter.ray, depth - 1).times(scatter.attenuation)
+
+      emitted + scattered
+    end
+  end
+end

data/lib/raysetta/util.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Raysetta
+  module Util
+    EPSILON = 1e-8
+
+    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.linear_to_gamma(linear_component)
+      return 0.0 unless linear_component > 0.0
+
+      Math.sqrt(linear_component)
+    end
+
+    def self.gamma_to_linear(gamma_component, gamma = 2.2)
+      return 0.0 unless gamma_component > 0.0
+
+      gamma_component ** gamma
+    end
+
+    def self.sphere_uv(point)
+      # point: a given point on the sphere of radius one, centered at the origin.
+      # u:     returned value [0,1] of angle around the Y axis from X=-1.
+      # v:     returned value [0,1] of angle from Y=-1 to Y=+1.
+      #     <1 0 0> yields <0.50 0.50>       <-1  0  0> yields <0.00 0.50>
+      #     <0 1 0> yields <0.50 1.00>       < 0 -1  0> yields <0.50 0.00>
+      #     <0 0 1> yields <0.25 0.50>       < 0  0 -1> yields <0.75 0.50>
+
+      theta = Math.acos(-point.y);
+      phi = Math.atan2(-point.z, point.x) + Math::PI;
+
+      Vec2.new(phi / (2.0*Math::PI), theta / Math::PI)
+    end
+  end
+end

data/lib/raysetta/vec2.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Vec2
+    attr_accessor :x, :y
+
+    alias :u :x
+    alias :v :y
+
+    alias :u= :x=
+    alias :v= :y=
+
+    def initialize(x = 0.0, y = x)
+      @x = x
+      @y = y
+    end
+
+    def self.random(min = 0.0, max = 1.0)
+      Vec2.new(Util.random(min, max), Util.random(min, max))
+    end
+
+    def self.sample_square = new(rand - 0.5, rand - 0.5)
+
+    def to_a = [x, y]
+    alias :to_ary :to_a
+
+    def [](i)
+      return x if i == 0
+      return y if i == 1
+      0.0
+    end
+
+    def []=(i, v)
+      self.x = v if i == 0
+      self.y = v if i == 1
+    end
+
+    def -@
+      Vec2.new(-x, -y)
+    end
+
+    def +(v) = Vec2.new(x + v.x, y + v.y)
+    def -(v) = Vec2.new(x - v.x, y - v.y)
+    def *(t) = Vec2.new(x * t, y * t)
+    def /(t) = self * (1.0/t)
+
+    def add(v)
+      self.x += v.x
+      self.y += v.y
+      self
+    end
+
+    def sub(v)
+      self.x -= v.x
+      self.y -= v.y
+      self
+    end
+
+    def mul(t)
+      self.x *= t
+      self.y *= t
+      self
+    end
+
+    def div(t)
+      mul(1.0/t)
+      self
+    end
+
+    def neg
+      self.x = -x
+      self.y = -y
+      self
+    end
+
+    def length = Math.sqrt(length_squared)
+    def length_squared = dot(self)
+
+    def dot(v)
+      x * v.x + y * v.y
+    end
+
+    def unit = self / length
+
+    def normalize
+      div(length)
+      self
+    end
+
+    def dup = Vec2.new(x, y)
+
+    def abs!
+      self.x = x.abs
+      self.y = y.abs
+      self
+    end
+
+    def abs
+      Vec2.new(x.abs, y.abs)
+    end
+
+    # Return true if the vector is close to zero in all dimensions.
+    def zero?
+      x.abs < Util::EPSILON &&
+      y.abs < Util::EPSILON
+    end
+
+    def to_s
+      "(#{x}, #{y})"
+    end
+
+    def ==(v)
+      (x - v.x).abs < Util::EPSILON && (y - v.y).abs < Util::EPSILON
+    end
+    alias :eql? :==
+
+    def eql?(v)
+      x == v.x && y == v.y
+    end
+
+    def hash
+      [x, y].hash
+    end
+  end
+end

data/lib/raysetta/vec3.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Vec3
+    attr_accessor :x, :y, :z
+
+    alias :r :x
+    alias :g :y
+    alias :b :z
+
+    alias :r= :x=
+    alias :g= :y=
+    alias :b= :z=
+
+    def initialize(x = 0.0, y = x, z = y)
+      @x = x
+      @y = y
+      @z = 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))
+    end
+
+    def self.random_in_unit_sphere
+      loop do
+        v = random(-1.0, 1.0)
+        return v if v.length_squared < 1
+      end
+    end
+
+    def self.random_unit = random_in_unit_sphere.normalize
+
+    def self.random_on_hemisphere(normal)
+      on_unit_sphere = random_unit
+      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 = 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 to_a = [x, y, z]
+    alias :to_ary :to_a
+
+    def [](i)
+      return x if i == 0
+      return y if i == 1
+      return z if i == 2
+      0.0
+    end
+
+    def []=(i, v)
+      self.x = v if i == 0
+      self.y = v if i == 1
+      self.z = v if i == 2
+    end
+
+    def -@
+      Vec3.new(-x, -y, -z)
+    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 multiply(v)
+      self.x *= v.x
+      self.y *= v.y
+      self.z *= v.z
+      self
+    end
+
+    def times(v)
+      dup.multiply(v)
+    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
+    end
+
+    def unit = self / length
+
+    def normalize
+      div(length)
+      self
+    end
+
+    def dup = Vec3.new(x, y, z)
+
+    def abs!
+      self.x = x.abs
+      self.y = y.abs
+      self.z = z.abs
+      self
+    end
+
+    def abs
+      Vec3.new(x.abs, y.abs, z.abs)
+    end
+
+    def smoothstep!
+      self.x = x**2 * (3.0 - 2.0 * x)
+      self.y = y**2 * (3.0 - 2.0 * y)
+      self.z = z**2 * (3.0 - 2.0 * z)
+      self
+    end
+    def smoothstep = dup.smoothstep!
+
+    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 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 to_pixel
+      # Apply a linear to gamma transform for gamma 2
+      rg = Util.linear_to_gamma(r)
+      gg = Util.linear_to_gamma(g)
+      bg = 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(rg)).to_i
+      gbyte = (256 * intensity.clamp(gg)).to_i
+      bbyte = (256 * intensity.clamp(bg)).to_i
+
+      # Return the pixel color components.
+      [rbyte, gbyte, bbyte]
+    end
+
+    def zero?
+      x.abs < Util::EPSILON &&
+      y.abs < Util::EPSILON &&
+      z.abs < Util::EPSILON
+    end
+
+    def to_s
+      "(#{x}, #{y}, #{z})"
+    end
+
+    def ==(v)
+      (x - v.x).abs < Util::EPSILON &&
+      (y - v.y).abs < Util::EPSILON &&
+      (z - v.z).abs < Util::EPSILON
+    end
+    alias :eql? :==
+
+    def eql?(v)
+      x == v.x && y == v.y && z == v.z
+    end
+
+    def hash
+      [x, y, z].hash
+    end
+  end
+end

data/lib/raysetta/version.rb

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

data/lib/raysetta.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Raysetta
+  class Error < StandardError; end
+end
+
+require_relative "raysetta/version"
+require_relative "raysetta/util"
+require_relative "raysetta/vec2"
+require_relative "raysetta/vec3"
+require_relative "raysetta/ray"
+require_relative "raysetta/interval"
+require_relative "raysetta/aabb"
+require_relative "raysetta/hit"
+require_relative "raysetta/scatter"
+require_relative "raysetta/entity_base"
+require_relative "raysetta/image"
+require_relative "raysetta/perlin"
+require_relative "raysetta/object/base"
+require_relative "raysetta/object/bvh"
+require_relative "raysetta/object/group"
+require_relative "raysetta/object/sphere"
+require_relative "raysetta/object/moving_sphere"
+require_relative "raysetta/object/quad"
+require_relative "raysetta/object/tri"
+require_relative "raysetta/object/box"
+require_relative "raysetta/material/base"
+require_relative "raysetta/material/lambertian"
+require_relative "raysetta/material/metal"
+require_relative "raysetta/material/dielectric"
+require_relative "raysetta/material/diffuse_light"
+require_relative "raysetta/texture/base"
+require_relative "raysetta/texture/solid_color"
+require_relative "raysetta/texture/checker"
+require_relative "raysetta/texture/image"
+require_relative "raysetta/texture/noise"
+require_relative "raysetta/background/base"
+require_relative "raysetta/background/solid"
+require_relative "raysetta/background/gradient"
+require_relative "raysetta/background/sphere_map"
+require_relative "raysetta/background/cube_map"
+require_relative "raysetta/camera"
+require_relative "raysetta/scene"
+require_relative "raysetta/tracer"

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "4.0.2"

data/scenes/box.json

@@ -0,0 +1,26 @@
+{
+  "world": {
+    "box":  { "type": "Box", "a": [-1.0, -2.0, -1.0], "b": [1.0, 2.0, 1.0], "material": "mat" }
+  },
+  "materials": {
+    "mat":     { "type": "Lambertian", "texture": "col" }
+  },
+  "textures": {
+    "col": { "type": "SolidColor", "albedo": [1.0, 0.2, 1.0] }
+  },
+  "images": {},
+  "noises": {},
+  "camera": {
+    "vfov": 80.0,
+    "lookfrom": [4.5, 4.5, 4.5],
+    "lookat": [0.0, 0.0, 0.0],
+    "vup": [0.0, 1.0, 0.0],
+    "defocus_angle": 0.0,
+    "focus_dist": 10.0
+  },
+  "background": {
+    "type": "Gradient",
+    "top": [0.5, 0.7, 1.0],
+    "bottom": [1.0, 1.0, 1.0]
+  }
+}