Merge branch 'hexops:main' into vulkan-clear-fix

platypro · web-flow · commit 37788bf56b18 · 2025-02-09T16:43:00.000-08:00
diff --git a/README.md b/README.md
@@ -18,3 +18,6 @@ Zig game engine & graphics toolkit for building high-performance, truly cross-pl
 ## Join the community
 
 Join the [Mach community on Discord](https://discord.gg/XNG3NZgCqp) to discuss this project, ask questions, get help, etc.
+
+**We're here to make games and have fun, so please help keep the community focused on that.** No politics/heated topics are allowed. Unfortunately, [the political landscape today makes it such that we must also state](https://emidoots.com/2025/i-want-code-not-politics): fascists can go f*k themselves, we support LGBTQ+ and minorities here - their existence is not political.
+
diff --git a/build.zig.zon b/build.zig.zon
@@ -22,8 +22,8 @@
             .lazy = true,
         },
         .mach_objc = .{
-            .url = "https://pkg.machengine.org/mach-objc/bb7ced86bf768979ff22254e31ed9934d74a0226.tar.gz",
-            .hash = "122006526df5979b71d5f0c3f849622661d05f69a4f7065537fbc04c2ae11030f1d5",
+            .url = "https://pkg.machengine.org/mach-objc/79b6f80c32b14948554958afe72dace261b14afc.tar.gz",
+            .hash = "12203675829014e69be2ea7c126ecf25d403009d336b7ca5f6e7c4ccede826c8e597",
             .lazy = true,
         },
         .xcode_frameworks = .{
diff --git a/src/math/mat.zig b/src/math/mat.zig
@@ -1,7 +1,10 @@
+const std = @import("std");
+
 const mach = @import("../main.zig");
 const testing = mach.testing;
 const math = mach.math;
 const vec = @import("vec.zig");
+const quat = @import("quat.zig");
 
 pub fn Mat2x2(
     comptime Scalar: type,
@@ -118,6 +121,7 @@ pub fn Mat2x2(
 
         pub const mul = Shared.mul;
         pub const mulVec = Shared.mulVec;
+        pub const format = Shared.format;
     };
 }
 
@@ -258,6 +262,7 @@ pub fn Mat3x3(
 
         pub const mul = Shared.mul;
         pub const mulVec = Shared.mulVec;
+        pub const format = Shared.format;
     };
 }
 
@@ -435,6 +440,22 @@ pub fn Mat4x4(
             );
         }
 
+        //https://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToMatrix/jay.htm
+        //Requires a normalized quaternion
+        pub inline fn rotateByQuaternion(quaternion: quat.Quat(T)) Matrix {
+            const qx = quaternion.v.x();
+            const qy = quaternion.v.y();
+            const qz = quaternion.v.z();
+            const qw = quaternion.v.w();
+
+            return Matrix.init(
+                &RowVec.init(1 - 2 * qy * qy - 2 * qz * qz, 2 * qx * qy - 2 * qz * qw, 2 * qx * qz + 2 * qy * qw, 0),
+                &RowVec.init(2 * qx * qy + 2 * qz * qw, 1 - 2 * qx * qx - 2 * qz * qz, 2 * qy * qz - 2 * qx * qw, 0),
+                &RowVec.init(2 * qx * qz - 2 * qy * qw, 2 * qy * qz + 2 * qx * qw, 1 - 2 * qx * qx - 2 * qy * qy, 0),
+                &RowVec.init(0, 0, 0, 1),
+            );
+        }
+
         /// Constructs a 2D projection matrix, aka. an orthographic projection matrix.
         ///
         /// First, a cuboid is defined with the parameters:
@@ -485,6 +506,7 @@ pub fn Mat4x4(
         pub const mulVec = Shared.mulVec;
         pub const eql = Shared.eql;
         pub const eqlApprox = Shared.eqlApprox;
+        pub const format = Shared.format;
     };
 }
 
@@ -542,6 +564,24 @@ pub fn MatShared(comptime RowVec: type, comptime ColVec: type, comptime Matrix:
             }
             return true;
         }
+
+        /// Custom format function for all matrix types.
+        pub inline fn format(
+            self: Matrix,
+            comptime fmt: []const u8,
+            options: std.fmt.FormatOptions,
+            writer: anytype,
+        ) @TypeOf(writer).Error!void {
+            const rows = @TypeOf(self).rows;
+            try writer.print("{{", .{});
+            inline for (0..rows) |r| {
+                try std.fmt.formatType(self.row(r), fmt, options, writer, 1);
+                if (r < rows - 1) {
+                    try writer.print(", ", .{});
+                }
+            }
+            try writer.print("}}", .{});
+        }
     };
 }
 
