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

0.14 zig version, pretty build.zig, renamed SDL defs

Browse Source
This commit is contained in:
duck
2025-05-03 01:56:24 +05:00
parent d36f7de1a5
commit 4374c6dd84
7 changed files with 271 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
src/game.zig
View File

@@ -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{

194
src/graphics.zig
View File

@@ -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);
}

2
src/main.zig
View File

@@ -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 {

3
src/sdl.zig
View File

@@ -1,3 +0,0 @@
pub usingnamespace @cImport({
@cInclude("SDL3/SDL.h");
});