Merge branch 'main' of https://github.com/HTRMC/FarHorizons

Author: HTRMC

.vscode/tasks.json

@@ -19,6 +19,14 @@
             "args": ["build", "run"],
             "group": "build",
             "problemMatcher": []
+        },
+        {
+            "label": "Build and Run (Tracy)",
+            "type": "shell",
+            "command": "./compiler/zig/zig.exe",
+            "args": ["build", "run", "-Dtracy=true"],
+            "group": "build",
+            "problemMatcher": []
         }
     ]
 }

.zigversion

@@ -1 +1 @@
-0.16.0-dev.1859+212968c57
+0.16.0-dev.2368+380ea6fb5

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HTRMC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -72,4 +72,4 @@ A voxel-based game/game-engine written in Zig with a Vulkan renderer. Inspired b
 
 ## License
 
-This project is licensed under All Rights Reserved.
+This project is licensed under MIT.

src/client/Main.zig

@@ -9,6 +9,7 @@ const DisplayData = shared.DisplayData;
 const GameData = shared.GameData;
 const QuickPlayData = shared.QuickPlayData;
 const CrashReport = shared.CrashReport;
+const profiler = shared.profiler;
 const FarHorizonsClient = @import("FarHorizonsClient.zig").FarHorizonsClient;
 
 pub const Main = struct {
@@ -22,7 +23,10 @@ pub const Main = struct {
     pub fn run(io: Io) !void {
         var gpa = std.heap.GeneralPurposeAllocator(.{}){};
         defer _ = gpa.deinit();
-        const allocator = gpa.allocator();
+
+        // Wrap allocator with Tracy for memory profiling (compiles to no-op when tracy disabled)
+        var tracy_alloc = profiler.TracyAllocator(null).init(gpa.allocator());
+        const allocator = tracy_alloc.allocator();
 
         // Use arena for strings that live for the program's lifetime
         var arena = std.heap.ArenaAllocator.init(allocator);
@@ -73,7 +77,9 @@ pub const Main = struct {
     };
 
     fn parseArgs(allocator: std.mem.Allocator) !ParsedArgs {
-        var args = try std.process.argsWithAllocator(allocator);
+        const cmd_line = std.os.windows.peb().ProcessParameters.CommandLine;
+        const cmd_line_slice = cmd_line.Buffer.?[0 .. cmd_line.Length / 2];
+        var args = try std.process.Args.Iterator.initAllocator(.{ .vector = cmd_line_slice }, allocator);
         defer args.deinit();
 
         // Skip executable name
@@ -147,7 +153,9 @@ pub fn main() void {
     const crash_allocator = std.heap.page_allocator;
 
     // Initialize the I/O subsystem
-    var io_threaded = Io.Threaded.init(crash_allocator, .{});
+    var io_threaded = Io.Threaded.init(crash_allocator, .{
+        .environ = std.process.Environ.empty,
+    });
     defer io_threaded.deinit();
     const io = io_threaded.io();
 

src/client/renderer/buffer/ChunkBufferManager.zig

@@ -295,9 +295,12 @@ pub const ChunkBufferManager = struct {
     }
 
     /// Begin a new frame (call before staging)
+    /// NOTE: Does NOT process deferred frees - that's done by upload thread via advanceFrameAndProcessFrees()
+    /// This only advances the frame counter for allocation tracking and begins the staging frame
     pub fn beginFrame(self: *Self, frame_fence: vk.VkFence) !void {
-        self.frame_counter += 1;
-        self.processDeferredFrees();
+        // NOTE: frame_counter is also incremented by upload thread in advanceFrameAndProcessFrees()
+        // This is intentional - main thread tracks its own frame for staging, upload thread tracks for deferred frees
+        // The deferred free logic uses >= comparison so slightly out-of-sync counters are safe
         try self.staging.beginFrame(frame_fence);
     }
 

src/server/Main.zig

@@ -16,7 +16,9 @@ pub const Main = struct {
         defer _ = gpa.deinit();
         const allocator = gpa.allocator();
 
-        var args = try std.process.argsWithAllocator(allocator);
+        const cmd_line = std.os.windows.peb().ProcessParameters.CommandLine;
+        const cmd_line_slice = cmd_line.Buffer.?[0 .. cmd_line.Length / 2];
+        var args = try std.process.Args.Iterator.initAllocator(.{ .vector = cmd_line_slice }, allocator);
         defer args.deinit();
 
         logger.info("Starting FarHorizons Server", .{});

src/shared/profiler.zig

@@ -193,3 +193,123 @@ pub inline fn isConnected() bool {
     }
     return false;
 }
+
+// =============================================================================
+// Memory Profiling
+// =============================================================================
+
+/// Report a memory allocation to Tracy
+pub inline fn alloc(ptr: ?*anyopaque, size: usize) void {
+    if (enabled) {
+        c.___tracy_emit_memory_alloc(ptr, size, 0);
+    }
+}
+
+/// Report a memory allocation with name to Tracy
+pub inline fn allocNamed(ptr: ?*anyopaque, size: usize, comptime name: [:0]const u8) void {
+    if (enabled) {
+        c.___tracy_emit_memory_alloc_named(ptr, size, 0, name.ptr);
+    }
+}
+
+/// Report a memory free to Tracy
+pub inline fn free(ptr: ?*anyopaque) void {
+    if (enabled) {
+        c.___tracy_emit_memory_free(ptr, 0);
+    }
+}
+
+/// Report a memory free with name to Tracy
+pub inline fn freeNamed(ptr: ?*anyopaque, comptime name: [:0]const u8) void {
+    if (enabled) {
+        c.___tracy_emit_memory_free_named(ptr, 0, name.ptr);
+    }
+}
+
+/// A wrapper allocator that reports all allocations to Tracy
+/// Use this to wrap your main allocator for memory profiling
+pub fn TracyAllocator(comptime name: ?[:0]const u8) type {
+    return struct {
+        parent_allocator: std.mem.Allocator,
+
+        const Self = @This();
+
+        pub fn init(parent: std.mem.Allocator) Self {
+            return .{ .parent_allocator = parent };
+        }
+
+        pub fn allocator(self: *Self) std.mem.Allocator {
+            return .{
+                .ptr = self,
+                .vtable = &.{
+                    .alloc = allocFn,
+                    .resize = resizeFn,
+                    .remap = remapFn,
+                    .free = freeFn,
+                },
+            };
+        }
+
+        fn allocFn(ctx: *anyopaque, len: usize, alignment: std.mem.Alignment, ret_addr: usize) ?[*]u8 {
+            const self: *Self = @ptrCast(@alignCast(ctx));
+            const result = self.parent_allocator.rawAlloc(len, alignment, ret_addr);
+            if (enabled and result != null) {
+                if (name) |n| {
+                    c.___tracy_emit_memory_alloc_named(result, len, 0, n.ptr);
+                } else {
+                    c.___tracy_emit_memory_alloc(result, len, 0);
+                }
+            }
+            return result;
+        }
+
+        fn resizeFn(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, new_len: usize, ret_addr: usize) bool {
+            const self: *Self = @ptrCast(@alignCast(ctx));
+            if (self.parent_allocator.rawResize(buf, alignment, new_len, ret_addr)) {
+                if (enabled) {
+                    // Tracy doesn't have a resize, so report as free + alloc
+                    if (name) |n| {
+                        c.___tracy_emit_memory_free_named(buf.ptr, 0, n.ptr);
+                        c.___tracy_emit_memory_alloc_named(buf.ptr, new_len, 0, n.ptr);
+                    } else {
+                        c.___tracy_emit_memory_free(buf.ptr, 0);
+                        c.___tracy_emit_memory_alloc(buf.ptr, new_len, 0);
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+
+        fn remapFn(ctx: *anyopaque, memory: []u8, alignment: std.mem.Alignment, new_len: usize, ret_addr: usize) ?[*]u8 {
+            const self: *Self = @ptrCast(@alignCast(ctx));
+            const old_ptr = memory.ptr;
+            const result = self.parent_allocator.rawRemap(memory, alignment, new_len, ret_addr);
+            if (enabled) {
+                if (result) |new_ptr| {
+                    // Successful remap - report free of old, alloc of new
+                    if (name) |n| {
+                        c.___tracy_emit_memory_free_named(old_ptr, 0, n.ptr);
+                        c.___tracy_emit_memory_alloc_named(new_ptr, new_len, 0, n.ptr);
+                    } else {
+                        c.___tracy_emit_memory_free(old_ptr, 0);
+                        c.___tracy_emit_memory_alloc(new_ptr, new_len, 0);
+                    }
+                }
+            }
+            return result;
+        }
+
+        fn freeFn(ctx: *anyopaque, buf: []u8, alignment: std.mem.Alignment, ret_addr: usize) void {
+            const self: *Self = @ptrCast(@alignCast(ctx));
+            if (enabled) {
+                if (name) |n| {
+                    c.___tracy_emit_memory_free_named(buf.ptr, 0, n.ptr);
+                } else {
+                    c.___tracy_emit_memory_free(buf.ptr, 0);
+                }
+            }
+            self.parent_allocator.rawFree(buf, alignment, ret_addr);
+        }
+    };
+}