repo: hackvr-turbo
action: commit
revision: 
path_from: 
revision_from: a99d404d847a0c13b91d1eacfef0a8a4f035245b:
path_to: 
revision_to: 

commit a99d404d847a0c13b91d1eacfef0a8a4f035245b
Author: Felix (xq) Queißner 
Date:   Sat Jul 4 02:55:44 2020 +0200

    First working version.

diff --git a/lib/hackvr/lib.zig b/lib/hackvr/lib.zig

--- a/lib/hackvr/lib.zig
+++ b/lib/hackvr/lib.zig
@@ -33,13 +33,15 @@ pub const Group = struct {
     /// flat list of all shapes
     shapes: std.ArrayList(Shape3D),

-    transform: zlm.Mat4,
+    translation: zlm.Vec3,
+    rotation: zlm.Vec3,

     pub fn init(allocator: *std.mem.Allocator, name: []const u8) Self {
         return Self{
             .name = name,
             .shapes = std.ArrayList(Shape3D).init(allocator),
-            .transform = zlm.Mat4.identity,
+            .translation = zlm.Vec3.zero,
+            .rotation = zlm.Vec3.zero,
         };
     }

@@ -159,14 +161,19 @@ pub fn applyEventToState(state: *State, event: parsing.Event) !void {
         },
         .move => |cmd| {
             var iter = state.findGroups(cmd.selector.groups);
-            while (iter.next()) |*grp| {
-                // semantics unclear
+            while (iter.next()) |grp| {
+                switch (cmd.direction) {
+                    .offset => |offset| {
+                        grp.translation = offset.apply(grp.translation);
+                    },
+                    else => std.debug.panic("relative movement not implemented yet", .{}),
+                }
             }
         },
         .rotate => |cmd| {
             var iter = state.findGroups(cmd.selector.groups);
-            while (iter.next()) |*grp| {
-                // semantics unclear
+            while (iter.next()) |grp| {
+                grp.rotation = cmd.vector.apply(grp.rotation);
             }
         },
         else => {
diff --git a/lib/hackvr/parser.zig b/lib/hackvr/parser.zig

--- a/lib/hackvr/parser.zig
+++ b/lib/hackvr/parser.zig
@@ -369,8 +369,8 @@ pub const AbsRelVector = struct {
     pub fn apply(self: Self, v3d: hvr.Vec3D) hvr.Vec3D {
         return .{
             .x = self.x.apply(v3d.x),
-            .y = self.x.apply(v3d.y),
-            .z = self.x.apply(v3d.z),
+            .y = self.y.apply(v3d.y),
+            .z = self.z.apply(v3d.z),
         };
     }
 };
diff --git a/lib/zgl b/lib/zgl

--- a/lib/zgl
+++ b/lib/zgl
@@ -1 +1 @@
-Subproject commit c37cf0cfbeeab94cc07121ce3c817cc6813c15fd
+Subproject commit b61a011872482d55f3b603f279fc3c39b8ae8b38
diff --git a/lib/zlm b/lib/zlm

--- a/lib/zlm
+++ b/lib/zlm
@@ -1 +1 @@
-Subproject commit 3d948806d30245c1ba575f53fc361490f7db9f12
+Subproject commit f64f7fed4c0a2fbef8586a7ab6f0d3a9644d6aba
diff --git a/src/main.zig b/src/main.zig

--- a/src/main.zig
+++ b/src/main.zig
@@ -153,9 +153,23 @@ pub fn main() anyerror!void {
     var vertex_buffer = try gl.createBuffer();
     defer vertex_buffer.delete();

+    const PolygonGroup = struct {
+        transform: zlm.Mat4,
+        begin_tris: usize,
+        count_tris: usize,
+        begin_lines: usize,
+        count_lines: usize,
+    };
+
+    var poly_groups = std.ArrayList(PolygonGroup).init(gpa);
+    defer poly_groups.deinit();
+
     var vertex_list = std.ArrayList(Vertex).init(gpa);
     defer vertex_list.deinit();

+    var outline_list = std.ArrayList(Vertex).init(gpa);
+    defer outline_list.deinit();
+
     try vao.vertexBuffer(0, vertex_buffer, 0, @sizeOf(Vertex));

     var shader_program = try gl.createProgram();
@@ -216,8 +230,13 @@ pub fn main() anyerror!void {
     };

     try gl.enable(.depth_test);
+    try gl.depthFunc(.less_or_equal);
+
+    var time: f32 = 0.0;

     mainLoop: while (true) {
+        time += 1.0 / 60.0;
+
         // process events
         {
             var event: c.SDL_Event = undefined;
@@ -232,9 +251,21 @@ pub fn main() anyerror!void {
         // Render scene from HackVR dataset
         {
             vertex_list.shrink(0);
+            poly_groups.shrink(0);

             var groups = state.iterator();
             while (groups.next()) |group| {
+                var poly_grp = PolygonGroup{
+                    .begin_tris = vertex_list.items.len,
+                    .count_tris = undefined,
+                    .begin_lines = outline_list.items.len,
+                    .count_lines = undefined,
+                    .transform = zlm.Mat4.mul(
+                        zlm.Mat4.createAngleAxis(zlm.Vec3.unitY, zlm.toRadians(group.rotation.y)),
+                        zlm.Mat4.createTranslation(group.translation),
+                    ),
+                };
+
                 for (group.shapes.items) |shape| {
                     if (shape.points.len < 3) {
                         std.debug.print("count: {}\n", .{shape.points.len});
@@ -258,21 +289,44 @@ pub fn main() anyerror!void {

                             i += 1;
                         }
+
+                        i = 1;
+                        while (i < shape.points.len) {
+                            try outline_list.append(Vertex{
+                                .position = shape.points[i - 1],
+                                .color = palette[15],
+                            });
+                            try outline_list.append(Vertex{
+                                .position = shape.points[i],
+                                .color = palette[15],
+                            });
+                            i += 1;
+                        }
+                        try outline_list.append(Vertex{
+                            .position = shape.points[0],
+                            .color = palette[15],
+                        });
+                        try outline_list.append(Vertex{
+                            .position = shape.points[shape.points.len - 1],
+                            .color = palette[15],
+                        });
                     }
                 }
+                poly_grp.count_tris = vertex_list.items.len - poly_grp.begin_tris;
+                poly_grp.count_lines = outline_list.items.len - poly_grp.begin_lines;
+
+                try poly_groups.append(poly_grp);
             }
         }

-        try gl.namedBufferData(vertex_buffer, Vertex, vertex_list.items, .dynamic_draw);
-
         const mat_proj = zlm.Mat4.createPerspective(1.0, 16.0 / 9.0, 0.1, 10000.0);
         const mat_view = zlm.Mat4.createLookAt(
-            .{ .x = -20, .y = 0, .z = 0 },
+            .{ .x = -50, .y = 30, .z = 0 },
             .{ .x = 0, .y = 0, .z = 0 },
-            .{ .x = 0, .y = 1, .z = 0 },
+            zlm.Vec3.unitY,
         );

-        const mat_view_proj = zlm.Mat4.mul(mat_view, mat_proj);
+        const mat_view_proj = zlm.Mat4.createAngleAxis(zlm.Vec3.unitY, time).mul(mat_view.mul(mat_proj));

         // render graphics
         {
@@ -286,14 +340,32 @@ pub fn main() anyerror!void {
             try vao.bind();
             try shader_program.use();

-            try gl.programUniformMatrix4(
-                shader_program,
-                transform_loc,
-                false,
-                @ptrCast([*]const [4][4]f32, &mat_view_proj.fields)[0..1],
-            );
+            try gl.namedBufferData(vertex_buffer, Vertex, vertex_list.items, .dynamic_draw);
+
+            for (poly_groups.items) |poly_grp| {
+                const transform = zlm.Mat4.mul(poly_grp.transform, mat_view_proj);
+
+                try gl.programUniformMatrix4(
+                    shader_program,
+                    transform_loc,
+                    false,
+                    @ptrCast([*]const [4][4]f32, &transform.fields)[0..1],
+                );

-            try gl.drawArrays(.triangles, 0, vertex_list.items.len);
+                try gl.drawArrays(.triangles, poly_grp.begin_tris, poly_grp.count_tris);
+            }
+            try gl.namedBufferData(vertex_buffer, Vertex, outline_list.items, .dynamic_draw);
+            for (poly_groups.items) |poly_grp| {
+                const transform = zlm.Mat4.mul(poly_grp.transform, mat_view_proj);
+
+                try gl.programUniformMatrix4(
+                    shader_program,
+                    transform_loc,
+                    false,
+                    @ptrCast([*]const [4][4]f32, &transform.fields)[0..1],
+                );
+                try gl.drawArrays(.lines, poly_grp.begin_lines, poly_grp.count_lines);
+            }

             c.SDL_GL_SwapWindow(window);
             c.SDL_Delay(10);

-----END OF PAGE-----