renati/voxel-game
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Switch to sokol

Browse Source
This commit is contained in:
Szymon Nowakowski
2025-11-08 17:43:11 +01:00
parent bf2c03b8d5
commit 1a3d52079b
51 changed files with 34 additions and 16843 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/Log.zig
View File

@@ -1,11 +0,0 @@
const std = @import("std");
level: std.log.Level,
message: []const u8,
pub fn init(level: std.log.Level, message: []const u8) @This() {
return .{
.level = level,
.message = message,
};
}

110
src/game.zig
View File

@@ -1,110 +0,0 @@
const std = @import("std");
const zglfw = @import("zglfw");
const zgui = @import("zgui");
const main = @import("main.zig");
var show_console: bool = false;
var show_demo_window: bool = false;
pub fn init() void {}
pub fn update(dt: f32) void {
_ = dt;
if (show_console) {
showConsole();
}
if (show_demo_window) {
zgui.showDemoWindow(&show_demo_window);
}
}
pub fn charCallback(
_: *zglfw.Window,
codepoint: u32,
) callconv(.C) void {
_ = codepoint;
}
pub fn cursorPosCallback(
_: *zglfw.Window,
xpos: f64,
ypos: f64,
) callconv(.C) void {
_ = xpos;
_ = ypos;
}
pub fn keyCallback(
_: *zglfw.Window,
key: zglfw.Key,
scancode: c_int,
action: zglfw.Action,
mods: zglfw.Mods,
) callconv(.C) void {
_ = scancode;
const no_mods = @as(c_int, @bitCast(mods)) == 0;
if (key == .grave_accent and action == .press and no_mods) {
show_console = !show_console;
}
if (key == .F1 and action == .press and no_mods) {
show_demo_window = true;
}
}
pub fn mouseButtonCallback(
_: *zglfw.Window,
button: zglfw.MouseButton,
action: zglfw.Action,
mods: zglfw.Mods,
) callconv(.C) void {
_ = button;
_ = action;
_ = mods;
}
pub fn scrollCallback(
_: *zglfw.Window,
xoffset: f64,
yoffset: f64,
) callconv(.C) void {
_ = xoffset;
_ = yoffset;
}
pub fn deinit() void {}
fn showConsole() void {
const display_size = zgui.io.getDisplaySize();
zgui.setNextWindowPos(.{
.x = 0,
.y = 0,
});
zgui.setNextWindowSize(.{
.w = display_size[0],
.h = main.min_window_height,
.cond = .once,
});
if (zgui.begin("Console", .{ .flags = .{
.no_title_bar = true,
.no_resize = true,
.no_move = true,
.no_collapse = true,
} })) {
for (main.logs.items) |log| {
zgui.textUnformattedColored(switch (log.level) {
.err => .{ 1, 0, 0, 1 },
.warn => .{ 1, 1, 0, 1 },
.info => .{ 1, 1, 1, 1 },
.debug => .{ 0.5, 0.5, 0.5, 1 },
}, log.message);
}
}
zgui.end();
}

208
src/main.zig
View File

