cleanup

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);
···
 
     const run_step = b.step("run", "Run the app");
     run_step.dependOn(&run_cmd.step);
-
-    const lib_unit_tests = b.addTest(.{
-        .root_source_file = .{ .path = "src/root.zig" },
-        .target = target,
-        .optimize = optimize,
-    });
-    const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
-    const test_step = b.step("test", "Run unit tests");
-    test_step.dependOn(&run_lib_unit_tests.step);
 }
 
 fn addDeps(b: *std.Build, module: *std.Build.Module) void {
+    const alib = b.dependency("a", .{
+        .log_ignore_default = true,
+    });
+    module.addImport("a", alib.module("a"));
+
     const zmath = b.dependency("zmath", .{
         .enable_cross_platform_determinism = true,
     });

src/hittable.zig

···
 
 const IntervalF32 = @import("interval.zig").IntervalF32;
 const Ray = @import("ray.zig");
+
+// Hittable Objects
 pub const Sphere = @import("hittable/sphere.zig");
 
 pub const HitRecord = struct {

src/interval.zig

···
                         return self.current;
                     } else return null;
                 }
+
+                pub fn nextInc(self: *Iterator) ?T {
+                    self.current += 1;
+                    return if (self.current <= self.interval.max) self.current else null;
+                }
+
+                pub fn nextExc(self: *Iterator) ?T {
+                    self.current += 1;
+                    return if (self.current < self.interval.max) self.current else null;
+                }
             };
 
             min: T,

src/main.zig

···
     spall.init_thread();
     defer spall.deinit_thread();
 
+    // Setting up the world
     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", .{});
+    const s = spall.trace(@src(), "Raytracer", .{});
 
+    // Raytracing part
     var raytracer = try rayray.Raytracer.init(allocator, world);
     defer raytracer.deinit();
 
···
 
     s.end();
 
+    // Saving to file
     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 spall = @import("spall");
 const zigimg = @import("zigimg");
 const color = zigimg.color;
-const zm = @import("zmath");
 
 pub const Camera = @import("camera.zig");
 pub const hittable = @import("hittable.zig");

src/renderer.zig

···
 
 const spall = @import("spall");
 const zigimg = @import("zigimg");
-const color = zigimg.color;
 const zm = @import("zmath");
 
 pub const Camera = @import("camera.zig");
+pub const hittable = @import("hittable.zig");
+pub const Ray = @import("ray.zig");
+
 pub const interval = @import("interval.zig");
 pub const IntervalUsize = interval.IntervalUsize;
 pub const IntervalF32 = interval.IntervalF32;
-pub const hittable = @import("hittable.zig");
-pub const Ray = @import("ray.zig");
 
 const log = std.log.scoped(.renderer);
 
···
 
 pub fn run(ctx: Context, height: IntervalUsize, width: IntervalUsize) void {
     var height_iter = height.iter();
-    height_iter.upper_boundry = .inclusive;
-
-    while (height_iter.next()) |j| {
+    while (height_iter.nextInc()) |j| {
         if (j >= ctx.cam.image_height) break;
 
         var width_iter = width.iter();
-        height_iter.upper_boundry = .inclusive;
-
-        while (width_iter.next()) |i| inner: {
-            if (i >= ctx.cam.image_width) break :inner;
-
+        while (width_iter.nextExc()) |i| {
             const pixel_center = ctx.cam.pixel00_loc + (zm.f32x4s(@as(f32, @floatFromInt(i))) * ctx.cam.pixel_delta_u) + (zm.f32x4s(@as(f32, @floatFromInt(j))) * ctx.cam.pixel_delta_v);
             const ray_direction = pixel_center - ctx.cam.camera_center;
             var ray = Ray.init(ctx.cam.camera_center, ray_direction);
···
     done.store(true, .Release);
 }
 
-fn vecToRgba(v: zm.Vec) color.Rgba32 {
+fn vecToRgba(v: zm.Vec) zigimg.color.Rgba32 {
     const r: u8 = @intFromFloat(255.999 * v[0]);
     const g: u8 = @intFromFloat(255.999 * v[1]);
     const b: u8 = @intFromFloat(255.999 * v[2]);
     const a: u8 = @intFromFloat(255.999 * v[3]);
 
-    return color.Rgba32.initRgba(r, g, b, a);
+    return zigimg.color.Rgba32.initRgba(r, g, b, a);
 }