mach: introduce cross platform Timer abstraction

This Timer uses std.time.Timer as backing timer in native platforms, and
will use custom timers for special platforms (wasm, android?, ios?).

Unlike std.time.Timer, its primary API is focused on floats. Also meant
to provides some convenient functions alongside base ones.

Follows std.time.Timer API, but methods by default return f32 i.e
non-precise variant with precise variants available returning u64.

src/Engine.zig

@@ -5,6 +5,7 @@ const gpu = @import("gpu");
 const App = @import("app");
 const structs = @import("structs.zig");
 const enums = @import("enums.zig");
+const Timer = @import("Timer.zig");
 
 const Engine = @This();
 
@@ -23,9 +24,9 @@ options: structs.Options,
 /// 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 * engine.delta_time)
-delta_time: f64 = 0,
+delta_time: f32 = 0,
 delta_time_ns: u64 = 0,
-timer: std.time.Timer,
+timer: Timer,
 
 pub const Core = struct {
     internal: GetCoreInternalType(),
@@ -64,7 +65,7 @@ pub fn init(allocator: std.mem.Allocator, options: structs.Options) !Engine {
     var engine = Engine{
         .allocator = allocator,
         .options = options,
-        .timer = try std.time.Timer.start(),
+        .timer = try Timer.start(),
         .core = undefined,
         .gpu_driver = undefined,
     };

src/Timer.zig

@@ -0,0 +1,41 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const Timer = @This();
+
+backing_timer: BackingTimerType = undefined,
+
+// TODO: verify declarations and its signatures
+const BackingTimerType = if (builtin.cpu.arch == .wasm32) void else std.time.Timer;
+
+/// Initialize the timer.
+pub fn start() !Timer {
+    return Timer{
+        .backing_timer = try BackingTimerType.start(),
+    };
+}
+
+/// Reads the timer value since start or the last reset in nanoseconds.
+pub fn readPrecise(timer: *Timer) u64 {
+    return timer.backing_timer.read();
+}
+
+/// Reads the timer value since start or the last reset in seconds.
+pub fn read(timer: *Timer) f32 {
+    return @intToFloat(f32, timer.readPrecise()) / @intToFloat(f32, std.time.ns_per_s);
+}
+
+/// Resets the timer value to 0/now.
+pub fn reset(timer: *Timer) void {
+    timer.backing_timer.reset();
+}
+
+/// Returns the current value of the timer in nanoseconds, then resets it.
+pub fn lapPrecise(timer: *Timer) u64 {
+    return timer.backing_timer.lap();
+}
+
+/// Returns the current value of the timer in seconds, then resets it.
+pub fn lap(timer: *Timer) f32 {
+    return @intToFloat(f32, timer.lapPrecise()) / @intToFloat(f32, std.time.ns_per_s);
+}

src/main.zig

@@ -1,3 +1,4 @@
 pub usingnamespace @import("structs.zig");
 pub usingnamespace @import("enums.zig");
 pub const Engine = @import("Engine.zig");
+pub const Timer = @import("Timer.zig");

src/native.zig

@@ -387,8 +387,8 @@ pub fn main() !void {
     while (!window.shouldClose()) {
         try glfw.pollEvents();
 
-        engine.delta_time_ns = engine.timer.lap();
-        engine.delta_time = @intToFloat(f64, engine.delta_time_ns) / @intToFloat(f64, std.time.ns_per_s);
+        engine.delta_time_ns = engine.timer.lapPrecise();
+        engine.delta_time = @intToFloat(f32, engine.delta_time_ns) / @intToFloat(f32, std.time.ns_per_s);
 
         var framebuffer_size = try window.getFramebufferSize();
         engine.gpu_driver.target_desc.width = framebuffer_size.width;