100 lines
2.8 KiB
Zig
100 lines
2.8 KiB
Zig
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.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();
|
|
}
|