diff --git a/build.zig b/build.zig index fbddd91..cf40a58 100644 --- a/build.zig +++ b/build.zig @@ -1,4 +1,5 @@ const std = @import("std"); +const Build = std.Build; /// Paths specified here are compiled to SPIR-V instead of being copied over const SHADERS: []const []const u8 = &.{ @@ -6,19 +7,110 @@ const SHADERS: []const []const u8 = &.{ "data/shaders/basic.frag", }; -pub fn build(b: *std.Build) void { +pub fn build(b: *Build) void { const target = b.standardTargetOptions(.{}); const optimize = b.standardOptimizeOption(.{}); + const exe = step_build_main(b, target, optimize); + b.installArtifact(exe); + + const copy_data = step_copy_data(b, target, optimize); + b.getInstallStep().dependOn(copy_data); + + const run = b.addRunArtifact(exe); + run.step.dependOn(b.getInstallStep()); + + // Why is this not the default behavoir? + run.setCwd(b.path(std.fs.path.relative(b.allocator, b.build_root.path.?, b.exe_dir) catch unreachable)); + + if (b.args) |args| { + run.addArgs(args); + } + + const run_step = b.step("run", "Run the app"); + run_step.dependOn(&run.step); + + const check_step = b.step("check", "Check for build errors"); + check_step.dependOn(&exe.step); +} + +fn step_build_main( + b: *Build, + target: Build.ResolvedTarget, + optimize: std.builtin.OptimizeMode, +) *Build.Step.Compile { const exe = b.addExecutable(.{ .name = "spacefarer", .root_source_file = b.path("src/main.zig"), .target = target, .optimize = optimize, }); - b.installArtifact(exe); - exe.linkLibC(); - exe.linkSystemLibrary("SDL3"); + + const sdl_module, const sdl_step = step_sdl_module(b, target, optimize); + exe.root_module.addImport("sdl", sdl_module); + exe.step.dependOn(sdl_step); + + return exe; +} + +fn step_build_sdl_translator( + b: *Build, + target: Build.ResolvedTarget, + optimize: std.builtin.OptimizeMode, +) *Build.Step.Compile { + const sdl_translator = b.addExecutable(.{ + .name = "sdl_header_translator", + .root_source_file = b.path("utils/sdl_translator.zig"), + .target = target, + .optimize = optimize, + }); + sdl_translator.linkSystemLibrary("SDL3"); + return sdl_translator; +} + +fn step_translate_sdl( + 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 translate = b.addRunArtifact(sdl_translator); + const sdl_rename = translate.addOutputFileArg("sdl_rename.h"); + return .{ + &translate.step, + sdl_rename, + }; +} + +fn step_sdl_module( + b: *Build, + target: Build.ResolvedTarget, + optimize: std.builtin.OptimizeMode, +) struct { *Build.Module, *Build.Step } { + const sdl_module = b.addModule("sdl", .{ + .root_source_file = b.path("lib/sdl.zig"), + .link_libc = true, + .target = target, + .optimize = optimize, + }); + sdl_module.linkSystemLibrary("SDL3", .{}); + + const translate_step, const sdl_rename = step_translate_sdl(b, target, optimize); + sdl_module.addIncludePath(sdl_rename.dirname()); + + return .{ + sdl_module, + translate_step, + }; +} + +fn step_copy_data( + b: *Build, + target: Build.ResolvedTarget, + optimize: std.builtin.OptimizeMode, +) *Build.Step { + _ = ⌖ + _ = &optimize; const copy_data_cmd = b.addInstallDirectory(.{ .source_dir = b.path("data"), @@ -26,8 +118,21 @@ pub fn build(b: *std.Build) void { .install_subdir = "data", .exclude_extensions = &.{ "vert", "frag" }, }); - b.getInstallStep().dependOn(©_data_cmd.step); + const build_shaders = step_build_shaders(b, target, optimize); + copy_data_cmd.step.dependOn(build_shaders); + + return ©_data_cmd.step; +} + +fn step_build_shaders( + b: *Build, + target: Build.ResolvedTarget, + optimize: std.builtin.OptimizeMode, +) *Build.Step { + _ = ⌖ + + const step = b.step("shaders", "Build all shaders with `glslc`"); for (SHADERS) |shader_path| { const glslc = b.addSystemCommand(&.{"glslc"}); if (optimize != .Debug) { @@ -45,16 +150,7 @@ pub fn build(b: *std.Build) void { glslc.addFileArg(b.path(shader_path)); glslc.addArg("-o"); const shader_artifact = glslc.addOutputFileArg(std.fs.path.basename(shader_path)); - b.getInstallStep().dependOn(&b.addInstallFileWithDir(shader_artifact, .bin, shader_path).step); + step.dependOn(&b.addInstallFileWithDir(shader_artifact, .bin, shader_path).step); } - - const run_cmd = b.addRunArtifact(exe); - run_cmd.setCwd(b.path(std.fs.path.relative(b.allocator, b.build_root.path.?, b.exe_dir) catch unreachable)); - run_cmd.step.dependOn(b.getInstallStep()); - if (b.args) |args| { - run_cmd.addArgs(args); - } - - const run_step = b.step("run", "Run the app"); - run_step.dependOn(&run_cmd.step); + return step; } diff --git a/build.zig.zon b/build.zig.zon index 6288439..9a6cca5 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -1,11 +1,15 @@ .{ - .name = "spacefarer", + .name = .spacefarer, .version = "0.0.0", + .fingerprint = 0x946ddccb5911fb15, + .minimum_zig_version = "0.14.0", .dependencies = .{}, .paths = .{ "build.zig", "build.zig.zon", "src", + "lib", + "utils", "data", }, } diff --git a/src/sdl.zig b/lib/sdl.zig similarity index 67% rename from src/sdl.zig rename to lib/sdl.zig index 09e95f1..0b1a51b 100644 --- a/src/sdl.zig +++ b/lib/sdl.zig @@ -1,3 +1,4 @@ pub usingnamespace @cImport({ @cInclude("SDL3/SDL.h"); + @cInclude("sdl_rename.h"); }); diff --git a/src/game.zig b/src/game.zig index 04fd65f..7af96f8 100644 --- a/src/game.zig +++ b/src/game.zig @@ -1,5 +1,5 @@ const std = @import("std"); -const sdl = @import("sdl.zig"); +const sdl = @import("sdl"); const Graphics = @import("graphics.zig"); graphics: Graphics, @@ -36,10 +36,10 @@ fn draw(self: *Self) GameError!void { } fn process_events(self: *Self) GameError!void { - sdl.SDL_PumpEvents(); + sdl.PumpEvents(); while (true) { - var buffer: [16]sdl.SDL_Event = undefined; - const count: usize = @intCast(sdl.SDL_PeepEvents(&buffer, buffer.len, sdl.SDL_GETEVENT, sdl.SDL_EVENT_FIRST, sdl.SDL_EVENT_LAST)); + 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); @@ -48,16 +48,16 @@ fn process_events(self: *Self) GameError!void { break; } } - sdl.SDL_FlushEvents(sdl.SDL_EVENT_FIRST, sdl.SDL_EVENT_LAST); + sdl.FlushEvents(sdl.EVENT_FIRST, sdl.EVENT_LAST); } -fn process_event(self: *Self, event: sdl.SDL_Event) void { +fn process_event(self: *Self, event: sdl.Event) void { switch (event.type) { - sdl.SDL_EVENT_QUIT => { + sdl.EVENT_QUIT => { self.running = false; }, - sdl.SDL_EVENT_WINDOW_RESIZED => { - if (event.window.windowID != sdl.SDL_GetWindowID(self.graphics.window)) return; + sdl.EVENT_WINDOW_RESIZED => { + if (event.window.windowID != sdl.GetWindowID(self.graphics.window)) return; self.graphics.resize(@intCast(event.window.data1), @intCast(event.window.data2)); }, else => {}, @@ -66,7 +66,7 @@ fn process_event(self: *Self, event: sdl.SDL_Event) void { pub fn deinit(self: *Self) void { self.graphics.destroy(); - sdl.SDL_Quit(); + sdl.Quit(); } pub const GameError = error{ diff --git a/src/graphics.zig b/src/graphics.zig index 9d319eb..4078646 100644 --- a/src/graphics.zig +++ b/src/graphics.zig @@ -1,86 +1,86 @@ const std = @import("std"); -const sdl = @import("sdl.zig"); +const sdl = @import("sdl"); const GameError = @import("game.zig").GameError; -window: *sdl.SDL_Window, -renderer: *sdl.SDL_Renderer, -device: *sdl.SDL_GPUDevice, +window: *sdl.Window, +renderer: *sdl.Renderer, +device: *sdl.GPUDevice, /// Only available while drawing -command_buffer: ?*sdl.SDL_GPUCommandBuffer, +command_buffer: ?*sdl.GPUCommandBuffer, -shader_vert: *sdl.SDL_GPUShader, -shader_frag: *sdl.SDL_GPUShader, +shader_vert: *sdl.GPUShader, +shader_frag: *sdl.GPUShader, -vertex_buffer: *sdl.SDL_GPUBuffer, -depth_texture: *sdl.SDL_GPUTexture, -pipeline: *sdl.SDL_GPUGraphicsPipeline, +vertex_buffer: *sdl.GPUBuffer, +depth_texture: *sdl.GPUTexture, +pipeline: *sdl.GPUGraphicsPipeline, to_resize: ?struct { u32, u32 } = null, const Self = @This(); pub fn create() GameError!Self { // Init - if (!sdl.SDL_Init(sdl.SDL_INIT_VIDEO | sdl.SDL_INIT_EVENTS)) return GameError.SdlError; + if (!sdl.Init(sdl.INIT_VIDEO | sdl.INIT_EVENTS)) return GameError.SdlError; // Window and Renderer - var renderer: ?*sdl.SDL_Renderer = null; - var window: ?*sdl.SDL_Window = null; + var renderer: ?*sdl.Renderer = null; + var window: ?*sdl.Window = null; - if (!sdl.SDL_CreateWindowAndRenderer( + if (!sdl.CreateWindowAndRenderer( "Spacefarer", 1600, 900, - sdl.SDL_WINDOW_VULKAN | sdl.SDL_WINDOW_RESIZABLE, + sdl.WINDOW_VULKAN | sdl.WINDOW_RESIZABLE, &window, &renderer, )) return GameError.SdlError; - errdefer sdl.SDL_DestroyRenderer(renderer); - errdefer sdl.SDL_DestroyWindow(window); + errdefer sdl.DestroyRenderer(renderer); + errdefer sdl.DestroyWindow(window); - if (!sdl.SDL_SetRenderVSync(renderer, sdl.SDL_RENDERER_VSYNC_ADAPTIVE)) return GameError.SdlError; + if (!sdl.SetRenderVSync(renderer, sdl.RENDERER_VSYNC_ADAPTIVE)) return GameError.SdlError; // Device - const device = sdl.SDL_CreateGPUDevice( - sdl.SDL_GPU_SHADERFORMAT_SPIRV, + const device = sdl.CreateGPUDevice( + sdl.GPU_SHADERFORMAT_SPIRV, @import("builtin").mode == .Debug, null, ) orelse return GameError.SdlError; - errdefer sdl.SDL_DestroyGPUDevice(device); + errdefer sdl.DestroyGPUDevice(device); // Claim - if (!sdl.SDL_ClaimWindowForGPUDevice(device, window)) return GameError.SdlError; - errdefer sdl.SDL_ReleaseWindowFromGPUDevice(device, window); + if (!sdl.ClaimWindowForGPUDevice(device, window)) return GameError.SdlError; + errdefer sdl.ReleaseWindowFromGPUDevice(device, window); const shader_vert = try load_shader( device, "data/shaders/basic.vert", - sdl.SDL_GPU_SHADERSTAGE_VERTEX, + sdl.GPU_SHADERSTAGE_VERTEX, ); - errdefer sdl.SDL_ReleaseGPUShader(device, shader_vert); + errdefer sdl.ReleaseGPUShader(device, shader_vert); const shader_frag = try load_shader( device, "data/shaders/basic.frag", - sdl.SDL_GPU_SHADERSTAGE_FRAGMENT, + sdl.GPU_SHADERSTAGE_FRAGMENT, ); - errdefer sdl.SDL_ReleaseGPUShader(device, shader_frag); + errdefer sdl.ReleaseGPUShader(device, shader_frag); - const vertex_buffer = sdl.SDL_CreateGPUBuffer(device, &.{ - .usage = sdl.SDL_GPU_BUFFERUSAGE_VERTEX, + const vertex_buffer = sdl.CreateGPUBuffer(device, &.{ + .usage = sdl.GPU_BUFFERUSAGE_VERTEX, // 6 Vertices * 3 Coordinates * 4 Bytes .size = 6 * 3 * 4, }) orelse return GameError.SdlError; - errdefer sdl.SDL_ReleaseGPUBuffer(device, vertex_buffer); + errdefer sdl.ReleaseGPUBuffer(device, vertex_buffer); - const transfer_buffer = sdl.SDL_CreateGPUTransferBuffer(device, &.{ + const transfer_buffer = sdl.CreateGPUTransferBuffer(device, &.{ .size = 6 * 3 * 4, - .usage = sdl.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, + .usage = sdl.GPU_TRANSFERBUFFERUSAGE_UPLOAD, }) orelse return GameError.SdlError; - defer sdl.SDL_ReleaseGPUTransferBuffer(device, transfer_buffer); + defer sdl.ReleaseGPUTransferBuffer(device, transfer_buffer); { // Filling up transfer buffer - const mapped_buffer: [*c]f32 = @alignCast(@ptrCast(sdl.SDL_MapGPUTransferBuffer(device, transfer_buffer, false) orelse return GameError.SdlError)); - defer sdl.SDL_UnmapGPUTransferBuffer(device, transfer_buffer); + const mapped_buffer: [*c]f32 = @alignCast(@ptrCast(sdl.MapGPUTransferBuffer(device, transfer_buffer, false) orelse return GameError.SdlError)); + defer sdl.UnmapGPUTransferBuffer(device, transfer_buffer); std.mem.copyForwards(f32, mapped_buffer[0 .. 6 * 3], &[6 * 3]f32{ // Triangle 1 -1.0, 0.0, 0.0, @@ -94,29 +94,29 @@ pub fn create() GameError!Self { } { // Copying data over from transfer buffer to vertex buffer - const command_buffer = sdl.SDL_AcquireGPUCommandBuffer(device) orelse return GameError.SdlError; - const copy_pass = sdl.SDL_BeginGPUCopyPass(command_buffer) orelse return GameError.SdlError; + const command_buffer = sdl.AcquireGPUCommandBuffer(device) orelse return GameError.SdlError; + const copy_pass = sdl.BeginGPUCopyPass(command_buffer) orelse return GameError.SdlError; - sdl.SDL_UploadToGPUBuffer(copy_pass, &.{ .transfer_buffer = transfer_buffer }, &.{ + sdl.UploadToGPUBuffer(copy_pass, &.{ .transfer_buffer = transfer_buffer }, &.{ .size = 6 * 3 * 4, .buffer = vertex_buffer, }, false); - sdl.SDL_EndGPUCopyPass(copy_pass); - if (!sdl.SDL_SubmitGPUCommandBuffer(command_buffer)) return GameError.SdlError; + sdl.EndGPUCopyPass(copy_pass); + if (!sdl.SubmitGPUCommandBuffer(command_buffer)) return GameError.SdlError; } - const target_format = sdl.SDL_GetGPUSwapchainTextureFormat(device, window); - if (target_format == sdl.SDL_GPU_TEXTUREFORMAT_INVALID) return GameError.SdlError; + const target_format = sdl.GetGPUSwapchainTextureFormat(device, window); + if (target_format == sdl.GPU_TEXTUREFORMAT_INVALID) return GameError.SdlError; // TODO: Clean var window_width: c_int = 1; var window_height: c_int = 1; - if (!sdl.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)); - errdefer sdl.SDL_ReleaseGPUTexture(device, depth_texture); + errdefer sdl.ReleaseGPUTexture(device, depth_texture); - const pipeline = sdl.SDL_CreateGPUGraphicsPipeline(device, &.{ + const pipeline = sdl.CreateGPUGraphicsPipeline(device, &.{ .vertex_shader = shader_vert, .fragment_shader = shader_frag, .vertex_input_state = .{ @@ -124,51 +124,51 @@ pub fn create() GameError!Self { .slot = 0, // 3 Coordinates * 4 Bytes .pitch = 3 * 4, - .input_rate = sdl.SDL_GPU_VERTEXINPUTRATE_VERTEX, + .input_rate = sdl.GPU_VERTEXINPUTRATE_VERTEX, }, .num_vertex_buffers = 1, - .vertex_attributes = &sdl.SDL_GPUVertexAttribute{ + .vertex_attributes = &sdl.GPUVertexAttribute{ .offset = 0, .location = 0, - .format = sdl.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, + .format = sdl.GPU_VERTEXELEMENTFORMAT_FLOAT3, .buffer_slot = 0, }, .num_vertex_attributes = 1, }, - .primitive_type = sdl.SDL_GPU_PRIMITIVETYPE_TRIANGLELIST, + .primitive_type = sdl.GPU_PRIMITIVETYPE_TRIANGLELIST, .rasterizer_state = .{ - .cull_mode = sdl.SDL_GPU_CULLMODE_BACK, - .fill_mode = sdl.SDL_GPU_FILLMODE_FILL, - .front_face = sdl.SDL_GPU_FRONTFACE_CLOCKWISE, + .cull_mode = sdl.GPU_CULLMODE_BACK, + .fill_mode = sdl.GPU_FILLMODE_FILL, + .front_face = sdl.GPU_FRONTFACE_CLOCKWISE, }, .multisample_state = .{ // .sample_count = 1, }, .depth_stencil_state = .{ - .compare_op = sdl.SDL_GPU_COMPAREOP_LESS, + .compare_op = sdl.GPU_COMPAREOP_LESS, .enable_depth_test = true, .enable_depth_write = true, }, .target_info = .{ - .depth_stencil_format = sdl.SDL_GPU_TEXTUREFORMAT_D16_UNORM, - .color_target_descriptions = &sdl.SDL_GPUColorTargetDescription{ + .depth_stencil_format = sdl.GPU_TEXTUREFORMAT_D16_UNORM, + .color_target_descriptions = &sdl.GPUColorTargetDescription{ .format = target_format, .blend_state = .{ .enable_blend = true, - .alpha_blend_op = sdl.SDL_GPU_BLENDOP_ADD, - .color_blend_op = sdl.SDL_GPU_BLENDOP_ADD, - .color_write_mask = sdl.SDL_GPU_COLORCOMPONENT_R | sdl.SDL_GPU_COLORCOMPONENT_G | sdl.SDL_GPU_COLORCOMPONENT_B | sdl.SDL_GPU_COLORCOMPONENT_A, - .src_alpha_blendfactor = sdl.SDL_GPU_BLENDFACTOR_ONE, - .src_color_blendfactor = sdl.SDL_GPU_BLENDFACTOR_SRC_ALPHA, - .dst_alpha_blendfactor = sdl.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, - .dst_color_blendfactor = sdl.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, + .alpha_blend_op = sdl.GPU_BLENDOP_ADD, + .color_blend_op = sdl.GPU_BLENDOP_ADD, + .color_write_mask = sdl.GPU_COLORCOMPONENT_R | sdl.GPU_COLORCOMPONENT_G | sdl.GPU_COLORCOMPONENT_B | sdl.GPU_COLORCOMPONENT_A, + .src_alpha_blendfactor = sdl.GPU_BLENDFACTOR_ONE, + .src_color_blendfactor = sdl.GPU_BLENDFACTOR_SRC_ALPHA, + .dst_alpha_blendfactor = sdl.GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, + .dst_color_blendfactor = sdl.GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, }, }, .num_color_targets = 1, .has_depth_stencil_target = true, }, }) orelse return GameError.SdlError; - errdefer sdl.SDL_ReleaseGPUGraphicsPipeline(pipeline); + errdefer sdl.ReleaseGPUGraphicsPipeline(pipeline); return .{ .window = window.?, @@ -184,26 +184,26 @@ pub fn create() GameError!Self { } pub fn destroy(self: *Self) void { - sdl.SDL_ReleaseWindowFromGPUDevice(self.device, self.window); - sdl.SDL_DestroyRenderer(self.renderer); - sdl.SDL_DestroyWindow(self.window); + sdl.ReleaseWindowFromGPUDevice(self.device, self.window); + sdl.DestroyRenderer(self.renderer); + sdl.DestroyWindow(self.window); - sdl.SDL_ReleaseGPUGraphicsPipeline(self.device, self.pipeline); - sdl.SDL_ReleaseGPUTexture(self.device, self.depth_texture); - sdl.SDL_ReleaseGPUBuffer(self.device, self.vertex_buffer); + sdl.ReleaseGPUGraphicsPipeline(self.device, self.pipeline); + sdl.ReleaseGPUTexture(self.device, self.depth_texture); + sdl.ReleaseGPUBuffer(self.device, self.vertex_buffer); - sdl.SDL_ReleaseGPUShader(self.device, self.shader_vert); - sdl.SDL_ReleaseGPUShader(self.device, self.shader_frag); + sdl.ReleaseGPUShader(self.device, self.shader_vert); + sdl.ReleaseGPUShader(self.device, self.shader_frag); if (self.command_buffer != null) { - _ = sdl.SDL_CancelGPUCommandBuffer(self.command_buffer); + _ = sdl.CancelGPUCommandBuffer(self.command_buffer); self.command_buffer = null; } - sdl.SDL_DestroyGPUDevice(self.device); + sdl.DestroyGPUDevice(self.device); } pub fn begin_draw(self: *Self) GameError!void { - self.command_buffer = sdl.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| { try self.reset_depth_texture(new_size[0], new_size[1]); self.to_resize = null; @@ -211,72 +211,72 @@ pub fn begin_draw(self: *Self) GameError!void { } pub fn draw_debug(self: *Self) GameError!void { - var render_target: ?*sdl.SDL_GPUTexture = null; + var render_target: ?*sdl.GPUTexture = null; var width: u32 = 0; var height: u32 = 0; - if (!sdl.SDL_WaitAndAcquireGPUSwapchainTexture(self.command_buffer, self.window, &render_target, &width, &height)) return GameError.SdlError; + if (!sdl.WaitAndAcquireGPUSwapchainTexture(self.command_buffer, self.window, &render_target, &width, &height)) return GameError.SdlError; // Hidden if (render_target == null) return; - const render_pass = sdl.SDL_BeginGPURenderPass(self.command_buffer, &.{ + const render_pass = sdl.BeginGPURenderPass(self.command_buffer, &.{ .clear_color = .{ .r = 0.0, .g = 0.0, .b = 1.0, .a = 1.0 }, .cycle = false, - .load_op = sdl.SDL_GPU_LOADOP_CLEAR, - // .store_op = sdl.SDL_GPU_STOREOP_RESOLVE, - .store_op = sdl.SDL_GPU_STOREOP_STORE, + .load_op = sdl.GPU_LOADOP_CLEAR, + // .store_op = sdl.GPU_STOREOP_RESOLVE, + .store_op = sdl.GPU_STOREOP_STORE, // .resolve_texture = render_target, .mip_level = 0, .texture = render_target, }, 1, &.{ .clear_depth = 1.0, - .load_op = sdl.SDL_GPU_LOADOP_CLEAR, - .store_op = sdl.SDL_GPU_STOREOP_DONT_CARE, - .stencil_load_op = sdl.SDL_GPU_STOREOP_DONT_CARE, - .stencil_store_op = sdl.SDL_GPU_STOREOP_DONT_CARE, + .load_op = sdl.GPU_LOADOP_CLEAR, + .store_op = sdl.GPU_STOREOP_DONT_CARE, + .stencil_load_op = sdl.GPU_STOREOP_DONT_CARE, + .stencil_store_op = sdl.GPU_STOREOP_DONT_CARE, .texture = self.depth_texture, }) orelse return GameError.SdlError; - sdl.SDL_BindGPUGraphicsPipeline(render_pass, self.pipeline); - sdl.SDL_BindGPUVertexBuffers(render_pass, 0, &.{ .offset = 0, .buffer = self.vertex_buffer }, 1); - sdl.SDL_DrawGPUPrimitives(render_pass, 6, 1, 0, 0); + sdl.BindGPUGraphicsPipeline(render_pass, self.pipeline); + sdl.BindGPUVertexBuffers(render_pass, 0, &.{ .offset = 0, .buffer = self.vertex_buffer }, 1); + sdl.DrawGPUPrimitives(render_pass, 6, 1, 0, 0); - sdl.SDL_EndGPURenderPass(render_pass); + sdl.EndGPURenderPass(render_pass); } pub fn end_draw(self: *Self) GameError!void { defer self.command_buffer = null; - if (!sdl.SDL_SubmitGPUCommandBuffer(self.command_buffer)) return GameError.SdlError; + if (!sdl.SubmitGPUCommandBuffer(self.command_buffer)) return GameError.SdlError; } -fn load_shader(device: *sdl.SDL_GPUDevice, path: []const u8, stage: c_uint) GameError!*sdl.SDL_GPUShader { +fn load_shader(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(); const code = file.readToEndAllocOptions(std.heap.c_allocator, 1024 * 1024 * 1024, null, @alignOf(u8), 0) catch return GameError.OSError; defer std.heap.c_allocator.free(code); - return sdl.SDL_CreateGPUShader(device, &.{ + return sdl.CreateGPUShader(device, &.{ .code = code, .code_size = code.len, .entrypoint = "main", - .format = sdl.SDL_GPU_SHADERFORMAT_SPIRV, + .format = sdl.GPU_SHADERFORMAT_SPIRV, .stage = stage, }) orelse return GameError.SdlError; } -fn create_depth_texture(device: *sdl.SDL_GPUDevice, width: u32, height: u32) GameError!*sdl.SDL_GPUTexture { - return sdl.SDL_CreateGPUTexture(device, &.{ - .format = sdl.SDL_GPU_TEXTUREFORMAT_D16_UNORM, +fn create_depth_texture(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, .width = width, .height = height, .num_levels = 1, - .usage = sdl.SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, + .usage = sdl.GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, }) orelse return GameError.SdlError; } fn reset_depth_texture(self: *Self, width: u32, height: u32) GameError!void { - sdl.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); } diff --git a/src/main.zig b/src/main.zig index 09be2b3..db89d1f 100644 --- a/src/main.zig +++ b/src/main.zig @@ -1,5 +1,5 @@ const std = @import("std"); -const sdl = @import("sdl.zig"); +const sdl = @import("sdl"); const Game = @import("game.zig"); pub fn run_game() !void { diff --git a/utils/sdl_translator.zig b/utils/sdl_translator.zig new file mode 100644 index 0000000..9704781 --- /dev/null +++ b/utils/sdl_translator.zig @@ -0,0 +1,45 @@ +const std = @import("std"); +const sdl = @cImport({ + @cInclude("SDL3/SDL.h"); +}); + +const PREFIX = "SDL_"; + +pub fn main() !void { + var gpa = std.heap.GeneralPurposeAllocator(.{}){}; + defer _ = gpa.deinit(); + const alloc = gpa.allocator(); + + var arg_iter = try std.process.argsWithAllocator(alloc); + defer arg_iter.deinit(); + + _ = arg_iter.next(); + const output = arg_iter.next().?; + + const file = try std.fs.createFileAbsolute(output, .{}); + defer file.close(); + + const writer = file.writer(); + + const stdout = std.io.getStdOut(); + defer stdout.close(); + + const out = stdout.writer(); + + var renamed_count: usize = 0; + for (@typeInfo(sdl).@"struct".decls) |decl| { + if (!std.mem.startsWith(u8, decl.name, PREFIX)) continue; + + const new_name: []const u8 = decl.name[PREFIX.len..]; + + try writer.print( + \\#define {1s} {0s} + \\ + , .{ decl.name, new_name }); + renamed_count += 1; + } + if (renamed_count == 0) { + @panic("No SDL definitions renamed"); + } + try out.print("[SDL Translator] {} SDL definitions renamed\n", .{renamed_count}); +}