@@ -1173,3 +1213,17 @@ test "projection2D_model_to_clip_space" {
     try testing.expect(math.Vec4, math.vec4(1, 0, 1, 1)).eql(mvp.mul(&math.Mat4x4.rotateY(math.degreesToRadians(90))).mulVec(&math.vec4(0, 0, 50, 1)));
     try testing.expect(math.Vec4, math.vec4(0, 0, 0.5, 1)).eql(mvp.mul(&math.Mat4x4.rotateZ(math.degreesToRadians(90))).mulVec(&math.vec4(0, 0, 50, 1)));
 }
+
+test "quaternion_rotation" {
+    const expected = math.Mat4x4.init(
+        &math.vec4(0.7716905, 0.5519065, 0.3160585, 0),
+        &math.vec4(-0.0782971, -0.4107276, 0.9083900, 0),
+        &math.vec4(0.6311602, -0.7257425, -0.2737419, 0),
+        &math.vec4(0, 0, 0, 1),
+    );
+
+    const q = math.Quat.fromAxisAngle(math.vec3(0.9182788, 0.1770672, 0.3541344), 4.2384558);
+    const result = math.Mat4x4.rotateByQuaternion(q.normalize());
+
+    try testing.expect(bool, true).eql(expected.eqlApprox(&result, 0.0000002));
+}
diff --git a/src/math/vec.zig b/src/math/vec.zig
@@ -67,6 +67,7 @@ pub fn Vec2(comptime Scalar: type) type {
         pub const minScalar = Shared.minScalar;
         pub const eqlApprox = Shared.eqlApprox;
         pub const eql = Shared.eql;
+        pub const format = Shared.format;
     };
 }
 
@@ -190,6 +191,7 @@ pub fn Vec3(comptime Scalar: type) type {
         pub const minScalar = Shared.minScalar;
         pub const eqlApprox = Shared.eqlApprox;
         pub const eql = Shared.eql;
+        pub const format = Shared.format;
     };
 }
 
@@ -269,6 +271,7 @@ pub fn Vec4(comptime Scalar: type) type {
         pub const minScalar = Shared.minScalar;
         pub const eqlApprox = Shared.eqlApprox;
         pub const eql = Shared.eql;
+        pub const format = Shared.format;
     };
 }
 
@@ -519,6 +522,16 @@ pub fn VecShared(comptime Scalar: type, comptime VecN: type) type {
         pub inline fn eql(a: *const VecN, b: *const VecN) bool {
             return a.eqlApprox(b, math.eps(Scalar));
         }
+
+        /// Custom format function for all vector types.
+        pub inline fn format(
+            self: VecN,
+            comptime fmt: []const u8,
+            options: std.fmt.FormatOptions,
+            writer: anytype,
+        ) @TypeOf(writer).Error!void {
+            try std.fmt.formatType(self.v, fmt, options, writer, 1);
+        }
     };
 }
 
diff --git a/src/module.zig b/src/module.zig
@@ -70,13 +70,21 @@ pub fn Objects(options: ObjectsOptions, comptime T: type) type {
 
             /// A bitset used to track per-field changes. Only used if options.track_fields == true.
             updated: ?std.bit_set.DynamicBitSetUnmanaged = if (options.track_fields) .{} else null,
+
+            /// Tags storage
+            tags: std.AutoHashMapUnmanaged(TaggedObject, ?ObjectID) = .{},
         },
 
         pub const IsMachObjects = void;
 
         const Generation = u16;
         const Index = u32;
 
