mach: rename mach.Engine -> mach.Core

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

src/Core.zig

@@ -0,0 +1,100 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const builtin = @import("builtin");
+const glfw = @import("glfw");
+const gpu = @import("gpu");
+const platform = @import("platform.zig");
+const structs = @import("structs.zig");
+const enums = @import("enums.zig");
+const Timer = @import("Timer.zig");
+
+const Core = @This();
+
+allocator: Allocator,
+
+options: structs.Options,
+
+/// The amount of time (in seconds) that has passed since the last frame was rendered.
+///
+/// For example, if you are animating a cube which should rotate 360 degrees every second,
+/// instead of writing (360.0 / 60.0) and assuming the frame rate is 60hz, write
+/// (360.0 * core.delta_time)
+delta_time: f32 = 0,
+delta_time_ns: u64 = 0,
+timer: Timer,
+
+device: gpu.Device,
+backend_type: gpu.Adapter.BackendType,
+swap_chain: ?gpu.SwapChain,
+swap_chain_format: gpu.Texture.Format,
+
+surface: ?gpu.Surface,
+current_desc: gpu.SwapChain.Descriptor,
+target_desc: gpu.SwapChain.Descriptor,
+
+internal: platform.Type,
+
+pub fn init(allocator: std.mem.Allocator) !Core {
+    var core: Core = undefined;
+    core.allocator = allocator;
+    core.options = structs.Options{};
+    core.timer = try Timer.start();
+
+    core.internal = try platform.Type.init(allocator, &core);
+
+    return core;
+}
+
+/// Set runtime options for application, like title, window size etc.
+///
+/// See mach.Options for details
+pub fn setOptions(core: *Core, options: structs.Options) !void {
+    try core.internal.setOptions(options);
+    core.options = options;
+}
+
+// Signals mach to stop the update loop.
+pub fn setShouldClose(core: *Core, value: bool) void {
+    core.internal.setShouldClose(value);
+}
+
+// Sets seconds to wait for an event with timeout before calling update()
+// again.
+//
+// timeout is in seconds (<= 0.0 disables waiting)
+// - pass std.math.inf(f64) to wait with no timeout
+//
+// update() can be called earlier than timeout if an event happens (key press,
+// mouse motion, etc.)
+//
+// update() can be called a bit later than timeout due to timer precision and
+// process scheduling.
+pub fn setWaitEvent(core: *Core, timeout: f64) void {
+    core.internal.setWaitEvent(timeout);
+}
+
+// Returns the framebuffer size, in subpixel units.
+//
+// e.g. returns 1280x960 on macOS for a window that is 640x480
+pub fn getFramebufferSize(core: *Core) structs.Size {
+    return core.internal.getFramebufferSize();
+}
+
+// Returns the widow size, in pixel units.
+//
+// e.g. returns 1280x960 on macOS for a window that is 640x480
+pub fn getWindowSize(core: *Core) structs.Size {
+    return core.internal.getWindowSize();
+}
+
+pub fn setMouseCursor(core: *Core, cursor: enums.MouseCursor) !void {
+    try core.internal.setMouseCursor(cursor);
+}
+
+pub fn hasEvent(core: *Core) bool {
+    return core.internal.hasEvent();
+}
+
+pub fn pollEvent(core: *Core) ?structs.Event {
+    return core.internal.pollEvent();
+}