Version

- Make all vtable functions non-optional, to improve error messages when `pub` is missing
- Fix up test output when PRINT_OUTPUT is enabled
- Move defines to a common build function
- Add -Dverbose to set PRINT_OUTPUT

Author: kcbanner

build.zig

@@ -1,5 +1,16 @@
 const std = @import("std");
 
+fn addMacros(module: *std.Build.Module, options: anytype) void {
+    if (options.enable_cross_platform_determinism)
+        module.addCMacro("JPH_CROSS_PLATFORM_DETERMINISTIC", "");
+    if (options.enable_debug_renderer)
+        module.addCMacro("JPH_DEBUG_RENDERER", "");
+    if (options.use_double_precision)
+        module.addCMacro("JPH_DOUBLE_PRECISION", "");
+    if (options.enable_asserts)
+        module.addCMacro("JPH_ENABLE_ASSERTS", "");
+}
+
 pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
@@ -84,15 +95,12 @@ pub fn build(b: *std.Build) void {
     const src_dir = "libs/Jolt";
     const c_flags = &.{
         "-std=c++17",
-        if (options.enable_cross_platform_determinism) "-DJPH_CROSS_PLATFORM_DETERMINISTIC" else "",
-        if (options.enable_debug_renderer) "-DJPH_DEBUG_RENDERER" else "",
-        if (options.use_double_precision) "-DJPH_DOUBLE_PRECISION" else "",
-        if (options.enable_asserts) "-DJPH_ENABLE_ASSERTS" else "",
         if (options.no_exceptions) "-fno-exceptions" else "",
         "-fno-access-control",
         "-fno-sanitize=undefined",
     };
 
+    addMacros(joltc.root_module, options);
     joltc.addCSourceFiles(.{
         .files = &.{
             "libs/JoltC/JoltPhysicsC.cpp",
@@ -258,17 +266,17 @@ pub fn build(b: *std.Build) void {
         tests.want_lto = false;
     }
 
+    addMacros(tests.root_module, options);
     tests.addCSourceFile(.{
         .file = b.path("libs/JoltC/JoltPhysicsC_Tests.c"),
         .flags = &.{
-            if (options.enable_cross_platform_determinism) "-DJPH_CROSS_PLATFORM_DETERMINISTIC" else "",
-            if (options.enable_debug_renderer) "-DJPH_DEBUG_RENDERER" else "",
-            if (options.use_double_precision) "-DJPH_DOUBLE_PRECISION" else "",
-            if (options.enable_asserts) "-DJPH_ENABLE_ASSERTS" else "",
             "-fno-sanitize=undefined",
         },
     });
 
+    if (b.option(bool, "verbose", "Print verbose test debug output to stderr") orelse false)
+        tests.root_module.addCMacro("PRINT_OUTPUT", "");
+
     tests.root_module.addImport("zphysics_options", options_module);
     tests.addIncludePath(b.path("libs/JoltC"));
     tests.linkLibrary(joltc);

libs/JoltC/JoltPhysicsC.cpp

@@ -739,7 +739,7 @@ class DebugRendererImpl final : public JPH::DebugRenderer
         BatchImpl(const JPC_DebugRenderer_Primitive *c_primitive) : RenderPrimitive(c_primitive) {}
         ~BatchImpl()
         {
-            if (sInstance && sInstance->c_renderer->vtbl->DestroyTriangleBatch)
+            if (sInstance)
             {
                 sInstance->c_renderer->vtbl->DestroyTriangleBatch(sInstance->c_renderer, (void*)c_primitive);
             }
@@ -790,6 +790,7 @@ class DebugRendererImpl final : public JPH::DebugRenderer
         valid &= (c_renderer->vtbl->DrawTriangle               != nullptr);
         valid &= (c_renderer->vtbl->CreateTriangleBatch        != nullptr);
         valid &= (c_renderer->vtbl->CreateTriangleBatchIndexed != nullptr);
+        valid &= (c_renderer->vtbl->DestroyTriangleBatch       != nullptr);
         valid &= (c_renderer->vtbl->DrawGeometry               != nullptr);
         valid &= (c_renderer->vtbl->DrawText3D                 != nullptr);
         return valid ? JPC_DEBUGRENDERER_SUCCESS : JPC_DEBUGRENDERER_INCOMPLETE_IMPL;

libs/JoltC/JoltPhysicsC_Tests.c

@@ -5,8 +5,6 @@
 #include <stdio.h>
 #include <string.h>
 
-//#define PRINT_OUTPUT
-
 // Object layers
 #define NUM_OBJ_LAYERS 2
 #define OBJ_LAYER_NON_MOVING 0
@@ -97,9 +95,9 @@ MyContactListener_OnContactValidate(void *in_self,
             "\tOnContactValidate(): in_base_offset (%f, %f, %f)\n",
             in_base_offset[0], in_base_offset[1], in_base_offset[2]);
     fprintf(stderr, "\tOnContactValidate(): penetration_depth (%f)\n", in_collision_result->penetration_depth);
-    fprintf(stderr, "\tOnContactValidate(): shape1_sub_shape_id (%d)\n", in_collision_result->shape1_sub_shape_id);
-    fprintf(stderr, "\tOnContactValidate(): shape2_sub_shape_id (%d)\n", in_collision_result->shape2_sub_shape_id);
-    fprintf(stderr, "\tOnContactValidate(): body2_id (%d)\n", in_collision_result->body2_id);
+    fprintf(stderr, "\tOnContactValidate(): shape1_sub_shape_id (%d)\n", in_collision_result->shape1_sub_shape_id.id);
+    fprintf(stderr, "\tOnContactValidate(): shape2_sub_shape_id (%d)\n", in_collision_result->shape2_sub_shape_id.id);
+    fprintf(stderr, "\tOnContactValidate(): body2_id (%d)\n", in_collision_result->body2_id.id);
 #endif
     return JPC_VALIDATE_RESULT_ACCEPT_ALL_CONTACTS;
 }
@@ -214,7 +212,7 @@ MyDebugRenderer_CreateTriangleBatch(void *in_self,
         (JPC_DebugRenderer_Primitive *)prim
         );
 #ifdef PRINT_OUTPUT
-    fprintf(stderr, "\tDebugRenderer: CreateTriangleBatch called. Created primitive %x\n", prim);
+    fprintf(stderr, "\tDebugRenderer: CreateTriangleBatch called. Created primitive %llx\n", (uint64_t)prim);
 #endif
     return batch;
 }
@@ -232,11 +230,21 @@ MyDebugRenderer_CreateTriangleBatchIndexed(void *in_self,
         (JPC_DebugRenderer_Primitive *)prim
         );
 #ifdef PRINT_OUTPUT
-    fprintf(stderr, "\tDebugRenderer: CreateTriangleBatchIndexed called. Created primitive %x\n", prim);
+    fprintf(stderr, "\tDebugRenderer: CreateTriangleBatchIndexed called. Created primitive %llx\n", (uint64_t)prim);
 #endif
     return batch;
 }
 
+static void
+MyDebugRenderer_DestroyTriangleBatch(void *in_self, void *in_batch)
+{
+    struct MyDebugRenderer *self = (struct MyDebugRenderer*) in_self;
+    struct MyRenderPrimitive *prim = (MyRenderPrimitive*)in_batch;
+#ifdef PRINT_OUTPUT
+    fprintf(stderr, "\tDebugRenderer: DestroyTriangleBatch called. Destroyed primitive %llx\n", (uint64_t)prim);
+#endif
+}
+
 static void
 MyDebugRenderer_DrawGeometry(void *in_self,
                              const JPC_RMatrix *inMatrix,
@@ -252,7 +260,7 @@ MyDebugRenderer_DrawGeometry(void *in_self,
     JPC_DebugRenderer_TriangleBatch *batch = in_geometry->LODs[0].batch;
     const JPC_DebugRenderer_Primitive *prim = JPC_DebugRenderer_TriangleBatch_GetPrimitive(batch);
 #ifdef PRINT_OUTPUT
-    fprintf(stderr, "\tDebugRenderer: DrawGeometry called for %x\n", prim);
+    fprintf(stderr, "\tDebugRenderer: DrawGeometry called for %llx\n", (uint64_t)prim);
 #endif
 }
 
@@ -277,6 +285,7 @@ MyDebugRenderer_Init(void)
               .DrawTriangle = MyDebugRenderer_DrawTriangle,
               .CreateTriangleBatch = MyDebugRenderer_CreateTriangleBatch,
               .CreateTriangleBatchIndexed = MyDebugRenderer_CreateTriangleBatchIndexed,
+              .DestroyTriangleBatch = MyDebugRenderer_DestroyTriangleBatch,
               .DrawGeometry = MyDebugRenderer_DrawGeometry,
               .DrawText3D = MyDebugRenderer_DrawText3D,
         };

src/zphysics.zig

@@ -131,8 +131,11 @@ fn initInterface(comptime T: type, comptime VTableT: type) *const VTableT {
             };
 
             if (opt_fn_info) |fn_info| {
+                if (is_opt)
+                    @compileError("vtable function pointer " ++ field.name ++ " must be non-optional");
+
                 if (!fn_info.calling_convention.eql(std.builtin.CallingConvention.c))
-                    @compileError("vtable function " ++ field.name ++ " must be callconv(.c)");
+                    @compileError("vtable function pointer " ++ field.name ++ " must be callconv(.c)");
 
                 if (@hasDecl(T, field.name)) {
                     @field(vtable, field.name) = &@field(T, field.name);
@@ -512,34 +515,31 @@ pub const ContactListener = extern struct {
 
     pub const VTable = extern struct {
         __header: VTableHeader = .{},
-        onContactValidate: ?*const fn (
+        onContactValidate: *const fn (
             self: *ContactListener,
             body1: *const Body,
             body2: *const Body,
             base_offset: *const [3]Real,
             collision_result: *const CollideShapeResult,
-        ) callconv(.c) ValidateResult = null,
-
-        onContactAdded: ?*const fn (
+        ) callconv(.c) ValidateResult,
+        onContactAdded: *const fn (
             self: *ContactListener,
             body1: *const Body,
             body2: *const Body,
             manifold: *const ContactManifold,
             settings: *ContactSettings,
-        ) callconv(.c) void = null,
-
-        onContactPersisted: ?*const fn (
+        ) callconv(.c) void,
+        onContactPersisted: *const fn (
             self: *ContactListener,
             body1: *const Body,
             body2: *const Body,
             manifold: *const ContactManifold,
             settings: *ContactSettings,
-        ) callconv(.c) void = null,
-
-        onContactRemoved: ?*const fn (
+        ) callconv(.c) void,
+        onContactRemoved: *const fn (
             self: *ContactListener,
             sub_shape_pair: *const SubShapeIdPair,
-        ) callconv(.c) void = null,
+        ) callconv(.c) void,
     };
 
     comptime {
@@ -1086,13 +1086,13 @@ pub const DebugRenderer = if (!debug_renderer_enabled) extern struct {} else ext
                 indices: [*]u32,
                 index_count: u32,
             ) callconv(.c) *TriangleBatch,
-            /// If this function is available, it will be called when the reference count
-            /// of the TriangleBatch returned by the above functions. `batch` will be the
+            /// Will be called when the reference count of the TriangleBatch
+            /// returned by the above functions reaches zero. `batch` will be the
             /// value that was passed to `DebugRenderer.createTriangleBatch`.
-            destroyTriangleBatch: ?*const fn (
+            destroyTriangleBatch: *const fn (
                 self: *T,
                 batch: *anyopaque,
-            ) callconv(.c) void = null,
+            ) callconv(.c) void,
             drawGeometry: *const fn (
                 self: *T,
                 model_matrix: *const RMatrix,