made a lot of libraries link dynamically- should make rebuilding objects so much faster

build.zig

@@ -182,10 +182,31 @@ pub fn addExtraModule(self: *BuildSystem, mod: *std.Build.Module, moduleName: []
     mod.addImport(moduleName, dep.module(moduleName));
 }
 
-pub fn addSDL3Install(self: *BuildSystem, b: *std.Build, optimize: std.builtin.OptimizeMode) void {
+pub fn addDependencyInstalls(self: *BuildSystem, b: *std.Build, optimize: std.builtin.OptimizeMode) void {
     b.installArtifact(b.dependency("sdl3_lib", .{ .target = self.target, .optimize = optimize }).artifact("SDL3"));
+    // b.installArtifact(b.dependency("Backlog", .{ .target = self.target, .optimize = optimize }).artifact("backlog_c"));
+
+    //b.installArtifact(b.dependency("spng", .{ .target = self.target, .optimize = optimize }).artifact("spng_c"));
+    //b.installArtifact(b.dependency("zphysics", .{ .target = self.target, .optimize = optimize }).artifact("joltc"));
+    //b.installArtifact(b.dependency("ozz", .{ .target = self.target, .optimize = optimize }).artifact("ozz_cpp"));
+
+    for (cDependencyList) |d| {
+        b.installArtifact(b.dependency(
+            d.dep,
+            .{ .target = self.target, .optimize = optimize },
+        ).artifact(d.artifact));
+    }
 }
 
+const cDependencyList: []const struct { dep: []const u8, artifact: []const u8 } = &.{
+    .{ .dep = "sdl3_lib", .artifact = "SDL3" },
+    .{ .dep = "spng", .artifact = "spng_c" },
+    .{ .dep = "lua", .artifact = "luac" },
+    .{ .dep = "miniaudio", .artifact = "miniaudio_c" },
+    .{ .dep = "zphysics", .artifact = "joltc" },
+    .{ .dep = "ozz", .artifact = "ozz_cpp" },
+};
+
 // ========= standalone build instance =======
 // maybe it should be an engine launcher or something..
 pub fn build(b: *std.Build) void {
@@ -224,23 +245,4 @@ pub fn build(b: *std.Build) void {
             mod.addImport("sdl3_fwd", lib);
         }
     }
-
-    {
-        const mod = b.addModule("BacklogExtern", .{
-            .target = target,
-            .optimize = optimize,
-            .root_source_file = b.path("engine/backlogExtern.zig"),
-        });
-
-        for (engineDepList) |depName| {
-            const dep = b.dependency(
-                depName,
-                .{
-                    .target = target,
-                    .optimize = optimize,
-                },
-            );
-            mod.addImport(depName, dep.module(depName));
-        }
-    }
 }

build.zig.zon

@@ -12,7 +12,11 @@
         .ui = .{ .path = "engine/ui" },
         .rend = .{.path = "engine/rend" },
         .SpirvReflect = .{ .path = "lib/spirv-reflect-zig" },
+
         .ozz = .{ .path = "lib/ozz" },
+        .spng = .{ .path = "lib/spng" },
+        .zphysics = .{ .path = "lib/zphysics" },
+
         .sdl3 = .{ .path = "lib/sdl3" },
         .sdl3_lib = .{ .path = "lib/sdl3/SDL" },
     },

engine/core/build.zig

@@ -1,14 +1,14 @@
 const std = @import("std");
 
 const dependencyList = [_][]const u8{
-    "spng",
-    "nfd",
     "p2",
     "tracy",
     "zmath",
     "packer",
     "sdl3",
     "lua",
+    "spng",
+    "nfd",
 };
 
 pub fn build(b: *std.Build) void {

lib/lua/build.zig

@@ -11,12 +11,13 @@ pub fn build(b: *std.Build) void {
         .link_libc = true,
     });
 
