added world

build.zig

···
         .target = target,
         .optimize = optimize,
     });
+    addDeps(b, &exe.root_module);
     exe.root_module.addImport("spall", spall.module("spall"));
     exe.root_module.addImport("rayray", rayray);
 

src/camera.zig

···
     };
 }
 
+pub fn deinit(self: *Camera) void {
+    self.image.deinit();
+}
+
 pub fn setPixel(self: *Camera, x: usize, y: usize, c: color.Rgba32) !void {
     if (x >= self.image_width or y >= self.image_height) return error.OutOfBounds;
     const i = x + self.image_width * y;

src/hittable.zig

···
+const std = @import("std");
+
+const zm = @import("zmath");
+
+const Ray = @import("ray.zig");
+pub const Sphere = @import("hittable/sphere.zig");
+
+pub const HitRecord = struct {
+    p: zm.Vec,
+    normal: zm.Vec = zm.f32x4s(1.0),
+    t: f32,
+    front_face: bool = true,
+
+    pub fn setFaceNormal(self: *HitRecord, r: *Ray, outward_normal: zm.Vec) void {
+        self.front_face = zm.dot3(r.dir, outward_normal)[0] < 0.0;
+        self.normal = if (self.front_face) outward_normal else -outward_normal;
+    }
+};
+
+pub const HittableType = enum {
+    sphere,
+};
+
+pub const Hittable = union(HittableType) {
+    sphere: Sphere,
+
+    pub fn initSphere(sphere: Sphere) Hittable {
+        return .{ .sphere = sphere };
+    }
+
+    pub fn hit(self: *Hittable, r: *Ray, ray_tmin: f32, ray_tmax: f32) ?HitRecord {
+        switch (self.*) {
+            .sphere => |*sphere| {
+                return sphere.hit(r, ray_tmin, ray_tmax);
+            },
+        }
+
+        return null;
+    }
+};
+
+pub const HittableList = struct {
+    list: std.ArrayList(Hittable),
+
+    pub fn init(allocator: std.mem.Allocator) HittableList {
+        const list = std.ArrayList(Hittable).init(allocator);
+
+        return .{ .list = list };
+    }
+
+    pub fn deinit(self: *HittableList) void {
+        self.list.deinit();
+    }
+
+    pub fn add(self: *HittableList, item: Hittable) !void {
+        try self.list.append(item);
+    }
+
+    pub fn hit(self: *HittableList, r: *Ray, ray_tmin: f32, ray_tmax: f32) ?HitRecord {
+        var rec: ?HitRecord = null;
+        var hit_anything = false;
+        var closest_so_far = ray_tmax;
+
+        for (self.list.items) |*object| {
+            if (object.hit(r, ray_tmin, closest_so_far)) |new_rec| {
+                rec = new_rec;
+                hit_anything = true;
+                closest_so_far = new_rec.t;
+            }
+        }
+
+        return rec;
+    }
+};

src/hittable/sphere.zig

···
+const zm = @import("zmath");
+
+const Ray = @import("../ray.zig");
+const HitRecord = @import("../hittable.zig").HitRecord;
+
+const Sphere = @This();
+
+center: zm.Vec,
+radius: f32,
+
+pub fn hit(self: *Sphere, r: *Ray, ray_tmin: f32, ray_tmax: f32) ?HitRecord {
+    const oc = r.orig - self.center;
+    const a = zm.lengthSq3(r.dir)[0];
+    const half_b = zm.dot3(oc, r.dir)[0];
+    const c = zm.dot3(oc, oc)[0] - self.radius * self.radius;
+
+    const discriminant = half_b * half_b - a * c;
+    if (discriminant < 0) return null;
+
+    const sqrtd = @sqrt(discriminant);
+
+    // Find the nearest root that lies in the acceptable range
+    var root = (-half_b - sqrtd) / a;
+    if (root <= ray_tmin or ray_tmax <= root) {
+        root = (-half_b + sqrtd) / a;
+        if (root <= ray_tmin or ray_tmax <= root) return null;
+    }
+
+    var rec = HitRecord{
+        .t = root,
+        .p = r.at(root),
+    };
+
+    const outward_normal = (rec.p - self.center) / zm.f32x4s(self.radius);
+    rec.setFaceNormal(r, outward_normal);
+
+    return rec;
+}

src/main.zig

···
 
 const a = @import("a");
 const spall = @import("spall");
+const zm = @import("zmath");
 
-const Raytracer = @import("rayray").Raytracer;
+const rayray = @import("rayray");
+const Hittable = rayray.hittable.Hittable;
+const HittableList = rayray.hittable.HittableList;
+const Sphere = rayray.hittable.Sphere;
 
 pub const std_options = .{
     .log_level = .debug,
···
     spall.init_thread();
     defer spall.deinit_thread();
 
+    var world = HittableList.init(allocator);
+    try world.add(Hittable.initSphere(Sphere{ .center = zm.f32x4(0, 0, -1, 0), .radius = 0.5 }));
+    try world.add(Hittable.initSphere(Sphere{ .center = zm.f32x4(0, -100.5, -1, 0), .radius = 100 }));
+
     const s = spall.trace(@src(), "Main", .{});
 
-    var raytracer = try Raytracer.init(allocator);
+    var raytracer = try rayray.Raytracer.init(allocator, world);
     defer raytracer.deinit();
 
     const img = try raytracer.render();

src/ray.zig

···
+const std = @import("std");
+
 const zm = @import("zmath");
 
+const hittable = @import("hittable.zig");
 const Ray = @This();
 
 orig: zm.Vec,
···
     return self.orig + zm.f32x4s(t) * self.dir;
 }
 
-pub fn color(r: *Ray) zm.Vec {
-    const t = hitSphere(zm.f32x4(0, 0, -1, 0), 0.5, r);
-    if (t > 0.0) {
-        const N = zm.normalize3(r.at(t) - zm.f32x4(0, 0, -1, 0));
-        return zm.f32x4s(0.5) * zm.f32x4(N[0] + 1, N[1] + 1, N[2] + 1, 1);
+pub fn color(r: *Ray, world: *hittable.HittableList) zm.Vec {
+    if (world.hit(r, 0, std.math.inf(f32))) |rec| {
+        return zm.f32x4s(0.5) * (rec.normal + zm.f32x4(1, 1, 1, 1));
     }
 
     const unit_direction = zm.normalize3(r.dir);

src/rayray.zig

···
 const zm = @import("zmath");
 
 const Camera = @import("camera.zig");
+pub const hittable = @import("hittable.zig");
 const Ray = @import("ray.zig");
 
 const log = std.log.scoped(.rayray);
···
     allocator: std.mem.Allocator,
 
     camera: Camera,
+    world: hittable.HittableList,
 
-    pub fn init(allocator: std.mem.Allocator) !Self {
+    pub fn init(allocator: std.mem.Allocator, world: hittable.HittableList) !Self {
         return .{
             .allocator = allocator,
             .camera = try Camera.init(allocator, 400, 16.0 / 9.0),
+            .world = world,
         };
     }
 
-    pub fn deinit(self: *const Self) void {
-        _ = self;
+    pub fn deinit(self: *Self) void {
+        self.camera.deinit();
+        self.world.deinit();
     }
 
     // TODO: Render in cubes not in rows
···
         const finished_threads = try self.allocator.alloc(bool, num_threads);
 
         for (0..num_threads) |row| {
-            const t = try std.Thread.spawn(.{}, render_thread, .{ &self.camera, row, row_height, &threads[row].done });
+            const t = try std.Thread.spawn(.{}, render_thread, .{ &self.camera, &self.world, row, row_height, &threads[row].done });
             threads[row].thread = t;
         }
 
···
         return self.camera.image;
     }
 
-    fn render_thread(cam: *Camera, row: usize, height: usize, done: *bool) void {
+    fn render_thread(cam: *Camera, world: *hittable.HittableList, row: usize, height: usize, done: *bool) void {
         spall.init_thread();
         defer spall.deinit_thread();
 
···
                 const pixel_center = cam.pixel00_loc + (zm.f32x4s(@as(f32, @floatFromInt(i))) * cam.pixel_delta_u) + (zm.f32x4s(@as(f32, @floatFromInt(j))) * cam.pixel_delta_v);
                 const ray_direction = pixel_center - cam.camera_center;
                 var ray = Ray.init(cam.camera_center, ray_direction);
-                const col = vecToRgba(ray.color());
+                const col = vecToRgba(ray.color(world));
 
                 cam.setPixel(i, j, col) catch break;
             }