ra 0.1.0 → 0.3.0

data/lib/ra/logger.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ra
+  # A logger used to make exe testing possible.
+  #
+  #   logger = Logger.new
+  #   logger.log("Greetings!")
+  class Logger
+    # @param stream [IO]
+    def initialize(stream: $stdout)
+      @stream = stream
+    end
+
+    # @param message [String]
+    def log(message = nil)
+      @stream.puts message
+    end
+  end
+end

data/lib/ra/material.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ra
+  # A material is used to define the properties of an object that impact the color applied. For example:
+  #
+  #   material = Ra::Material.new(
+  #    base: Ra::Color.uniform(0.5),
+  #    ambient: 0.2,
+  #    diffuse: 0.5,
+  #    specular: 0.7,
+  #    shininess: 200,
+  #   )
+  class Material
+    attr_accessor :base, :ambient, :diffuse, :specular, :shininess
+
+    # @param base [Ra::Color, Ra::Pattern:::Base]
+    # @param ambient [Float] between 0.0 and 1.0
+    # @param diffuse [Float] between 0.0 and 1.0
+    # @param specular [Float] between 0.0 and 1.0
+    # @param shininess [Numeric]
+    def initialize(base:, ambient: 0.0, diffuse: 0.8, specular: 0.2, shininess: 80)
+      @base = base
+      @ambient = ambient
+      @diffuse = diffuse
+      @specular = specular
+      @shininess = shininess
+    end
+
+    # @param point [Vector]
+    # @return [Ra::Color]
+    def color(point:)
+      return base if base.is_a?(Color)
+
+      base.color(point:)
+    end
+  end
+end

data/lib/ra/pattern/base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # An abstract pattern. Any concrete subclass of pattern must implement the method `color`.
+    class Base
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      # @return [Ra::Color]
+      def color(point:)
+        raise NotImplementedError, '#color must be implemented by a concrete subclass'
+      end
+    end
+  end
+end

data/lib/ra/pattern/checkers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A checkers pattern that alternates colors using:
+    #
+    #   colors[⌊u * rows⌋ + ⌊v * cols)⌋ % colors.count]
+    class Checkers < Base
+      DEFAULT_ROWS = 2
+      DEFAULT_COLS = 2
+      DEFAULT_COLORS = [
+        Color.black,
+        Color.white,
+      ].freeze
+
+      # @param rows [Integer]
+      # @param cols [Integer]
+      # @param colors [Array<Ra::Color>]
+      def initialize(cols: DEFAULT_COLS, rows: DEFAULT_ROWS, colors: DEFAULT_COLORS)
+        super()
+        @rows = rows
+        @cols = cols
+        @colors = colors
+      end
+
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      # @return [Ra::Color]
+      def color(point:)
+        u = point[0]
+        v = point[1]
+        index = (u * @rows).floor + (v * @cols).floor
+
+        @colors[index % @colors.count]
+      end
+    end
+  end
+end

data/lib/ra/pattern/gradient.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A graident pattern from `color_a` to `color_b` using:
+    #
+    #   color_b + (color_b - color_a) * (u + v) / 2
+    class Gradient < Base
+      # @param color_a [Ra::Color]
+      # @param color_b [Ra::Color]
+      def initialize(color_a:, color_b:)
+        super()
+        @color_a = color_a
+        @color_b = color_b
+      end
+
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      # @return [Ra::Color]
+      def color(point:)
+        u = point[0]
+        v = point[1]
+        value = (u + v) / 2
+
+        @color_a + ((@color_b - @color_a) * value)
+      end
+    end
+  end
+end

data/lib/ra/pattern/rings.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A rings pattern that alternates colors using:
+    #
+    #   colors[⌊√(u² + v²)⌋]
+    class Rings < Base
+      # @param colors [Array<Ra::Color>]
+      def initialize(colors:)
+        super()
+        @colors = colors
+      end
+
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      # @return [Ra::Color]
+      def color(point:)
+        u = point[0]
+        v = point[1]
+        index = Math.sqrt((u**2) + (v**2)).floor
+
+        @colors[index % @colors.count]
+      end
+    end
+  end
+end

data/lib/ra/pattern/stripes.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A stripe pattern that alternates colors using:
+    #
+    #   colors[⌊point.x⌋]
+    class Stripes < Base
+      # @param colors [Array<Ra::Color>]
+      def initialize(colors:)
+        super()
+        @colors = colors
+      end
+
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      # @return [Ra::Color]
+      def color(point:)
+        count = @colors.count
+        u = point[0]
+        v = point[1]
+        value = (u + v) * (2 * count)
+
+        @colors[value.floor % count]
+      end
+    end
+  end
+end

