ra 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3603ce3fb7fc5149c4d723fc2c57d14b590f31aa6097a365ca02b554cce464f5
-  data.tar.gz: 5bed4817b7bbfaf3a6994cfb2450d6957802a1921ec560178c2cf01583921824
+  metadata.gz: d7ee2d6f85d018ae7eeb70e9796973277176ddac2940dbe442355cfd8f55bd5d
+  data.tar.gz: 7ca5f9394c0d2e62ba5348c3047b482554ebe8437646cc1fa100eea0141fa67d
 SHA512:
-  metadata.gz: e0899f44711e31595f7d1a414092876f4a3bb485e84c0f35431dc479b93829e4dcc01272e29b5098ad46f52523f7927bcb96fc02e7e27f2f3b0933e50af17499
-  data.tar.gz: 6b4bb9c3120bb240c7fa4c993de673a4dfe351825cf072a34d0464caaff43002507f17ea3b7f2dc0166dfaf45cb1817b032f419fbdfae6448b0c4a68e0dd7d04
+  metadata.gz: c6c66f296b05b5fb771dfaab9a95b0523c5ec3563da731c6f0e177a9bc775d7309c59b3e67d2e56c4ea8d070a009e4d0b7b0d84d167bcaa2644a9886857ae3f4
+  data.tar.gz: c6c2465c7cc20c95aaaa3802dc0d5ad54bedfa6d8fa023bb24f9e6dfad4144b45c58ede27c998d87167ff755883afce0d7385beb0341610fa1ddadbe143a0c90

data/README.md

@@ -1,5 +1,13 @@
 # Ra
 
