libmach: update API, exposes init, update, and deinit functions

src/bindings.zig

@@ -1,52 +0,0 @@
-const std = @import("std");
-const gpu = @import("gpu");
-const Core = @import("Core.zig");
-const libmach = @import("platform/libmach.zig");
-const native = @import("platform/native.zig");
-
-// Current Limitations:
-// 1. Currently, ecs seems to be using some weird compile-time type trickery, so I'm not exactly sure how
-// `engine` should be integrated into the C API
-// 2. Core might need to expose more state so more API functions can be exposed (for example, the WebGPU API)
-// 3. Be very careful about arguments, types, memory, etc - any mismatch will result in undefined behavior
-
-pub const App = libmach;
-
-pub export fn mach_core_set_init(core_init: libmach.CoreCallback) void {
-    std.debug.print("mach core set init\n", .{});
-    libmach.core_callbacks.core_init = core_init;
-}
-
-pub export fn mach_core_set_deinit(core_deinit: libmach.CoreCallback) void {
-    std.debug.print("mach core set deinit\n", .{});
-    libmach.core_callbacks.core_deinit = core_deinit;
-}
-
-pub export fn mach_core_set_update(core_update: libmach.CoreCallback) void {
-    std.debug.print("mach core set update\n", .{});
-    libmach.core_callbacks.core_update = core_update;
-}
-
-pub export fn mach_run() void {
-    if (libmach.core_callbacks.core_init == null) {
-        std.debug.print("Did not provide a core_init callback\n", .{});
-        return;
-    }
-    if (libmach.core_callbacks.core_update == null) {
-        std.debug.print("Did not provide a core_update callback\n", .{});
-        return;
-    }
-    if (libmach.core_callbacks.core_deinit == null) {
-        std.debug.print("Did not provide a core_deinit callback\n", .{});
-        return;
-    }
-    native.main() catch unreachable;
-}
-
-pub export fn core_set_should_close(core: *Core) void {
-    core.*.setShouldClose(true);
-}
-
-pub export fn core_delta_time(core: *Core) f32 {
-    return core.*.delta_time;
-}

src/platform/libmach.zig

@@ -2,34 +2,106 @@ const std = @import("std");
 const Core = @import("../Core.zig");
 const gpu = @import("gpu");
 const ecs = @import("ecs");
+const glfw = @import("glfw");
 
 pub const App = @This();
 
-// Zig says that *App has a size of 0 bits, and it won't compile if
-// pub const core_callback_t = fn (*App, *Core) callconv(.C) void;
-// What is *App needed for anyway?
-pub const CoreCallback = fn (*Core) callconv(.C) void;
+// Dummy init, deinit, and update functions
+pub fn init(_: *App, _: *Core) !void { }
 
-pub const CoreCallbacks = struct {
-    core_init: ?CoreCallback,
-    core_update: ?CoreCallback,
-    core_deinit: ?CoreCallback,
-};
+pub fn deinit(_: *App, _: *Core) void { }
 
-pub var core_callbacks = CoreCallbacks {
-    .core_init = null,
-    .core_update = null,
-    .core_deinit = null,
-};
+pub fn update(_: *App, _: *Core) !void { }
 
-pub fn init(_: *App, core: *Core) !void {
-    core_callbacks.core_init.?(core);
+// Current Limitations:
+// 1. Currently, ecs seems to be using some weird compile-time type trickery, so I'm not exactly sure how
+// `engine` should be integrated into the C API
+// 2. Core might need to expose more state so more API functions can be exposed (for example, the WebGPU API)
+// 3. Be very careful about arguments, types, memory, etc - any mismatch will result in undefined behavior
+
+pub export fn mach_set_should_close(core: *Core) void {
+    core.setShouldClose(true);
 }
 
-pub fn deinit(_: *App, core: *Core) void {
-    core_callbacks.core_deinit.?(core);
+pub export fn mach_delta_time(core: *Core) f32 {
+    return core.delta_time;
 }
 
-pub fn update(_: *App, core: *Core) !void {
-    core_callbacks.core_update.?(core);
+var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+const allocator = gpa.allocator();
+
+// Initializes and returns Mach's core structure
+// Uses an optional type so it is valid to return 0 (on an error)
+// TODO: come up with a better error reporting system
+pub export fn mach_init_core() ?*Core {
+    const core: *Core = allocator.create(Core) catch {
+        return @intToPtr(?*Core, 0); // on error, return null pointer
+    };
+    core.* = Core.init(allocator) catch {
+        return @intToPtr(?*Core, 0); // on error, return null pointer
+    };
+
+    // // Glfw specific: initialize the user pointer used in callbacks
+    core.*.internal.initCallback();
+
+    return core;
+}
+
+// Deinitializes mach core structure
+pub export fn mach_deinit(core: *Core) void {
+    core.internal.deinit();
+    allocator.destroy(core);
+}
+
+pub export fn mach_window_should_close(core: *Core) bool {
+    return core.internal.window.shouldClose();
+}
+
+pub const CoreCallback = fn (*Core, u32, u32) callconv(.C) void;
+
+// Adapted from native.zig
+pub export fn mach_update(core: *Core, resize_fn: ?CoreCallback) i32 {
+    if (core.internal.wait_event_timeout > 0.0) {
+        if (core.internal.wait_event_timeout == std.math.inf(f64)) {
+            // Wait for an event
+            glfw.waitEvents() catch {
+                return 0;
+            };
+        } else {
+            // Wait for an event with a timeout
+            glfw.waitEventsTimeout(core.internal.wait_event_timeout) catch {
+                return 0;
+            };
+        }
+    } else {
+        // Don't wait for events
+        glfw.pollEvents() catch {
+            return 0;
+        };
+    }
+
+    core.delta_time_ns = core.timer.lapPrecise();
+    core.delta_time = @intToFloat(f32, core.delta_time_ns) / @intToFloat(f32, std.time.ns_per_s);
+
+    var framebuffer_size = core.getFramebufferSize();
+    core.target_desc.width = framebuffer_size.width;
+    core.target_desc.height = framebuffer_size.height;
+
+    if (core.swap_chain == null or !core.current_desc.equal(&core.target_desc)) {
+        const use_legacy_api = core.surface == null;
+        if (!use_legacy_api) {
+            core.swap_chain = core.device.nativeCreateSwapChain(core.surface, &core.target_desc);
+        } else core.swap_chain.?.configure(
+            core.swap_chain_format,
+            .{ .render_attachment = true },
+            core.target_desc.width,
+            core.target_desc.height,
+        );
+
+        if (resize_fn != null) {
+            resize_fn.?(core, core.target_desc.width, core.target_desc.height);
+        }
+        core.current_desc = core.target_desc;
+    }
+    return 1;
 }

src/platform/native.zig

@@ -222,7 +222,7 @@ pub const Platform = struct {
         platform.events.append(node);
     }
 
-    fn initCallback(platform: *Platform) void {
+    pub fn initCallback(platform: *Platform) void {
         platform.user_ptr = UserPtr{ .platform = platform };
 
         platform.window.setUserPointer(&platform.user_ptr);