ra 0.1.0 → 0.2.0

data/lib/ra/lighting.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Ra
+  # Lighting encaspulates a [Phong Reflection Model](https://en.wikipedia.org/wiki/phong_reflection_model).
+  class Lighting
+    attr_accessor :light, :surface, :shadowed
+
+    # @param light [Ra::Light]
+    # @param surface [Ra::Surface]
+    # @param shadowed [Boolean]
+    def initialize(light:, surface:, shadowed:)
+      @surface = surface
+      @shadowed = shadowed
+      @light = light
+    end
+
+    # @param shadowed [Boolean]
+    # @return [Ra::Color]
+    def color
+      ambient_color + diffuse_color + specular_color
+    end
+
+    private
+
+    # @param [Ra::Shape]
+    def shape
+      surface.shape
+    end
+
+    # @return [Vector]
+    def point
+      surface.point
+    end
+
+    # @return [Vector]
+    def normalv
+      surface.normalv
+    end
+
+    # @return [Vector]
+    def eyev
+      surface.eyev
+    end
+
+    # @return [Ra::Material]
+    def material
+      shape.material
+    end
+
+    # @return [Ra::Vector]
+    def lightv
+      @lightv ||= (light.position - point).normalize
+    end
+
+    # @return [Ra::Vector]
+    def reflectv
+      @reflectv ||= -(lightv - (normalv * 2 * lightv.dot(normalv)))
+    end
+
+    # @return [Ra::Vector]
+    def light_dot_normal
+      @light_dot_normal ||= lightv.dot(normalv)
+    end
+
+    # @return [Ra::Vector]
+    def reflect_dot_eye
+      @reflect_dot_eye ||= reflectv.dot(eyev)
+    end
+
+    # @return [Ra::Color]
+    def ambient_color
+      @ambient_color ||= effective_color * material.ambient
+    end
+
+    # @return [Ra::Color, nil]
+    def diffuse_color
+      return if shadowed
+      return if light_dot_normal.negative?
+
+      @diffuse_color ||= effective_color * material.diffuse * light_dot_normal
+    end
+
+    # @return [Ra::Color, nil]
+    def specular_color
+      return if shadowed
+      return if light_dot_normal.negative?
+      return unless reflect_dot_eye.positive?
+
+      @specular_color ||= light.intensity * material.specular * (reflect_dot_eye**material.shininess)
+    end
+
+    # @return [Ra::Color]
+    def effective_color
+      @effective_color ||= shape.color(point:) * light.intensity
+    end
+  end
+end

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.2, diffuse: 0.6, specular: 0.6, shininess: 200)
+      @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,31 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # An abstract pattern. Any concrete subclass of pattern must implement the
+    # method `local_color`.
+    class Base
+      attr_accessor :transform
+
+      # @param transform [Ra::Matrix]
+      def initialize(transform: Transform::IDENTITY)
+        @transform = transform
+      end
+
+      # @param point [Vector]
+      # @return [Ra::Color]
+      def color(point:)
+        local_point = transform.inverse * point
+        local_color(local_point:)
+      end
+
+      protected
+
+      # @param local_point [Vector]
+      # @return [Ra::Color]
+      def local_color(local_point:)
+        raise NotImplementedError, '#local_color must be implemented by a concrete subclass'
+      end
+    end
+  end
+end

data/lib/ra/pattern/checkers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A checkers pattern that alternates colors using:
+    #
+    #   colors[⌊√(point.x² + point.z²)⌋]
+    class Checkers < Base
+      attr_accessor :colors
+
+      # @param colors [Array<Ra::Color>]
+      # @param transform [Ra::Matrix]
+      def initialize(colors:, transform: Transform::IDENTITY)
+        super(transform:)
+        @colors = colors
+      end
+
+      protected
+
+      # @param local_point [Vector]
+      # @return [Ra::Color]
+      def local_color(local_point:)
+        x = local_point[0]
+        y = local_point[1]
+        z = local_point[2]
+        index = x.floor + y.floor + z.floor
+
+        colors[index % colors.count]
+      end
+    end
+  end
+end

data/lib/ra/pattern/gradient.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A graident pattern from `color_a` to `color_b` using:
+    #
+    #   color_b + (color_b - color_a) * (point.x - point.x.floor)
+    class Gradient < Base
+      # @param color_a [Ra::Color]
+      # @param color_b [Ra::Color]
+      # @param transform [Ra::Matrix]
+      def initialize(color_a:, color_b:, transform: Transform::IDENTITY)
+        super(transform:)
+        @color_a = color_a
+        @color_b = color_b
+      end
+
+      protected
+
+      # @param local_point [Vector]
+      # @return [Ra::Color]
+      def local_color(local_point:)
+        value = local_point[0]
+        fraction = value - value.floor
+        @color_a + ((@color_b - @color_a) * fraction)
+      end
+    end
+  end
+end

data/lib/ra/pattern/rings.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A rings pattern that alternates colors using:
+    #
+    #   colors[⌊√(point.x² + point.z²)⌋]
+    class Rings < Base
+      attr_accessor :colors
+
+      # @param colors [Array<Rays::Color>]
+      # @param transform [Rays::Matrix]
+      def initialize(colors:, transform: DEFAULT_TRANSFORM)
+        super(transform:)
+        @colors = colors
+      end
+
+      protected
+
+      # @param local_point [Vector]
+      # @return [Rays::Color]
+      def local_color(local_point:)
+        x = local_point[0]
+        z = local_point[2]
+        index = Math.sqrt((x**2) + (z**2)).floor
+
+        colors[index % colors.count]
+      end
+    end
+  end
+end

data/lib/ra/pattern/stripes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ra
+  module Pattern
+    # A stripe pattern that alternates colors using:
+    #
+    #   colors[⌊point.x⌋]
+    class Stripes < Base
+      attr_accessor :colors
+
+      # @param colors [Array<Ra::Color>]
+      # @param transform [Ra::Matrix]
+      def initialize(colors:, transform: Transform::IDENTITY)
+        super(transform:)
+        @colors = colors
+      end
+
+      protected
+
+      # @param local_point [Vector]
+      # @return [Ra::Color]
+      def local_color(local_point:)
+        x = local_point[0]
+        index = x.floor
+
+        colors[index % colors.count]
+      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,54 @@
+# 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, :transform
+
+      # @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]
+      # @return [Vector]
+      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]
+      # @return [Color]
+      def color(point:)
+        @material.color(point: transform.inverse * point)
+      end
+
+      private
+
+      # @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,89 @@
+# 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
+      protected
+
+      # @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]
+      # @param value [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
+    end
+  end
+end

data/lib/ra/shape/plane.rb

@@ -0,0 +1,45 @@
+# 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
+      protected
+
+      # @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,75 @@
+# 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
+      protected
+
+      # @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
+      point + (normalv * EPSILON)
+    end
+  end
+end