data/lib/ra/pattern/texture.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'mini_magick'
+
+module Ra
+  module Pattern
+    # A texture that can load an AVIF / JPG / PNG / BMP:
+    #
+    #   colors[⌊point.x⌋]
+    class Texture < Base
+      # @param path [Pathname]
+      def initialize(path:)
+        super()
+        @path = path
+      end
+
+      # @param point [Array<Numeric,Numeric>] <u = 0.0..1.0, v = 0.0..1.0>
+      # @return [Ra::Color]
+      def color(point:)
+        pixel = pixel(point:)
+
+        Color.new(
+          r: Float(pixel[0]) / Color::PRECISION,
+          g: Float(pixel[1]) / Color::PRECISION,
+          b: Float(pixel[2]) / Color::PRECISION,
+        )
+      end
+
+      private
+
+      # @return [Array<0..255,0..255,0..255>]
+      def pixel(point:)
+        u = point[0]
+        v = 1.0 - point[1]
+
+        x = (u * image.width.pred).round
+        y = (v * image.height.pred).round
+
+        pixels[y][x]
+      end
+
+      # @return [Array<Array<0..255,0..255,0.255>>]
+      def pixels
+        @pixels ||= image.get_pixels
+      end
+
+      def image
+        @image ||= MiniMagick::Image.open(@path)
+      end
+    end
+  end
+end

data/lib/ra/ray.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ra
+  # A ray is positioned at an origin travelling by a direction. A ray is cast and used to identify collisions with
+  # objects. For example:
+  #
+  #   ray = Ra::Ray.new(
+  #     origin: Vector[0, 0, 0, Ra::Tuple::POINT],
+  #     direction: Vector[1, 2, 3, Ra::Tuple::VECTOR],
+  #   )
+  #   ray.position(t: 1) == Vector[1, 2, 3, Ra::Tuple::VECTOR]
+  #   ray.position(t: 2) == Vector[2, 4, 6, Ra::Tuple::VECTOR]
+  #   ray.position(t: 3) == Vector[3, 6, 9, Ra::Tuple::VECTOR]
+  #
+  # A ray can be transformed. This is useful when considering the ray relative to an object that has a transform
+  # associated with it. For example:
+  #
+  #   ray = Ra::Ray.new(
+  #     origin: Vector[0, 0, 0, Ra::Tuple::POINT],
+  #     direction: Vector[1, 2, 3, Ra::Tuple::VECTOR],
+  #   )
+  #   ray.transform(transform: Ra::Transform.scale(1, 2, 3))
+  class Ray
+    attr_accessor :origin, :direction
+
+    # @param origin [Vector] e.g. Vector[1, 2, 3, Ra::Tuple::POINT]
+    # @param direction [Vector] e.g. Vector[1, 2, 3, Ra::Tuple::VECTOR]
+    def initialize(origin:, direction:)
+      @origin = origin
+      @direction = direction
+    end
+
+    # @param t [Numeric]
+    # @return [Vector]
+    def position(t:)
+      @origin + (@direction * t)
+    end
+
+    # @param transform [Ra::Transform]
+    # @return [Ra::Ray]
+    def transform(transform)
+      self.class.new(
+        origin: transform * @origin,
+        direction: transform * @direction,
+      )
+    end
+
+    # @return [Boolean]
+    def ==(other)
+      origin == other.origin && direction == other.direction
+    end
+  end
+end

data/lib/ra/shape/base.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Ra
+  module Shape
+    # An abstract shape. Any concrete subclass of shape must implement the
+    # methods `l_normal` and `t_intersect`. Both methods use a point / ray
+    # with a local transform applied.
+    class Base
+      attr_accessor :material
+
+      # @param material [Ra::Material]
+      # @param transform [Ra::Matrix]
+      def initialize(material:, transform: Transform::IDENTITY)
+        @material = material
+        @transform = transform
+      end
+
+      # @param ray [Ra::Ray]
+      # @return [Array<Ra::Intersection>]
+      def intersect(ray:)
+        t_intersect(ray: ray.transform(@transform.inverse))
+          .map { |t| Ra::Intersection.new(ray:, shape: self, t:) }
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <x, y, z, Tuple::POINT>
+      def normal(point:)
+        normal = @transform.inverse.transpose * l_normal(point: @transform.inverse * point)
+
+        Vector[normal[0], normal[1], normal[2], Ra::Tuple::VECTOR].normalize
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Color]
+      def color(point:)
+        @material.color(point: uv_point(point: @transform.inverse * point))
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point(point:)
+        raise NotImplementedError, '#uv_point must be implemented by a concrete subclass'
+      end
+
+      # @param ray [Ra::Ray] local
+      # @return [Array<Intersection>]
+      def t_intersect(ray:)
+        raise NotImplementedError, '#t_intersect must be implemented by a concrete subclass'
+      end
+
+      # @param point [Vector] local
+      # @return [Vector]
+      def l_normal(point:)
+        raise NotImplementedError, '#l_normal must be implemented by a concrete subclass'
+      end
+    end
+  end
+end