@@ -1,202 +1,8 @@
const std = @import("std");
const sokol = @import("sokol");
const slog = sokol.log;
const sg = sokol.gfx;
const sapp = sokol.app;
const sglue = sokol.glue;
const simgui = sokol.imgui;
const zaudio = @import("zaudio");
const zglfw = @import("zglfw");
const zgpu = @import("zgpu");
const zgui = @import("zgui");
const ztracy = @import("ztracy");
const game = @import("game.zig");
const Log = @import("Log.zig");
pub const min_framerate = 30.0;
pub const min_frametime = 1.0 / min_framerate;
pub const min_window_height = 360;
pub const min_window_width = 640;
pub const temp_allocator_capacity = 16 * 1024 * 1024;
pub const window_title = "voxel-game";
pub var allocator: std.mem.Allocator = undefined;
pub var audio_engine: *zaudio.Engine = undefined;
pub var gctx: *zgpu.GraphicsContext = undefined;
pub var logs: std.ArrayListUnmanaged(Log) = undefined;
pub var temp_allocator: std.mem.Allocator = undefined;
pub var window: *zglfw.Window = undefined;
pub const std_options: std.Options = .{
.logFn = logFn,
};
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
var ta = ztracy.TracyAllocator.init(gpa.allocator());
var fba = std.heap.FixedBufferAllocator.init(&struct {
pub var buffer: [temp_allocator_capacity]u8 = undefined;
}.buffer);
allocator = ta.allocator();
temp_allocator = fba.threadSafeAllocator();
defer {
for (logs.items) |log| {
allocator.free(log.message);
}
logs.deinit(allocator);
}
// --- zaudio --------------------------------------------------------------
const zone_init_zaudio = ztracy.ZoneN(@src(), "Init zaudio");
zaudio.init(allocator);
defer zaudio.deinit();
audio_engine = try zaudio.Engine.create(null);
defer audio_engine.destroy();
zone_init_zaudio.End();
// --- zglfw ---------------------------------------------------------------
const zone_init_zglfw = ztracy.ZoneN(@src(), "Init zglfw");
try zglfw.init();
defer zglfw.terminate();
const monitor = zglfw.getPrimaryMonitor() orelse return error.PrimaryMonitorNotFound;
const video_mode = try monitor.getVideoMode();
zglfw.windowHint(.client_api, .no_api);
window = try zglfw.Window.create(video_mode.width, video_mode.height, window_title, monitor);
window.setSizeLimits(
min_window_width,
min_window_height,
-1,
-1,
);
defer window.destroy();
std.debug.assert(zglfw.setCharCallback(window, game.charCallback) == null);
std.debug.assert(zglfw.setCursorPosCallback(window, game.cursorPosCallback) == null);
std.debug.assert(zglfw.setKeyCallback(window, game.keyCallback) == null);
std.debug.assert(zglfw.setMouseButtonCallback(window, game.mouseButtonCallback) == null);
std.debug.assert(zglfw.setScrollCallback(window, game.scrollCallback) == null);
zone_init_zglfw.End();
// --- zgpu ----------------------------------------------------------------
const zone_init_zgpu = ztracy.ZoneN(@src(), "Init zgpu");
gctx = try zgpu.GraphicsContext.create(allocator, .{
.window = window,
.fn_getTime = @ptrCast(&zglfw.getTime),
.fn_getFramebufferSize = @ptrCast(&zglfw.Window.getFramebufferSize),
.fn_getWin32Window = @ptrCast(&zglfw.getWin32Window),
.fn_getX11Display = @ptrCast(&zglfw.getX11Display),
.fn_getX11Window = @ptrCast(&zglfw.getX11Window),
.fn_getWaylandDisplay = @ptrCast(&zglfw.getWaylandDisplay),
.fn_getWaylandSurface = @ptrCast(&zglfw.getWaylandWindow),
.fn_getCocoaWindow = @ptrCast(&zglfw.getCocoaWindow),
}, .{});
defer gctx.destroy(allocator);
zone_init_zgpu.End();
// --- zgui ----------------------------------------------------------------
const zone_init_zgui = ztracy.ZoneN(@src(), "Init zgui");
zgui.init(allocator);
defer zgui.deinit();
zgui.backend.init(
window,
gctx.device,
@intFromEnum(zgpu.GraphicsContext.swapchain_format),
@intFromEnum(zgpu.wgpu.TextureFormat.undef),
);
defer zgui.backend.deinit();
zgui.io.setIniFilename(null);
zone_init_zgui.End();
// --- game ----------------------------------------------------------------
const zone_init_game = ztracy.ZoneN(@src(), "Init game");
game.init();
defer game.deinit();
zone_init_game.End();
// --- main loop -----------------------------------------------------------
const zone_main_loop = ztracy.ZoneN(@src(), "Main loop");
var t2 = zglfw.getTime();
while (!window.shouldClose()) {
ztracy.FrameMark();
fba.reset();
const t1 = zglfw.getTime();
const dt: f32 = @floatCast(@max(t2 - t1, min_frametime));
t2 = t1;
zglfw.pollEvents();
zgui.backend.newFrame(
gctx.swapchain_descriptor.width,
gctx.swapchain_descriptor.height,
);
game.update(dt);
const swapchain_texture_view = gctx.swapchain.getCurrentTextureView();
defer swapchain_texture_view.release();
const commands = commands: {
const encoder = gctx.device.createCommandEncoder(null);
defer encoder.release();
{
const pass = zgpu.beginRenderPassSimple(
encoder,
.load,
swapchain_texture_view,
null,
null,
null,
);
defer zgpu.endReleasePass(pass);
zgui.backend.draw(pass);
}
break :commands encoder.finish(null);
};
defer commands.release();
gctx.submit(&.{commands});
_ = gctx.present();
}
zone_main_loop.End();
}
fn logFn(
comptime level: std.log.Level,
comptime _: @Type(.enum_literal),
comptime fmt: []const u8,
args: anytype,
) void {
const message = std.fmt.allocPrint(allocator, fmt, args) catch return;
logs.append(allocator, Log.init(level, message)) catch {
allocator.free(message);
return;
};
}
pub fn main() void {}