ПРавильные прямоугольники

src/render/CpuRenderEngine.zig

@@ -64,26 +64,82 @@ fn renderSquares(self: CpuRenderEngine, pixels: []Color.PMA, canvas_size: ImageS
     _ = self;
 
     const squares_num = 5;
-    const thikness: u32 = @intFromFloat(@as(f32, @floatFromInt(canvas_size.w + canvas_size.h)) / 2 * 0.03);
-    const squares_sum_height = canvas_size.h - thikness * (squares_num + 1);
-    const square_height = squares_sum_height / squares_num;
+    var thikness: u32 = @intFromFloat(@as(f32, @floatFromInt(canvas_size.w + canvas_size.h)) / 2 * 0.03);
+    if (thikness == 0) thikness = 1;
+
+    const squares_sum_w = canvas_size.w - thikness * (squares_num + 1);
+    const base_w = squares_sum_w / squares_num;
+    const extra_w = squares_sum_w % squares_num;
+    const squares_sum_h = canvas_size.h - thikness * (squares_num + 1);
+    const base_h = squares_sum_h / squares_num;
+    const extra_h = squares_sum_h % squares_num;
+
+    var x_pos: [6]u32 = undefined;
+    x_pos[0] = 0;
+    for (1..squares_num + 1) |i| {
+        const w = base_w + if (i - 1 < extra_w) @as(u32, 1) else 0;
+        x_pos[i] = x_pos[i - 1] + thikness + w;
+    }
+
+    var y_pos: [6]u32 = undefined;
+    y_pos[0] = 0;
+    for (1..squares_num + 1) |i| {
+        const h = base_h + if (i - 1 < extra_h) @as(u32, 1) else 0;
+        y_pos[i] = y_pos[i - 1] + thikness + h;
+    }
 
     var y: u32 = 0;
-    while (y < visible_rect.h) {
+    while (y < visible_rect.h) : (y += 1) {
         const canvas_y = y + visible_rect.y;
-        var start_line_index = canvas_y / square_height;
+        if (canvas_y >= canvas_size.h) continue;
+        var x: u32 = 0;
+        while (x < visible_rect.w) : (x += 1) {
+            const canvas_x = x + visible_rect.x;
+            if (canvas_x >= canvas_size.w) continue;
 
-        start_line_index = start_line_index * square_height + thikness * (if (start_line_index > 0) start_line_index - 1 else 0);
-        const draw_line = canvas_y < start_line_index + thikness and canvas_y >= start_line_index;
-        if (draw_line) {
-            var x: u32 = 0;
-            while (x < visible_rect.w) {
-                pixels[y * visible_rect.w + x] = .{ .r = 255, .b = 0, .g = 0, .a = 255 };
+            // Check if in vertical line
+            var in_vertical_line = false;
+            for (x_pos) |pos| {
+                if (canvas_x >= pos and canvas_x < pos + thikness) {
+                    in_vertical_line = true;
+                    break;
+                }
+            }
 
-                x += 1;
+            // Check if in horizontal line
+            var in_horizontal_line = false;
+            for (y_pos) |pos| {
+                if (canvas_y >= pos and canvas_y < pos + thikness) {
+                    in_horizontal_line = true;
+                    break;
+                }
+            }
+
+            if (in_vertical_line or in_horizontal_line) {
+                pixels[y * visible_rect.w + x] = .{ .r = 255, .g = 0, .b = 0, .a = 255 };
+            } else {
+                // Find square
+                var square_x: u32 = 0;
+                for (0..squares_num) |i| {
+                    if (canvas_x >= x_pos[i] + thikness and canvas_x < x_pos[i + 1]) {
+                        square_x = @intCast(i);
+                        break;
+                    }
+                }
+                var square_y: u32 = 0;
+                for (0..squares_num) |i| {
+                    if (canvas_y >= y_pos[i] + thikness and canvas_y < y_pos[i + 1]) {
+                        square_y = @intCast(i);
+                        break;
+                    }
+                }
+                if (square_x % 2 == square_y % 2) {
+                    pixels[y * visible_rect.w + x] = .{ .r = 255, .g = 255, .b = 255, .a = 255 };
+                } else {
+                    pixels[y * visible_rect.w + x] = .{ .r = 0, .g = 0, .b = 0, .a = 255 };
+                }
             }
         }
-        y += 1;
     }
 }
 
@@ -98,7 +154,7 @@ pub fn example(self: CpuRenderEngine, canvas_size: ImageSize, visible_rect: Imag
     const pixels = try self._allocator.alloc(Color.PMA, @as(usize, width) * height);
     defer self._allocator.free(pixels);
 
-    std.debug.print("w={any}, fw={any};\th={any}, fh={any}\n", .{ width, full_w, height, full_h });
+    // std.debug.print("w={any}, fw={any};\th={any}, fh={any}\n", .{ width, full_w, height, full_h });
 
     switch (self.type) {
         .Gradient => self.renderGradient(pixels, width, height, full_w, full_h, visible_rect),