ra 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3789cd972787fd603b8b9fb569a1c57ee339d908ccb3b28b27cc66631f9568ef
-  data.tar.gz: 748652af8fde85dbeb80fbdfc2cf4fd33756938654522d9f3c2b03f739bcadad
+  metadata.gz: 96608d9848ea1181d69813cd6a37cfcc5cb0ac04564048ed4b2a9d6f4af27414
+  data.tar.gz: a1bfbd9254cc6c56abab623bdf65d9a3282904c4b43039c3609934a2d8d273b1
 SHA512:
-  metadata.gz: 862fb845e4379218540100334fb7366f9ecf1674d1026da473ddc6c783bf228b6483512bf51d0c83218ec650ff1959e61a48756953da1a6118aae165c4057f77
-  data.tar.gz: 9d21e31c6fda9b0795316ea2a9690fd087d646b5758ab873d82fb2aebec377cd08327a0eefde9cea00d8ff4e1088ddbb015691f7e16baee509b967918b07bcd6
+  metadata.gz: b63eba61eb50a16fc55388b409b27dde40e092009f920ffe614fb15e29683ac58b129a2bf3848c0944b220ed2b6aca1cfb434a2441d050a601a801fb60c5e0ae
+  data.tar.gz: 004eb7ca2f72a3804f62332f1f909cd2875dbc46928ea6392e22b32a34ae5a3ea55117a6bda5dfd15b84b33d8f1c3d990517b10b1d64ed08497e3fe5b8619750

data/README.md

@@ -1,6 +1,6 @@
 # Ra
 