data/lib/ra/shape/cube.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Ra
+  module Shape
+    # A cube centered at <0,0,0> with sides of l=2. A cube surface is defined:
+    #
+    #   x between (-1..+1)
+    #   y between (-1..+1)
+    #   z between (-1..+1)
+    #   x = ±1 OR y = ±1 OR z = ±1
+    #
+    # A ray `x` / `y` / `z` values at `t` use the `origin` and `direction`:
+    #
+    #   x = origin.x + direction.x * t
+    #   y = origin.y + direction.y * t
+    #   z = origin.z + direction.z * t
+    #
+    # The ray therefore may intersect when:
+    #
+    #   origin.x + direction.x * t = ±1 OR origin.y + direction.y * t = ±1 OR origin.z + direction.z * t = ±1
+    #
+    # Thus 6 planes can be checked for intersect.
+    class Cube < Base
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point(point:)
+        x = point[0]
+        y = point[1]
+        z = point[2]
+        value = [x, y, z].max_by(&:abs)
+
+        case value
+        when x then x.positive? ? uv_point_r(point:) : uv_point_l(point:)
+        when y then y.positive? ? uv_point_u(point:) : uv_point_d(point:)
+        else        z.positive? ? uv_point_f(point:) : uv_point_b(point:)
+        end
+      end
+
+      # @param ray [Ra::Ray] local
+      # @return [Array<Numeric>]
+      def t_intersect(ray:)
+        t_min = t_min(ray:)
+        t_max = t_max(ray:)
+
+        return [] if !t_min || !t_max || t_min > t_max
+
+        [
+          t_min,
+          t_max,
+        ]
+      end
+
+      # @param point [Vector]
+      # @return [Ra::Tuple]
+      def l_normal(point:)
+        x = point[0].abs
+        y = point[1].abs
+        z = point[2].abs
+
+        Vector[
+          (is_x = x > y && x > z) ? 1 : 0,
+          (is_y = y > x && y > z) ? 1 : 0,
+          is_x || is_y ? 0 : 1,
+          Ra::Tuple::VECTOR
+        ]
+      end
+
+      private
+
+      # @param ray [Ra::Ray]
+      # @return [Integer]
+      def t_min(ray:)
+        (0..2).map { |i| t_min_max(ray.origin[i], ray.direction[i]).min }.max
+      end
+
+      # @param ray [Ra::Ray]
+      # @return [Integer]
+      def t_max(ray:)
+        (0..2).map { |i| t_min_max(ray.origin[i], ray.direction[i]).max }.min
+      end
+
+      # @param origin [Numeric]
+      # @param direction [Numeric]
+      # @return [Array<Numeric,Numeric>]
+      def t_min_max(origin, direction)
+        t_min_numerator = -1 - origin
+        t_max_numerator = +1 - origin
+
+        if direction.abs < EPSILON
+          t_min = t_min_numerator * Float::INFINITY
+          t_max = t_max_numerator * Float::INFINITY
+        else
+          t_min = t_min_numerator / direction
+          t_max = t_max_numerator / direction
+        end
+
+        t_min < t_max ? [t_min, t_max] : [t_max, t_min]
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point_u(point:)
+        Vector[
+          ((point[0] + 1) % 2) / 2,
+          ((1 - point[2]) % 2) / 2,
+        ]
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point_d(point:)
+        Vector[
+          ((point[0] + 1) % 2) / 2,
+          ((point[2] + 1) % 2) / 2,
+        ]
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point_l(point:)
+        Vector[
+          ((point[2] + 1) % 2) / 2,
+          ((point[1] + 1) % 2) / 2,
+        ]
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point_r(point:)
+        Vector[
+          ((1 - point[2]) % 2) / 2,
+          ((point[1] + 1) % 2) / 2,
+        ]
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point_b(point:)
+        Vector[
+          ((1 - point[0]) % 2) / 2,
+          ((point[1] + 1) % 2) / 2,
+        ]
+      end
+
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point_f(point:)
+        Vector[
+          ((point[0] + 1) % 2) / 2,
+          ((point[1] + 1) % 2) / 2,
+        ]
+      end
+    end
+  end
+end