+        const TaggedObject = struct {
+            object_id: ObjectID,
+            tag_hash: u64,
+        };
+
         const PackedID = packed struct(u64) {
             type_id: ObjectTypeID,
             generation: Generation,
@@ -275,6 +283,52 @@ pub fn Objects(options: ObjectsOptions, comptime T: type) type {
             if (mach.is_debug) data.set(unpacked.index, undefined);
         }
 
+        // TODO(objects): evaluate whether tag operations should ever return an error
+
+        /// Sets a tag on an object
+        pub fn setTag(objs: *@This(), id: ObjectID, comptime M: type, tag: ModuleTagEnum(M), value_id: ?ObjectID) !void {
+            _ = objs.validateAndUnpack(id, "setTag");
+
+            // TODO: validate that value_id is an object coming from the mach.Objects(T) list indicated by the tag value in M.mach_tags.
+            //const value_mach_objects = moduleTagValueObjects(M, tag);
+
+            const tagged = TaggedObject{
+                .object_id = id,
+                .tag_hash = std.hash.Wyhash.hash(0, @tagName(tag)),
+            };
+            try objs.internal.tags.put(objs.internal.allocator, tagged, value_id);
+        }
+
+        /// Removes a tag on an object
+        pub fn removeTag(objs: *@This(), id: ObjectID, comptime M: type, tag: ModuleTagEnum(M)) void {
+            _ = objs.validateAndUnpack(id, "removeTag");
+            const tagged = TaggedObject{
+                .object_id = id,
+                .tag_hash = std.hash.Wyhash.hash(0, @tagName(tag)),
+            };
+            _ = objs.internal.tags.remove(tagged);
+        }
+
+        /// Whether an object has a tag
+        pub fn hasTag(objs: *@This(), id: ObjectID, comptime M: type, tag: ModuleTagEnum(M)) bool {
+            _ = objs.validateAndUnpack(id, "hasTag");
+            const tagged = TaggedObject{
+                .object_id = id,
+                .tag_hash = std.hash.Wyhash.hash(0, @tagName(tag)),
+            };
+            return objs.internal.tags.contains(tagged);
+        }
+
+        /// Get an object's tag value, or null.
+        pub fn getTag(objs: *@This(), id: ObjectID, comptime M: type, tag: ModuleTagEnum(M)) ?mach.ObjectID {
+            _ = objs.validateAndUnpack(id, "getTag");
+            const tagged = TaggedObject{
+                .object_id = id,
+                .tag_hash = std.hash.Wyhash.hash(0, @tagName(tag)),
+            };
+            return objs.internal.tags.get(tagged) orelse null;
+        }
+
         pub fn slice(objs: *@This()) Slice {
             return Slice{
                 .index = 0,
@@ -497,6 +551,46 @@ fn ModuleFunctionName2(comptime M: type) type {
     });
 }
 
+/// Enum describing all mach_tags for a given comptime-known module.
+fn ModuleTagEnum(comptime M: type) type {
+    // TODO(object): handle duplicate enum field case in mach_tags with a more clear error?
+    // TODO(object): improve validation error messages here
+    validate(M);
+    if (@typeInfo(@TypeOf(M.mach_tags)) != .@"struct") {
+        @compileError("mach: invalid module, `pub const mach_tags must be `.{ .is_monster, .{ .renderer, mach.Renderer.objects } }`, found: " ++ @typeName(@TypeOf(M.mach_tags)));
+    }
+    var enum_fields: []const std.builtin.Type.EnumField = &[0]std.builtin.Type.EnumField{};
+    var i: u32 = 0;
+    inline for (@typeInfo(@TypeOf(M.mach_tags)).@"struct".fields, 0..) |field, field_index| {
+        const f = M.mach_tags[field_index];
+        if (@typeInfo(field.type) == .enum_literal) {
+            enum_fields = enum_fields ++ [_]std.builtin.Type.EnumField{.{ .name = @tagName(f), .value = i }};
+            i += 1;
+        } else {
+            if (@typeInfo(field.type) != .@"struct") {
+                @compileError("mach: invalid module, mach_tags entry is not an enum literal or struct, found: " ++ @typeName(field.type));
+            }
+            // TODO(objects): validate length of struct
+            const tag = f.@"0";
+            const M2 = f.@"1";
+            const object_list_tag = f.@"2";
+            _ = object_list_tag; // autofix
+            validate(M2);
+            // TODO: validate that M2.object_list_tag is a mach objects list
+            enum_fields = enum_fields ++ [_]std.builtin.Type.EnumField{.{ .name = @tagName(tag), .value = i }};
+            i += 1;
+        }
+    }
+    return @Type(.{
+        .@"enum" = .{
+            .tag_type = if (enum_fields.len > 0) std.math.IntFittingRange(0, enum_fields.len - 1) else u0,
+            .fields = enum_fields,
+            .decls = &[_]std.builtin.Type.Declaration{},
+            .is_exhaustive = true,
+        },
+    });
+}
+
 pub fn Modules(module_lists: anytype) type {
     inline for (moduleTuple(module_lists)) |module| {
         validate(module);
