Add "la planche a pain"

src/HitRecord.zig

@@ -2,7 +2,13 @@ const Vec3 = @import("Vec3.zig").Vec3;
 const Pt3 = @import("Pt3.zig").Pt3;
 
 pub const HitRecord = struct {
+    const Self = @This();
+
     hit: bool,
     normal: Vec3,
     intersection_point: Pt3,
+
+    pub fn nil() Self {
+        return Self{ .hit = false, .normal = Vec3.nil(), .intersection_point = Pt3.nil() };
+    }
 };

src/Plane.zig

@@ -0,0 +1,91 @@
+const Pt3 = @import("Pt3.zig").Pt3;
+const Ray = @import("Ray.zig").Ray;
+const std = @import("std");
+const HitRecord = @import("HitRecord.zig").HitRecord;
+const Vec3 = @import("Vec3.zig").Vec3;
+
+pub const Plane = struct {
+    const Self = @This();
+
+    normal: Vec3,
+    origin: Pt3,
+
+    pub fn hits(self: *const Self, ray: Ray) HitRecord {
+        const denom = self.normal.dot(ray.direction);
+
+        if (denom == 0.0) {
+            return HitRecord.nil();
+        }
+
+        const t = (self.origin.subVec3(ray.origin)).dot(self.normal) / denom;
+
+        if (t < 0.0) {
+            return HitRecord.nil();
+        }
+
+        const hit_point = ray.at(t);
+        return HitRecord{
+            .hit = true,
+            .intersection_point = hit_point,
+            .normal = self.normal,
+        };
+    }
+};
+
+test "hit" {
+    const plane = Plane{
+        .normal = Vec3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+        .origin = Pt3{ .x = 0.0, .y = 0.0, .z = 0.0 },
+    };
+
+    const ray = Ray{
+        .origin = Pt3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+        .direction = Vec3{ .x = 0.0, .y = -1.0, .z = 0.0 },
+    };
+
+    const hit_record = plane.hits(ray);
+
+    try std.testing.expect(hit_record.hit);
+    try std.testing.expect(hit_record.intersection_point.x == 0.0);
+    try std.testing.expect(hit_record.intersection_point.y == 0.0);
+    try std.testing.expect(hit_record.intersection_point.z == 0.0);
+    try std.testing.expect(hit_record.normal.x == 0.0);
+    try std.testing.expect(hit_record.normal.y == 1.0);
+    try std.testing.expect(hit_record.normal.z == 0.0);
+}
+
+test "dontHit" {
+    const plane = Plane{
+        .normal = Vec3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+        .origin = Pt3{ .x = 0.0, .y = 0.0, .z = 0.0 },
+    };
+
+    const ray = Ray{
+        .origin = Pt3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+        .direction = Vec3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+    };
+
+    const hit_record = plane.hits(ray);
+
+    try std.testing.expect(!hit_record.hit);
+}
+
+test "parallel" {
+    const plane = Plane{
+        .normal = Vec3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+        .origin = Pt3{ .x = 0.0, .y = 0.0, .z = 0.0 },
+    };
+
+    const ray = Ray{
+        .origin = Pt3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+        .direction = Vec3{ .x = 0.0, .y = 1.0, .z = 0.0 },
+    };
+
+    const hit_record = plane.hits(ray);
+
+    try std.testing.expect(!hit_record.hit);
+}
+
+test {
+    std.testing.refAllDecls(@This());
+}

src/Ray.zig

@@ -1,9 +1,15 @@
 const std = @import("std");
+const Pt3 = @import("Pt3.zig").Pt3;
+const Vec3 = @import("Vec3.zig").Vec3;
 pub const Ray = struct {
     const Self = @This();
 
-    origin: @import("Pt3.zig").Pt3,
-    direction: @import("Vec3.zig").Vec3,
+    origin: Pt3,
+    direction: Vec3,
+
+    pub fn at(self: Self, t: f32) Pt3 {
+        return self.origin.addVec3(self.direction.mulf32(t));
+    }
 };
 
 test {

src/Vec3.zig

@@ -23,6 +23,18 @@ pub const Vec3 = struct {
         };
     }
 
+    pub fn collapse(self: *const Self) f32 {
+        return self.x + self.y + self.z;
+    }
+
+    pub fn inv(self: *const Self) Vec3 {
+        return Vec3{
+            .x = -self.x,
+            .y = -self.y,
+            .z = -self.z,
+        };
+    }
+
     pub fn addVec3(self: *const Self, other: Self) Vec3 {
         return Vec3{
             .x = self.x + other.x,

src/main.zig

@@ -6,6 +6,7 @@ const Sphere = @import("Sphere.zig").Sphere;
 const Camera = @import("Camera.zig").Camera;
 const qoi = @import("qoi.zig");
 const Light = @import("Light.zig").Light;
+pub const Plane = @import("Plane.zig").Plane;
 
 fn compute_lighting(intersection: Vec3, normal: Vec3, light: Pt3, ambient: f32) f32 {
     const L = intersection.to(light);