data/lib/ra/shape/plane.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ra
+  module Shape
+    # A plane for all x / z where y = 0. A plane surface is defined:
+    #
+    #   y = 0
+    #
+    # A ray `x` / `y` / `z` values at `t` use the `origin` and `direction`:
+    #
+    #   x = origin.x + direction.x * t
+    #   y = origin.y + direction.y * t
+    #   z = origin.z + direction.z * t
+    #
+    # Therefore, a plane has a single intersection at:
+    #
+    #   t = -origin.y / direction.y
+    #
+    # A direction.y < EPISLON indicates the ray does not intersect the plane.
+    class Plane < Base
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point(point:)
+        Vector[
+          point[0] % 1, # u = x % 1
+          point[2] % 1, # v = y % 2
+        ]
+      end
+
+      # @param ray [Ra::Ray] local
+      # @return [Array<Numeric>]
+      def t_intersect(ray:)
+        origin_y = ray.origin[1]
+        direction_y = ray.direction[1]
+
+        return [] if direction_y.abs < EPSILON
+
+        [-origin_y / direction_y]
+      end
+
+      # @return [Ra::Tuple]
+      def l_normal(*)
+        Vector[
+          0,
+          1,
+          0,
+          Ra::Tuple::VECTOR
+        ]
+      end
+    end
+  end
+end

data/lib/ra/shape/sphere.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Ra
+  module Shape
+    # A sphere at origin <0,0,0> with a radius 1. A sphere surface is defined:
+    #
+    #   x² + y² + z² = radius²
+    #
+    # A unit radius simplifies further:
+    #
+    #   x² + y² + z² = 1
+    #
+    # A ray `x` / `y` / `z` values at `t` use the `origin` and `direction`:
+    #
+    #   x = origin.x + direction.x * t
+    #   y = origin.y + direction.y * t
+    #   z = origin.z + direction.z * t
+    #
+    # Substituting `x` / `y` / `z` allows for solving for `t`:
+    #
+    #   1 = (origin.x + direction.x * t)²
+    #     + (origin.y + direction.y * t)²
+    #     + (origin.z + direction.z * t)²
+    #
+    # Simplifying gives us a quadratic formula with terms defined as:
+    #
+    #   a = direction.x² + direction.y² + direction.z²
+    #   b = 2 * ((origin.x * direction.x) + (origin.y * direction.y) + (origin.z * direction.z))
+    #   c = origin.x² + origin.y² + origin.z² - 1
+    #   discriminant = b² - 4ac
+    #   t = (-b ± √discriminant) / (2a)
+    #
+    # A discriminant <0 indicates the ray does not intersect the sphere.
+    class Sphere < Base
+      # @param point [Vector] <x, y, z, Tuple::POINT>
+      # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
+      def uv_point(point:)
+        x = point[0]
+        y = point[1]
+        z = point[2]
+
+        radius = Vector[x, y, z].magnitude
+        theta = Math.atan2(x, z)
+        phi = Math.acos(y / radius)
+
+        u = 1 - ((theta / (2 * Math::PI)) + 0.5)
+        v = 1 - (phi / Math::PI)
+
+        Vector[u, v]
+      end
+
+      # @param ray [Ra::Ray] local
+      # @return [Array<Numeric>]
+      def t_intersect(ray:)
+        origin = ray.origin - Vector[0, 0, 0, Ra::Tuple::POINT]
+        direction = ray.direction
+
+        quadratic(
+          a: direction.dot(direction),
+          b: 2 * direction.dot(origin),
+          c: origin.dot(origin) - 1,
+        )
+      end
+
+      # @param point [Vector]
+      # @return [Ra::Tuple]
+      def l_normal(point:)
+        point - Vector[0, 0, 0, Ra::Tuple::VECTOR]
+      end
+
+      private
+
+      # (-b ± √(b² - 4ac)) / (2a)
+      #
+      # @param a [Numeric]
+      # @param b [Numeric]
+      # @param c [Numeric]
+      # @return [Array<Numeric>]
+      def quadratic(a:, b:, c:)
+        discriminant = (b**2) - (4 * a * c)
+        return [] if discriminant.negative?
+
+        [
+          (-b - Math.sqrt(discriminant)) / (2 * a),
+          (-b + Math.sqrt(discriminant)) / (2 * a),
+        ]
+      end
+    end
+  end
+end

data/lib/ra/surface.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ra
+  # A surface contains everything needed to apply lighting.
+  class Surface
+    attr_accessor :eyev, :normalv, :shape, :point
+
+    # @param eyev [Vector]
+    # @param normalv [Vector]
+    # @param shape [Ra::Shape]
+    # @param point [Vector]
+    def initialize(eyev:, normalv:, shape:, point:)
+      @eyev = eyev
+      @normalv = normalv.dot(eyev).negative? ? -normalv : +normalv
+      @shape = shape
+      @point = point
+    end
+
+    # @return [Vector]
+    def hpoint
+      @hpoint ||= point + (normalv * EPSILON)
+    end
+  end
+end