-Named for ["Ra"](https://en.wikipedia.org/wiki/Ra).
+Named for [Ra](https://en.wikipedia.org/wiki/Ra) - arguably the original ray tracer.
 
 ## Installation
 
@@ -11,7 +11,8 @@ gem install ra
 ## Usage
 
 ```sh
-ra -w 2560 -h 2048 | convert - sample.avif
+ra -w 2560 -h 2048 > sample.ppm
+convert -quality 80  sample.ppm sample.avif
 ```
 
 ![Sample](./sample.avif)

data/exe/ra

@@ -8,8 +8,8 @@ require 'slop'
 config = Slop.parse(ARGV) do |options|
   options.banner = 'Usage: ra -w 2560 -h 2048 | convert - sample.avif'
 
-  options.integer '-w', '--width', 'width', default: 1280
-  options.integer '-h', '--height', 'height', default: 1024
+  options.integer '-w', '--width', 'width', default: 2560
+  options.integer '-h', '--height', 'height', default: 2048
   options.integer '-fov', 'degrees', default: 60
 
   options.on('--help', 'help') do
@@ -23,9 +23,16 @@ config = Slop.parse(ARGV) do |options|
   end
 end
 
-light = Ra::Light.new(
-  position: Vector[+5, +7, -9, Ra::Tuple::POINT],
-  intensity: Ra::Color.white,
+earth = Ra::Pattern::Texture.new(path: File.join(File.dirname(__FILE__), '..', 'textures/earth.avif'))
+
+light_l = Ra::Light.new(
+  position: Vector[+5, +3, -9, Ra::Tuple::POINT],
+  intensity: Ra::Color.uniform(0.5),
+)
+
+light_r = Ra::Light.new(
+  position: Vector[-5, +3, -9, Ra::Tuple::POINT],
+  intensity: Ra::Color.uniform(0.5),
 )
 
 camera = Ra::Camera.new(
@@ -33,95 +40,98 @@ camera = Ra::Camera.new(
   h: config[:h],
   fov: config[:fov] * Math::PI / 180,
   transform: Ra::Transform.view(
-    from: Vector[0, +1.5, -5.0, Ra::Tuple::POINT],
-    to: Vector[0, 0, +1.0, Ra::Tuple::POINT],
+    from: Vector[0, +1.5, -4.0, Ra::Tuple::POINT],
+    to: Vector[0, 0, 0, Ra::Tuple::POINT],
     up: Vector[0, 1, 0, Ra::Tuple::VECTOR],
   ),
 )
 
-floor_material = Ra::Material.new(base: Ra::Pattern::Checkers.new(
-  colors: [
-    Ra::Color.hex('#e2e8f0'),
-    Ra::Color.hex('#94a3b8'),
-  ],
-  transform: Ra::Transform
-    .scale(0.4, 0.4, 0.4)
-    .translate(0, +0.2, 0),
-))
-
-wall_material = Ra::Material.new(base: Ra::Pattern::Stripes.new(
-  colors: [
-    Ra::Color.hex('#94a3b8'),
-    Ra::Color.hex('#475569'),
-  ],
+floor = Ra::Shape::Plane.new(
+  material: Ra::Material.new(
+    base: Ra::Pattern::Checkers.new(
+      colors: [
+        Ra::Color.hex('#e2e8f0'),
+        Ra::Color.hex('#1e293b'),
+      ],
+    ),
+    reflective: 0.2,
+  ),
   transform: Ra::Transform
-    .rotate_x(Math::PI / 4)
     .rotate_y(Math::PI / 4)
-    .scale(0.2, 0.2, 0.2),
-))
-
-floor = Ra::Shape::Plane.new(
-  material: floor_material,
+    .scale(0.5, 0.5, 0.5),
 )
 
 wall_l = Ra::Shape::Plane.new(
-  material: wall_material,
+  material: Ra::Material.new(
+    base: Ra::Pattern::Stripes.new(
+      colors: [
+        Ra::Color.hex('#f5f5f4'),
+        Ra::Color.hex('#e7e5e4'),
+      ],
+    ),
+  ),
   transform: Ra::Transform
-    .translate(0, 0, +5.0)
+    .translate(0, 0, +3.0)
     .rotate_y(-Math::PI / 4)
     .rotate_x(Math::PI / 2),
 )
 
 wall_r = Ra::Shape::Plane.new(
-  material: wall_material,
+  material: Ra::Material.new(
+    base: Ra::Pattern::Stripes.new(
+      colors: [
+        Ra::Color.hex('#f5f5f4'),
+        Ra::Color.hex('#e7e5e4'),
+      ],
+    ),
+  ),
   transform: Ra::Transform
-    .translate(0, 0, +5.0)
+    .translate(0, 0, +3.0)
     .rotate_y(Math::PI / 4)
     .rotate_x(Math::PI / 2),
 )
 
 sphere = Ra::Shape::Sphere.new(
-  material: Ra::Material.new(base: Ra::Pattern::Rings.new(
-    colors: [
-      Ra::Color.hex('#f87171'),
-      Ra::Color.hex('#dc2626'),
-    ],
-    transform: Ra::Transform
-      .rotate_x(Math::PI / 4)
-      .rotate_y(Math::PI / 4)
-      .scale(0.2, 0.2, 0.2),
-  )),
+  material: Ra::Material.new(base: earth),
   transform: Ra::Transform
     .translate(0, +0.5, -2.0)
+    .rotate_y(Math::PI / 2)
     .scale(0.5, 0.5, 0.5),
 )
 
 cube_l = Ra::Shape::Cube.new(
-  material: Ra::Material.new(base: Ra::Pattern::Gradient.new(
-    color_a: Ra::Color.hex('#f43f5e'),
-    color_b: Ra::Color.hex('#8b5cf6'),
-    transform: Ra::Transform
-      .translate(1.0, 1.0, 1.0)
-      .scale(3.0, 3.0, 3.0),
-  )),
+  material: Ra::Material.new(
+    base: Ra::Pattern::Gradient.new(
+      color_a: Ra::Color.hex('#f43f5e'),
+      color_b: Ra::Color.hex('#8b5cf6'),
+    ),
+    reflective: 0.2,
+  ),
   transform: Ra::Transform
-    .translate(+1.0, +0.3, -1.5)
-    .scale(0.3, 0.3, 0.3),
+    .translate(+1.0, +0.3, -1.0)
+    .scale(0.3, 0.3, 0.3)
+    .rotate_y(-Math::PI / 8),
 )
 
 cube_r = Ra::Shape::Cube.new(
-  material: Ra::Material.new(base: Ra::Pattern::Gradient.new(
-    color_a: Ra::Color.hex('#84cc16'),
-    color_b: Ra::Color.hex('#f97316'),
-    transform: Ra::Transform
-      .translate(1.0, 1.0, 1.0)
-      .scale(3.0, 3.0, 3.0),
-  )),
+  material: Ra::Material.new(
+    base: Ra::Pattern::Gradient.new(
+      color_a: Ra::Color.hex('#84cc16'),
+      color_b: Ra::Color.hex('#f97316'),
+    ),
+    reflective: 0.5,
+  ),
   transform: Ra::Transform
-    .translate(-1.0, -0.3, -1.5)
-    .scale(0.3, 0.3, 0.3),
+    .translate(-1.0, +0.3, -1.0)
+    .scale(0.3, 0.3, 0.3)
+    .rotate_y(+Math::PI / 8),
 )
 
+lights = [
+  light_l,
+  light_r,
+]
+
 shapes = [
   floor,
   wall_l,
@@ -131,7 +141,7 @@ shapes = [
   cube_r,
 ].freeze
 
-world = Ra::World.new(light:, shapes:)
+world = Ra::World.new(lights:, shapes:)
 engine = Ra::Engine.new(camera:, world:)
 canvas = engine.render
 

data/lib/ra/camera.rb

@@ -82,7 +82,7 @@ module Ra
       half_h - offset_y
     end
 
-    # @param y [Float]
+    # @param x [Float]
     # @return [Float]
     def world_x(x:)
       offset_x = (x + 0.5) * p_size

data/lib/ra/canvas.rb

@@ -16,19 +16,12 @@ module Ra
   class Canvas
     attr_accessor :w, :h, :precision
 
-    DEFAULT_COLOR = Color.black
-    private_constant :DEFAULT_COLOR
-
-    DEFAULT_PRECISION = 255
-    private_constant :DEFAULT_PRECISION
-
     PPM_VERSION = 'P3'
-    private_constant :PPM_VERSION
 
     # @param w [Integer]
     # @param h [Integer]
     # @param precision [Integer]
-    def initialize(w:, h:, precision: DEFAULT_PRECISION)
+    def initialize(w:, h:, precision: Color::PRECISION)
       @w = w
       @h = h
       @precision = precision
@@ -43,7 +36,7 @@ module Ra
       raise ArgumentError, "x=#{x} must be < #{@w}" unless x < @w
       raise ArgumentError, "y=#{y} must be < #{@h}" unless y < @h
 
-      @pixels[x][y] || DEFAULT_COLOR
+      @pixels[x][y] || Color.black
     end
 
     # @param x [Integer]

data/lib/ra/color.rb

@@ -19,8 +19,17 @@ module Ra
   class Color
     attr_accessor :r, :g, :b
 
-    DEFAULT_PRECISION = 255
-    private_constant :DEFAULT_PRECISION
+    PRECISION = 255
+
+    # @param value [Array<Numeric,Numeric,Numeric>]
+    # @return [Ra::Color]
+    def self.[](value)
+      new(
+        r: value[0],
+        g: value[1],
+        b: value[2],
+      )
+    end
 
     # @param value [String] e.g. "#336699"
     # @return [Ra::Color]
@@ -28,9 +37,9 @@ module Ra
       r, g, b = value.match(/^#(..)(..)(..)$/).captures.map(&:hex)
 
       new(
-        r: Float(r) / DEFAULT_PRECISION,
-        g: Float(g) / DEFAULT_PRECISION,
-        b: Float(b) / DEFAULT_PRECISION,
+        r: Float(r) / PRECISION,
+        g: Float(g) / PRECISION,
+        b: Float(b) / PRECISION,
       )
     end
 
@@ -61,7 +70,7 @@ module Ra
 
     # @param precision [Integer]
     # @return [Integer]
-    def ppm(precision: DEFAULT_PRECISION)
+    def ppm(precision: PRECISION)
       "#{r_val(precision:)} #{g_val(precision:)} #{b_val(precision:)}"
     end
 
@@ -123,17 +132,17 @@ module Ra
     protected
 
     # @return [Integer]
-    def r_val(precision: DEFAULT_PRECISION)
+    def r_val(precision: PRECISION)
       val(value: r, precision:)
     end
 
     # @return [Integer]
-    def g_val(precision: DEFAULT_PRECISION)
+    def g_val(precision: PRECISION)
       val(value: g, precision:)
     end
 
     # @return [Integer]
-    def b_val(precision: DEFAULT_PRECISION)
+    def b_val(precision: PRECISION)
       val(value: b, precision:)
     end
 
@@ -142,7 +151,7 @@ module Ra
     # @param value [Numeric]
     # @param precision [Integer]
     # @return [Integer]
-    def val(value:, precision: DEFAULT_PRECISION)
+    def val(value:, precision: PRECISION)
       (value * precision).clamp(0, precision).round
     end
   end

data/lib/ra/engine.rb

@@ -31,10 +31,7 @@ module Ra
     def draw(x:, y:, canvas:)
       ray = @camera.ray(x:, y:)
 
-      intersections = @world.intersect(ray:)
-      intersection = Intersection.hit(intersections:)
-
-      canvas[x, y] = @world.color(intersection:) if intersection
+      canvas[x, y] = @world.color(ray:)
     end
   end
 end

data/lib/ra/intersection.rb

@@ -38,8 +38,9 @@ module Ra
       point = ray.position(t:)
       eyev = -ray.direction
       normalv = shape.normal(point:)
+      reflectv = Tuple.reflect(ray.direction, normalv)
 
-      Surface.new(shape:, eyev:, normalv:, point:)
+      Surface.new(shape:, eyev:, normalv:, reflectv:, point:)
     end
   end
 end

data/lib/ra/lighting.rb

@@ -14,7 +14,6 @@ module Ra
       @light = light
     end
 
-    # @param shadowed [Boolean]
     # @return [Ra::Color]
     def color
       ambient_color + diffuse_color + specular_color
@@ -22,7 +21,7 @@ module Ra
 
     private
 
-    # @param [Ra::Shape]
+    # @return [Ra::Shape]
     def shape
       surface.shape
     end
@@ -54,7 +53,7 @@ module Ra
 
     # @return [Ra::Vector]
     def reflectv
-      @reflectv ||= -(lightv - (normalv * 2 * lightv.dot(normalv)))
+      @reflectv ||= -Tuple.reflect(lightv, normalv)
     end
 
     # @return [Ra::Vector]

data/lib/ra/material.rb

@@ -11,17 +11,24 @@ module Ra
   #    shininess: 200,
   #   )
   class Material
-    attr_accessor :base, :ambient, :diffuse, :specular, :shininess
+    attr_accessor :base, :ambient, :diffuse, :reflective, :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 reflective [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)
+    def initialize(base:, ambient: 0.0, diffuse: 0.8, reflective: 0.0, specular: 0.2, shininess: 80)
+      raise ArgumentError, "ambient=#{ambient} must be between 0 and 1" unless ambient.between?(0, 1)
+      raise ArgumentError, "ambient=#{diffuse} must be between 0 and 1" unless diffuse.between?(0, 1)
+      raise ArgumentError, "ambient=#{reflective} must be between 0 and 1" unless reflective.between?(0, 1)
+      raise ArgumentError, "specular=#{specular} must be between 0 and 1" unless specular.between?(0, 1)
+
       @base = base
       @ambient = ambient
       @diffuse = diffuse
+      @reflective = reflective
       @specular = specular
       @shininess = shininess
     end

data/lib/ra/pattern/base.rb

@@ -2,29 +2,12 @@
 
 module Ra
   module Pattern
-    # An abstract pattern. Any concrete subclass of pattern must implement the
-    # method `local_color`.
+    # An abstract pattern. Any concrete subclass of pattern must implement the method `color`.
     class Base
-      attr_accessor :transform
-
-      # @param transform [Ra::Matrix]
-      def initialize(transform: Transform::IDENTITY)
-        @transform = transform
-      end
-
-      # @param point [Vector]
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
       # @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'
+        raise NotImplementedError, '#color must be implemented by a concrete subclass'
       end
     end
   end

data/lib/ra/pattern/checkers.rb

@@ -4,28 +4,33 @@ module Ra
   module Pattern
     # A checkers pattern that alternates colors using:
     #
-    #   colors[⌊√(point.x² + point.z²)⌋]
+    #   colors[⌊u * rows⌋ + ⌊v * cols)⌋ % colors.count]
     class Checkers < Base
-      attr_accessor :colors
+      DEFAULT_ROWS = 2
+      DEFAULT_COLS = 2
+      DEFAULT_COLORS = [
+        Color.black,
+        Color.white,
+      ].freeze
 
+      # @param rows [Integer]
+      # @param cols [Integer]
       # @param colors [Array<Ra::Color>]
-      # @param transform [Ra::Matrix]
-      def initialize(colors:, transform: Transform::IDENTITY)
-        super(transform:)
+      def initialize(cols: DEFAULT_COLS, rows: DEFAULT_ROWS, colors: DEFAULT_COLORS)
+        super()
+        @rows = rows
+        @cols = cols
         @colors = colors
       end
 
-      protected
-
-      # @param local_point [Vector]
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
       # @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
+      def color(point:)
+        u = point[0]
+        v = point[1]
+        index = (u * @rows).floor + (v * @cols).floor
 
-        colors[index % colors.count]
+        @colors[index % @colors.count]
       end
     end
   end

data/lib/ra/pattern/gradient.rb

@@ -4,25 +4,24 @@ 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)
+    #   color_b + (color_b - color_a) * (u + v) / 2
     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:)
+      def initialize(color_a:, color_b:)
+        super()
         @color_a = color_a
         @color_b = color_b
       end
 
-      protected
-
-      # @param local_point [Vector]
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
       # @return [Ra::Color]
-      def local_color(local_point:)
-        value = local_point[0]
-        fraction = value - value.floor
-        @color_a + ((@color_b - @color_a) * fraction)
+      def color(point:)
+        u = point[0]
+        v = point[1]
+        value = (u + v) / 2
+
+        @color_a + ((@color_b - @color_a) * value)
       end
     end
   end

data/lib/ra/pattern/rings.rb

@@ -4,27 +4,22 @@ module Ra
   module Pattern
     # A rings pattern that alternates colors using:
     #
-    #   colors[⌊√(point.x² + point.z²)⌋]
+    #   colors[⌊√(u² + v²)⌋]
     class Rings < Base
-      attr_accessor :colors
-
-      # @param colors [Array<Rays::Color>]
-      # @param transform [Rays::Matrix]
-      def initialize(colors:, transform: DEFAULT_TRANSFORM)
-        super(transform:)
+      # @param colors [Array<Ra::Color>]
+      def initialize(colors:)
+        super()
         @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
+      # @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]
+        @colors[index % @colors.count]
       end
     end
   end

data/lib/ra/pattern/stripes.rb

@@ -6,24 +6,21 @@ module Ra
     #
     #   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:)
+      def initialize(colors:)
+        super()
         @colors = colors
       end
 
-      protected
-
-      # @param local_point [Vector]
+      # @param point [Vector] <u = 0.0..1.0, v = 0.0..1.0>
       # @return [Ra::Color]
-      def local_color(local_point:)
-        x = local_point[0]
-        index = x.floor
+      def color(point:)
+        count = @colors.count
+        u = point[0]
+        v = point[1]
+        value = (u + v) * (2 * count)
 
-        colors[index % colors.count]
+        @colors[value.floor % count]
       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/shape/base.rb

@@ -6,7 +6,7 @@ module Ra
     # methods `l_normal` and `t_intersect`. Both methods use a point / ray
     # with a local transform applied.
     class Base
-      attr_accessor :material, :transform
+      attr_accessor :material
 
       # @param material [Ra::Material]
       # @param transform [Ra::Matrix]
@@ -18,25 +18,29 @@ module Ra
       # @param ray [Ra::Ray]
       # @return [Array<Ra::Intersection>]
       def intersect(ray:)
-        t_intersect(ray: ray.transform(transform.inverse))
+        t_intersect(ray: ray.transform(@transform.inverse))
           .map { |t| Ra::Intersection.new(ray:, shape: self, t:) }
       end
 
-      # @param point [Vector]
-      # @return [Vector]
+      # @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)
+        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]
+      # @param point [Vector] <x, y, z, Tuple::POINT>
       # @return [Color]
       def color(point:)
-        @material.color(point: transform.inverse * point)
+        @material.color(point: uv_point(point: @transform.inverse * point))
       end
 
-      private
+      # @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>]

data/lib/ra/shape/cube.rb

@@ -21,7 +21,20 @@ module Ra
     #
     # Thus 6 planes can be checked for intersect.
     class Cube < Base
-      protected
+      # @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>]
@@ -68,7 +81,6 @@ module Ra
 
       # @param origin [Numeric]
       # @param direction [Numeric]
-      # @param value [Numeric]
       # @return [Array<Numeric,Numeric>]
       def t_min_max(origin, direction)
         t_min_numerator = -1 - origin
@@ -84,6 +96,60 @@ module Ra
 
         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

@@ -18,7 +18,14 @@ module Ra
     #
     # A direction.y < EPISLON indicates the ray does not intersect the plane.
     class Plane < Base
-      protected
+      # @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>]

data/lib/ra/shape/sphere.rb

@@ -32,7 +32,22 @@ module Ra
     #
     # A discriminant <0 indicates the ray does not intersect the sphere.
     class Sphere < Base
-      protected
+      # @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>]

data/lib/ra/surface.rb

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

data/lib/ra/tuple.rb

@@ -9,8 +9,8 @@ module Ra
     POINT = 1
     VECTOR = 0
 
-    # @return source [Vector]
-    # @return target [Vector]
+    # @param source [Vector]
+    # @param target [Vector]
     # @return [Vector]
     def self.cross(source, target)
       cross = Vector[source[0], source[1], source[2]].cross(Vector[target[0], target[1], target[2]])
@@ -22,5 +22,12 @@ module Ra
         Tuple::VECTOR,
       ]
     end
+
+    # @param vector [Vector]
+    # @param normal [Vector]
+    # @return [Vector]
+    def self.reflect(vector, normal)
+      vector - (normal * 2 * vector.dot(normal))
+    end
   end
 end

data/lib/ra/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ra
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

data/lib/ra/world.rb

@@ -3,12 +3,10 @@
 module Ra
   # A world is composed of objects (lights / cameras) and handles coloring of rays.
   class World
-    attr_accessor :light, :shapes
-
-    # @param light [Ra::Light]
+    # @param lights [Ra::Light]
     # @param shapes [Array<Ra::Shape>]
-    def initialize(light:, shapes:)
-      @light = light
+    def initialize(lights:, shapes:)
+      @lights = lights
       @shapes = shapes
     end
 
@@ -26,18 +24,42 @@ module Ra
       Intersection.hit(intersections:)
     end
 
-    # @param intersection [Ra::Intersection]
+    # @param ray [Ra::Ray]
     # @return [Ra::Color]
-    def color(intersection:)
+    def color(ray:, remaining: 4)
+      intersection = intersection(ray:)
+      return unless intersection
+
       surface = intersection.surface
-      shadowed = shadowed?(point: surface.hpoint)
 
-      Lighting.new(shadowed:, surface:, light:).color
+      colors = @lights.map do |light|
+        shadowed = shadowed?(point: surface.hpoint, light:)
+        lighting = Lighting.new(light:, shadowed:, surface:)
+        lighting.color
+      end
+
+      colors.reduce(&:+) + reflect(surface:, remaining:)
+    end
+
+    # @param surface [Ra::Surface]
+    # @param remaining [Integer]
+    # @return [Ra::Color]
+    def reflect(surface:, remaining:)
+      return if remaining.zero?
+
+      material = surface.shape.material
+      return unless material.reflective.positive?
+
+      ray = Ray.new(origin: surface.hpoint, direction: surface.reflectv)
+
+      color = color(ray:, remaining: remaining.pred)
+      color * material.reflective if color
     end
 
+    # @param light [Ra::Light]
     # @param point [Ra::Point]
-    def shadowed?(point:)
-      vector = @light.position - point
+    def shadowed?(light:, point:)
+      vector = light.position - point
       distance = vector.magnitude
       direction = vector.normalize
       ray = Ray.new(origin: point, direction:)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ra
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Kevin Sylvestre
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-11-22 00:00:00.000000000 Z
+date: 2023-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: matrix
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: slop
   requirement: !ruby/object:Gem::Requirement
@@ -77,6 +91,7 @@ files:
 - lib/ra/pattern/gradient.rb
 - lib/ra/pattern/rings.rb
 - lib/ra/pattern/stripes.rb
+- lib/ra/pattern/texture.rb
 - lib/ra/ray.rb
 - lib/ra/shape/base.rb
 - lib/ra/shape/cube.rb