added threaded image renderer + output as png

.gitignore

···
 /zig-cache
 /zig-out
+/out

build.zig

···
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    const enable_spall = b.option(bool, "enable_spall", "Enable spall profiling") orelse false;
+    const spall = b.dependency("spall", .{
+        .enable = enable_spall,
+    });
+
     const rayray = b.addModule("rayray", .{
         .root_source_file = .{ .path = "src/rayray.zig" },
         .target = target,
         .optimize = optimize,
     });
+    rayray.addImport("spall", spall.module("spall"));
+
     addDeps(b, rayray);
 
     const exe = b.addExecutable(.{
···
         .target = target,
         .optimize = optimize,
     });
-
+    exe.root_module.addImport("spall", spall.module("spall"));
     exe.root_module.addImport("rayray", rayray);
 
     b.installArtifact(exe);

build.zig.zon

···
     .dependencies = .{
         // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
         .zigimg = .{
-            .url = "https://github.com/zigimg/zigimg/archive/2224f91ea4cf70f2254848657e308761b8cc8c5d.tar.gz",
-            // dumy hash, because zigimg does not contain a build.zig. zon
-            .hash = "122029f65edf3965d86f7d0741fe141bcc1d68b1f013fa7280bbfda4e87c6affc15f",
+            .url = "https://github.com/rockorager/zigimg/archive/19a49a7e44fb4b1c22341dfbd6566019de742055.tar.gz",
+            .hash = "1220ebfa8587cfd644995fc08e218dbb3ebd7344fb8e129ff02bc5a6d52a2325370d",
+        },
+        .spall = .{
+            .url = "https://git.sr.ht/~altagos/zig-spall/archive/7cae52aa2d1a519006e0c90fbd179cf7fcac0c83.tar.gz",
+            .hash = "1220753b2f9e7c4f3fb6cdc8fc275cc9073904ea7032a1f5596aa776a857de69f72c",
         },
 
         // libs folder

src/main.zig

···
+const std = @import("std");
+
+const spall = @import("spall");
+
 const Raytracer = @import("rayray").Raytracer;
 
 pub fn main() !void {
-    const raytracer = Raytracer.init();
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    try spall.init("./out/trace.spall");
+    defer spall.deinit();
+
+    spall.init_thread();
+    defer spall.deinit_thread();
+
+    const s = spall.trace(@src(), "Main", .{});
+
+    var raytracer = try Raytracer.init(allocator);
     defer raytracer.deinit();
+
+    const img = try raytracer.render();
+
+    s.end();
+    try img.writeToFilePath("./out/out.png", .{ .png = .{} });
 }

src/rayray.zig

···
 const std = @import("std");
 
+const spall = @import("spall");
+const zigimg = @import("zigimg");
+const color = zigimg.color;
+
 pub const Raytracer = struct {
     const Self = @This();
 
     allocator: std.mem.Allocator,
 
-    pub fn init(allocator: std.mem.Allocator) Self {
+    camera: Camera,
+
+    pub fn init(allocator: std.mem.Allocator) !Self {
         return .{
             .allocator = allocator,
+            .camera = try Camera.init(allocator, 256 * 10, 256 * 10),
         };
     }
 
···
         _ = self;
     }
 
-    pub fn render(self: *Self) void {
-        _ = self;
+    pub fn render(self: *Self) !zigimg.Image {
+        const s = spall.trace(@src(), "render", .{});
+        defer s.end();
+
+        const rows: usize = try std.Thread.getCpuCount();
+        const row_height = @divTrunc(self.camera.height, rows);
+        const num_threads = blk: {
+            if (self.camera.height % rows == 0) {
+                break :blk rows;
+            }
+            break :blk rows + 1;
+        };
+        std.debug.print("rows: {}, row_height: {}, num_threads: {}", .{ rows, row_height, num_threads });
+
+        const threads = try self.allocator.alloc(std.Thread, num_threads);
+        defer self.allocator.free(threads);
+
+        for (0..num_threads) |row| {
+            const t = try std.Thread.spawn(.{}, r, .{ &self.camera, row, row_height });
+            threads[row] = t;
+        }
+
+        for (threads) |t| {
+            t.join();
+        }
+
+        return self.camera.image;
+    }
+
+    fn r(camera: *Camera, row: usize, height: usize) void {
+        spall.init_thread();
+        defer spall.deinit_thread();
+
+        const s = spall.trace(@src(), "thread {}", .{row});
+        defer s.end();
+
+        for (0..height) |iy| {
+            const y = iy + height * row;
+            if (y >= camera.height) break;
+
+            for (0..camera.width) |x| {
+                @setRuntimeSafety(false);
+                if (iy <= height - 5) {
+                    camera.setPixel(x, y, color.Rgba32.initRgba(
+                        @intCast(x),
+                        @intCast(y),
+                        0,
+                        255,
+                    )) catch break;
+                } else {
+                    camera.setPixel(x, y, color.Rgba32.initRgba(
+                        0,
+                        0,
+                        255,
+                        255,
+                    )) catch break;
+                }
+            }
+        }
     }
 };
 
-pub const Camera = struct {};
+pub const Camera = struct {
+    width: usize,
+    height: usize,
+    image: zigimg.Image,
+
+    pub fn init(allocator: std.mem.Allocator, width: usize, height: usize) !Camera {
+        const img = try zigimg.Image.create(allocator, width, height, zigimg.PixelFormat.rgba32);
+
+        return Camera{
+            .width = width,
+            .height = height,
+            .image = img,
+        };
+    }
+
+    pub fn setPixel(self: *Camera, x: usize, y: usize, c: color.Rgba32) !void {
+        if (x >= self.width or y >= self.height) return error.OutOfBounds;
+        const i = x + self.width * y;
+        self.image.pixels.rgba32[i] = c;
+    }
+};