From c19120c3fcd1118f729327c9897a013d90ecd078 Mon Sep 17 00:00:00 2001 From: duck Date: Sun, 4 May 2025 17:49:28 +0500 Subject: [PATCH] camelCase for function names --- build.zig | 24 +++++++-------- src/game.zig | 14 ++++----- src/graph.zig | 69 +++++++++++++++++++++--------------------- src/graph/resource.zig | 20 ++++++------ src/graph/system.zig | 14 ++++----- src/graph/utils.zig | 32 ++++++++++---------- src/graphics.zig | 28 ++++++++--------- src/main.zig | 4 +-- 8 files changed, 102 insertions(+), 103 deletions(-) diff --git a/build.zig b/build.zig index cf40a58..ab674ba 100644 --- a/build.zig +++ b/build.zig @@ -11,10 +11,10 @@ pub fn build(b: *Build) void { const target = b.standardTargetOptions(.{}); const optimize = b.standardOptimizeOption(.{}); - const exe = step_build_main(b, target, optimize); + const exe = stepBuildMain(b, target, optimize); b.installArtifact(exe); - const copy_data = step_copy_data(b, target, optimize); + const copy_data = stepCopyData(b, target, optimize); b.getInstallStep().dependOn(copy_data); const run = b.addRunArtifact(exe); @@ -34,7 +34,7 @@ pub fn build(b: *Build) void { check_step.dependOn(&exe.step); } -fn step_build_main( +fn stepBuildMain( b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, @@ -46,14 +46,14 @@ fn step_build_main( .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.step.dependOn(sdl_step); return exe; } -fn step_build_sdl_translator( +fn stepBuildSdlTranslator( b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, @@ -68,12 +68,12 @@ fn step_build_sdl_translator( return sdl_translator; } -fn step_translate_sdl( +fn stepTranslateSdl( b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, ) 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 sdl_rename = translate.addOutputFileArg("sdl_rename.h"); return .{ @@ -82,7 +82,7 @@ fn step_translate_sdl( }; } -fn step_sdl_module( +fn stepSdlModule( b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, @@ -95,7 +95,7 @@ fn step_sdl_module( }); 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()); return .{ @@ -104,7 +104,7 @@ fn step_sdl_module( }; } -fn step_copy_data( +fn stepCopyData( b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, @@ -118,14 +118,14 @@ fn step_copy_data( .install_subdir = "data", .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); return ©_data_cmd.step; } -fn step_build_shaders( +fn stepBuildShaders( b: *Build, target: Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, diff --git a/src/game.zig b/src/game.zig index 7af96f8..4a2d299 100644 --- a/src/game.zig +++ b/src/game.zig @@ -16,7 +16,7 @@ pub fn init() GameError!Self { pub fn run(self: *Self) GameError!void { self.running = true; while (true) { - try self.process_events(); + try self.processEvents(); if (!self.running) { break; } @@ -30,19 +30,19 @@ fn update(self: *Self) GameError!void { } fn draw(self: *Self) GameError!void { - try self.graphics.begin_draw(); - try self.graphics.draw_debug(); - try self.graphics.end_draw(); + try self.graphics.beginDraw(); + try self.graphics.drawDebug(); + try self.graphics.endDraw(); } -fn process_events(self: *Self) GameError!void { +fn processEvents(self: *Self) GameError!void { sdl.PumpEvents(); while (true) { var buffer: [16]sdl.Event = undefined; const count: usize = @intCast(sdl.PeepEvents(&buffer, buffer.len, sdl.GETEVENT, sdl.EVENT_FIRST, sdl.EVENT_LAST)); if (count == -1) return GameError.SdlError; for (buffer[0..count]) |event| { - self.process_event(event); + self.processEvent(event); } if (count < buffer.len) { break; @@ -51,7 +51,7 @@ fn process_events(self: *Self) GameError!void { 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) { sdl.EVENT_QUIT => { self.running = false; diff --git a/src/graph.zig b/src/graph.zig index b7e0114..11b4bed 100644 --- a/src/graph.zig +++ b/src/graph.zig @@ -70,22 +70,21 @@ pub fn deinit(self: *Self) void { 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); try self.system_queue.append(self.alloc, system); } -fn run_all_systems(self: *Self) GraphError!void { - while (self.system_queue.items.len > 0) { - const next_system = self.system_queue.pop(); +fn runAllSystems(self: *Self) GraphError!void { + while (self.system_queue.pop()) |next_system| { defer next_system.deinit(self.alloc); - try self.run_system(next_system); + try self.runSystem(next_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 controller: ?Controller = null; errdefer if (controller) |*c| c.deinit(); @@ -94,10 +93,10 @@ fn run_system(self: *Self, system: System) GraphError!void { for (system.requested_types) |request| { switch (request) { .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 = try self.get_controller(); + controller = try self.getController(); buffer[buffer_len] = @ptrCast(&controller.?); }, } @@ -107,44 +106,44 @@ fn run_system(self: *Self, system: System) GraphError!void { if (controller) |c| { 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| { switch (command) { - .add_resource => |r| try self.add_resource(r), - .queue_system => |s| try self.enqueue_system(s), + .add_resource => |r| try self.addResource(r), + .queue_system => |s| try self.enqueueSystem(s), } } } -fn get_controller(self: *Self) !Controller { - if (self.controllers.popOrNull()) |c| { +fn getController(self: *Self) !Controller { + if (self.controllers.pop()) |c| { return c; } return Controller.create(self.alloc); } /// 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; - try self.apply_commands(c.commands()); + try self.applyCommands(c.commands()); c.clear(); try self.controllers.append(self.alloc, c); // TODO: Handle controller error state } -pub inline fn get_resource(self: *Self, comptime resource: type) ?*resource { - utils.validate_resource(resource); - if (get_anyopaque_resource(self, utils.hash_type(resource))) |ptr| { +pub inline fn getResource(self: *Self, comptime resource: type) ?*resource { + utils.validateResource(resource); + if (getAnyopaqueResource(self, utils.hashType(resource))) |ptr| { return @alignCast(@ptrCast(ptr)); } 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| { 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` -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); if (previous) |*p| { p.value.deinit(self.alloc); @@ -169,35 +168,35 @@ test { const TestResource = struct { number: u32, - fn add_one(rsc: *@This()) void { + fn addOne(rsc: *@This()) void { rsc.number += 1; } - fn add_ten(rsc: *@This()) void { + fn addTen(rsc: *@This()) void { rsc.number += 10; } - fn add_eleven(cmd: *Controller) void { - cmd.queue_system(add_ten); - cmd.queue_system(add_one); + fn addEleven(cmd: *Controller) void { + cmd.queueSystem(addTen); + cmd.queuesystem(addOne); } }; var graph = try Graph.init(std.testing.allocator); defer graph.deinit(); - var controller = try graph.get_controller(); - controller.add_resource(TestResource{ .number = 100 }); + var controller = try graph.getController(); + controller.addResource(TestResource{ .number = 100 }); - controller.queue_system(TestResource.add_one); - controller.queue_system(TestResource.add_one); + controller.queueSystem(TestResource.addOne); + 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); } diff --git a/src/graph/resource.zig b/src/graph/resource.zig index 2aa2f54..7fae214 100644 --- a/src/graph/resource.zig +++ b/src/graph/resource.zig @@ -56,32 +56,32 @@ pub const Controller = struct { } /// Adds resource to the global storage, discarding any previously existing data - pub inline fn add_resource(self: *Controller, resource: anytype) void { - utils.validate_resource(@TypeOf(resource)); + pub inline fn addResource(self: *Controller, resource: anytype) void { + utils.validateResource(@TypeOf(resource)); - self.add_anyopaque_resource( + self.addAnyopaqueResource( @ptrCast(&resource), - utils.hash_type(@TypeOf(resource)), + utils.hashType(@TypeOf(resource)), @sizeOf(@TypeOf(resource)), @alignOf(@TypeOf(resource)), ) catch |err| self.fail(err); } - pub fn queue_system(self: *Controller, comptime function: anytype) void { - utils.validate_system(function); + pub fn queueSystem(self: *Controller, comptime function: anytype) void { + 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 { - var system = try System.from_function(function, self.alloc); + fn queueSystemInternal(self: *Controller, comptime function: anytype) !void { + var system = try System.fromFunction(function, self.alloc); errdefer system.deinit(self.alloc); try self.command_buffer.append(self.alloc, .{ .queue_system = system }); } /// `previous_output` is expected to be aligned accordingly - fn add_anyopaque_resource( + fn addAnyopaqueResource( self: *Controller, resource: *const anyopaque, hash: utils.Hash, diff --git a/src/graph/system.zig b/src/graph/system.zig index f3cc5b9..5914e41 100644 --- a/src/graph/system.zig +++ b/src/graph/system.zig @@ -13,20 +13,20 @@ pub const Request = union(enum) { }; const Self = @This(); -pub fn from_function(comptime function: anytype, alloc: std.mem.Allocator) !Self { - utils.validate_system(function); +pub fn fromFunction(comptime function: anytype, alloc: std.mem.Allocator) !Self { + utils.validateSystem(function); - var requests: [@typeInfo(@TypeOf(function)).Fn.params.len]Request = undefined; - inline for (0.., @typeInfo(@TypeOf(function)).Fn.params) |i, param| { - switch (@typeInfo(param.type.?).Pointer.child) { + var requests: [@typeInfo(@TypeOf(function)).@"fn".params.len]Request = undefined; + inline for (0.., @typeInfo(@TypeOf(function)).@"fn".params) |i, param| { + switch (@typeInfo(param.type.?).pointer.child) { 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{ .requested_types = try alloc.dupe(Request, &requests), - .function_runner = utils.generate_runner(function), + .function_runner = utils.generateRunner(function), }; } diff --git a/src/graph/utils.zig b/src/graph/utils.zig index 271bc9f..688bb8c 100644 --- a/src/graph/utils.zig +++ b/src/graph/utils.zig @@ -5,11 +5,11 @@ const System = @import("system.zig"); pub const Hash = u32; const HashAlgorithm = std.crypto.hash.blake2.Blake2s(@bitSizeOf(Hash)); -pub inline fn hash_type(comptime h_type: type) Hash { - return hash_string(@typeName(h_type)); +pub inline fn hashType(comptime h_type: type) Hash { + return hashString(@typeName(h_type)); } -pub fn hash_string(comptime name: []const u8) Hash { +pub fn hashString(comptime name: []const u8) Hash { @setEvalBranchQuota(100000); 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)) { - .Struct, .Enum, .Union => return, + .@"struct", .@"enum", .@"union" => return, 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)); - 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.is_var_args) @compileError("System cannot be variadic"); - if (info.Fn.is_generic) @compileError("System cannot be generic"); + 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".is_var_args) @compileError("System cannot be variadic"); + if (info.@"fn".is_generic) @compileError("System cannot be generic"); const controller_requests: usize = 0; - inline for (info.Fn.params) |param| { - if (@typeInfo(param.type.?) != .Pointer) @compileError("Systems can only have pointer parameters"); - switch (@typeInfo(param.type.?).Pointer.child) { + inline for (info.@"fn".params) |param| { + if (@typeInfo(param.type.?) != .pointer) @compileError("Systems can only have pointer parameters"); + switch (@typeInfo(param.type.?).pointer.child) { Resource.Controller => { // controller_requests += 1; // _ = &controller_requests; }, - else => |t| validate_resource(t), + else => |t| validateResource(t), } } 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 { fn runner(resources: []const *anyopaque) void { 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])); } @call(.always_inline, system, args); diff --git a/src/graphics.zig b/src/graphics.zig index 630bacb..7484d05 100644 --- a/src/graphics.zig +++ b/src/graphics.zig @@ -52,14 +52,14 @@ pub fn create() GameError!Self { if (!sdl.ClaimWindowForGPUDevice(device, window)) return GameError.SdlError; errdefer sdl.ReleaseWindowFromGPUDevice(device, window); - const shader_vert = try load_shader( + const shader_vert = try loadShader( device, "data/shaders/basic.vert", sdl.GPU_SHADERSTAGE_VERTEX, ); errdefer sdl.ReleaseGPUShader(device, shader_vert); - const shader_frag = try load_shader( + const shader_frag = try loadShader( device, "data/shaders/basic.frag", sdl.GPU_SHADERSTAGE_FRAGMENT, @@ -115,10 +115,10 @@ pub fn create() GameError!Self { var window_height: c_int = 1; 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); - 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); const pipeline = sdl.CreateGPUGraphicsPipeline(device, &.{ @@ -209,15 +209,15 @@ pub fn destroy(self: *Self) void { 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; 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; } } -pub fn draw_debug(self: *Self) GameError!void { +pub fn drawDebug(self: *Self) GameError!void { var render_target: ?*sdl.GPUTexture = null; var width: u32 = 0; var height: u32 = 0; @@ -250,12 +250,12 @@ pub fn draw_debug(self: *Self) GameError!void { sdl.EndGPURenderPass(render_pass); } -pub fn end_draw(self: *Self) GameError!void { +pub fn endDraw(self: *Self) GameError!void { defer self.command_buffer = null; 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; defer file.close(); @@ -271,7 +271,7 @@ fn load_shader(device: *sdl.GPUDevice, path: []const u8, stage: c_uint) GameErro }) 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, &.{ .format = sdl.GPU_TEXTUREFORMAT_D16_UNORM, .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; } -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, &.{ .format = format, .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; } -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); - 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); 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 { diff --git a/src/main.zig b/src/main.zig index db89d1f..00fa81a 100644 --- a/src/main.zig +++ b/src/main.zig @@ -2,14 +2,14 @@ const std = @import("std"); const sdl = @import("sdl"); const Game = @import("game.zig"); -pub fn run_game() !void { +pub fn runGame() !void { var game = try Game.init(); defer game.deinit(); try game.run(); } pub fn main() !void { - run_game() catch |err| { + runGame() catch |err| { switch (err) { error.SdlError => { std.debug.print("SDL Error:\n---\n{s}\n---\n", .{sdl.SDL_GetError()});