+[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ksylvest/ra/blob/main/LICENSE)
+[![RubyGems](https://img.shields.io/gem/v/ra)](https://rubygems.org/gems/ra)
+[![GitHub](https://img.shields.io/badge/github-repo-blue.svg)](https://github.com/ksylvest/ra)
+[![Yard](https://img.shields.io/badge/docs-site-blue.svg)](https://ra.ksylvest.com)
+[![CircleCI](https://img.shields.io/circleci/build/github/ksylvest/ra)](https://circleci.com/gh/ksylvest/ra)
+[![Code Climate Maintainability](https://img.shields.io/codeclimate/maintainability/ksylvest/ra)](https://codeclimate.com/github/ksylvest/ra)
+[![Code Climate Coverage](https://img.shields.io/codeclimate/coverage/ksylvest/ra)](https://codeclimate.com/github/ksylvest/ra)
+
 Named for [Ra](https://en.wikipedia.org/wiki/Ra) - arguably the original ray tracer.
 
 ## Installation
@@ -12,7 +20,7 @@ gem install ra
 
 ```sh
 ra -w 2560 -h 2048 > sample.ppm
-convert -quality 80  sample.ppm sample.avif
+convert -quality 80 sample.ppm sample.avif
 ```
 
-![Sample](./sample.avif)
+![Sample](https://github.com/ksylvest/ra/raw/main/sample.avif)

data/exe/ra

@@ -10,7 +10,7 @@ config = Slop.parse(ARGV) do |options|
 
   options.integer '-w', '--width', 'width', default: 2560
   options.integer '-h', '--height', 'height', default: 2048
-  options.integer '-fov', 'degrees', default: 60
+  options.integer '-fov', 'degrees', default: 90
 
   options.on('--help', 'help') do
     Ra.logger.log(options)
@@ -26,13 +26,13 @@ end
 earth = Ra::Pattern::Texture.new(path: File.join(File.dirname(__FILE__), '..', 'assets/earth.avif'))
 
 light_l = Ra::Light.new(
-  position: Vector[+5, +3, -9, Ra::Tuple::POINT],
-  intensity: Ra::Color.uniform(0.5),
+  position: Vector[+3.0, +2.0, -5.0, Ra::Tuple::POINT],
+  intensity: Ra::Color.uniform(0.75),
 )
 
 light_r = Ra::Light.new(
-  position: Vector[-5, +3, -9, Ra::Tuple::POINT],
-  intensity: Ra::Color.uniform(0.5),
+  position: Vector[-3.0, +2.0, -5.0, Ra::Tuple::POINT],
+  intensity: Ra::Color.uniform(0.75),
 )
 
 camera = Ra::Camera.new(
@@ -41,7 +41,7 @@ camera = Ra::Camera.new(
   fov: config[:fov] * Math::PI / 180,
   transform: Ra::Transform.view(
     from: Vector[0, +1.5, -4.0, Ra::Tuple::POINT],
-    to: Vector[0, 0, 0, Ra::Tuple::POINT],
+    to: Vector[0, +0.5, 0, Ra::Tuple::POINT],
     up: Vector[0, 1, 0, Ra::Tuple::VECTOR],
   ),
 )
@@ -57,19 +57,28 @@ floor = Ra::Shape::Plane.new(
     reflective: 0.2,
   ),
   transform: Ra::Transform
-    .rotate_y(Math::PI / 4)
-    .scale(0.5, 0.5, 0.5),
+    .rotate_y(Math::PI / 4),
 )
 
-wall_l = Ra::Shape::Plane.new(
+ceiling = Ra::Shape::Plane.new(
   material: Ra::Material.new(
     base: Ra::Pattern::Stripes.new(
       colors: [
-        Ra::Color.hex('#f5f5f4'),
+        Ra::Color.hex('#e4e4e7'),
         Ra::Color.hex('#e7e5e4'),
       ],
     ),
   ),
+  transform: Ra::Transform
+    .translate(0, +3.0, 0)
+    .scale(0.2, 0.2, 0.2)
+    .rotate_y(Math::PI / 4),
+)
+
+wall_l = Ra::Shape::Plane.new(
+  material: Ra::Material.new(
+    base: Ra::Color.hex('#6b21a8'),
+  ),
   transform: Ra::Transform
     .translate(0, 0, +3.0)
     .rotate_y(-Math::PI / 4)
@@ -78,12 +87,7 @@ wall_l = Ra::Shape::Plane.new(
 
 wall_r = Ra::Shape::Plane.new(
   material: Ra::Material.new(
-    base: Ra::Pattern::Stripes.new(
-      colors: [
-        Ra::Color.hex('#f5f5f4'),
-        Ra::Color.hex('#e7e5e4'),
-      ],
-    ),
+    base: Ra::Color.hex('#9f1239'),
   ),
   transform: Ra::Transform
     .translate(0, 0, +3.0)
@@ -92,38 +96,41 @@ wall_r = Ra::Shape::Plane.new(
 )
 
 sphere = Ra::Shape::Sphere.new(
-  material: Ra::Material.new(base: earth),
+  material: Ra::Material.new(
+    base: earth,
+    reflective: 0.3,
+  ),
   transform: Ra::Transform
-    .translate(0, +0.5, -2.0)
+    .translate(0, +0.6, -2.0)
     .rotate_y(Math::PI / 2)
-    .scale(0.5, 0.5, 0.5),
+    .scale(0.6, 0.6, 0.6),
 )
 
-cube_l = Ra::Shape::Cube.new(
+cube = 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'),
     ),
-    reflective: 0.2,
+    reflective: 0.3,
   ),
   transform: Ra::Transform
-    .translate(+1.0, +0.3, -1.0)
-    .scale(0.3, 0.3, 0.3)
+    .translate(+1.6, +0.4, -0.8)
+    .scale(0.4, 0.4, 0.4)
     .rotate_y(-Math::PI / 8),
 )
 
-cube_r = Ra::Shape::Cube.new(
+cylinder = Ra::Shape::Cylinder.new(
   material: Ra::Material.new(
     base: Ra::Pattern::Gradient.new(
       color_a: Ra::Color.hex('#84cc16'),
       color_b: Ra::Color.hex('#f97316'),
     ),
-    reflective: 0.5,
+    reflective: 0.3,
   ),
   transform: Ra::Transform
-    .translate(-1.0, +0.3, -1.0)
-    .scale(0.3, 0.3, 0.3)
+    .translate(-1.6, +0.4, -0.8)
+    .scale(0.4, 0.4, 0.4)
     .rotate_y(+Math::PI / 8),
 )
 
@@ -134,15 +141,15 @@ lights = [
 
 shapes = [
   floor,
+  ceiling,
   wall_l,
   wall_r,
   sphere,
-  cube_l,
-  cube_r,
+  cube,
+  cylinder,
 ].freeze
 
 world = Ra::World.new(lights:, shapes:)
 engine = Ra::Engine.new(camera:, world:)
-canvas = engine.render
 
-Ra.logger.log(canvas.ppm)
+engine.ppm { |text| Ra.logger.log(text) }

data/lib/ra/camera.rb

@@ -24,15 +24,31 @@ module Ra
   # dimensions rays are cast to the center of pixels evenly distrubted across
   # the screen.
   class Camera
-    attr_accessor :h, :w, :fov, :transform
+    include Enumerable
+
+    # @!attribute h
+    #   @return [Integer]
+    attr_accessor :h
+
+    # @!attribute w
+    #   @return [Integer]
+    attr_accessor :w
+
+    # @!attribute fov
+    #   @return [Numeric]
+    attr_accessor :fov
+
+    # @!attribute transform
+    #   @return [Ra::Transform]
+    attr_accessor :transform
 
     DEFAULT_W = 1280
     DEFAULT_H = 1024
     DEFAULT_FOV = Math::PI / 3
 
     # @param transform [Ra::Transform]
-    # @param h [Numeric]
-    # @param w [Numeric]
+    # @param h [Integer]
+    # @param w [Integer]
     # @param fov [Numeric]
     def initialize(transform: Transform::IDENTITY, h: DEFAULT_H, w: DEFAULT_W, fov: DEFAULT_FOV)
       @transform = transform
@@ -41,6 +57,22 @@ module Ra
       @fov = fov
     end
 
+    # @yield [y, x, ray] y, x, ray
+    # @yieldparam [Integer] y
+    # @yieldparam [Integer] x
+    # @yieldparam [Ra::Ray] ray
+    def each
+      @h.times do |y|
+        @w.times do |x|
+          ray = ray(
+            y:,
+            x:,
+          )
+          yield(y, x, ray)
+        end
+      end
+    end
+
     # @param x [Numeric]
     # @param y [Numeric]
     # @return [Ra::Ray]

data/lib/ra/color.rb

@@ -17,7 +17,17 @@ module Ra
   #   )
   #   color.ppm == "128 179 230"
   class Color
-    attr_accessor :r, :g, :b
+    # @!attribute r
+    #   @return [Numeric]
+    attr_accessor :r
+
+    # @!attribute g
+    #   @return [Numeric]
+    attr_accessor :g
+
+    # @!attribute b
+    #   @return [Numeric]
+    attr_accessor :b
 
     PRECISION = 255
 

data/lib/ra/engine.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
 module Ra
-  # An engine takes uses a world / camera to generate a canvas.
+  # An engine takes a world / camera and generates a PPM.
   class Engine
+    include Enumerable
+
     PRECISION = 255
+    PORCESSES = 8
+
+    PPM_VERSION = 'P3'
+    PPM_DEFAULT = '0 0 0'
 
     # @param world [Ra::World]
     # @param camera [Ra::Camera]
@@ -12,26 +18,27 @@ module Ra
       @camera = camera
     end
 
-    # @return [Ra::Canvas]
-    def render
-      Ra::Canvas.new(w: @camera.w, h: @camera.h, precision: PRECISION).tap do |canvas|
-        @camera.h.times do |y|
-          @camera.w.times do |x|
-            draw(x:, y:, canvas:)
-          end
-        end
+    # @yield [pixel]
+    # @yieldparam [Ra::Pixel] pixel
+    def each
+      @camera.each do |y, x, ray|
+        color = @world.color(ray:)
+        yield(Ra::Pixel.new(x:, y:, color:))
       end
     end
 
-    private
+    # @yield [text]
+    # @yieldparam [String] text
+    def ppm
+      yield(<<~PPM)
+        #{PPM_VERSION}
+        #{@camera.w} #{@camera.h}
+        #{Color::PRECISION}
+      PPM
 
-    # @param x [Integer]
-    # @param y [Integer]
-    # @param canvas [Ra::Canvas]
-    def draw(x:, y:, canvas:)
-      ray = @camera.ray(x:, y:)
-
-      canvas[x, y] = @world.color(ray:)
+      each do |pixel|
+        yield(pixel.color ? pixel.color.ppm : PPM_DEFAULT)
+      end
     end
   end
 end

data/lib/ra/intersection.rb

@@ -3,7 +3,17 @@
 module Ra
   # An intersection tracks the time t at which a shape is intersected by a ray.
   class Intersection
-    attr_accessor :t, :ray, :shape
+    # @!attribute t
+    #   @return [Numeric]
+    attr_accessor :t
+
+    # @attribute ray
+    #   @return [Ra::Ray]
+    attr_accessor :ray
+
+    # @attribute shape
+    #   @return [Ra::Shape::Base]
+    attr_accessor :shape
 
     # @param intersections Array<Ra::Intersection>
     # @return [Ra::Intersection, nil]
@@ -42,5 +52,25 @@ module Ra
 
       Surface.new(shape:, eyev:, normalv:, reflectv:, point:)
     end
+
+    # @return [Vector]
+    def position
+      @position ||= @ray.position(t: @t)
+    end
+
+    # @return [Numeric]
+    def x
+      position[0]
+    end
+
+    # @return [Numeric]
+    def y
+      position[1]
+    end
+
+    # @return [Numeric]
+    def z
+      position[1]
+    end
   end
 end

data/lib/ra/light.rb

@@ -9,7 +9,13 @@ module Ra
   #     position: Vector[0, 0, 0, Ra::Tuple::POINT],
   #   )
   class Light
-    attr_accessor :intensity, :position
+    # @!attribute intensity
+    #   @return [Ra::Color]
+    attr_accessor :intensity
+
+    # @!attribute position
+    #   @return [Vector]
+    attr_accessor :position
 
     # @param intensity [Ra::Color]
     # @param position [Vector]

data/lib/ra/lighting.rb

@@ -3,7 +3,17 @@
 module Ra
   # Lighting encaspulates a [Phong Reflection Model](https://en.wikipedia.org/wiki/phong_reflection_model).
   class Lighting
-    attr_accessor :light, :surface, :shadowed
+    # @!attribute surface
+    #   @return [Ra::Surface]
+    attr_accessor :surface
+
+    # @!attribute shadowed
+    #   @return [Boolean]
+    attr_accessor :shadowed
+
+    # @!attribute light
+    #   @return [Ra::Light]
+    attr_accessor :light
 
     # @param light [Ra::Light]
     # @param surface [Ra::Surface]

data/lib/ra/material.rb

@@ -11,14 +11,36 @@ module Ra
   #    shininess: 200,
   #   )
   class Material
-    attr_accessor :base, :ambient, :diffuse, :reflective, :specular, :shininess
+    # @!attribute base
+    #   @return [Ra::Color, Ra::Pattern::Base]
+    attr_accessor :base
+
+    # @!attribute ambient
+    #   @return [Float]
+    attr_accessor :ambient
+
+    # @!attribute diffuse
+    #   @return [Float]
+    attr_accessor :diffuse
+
+    # @!attribute reflective
+    #   @return [Float]
+    attr_accessor :reflective
+
+    # @!attribute specular
+    #   @return [Float]
+    attr_accessor :specular
+
+    # @!attribute shininess
+    #   @return [Integer]
+    attr_accessor :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]
+    # @param shininess [Integer]
     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)

data/lib/ra/pixel.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ra
+  # A pixel is a point in an image. It pairs the coordinates (x,y) with the color for that point.
+  class Pixel
+    # @!attribute x
+    #   @return [Integer]
+    attr_accessor :x
+
+    # @!attribute y
+    #   @return [Integer]
+    attr_accessor :y
+
+    # @!attribute color
+    #   @return [Ra::Color]
+    attr_accessor :color
+
+    # @param x [Integer]
+    # @param y [Integer]
+    # @param color [Ra::Color]
+    def initialize(x:, y:, color:)
+      @x = x
+      @y = y
+      @color = color
+    end
+  end
+end

data/lib/ra/quadratic.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ra
+  # A solver for all things quadratic. Given the equation:
+  #
+  #   ax² + bx +c = 0
+  #
+  # The solution for `x`` can be found via:
+  #
+  #   (-b ± √(b² - 4ac)) / (2a)
+  #
+  # No solution is defined when the discriminant (`b² - 4ac`) is negative or `a` is zero.
+  module Quadratic
+    # (-b ± √(b² - 4ac)) / (2a)
+    #
+    # @param a [Numeric]
+    # @param b [Numeric]
+    # @param c [Numeric]
+    # @return [Array<Numeric>]
+    def self.solve(a:, b:, c:)
+      return [] if a.zero?
+
+      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

data/lib/ra/ray.rb

@@ -21,7 +21,13 @@ module Ra
   #   )
   #   ray.transform(transform: Ra::Transform.scale(1, 2, 3))
   class Ray
-    attr_accessor :origin, :direction
+    # @!attribute origin
+    #   @return [Vector]
+    attr_accessor :origin
+
+    # @!attribute direction
+    #   @return [Vector]
+    attr_accessor :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]
@@ -49,5 +55,90 @@ module Ra
     def ==(other)
       origin == other.origin && direction == other.direction
     end
+
+    # @param t [Numeric]
+    # @return [Numeric]
+    def x(t:)
+      origin_x + (direction_x * t)
+    end
+
+    # @param t [Numeric]
+    # @return [Numeric]
+    def y(t:)
+      origin_y + (direction_y * t)
+    end
+
+    # @param t [Numeric]
+    # @return [Numeric]
+    def z(t:)
+      origin_z + (direction_z * t)
+    end
+
+    # The time t when the ray is at x
+    # @param x [Numeric]
+    # @return [Numeric]
+    def t_x(x)
+      return if direction_x.zero?
+
+      (x - origin_x) / direction_x
+    end
+
+    # The time t when the ray is at y
+    # @param y [Numeric]
+    # @return [Numeric, nil]
+    def t_y(y)
+      return if direction_y.zero?
+
+      (y - origin_y) / direction_y
+    end
+
+    # The time t when the ray is at z
+    # @param z [Numeric]
+    # @return [Numeric, nil]
+    def t_z(z)
+      return if direction_z.zero?
+
+      (z - origin_z) / direction_z
+    end
+
+    # @return [Numeric]
+    def direction_x
+      @direction[0]
+    end
+
+    # @return [Numeric]
+    def direction_y
+      @direction[1]
+    end
+
+    # @return [Numeric]
+    def direction_z
+      @direction[2]
+    end
+
+    # @return [0] 0 = vector / 1 = point
+    def direction_w
+      @direction[3]
+    end
+
+    # @return [Numeric]
+    def origin_x
+      @origin[0]
+    end
+
+    # @return [Numeric]
+    def origin_y
+      @origin[1]
+    end
+
+    # @return [Numeric]
+    def origin_z
+      @origin[2]
+    end
+
+    # @return [1] 0 = vector / 1 = point
+    def origin_w
+      @origin[3]
+    end
   end
 end

data/lib/ra/shape/base.rb

@@ -6,6 +6,8 @@ module Ra
     # methods `l_normal` and `t_intersect`. Both methods use a point / ray
     # with a local transform applied.
     class Base
+      # @!attribute material
+      #   @return [Ra::Material]
       attr_accessor :material
 
       # @param material [Ra::Material]

data/lib/ra/shape/cylinder.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Ra
+  module Shape
+    # A cylinder at origin <0,0,0> with a radius 1. A cylinder surface is defined:
+    #
+    #   (x² + z² = radius² AND y BETWEEN ±1) OR (y = ±1 AND x² + z² < radius)
+    #
+    # 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`:
+    #
+    #   (origin.x + direction.x * t)² + (origin.z + direction.z * t)² = 1
+    #
+    # Simplifying gives a quadratic formula with terms defined as:
+    #
+    #   a = direction.x² + direction.z²
+    #   b = 2 * ((origin.x * direction.x) + (origin.z * direction.z))
+    #   c = origin.x² + origin.z² - 1
+    #   discriminant = b² - 4ac
+    #   t = (-b ± √discriminant) / (2a)
+    #
+    # A discriminant <0 indicates the ray does not intersect the sphere.
+    class Cylinder < Base
+      MIN_Y = -1
+      MAX_Y = +1
+      RADIUS = 1
+
+      # @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]
+
+        theta = Math.atan2(x, z)
+
+        u = 1 - ((theta / (2 * Math::PI)) + 0.5)
+        v = y % 1.0
+
+        Vector[u, v]
+      end
+
+      # @param ray [Ra::Ray] local
+      # @return [Array<Numeric>]
+      def t_intersect(ray:)
+        t_intersect_caps(ray:) +
+          t_intersect_side(ray:).filter { |t| ray.y(t:) > MIN_Y && ray.y(t:) < MAX_Y }
+      end
+
+      # @param point [Vector]
+      # @return [Ra::Tuple]
+      def l_normal(point:)
+        x = point[0]
+        y = point[1]
+        z = point[2]
+
+        distance = (x * x) + (z * z)
+
+        if distance < 1
+          return Vector[0, +1, 0, Tuple::VECTOR] if y >= MAX_Y - EPSILON
+          return Vector[0, -1, 0, Tuple::VECTOR] if y <= MIN_Y + EPSILON
+        end
+
+        Vector[point[0], 0, point[2], Tuple::VECTOR]
+      end
+
+      private
+
+      # @param ray [Ra::Ray] local
+      # @return [Array<Numeric>]
+      def t_intersect_side(ray:)
+        direction_x = ray.direction_x
+        direction_z = ray.direction_z
+        origin_x = ray.origin_x
+        origin_z = ray.origin_z
+
+        Quadratic.solve(
+          a: (direction_x * direction_x) + (direction_z * direction_z),
+          b: 2 * ((origin_x * direction_x) + (origin_z * direction_z)),
+          c: ((origin_x * origin_x) + (origin_z * origin_z)) - RADIUS,
+        )
+      end
+
+      def t_intersect_caps(ray:)
+        [
+          t_intersect_y(ray:, y: MIN_Y),
+          t_intersect_y(ray:, y: MAX_Y),
+        ].compact
+      end
+
+      # @param ray [Ra::Ray] local
+      # @return [Numeric, nil]
+      def t_intersect_y(ray:, y:)
+        t = ray.t_y(y)
+        return unless t
+
+        point = ray.position(t:)
+
+        return if (point[0] * point[0]) + (point[2] * point[2]) > RADIUS
+
+        t
+      end
+    end
+  end
+end

data/lib/ra/shape/plane.rb

@@ -30,8 +30,8 @@ module Ra
       # @param ray [Ra::Ray] local
       # @return [Array<Numeric>]
       def t_intersect(ray:)
-        origin_y = ray.origin[1]
-        direction_y = ray.direction[1]
+        origin_y = ray.origin_y
+        direction_y = ray.direction_y
 
         return [] if direction_y.abs < EPSILON
 

data/lib/ra/shape/sphere.rb

@@ -32,6 +32,8 @@ module Ra
     #
     # A discriminant <0 indicates the ray does not intersect the sphere.
     class Sphere < Base
+      RADIUS = 1
+
       # @param point [Vector] <x, y, z, Tuple::POINT>
       # @return [Vector] <u = 0.0..1.0, v = 0.0..1.0>
       def uv_point(point:)
@@ -55,10 +57,10 @@ module Ra
         origin = ray.origin - Vector[0, 0, 0, Ra::Tuple::POINT]
         direction = ray.direction
 
-        quadratic(
+        Quadratic.solve(
           a: direction.dot(direction),
           b: 2 * direction.dot(origin),
-          c: origin.dot(origin) - 1,
+          c: origin.dot(origin) - RADIUS,
         )
       end
 
@@ -67,24 +69,6 @@ module Ra
       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

@@ -3,7 +3,25 @@
 module Ra
   # A surface contains everything needed to apply lighting.
   class Surface
-    attr_accessor :eyev, :normalv, :reflectv, :shape, :point
+    # @!attribute eyev
+    #   @return [Vector]
+    attr_accessor :eyev
+
+    # @!attribute normalv
+    #   @return [Vector]
+    attr_accessor :normalv
+
+    # @!attribute reflectv
+    #   @return [Vector]
+    attr_accessor :reflectv
+
+    # @!attribute shape
+    #   @return [Ra::Shape]
+    attr_accessor :shape
+
+    # @!attribute point
+    #   @return [Vector]
+    attr_accessor :point
 
     # @param eyev [Vector]
     # @param normalv [Vector]

data/lib/ra/transform.rb

@@ -94,34 +94,34 @@ module Ra
     # @param x [Numeric]
     # @param y [Numeric]
     # @param z [Numeric]
-    def translate(...)
-      self * self.class.translate(...)
+    def translate(x, y, z)
+      self * self.class.translate(x, y, z)
     end
 
     # @return [Ra::Transform]
     # @param x [Numeric]
     # @param y [Numeric]
     # @param z [Numeric]
-    def scale(...)
-      self * self.class.scale(...)
+    def scale(x, y, z)
+      self * self.class.scale(x, y, z)
     end
 
     # @return [Ra::Transform]
     # @param rotation [Numeric]
-    def rotate_x(...)
-      self * self.class.rotate_x(...)
+    def rotate_x(rotation)
+      self * self.class.rotate_x(rotation)
     end
 
     # @return [Ra::Transform]
     # @param rotation [Numeric]
-    def rotate_y(...)
-      self * self.class.rotate_y(...)
+    def rotate_y(rotation)
+      self * self.class.rotate_y(rotation)
     end
 
     # @return [Ra::Transform]
     # @param rotation [Numeric]
-    def rotate_z(...)
-      self * self.class.rotate_z(...)
+    def rotate_z(rotation)
+      self * self.class.rotate_z(rotation)
     end
 
     # Avoid re-computing a transform inverse by memoizing.

data/lib/ra/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ra
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Kevin Sylvestre
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-23 00:00:00.000000000 Z
+date: 2024-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: matrix
@@ -79,7 +79,6 @@ files:
 - exe/ra
 - lib/ra.rb
 - lib/ra/camera.rb
-- lib/ra/canvas.rb
 - lib/ra/color.rb
 - lib/ra/engine.rb
 - lib/ra/intersection.rb
@@ -93,9 +92,12 @@ files:
 - lib/ra/pattern/rings.rb
 - lib/ra/pattern/stripes.rb
 - lib/ra/pattern/texture.rb
+- lib/ra/pixel.rb
+- lib/ra/quadratic.rb
 - lib/ra/ray.rb
 - lib/ra/shape/base.rb
 - lib/ra/shape/cube.rb
+- lib/ra/shape/cylinder.rb
 - lib/ra/shape/plane.rb
 - lib/ra/shape/sphere.rb
 - lib/ra/surface.rb
@@ -123,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.23
 signing_key: 
 specification_version: 4
 summary: A graphics library written for fun.

data/lib/ra/canvas.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Ra
-  # A canvas is used to track pixels at <x,y> coordinates. It is given a w / h
-  # and on initialization allocates a w by h collection of pixels. For example,
-  # defining a basic black and white checkboard canvas with altering squares
-  # then saving as [PPM](https://netpbm.sourceforge.net/doc/ppm.html):
-  #
-  #   canvas = Ra::Canvas.new(w: 4, h: 5, precision: 15)
-  #   canvas.w.times do |x|
-  #     canvas.h.times do |y|
-  #       canvas[x,y] = (x + y) % 2 == 0 ? Ra::Color.black : Ra::Color.white
-  #     end
-  #   end
-  #   canvas.ppm
-  class Canvas
-    attr_accessor :w, :h, :precision
-
-    PPM_VERSION = 'P3'
-
-    # @param w [Integer]
-    # @param h [Integer]
-    # @param precision [Integer]
-    def initialize(w:, h:, precision: Color::PRECISION)
-      @w = w
-      @h = h
-      @precision = precision
-      @pixels = Array.new(w) { Array.new(h) }
-    end
-
-    # @param x [Integer]
-    # @param y [Integer]
-    def [](x, y)
-      raise ArgumentError, "x=#{x} cannot be negative" if x.negative?
-      raise ArgumentError, "y=#{y} cannot be negative" if y.negative?
-      raise ArgumentError, "x=#{x} must be < #{@w}" unless x < @w
-      raise ArgumentError, "y=#{y} must be < #{@h}" unless y < @h
-
-      @pixels[x][y] || Color.black
-    end
-
-    # @param x [Integer]
-    # @param y [Integer]
-    # @param color [Ra::Color]
-    def []=(x, y, color)
-      raise ArgumentError, "x=#{x} cannot be negative" if x.negative?
-      raise ArgumentError, "y=#{y} cannot be negative" if y.negative?
-      raise ArgumentError, "x=#{x} must be < #{@w}" unless x < @w
-      raise ArgumentError, "y=#{y} must be < #{@h}" unless y < @h
-
-      @pixels[x][y] = color
-    end
-
-    # @return [String]
-    def ppm
-      buffer = String.new(<<~PPM, encoding: 'ascii')
-        #{PPM_VERSION}
-        #{@w} #{@h}
-        #{@precision}
-      PPM
-
-      @h.times do |y|
-        @w.times do |x|
-          buffer << (self[x, y].ppm(precision: @precision)) << "\n"
-        end
-      end
-
-      buffer
-    end
-  end
-end