-    const luac = b.addStaticLibrary(.{
+    const luac = b.addSharedLibrary(.{
         .name = "luac",
         .target = target,
         .optimize = optimize,
         .link_libc = true,
     });
+    b.installArtifact(luac);
 
     luac.addCSourceFiles(.{
         .root = b.path("lua/src/"),

lib/miniaudio/build.zig

@@ -4,12 +4,14 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const miniaudio_c = b.addStaticLibrary(.{
+    const miniaudio_c = b.addSharedLibrary(.{
         .name = "miniaudio_c",
         .target = target,
         .optimize = optimize,
         .link_libc = true,
     });
+
+    b.installArtifact(miniaudio_c);
     miniaudio_c.addCSourceFile(.{ .file = b.path("src/miniaudio.cpp"), .flags = &.{"-fno-sanitize=all"} });
     miniaudio_c.addIncludePath(b.path("include"));
 

lib/ozz/build.zig

@@ -86,6 +86,44 @@ pub const GltfToOzz = struct {
         const ozz_mod = dep.artifact("ozz_cpp");
         exe.root_module.linkLibrary(ozz_mod);
 
+        exe.root_module.addIncludePath(b.path("ozz-animation/include"));
+        exe.root_module.addIncludePath(b.path("ozz-animation/src"));
+        exe.linkLibC();
+
+        if (ozz_build.graph.host.result.abi != .msvc)
+            exe.linkLibCpp();
+
+        exe.root_module.addCSourceFiles(.{
+            .files = &.{
+                src_dir ++ "options/options.cc",
+                src_dir ++ "geometry/runtime/skinning_job.cc",
+                src_dir ++ "base/containers/string_archive.cc",
+                src_dir ++ "base/io/archive.cc",
+                src_dir ++ "base/io/stream.cc",
+                src_dir ++ "base/log.cc",
+                src_dir ++ "base/platform.cc",
+                src_dir ++ "base/maths/box.cc",
+                src_dir ++ "base/maths/math_archive.cc",
+                src_dir ++ "base/maths/simd_math.cc",
+                src_dir ++ "base/maths/simd_math_archive.cc",
+                src_dir ++ "base/maths/soa_math_archive.cc",
+                src_dir ++ "base/memory/allocator.cc",
+                src_dir ++ "animation/runtime/animation.cc",
+                src_dir ++ "animation/runtime/animation_utils.cc",
+                src_dir ++ "animation/runtime/blending_job.cc",
+                src_dir ++ "animation/runtime/ik_aim_job.cc",
+                src_dir ++ "animation/runtime/ik_two_bone_job.cc",
+                src_dir ++ "animation/runtime/local_to_model_job.cc",
+                src_dir ++ "animation/runtime/sampling_job.cc",
+                src_dir ++ "animation/runtime/skeleton.cc",
+                src_dir ++ "animation/runtime/skeleton_utils.cc",
+                src_dir ++ "animation/runtime/track.cc",
+                src_dir ++ "animation/runtime/track_sampling_job.cc",
+                src_dir ++ "animation/runtime/track_triggering_job.cc",
+                "src/ozz_zig.cpp",
+            },
+        });
+
         return .{
             .b = b,
             .ozz_build = ozz_build,
@@ -103,7 +141,7 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
     const target = b.standardTargetOptions(.{});
 
-    const ozz_cpp = b.addStaticLibrary(.{
+    const ozz_cpp = b.addSharedLibrary(.{
         .name = "ozz_cpp",
         .target = target,
         .optimize = optimize,
@@ -146,6 +184,7 @@ pub fn build(b: *std.Build) void {
             src_dir ++ "animation/runtime/track.cc",
             src_dir ++ "animation/runtime/track_sampling_job.cc",
             src_dir ++ "animation/runtime/track_triggering_job.cc",
+            "src/ozz_zig.cpp",
         },
     });
 
@@ -155,11 +194,7 @@ pub fn build(b: *std.Build) void {
 
     ozz.addIncludePath(b.path("ozz-animation/include"));
 
-    ozz.addCSourceFiles(.{
+    ozz.linkLibrary(ozz_cpp);
-        .files = &.{
-            "src/ozz_zig.cpp",
-        },
-    });
 
     const tests = b.addTest(.{
         .name = "ozz-tests",

lib/ozz/src/ozz_zig.cpp

@@ -16,6 +16,12 @@
 #include "ozz/base/io/archive_traits.h"
 #include "ozz/base/io/stream.h"
 
+#ifdef _WIN32
+#define OZZ_CPP_API __declspec(dllexport)
+#else 
+#define OZZ_CPP_API
+#endif
+
 extern "C" {
 
 struct OpaqueSpan 
@@ -41,27 +47,27 @@ void testFunc()
     archive >> skeleton;
 }
 
-void startupOzz()
+OZZ_CPP_API void startupOzz()
 {
 }
 
-void shutdownOzz()
+OZZ_CPP_API void shutdownOzz()
 {
 }
 
-bool SamplingJob_Run_c(void* context)
+OZZ_CPP_API bool SamplingJob_Run_c(void* context)
 {
     ozz::animation::SamplingJob* self = static_cast<ozz::animation::SamplingJob*>(context);
     return self->Run();
 }
 
-bool SamplingJob_Validate_c(void* context)
+OZZ_CPP_API bool SamplingJob_Validate_c(void* context)
 {
     ozz::animation::SamplingJob* self = static_cast<ozz::animation::SamplingJob*>(context);
     return self->Validate();
 }
  
-OpaqueSpan SkeletonGetJointsList_c(void* context) 
+OZZ_CPP_API OpaqueSpan SkeletonGetJointsList_c(void* context) 
 {
     ozz::animation::Skeleton* self = static_cast<ozz::animation::Skeleton*>(context);
     auto s = self->joint_names();
@@ -69,25 +75,25 @@ OpaqueSpan SkeletonGetJointsList_c(void* context)
     return *ptr;
 }
 
-int SkeletonNumJoints_c(void* context)
+OZZ_CPP_API int SkeletonNumJoints_c(void* context)
 {
     ozz::animation::Skeleton* self = static_cast<ozz::animation::Skeleton*>(context);
     return self->num_joints();
 }
 
-int SkeletonNumSoaJoints_c(void* context)
+OZZ_CPP_API int SkeletonNumSoaJoints_c(void* context)
 {
     ozz::animation::Skeleton* self = static_cast<ozz::animation::Skeleton*>(context);
     return self->num_soa_joints();
 }
 
-void* CreateSkeleton_c()
+OZZ_CPP_API void* CreateSkeleton_c()
 {
     ozz::animation::Skeleton* rv = new ozz::animation::Skeleton();
     return rv;
 }
 
-void LoadSkeletonFromBytes_c(void* skeleton, void* start, size_t size)
+OZZ_CPP_API void LoadSkeletonFromBytes_c(void* skeleton, void* start, size_t size)
 {
     ozz::animation::Skeleton* sk = static_cast<ozz::animation::Skeleton*>(skeleton);
 
@@ -106,7 +112,7 @@ void LoadSkeletonFromBytes_c(void* skeleton, void* start, size_t size)
     archive >> *sk;
 }
 
-void LoadSkeletonFromFile_c(void* skeleton, const char* filename)
+OZZ_CPP_API void LoadSkeletonFromFile_c(void* skeleton, const char* filename)
 {
     ozz::animation::Skeleton* sk = static_cast<ozz::animation::Skeleton*>(skeleton);
 
@@ -131,7 +137,7 @@ void LoadSkeletonFromFile_c(void* skeleton, const char* filename)
 }
 
 
-OpaqueSpan SkeletonJointRestPoses_c (void* skeleton)
+OZZ_CPP_API OpaqueSpan SkeletonJointRestPoses_c (void* skeleton)
 {
     ozz::animation::Skeleton* sk = static_cast<ozz::animation::Skeleton*>(skeleton);
     auto x = sk->joint_rest_poses();
@@ -140,33 +146,33 @@ OpaqueSpan SkeletonJointRestPoses_c (void* skeleton)
     return *p;
 }
 
-void DestroySkeleton_c(void* skeleton)
+OZZ_CPP_API void DestroySkeleton_c(void* skeleton)
 {
     ozz::animation::Skeleton* sk = static_cast<ozz::animation::Skeleton*>(skeleton);
     
     delete sk;
 }
 
-float AnimationGetDuration_c(void* animation) 
+OZZ_CPP_API float AnimationGetDuration_c(void* animation) 
 {
     ozz::animation::Animation* a = static_cast<ozz::animation::Animation*>(animation);
     return a->duration();
 }
 
-void* CreateAnimation_c()
+OZZ_CPP_API void* CreateAnimation_c()
 {
     ozz::animation::Animation* a = new ozz::animation::Animation();
     return a;
 }
 
 
-void DestroyAnimation_c(void* anim)
+OZZ_CPP_API void DestroyAnimation_c(void* anim)
 {
     ozz::animation::Animation* self = static_cast<ozz::animation::Animation*>(anim);
     delete self;
 }
 
-void LoadAnimationFromBytes_c(void* anim, void* start, size_t size)
+OZZ_CPP_API void LoadAnimationFromBytes_c(void* anim, void* start, size_t size)
 {
     ozz::animation::Animation* self = static_cast<ozz::animation::Animation*>(anim);
     ozz::io::MemoryStream ms;   
@@ -184,7 +190,7 @@ void LoadAnimationFromBytes_c(void* anim, void* start, size_t size)
     archive >> *self;
 }
 
-void LoadAnimationFromFile_c(void* anim, const char* filename)
+OZZ_CPP_API void LoadAnimationFromFile_c(void* anim, const char* filename)
 {
     ozz::animation::Animation* self = static_cast<ozz::animation::Animation*>(anim);
 
@@ -211,56 +217,56 @@ void LoadAnimationFromFile_c(void* anim, const char* filename)
 // === SmplingJobContext ===
 
     //pub extern fn CreateSamplingJobContextCount_c(c_int) callconv(.C) ?*anyopaque;
-void* CreateSamplingJobContext_c() 
+OZZ_CPP_API void* CreateSamplingJobContext_c() 
 {
     ozz::animation::SamplingJob::Context* rv = new ozz::animation::SamplingJob::Context();
     
     return rv;
 }
 
-void* CreateSamplingJobContextCount_c(int count) 
+OZZ_CPP_API void* CreateSamplingJobContextCount_c(int count) 
 {
     ozz::animation::SamplingJob::Context* rv = new ozz::animation::SamplingJob::Context(count);
     
     return rv;
 }
 
-void DestroySamplingJobContext_c(void* context) 
+OZZ_CPP_API void DestroySamplingJobContext_c(void* context) 
 {
     ozz::animation::SamplingJob::Context* self = static_cast<ozz::animation::SamplingJob::Context*>(context);
 
     delete self;
 }
 
-void SamplingJobContext_Resize_c(void* context, int maxSize) 
+OZZ_CPP_API void SamplingJobContext_Resize_c(void* context, int maxSize) 
 {
     ozz::animation::SamplingJob::Context* self = static_cast<ozz::animation::SamplingJob::Context*>(context);
 
     self->Resize(maxSize);
 }
 
-void SamplingJobContext_Invalidate_c(void* context) 
+OZZ_CPP_API void SamplingJobContext_Invalidate_c(void* context) 
 {
     ozz::animation::SamplingJob::Context* self = static_cast<ozz::animation::SamplingJob::Context*>(context);
 
     self->Invalidate();
 }
 
-int SamplingJobContext_MaxSoaTracks_c(void* context)
+OZZ_CPP_API int SamplingJobContext_MaxSoaTracks_c(void* context)
 {
     ozz::animation::SamplingJob::Context* self = static_cast<ozz::animation::SamplingJob::Context*>(context);
 
     return self->max_soa_tracks();
 }
 
-int SamplingJobContext_MaxTracks_c(void* context)
+OZZ_CPP_API int SamplingJobContext_MaxTracks_c(void* context)
 {
     ozz::animation::SamplingJob::Context* self = static_cast<ozz::animation::SamplingJob::Context*>(context);
 
     return self->max_tracks();
 }
 
-bool LocalToModelJob_Run_c(void* context)
+OZZ_CPP_API bool LocalToModelJob_Run_c(void* context)
 {
     ozz::animation::LocalToModelJob* self = static_cast<ozz::animation::LocalToModelJob*>(context);
 
@@ -269,13 +275,13 @@ bool LocalToModelJob_Run_c(void* context)
 
 // Blending job
 
-bool BlendingJob_Validate_c(void* context)
+OZZ_CPP_API bool BlendingJob_Validate_c(void* context)
 {
     ozz::animation::BlendingJob* self = static_cast<ozz::animation::BlendingJob*>(context);
     return self->Validate();
 }
 
-bool BlendingJob_Run_c(void* context)
+OZZ_CPP_API bool BlendingJob_Run_c(void* context)
 {
     ozz::animation::BlendingJob* self = static_cast<ozz::animation::BlendingJob*>(context);
     return self->Run();

lib/packer/src/watcher.cpp

@@ -8,7 +8,7 @@ extern "C" void* createWatchPoint(
     auto* watch = new filewatch::FileWatch<std::string>(
         watchPath,
         [cb, ctx] (const std::string& path, const filewatch::Event change_type) {
-            std::cout <<  event_to_string(change_type) << std::endl;
+            // std::cout <<  event_to_string(change_type) << std::endl;
             cb(path.c_str(), ctx);
         }
     );

lib/spng/build.zig

@@ -4,7 +4,7 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const spng_c = b.addStaticLibrary(
+    const spng_c = b.addSharedLibrary(
         .{
             .optimize = optimize,
             .target = target,
@@ -28,9 +28,10 @@ pub fn build(b: *std.Build) void {
 
     mod.addIncludePath(b.path("spng"));
     mod.addIncludePath(b.path("./"));
-
     mod.linkLibrary(spng_c);
 
+    b.installArtifact(spng_c);
+
     const test_step = b.step("test", "run unit tests for spng");
     const tests = b.addTest(.{
         .target = target,

lib/zphysics/build.zig

@@ -42,7 +42,7 @@ pub fn build(b: *std.Build) void {
     });
     zjolt.addIncludePath(b.path("libs/JoltC"));
 
-    const joltc = b.addStaticLibrary(.{
+    const joltc = b.addSharedLibrary(.{
         .name = "joltc",
         .target = target,
         .optimize = optimize,

lib/zphysics/libs/JoltC/JoltPhysicsC.cpp

@@ -1,3 +1,5 @@
+#define __JPC_API_IMPL 1
+
 #include "JoltPhysicsC.h"
 
 #include <assert.h>

lib/zphysics/libs/JoltC/JoltPhysicsC.h

@@ -11,7 +11,17 @@
 // Const
 //
 //--------------------------------------------------------------------------------------------------
-#define JPC_API // TODO: Define this properly
+
+#ifdef __JPC_API_IMPL
+#ifdef _WIN32
+    #define JPC_API __declspec(dllexport) // TODO: Define this properly
+#else
+    #define JPC_API
+#endif _WIN32
+#else
+    #define JPC_API
+#endif
+
 
 // Always turn on asserts in Debug mode
 #if defined(_DEBUG) || defined(JPH_ENABLE_ASSERTS)

projects/build.zig

@@ -30,6 +30,8 @@ pub fn build(b: *std.Build) void {
         .name = "externGame",
     });
 
+    blbuild.addExtraModule(sampleGameExtern.root_module, "gameExtras");
+
     sampleGameExtern.root_module.addImport("backlog", blbuild.nw_mod);
 
     const installExtern = b.addInstallArtifact(sampleGameExtern, .{
@@ -37,5 +39,5 @@ pub fn build(b: *std.Build) void {
     });
     b.getInstallStep().dependOn(&installExtern.step);
 
-    blbuild.addSDL3Install(b, .ReleaseFast); //.ReleaseFast);
+    blbuild.addDependencyInstalls(b, .ReleaseFast); //.ReleaseFast);
 }

projects/build.zig.zon

@@ -14,13 +14,20 @@
         // engine libraries
         .Backlog = .{ .path = "../" },
 
-        .sdl3_lib = .{ .path = "../lib/sdl3/SDL" },
+
         .SpirvReflect = .{ .path = "../lib/spirv-reflect-zig" },
 
         .gameExtras = .{.path = "../extras/gameExtras"},
         .videoplayer = .{.path = "../extras/videoplayer"},
         .doomplayer = .{.path = "../extras/doomplayer"},
         .bsp = .{.path = "../extras/bsp"},
+
+        .zphysics = .{.path = "../lib/zphysics"},
+        .spng = .{ .path = "../lib/spng" },
+        .ozz = .{ .path = "../lib/ozz" },
+        .sdl3_lib = .{ .path = "../lib/sdl3/SDL" },
+        .miniaudio = .{ .path = "../lib/miniaudio" },
+        .lua = .{ .path = "../lib/lua" },
     },
     .paths = .{
         "",

projects/sampleGame/externGame/externGame.zig

@@ -55,7 +55,6 @@ pub const ExternGameObject = struct {
     pub fn tick(self: *@This(), dt: f64) void {
         _ = dt;
         _ = self;
-
         const rctx = rend.context();
         imgui.utils.structDebugWindow(rctx);