added logging

build.zig

···
     exe.root_module.addImport("spall", spall.module("spall"));
     exe.root_module.addImport("rayray", rayray);
 
+    const alib = b.dependency("a", .{
+        .target = target,
+        .optimize = optimize,
+        .log_ignore_default = true,
+    });
+
+    exe.root_module.addImport("a", alib.module("a"));
+
     b.installArtifact(exe);
 
     const run_cmd = b.addRunArtifact(exe);

build.zig.zon

···
     .minimum_zig_version = "0.12.0-dev.2631+3069669bc",
     .dependencies = .{
         // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        .a = .{
+            .url = "https://git.sr.ht/~altagos/a/archive/790275535ae4ea236406dc198413c4d4f31919e7.tar.gz",
+            .hash = "12204b052e9dda5b17e6271afcf4bf0112d4f5012b73201cec4fbb6cc85e1d400ec5",
+        },
         .zigimg = .{
             .url = "https://github.com/rockorager/zigimg/archive/19a49a7e44fb4b1c22341dfbd6566019de742055.tar.gz",
             .hash = "1220ebfa8587cfd644995fc08e218dbb3ebd7344fb8e129ff02bc5a6d52a2325370d",

src/main.zig

···
 const std = @import("std");
 
+const a = @import("a");
 const spall = @import("spall");
 
 const Raytracer = @import("rayray").Raytracer;
+
+pub const std_options = .{
+    .log_level = .debug,
+    .logFn = a.log.logFn,
+};
 
 pub fn main() !void {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
···
     defer raytracer.deinit();
 
     const img = try raytracer.render();
+    std.log.info("Image rendered", .{});
 
     s.end();
+
+    const s_saving = spall.trace(@src(), "Write Image", .{});
+    defer s_saving.end();
     try img.writeToFilePath("./out/out.png", .{ .png = .{} });
+    std.log.info("Image saved to: out/out.ong", .{});
 }

src/rayray.zig

···
 const zigimg = @import("zigimg");
 const color = zigimg.color;
 
+const log = std.log.scoped(.rayray);
+
 pub const Raytracer = struct {
     const Self = @This();
 
···
         _ = self;
     }
 
+    // TODO: Render in cubes not in rows
     pub fn render(self: *Self) !zigimg.Image {
-        const s = spall.trace(@src(), "render", .{});
+        const s = spall.trace(@src(), "Render", .{});
         defer s.end();
 
         const rows: usize = try std.Thread.getCpuCount();
···
             }
             break :blk rows + 1;
         };
-        std.debug.print("rows: {}, row_height: {}, num_threads: {}", .{ rows, row_height, num_threads });
+
+        log.debug("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);
···
         return self.camera.image;
     }
 
-    fn r(camera: *Camera, row: usize, height: usize) void {
+    fn r(cam: *Camera, row: usize, height: usize) void {
         spall.init_thread();
         defer spall.deinit_thread();
 
-        const s = spall.trace(@src(), "thread {}", .{row});
+        const s = spall.trace(@src(), "Render Thread {}", .{row});
         defer s.end();
 
         for (0..height) |iy| {
             const y = iy + height * row;
-            if (y >= camera.height) break;
+            if (y >= cam.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;
-                }
+            for (0..cam.width) |x| {
+                const col = blk: {
+                    if (iy <= height - 5) {
+                        @setRuntimeSafety(false);
+                        break :blk color.Rgba32.initRgba(
+                            @intCast(x),
+                            @intCast(y),
+                            0,
+                            255,
+                        );
+                    }
+                    break :blk color.Rgba32.initRgba(0, 0, 255, 255);
+                };
+
+                cam.setPixel(x, y, col) catch break;
             }
         }
     }