duck-that-quacks/spacefarer
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

camelCase for function names

Browse Source
This commit is contained in:
duck
2025-05-04 17:49:28 +05:00
parent b133a747ae
commit c19120c3fc
8 changed files with 102 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
build.zig
View File

@@ -11,10 +11,10 @@ pub fn build(b: *Build) void {
const target = b.standardTargetOptions(.{}); const target = b.standardTargetOptions(.{});
const optimize = b.standardOptimizeOption(.{}); const optimize = b.standardOptimizeOption(.{});
const exe = step_build_main(b, target, optimize); const exe = stepBuildMain(b, target, optimize);
b.installArtifact(exe); b.installArtifact(exe);
const copy_data = step_copy_data(b, target, optimize); const copy_data = stepCopyData(b, target, optimize);
b.getInstallStep().dependOn(copy_data); b.getInstallStep().dependOn(copy_data);
const run = b.addRunArtifact(exe); const run = b.addRunArtifact(exe);
@@ -34,7 +34,7 @@ pub fn build(b: *Build) void {
check_step.dependOn(&exe.step); check_step.dependOn(&exe.step);
} }
fn step_build_main( fn stepBuildMain(
b: *Build, b: *Build,
target: Build.ResolvedTarget, target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
@@ -46,14 +46,14 @@ fn step_build_main(
.optimize = optimize, .optimize = optimize,
}); });
const sdl_module, const sdl_step = step_sdl_module(b, target, optimize); const sdl_module, const sdl_step = stepSdlModule(b, target, optimize);
exe.root_module.addImport("sdl", sdl_module); exe.root_module.addImport("sdl", sdl_module);
exe.step.dependOn(sdl_step); exe.step.dependOn(sdl_step);
return exe; return exe;
} }
fn step_build_sdl_translator( fn stepBuildSdlTranslator(
b: *Build, b: *Build,
target: Build.ResolvedTarget, target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
@@ -68,12 +68,12 @@ fn step_build_sdl_translator(
return sdl_translator; return sdl_translator;
} }
fn step_translate_sdl( fn stepTranslateSdl(
b: *Build, b: *Build,
target: Build.ResolvedTarget, target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
) struct { *Build.Step, Build.LazyPath } { ) struct { *Build.Step, Build.LazyPath } {
const sdl_translator = step_build_sdl_translator(b, target, optimize); const sdl_translator = stepBuildSdlTranslator(b, target, optimize);
const translate = b.addRunArtifact(sdl_translator); const translate = b.addRunArtifact(sdl_translator);
const sdl_rename = translate.addOutputFileArg("sdl_rename.h"); const sdl_rename = translate.addOutputFileArg("sdl_rename.h");
return .{ return .{
@@ -82,7 +82,7 @@ fn step_translate_sdl(
}; };
} }
fn step_sdl_module( fn stepSdlModule(
b: *Build, b: *Build,
target: Build.ResolvedTarget, target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
@@ -95,7 +95,7 @@ fn step_sdl_module(
}); });
sdl_module.linkSystemLibrary("SDL3", .{}); sdl_module.linkSystemLibrary("SDL3", .{});
const translate_step, const sdl_rename = step_translate_sdl(b, target, optimize); const translate_step, const sdl_rename = stepTranslateSdl(b, target, optimize);
sdl_module.addIncludePath(sdl_rename.dirname()); sdl_module.addIncludePath(sdl_rename.dirname());
return .{ return .{
@@ -104,7 +104,7 @@ fn step_sdl_module(
}; };
} }
fn step_copy_data( fn stepCopyData(
b: *Build, b: *Build,
target: Build.ResolvedTarget, target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,
@@ -118,14 +118,14 @@ fn step_copy_data(
.install_subdir = "data", .install_subdir = "data",
.exclude_extensions = &.{ "vert", "frag" }, .exclude_extensions = &.{ "vert", "frag" },
}); });
const build_shaders = step_build_shaders(b, target, optimize); const build_shaders = stepBuildShaders(b, target, optimize);
copy_data_cmd.step.dependOn(build_shaders); copy_data_cmd.step.dependOn(build_shaders);
return &copy_data_cmd.step; return &copy_data_cmd.step;
} }
fn step_build_shaders( fn stepBuildShaders(
b: *Build, b: *Build,
target: Build.ResolvedTarget, target: Build.ResolvedTarget,
optimize: std.builtin.OptimizeMode, optimize: std.builtin.OptimizeMode,

14
src/game.zig
View File

@@ -16,7 +16,7 @@ pub fn init() GameError!Self {
pub fn run(self: *Self) GameError!void { pub fn run(self: *Self) GameError!void {
self.running = true; self.running = true;
while (true) { while (true) {
try self.process_events(); try self.processEvents();
if (!self.running) { if (!self.running) {
break; break;
} }
@@ -30,19 +30,19 @@ fn update(self: *Self) GameError!void {
} }
fn draw(self: *Self) GameError!void { fn draw(self: *Self) GameError!void {
try self.graphics.begin_draw(); try self.graphics.beginDraw();
try self.graphics.draw_debug(); try self.graphics.drawDebug();
try self.graphics.end_draw(); try self.graphics.endDraw();
} }
fn process_events(self: *Self) GameError!void { fn processEvents(self: *Self) GameError!void {
sdl.PumpEvents(); sdl.PumpEvents();
while (true) { while (true) {
var buffer: [16]sdl.Event = undefined; var buffer: [16]sdl.Event = undefined;
const count: usize = @intCast(sdl.PeepEvents(&buffer, buffer.len, sdl.GETEVENT, sdl.EVENT_FIRST, sdl.EVENT_LAST)); const count: usize = @intCast(sdl.PeepEvents(&buffer, buffer.len, sdl.GETEVENT, sdl.EVENT_FIRST, sdl.EVENT_LAST));
if (count == -1) return GameError.SdlError; if (count == -1) return GameError.SdlError;
for (buffer[0..count]) |event| { for (buffer[0..count]) |event| {
self.process_event(event); self.processEvent(event);
} }
if (count < buffer.len) { if (count < buffer.len) {
break; break;
@@ -51,7 +51,7 @@ fn process_events(self: *Self) GameError!void {
sdl.FlushEvents(sdl.EVENT_FIRST, sdl.EVENT_LAST); sdl.FlushEvents(sdl.EVENT_FIRST, sdl.EVENT_LAST);
} }
fn process_event(self: *Self, event: sdl.Event) void { fn processEvent(self: *Self, event: sdl.Event) void {
switch (event.type) { switch (event.type) {
sdl.EVENT_QUIT => { sdl.EVENT_QUIT => {
self.running = false; self.running = false;

69
src/graph.zig
View File

@@ -70,22 +70,21 @@ pub fn deinit(self: *Self) void {
self.controllers.deinit(self.alloc); self.controllers.deinit(self.alloc);
} }
fn enqueue_system(self: *Self, system: System) !void { fn enqueueSystem(self: *Self, system: System) !void {
errdefer system.deinit(self.alloc); errdefer system.deinit(self.alloc);
try self.system_queue.append(self.alloc, system); try self.system_queue.append(self.alloc, system);
} }
fn run_all_systems(self: *Self) GraphError!void { fn runAllSystems(self: *Self) GraphError!void {
while (self.system_queue.items.len > 0) { while (self.system_queue.pop()) |next_system| {
const next_system = self.system_queue.pop();
defer next_system.deinit(self.alloc); defer next_system.deinit(self.alloc);
try self.run_system(next_system); try self.runSystem(next_system);
} }
} }
/// Does not deallocate the system /// Does not deallocate the system
fn run_system(self: *Self, system: System) GraphError!void { fn runSystem(self: *Self, system: System) GraphError!void {
var buffer: [MAX_SYSTEM_REQUESTS]*anyopaque = undefined; var buffer: [MAX_SYSTEM_REQUESTS]*anyopaque = undefined;
var controller: ?Controller = null; var controller: ?Controller = null;
errdefer if (controller) |*c| c.deinit(); errdefer if (controller) |*c| c.deinit();
@@ -94,10 +93,10 @@ fn run_system(self: *Self, system: System) GraphError!void {
for (system.requested_types) |request| { for (system.requested_types) |request| {
switch (request) { switch (request) {
.resource => |resource| { .resource => |resource| {
buffer[buffer_len] = self.get_anyopaque_resource(resource) orelse return GraphError.MissingResource; buffer[buffer_len] = self.getAnyopaqueResource(resource) orelse return GraphError.MissingResource;
}, },
.controller => { .controller => {
controller = try self.get_controller(); controller = try self.getController();
buffer[buffer_len] = @ptrCast(&controller.?); buffer[buffer_len] = @ptrCast(&controller.?);
}, },
} }
@@ -107,44 +106,44 @@ fn run_system(self: *Self, system: System) GraphError!void {
if (controller) |c| { if (controller) |c| {
defer controller = null; defer controller = null;
try self.free_controller(c); try self.freeController(c);
} }
} }
fn apply_commands(self: *Self, commands: []const Controller.Command) !void { fn applyCommands(self: *Self, commands: []const Controller.Command) !void {
for (commands) |command| { for (commands) |command| {
switch (command) { switch (command) {
.add_resource => |r| try self.add_resource(r), .add_resource => |r| try self.addResource(r),
.queue_system => |s| try self.enqueue_system(s), .queue_system => |s| try self.enqueueSystem(s),
} }
} }
} }
fn get_controller(self: *Self) !Controller { fn getController(self: *Self) !Controller {
if (self.controllers.popOrNull()) |c| { if (self.controllers.pop()) |c| {
return c; return c;
} }
return Controller.create(self.alloc); return Controller.create(self.alloc);
} }
/// Evaluates and clears the controller (even if errors out) /// Evaluates and clears the controller (even if errors out)
fn free_controller(self: *Self, controller: Controller) !void { fn freeController(self: *Self, controller: Controller) !void {
var c = controller; var c = controller;
try self.apply_commands(c.commands()); try self.applyCommands(c.commands());
c.clear(); c.clear();
try self.controllers.append(self.alloc, c); try self.controllers.append(self.alloc, c);
// TODO: Handle controller error state // TODO: Handle controller error state
} }
pub inline fn get_resource(self: *Self, comptime resource: type) ?*resource { pub inline fn getResource(self: *Self, comptime resource: type) ?*resource {
utils.validate_resource(resource); utils.validateResource(resource);
if (get_anyopaque_resource(self, utils.hash_type(resource))) |ptr| { if (getAnyopaqueResource(self, utils.hashType(resource))) |ptr| {
return @alignCast(@ptrCast(ptr)); return @alignCast(@ptrCast(ptr));
} }
return null; return null;
} }
fn get_anyopaque_resource(self: *Self, resource_hash: utils.Hash) ?*anyopaque { fn getAnyopaqueResource(self: *Self, resource_hash: utils.Hash) ?*anyopaque {
if (self.resources.get(resource_hash)) |resource| { if (self.resources.get(resource_hash)) |resource| {
return resource.pointer; return resource.pointer;
} }
@@ -152,7 +151,7 @@ fn get_anyopaque_resource(self: *Self, resource_hash: utils.Hash) ?*anyopaque {
} }
/// Discards any previous resource data, resource is assumed to be allocated with `self.alloc` /// Discards any previous resource data, resource is assumed to be allocated with `self.alloc`
pub inline fn add_resource(self: *Self, resource: Resource) !void { pub inline fn addResource(self: *Self, resource: Resource) !void {
var previous = try self.resources.fetchPut(self.alloc, resource.hash, resource); var previous = try self.resources.fetchPut(self.alloc, resource.hash, resource);
if (previous) |*p| { if (previous) |*p| {
p.value.deinit(self.alloc); p.value.deinit(self.alloc);
@@ -169,35 +168,35 @@ test {
const TestResource = struct { const TestResource = struct {
number: u32, number: u32,
fn add_one(rsc: *@This()) void { fn addOne(rsc: *@This()) void {
rsc.number += 1; rsc.number += 1;
} }
fn add_ten(rsc: *@This()) void { fn addTen(rsc: *@This()) void {
rsc.number += 10; rsc.number += 10;
} }
fn add_eleven(cmd: *Controller) void { fn addEleven(cmd: *Controller) void {
cmd.queue_system(add_ten); cmd.queueSystem(addTen);
cmd.queue_system(add_one); cmd.queuesystem(addOne);
} }
}; };
var graph = try Graph.init(std.testing.allocator); var graph = try Graph.init(std.testing.allocator);
defer graph.deinit(); defer graph.deinit();
var controller = try graph.get_controller(); var controller = try graph.getController();
controller.add_resource(TestResource{ .number = 100 }); controller.addResource(TestResource{ .number = 100 });
controller.queue_system(TestResource.add_one); controller.queueSystem(TestResource.addOne);
controller.queue_system(TestResource.add_one); controller.queueSystem(TestResource.addOne);
controller.queue_system(TestResource.add_ten); controller.queueSystem(TestResource.addTen);
controller.queue_system(TestResource.add_eleven); controller.queueSystem(TestResource.addEleven);
try graph.free_controller(controller); try graph.freeController(controller);
try graph.run_all_systems(); try graph.runAllSystems();
const result = graph.get_resource(TestResource); const result = graph.getResource(TestResource);
try std.testing.expectEqual(result.?.number, 123); try std.testing.expectEqual(result.?.number, 123);
} }

20
src/graph/resource.zig
View File

@@ -56,32 +56,32 @@ pub const Controller = struct {
} }
/// Adds resource to the global storage, discarding any previously existing data /// Adds resource to the global storage, discarding any previously existing data
pub inline fn add_resource(self: *Controller, resource: anytype) void { pub inline fn addResource(self: *Controller, resource: anytype) void {
utils.validate_resource(@TypeOf(resource)); utils.validateResource(@TypeOf(resource));
self.add_anyopaque_resource( self.addAnyopaqueResource(
@ptrCast(&resource), @ptrCast(&resource),
utils.hash_type(@TypeOf(resource)), utils.hashType(@TypeOf(resource)),
@sizeOf(@TypeOf(resource)), @sizeOf(@TypeOf(resource)),
@alignOf(@TypeOf(resource)), @alignOf(@TypeOf(resource)),
) catch |err| self.fail(err); ) catch |err| self.fail(err);
} }
pub fn queue_system(self: *Controller, comptime function: anytype) void { pub fn queueSystem(self: *Controller, comptime function: anytype) void {
utils.validate_system(function); utils.validateSystem(function);
self.queue_system_internal(function) catch |err| self.fail(err); self.queueSystemInternal(function) catch |err| self.fail(err);
} }
fn queue_system_internal(self: *Controller, comptime function: anytype) !void { fn queueSystemInternal(self: *Controller, comptime function: anytype) !void {
var system = try System.from_function(function, self.alloc); var system = try System.fromFunction(function, self.alloc);
errdefer system.deinit(self.alloc); errdefer system.deinit(self.alloc);
try self.command_buffer.append(self.alloc, .{ .queue_system = system }); try self.command_buffer.append(self.alloc, .{ .queue_system = system });
} }
/// `previous_output` is expected to be aligned accordingly /// `previous_output` is expected to be aligned accordingly
fn add_anyopaque_resource( fn addAnyopaqueResource(
self: *Controller, self: *Controller,
resource: *const anyopaque, resource: *const anyopaque,
hash: utils.Hash, hash: utils.Hash,

14
src/graph/system.zig
View File

@@ -13,20 +13,20 @@ pub const Request = union(enum) {
}; };
const Self = @This(); const Self = @This();
pub fn from_function(comptime function: anytype, alloc: std.mem.Allocator) !Self { pub fn fromFunction(comptime function: anytype, alloc: std.mem.Allocator) !Self {
utils.validate_system(function); utils.validateSystem(function);
var requests: [@typeInfo(@TypeOf(function)).Fn.params.len]Request = undefined; var requests: [@typeInfo(@TypeOf(function)).@"fn".params.len]Request = undefined;
inline for (0.., @typeInfo(@TypeOf(function)).Fn.params) |i, param| { inline for (0.., @typeInfo(@TypeOf(function)).@"fn".params) |i, param| {
switch (@typeInfo(param.type.?).Pointer.child) { switch (@typeInfo(param.type.?).pointer.child) {
Controller => requests[i] = .controller, Controller => requests[i] = .controller,
else => |resource_type| requests[i] = .{ .resource = utils.hash_type(resource_type) }, else => |resource_type| requests[i] = .{ .resource = utils.hashType(resource_type) },
} }
} }
return Self{ return Self{
.requested_types = try alloc.dupe(Request, &requests), .requested_types = try alloc.dupe(Request, &requests),
.function_runner = utils.generate_runner(function), .function_runner = utils.generateRunner(function),
}; };
} }

32
src/graph/utils.zig
View File

@@ -5,11 +5,11 @@ const System = @import("system.zig");
pub const Hash = u32; pub const Hash = u32;
const HashAlgorithm = std.crypto.hash.blake2.Blake2s(@bitSizeOf(Hash)); const HashAlgorithm = std.crypto.hash.blake2.Blake2s(@bitSizeOf(Hash));
pub inline fn hash_type(comptime h_type: type) Hash { pub inline fn hashType(comptime h_type: type) Hash {
return hash_string(@typeName(h_type)); return hashString(@typeName(h_type));
} }
pub fn hash_string(comptime name: []const u8) Hash { pub fn hashString(comptime name: []const u8) Hash {
@setEvalBranchQuota(100000); @setEvalBranchQuota(100000);
var output: [@divExact(@bitSizeOf(Hash), 8)]u8 = undefined; var output: [@divExact(@bitSizeOf(Hash), 8)]u8 = undefined;
@@ -21,39 +21,39 @@ pub fn hash_string(comptime name: []const u8) Hash {
); );
} }
pub fn validate_resource(comptime resource_type: type) void { pub fn validateResource(comptime resource_type: type) void {
switch (@typeInfo(resource_type)) { switch (@typeInfo(resource_type)) {
.Struct, .Enum, .Union => return, .@"struct", .@"enum", .@"union" => return,
else => @compileError("Invalid resource type \"" ++ @typeName(resource_type) ++ "\""), else => @compileError("Invalid resource type \"" ++ @typeName(resource_type) ++ "\""),
} }
} }
pub fn validate_system(comptime system: anytype) void { pub fn validateSystem(comptime system: anytype) void {
const info = @typeInfo(@TypeOf(system)); const info = @typeInfo(@TypeOf(system));
if (info != .Fn) @compileError("System can only be a function, got " ++ @typeName(system)); if (info != .@"fn") @compileError("System can only be a function, got " ++ @typeName(system));
if (info.Fn.return_type != void) @compileError("Systems are not allowed to return any value (" ++ @typeName(info.Fn.return_type.?) ++ " returned)"); if (info.@"fn".return_type != void) @compileError("Systems are not allowed to return any value (" ++ @typeName(info.Fn.return_type.?) ++ " returned)");
if (info.Fn.is_var_args) @compileError("System cannot be variadic"); if (info.@"fn".is_var_args) @compileError("System cannot be variadic");
if (info.Fn.is_generic) @compileError("System cannot be generic"); if (info.@"fn".is_generic) @compileError("System cannot be generic");
const controller_requests: usize = 0; const controller_requests: usize = 0;
inline for (info.Fn.params) |param| { inline for (info.@"fn".params) |param| {
if (@typeInfo(param.type.?) != .Pointer) @compileError("Systems can only have pointer parameters"); if (@typeInfo(param.type.?) != .pointer) @compileError("Systems can only have pointer parameters");
switch (@typeInfo(param.type.?).Pointer.child) { switch (@typeInfo(param.type.?).pointer.child) {
Resource.Controller => { Resource.Controller => {
// controller_requests += 1; // controller_requests += 1;
// _ = &controller_requests; // _ = &controller_requests;
}, },
else => |t| validate_resource(t), else => |t| validateResource(t),
} }
} }
if (controller_requests > 1) @compileError("A system cannot request controller more than once"); if (controller_requests > 1) @compileError("A system cannot request controller more than once");
} }
pub fn generate_runner(comptime system: anytype) fn ([]const *anyopaque) void { pub fn generateRunner(comptime system: anytype) fn ([]const *anyopaque) void {
const RunnerImpl = struct { const RunnerImpl = struct {
fn runner(resources: []const *anyopaque) void { fn runner(resources: []const *anyopaque) void {
var args: std.meta.ArgsTuple(@TypeOf(system)) = undefined; var args: std.meta.ArgsTuple(@TypeOf(system)) = undefined;
inline for (0..@typeInfo(@TypeOf(system)).Fn.params.len) |index| { inline for (0..@typeInfo(@TypeOf(system)).@"fn".params.len) |index| {
args[index] = @alignCast(@ptrCast(resources[index])); args[index] = @alignCast(@ptrCast(resources[index]));
} }
@call(.always_inline, system, args); @call(.always_inline, system, args);

28
src/graphics.zig
View File

@@ -52,14 +52,14 @@ pub fn create() GameError!Self {
if (!sdl.ClaimWindowForGPUDevice(device, window)) return GameError.SdlError; if (!sdl.ClaimWindowForGPUDevice(device, window)) return GameError.SdlError;
errdefer sdl.ReleaseWindowFromGPUDevice(device, window); errdefer sdl.ReleaseWindowFromGPUDevice(device, window);
const shader_vert = try load_shader( const shader_vert = try loadShader(
device, device,
"data/shaders/basic.vert", "data/shaders/basic.vert",
sdl.GPU_SHADERSTAGE_VERTEX, sdl.GPU_SHADERSTAGE_VERTEX,
); );
errdefer sdl.ReleaseGPUShader(device, shader_vert); errdefer sdl.ReleaseGPUShader(device, shader_vert);
const shader_frag = try load_shader( const shader_frag = try loadShader(
device, device,
"data/shaders/basic.frag", "data/shaders/basic.frag",
sdl.GPU_SHADERSTAGE_FRAGMENT, sdl.GPU_SHADERSTAGE_FRAGMENT,
@@ -115,10 +115,10 @@ pub fn create() GameError!Self {
var window_height: c_int = 1; var window_height: c_int = 1;
if (!sdl.GetWindowSizeInPixels(window, &window_width, &window_height)) return GameError.SdlError; if (!sdl.GetWindowSizeInPixels(window, &window_width, &window_height)) return GameError.SdlError;
const depth_texture = try create_depth_texture(device, @intCast(window_width), @intCast(window_height)); const depth_texture = try createDepthTexture(device, @intCast(window_width), @intCast(window_height));
errdefer sdl.ReleaseGPUTexture(device, depth_texture); errdefer sdl.ReleaseGPUTexture(device, depth_texture);
const msaa_resolve = try create_texture(device, @intCast(window_width), @intCast(window_height), target_format); const msaa_resolve = try createTexture(device, @intCast(window_width), @intCast(window_height), target_format);
errdefer sdl.ReleaseGPUTexture(device, msaa_resolve); errdefer sdl.ReleaseGPUTexture(device, msaa_resolve);
const pipeline = sdl.CreateGPUGraphicsPipeline(device, &.{ const pipeline = sdl.CreateGPUGraphicsPipeline(device, &.{
@@ -209,15 +209,15 @@ pub fn destroy(self: *Self) void {
sdl.DestroyGPUDevice(self.device); sdl.DestroyGPUDevice(self.device);
} }
pub fn begin_draw(self: *Self) GameError!void { pub fn beginDraw(self: *Self) GameError!void {
self.command_buffer = sdl.AcquireGPUCommandBuffer(self.device) orelse return GameError.SdlError; self.command_buffer = sdl.AcquireGPUCommandBuffer(self.device) orelse return GameError.SdlError;
if (self.to_resize) |new_size| { if (self.to_resize) |new_size| {
try self.reset_textures(new_size[0], new_size[1]); try self.resetTextures(new_size[0], new_size[1]);
self.to_resize = null; self.to_resize = null;
} }
} }
pub fn draw_debug(self: *Self) GameError!void { pub fn drawDebug(self: *Self) GameError!void {
var render_target: ?*sdl.GPUTexture = null; var render_target: ?*sdl.GPUTexture = null;
var width: u32 = 0; var width: u32 = 0;
var height: u32 = 0; var height: u32 = 0;
@@ -250,12 +250,12 @@ pub fn draw_debug(self: *Self) GameError!void {
sdl.EndGPURenderPass(render_pass); sdl.EndGPURenderPass(render_pass);
} }
pub fn end_draw(self: *Self) GameError!void { pub fn endDraw(self: *Self) GameError!void {
defer self.command_buffer = null; defer self.command_buffer = null;
if (!sdl.SubmitGPUCommandBuffer(self.command_buffer)) return GameError.SdlError; if (!sdl.SubmitGPUCommandBuffer(self.command_buffer)) return GameError.SdlError;
} }
fn load_shader(device: *sdl.GPUDevice, path: []const u8, stage: c_uint) GameError!*sdl.GPUShader { fn loadShader(device: *sdl.GPUDevice, path: []const u8, stage: c_uint) GameError!*sdl.GPUShader {
const file = std.fs.cwd().openFile(path, .{}) catch return GameError.OSError; const file = std.fs.cwd().openFile(path, .{}) catch return GameError.OSError;
defer file.close(); defer file.close();
@@ -271,7 +271,7 @@ fn load_shader(device: *sdl.GPUDevice, path: []const u8, stage: c_uint) GameErro
}) orelse return GameError.SdlError; }) orelse return GameError.SdlError;
} }
fn create_depth_texture(device: *sdl.GPUDevice, width: u32, height: u32) GameError!*sdl.GPUTexture { fn createDepthTexture(device: *sdl.GPUDevice, width: u32, height: u32) GameError!*sdl.GPUTexture {
return sdl.CreateGPUTexture(device, &.{ return sdl.CreateGPUTexture(device, &.{
.format = sdl.GPU_TEXTUREFORMAT_D16_UNORM, .format = sdl.GPU_TEXTUREFORMAT_D16_UNORM,
.layer_count_or_depth = 1, .layer_count_or_depth = 1,
@@ -283,7 +283,7 @@ fn create_depth_texture(device: *sdl.GPUDevice, width: u32, height: u32) GameErr
}) orelse return GameError.SdlError; }) orelse return GameError.SdlError;
} }
fn create_texture(device: *sdl.GPUDevice, width: u32, height: u32, format: c_uint) GameError!*sdl.GPUTexture { fn createTexture(device: *sdl.GPUDevice, width: u32, height: u32, format: c_uint) GameError!*sdl.GPUTexture {
return sdl.CreateGPUTexture(device, &.{ return sdl.CreateGPUTexture(device, &.{
.format = format, .format = format,
.layer_count_or_depth = 1, .layer_count_or_depth = 1,
@@ -295,14 +295,14 @@ fn create_texture(device: *sdl.GPUDevice, width: u32, height: u32, format: c_uin
}) orelse return GameError.SdlError; }) orelse return GameError.SdlError;
} }
fn reset_textures(self: *Self, width: u32, height: u32) GameError!void { fn resetTextures(self: *Self, width: u32, height: u32) GameError!void {
sdl.ReleaseGPUTexture(self.device, self.depth_texture); sdl.ReleaseGPUTexture(self.device, self.depth_texture);
self.depth_texture = try create_depth_texture(self.device, width, height); self.depth_texture = try createDepthTexture(self.device, width, height);
const target_format = sdl.SDL_GetGPUSwapchainTextureFormat(self.device, self.window); const target_format = sdl.SDL_GetGPUSwapchainTextureFormat(self.device, self.window);
sdl.ReleaseGPUTexture(self.device, self.msaa_resolve); sdl.ReleaseGPUTexture(self.device, self.msaa_resolve);
self.msaa_resolve = try create_texture(self.device, width, height, target_format); self.msaa_resolve = try createTexture(self.device, width, height, target_format);
} }
pub fn resize(self: *Self, width: u32, height: u32) void { pub fn resize(self: *Self, width: u32, height: u32) void {

4
src/main.zig
View File

@@ -2,14 +2,14 @@ const std = @import("std");
const sdl = @import("sdl"); const sdl = @import("sdl");
const Game = @import("game.zig"); const Game = @import("game.zig");
pub fn run_game() !void { pub fn runGame() !void {
var game = try Game.init(); var game = try Game.init();
defer game.deinit(); defer game.deinit();
try game.run(); try game.run();
} }
pub fn main() !void { pub fn main() !void {
run_game() catch |err| { runGame() catch |err| {
switch (err) { switch (err) {
error.SdlError => { error.SdlError => {
std.debug.print("SDL Error:\n---\n{s}\n---\n", .{sdl.SDL_GetError()}); std.debug.print("SDL Error:\n---\n{s}\n---\n", .{sdl.SDL_GetError()});