From 38783e613243910d9e1b9ed01e7a2cd5154a5018 Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 06:53:32 -0700
Subject: [PATCH 1/8] Check for ray striking and missing a cylinder

(Implemented using Anthropic's Claude)
---
 src/main/scala/Cylinder.scala      | 111 +++++++++++++++++++++++++++++
 src/test/scala/CylinderSuite.scala |  67 +++++++++++++++++
 2 files changed, 178 insertions(+)
 create mode 100644 src/main/scala/Cylinder.scala
 create mode 100644 src/test/scala/CylinderSuite.scala

diff --git a/src/main/scala/Cylinder.scala b/src/main/scala/Cylinder.scala
new file mode 100644
index 0000000..8af67aa
--- /dev/null
+++ b/src/main/scala/Cylinder.scala
@@ -0,0 +1,111 @@
+package com.samuelcantrell.raytracer.cylinder
+
+import com.samuelcantrell.raytracer.ray
+import com.samuelcantrell.raytracer.tuple
+import com.samuelcantrell.raytracer.intersection
+import com.samuelcantrell.raytracer.matrix
+import com.samuelcantrell.raytracer.material
+import com.samuelcantrell.raytracer.shape
+import java.util.UUID
+
+case class Cylinder(
+    id: String = UUID.randomUUID().toString,
+    transform: matrix.Matrix = matrix.Matrix.identity(),
+    objectMaterial: material.Material = material.material(),
+    minimum: Double = Double.NegativeInfinity,
+    maximum: Double = Double.PositiveInfinity,
+    closed: Boolean = false
+) extends shape.Shape {
+
+  def localIntersect(localRay: ray.Ray): intersection.Intersections = {
+    val a = localRay.direction.x * localRay.direction.x + 
+            localRay.direction.z * localRay.direction.z
+
+    // Ray is parallel to the y axis
+    if (math.abs(a) < 1e-10) {
+      intersection.Intersections(Array.empty[intersection.Intersection])
+    } else {
+      val b = 2 * localRay.origin.x * localRay.direction.x + 
+              2 * localRay.origin.z * localRay.direction.z
+      val c = localRay.origin.x * localRay.origin.x + 
+              localRay.origin.z * localRay.origin.z - 1
+
+      val discriminant = b * b - 4 * a * c
+
+      // Ray does not intersect the cylinder
+      if (discriminant < 0) {
+        intersection.Intersections(Array.empty[intersection.Intersection])
+      } else {
+        val t0 = (-b - math.sqrt(discriminant)) / (2 * a)
+        val t1 = (-b + math.sqrt(discriminant)) / (2 * a)
+
+        val (t0_sorted, t1_sorted) = if (t0 > t1) (t1, t0) else (t0, t1)
+
+        val y0 = localRay.origin.y + t0_sorted * localRay.direction.y
+        val y1 = localRay.origin.y + t1_sorted * localRay.direction.y
+
+        val intersections = scala.collection.mutable.ArrayBuffer[intersection.Intersection]()
+
+        if (minimum < y0 && y0 < maximum) {
+          intersections += intersection.intersection(t0_sorted, this)
+        }
+
+        if (minimum < y1 && y1 < maximum) {
+          intersections += intersection.intersection(t1_sorted, this)
+        }
+
+        intersection.Intersections(intersections.toArray)
+      }
+    }
+  }
+
+  def localNormalAt(localPoint: tuple.Tuple): tuple.Tuple = {
+    val dist = localPoint.x * localPoint.x + localPoint.z * localPoint.z
+
+    if (dist < 1 && localPoint.y >= maximum - 1e-10) {
+      tuple.makeVector(0, 1, 0)
+    } else if (dist < 1 && localPoint.y <= minimum + 1e-10) {
+      tuple.makeVector(0, -1, 0)
+    } else {
+      tuple.makeVector(localPoint.x, 0, localPoint.z)
+    }
+  }
+
+  def withTransform(newTransform: matrix.Matrix): Cylinder = {
+    this.copy(transform = newTransform)
+  }
+
+  def withMaterial(newMaterial: material.Material): Cylinder = {
+    this.copy(objectMaterial = newMaterial)
+  }
+}
+
+def cylinder(): Cylinder = {
+  Cylinder()
+}
+
+// Convenience functions for backward compatibility
+def setTransform(c: Cylinder, t: matrix.Matrix): Cylinder = {
+  shape.setTransform(c, t)
+}
+
+def setMaterial(c: Cylinder, m: material.Material): Cylinder = {
+  shape.setMaterial(c, m)
+}
+
+def intersect(c: Cylinder, r: ray.Ray): intersection.Intersections = {
+  shape.intersect(c, r)
+}
+
+def normalAt(c: Cylinder, worldPoint: tuple.Tuple): tuple.Tuple = {
+  shape.normalAt(c, worldPoint)
+}
+
+// Direct access to local methods for testing
+def localIntersect(c: Cylinder, localRay: ray.Ray): intersection.Intersections = {
+  c.localIntersect(localRay)
+}
+
+def localNormalAt(c: Cylinder, localPoint: tuple.Tuple): tuple.Tuple = {
+  c.localNormalAt(localPoint)
+}
\ No newline at end of file
diff --git a/src/test/scala/CylinderSuite.scala b/src/test/scala/CylinderSuite.scala
new file mode 100644
index 0000000..a0dd1d7
--- /dev/null
+++ b/src/test/scala/CylinderSuite.scala
@@ -0,0 +1,67 @@
+import com.samuelcantrell.raytracer.cylinder._
+import com.samuelcantrell.raytracer.ray
+import com.samuelcantrell.raytracer.tuple
+import com.samuelcantrell.raytracer.equality
+
+class CylinderSuite extends munit.FunSuite {
+
+  test("A ray misses a cylinder - test 1") {
+    val cyl = cylinder()
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 0))
+    val r = ray.ray(tuple.makePoint(1, 0, 0), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("A ray misses a cylinder - test 2") {
+    val cyl = cylinder()
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 0))
+    val r = ray.ray(tuple.makePoint(0, 0, 0), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("A ray misses a cylinder - test 3") {
+    val cyl = cylinder()
+    val direction = tuple.normalize(tuple.makeVector(1, 1, 1))
+    val r = ray.ray(tuple.makePoint(0, 0, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("A ray strikes a cylinder - test 1") {
+    val cyl = cylinder()
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(1, 0, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+    assertEquals(equality.almostEqual(xs(0).t, 5.0), true)
+    assertEquals(equality.almostEqual(xs(1).t, 5.0), true)
+  }
+
+  test("A ray strikes a cylinder - test 2") {
+    val cyl = cylinder()
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(0, 0, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+    assertEquals(equality.almostEqual(xs(0).t, 4.0), true)
+    assertEquals(equality.almostEqual(xs(1).t, 6.0), true)
+  }
+
+  test("A ray strikes a cylinder - test 3") {
+    val cyl = cylinder()
+    val direction = tuple.normalize(tuple.makeVector(0.1, 1, 1))
+    val r = ray.ray(tuple.makePoint(0.5, 0, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+    assertEquals(equality.almostEqual(xs(0).t, 6.80798, 0.0001), true)
+    assertEquals(equality.almostEqual(xs(1).t, 7.08872, 0.0001), true)
+  }
+}

From 0adde86573ac0328624c7df2a58909f654aabdb3 Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 06:55:07 -0700
Subject: [PATCH 2/8] Compute normal vector for a cylinder

(Implemented using Anthropic's Claude)
---
 src/test/scala/CylinderSuite.scala | 32 ++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/test/scala/CylinderSuite.scala b/src/test/scala/CylinderSuite.scala
index a0dd1d7..e02ebd0 100644
--- a/src/test/scala/CylinderSuite.scala
+++ b/src/test/scala/CylinderSuite.scala
@@ -64,4 +64,36 @@ class CylinderSuite extends munit.FunSuite {
     assertEquals(equality.almostEqual(xs(0).t, 6.80798, 0.0001), true)
     assertEquals(equality.almostEqual(xs(1).t, 7.08872, 0.0001), true)
   }
+
+  test("Normal vector on a cylinder - point(1, 0, 0)") {
+    val cyl = cylinder()
+    val n = localNormalAt(cyl, tuple.makePoint(1, 0, 0))
+    val expected = tuple.makeVector(1, 0, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("Normal vector on a cylinder - point(0, 5, -1)") {
+    val cyl = cylinder()
+    val n = localNormalAt(cyl, tuple.makePoint(0, 5, -1))
+    val expected = tuple.makeVector(0, 0, -1)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("Normal vector on a cylinder - point(0, -2, 1)") {
+    val cyl = cylinder()
+    val n = localNormalAt(cyl, tuple.makePoint(0, -2, 1))
+    val expected = tuple.makeVector(0, 0, 1)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("Normal vector on a cylinder - point(-1, 1, 0)") {
+    val cyl = cylinder()
+    val n = localNormalAt(cyl, tuple.makePoint(-1, 1, 0))
+    val expected = tuple.makeVector(-1, 0, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
 }

From 6cf5dbc4dc8cd7c81a4debb040935e5ecc86784b Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 11:35:16 -0700
Subject: [PATCH 3/8] Add tests for cylinder length

(Implemented using Anthropic's Claude)
---
 src/test/scala/CylinderSuite.scala | 61 ++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/src/test/scala/CylinderSuite.scala b/src/test/scala/CylinderSuite.scala
index e02ebd0..fe9dd08 100644
--- a/src/test/scala/CylinderSuite.scala
+++ b/src/test/scala/CylinderSuite.scala
@@ -5,6 +5,13 @@ import com.samuelcantrell.raytracer.equality
 
 class CylinderSuite extends munit.FunSuite {
 
+  test("The default minimum and maximum for a cylinder") {
+    val cyl = cylinder()
+    
+    assertEquals(cyl.minimum, Double.NegativeInfinity)
+    assertEquals(cyl.maximum, Double.PositiveInfinity)
+  }
+
   test("A ray misses a cylinder - test 1") {
     val cyl = cylinder()
     val direction = tuple.normalize(tuple.makeVector(0, 1, 0))
@@ -96,4 +103,58 @@ class CylinderSuite extends munit.FunSuite {
 
     assertEquals(tuple.isEqual(n, expected), true)
   }
+
+  test("Intersecting a constrained cylinder - test 1") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2)
+    val direction = tuple.normalize(tuple.makeVector(0.1, 1, 0))
+    val r = ray.ray(tuple.makePoint(0, 1.5, 0), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("Intersecting a constrained cylinder - test 2") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2)
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(0, 3, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("Intersecting a constrained cylinder - test 3") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2)
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(0, 0, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("Intersecting a constrained cylinder - test 4") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2)
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(0, 2, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("Intersecting a constrained cylinder - test 5") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2)
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(0, 1, -5), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("Intersecting a constrained cylinder - test 6") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2)
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(0, 1.5, -2), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+  }
 }

From 655e03af65106894ade21c275e2cfdc884868ea9 Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 11:41:50 -0700
Subject: [PATCH 4/8] Use EPSILON for checking

(Implemented using Anthropic's Claude)
---
 src/main/scala/Cylinder.scala | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/main/scala/Cylinder.scala b/src/main/scala/Cylinder.scala
index 8af67aa..4b6fcf9 100644
--- a/src/main/scala/Cylinder.scala
+++ b/src/main/scala/Cylinder.scala
@@ -6,6 +6,7 @@ import com.samuelcantrell.raytracer.intersection
 import com.samuelcantrell.raytracer.matrix
 import com.samuelcantrell.raytracer.material
 import com.samuelcantrell.raytracer.shape
+import com.samuelcantrell.raytracer.equality
 import java.util.UUID
 
 case class Cylinder(
@@ -62,9 +63,9 @@ case class Cylinder(
   def localNormalAt(localPoint: tuple.Tuple): tuple.Tuple = {
     val dist = localPoint.x * localPoint.x + localPoint.z * localPoint.z
 
-    if (dist < 1 && localPoint.y >= maximum - 1e-10) {
+    if (dist < 1 && localPoint.y >= maximum - equality.EPSILON) {
       tuple.makeVector(0, 1, 0)
-    } else if (dist < 1 && localPoint.y <= minimum + 1e-10) {
+    } else if (dist < 1 && localPoint.y <= minimum + equality.EPSILON) {
       tuple.makeVector(0, -1, 0)
     } else {
       tuple.makeVector(localPoint.x, 0, localPoint.z)

From 321107162f26e1173e47d6806930038db0f7cf45 Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 11:42:15 -0700
Subject: [PATCH 5/8] Add caps to cylinders

(Implemented using Anthropic's Claude)
---
 src/main/scala/Cylinder.scala      | 51 +++++++++++----
 src/test/scala/CylinderSuite.scala | 99 ++++++++++++++++++++++++++++++
 2 files changed, 138 insertions(+), 12 deletions(-)

diff --git a/src/main/scala/Cylinder.scala b/src/main/scala/Cylinder.scala
index 4b6fcf9..eab78a7 100644
--- a/src/main/scala/Cylinder.scala
+++ b/src/main/scala/Cylinder.scala
@@ -19,13 +19,14 @@ case class Cylinder(
 ) extends shape.Shape {
 
   def localIntersect(localRay: ray.Ray): intersection.Intersections = {
+    val intersections = scala.collection.mutable.ArrayBuffer[intersection.Intersection]()
+    
+    // Check for intersections with the cylinder walls
     val a = localRay.direction.x * localRay.direction.x + 
             localRay.direction.z * localRay.direction.z
 
-    // Ray is parallel to the y axis
-    if (math.abs(a) < 1e-10) {
-      intersection.Intersections(Array.empty[intersection.Intersection])
-    } else {
+    // Ray is not parallel to the y axis
+    if (math.abs(a) >= equality.EPSILON) {
       val b = 2 * localRay.origin.x * localRay.direction.x + 
               2 * localRay.origin.z * localRay.direction.z
       val c = localRay.origin.x * localRay.origin.x + 
@@ -33,10 +34,8 @@ case class Cylinder(
 
       val discriminant = b * b - 4 * a * c
 
-      // Ray does not intersect the cylinder
-      if (discriminant < 0) {
-        intersection.Intersections(Array.empty[intersection.Intersection])
-      } else {
+      // Ray intersects the cylinder
+      if (discriminant >= 0) {
         val t0 = (-b - math.sqrt(discriminant)) / (2 * a)
         val t1 = (-b + math.sqrt(discriminant)) / (2 * a)
 
@@ -45,8 +44,6 @@ case class Cylinder(
         val y0 = localRay.origin.y + t0_sorted * localRay.direction.y
         val y1 = localRay.origin.y + t1_sorted * localRay.direction.y
 
-        val intersections = scala.collection.mutable.ArrayBuffer[intersection.Intersection]()
-
         if (minimum < y0 && y0 < maximum) {
           intersections += intersection.intersection(t0_sorted, this)
         }
@@ -54,10 +51,40 @@ case class Cylinder(
         if (minimum < y1 && y1 < maximum) {
           intersections += intersection.intersection(t1_sorted, this)
         }
-
-        intersection.Intersections(intersections.toArray)
       }
     }
+    
+    // Check for intersections with the caps if the cylinder is closed
+    if (closed) {
+      intersectCaps(localRay, intersections)
+    }
+
+    intersection.Intersections(intersections.toArray)
+  }
+
+  private def intersectCaps(localRay: ray.Ray, intersections: scala.collection.mutable.ArrayBuffer[intersection.Intersection]): Unit = {
+    // Check if ray is parallel to the xz plane
+    if (math.abs(localRay.direction.y) < equality.EPSILON) {
+      return
+    }
+
+    // Check intersection with lower cap at y = minimum
+    val t_lower = (minimum - localRay.origin.y) / localRay.direction.y
+    if (checkCap(localRay, t_lower)) {
+      intersections += intersection.intersection(t_lower, this)
+    }
+
+    // Check intersection with upper cap at y = maximum
+    val t_upper = (maximum - localRay.origin.y) / localRay.direction.y
+    if (checkCap(localRay, t_upper)) {
+      intersections += intersection.intersection(t_upper, this)
+    }
+  }
+
+  private def checkCap(r: ray.Ray, t: Double): Boolean = {
+    val x = r.origin.x + t * r.direction.x
+    val z = r.origin.z + t * r.direction.z
+    (x * x + z * z) <= 1
   }
 
   def localNormalAt(localPoint: tuple.Tuple): tuple.Tuple = {
diff --git a/src/test/scala/CylinderSuite.scala b/src/test/scala/CylinderSuite.scala
index fe9dd08..d10f157 100644
--- a/src/test/scala/CylinderSuite.scala
+++ b/src/test/scala/CylinderSuite.scala
@@ -12,6 +12,12 @@ class CylinderSuite extends munit.FunSuite {
     assertEquals(cyl.maximum, Double.PositiveInfinity)
   }
 
+  test("The default closed value for a cylinder") {
+    val cyl = cylinder()
+    
+    assertEquals(cyl.closed, false)
+  }
+
   test("A ray misses a cylinder - test 1") {
     val cyl = cylinder()
     val direction = tuple.normalize(tuple.makeVector(0, 1, 0))
@@ -157,4 +163,97 @@ class CylinderSuite extends munit.FunSuite {
 
     assertEquals(xs.count, 2)
   }
+
+  test("Intersecting the caps of a closed cylinder - test 1") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, -1, 0))
+    val r = ray.ray(tuple.makePoint(0, 3, 0), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+  }
+
+  test("Intersecting the caps of a closed cylinder - test 2") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, -1, 2))
+    val r = ray.ray(tuple.makePoint(0, 3, -2), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+  }
+
+  test("Intersecting the caps of a closed cylinder - test 3") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, -1, 1))
+    val r = ray.ray(tuple.makePoint(0, 4, -2), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+  }
+
+  test("Intersecting the caps of a closed cylinder - test 4") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 2))
+    val r = ray.ray(tuple.makePoint(0, 0, -2), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+  }
+
+  test("Intersecting the caps of a closed cylinder - test 5") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 1))
+    val r = ray.ray(tuple.makePoint(0, -1, -2), direction)
+    val xs = localIntersect(cyl, r)
+
+    assertEquals(xs.count, 2)
+  }
+
+  test("The normal vector on a cylinder's end caps - point(0, 1, 0)") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val n = localNormalAt(cyl, tuple.makePoint(0, 1, 0))
+    val expected = tuple.makeVector(0, -1, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("The normal vector on a cylinder's end caps - point(0.5, 1, 0)") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val n = localNormalAt(cyl, tuple.makePoint(0.5, 1, 0))
+    val expected = tuple.makeVector(0, -1, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("The normal vector on a cylinder's end caps - point(0, 1, 0.5)") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val n = localNormalAt(cyl, tuple.makePoint(0, 1, 0.5))
+    val expected = tuple.makeVector(0, -1, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("The normal vector on a cylinder's end caps - point(0, 2, 0)") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val n = localNormalAt(cyl, tuple.makePoint(0, 2, 0))
+    val expected = tuple.makeVector(0, 1, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("The normal vector on a cylinder's end caps - point(0.5, 2, 0)") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val n = localNormalAt(cyl, tuple.makePoint(0.5, 2, 0))
+    val expected = tuple.makeVector(0, 1, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("The normal vector on a cylinder's end caps - point(0, 2, 0.5)") {
+    val cyl = cylinder().copy(minimum = 1, maximum = 2, closed = true)
+    val n = localNormalAt(cyl, tuple.makePoint(0, 2, 0.5))
+    val expected = tuple.makeVector(0, 1, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
 }

From d7423106c43f927f1b1f1796de5a737f3fed543e Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 11:49:51 -0700
Subject: [PATCH 6/8] Add Cone primitive

(Implemented using Anthropic's Claude)
---
 src/main/scala/Cone.scala      | 154 +++++++++++++++++++++++++++++++++
 src/test/scala/ConeSuite.scala | 101 +++++++++++++++++++++
 2 files changed, 255 insertions(+)
 create mode 100644 src/main/scala/Cone.scala
 create mode 100644 src/test/scala/ConeSuite.scala

diff --git a/src/main/scala/Cone.scala b/src/main/scala/Cone.scala
new file mode 100644
index 0000000..e4a1966
--- /dev/null
+++ b/src/main/scala/Cone.scala
@@ -0,0 +1,154 @@
+package com.samuelcantrell.raytracer.cone
+
+import com.samuelcantrell.raytracer.ray
+import com.samuelcantrell.raytracer.tuple
+import com.samuelcantrell.raytracer.intersection
+import com.samuelcantrell.raytracer.matrix
+import com.samuelcantrell.raytracer.material
+import com.samuelcantrell.raytracer.shape
+import com.samuelcantrell.raytracer.equality
+import java.util.UUID
+
+case class Cone(
+    id: String = UUID.randomUUID().toString,
+    transform: matrix.Matrix = matrix.Matrix.identity(),
+    objectMaterial: material.Material = material.material(),
+    minimum: Double = Double.NegativeInfinity,
+    maximum: Double = Double.PositiveInfinity,
+    closed: Boolean = false
+) extends shape.Shape {
+
+  def localIntersect(localRay: ray.Ray): intersection.Intersections = {
+    val intersections = scala.collection.mutable.ArrayBuffer[intersection.Intersection]()
+    
+    // Check for intersections with the cone surface
+    // Cone equation: x² + z² = y²
+    // Substituting ray: (ox + t*dx)² + (oz + t*dz)² = (oy + t*dy)²
+    val a = localRay.direction.x * localRay.direction.x + 
+            localRay.direction.z * localRay.direction.z - 
+            localRay.direction.y * localRay.direction.y
+    
+    val b = 2 * localRay.origin.x * localRay.direction.x + 
+            2 * localRay.origin.z * localRay.direction.z - 
+            2 * localRay.origin.y * localRay.direction.y
+            
+    val c = localRay.origin.x * localRay.origin.x + 
+            localRay.origin.z * localRay.origin.z - 
+            localRay.origin.y * localRay.origin.y
+
+    if (math.abs(a) < equality.EPSILON) {
+      // Ray is parallel to one of the cone's halves
+      if (math.abs(b) >= equality.EPSILON) {
+        val t = -c / (2 * b)
+        val y = localRay.origin.y + t * localRay.direction.y
+        if (minimum < y && y < maximum) {
+          intersections += intersection.intersection(t, this)
+        }
+      }
+    } else {
+      val discriminant = b * b - 4 * a * c
+
+      if (discriminant >= 0) {
+        val t0 = (-b - math.sqrt(discriminant)) / (2 * a)
+        val t1 = (-b + math.sqrt(discriminant)) / (2 * a)
+
+        val (t0_sorted, t1_sorted) = if (t0 > t1) (t1, t0) else (t0, t1)
+
+        val y0 = localRay.origin.y + t0_sorted * localRay.direction.y
+        val y1 = localRay.origin.y + t1_sorted * localRay.direction.y
+
+        if (minimum < y0 && y0 < maximum) {
+          intersections += intersection.intersection(t0_sorted, this)
+        }
+
+        if (minimum < y1 && y1 < maximum) {
+          intersections += intersection.intersection(t1_sorted, this)
+        }
+      }
+    }
+    
+    // Check for intersections with the caps if the cone is closed
+    if (closed) {
+      intersectCaps(localRay, intersections)
+    }
+
+    intersection.Intersections(intersections.toArray)
+  }
+
+  private def intersectCaps(localRay: ray.Ray, intersections: scala.collection.mutable.ArrayBuffer[intersection.Intersection]): Unit = {
+    // Check if ray is parallel to the xz plane
+    if (math.abs(localRay.direction.y) < equality.EPSILON) {
+      return
+    }
+
+    // Check intersection with lower cap at y = minimum
+    val t_lower = (minimum - localRay.origin.y) / localRay.direction.y
+    if (checkCap(localRay, t_lower, minimum)) {
+      intersections += intersection.intersection(t_lower, this)
+    }
+
+    // Check intersection with upper cap at y = maximum
+    val t_upper = (maximum - localRay.origin.y) / localRay.direction.y
+    if (checkCap(localRay, t_upper, maximum)) {
+      intersections += intersection.intersection(t_upper, this)
+    }
+  }
+
+  private def checkCap(r: ray.Ray, t: Double, y: Double): Boolean = {
+    val x = r.origin.x + t * r.direction.x
+    val z = r.origin.z + t * r.direction.z
+    val radius = math.abs(y)
+    (x * x + z * z) <= radius * radius
+  }
+
+  def localNormalAt(localPoint: tuple.Tuple): tuple.Tuple = {
+    val dist = localPoint.x * localPoint.x + localPoint.z * localPoint.z
+
+    if (dist < math.abs(localPoint.y) && localPoint.y >= maximum - equality.EPSILON) {
+      tuple.makeVector(0, 1, 0)
+    } else if (dist < math.abs(localPoint.y) && localPoint.y <= minimum + equality.EPSILON) {
+      tuple.makeVector(0, -1, 0)
+    } else {
+      val y = if (localPoint.y > 0) -math.sqrt(dist) else math.sqrt(dist)
+      tuple.makeVector(localPoint.x, y, localPoint.z)
+    }
+  }
+
+  def withTransform(newTransform: matrix.Matrix): Cone = {
+    this.copy(transform = newTransform)
+  }
+
+  def withMaterial(newMaterial: material.Material): Cone = {
+    this.copy(objectMaterial = newMaterial)
+  }
+}
+
+def cone(): Cone = {
+  Cone()
+}
+
+// Convenience functions for backward compatibility
+def setTransform(c: Cone, t: matrix.Matrix): Cone = {
+  shape.setTransform(c, t)
+}
+
+def setMaterial(c: Cone, m: material.Material): Cone = {
+  shape.setMaterial(c, m)
+}
+
+def intersect(c: Cone, r: ray.Ray): intersection.Intersections = {
+  shape.intersect(c, r)
+}
+
+def normalAt(c: Cone, worldPoint: tuple.Tuple): tuple.Tuple = {
+  shape.normalAt(c, worldPoint)
+}
+
+// Direct access to local methods for testing
+def localIntersect(c: Cone, localRay: ray.Ray): intersection.Intersections = {
+  c.localIntersect(localRay)
+}
+
+def localNormalAt(c: Cone, localPoint: tuple.Tuple): tuple.Tuple = {
+  c.localNormalAt(localPoint)
+}
\ No newline at end of file
diff --git a/src/test/scala/ConeSuite.scala b/src/test/scala/ConeSuite.scala
new file mode 100644
index 0000000..90f3011
--- /dev/null
+++ b/src/test/scala/ConeSuite.scala
@@ -0,0 +1,101 @@
+import com.samuelcantrell.raytracer.cone._
+import com.samuelcantrell.raytracer.ray
+import com.samuelcantrell.raytracer.tuple
+import com.samuelcantrell.raytracer.equality
+
+class ConeSuite extends munit.FunSuite {
+
+  test("Intersecting a cone with a ray - test 1") {
+    val shape = cone()
+    val direction = tuple.normalize(tuple.makeVector(0, 0, 1))
+    val r = ray.ray(tuple.makePoint(0, 0, -5), direction)
+    val xs = localIntersect(shape, r)
+
+    assertEquals(xs.count, 2)
+    assertEquals(equality.almostEqual(xs(0).t, 5.0), true)
+    assertEquals(equality.almostEqual(xs(1).t, 5.0), true)
+  }
+
+  test("Intersecting a cone with a ray - test 2") {
+    val shape = cone()
+    val direction = tuple.normalize(tuple.makeVector(1, 1, 1))
+    val r = ray.ray(tuple.makePoint(0, 0, -5), direction)
+    val xs = localIntersect(shape, r)
+
+    assertEquals(xs.count, 2)
+    assertEquals(equality.almostEqual(xs(0).t, 8.66025, 0.001), true)
+    assertEquals(equality.almostEqual(xs(1).t, 8.66025, 0.001), true)
+  }
+
+  test("Intersecting a cone with a ray - test 3") {
+    val shape = cone()
+    val direction = tuple.normalize(tuple.makeVector(-0.5, -1, 1))
+    val r = ray.ray(tuple.makePoint(1, 1, -5), direction)
+    val xs = localIntersect(shape, r)
+
+    assertEquals(xs.count, 2)
+    assertEquals(equality.almostEqual(xs(0).t, 4.55006, 0.001), true)
+    assertEquals(equality.almostEqual(xs(1).t, 49.44994, 0.001), true)
+  }
+
+  test("Intersecting a cone with a ray parallel to one of its halves") {
+    val shape = cone()
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 1))
+    val r = ray.ray(tuple.makePoint(0, 0, -1), direction)
+    val xs = localIntersect(shape, r)
+
+    assertEquals(xs.count, 1)
+    assertEquals(equality.almostEqual(xs(0).t, 0.35355, 0.001), true)
+  }
+
+  test("Intersecting a cone's end caps - test 1") {
+    val shape = cone().copy(minimum = -0.5, maximum = 0.5, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 0))
+    val r = ray.ray(tuple.makePoint(0, 0, -5), direction)
+    val xs = localIntersect(shape, r)
+
+    assertEquals(xs.count, 0)
+  }
+
+  test("Intersecting a cone's end caps - test 2") {
+    val shape = cone().copy(minimum = -0.5, maximum = 0.5, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 1))
+    val r = ray.ray(tuple.makePoint(0, 0, -0.25), direction)
+    val xs = localIntersect(shape, r)
+
+    assertEquals(xs.count, 2)
+  }
+
+  test("Intersecting a cone's end caps - test 3") {
+    val shape = cone().copy(minimum = -0.5, maximum = 0.5, closed = true)
+    val direction = tuple.normalize(tuple.makeVector(0, 1, 0))
+    val r = ray.ray(tuple.makePoint(0, 0, -0.25), direction)
+    val xs = localIntersect(shape, r)
+
+    assertEquals(xs.count, 4)
+  }
+
+  test("Computing the normal vector on a cone - point(0, 0, 0)") {
+    val shape = cone()
+    val n = localNormalAt(shape, tuple.makePoint(0, 0, 0))
+    val expected = tuple.makeVector(0, 0, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("Computing the normal vector on a cone - point(1, 1, 1)") {
+    val shape = cone()
+    val n = localNormalAt(shape, tuple.makePoint(1, 1, 1))
+    val expected = tuple.makeVector(1, -math.sqrt(2), 1)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+
+  test("Computing the normal vector on a cone - point(-1, -1, 0)") {
+    val shape = cone()
+    val n = localNormalAt(shape, tuple.makePoint(-1, -1, 0))
+    val expected = tuple.makeVector(-1, 1, 0)
+
+    assertEquals(tuple.isEqual(n, expected), true)
+  }
+}
\ No newline at end of file

From fa308f76cb66b884c84f97de6ba15861afeabc70 Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 15:45:08 -0700
Subject: [PATCH 7/8] Refactor Cone and Cylinder for common code

(Implemented using Anthropic's Claude)
---
 src/main/scala/Cone.scala         | 108 +++++++---------------------
 src/main/scala/Cylinder.scala     | 103 +++++++--------------------
 src/main/scala/QuadricShape.scala | 112 ++++++++++++++++++++++++++++++
 3 files changed, 162 insertions(+), 161 deletions(-)
 create mode 100644 src/main/scala/QuadricShape.scala

diff --git a/src/main/scala/Cone.scala b/src/main/scala/Cone.scala
index e4a1966..234d61c 100644
--- a/src/main/scala/Cone.scala
+++ b/src/main/scala/Cone.scala
@@ -7,111 +7,53 @@ import com.samuelcantrell.raytracer.matrix
 import com.samuelcantrell.raytracer.material
 import com.samuelcantrell.raytracer.shape
 import com.samuelcantrell.raytracer.equality
+import com.samuelcantrell.raytracer.quadric.QuadricShape
 import java.util.UUID
 
 case class Cone(
-    id: String = UUID.randomUUID().toString,
-    transform: matrix.Matrix = matrix.Matrix.identity(),
-    objectMaterial: material.Material = material.material(),
-    minimum: Double = Double.NegativeInfinity,
-    maximum: Double = Double.PositiveInfinity,
-    closed: Boolean = false
-) extends shape.Shape {
-
-  def localIntersect(localRay: ray.Ray): intersection.Intersections = {
-    val intersections = scala.collection.mutable.ArrayBuffer[intersection.Intersection]()
-    
-    // Check for intersections with the cone surface
+    override val id: String = UUID.randomUUID().toString,
+    override val transform: matrix.Matrix = matrix.Matrix.identity(),
+    override val objectMaterial: material.Material = material.material(),
+    override val minimum: Double = Double.NegativeInfinity,
+    override val maximum: Double = Double.PositiveInfinity,
+    override val closed: Boolean = false
+) extends QuadricShape(id, transform, objectMaterial, minimum, maximum, closed) {
+
+  // Cone-specific implementations
+  protected def surfaceIntersectionCoefficients(localRay: ray.Ray): (Double, Double, Double) = {
     // Cone equation: x² + z² = y²
-    // Substituting ray: (ox + t*dx)² + (oz + t*dz)² = (oy + t*dy)²
     val a = localRay.direction.x * localRay.direction.x + 
             localRay.direction.z * localRay.direction.z - 
             localRay.direction.y * localRay.direction.y
-    
     val b = 2 * localRay.origin.x * localRay.direction.x + 
             2 * localRay.origin.z * localRay.direction.z - 
             2 * localRay.origin.y * localRay.direction.y
-            
     val c = localRay.origin.x * localRay.origin.x + 
             localRay.origin.z * localRay.origin.z - 
             localRay.origin.y * localRay.origin.y
+    (a, b, c)
+  }
 
-    if (math.abs(a) < equality.EPSILON) {
-      // Ray is parallel to one of the cone's halves
-      if (math.abs(b) >= equality.EPSILON) {
-        val t = -c / (2 * b)
-        val y = localRay.origin.y + t * localRay.direction.y
-        if (minimum < y && y < maximum) {
-          intersections += intersection.intersection(t, this)
-        }
-      }
+  protected def handleParallelRay(localRay: ray.Ray, b: Double, c: Double): Option[Double] = {
+    // Ray is parallel to one of the cone's halves
+    if (math.abs(b) >= equality.EPSILON) {
+      Some(-c / (2 * b))
     } else {
-      val discriminant = b * b - 4 * a * c
-
-      if (discriminant >= 0) {
-        val t0 = (-b - math.sqrt(discriminant)) / (2 * a)
-        val t1 = (-b + math.sqrt(discriminant)) / (2 * a)
-
-        val (t0_sorted, t1_sorted) = if (t0 > t1) (t1, t0) else (t0, t1)
-
-        val y0 = localRay.origin.y + t0_sorted * localRay.direction.y
-        val y1 = localRay.origin.y + t1_sorted * localRay.direction.y
-
-        if (minimum < y0 && y0 < maximum) {
-          intersections += intersection.intersection(t0_sorted, this)
-        }
-
-        if (minimum < y1 && y1 < maximum) {
-          intersections += intersection.intersection(t1_sorted, this)
-        }
-      }
-    }
-    
-    // Check for intersections with the caps if the cone is closed
-    if (closed) {
-      intersectCaps(localRay, intersections)
+      None
     }
-
-    intersection.Intersections(intersections.toArray)
   }
 
-  private def intersectCaps(localRay: ray.Ray, intersections: scala.collection.mutable.ArrayBuffer[intersection.Intersection]): Unit = {
-    // Check if ray is parallel to the xz plane
-    if (math.abs(localRay.direction.y) < equality.EPSILON) {
-      return
-    }
-
-    // Check intersection with lower cap at y = minimum
-    val t_lower = (minimum - localRay.origin.y) / localRay.direction.y
-    if (checkCap(localRay, t_lower, minimum)) {
-      intersections += intersection.intersection(t_lower, this)
-    }
-
-    // Check intersection with upper cap at y = maximum
-    val t_upper = (maximum - localRay.origin.y) / localRay.direction.y
-    if (checkCap(localRay, t_upper, maximum)) {
-      intersections += intersection.intersection(t_upper, this)
-    }
-  }
+  protected def capRadius(y: Double): Double = math.abs(y)
 
-  private def checkCap(r: ray.Ray, t: Double, y: Double): Boolean = {
-    val x = r.origin.x + t * r.direction.x
-    val z = r.origin.z + t * r.direction.z
-    val radius = math.abs(y)
-    (x * x + z * z) <= radius * radius
+  protected def surfaceNormal(localPoint: tuple.Tuple): tuple.Tuple = {
+    val dist = localPoint.x * localPoint.x + localPoint.z * localPoint.z
+    val y = if (localPoint.y > 0) -math.sqrt(dist) else math.sqrt(dist)
+    tuple.makeVector(localPoint.x, y, localPoint.z)
   }
 
-  def localNormalAt(localPoint: tuple.Tuple): tuple.Tuple = {
+  protected def isOnCap(localPoint: tuple.Tuple, y: Double): Boolean = {
     val dist = localPoint.x * localPoint.x + localPoint.z * localPoint.z
-
-    if (dist < math.abs(localPoint.y) && localPoint.y >= maximum - equality.EPSILON) {
-      tuple.makeVector(0, 1, 0)
-    } else if (dist < math.abs(localPoint.y) && localPoint.y <= minimum + equality.EPSILON) {
-      tuple.makeVector(0, -1, 0)
-    } else {
-      val y = if (localPoint.y > 0) -math.sqrt(dist) else math.sqrt(dist)
-      tuple.makeVector(localPoint.x, y, localPoint.z)
-    }
+    dist < math.abs(y) && math.abs(localPoint.y - y) < equality.EPSILON
   }
 
   def withTransform(newTransform: matrix.Matrix): Cone = {
diff --git a/src/main/scala/Cylinder.scala b/src/main/scala/Cylinder.scala
index eab78a7..dcfa5bd 100644
--- a/src/main/scala/Cylinder.scala
+++ b/src/main/scala/Cylinder.scala
@@ -7,96 +7,43 @@ import com.samuelcantrell.raytracer.matrix
 import com.samuelcantrell.raytracer.material
 import com.samuelcantrell.raytracer.shape
 import com.samuelcantrell.raytracer.equality
+import com.samuelcantrell.raytracer.quadric.QuadricShape
 import java.util.UUID
 
 case class Cylinder(
-    id: String = UUID.randomUUID().toString,
-    transform: matrix.Matrix = matrix.Matrix.identity(),
-    objectMaterial: material.Material = material.material(),
-    minimum: Double = Double.NegativeInfinity,
-    maximum: Double = Double.PositiveInfinity,
-    closed: Boolean = false
-) extends shape.Shape {
-
-  def localIntersect(localRay: ray.Ray): intersection.Intersections = {
-    val intersections = scala.collection.mutable.ArrayBuffer[intersection.Intersection]()
-    
-    // Check for intersections with the cylinder walls
+    override val id: String = UUID.randomUUID().toString,
+    override val transform: matrix.Matrix = matrix.Matrix.identity(),
+    override val objectMaterial: material.Material = material.material(),
+    override val minimum: Double = Double.NegativeInfinity,
+    override val maximum: Double = Double.PositiveInfinity,
+    override val closed: Boolean = false
+) extends QuadricShape(id, transform, objectMaterial, minimum, maximum, closed) {
+
+  // Cylinder-specific implementations
+  protected def surfaceIntersectionCoefficients(localRay: ray.Ray): (Double, Double, Double) = {
     val a = localRay.direction.x * localRay.direction.x + 
             localRay.direction.z * localRay.direction.z
-
-    // Ray is not parallel to the y axis
-    if (math.abs(a) >= equality.EPSILON) {
-      val b = 2 * localRay.origin.x * localRay.direction.x + 
-              2 * localRay.origin.z * localRay.direction.z
-      val c = localRay.origin.x * localRay.origin.x + 
-              localRay.origin.z * localRay.origin.z - 1
-
-      val discriminant = b * b - 4 * a * c
-
-      // Ray intersects the cylinder
-      if (discriminant >= 0) {
-        val t0 = (-b - math.sqrt(discriminant)) / (2 * a)
-        val t1 = (-b + math.sqrt(discriminant)) / (2 * a)
-
-        val (t0_sorted, t1_sorted) = if (t0 > t1) (t1, t0) else (t0, t1)
-
-        val y0 = localRay.origin.y + t0_sorted * localRay.direction.y
-        val y1 = localRay.origin.y + t1_sorted * localRay.direction.y
-
-        if (minimum < y0 && y0 < maximum) {
-          intersections += intersection.intersection(t0_sorted, this)
-        }
-
-        if (minimum < y1 && y1 < maximum) {
-          intersections += intersection.intersection(t1_sorted, this)
-        }
-      }
-    }
-    
-    // Check for intersections with the caps if the cylinder is closed
-    if (closed) {
-      intersectCaps(localRay, intersections)
-    }
-
-    intersection.Intersections(intersections.toArray)
+    val b = 2 * localRay.origin.x * localRay.direction.x + 
+            2 * localRay.origin.z * localRay.direction.z
+    val c = localRay.origin.x * localRay.origin.x + 
+            localRay.origin.z * localRay.origin.z - 1
+    (a, b, c)
   }
 
-  private def intersectCaps(localRay: ray.Ray, intersections: scala.collection.mutable.ArrayBuffer[intersection.Intersection]): Unit = {
-    // Check if ray is parallel to the xz plane
-    if (math.abs(localRay.direction.y) < equality.EPSILON) {
-      return
-    }
-
-    // Check intersection with lower cap at y = minimum
-    val t_lower = (minimum - localRay.origin.y) / localRay.direction.y
-    if (checkCap(localRay, t_lower)) {
-      intersections += intersection.intersection(t_lower, this)
-    }
-
-    // Check intersection with upper cap at y = maximum
-    val t_upper = (maximum - localRay.origin.y) / localRay.direction.y
-    if (checkCap(localRay, t_upper)) {
-      intersections += intersection.intersection(t_upper, this)
-    }
+  protected def handleParallelRay(localRay: ray.Ray, b: Double, c: Double): Option[Double] = {
+    // Cylinders don't have parallel ray intersections (when a ≈ 0, no intersection)
+    None
   }
 
-  private def checkCap(r: ray.Ray, t: Double): Boolean = {
-    val x = r.origin.x + t * r.direction.x
-    val z = r.origin.z + t * r.direction.z
-    (x * x + z * z) <= 1
+  protected def capRadius(y: Double): Double = 1.0
+
+  protected def surfaceNormal(localPoint: tuple.Tuple): tuple.Tuple = {
+    tuple.makeVector(localPoint.x, 0, localPoint.z)
   }
 
-  def localNormalAt(localPoint: tuple.Tuple): tuple.Tuple = {
+  protected def isOnCap(localPoint: tuple.Tuple, y: Double): Boolean = {
     val dist = localPoint.x * localPoint.x + localPoint.z * localPoint.z
-
-    if (dist < 1 && localPoint.y >= maximum - equality.EPSILON) {
-      tuple.makeVector(0, 1, 0)
-    } else if (dist < 1 && localPoint.y <= minimum + equality.EPSILON) {
-      tuple.makeVector(0, -1, 0)
-    } else {
-      tuple.makeVector(localPoint.x, 0, localPoint.z)
-    }
+    dist < 1 && math.abs(localPoint.y - y) < equality.EPSILON
   }
 
   def withTransform(newTransform: matrix.Matrix): Cylinder = {
diff --git a/src/main/scala/QuadricShape.scala b/src/main/scala/QuadricShape.scala
new file mode 100644
index 0000000..3baa4f2
--- /dev/null
+++ b/src/main/scala/QuadricShape.scala
@@ -0,0 +1,112 @@
+package com.samuelcantrell.raytracer.quadric
+
+import com.samuelcantrell.raytracer.ray
+import com.samuelcantrell.raytracer.tuple
+import com.samuelcantrell.raytracer.intersection
+import com.samuelcantrell.raytracer.matrix
+import com.samuelcantrell.raytracer.material
+import com.samuelcantrell.raytracer.shape
+import com.samuelcantrell.raytracer.equality
+import java.util.UUID
+
+// Base trait for shapes that can be represented by quadric surfaces (cylinders, cones, etc.)
+abstract class QuadricShape(
+    val id: String = UUID.randomUUID().toString,
+    val transform: matrix.Matrix = matrix.Matrix.identity(),
+    val objectMaterial: material.Material = material.material(),
+    val minimum: Double = Double.NegativeInfinity,
+    val maximum: Double = Double.PositiveInfinity,
+    val closed: Boolean = false
+) extends shape.Shape {
+
+  // Abstract methods that subclasses must implement
+  protected def surfaceIntersectionCoefficients(localRay: ray.Ray): (Double, Double, Double)
+  protected def handleParallelRay(localRay: ray.Ray, b: Double, c: Double): Option[Double]
+  protected def capRadius(y: Double): Double
+  protected def surfaceNormal(localPoint: tuple.Tuple): tuple.Tuple
+  protected def isOnCap(localPoint: tuple.Tuple, y: Double): Boolean
+
+  def localIntersect(localRay: ray.Ray): intersection.Intersections = {
+    val intersections = scala.collection.mutable.ArrayBuffer[intersection.Intersection]()
+    
+    // Get surface intersection coefficients from subclass
+    val (a, b, c) = surfaceIntersectionCoefficients(localRay)
+
+    if (math.abs(a) < equality.EPSILON) {
+      // Handle special case (parallel ray for cones, never happens for cylinders)
+      handleParallelRay(localRay, b, c) match {
+        case Some(t) =>
+          val y = localRay.origin.y + t * localRay.direction.y
+          if (minimum < y && y < maximum) {
+            intersections += intersection.intersection(t, this)
+          }
+        case None => // No intersection
+      }
+    } else {
+      val discriminant = b * b - 4 * a * c
+
+      if (discriminant >= 0) {
+        val t0 = (-b - math.sqrt(discriminant)) / (2 * a)
+        val t1 = (-b + math.sqrt(discriminant)) / (2 * a)
+
+        val (t0_sorted, t1_sorted) = if (t0 > t1) (t1, t0) else (t0, t1)
+
+        val y0 = localRay.origin.y + t0_sorted * localRay.direction.y
+        val y1 = localRay.origin.y + t1_sorted * localRay.direction.y
+
+        if (minimum < y0 && y0 < maximum) {
+          intersections += intersection.intersection(t0_sorted, this)
+        }
+
+        if (minimum < y1 && y1 < maximum) {
+          intersections += intersection.intersection(t1_sorted, this)
+        }
+      }
+    }
+    
+    // Check for intersections with the caps if the shape is closed
+    if (closed) {
+      intersectCaps(localRay, intersections)
+    }
+
+    intersection.Intersections(intersections.toArray)
+  }
+
+  private def intersectCaps(localRay: ray.Ray, intersections: scala.collection.mutable.ArrayBuffer[intersection.Intersection]): Unit = {
+    // Check if ray is parallel to the xz plane
+    if (math.abs(localRay.direction.y) < equality.EPSILON) {
+      return
+    }
+
+    // Check intersection with lower cap at y = minimum
+    val t_lower = (minimum - localRay.origin.y) / localRay.direction.y
+    if (checkCap(localRay, t_lower, minimum)) {
+      intersections += intersection.intersection(t_lower, this)
+    }
+
+    // Check intersection with upper cap at y = maximum
+    val t_upper = (maximum - localRay.origin.y) / localRay.direction.y
+    if (checkCap(localRay, t_upper, maximum)) {
+      intersections += intersection.intersection(t_upper, this)
+    }
+  }
+
+  private def checkCap(r: ray.Ray, t: Double, y: Double): Boolean = {
+    val x = r.origin.x + t * r.direction.x
+    val z = r.origin.z + t * r.direction.z
+    val radius = capRadius(y)
+    (x * x + z * z) <= radius * radius
+  }
+
+  def localNormalAt(localPoint: tuple.Tuple): tuple.Tuple = {
+    // Check if we're on a cap first
+    if (isOnCap(localPoint, maximum)) {
+      tuple.makeVector(0, 1, 0)
+    } else if (isOnCap(localPoint, minimum)) {
+      tuple.makeVector(0, -1, 0)
+    } else {
+      // We're on the surface
+      surfaceNormal(localPoint)
+    }
+  }
+}
\ No newline at end of file

From 60246982125e49cc841c8af9ae6d4c4e07f32ee2 Mon Sep 17 00:00:00 2001
From: Sam Cantrell <1220819+samcan@users.noreply.github.com>
Date: Tue, 19 Aug 2025 16:02:48 -0700
Subject: [PATCH 8/8] Updated main scene and README

(Implemented using Anthropic's Claude)
---
 README.md                 |  14 ++++++++++----
 docs/cylinder.png         | Bin 0 -> 35631 bytes
 src/main/scala/Main.scala |  36 +++++++++++++++++++++++++++++++++++-
 3 files changed, 45 insertions(+), 5 deletions(-)
 create mode 100644 docs/cylinder.png

diff --git a/README.md b/README.md
index 20595f6..e4cae55 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,8 @@ This project was implemented as a learning experience using Anthropic's Claude a
 This ray tracer currently supports:
 
 ### Core Rendering
-- **Ray-object intersection** for spheres, planes, and cubes
+- **Ray-object intersection** for spheres, planes, cubes, cylinders, and cones
+- **Quadric surface support** with shared geometry handling for cylinders and cones
 - **Phong lighting model** with ambient, diffuse, and specular components
 - **Shadows** with accurate shadow ray calculations
 - **Camera system** with configurable field of view and transforms
@@ -28,6 +29,8 @@ This ray tracer currently supports:
 - **Total internal reflection** for accurate light behavior in transparent objects
 
 ### Geometry & Transformations
+- **Primitive shapes**: spheres, planes, cubes, cylinders (with caps), and cones (with caps)
+- **Constrained primitives**: cylinders and cones with configurable height limits
 - **3D transformations**: translation, scaling, rotation, shearing
 - **View transformations** for camera positioning
 - **Matrix operations** with 4x4 homogeneous coordinates
@@ -37,7 +40,7 @@ This ray tracer currently supports:
 
 The raytracer can render complex scenes with multiple objects, transparency, refraction, reflections, and realistic lighting:
 
-![Sample raytraced scene with cube, spheres, transparency and reflections](docs/cube.png)
+![Sample raytraced scene with cylinders, cones, cubes, spheres, transparency and reflections](docs/cylinder.png)
 
 ## Getting Started
 
@@ -75,8 +78,9 @@ sbt test
 ## Project Structure
 
 - `src/main/scala/` - Core raytracer implementation
-  - `Main.scala` - Demo scene with spheres, planes, cubes, and lighting
-  - `Ray.scala`, `Sphere.scala`, `Plane.scala`, `Cube.scala` - Geometric primitives
+  - `Main.scala` - Demo scene with spheres, planes, cubes, cylinders, cones, and lighting
+  - `Ray.scala`, `Sphere.scala`, `Plane.scala`, `Cube.scala`, `Cylinder.scala`, `Cone.scala` - Geometric primitives
+  - `QuadricShape.scala` - Base class for quadric surfaces (cylinders and cones)
   - `Material.scala`, `Pattern.scala` - Surface properties and patterns
   - `Camera.scala`, `World.scala` - Scene and camera management
   - `Color.scala`, `Canvas.scala` - Color handling and image generation
@@ -93,6 +97,8 @@ The default scene (in `Main.scala`) renders:
   - **Right sphere**: Highly reflective metallic surface
   - **Left sphere**: Matte yellow-orange surface
 - A red cube positioned in the background with rotation
+- A blue cylinder with closed caps positioned on the left side
+- An orange cone with closed caps positioned in the foreground
 - Point light source positioned above and to the left
 
 You can modify the scene by editing `Main.scala` to experiment with different:
diff --git a/docs/cylinder.png b/docs/cylinder.png
new file mode 100644
index 0000000000000000000000000000000000000000..39d7511f735e1a29561d1b34f01b40f86b24ff4a
GIT binary patch
literal 35631
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
BkBk5S

literal 0
HcmV?d00001

diff --git a/src/main/scala/Main.scala b/src/main/scala/Main.scala
index 9fdb98a..3b96168 100644
--- a/src/main/scala/Main.scala
+++ b/src/main/scala/Main.scala
@@ -1,6 +1,8 @@
 import com.samuelcantrell.raytracer.sphere
 import com.samuelcantrell.raytracer.plane
 import com.samuelcantrell.raytracer.cube
+import com.samuelcantrell.raytracer.cylinder
+import com.samuelcantrell.raytracer.cone
 import com.samuelcantrell.raytracer.transformation
 import com.samuelcantrell.raytracer.material
 import com.samuelcantrell.raytracer.color
@@ -92,6 +94,36 @@ import com.samuelcantrell.raytracer.pattern
     )
   val cubeWithMaterial = cube.setMaterial(cubeTransformed, cubeMaterial)
 
+  // Create a cylinder
+  val cylinderShape = cylinder.cylinder().copy(minimum = 0, maximum = 2, closed = true)
+  val cylinderTransform = transformation.translation(-2, 0, 1) *
+    transformation.scaling(0.5, 1, 0.5)
+  val cylinderTransformed = cylinder.setTransform(cylinderShape, cylinderTransform)
+  val cylinderMaterial = material
+    .material()
+    .copy(
+      materialColor = color.Color(0.2, 0.6, 0.9),
+      diffuse = 0.8,
+      specular = 0.3,
+      reflective = 0.1
+    )
+  val cylinderWithMaterial = cylinder.setMaterial(cylinderTransformed, cylinderMaterial)
+
+  // Create a cone
+  val coneShape = cone.cone().copy(minimum = -1, maximum = 0, closed = true)
+  val coneTransform = transformation.translation(0.5, 1, -2) *
+    transformation.scaling(0.8, 1, 0.8)
+  val coneTransformed = cone.setTransform(coneShape, coneTransform)
+  val coneMaterial = material
+    .material()
+    .copy(
+      materialColor = color.Color(0.9, 0.4, 0.1),
+      diffuse = 0.7,
+      specular = 0.4,
+      reflective = 0.05
+    )
+  val coneWithMaterial = cone.setMaterial(coneTransformed, coneMaterial)
+
   // Create the world with all objects
   val lightSource = light.pointLight(
     tuple.makePoint(-10, 10, -10),
@@ -104,7 +136,9 @@ import com.samuelcantrell.raytracer.pattern
       middleWithMaterial,
       rightWithMaterial,
       leftWithMaterial,
-      cubeWithMaterial
+      cubeWithMaterial,
+      cylinderWithMaterial,
+      coneWithMaterial
     ),
     lightSource = Some(lightSource)
   )