Specialise layers to be either lists of vertices or squares

1 files changed, 21 insertions, 36 deletions

diff --git a/src/main.zig b/src/main.zig
index 8b77440..781b9a7 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -49,58 +49,43 @@ pub fn main() !void {
     var map = try level.Map.new(16, 16, &gpa.allocator);
     defer map.deinit();
 
-    // floor
-    const square_coords = [_][2]f32{
-        .{ 0.00, 0.00 },
-        .{ 1.00, 0.00 },
-        .{ 1.00, 1.00 },
-        .{ 0.00, 1.00 },
-    };
-
     var y: u32 = 0;
     while (y < 16) : (y += 1) {
         var x: usize = 0;
         while (x < 16) : (x += 1) {
-            var floor_verts = try std.BoundedArray([2]f32, level.Layer.MAX_VERTS).fromSlice(square_coords[0..]);
-            try map.cells.items[y * 16 + x].lower_layers.append(level.Layer{ .height = 0, .vertices = floor_verts });
+            try map.cells.items[y * 16 + x].lower_layers.append(level.Layer{ .height = 0, .polygon = .square });
             if (y == 0 or y == 15 or x == 0) {
-                try map.cells.items[y * 16 + x].lower_layers.append(level.Layer{ .height = 2, .vertices = floor_verts });
+                try map.cells.items[y * 16 + x].lower_layers.append(level.Layer{ .height = 2, .polygon = .square });
             } else {
                 if (x == 15)
-                    try map.cells.items[y * 16 + x].lower_layers.append(level.Layer{ .height = 2, .vertices = floor_verts, .vertical_texture = 2 });
+                    try map.cells.items[y * 16 + x].lower_layers.append(level.Layer{ .height = 2, .polygon = .square, .vertical_texture = 2 });
             }
             if (y == 7 and x >= 5 and x <= 10) {
                 const vert_coords0 = [_][2]f32{
-                    .{ 0.10, 0.10 },
-                    .{ 0.90, 0.10 },
-                    .{ 0.90, 0.90 },
-                    .{ 0.10, 0.90 },
+                    .{ 0.50, 0.10 },
+                    .{ 0.10, 0.80 },
+                    .{ 0.90, 0.80 },
                 };
-                var verts = try std.BoundedArray([2]f32, level.Layer.MAX_VERTS).fromSlice(vert_coords0[0..]);
-                var layer = level.Layer{ .height = 0.5, .vertices = verts, .vertical_texture = 3, .horizontal_texture = 1 };
+                var verts = try std.BoundedArray([2]f32, level.Polygon.MAX_VERTS).fromSlice(vert_coords0[0..]);
+                var layer = level.Layer{ .height = 0.5, .polygon = .{ .vertices = verts }, .vertical_texture = 3, .horizontal_texture = 1, .vertical_texture_scale = 3 };
 
                 try map.cells.items[y * 16 + x].lower_layers.append(layer);
 
-                const vert_coords1 = [_][2]f32{
-                    .{ 0.75, 0.5 },
-                    .{ 0.72838634, 0.60168415 },
-                    .{ 0.66728264, 0.68578625 },
-                    .{ 0.57725424, 0.7377641 },
-                    .{ 0.47386786, 0.74863046 },
-                    .{ 0.375, 0.71650636 },
-                    .{ 0.29774573, 0.6469463 },
-                    .{ 0.2554631, 0.5519779 },
-                    .{ 0.25546312, 0.44802207 },
-                    .{ 0.29774576, 0.35305366 },
-                    .{ 0.37500003, 0.28349364 },
-                    .{ 0.47386792, 0.25136954 },
-                    .{ 0.5772543, 0.26223588 },
-                    .{ 0.6672827, 0.3142138 },
-                    .{ 0.7283864, 0.39831588 },
+                // cylinder
+                const vert_coords1 = comptime blk: {
+                    const size = level.Polygon.MAX_VERTS;
+                    var shape: [size][2]f32 = [_][2]f32{.{ 0, 0 }} ** size;
+                    for (shape) |*pair, i| {
+                        const theta = @intToFloat(f32, i) / @intToFloat(f32, shape.len) * 2 * std.math.pi;
+                        pair.*[0] = 0.5 + 0.2 * std.math.cos(theta);
+                        pair.*[1] = 0.5 + 0.2 * std.math.sin(theta);
+                    }
+                    break :blk shape;
                 };
-                verts = try std.BoundedArray([2]f32, level.Layer.MAX_VERTS).fromSlice(vert_coords1[0..]);
 
-                layer = level.Layer{ .height = 1, .vertices = verts, .vertical_texture = 1, .horizontal_texture = 2, .vertical_texture_scale = 2 };
+                verts = try std.BoundedArray([2]f32, level.Polygon.MAX_VERTS).fromSlice(vert_coords1[0..]);
+
+                layer = level.Layer{ .height = 1, .polygon = .{ .vertices = verts }, .vertical_texture = 1, .horizontal_texture = 2, .vertical_texture_scale = 2 };
                 try map.cells.items[y * 16 + x].lower_layers.append(layer);
             }
         }