Initial commit

.gitignore

@@ -0,0 +1,2 @@
+/.zig-cache
+/zig-out

build.zig

@@ -0,0 +1,25 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    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 run_cmd = b.addRunArtifact(exe);
+    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);
+}

build.zig.zon

@@ -0,0 +1,10 @@
+.{
+    .name = "spacefarer",
+    .version = "0.0.0",
+    .dependencies = .{},
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+    },
+}

src/game.zig

@@ -0,0 +1,88 @@
+const std = @import("std");
+const sdl = @import("sdl.zig");
+
+renderer: ?*sdl.SDL_Renderer,
+window: ?*sdl.SDL_Window,
+running: bool,
+
+const Self = @This();
+pub fn init() GameError!Self {
+    if (!sdl.SDL_Init(sdl.SDL_INIT_VIDEO | sdl.SDL_INIT_EVENTS)) return GameError.SdlError;
+
+    var renderer: ?*sdl.SDL_Renderer = null;
+    var window: ?*sdl.SDL_Window = null;
+
+    if (!sdl.SDL_CreateWindowAndRenderer(
+        "Spacefarer",
+        1600,
+        900,
+        sdl.SDL_WINDOW_VULKAN,
+        &window,
+        &renderer,
+    )) return GameError.SdlError;
+
+    if (!sdl.SDL_SetRenderVSync(renderer, sdl.SDL_RENDERER_VSYNC_ADAPTIVE)) return GameError.SdlError;
+
+    return Self{
+        .renderer = renderer,
+        .window = window,
+        .running = false,
+    };
+}
+
+pub fn run(self: *Self) GameError!void {
+    self.running = true;
+    while (true) {
+        try self.process_events();
+        if (!self.running) {
+            break;
+        }
+        try self.update();
+        try self.draw();
+    }
+}
+
+fn update(self: *Self) GameError!void {
+    _ = self;
+}
+
+fn draw(self: *Self) GameError!void {
+    if (!sdl.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255)) return GameError.SdlError;
+    if (!sdl.SDL_RenderClear(self.renderer)) return GameError.SdlError;
+    if (!sdl.SDL_RenderPresent(self.renderer)) return GameError.SdlError;
+}
+
+fn process_events(self: *Self) GameError!void {
+    sdl.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));
+        if (count == -1) return GameError.SdlError;
+        for (buffer[0..count]) |event| {
+            self.process_event(event);
+        }
+        if (count < buffer.len) {
+            break;
+        }
+    }
+    sdl.SDL_FlushEvents(sdl.SDL_EVENT_FIRST, sdl.SDL_EVENT_LAST);
+}
+
+fn process_event(self: *Self, event: sdl.SDL_Event) void {
+    switch (event.type) {
+        sdl.SDL_EVENT_QUIT => {
+            self.running = false;
+        },
+        else => {},
+    }
+}
+
+pub fn deinit(self: *Self) void {
+    sdl.SDL_DestroyRenderer(self.renderer);
+    sdl.SDL_DestroyWindow(self.window);
+    sdl.SDL_Quit();
+}
+
+pub const GameError = error{
+    SdlError,
+};

src/main.zig

@@ -0,0 +1,8 @@
+const std = @import("std");
+const Game = @import("game.zig");
+
+pub fn main() !void {
+    var game = try Game.init();
+    defer game.deinit();
+    try game.run();
+}

src/sdl.zig

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