From 9f86883188620d4b8b6cc2fe50f4e8cfcb3984d6 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 9 Aug 2025 21:10:31 -0700 Subject: [PATCH 01/46] feat(resources): begin implementing resource management utilities such as separating data from functionality and handles to said data --- src/api/command_buffer.zig | 46 +++++++++++++++++++++++++-- src/api/renderpass.zig | 4 +-- src/mem/handle.zig | 60 ++++++++++++++++++++++++++++++++++++ src/mem/helpers.zig | 0 src/mem/registry.zig | 0 src/mem/resource_manager.zig | 16 ++++++++++ 6 files changed, 121 insertions(+), 5 deletions(-) create mode 100644 src/mem/handle.zig create mode 100644 src/mem/helpers.zig create mode 100644 src/mem/registry.zig create mode 100644 src/mem/resource_manager.zig diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index b83c4b4..8838262 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -20,9 +20,10 @@ one_shot: bool = false, pub const Config = struct { src_queue_family: queue.QueueFamily = .Graphics, + one_shot: bool = false, }; -pub fn init(ctx: *const Context, config: Config) !Self { +pub fn init(self: *CommandBuffer, ctx: *const Context, config: Config) !void { const dev = ctx.env(.dev); return initDev(dev, config); } @@ -41,11 +42,18 @@ fn initDev(dev: *const DeviceHandler, config: Config) !Self { return err; }; - return .{ + var api_cmd_buf = CommandBuffer{ .h_cmd_buffer = cmd_buffer, .h_cmd_pool = dev.getCommandPool(config.src_queue_family), .dev = dev, }; + + if (config.one_shot) { + api_cmd_buf.one_shot = true; + api_cmd_buf.beginConfig(.{.one_time_submit_bit = true}) + } + + return api_cmd_buf; } pub fn oneShot(dev: *const DeviceHandler, config: Config) !Self { @@ -94,7 +102,7 @@ pub fn submit(self: *const Self, comptime fam: queue.QueueFamily, sync: api.Sync ); } -pub fn deinit(self: *const Self) void { +pub fn deinit(self: *const CommandBuffer) void { // make sure the command buffer isn't in use before destroying it.. self.dev.waitIdle() catch {}; self.dev.pr_dev.freeCommandBuffers( @@ -103,3 +111,35 @@ pub fn deinit(self: *const Self) void { util.asManyPtr(vk.CommandBuffer, &self.h_cmd_buffer), ); } + +const res = @import("../mem/resource_manager.zig"); + +pub const CommandBuffer = struct { + h_cmd_buffer: vk.CommandBuffer, + h_cmd_pool: vk.CommandPool, + + dev: *const DeviceHandler, + one_shot: bool = false, +}; + +const Entry = res.Registry.AddEntry(.{ + .state = CommandBuffer, + .proxy = CommandBufferProxy, +}, init, deinit); + +pub const CommandBufferProxy = struct { + const CommandBufferHandle = res.Handle(CommandBuffer); + + handle: CommandBufferHandle, + + pub const bind = Entry.BindFn; + // easier than "Factory.destroyHandle(thing)" + pub const deinit = Entry.DeinitFn; + + pub const submit = res.APIFunction(submit); + pub const reset = res.APIFunction(reset); + pub const begin = res.APIFunction(begin); + pub const beginConfig = res.APIFunction(beginConfig); + pub const end = res.APIFunction(end); +}; + diff --git a/src/api/renderpass.zig b/src/api/renderpass.zig index 91f21ec..13cbfe1 100644 --- a/src/api/renderpass.zig +++ b/src/api/renderpass.zig @@ -101,10 +101,10 @@ pub fn initAlloc( .p_attachments = attachments_list.ptr, .subpass_count = 1, - .p_subpasses = util.asManyPtr(vk.SubpassDescription, &subpass_desc), + .p_subpasses = &.{subpass_desc}, .dependency_count = 1, - .p_dependencies = util.asManyPtr(vk.SubpassDependency, &subpass_dep), + .p_dependencies =&.{subpass_dep}, }, null) catch |err| { log.err("Failed to create render pass: {!}", .{err}); return err; diff --git a/src/mem/handle.zig b/src/mem/handle.zig new file mode 100644 index 0000000..1d67598 --- /dev/null +++ b/src/mem/handle.zig @@ -0,0 +1,60 @@ +const std = @import("std"); + +pub const HandleType = enum { + Single, + Multi, +}; +/// generic type-erased handle +/// contains the minimal amount of data required to work, but no higher-level functionality +/// To ensure safety, don't initialize these from scratch, +pub const OpaqueHandle = struct { + // value is always treated in a type-erased manner, + // gets and sets, as well as wrapped API functions will cast this as the appropriate + // type + // This is sort of not safe, so I'll provide debug functionality to ensure that handles + // are valid whenever they're acquired. + value: *anyopaque, + + type_data: union(HandleType) { + Single, + Multi: usize, + }, +}; + + +const assert = std.debug.assert; +/// Typed handle, with support for derefrence +pub fn Handle(comptime T: type) type { + return struct { + const Self = @This(); + base: OpaqueHandle, + + // TODO: Implement this so that you can't just pass any opaque handle -- + // It needs to be guarunteed that the handle bound is of a compatible type + // -- TO do that, I'll need to implement at least some of the type-scoped allocators + // first + pub fn bindOpaque(self: *Self) void { + } + + // these are ease-of-use pseudo-dereference operators + pub fn get(self: *const Self) *const T { + assert(self.base.type_data == .Single); + return @as(*const T, @ptrCast(self.base.value)); + } + + pub fn getMut(self: *Self) *T { + assert(self.base.type_data == .Single); + return @as(*T, @ptrCast(self.base.value)); + } + + pub fn getMulti(self: *const Self) []const T { + assert(self.base.type_data == .Multi); + return @as([*]const T, @ptrCast(self.base.value))[0..self.base.type_data.Multi]; + } + + pub fn getMultiMut(self: *Self) []T { + assert(self.base.type_data == .Multi); + return @as([*]T, @ptrCast(self.base.value))[0..self.base.type_data.Multi]; + } + }; +} diff --git a/src/mem/helpers.zig b/src/mem/helpers.zig new file mode 100644 index 0000000..e69de29 diff --git a/src/mem/registry.zig b/src/mem/registry.zig new file mode 100644 index 0000000..e69de29 diff --git a/src/mem/resource_manager.zig b/src/mem/resource_manager.zig new file mode 100644 index 0000000..1a22007 --- /dev/null +++ b/src/mem/resource_manager.zig @@ -0,0 +1,16 @@ +const Self = @This(); + +pub const Registry = @import("registry.zig"); +const h = @import("handle.zig"); + +pub const Handle = h.Handle; +pub const OpaqueHandle = h.OpaqueHandle; + + +pub const Config = struct { + +}; + + +pub fn init(config: Config) void { +} From 0b4f78e3392a0f8e5e8a000cde8a1b01b62056e2 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 10 Aug 2025 21:18:47 -0700 Subject: [PATCH 02/46] feat(reg): fleshed out registry with radix sorted entry table --- src/api/command_buffer.zig | 4 +- src/api/image.zig | 8 +++- src/mem/common.zig | 46 +++++++++++++++++++ src/mem/helpers.zig | 0 src/mem/pool_allocator.zig | 13 ++++++ src/mem/registry.zig | 90 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 157 insertions(+), 4 deletions(-) create mode 100644 src/mem/common.zig delete mode 100644 src/mem/helpers.zig create mode 100644 src/mem/pool_allocator.zig diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index 8838262..1665275 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -132,9 +132,9 @@ pub const CommandBufferProxy = struct { handle: CommandBufferHandle, - pub const bind = Entry.BindFn; + pub const bind = Entry.bindFn; // easier than "Factory.destroyHandle(thing)" - pub const deinit = Entry.DeinitFn; + pub const deinit = Entry.deinitFn; pub const submit = res.APIFunction(submit); pub const reset = res.APIFunction(reset); diff --git a/src/api/image.zig b/src/api/image.zig index cd245cd..640f1d0 100644 --- a/src/api/image.zig +++ b/src/api/image.zig @@ -349,7 +349,11 @@ pub fn cmdClear( ); } -fn initSelf(self: *Self, dev: *const DeviceHandler, config: Config) !void { +fn initSelf( + self: *Self, + dev: *const DeviceHandler, + config: Config, +) !void { const image_info = vk.ImageCreateInfo{ .image_type = .@"2d", .extent = .{ @@ -431,7 +435,7 @@ pub fn init(ctx: *const Context, config: Config) !Self { } /// creates an image from an image file. -/// Image parameters will be tuned for usage as a texture +/// Image parameters will be tuned for usage as a texture /// more so than a general purpose image for now... pub fn fromFile(ctx: *const Context, allocator: Allocator, path: []const u8) !Self { var image_data = rsh.loadImageFile(path, allocator) catch |err| { diff --git a/src/mem/common.zig b/src/mem/common.zig new file mode 100644 index 0000000..c8ff5d6 --- /dev/null +++ b/src/mem/common.zig @@ -0,0 +1,46 @@ +const std = @import("std"); +const assert = std.debug.assert; +/// This is cursed as hell.. +/// Returns a unique identifier for any type at comptime or runtime +/// https://github.com/ziglang/zig/issues/19858#issuecomment-2094339450 +pub const TypeId = usize; +pub fn typeId(comptime T: type) TypeId { + // Uhhh.... + return @intFromError(@field(anyerror, @typeName(T))); +} + + +fn APIFunctionType(func: anytype) type { + const T = @TypeOf(func); + +} + +pub const AnyPtr = struct { + + ptr: *anyopaque, + id: TypeId, + + pub fn from(comptime T: type, ptr: *T) AnyPtr { + return .{ + .ptr = ptr, + .id = typeId(T), + }; + } + + pub fn get(self: AnyPtr, comptime T: type) *T { + assert(self.id = typeId(T)); + return @as(*T, @ptrCast(@alignCast(self.ptr))); + } + +} + +/// # Overview: +/// This just remaps the first argument from a pointer to the DATA +/// type to a pointer to the API proxy type, with some minimal surrounding logic +/// in the wrapping function's body +/// +/// ## Notes: +/// Automagically handles multi-application of the internal function based +/// on the number of objects referenced by the handle. +pub fn APIFunction(func: anytype) APIFunctionType(func) { +} diff --git a/src/mem/helpers.zig b/src/mem/helpers.zig deleted file mode 100644 index e69de29..0000000 diff --git a/src/mem/pool_allocator.zig b/src/mem/pool_allocator.zig new file mode 100644 index 0000000..d7abc9c --- /dev/null +++ b/src/mem/pool_allocator.zig @@ -0,0 +1,13 @@ +//! Takes in a fixed, preallocated +//! buffer of memory and manages it as a pool of +//! a given type of objects to be allocated and freed independently. +//! +//! Free space will be tracked as a RB tree (or maybe a buddy allocator dunno) +//! and alignment requirements and backing allocators (to create the buffer) can be specified at +//! initialization time... +//! +//! Pools contain a fixed capacity that CANNOT be modified unless the pool is later resized, +//! which will probably have a buch of bad side effects that make it not really that good of an idea +//! (i.e invalidates everything so all pointers to handles are not guaranteed). + + diff --git a/src/mem/registry.zig b/src/mem/registry.zig index e69de29..b6de4e7 100644 --- a/src/mem/registry.zig +++ b/src/mem/registry.zig @@ -0,0 +1,90 @@ +const std = @import("std"); + +const common = @import("common.zig"); +const Context = @import("../context.zig"); + +const Allocator = std.mem.Allocator; +const AnyPtr = common.AnyPtr; +const TypeId = common.TypeId; + +const Self = @This(); + +pub const EntryConfig = struct { + // type for storing data + state: type, + + // type for associating and operating on data + proxy: type, + + // error set for init functions (omit for anyerror) + init_errors: ?type, + + // the type of the configuration struct (if any) + config_type: ?type = null, + // whether or not initialization depends on an allocator + requires_alloc: bool = false, +}; + + +// this returns the meta-information of the registry entry +// (underlying function types, unique type identifier) +pub fn RegistryEntryType(comptime config: EntryConfig) type { + return struct { + // remember, these functions should be remapped first arguments to the proxy + pub const InitFnType = InitFnTemplate(config), + pub const DeinitFnType = DeinitFnTemplate(config), + pub const entry_id = helpers.typeId(config.state); + }; +}; + + +/// NOTE: this could be a lot less branchy and stupid, but +/// that would come at the cost of @Type, which is not supported +/// by LSPs. I might redo this if it turns out this template doesn't +/// get directly touched by user code. +fn InitFnTemplate(comptime config: EntryConfig) type { + const error_type = config.init_errors orelse anyerror; + if (config.config_type) |ct| { + if (config.requires_alloc) { + return *const fn (*config.state, *const Context, Allocator, ct) error_type!void; + } else { + return *const fn (*config.state, *const Context, ct) error_type!void; + } + } else { + if (config.requires_alloc) { + return *const fn (*config.state, *const Context, Allocator) error_type!void; + } else { + return *const fn (*config.state, *const Context) error_type!void; + } + } +} + +fn DeinitFnTemplate(comptime config: EntryConfig) type { + return if (config.requires_alloc) + (*const fn (*config.state, Allocator) void) + else + (*const fn (*config.state) void); +} + +pub const RegistryEntry = struct { + type_id: TypeId, + initFn: AnyPtr, + deinitFn: AnyPtr, +}; + +// Radix-sorted list of entries by type id +const entries: []RegistryEntry; + +pub fn AddEntry( + self: *Self, + comptime config: EntryConfig, + initFn: InitFnTemplate(config), + deinitFn: DeinitFnTemplate(config), +) *const RegistryEntry { + const EntryType = RegistryEntryType(config); + const entry = RegistryEntry{ + .initFn = AnyPtr.from(EntryType.InitFn, initFn), + .deinitFn = AntPtr.from(EntryType.DeinitFn, deinitFn), + }; + +} From 23855c011b56324d37b41067cd696764ccf9634d Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Tue, 12 Aug 2025 17:06:44 -0700 Subject: [PATCH 03/46] feat(res): implemented pool allocator and tests save for individual frees --- src/mem/common.zig | 16 ++- src/mem/handle.zig | 29 +++-- src/mem/pool_allocator.zig | 259 ++++++++++++++++++++++++++++++++++++- src/mem/unused.zig | 165 +++++++++++++++++++++++ 4 files changed, 453 insertions(+), 16 deletions(-) create mode 100644 src/mem/unused.zig diff --git a/src/mem/common.zig b/src/mem/common.zig index c8ff5d6..c25dcae 100644 --- a/src/mem/common.zig +++ b/src/mem/common.zig @@ -1,5 +1,6 @@ const std = @import("std"); const assert = std.debug.assert; + /// This is cursed as hell.. /// Returns a unique identifier for any type at comptime or runtime /// https://github.com/ziglang/zig/issues/19858#issuecomment-2094339450 @@ -10,11 +11,15 @@ pub fn typeId(comptime T: type) TypeId { } + fn APIFunctionType(func: anytype) type { const T = @TypeOf(func); - + _ = T; } +// Type Ids shoudl only be conditionally compiled +// in a runtime safety build, otherwise all type ID checking should +// be a no-op pub const AnyPtr = struct { ptr: *anyopaque, @@ -28,11 +33,10 @@ pub const AnyPtr = struct { } pub fn get(self: AnyPtr, comptime T: type) *T { - assert(self.id = typeId(T)); + assert(self.id == typeId(T)); return @as(*T, @ptrCast(@alignCast(self.ptr))); } - -} +}; /// # Overview: /// This just remaps the first argument from a pointer to the DATA @@ -42,5 +46,9 @@ pub const AnyPtr = struct { /// ## Notes: /// Automagically handles multi-application of the internal function based /// on the number of objects referenced by the handle. +/// FIX: This is seeming to be disgusting to implement per-spec here +/// Need an alternative method, either constraining type signatures +/// or just not automating API function binding since there isn't that much extra code +/// I need right now pub fn APIFunction(func: anytype) APIFunctionType(func) { } diff --git a/src/mem/handle.zig b/src/mem/handle.zig index 1d67598..47283d2 100644 --- a/src/mem/handle.zig +++ b/src/mem/handle.zig @@ -1,4 +1,7 @@ const std = @import("std"); +const common = @import("common.zig"); + +const AnyPtr = common.AnyPtr; pub const HandleType = enum { Single, @@ -13,7 +16,7 @@ pub const OpaqueHandle = struct { // type // This is sort of not safe, so I'll provide debug functionality to ensure that handles // are valid whenever they're acquired. - value: *anyopaque, + value: AnyPtr, type_data: union(HandleType) { Single, @@ -21,40 +24,48 @@ pub const OpaqueHandle = struct { }, }; - const assert = std.debug.assert; + /// Typed handle, with support for derefrence pub fn Handle(comptime T: type) type { return struct { const Self = @This(); base: OpaqueHandle, - + // TODO: Implement this so that you can't just pass any opaque handle -- // It needs to be guarunteed that the handle bound is of a compatible type // -- TO do that, I'll need to implement at least some of the type-scoped allocators // first - pub fn bindOpaque(self: *Self) void { + pub fn bindOpaque(self: *Self, new: OpaqueHandle) void { + assert(self.base.value.id == new.value.id); + self.base = new; } - + // these are ease-of-use pseudo-dereference operators pub fn get(self: *const Self) *const T { assert(self.base.type_data == .Single); - return @as(*const T, @ptrCast(self.base.value)); + return self.base.value.get(T); } pub fn getMut(self: *Self) *T { assert(self.base.type_data == .Single); - return @as(*T, @ptrCast(self.base.value)); + return self.base.value.get(T); } pub fn getMulti(self: *const Self) []const T { assert(self.base.type_data == .Multi); - return @as([*]const T, @ptrCast(self.base.value))[0..self.base.type_data.Multi]; + return @as( + [*]const T, + @ptrCast(self.base.value.get(T)), + )[0..self.base.type_data.Multi]; } pub fn getMultiMut(self: *Self) []T { assert(self.base.type_data == .Multi); - return @as([*]T, @ptrCast(self.base.value))[0..self.base.type_data.Multi]; + return @as( + [*]T, + @ptrCast(self.base.value.get(T)), + )[0..self.base.type_data.Multi]; } }; } diff --git a/src/mem/pool_allocator.zig b/src/mem/pool_allocator.zig index d7abc9c..a63678d 100644 --- a/src/mem/pool_allocator.zig +++ b/src/mem/pool_allocator.zig @@ -1,13 +1,266 @@ -//! Takes in a fixed, preallocated -//! buffer of memory and manages it as a pool of +//! Takes in a fixed, preallocated +//! buffer of memory and manages it as a pool of //! a given type of objects to be allocated and freed independently. //! //! Free space will be tracked as a RB tree (or maybe a buddy allocator dunno) -//! and alignment requirements and backing allocators (to create the buffer) can be specified at +//! and alignment requirements and backing allocators (to create the buffer) can be specified at //! initialization time... //! //! Pools contain a fixed capacity that CANNOT be modified unless the pool is later resized, //! which will probably have a buch of bad side effects that make it not really that good of an idea //! (i.e invalidates everything so all pointers to handles are not guaranteed). +//! +//! TODO: A great feature would be adding scoped allocations for individual pools +//! which match vulkan object's lifetimes (generally they are the same per-type of object) + +const std = @import("std"); +const common = @import("common.zig"); +const assert = std.debug.assert; + +const Allocator = std.mem.Allocator; +const AnyPtr = common.AnyPtr; + +const Self = @This(); + +/// Free space LInked list +/// Mostly just a std.LinkedList of allocation headers +/// but does some extra stuff to have the nodes stored in-place +/// with the actual memory pool. +const FreeSpaceList = struct { + const BlockHeader = struct { + elem_count: usize, + }; + + const BlockList = std.DoublyLinkedList(BlockHeader); + const ListNode = BlockList.Node; + + elem_size: usize, + free_nodes: BlockList, + buf: []u8, + + fn makeNode(buf: []u8, header: BlockHeader) *ListNode { + assert(buf.len > @sizeOf(ListNode)); + const node = @as(*ListNode, @ptrCast(@alignCast(buf.ptr))); + + node.data = header; + return node; + } + + // possibly use a free-list styled allocator to do this + fn coalesce(self: *FreeSpaceList, root: *ListNode) void { + _ = self; + _ = root; + } + + // This function does not work at all lol + pub fn pop(self: *FreeSpaceList, count: usize) ?*anyopaque { + var node: ?*ListNode = self.free_nodes.popFirst() orelse return null; + + while (node != null and node.?.data.elem_count < count) : (node = node.?.next) {} + + const n = node orelse return null; + + if (n.data.elem_count > count) { + const block_size = n.data.elem_count - count; + const bytes_size = block_size * self.elem_size; + const new_node: *ListNode = @ptrFromInt(@intFromPtr(n) + bytes_size); + + new_node.* = .{ .data = .{ + .elem_count = block_size, + } }; + + self.free_nodes.prepend(new_node); + } + + return n; + } + + pub fn free(self: *FreeSpaceList, ptr: *anyopaque) void { + //TODO: This needs some work + //Can't use a linked list to effectively handle multiple item frees, even with a count + //Mostly because of the coalesce routine (it would need to be an RB tree of sorts) + + _ = self; + _ = ptr; + } + + pub fn init(buf: []u8, elem_size: usize) FreeSpaceList { + const num_elements = @divExact(buf.len, elem_size); + const node = makeNode(buf, .{ .elem_count = num_elements }); + + var list = BlockList{}; + list.prepend(node); + + return FreeSpaceList{ + .elem_size = elem_size, + .free_nodes = list, + .buf = buf, + }; + } +}; + +/// Type Safe generic pool wrapper +pub fn TypedPool(comptime T: type) type { + return struct { + const Pool = @This(); + const elem_size = @sizeOf(T); + const type_id = common.typeId(T); + inner: Self, + + pub fn initAlloc(allocator: Allocator, count: usize) !Pool { + const pool_config = Config{ + .elem_size = elem_size, + .elem_count = count, + }; + + return Pool{ + .inner = Self.initAlloc(allocator, pool_config), + }; + } + + pub fn init(buf: []T, count: usize) Pool { + const bytes_len = buf.len * elem_size; + const buffer = @as([*]u8, @ptrCast(@alignCast(buf.ptr)))[0..bytes_len]; + + const pool_config = Config{ + .elem_size = elem_size, + .elem_count = count, + }; + + return Pool.init(buffer, pool_config); + } + + pub fn reserve(self: *Pool) PoolErrors!*T { + return @as(*T, @ptrCast(@alignCast(try self.inner.reserve()))); + } + + pub fn reserveRange(self: *Pool, count: usize) PoolErrors![]T { + return @as([*]T, @ptrCast( + @alignCast(try self.inner.reserveRange(count)), + ))[0..count]; + } + + pub fn freeAll(self: *Pool) void { + self.inner.freeAll(); + } + + pub fn deinit(self: *Pool) void { + self.inner.deinit(); + } + }; +} + +// Limited to u32 boundaries, just used usize since int casting is annoying +pub const Config = struct { + elem_size: usize, + elem_count: usize, +}; + +pub const PoolErrors = error{ + OutOfMemory, +}; + +config: Config, + +// raw backing buffer, very rarely directly access this... +buf: []u8, +free_space: FreeSpaceList, + +allocator: ?Allocator = null, + +pub fn initAlloc(allocator: Allocator, config: Config) !Self { + const total_size = config.elem_count * config.elem_size; + const buf = try allocator.alloc(u8, total_size); + + var new = init(buf, config); + new.allocator = allocator; + + return new; +} + +/// Reserve a single item +/// Pointer is guarunteed to refer to a block +/// of memory for the correct size. +pub fn reserve(self: *Self) PoolErrors!*anyopaque { + return self.free_space.pop(1) orelse PoolErrors.OutOfMemory; +} + +/// Reserve multiple items contiguously +pub fn reserveRange(self: *Self, count: usize) PoolErrors!*anyopaque { + return self.free_space.pop(count) orelse return PoolErrors.OutOfMemory; +} + +/// free a previous allocation +/// I'll do this later once pool items are more likely to be reused +pub fn free(self: *Self, item: *anyopaque) void { + _ = self; + _ = item; +} + +pub fn freeAll(self: *Self) void { + // Just overwrite the existing free space list with a new one, which will cover the entire pool + // no leakage issues since the list is stored in-place + self.free_space = FreeSpaceList.init(self.buf, self.config.elem_size); +} +/// ## Notes: +/// * Directly passed buffer must respect alginment requirements +/// of the state type +pub fn init(buf: []u8, config: Config) Self { + return .{ + .config = config, + + .buf = buf, + .free_space = FreeSpaceList.init(buf, config.elem_size), + }; +} + +pub fn deinit(self: *Self) void { + if (self.allocator) |allocator| { + allocator.free(self.buf); + } +} + +// Testing goes here: +// We're probably gonna need a lot of them lol. + + +const TestingStructA = struct { + items: [6]u32, +}; +const TestingPool = TypedPool(TestingStructA); + +const testing = std.testing; + +// Pool allocation tests +test "pool alloc" { + var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); + defer pool.deinit(); + + for (0..512) |_| { + _ = try pool.reserve(); + } + + _ = try pool.reserveRange(512); +} + +test "pool free" { + //TODO: Testing partial frees + + // free everything + var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); + _ = try pool.reserveRange(240); + + pool.freeAll(); + if (pool.inner.free_space.free_nodes.first) |f| { + try testing.expect(f.data.elem_count == 1024); + try testing.expect(f.next == null); + } else return error.InvalidFreeList; +} +test "out of memory" { + var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); + defer pool.deinit(); + _ = try pool.reserveRange(120); + testing.expectError(PoolErrors.OutOfMemory, pool.reserveRange(905)); +} diff --git a/src/mem/unused.zig b/src/mem/unused.zig new file mode 100644 index 0000000..30c39c0 --- /dev/null +++ b/src/mem/unused.zig @@ -0,0 +1,165 @@ +//! Unused code +//! Mostly exists because I mistook a pool allocator +//! for a free list allocator and created part of an RBtree +//! +//! oops + +const RBTree = struct { + const NodeColor = enum(u8) { + Red, + Black, + }; + + ///NOTE: Probably best if this is 8-aligned + pub const Node = struct { + parent: *Node, + left: *Node = null_node, + right: *Node = null_node, + + color: NodeColor, + buf: ?[]u8, + + pub inline fn isLeaf(self: Node) bool { + return self.buf != null; + } + + pub inline fn isNull(self: Node) bool { + return self.left == null_node and self.right == null_node; + } + }; + + const null_node = &Node{ + .parent = null_node, + .left = null_node, + .right = null_node, + + .color = .Black, + .buf = null, + }; + + root: *Node, + black_height: u32 = 1, + + fn partitionBuffer(buf: []u8) struct { *Node, []u8 } { + assert(buf.len > @sizeOf(*Node)); + + const node_space = @as( + *Node, + @ptrCast(@alignCast(buf[0..@sizeOf(*Node)].ptr)), + ); + + const buf_space = buf[@sizeOf(*Node)..]; + + return .{ node_space, buf_space }; + } + + fn leftRotate() void {} + + fn rightRotate() void {} + + pub fn init(buf: []u8) RBTree { + const root, const rest = partitionBuffer(buf); + + root.* = .{ + .parent = null_node, + .color = .Black, + .buf = rest, + }; + + return .{ + .root = root, + }; + } + + pub fn insert(len: usize) void {} + + pub fn delete() void {} + + pub fn find() void {} +}; + + + +/// Red-Black Tree Tests +/// Makes a horribly unoptimized testing RB tree +/// by individually allocating and connecting nodes. +/// This function does not respect RBTree rules, and therefore must be +/// constructed correctly by hand for test cases. +const TreeTestBuilder = struct { + const Direction = enum { + Left, + Right, + }; + + root: *RBTree.Node, + allocator: Allocator, + + current_node: *RBTree.Node, + + pub fn initAlloc(allocator: Allocator, root_size: usize) TreeTestBuilder { + const root: *RBTree.Node = allocator.create(RBTree.Node) orelse + @panic("Allocation failure during test"); + + root.parent = RBTree.null_node; + root.left = RBTree.null_node; + root.right = RBTree.null_node; + root.color = .Black; + + return TreeTestBuilder{ + .root = root, + .allocator = allocator, + .current_node = root, + }; + } + + /// deep-copy every node of an existing tree while preserving structure + pub fn deepCopy(orig: *const RBTree, allocator: Allocator) TreeTestBuilder {} + + // creates a new child + pub fn child( + self: *TreeTestBuilder, + dir: Direction, + col: RBTree.NodeColor, + size: usize, + ) *TreeTestBuilder {} + + /// sets current node pointer to parent + pub fn end(self: *TreeTestBuilder) *TreeTestBuilder {} + + pub fn build(self: *TreeTestBuilder) RBTree {} +}; + + +fn expectTreeEqual(a: RBTree, b: RBTree, label: []const u8) !void { +} + +test "insertion (all cases)" { + var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer arena.deinit(); + + const scratch = arena.allocator(); + + // Insertion case 1: + const initial_tree_1 = TreeTestBuilder.initAlloc(scratch, 128).build(); + var final = TreeTestBuilder.deepCopy(&initial_tree_1).build(); + final.insert(64); + + const final_tree_1 = TreeTestBuilder.initAlloc(scratch, 128) + .child(.Left, .Red, 64) + .build(); + + try expectTreeEqual(initial_tree_1, final_tree_1, "insertion case 1"); + + // Insertion case 2 (single iteration): + const initial_tree_2 = TreeTestBuilder.initAlloc(scratch, 128) + .child(.Left, .Red, 64) + .end() + .child(.Right, .Red, + // Insertion case 2 & 3: +} + +test "deletion (all cases)" {} + +test "find (included)" {} + +test "find (not included)" {} From 7f051930f649e96afb3b0cdb580a0c2a069e0a64 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 15 Aug 2025 19:29:42 -0700 Subject: [PATCH 04/46] feat(reg): implemented a cursed type registry system... we'll see if this is a major pain or a help... --- build.zig | 17 +- src/api/api.zig | 6 +- src/api/command_buffer.zig | 58 ++++--- src/context.zig | 12 ++ src/mem/registry.zig | 90 ----------- src/mem/resource_manager.zig | 16 -- src/{mem => res}/common.zig | 9 ++ src/{mem => res}/handle.zig | 0 src/{mem => res}/pool_allocator.zig | 10 +- src/res/registry.zig | 239 ++++++++++++++++++++++++++++ src/res/res.zig | 7 + src/res/resource_manager.zig | 51 ++++++ src/{mem => res}/unused.zig | 0 src/root.zig | 14 ++ src/test/test_all.zig | 4 + {test => src/test}/test_math.zig | 1 + src/test/unit_test.zig | 1 + src/test_all.zig | 5 - test/test_env.zig | 54 ------- 19 files changed, 400 insertions(+), 194 deletions(-) delete mode 100644 src/mem/registry.zig delete mode 100644 src/mem/resource_manager.zig rename src/{mem => res}/common.zig (83%) rename src/{mem => res}/handle.zig (100%) rename src/{mem => res}/pool_allocator.zig (96%) create mode 100644 src/res/registry.zig create mode 100644 src/res/res.zig create mode 100644 src/res/resource_manager.zig rename src/{mem => res}/unused.zig (100%) create mode 100644 src/test/test_all.zig rename {test => src/test}/test_math.zig (98%) create mode 100644 src/test/unit_test.zig delete mode 100644 src/test_all.zig delete mode 100644 test/test_env.zig diff --git a/build.zig b/build.zig index db0955a..beb200b 100644 --- a/build.zig +++ b/build.zig @@ -178,9 +178,18 @@ fn buildSamples( /// adds a single module and compile step containing /// all included tests (based on specified options) -fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies) void { - _ = b; - _ = lib_mod; +fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies, opts: BuildOpts) void { + const test_comp = b.addTest(.{ + .name = "unit tests", + .root_module = lib_mod, + .target = opts.target, + }); + b.installArtifact(test_comp); + + const test_step = b.addRunArtifact(test_comp); + const test_cmd = b.step("run-tests", "run all unit tests"); + test_cmd.dependOn(&test_step.step); + _ = deps; } // Although this function looks imperative, note that its job is to @@ -197,7 +206,7 @@ pub fn build(b: *Build) void { // handle samples and testing if specified buildSamples(b, lib_mod, deps, opts); - buildTests(b, lib_mod, deps); + buildTests(b, lib_mod, deps, opts); // zls-friendly check step // (which made all the rest of the code way grosser) diff --git a/src/api/api.zig b/src/api/api.zig index 4d71e99..8614ec4 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -64,4 +64,8 @@ pub const Fence = sync.Fence; // shaders pub const ShaderModule = sh.Module; - +// Obtaining RTTI for vulkan API +const Registry = @import("../res/res.zig").Registry; +pub fn initRegistry(reg: *Registry) !void { + try CommandBuffer.addEntries(reg); +} diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index 1665275..99e4440 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -23,9 +23,9 @@ pub const Config = struct { one_shot: bool = false, }; -pub fn init(self: *CommandBuffer, ctx: *const Context, config: Config) !void { +pub fn init(ctx: *const Context, config: Config) !Self { const dev = ctx.env(.dev); - return initDev(dev, config); + return try initDev(dev, config); } fn initDev(dev: *const DeviceHandler, config: Config) !Self { @@ -42,7 +42,7 @@ fn initDev(dev: *const DeviceHandler, config: Config) !Self { return err; }; - var api_cmd_buf = CommandBuffer{ + var api_cmd_buf = Self{ .h_cmd_buffer = cmd_buffer, .h_cmd_pool = dev.getCommandPool(config.src_queue_family), .dev = dev, @@ -50,7 +50,7 @@ fn initDev(dev: *const DeviceHandler, config: Config) !Self { if (config.one_shot) { api_cmd_buf.one_shot = true; - api_cmd_buf.beginConfig(.{.one_time_submit_bit = true}) + try api_cmd_buf.beginConfig(.{ .one_time_submit_bit = true }); } return api_cmd_buf; @@ -102,7 +102,7 @@ pub fn submit(self: *const Self, comptime fam: queue.QueueFamily, sync: api.Sync ); } -pub fn deinit(self: *const CommandBuffer) void { +pub fn deinit(self: *const Self) void { // make sure the command buffer isn't in use before destroying it.. self.dev.waitIdle() catch {}; self.dev.pr_dev.freeCommandBuffers( @@ -112,7 +112,7 @@ pub fn deinit(self: *const CommandBuffer) void { ); } -const res = @import("../mem/resource_manager.zig"); +const res = @import("../res/res.zig"); pub const CommandBuffer = struct { h_cmd_buffer: vk.CommandBuffer, @@ -122,24 +122,44 @@ pub const CommandBuffer = struct { one_shot: bool = false, }; -const Entry = res.Registry.AddEntry(.{ - .state = CommandBuffer, - .proxy = CommandBufferProxy, -}, init, deinit); +const CommandBufferInitErrors = error { + Something, +}; + +fn dummyInit(self: *CommandBuffer, ctx: *const Context, config: Config) CommandBufferInitErrors!void { + _ = self; + _ = config; + _ = ctx; +} + +fn dummyDeinit(self: *const CommandBuffer) void { + _ = self; +} + +const Registry = @import("../res/res.zig").Registry; +pub fn addEntries(reg: *Registry) !void { + try reg.AddEntry(.{ + .state = CommandBuffer, + .proxy = CommandBufferProxy, + .init_errors =CommandBufferInitErrors, + .config_type = Config, + .management = .Pooled, + .requires_alloc = false, + }, dummyInit, dummyDeinit); +} pub const CommandBufferProxy = struct { const CommandBufferHandle = res.Handle(CommandBuffer); handle: CommandBufferHandle, - pub const bind = Entry.bindFn; - // easier than "Factory.destroyHandle(thing)" - pub const deinit = Entry.deinitFn; + //pub const bind = Entry.bindFn; + //// easier than "Factory.destroyHandle(thing)" + //pub const deinit = Entry.deinitFn; - pub const submit = res.APIFunction(submit); - pub const reset = res.APIFunction(reset); - pub const begin = res.APIFunction(begin); - pub const beginConfig = res.APIFunction(beginConfig); - pub const end = res.APIFunction(end); + //pub const submit = res.APIFunction(submit); + //pub const reset = res.APIFunction(reset); + //pub const begin = res.APIFunction(begin); + //pub const beginConfig = res.APIFunction(beginConfig); + //pub const end = res.APIFunction(end); }; - diff --git a/src/context.zig b/src/context.zig index 5815999..d7a3f6a 100644 --- a/src/context.zig +++ b/src/context.zig @@ -4,9 +4,11 @@ const vk = @import("vulkan"); const glfw = @import("glfw"); const e = @import("env.zig"); +const res = @import("res/res.zig"); const Allocator = std.mem.Allocator; const ExtensionNameList = std.ArrayList([*:0]const u8); +const Registry = res.Registry; const Device = api.DeviceHandler; const Instance = api.InstanceHandler; @@ -54,6 +56,9 @@ compute_queue: api.ComputeQueue, allocator: Allocator, +resources: res.ResourceManager, +registry: Registry, + fn ResolveEnvType(comptime field: anytype) type { return switch (@TypeOf(field)) { void => *const Environment, @@ -94,6 +99,7 @@ pub const Config = struct { dev_extensions: []const [*:0]const u8 = &.{}, window: *const glfw.Window, loader: glfw.GetProcAddrHandler, + management: res.ResourceManager.Config, }; /// TODO: maybe have an unmanaged variant for more fine-grained user control @@ -177,6 +183,11 @@ pub fn init(allocator: Allocator, config: Config) !*Self { new.ctx_env = Environment.init(new); + new.registry = try Registry.init(allocator); + try api.initRegistry(&new.registry); + + new.resources = try res.ResourceManager.init(config.management, new.registry); + return new; } @@ -184,6 +195,7 @@ pub fn deinit(self: *Self) void { self.dev.deinit(); self.surf.deinit(); self.inst.deinit(); + self.registry.deinit(); const alloc = self.allocator; alloc.destroy(self); diff --git a/src/mem/registry.zig b/src/mem/registry.zig deleted file mode 100644 index b6de4e7..0000000 --- a/src/mem/registry.zig +++ /dev/null @@ -1,90 +0,0 @@ -const std = @import("std"); - -const common = @import("common.zig"); -const Context = @import("../context.zig"); - -const Allocator = std.mem.Allocator; -const AnyPtr = common.AnyPtr; -const TypeId = common.TypeId; - -const Self = @This(); - -pub const EntryConfig = struct { - // type for storing data - state: type, - - // type for associating and operating on data - proxy: type, - - // error set for init functions (omit for anyerror) - init_errors: ?type, - - // the type of the configuration struct (if any) - config_type: ?type = null, - // whether or not initialization depends on an allocator - requires_alloc: bool = false, -}; - - -// this returns the meta-information of the registry entry -// (underlying function types, unique type identifier) -pub fn RegistryEntryType(comptime config: EntryConfig) type { - return struct { - // remember, these functions should be remapped first arguments to the proxy - pub const InitFnType = InitFnTemplate(config), - pub const DeinitFnType = DeinitFnTemplate(config), - pub const entry_id = helpers.typeId(config.state); - }; -}; - - -/// NOTE: this could be a lot less branchy and stupid, but -/// that would come at the cost of @Type, which is not supported -/// by LSPs. I might redo this if it turns out this template doesn't -/// get directly touched by user code. -fn InitFnTemplate(comptime config: EntryConfig) type { - const error_type = config.init_errors orelse anyerror; - if (config.config_type) |ct| { - if (config.requires_alloc) { - return *const fn (*config.state, *const Context, Allocator, ct) error_type!void; - } else { - return *const fn (*config.state, *const Context, ct) error_type!void; - } - } else { - if (config.requires_alloc) { - return *const fn (*config.state, *const Context, Allocator) error_type!void; - } else { - return *const fn (*config.state, *const Context) error_type!void; - } - } -} - -fn DeinitFnTemplate(comptime config: EntryConfig) type { - return if (config.requires_alloc) - (*const fn (*config.state, Allocator) void) - else - (*const fn (*config.state) void); -} - -pub const RegistryEntry = struct { - type_id: TypeId, - initFn: AnyPtr, - deinitFn: AnyPtr, -}; - -// Radix-sorted list of entries by type id -const entries: []RegistryEntry; - -pub fn AddEntry( - self: *Self, - comptime config: EntryConfig, - initFn: InitFnTemplate(config), - deinitFn: DeinitFnTemplate(config), -) *const RegistryEntry { - const EntryType = RegistryEntryType(config); - const entry = RegistryEntry{ - .initFn = AnyPtr.from(EntryType.InitFn, initFn), - .deinitFn = AntPtr.from(EntryType.DeinitFn, deinitFn), - }; - -} diff --git a/src/mem/resource_manager.zig b/src/mem/resource_manager.zig deleted file mode 100644 index 1a22007..0000000 --- a/src/mem/resource_manager.zig +++ /dev/null @@ -1,16 +0,0 @@ -const Self = @This(); - -pub const Registry = @import("registry.zig"); -const h = @import("handle.zig"); - -pub const Handle = h.Handle; -pub const OpaqueHandle = h.OpaqueHandle; - - -pub const Config = struct { - -}; - - -pub fn init(config: Config) void { -} diff --git a/src/mem/common.zig b/src/res/common.zig similarity index 83% rename from src/mem/common.zig rename to src/res/common.zig index c25dcae..6e4bb64 100644 --- a/src/mem/common.zig +++ b/src/res/common.zig @@ -31,6 +31,15 @@ pub const AnyPtr = struct { .id = typeId(T), }; } + + /// Used if the underlying type is already a pointer + pub fn fromDirect(comptime T: type, ptr: T) AnyPtr { + return .{ + // Only reason const cast is here is because I'm probably gonna toss this entire type + .ptr = @constCast(ptr), + .id = typeId(T), + }; + } pub fn get(self: AnyPtr, comptime T: type) *T { assert(self.id == typeId(T)); diff --git a/src/mem/handle.zig b/src/res/handle.zig similarity index 100% rename from src/mem/handle.zig rename to src/res/handle.zig diff --git a/src/mem/pool_allocator.zig b/src/res/pool_allocator.zig similarity index 96% rename from src/mem/pool_allocator.zig rename to src/res/pool_allocator.zig index a63678d..d512edd 100644 --- a/src/mem/pool_allocator.zig +++ b/src/res/pool_allocator.zig @@ -61,12 +61,11 @@ const FreeSpaceList = struct { const n = node orelse return null; if (n.data.elem_count > count) { - const block_size = n.data.elem_count - count; - const bytes_size = block_size * self.elem_size; + const bytes_size = count * self.elem_size; const new_node: *ListNode = @ptrFromInt(@intFromPtr(n) + bytes_size); new_node.* = .{ .data = .{ - .elem_count = block_size, + .elem_count = n.data.elem_count - count, } }; self.free_nodes.prepend(new_node); @@ -114,7 +113,7 @@ pub fn TypedPool(comptime T: type) type { }; return Pool{ - .inner = Self.initAlloc(allocator, pool_config), + .inner = try Self.initAlloc(allocator, pool_config), }; } @@ -202,6 +201,7 @@ pub fn freeAll(self: *Self) void { // no leakage issues since the list is stored in-place self.free_space = FreeSpaceList.init(self.buf, self.config.elem_size); } + /// ## Notes: /// * Directly passed buffer must respect alginment requirements /// of the state type @@ -262,5 +262,5 @@ test "out of memory" { defer pool.deinit(); _ = try pool.reserveRange(120); - testing.expectError(PoolErrors.OutOfMemory, pool.reserveRange(905)); + try testing.expectError(PoolErrors.OutOfMemory, pool.reserveRange(905)); } diff --git a/src/res/registry.zig b/src/res/registry.zig new file mode 100644 index 0000000..ec16026 --- /dev/null +++ b/src/res/registry.zig @@ -0,0 +1,239 @@ +//! Registry for all existing API types containg information about +//! how they should be handled by the resource manager/API handlers +//! +//!NOTE: +//! This is globally defined and not scoped to an application context +const std = @import("std"); + +const common = @import("common.zig"); +const Context = @import("../context.zig"); + +const Allocator = std.mem.Allocator; +const AnyPtr = common.AnyPtr; +const TypeId = common.TypeId; + +const Self = @This(); + +pub const EntryConfig = struct { + // type for storing data + state: type, + + // type for associating and operating on data + proxy: type, + + // error set for init functions (omit for anyerror) + init_errors: ?type, + + // the type of the configuration struct (if any) + config_type: ?type = null, + // whether or not initialization depends on an allocator + requires_alloc: bool = false, + management: ManagementMode = .Pooled, +}; + +// this returns the meta-information of the registry entry +// (underlying function types, unique type identifier) +pub fn RegistryEntryType(comptime config: EntryConfig) type { + return struct { + // remember, these functions should be remapped first arguments to the proxy + pub const InitFnType = InitFnTemplate(config); + pub const DeinitFnType = DeinitFnTemplate(config); + pub const entry_id = common.typeId(config.state); + }; +} + +/// NOTE: this could be a lot less branchy and stupid, but +/// that would come at the cost of @Type, which is not supported +/// by LSPs. I might redo this if it turns out this template doesn't +/// get directly touched by user code. +fn InitFnTemplate(comptime config: EntryConfig) type { + const error_type = config.init_errors orelse anyerror; + if (config.config_type) |ct| { + if (config.requires_alloc) { + return *const fn (*config.state, *const Context, Allocator, ct) error_type!void; + } else { + return *const fn (*config.state, *const Context, ct) error_type!void; + } + } else { + if (config.requires_alloc) { + return *const fn (*config.state, *const Context, Allocator) error_type!void; + } else { + return *const fn (*config.state, *const Context) error_type!void; + } + } +} + +fn DeinitFnTemplate(comptime config: EntryConfig) type { + return if (config.requires_alloc) + (*const fn (*config.state, Allocator) void) + else + (*const fn (*config.state) void); +} + +pub const RegistryEntry = struct { + type_id: TypeId, + type_name: []const u8, + + initFn: AnyPtr, + deinitFn: AnyPtr, + + management: ManagementMode, +}; + +pub const ManagementMode = enum { + Unmanaged, + Pooled, + SomeThirdThing, +}; + +entries: std.ArrayList(RegistryEntry), + +pub fn init(allocator: Allocator) !Self { + return .{ + .entries = std.ArrayList(RegistryEntry).init(allocator), + }; +} + +pub fn AddEntry( + self: *Self, + comptime config: EntryConfig, + comptime initFn: InitFnTemplate(config), + comptime deinitFn: DeinitFnTemplate(config), +) !void { + const EntryType = RegistryEntryType(config); + + const entry = RegistryEntry{ + .initFn = AnyPtr.fromDirect(EntryType.InitFnType, initFn), + .deinitFn = AnyPtr.fromDirect(EntryType.DeinitFnType, deinitFn), + + .type_id = common.typeId(config.state), + .type_name = @typeName(config.state), + .management = config.management, + }; + + try self.entries.append(entry); +} + +pub const PredicateFn = *const fn (*const RegistryEntry) bool; +pub const Predicate = struct { + pub fn ManagementModeIs(comptime mode: ManagementMode) PredicateFn { + const Container = struct { + pub fn predicate(entry: *const RegistryEntry) bool { + return entry.management == mode; + } + }; + + return Container.predicate; + } + + pub fn TypeIdMatches(comptime id: TypeId) PredicateFn { + const Container = struct { + pub fn predicate(entry: *const RegistryEntry) bool { + return entry.type_id == id; + } + }; + + return Container.predicate; + } +}; + +const debug = std.debug; + +pub const Query = struct { + const MAX_PREDICATES = 6; + + predicates: [MAX_PREDICATES]PredicateFn, + num_predicates: u8, + entries: []RegistryEntry, + + pub const Iterator = struct { + entries: []const RegistryEntry, + predicates: []PredicateFn, + index: usize, + + fn matches(self: *Iterator, entry: *const RegistryEntry) bool { + for (self.predicates) |p| { + if (!p(entry)) return false; + } + + return true; + } + + pub fn next(self: *Iterator) ?*const RegistryEntry { + while (self.index < self.entries.len and + !self.matches(&self.entries[self.index])) : (self.index += 1) + {} + + return if (self.index < self.entries.len) + &self.entries[self.index] + else + null; + } + }; + + pub fn where(self: *Query, predicate: PredicateFn) *Query { + debug.assert(self.num_predicates < MAX_PREDICATES); + + self.predicates[@intCast(self.num_predicates)] = predicate; + self.num_predicates += 1; + + return self; + } + + pub fn iterator(self: *Query) Iterator { + return Iterator{ + .index = 0, + .entries = self.entries, + .predicates = self.predicates[0..self.num_predicates], + }; + } + + pub fn first(self: *Query) ?*const RegistryEntry { + var iter = self.iterator(); + return iter.next(); + } +}; + +/// begins an entry selection query +pub fn select(self: *Self) Query { + return Query{ + .predicates = [_]PredicateFn{undefined} ** Query.MAX_PREDICATES, + .num_predicates = 0, + .entries = self.entries.items, + }; +} + +pub fn deinit(self: *Self) void { + self.entries.deinit(); +} + +const api = @import("../api/api.zig"); +const testing = std.testing; + +const NonexistentStruct = struct {}; + +test "api entries" { + // try querying an existing entry + var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); + defer arena.deinit(); + + var reg = try Self.init(arena.allocator()); + try api.initRegistry(®); + + var q1 = reg.select(); + const item = q1 + .where(Predicate.ManagementModeIs(.Pooled)) + .where(Predicate.TypeIdMatches(common.typeId(api.CommandBuffer.CommandBuffer))) + .first(); + + try testing.expect(item != null); + try testing.expect(item.?.type_id == common.typeId(api.CommandBuffer.CommandBuffer)); + + // try querying for something that doesn't exist + var q2 = reg.select(); + const nonexistent = q2 + .where(Predicate.TypeIdMatches(common.typeId(NonexistentStruct))) + .first(); + + try testing.expect(nonexistent == null); +} diff --git a/src/res/res.zig b/src/res/res.zig new file mode 100644 index 0000000..40fba8d --- /dev/null +++ b/src/res/res.zig @@ -0,0 +1,7 @@ + +pub const Registry = @import("registry.zig"); +pub const PoolAllocator = @import("pool_allocator.zig"); +pub const ResourceManager = @import("resource_manager.zig"); + +pub const OpaqueHandle = @import("handle.zig").OpaqueHandle; +pub const Handle = @import("handle.zig").Handle; diff --git a/src/res/resource_manager.zig b/src/res/resource_manager.zig new file mode 100644 index 0000000..916e609 --- /dev/null +++ b/src/res/resource_manager.zig @@ -0,0 +1,51 @@ +const std = @import("std"); +const Self = @This(); + +const common = @import("common.zig"); +const Registry = @import("registry.zig"); +const h = @import("handle.zig"); + +const PoolAllocator = @import("pool_allocator.zig"); +const Allocator = std.mem.Allocator; + +const TypeId = common.TypeId; +const MemoryPoolsTable = std.AutoHashMap(TypeId, PoolAllocator); + +const Handle = h.Handle; +const OpaqueHandle = h.OpaqueHandle; +const Predicate = Registry.Predicate; + +pub const Config = struct { + allocator: Allocator, + pool_sizes: usize, +}; + +pools: MemoryPoolsTable, + +pub fn init(config: Config, registry: Registry) !Self { + // loop through each API registry entry + // and initialize the table with a pool for each entry + // whose management strategy is tagged as "Pooled" + + const entries = registry.select() + .where(Predicate.ManagementModeIs(.Pooled)) + .iterator(); + + var table = MemoryPoolsTable.init(config.allocator); + + while (entries.next()) |entry| { + std.debug.print("Creating pool for type {s}\n", .{entry.type_name}); + const pool_config = PoolAllocator.Config{ + .elem_size = entry.size_bytes, + .elem_count = config.pool_sizes, + }; + + try table.put(entry.id, + try PoolAllocator.initAlloc(config.allocator, pool_config), + ); + } + + return Self{ + .pools = table, + }; +} diff --git a/src/mem/unused.zig b/src/res/unused.zig similarity index 100% rename from src/mem/unused.zig rename to src/res/unused.zig diff --git a/src/root.zig b/src/root.zig index ba97013..a219005 100644 --- a/src/root.zig +++ b/src/root.zig @@ -1,5 +1,19 @@ pub const Context = @import("context.zig"); +// Low-Level vulkan wrappers pub const api = @import("api/api.zig"); + +// Linear algebra math pub const math = @import("math.zig"); + +// random common utilities (i.e: "misc") pub const util = @import("util.zig"); + +// Resource manager NOTE: (not sure if this should be exported tbh) +pub const res = @import("res/res.zig"); + +// imports for testing +comptime { + _ = @import("res/pool_allocator.zig"); + _ = @import("res/registry.zig"); +} diff --git a/src/test/test_all.zig b/src/test/test_all.zig new file mode 100644 index 0000000..d26f356 --- /dev/null +++ b/src/test/test_all.zig @@ -0,0 +1,4 @@ + +comptime { + _ = @import("../mem/pool_allocator.zig"); +} diff --git a/test/test_math.zig b/src/test/test_math.zig similarity index 98% rename from test/test_math.zig rename to src/test/test_math.zig index 04fb618..1c8093d 100644 --- a/test/test_math.zig +++ b/src/test/test_math.zig @@ -1,3 +1,4 @@ +//! WARN: Hopelessly out of date with current const meth = @import("ray").meth; const std = @import("std"); diff --git a/src/test/unit_test.zig b/src/test/unit_test.zig new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/test/unit_test.zig @@ -0,0 +1 @@ + diff --git a/src/test_all.zig b/src/test_all.zig deleted file mode 100644 index 38b6580..0000000 --- a/src/test_all.zig +++ /dev/null @@ -1,5 +0,0 @@ - - -comptime { - _ = @import("../src/main.zig"); -} diff --git a/test/test_env.zig b/test/test_env.zig deleted file mode 100644 index 92fce2b..0000000 --- a/test/test_env.zig +++ /dev/null @@ -1,54 +0,0 @@ -const std = @import("std"); - -const expect = std.testing.expect; - -var testing_allocator = std.heap.DebugAllocator(.{ .safety = true }).init; - -test "context initialization" { - const alloc = testing_allocator.allocator(); - const window = try makeBasicWindow(900, 600, "Actual Test Window"); - defer glfw.terminate(); - defer window.destroy(); - - const ctx = try Context.init(alloc, .{ - .window = &window, - .loader = glfw.glfwGetInstanceProcAddress, - .inst_extensions = glfwInstanceExtensions(), - }); - defer ctx.deinit(); -} - -test "environment querying" { - const alloc = testing_allocator.allocator(); - const window = try makeBasicWindow(900, 600, "Actual Actual Test Window"); - defer glfw.terminate(); - defer window.destroy(); - - const ctx = try Context.init(alloc, .{ - .window = &window, - .loader = glfw.glfwGetInstanceProcAddress, - .inst_extensions = glfwInstanceExtensions(), - }); - defer ctx.deinit(); - - const global_interface: *const ray.api.GlobalInterface = ctx.env(.gi); - const instance_interface = ctx.env(.ii); - const dev_interface = ctx.env(.di); - - std.debug.print("global_interface type: {s}\n", .{@typeName(@TypeOf(global_interface))}); - std.debug.print("instance_interface type: {s}\n", .{@typeName(@TypeOf(instance_interface))}); - std.debug.print("dev_interface type: {s}\n", .{@typeName(@TypeOf(dev_interface))}); - - //TODO: Do some rudimentary vulkan API test call. - const available = global_interface.enumerateInstanceExtensionPropertiesAlloc( - null, - alloc, - ) catch { - return error.ExtensionEnumerationFailed; - }; - defer alloc.free(available); -} - -test "basic vulkan type creation" { - try expect(true); -} From a181579a13ea344cc9a1790f96528f35116f3b40 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 15 Aug 2025 19:49:02 -0700 Subject: [PATCH 05/46] fix(imports): Slightly clean up the file structure (more work needs to be done here) --- src/api/api.zig | 2 +- src/api/command_buffer.zig | 9 +++++---- src/{res => common}/common.zig | 4 ++++ src/{res => common}/handle.zig | 0 src/context.zig | 2 +- src/{res => resource_management}/pool_allocator.zig | 2 +- src/{res => resource_management}/registry.zig | 11 ++++++----- src/{res => resource_management}/res.zig | 3 --- src/{res => resource_management}/resource_manager.zig | 7 +++---- src/{res => resource_management}/unused.zig | 0 src/root.zig | 6 +++--- src/util.zig | 3 +++ 12 files changed, 27 insertions(+), 22 deletions(-) rename src/{res => common}/common.zig (94%) rename src/{res => common}/handle.zig (100%) rename src/{res => resource_management}/pool_allocator.zig (99%) rename src/{res => resource_management}/registry.zig (96%) rename src/{res => resource_management}/res.zig (59%) rename src/{res => resource_management}/resource_manager.zig (90%) rename src/{res => resource_management}/unused.zig (100%) diff --git a/src/api/api.zig b/src/api/api.zig index 8614ec4..f1b37ec 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -65,7 +65,7 @@ pub const Fence = sync.Fence; pub const ShaderModule = sh.Module; // Obtaining RTTI for vulkan API -const Registry = @import("../res/res.zig").Registry; +const Registry = @import("../resource_management/res.zig").Registry; pub fn initRegistry(reg: *Registry) !void { try CommandBuffer.addEntries(reg); } diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index 99e4440..9f6b909 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -112,7 +112,8 @@ pub fn deinit(self: *const Self) void { ); } -const res = @import("../res/res.zig"); +const res = @import("../resource_management/res.zig"); +const common = @import("../common/common.zig"); pub const CommandBuffer = struct { h_cmd_buffer: vk.CommandBuffer, @@ -136,9 +137,9 @@ fn dummyDeinit(self: *const CommandBuffer) void { _ = self; } -const Registry = @import("../res/res.zig").Registry; +const Registry = res.Registry; pub fn addEntries(reg: *Registry) !void { - try reg.AddEntry(.{ + reg.addEntry(.{ .state = CommandBuffer, .proxy = CommandBufferProxy, .init_errors =CommandBufferInitErrors, @@ -149,7 +150,7 @@ pub fn addEntries(reg: *Registry) !void { } pub const CommandBufferProxy = struct { - const CommandBufferHandle = res.Handle(CommandBuffer); + const CommandBufferHandle = common.Handle(CommandBuffer); handle: CommandBufferHandle, diff --git a/src/res/common.zig b/src/common/common.zig similarity index 94% rename from src/res/common.zig rename to src/common/common.zig index 6e4bb64..f1c7c42 100644 --- a/src/res/common.zig +++ b/src/common/common.zig @@ -1,6 +1,10 @@ const std = @import("std"); const assert = std.debug.assert; +const h = @import("handle.zig"); +pub const Handle = h.Handle; +pub const OpaqueHandle = h.OpaqueHandle; + /// This is cursed as hell.. /// Returns a unique identifier for any type at comptime or runtime /// https://github.com/ziglang/zig/issues/19858#issuecomment-2094339450 diff --git a/src/res/handle.zig b/src/common/handle.zig similarity index 100% rename from src/res/handle.zig rename to src/common/handle.zig diff --git a/src/context.zig b/src/context.zig index d7a3f6a..57c8b1b 100644 --- a/src/context.zig +++ b/src/context.zig @@ -4,7 +4,7 @@ const vk = @import("vulkan"); const glfw = @import("glfw"); const e = @import("env.zig"); -const res = @import("res/res.zig"); +const res = @import("resource_management/res.zig"); const Allocator = std.mem.Allocator; const ExtensionNameList = std.ArrayList([*:0]const u8); diff --git a/src/res/pool_allocator.zig b/src/resource_management/pool_allocator.zig similarity index 99% rename from src/res/pool_allocator.zig rename to src/resource_management/pool_allocator.zig index d512edd..cde7ed9 100644 --- a/src/res/pool_allocator.zig +++ b/src/resource_management/pool_allocator.zig @@ -14,7 +14,7 @@ //! which match vulkan object's lifetimes (generally they are the same per-type of object) const std = @import("std"); -const common = @import("common.zig"); +const common = @import("../common/common.zig"); const assert = std.debug.assert; const Allocator = std.mem.Allocator; diff --git a/src/res/registry.zig b/src/resource_management/registry.zig similarity index 96% rename from src/res/registry.zig rename to src/resource_management/registry.zig index ec16026..d506e09 100644 --- a/src/res/registry.zig +++ b/src/resource_management/registry.zig @@ -5,7 +5,7 @@ //! This is globally defined and not scoped to an application context const std = @import("std"); -const common = @import("common.zig"); +const common = @import("../common/common.zig"); const Context = @import("../context.zig"); const Allocator = std.mem.Allocator; @@ -94,12 +94,12 @@ pub fn init(allocator: Allocator) !Self { }; } -pub fn AddEntry( +pub fn addEntry( self: *Self, comptime config: EntryConfig, comptime initFn: InitFnTemplate(config), comptime deinitFn: DeinitFnTemplate(config), -) !void { +) void { const EntryType = RegistryEntryType(config); const entry = RegistryEntry{ @@ -110,8 +110,9 @@ pub fn AddEntry( .type_name = @typeName(config.state), .management = config.management, }; - - try self.entries.append(entry); + + // If the type registry fails to build, there is literally nothing to be done about it. + self.entries.append(entry) catch @panic("Failed to build type registry due to an allocation error!"); } pub const PredicateFn = *const fn (*const RegistryEntry) bool; diff --git a/src/res/res.zig b/src/resource_management/res.zig similarity index 59% rename from src/res/res.zig rename to src/resource_management/res.zig index 40fba8d..bef67b0 100644 --- a/src/res/res.zig +++ b/src/resource_management/res.zig @@ -2,6 +2,3 @@ pub const Registry = @import("registry.zig"); pub const PoolAllocator = @import("pool_allocator.zig"); pub const ResourceManager = @import("resource_manager.zig"); - -pub const OpaqueHandle = @import("handle.zig").OpaqueHandle; -pub const Handle = @import("handle.zig").Handle; diff --git a/src/res/resource_manager.zig b/src/resource_management/resource_manager.zig similarity index 90% rename from src/res/resource_manager.zig rename to src/resource_management/resource_manager.zig index 916e609..f618e3b 100644 --- a/src/res/resource_manager.zig +++ b/src/resource_management/resource_manager.zig @@ -1,9 +1,8 @@ const std = @import("std"); const Self = @This(); -const common = @import("common.zig"); +const common = @import("../common/common.zig"); const Registry = @import("registry.zig"); -const h = @import("handle.zig"); const PoolAllocator = @import("pool_allocator.zig"); const Allocator = std.mem.Allocator; @@ -11,8 +10,8 @@ const Allocator = std.mem.Allocator; const TypeId = common.TypeId; const MemoryPoolsTable = std.AutoHashMap(TypeId, PoolAllocator); -const Handle = h.Handle; -const OpaqueHandle = h.OpaqueHandle; +const Handle = common.Handle; +const OpaqueHandle = common.OpaqueHandle; const Predicate = Registry.Predicate; pub const Config = struct { diff --git a/src/res/unused.zig b/src/resource_management/unused.zig similarity index 100% rename from src/res/unused.zig rename to src/resource_management/unused.zig diff --git a/src/root.zig b/src/root.zig index a219005..18c253f 100644 --- a/src/root.zig +++ b/src/root.zig @@ -10,10 +10,10 @@ pub const math = @import("math.zig"); pub const util = @import("util.zig"); // Resource manager NOTE: (not sure if this should be exported tbh) -pub const res = @import("res/res.zig"); +pub const res = @import("resource_management/res.zig"); // imports for testing comptime { - _ = @import("res/pool_allocator.zig"); - _ = @import("res/registry.zig"); + _ = @import("resource_management/pool_allocator.zig"); + _ = @import("resource_management/registry.zig"); } diff --git a/src/util.zig b/src/util.zig index 83eb030..02e8316 100644 --- a/src/util.zig +++ b/src/util.zig @@ -1,3 +1,6 @@ +//! TODO: Merge this into the common directory +//! Most of this is completely unused and useless, so +//! only a bit of this iwll be included... const std = @import("std"); pub fn asCString(rep: anytype) [*:0]const u8 { return @as([*:0]const u8, @ptrCast(rep)); From 3ac83fed002f15021b63764005c6a1054035e150 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 16 Aug 2025 15:22:25 -0700 Subject: [PATCH 06/46] chore(pool_allocator): update pool allocator with spec for handle-based allocations --- src/factory.zig | 3 +++ src/resource_management/pool_allocator.zig | 4 +++- 2 files changed, 6 insertions(+), 1 deletion(-) create mode 100644 src/factory.zig diff --git a/src/factory.zig b/src/factory.zig new file mode 100644 index 0000000..ad118a8 --- /dev/null +++ b/src/factory.zig @@ -0,0 +1,3 @@ +//! low-level API factory -- contains initializers +//! for memory managed API types which are in turn wrappers +//! to their unmanaged versions... diff --git a/src/resource_management/pool_allocator.zig b/src/resource_management/pool_allocator.zig index cde7ed9..bc219cc 100644 --- a/src/resource_management/pool_allocator.zig +++ b/src/resource_management/pool_allocator.zig @@ -199,6 +199,7 @@ pub fn free(self: *Self, item: *anyopaque) void { pub fn freeAll(self: *Self) void { // Just overwrite the existing free space list with a new one, which will cover the entire pool // no leakage issues since the list is stored in-place + // of course, existing allocations are all invalidated and can be overwritten whenever now self.free_space = FreeSpaceList.init(self.buf, self.config.elem_size); } @@ -206,11 +207,12 @@ pub fn freeAll(self: *Self) void { /// * Directly passed buffer must respect alginment requirements /// of the state type pub fn init(buf: []u8, config: Config) Self { + const resolved_size: usize = @min(@sizeOf(FreeSpaceList.ListNode), config.elem_size); return .{ .config = config, .buf = buf, - .free_space = FreeSpaceList.init(buf, config.elem_size), + .free_space = FreeSpaceList.init(buf, resolved_size), }; } From 4951574f9773caf22dee8da3bb638809ad6096b5 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 17 Aug 2025 17:45:43 -0700 Subject: [PATCH 07/46] feat(vulkan): added a descriptor pool manager with configurable pools to be selected based on descriptor usage hints --- src/api/allocator.zig | 8 + src/api/base.zig | 22 +- src/api/common.zig | 47 +++ src/api/descriptor.zig | 42 +-- src/api/descriptor_pool.zig | 315 +++++++++++++++++++++ src/api/types.zig | 9 - src/context.zig | 2 +- src/glfw.zig | 5 + src/resource_management/pool_allocator.zig | 6 + 9 files changed, 409 insertions(+), 47 deletions(-) create mode 100644 src/api/allocator.zig create mode 100644 src/api/common.zig create mode 100644 src/api/descriptor_pool.zig delete mode 100644 src/api/types.zig diff --git a/src/api/allocator.zig b/src/api/allocator.zig new file mode 100644 index 0000000..252b871 --- /dev/null +++ b/src/api/allocator.zig @@ -0,0 +1,8 @@ +//! Vulkan-specific allocator for giving user control over host and device-side allocations. +//! Of course, the standard zig allocation interface is great but it's usage doesn't +//! fit well into device-side memory allocations, so we have this. +//! +//! I will do my best to keep the implementation of this allocator be as in-line as possible +//! to the standard memory allocation interface (if I can I will support creating +//! std.mem.Allocators). + diff --git a/src/api/base.zig b/src/api/base.zig index c9088b1..64b024f 100644 --- a/src/api/base.zig +++ b/src/api/base.zig @@ -652,17 +652,23 @@ pub const SurfaceHandler = struct { h_window: *const glfw.Window = undefined, h_surface: vk.SurfaceKHR = .null_handle, ctx: *const InstanceHandler = undefined, - - pub fn init(window: *const glfw.Window, ctx: *const InstanceHandler) !SurfaceHandler { - var surface: vk.SurfaceKHR = undefined; - - if (glfw.glfwCreateWindowSurface(ctx.pr_inst.handle, window.handle, null, &surface) != .success) { - log.debug("failed to create window surface!", .{}); - return error.SurfaceCreationFailed; + + /// Only reason window is optional is if we don't care + /// about presenting to a screen. + /// It is on the user to not create types that involve a window + /// -- may redo later for easier use and more predictable errors + pub fn init(window: ?*const glfw.Window, ctx: *const InstanceHandler) !SurfaceHandler { + var surface: vk.SurfaceKHR = .null_handle; + + if (window) |w| { + if (glfw.glfwCreateWindowSurface(ctx.pr_inst.handle, w.handle, null, &surface) != .success) { + log.debug("failed to create window surface!", .{}); + return error.SurfaceCreationFailed; + } } return SurfaceHandler{ - .h_window = window, + .h_window = window orelse undefined, .h_surface = surface, .ctx = ctx, }; diff --git a/src/api/common.zig b/src/api/common.zig new file mode 100644 index 0000000..3588994 --- /dev/null +++ b/src/api/common.zig @@ -0,0 +1,47 @@ +const vk = @import("vulkan"); + +pub const SyncInfo = struct { + fence_sig: ?vk.Fence = null, + fence_wait: ?vk.Fence = null, + + sem_sig: ?vk.Semaphore = null, + sem_wait: ?vk.Semaphore = null, +}; + +pub const DescriptorUsageInfo = packed struct { + /// THis just directly controls which pool the descriptor is + /// allocated into. For the moment, all descriptors will be + /// either transient or application scoped + pub const LifetimeScope = enum { + /// descriptor exists for just a single frame + /// which places it into the "transient" pool + Transient, + + /// Descriptor exists for a longer time, but + /// can still be freed and replaced. This pool still follows vulkan + /// rules, but "freed" descriptors are placed into a free store + /// which allows them to be rewritten instead of being completely reallocated. + Scene, + + /// These descriptors are completely static. Never to be freed until the application dies + Static, + }; + + lifetime_bits: LifetimeScope, +}; + +pub const DescriptorType = enum(u8) { + Uniform, + Sampler, + StorageBuffer, + Image, + + pub fn toVkDescriptor(self: DescriptorType) vk.DescriptorType { + return switch(self) { + .Uniform => .uniform_buffer, + .Sampler => .combined_image_sampler, + .StorageBuffer => .storage_buffer, + .Image => .storage_image, + }; + } +}; diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index a449b53..16b86ee 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -6,8 +6,7 @@ const vk = @import("vulkan"); const util = @import("../util.zig"); const uniform = @import("uniform.zig"); const buffer = @import("buffer.zig"); - -const many = util.asManyPtr; +const common = @import("common.zig"); const Allocator = std.mem.Allocator; @@ -35,12 +34,7 @@ fn createDescriptorPool(pr_dev: *const vk.DeviceProxy) !vk.DescriptorPool { }, null); } -pub const DescriptorType = enum(u8) { - Uniform, - Sampler, - StorageBuffer, - Image, -}; +pub const DescriptorType = common.DescriptorType; pub const ResolvedBinding = struct { stages: vk.ShaderStageFlags, @@ -77,7 +71,6 @@ pub const Config = struct { }; h_desc_layout: vk.DescriptorSetLayout, -h_desc_pool: vk.DescriptorPool, h_desc_set: vk.DescriptorSet, pr_dev: *const vk.DeviceProxy, allocator: Allocator, @@ -176,10 +169,9 @@ fn updateDescriptorSets( writes[index].descriptor_type = dt; - writes[index].p_buffer_info = many( - vk.DescriptorBufferInfo, - &write_infos[index].Buffer, - ); + writes[index].p_buffer_info = &.{ + write_infos[index].Buffer, + }; }, } } @@ -194,6 +186,7 @@ fn updateDescriptorSets( pub fn init(ctx: *const Context, allocator: Allocator, config: Config) !Self { const dev: *const DeviceHandler = ctx.env(.dev); + var desc_pools = ctx.env(.desc); var desc_bindings = try allocator.alloc( vk.DescriptorSetLayoutBinding, @@ -213,16 +206,7 @@ pub fn init(ctx: *const Context, allocator: Allocator, config: Config) !Self { null, ); - const desc_pool = try createDescriptorPool(&dev.pr_dev); - errdefer dev.pr_dev.destroyDescriptorPool(desc_pool, null); - - var desc_set = [_]vk.DescriptorSet{.null_handle}; - - try dev.pr_dev.allocateDescriptorSets(&.{ - .descriptor_pool = desc_pool, - .descriptor_set_count = 1, - .p_set_layouts = many(vk.DescriptorSetLayout, &desc_layout), - }, desc_set[0..]); + const desc_set = try desc_pools.reserve(config.usage, desc_layout); // setup the bloody descriptor sets and associate them wit the buffer const owned_bindings = try allocator.alloc( @@ -234,9 +218,8 @@ pub fn init(ctx: *const Context, allocator: Allocator, config: Config) !Self { var descriptor = Self{ .h_desc_layout = desc_layout, - .h_desc_pool = desc_pool, .pr_dev = &dev.pr_dev, - .h_desc_set = desc_set[0], + .h_desc_set = desc_set, .resolved_bindings = owned_bindings, .allocator = allocator, }; @@ -263,15 +246,16 @@ pub fn bind( layout, 0, 1, - many(vk.DescriptorSet, &self.h_desc_set), + &.{self.h_desc_set}, 0, null, ); } -pub fn deinit(self: *Self) void { - self.pr_dev.destroyDescriptorPool(self.h_desc_pool, null); - self.pr_dev.destroyDescriptorSetLayout(self.h_desc_layout, null); +pub fn deinit(self: *Self, ctx: *const Context) void { + var desc_pool = ctx.env(.desc); + // this may do nothing depending on usage + desc_pool.free(self.usage, self.h_desc_set); self.allocator.free(self.resolved_bindings); } diff --git a/src/api/descriptor_pool.zig b/src/api/descriptor_pool.zig new file mode 100644 index 0000000..4ea695b --- /dev/null +++ b/src/api/descriptor_pool.zig @@ -0,0 +1,315 @@ +//! This is more of a manager for descriptor pools then +//! an singular descriptor pool. +//! +//! The idea here is to have descriptors specify so called "usage hints" +//! which are meant to describe how the descriptor will be used. +//! These hints will encompass either the lifetime of the descriptor set and/or +//! the actual makeup of descriptors. + +const common = @import("common.zig"); +const vk = @import("vulkan"); +const std = @import("std"); +const api = @import("api.zig"); + +const Allocator = std.mem.Allocator; + +const UsageInfo = common.DescriptorUsageInfo; +const PoolUsageMap = std.EnumMap(UsageInfo.LifetimeScope); +const Context = @import("../context.zig"); + +const log = std.log.scoped(.desc_pool); + +const PoolErrors = error{ + /// Pool has run out of memory + OutOfMemory, + /// an internal vulkan error has occured + /// (best check validation logs on a debug build) + Internal, +}; + +const AnyPool = struct { + pub const VTable = struct { + rawReserve: *const fn ( + *anyopaque, + usize, + /// This mostly exists for the purpose of potentially having more sophisticated pool managment + /// within a single usage pool + []const UsageInfo, + []const vk.DescriptorSetLayout, + /// Descriptor sets are written into this user provided slice rather than allocation + []vk.DescriptorSet, + ) PoolErrors![]vk.DescriptorSet, + rawFree: *const fn ( + *anyopaque, + []const UsageInfo, + []const vk.DescriptorSet, + ) void, + + reset: *const fn ( + *anyopaque, + ) void, + }; + + vtable: *const VTable, + ctx: *anyopaque, + + pub fn rawReserve( + self: AnyPool, + count: usize, + usages: []const UsageInfo, + layouts: []const vk.DescriptorSetLayout, + ) PoolErrors![]vk.DescriptorSet { + return self.vtable.rawReserve(self.ctx, count, usages, layouts); + } + + pub fn rawFree( + self: AnyPool, + usages: []const UsageInfo, + layouts: []const vk.DescriptorSet, + ) void { + return self.vtable.rawFree(self.ctx, usages, layouts); + } + + pub fn reset( + self: AnyPool, + ) void { + return self.vtable.reset(self.ctx); + } +}; + +const DescriptorSizeRatios = std.EnumMap(common.DescriptorType, f32); + +const DescriptorType = common.DescriptorType; +const PoolArena = struct { + const ratios = DescriptorSizeRatios.init(.{ + .Uniform = 1.0, + .Sampler = 2.0, + .StorageBuffer = 0.5, + .Image = 1.0, + }); + + inline fn calcDescriptorCount(t: DescriptorType, size: usize) u32 { + const ratio = ratios.get(t) orelse unreachable; + return @intFromFloat(ratio * @as(f32, @floatFromInt(size))); + } + fn poolSizesForCount(set_count: usize) [4]vk.DescriptorPoolSize { + return [_]vk.DescriptorPoolSize{ + .{ + .type = DescriptorType.Uniform.toVkDescriptor(), + .descriptor_count = calcDescriptorCount(.Uniform, set_count), + }, + .{ + .type = DescriptorType.Sampler.toVkDescriptor(), + .descriptor_count = calcDescriptorCount(.Sampler, set_count), + }, + .{ + .type = DescriptorType.Image.toVkDescriptor(), + .descriptor_count = calcDescriptorCount(.Image, set_count), + }, + .{ + .type = DescriptorType.StorageBuffer.toVkDescriptor(), + .descriptor_count = calcDescriptorCount(.StorageBuffer, set_count), + }, + }; + } + + h_desc_pool: vk.DescriptorPool, + di: *const api.DeviceInterface, + + pub fn init(di: *const api.DeviceInterface, size: usize) !PoolArena { + const pool_sizes = poolSizesForCount(size); + + const pool_create_info = vk.DescriptorPoolCreateInfo{ + .max_sets = @intCast(size), + .p_pool_sizes = &pool_sizes, + .pool_size_count = pool_sizes.len, + }; + + const desc_pool = try di.createDescriptorPool( + &pool_create_info, + null, + ); + + return PoolArena{ + .h_desc_pool = desc_pool, + .di = di, + }; + } + + fn rawReserve( + ctx: *anyopaque, + usages: []const UsageInfo, + layouts: []const vk.DescriptorSetLayout, + /// Caller provides the memory for the sets (tries to allocate a set for all elements of slice) + sets: []vk.DescriptorSet, + ) PoolErrors!void { + const self = @as(*PoolArena, @ptrCast(@alignCast(ctx))); + + const alloc_info = vk.DescriptorSetAllocateInfo{ + .descriptor_pool = self.h_desc_pool, + .descriptor_set_count = @intCast(sets.len), + .p_set_layouts = layouts.ptr, + }; + + try self.di.allocateDescriptorSets(&alloc_info, sets.ptr) catch |e| { + switch (e) { + .OutOfHostMemory, .OutOfDeviceMemory, .OutOfPoolMemory => PoolErrors.OutOfMemory, + .FragmentedPool => blk: { + // TODO: possibly trigger a defragging routine here + log.debug( + "pool is too fragmented to allocate.", + .{}, + ); + break :blk PoolErrors.OutOfMemory; + }, + else => PoolErrors.Internal, + } + }; + + _ = usages; + } + + fn rawFree( + ctx: *anyopaque, + usages: []const UsageInfo, + sets: []const vk.DescriptorSet, + ) void { + // Freeing single sets is not allowed without a flag + // and is thus a no-op for this implementation + _ = ctx; + _ = usages; + _ = sets; + } + + fn reset( + ctx: *anyopaque, + ) void { + const self = @as(*PoolArena, @ptrCast(@alignCast(ctx))); + self.di.resetDescriptorPool(self.h_desc_pool, .{}) catch + @panic("internal descriptor pool error occured"); + } + + pub fn interface(self: *PoolArena) AnyPool { + return AnyPool{ + .ctx = self, + .vtable = &AnyPool.VTable{ + .rawFree = rawFree, + .rawReserve = rawReserve, + .reset = reset, + }, + }; + } +}; + +/// for now, I think it is permissible to +/// have the static pool be managed the +/// same as the transient pool via a PoolArena +/// (it just gets freed at the end) +// const StaticPool = struct { +// h_desc_pool: vk.DescriptorPool, +// }; + +pools_by_usage: PoolUsageMap, + +transient_pool: PoolArena, +//lol +scene_pool: PoolArena, +static_pool: PoolArena, + +const Self = @This(); + +pub const PoolSizes = struct { + transient: usize, + scene: usize, + static: usize, +}; + +//keeps the door open for a more complicated descriptor managment +fn poolByUsage(self: *Self, usage: UsageInfo) AnyPool { + return self.pools_by_usage.get(usage.lifetime_bits) orelse unreachable; +} + +pub fn initSelf(self: *Self, ctx: *const Context, sizes: PoolSizes) !void { + const di = ctx.env(.di); + + self.transient_pool = try PoolArena.init(di, sizes.transient); + errdefer self.transient_pool.deinit(); + + self.scene_pool = try PoolArena.init(di, sizes.scene); + errdefer self.scene_pool.deinit(); + + self.static_pool = try PoolArena.init(di, sizes.static); + errdefer self.static_pool.deinit(); + + self.pools_by_usage = try PoolUsageMap.init(.{ + .Transient = self.transient_pool.interface(), + .Scene = self.scene_pool.interface(), + .Static = self.static_pool.interface(), + }); +} + +pub fn resetTransient(self: *Self) void { + self.transient_pool.interface().reset(); +} + +pub fn reserve( + self: *Self, + usage: UsageInfo, + layout: vk.DescriptorSetLayout, +) !vk.DescriptorSet { + const set = try self.reserveRange(1, &.{usage}, &.{layout}); + return set[0]; +} + +pub fn reserveRange( + self: *Self, + count: usize, + usage: UsageInfo, + layouts: []const vk.DescriptorSetLayout, +) ![]vk.DescriptorSetLayout { + const pool = self.poolByUsage(usage); + return pool.rawReserve(count, &.{usage}, layouts); +} + +pub fn free( + self: *Self, + // free does something different depending on the usage + usage: UsageInfo, + set: vk.DescriptorSet, +) void { + self.freeRange(&.{usage}, &.{set}); +} + +pub fn freeRange( + self: *Self, + usages: []const UsageInfo, + sets: []const vk.DescriptorSet, +) void { + for (usages, sets) |u, s| { + const pool = self.poolByUsage(u); + pool.rawFree(&.{u}, &.{s}); + } +} + +const glfw = @import("glfw"); + +test "transient allocations" { + var alloc = std.heap.DebugAllocator(.{ + .safety = true, + .enable_memory_limit = true, + }); + var test_ctx = try Context.init(alloc.allocator(), .{ + .management = .{ + .allocator = alloc.allocator(), + .pool_sizes = 1024, + }, + .inst_extensions = glfw.instanceExtensions(), + .loader = glfw.glfwGetInstanceProcAddress, + .window = null, + }); + + var pool = test_ctx.env(.desc); + + const d = pool.reserve( + pool.resetTransient(); +} diff --git a/src/api/types.zig b/src/api/types.zig deleted file mode 100644 index 4f40141..0000000 --- a/src/api/types.zig +++ /dev/null @@ -1,9 +0,0 @@ -const vk = @import("vulkan"); - -pub const SyncInfo = struct { - fence_sig: ?vk.Fence = null, - fence_wait: ?vk.Fence = null, - - sem_sig: ?vk.Semaphore = null, - sem_wait: ?vk.Semaphore = null, -}; diff --git a/src/context.zig b/src/context.zig index 57c8b1b..02d2b3d 100644 --- a/src/context.zig +++ b/src/context.zig @@ -97,7 +97,7 @@ pub fn env(self: *const Self, comptime field: anytype) ResolveEnvType(field) { pub const Config = struct { inst_extensions: []const [*:0]const u8 = &.{}, dev_extensions: []const [*:0]const u8 = &.{}, - window: *const glfw.Window, + window: ?*const glfw.Window, loader: glfw.GetProcAddrHandler, management: res.ResourceManager.Config, }; diff --git a/src/glfw.zig b/src/glfw.zig index 2e8003f..6325bee 100644 --- a/src/glfw.zig +++ b/src/glfw.zig @@ -55,6 +55,11 @@ const glfwWindowShouldClose = c.glfwWindowShouldClose; const glfwCreateWindow = c.glfwCreateWindow; const glfwWindowHint = c.glfwWindowHint; +pub fn instanceExtensions() [][*:0]const u8 { + var count: u32 = 0; + return @ptrCast(getRequiredInstanceExtensions(&count)[0..count]); +} + pub const Window = struct { handle: *GLFWwindow, diff --git a/src/resource_management/pool_allocator.zig b/src/resource_management/pool_allocator.zig index bc219cc..2207f47 100644 --- a/src/resource_management/pool_allocator.zig +++ b/src/resource_management/pool_allocator.zig @@ -196,6 +196,12 @@ pub fn free(self: *Self, item: *anyopaque) void { _ = item; } +/// "items" MUST refer to a slice of type-matching handles... +/// It's not a slice because you cant directly have slices +/// whose underling type is unknown (opaque). +pub fn freeRange(self: *Self, items: *anyopaque, count: usize) void { +} + pub fn freeAll(self: *Self) void { // Just overwrite the existing free space list with a new one, which will cover the entire pool // no leakage issues since the list is stored in-place From 4a88cf2ca9cf18cb77f10d694739963012cf799d Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 17 Aug 2025 21:35:24 -0700 Subject: [PATCH 08/46] feat(config): worked out an API for sensible defaults --- src/api/image.zig | 37 +++++++++++++++++++++++++++++++++++++ src/common/config.zig | 10 ++++++++++ src/common/iterator.zig | 0 3 files changed, 47 insertions(+) create mode 100644 src/common/config.zig create mode 100644 src/common/iterator.zig diff --git a/src/api/image.zig b/src/api/image.zig index 640f1d0..d7830f1 100644 --- a/src/api/image.zig +++ b/src/api/image.zig @@ -1,6 +1,7 @@ const std = @import("std"); const vk = @import("vulkan"); const rsh = @import("rshc"); +const common = @import("common"); const buf = @import("buffer.zig"); const util = @import("../util.zig"); @@ -54,6 +55,42 @@ pub const Config = struct { clear_col: ?vk.ClearColorValue = null, staging_buf: ?*StagingBuffer = null, initial_layout: vk.ImageLayout = .undefined, + + // Configuration stuff + const config = common.config; + const ConfigurationRegistry = config.ConfigurationRegistry; + + pub const Profiles = enum { + Texture, + Storage, + Depth, + }; + + fn configureStorage(cfg: *Config, params: struct { + usage_flags: vk.ImageUsageFlags, + }) void {} + + fn resolveExtent(swapchain: *const api.Swapchain) vk.Extent2D { + return swapchain.extent; + } + + const Registry = ConfigurationRegistry(Config, Profiles, .{ + .Texture = config.Parameterized(Config{ + .usage = .{ + .sampled_bit = true, + }, + }, .{ + .extent = config.Parameter(vk.Extent2D, "swapchain", resolveExtent), + }), + .Storage = configureStorage, + .Depth = Config{}, + .Default = Config{}, + }); + + pub const from = Registry.BuilderMixin; + // this is either a function or a static ref + pub const default = Registry.DefaultMixin; + pub const profile = Registry.ProfileMixin; }; fn createImageMemory( diff --git a/src/common/config.zig b/src/common/config.zig new file mode 100644 index 0000000..a63e31b --- /dev/null +++ b/src/common/config.zig @@ -0,0 +1,10 @@ +//! Configurations and stuff but cooler + + +pub fn ConfigurationRegistry( + comptime ConfigType: type, + comptime Profiles: type, + comptime profile_defs: anytype, +) type { + +} diff --git a/src/common/iterator.zig b/src/common/iterator.zig new file mode 100644 index 0000000..e69de29 From a6bfce3f32db34b0cc96fb6b71fa855d1a748618 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 17 Aug 2025 23:16:08 -0700 Subject: [PATCH 09/46] feat(config): updated config registry to validate parapoly'd types --- src/common/common.zig | 3 +++ src/common/config.zig | 62 +++++++++++++++++++++++++++++++++++++++++++ src/common/util.zig | 55 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 120 insertions(+) create mode 100644 src/common/util.zig diff --git a/src/common/common.zig b/src/common/common.zig index f1c7c42..c9d67c2 100644 --- a/src/common/common.zig +++ b/src/common/common.zig @@ -5,6 +5,9 @@ const h = @import("handle.zig"); pub const Handle = h.Handle; pub const OpaqueHandle = h.OpaqueHandle; +pub const config = @import("config.zig"); +pub const util = @import("util.zig"); + /// This is cursed as hell.. /// Returns a unique identifier for any type at comptime or runtime /// https://github.com/ziglang/zig/issues/19858#issuecomment-2094339450 diff --git a/src/common/config.zig b/src/common/config.zig index a63e31b..bf78854 100644 --- a/src/common/config.zig +++ b/src/common/config.zig @@ -1,10 +1,72 @@ //! Configurations and stuff but cooler +const std = @import("std"); +const util = @import("common.zig").util; + +fn validateProfiles( + comptime T: type, + comptime Hint: type, +) std.builtin.Type.Enum { + const pinfo = @typeInfo(T); + if (!pinfo == .@"enum") + @compileError("Invalid profile listing enum: " ++ + @typeName(T) ++ " for config type: " ++ @typeName(Hint)); + + return pinfo.@"enum"; +} + +fn validateDef( + comptime T: type, + comptime def: anytype, + comptime Hint: type, +) void { + const info = @typeInfo(@TypeOf(def)); + + switch (info) { + .@"struct" => |*s| { + const pinfo = @typeInfo(T).@"enum"; + for (pinfo.fields) |fld| { + if (util.tryGetField(s, fld.name)) { + @compileError("Profile def missing field: " ++ + fld.name ++ " for config type: " ++ @typeName(Hint)); + } + } + }, + else => @compileError("Invalid profile def struct: " ++ + @typeName(T) ++ " for config type: " ++ @typeName(Hint)), + } +} + pub fn ConfigurationRegistry( + /// ConfigType can be any struct comptime ConfigType: type, + /// Profiles must be a packed, non-sparse enum, (preferably human readable) comptime Profiles: type, + /// profile_defs must be an anonymous struct literal + /// whose fields are named after the "Profile" enum fields + /// with an additional field called "Default" for the default configuration + /// Values can either be valid instances of the configuration struct type, + /// or one of the provided parameterization helper types comptime profile_defs: anytype, ) type { + const profile_info = validateProfiles(Profiles, ConfigType); + validateDef(Profiles, profile_defs, ConfigType); + const profiles_len = profile_info.fields.len; } + +pub fn Parameterized( + comptime instance: anytype, + comptime params: anytype, +) @TypeOf(instance) {} + +fn ResolverFn(comptime T: type) type {} + +pub const ParameterDef = struct {}; + +pub fn Parameter( + comptime T: type, + comptime field_name: [:0]const u8, + comptime resolver: anytype, +) ParameterDef {} diff --git a/src/common/util.zig b/src/common/util.zig new file mode 100644 index 0000000..02e8316 --- /dev/null +++ b/src/common/util.zig @@ -0,0 +1,55 @@ +//! TODO: Merge this into the common directory +//! Most of this is completely unused and useless, so +//! only a bit of this iwll be included... +const std = @import("std"); +pub fn asCString(rep: anytype) [*:0]const u8 { + return @as([*:0]const u8, @ptrCast(rep)); +} + +pub fn emptySlice(comptime T: type) []T { + return &[0]T{}; +} + +//FIXME: This is due for a BIG REFACTOR COMING SOON +// (because it is much worse than just &.{} which I Didn't know was a thing oops. +pub fn asManyPtr(comptime T: type, ptr: *const T) [*]const T { + return @as([*]const T, @ptrCast(ptr)); +} + +//FIXME: This is due for a BIG REFACTOR COMING SOON +// (because it is much worse than just &.{} which I Didn't know was a thing oops. +// funilly enough, &.{1, 2, 3} is shorter than span(.{1, 2, 3}). I just don't +// like reading docs + idk how. +pub fn span(v: anytype) [] @TypeOf(v[0]) { + const T = @TypeOf(v[0]); + comptime var sp: [v.len] T = undefined; + for (v, 0..) |val, index| { + sp[index] = val; + } + + return sp[0..]; +} + +const StructInfo = std.builtin.Type.Struct; +const StructField = std.builtin.Type.StructField; +const Function = std.builtin.Type.Fn; + +// Reflection Stuff +pub fn tryGetField(info: *StructInfo, name: []const u8) ?*StructField { + for (info.fields) |*fld| { + if (std.mem.eql(u8, fld.name, name) == .eq) { + return fld; + } + } + + return null; +} + +pub fn signatureMatches(a: *const Function, b: *const Function) bool { + if (a.params.len != b.params.len) return false; + for (a.params, b.params) |p1, p2| + if (p1.type != p2.type) return false; + + if (!a.calling_convention.eql(b)) return false; + return true; +} From af5d4965eb752033c1703ff658b44f5664f1bfbb Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 18 Aug 2025 20:22:39 -0700 Subject: [PATCH 10/46] feat(config): implemented first pass of config registry type with common mixins and profile + builder support --- build.zig | 11 ++ src/api/image.zig | 7 +- src/common/common.zig | 5 + src/common/config.zig | 257 ++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 271 insertions(+), 9 deletions(-) diff --git a/build.zig b/build.zig index beb200b..142a0f2 100644 --- a/build.zig +++ b/build.zig @@ -15,6 +15,7 @@ const Dependencies = struct { rshc: *Module, vulkan: *Module, glfw: *Module, + common: *Module, }; fn resolveGLFWSystemDeps(m: *Module) void { @@ -48,10 +49,17 @@ fn buildDeps(b: *Build, opts: BuildOpts) Dependencies { resolveGLFWSystemDeps(glfw_mod); + const common_mod = b.createModule(.{ + .optimize = opts.optimize, + .target = opts.target, + .root_source_file = b.path("src/common/common.zig"), + }); + return .{ .rshc = rshc_mod, .vulkan = vulkan_mod, .glfw = glfw_mod, + .common = common_mod, }; } @@ -69,6 +77,9 @@ fn buildLibrary( }); lib_mod.addImport("vulkan", deps.vulkan); + lib_mod.addImport("common", deps.common); + + // Temporary for development lib_mod.addImport("rshc", deps.rshc); lib_mod.addImport("glfw", deps.glfw); diff --git a/src/api/image.zig b/src/api/image.zig index d7830f1..9112e1a 100644 --- a/src/api/image.zig +++ b/src/api/image.zig @@ -82,11 +82,16 @@ pub const Config = struct { }, .{ .extent = config.Parameter(vk.Extent2D, "swapchain", resolveExtent), }), - .Storage = configureStorage, + .Storage = Config{}, .Depth = Config{}, .Default = Config{}, }); + /// const image_cfg = Image.Config.from(.Texture, .{ + /// .swapchain = &my_swapchain, + /// }); + /// const image = api.Image.init(&my_context, allocator, image_config); + pub const from = Registry.BuilderMixin; // this is either a function or a static ref pub const default = Registry.DefaultMixin; diff --git a/src/common/common.zig b/src/common/common.zig index c9d67c2..b0a2c31 100644 --- a/src/common/common.zig +++ b/src/common/common.zig @@ -68,3 +68,8 @@ pub const AnyPtr = struct { /// I need right now pub fn APIFunction(func: anytype) APIFunctionType(func) { } + + +comptime { + _ = @import("config.zig"); +} diff --git a/src/common/config.zig b/src/common/config.zig index bf78854..5eda0cf 100644 --- a/src/common/config.zig +++ b/src/common/config.zig @@ -4,7 +4,7 @@ const std = @import("std"); const util = @import("common.zig").util; fn validateProfiles( - comptime T: type, + comptime T: type, comptime Hint: type, ) std.builtin.Type.Enum { const pinfo = @typeInfo(T); @@ -19,25 +19,52 @@ fn validateDef( comptime T: type, comptime def: anytype, comptime Hint: type, -) void { +) []const std.builtin.Type.StructField { const info = @typeInfo(@TypeOf(def)); switch (info) { .@"struct" => |*s| { const pinfo = @typeInfo(T).@"enum"; for (pinfo.fields) |fld| { - if (util.tryGetField(s, fld.name)) { + if (!util.tryGetField(s, fld.name)) { @compileError("Profile def missing field: " ++ fld.name ++ " for config type: " ++ @typeName(Hint)); } } + + if (!util.tryGetField(s, "Default")) { + @compileError("Profile def missing default field " ++ + " for config type: " ++ @typeName(Hint)); + } }, else => @compileError("Invalid profile def struct: " ++ @typeName(T) ++ " for config type: " ++ @typeName(Hint)), } + return @typeInfo(@TypeOf(def)).@"struct".fields; } +pub const ParameterDef = struct { + OutputType: type, + out_fld_name: [:0]const u8, + in_fld_name: [:0]const u8, + + InputType: type, + resolver: *anyopaque, +}; + +fn ProfileDef(comptime ConfigType: type) type { + return union(enum) { + Valued: struct { + PType: type, + default_val: ConfigType, + // map from field names to all resolver functions (built from param data) + resolvers: ?std.StaticStringMap(ParameterDef), + }, + Function, + }; +} + pub fn ConfigurationRegistry( /// ConfigType can be any struct comptime ConfigType: type, @@ -51,22 +78,236 @@ pub fn ConfigurationRegistry( comptime profile_defs: anytype, ) type { const profile_info = validateProfiles(Profiles, ConfigType); - validateDef(Profiles, profile_defs, ConfigType); + const def_fields = validateDef(Profiles, profile_defs, ConfigType); const profiles_len = profile_info.fields.len; + const ProfileDefType = ProfileDef(ConfigType); + comptime var profiles: [profiles_len]ProfileDefType = .{}; + + for (def_fields) |fld| { + const field_index: usize = if (std.mem.eql(fld.name, "Default") == .eq) + @intFromEnum(std.meta.stringToEnum( + Profiles, + fld.name, + ) orelse unreachable) + else + (profiles_len - 1); + + profiles[field_index] = switch (fld.type) { + ParameterizedProfileDef(ConfigType) => blk: { + const parameters = @field(profile_defs, fld.name).params; + + comptime var ptype_fields: []std.builtin.Type.StructField = &.{}; + comptime var resolvers = .{}; + + for (parameters) |p| { + ptype_fields = ptype_fields ++ [_]std.builtin.Type.StructField{.{ + .name = p.fld_name, + .type = p.InputType, + }}; + + resolvers = resolvers ++ .{p.in_fld_name, p}; + } + + const PType = @Type(.{ + .@"struct" = std.builtin.Type.Struct{ + .fields = ptype_fields, + }, + }); + + const default_val = @field(profile_defs, fld.name).default_val; + + break :blk ProfileDefType{ .Valued = .{ + .PType = PType, + .default_val = default_val, + .resolvers = std.StaticStringMap(ParameterDef) + .initComptime(resolvers), + } }; + }, + ConfigType => blk: { + const default_val: ConfigType = @field(profile_defs, fld.name); + + break :blk ProfileDefType{ .Valued = .{ + .PType = null, + .default_val = default_val, + .resolvers = null, + } }; + }, + else => { + //TODO: Check for a full mapping function signature later + @compileError("Invalid profile def entry for type: " ++ + @typeName(ConfigType)); + } + }; + } + + return struct { + const Self = @This(); + const profile_data: []const ProfileDef = profiles[0..profiles_len]; + const default_index = profiles_len - 1; + // TODO: Check presence of fields + // and make sure the params are a struct literal. + fn comptimeValidate(params: anytype, index: usize) void { + comptime { + const params_info = @typeInfo(@TypeOf(params)); + switch (params_info) { + .@"struct" => {}, + else => @compileError("Invalid parameter literal: must be struct!"), + } + + _ = index; + } + } + pub const ConfigBuilder = struct { + underlying: ConfigType, + pub fn extend(self: *ConfigBuilder, vals: ConfigType) *ConfigBuilder { + inline for (@typeInfo(ConfigType).@"struct".fields) |*fld| { + @field(self.underlying, fld.name) = @field(vals, fld.nam); + } + + return self; + } + + pub fn combine(self: *ConfigBuilder, profile: Profiles, params: anytype) *ConfigBuilder { + const other = Self.ProfileMixin(profile, params); + return self.extend(other); + } + + pub fn finalize(self: *const ConfigBuilder) ConfigType { + return self.underlying; + } + }; + + pub fn BuilderMixin(profile: Profiles, params: anytype) ConfigBuilder { + return .{ + .underlying = setFromProfileIndex(@intFromEnum(profile), params), + }; + } + + fn setFromProfileIndex(index: usize, params: anytype) ConfigType { + const profile_def = profile_data[index]; + return switch (profile_def) { + .Valued => |*v| blk: { + var val: ConfigType = v.default_val; + if (v.resolvers) |rmap| { + const ptype_info = @typeInfo(v.PType).@"struct"; + + inline for (ptype_info.fields) |*fld| { + const res = rmap.get(fld.name) orelse unreachable; + @field(val, res.out_fld_name) = @as(*const fn ( + res.InputType + ) res.OutputType, @ptrCast(@alignCast(res.resolver)))( + @field(params, res.in_fld_name) + ); + } + } + + break :blk val; + }, + .Function => @compileError("Function-based profiles currently unsupported!"), + }; + } + + pub fn DefaultMixin(params: anytype) ConfigType { + return setFromProfileIndex(default_index, params); + } + + pub fn ProfileMixin(profile: Profiles, params: anytype) ConfigType { + return setFromProfileIndex(@intFromEnum(profile), params); + } + }; +} + + +fn ParameterizedProfileDef(comptime ConfigType: type) type { + return struct { + params: []const ParameterDef, + default_value: ConfigType, + }; } pub fn Parameterized( comptime instance: anytype, comptime params: anytype, -) @TypeOf(instance) {} +) ParameterizedProfileDef(@TypeOf(instance)) { + if (@typeInfo(@TypeOf(params)) == .@"struct") + @compileError("Invalid parameterset type (must be struct) " ++ + @typeName(instance)); + + const pinfo = @typeInfo(@TypeOf(params)).@"struct"; + comptime var params2: []ParameterDef = &.{}; + + for (pinfo.fields) |fld| { + const val = @field(pinfo, fld.name); -fn ResolverFn(comptime T: type) type {} + params2 = params2 ++ [_]ParameterDef{.{ + .out_fld_name = fld.name, -pub const ParameterDef = struct {}; + .OutputType = val.@"0", + .InputType = val.@"1", + .in_fld_name = val.@"2", + .resolver = val.@"3", + }}; + } + + return .{ + .params = params2, + .default_value = instance, + }; +} +// fn ResolverFn(comptime T: type) type {} + +// since the output field names are mapped to the left-hand side +// of an assignment, we need a temporary storage record for the rest of the data. +// This is mostly for usage ergonomics, there's no actual implementation reason +// that it has to be this way. +const IntermediateParam = struct { + InputType: type, + OutputType: type, + in_field_name: [:0]const u8, + resolver: *anyopaque, +}; + +//Parameters can be either: +// - Resolver functions which map from an input type to a config field +// - Direct mappings from input parameters to config fields +// (in this case, "resolver" would be null. pub fn Parameter( comptime T: type, comptime field_name: [:0]const u8, comptime resolver: anytype, -) ParameterDef {} +) std.meta.Tuple(&.{ type, type, [:0]const u8, *anyopaque }) { + const ResolverType = @TypeOf(resolver); + const rinfo = @typeInfo(ResolverType); + + const InputType, const res = switch (rinfo) { + .@"fn" => |f| blk: { + if (f.params.len != 1) + @compileError("Resolver functions must take a single argument"); + const input_arg = f.params[0]; + + break :blk .{ input_arg.type, resolver }; + }, + .null => blk: { + const Container = struct { + pub fn noOp(in: T) T { + return in; + } + }; + + break :blk .{ T, Container.noOp }; + }, + else => @compileError("resolver must be a function or null"), + }; + + return .{ T, InputType, field_name, res }; +} + +test "config (default value)" {} + +test "config (profile)" {} + +test "config (parameterized profile)" {} + +test "config (value composition)" {} From a53c7d316b5e18f8a21699a3ad6d0e4ed088e36e Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 18 Aug 2025 21:27:20 -0700 Subject: [PATCH 11/46] test(config): added basic unit test coverage for sensible defaults use cases --- src/common/config.zig | 206 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 193 insertions(+), 13 deletions(-) diff --git a/src/common/config.zig b/src/common/config.zig index 5eda0cf..b2af514 100644 --- a/src/common/config.zig +++ b/src/common/config.zig @@ -43,7 +43,6 @@ fn validateDef( return @typeInfo(@TypeOf(def)).@"struct".fields; } - pub const ParameterDef = struct { OutputType: type, out_fld_name: [:0]const u8, @@ -106,7 +105,7 @@ pub fn ConfigurationRegistry( .type = p.InputType, }}; - resolvers = resolvers ++ .{p.in_fld_name, p}; + resolvers = resolvers ++ .{ p.in_fld_name, p }; } const PType = @Type(.{ @@ -194,13 +193,9 @@ pub fn ConfigurationRegistry( inline for (ptype_info.fields) |*fld| { const res = rmap.get(fld.name) orelse unreachable; - @field(val, res.out_fld_name) = @as(*const fn ( - res.InputType - ) res.OutputType, @ptrCast(@alignCast(res.resolver)))( - @field(params, res.in_fld_name) - ); + @field(val, res.out_fld_name) = @as(*const fn (res.InputType) res.OutputType, @ptrCast(@alignCast(res.resolver)))(@field(params, res.in_fld_name)); } - } + } break :blk val; }, @@ -218,7 +213,6 @@ pub fn ConfigurationRegistry( }; } - fn ParameterizedProfileDef(comptime ConfigType: type) type { return struct { params: []const ParameterDef, @@ -304,10 +298,196 @@ pub fn Parameter( return .{ T, InputType, field_name, res }; } -test "config (default value)" {} +const testing = std.testing; + +const TestBitField = packed struct { + bit_1: bool = false, + bit_2: bool = false, + bit_3: bool = false, + rest: u5 = 0, +}; + +const TestConfigStruct = struct { + flags: TestBitField = .{}, + + comptime_field_a: u32 = 0, + comptime_field_b: usize = 0, + name: []const u8 = undefined, + + pointer: *const usize = undefined, + writer: ?std.io.AnyWriter = null, + + pub const Profiles = enum { + Larry, + Harry, + WriterBoy, + PartialA, + PartialB, + }; + + const larry_last_name_table = [_][]const u8{ + "Larry Larryson", + "Larry Jerryson", + "Larry The Lobster", + "Larry the Platypus", + }; + + fn resolveLarryName(index: usize) []const u8 { + return larry_last_name_table[@mod(index, larry_last_name_table.len)]; + } + + fn sideEffectyResolver(w: std.io.AnyWriter) std.io.AnyWriter { + w.write("Evil function") catch @panic("Test write failed"); + return w; + } -test "config (profile)" {} + pub const larrys_num: usize = 1000; -test "config (parameterized profile)" {} + const Registry = ConfigurationRegistry(TestConfigStruct, Profiles, .{ + .Harry = TestConfigStruct{ + .flags = .{ + .bit_1 = true, + .bit_2 = false, + .bit_3 = true, + .rest = 10, + }, + .comptime_field_a = 100, + .comptime_field_b = 0, + .name = "Harry Harryson", -test "config (value composition)" {} + .pointer = &larrys_num, + .writer = null, + }, + .Larry = Parameterized(TestConfigStruct{ + .flags = .{}, + .comptime_field_a = 6291, + .writer = null, + }, .{ + .comptime_field_b = Parameter(usize, "larry_bank_id", null), + .name = Parameter([]const u8, "larry_name_id", resolveLarryName), + .pointer = Parameter(*const usize, "larry_number", null), + }), + .WriterBoy = Parameterized(TestConfigStruct{ + .name = "Writer Boy", + }, .{ + .writer = Parameter(std.io.AnyWriter, "some_writer", sideEffectyResolver), + }), + .Default = TestConfigStruct{ + .flags = .{ + .bit_1 = false, + .bit_2 = true, + .bit_3 = false, + .rest = 2, + }, + .comptime_field_a = 123, + .comptime_field_b = 320432, + .name = "Default", + + .pointer = &larrys_num, + .writer = null, + }, + .PartialA = TestConfigStruct{ + .flags = .{.bit_1 = true}, + .comptime_field_a = 999, + }, + .PartialB = Parameterized(TestConfigStruct{ + .comptime_field_b = 998, + .pointer = &larrys_num, + .writer = null, + }, .{ + .name = Parameter([]const u8, "partial_name", null), + }), + }); + + const from = Registry.BuilderMixin; + const profile = Registry.ProfileMixin; + const default = Registry.DefaultMixin; +}; + +test "config (default value)" { + const default = TestConfigStruct.default(.{}); + + try testing.expectEqual(default, TestConfigStruct{ + .flags = .{ + .bit_1 = false, + .bit_2 = true, + .bit_3 = false, + .rest = 2, + }, + .comptime_field_a = 123, + .comptime_field_b = 320432, + .name = "Default", + + .pointer = &TestConfigStruct.larrys_num, + .writer = null, + }); +} + +test "config (profile)" { + const profile = TestConfigStruct.profile(.Harry, .{}); + + try testing.expectEqual(profile, TestConfigStruct{ + .flags = .{ + .bit_1 = true, + .bit_2 = false, + .bit_3 = true, + .rest = 10, + }, + .comptime_field_a = 100, + .comptime_field_b = 0, + .name = "Harry Harryson", + + .pointer = &TestConfigStruct.larrys_num, + .writer = null, + }); +} + +test "config (parameterized profile)" { + const string: [64]u8 = .{}; + var stream = std.io.fixedBufferStream(string); + + const larry_num: usize = 12321; + + const val = TestConfigStruct.profile(.Larry, .{ + .larry_bank_id = 943, + .larry_name_id = 1, + .larry_number = 293, + }); + + try testing.expectEqual(val, TestConfigStruct{ + .flags = .{}, + .comptime_field_a = 6291, + .writer = null, + .comptime_field_b = 943, + .name = "Larry Jerryson", + .pointer = &larry_num, + }); + + const writer_val = TestConfigStruct.profile(.WriterBoy, .{ + .some_writer = stream.writer(), + }); + + try testing.expectEqual(writer_val, TestConfigStruct{ + .name = "Writer Boy", + .writer = stream.writer(), + }); + + try testing.expectEqualSlices(u8, string[0..("Writer Boy").len], "Writer Boy"); +} + +test "config (value composition)" { + var val_a_b = TestConfigStruct.from(.PartialA, .{}); + const res = val_a_b.extend(.{ + .comptime_field_b = 998, + .pointer = &TestConfigStruct.larrys_num, + .writer = null, + .name = "Name Here", + }).finalize(); + + const res2 = val_a_b.combine(.PartialB, .{ + .partial_name = "Name Here", + }); + + + try testing.expectEqual(res, res2); +} From 4410cc7244478db36d5352a299b9846ac3bf287a Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 18 Aug 2025 23:12:54 -0700 Subject: [PATCH 12/46] fix(config): fixed various compile time errors so that test cases pass --- src/common/config.zig | 114 ++++++++++++++++++++++++------------------ src/common/util.zig | 4 +- 2 files changed, 68 insertions(+), 50 deletions(-) diff --git a/src/common/config.zig b/src/common/config.zig index b2af514..e78c206 100644 --- a/src/common/config.zig +++ b/src/common/config.zig @@ -8,7 +8,7 @@ fn validateProfiles( comptime Hint: type, ) std.builtin.Type.Enum { const pinfo = @typeInfo(T); - if (!pinfo == .@"enum") + if (pinfo != .@"enum") @compileError("Invalid profile listing enum: " ++ @typeName(T) ++ " for config type: " ++ @typeName(Hint)); @@ -26,13 +26,13 @@ fn validateDef( .@"struct" => |*s| { const pinfo = @typeInfo(T).@"enum"; for (pinfo.fields) |fld| { - if (!util.tryGetField(s, fld.name)) { + if (util.tryGetField(s, fld.name) == null) { @compileError("Profile def missing field: " ++ fld.name ++ " for config type: " ++ @typeName(Hint)); } } - if (!util.tryGetField(s, "Default")) { + if (util.tryGetField(s, "Default") == null) { @compileError("Profile def missing default field " ++ " for config type: " ++ @typeName(Hint)); } @@ -49,13 +49,13 @@ pub const ParameterDef = struct { in_fld_name: [:0]const u8, InputType: type, - resolver: *anyopaque, + resolver: *const anyopaque, }; fn ProfileDef(comptime ConfigType: type) type { return union(enum) { Valued: struct { - PType: type, + PType: ?type, default_val: ConfigType, // map from field names to all resolver functions (built from param data) resolvers: ?std.StaticStringMap(ParameterDef), @@ -79,12 +79,13 @@ pub fn ConfigurationRegistry( const profile_info = validateProfiles(Profiles, ConfigType); const def_fields = validateDef(Profiles, profile_defs, ConfigType); - const profiles_len = profile_info.fields.len; + // Extra field for the default profile + const profiles_len = profile_info.fields.len + 1; const ProfileDefType = ProfileDef(ConfigType); - comptime var profiles: [profiles_len]ProfileDefType = .{}; + comptime var profiles: [profiles_len]ProfileDefType = .{undefined} ** profiles_len; for (def_fields) |fld| { - const field_index: usize = if (std.mem.eql(fld.name, "Default") == .eq) + const field_index: usize = if (!std.mem.eql(u8, fld.name, "Default")) @intFromEnum(std.meta.stringToEnum( Profiles, fld.name, @@ -96,21 +97,27 @@ pub fn ConfigurationRegistry( ParameterizedProfileDef(ConfigType) => blk: { const parameters = @field(profile_defs, fld.name).params; - comptime var ptype_fields: []std.builtin.Type.StructField = &.{}; - comptime var resolvers = .{}; + comptime var ptype_fields: []const std.builtin.Type.StructField = &.{}; + comptime var resolvers: []const struct {[]const u8, ParameterDef} = &.{}; for (parameters) |p| { ptype_fields = ptype_fields ++ [_]std.builtin.Type.StructField{.{ - .name = p.fld_name, + .name = p.in_fld_name, .type = p.InputType, + .default_value_ptr = null, + .is_comptime = false, + .alignment = @alignOf(p.InputType), }}; - resolvers = resolvers ++ .{ p.in_fld_name, p }; + resolvers = resolvers ++ .{ .{ p.in_fld_name, p } }; } const PType = @Type(.{ .@"struct" = std.builtin.Type.Struct{ .fields = ptype_fields, + .decls = &.{}, + .is_tuple = false, + .layout = .auto, }, }); @@ -138,11 +145,12 @@ pub fn ConfigurationRegistry( @typeName(ConfigType)); } }; + } return struct { const Self = @This(); - const profile_data: []const ProfileDef = profiles[0..profiles_len]; + const profile_data: [profiles_len]ProfileDefType = profiles; const default_index = profiles_len - 1; // TODO: Check presence of fields // and make sure the params are a struct literal. @@ -161,13 +169,13 @@ pub fn ConfigurationRegistry( underlying: ConfigType, pub fn extend(self: *ConfigBuilder, vals: ConfigType) *ConfigBuilder { inline for (@typeInfo(ConfigType).@"struct".fields) |*fld| { - @field(self.underlying, fld.name) = @field(vals, fld.nam); + @field(self.underlying, fld.name) = @field(vals, fld.name); } return self; } - pub fn combine(self: *ConfigBuilder, profile: Profiles, params: anytype) *ConfigBuilder { + pub fn combine(self: *ConfigBuilder, comptime profile: Profiles, params: anytype) *ConfigBuilder { const other = Self.ProfileMixin(profile, params); return self.extend(other); } @@ -177,23 +185,27 @@ pub fn ConfigurationRegistry( } }; - pub fn BuilderMixin(profile: Profiles, params: anytype) ConfigBuilder { + pub fn BuilderMixin(comptime profile: Profiles, params: anytype) ConfigBuilder { return .{ .underlying = setFromProfileIndex(@intFromEnum(profile), params), }; } - fn setFromProfileIndex(index: usize, params: anytype) ConfigType { + fn setFromProfileIndex(comptime index: usize, params: anytype) ConfigType { const profile_def = profile_data[index]; return switch (profile_def) { .Valued => |*v| blk: { var val: ConfigType = v.default_val; if (v.resolvers) |rmap| { - const ptype_info = @typeInfo(v.PType).@"struct"; + // PType is only null if there are no resolver methods... + const ptype_info = @typeInfo(v.PType orelse unreachable).@"struct"; inline for (ptype_info.fields) |*fld| { const res = rmap.get(fld.name) orelse unreachable; - @field(val, res.out_fld_name) = @as(*const fn (res.InputType) res.OutputType, @ptrCast(@alignCast(res.resolver)))(@field(params, res.in_fld_name)); + @field(val, res.out_fld_name) = @as( + *const fn (res.InputType) res.OutputType, + @ptrCast(@alignCast(res.resolver))) + (@field(params, res.in_fld_name)); } } @@ -207,7 +219,7 @@ pub fn ConfigurationRegistry( return setFromProfileIndex(default_index, params); } - pub fn ProfileMixin(profile: Profiles, params: anytype) ConfigType { + pub fn ProfileMixin(comptime profile: Profiles, params: anytype) ConfigType { return setFromProfileIndex(@intFromEnum(profile), params); } }; @@ -216,7 +228,7 @@ pub fn ConfigurationRegistry( fn ParameterizedProfileDef(comptime ConfigType: type) type { return struct { params: []const ParameterDef, - default_value: ConfigType, + default_val: ConfigType, }; } @@ -224,29 +236,29 @@ pub fn Parameterized( comptime instance: anytype, comptime params: anytype, ) ParameterizedProfileDef(@TypeOf(instance)) { - if (@typeInfo(@TypeOf(params)) == .@"struct") + if (@typeInfo(@TypeOf(params)) != .@"struct") @compileError("Invalid parameterset type (must be struct) " ++ - @typeName(instance)); + @typeName(@TypeOf(instance))); const pinfo = @typeInfo(@TypeOf(params)).@"struct"; - comptime var params2: []ParameterDef = &.{}; + comptime var params_list: []const ParameterDef = &.{}; for (pinfo.fields) |fld| { - const val = @field(pinfo, fld.name); + const val = @field(params, fld.name); - params2 = params2 ++ [_]ParameterDef{.{ + params_list = params_list ++ [_]ParameterDef{.{ .out_fld_name = fld.name, - .OutputType = val.@"0", - .InputType = val.@"1", - .in_fld_name = val.@"2", - .resolver = val.@"3", + .OutputType = val.OutputType, + .InputType = val.InputType, + .in_fld_name = val.in_fld_name, + .resolver = val.resolver, }}; } return .{ - .params = params2, - .default_value = instance, + .params = params_list, + .default_val = instance, }; } @@ -257,10 +269,10 @@ pub fn Parameterized( // This is mostly for usage ergonomics, there's no actual implementation reason // that it has to be this way. const IntermediateParam = struct { - InputType: type, OutputType: type, - in_field_name: [:0]const u8, - resolver: *anyopaque, + InputType: type, + in_fld_name: [:0]const u8, + resolver: *const anyopaque, }; //Parameters can be either: @@ -271,7 +283,7 @@ pub fn Parameter( comptime T: type, comptime field_name: [:0]const u8, comptime resolver: anytype, -) std.meta.Tuple(&.{ type, type, [:0]const u8, *anyopaque }) { +) IntermediateParam { const ResolverType = @TypeOf(resolver); const rinfo = @typeInfo(ResolverType); @@ -281,7 +293,7 @@ pub fn Parameter( @compileError("Resolver functions must take a single argument"); const input_arg = f.params[0]; - break :blk .{ input_arg.type, resolver }; + break :blk .{ input_arg.type.?, resolver }; }, .null => blk: { const Container = struct { @@ -295,7 +307,12 @@ pub fn Parameter( else => @compileError("resolver must be a function or null"), }; - return .{ T, InputType, field_name, res }; + return IntermediateParam{ + .OutputType = T, + .InputType = InputType, + .in_fld_name = field_name, + .resolver = res, + }; } const testing = std.testing; @@ -312,9 +329,9 @@ const TestConfigStruct = struct { comptime_field_a: u32 = 0, comptime_field_b: usize = 0, - name: []const u8 = undefined, + name: []const u8 = "Unknown", - pointer: *const usize = undefined, + pointer: *const usize = &larrys_num, writer: ?std.io.AnyWriter = null, pub const Profiles = enum { @@ -337,7 +354,7 @@ const TestConfigStruct = struct { } fn sideEffectyResolver(w: std.io.AnyWriter) std.io.AnyWriter { - w.write("Evil function") catch @panic("Test write failed"); + _ = w.write("Evil function") catch @panic("Test write failed"); return w; } @@ -443,15 +460,16 @@ test "config (profile)" { } test "config (parameterized profile)" { - const string: [64]u8 = .{}; - var stream = std.io.fixedBufferStream(string); + var string: [64]u8 = .{0} ** 64; + var stream = std.io.fixedBufferStream(string[0..]); + var w = stream.writer(); const larry_num: usize = 12321; const val = TestConfigStruct.profile(.Larry, .{ .larry_bank_id = 943, .larry_name_id = 1, - .larry_number = 293, + .larry_number = &larry_num, }); try testing.expectEqual(val, TestConfigStruct{ @@ -464,15 +482,15 @@ test "config (parameterized profile)" { }); const writer_val = TestConfigStruct.profile(.WriterBoy, .{ - .some_writer = stream.writer(), + .some_writer = w.any(), }); try testing.expectEqual(writer_val, TestConfigStruct{ .name = "Writer Boy", - .writer = stream.writer(), + .writer = w.any(), }); - try testing.expectEqualSlices(u8, string[0..("Writer Boy").len], "Writer Boy"); + try testing.expectEqualSlices(u8, string[0..("Evil function").len], "Evil function"); } test "config (value composition)" { @@ -486,7 +504,7 @@ test "config (value composition)" { const res2 = val_a_b.combine(.PartialB, .{ .partial_name = "Name Here", - }); + }).finalize(); try testing.expectEqual(res, res2); diff --git a/src/common/util.zig b/src/common/util.zig index 02e8316..df2ad0b 100644 --- a/src/common/util.zig +++ b/src/common/util.zig @@ -35,9 +35,9 @@ const StructField = std.builtin.Type.StructField; const Function = std.builtin.Type.Fn; // Reflection Stuff -pub fn tryGetField(info: *StructInfo, name: []const u8) ?*StructField { +pub fn tryGetField(info: *const StructInfo, name: []const u8) ?*const StructField { for (info.fields) |*fld| { - if (std.mem.eql(u8, fld.name, name) == .eq) { + if (std.mem.eql(u8, fld.name, name)) { return fld; } } From 7bea56085fee1a7f110347a3100aaedb01f34218 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 18 Aug 2025 23:13:26 -0700 Subject: [PATCH 13/46] refactor(ray): updated ray module code to include common.zig as a module --- build.zig | 12 +++++- src/api/command_buffer.zig | 2 +- src/api/image.zig | 42 -------------------- src/resource_management/pool_allocator.zig | 2 +- src/resource_management/registry.zig | 2 +- src/resource_management/resource_manager.zig | 2 +- src/root.zig | 3 +- src/util.zig | 2 +- 8 files changed, 17 insertions(+), 50 deletions(-) diff --git a/build.zig b/build.zig index 142a0f2..5ef10dd 100644 --- a/build.zig +++ b/build.zig @@ -195,13 +195,21 @@ fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies, opts: BuildOpts) .root_module = lib_mod, .target = opts.target, }); + + const common_tests = b.addTest(.{ + .name = "common unit tests", + .root_module = deps.common, + .target = opts.target, + }); b.installArtifact(test_comp); + b.installArtifact(common_tests); const test_step = b.addRunArtifact(test_comp); + const common_test_step = b.addRunArtifact(common_tests); const test_cmd = b.step("run-tests", "run all unit tests"); + test_cmd.dependOn(&test_step.step); - - _ = deps; + test_cmd.dependOn(&common_test_step.step); } // Although this function looks imperative, note that its job is to // declaratively construct a build graph that will be executed by an external diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index 9f6b909..13448c7 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -113,7 +113,7 @@ pub fn deinit(self: *const Self) void { } const res = @import("../resource_management/res.zig"); -const common = @import("../common/common.zig"); +const common = @import("common"); pub const CommandBuffer = struct { h_cmd_buffer: vk.CommandBuffer, diff --git a/src/api/image.zig b/src/api/image.zig index 9112e1a..640f1d0 100644 --- a/src/api/image.zig +++ b/src/api/image.zig @@ -1,7 +1,6 @@ const std = @import("std"); const vk = @import("vulkan"); const rsh = @import("rshc"); -const common = @import("common"); const buf = @import("buffer.zig"); const util = @import("../util.zig"); @@ -55,47 +54,6 @@ pub const Config = struct { clear_col: ?vk.ClearColorValue = null, staging_buf: ?*StagingBuffer = null, initial_layout: vk.ImageLayout = .undefined, - - // Configuration stuff - const config = common.config; - const ConfigurationRegistry = config.ConfigurationRegistry; - - pub const Profiles = enum { - Texture, - Storage, - Depth, - }; - - fn configureStorage(cfg: *Config, params: struct { - usage_flags: vk.ImageUsageFlags, - }) void {} - - fn resolveExtent(swapchain: *const api.Swapchain) vk.Extent2D { - return swapchain.extent; - } - - const Registry = ConfigurationRegistry(Config, Profiles, .{ - .Texture = config.Parameterized(Config{ - .usage = .{ - .sampled_bit = true, - }, - }, .{ - .extent = config.Parameter(vk.Extent2D, "swapchain", resolveExtent), - }), - .Storage = Config{}, - .Depth = Config{}, - .Default = Config{}, - }); - - /// const image_cfg = Image.Config.from(.Texture, .{ - /// .swapchain = &my_swapchain, - /// }); - /// const image = api.Image.init(&my_context, allocator, image_config); - - pub const from = Registry.BuilderMixin; - // this is either a function or a static ref - pub const default = Registry.DefaultMixin; - pub const profile = Registry.ProfileMixin; }; fn createImageMemory( diff --git a/src/resource_management/pool_allocator.zig b/src/resource_management/pool_allocator.zig index bc219cc..d060425 100644 --- a/src/resource_management/pool_allocator.zig +++ b/src/resource_management/pool_allocator.zig @@ -14,7 +14,7 @@ //! which match vulkan object's lifetimes (generally they are the same per-type of object) const std = @import("std"); -const common = @import("../common/common.zig"); +const common = @import("common"); const assert = std.debug.assert; const Allocator = std.mem.Allocator; diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index d506e09..5e86ca9 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -5,7 +5,7 @@ //! This is globally defined and not scoped to an application context const std = @import("std"); -const common = @import("../common/common.zig"); +const common = @import("common"); const Context = @import("../context.zig"); const Allocator = std.mem.Allocator; diff --git a/src/resource_management/resource_manager.zig b/src/resource_management/resource_manager.zig index f618e3b..c6b25a9 100644 --- a/src/resource_management/resource_manager.zig +++ b/src/resource_management/resource_manager.zig @@ -1,7 +1,7 @@ const std = @import("std"); const Self = @This(); -const common = @import("../common/common.zig"); +const common = @import("common"); const Registry = @import("registry.zig"); const PoolAllocator = @import("pool_allocator.zig"); diff --git a/src/root.zig b/src/root.zig index 18c253f..ab675c3 100644 --- a/src/root.zig +++ b/src/root.zig @@ -6,7 +6,8 @@ pub const api = @import("api/api.zig"); // Linear algebra math pub const math = @import("math.zig"); -// random common utilities (i.e: "misc") +//TODO: replace the shitty utils with common +pub const common = @import("common"); pub const util = @import("util.zig"); // Resource manager NOTE: (not sure if this should be exported tbh) diff --git a/src/util.zig b/src/util.zig index 02e8316..269a051 100644 --- a/src/util.zig +++ b/src/util.zig @@ -35,7 +35,7 @@ const StructField = std.builtin.Type.StructField; const Function = std.builtin.Type.Fn; // Reflection Stuff -pub fn tryGetField(info: *StructInfo, name: []const u8) ?*StructField { +pub fn tryGetField(info: *const StructInfo, name: []const u8) ?*StructField { for (info.fields) |*fld| { if (std.mem.eql(u8, fld.name, name) == .eq) { return fld; From ee303255f7cb5c6ab59c3c0a31173bcf93c9753a Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Tue, 19 Aug 2025 10:53:01 -0700 Subject: [PATCH 14/46] fix(config): fixed struct union by ensuring only non-default values overwrite the base struct --- src/common/config.zig | 52 ++++++++++++++++++++++++++++++------------- 1 file changed, 37 insertions(+), 15 deletions(-) diff --git a/src/common/config.zig b/src/common/config.zig index e78c206..c7fd9f8 100644 --- a/src/common/config.zig +++ b/src/common/config.zig @@ -98,7 +98,7 @@ pub fn ConfigurationRegistry( const parameters = @field(profile_defs, fld.name).params; comptime var ptype_fields: []const std.builtin.Type.StructField = &.{}; - comptime var resolvers: []const struct {[]const u8, ParameterDef} = &.{}; + comptime var resolvers: []const struct { []const u8, ParameterDef } = &.{}; for (parameters) |p| { ptype_fields = ptype_fields ++ [_]std.builtin.Type.StructField{.{ @@ -109,7 +109,7 @@ pub fn ConfigurationRegistry( .alignment = @alignOf(p.InputType), }}; - resolvers = resolvers ++ .{ .{ p.in_fld_name, p } }; + resolvers = resolvers ++ .{.{ p.in_fld_name, p }}; } const PType = @Type(.{ @@ -145,7 +145,6 @@ pub fn ConfigurationRegistry( @typeName(ConfigType)); } }; - } return struct { @@ -169,7 +168,16 @@ pub fn ConfigurationRegistry( underlying: ConfigType, pub fn extend(self: *ConfigBuilder, vals: ConfigType) *ConfigBuilder { inline for (@typeInfo(ConfigType).@"struct".fields) |*fld| { - @field(self.underlying, fld.name) = @field(vals, fld.name); + const default_val = fld.defaultValue(); + const in_val = @field(vals, fld.name); + + // This ensures we do not overwrite fields that are left as default values. + if (!std.meta.eql(default_val, in_val)) { + @field( + self.underlying, + fld.name, + ) = @field(vals, fld.name); + } } return self; @@ -202,10 +210,14 @@ pub fn ConfigurationRegistry( inline for (ptype_info.fields) |*fld| { const res = rmap.get(fld.name) orelse unreachable; - @field(val, res.out_fld_name) = @as( - *const fn (res.InputType) res.OutputType, - @ptrCast(@alignCast(res.resolver))) - (@field(params, res.in_fld_name)); + const in_val = @field(params, res.in_fld_name); + + const func = @as( + *const fn (res.InputType) res.OutputType, + @ptrCast(@alignCast(res.resolver)), + ); + + @field(val, res.out_fld_name) = func(in_val); } } @@ -307,11 +319,11 @@ pub fn Parameter( else => @compileError("resolver must be a function or null"), }; - return IntermediateParam{ - .OutputType = T, - .InputType = InputType, - .in_fld_name = field_name, - .resolver = res, + return IntermediateParam{ + .OutputType = T, + .InputType = InputType, + .in_fld_name = field_name, + .resolver = res, }; } @@ -404,7 +416,7 @@ const TestConfigStruct = struct { .writer = null, }, .PartialA = TestConfigStruct{ - .flags = .{.bit_1 = true}, + .flags = .{ .bit_1 = true }, .comptime_field_a = 999, }, .PartialB = Parameterized(TestConfigStruct{ @@ -506,6 +518,16 @@ test "config (value composition)" { .partial_name = "Name Here", }).finalize(); - try testing.expectEqual(res, res2); } + +test "overwritting values" { + var partial_val_builder = TestConfigStruct.from(.PartialA, .{}); + + // makes sure composition doesn't overwrite the original values with default values... + const config = partial_val_builder.extend(.{ + .comptime_field_b = 10230, + }).finalize(); + + try testing.expect(config.comptime_field_a == 999); +} From 458bab581ed3d6e021d1e70ac20e4050e5217897 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 23 Aug 2025 13:00:16 -0700 Subject: [PATCH 15/46] feat(api): implement descriptor pool with allocations based on usage hints --- src/api/api.zig | 4 +++- src/api/{common.zig => common_types.zig} | 0 src/api/descriptor.zig | 2 +- src/api/descriptor_pool.zig | 2 +- src/context.zig | 5 +---- src/resource_management/pool_allocator.zig | 3 +++ 6 files changed, 9 insertions(+), 7 deletions(-) rename src/api/{common.zig => common_types.zig} (100%) diff --git a/src/api/api.zig b/src/api/api.zig index f1b37ec..2639363 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -52,9 +52,10 @@ const BufInterface = buf.AnyBuffer; pub const Descriptor = @import("descriptor.zig"); pub const ResolvedDescriptorBinding = Descriptor.ResolvedBinding; +pub const DescriptorPool = @import("descriptor_pool.zig"); // additional utility structs and stuff -const types = @import("types.zig"); +const types = @import("common_types.zig"); pub const SyncInfo = types.SyncInfo; // sync stuff @@ -66,6 +67,7 @@ pub const ShaderModule = sh.Module; // Obtaining RTTI for vulkan API const Registry = @import("../resource_management/res.zig").Registry; + pub fn initRegistry(reg: *Registry) !void { try CommandBuffer.addEntries(reg); } diff --git a/src/api/common.zig b/src/api/common_types.zig similarity index 100% rename from src/api/common.zig rename to src/api/common_types.zig diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index 16b86ee..76b07a6 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -6,7 +6,7 @@ const vk = @import("vulkan"); const util = @import("../util.zig"); const uniform = @import("uniform.zig"); const buffer = @import("buffer.zig"); -const common = @import("common.zig"); +const common = @import("common_types.zig"); const Allocator = std.mem.Allocator; diff --git a/src/api/descriptor_pool.zig b/src/api/descriptor_pool.zig index 4ea695b..b11699e 100644 --- a/src/api/descriptor_pool.zig +++ b/src/api/descriptor_pool.zig @@ -6,7 +6,7 @@ //! These hints will encompass either the lifetime of the descriptor set and/or //! the actual makeup of descriptors. -const common = @import("common.zig"); +const common = @import("common_types.zig"); const vk = @import("vulkan"); const std = @import("std"); const api = @import("api.zig"); diff --git a/src/context.zig b/src/context.zig index 02d2b3d..0bbdd7a 100644 --- a/src/context.zig +++ b/src/context.zig @@ -140,10 +140,7 @@ pub fn init(allocator: Allocator, config: Config) !*Self { // Initialize Instance and device from parameters // Later on, I'll have some better ways to handle ownership and lifetimes - // then just raw heap allocations lol - - // Would be great if errdefers worked in initializers... because I like keeping initialization - // in initializers when I can + // then just raw heap allocations lol (Working on it) new.inst = try Instance.init(&.{ .instance = .{ diff --git a/src/resource_management/pool_allocator.zig b/src/resource_management/pool_allocator.zig index f9d1353..9f1effd 100644 --- a/src/resource_management/pool_allocator.zig +++ b/src/resource_management/pool_allocator.zig @@ -200,6 +200,9 @@ pub fn free(self: *Self, item: *anyopaque) void { /// It's not a slice because you cant directly have slices /// whose underling type is unknown (opaque). pub fn freeRange(self: *Self, items: *anyopaque, count: usize) void { + _ = self; + _ = items; + _ = count; } pub fn freeAll(self: *Self) void { From 98ac7f2af95024dedc8bf855a130190f6181f76c Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 23 Aug 2025 17:58:40 -0700 Subject: [PATCH 16/46] feat(vulkan): implemented vulkan pools and reworked descriptor creation to be a lot smoother --- src/api/api.zig | 5 +- src/api/common_types.zig | 4 + src/api/descriptor.zig | 441 +++++++++++++++++++++++------------- src/api/descriptor_pool.zig | 22 -- src/api/uniform.zig | 1 + 5 files changed, 288 insertions(+), 185 deletions(-) diff --git a/src/api/api.zig b/src/api/api.zig index 2639363..ad68219 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -8,6 +8,7 @@ const ind_buf = @import("index_buffer.zig"); const sh = @import("shader.zig"); const uni_buf = @import("uniform.zig"); const vert_buf = @import("vertex_buffer.zig"); +const common = @import("common_types.zig"); // direct vulkan-zig imports pub const GlobalInterface = vk.BaseWrapper; @@ -48,11 +49,13 @@ pub const ComptimeVertexBuffer = vert_buf.VertexBuffer; pub const ComptimeIndexBuffer = ind_buf.IndexBuffer; pub const ComptimeUniformBuffer = uni_buf.UniformBuffer; pub const ComptimeStorageBuffer = @import("storage_buffer.zig").ComptimeStorageBuffer; -const BufInterface = buf.AnyBuffer; +pub const BufInterface = buf.AnyBuffer; pub const Descriptor = @import("descriptor.zig"); pub const ResolvedDescriptorBinding = Descriptor.ResolvedBinding; pub const DescriptorPool = @import("descriptor_pool.zig"); +pub const DescriptorType = common.DescriptorType; +pub const DescriptorUsageInfo = common.DescriptorUsageInfo; // additional utility structs and stuff const types = @import("common_types.zig"); diff --git a/src/api/common_types.zig b/src/api/common_types.zig index 3588994..9329a74 100644 --- a/src/api/common_types.zig +++ b/src/api/common_types.zig @@ -44,4 +44,8 @@ pub const DescriptorType = enum(u8) { .Image => .storage_image, }; } + + pub fn toIndex(self: DescriptorType) usize { + return @intFromEnum(self); + } }; diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index 76b07a6..8de1a37 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -4,21 +4,18 @@ const std = @import("std"); const vk = @import("vulkan"); const util = @import("../util.zig"); -const uniform = @import("uniform.zig"); -const buffer = @import("buffer.zig"); const common = @import("common_types.zig"); -const Allocator = std.mem.Allocator; +const api = @import("api.zig"); -const DeviceHandler = @import("base.zig").DeviceHandler; -const UniformBuffer = uniform.UniformBuffer; -const CommandBuffer = @import("command_buffer.zig"); const Context = @import("../context.zig"); -const AnyBuffer = buffer.AnyBuffer; - -const TexImage = @import("texture.zig"); -const Image = @import("image.zig"); +const Allocator = std.mem.Allocator; +const DeviceHandler = api.DeviceHandler; +const UniformBuffer = api.ComptimeUniformBuffer; +const CommandBuffer = api.CommandBuffer; +const AnyBuffer = api.BufInterface; +const Image = api.Image; const log = std.log.scoped(.descriptor); @@ -34,6 +31,11 @@ fn createDescriptorPool(pr_dev: *const vk.DeviceProxy) !vk.DescriptorPool { }, null); } +pub const Config = struct { + layout: DescriptorLayout, + usage: common.DescriptorUsageInfo, +}; + pub const DescriptorType = common.DescriptorType; pub const ResolvedBinding = struct { @@ -65,168 +67,24 @@ const BindingWriteInfo = union(enum) { /// is the (0 indexed) order they be actually laid out const Self = @This(); -pub const Config = struct { - // this gets copied to the actual array, so it can be specified locally no problemo - bindings: []const ResolvedBinding, -}; - -h_desc_layout: vk.DescriptorSetLayout, h_desc_set: vk.DescriptorSet, pr_dev: *const vk.DeviceProxy, -allocator: Allocator, - -resolved_bindings: []ResolvedBinding = undefined, - -fn resolveDescriptorLayout( - layouts: []vk.DescriptorSetLayoutBinding, - bindings: []const ResolvedBinding, -) void { - // I guess just ignore any extra bindings specified, not my problem lol - for (0..layouts.len) |index| { - layouts[index] = vk.DescriptorSetLayoutBinding{ - .binding = @intCast(index), - .descriptor_count = 1, - .stage_flags = bindings[index].stages, - - .descriptor_type = switch (bindings[index].data) { - .Sampler => .combined_image_sampler, - .Uniform => .uniform_buffer, - .StorageBuffer => .storage_buffer, - .Image => .storage_image, - }, - }; - } -} - -fn updateDescriptorSets( - self: *Self, - dev: *const DeviceHandler, - desc_set: vk.DescriptorSet, - allocator: Allocator, -) !void { - const num_bindings = self.resolved_bindings.len; - var writes: []vk.WriteDescriptorSet = try allocator.alloc( - vk.WriteDescriptorSet, - num_bindings, - ); - defer allocator.free(writes); - var write_infos: []BindingWriteInfo = try allocator.alloc( - BindingWriteInfo, - num_bindings, - ); - defer allocator.free(write_infos); - - for (self.resolved_bindings, 0..num_bindings) |binding, index| { - writes[index] = vk.WriteDescriptorSet{ - .descriptor_type = undefined, - - .dst_binding = @intCast(index), - .dst_array_element = 0, - .descriptor_count = 1, - .dst_set = desc_set, - - .p_buffer_info = undefined, - .p_image_info = undefined, - .p_texel_buffer_view = undefined, - }; - - self.resolved_bindings[index] = binding; - - switch (binding.data) { - .Sampler => |sampler| { - write_infos[index] = .{ .Image = vk.DescriptorImageInfo{ - .image_layout = .read_only_optimal, - .image_view = sampler.view, - .sampler = sampler.sampler, - } }; - - writes[index].descriptor_type = .combined_image_sampler; - writes[index].p_image_info = &.{write_infos[index].Image}; - }, - .Image => |img| { - write_infos[index] = .{ .Image = vk.DescriptorImageInfo{ - .image_layout = .general, - .image_view = img.view, - .sampler = .null_handle, - } }; - - writes[index].p_image_info = &.{write_infos[index].Image}; - writes[index].descriptor_type = .storage_image; - }, - else => { - const buf: AnyBuffer, const dt: vk.DescriptorType = switch (binding.data) { - .Uniform => |buf| .{ buf, .uniform_buffer }, - .StorageBuffer => |buf| .{ buf, .storage_buffer }, - else => unreachable, - }; - - write_infos[index] = .{ .Buffer = vk.DescriptorBufferInfo{ - .buffer = buf.handle, - .offset = 0, - .range = buf.size, - } }; - - writes[index].descriptor_type = dt; - - writes[index].p_buffer_info = &.{ - write_infos[index].Buffer, - }; - }, - } - } - - dev.pr_dev.updateDescriptorSets( - @intCast(writes.len), - writes[0..].ptr, - 0, - null, - ); -} +layout: DescriptorLayout, -pub fn init(ctx: *const Context, allocator: Allocator, config: Config) !Self { +pub fn init(ctx: *const Context, config: Config) !Self { const dev: *const DeviceHandler = ctx.env(.dev); var desc_pools = ctx.env(.desc); - var desc_bindings = try allocator.alloc( - vk.DescriptorSetLayoutBinding, - config.bindings.len, - ); - defer allocator.free(desc_bindings); - - resolveDescriptorLayout(desc_bindings, config.bindings); - - const layout_info = vk.DescriptorSetLayoutCreateInfo{ - .binding_count = @intCast(desc_bindings.len), - .p_bindings = desc_bindings[0..].ptr, - }; - - const desc_layout = try dev.pr_dev.createDescriptorSetLayout( - &layout_info, - null, - ); - - const desc_set = try desc_pools.reserve(config.usage, desc_layout); - - // setup the bloody descriptor sets and associate them wit the buffer - const owned_bindings = try allocator.alloc( - ResolvedBinding, - config.bindings.len, - ); - errdefer allocator.free(owned_bindings); - std.mem.copyForwards(ResolvedBinding, owned_bindings, config.bindings); + const desc_set = try desc_pools.reserve(config.usage, config.layout); var descriptor = Self{ - .h_desc_layout = desc_layout, + .layout = config.layout, .pr_dev = &dev.pr_dev, .h_desc_set = desc_set, - .resolved_bindings = owned_bindings, - .allocator = allocator, }; errdefer descriptor.deinit(); - try descriptor.updateDescriptorSets(dev, desc_set[0], allocator); - return descriptor; } @@ -234,7 +92,9 @@ pub const BindInfo = struct { bind_point: vk.PipelineBindPoint = .graphics, }; -pub fn bind( +/// formerly "bind" (renamed to avoid confusion with +/// binding concrete resources to descriptor slots) +pub fn use( self: *const Self, cmd_buf: *const CommandBuffer, layout: vk.PipelineLayout, @@ -256,18 +116,275 @@ pub fn deinit(self: *Self, ctx: *const Context) void { var desc_pool = ctx.env(.desc); // this may do nothing depending on usage desc_pool.free(self.usage, self.h_desc_set); + self.layout.deinit(); +} - self.allocator.free(self.resolved_bindings); +pub fn bindUniformsNamed(self: *Self, name: []const u8, ubo: AnyBuffer) void { + const loc = self.layout.named_bindings.get(name) orelse return; + self.bindUniforms(loc, ubo); } -pub fn update(self: *Self, index: usize, data: anytype) !void { +pub fn bindSamplerNamed(self: *Self, name: []const u8, sampler: vk.Sampler, view: vk.ImageView) void { + const loc = self.layout.named_bindings.get(name) orelse return; + self.bindSampler(loc, sampler, view); +} + +pub fn bindImageNamed(self: *Self, name: []const u8, img: *const Image, view: vk.ImageView) void { + const loc = self.layout.named_bindings.get(name) orelse return; + self.bindImage(loc, img, view); +} + +pub fn bindBufferNamed(self: *Self, name: []const u8, buf: AnyBuffer) void { + const loc = self.layout.named_bindings.get(name) orelse return; + self.bindBuffer(loc, buf); +} + +pub fn bindUniforms(self: *Self, index: usize, ubo: AnyBuffer) void { + self.bindBase(index, .{.Uniform = ubo}); +} + +pub fn bindSampler(self: *Self, index: usize, sampler: vk.Sampler, view: vk.ImageView) void { + self.bindBase(index, .{.Sampler = .{ + .sampler = sampler, + .view = view, + }}); +} + +pub fn bindImage(self: *Self, index: usize, img: *const Image, view: vk.ImageView) void { + self.bindBase(index, .{.Image = .{ + .img = img, + .view = view, + }}); +} + +pub fn bindBuffer(self: *Self, index: usize, buf: AnyBuffer) void { + self.bindBase(index, .{.StorageBuffer = buf}); +} + +fn bindBase(self: *Self, index: usize, b: DescriptorBinding) void { + const write = &self.layout.writes[index]; + write.* = vk.WriteDescriptorSet{ + .descriptor_type = undefined, + + .dst_binding = @intCast(index), + .dst_array_element = 0, + .descriptor_count = 1, + .dst_set = self.h_desc_set, + + .p_buffer_info = undefined, + .p_image_info = undefined, + .p_texel_buffer_view = undefined, + }; + + var binding: BindingWriteInfo = undefined; + + switch (b) { + .Sampler => |sampler| { + binding = .{ .Image = vk.DescriptorImageInfo{ + .image_layout = .read_only_optimal, + .image_view = sampler.view, + .sampler = sampler.sampler, + } }; + + write.descriptor_type = .combined_image_sampler; + write.p_image_info = &.{binding.Image}; + }, + .Image => |img| { + binding = .{ .Image = vk.DescriptorImageInfo{ + .image_layout = .general, + .image_view = img.view, + .sampler = .null_handle, + } }; + + write.p_image_info = &.{binding.Image}; + write.descriptor_type = .storage_image; + }, + else => { + const buf: AnyBuffer, const dt: vk.DescriptorType = switch (binding.data) { + .Uniform => |buf| .{ buf, .uniform_buffer }, + .StorageBuffer => |buf| .{ buf, .storage_buffer }, + else => unreachable, + }; + + binding = .{ .Buffer = vk.DescriptorBufferInfo{ + .buffer = buf.handle, + .offset = 0, + .range = buf.size, + } }; + + write.descriptor_type = dt; + + write.p_buffer_info = &.{binding.Buffer}; + }, + } +} + + +/// Write descriptor values to the descriptor set. +/// -- This should happen anytime the descriptor's makeup changes +/// (i.e a new texture or buffer is needed) +/// Do note that just updating data of existing uniform or storage buffers +/// should just be done directly using the "setValue" function +pub fn update(self: *Self) void { + self.pr_dev.updateDescriptorSets( + @intCast(self.layout.writes.len), + self.layout.writes.ptr, + 0, + null, + ); +} + +/// Formerly "update" +pub fn setValue(self: *Self, index: usize, data: anytype) !void { const binding = self.resolved_bindings[index]; switch (binding.data) { .Uniform => |buf| try buf.setData(data), .StorageBuffer => |buf| try buf.setData(data), else => { - log.err("Fuck (AKA no texture updating pretty please)", .{}); + log.err("Images may not be written from via descriptors", .{}); return error.Unsupported; }, } } + +const DescriptorBinding = union(DescriptorType) { + Uniform: AnyBuffer, + StorageBuffer: AnyBuffer, + Image: struct { + img: *const Image, + view: vk.ImageView, + }, + Sampler: struct { + sampler: vk.Sampler, + view: vk.ImageView, + }, +}; + +const debug = std.debug; + +// Descriptor layouts done better +pub const DescriptorLayout = struct { + const Specifier = struct { + u32, + []const u8, + DescriptorType, + vk.ShaderStageFlags, + + }; + + fn id(spec: Specifier) SpecifierID { + return SpecifierID{ + .type = @intCast(spec.@"2".toIndex()), + .stage_flags = spec.@"3", + }; + } + const SpecifierID = packed struct { + type: u32, + stage_flags: vk.ShaderStageFlags, + }; + + di: *const api.DeviceInterface, + allocator: Allocator, + + specifiers: std.ArrayListUnmanaged(Specifier), + named_bindings: std.StringArrayHashMap(usize), + + writes: []vk.WriteDescriptorSet, + layout: ?vk.DescriptorLayout = null, + size: usize, + + /// Screw you, just figure out how many descriptors you need before + /// allocating shit all over the place. + pub fn init(ctx: *const Context, allocator: Allocator, size: usize) !DescriptorLayout { + var bindings_map = std.StringArrayHashMap(usize).init(allocator); + + try bindings_map.ensureTotalCapacity(size); + return DescriptorLayout{ + .di = ctx.env(.dev), + .allocator = allocator, + + .specifiers = try std.ArrayListUnmanaged(Specifier).initCapacity(allocator, size), + + .writes = try allocator.alloc(vk.WriteDescriptorSet, size), + .size = usize, + }; + } + + pub fn addDescriptor(self: *DescriptorLayout, spec: Specifier) void { + debug.assert(self.specifiers.items.len + 1 < self.size); + self.specifiers.appendAssumeCapacity(spec); + self.named_bindings.putAssumeCapacity(spec.@"1", self.specifiers.items.len - 1); + } + + pub fn addDescriptors(self: *DescriptorLayout, specs: []const Specifier) void { + debug.assert(self.specifiers.items.len + specs.len < self.size); + + for (specs) |spec| { + self.specifiers.insertAssumeCapacity(@intCast(spec.@"0"), spec); + self.named_bindings.putAssumeCapacity(spec.@"1", self.specifiers.items.len - 1); + } + } + + pub fn resolve(self: *DescriptorLayout) !void { + const layout_infos = try self.allocator.alloc(vk.DescriptorSetLayoutBinding, self.size); + defer self.allocator.free(layout_infos); + + for (self.specifiers, layout_infos) |spec, layout_info| { + layout_info.descriptor_count = 1; + layout_info.descriptor_type = layout_info.@"2".toVkDescriptor(); + + layout_info.binding = spec.@"0"; + layout_info.stage_flags = spec.@"3"; + } + + self.layout = try self.di.createDescriptorSetLayout(&.{ + .binding_count = @intCast(layout_infos.len), + .p_bindings = layout_infos.ptr, + }, null); + } + + pub fn deinit(self: *const DescriptorLayout) void { + self.allocator.free(self.writes); + self.specifiers.deinit(self.allocator); + + if (self.layout) |l| { + self.di.destroyDescriptorSetLayout(l, null); + } + } +}; + +//TODO: Unfortunately any unit tests involving context-inditialized objects +//are impossible because the context explodes when you don't intialize it correctly +//(i.e without a window, since you shouldn't have unit tests spawn a gajillion windows if +//you can help it) + +//NOTE: Example usage +// +//pub fn thing() void { +// const ctx: Context = undefined; +// const allocator: Allocator = undefined; +// +// var layout = try DescriptorLayout.init(); +// +// try layout.addDescriptors(&.{ +// .{ 0, "Uniforms", .Uniform }, +// .{ 1, "MainTex", .Sampler }, +// .{ 2, "ComputeOutput", .Image }, +// }); +// try layout.resolve(); +// +// //NOTE: You give ownership to the descriptor when you +// var desc = try Self.init(ctx, allocator, layout); +// +// // After consideration, I have elected to prefix this family of functions +// // with "bind", as they are what associates a concrete resource +// // with the descriptor "slot" persay. In the case of image-type descriptors, +// // these functions are literally all that you need to associate a concrete +// // image with a descriptor slot, making them almost analogous with "glBindTexture" and such. +// desc.bindUniformsNamed("Uniforms", some_ubo); +// desc.bindSamplerNamed("MainTex", some_texture); +// desc.bindBufferNamed("BuffyTheBuffer", some_buffer); +// desc.bindImageNamed("ComputeOutput", some_storage_image); +// +// desc.update(); +//} diff --git a/src/api/descriptor_pool.zig b/src/api/descriptor_pool.zig index b11699e..d018cd3 100644 --- a/src/api/descriptor_pool.zig +++ b/src/api/descriptor_pool.zig @@ -291,25 +291,3 @@ pub fn freeRange( } } -const glfw = @import("glfw"); - -test "transient allocations" { - var alloc = std.heap.DebugAllocator(.{ - .safety = true, - .enable_memory_limit = true, - }); - var test_ctx = try Context.init(alloc.allocator(), .{ - .management = .{ - .allocator = alloc.allocator(), - .pool_sizes = 1024, - }, - .inst_extensions = glfw.instanceExtensions(), - .loader = glfw.glfwGetInstanceProcAddress, - .window = null, - }); - - var pool = test_ctx.env(.desc); - - const d = pool.reserve( - pool.resetTransient(); -} diff --git a/src/api/uniform.zig b/src/api/uniform.zig index 3ed0e94..89018d8 100644 --- a/src/api/uniform.zig +++ b/src/api/uniform.zig @@ -9,6 +9,7 @@ const Context = @import("../context.zig"); const AnyBuffer = buf_api.AnyBuffer; const GenericBuffer = buf_api.GenericBuffer; +/// More like undefined behaviour object LMAO pub fn UniformBuffer(T: type) type { return struct { const Self = @This(); From d623a0a9e69d528ecbd077f16eab036a92b30512 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 23 Aug 2025 17:59:48 -0700 Subject: [PATCH 17/46] fix(res): fixed a minor usage issue involving the constness of a registry query --- src/context.zig | 31 ++++++++++++++++++-- src/resource_management/registry.zig | 2 ++ src/resource_management/resource_manager.zig | 14 +++++---- src/root.zig | 1 + 4 files changed, 40 insertions(+), 8 deletions(-) diff --git a/src/context.zig b/src/context.zig index 0bbdd7a..1c562e4 100644 --- a/src/context.zig +++ b/src/context.zig @@ -97,7 +97,7 @@ pub fn env(self: *const Self, comptime field: anytype) ResolveEnvType(field) { pub const Config = struct { inst_extensions: []const [*:0]const u8 = &.{}, dev_extensions: []const [*:0]const u8 = &.{}, - window: ?*const glfw.Window, + window: ?*const glfw.Window = null, loader: glfw.GetProcAddrHandler, management: res.ResourceManager.Config, }; @@ -183,7 +183,7 @@ pub fn init(allocator: Allocator, config: Config) !*Self { new.registry = try Registry.init(allocator); try api.initRegistry(&new.registry); - new.resources = try res.ResourceManager.init(config.management, new.registry); + new.resources = try res.ResourceManager.init(config.management, &new.registry); return new; } @@ -226,3 +226,30 @@ pub fn presentFrame( const image = swapchain.image_index; try self.present_queue.present(swapchain, image, sync.sem_wait); } + +//BUG: This cannot work since windowless contexts would require +//a lot more features that I currently support +// test "windowless context" { +// var allocator = std.heap.DebugAllocator(.{ +// .safety = true, +// }).init; +// defer { +// _ = allocator.detectLeaks(); +// if (allocator.deinit() != .ok) { +// std.debug.print("Oppsies\n", .{}); +// } +// } +// try glfw.init(); +// +// const extensions = glfw.instanceExtensions(); +// +// var ctx = try Self.init(allocator.allocator(), .{ +// .inst_extensions = extensions, +// .loader = glfw.glfwGetInstanceProcAddress, +// .management = .{ +// .allocator = allocator.allocator(), +// .pool_sizes = 1024, +// }, +// }); +// defer ctx.deinit(); +// } diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index 5e86ca9..d8f7aa1 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -73,6 +73,7 @@ fn DeinitFnTemplate(comptime config: EntryConfig) type { pub const RegistryEntry = struct { type_id: TypeId, type_name: []const u8, + size_bytes: usize, initFn: AnyPtr, deinitFn: AnyPtr, @@ -109,6 +110,7 @@ pub fn addEntry( .type_id = common.typeId(config.state), .type_name = @typeName(config.state), .management = config.management, + .size_bytes = @sizeOf(config.state), }; // If the type registry fails to build, there is literally nothing to be done about it. diff --git a/src/resource_management/resource_manager.zig b/src/resource_management/resource_manager.zig index c6b25a9..ee0b064 100644 --- a/src/resource_management/resource_manager.zig +++ b/src/resource_management/resource_manager.zig @@ -21,14 +21,15 @@ pub const Config = struct { pools: MemoryPoolsTable, -pub fn init(config: Config, registry: Registry) !Self { - // loop through each API registry entry +pub fn init(config: Config, registry: *Registry) !Self { + // loop through each API registry entry // and initialize the table with a pool for each entry // whose management strategy is tagged as "Pooled" - - const entries = registry.select() + + var entries_iter = registry.select(); + var entries = entries_iter .where(Predicate.ManagementModeIs(.Pooled)) - .iterator(); + .iterator(); var table = MemoryPoolsTable.init(config.allocator); @@ -39,7 +40,8 @@ pub fn init(config: Config, registry: Registry) !Self { .elem_count = config.pool_sizes, }; - try table.put(entry.id, + try table.put( + entry.type_id, try PoolAllocator.initAlloc(config.allocator, pool_config), ); } diff --git a/src/root.zig b/src/root.zig index ab675c3..2c5738a 100644 --- a/src/root.zig +++ b/src/root.zig @@ -17,4 +17,5 @@ pub const res = @import("resource_management/res.zig"); comptime { _ = @import("resource_management/pool_allocator.zig"); _ = @import("resource_management/registry.zig"); + _ = @import("context.zig"); } From 450c230d4232c927914406240672a5c5a187b91a Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 23 Aug 2025 18:05:41 -0700 Subject: [PATCH 18/46] feat(context): added descriptor pool manager to app context --- src/context.zig | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/context.zig b/src/context.zig index 1c562e4..2cc68ca 100644 --- a/src/context.zig +++ b/src/context.zig @@ -27,6 +27,7 @@ const EnvBacking = struct { inst: Ref(Instance, .{}), dev: Ref(Device, .{}), surf: Ref(Surface, .{}), + desc: Ref(api.DescriptorPool, .{.field = "descriptor_pool"}), gi: Ref(GlobalInterface, .{ .field = "global_interface" }), ii: Ref(InstanceInterface, .{ .field = "inst_interface" }), @@ -57,6 +58,7 @@ compute_queue: api.ComputeQueue, allocator: Allocator, resources: res.ResourceManager, +descriptor_pool: api.DescriptorPool, registry: Registry, fn ResolveEnvType(comptime field: anytype) type { @@ -184,6 +186,11 @@ pub fn init(allocator: Allocator, config: Config) !*Self { try api.initRegistry(&new.registry); new.resources = try res.ResourceManager.init(config.management, &new.registry); + try api.DescriptorPool.initSelf(&new.descriptor_pool, new, .{ + .scene = 1024, + .static = 1024, + .transient = 1024, + }); return new; } From f3be4d94068d3c83d346131072ec47114091a83d Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 23 Aug 2025 18:16:04 -0700 Subject: [PATCH 19/46] fix: minor compilation errors for DescriptorUsageInfo --- src/api/common_types.zig | 2 +- src/api/descriptor_pool.zig | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/api/common_types.zig b/src/api/common_types.zig index 9329a74..052f68d 100644 --- a/src/api/common_types.zig +++ b/src/api/common_types.zig @@ -12,7 +12,7 @@ pub const DescriptorUsageInfo = packed struct { /// THis just directly controls which pool the descriptor is /// allocated into. For the moment, all descriptors will be /// either transient or application scoped - pub const LifetimeScope = enum { + pub const LifetimeScope = enum(u3) { /// descriptor exists for just a single frame /// which places it into the "transient" pool Transient, diff --git a/src/api/descriptor_pool.zig b/src/api/descriptor_pool.zig index d018cd3..79d8399 100644 --- a/src/api/descriptor_pool.zig +++ b/src/api/descriptor_pool.zig @@ -14,7 +14,7 @@ const api = @import("api.zig"); const Allocator = std.mem.Allocator; const UsageInfo = common.DescriptorUsageInfo; -const PoolUsageMap = std.EnumMap(UsageInfo.LifetimeScope); +const PoolUsageMap = std.EnumMap(UsageInfo.LifetimeScope, AnyPool); const Context = @import("../context.zig"); const log = std.log.scoped(.desc_pool); From f2b751f6ecb360e46da18fa1f52ad576165bb06f Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 24 Aug 2025 12:01:02 -0700 Subject: [PATCH 20/46] fix(pool): fixed alignment and slot sizing issues by enforcing a minimum element size limit --- src/api/api.zig | 2 +- src/api/compute.zig | 17 ++-- src/api/descriptor.zig | 93 ++++++++++++---------- src/api/descriptor_pool.zig | 42 ++++++---- src/context.zig | 14 +++- src/env.zig | 3 +- src/resource_management/pool_allocator.zig | 40 ++++++++-- src/resource_management/registry.zig | 13 ++- 8 files changed, 138 insertions(+), 86 deletions(-) diff --git a/src/api/api.zig b/src/api/api.zig index ad68219..3034520 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -52,8 +52,8 @@ pub const ComptimeStorageBuffer = @import("storage_buffer.zig").ComptimeStorageB pub const BufInterface = buf.AnyBuffer; pub const Descriptor = @import("descriptor.zig"); -pub const ResolvedDescriptorBinding = Descriptor.ResolvedBinding; pub const DescriptorPool = @import("descriptor_pool.zig"); +pub const DescriptorLayout = Descriptor.DescriptorLayout; pub const DescriptorType = common.DescriptorType; pub const DescriptorUsageInfo = common.DescriptorUsageInfo; diff --git a/src/api/compute.zig b/src/api/compute.zig index ecf53cf..cfd252f 100644 --- a/src/api/compute.zig +++ b/src/api/compute.zig @@ -17,7 +17,7 @@ const Self = @This(); pub const Config = struct { shader: *const ShaderModule, - desc_bindings: []const ResolvedBinding, + desc: api.Descriptor, }; pr_dev: *const DeviceInterface, @@ -25,24 +25,19 @@ h_pipeline: vk.Pipeline, h_pipeline_layout: vk.PipelineLayout, desc: Descriptor, -pub fn init(ctx: *const Context, allocator: Allocator, cfg: Config) !Self { +pub fn init(ctx: *const Context, cfg: Config) !Self { const pr_dev: *const DeviceInterface = ctx.env(.di); - var desc = try Descriptor.init(ctx, allocator, .{ - .bindings = cfg.desc_bindings, - }); - errdefer desc.deinit(); - // create the actual pipeline const layout = try pr_dev.createPipelineLayout(&.{ .flags = .{}, .set_layout_count = 1, - .p_set_layouts = &.{desc.h_desc_layout}, + .p_set_layouts = &.{cfg.desc.vkLayout()}, }, null); errdefer pr_dev.destroyPipelineLayout(layout, null); var new = Self{ .pr_dev = pr_dev, - .desc = desc, + .desc = cfg.desc, .h_pipeline_layout = layout, .h_pipeline = .null_handle, }; @@ -65,12 +60,12 @@ pub fn init(ctx: *const Context, allocator: Allocator, cfg: Config) !Self { } pub fn updateData(self: *Self, binding: u32, data: anytype) !void { - self.desc.update(binding, data); + self.desc.setValue(binding, data); } pub fn bind(self: *const Self, cmd_buf: *const CommandBuffer) void { self.pr_dev.cmdBindPipeline(cmd_buf.h_cmd_buffer, .compute, self.h_pipeline); - self.desc.bind(cmd_buf, self.h_pipeline_layout, .{ .bind_point = .compute }); + self.desc.use(cmd_buf, self.h_pipeline_layout, .{ .bind_point = .compute }); } pub fn dispatch( diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index 8de1a37..cfed23c 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -38,23 +38,6 @@ pub const Config = struct { pub const DescriptorType = common.DescriptorType; -pub const ResolvedBinding = struct { - stages: vk.ShaderStageFlags, - data: union(DescriptorType) { - Uniform: AnyBuffer, - Sampler: struct { - sampler: vk.Sampler, - view: vk.ImageView, - }, - StorageBuffer: AnyBuffer, - Image: struct { - img: *const Image, - // caller is responsible for this for now - view: vk.ImageView, - }, - }, -}; - // flattened since buffers are the same regardless // of whether they be uniform or storage const BindingWriteInfo = union(enum) { @@ -73,10 +56,15 @@ pr_dev: *const vk.DeviceProxy, layout: DescriptorLayout, pub fn init(ctx: *const Context, config: Config) !Self { + if (config.layout.layout == null) { + log.err("Invalid descriptor layout (likely forgot to call resolve())", .{}); + return error.InvalidLayout; + } + const dev: *const DeviceHandler = ctx.env(.dev); var desc_pools = ctx.env(.desc); - const desc_set = try desc_pools.reserve(config.usage, config.layout); + const desc_set = try desc_pools.reserve(config.usage, config.layout.layout.?); var descriptor = Self{ .layout = config.layout, @@ -112,11 +100,14 @@ pub fn use( ); } -pub fn deinit(self: *Self, ctx: *const Context) void { - var desc_pool = ctx.env(.desc); +pub fn deinit(self: *Self) void {//, ctx: *const Context) void { + //FIXME: Can't pass context until lifecyle routines are integrated + _ = self; + + //var desc_pool = ctx.env(.desc); // this may do nothing depending on usage - desc_pool.free(self.usage, self.h_desc_set); - self.layout.deinit(); + //desc_pool.free(self.usage, self.h_desc_set); + //self.layout.deinit(); } pub fn bindUniformsNamed(self: *Self, name: []const u8, ubo: AnyBuffer) void { @@ -124,12 +115,12 @@ pub fn bindUniformsNamed(self: *Self, name: []const u8, ubo: AnyBuffer) void { self.bindUniforms(loc, ubo); } -pub fn bindSamplerNamed(self: *Self, name: []const u8, sampler: vk.Sampler, view: vk.ImageView) void { +pub fn bindSamplerNamed(self: *Self, name: []const u8, sampler: vk.Sampler, view: Image.View) void { const loc = self.layout.named_bindings.get(name) orelse return; self.bindSampler(loc, sampler, view); } -pub fn bindImageNamed(self: *Self, name: []const u8, img: *const Image, view: vk.ImageView) void { +pub fn bindImageNamed(self: *Self, name: []const u8, img: *const Image, view: Image.View) void { const loc = self.layout.named_bindings.get(name) orelse return; self.bindImage(loc, img, view); } @@ -143,14 +134,15 @@ pub fn bindUniforms(self: *Self, index: usize, ubo: AnyBuffer) void { self.bindBase(index, .{.Uniform = ubo}); } -pub fn bindSampler(self: *Self, index: usize, sampler: vk.Sampler, view: vk.ImageView) void { +pub fn bindSampler(self: *Self, index: usize, sampler: vk.Sampler, view: Image.View) void { self.bindBase(index, .{.Sampler = .{ .sampler = sampler, .view = view, }}); } -pub fn bindImage(self: *Self, index: usize, img: *const Image, view: vk.ImageView) void { +//TODO: Get rid of *img if i don't need it +pub fn bindImage(self: *Self, index: usize, img: *const Image, view: Image.View) void { self.bindBase(index, .{.Image = .{ .img = img, .view = view, @@ -182,7 +174,7 @@ fn bindBase(self: *Self, index: usize, b: DescriptorBinding) void { .Sampler => |sampler| { binding = .{ .Image = vk.DescriptorImageInfo{ .image_layout = .read_only_optimal, - .image_view = sampler.view, + .image_view = sampler.view.h_view, .sampler = sampler.sampler, } }; @@ -192,7 +184,7 @@ fn bindBase(self: *Self, index: usize, b: DescriptorBinding) void { .Image => |img| { binding = .{ .Image = vk.DescriptorImageInfo{ .image_layout = .general, - .image_view = img.view, + .image_view = img.view.h_view, .sampler = .null_handle, } }; @@ -200,7 +192,7 @@ fn bindBase(self: *Self, index: usize, b: DescriptorBinding) void { write.descriptor_type = .storage_image; }, else => { - const buf: AnyBuffer, const dt: vk.DescriptorType = switch (binding.data) { + const buf: AnyBuffer, const dt: vk.DescriptorType = switch (b) { .Uniform => |buf| .{ buf, .uniform_buffer }, .StorageBuffer => |buf| .{ buf, .storage_buffer }, else => unreachable, @@ -234,6 +226,11 @@ pub fn update(self: *Self) void { ); } +pub fn vkLayout(self: *const Self) vk.DescriptorSetLayout { + // this has already been checked during initialization. + return self.layout.layout orelse unreachable; +} + /// Formerly "update" pub fn setValue(self: *Self, index: usize, data: anytype) !void { const binding = self.resolved_bindings[index]; @@ -249,14 +246,14 @@ pub fn setValue(self: *Self, index: usize, data: anytype) !void { const DescriptorBinding = union(DescriptorType) { Uniform: AnyBuffer, + Sampler: struct { + sampler: vk.Sampler, + view: Image.View, + }, StorageBuffer: AnyBuffer, Image: struct { img: *const Image, - view: vk.ImageView, - }, - Sampler: struct { - sampler: vk.Sampler, - view: vk.ImageView, + view: Image.View, }, }; @@ -287,26 +284,34 @@ pub const DescriptorLayout = struct { allocator: Allocator, specifiers: std.ArrayListUnmanaged(Specifier), - named_bindings: std.StringArrayHashMap(usize), + named_bindings: std.StringArrayHashMapUnmanaged(usize), writes: []vk.WriteDescriptorSet, - layout: ?vk.DescriptorLayout = null, + layout: ?vk.DescriptorSetLayout = null, size: usize, /// Screw you, just figure out how many descriptors you need before /// allocating shit all over the place. pub fn init(ctx: *const Context, allocator: Allocator, size: usize) !DescriptorLayout { - var bindings_map = std.StringArrayHashMap(usize).init(allocator); + var bindings_map = try std.StringArrayHashMapUnmanaged(usize).init(allocator, &.{}, &.{}); + errdefer bindings_map.deinit(allocator); + + const writes_buf = try allocator.alloc(vk.WriteDescriptorSet, size); + errdefer allocator.free(writes_buf); + + var specifiers = try std.ArrayListUnmanaged(Specifier).initCapacity(allocator, size); + errdefer specifiers.deinit(allocator); - try bindings_map.ensureTotalCapacity(size); + try bindings_map.ensureTotalCapacity(allocator, size); return DescriptorLayout{ - .di = ctx.env(.dev), + .di = ctx.env(.di), .allocator = allocator, - .specifiers = try std.ArrayListUnmanaged(Specifier).initCapacity(allocator, size), + .specifiers = specifiers, + .named_bindings = bindings_map, - .writes = try allocator.alloc(vk.WriteDescriptorSet, size), - .size = usize, + .writes = writes_buf, + .size = size, }; } @@ -329,9 +334,9 @@ pub const DescriptorLayout = struct { const layout_infos = try self.allocator.alloc(vk.DescriptorSetLayoutBinding, self.size); defer self.allocator.free(layout_infos); - for (self.specifiers, layout_infos) |spec, layout_info| { + for (self.specifiers.items, layout_infos) |spec, *layout_info| { layout_info.descriptor_count = 1; - layout_info.descriptor_type = layout_info.@"2".toVkDescriptor(); + layout_info.descriptor_type = spec.@"2".toVkDescriptor(); layout_info.binding = spec.@"0"; layout_info.stage_flags = spec.@"3"; diff --git a/src/api/descriptor_pool.zig b/src/api/descriptor_pool.zig index 79d8399..23b157e 100644 --- a/src/api/descriptor_pool.zig +++ b/src/api/descriptor_pool.zig @@ -31,14 +31,13 @@ const AnyPool = struct { pub const VTable = struct { rawReserve: *const fn ( *anyopaque, - usize, /// This mostly exists for the purpose of potentially having more sophisticated pool managment /// within a single usage pool []const UsageInfo, []const vk.DescriptorSetLayout, /// Descriptor sets are written into this user provided slice rather than allocation []vk.DescriptorSet, - ) PoolErrors![]vk.DescriptorSet, + ) PoolErrors!void, rawFree: *const fn ( *anyopaque, []const UsageInfo, @@ -55,11 +54,11 @@ const AnyPool = struct { pub fn rawReserve( self: AnyPool, - count: usize, usages: []const UsageInfo, layouts: []const vk.DescriptorSetLayout, - ) PoolErrors![]vk.DescriptorSet { - return self.vtable.rawReserve(self.ctx, count, usages, layouts); + sets: []vk.DescriptorSet, + ) PoolErrors!void { + try self.vtable.rawReserve(self.ctx, usages, layouts, sets); } pub fn rawFree( @@ -151,10 +150,10 @@ const PoolArena = struct { .p_set_layouts = layouts.ptr, }; - try self.di.allocateDescriptorSets(&alloc_info, sets.ptr) catch |e| { - switch (e) { - .OutOfHostMemory, .OutOfDeviceMemory, .OutOfPoolMemory => PoolErrors.OutOfMemory, - .FragmentedPool => blk: { + self.di.allocateDescriptorSets(&alloc_info, sets.ptr) catch |e| { + return switch (e) { + error.OutOfHostMemory, error.OutOfDeviceMemory, error.OutOfPoolMemory => PoolErrors.OutOfMemory, + error.FragmentedPool => blk: { // TODO: possibly trigger a defragging routine here log.debug( "pool is too fragmented to allocate.", @@ -163,7 +162,7 @@ const PoolArena = struct { break :blk PoolErrors.OutOfMemory; }, else => PoolErrors.Internal, - } + }; }; _ = usages; @@ -199,6 +198,10 @@ const PoolArena = struct { }, }; } + + pub fn deinit(self: *PoolArena) void { + self.di.destroyDescriptorPool(self.h_desc_pool, null); + } }; /// for now, I think it is permissible to @@ -241,7 +244,7 @@ pub fn initSelf(self: *Self, ctx: *const Context, sizes: PoolSizes) !void { self.static_pool = try PoolArena.init(di, sizes.static); errdefer self.static_pool.deinit(); - self.pools_by_usage = try PoolUsageMap.init(.{ + self.pools_by_usage = PoolUsageMap.init(.{ .Transient = self.transient_pool.interface(), .Scene = self.scene_pool.interface(), .Static = self.static_pool.interface(), @@ -257,18 +260,21 @@ pub fn reserve( usage: UsageInfo, layout: vk.DescriptorSetLayout, ) !vk.DescriptorSet { - const set = try self.reserveRange(1, &.{usage}, &.{layout}); + const pool = self.poolByUsage(usage); + var set = [1]vk.DescriptorSet{undefined}; + try pool.rawReserve(&.{usage}, &.{layout}, set[0..]); + return set[0]; } pub fn reserveRange( self: *Self, - count: usize, usage: UsageInfo, layouts: []const vk.DescriptorSetLayout, -) ![]vk.DescriptorSetLayout { + sets: []vk.DescriptorSet, +) !void { const pool = self.poolByUsage(usage); - return pool.rawReserve(count, &.{usage}, layouts); + try pool.rawReserve( &.{usage}, layouts, sets); } pub fn free( @@ -291,3 +297,9 @@ pub fn freeRange( } } +pub fn deinit(self: *Self) void { + self.scene_pool.deinit(); + self.static_pool.deinit(); + self.transient_pool.deinit(); +} + diff --git a/src/context.zig b/src/context.zig index 2cc68ca..623a6eb 100644 --- a/src/context.zig +++ b/src/context.zig @@ -27,7 +27,10 @@ const EnvBacking = struct { inst: Ref(Instance, .{}), dev: Ref(Device, .{}), surf: Ref(Surface, .{}), - desc: Ref(api.DescriptorPool, .{.field = "descriptor_pool"}), + desc: Ref(api.DescriptorPool, .{ + .field = "descriptor_pool", + .mutable = true, + }), gi: Ref(GlobalInterface, .{ .field = "global_interface" }), ii: Ref(InstanceInterface, .{ .field = "inst_interface" }), @@ -74,6 +77,7 @@ fn ResolveEnvType(comptime field: anytype) type { /// becomes more of a concern /// * .inst -> VkInstance (Retrieves application's VkInstance handle, generally not useful for application logic) /// * .dev -> VkDevice (Retrieves application's VkDevice handle, generally not useful for application logic) +/// * .desc -> Descriptor Pool (Application-wide descriptor pools (not much reason to access this on the user side) /// /// ### Interfaces /// * .gi -> global interface (does not require an instanced handle of any kind, generally setup such as extension querying @@ -190,12 +194,14 @@ pub fn init(allocator: Allocator, config: Config) !*Self { .scene = 1024, .static = 1024, .transient = 1024, - }); + }); return new; } pub fn deinit(self: *Self) void { + self.descriptor_pool.deinit(); + self.dev.deinit(); self.surf.deinit(); self.inst.deinit(); @@ -247,9 +253,9 @@ pub fn presentFrame( // } // } // try glfw.init(); -// +// // const extensions = glfw.instanceExtensions(); -// +// // var ctx = try Self.init(allocator.allocator(), .{ // .inst_extensions = extensions, // .loader = glfw.glfwGetInstanceProcAddress, diff --git a/src/env.zig b/src/env.zig index 0631832..232414e 100644 --- a/src/env.zig +++ b/src/env.zig @@ -5,13 +5,14 @@ const std = @import("std"); const RefConfig = struct { field: ?[]const u8 = null, + mutable: bool = false, }; /// returns a const non-owning pointer to the object /// (might enforce a bit more memory safety here later) pub fn Ref(comptime T: type, comptime config: RefConfig) type { return struct { pub const field = config.field; - pub const InnerType = *const T; + pub const InnerType = if (!config.mutable) *const T else *T; const Self = @This(); inner: InnerType, diff --git a/src/resource_management/pool_allocator.zig b/src/resource_management/pool_allocator.zig index 9f1effd..19ff1d2 100644 --- a/src/resource_management/pool_allocator.zig +++ b/src/resource_management/pool_allocator.zig @@ -32,7 +32,7 @@ const FreeSpaceList = struct { }; const BlockList = std.DoublyLinkedList(BlockHeader); - const ListNode = BlockList.Node; + pub const ListNode = BlockList.Node; elem_size: usize, free_nodes: BlockList, @@ -85,6 +85,7 @@ const FreeSpaceList = struct { pub fn init(buf: []u8, elem_size: usize) FreeSpaceList { const num_elements = @divExact(buf.len, elem_size); + const node = makeNode(buf, .{ .elem_count = num_elements }); var list = BlockList{}; @@ -177,6 +178,16 @@ pub fn initAlloc(allocator: Allocator, config: Config) !Self { return new; } +pub fn initAllocAligned(allocator: Allocator, comptime alignment: u29, config: Config) !Self { + const total_size = config.elem_count * config.elem_size; + const buf = try allocator.alignedAlloc(u8, alignment, total_size); + + var new = init(buf, config); + new.allocator = allocator; + + return new; +} + /// Reserve a single item /// Pointer is guarunteed to refer to a block /// of memory for the correct size. @@ -216,7 +227,7 @@ pub fn freeAll(self: *Self) void { /// * Directly passed buffer must respect alginment requirements /// of the state type pub fn init(buf: []u8, config: Config) Self { - const resolved_size: usize = @min(@sizeOf(FreeSpaceList.ListNode), config.elem_size); + const resolved_size: usize = @max(@sizeOf(FreeSpaceList.ListNode), config.elem_size); return .{ .config = config, @@ -234,9 +245,8 @@ pub fn deinit(self: *Self) void { // Testing goes here: // We're probably gonna need a lot of them lol. - const TestingStructA = struct { - items: [6]u32, + items: [10]u32, }; const TestingPool = TypedPool(TestingStructA); @@ -256,7 +266,7 @@ test "pool alloc" { test "pool free" { //TODO: Testing partial frees - + // free everything var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); _ = try pool.reserveRange(240); @@ -268,10 +278,28 @@ test "pool free" { } else return error.InvalidFreeList; } +const Small = struct { + a: u8 = 0, + b: u8 = 0, + c: u8 = 0, +}; + test "out of memory" { var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); defer pool.deinit(); _ = try pool.reserveRange(120); - try testing.expectError(PoolErrors.OutOfMemory, pool.reserveRange(905)); } + +test "pool with small object" { + var pool = try TypedPool(Small).initAlloc(std.heap.page_allocator, 1024); + defer pool.deinit(); + _ = try pool.reserveRange(1); + + pool.freeAll(); + if (pool.inner.free_space.free_nodes.first) |f| { + try testing.expect(f.data.elem_count == 1024); + try testing.expect(f.next == null); + } else return error.InvalidFreeList; +} + diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index d8f7aa1..8cff2de 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -167,10 +167,15 @@ pub const Query = struct { !self.matches(&self.entries[self.index])) : (self.index += 1) {} - return if (self.index < self.entries.len) - &self.entries[self.index] - else - null; + if (self.index < self.entries.len){ + const tmp = &self.entries[self.index]; + self.index += 1; + + return tmp; + } + else { + return null; + } } }; From 90146787839c5a6632eccc2595e8706108599de6 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 24 Aug 2025 12:01:37 -0700 Subject: [PATCH 21/46] feat(sample): updated samples to use new descriptor initialization --- build.zig | 4 +- samples/common/render_quad.zig | 4 +- samples/compute_drawing/main.zig | 80 +++++++++++++++++++------------- 3 files changed, 53 insertions(+), 35 deletions(-) diff --git a/build.zig b/build.zig index 5ef10dd..8fd02dd 100644 --- a/build.zig +++ b/build.zig @@ -191,13 +191,13 @@ fn buildSamples( /// all included tests (based on specified options) fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies, opts: BuildOpts) void { const test_comp = b.addTest(.{ - .name = "unit tests", + .name = "unit_tests", .root_module = lib_mod, .target = opts.target, }); const common_tests = b.addTest(.{ - .name = "common unit tests", + .name = "common_unit_tests", .root_module = deps.common, .target = opts.target, }); diff --git a/samples/common/render_quad.zig b/samples/common/render_quad.zig index 787753b..95693a0 100644 --- a/samples/common/render_quad.zig +++ b/samples/common/render_quad.zig @@ -81,7 +81,7 @@ pub fn initSelf(self: *Self, ctx: *const Context, allocator: Allocator, config: }, .viewport = .{ .Swapchain = config.swapchain }, .descriptors = if (config.frag_descriptors) |fd| &.{ - fd.h_desc_layout, + fd.vkLayout(), } else &.{}, }); defer fixed_functions_config.deinit(); @@ -119,7 +119,7 @@ pub fn drawOneShot(self: *const Self, cmd_buf: *const CommandBuffer, framebuffer self.renderpass.begin(cmd_buf, framebuffer, image_index); if (self.desc) |d| { - d.bind(cmd_buf, self.pipeline.h_pipeline_layout, .{}); + d.use(cmd_buf, self.pipeline.h_pipeline_layout, .{}); } self.dev.draw(cmd_buf, 6, 1, 0, 0); diff --git a/samples/compute_drawing/main.zig b/samples/compute_drawing/main.zig index 0c9cab1..38dfaed 100644 --- a/samples/compute_drawing/main.zig +++ b/samples/compute_drawing/main.zig @@ -25,7 +25,7 @@ const GraphicsPipeline = api.GraphicsPipeline; const RenderPass = api.RenderPass; const FixedFunctionState = api.FixedFunctionState; const Descriptor = api.Descriptor; -const DescriptorBinding = api.ResolvedDescriptorBinding; +const DescriptorLayout = api.DescriptorLayout; const CommandBuffer = api.CommandBuffer; const Semaphore = api.Semaphore; @@ -141,6 +141,10 @@ const SampleState = struct { .inst_extensions = helpers.glfwInstanceExtensions(), .loader = glfw.glfwGetInstanceProcAddress, .window = &self.window, + .management = .{ + .allocator = self.allocator, + .pool_sizes = 1024, + }, }); } @@ -177,19 +181,32 @@ const SampleState = struct { try self.gpu_state.uniforms.setData(&self.gpu_state.host_uniforms); // create fragment-specific descriptors - self.graphics.descriptor = try Descriptor.init(self.ctx, self.allocator, .{ - .bindings = &.{ .{ - .data = .{ .Uniform = self.gpu_state.uniforms.buffer() }, - .stages = .{ .fragment_bit = true }, - }, DescriptorBinding{ - .data = .{ .Sampler = .{ - .sampler = self.gpu_state.render_sampler, - .view = self.gpu_state.render_view.h_view, - } }, - .stages = .{ .fragment_bit = true }, - } }, + var frag_desc_layout = try DescriptorLayout.init(self.ctx, self.allocator, 2); + frag_desc_layout.addDescriptors(&.{ + .{ 0, "FragUniforms", .Uniform, .{ .fragment_bit = true } }, + .{ 1, "MainTex", .Sampler, .{ .fragment_bit = true } }, + }); + try frag_desc_layout.resolve(); + + self.graphics.descriptor = try Descriptor.init(self.ctx, .{ + .layout = frag_desc_layout, + .usage = .{ + .lifetime_bits = .Static, + }, }); + self.graphics.descriptor.bindUniformsNamed( + "FragUniforms", + self.gpu_state.uniforms.buffer(), + ); + self.graphics.descriptor.bindSamplerNamed( + "MainTex", + self.gpu_state.render_sampler, + self.gpu_state.render_view + ); + + self.graphics.descriptor.update(); + try self.graphics.render_quad.initSelf(self.ctx, self.allocator, .{ .frag_shader = &frag_shader, .frag_descriptors = &self.graphics.descriptor, @@ -243,26 +260,27 @@ const SampleState = struct { self.gpu_state.compute_uniforms = try UniformBuffer(ComputeUniforms).create(self.ctx); self.gpu_state.particles = try StorageBuffer(Particle).create(self.ctx, PARTICLE_COUNT); - const descriptors: []const DescriptorBinding = &.{ - .{ - .data = .{ .Uniform = self.gpu_state.compute_uniforms.buffer() }, - .stages = .{ .compute_bit = true }, - }, - .{ - .data = .{ .StorageBuffer = self.gpu_state.particles.buffer() }, - .stages = .{ .compute_bit = true }, - }, - .{ - .data = .{ .Image = .{ - .img = &self.gpu_state.render_target, - .view = self.gpu_state.render_view.h_view, - } }, - .stages = .{ .compute_bit = true }, - }, - }; - self.compute.pipeline = try Compute.init(self.ctx, self.allocator, .{ + var compute_desc_layout = try DescriptorLayout.init(self.ctx, self.allocator, 3); + compute_desc_layout.addDescriptors(&.{ + .{ 0, "Uniforms", .Uniform, .{ .compute_bit = true } }, + .{ 1, "Particles", .StorageBuffer, .{ .compute_bit = true } }, + .{ 2, "RenderTarget", .Image, .{ .compute_bit = true } }, + }); + try compute_desc_layout.resolve(); + + var compute_descriptor = try Descriptor.init(self.ctx, .{ + .layout = compute_desc_layout, + .usage = .{.lifetime_bits = .Static}, + }); + + compute_descriptor.bindUniformsNamed("Uniforms", self.gpu_state.compute_uniforms.buffer()); + compute_descriptor.bindBufferNamed("Particles", self.gpu_state.particles.buffer()); + compute_descriptor.bindImageNamed("RenderTarget", &self.gpu_state.render_target, self.gpu_state.render_view); + compute_descriptor.update(); + + self.compute.pipeline = try Compute.init(self.ctx, .{ .shader = &shader, - .desc_bindings = descriptors, + .desc = compute_descriptor, }); } From 3f13daa264f5f270e7c0f2c0941689a003689cbe Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 24 Aug 2025 18:13:10 -0700 Subject: [PATCH 22/46] fix(descriptor): explicitly initialize p_immutable_samplers since a sampler descriptor will attempt to read that field on layout init --- samples/compute_drawing/main.zig | 8 +--- src/api/descriptor.zig | 80 ++++++++++++++++++-------------- 2 files changed, 47 insertions(+), 41 deletions(-) diff --git a/samples/compute_drawing/main.zig b/samples/compute_drawing/main.zig index 38dfaed..c75022e 100644 --- a/samples/compute_drawing/main.zig +++ b/samples/compute_drawing/main.zig @@ -199,11 +199,7 @@ const SampleState = struct { "FragUniforms", self.gpu_state.uniforms.buffer(), ); - self.graphics.descriptor.bindSamplerNamed( - "MainTex", - self.gpu_state.render_sampler, - self.gpu_state.render_view - ); + self.graphics.descriptor.bindSamplerNamed("MainTex", self.gpu_state.render_sampler, self.gpu_state.render_view); self.graphics.descriptor.update(); @@ -270,7 +266,7 @@ const SampleState = struct { var compute_descriptor = try Descriptor.init(self.ctx, .{ .layout = compute_desc_layout, - .usage = .{.lifetime_bits = .Static}, + .usage = .{ .lifetime_bits = .Static }, }); compute_descriptor.bindUniformsNamed("Uniforms", self.gpu_state.compute_uniforms.buffer()); diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index cfed23c..5e170c6 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -100,14 +100,13 @@ pub fn use( ); } -pub fn deinit(self: *Self) void {//, ctx: *const Context) void { - //FIXME: Can't pass context until lifecyle routines are integrated - _ = self; +//FIXME: Can't pass context until lifecyle routines are integrated +pub fn deinit(self: *Self) void { //, ctx: *const Context) void { //var desc_pool = ctx.env(.desc); // this may do nothing depending on usage //desc_pool.free(self.usage, self.h_desc_set); - //self.layout.deinit(); + self.layout.deinit(); } pub fn bindUniformsNamed(self: *Self, name: []const u8, ubo: AnyBuffer) void { @@ -131,29 +130,30 @@ pub fn bindBufferNamed(self: *Self, name: []const u8, buf: AnyBuffer) void { } pub fn bindUniforms(self: *Self, index: usize, ubo: AnyBuffer) void { - self.bindBase(index, .{.Uniform = ubo}); + self.bindBase(index, .{ .Uniform = ubo }); } pub fn bindSampler(self: *Self, index: usize, sampler: vk.Sampler, view: Image.View) void { - self.bindBase(index, .{.Sampler = .{ + self.bindBase(index, .{ .Sampler = .{ .sampler = sampler, .view = view, - }}); + } }); } //TODO: Get rid of *img if i don't need it pub fn bindImage(self: *Self, index: usize, img: *const Image, view: Image.View) void { - self.bindBase(index, .{.Image = .{ + self.bindBase(index, .{ .Image = .{ .img = img, .view = view, - }}); + } }); } pub fn bindBuffer(self: *Self, index: usize, buf: AnyBuffer) void { - self.bindBase(index, .{.StorageBuffer = buf}); + self.bindBase(index, .{ .StorageBuffer = buf }); } fn bindBase(self: *Self, index: usize, b: DescriptorBinding) void { + debug.assert(index < self.layout.size); const write = &self.layout.writes[index]; write.* = vk.WriteDescriptorSet{ .descriptor_type = undefined, @@ -168,27 +168,27 @@ fn bindBase(self: *Self, index: usize, b: DescriptorBinding) void { .p_texel_buffer_view = undefined, }; - var binding: BindingWriteInfo = undefined; + const binding = &self.layout.write_infos[index]; switch (b) { .Sampler => |sampler| { - binding = .{ .Image = vk.DescriptorImageInfo{ + binding.* = .{ .Image = vk.DescriptorImageInfo{ .image_layout = .read_only_optimal, .image_view = sampler.view.h_view, .sampler = sampler.sampler, } }; + write.p_image_info = @as([*]vk.DescriptorImageInfo, @ptrCast(&binding.Image)); write.descriptor_type = .combined_image_sampler; - write.p_image_info = &.{binding.Image}; }, .Image => |img| { - binding = .{ .Image = vk.DescriptorImageInfo{ + binding.* = .{ .Image = vk.DescriptorImageInfo{ .image_layout = .general, .image_view = img.view.h_view, .sampler = .null_handle, } }; - write.p_image_info = &.{binding.Image}; + write.p_image_info = @as([*]vk.DescriptorImageInfo, @ptrCast(&binding.Image)); write.descriptor_type = .storage_image; }, else => { @@ -198,20 +198,18 @@ fn bindBase(self: *Self, index: usize, b: DescriptorBinding) void { else => unreachable, }; - binding = .{ .Buffer = vk.DescriptorBufferInfo{ + binding.* = .{ .Buffer = vk.DescriptorBufferInfo{ .buffer = buf.handle, .offset = 0, .range = buf.size, } }; + write.p_buffer_info = @as([*]vk.DescriptorBufferInfo, @ptrCast(&binding.Buffer)); write.descriptor_type = dt; - - write.p_buffer_info = &.{binding.Buffer}; }, } } - /// Write descriptor values to the descriptor set. /// -- This should happen anytime the descriptor's makeup changes /// (i.e a new texture or buffer is needed) @@ -261,12 +259,11 @@ const debug = std.debug; // Descriptor layouts done better pub const DescriptorLayout = struct { - const Specifier = struct { - u32, - []const u8, - DescriptorType, - vk.ShaderStageFlags, - + const Specifier = struct { + u32, + []const u8, + DescriptorType, + vk.ShaderStageFlags, }; fn id(spec: Specifier) SpecifierID { @@ -285,8 +282,9 @@ pub const DescriptorLayout = struct { specifiers: std.ArrayListUnmanaged(Specifier), named_bindings: std.StringArrayHashMapUnmanaged(usize), - + writes: []vk.WriteDescriptorSet, + write_infos: []BindingWriteInfo, layout: ?vk.DescriptorSetLayout = null, size: usize, @@ -299,6 +297,9 @@ pub const DescriptorLayout = struct { const writes_buf = try allocator.alloc(vk.WriteDescriptorSet, size); errdefer allocator.free(writes_buf); + const write_infos_buf = try allocator.alloc(BindingWriteInfo, size); + errdefer allocator.free(write_infos_buf); + var specifiers = try std.ArrayListUnmanaged(Specifier).initCapacity(allocator, size); errdefer specifiers.deinit(allocator); @@ -311,6 +312,7 @@ pub const DescriptorLayout = struct { .named_bindings = bindings_map, .writes = writes_buf, + .write_infos = write_infos_buf, .size = size, }; } @@ -322,7 +324,12 @@ pub const DescriptorLayout = struct { } pub fn addDescriptors(self: *DescriptorLayout, specs: []const Specifier) void { - debug.assert(self.specifiers.items.len + specs.len < self.size); + std.debug.print("added spec count: {d}\n size: {d}\n expected range: {d}\n", .{ + specs.len, + self.size, + self.specifiers.items.len + specs.len, + }); + debug.assert(self.specifiers.items.len + specs.len <= self.size); for (specs) |spec| { self.specifiers.insertAssumeCapacity(@intCast(spec.@"0"), spec); @@ -331,27 +338,30 @@ pub const DescriptorLayout = struct { } pub fn resolve(self: *DescriptorLayout) !void { - const layout_infos = try self.allocator.alloc(vk.DescriptorSetLayoutBinding, self.size); + const layout_infos = try self.allocator.alloc(vk.DescriptorSetLayoutBinding, self.size); defer self.allocator.free(layout_infos); for (self.specifiers.items, layout_infos) |spec, *layout_info| { + std.debug.print("Adding: {s}\n", .{@tagName(spec.@"2".toVkDescriptor())}); layout_info.descriptor_count = 1; - layout_info.descriptor_type = spec.@"2".toVkDescriptor(); - + layout_info.binding = spec.@"0"; + layout_info.descriptor_type = spec.@"2".toVkDescriptor(); layout_info.stage_flags = spec.@"3"; + layout_info.p_immutable_samplers = null; } self.layout = try self.di.createDescriptorSetLayout(&.{ .binding_count = @intCast(layout_infos.len), .p_bindings = layout_infos.ptr, - }, null); + }, null); } - pub fn deinit(self: *const DescriptorLayout) void { + pub fn deinit(self: *DescriptorLayout) void { self.allocator.free(self.writes); + self.allocator.free(self.write_infos); self.specifiers.deinit(self.allocator); - + if (self.layout) |l| { self.di.destroyDescriptorSetLayout(l, null); } @@ -380,11 +390,11 @@ pub const DescriptorLayout = struct { // // //NOTE: You give ownership to the descriptor when you // var desc = try Self.init(ctx, allocator, layout); -// +// // // After consideration, I have elected to prefix this family of functions // // with "bind", as they are what associates a concrete resource // // with the descriptor "slot" persay. In the case of image-type descriptors, -// // these functions are literally all that you need to associate a concrete +// // these functions are literally all that you need to associate a concrete // // image with a descriptor slot, making them almost analogous with "glBindTexture" and such. // desc.bindUniformsNamed("Uniforms", some_ubo); // desc.bindSamplerNamed("MainTex", some_texture); From 21b260ee708d2fa114fae477ae1770dc6f729efa Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 1 Sep 2025 20:48:06 -0700 Subject: [PATCH 23/46] feat(api): begun work on GPU memory virtualization system and accompanying allocator --- samples/basic_planes.zig | 4 +- src/api/allocator.zig | 313 ++++++++++++++++++- src/api/base.zig | 7 + src/api/descriptor.zig | 6 - src/resource_management/resource_manager.zig | 1 - 5 files changed, 321 insertions(+), 10 deletions(-) diff --git a/samples/basic_planes.zig b/samples/basic_planes.zig index d66c596..2c3ae9d 100644 --- a/samples/basic_planes.zig +++ b/samples/basic_planes.zig @@ -406,7 +406,7 @@ pub fn main() !void { defer window.destroy(); glfw.vulkanSupported() catch |err| { - std.debug.print("Could not load Vulkan\n", .{}); + std.log.err("Could not load Vulkan", .{}); return err; }; @@ -425,5 +425,5 @@ pub fn main() !void { try mainLoop(); } - std.debug.print("You win!\n", .{}); + std.log.info("You win!\n", .{}); } diff --git a/src/api/allocator.zig b/src/api/allocator.zig index 252b871..d003b43 100644 --- a/src/api/allocator.zig +++ b/src/api/allocator.zig @@ -1,8 +1,319 @@ //! Vulkan-specific allocator for giving user control over host and device-side allocations. -//! Of course, the standard zig allocation interface is great but it's usage doesn't +//! Of course, the standard zig allocation interface is great but it's usage doesn't //! fit well into device-side memory allocations, so we have this. //! //! I will do my best to keep the implementation of this allocator be as in-line as possible //! to the standard memory allocation interface (if I can I will support creating //! std.mem.Allocators). +const std = @import("std"); +const vk = @import("vulkan"); +const common = @import("common"); +const api = @import("api.zig"); + +const Context = @import("../context.zig"); + +/// Represents an individual memory allocation.. +/// Depending on the allocated memory's properties, +/// Accessing the memory might require creating a staging buffer +/// or flushing and invalidating cached host-mapped memory +/// +/// Probably should handleify this, to make allocations more resistant +/// to changes in location and such +pub const Allocation = struct { + src_heap: vk.DeviceMemory, + offset: u32, + size: u32, +}; + +const AllocationScope = enum(u2) { + /// General Purpose, Picks a free-list styled, static heap + /// (in fact, It'll likely just choose the scene heap outright) + /// This is the "idontwanttothinkaboutit" option + General, + /// Short lived, Maximum of a single frame. This creates the allocation + /// in a high-performance linear allocator (probably an arena with some bells and whistles) + /// and invalidates it (clears the buffer) every frame. Use for fire-and-forget operations + Transient, + /// Medium Lived, Persists across frames but may be freed/reused if new resources need to be loaded + /// during runtime. May use a free list or a ring-buffer with an LRU mechanism to clear potentially unused + /// resources. + Scene, + /// Never freed. Exists across all scenes, Note that freeing may be a no-op in some cases + /// So be careful to only reserve what is necessary for static memory + Static, +}; + +const AllocationPropertyFlags = packed struct { + /// Whether or not memory should be directly mappable on the host + /// Otherwise, transfers and staging buffers are necessary + host_mappable: bool = false, + + /// Whether or not memory should be addressable in a sequential manner, + /// (i.e copied forwards, or maybe backwards). + seq_access: bool = false, + + /// Whether or not memory should be addressable in a random manner, + /// (indexing, partial copies, etc). This also implies sequantial access is allowed + /// so no need to set both .seq_access and this. + /// Random access will likely prefer cached memory whereas sequential access will prefer coherent. + rand_access: bool = false, + + /// How long will this allocation live? + /// This will control which heap and which allocation algorithm + /// will be used for this allocation + lifetime_hint: AllocationScope = .General, +}; +const StructureHints = packed struct { + /// Size in bytes of the structure + /// use for untyped but otherwise fixed-sized resources. Especially if you have multiple of the same + /// so that the same pool can be used and potentially CPU/GPU time saved with initialization + /// + /// This should be an either/or with type_id, as specifying values for both prefers type_id + size: ?usize = null, + + /// Specific type ID of the structure. Use if you have fixed-sized resource of a known type + /// This in particlar will prefer a slab allocator over a generic pool. + /// For best type safe results, Most functions that allocate will accept a comptime type + /// to interpret the resulting memory in the case of direct host interaction. + type_id: ?common.TypeId = null, +}; + +pub const AllocationConfig = packed struct { + pub const GeneralFlags = packed struct { + ///General stuff + /// Whether or not the best fit should be selected in case a perfect + /// allocator match isn't found + best_fit: bool = true, + + /// Force the allocator to perform a dedicated + /// VkAllocateMemory specifically for this allocation (renders most configuration moot) + force_dedicated: bool = false, + }; + + pub const Resolved = packed struct { + mem_props: vk.MemoryPropertyFlags, + mem_reqs: vk.MemoryRequirements, + general_flags: GeneralFlags, + }; + /// Directly force an allocation to be for memory with + /// the specified properties + /// This will be prioritized over any other settings + /// So use carefully. + mem_props_override: ?vk.MemoryPropertyFlags = null, + + /// Requested memory properties, includes various hints for needed + /// memory operations along with lifetimes. + /// This is used in picking a heap and memory type in the heap (rather then just mapping + /// directly to type indices) + req_mem_props: AllocationPropertyFlags, + + /// The physical requirements for a given resource, such as size, + /// alignments, and compatible memory types, you can manually specify these, + /// or use the more convenient "resource_owner" field to infer them from the given resource + resource_requirements: ?vk.MemoryRequirements = null, + + /// Directly pass in the resource owning the allocation to infer base memory requirements.. + /// Must be a valid handle + resource_owner: ?union(enum) { + Buffer: vk.Buffer, + Image: vk.Image, + } = null, + + /// Structure hints + /// This controls whether or not to use a structured memory pool + /// based on given parameters + structure_hints: StructureHints = .{}, + + general: GeneralFlags = .{}, + + /// Flattens all nullable values and optional configuration parameters + /// into a common resolved layout + /// This shouldn't fail with an error, but just assert at you if you do invalid config + pub fn flatten(self: *const AllocationConfig) Resolved {} +}; + +/// Just a thin wrapper over a VkDeviceMemory with some extra crap +/// Think of this as an individual device memory, the only real difference is that +/// it supports suballocations on a less granular page size. +const GPUBlock = struct { + parent_heap: *const Heap, + mem: vk.DeviceMemory, + + /// offset into physical GPU memory pool, + /// Probably can save some bits since pages will be relatively large + break_limit: u16, + page_count: u16, + + /// Performs exactly one GPU allocation of the specified # of pages + /// (determined by the parent heap) + /// + /// This function should not be allowed to error, since budgets and memory + /// limits should be figured out ahead of time. Essentially, a new block + /// should only ever be created if there is actually space for one. + pub fn init(heap: *Heap, page_count: u16) GPUBlock { + } +}; + +/// Individual memory heap, +/// This maps cleanly onto vulkan's idea of a heap. and is essentially a wrapper +/// with some bookkeeping info along with supported memory types. +/// Think of this as an otherwise unstructured blob of page-sized virtual chunks +/// Each heap gets exactly 1 Vulkan device heap bound to it, which it will then suballocate until it's exhausted +const Heap = struct { + const VulkanAllocationPool = std.heap.MemoryPoolExtra(GPUBlock, .{ + .growable = false, + }); + + pages: VulkanAllocationPool, + page_size: usize, + + + /// How big/how many pages should there be for this heap??? + /// We mostly care about usage as it relates to size (or available budget) + /// to the application. + /// Note that this is more of an estimate then anything else, + /// Vulkan allocations won't exactly match pages often, however the minimum allocation + /// size will be for individual pages. + fn deterimineVirtualMemProps(budget: *const api.DeviceMemoryBudget) struct {usize, usize} { + //TODO: I might consider using 2 separate heurstics depending on whether the Budget query extension is avialable + } + + pub fn init(heap_budget: *const api.DeviceMemoryBudget, allocator: std.mem.Allocator) Error!Heap { + const page_size, const max_pages = deterimineVirtualMemProps(heap_budget); + + return Heap{ + // I distinguish host (app-side CPU) and GPU allocation failures, + // cuz otherwise shit gets confusing + .pages = VulkanAllocationPool.initPreheated(allocator, max_pages) catch { + return error.HostOutOfMemory; + }, + .page_size = page_size, + .break_limit = 0, + }; + } + + /// Allocate new memory blocks. This either increases the break limit of an existing GPU block + /// or allocates a new one + pub fn grow(self: *Heap, reqs: vk.MemoryRequirements) void { + } +}; + +pub const Error = error{ + HostOutOfMemory, + DeviceOutOfMemory, + NoMatchingHeap, + // InvalidConfiguration, This'll be handled with asserts in debug +}; + +/// Map of available memory heaps (pools) +/// This is just an array with extra steps +const HeapMap = struct { + heaps: []Heap, + /// prefills heaps with pools of handles + pub fn init(layout: *const api.DeviceMemoryLayout, allocator: std.mem.Allocator) Error!HeapMap { + const num_heaps = layout.memory_heaps.len; + + const heaps = allocator.alloc(Heap, num_heaps) catch + return error.HostOutOfMemory; + + for (heaps, layout.memory_heaps) |*heap, props| { + heap.* = try heap.init(props.index, props.supported_props); + } + } + + pub fn get(self: *HeapMap, index: usize) Error!*Heap { + if (index >= self.heaps.len) return error.NoMatchingHeap; + return self.heaps[index]; + } +}; + +/// Manages top-level handles to instantiated +/// heap allocations for all included memory types +/// This is one of the few allocators that directly allows for memory configuration +/// rather than just having a predefined configuration specified at initialization time. +/// Also, I don't really think this'll fit into a standard interface +/// +/// ## For Users: +/// * DO NOT use this for general purpose allocations. Think of this as the OS syscall heap allocator, +/// except worse. +/// * Every single allocation will likely consume a huge chunk of memory and likely result in +/// a separate GPU allocation, which vulkan no likey. +/// * Rather, it is better to use this as a parent allocator for a more efficient child allocator. +/// This ensures the giant memory blob is better utilized then being wasted on a single 24 byte +/// uniform buffer. +pub const VirtualAllocator = struct { + allocator: std.mem.Allocator, + + dev_mem_layout: *const api.DeviceMemoryLayout, + di: *const api.DeviceInterface, + heaps: HeapMap, + + /// Doesn't actually do much rn but could anticipatorially do some ahead-of-time heap allocation + pub fn init(ctx: *const Context, allocator: std.mem.Allocator) Error!VirtualAllocator { + const layout = ctx.env(.dev_mem_layout); + return VirtualAllocator{ + .allocator = allocator, + .di = ctx.env(.di), + .dev_mem_layout = layout, + .heaps = HeapMap.init(layout), + }; + } + + pub fn allocate(self: *VirtualAllocator, config: AllocationConfig) Error!Allocation { + const resolved_config = config.flatten(); + const reqs = resolved_config.mem_reqs; + const props = resolved_config.mem_props; + + const type_index: u32 = self.dev_mem_layout.findCompatibleHeapIndex(reqs, props) orelse return Error.NoMatchingHeap; + + var chosen_heap = try self.heaps.get(type_index); + + const new_mem = try chosen_heap.grow(reqs); + } +}; + +// Vulkan Memory Types and Heaps: +// * There are memory heaps, which generally map to GPU/CPU physical memory +// * Each heap has a fixed budget of total bytes, which may differ from the total memory available in said heap +// * Memory types, are bound to a heap, and offer a view into said memory +// with specific properties, backed by the implementation most likely. +// * These properties will be backed by the implementation, supporting things +// like GPU-Host coherency, or requireing cache flush/invalidtion operations. +// Rather then just having user specify the memory types they'd like for an allocation, +// Users will give hints that better inform their actual usage, such as whether to use linear allocation, +// or to ensure the memory is host-mappable. + +// pub fn fucc() !void { +// const ctx: *const Context = Context.MagicallyInit(yadda yadda); +// +// // ....Other initialization shit... +// +// // Way 1: Just specifying memory directly +// // Assume Yadda Yadda means correct memory/init configuration +// // ctx.mem is a per-context "configurable" allocator as stated +// const buf_memory = try ctx.mem.allocate(yadda yadda); +// const my_buffer = VertexBuffer.init(ctx, buf_memory, .{yadda yadda}); +// +// // This allows users to do, for example +// // pick a specific existing allocator or create their own +// +// // Uses the same "AllocationConfig" to find a compatible allocator +// // ALSO: var my_way_better_allocator = GPUStackAllocator.init(some_other_memory_block).allocator(); +// var my_way_better_allocator = ctx.mem.findAllocator(AllocationConfig{}) orelse @panic("Reinvented the wheel too hard"); +// const mem2 = try my_way_better_allocator.allocate(.{yadda yadda}); +// const my_buffer2 = VertexBuffer.init(ctx, mem2, .{yadda yadda}); +// +// // Way 2: Asking the buffer and finding a graceful compromise +// var required: AllocationConfig = VertexBuffer.getRequiredPropertiesFor(.{some_use_case}); +// // Can fail if the buffer has a hard requirement for something +// // (OPTIONAL) +// try required.unify(AllocationConfig{my_extra_properties}); +// +// const mem3 = try ctx.mem.allocate(required); +// const my_buffer3 = VertexBuffer.init(ctx, mem3, .{yadda yadda}); +// +// +// // Way 3: Automated: +// const my_buffer4 = try VertexBuffer.initAlloc(ctx, .{yadda yadda}); +// } diff --git a/src/api/base.zig b/src/api/base.zig index 64b024f..5b621b9 100644 --- a/src/api/base.zig +++ b/src/api/base.zig @@ -354,8 +354,15 @@ pub const DeviceHandler = struct { var found = false; var chosen_mem: u32 = 0; + for (0..dev_mem_props.memory_heap_count) |i| { + const heap = dev_mem_props.memory_heaps[i]; + log.debug("{d}. memory heap: {s} (size: {d})", .{i, heap.flags, heap.size}); + } + for (0..dev_mem_props.memory_type_count) |i| { const mem_flags = dev_mem_props.memory_types[i].property_flags; + const heap_index = dev_mem_props.memory_types[i].heap_index; + log.debug("Memory Type {d} (heap {d}): {s}", .{i, heap_index, mem_flags}); if (mem_reqs.memory_type_bits & (@as(u32, 1) << @intCast(i)) != 0 and mem_flags.contains(requested_flags)) { found = true; diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index 5e170c6..aa49b8d 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -324,11 +324,6 @@ pub const DescriptorLayout = struct { } pub fn addDescriptors(self: *DescriptorLayout, specs: []const Specifier) void { - std.debug.print("added spec count: {d}\n size: {d}\n expected range: {d}\n", .{ - specs.len, - self.size, - self.specifiers.items.len + specs.len, - }); debug.assert(self.specifiers.items.len + specs.len <= self.size); for (specs) |spec| { @@ -342,7 +337,6 @@ pub const DescriptorLayout = struct { defer self.allocator.free(layout_infos); for (self.specifiers.items, layout_infos) |spec, *layout_info| { - std.debug.print("Adding: {s}\n", .{@tagName(spec.@"2".toVkDescriptor())}); layout_info.descriptor_count = 1; layout_info.binding = spec.@"0"; diff --git a/src/resource_management/resource_manager.zig b/src/resource_management/resource_manager.zig index ee0b064..8123b39 100644 --- a/src/resource_management/resource_manager.zig +++ b/src/resource_management/resource_manager.zig @@ -34,7 +34,6 @@ pub fn init(config: Config, registry: *Registry) !Self { var table = MemoryPoolsTable.init(config.allocator); while (entries.next()) |entry| { - std.debug.print("Creating pool for type {s}\n", .{entry.type_name}); const pool_config = PoolAllocator.Config{ .elem_size = entry.size_bytes, .elem_count = config.pool_sizes, From d87871f7c0d2965ef35989d3ce706fc782314455 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Tue, 2 Sep 2025 21:24:43 -0700 Subject: [PATCH 24/46] refactor(pool): refactored pools to work using handle indexing --- src/api/api.zig | 6 +- src/api/memory/DeviceMemoryLayout.zig | 45 +++ src/api/{ => memory}/allocator.zig | 125 ++------- src/api/memory/heap.zig | 139 ++++++++++ src/common/common.zig | 5 + src/common/pool_allocator.zig | 245 +++++++++++++++++ src/resource_management/pool_allocator.zig | 305 --------------------- 7 files changed, 465 insertions(+), 405 deletions(-) create mode 100644 src/api/memory/DeviceMemoryLayout.zig rename src/api/{ => memory}/allocator.zig (73%) create mode 100644 src/api/memory/heap.zig create mode 100644 src/common/pool_allocator.zig delete mode 100644 src/resource_management/pool_allocator.zig diff --git a/src/api/api.zig b/src/api/api.zig index 3034520..3663cb1 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -11,9 +11,9 @@ const vert_buf = @import("vertex_buffer.zig"); const common = @import("common_types.zig"); // direct vulkan-zig imports -pub const GlobalInterface = vk.BaseWrapper; -pub const InstanceInterface = vk.InstanceProxy; -pub const DeviceInterface = vk.DeviceProxy; +pub const GlobalInterface = *const vk.BaseWrapper; +pub const InstanceInterface = *const vk.InstanceProxy; +pub const DeviceInterface = *const vk.DeviceProxy; pub const DynamicState = vk.DynamicState; /// All registered extensions for devices and instances diff --git a/src/api/memory/DeviceMemoryLayout.zig b/src/api/memory/DeviceMemoryLayout.zig new file mode 100644 index 0000000..9b28889 --- /dev/null +++ b/src/api/memory/DeviceMemoryLayout.zig @@ -0,0 +1,45 @@ +const std = @import("std"); +const vk = @import("vulkan"); +const api = @import("../api.zig"); +const heap = @import("heap.zig"); + +const Context = @import("../../context.zig"); + +const Layout = @This(); +const HeapMap = heap.HeapMap; +const Heap = HeapMap.Handle; + +const DeviceLayoutError = error{ + OutOfMemory, +}; + +raw_mem_props: vk.PhysicalDeviceMemoryProperties, +heaps: HeapMap, + +pub fn init( + ctx: *const Context, + allocator: std.mem.Allocator, +) DeviceLayoutError!Layout { + const dev: *const api.DeviceHandler = ctx.env(.dev); + const ii: api.InstanceInterface = ctx.env(.ii); + + const mem_props = ii.getPhysicalDeviceMemoryProperties(dev.h_pdev); + + const valid_heaps = mem_props.memory_heaps[0..mem_props.memory_heap_count]; + const valid_types = mem_props.memory_types[0..mem_props.memory_type_count]; + + return Layout{ + .raw_mem_props = mem_props, + .heaps = try HeapMap.init(valid_heaps, valid_types, allocator), + }; +} + +pub fn heapSupportsType( + self: *const Layout, + heap: Heap, + type_index: usize, +) bool { + return null; +} + +pub fn typeSupportsProperty(self: *const Layout, type_index: usize, properties: vk.MemoryPropertyFlags) bool {} diff --git a/src/api/allocator.zig b/src/api/memory/allocator.zig similarity index 73% rename from src/api/allocator.zig rename to src/api/memory/allocator.zig index d003b43..ede65aa 100644 --- a/src/api/allocator.zig +++ b/src/api/memory/allocator.zig @@ -6,6 +6,11 @@ //! to the standard memory allocation interface (if I can I will support creating //! std.mem.Allocators). +/// GAYAYUIQHOIUDSAHIUHDLIHGLUSDhlhfLIHUDS +/// Guhh, now we're doing memeory management for the memory management fuuuuuuuuck. +/// Guhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh +/// + const std = @import("std"); const vk = @import("vulkan"); const common = @import("common"); @@ -20,12 +25,23 @@ const Context = @import("../context.zig"); /// /// Probably should handleify this, to make allocations more resistant /// to changes in location and such -pub const Allocation = struct { +const AllocationData = struct { src_heap: vk.DeviceMemory, offset: u32, size: u32, }; +pub const Error = error{ + HostOutOfMemory, + DeviceOutOfMemory, + NoMatchingHeap, + // InvalidConfiguration, This'll be handled with asserts in debug +}; + + +pub const Allocation = common.Handle(AllocationData); +pub const Heap = common.Handle(HeapData); + const AllocationScope = enum(u2) { /// General Purpose, Picks a free-list styled, static heap /// (in fact, It'll likely just choose the scene heap outright) @@ -64,6 +80,7 @@ const AllocationPropertyFlags = packed struct { /// will be used for this allocation lifetime_hint: AllocationScope = .General, }; + const StructureHints = packed struct { /// Size in bytes of the structure /// use for untyped but otherwise fixed-sized resources. Especially if you have multiple of the same @@ -79,6 +96,12 @@ const StructureHints = packed struct { type_id: ?common.TypeId = null, }; +const DedicatedAllocationPolicyBits = enum(u2) { + Force, + Disallow, + Unspecified, +}; + pub const AllocationConfig = packed struct { pub const GeneralFlags = packed struct { ///General stuff @@ -88,7 +111,7 @@ pub const AllocationConfig = packed struct { /// Force the allocator to perform a dedicated /// VkAllocateMemory specifically for this allocation (renders most configuration moot) - force_dedicated: bool = false, + dedicated_alloc_policy: DedicatedAllocationPolicyBits = .Unspecified, }; pub const Resolved = packed struct { @@ -133,100 +156,6 @@ pub const AllocationConfig = packed struct { pub fn flatten(self: *const AllocationConfig) Resolved {} }; -/// Just a thin wrapper over a VkDeviceMemory with some extra crap -/// Think of this as an individual device memory, the only real difference is that -/// it supports suballocations on a less granular page size. -const GPUBlock = struct { - parent_heap: *const Heap, - mem: vk.DeviceMemory, - - /// offset into physical GPU memory pool, - /// Probably can save some bits since pages will be relatively large - break_limit: u16, - page_count: u16, - - /// Performs exactly one GPU allocation of the specified # of pages - /// (determined by the parent heap) - /// - /// This function should not be allowed to error, since budgets and memory - /// limits should be figured out ahead of time. Essentially, a new block - /// should only ever be created if there is actually space for one. - pub fn init(heap: *Heap, page_count: u16) GPUBlock { - } -}; - -/// Individual memory heap, -/// This maps cleanly onto vulkan's idea of a heap. and is essentially a wrapper -/// with some bookkeeping info along with supported memory types. -/// Think of this as an otherwise unstructured blob of page-sized virtual chunks -/// Each heap gets exactly 1 Vulkan device heap bound to it, which it will then suballocate until it's exhausted -const Heap = struct { - const VulkanAllocationPool = std.heap.MemoryPoolExtra(GPUBlock, .{ - .growable = false, - }); - - pages: VulkanAllocationPool, - page_size: usize, - - - /// How big/how many pages should there be for this heap??? - /// We mostly care about usage as it relates to size (or available budget) - /// to the application. - /// Note that this is more of an estimate then anything else, - /// Vulkan allocations won't exactly match pages often, however the minimum allocation - /// size will be for individual pages. - fn deterimineVirtualMemProps(budget: *const api.DeviceMemoryBudget) struct {usize, usize} { - //TODO: I might consider using 2 separate heurstics depending on whether the Budget query extension is avialable - } - - pub fn init(heap_budget: *const api.DeviceMemoryBudget, allocator: std.mem.Allocator) Error!Heap { - const page_size, const max_pages = deterimineVirtualMemProps(heap_budget); - - return Heap{ - // I distinguish host (app-side CPU) and GPU allocation failures, - // cuz otherwise shit gets confusing - .pages = VulkanAllocationPool.initPreheated(allocator, max_pages) catch { - return error.HostOutOfMemory; - }, - .page_size = page_size, - .break_limit = 0, - }; - } - - /// Allocate new memory blocks. This either increases the break limit of an existing GPU block - /// or allocates a new one - pub fn grow(self: *Heap, reqs: vk.MemoryRequirements) void { - } -}; - -pub const Error = error{ - HostOutOfMemory, - DeviceOutOfMemory, - NoMatchingHeap, - // InvalidConfiguration, This'll be handled with asserts in debug -}; - -/// Map of available memory heaps (pools) -/// This is just an array with extra steps -const HeapMap = struct { - heaps: []Heap, - /// prefills heaps with pools of handles - pub fn init(layout: *const api.DeviceMemoryLayout, allocator: std.mem.Allocator) Error!HeapMap { - const num_heaps = layout.memory_heaps.len; - - const heaps = allocator.alloc(Heap, num_heaps) catch - return error.HostOutOfMemory; - - for (heaps, layout.memory_heaps) |*heap, props| { - heap.* = try heap.init(props.index, props.supported_props); - } - } - - pub fn get(self: *HeapMap, index: usize) Error!*Heap { - if (index >= self.heaps.len) return error.NoMatchingHeap; - return self.heaps[index]; - } -}; /// Manages top-level handles to instantiated /// heap allocations for all included memory types @@ -260,6 +189,8 @@ pub const VirtualAllocator = struct { }; } + /// NOTE: This allocator doesn't support best fit re-indexing, + /// that happens at a higher level. pub fn allocate(self: *VirtualAllocator, config: AllocationConfig) Error!Allocation { const resolved_config = config.flatten(); const reqs = resolved_config.mem_reqs; @@ -269,7 +200,7 @@ pub const VirtualAllocator = struct { var chosen_heap = try self.heaps.get(type_index); - const new_mem = try chosen_heap.grow(reqs); + return chosen_heap.grow(reqs); } }; diff --git a/src/api/memory/heap.zig b/src/api/memory/heap.zig new file mode 100644 index 0000000..7514661 --- /dev/null +++ b/src/api/memory/heap.zig @@ -0,0 +1,139 @@ +const common = @import("common"); +const vk = @import("vulkan"); +const std = @import("std"); + +/// Just a thin wrapper over a VkDeviceMemory with some extra crap +/// Think of this as an individual device memory, the only real difference is that +/// it supports suballocations on a less granular page size. +/// This is more of a low-level arena, which can grow but expects +/// free chunks to be managed by a higher level system. +/// Deinitiialize it to destroy the associated DeviceMemory +pub const GPUBlock = struct { + const PageRange = struct { + h_block: common.Handle(GPUBlock), + offset: u32, + count: u32, + }; + + parent_heap: Heap, + mem: vk.DeviceMemory, + + /// offset into physical GPU memory pool, + /// Probably can save some bits since pages will be relatively large + break_limit: u16, + page_count: u16, + + /// Performs exactly one GPU allocation of the specified # of pages + /// (determined by the parent heap) + /// + /// This function should not be allowed to error, since budgets and memory + /// limits should be figured out ahead of time. Essentially, a new block + /// should only ever be created if there is actually space for one. + pub fn init(heap: Heap, page_count: u16) GPUBlock { + } + + /// Increase size of GPU block, essentially allocating more of the given heap + /// to the application process + pub fn grow(self: *GPUBlock, amount: usize) Error!Allocation { + + } + + /// Allocate a new page range if space currently exists in the given GPU block. + /// This will only be called by heaps if they don't have a free range of compatible + /// pages + pub fn allocatePageRange(self: *GPUBlock, count: usize) PageRange { + } + + pub fn deinit(self: *GPUBlock) void { + } +}; + +/// Individual memory heap, +/// This maps cleanly onto vulkan's idea of a heap. and is essentially a wrapper +/// with some bookkeeping info along with supported memory types. +/// Think of this as an otherwise unstructured blob of page-sized virtual chunks +/// Each heap gets exactly 1 Vulkan device heap bound to it, which it will then suballocate until it's exhausted +const HeapData = struct { + const VulkanBlockPool = common.MemoryPool(GPUBlock, .{ + .IndexType = u16, + }); + + const GPUBlockHandle = VulkanBlockPool.Handle; + + pages: VulkanBlockPool, + page_size: usize, + block_size: usize, + + + /// How big/how many pages should there be for this heap??? + /// We mostly care about usage as it relates to size (or available budget) + /// to the application. + /// Note that this is more of an estimate then anything else, + /// Vulkan allocations won't exactly match pages often, however the minimum allocation + /// size will be for individual pages. + fn deterimineVirtualMemProps(budget: *const api.DeviceMemoryBudget) struct {usize, usize, usize} { + //TODO: I might consider using 2 separate heurstics depending on whether the Budget query extension is avialable + } + + pub fn init(heap_budget: *const api.DeviceMemoryBudget, allocator: std.mem.Allocator) Error!HeapData { + const page_size, + const max_pages, + const block_size = deterimineVirtualMemProps(heap_budget); + + return HeapData{ + // I distinguish host (app-side CPU) and GPU allocation failures, + // cuz otherwise shit gets confusing + .pages = VulkanBlockPool.initPreheated( + allocator, + heap_budget.size / block_size, + ) catch { + return error.HostOutOfMemory; + }, + .page_size = page_size, + .block_size = block_size, + }; + } + + /// Allocate new memory blocks. This either increases the break limit of an existing GPU block + /// or allocates a new one + pub fn grow(self: *HeapData, reqs: vk.MemoryRequirements) Error!GPUBlock.PageRange { + } + + pub fn shrink(self: *HeapData, alloc: Allocation) void { + } +}; + +/// Map of available memory heaps (pools) +/// This is just an array with extra steps +pub const HeapMap = struct { + const HeapPool = common.MemoryPool(HeapData, .{ + .IndexType = u8, + }); + + pub const Handle = HeapPool.Handle; + heaps: HeapPool, + /// prefills heaps with pools of handles + pub fn init(heaps: []const vk.MemoryHeap, types: []const vk.MemoryType, allocator: std.mem.Allocator) Error!HeapMap { + const num_heaps = layout.memory_heaps.len; + + const heaps = HeapPool.init(num_heaps, allocator) catch + return error.HostOutOfMemory; + + for (heaps.items, layout.memory_heaps) |*heap, props| { + heap.* = try HeapData.init(props.index, props.supported_props); + } + + return HeapMap{ + .heaps = heaps, + }; + } + + pub fn getHeapForMemoryType(self: *HeapMap, type_index: usize) Error!Heap { + + } + + pub fn getHeapByIndex(self: *HeapMap, mem_index: usize) Error!Heap { + if (mem_index >= self.heaps.items.len) return error.NoMatchingHeap; + return self.heaps.handle(mem_index); + } +}; diff --git a/src/common/common.zig b/src/common/common.zig index b0a2c31..0079260 100644 --- a/src/common/common.zig +++ b/src/common/common.zig @@ -5,6 +5,11 @@ const h = @import("handle.zig"); pub const Handle = h.Handle; pub const OpaqueHandle = h.OpaqueHandle; +// these resemble std's pools, but they have intrinsic support for handle +// indexing +pub const OpaqueMemoryPool = @import("pool_allocator.zig"); +pub const MemoryPool = OpaqueMemoryPool.TypedPool; + pub const config = @import("config.zig"); pub const util = @import("util.zig"); diff --git a/src/common/pool_allocator.zig b/src/common/pool_allocator.zig new file mode 100644 index 0000000..b6ce177 --- /dev/null +++ b/src/common/pool_allocator.zig @@ -0,0 +1,245 @@ +//! Takes in a fixed, preallocated +//! buffer of memory and manages it as a pool of +//! a given type of objects to be allocated and freed independently. +//! +//! Free space will be tracked as a RB tree (or maybe a buddy allocator dunno) +//! and alignment requirements and backing allocators (to create the buffer) can be specified at +//! initialization time... +//! +//! Pools contain a fixed capacity that CANNOT be modified unless the pool is later resized, +//! which will probably have a buch of bad side effects that make it not really that good of an idea +//! (i.e invalidates everything so all pointers to handles are not guaranteed). +//! +//! TODO: A great feature would be adding scoped allocations for individual pools +//! which match vulkan object's lifetimes (generally they are the same per-type of object) + +const std = @import("std"); +const common = @import("common"); +const assert = std.debug.assert; + +const Allocator = std.mem.Allocator; +const AnyPtr = common.AnyPtr; + +const Self = @This(); + +const PoolError = error{ + OutOfMemory, + InvalidHandle, +}; + +const TypedPoolConfig = struct { + index_bits: usize = 32, + generation_bits: usize = 32, + growable: bool = false, +}; + +// I didn't plan this out at all lol +// Plan: +// Step 1: 2 regions per page: handle and object storage +// Step 2: Memory broken into pages (done) +// Step 3: Pages can be created if more space is needed and growing is allowed (done) +// Step 4: Profit (never happening) + +/// Type Safe generic pool +pub fn TypedPool(comptime T: type, comptime config: TypedPoolConfig) type { + return struct { + const default_page_size = 2048; + + const PoolSlotType = if (@sizeOf(T) > @sizeOf(FreeNode)) + T + else + FreeNode; + + const Pool = @This(); + const elem_size = @sizeOf(PoolSlotType); + const alignment = @alignOf(PoolSlotType); + + const handles_padding: usize = @sizeOf(PageHeader) % @alignOf(Handle); + const slots_padding: usize = @sizeOf(Handle) % @alignOf(PoolSlotType); + + const PageHeader = PageTableList.Node; + + // give 0 shits about anything but the next freee node + const FreeSpaceList = std.SinglyLinkedList(struct {}); + + const FreeNode = FreeSpaceList.Node; + + /// pages additionally give some shits about alignment + const PageTableList = std.SinglyLinkedList(struct { + const Header = @This(); + cap: usize, + count: usize, + + pub fn handles(self: *Header) []Handle { + const base_address: usize = std.mem.Alignment.forward( + std.mem.Alignment.fromByteUnits(@alignOf(PageHeader)), + @intFromPtr(self) + @sizeOf(PageHeader), + ); + + const ptr = @as([*]Handle, @ptrFromInt(base_address)); + return ptr[0..self.count]; + } + + pub fn slots(self: *Header) []FreeNode { + // Implemented the lazy way, who gives a shit + const base_handle_addr = std.mem.Alignment.forward( + std.mem.Alignment.fromByteUnits(alignment), + @intFromPtr(self.handles().ptr), + ); + + const ptr = @as([*]FreeNode, @ptrFromInt(base_handle_addr)); + + return ptr[0..self.count]; + } + }); + pub const Handle = common.Handle(T, .{ + .generation_bits = config.generation_bits, + .index_bits = config.index_bits, + }); + + free_list: FreeSpaceList, + page_list: PageTableList, + allocator: Allocator, + + pub fn initPreheated(allocator: Allocator, count: usize) PoolError!Pool { + var new_pool = try Pool.init(allocator); + errdefer new_pool.deinit(); + + try new_pool.forceGrowPage(@max(count, @min(count * 2, std.math.maxInt(u16)))); + try new_pool.preheat(count); + return new_pool; + } + + pub fn newFreeNode(self: *Pool) PoolError!*FreeNode { + var page_node = self.page_list.first orelse + try self.growPage(default_page_size); + + if (page_node.data.cap == 0) { + page_node = try self.growPage(default_page_size); + } + + const new_node = page_node.data.slots()[page_node.data.cap - 1]; + page_node.data.cap -= 1; + + return new_node; + } + + /// Returns OutOfMemory if Not enough page space is allocated + pub fn preheat(self: *Pool, count: usize) PoolError!void { + for (0..count) |_| { + self.free_list.prepend(try self.newFreeNode()); + } + } + + /// This distinction exists for the purposes of an initial pool allocation + fn forceGrowPage(self: *Pool, object_count: usize) PoolError!*PageHeader { + // This probably needs to include alignment padding bytes for the underlying type + const size_bytes = object_count * elem_size + + @sizeOf(PageHeader) + handles_padding + slots_padding; + + const new_block = try self.allocator.alignedAlloc( + u8, + @alignOf(PageHeader), + size_bytes, + ); + + const new_header = @as(*PageHeader, @ptrCast(new_block.ptr)); + + // This is for obtaining the starting address from a aligned address. + + new_header.data = object_count; + self.page_list.prepend(new_header); + + return new_header; + } + + pub fn growPage(self: *Pool, object_count: usize) PoolError!*PageHeader { + if (!config.growable) return error.OutOfMemory; + + return self.forceGrowPage(object_count); + } + + pub fn init(allocator: Allocator) PoolError!Pool { + return Pool{ + .free_list = .{}, + .page_list = .{}, + .allocator = allocator, + }; + } + + pub fn reserve(self: *Pool) PoolError!Handle { + } + + pub fn free(self: *Pool, val: Handle) void { + } + + pub fn reset(self: *Pool) void {} + + pub fn deinit(self: *Pool) void { + while (self.page_list.popFirst()) |page| { + self.allocator.free(page); + } + } + }; +} + +// Testing goes here: +// We're probably gonna need a lot of them lol. + +const TestingStructA = struct { + items: [10]u32, +}; +const TestingPool = TypedPool(TestingStructA); + +const testing = std.testing; + +// Pool allocation tests +test "pool alloc" { + var pool = try TestingPool.initPreheated(std.heap.page_allocator, 1024); + defer pool.deinit(); + + for (0..512) |_| { + _ = try pool.reserve(); + } + + _ = try pool.reserveRange(512); +} + +test "pool free" { + //TODO: Testing partial frees + + // free everything + var pool = try TestingPool.initPreheated(std.heap.page_allocator, 1024); + _ = try pool.reserveRange(240); + + pool.freeAll(); + if (pool.inner.free_space.free_nodes.first) |f| { + try testing.expect(f.data.elem_count == 1024); + try testing.expect(f.next == null); + } else return error.InvalidFreeList; +} + +const Small = struct { + a: u8 = 0, + b: u8 = 0, + c: u8 = 0, +}; + +test "out of memory" { + var pool = try TestingPool.initPreheated(std.heap.page_allocator, 1024); + defer pool.deinit(); + + _ = try pool.reserveRange(120); +} + +test "pool with small object" { + var pool = try TypedPool(Small).initPreheated(std.heap.page_allocator, 1024); + defer pool.deinit(); + _ = try pool.reserveRange(1); + + pool.freeAll(); + if (pool.inner.free_space.free_nodes.first) |f| { + try testing.expect(f.data.elem_count == 1024); + try testing.expect(f.next == null); + } else return error.InvalidFreeList; +} diff --git a/src/resource_management/pool_allocator.zig b/src/resource_management/pool_allocator.zig deleted file mode 100644 index 19ff1d2..0000000 --- a/src/resource_management/pool_allocator.zig +++ /dev/null @@ -1,305 +0,0 @@ -//! Takes in a fixed, preallocated -//! buffer of memory and manages it as a pool of -//! a given type of objects to be allocated and freed independently. -//! -//! Free space will be tracked as a RB tree (or maybe a buddy allocator dunno) -//! and alignment requirements and backing allocators (to create the buffer) can be specified at -//! initialization time... -//! -//! Pools contain a fixed capacity that CANNOT be modified unless the pool is later resized, -//! which will probably have a buch of bad side effects that make it not really that good of an idea -//! (i.e invalidates everything so all pointers to handles are not guaranteed). -//! -//! TODO: A great feature would be adding scoped allocations for individual pools -//! which match vulkan object's lifetimes (generally they are the same per-type of object) - -const std = @import("std"); -const common = @import("common"); -const assert = std.debug.assert; - -const Allocator = std.mem.Allocator; -const AnyPtr = common.AnyPtr; - -const Self = @This(); - -/// Free space LInked list -/// Mostly just a std.LinkedList of allocation headers -/// but does some extra stuff to have the nodes stored in-place -/// with the actual memory pool. -const FreeSpaceList = struct { - const BlockHeader = struct { - elem_count: usize, - }; - - const BlockList = std.DoublyLinkedList(BlockHeader); - pub const ListNode = BlockList.Node; - - elem_size: usize, - free_nodes: BlockList, - buf: []u8, - - fn makeNode(buf: []u8, header: BlockHeader) *ListNode { - assert(buf.len > @sizeOf(ListNode)); - const node = @as(*ListNode, @ptrCast(@alignCast(buf.ptr))); - - node.data = header; - return node; - } - - // possibly use a free-list styled allocator to do this - fn coalesce(self: *FreeSpaceList, root: *ListNode) void { - _ = self; - _ = root; - } - - // This function does not work at all lol - pub fn pop(self: *FreeSpaceList, count: usize) ?*anyopaque { - var node: ?*ListNode = self.free_nodes.popFirst() orelse return null; - - while (node != null and node.?.data.elem_count < count) : (node = node.?.next) {} - - const n = node orelse return null; - - if (n.data.elem_count > count) { - const bytes_size = count * self.elem_size; - const new_node: *ListNode = @ptrFromInt(@intFromPtr(n) + bytes_size); - - new_node.* = .{ .data = .{ - .elem_count = n.data.elem_count - count, - } }; - - self.free_nodes.prepend(new_node); - } - - return n; - } - - pub fn free(self: *FreeSpaceList, ptr: *anyopaque) void { - //TODO: This needs some work - //Can't use a linked list to effectively handle multiple item frees, even with a count - //Mostly because of the coalesce routine (it would need to be an RB tree of sorts) - - _ = self; - _ = ptr; - } - - pub fn init(buf: []u8, elem_size: usize) FreeSpaceList { - const num_elements = @divExact(buf.len, elem_size); - - const node = makeNode(buf, .{ .elem_count = num_elements }); - - var list = BlockList{}; - list.prepend(node); - - return FreeSpaceList{ - .elem_size = elem_size, - .free_nodes = list, - .buf = buf, - }; - } -}; - -/// Type Safe generic pool wrapper -pub fn TypedPool(comptime T: type) type { - return struct { - const Pool = @This(); - const elem_size = @sizeOf(T); - const type_id = common.typeId(T); - inner: Self, - - pub fn initAlloc(allocator: Allocator, count: usize) !Pool { - const pool_config = Config{ - .elem_size = elem_size, - .elem_count = count, - }; - - return Pool{ - .inner = try Self.initAlloc(allocator, pool_config), - }; - } - - pub fn init(buf: []T, count: usize) Pool { - const bytes_len = buf.len * elem_size; - const buffer = @as([*]u8, @ptrCast(@alignCast(buf.ptr)))[0..bytes_len]; - - const pool_config = Config{ - .elem_size = elem_size, - .elem_count = count, - }; - - return Pool.init(buffer, pool_config); - } - - pub fn reserve(self: *Pool) PoolErrors!*T { - return @as(*T, @ptrCast(@alignCast(try self.inner.reserve()))); - } - - pub fn reserveRange(self: *Pool, count: usize) PoolErrors![]T { - return @as([*]T, @ptrCast( - @alignCast(try self.inner.reserveRange(count)), - ))[0..count]; - } - - pub fn freeAll(self: *Pool) void { - self.inner.freeAll(); - } - - pub fn deinit(self: *Pool) void { - self.inner.deinit(); - } - }; -} - -// Limited to u32 boundaries, just used usize since int casting is annoying -pub const Config = struct { - elem_size: usize, - elem_count: usize, -}; - -pub const PoolErrors = error{ - OutOfMemory, -}; - -config: Config, - -// raw backing buffer, very rarely directly access this... -buf: []u8, -free_space: FreeSpaceList, - -allocator: ?Allocator = null, - -pub fn initAlloc(allocator: Allocator, config: Config) !Self { - const total_size = config.elem_count * config.elem_size; - const buf = try allocator.alloc(u8, total_size); - - var new = init(buf, config); - new.allocator = allocator; - - return new; -} - -pub fn initAllocAligned(allocator: Allocator, comptime alignment: u29, config: Config) !Self { - const total_size = config.elem_count * config.elem_size; - const buf = try allocator.alignedAlloc(u8, alignment, total_size); - - var new = init(buf, config); - new.allocator = allocator; - - return new; -} - -/// Reserve a single item -/// Pointer is guarunteed to refer to a block -/// of memory for the correct size. -pub fn reserve(self: *Self) PoolErrors!*anyopaque { - return self.free_space.pop(1) orelse PoolErrors.OutOfMemory; -} - -/// Reserve multiple items contiguously -pub fn reserveRange(self: *Self, count: usize) PoolErrors!*anyopaque { - return self.free_space.pop(count) orelse return PoolErrors.OutOfMemory; -} - -/// free a previous allocation -/// I'll do this later once pool items are more likely to be reused -pub fn free(self: *Self, item: *anyopaque) void { - _ = self; - _ = item; -} - -/// "items" MUST refer to a slice of type-matching handles... -/// It's not a slice because you cant directly have slices -/// whose underling type is unknown (opaque). -pub fn freeRange(self: *Self, items: *anyopaque, count: usize) void { - _ = self; - _ = items; - _ = count; -} - -pub fn freeAll(self: *Self) void { - // Just overwrite the existing free space list with a new one, which will cover the entire pool - // no leakage issues since the list is stored in-place - // of course, existing allocations are all invalidated and can be overwritten whenever now - self.free_space = FreeSpaceList.init(self.buf, self.config.elem_size); -} - -/// ## Notes: -/// * Directly passed buffer must respect alginment requirements -/// of the state type -pub fn init(buf: []u8, config: Config) Self { - const resolved_size: usize = @max(@sizeOf(FreeSpaceList.ListNode), config.elem_size); - return .{ - .config = config, - - .buf = buf, - .free_space = FreeSpaceList.init(buf, resolved_size), - }; -} - -pub fn deinit(self: *Self) void { - if (self.allocator) |allocator| { - allocator.free(self.buf); - } -} - -// Testing goes here: -// We're probably gonna need a lot of them lol. - -const TestingStructA = struct { - items: [10]u32, -}; -const TestingPool = TypedPool(TestingStructA); - -const testing = std.testing; - -// Pool allocation tests -test "pool alloc" { - var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); - defer pool.deinit(); - - for (0..512) |_| { - _ = try pool.reserve(); - } - - _ = try pool.reserveRange(512); -} - -test "pool free" { - //TODO: Testing partial frees - - // free everything - var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); - _ = try pool.reserveRange(240); - - pool.freeAll(); - if (pool.inner.free_space.free_nodes.first) |f| { - try testing.expect(f.data.elem_count == 1024); - try testing.expect(f.next == null); - } else return error.InvalidFreeList; -} - -const Small = struct { - a: u8 = 0, - b: u8 = 0, - c: u8 = 0, -}; - -test "out of memory" { - var pool = try TestingPool.initAlloc(std.heap.page_allocator, 1024); - defer pool.deinit(); - - _ = try pool.reserveRange(120); -} - -test "pool with small object" { - var pool = try TypedPool(Small).initAlloc(std.heap.page_allocator, 1024); - defer pool.deinit(); - _ = try pool.reserveRange(1); - - pool.freeAll(); - if (pool.inner.free_space.free_nodes.first) |f| { - try testing.expect(f.data.elem_count == 1024); - try testing.expect(f.next == null); - } else return error.InvalidFreeList; -} - From b34a325f16df83fddeefbfbc5c50b23a7a4ae73f Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 5 Sep 2025 11:56:42 -0700 Subject: [PATCH 25/46] feat(pool): finished implementing a handle-based object pool --- src/common/common.zig | 2 +- src/common/handle.zig | 51 ++--- src/common/object_pool.zig | 365 ++++++++++++++++++++++++++++++++++ src/common/pool_allocator.zig | 245 ----------------------- 4 files changed, 382 insertions(+), 281 deletions(-) create mode 100644 src/common/object_pool.zig delete mode 100644 src/common/pool_allocator.zig diff --git a/src/common/common.zig b/src/common/common.zig index 0079260..5bcd633 100644 --- a/src/common/common.zig +++ b/src/common/common.zig @@ -2,7 +2,7 @@ const std = @import("std"); const assert = std.debug.assert; const h = @import("handle.zig"); -pub const Handle = h.Handle; +pub const Handle = h.TypedHandle; pub const OpaqueHandle = h.OpaqueHandle; // these resemble std's pools, but they have intrinsic support for handle diff --git a/src/common/handle.zig b/src/common/handle.zig index 47283d2..70a142e 100644 --- a/src/common/handle.zig +++ b/src/common/handle.zig @@ -26,46 +26,27 @@ pub const OpaqueHandle = struct { const assert = std.debug.assert; -/// Typed handle, with support for derefrence -pub fn Handle(comptime T: type) type { - return struct { - const Self = @This(); - base: OpaqueHandle, +pub const Config = struct { + index_bits: u16 = 32, + generation_bits: u16 = 32, +}; - // TODO: Implement this so that you can't just pass any opaque handle -- - // It needs to be guarunteed that the handle bound is of a compatible type - // -- TO do that, I'll need to implement at least some of the type-scoped allocators - // first - pub fn bindOpaque(self: *Self, new: OpaqueHandle) void { - assert(self.base.value.id == new.value.id); - self.base = new; - } - // these are ease-of-use pseudo-dereference operators - pub fn get(self: *const Self) *const T { - assert(self.base.type_data == .Single); - return self.base.value.get(T); - } +/// Typed handle, with support for derefrence +pub fn TypedHandle(comptime T: type, comptime config: Config) type { + const IndexType: type = std.meta.Int(.unsigned, config.index_bits); + const GenerationType: type = std.meta.Int(.unsigned, config.generation_bits); - pub fn getMut(self: *Self) *T { - assert(self.base.type_data == .Single); - return self.base.value.get(T); - } + return packed struct { + const UnderlyingType = T; + const Handle = @This(); - pub fn getMulti(self: *const Self) []const T { - assert(self.base.type_data == .Multi); - return @as( - [*]const T, - @ptrCast(self.base.value.get(T)), - )[0..self.base.type_data.Multi]; - } + index: IndexType = 0, + gen: GenerationType = 0, - pub fn getMultiMut(self: *Self) []T { - assert(self.base.type_data == .Multi); - return @as( - [*]T, - @ptrCast(self.base.value.get(T)), - )[0..self.base.type_data.Multi]; + pub fn bind(handle: *Handle, index: IndexType) void { + handle.index = index; + handle.gen += 1; } }; } diff --git a/src/common/object_pool.zig b/src/common/object_pool.zig new file mode 100644 index 0000000..4d27a0d --- /dev/null +++ b/src/common/object_pool.zig @@ -0,0 +1,365 @@ +//! Its a pool that works like a pool with handle indexing. Good for DOD +//! centralized data storage in da memory. This is the cornerstone +//! of the memory management sytem for this application. +//! +//! TODO: A great feature would be adding scoped allocations for individual pools +//! which match vulkan object's lifetimes (generally they are the same per-type of object) + +const std = @import("std"); +const common = @import("common"); +const builtin = @import("builtin"); +const assert = std.debug.assert; + +const Allocator = std.mem.Allocator; +const AnyPtr = common.AnyPtr; +const Alignment = std.mem.Alignment; + +const Self = @This(); + +const PoolError = error{ + OutOfMemory, + InvalidHandle, + OutOfBounds, +}; + +const TypedPoolConfig = struct { + /// Leave null for default type alignment + alignment: ?std.mem.Alignment = null, + /// Leave null for 32-bit indexing and equal generation counter. + IndexType: type = u32, + /// Can pool expand once existing resources are exhausted? + /// NOTE: THis is a little janky in implenmentation for the moment + growable: bool = false, +}; + +// I didn't plan this out at all lol +// Plan: +// Step 1: Handles and slots are stored in separate blocks, indexed as slices in the header +// (this is to decrease alignment padding bytes) +// Step 1.1: +// Step 2: Memory broken into pages (done) +// Step 3: Pages can be created if more space is needed and growing is allowed (done) + + +/// Finds the address offset between 2 separately alignments, +/// i.e the padding bytes required. +fn alignForwardDiff(comptime T: type, comptime b: Alignment) comptime_int { + return b.toByteUnits() - (@sizeOf(T) % b.toByteUnits()); +} + +///TODO: Handle bit widths smaller then a single page +fn PartitionIndexType(comptime IndexType: type, page_size: usize) type { + const low_bits = 12; + const high_bits = @typeInfo(IndexType).int.bits - low_bits; + + return packed struct { + page_index: std.meta.Int(.unsigned, high_bits), + addr: std.meta.Int(.unsigned, low_bits), + }; + + +} + +/// Type Safe generic pool +/// Note that signedness is unsupported in config since there is no point +/// in supporting negative indexing +pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { + if (@typeInfo(config.IndexType) != .int) + @compileError("IndexType must be an integer"); + if (@typeInfo(config.IndexType).int.bits < 12) + @compileError("IndexType must have a bit-width of at least 12"); + if (@typeInfo(config.IndexType).int.signedness != .unsigned) + @compileError("IndexType must be unsigned"); + + const resolved_alignment = if (config.alignment) |al| + al + else + Alignment.fromByteUnits(@alignOf(T)); + + return struct { + pub const IndexType = config.IndexType; + /// needs to accomodate free list nodes at least... + const SlotType = if (@sizeOf(T) > @sizeOf(FreeNode)) T else FreeNode; + const Pool = @This(); + + + const FreeNode = struct { + next: ?*FreeNode, + page: *Page, + }; + + pub const Handle = packed struct { + pub const PartitionedIndex = PartitionIndexType(IndexType, page_size); + index: PartitionedIndex, + gen: IndexType, + + // These 2 functions are meant to update state in the stored handle state + // of the pool, not the handles the user gets + pub fn bind(h: *Handle, idx: IndexType, page_index: IndexType) void { + h.index.addr = @intCast(index); + h.index.page_index = @intCast(page_index); + } + + pub fn unbind(h: *Handle) void { + h.index.addr = 0; + h.index.page_index = 0; + h.gen += 1; + } + } + + /// Pages are broken into 2 separately alligned sections of memory + /// - Handles (contiains handle information mainly gen count) + /// - Slots (contains actual data for the object stuff) + /// + /// Both are forwards aligned to their natural aligned addresses + /// for minimal padding due to a disjoint in the alignment of handles + /// and the container type + const Page = struct { + cap: usize = page_size, + index: usize, + handles: [*]Handle, // to prevent gross pointer arithmetic + slots: [*]SlotType, + }; + + const PageArray = std.ArrayListUnmanaged(*Page); + + pub const page_size = 4096; + const handle_align_padding = alignForwardDiff( + Page, + Alignment.fromByteUnits(@alignOf(Handle)), + ); + const slot_align_padding = alignForwardDiff(Handle, resolved_alignment); + + free_list: ?*FreeNode = null, + allocator: Allocator, + + page_table: PageArray, + + // tracks the currently growing page in the allocator (for reuse purposes) + current_page: usize = 0, + + fn prependFreeNode(pool: *Pool, node: *FreeNode) void { + node.next = pool.free_list; + pool.free_list = node; + } + + fn popFreeNode(pool: *Pool) ?*FreeNode { + const free_node = pool.free_list; + + if (pool.free_list) |fl| { + pool.free_list = pool.free_list.next; + } + + return free_node; + } + + fn growPageIfAllowed(pool: *Pool) PoolError!*Page { + if (!config.growable) return error.OutOfMemory; + return self.justGrowTheFuckingPage(page_size); + } + + fn indexForNode(node: *FreeNode) usize { + const relative_addr = @intFromPtr(node) - @intFromPtr(node.page.slots.ptr); + return @divExact(relative_addr, @sizeOf(SlotType)); + } + + /// Ensures there's enough capacity without altering + /// the free list + fn ensureCapacity(pool: *Pool, cap: usize) PoolError!void { + var current_cap = 0; + for (pool.page_table) |page| { + current_cap += page.cap; + } + + if (current_cap >= cap) return; + + const needed_cap = cap - current_cap; + const needed_pages = @divFloor(needed_cap, page_size) + 1; + + for (0..needed_pages) |_| { + pool.justGrowTheFuckingPage(page_size); + } + } + + fn justGrowTheFuckingPage(pool: *Pool, size: usize) PoolError!*Page { + // If we have an extra unused page, just return that instead. + // This covers the cases of pool reuse via the .reset() method + if (pool.page_table.items.len - 1 > pool.current_page) { + return &pool.page_table.items[pool.current_page + 1]; + } + const allocation_size = size * @sizeOf(SlotType) + + handle_align_padding + slot_align_padding); + + const new_page = try pool.allocator.allocAligned( + u8, + @alignOf(Page), + allocation_size, + ); + errdefer pool.allocator.free(new_page); + + const page_ptr = @as(*Page, @ptrCast(new_page.ptr)); + + const handles_addr: [*]Handle = + @ptrFromInt(@intFromPtr(base_addr) + + @sizeOf(Page) + handle_align_padding + ); + + const slots_addr: [*]SlotType = @ptrFromInt( + @intFromPtr(handles_addr) + + page_size * @sizeOf(SlotType) + slot_align_padding + ); + + page_ptr.* = .{ + .handles = handles_addr, + .slots = slots_addr, + .index = pool.page_table.len, + }; + + try pool.page_table.append(page_ptr, self.allocator); + return page_ptr; + } + + /// yeet a new free node onto the free list + pub fn allocNew(pool: *Pool) PoolError!*FreeNode { + var current_page = &pool.page_table.items[pool.current_page]; + if (current_page.cap == 0) { + current_page = try self.growPageIfAllowed(); + pool.current_page += 1; + } + + const next_index = page_size - current_page.cap; + const node: *FreeNode = @ptrCast(¤t_page.slots[next_index]); + node.page = current_page; + + current_page.cap -= 1; + return node; + } + + /// Initialize the thing + /// A non growable pool should use initPreheated since no pool memory + /// is allocated aside from the page table in this function + pub fn init(allocator: Allocator, initial_size: usize) PoolError!Pool { + var pool = Pool{ + // This is completely arbitrary + .page_table = try PageArray.initCapacity(allocator, 32), + .allocator = allocator, + }; + + if (config.growable) { + try pool.ensureCapacity(initial_size); + } + + return pool; + } + + /// Initialize the thing with cap guaranteed free slots before next allocation + pub fn initPreheated(allocator: Allocator, cap: usize) PoolError!Pool { + var new_pool = try init(allocator); + try new_pool.preheat(cap); + + return new_pool; + } + + pub fn preheat(pool: *Pool, cap: usize) PoolError!void { + for (0..cap) |i| { + const node = try pool.allocNew(); + pool.prependFreeNode(node); + } + } + + fn fetchPageIfValid(pool *Pool, h: Handle) PoolError!*Page { + if (builtin.mode == .ReleaseSafe or builtin.mode == .Debug) { + if (h.index.page_index > pool.page_table.items.len) + return error.OutOfBounds; + } + + const page = &pool.page_table[h.index.page_index]; + + const handle = page.handles[h.index.addr]; + if (h.gen != handle.gen) return error.InvalidHandle; + + return page; + } + + // get an element outta the pool + pub fn get(pool: *Pool, h: Handle) PoolError!*T { + const page = try pool.fetchPageIfValid(h); + return &page.slots[h.index.addr]; + } + + /// reserve a single handle and allocate if needed + pub fn reserve(pool: *Pool) PoolError!Handle { + var node = pool.popFree() orelse + pool.allocNew(); + + const index = pool.indexForNode(node); + + const handle = &node.page.handles[index]; + handle.bind(index, node.page.index); + + return handle.*; + } + + /// Reserve an item from the poool and initialize it with the givne value + pub fn reserveInit(pool: *Pool, val: *const T) PoolError!Handle { + const h = try pool.reserve(); + const v = pool.get(h) orelse unreachable; + v.* = val.*; + + return h; + } + + /// reserve a single handle whilst assuming there is space + /// Useful if you know that the pool will have space for a reservation + /// and you don't want to deal with an unreachable failure point + /// ... Of course, it should actually be unreachable... + pub fn reserveAssumeCapacity(pool: *Pool) Handle { + var node = pool.popFree() orelse unreachable; + const index = pool.indexForNode(node); + + const handle = &node.page.handles[index]; + handle.bind(index, node.page.index); + + return handle.*; + } + + pub fn reserveAssumeCapacityInit(pool: *Pool, val: *const T) Handle { + const h = pool.reserveAssumeCapacity(); + const v = pool.get(h) orelse unreachable; + + v.* = val.*; + return h; + } + + + /// return a handle to the pool, freeing it. + pub fn free(pool: *Pool, h: Handle) void { + const page = pool.fetchPageIfValid(h); + const h = &page.handles[h.index.addr]; + const former_slot: *FreeNode = @ptrCast(&page.slots[h.index.addr]); + + h.unbind(); + pool.prependFreeNode(former_slot); + } + + /// reset the pool's allocations but don't bother freeing the backing memory + pub fn reset(pool: *Pool) void { + for (pool.page_table.items) |*page| { + page.cap = page_size; + } + pool.current_page = 0; + + pool.free_list = pool.allocNew() catch unreachable; + } + + /// Destroy the entire pool and free all the memory + pub fn deinit(pool: *Pool) void { + for (pool.page_table) |*page| { + pool.allocator.free(page); + } + + pool.page_table.deinit(pool.allocator); + } + }; +} + diff --git a/src/common/pool_allocator.zig b/src/common/pool_allocator.zig deleted file mode 100644 index b6ce177..0000000 --- a/src/common/pool_allocator.zig +++ /dev/null @@ -1,245 +0,0 @@ -//! Takes in a fixed, preallocated -//! buffer of memory and manages it as a pool of -//! a given type of objects to be allocated and freed independently. -//! -//! Free space will be tracked as a RB tree (or maybe a buddy allocator dunno) -//! and alignment requirements and backing allocators (to create the buffer) can be specified at -//! initialization time... -//! -//! Pools contain a fixed capacity that CANNOT be modified unless the pool is later resized, -//! which will probably have a buch of bad side effects that make it not really that good of an idea -//! (i.e invalidates everything so all pointers to handles are not guaranteed). -//! -//! TODO: A great feature would be adding scoped allocations for individual pools -//! which match vulkan object's lifetimes (generally they are the same per-type of object) - -const std = @import("std"); -const common = @import("common"); -const assert = std.debug.assert; - -const Allocator = std.mem.Allocator; -const AnyPtr = common.AnyPtr; - -const Self = @This(); - -const PoolError = error{ - OutOfMemory, - InvalidHandle, -}; - -const TypedPoolConfig = struct { - index_bits: usize = 32, - generation_bits: usize = 32, - growable: bool = false, -}; - -// I didn't plan this out at all lol -// Plan: -// Step 1: 2 regions per page: handle and object storage -// Step 2: Memory broken into pages (done) -// Step 3: Pages can be created if more space is needed and growing is allowed (done) -// Step 4: Profit (never happening) - -/// Type Safe generic pool -pub fn TypedPool(comptime T: type, comptime config: TypedPoolConfig) type { - return struct { - const default_page_size = 2048; - - const PoolSlotType = if (@sizeOf(T) > @sizeOf(FreeNode)) - T - else - FreeNode; - - const Pool = @This(); - const elem_size = @sizeOf(PoolSlotType); - const alignment = @alignOf(PoolSlotType); - - const handles_padding: usize = @sizeOf(PageHeader) % @alignOf(Handle); - const slots_padding: usize = @sizeOf(Handle) % @alignOf(PoolSlotType); - - const PageHeader = PageTableList.Node; - - // give 0 shits about anything but the next freee node - const FreeSpaceList = std.SinglyLinkedList(struct {}); - - const FreeNode = FreeSpaceList.Node; - - /// pages additionally give some shits about alignment - const PageTableList = std.SinglyLinkedList(struct { - const Header = @This(); - cap: usize, - count: usize, - - pub fn handles(self: *Header) []Handle { - const base_address: usize = std.mem.Alignment.forward( - std.mem.Alignment.fromByteUnits(@alignOf(PageHeader)), - @intFromPtr(self) + @sizeOf(PageHeader), - ); - - const ptr = @as([*]Handle, @ptrFromInt(base_address)); - return ptr[0..self.count]; - } - - pub fn slots(self: *Header) []FreeNode { - // Implemented the lazy way, who gives a shit - const base_handle_addr = std.mem.Alignment.forward( - std.mem.Alignment.fromByteUnits(alignment), - @intFromPtr(self.handles().ptr), - ); - - const ptr = @as([*]FreeNode, @ptrFromInt(base_handle_addr)); - - return ptr[0..self.count]; - } - }); - pub const Handle = common.Handle(T, .{ - .generation_bits = config.generation_bits, - .index_bits = config.index_bits, - }); - - free_list: FreeSpaceList, - page_list: PageTableList, - allocator: Allocator, - - pub fn initPreheated(allocator: Allocator, count: usize) PoolError!Pool { - var new_pool = try Pool.init(allocator); - errdefer new_pool.deinit(); - - try new_pool.forceGrowPage(@max(count, @min(count * 2, std.math.maxInt(u16)))); - try new_pool.preheat(count); - return new_pool; - } - - pub fn newFreeNode(self: *Pool) PoolError!*FreeNode { - var page_node = self.page_list.first orelse - try self.growPage(default_page_size); - - if (page_node.data.cap == 0) { - page_node = try self.growPage(default_page_size); - } - - const new_node = page_node.data.slots()[page_node.data.cap - 1]; - page_node.data.cap -= 1; - - return new_node; - } - - /// Returns OutOfMemory if Not enough page space is allocated - pub fn preheat(self: *Pool, count: usize) PoolError!void { - for (0..count) |_| { - self.free_list.prepend(try self.newFreeNode()); - } - } - - /// This distinction exists for the purposes of an initial pool allocation - fn forceGrowPage(self: *Pool, object_count: usize) PoolError!*PageHeader { - // This probably needs to include alignment padding bytes for the underlying type - const size_bytes = object_count * elem_size + - @sizeOf(PageHeader) + handles_padding + slots_padding; - - const new_block = try self.allocator.alignedAlloc( - u8, - @alignOf(PageHeader), - size_bytes, - ); - - const new_header = @as(*PageHeader, @ptrCast(new_block.ptr)); - - // This is for obtaining the starting address from a aligned address. - - new_header.data = object_count; - self.page_list.prepend(new_header); - - return new_header; - } - - pub fn growPage(self: *Pool, object_count: usize) PoolError!*PageHeader { - if (!config.growable) return error.OutOfMemory; - - return self.forceGrowPage(object_count); - } - - pub fn init(allocator: Allocator) PoolError!Pool { - return Pool{ - .free_list = .{}, - .page_list = .{}, - .allocator = allocator, - }; - } - - pub fn reserve(self: *Pool) PoolError!Handle { - } - - pub fn free(self: *Pool, val: Handle) void { - } - - pub fn reset(self: *Pool) void {} - - pub fn deinit(self: *Pool) void { - while (self.page_list.popFirst()) |page| { - self.allocator.free(page); - } - } - }; -} - -// Testing goes here: -// We're probably gonna need a lot of them lol. - -const TestingStructA = struct { - items: [10]u32, -}; -const TestingPool = TypedPool(TestingStructA); - -const testing = std.testing; - -// Pool allocation tests -test "pool alloc" { - var pool = try TestingPool.initPreheated(std.heap.page_allocator, 1024); - defer pool.deinit(); - - for (0..512) |_| { - _ = try pool.reserve(); - } - - _ = try pool.reserveRange(512); -} - -test "pool free" { - //TODO: Testing partial frees - - // free everything - var pool = try TestingPool.initPreheated(std.heap.page_allocator, 1024); - _ = try pool.reserveRange(240); - - pool.freeAll(); - if (pool.inner.free_space.free_nodes.first) |f| { - try testing.expect(f.data.elem_count == 1024); - try testing.expect(f.next == null); - } else return error.InvalidFreeList; -} - -const Small = struct { - a: u8 = 0, - b: u8 = 0, - c: u8 = 0, -}; - -test "out of memory" { - var pool = try TestingPool.initPreheated(std.heap.page_allocator, 1024); - defer pool.deinit(); - - _ = try pool.reserveRange(120); -} - -test "pool with small object" { - var pool = try TypedPool(Small).initPreheated(std.heap.page_allocator, 1024); - defer pool.deinit(); - _ = try pool.reserveRange(1); - - pool.freeAll(); - if (pool.inner.free_space.free_nodes.first) |f| { - try testing.expect(f.data.elem_count == 1024); - try testing.expect(f.next == null); - } else return error.InvalidFreeList; -} From 1acfef6a04bb0ca1ee2dbcb3c86eb5c86d3bbabc Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 5 Sep 2025 22:49:19 -0700 Subject: [PATCH 26/46] fix(pool): pool complies with basic test coverage including memory integrity checks --- src/api/command_buffer.zig | 2 +- src/common/common.zig | 4 +- src/common/object_pool.zig | 260 ++++++++++++++----- src/resource_management/res.zig | 1 - src/resource_management/resource_manager.zig | 53 ++-- src/root.zig | 1 - src/test/test_all.zig | 4 - src/test/test_math.zig | 126 --------- src/test/unit_test.zig | 1 - 9 files changed, 229 insertions(+), 223 deletions(-) delete mode 100644 src/test/test_all.zig delete mode 100644 src/test/test_math.zig delete mode 100644 src/test/unit_test.zig diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index 13448c7..c65592e 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -150,7 +150,7 @@ pub fn addEntries(reg: *Registry) !void { } pub const CommandBufferProxy = struct { - const CommandBufferHandle = common.Handle(CommandBuffer); + const CommandBufferHandle = common.Handle(CommandBuffer, .{}); handle: CommandBufferHandle, diff --git a/src/common/common.zig b/src/common/common.zig index 5bcd633..42648b8 100644 --- a/src/common/common.zig +++ b/src/common/common.zig @@ -7,8 +7,7 @@ pub const OpaqueHandle = h.OpaqueHandle; // these resemble std's pools, but they have intrinsic support for handle // indexing -pub const OpaqueMemoryPool = @import("pool_allocator.zig"); -pub const MemoryPool = OpaqueMemoryPool.TypedPool; +pub const ObjectPool = @import("object_pool.zig").ObjectPool; pub const config = @import("config.zig"); pub const util = @import("util.zig"); @@ -77,4 +76,5 @@ pub fn APIFunction(func: anytype) APIFunctionType(func) { comptime { _ = @import("config.zig"); + _ = @import("object_pool.zig"); } diff --git a/src/common/object_pool.zig b/src/common/object_pool.zig index 4d27a0d..8770294 100644 --- a/src/common/object_pool.zig +++ b/src/common/object_pool.zig @@ -8,7 +8,7 @@ const std = @import("std"); const common = @import("common"); const builtin = @import("builtin"); -const assert = std.debug.assert; +const debug = std.debug; const Allocator = std.mem.Allocator; const AnyPtr = common.AnyPtr; @@ -19,17 +19,16 @@ const Self = @This(); const PoolError = error{ OutOfMemory, InvalidHandle, - OutOfBounds, }; -const TypedPoolConfig = struct { +const Config = struct { /// Leave null for default type alignment alignment: ?std.mem.Alignment = null, /// Leave null for 32-bit indexing and equal generation counter. IndexType: type = u32, /// Can pool expand once existing resources are exhausted? - /// NOTE: THis is a little janky in implenmentation for the moment - growable: bool = false, + /// NOTE: This is a little janky in implenmentation for the moment + growable: bool = true, }; // I didn't plan this out at all lol @@ -44,14 +43,20 @@ const TypedPoolConfig = struct { /// Finds the address offset between 2 separately alignments, /// i.e the padding bytes required. fn alignForwardDiff(comptime T: type, comptime b: Alignment) comptime_int { - return b.toByteUnits() - (@sizeOf(T) % b.toByteUnits()); + // @compileLog(@typeName(T)); + // @compileLog(@sizeOf(T)); + // @compileLog(b.toByteUnits()); + return @sizeOf(T) % b.toByteUnits(); } ///TODO: Handle bit widths smaller then a single page fn PartitionIndexType(comptime IndexType: type, page_size: usize) type { + _ = page_size; + const low_bits = 12; const high_bits = @typeInfo(IndexType).int.bits - low_bits; + return packed struct { page_index: std.meta.Int(.unsigned, high_bits), addr: std.meta.Int(.unsigned, low_bits), @@ -63,7 +68,7 @@ fn PartitionIndexType(comptime IndexType: type, page_size: usize) type { /// Type Safe generic pool /// Note that signedness is unsupported in config since there is no point /// in supporting negative indexing -pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { +pub fn ObjectPool(comptime T: type, comptime config: Config) type { if (@typeInfo(config.IndexType) != .int) @compileError("IndexType must be an integer"); if (@typeInfo(config.IndexType).int.bits < 12) @@ -82,7 +87,6 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { const SlotType = if (@sizeOf(T) > @sizeOf(FreeNode)) T else FreeNode; const Pool = @This(); - const FreeNode = struct { next: ?*FreeNode, page: *Page, @@ -95,8 +99,11 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { // These 2 functions are meant to update state in the stored handle state // of the pool, not the handles the user gets - pub fn bind(h: *Handle, idx: IndexType, page_index: IndexType) void { - h.index.addr = @intCast(index); + pub fn bind(h: *Handle, idx: usize, page_index: usize) void { + debug.assert(idx < std.math.maxInt(IndexType)); + debug.assert(page_index < std.math.maxInt(IndexType)); + + h.index.addr = @intCast(idx); h.index.page_index = @intCast(page_index); } @@ -105,7 +112,7 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { h.index.page_index = 0; h.gen += 1; } - } + }; /// Pages are broken into 2 separately alligned sections of memory /// - Handles (contiains handle information mainly gen count) @@ -147,7 +154,7 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { const free_node = pool.free_list; if (pool.free_list) |fl| { - pool.free_list = pool.free_list.next; + pool.free_list = fl.next; } return free_node; @@ -155,19 +162,19 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { fn growPageIfAllowed(pool: *Pool) PoolError!*Page { if (!config.growable) return error.OutOfMemory; - return self.justGrowTheFuckingPage(page_size); + return pool.justGrowTheFuckingPage(page_size); } fn indexForNode(node: *FreeNode) usize { - const relative_addr = @intFromPtr(node) - @intFromPtr(node.page.slots.ptr); + const relative_addr = @intFromPtr(node) - @intFromPtr(node.page.slots); return @divExact(relative_addr, @sizeOf(SlotType)); } /// Ensures there's enough capacity without altering /// the free list fn ensureCapacity(pool: *Pool, cap: usize) PoolError!void { - var current_cap = 0; - for (pool.page_table) |page| { + var current_cap: usize = 0; + for (pool.page_table.items) |page| { current_cap += page.cap; } @@ -175,22 +182,32 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { const needed_cap = cap - current_cap; const needed_pages = @divFloor(needed_cap, page_size) + 1; - + + var p: *Page = undefined; for (0..needed_pages) |_| { - pool.justGrowTheFuckingPage(page_size); + p = try pool.justGrowTheFuckingPage(page_size); } + + // Lower the final page's capacity + // So OutOfMemory happens when expected + p.cap = needed_cap % page_size; + } + + inline fn calcAllocationSize(size: usize) usize { + return size * @sizeOf(Handle) + size * @sizeOf(SlotType) + @sizeOf(Page) + + handle_align_padding + slot_align_padding; } fn justGrowTheFuckingPage(pool: *Pool, size: usize) PoolError!*Page { // If we have an extra unused page, just return that instead. // This covers the cases of pool reuse via the .reset() method - if (pool.page_table.items.len - 1 > pool.current_page) { - return &pool.page_table.items[pool.current_page + 1]; + if (pool.page_table.items.len != 0 and + pool.page_table.items.len - 1 > pool.current_page) { + return pool.page_table.items[pool.current_page + 1]; } - const allocation_size = size * @sizeOf(SlotType) + - handle_align_padding + slot_align_padding); + const allocation_size = calcAllocationSize(size); - const new_page = try pool.allocator.allocAligned( + const new_page = try pool.allocator.alignedAlloc( u8, @alignOf(Page), allocation_size, @@ -200,35 +217,36 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { const page_ptr = @as(*Page, @ptrCast(new_page.ptr)); const handles_addr: [*]Handle = - @ptrFromInt(@intFromPtr(base_addr) + + @ptrFromInt(@intFromPtr(page_ptr) + @sizeOf(Page) + handle_align_padding ); + const slots_addr: [*]SlotType = @ptrFromInt( @intFromPtr(handles_addr) + - page_size * @sizeOf(SlotType) + slot_align_padding + page_size * @sizeOf(Handle) + slot_align_padding ); page_ptr.* = .{ .handles = handles_addr, .slots = slots_addr, - .index = pool.page_table.len, + .index = pool.page_table.items.len, }; - try pool.page_table.append(page_ptr, self.allocator); + try pool.page_table.append(pool.allocator, page_ptr); return page_ptr; } /// yeet a new free node onto the free list pub fn allocNew(pool: *Pool) PoolError!*FreeNode { - var current_page = &pool.page_table.items[pool.current_page]; + var current_page = pool.page_table.items[pool.current_page]; if (current_page.cap == 0) { - current_page = try self.growPageIfAllowed(); + current_page = try pool.growPageIfAllowed(); pool.current_page += 1; } - const next_index = page_size - current_page.cap; - const node: *FreeNode = @ptrCast(¤t_page.slots[next_index]); + const next_index = current_page.cap - 1; + const node: *FreeNode = @ptrCast(@alignCast(¤t_page.slots[next_index])); node.page = current_page; current_page.cap -= 1; @@ -245,35 +263,30 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { .allocator = allocator, }; - if (config.growable) { - try pool.ensureCapacity(initial_size); - } + try pool.ensureCapacity(initial_size); return pool; } /// Initialize the thing with cap guaranteed free slots before next allocation pub fn initPreheated(allocator: Allocator, cap: usize) PoolError!Pool { - var new_pool = try init(allocator); - try new_pool.preheat(cap); + var new_pool = try init(allocator, cap); + try new_pool.ensureCapacity(cap); + new_pool.preheat(cap) catch unreachable; return new_pool; } pub fn preheat(pool: *Pool, cap: usize) PoolError!void { - for (0..cap) |i| { - const node = try pool.allocNew(); + for (0..cap) |_| { + const node = try pool.allocNew(); pool.prependFreeNode(node); } } - fn fetchPageIfValid(pool *Pool, h: Handle) PoolError!*Page { - if (builtin.mode == .ReleaseSafe or builtin.mode == .Debug) { - if (h.index.page_index > pool.page_table.items.len) - return error.OutOfBounds; - } - - const page = &pool.page_table[h.index.page_index]; + fn fetchPageIfValid(pool: *Pool, h: Handle) PoolError!*Page { + debug.assert(h.index.page_index <= pool.page_table.items.len); + const page = pool.page_table.items[h.index.page_index]; const handle = page.handles[h.index.addr]; if (h.gen != handle.gen) return error.InvalidHandle; @@ -284,27 +297,27 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { // get an element outta the pool pub fn get(pool: *Pool, h: Handle) PoolError!*T { const page = try pool.fetchPageIfValid(h); - return &page.slots[h.index.addr]; + return @as(*T, @ptrCast(@alignCast(&page.slots[h.index.addr]))); } /// reserve a single handle and allocate if needed pub fn reserve(pool: *Pool) PoolError!Handle { - var node = pool.popFree() orelse - pool.allocNew(); + var node = pool.popFreeNode() orelse + try pool.allocNew(); - const index = pool.indexForNode(node); + const index = indexForNode(node); const handle = &node.page.handles[index]; - handle.bind(index, node.page.index); + handle.bind(index, @intCast(node.page.index)); return handle.*; } /// Reserve an item from the poool and initialize it with the givne value - pub fn reserveInit(pool: *Pool, val: *const T) PoolError!Handle { + pub fn reserveInit(pool: *Pool, val: T) PoolError!Handle { const h = try pool.reserve(); - const v = pool.get(h) orelse unreachable; - v.* = val.*; + const v = pool.get(h) catch unreachable; + v.* = val; return h; } @@ -314,8 +327,8 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { /// and you don't want to deal with an unreachable failure point /// ... Of course, it should actually be unreachable... pub fn reserveAssumeCapacity(pool: *Pool) Handle { - var node = pool.popFree() orelse unreachable; - const index = pool.indexForNode(node); + var node = pool.popFreeNode() orelse unreachable; + const index = indexForNode(node); const handle = &node.page.handles[index]; handle.bind(index, node.page.index); @@ -334,17 +347,18 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { /// return a handle to the pool, freeing it. pub fn free(pool: *Pool, h: Handle) void { - const page = pool.fetchPageIfValid(h); - const h = &page.handles[h.index.addr]; + const page = pool.fetchPageIfValid(h) catch return; + const backing_h = &page.handles[h.index.addr]; const former_slot: *FreeNode = @ptrCast(&page.slots[h.index.addr]); - h.unbind(); + backing_h.unbind(); pool.prependFreeNode(former_slot); } /// reset the pool's allocations but don't bother freeing the backing memory + /// BUG: This function is completely BORKED, lemme fix it later pub fn reset(pool: *Pool) void { - for (pool.page_table.items) |*page| { + for (pool.page_table.items) |page| { page.cap = page_size; } pool.current_page = 0; @@ -354,8 +368,10 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { /// Destroy the entire pool and free all the memory pub fn deinit(pool: *Pool) void { - for (pool.page_table) |*page| { - pool.allocator.free(page); + const allocation_size = calcAllocationSize(page_size); + for (pool.page_table.items) |page| { + const original_slice: []u8 = @as([*]u8, @ptrCast(@alignCast(page)))[0..allocation_size]; + pool.allocator.free(original_slice); } pool.page_table.deinit(pool.allocator); @@ -363,3 +379,125 @@ pub fn ObjectPool(comptime T: type, comptime config: TypedPoolConfig) type { }; } +const testing = std.testing; + +const TestingTypeA = [10]u32; + +test "out of memory" { + + var pool = try ObjectPool(TestingTypeA, .{.growable = false}).init(testing.allocator, 2); + defer pool.deinit(); + + for (0..2) |_| { + _ = try pool.reserve(); + } + + try testing.expectError(error.OutOfMemory, pool.reserve()); + + + try testing.expectError(error.OutOfMemory, ObjectPool(usize, .{}).init( + testing.failing_allocator, + 10, + )); +} + +test "preheat" { + var pool = try ObjectPool(TestingTypeA, .{.growable = false}).initPreheated(testing.allocator, 32); + defer pool.deinit(); + + for (0..32) |_| { + _ = pool.reserveAssumeCapacity(); + } + + try testing.expectError(error.OutOfMemory, pool.reserve()); + + var pool2 = try ObjectPool(TestingTypeA, .{}).initPreheated(testing.allocator, 10); + defer pool2.deinit(); + //try pool2.preheat(10); + + for (0..10) |_| { + _ = pool2.reserveAssumeCapacity(); + } +} + +test "growable pool" { + const TestingTypeB = struct { + name: []const u8, + age: usize, + }; + + var pool = try ObjectPool(TestingTypeB, .{}).init(testing.allocator, 1); + defer pool.deinit(); + + for (0..5000) |_| { + _ = try pool.reserve(); + } + + const h = try pool.reserveInit(.{ + .name = "Jerry Smith", + .age = 420690, + }); + + try testing.expectEqual((try pool.get(h)).*, TestingTypeB{ + .name = "Jerry Smith", + .age = 420690, + }); +} + +test "integrity" { + var pool = try ObjectPool(TestingTypeA, .{}).init(testing.allocator, 1024); + defer pool.deinit(); + + const h = try pool.reserveInit(.{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}); + const v = try pool.get(h); + + try testing.expectEqual(v.*, TestingTypeA{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}); + + var h2 = h; + h2.gen += 102313; + + try testing.expectError(error.InvalidHandle, pool.get(h2)); +} + + +test "small object allocations" { + const Smol = u8; + const HandleType = ObjectPool(Smol, .{}).Handle; + var handles: [1024]HandleType = undefined; + + var pool = try ObjectPool(Smol, .{}).init(testing.allocator, handles.len); + defer pool.deinit(); + + + for (0..handles.len) |i| { + const val: u8 = @intCast(@mod(i, std.math.maxInt(u8))); + handles[i] = try pool.reserveInit(val); + + try testing.expectEqual((try pool.get(handles[i])).*, val); + } + + for (0..handles.len) |i| { + pool.free(handles[i]); + try testing.expectError(error.InvalidHandle, pool.get(handles[i])); + } + +} + +test "use after free" { + var pool = try ObjectPool(u32, .{.growable = false}).init(testing.allocator, 10); + defer pool.deinit(); + + const h1 = try pool.reserveInit(42069); + try testing.expectEqualDeep((try pool.get(h1)).*, @as(u32, 42069)); + + pool.free(h1); + try testing.expectError(error.InvalidHandle, pool.get(h1)); + + const h2 = try pool.reserveInit(80085); + try testing.expectEqual((try pool.get(h2)).*, @as(u32, 80085)); + + //pool.reset(); + //try pool.preheat(20); + + //try testing.expectError(error.InvalidHandle, pool.get(h2)); +} diff --git a/src/resource_management/res.zig b/src/resource_management/res.zig index bef67b0..37802cf 100644 --- a/src/resource_management/res.zig +++ b/src/resource_management/res.zig @@ -1,4 +1,3 @@ pub const Registry = @import("registry.zig"); -pub const PoolAllocator = @import("pool_allocator.zig"); pub const ResourceManager = @import("resource_manager.zig"); diff --git a/src/resource_management/resource_manager.zig b/src/resource_management/resource_manager.zig index 8123b39..6f1952e 100644 --- a/src/resource_management/resource_manager.zig +++ b/src/resource_management/resource_manager.zig @@ -4,11 +4,9 @@ const Self = @This(); const common = @import("common"); const Registry = @import("registry.zig"); -const PoolAllocator = @import("pool_allocator.zig"); const Allocator = std.mem.Allocator; const TypeId = common.TypeId; -const MemoryPoolsTable = std.AutoHashMap(TypeId, PoolAllocator); const Handle = common.Handle; const OpaqueHandle = common.OpaqueHandle; @@ -19,33 +17,36 @@ pub const Config = struct { pool_sizes: usize, }; -pools: MemoryPoolsTable, +// pools: MemoryPoolsTable, pub fn init(config: Config, registry: *Registry) !Self { + _ = config; + _ = registry; + + return undefined; // loop through each API registry entry // and initialize the table with a pool for each entry // whose management strategy is tagged as "Pooled" - - var entries_iter = registry.select(); - var entries = entries_iter - .where(Predicate.ManagementModeIs(.Pooled)) - .iterator(); - - var table = MemoryPoolsTable.init(config.allocator); - - while (entries.next()) |entry| { - const pool_config = PoolAllocator.Config{ - .elem_size = entry.size_bytes, - .elem_count = config.pool_sizes, - }; - - try table.put( - entry.type_id, - try PoolAllocator.initAlloc(config.allocator, pool_config), - ); - } - - return Self{ - .pools = table, - }; + // var entries_iter = registry.select(); + // var entries = entries_iter + // .where(Predicate.ManagementModeIs(.Pooled)) + // .iterator(); + + // var table = MemoryPoolsTable.init(config.allocator); + + // while (entries.next()) |entry| { + // const pool_config = PoolAllocator.Config{ + // .elem_size = entry.size_bytes, + // .elem_count = config.pool_sizes, + // }; + + // try table.put( + // entry.type_id, + // try PoolAllocator.initAlloc(config.allocator, pool_config), + // ); + // } + + // return Self{ + // .pools = table, + // }; } diff --git a/src/root.zig b/src/root.zig index 2c5738a..5e6ff3d 100644 --- a/src/root.zig +++ b/src/root.zig @@ -15,7 +15,6 @@ pub const res = @import("resource_management/res.zig"); // imports for testing comptime { - _ = @import("resource_management/pool_allocator.zig"); _ = @import("resource_management/registry.zig"); _ = @import("context.zig"); } diff --git a/src/test/test_all.zig b/src/test/test_all.zig deleted file mode 100644 index d26f356..0000000 --- a/src/test/test_all.zig +++ /dev/null @@ -1,4 +0,0 @@ - -comptime { - _ = @import("../mem/pool_allocator.zig"); -} diff --git a/src/test/test_math.zig b/src/test/test_math.zig deleted file mode 100644 index 1c8093d..0000000 --- a/src/test/test_math.zig +++ /dev/null @@ -1,126 +0,0 @@ -//! WARN: Hopelessly out of date with current -const meth = @import("ray").meth; - -const std = @import("std"); - -const Mat4 = meth.Mat4; -const vec = meth.vec; - -const expect = std.testing.expect; -// NOTE: I'm adding unit tests for the math library straight up -// because just debugging these by running the application would fucking -// suck... -const test_log = std.log.scoped(.math_tests); - -fn assertEqual(matrices: anytype, op: []const u8) !void { - const first = matrices[0]; - inline for (matrices) |v| { - if (!Mat4.eql(first, v)) { - test_log.err( - "Matrix {s} failed: \nExpected: \n{s} \nGot: \n{s}", - .{ op, first, v }, - ); - - return error.MatricesNotEqualWTFBro; - } - } -} - -const glm = @cImport({ - @cInclude("cglm/struct.h"); -}); - -test "matrix multiplication" { - const mat1 = Mat4.create(.{ - .{ 1.0, 2.0, 3.0, 4.0 }, - .{ 3.0, 2.0, 1.0, 1.0 }, - .{ 1.0, 2.0, 3.0, 2.0 }, - .{ 2.0, 3.0, 7.0, 3.0 }, - }); - - const mat2 = Mat4.create(.{ - .{ 4.0, 5.0, 6.0, 7.0 }, - .{ 6.0, 5.0, 4.0, 3.0 }, - .{ 4.0, 6.0, 5.0, 9.0 }, - .{ 2.0, 8.0, 5.0, 3.0 }, - }); - - const res = Mat4.mul(mat1, mat2); - - const correct = Mat4.create(.{ - .{ 36.0, 65.0, 49.0, 52.0 }, - .{ 30.0, 39.0, 36.0, 39.0 }, - .{ 32.0, 49.0, 39.0, 46.0 }, - .{ 60.0, 91.0, 74.0, 95.0 }, - }); - - try assertEqual(.{ correct, res }, "multiplication"); -} - -test "matrix ordering" { - // make sure the bloody matrices are column-major ordered - const mat1 = Mat4.create(.{ - .{1.0, 2.0, 3.0, 4.0}, - .{1.0, 2.0, 3.0, 4.0}, - .{1.0, 2.0, 3.0, 4.0}, - .{1.0, 2.0, 3.0, 4.0}, - }); - - for (mat1.data, 0..) |col, v| { - for (col) |item| { - const fv: f32 = @floatFromInt(v + 1); - if (item != fv) { - test_log.err("Matrix ordering incorrect! {d} != {d}", .{item, fv}); - test_log.err("Matrix: \n{s}", .{mat1}); - return error.NotColumnMajorBro; - } - } - } -} - -test "matrix translation" { - const mat1 = Mat4.identity().translate(vec(.{ 10.0, 20.0, 30.0 })); - const res = Mat4.create(.{ - .{ 1.0, 0.0, 0.0, 10.0 }, - .{ 0.0, 1.0, 0.0, 20.0 }, - .{ 0.0, 0.0, 1.0, 30.0 }, - .{ 0.0, 0.0, 0.0, 1.0 }, - }); - - try assertEqual(.{ res, mat1 }, "translation"); -} - -test "matrix rotation" { - const rot = meth.radians(45.0); - const mat1 = Mat4.identity().rotateZ(rot); - var res = Mat4.identity(); - - const mat = glm.glms_rotate_z(glm.glms_mat4_identity(), rot); - res.data = mat.raw; - - try assertEqual(.{ res, mat1 }, "Z rotation"); -} - -test "matrix projection" { - const mat1 = Mat4.perspective(meth.radians(75.0), 600.0 / 900.0, 0.1, 30.0); - const res = Mat4.create(.{ - .{ 1.9548, 0.0000, 0.0000, 0.0000 }, - .{ 0.0000, 1.3032, 0.0000, 0.0000 }, - .{ 0.0000, 0.0000, -1.0033, -1.0000 }, - .{ 0.0000, 0.0000, -0.1003, 0.0000 }, - }).transpose(); - - try assertEqual(.{ res, mat1 }, "perspective projection"); -} - -test "matrix view" { - const mat1 = Mat4.lookAt(vec(.{ 2.0, 2.0, 2.0 }), vec(.{ 0, 0, 0 }), meth.Vec3.global_up); - const res = Mat4.create(.{ - .{ 0.7071, -0.4082, -0.5774, 0.0000 }, - .{ -0.7071, -0.4082, -0.5774, 0.0000 }, - .{ 0.0000, 0.8165, -0.5774, 0.0000 }, - .{ -0.0000, -0.0000, -3.4641, 1.0000 }, - }).transpose(); - - try assertEqual(.{ res, mat1 }, "look at"); -} diff --git a/src/test/unit_test.zig b/src/test/unit_test.zig deleted file mode 100644 index 8b13789..0000000 --- a/src/test/unit_test.zig +++ /dev/null @@ -1 +0,0 @@ - From eee49513de8c182048dd3964c461226e31529fbe Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Wed, 10 Sep 2025 00:27:29 -0700 Subject: [PATCH 27/46] feat(virtual_allocator): virtualized GPU memory and begin scaffolding a top-level allocator analogous to a syscall'd allocator --- src/api/api.zig | 6 + src/api/memory/DeviceMemoryLayout.zig | 32 ++-- src/api/memory/allocator.zig | 85 ++++++++--- src/api/memory/heap.zig | 201 ++++++++++---------------- src/common/common.zig | 2 +- src/common/handle.zig | 130 ++++++++++++----- src/common/object_pool.zig | 99 +++++++++---- src/context.zig | 39 ++++- src/root.zig | 1 + 9 files changed, 361 insertions(+), 234 deletions(-) diff --git a/src/api/api.zig b/src/api/api.zig index 3663cb1..05c3f7e 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -22,6 +22,7 @@ pub const extensions = vk.extensions; pub const InstanceHandler = base.InstanceHandler; pub const DeviceHandler = base.DeviceHandler; pub const SurfaceHandler = base.SurfaceHandler; +pub const DeviceMemoryLayout = @import("memory/DeviceMemoryLayout.zig"); pub const GraphicsQueue = queue.GraphicsQueue; pub const ComputeQueue = queue.ComputeQueue; @@ -57,6 +58,7 @@ pub const DescriptorLayout = Descriptor.DescriptorLayout; pub const DescriptorType = common.DescriptorType; pub const DescriptorUsageInfo = common.DescriptorUsageInfo; + // additional utility structs and stuff const types = @import("common_types.zig"); pub const SyncInfo = types.SyncInfo; @@ -74,3 +76,7 @@ const Registry = @import("../resource_management/res.zig").Registry; pub fn initRegistry(reg: *Registry) !void { try CommandBuffer.addEntries(reg); } + +comptime { + _ = @import("memory/allocator.zig"); +} diff --git a/src/api/memory/DeviceMemoryLayout.zig b/src/api/memory/DeviceMemoryLayout.zig index 9b28889..5118551 100644 --- a/src/api/memory/DeviceMemoryLayout.zig +++ b/src/api/memory/DeviceMemoryLayout.zig @@ -9,37 +9,43 @@ const Layout = @This(); const HeapMap = heap.HeapMap; const Heap = HeapMap.Handle; +pub const Env = Context.EnvSubset(.{.dev, .ii}); + const DeviceLayoutError = error{ OutOfMemory, }; raw_mem_props: vk.PhysicalDeviceMemoryProperties, -heaps: HeapMap, +// heaps: HeapMap, pub fn init( - ctx: *const Context, + env: Env, allocator: std.mem.Allocator, ) DeviceLayoutError!Layout { - const dev: *const api.DeviceHandler = ctx.env(.dev); - const ii: api.InstanceInterface = ctx.env(.ii); + const dev: *const api.DeviceHandler = env.dev; + const ii: api.InstanceInterface = env.ii; const mem_props = ii.getPhysicalDeviceMemoryProperties(dev.h_pdev); const valid_heaps = mem_props.memory_heaps[0..mem_props.memory_heap_count]; const valid_types = mem_props.memory_types[0..mem_props.memory_type_count]; + _ = allocator; + _ = valid_types; + _ = valid_heaps; + return Layout{ .raw_mem_props = mem_props, - .heaps = try HeapMap.init(valid_heaps, valid_types, allocator), + //.heaps = try HeapMap.init(valid_heaps, valid_types, allocator), }; } -pub fn heapSupportsType( - self: *const Layout, - heap: Heap, - type_index: usize, -) bool { - return null; -} +//pub fn heapSupportsType( +// self: *const Layout, +// heap: Heap, +// type_index: usize, +//) bool { +// return null; +//} -pub fn typeSupportsProperty(self: *const Layout, type_index: usize, properties: vk.MemoryPropertyFlags) bool {} +//pub fn typeSupportsProperty(self: *const Layout, type_index: usize, properties: vk.MemoryPropertyFlags) bool {} diff --git a/src/api/memory/allocator.zig b/src/api/memory/allocator.zig index ede65aa..2ffa92e 100644 --- a/src/api/memory/allocator.zig +++ b/src/api/memory/allocator.zig @@ -14,9 +14,9 @@ const std = @import("std"); const vk = @import("vulkan"); const common = @import("common"); -const api = @import("api.zig"); +const api = @import("../api.zig"); -const Context = @import("../context.zig"); +const Context = @import("../../context.zig"); /// Represents an individual memory allocation.. /// Depending on the allocated memory's properties, @@ -39,8 +39,8 @@ pub const Error = error{ }; -pub const Allocation = common.Handle(AllocationData); -pub const Heap = common.Handle(HeapData); +//pub const Allocation = common.Handle(AllocationData); +//pub const Heap = common.Handle(HeapData); const AllocationScope = enum(u2) { /// General Purpose, Picks a free-list styled, static heap @@ -109,6 +109,10 @@ pub const AllocationConfig = packed struct { /// allocator match isn't found best_fit: bool = true, + /// Relevant allocation is promised but may not actually be allocated until + /// the allocation is first accessed + lazy: bool = false, + /// Force the allocator to perform a dedicated /// VkAllocateMemory specifically for this allocation (renders most configuration moot) dedicated_alloc_policy: DedicatedAllocationPolicyBits = .Unspecified, @@ -151,11 +155,23 @@ pub const AllocationConfig = packed struct { general: GeneralFlags = .{}, /// Flattens all nullable values and optional configuration parameters - /// into a common resolved layout - /// This shouldn't fail with an error, but just assert at you if you do invalid config - pub fn flatten(self: *const AllocationConfig) Resolved {} + /// into a common resolved layout. + /// This tends to ignore certain information + /// in order to generate concrete allocation parameters so further config processing is + /// usually done by the configurable allocator beforehand to resolve which allocator to use + pub fn flatten(self: *const AllocationConfig) Resolved { + _ = self; + return undefined; + } }; +const Allocation = struct { + Fuck: u32, +}; + +const ReifiedAllocation = struct { + Me: u32, +}; /// Manages top-level handles to instantiated /// heap allocations for all included memory types @@ -171,36 +187,50 @@ pub const AllocationConfig = packed struct { /// * Rather, it is better to use this as a parent allocator for a more efficient child allocator. /// This ensures the giant memory blob is better utilized then being wasted on a single 24 byte /// uniform buffer. +/// * Recommended not to instance this yourself, as every context's memory manager will come with +/// an instanced version +/// * This allocator uses an extremely basic algorithm which allocates and frees large blocks of memory +/// with little regard for fragmentation, making it a poor choice anyways for a general-purpose allocator pub const VirtualAllocator = struct { + /// Env's can be manually initialized if you don't want to + /// go through the entire context init schtick + pub const Env = Context.EnvSubset(.{.mem_layout, .di}); + allocator: std.mem.Allocator, + env: Env, + + // Free list tracking which unfortunately can't be in-place sigh - dev_mem_layout: *const api.DeviceMemoryLayout, - di: *const api.DeviceInterface, - heaps: HeapMap, /// Doesn't actually do much rn but could anticipatorially do some ahead-of-time heap allocation - pub fn init(ctx: *const Context, allocator: std.mem.Allocator) Error!VirtualAllocator { - const layout = ctx.env(.dev_mem_layout); + pub fn init( + env: Env, + allocator: std.mem.Allocator, + ) Error!VirtualAllocator { return VirtualAllocator{ .allocator = allocator, - .di = ctx.env(.di), - .dev_mem_layout = layout, - .heaps = HeapMap.init(layout), + .env = env, }; } + /// NOTE: This allocator doesn't support best fit re-indexing, /// that happens at a higher level. pub fn allocate(self: *VirtualAllocator, config: AllocationConfig) Error!Allocation { - const resolved_config = config.flatten(); - const reqs = resolved_config.mem_reqs; - const props = resolved_config.mem_props; - - const type_index: u32 = self.dev_mem_layout.findCompatibleHeapIndex(reqs, props) orelse return Error.NoMatchingHeap; + _ = self; + _ = config; - var chosen_heap = try self.heaps.get(type_index); - - return chosen_heap.grow(reqs); + return undefined; + } + + /// This version returns a reified handle to the allocation table + /// which is essentially combined data and API along with pointer to the backing pool + /// for that classic OOP feel (even if it's all a lie) + pub fn allocateReified(self: *VirtualAllocator, config: AllocationConfig) Error!ReifiedAllocation { + _ = self; + _ = config; + + return undefined; } }; @@ -248,3 +278,12 @@ pub const VirtualAllocator = struct { // // Way 3: Automated: // const my_buffer4 = try VertexBuffer.initAlloc(ctx, .{yadda yadda}); // } + +const debug = std.debug; + +test "compiles" { + const thing = @typeInfo(VirtualAllocator); + inline for (thing.@"struct".fields) |fld| { + std.debug.print("Field: {s}\n", .{fld.name}); + } +} diff --git a/src/api/memory/heap.zig b/src/api/memory/heap.zig index 7514661..9fe86af 100644 --- a/src/api/memory/heap.zig +++ b/src/api/memory/heap.zig @@ -1,139 +1,84 @@ +//! A heap is a blob of memory which can +//! be partitioned into blocks of arbitrary sizes +//! It gives 0 shits about anything other then +//! allocating and deallocating memory ranges. +//! Think of it more as a view into a section of the device's memory +//! layout rather than the actual memory itself. +//! The actual memory properties are just stored in DeviceMemoryLayout +//! to prevent unnecesary duplication. + const common = @import("common"); const vk = @import("vulkan"); const std = @import("std"); -/// Just a thin wrapper over a VkDeviceMemory with some extra crap -/// Think of this as an individual device memory, the only real difference is that -/// it supports suballocations on a less granular page size. -/// This is more of a low-level arena, which can grow but expects -/// free chunks to be managed by a higher level system. -/// Deinitiialize it to destroy the associated DeviceMemory -pub const GPUBlock = struct { - const PageRange = struct { - h_block: common.Handle(GPUBlock), - offset: u32, - count: u32, - }; +const debut = std.debug; - parent_heap: Heap, - mem: vk.DeviceMemory, - - /// offset into physical GPU memory pool, - /// Probably can save some bits since pages will be relatively large - break_limit: u16, - page_count: u16, - - /// Performs exactly one GPU allocation of the specified # of pages - /// (determined by the parent heap) - /// - /// This function should not be allowed to error, since budgets and memory - /// limits should be figured out ahead of time. Essentially, a new block - /// should only ever be created if there is actually space for one. - pub fn init(heap: Heap, page_count: u16) GPUBlock { - } - - /// Increase size of GPU block, essentially allocating more of the given heap - /// to the application process - pub fn grow(self: *GPUBlock, amount: usize) Error!Allocation { +const Heap = @This(); - } +const Context = @import("../../context.zig"); - /// Allocate a new page range if space currently exists in the given GPU block. - /// This will only be called by heaps if they don't have a free range of compatible - /// pages - pub fn allocatePageRange(self: *GPUBlock, count: usize) PageRange { - } - - pub fn deinit(self: *GPUBlock) void { - } -}; +pub const Env = Context.EnvSubset(.{.mem_layout, .di}); -/// Individual memory heap, -/// This maps cleanly onto vulkan's idea of a heap. and is essentially a wrapper -/// with some bookkeeping info along with supported memory types. -/// Think of this as an otherwise unstructured blob of page-sized virtual chunks -/// Each heap gets exactly 1 Vulkan device heap bound to it, which it will then suballocate until it's exhausted -const HeapData = struct { - const VulkanBlockPool = common.MemoryPool(GPUBlock, .{ - .IndexType = u16, - }); - - const GPUBlockHandle = VulkanBlockPool.Handle; - - pages: VulkanBlockPool, - page_size: usize, - block_size: usize, - - - /// How big/how many pages should there be for this heap??? - /// We mostly care about usage as it relates to size (or available budget) - /// to the application. - /// Note that this is more of an estimate then anything else, - /// Vulkan allocations won't exactly match pages often, however the minimum allocation - /// size will be for individual pages. - fn deterimineVirtualMemProps(budget: *const api.DeviceMemoryBudget) struct {usize, usize, usize} { - //TODO: I might consider using 2 separate heurstics depending on whether the Budget query extension is avialable - } - - pub fn init(heap_budget: *const api.DeviceMemoryBudget, allocator: std.mem.Allocator) Error!HeapData { - const page_size, - const max_pages, - const block_size = deterimineVirtualMemProps(heap_budget); - - return HeapData{ - // I distinguish host (app-side CPU) and GPU allocation failures, - // cuz otherwise shit gets confusing - .pages = VulkanBlockPool.initPreheated( - allocator, - heap_budget.size / block_size, - ) catch { - return error.HostOutOfMemory; - }, - .page_size = page_size, - .block_size = block_size, - }; - } - - /// Allocate new memory blocks. This either increases the break limit of an existing GPU block - /// or allocates a new one - pub fn grow(self: *HeapData, reqs: vk.MemoryRequirements) Error!GPUBlock.PageRange { - } - - pub fn shrink(self: *HeapData, alloc: Allocation) void { - } +pub const Error = error { + DeviceOutOfMemory, + IncompatibleProperties, }; -/// Map of available memory heaps (pools) -/// This is just an array with extra steps -pub const HeapMap = struct { - const HeapPool = common.MemoryPool(HeapData, .{ - .IndexType = u8, - }); - - pub const Handle = HeapPool.Handle; - heaps: HeapPool, - /// prefills heaps with pools of handles - pub fn init(heaps: []const vk.MemoryHeap, types: []const vk.MemoryType, allocator: std.mem.Allocator) Error!HeapMap { - const num_heaps = layout.memory_heaps.len; - - const heaps = HeapPool.init(num_heaps, allocator) catch - return error.HostOutOfMemory; +env: Env, +index: u32, +available_budget: usize, - for (heaps.items, layout.memory_heaps) |*heap, props| { - heap.* = try HeapData.init(props.index, props.supported_props); - } - - return HeapMap{ - .heaps = heaps, - }; - } - - pub fn getHeapForMemoryType(self: *HeapMap, type_index: usize) Error!Heap { - - } - - pub fn getHeapByIndex(self: *HeapMap, mem_index: usize) Error!Heap { - if (mem_index >= self.heaps.items.len) return error.NoMatchingHeap; - return self.heaps.handle(mem_index); - } -}; +/// Calculates based on the budget returned by +/// the vulkan extension, or in absence, using a heuristic +/// based on the total memory of said heap. +fn calcAvailableBudget(env: Env, heap_index: u32) usize { + const props = env.mem_layout.getBasicHeapProps(heap_index); + + // calculates a percentage of an integer value + return common.pct(props.heapSizeBytes(), 75); +} + +pub fn init(env: Env, heap_index: u32) Heap { + // figure out how much memory we can allocate + return Heap { + .env = env, + .index = heap_index, + .available_budget = calcAvailableBudget(env, heap_index), + }; +} + +fn matchesMask(bit: u32, mask: u32) bool { + return mask & (@as(u32, 1) << bit) != 0; +} + +pub fn alloc( + heap: *Heap, + mem_type: u32, + reqs: vk.MemoryRequirements, +) Error!vk.DeviceMemory { + debug.assert(mem_type < vk.MAX_MEMORY_TYPES); + debug.assert(matchesMask(mem_type, reqs.memory_type_bits)); + + return heap.env.di.allocateMemory(&.{ + .allocation_size = mem_reqs.size, + .memory_type_index = mem_type, + }, null); +} + +pub fn allocWithProps( + heap: *Heap, + props: vk.MemoryProperties, + reqs: vk.MemoryRequirements, +) Error!vk.DeviceMemory { + if (!heap.env.mem_layout.heapSupports(heap.index, props)) + return error.IncompatibleProperties; + + const mem_type = heap.env.mem_layout.compatibleTypeInHeap(heap.index, props) orelse + return error.IncompatibleProperties; + + return heap.alloc(mem_type, reqs); +} + +pub fn free(heap: *Heap, mem: vk.DeviceMemory) void { + heap.env.di.freeMemory(mem, null); +} diff --git a/src/common/common.zig b/src/common/common.zig index 42648b8..a3bb766 100644 --- a/src/common/common.zig +++ b/src/common/common.zig @@ -2,7 +2,7 @@ const std = @import("std"); const assert = std.debug.assert; const h = @import("handle.zig"); -pub const Handle = h.TypedHandle; +pub const Handle = h.Handle; pub const OpaqueHandle = h.OpaqueHandle; // these resemble std's pools, but they have intrinsic support for handle diff --git a/src/common/handle.zig b/src/common/handle.zig index 70a142e..a67d7b3 100644 --- a/src/common/handle.zig +++ b/src/common/handle.zig @@ -1,52 +1,106 @@ const std = @import("std"); const common = @import("common.zig"); +// const ct = common.ct; + const AnyPtr = common.AnyPtr; -pub const HandleType = enum { - Single, - Multi, -}; -/// generic type-erased handle -/// contains the minimal amount of data required to work, but no higher-level functionality -/// To ensure safety, don't initialize these from scratch, -pub const OpaqueHandle = struct { - // value is always treated in a type-erased manner, - // gets and sets, as well as wrapped API functions will cast this as the appropriate - // type - // This is sort of not safe, so I'll provide debug functionality to ensure that handles - // are valid whenever they're acquired. - value: AnyPtr, - - type_data: union(HandleType) { - Single, - Multi: usize, - }, +pub const Config = struct { + index_bits: usize = 32, + gen_bits: usize = 32, + + partition_bit: ?usize = null, }; -const assert = std.debug.assert; +fn PartitionIndexType(index_bits: usize, partition: usize) type { + return if (partition == 0) + std.meta.Int(.unsigned, index_bits) + else + packed struct { + lhs: std.meta.Int(.unsigned, partition), + rhs: std.meta.Int(.unsigned, index_bits - partition), + }; +} -pub const Config = struct { - index_bits: u16 = 32, - generation_bits: u16 = 32, -}; +pub fn Handle( + comptime T: type, + comptime config: Config, +) type { + const partition_bit = config.partition_bit orelse 0; + + if (config.index_bits > 64) + @compileError( + "index_bits (" ++ + config.index_bits ++ + ") must be within the range of <=64"); + + if (partition_bit > config.index_bits) + @compileError("index bit partition must lie within the range of index bits"); + + const IndexType = PartitionIndexType(config.index_bits, partition_bit); + + if (config.gen_bits == 0) { + return packed struct { + const Self = @This(); + const Type = T; -/// Typed handle, with support for derefrence -pub fn TypedHandle(comptime T: type, comptime config: Config) type { - const IndexType: type = std.meta.Int(.unsigned, config.index_bits); - const GenerationType: type = std.meta.Int(.unsigned, config.generation_bits); + pub fn Reified(err: type, getter: *const fn (*anyopaque, Self) err!*T) type { + return packed struct { + h: Self, + p: *anyopaque, - return packed struct { - const UnderlyingType = T; - const Handle = @This(); + pub fn get(self: @This()) err!*T { + return getter(self.p, self.h); + } - index: IndexType = 0, - gen: GenerationType = 0, + pub fn init(h: Self, mem: *anyopaque) @This() { + return .{ + .h = h, + .p = mem, + }; + } + }; + } - pub fn bind(handle: *Handle, index: IndexType) void { - handle.index = index; - handle.gen += 1; - } - }; + index: IndexType, + + }; + } + else { + // gen is included only if we want a generation counter + const GenType = std.meta.Int(.unsigned, config.gen_bits); + + return packed struct { + const Type = T; + const Self = @This(); + + /// Uhh duplicate im lazy + pub fn Reified(err: type, getter: *const fn (*anyopaque, Self) err!*T) type { + return packed struct { + h: Self, + p: *anyopaque, + + pub fn get(self: @This()) err!*T { + return getter(self.p, self.h); + } + + pub fn init(h: Self, mem: *anyopaque) @This() { + return .{ + .h = h, + .p = mem, + }; + } + }; + } + + + gen: GenType, + index: IndexType, + }; + } } + + +pub const OpaqueHandle = packed struct { +}; diff --git a/src/common/object_pool.zig b/src/common/object_pool.zig index 8770294..623beeb 100644 --- a/src/common/object_pool.zig +++ b/src/common/object_pool.zig @@ -6,7 +6,7 @@ //! which match vulkan object's lifetimes (generally they are the same per-type of object) const std = @import("std"); -const common = @import("common"); +const common = @import("common.zig"); const builtin = @import("builtin"); const debug = std.debug; @@ -76,6 +76,8 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { if (@typeInfo(config.IndexType).int.signedness != .unsigned) @compileError("IndexType must be unsigned"); + + const resolved_alignment = if (config.alignment) |al| al else @@ -92,27 +94,34 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { page: *Page, }; - pub const Handle = packed struct { - pub const PartitionedIndex = PartitionIndexType(IndexType, page_size); - index: PartitionedIndex, - gen: IndexType, + pub const Handle = common.Handle(T, .{ + .index_bits = @typeInfo(config.IndexType).int.bits, + .gen_bits = @typeInfo(config.IndexType).int.bits, + .partition_bit = 12, + }); + + fn getReified(p: *anyopaque, h: Handle) PoolError!*T { + const pool: *Pool = @ptrCast(@alignCast(p)); + return pool.get(h); + } + + pub const ReifiedHandle = Handle.Reified(PoolError, getReified); - // These 2 functions are meant to update state in the stored handle state - // of the pool, not the handles the user gets - pub fn bind(h: *Handle, idx: usize, page_index: usize) void { - debug.assert(idx < std.math.maxInt(IndexType)); - debug.assert(page_index < std.math.maxInt(IndexType)); - - h.index.addr = @intCast(idx); - h.index.page_index = @intCast(page_index); - } + // These 2 functions are meant to update state in the stored handle state + // of the pool, not the handles the user gets + fn bind(h: *Handle, idx: usize, page_index: usize) void { + debug.assert(idx < std.math.maxInt(IndexType)); + debug.assert(page_index < std.math.maxInt(IndexType)); + + h.index.lhs = @intCast(idx); + h.index.rhs = @intCast(page_index); + } - pub fn unbind(h: *Handle) void { - h.index.addr = 0; - h.index.page_index = 0; - h.gen += 1; - } - }; + fn unbind(h: *Handle) void { + h.index.lhs = 0; + h.index.rhs = 0; + h.gen += 1; + } /// Pages are broken into 2 separately alligned sections of memory /// - Handles (contiains handle information mainly gen count) @@ -285,10 +294,10 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { } fn fetchPageIfValid(pool: *Pool, h: Handle) PoolError!*Page { - debug.assert(h.index.page_index <= pool.page_table.items.len); - const page = pool.page_table.items[h.index.page_index]; + debug.assert(h.index.rhs <= pool.page_table.items.len); + const page = pool.page_table.items[h.index.rhs]; - const handle = page.handles[h.index.addr]; + const handle = page.handles[h.index.lhs]; if (h.gen != handle.gen) return error.InvalidHandle; return page; @@ -297,7 +306,7 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { // get an element outta the pool pub fn get(pool: *Pool, h: Handle) PoolError!*T { const page = try pool.fetchPageIfValid(h); - return @as(*T, @ptrCast(@alignCast(&page.slots[h.index.addr]))); + return @as(*T, @ptrCast(@alignCast(&page.slots[h.index.lhs]))); } /// reserve a single handle and allocate if needed @@ -308,7 +317,7 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { const index = indexForNode(node); const handle = &node.page.handles[index]; - handle.bind(index, @intCast(node.page.index)); + bind(handle, index, @intCast(node.page.index)); return handle.*; } @@ -322,6 +331,19 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { return h; } + /// Reserve an item and retain memory of which pool allocated it in the handle + /// (essentially "reifying the handle" by + /// giving all the information needed to resolve the data) + pub fn reserveReified(pool: *Pool) PoolError!ReifiedHandle { + const h = try pool.reserve(); + return ReifiedHandle.init(h, pool); + } + + pub fn reserveAssumeCapacityReified(pool: *Pool) ReifiedHandle { + const h = pool.reserveAssumeCapacity(); + return ReifiedHandle.init(h, pool); + } + /// reserve a single handle whilst assuming there is space /// Useful if you know that the pool will have space for a reservation /// and you don't want to deal with an unreachable failure point @@ -331,7 +353,7 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { const index = indexForNode(node); const handle = &node.page.handles[index]; - handle.bind(index, node.page.index); + bind(handle, index, node.page.index); return handle.*; } @@ -348,10 +370,10 @@ pub fn ObjectPool(comptime T: type, comptime config: Config) type { /// return a handle to the pool, freeing it. pub fn free(pool: *Pool, h: Handle) void { const page = pool.fetchPageIfValid(h) catch return; - const backing_h = &page.handles[h.index.addr]; - const former_slot: *FreeNode = @ptrCast(&page.slots[h.index.addr]); + const backing_h = &page.handles[h.index.lhs]; + const former_slot: *FreeNode = @ptrCast(&page.slots[h.index.lhs]); - backing_h.unbind(); + unbind(backing_h); pool.prependFreeNode(former_slot); } @@ -429,6 +451,7 @@ test "growable pool" { var pool = try ObjectPool(TestingTypeB, .{}).init(testing.allocator, 1); defer pool.deinit(); + for (0..5000) |_| { _ = try pool.reserve(); } @@ -501,3 +524,21 @@ test "use after free" { //try testing.expectError(error.InvalidHandle, pool.get(h2)); } + +test "reification" { + const TestStruct = struct { + name: []const u8, + id: usize, + }; + var pool = try ObjectPool(TestStruct, .{.growable = false}).init(testing.allocator, 128); + defer pool.deinit(); + + const h = try pool.reserveInit(.{ + .name = "larry the libster", + .id = 932932, + }); + + const h2 = ObjectPool(TestStruct, .{.growable = false}).ReifiedHandle.init(h, &pool); + + try testing.expectEqual(try pool.get(h), try h2.get()); +} diff --git a/src/context.zig b/src/context.zig index 623a6eb..fca2a59 100644 --- a/src/context.zig +++ b/src/context.zig @@ -35,6 +35,9 @@ const EnvBacking = struct { gi: Ref(GlobalInterface, .{ .field = "global_interface" }), ii: Ref(InstanceInterface, .{ .field = "inst_interface" }), di: Ref(DeviceInterface, .{ .field = "dev_interface" }), + + mem_layout: Ref(api.DeviceMemoryLayout, .{}), + }; const Environment = e.For(EnvBacking); @@ -240,6 +243,40 @@ pub fn presentFrame( try self.present_queue.present(swapchain, image, sync.sem_wait); } +const meta = std.meta; + +/// Defines an env subset type which can be automatically populated by a factory +pub fn EnvSubset(comptime fields: anytype) type { + const StructField = std.builtin.Type.StructField; + //const num_fields = fields.len; + + comptime var field_infos: []const StructField = &.{}; + for (fields) |enum_lit| { + const matching_field = meta.fieldInfo(EnvBacking, enum_lit); + const MatchingFieldType = matching_field.type; + + + // This is janky due to how the env system mapps fields oops + const mapped_field_info = StructField{ + .default_value_ptr = null, + .type = MatchingFieldType.InnerType, + .is_comptime = false, + .alignment = @alignOf(MatchingFieldType.InnerType), + .name = matching_field.name, + }; + field_infos = field_infos ++ [1]StructField{mapped_field_info}; + } + + return @Type(.{ + .@"struct" = .{ + .fields = field_infos, + .decls = &.{}, + .layout = .auto, + .is_tuple = false, + }, + }); +} + //BUG: This cannot work since windowless contexts would require //a lot more features that I currently support // test "windowless context" { @@ -264,5 +301,3 @@ pub fn presentFrame( // .pool_sizes = 1024, // }, // }); -// defer ctx.deinit(); -// } diff --git a/src/root.zig b/src/root.zig index 5e6ff3d..d6acf99 100644 --- a/src/root.zig +++ b/src/root.zig @@ -17,4 +17,5 @@ pub const res = @import("resource_management/res.zig"); comptime { _ = @import("resource_management/registry.zig"); _ = @import("context.zig"); + _ = @import("api/api.zig"); } From e342bfc32ca097195c60d3e8e59d8bc1044836be Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 12 Sep 2025 22:42:28 -0700 Subject: [PATCH 28/46] fml --- src/api/api.zig | 1 + src/api/base.zig | 74 ++++++++++------- src/api/buffer.zig | 2 +- src/api/command_buffer.zig | 2 +- src/api/compute.zig | 2 +- src/api/descriptor.zig | 2 +- src/api/graphics_pipeline.zig | 2 +- src/api/image.zig | 2 +- src/api/memory/DeviceMemoryLayout.zig | 113 ++++++++++++++++++++++---- src/api/memory/allocator.zig | 18 ++-- src/api/memory/heap.zig | 69 +++++++++++++--- src/api/queue.zig | 2 +- src/api/renderpass.zig | 2 +- src/api/swapchain.zig | 13 +-- src/api/vertex_buffer.zig | 2 +- src/common/util.zig | 60 ++++++++++++++ src/context.zig | 10 +-- src/env.zig | 8 +- src/glfw.zig | 6 +- src/root.zig | 3 +- src/tests/testing.zig | 92 +++++++++++++++++++++ src/util.zig | 55 ------------- 22 files changed, 397 insertions(+), 143 deletions(-) create mode 100644 src/tests/testing.zig delete mode 100644 src/util.zig diff --git a/src/api/api.zig b/src/api/api.zig index 05c3f7e..8228f07 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -79,4 +79,5 @@ pub fn initRegistry(reg: *Registry) !void { comptime { _ = @import("memory/allocator.zig"); + _ = @import("memory/Heap.zig"); } diff --git a/src/api/base.zig b/src/api/base.zig index 5b621b9..dce8259 100644 --- a/src/api/base.zig +++ b/src/api/base.zig @@ -3,7 +3,7 @@ const vk = @import("vulkan"); const std = @import("std"); const glfw = @import("glfw"); -const util = @import("../util.zig"); +const util = @import("common").util; const api = @import("api.zig"); const Allocator = std.mem.Allocator; @@ -56,10 +56,6 @@ pub const InstanceHandler = struct { validation_layers: []const [*:0]const u8, }, - device: struct { - required_extensions: []const [*:0]const u8, - }, - loader: GetProcAddrHandler, allocator: Allocator, enable_debug_log: bool, @@ -98,7 +94,7 @@ pub const InstanceHandler = struct { }; } - fn createInstance(self: *InstanceHandler, config: *const Config) !void { + fn createInstance(self: *InstanceHandler, config: Config) !void { // log the available extensions const available = self.w_db.enumerateInstanceExtensionPropertiesAlloc( @@ -182,7 +178,7 @@ pub const InstanceHandler = struct { ); } - fn loadBase(self: *InstanceHandler, config: *const Config) !void { + fn loadBase(self: *InstanceHandler, config: Config) !void { self.w_db = vk.BaseWrapper.load(config.loader); // check to see if the dispatch table loading fucked up @@ -192,7 +188,7 @@ pub const InstanceHandler = struct { } } - pub fn init(config: *const Config) !InstanceHandler { + pub fn init(config: Config) !InstanceHandler { var ctx: InstanceHandler = .{ .allocator = config.allocator, }; @@ -226,7 +222,7 @@ pub const InstanceHandler = struct { //TODO: Yeet into a non-owning view of context pub const DeviceHandler = struct { pub const Config = struct { - surface: *const SurfaceHandler, + surface: ?*const SurfaceHandler, required_extensions: []const [*:0]const u8 = &[0][*:0]const u8{}, }; @@ -329,7 +325,7 @@ pub const DeviceHandler = struct { // TODO: Support overlap in queue families // (i.e) some queues might support both compute and graphics operations families: FamilyIndices, - swapchain_details: SwapchainSupportDetails, + swapchain_details: ?SwapchainSupportDetails, h_dev: vk.Device = .null_handle, h_pdev: vk.PhysicalDevice = .null_handle, @@ -380,7 +376,7 @@ pub const DeviceHandler = struct { fn getQueueFamilies( dev: vk.PhysicalDevice, pr_inst: *const vk.InstanceProxy, - surface: *const SurfaceHandler, + surface: ?*const SurfaceHandler, allocator: Allocator, ) FamilyIndices { var found_indices: FamilyIndices = .{ @@ -412,13 +408,16 @@ pub const DeviceHandler = struct { })) { found_indices.compute_family = i; } - - if ((pr_inst.getPhysicalDeviceSurfaceSupportKHR( - dev, - i, - surface.h_surface, - ) catch vk.FALSE) == vk.TRUE) { - found_indices.present_family = i; + + // HACK: Guhh + if (surface) |surf| { + if ((pr_inst.getPhysicalDeviceSurfaceSupportKHR( + dev, + i, + surf.h_surface, + ) catch vk.FALSE) == vk.TRUE) { + found_indices.present_family = i; + } } } @@ -452,7 +451,7 @@ pub const DeviceHandler = struct { // This will likely require a bit of upgrade when I consider making this project more portable fn pickSuitablePhysicalDevice( pr_inst: *const vk.InstanceProxy, - config: *const Config, + config: Config, allocator: Allocator, ) ?vk.PhysicalDevice { const physical_devices = @@ -480,7 +479,7 @@ pub const DeviceHandler = struct { // Later on, I plan to accept a device properties struct // which shall serve as the criteria for choosing a graphics unit - pub fn init(parent: *const InstanceHandler, config: *const Config) !DeviceHandler { + pub fn init(parent: *const InstanceHandler, config: Config) !DeviceHandler { // attempt to find a suitable device -- hardcoded for now const chosen_dev = pickSuitablePhysicalDevice( &parent.pr_inst, @@ -500,15 +499,23 @@ pub const DeviceHandler = struct { parent.allocator, ); - // just enable all the available features lmao + //HACK: Extremely lazy fix for device being hardcoded + //for a surface. Please replace this once proper featureset + //support exists const dev_features = parent.pr_inst.getPhysicalDeviceFeatures(chosen_dev); - const swapchain_details = getDeviceSupport( - &parent.pr_inst, - config.surface, - chosen_dev, - parent.allocator, - ) catch unreachable; - errdefer swapchain_details.deinit(); + const swapchain_details = if (config.surface) |surf| + getDeviceSupport( + &parent.pr_inst, + surf, + chosen_dev, + parent.allocator, + ) catch unreachable + else + null; + + if (swapchain_details) |sd| { + errdefer sd.deinit(); + } const priority = [_]f32{1.0}; @@ -520,7 +527,8 @@ pub const DeviceHandler = struct { .p_queue_priorities = &priority, }, .{ - .queue_family_index = dev_queue_indices.present_family.?, + .queue_family_index = dev_queue_indices.present_family orelse + undefined, .queue_count = 1, .p_queue_priorities = &priority, }, @@ -528,7 +536,7 @@ pub const DeviceHandler = struct { const logical_dev = parent.pr_inst.createDevice(chosen_dev, &.{ .p_queue_create_infos = &queue_create_infos, - .queue_create_info_count = queue_create_infos.len, + .queue_create_info_count = if (config.surface != null) queue_create_infos.len else 1, .p_enabled_features = @ptrCast(&dev_features), .pp_enabled_extension_names = config.required_extensions.ptr, .enabled_extension_count = @intCast(config.required_extensions.len), @@ -591,7 +599,11 @@ pub const DeviceHandler = struct { self.pr_dev.destroyDevice(null); self.ctx.allocator.destroy(self.dev_wrapper); - self.swapchain_details.deinit(); + // HACK: Quick fix to get device working without a window + // surface, please replace once proper featuresets are introduced + if (self.swapchain_details) |*sd| { + sd.deinit(); + } } pub fn getMemProperties(self: *const DeviceHandler) vk.PhysicalDeviceMemoryProperties { diff --git a/src/api/buffer.zig b/src/api/buffer.zig index d690d61..544289e 100644 --- a/src/api/buffer.zig +++ b/src/api/buffer.zig @@ -4,7 +4,7 @@ const std = @import("std"); const log = std.log.scoped(.buffer); const meth = @import("../math.zig"); -const util = @import("../util.zig"); +const util = @import("common").util; const CommandBuffer = @import("command_buffer.zig"); const DeviceHandler = @import("base.zig").DeviceHandler; diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index c65592e..f888255 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -2,7 +2,7 @@ const std = @import("std"); const api = @import("api.zig"); const vk = @import("vulkan"); const base = @import("base.zig"); -const util = @import("../util.zig"); +const util = @import("common").util; const queue = @import("queue.zig"); const Context = @import("../context.zig"); diff --git a/src/api/compute.zig b/src/api/compute.zig index cfd252f..d4254a3 100644 --- a/src/api/compute.zig +++ b/src/api/compute.zig @@ -1,7 +1,7 @@ const std = @import("std"); const vk = @import("vulkan"); const api = @import("api.zig"); -const util = @import("../util.zig"); +const util = @import("common").util; const DeviceInterface = api.DeviceInterface; const ShaderModule = api.ShaderModule; diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index aa49b8d..91013e2 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -3,7 +3,7 @@ const std = @import("std"); const vk = @import("vulkan"); -const util = @import("../util.zig"); +const util = @import("common").util; const common = @import("common_types.zig"); const api = @import("api.zig"); diff --git a/src/api/graphics_pipeline.zig b/src/api/graphics_pipeline.zig index 34ff985..05ccd94 100644 --- a/src/api/graphics_pipeline.zig +++ b/src/api/graphics_pipeline.zig @@ -1,7 +1,7 @@ const std = @import("std"); const vk = @import("vulkan"); const base = @import("base.zig"); -const util = @import("../util.zig"); +const util = @import("common").util; const shader = @import("shader.zig"); const Allocator = std.mem.Allocator; diff --git a/src/api/image.zig b/src/api/image.zig index 640f1d0..a589c74 100644 --- a/src/api/image.zig +++ b/src/api/image.zig @@ -3,7 +3,7 @@ const vk = @import("vulkan"); const rsh = @import("rshc"); const buf = @import("buffer.zig"); -const util = @import("../util.zig"); +const util = @import("common").util; const Allocator = std.mem.Allocator; const Context = @import("../context.zig"); diff --git a/src/api/memory/DeviceMemoryLayout.zig b/src/api/memory/DeviceMemoryLayout.zig index 5118551..6b565b4 100644 --- a/src/api/memory/DeviceMemoryLayout.zig +++ b/src/api/memory/DeviceMemoryLayout.zig @@ -1,45 +1,130 @@ const std = @import("std"); const vk = @import("vulkan"); const api = @import("../api.zig"); -const heap = @import("heap.zig"); + +const debug = std.debug; + +const Heap = @import("Heap.zig"); const Context = @import("../../context.zig"); const Layout = @This(); -const HeapMap = heap.HeapMap; -const Heap = HeapMap.Handle; -pub const Env = Context.EnvSubset(.{.dev, .ii}); +//pub const Env = Context.EnvSubset(.{.dev, .ii}); +pub const Env = struct { + dev: *const api.DeviceHandler, + ii: api.InstanceInterface, +}; const DeviceLayoutError = error{ OutOfMemory, + OutOfBounds, +}; + +/// Basic properties of a memory heap... +/// TODO: Extend std's MultiArray to support sparse indexing +const HeapProperties = struct { + max_size: usize, + supported_type_props: vk.MemoryPropertyFlags, }; raw_mem_props: vk.PhysicalDeviceMemoryProperties, // heaps: HeapMap, +// index tables for memory properties +prop_type_index: [vk.MAX_MEMORY_TYPES]vk.MemoryPropertyFlags, +heap_prop_index: [vk.MAX_MEMORY_HEAPS]HeapProperties, +type_heap_index: [vk.MAX_MEMORY_TYPES]u32, + +mem_type_count: usize, +mem_heap_count: usize, + +env: Env, + pub fn init( env: Env, - allocator: std.mem.Allocator, -) DeviceLayoutError!Layout { +) Layout { const dev: *const api.DeviceHandler = env.dev; const ii: api.InstanceInterface = env.ii; const mem_props = ii.getPhysicalDeviceMemoryProperties(dev.h_pdev); - const valid_heaps = mem_props.memory_heaps[0..mem_props.memory_heap_count]; - const valid_types = mem_props.memory_types[0..mem_props.memory_type_count]; + var new_layout = Layout{ + .raw_mem_props = mem_props, - _ = allocator; - _ = valid_types; - _ = valid_heaps; + .prop_type_index = undefined, + .heap_prop_index = undefined, + .type_heap_index = undefined, + + .mem_type_count = mem_props.memory_type_count, + .mem_heap_count = mem_props.memory_heap_count, - return Layout{ - .raw_mem_props = mem_props, - //.heaps = try HeapMap.init(valid_heaps, valid_types, allocator), + .env = env, }; + + for (0.., + &new_layout.prop_type_index, + &new_layout.type_heap_index, + ) |i, *prop, *h| { + prop.* = mem_props.memory_types[i].property_flags; + h.* = mem_props.memory_types[i].heap_index; + } + + for (0.., &new_layout.heap_prop_index) |i, *prop| { + prop.* = HeapProperties{ + .max_size = mem_props.memory_heaps[i].size, + .supported_type_props = undefined, + }; + } + + return new_layout; } +pub fn getBasicHeapProps(layout: *const Layout, heap: u32) ?HeapProperties { + if (heap > vk.MAX_MEMORY_HEAPS) return null; + return layout.heap_prop_index[heap]; +} + + +pub fn compatibleTypeInHeap( + layout: *const Layout, + heap: u32, + props: vk.MemoryPropertyFlags +) ?u32 { + for (0..layout.mem_type_count) |t| { + if (layout.type_heap_index[t] != heap) continue; + const type_props = layout.prop_type_index[t]; + + if (type_props.contains(props)) return t; + } + + return null; +} + +pub fn findSupportingHeap( + layout: *const Layout, + props: vk.MemoryPropertyFlags +) ?u32 { + for (0..layout.mem_heap_count) |h| { + const heap_props = layout.heap_prop_index[h].supported_type_props; + if (heap_props.contains(props)) return @intCast(h); + } + + return null; +} + +/// You now own the heap as it is an active view of the +/// device's memory as opposed to a passive overview such as this +pub fn acquireHeap(layout: *Layout, index: u32) Heap { + debug.assert(index < layout.mem_heap_count); + + return Heap.init(.{ + .mem_layout = layout, + .di = &layout.env.dev.pr_dev, //TODO: Rename pr_dev as di + }, index); +} + + //pub fn heapSupportsType( // self: *const Layout, // heap: Heap, diff --git a/src/api/memory/allocator.zig b/src/api/memory/allocator.zig index 2ffa92e..42bc655 100644 --- a/src/api/memory/allocator.zig +++ b/src/api/memory/allocator.zig @@ -111,6 +111,8 @@ pub const AllocationConfig = packed struct { /// Relevant allocation is promised but may not actually be allocated until /// the allocation is first accessed + /// NOTE: Uuuhhh, I gotta make sure this actually guaruntees a valid memory allocation + /// when its needed lazy: bool = false, /// Force the allocator to perform a dedicated @@ -159,19 +161,18 @@ pub const AllocationConfig = packed struct { /// This tends to ignore certain information /// in order to generate concrete allocation parameters so further config processing is /// usually done by the configurable allocator beforehand to resolve which allocator to use + /// This is moreso "stage 2" resolution as defined in the spec pub fn flatten(self: *const AllocationConfig) Resolved { _ = self; return undefined; } }; -const Allocation = struct { - Fuck: u32, -}; +const Allocation = common.Handle(AllocationData, .{ + .partition_bit = 12, +}); -const ReifiedAllocation = struct { - Me: u32, -}; +const ReifiedAllocation = Allocation.Reified; /// Manages top-level handles to instantiated /// heap allocations for all included memory types @@ -232,6 +233,11 @@ pub const VirtualAllocator = struct { return undefined; } + + pub fn free(self: *VirtualAllocator, mem: Allocation) void { + _ = self; + _ = mem; + } }; // Vulkan Memory Types and Heaps: diff --git a/src/api/memory/heap.zig b/src/api/memory/heap.zig index 9fe86af..3d0d1e8 100644 --- a/src/api/memory/heap.zig +++ b/src/api/memory/heap.zig @@ -8,10 +8,11 @@ //! to prevent unnecesary duplication. const common = @import("common"); +const util = common.util; const vk = @import("vulkan"); const std = @import("std"); -const debut = std.debug; +const debug = std.debug; const Heap = @This(); @@ -32,22 +33,21 @@ available_budget: usize, /// the vulkan extension, or in absence, using a heuristic /// based on the total memory of said heap. fn calcAvailableBudget(env: Env, heap_index: u32) usize { - const props = env.mem_layout.getBasicHeapProps(heap_index); - - // calculates a percentage of an integer value - return common.pct(props.heapSizeBytes(), 75); + const props = env.mem_layout.getBasicHeapProps(heap_index) orelse + return 0; + return util.pct(props.max_size, 75); } pub fn init(env: Env, heap_index: u32) Heap { // figure out how much memory we can allocate return Heap { - .env = env, - .index = heap_index, + .env = env, + .index = heap_index, .available_budget = calcAvailableBudget(env, heap_index), }; } -fn matchesMask(bit: u32, mask: u32) bool { +inline fn matchesMask(bit: u32, mask: u32) bool { return mask & (@as(u32, 1) << bit) != 0; } @@ -58,21 +58,21 @@ pub fn alloc( ) Error!vk.DeviceMemory { debug.assert(mem_type < vk.MAX_MEMORY_TYPES); debug.assert(matchesMask(mem_type, reqs.memory_type_bits)); + util.assertMsg(reqs.size >= util.megabytes(16), + "Due to GPU memory restrictions, small dedicated allocations must use \"allocSmall\"", + ); return heap.env.di.allocateMemory(&.{ - .allocation_size = mem_reqs.size, + .allocation_size = reqs.size, .memory_type_index = mem_type, }, null); } pub fn allocWithProps( heap: *Heap, - props: vk.MemoryProperties, + props: vk.MemoryPropertyFlags, reqs: vk.MemoryRequirements, ) Error!vk.DeviceMemory { - if (!heap.env.mem_layout.heapSupports(heap.index, props)) - return error.IncompatibleProperties; - const mem_type = heap.env.mem_layout.compatibleTypeInHeap(heap.index, props) orelse return error.IncompatibleProperties; @@ -82,3 +82,46 @@ pub fn allocWithProps( pub fn free(heap: *Heap, mem: vk.DeviceMemory) void { heap.env.di.freeMemory(mem, null); } + + +// Comptime-invoked so that +// optional features can be enabled +// given required extensions are present. +// TODO: Feature sets n stuff +//pub fn requestExtensions(fs: FeatureSet) []const ?[:0]const u8 { +// return &.{ +// fs.ifEnabled("VK_EXT_memory_budget", .AccurateHeapReadouts), +// }; +//} + +const testing = std.testing; + +const ray = @import("../../root.zig"); +const TestingContext = ray.testing.MinimalVulkanContext; + +test "raw heap allocations" { + const testing_props = vk.MemoryPropertyFlags{ + .host_visible_bit = true, + .host_coherent_bit = true, + }; + var minimal_vulkan = try TestingContext.initMinimalVulkan(testing.allocator, .{ + .noscreen = true, + }); + defer minimal_vulkan.deinit(testing.allocator); + + const test_heap_index = minimal_vulkan.mem_layout.findSupportingHeap( + testing_props, + ) orelse return error.NoMatchingHeap; + + var heap = minimal_vulkan.mem_layout.acquireHeap(test_heap_index); + + // Raw map memory for a write/read cycle + const mem_handle = try heap.allocWithProps(testing_props, .{ + }); + + const mem = try minimal_vulkan.di.mapMemory(mem_handle); + mem.* = "100 bottles of beer on the wall"; + + try minimal_vulkan.di.unmapMemory(mem_handle); + // If it doesn't segfault or yield validation errors, then it worked. +} diff --git a/src/api/queue.zig b/src/api/queue.zig index 5bfadfc..6b0f17d 100644 --- a/src/api/queue.zig +++ b/src/api/queue.zig @@ -1,6 +1,6 @@ const std = @import("std"); const vk = @import("vulkan"); -const util = @import("../util.zig"); +const util = @import("common").util; const Context = @import("../context.zig"); diff --git a/src/api/renderpass.zig b/src/api/renderpass.zig index 13cbfe1..ceea771 100644 --- a/src/api/renderpass.zig +++ b/src/api/renderpass.zig @@ -1,7 +1,7 @@ const std = @import("std"); const vk = @import("vulkan"); const base = @import("base.zig"); -const util = @import("../util.zig"); +const util = @import("common").util; const Context = @import("../context.zig"); const DeviceHandler = base.DeviceHandler; diff --git a/src/api/swapchain.zig b/src/api/swapchain.zig index 6ee0fdc..7fbffed 100644 --- a/src/api/swapchain.zig +++ b/src/api/swapchain.zig @@ -1,6 +1,6 @@ const std = @import("std"); const vk = @import("vulkan"); -const util = @import("../util.zig"); +const util = @import("common").util; const base = @import("base.zig"); const Context = @import("../context.zig"); @@ -142,14 +142,17 @@ pub fn init( allocator: Allocator, config: Config, ) !Self { - // TODO: Swapchain support details should probably lie within the Surface type - // instead of the device since these details mostly concern properties of the chosen - // draw surface. + // The swapchain should NEVER be initialized + // without surface support, though this implementation + // is a bit spaghetti const device: *const DeviceHandler = ctx.env(.dev); const pr_dev: *const vk.DeviceProxy = ctx.env(.di); const surface: *const SurfaceHandler = ctx.env(.surf); - const details: *const DeviceHandler.SwapchainSupportDetails = &device.swapchain_details; + if (device.swapchain_details == null) + @panic("Cannot initialize swapchain without surface support"); + + const details: *const DeviceHandler.SwapchainSupportDetails = &device.swapchain_details.?; // request an appropriate number of swapchain images var image_count: u32 = details.capabilities.min_image_count + 1; diff --git a/src/api/vertex_buffer.zig b/src/api/vertex_buffer.zig index 02ad17f..835c77c 100644 --- a/src/api/vertex_buffer.zig +++ b/src/api/vertex_buffer.zig @@ -5,7 +5,7 @@ const StructInfo = TypeInfo.Struct; const vk = @import("vulkan"); const meth = @import("../math.zig"); -const util = @import("../util.zig"); +const util = @import("common").util; const buf = @import("buffer.zig"); const Layout = union(enum) { diff --git a/src/common/util.zig b/src/common/util.zig index df2ad0b..75d502c 100644 --- a/src/common/util.zig +++ b/src/common/util.zig @@ -2,6 +2,7 @@ //! Most of this is completely unused and useless, so //! only a bit of this iwll be included... const std = @import("std"); +const builtin = @import("builtin"); pub fn asCString(rep: anytype) [*:0]const u8 { return @as([*:0]const u8, @ptrCast(rep)); } @@ -45,6 +46,65 @@ pub fn tryGetField(info: *const StructInfo, name: []const u8) ?*const StructFiel return null; } +/// returns the percentage of a number +/// should work for all numeric types +pub fn pct(num: anytype, percentage: @TypeOf(num)) @TypeOf(num) { + return @divTrunc(num * percentage, 100); +} + + +const BasicMemUnits = enum(usize) { + Bytes, + Kilobytes, + Megabytes, + Gigabytes, +}; + + +/// Obviously, val should be numerical, but should +/// otherwise work with integral and floating points, +/// illegal divisions notwithstanding. +pub inline fn transformMemUnits( + comptime from: BasicMemUnits, + comptime to: BasicMemUnits, + val: anytype +) @TypeOf(val) { + const info = @typeInfo(@TypeOf(val)); + const num, const denom = comptime blk: { + var a = 1; + var b = 1; + + for (0..@intFromEnum(to)) |_| { + a *= 1024; + } + for (0..@intFromEnum(from)) |_| { + b *= 1024; + } + + break :blk .{a, b}; + }; + if (info == .int) { + return @divFloor(num, denom) * val; + } else { + const fnum: @TypeOf(val) = @floatFromInt(num); + const fden: @TypeOf(val) = @floatFromInt(denom); + return (fnum / fden) * val; + } +} + + +pub inline fn megabytes(val: anytype) @TypeOf(val) { + return transformMemUnits(.Megabytes, .Bytes, val); +} + +pub inline fn assertMsg(ok: bool, comptime msg: []const u8) void { + if (builtin.mode == .Debug or builtin.mode == .ReleaseSafe) { + if (!ok) { + @panic("Assertion failed: " ++ msg); + } + } +} + pub fn signatureMatches(a: *const Function, b: *const Function) bool { if (a.params.len != b.params.len) return false; for (a.params, b.params) |p1, p2| diff --git a/src/context.zig b/src/context.zig index fca2a59..3134062 100644 --- a/src/context.zig +++ b/src/context.zig @@ -49,9 +49,9 @@ inst: Instance, dev: Device, surf: Surface, -global_interface: *const GlobalInterface, -inst_interface: *const InstanceInterface, -dev_interface: *const DeviceInterface, +global_interface: GlobalInterface, +inst_interface: InstanceInterface, +dev_interface: DeviceInterface, graphics_queue: api.GraphicsQueue, present_queue: api.PresentQueue, @@ -151,7 +151,7 @@ pub fn init(allocator: Allocator, config: Config) !*Self { // Later on, I'll have some better ways to handle ownership and lifetimes // then just raw heap allocations lol (Working on it) - new.inst = try Instance.init(&.{ + new.inst = try Instance.init(.{ .instance = .{ .required_extensions = all_inst_ext.items, .validation_layers = &.{ @@ -159,9 +159,7 @@ pub fn init(allocator: Allocator, config: Config) !*Self { }, }, .allocator = allocator, - .device = undefined, .enable_debug_log = true, - .loader = config.loader, }); errdefer new.inst.deinit(); diff --git a/src/env.zig b/src/env.zig index 232414e..f1a6dea 100644 --- a/src/env.zig +++ b/src/env.zig @@ -7,12 +7,18 @@ const RefConfig = struct { field: ?[]const u8 = null, mutable: bool = false, }; + +fn ResolveInnerType(comptime T: type, comptime config: RefConfig) type { + const AsPtr = if (!config.mutable) *const T else *T; + + return if (@typeInfo(T) == .pointer) T else AsPtr; +} /// returns a const non-owning pointer to the object /// (might enforce a bit more memory safety here later) pub fn Ref(comptime T: type, comptime config: RefConfig) type { return struct { pub const field = config.field; - pub const InnerType = if (!config.mutable) *const T else *T; + pub const InnerType = ResolveInnerType(T, config); const Self = @This(); inner: InnerType, diff --git a/src/glfw.zig b/src/glfw.zig index 6325bee..cc58519 100644 --- a/src/glfw.zig +++ b/src/glfw.zig @@ -35,8 +35,10 @@ fn ErrorOnFalse(comptime func: fn () callconv(.c) c_int, comptime err: anytype) return wrapperType.wrapper; } -pub extern fn glfwGetInstanceProcAddress(instance: vk.Instance, name: [*:0]const u8) vk.PfnVoidFunction; -pub extern fn glfwCreateWindowSurface(instance: vk.Instance, window: *GLFWwindow, allocation_callbacks: ?*const vk.AllocationCallbacks, surface: *vk.SurfaceKHR) vk.Result; +extern fn glfwGetInstanceProcAddress(instance: vk.Instance, name: [*:0]const u8) vk.PfnVoidFunction; +extern fn glfwCreateWindowSurface(instance: vk.Instance, window: *GLFWwindow, allocation_callbacks: ?*const vk.AllocationCallbacks, surface: *vk.SurfaceKHR) vk.Result; + +pub const getInstanceProcAddress = glfwGetInstanceProcAddress; pub const init = ErrorOnFalse(c.glfwInit, error.GLFWInitFailed); pub const terminate = c.glfwTerminate; diff --git a/src/root.zig b/src/root.zig index d6acf99..2a76e92 100644 --- a/src/root.zig +++ b/src/root.zig @@ -8,11 +8,12 @@ pub const math = @import("math.zig"); //TODO: replace the shitty utils with common pub const common = @import("common"); -pub const util = @import("util.zig"); // Resource manager NOTE: (not sure if this should be exported tbh) pub const res = @import("resource_management/res.zig"); +pub const testing = @import("tests/testing.zig"); + // imports for testing comptime { _ = @import("resource_management/registry.zig"); diff --git a/src/tests/testing.zig b/src/tests/testing.zig new file mode 100644 index 0000000..e823885 --- /dev/null +++ b/src/tests/testing.zig @@ -0,0 +1,92 @@ +//! These testing utilities are intended to be used soley for testing blocks +//! and will cause a compilation error if imported outside of a testing binary. + +comptime { + const builtin = @import("builtin"); + if (!builtin.is_test) + @compileError("DO NOT USE THIS MODULE OUTSIDE TESTING BRUH"); +} + +const std = @import("std"); +const api = @import("../api/api.zig"); +const glfw = @import("glfw"); + +pub const MinimalVulkanContext = struct { + const Config = struct { + noscreen: bool = false, + }; + + dev: api.DeviceHandler, + inst: api.InstanceHandler, + + di: api.DeviceInterface, + ii: api.InstanceInterface, + gi: api.GlobalInterface, + + mem_layout: api.DeviceMemoryLayout, + /// Creates an extremely stripped-down minimal + /// vulkan context without most of the core rendering utilities. + /// Do not use for normal rendering. + pub fn initMinimalVulkan( + allocator: std.mem.Allocator, + config: Config, + ) !*MinimalVulkanContext { + const new_ctx = try allocator.create(MinimalVulkanContext); + + const min_inst_ext = [_][*:0]const u8{ + api.extensions.khr_get_physical_device_properties_2.name, + api.extensions.ext_debug_utils.name, + api.extensions.khr_surface.name, + }; + + const min_dev_ext = [_][*:0]const u8{ + api.extensions.khr_swapchain.name, + }; + + + new_ctx.inst = try api.InstanceHandler.init(.{ + .instance = .{ + .required_extensions = min_inst_ext[0..], + .validation_layers = &.{ + "VK_LAYER_KHRONOS_validation", + }, + }, + .allocator = allocator, + .enable_debug_log = true, + .loader = glfw.getInstanceProcAddress, + }); + errdefer new_ctx.inst.deinit(); + + new_ctx.dev = try api.DeviceHandler.init(&new_ctx.inst, .{ + .required_extensions = min_dev_ext[0..], + .surface = null, + }); + + new_ctx.gi = &new_ctx.inst.w_db; + new_ctx.ii = &new_ctx.inst.pr_inst; + new_ctx.di = &new_ctx.dev.pr_dev; + + new_ctx.mem_layout = api.DeviceMemoryLayout.init(.{ + .dev = &new_ctx.dev, + .ii = new_ctx.ii, + }); + + _ = config; + + return new_ctx; + } + + /// Allocator should be the same allocator used to initialize + /// the structure + pub fn deinit( + ctx: *MinimalVulkanContext, + allocator: std.mem.Allocator + ) void { + ctx.dev.deinit(); + ctx.inst.deinit(); + + allocator.destroy(ctx); + } +}; + + diff --git a/src/util.zig b/src/util.zig deleted file mode 100644 index 269a051..0000000 --- a/src/util.zig +++ /dev/null @@ -1,55 +0,0 @@ -//! TODO: Merge this into the common directory -//! Most of this is completely unused and useless, so -//! only a bit of this iwll be included... -const std = @import("std"); -pub fn asCString(rep: anytype) [*:0]const u8 { - return @as([*:0]const u8, @ptrCast(rep)); -} - -pub fn emptySlice(comptime T: type) []T { - return &[0]T{}; -} - -//FIXME: This is due for a BIG REFACTOR COMING SOON -// (because it is much worse than just &.{} which I Didn't know was a thing oops. -pub fn asManyPtr(comptime T: type, ptr: *const T) [*]const T { - return @as([*]const T, @ptrCast(ptr)); -} - -//FIXME: This is due for a BIG REFACTOR COMING SOON -// (because it is much worse than just &.{} which I Didn't know was a thing oops. -// funilly enough, &.{1, 2, 3} is shorter than span(.{1, 2, 3}). I just don't -// like reading docs + idk how. -pub fn span(v: anytype) [] @TypeOf(v[0]) { - const T = @TypeOf(v[0]); - comptime var sp: [v.len] T = undefined; - for (v, 0..) |val, index| { - sp[index] = val; - } - - return sp[0..]; -} - -const StructInfo = std.builtin.Type.Struct; -const StructField = std.builtin.Type.StructField; -const Function = std.builtin.Type.Fn; - -// Reflection Stuff -pub fn tryGetField(info: *const StructInfo, name: []const u8) ?*StructField { - for (info.fields) |*fld| { - if (std.mem.eql(u8, fld.name, name) == .eq) { - return fld; - } - } - - return null; -} - -pub fn signatureMatches(a: *const Function, b: *const Function) bool { - if (a.params.len != b.params.len) return false; - for (a.params, b.params) |p1, p2| - if (p1.type != p2.type) return false; - - if (!a.calling_convention.eql(b)) return false; - return true; -} From 2314af51093e508a2d6df0b5fb6fe631840661fa Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 12 Sep 2025 23:17:32 -0700 Subject: [PATCH 29/46] fix (heap): at least it compiles now... Actually working is tommorw's problem --- src/api/memory/DeviceMemoryLayout.zig | 2 +- src/api/memory/heap.zig | 26 +++++++++++++++------- src/common/util.zig | 31 ++++++++++++++------------- 3 files changed, 35 insertions(+), 24 deletions(-) diff --git a/src/api/memory/DeviceMemoryLayout.zig b/src/api/memory/DeviceMemoryLayout.zig index 6b565b4..9509e36 100644 --- a/src/api/memory/DeviceMemoryLayout.zig +++ b/src/api/memory/DeviceMemoryLayout.zig @@ -95,7 +95,7 @@ pub fn compatibleTypeInHeap( if (layout.type_heap_index[t] != heap) continue; const type_props = layout.prop_type_index[t]; - if (type_props.contains(props)) return t; + if (type_props.contains(props)) return @intCast(t); } return null; diff --git a/src/api/memory/heap.zig b/src/api/memory/heap.zig index 3d0d1e8..5fabf20 100644 --- a/src/api/memory/heap.zig +++ b/src/api/memory/heap.zig @@ -21,8 +21,12 @@ const Context = @import("../../context.zig"); pub const Env = Context.EnvSubset(.{.mem_layout, .di}); pub const Error = error { - DeviceOutOfMemory, IncompatibleProperties, + OutOfHostMemory, + OutOfDeviceMemory, + Unknown, + InvalidExternalHandle, + InvalidOpaqueCaptureAddressKHR, }; env: Env, @@ -48,7 +52,7 @@ pub fn init(env: Env, heap_index: u32) Heap { } inline fn matchesMask(bit: u32, mask: u32) bool { - return mask & (@as(u32, 1) << bit) != 0; + return mask & (@as(u32, 1) << @intCast(bit)) != 0; } pub fn alloc( @@ -58,7 +62,8 @@ pub fn alloc( ) Error!vk.DeviceMemory { debug.assert(mem_type < vk.MAX_MEMORY_TYPES); debug.assert(matchesMask(mem_type, reqs.memory_type_bits)); - util.assertMsg(reqs.size >= util.megabytes(16), + + util.assertMsg(reqs.size >= util.megabytes(@as(vk.DeviceSize, 16)), "Due to GPU memory restrictions, small dedicated allocations must use \"allocSmall\"", ); @@ -74,9 +79,9 @@ pub fn allocWithProps( reqs: vk.MemoryRequirements, ) Error!vk.DeviceMemory { const mem_type = heap.env.mem_layout.compatibleTypeInHeap(heap.index, props) orelse - return error.IncompatibleProperties; + return error.IncompatibleProperties; - return heap.alloc(mem_type, reqs); + return heap.alloc(mem_type, reqs); } pub fn free(heap: *Heap, mem: vk.DeviceMemory) void { @@ -115,13 +120,18 @@ test "raw heap allocations" { var heap = minimal_vulkan.mem_layout.acquireHeap(test_heap_index); + // Raw map memory for a write/read cycle const mem_handle = try heap.allocWithProps(testing_props, .{ + .size = 128, + .alignment = 4, + .memory_type_bits = 0, }); + _ = mem_handle; - const mem = try minimal_vulkan.di.mapMemory(mem_handle); - mem.* = "100 bottles of beer on the wall"; + //const mem = try minimal_vulkan.di.mapMemory(mem_handle); + //mem.* = "100 bottles of beer on the wall"; - try minimal_vulkan.di.unmapMemory(mem_handle); + //try minimal_vulkan.di.unmapMemory(mem_handle); // If it doesn't segfault or yield validation errors, then it worked. } diff --git a/src/common/util.zig b/src/common/util.zig index 75d502c..8c127aa 100644 --- a/src/common/util.zig +++ b/src/common/util.zig @@ -69,25 +69,26 @@ pub inline fn transformMemUnits( comptime to: BasicMemUnits, val: anytype ) @TypeOf(val) { - const info = @typeInfo(@TypeOf(val)); - const num, const denom = comptime blk: { - var a = 1; - var b = 1; + const ValueType = @TypeOf(val); + const info = @typeInfo(ValueType); + + var a: ValueType = 1; + var b: ValueType = 1; + + for (0..@intFromEnum(to)) |_| { + a *= 1024; + } + for (1..@intFromEnum(from)) |_| { + b *= 1024; + } - for (0..@intFromEnum(to)) |_| { - a *= 1024; - } - for (0..@intFromEnum(from)) |_| { - b *= 1024; - } - break :blk .{a, b}; - }; if (info == .int) { - return @divFloor(num, denom) * val; + return @divFloor(a, b) * val; } else { - const fnum: @TypeOf(val) = @floatFromInt(num); - const fden: @TypeOf(val) = @floatFromInt(denom); + const fnum: ValueType = @floatFromInt(a); + const fden: ValueType = @floatFromInt(b); + return (fnum / fden) * val; } } From f957cf3ce1c660e1998806b1883a5ac734515964 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 13 Sep 2025 11:46:23 -0700 Subject: [PATCH 30/46] fix(heap): Fixed heap identification based on supported memory types and passed basic raw allocation test --- src/api/base.zig | 3 +- src/api/descriptor.zig | 2 +- src/api/memory/DeviceMemoryLayout.zig | 8 +++--- src/api/memory/allocator.zig | 7 ----- src/api/memory/heap.zig | 41 +++++++++++++++++++-------- src/glfw.zig | 2 +- src/tests/testing.zig | 4 +++ 7 files changed, 40 insertions(+), 27 deletions(-) diff --git a/src/api/base.zig b/src/api/base.zig index dce8259..0d9e94e 100644 --- a/src/api/base.zig +++ b/src/api/base.zig @@ -95,8 +95,6 @@ pub const InstanceHandler = struct { } fn createInstance(self: *InstanceHandler, config: Config) !void { - - // log the available extensions const available = self.w_db.enumerateInstanceExtensionPropertiesAlloc( null, config.allocator, @@ -104,6 +102,7 @@ pub const InstanceHandler = struct { log.debug("Failed to enumerate extension properties... this is probably bad.\n", .{}); return error.ExtensionEnumerationFailed; }; + defer config.allocator.free(available); log.debug("Available Extensions:", .{}); diff --git a/src/api/descriptor.zig b/src/api/descriptor.zig index 91013e2..c02b0bc 100644 --- a/src/api/descriptor.zig +++ b/src/api/descriptor.zig @@ -1,6 +1,7 @@ //! A pretty temporary implementation for //! basic descriptor management in vulkan, manages it's own pool for now const std = @import("std"); +const debug = std.debug; const vk = @import("vulkan"); const util = @import("common").util; @@ -255,7 +256,6 @@ const DescriptorBinding = union(DescriptorType) { }, }; -const debug = std.debug; // Descriptor layouts done better pub const DescriptorLayout = struct { diff --git a/src/api/memory/DeviceMemoryLayout.zig b/src/api/memory/DeviceMemoryLayout.zig index 9509e36..42e11d4 100644 --- a/src/api/memory/DeviceMemoryLayout.zig +++ b/src/api/memory/DeviceMemoryLayout.zig @@ -68,13 +68,13 @@ pub fn init( ) |i, *prop, *h| { prop.* = mem_props.memory_types[i].property_flags; h.* = mem_props.memory_types[i].heap_index; + + const heap_props = &new_layout.heap_prop_index[h.*].supported_type_props; + heap_props.* = heap_props.merge(prop.*); } for (0.., &new_layout.heap_prop_index) |i, *prop| { - prop.* = HeapProperties{ - .max_size = mem_props.memory_heaps[i].size, - .supported_type_props = undefined, - }; + prop.max_size = mem_props.memory_heaps[i].size; } return new_layout; diff --git a/src/api/memory/allocator.zig b/src/api/memory/allocator.zig index 42bc655..51789d5 100644 --- a/src/api/memory/allocator.zig +++ b/src/api/memory/allocator.zig @@ -286,10 +286,3 @@ pub const VirtualAllocator = struct { // } const debug = std.debug; - -test "compiles" { - const thing = @typeInfo(VirtualAllocator); - inline for (thing.@"struct".fields) |fld| { - std.debug.print("Field: {s}\n", .{fld.name}); - } -} diff --git a/src/api/memory/heap.zig b/src/api/memory/heap.zig index 5fabf20..3587c46 100644 --- a/src/api/memory/heap.zig +++ b/src/api/memory/heap.zig @@ -29,6 +29,15 @@ pub const Error = error { InvalidOpaqueCaptureAddressKHR, }; +/// Since memory type bits are a pain to set manually, +/// I'll try to keep that automated as much as I can, +/// hence the need for this equivalent struct with defualt values +pub const MemoryRequirements = struct { + size: vk.DeviceSize, + alignment: vk.DeviceSize, + memory_type_bits: ?u32 = null, +}; + env: Env, index: u32, available_budget: usize, @@ -58,17 +67,22 @@ inline fn matchesMask(bit: u32, mask: u32) bool { pub fn alloc( heap: *Heap, mem_type: u32, - reqs: vk.MemoryRequirements, + reqs: MemoryRequirements, ) Error!vk.DeviceMemory { + var resolved_reqs = reqs; + if (resolved_reqs.memory_type_bits == null) { + resolved_reqs.memory_type_bits = @as(u32, 1) << @as(u5, @intCast(mem_type)); + } + debug.assert(mem_type < vk.MAX_MEMORY_TYPES); - debug.assert(matchesMask(mem_type, reqs.memory_type_bits)); + debug.assert(matchesMask(mem_type, resolved_reqs.memory_type_bits.?)); - util.assertMsg(reqs.size >= util.megabytes(@as(vk.DeviceSize, 16)), + util.assertMsg(resolved_reqs.size >= util.megabytes(@as(vk.DeviceSize, 16)), "Due to GPU memory restrictions, small dedicated allocations must use \"allocSmall\"", ); return heap.env.di.allocateMemory(&.{ - .allocation_size = reqs.size, + .allocation_size = resolved_reqs.size, .memory_type_index = mem_type, }, null); } @@ -76,7 +90,7 @@ pub fn alloc( pub fn allocWithProps( heap: *Heap, props: vk.MemoryPropertyFlags, - reqs: vk.MemoryRequirements, + reqs: MemoryRequirements, ) Error!vk.DeviceMemory { const mem_type = heap.env.mem_layout.compatibleTypeInHeap(heap.index, props) orelse return error.IncompatibleProperties; @@ -124,14 +138,17 @@ test "raw heap allocations" { // Raw map memory for a write/read cycle const mem_handle = try heap.allocWithProps(testing_props, .{ .size = 128, - .alignment = 4, - .memory_type_bits = 0, + .alignment = 1, }); - _ = mem_handle; - //const mem = try minimal_vulkan.di.mapMemory(mem_handle); - //mem.* = "100 bottles of beer on the wall"; + const mem = @as( + [*]u8, + @ptrCast(@alignCast( + try minimal_vulkan.di.mapMemory(mem_handle, 0, 128, .{}) + )), + )[0..128]; + + std.mem.copyForwards(u8, mem, "100 bottles of beer on the wall"); - //try minimal_vulkan.di.unmapMemory(mem_handle); - // If it doesn't segfault or yield validation errors, then it worked. + minimal_vulkan.di.unmapMemory(mem_handle); } diff --git a/src/glfw.zig b/src/glfw.zig index cc58519..f07eba3 100644 --- a/src/glfw.zig +++ b/src/glfw.zig @@ -41,7 +41,7 @@ extern fn glfwCreateWindowSurface(instance: vk.Instance, window: *GLFWwindow, al pub const getInstanceProcAddress = glfwGetInstanceProcAddress; pub const init = ErrorOnFalse(c.glfwInit, error.GLFWInitFailed); -pub const terminate = c.glfwTerminate; +pub const deinit = c.glfwTerminate; pub const vulkanSupported = ErrorOnFalse(c.glfwVulkanSupported, error.VulkanUnsupported); pub const getRequiredInstanceExtensions = c.glfwGetRequiredInstanceExtensions; pub const getFramebufferSize = c.glfwGetFramebufferSize; diff --git a/src/tests/testing.zig b/src/tests/testing.zig index e823885..5e131ab 100644 --- a/src/tests/testing.zig +++ b/src/tests/testing.zig @@ -33,6 +33,8 @@ pub const MinimalVulkanContext = struct { ) !*MinimalVulkanContext { const new_ctx = try allocator.create(MinimalVulkanContext); + try glfw.init(); + const min_inst_ext = [_][*:0]const u8{ api.extensions.khr_get_physical_device_properties_2.name, api.extensions.ext_debug_utils.name, @@ -86,6 +88,8 @@ pub const MinimalVulkanContext = struct { ctx.inst.deinit(); allocator.destroy(ctx); + + glfw.deinit(); } }; From 89aa72505854dca97e51f522c37d5d7e2d3178d9 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 13 Sep 2025 12:15:08 -0700 Subject: [PATCH 31/46] fix(heap): properly freed allocated device memory in test --- src/api/base.zig | 8 ++++---- src/api/memory/heap.zig | 2 ++ 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/api/base.zig b/src/api/base.zig index 0d9e94e..fe440fa 100644 --- a/src/api/base.zig +++ b/src/api/base.zig @@ -26,8 +26,8 @@ fn debugCallback( p_user_data: ?*anyopaque, ) callconv(.c) vk.Bool32 { const callback_data = p_callback_data orelse { - validation_log.err( - "Something probably bad happened but vulkan won't fucking give me the info", + std.debug.print( + "Something probably bad happened but vulkan won't fucking give me the info\n", .{}, ); return vk.FALSE; @@ -37,8 +37,8 @@ fn debugCallback( // That way, logging levels will work for vulkan validation as well.. const msg_level = message_severity.toInt(); - validation_log.debug( - "{d} -- {s}", + std.debug.print( + "{d} -- {s}\n", .{ msg_level, callback_data.p_message orelse "Fuck" }, ); diff --git a/src/api/memory/heap.zig b/src/api/memory/heap.zig index 3587c46..4c77850 100644 --- a/src/api/memory/heap.zig +++ b/src/api/memory/heap.zig @@ -140,6 +140,8 @@ test "raw heap allocations" { .size = 128, .alignment = 1, }); + defer heap.free(mem_handle); + const mem = @as( [*]u8, From 4119fd66edb7592d4013881d5738e1ad0aa7b986 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 14 Sep 2025 09:20:11 -0700 Subject: [PATCH 32/46] feat(vulkan): blocked out a design for device memory pools although this may need some further thought --- src/api/memory/VulkanPool.zig | 95 +++++++++++++++++++++++++++++++++++ src/api/memory/allocation.zig | 27 ++++++++++ src/api/memory/allocator.zig | 58 +++++++++++---------- 3 files changed, 154 insertions(+), 26 deletions(-) create mode 100644 src/api/memory/VulkanPool.zig create mode 100644 src/api/memory/allocation.zig diff --git a/src/api/memory/VulkanPool.zig b/src/api/memory/VulkanPool.zig new file mode 100644 index 0000000..d562611 --- /dev/null +++ b/src/api/memory/VulkanPool.zig @@ -0,0 +1,95 @@ +//! A pool represents a logical view into memory, and can be generated from any valid allocation. +//! Contains metadata about the allocation it references (and unlike allocations, this persists +//! even when not in debug mode) along with a list of host-allocated control blocks +//! for bookkeeping information regarding the memory allocation. + +const common = @import("common"); +const std = @import("std"); + +const allocation = @import("allocation.zig"); + +const AllocationData = allocation.AllocationData; +const Allocation = allocation.Allocation; +const ReifiedAllocation = allocation.ReifiedAllocation; + +const ControlBlockTable = std.AutoHashMap(common.TypeId, ControlBlockHeader); +const AllocationTable = common.ObjectPool(AllocationData, .{}); + +const prealloc_size: usize = 64; +const SrcAllocationList = std.SegmentedList(ReifiedAllocaiton, prealloc_size); + +const Pool = @This(); + + +const Error = error { + OutOfMemory, +}; + +const ControlBlockHeader = struct { + algorithm_type: common.TypeId, + p_control: *anyopaque, +}; + +// arraylists don't play nice with arenas +control_blocks: ControlBlockTable, +control_arena: std.heap.ArenaAllocator, + +// TODO: should be able to specify handles in the args +// since just guessing here is a pain +// (luckily the partition bit works out in this case) +allocation_table: AllocationTable, +src_allocations: SrcAllocationList, + +type_index: u32, + +pub fn init(allocation: ReifiedAllocation, host_allocator: std.mem.Allocator) Error!Pool { + var arena = std.heap.ArenaAllocator.init(host_allocator), + errdefer arena.deinit(); + + var src_allocations = SrcAllocationList{}; + errdefer src_allocations.deinit(); + + var control_blocks = try ControlBlockTable.init(host_allocator); + errdefer control_blocks.deinit(); + + const type_index = allocation.get().meta.type_index; + + (src_allocations.addOne() catch unreachable).* = allocation; + return Pool{ + .control_blocks = control_blocks, + .control_arena = arena, + .type_index = type_index, + + .src_allocations = src_allocations, + .allocation_table = try AllocationTable.initPreheated( + arena.allocator(), + 512, + ), + }; +} + +/// Technically, we could just get away with updating bookeeping information ad hoc +/// since allocations are just offsets into a memory blob. +pub fn extend(pool: *Pool, new_allocation: ReifiedAllocation) Error!Pool { + +} + +/// Most allocation algorithms will just call this when binding a memory pool +/// This can also allocate new control blocks if a new algorithm is used +/// Expects the type to have a control block nested as a declaration +pub fn getControlBlock( + pool: *Pool, + comptime AlgorithmType: type, + inst: *const AlgorithmType +) Error!*AlgorithmType { + if (!std.meta.hasDecl(AlgorithmType, "ControlType")) + @compileError("AlgorithmType must have ControlType decl to manage bookkeeping"); + const ControlBlock = AlgorithmType.ControlBlock; + + +} + +pub fn deinit(pool: *Pool) void { +} + +// This is the class you want to access private form shit diff --git a/src/api/memory/allocation.zig b/src/api/memory/allocation.zig new file mode 100644 index 0000000..abff602 --- /dev/null +++ b/src/api/memory/allocation.zig @@ -0,0 +1,27 @@ +const vk = @import("vulkan"); +/// Represents an individual memory allocation.. +/// Depending on the allocated memory's properties, +/// Accessing the memory might require creating a staging buffer +/// or flushing and invalidating cached host-mapped memory +/// +/// Probably should handleify this, to make allocations more resistant +/// to changes in location and such + + +pub const DeviceMemoryRange = struct { + offset: usize, + size: usize, +}; + +pub const AllocationData = struct { + src_heap: vk.DeviceMemory, + range: DeviceMemoryRange, +}; + +/// Handle for allocation data +pub const Allocation = common.Handle(AllocationData, .{ + .partition_bit = 12, +}); + +/// Reified (complete) handle for allocation data +pub const ReifiedAllocation = Allocation.Reified; diff --git a/src/api/memory/allocator.zig b/src/api/memory/allocator.zig index 51789d5..dc2ce6c 100644 --- a/src/api/memory/allocator.zig +++ b/src/api/memory/allocator.zig @@ -6,11 +6,6 @@ //! to the standard memory allocation interface (if I can I will support creating //! std.mem.Allocators). -/// GAYAYUIQHOIUDSAHIUHDLIHGLUSDhlhfLIHUDS -/// Guhh, now we're doing memeory management for the memory management fuuuuuuuuck. -/// Guhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh -/// - const std = @import("std"); const vk = @import("vulkan"); const common = @import("common"); @@ -18,18 +13,7 @@ const api = @import("../api.zig"); const Context = @import("../../context.zig"); -/// Represents an individual memory allocation.. -/// Depending on the allocated memory's properties, -/// Accessing the memory might require creating a staging buffer -/// or flushing and invalidating cached host-mapped memory -/// -/// Probably should handleify this, to make allocations more resistant -/// to changes in location and such -const AllocationData = struct { - src_heap: vk.DeviceMemory, - offset: u32, - size: u32, -}; +const allocation = @import("allocation.zig"); pub const Error = error{ HostOutOfMemory, @@ -39,8 +23,9 @@ pub const Error = error{ }; -//pub const Allocation = common.Handle(AllocationData); -//pub const Heap = common.Handle(HeapData); +const Allocation = allocation.Allocation; +const ReifiedAllocation = allocation.ReifiedAllocation; + const AllocationScope = enum(u2) { /// General Purpose, Picks a free-list styled, static heap @@ -60,6 +45,17 @@ const AllocationScope = enum(u2) { Static, }; +const ResourceLayoutType = enum(u1) { + /// The resource is expected to have a linear, + /// (i.e a contiguous array) layout, which concerns buffers. + /// This does not imply that the actual user-defined layout of a buffer needs to be a specific way, + /// moreso that the resource won't use any vulkan driver supported layout options. + Linear, + /// The resource is expected to have a varying/vulkan + /// supported layout. This applies mostly to images + Optimal, +}; + const AllocationPropertyFlags = packed struct { /// Whether or not memory should be directly mappable on the host /// Otherwise, transfers and staging buffers are necessary @@ -78,7 +74,7 @@ const AllocationPropertyFlags = packed struct { /// How long will this allocation live? /// This will control which heap and which allocation algorithm /// will be used for this allocation - lifetime_hint: AllocationScope = .General, + lifetime_hint: AllocationScope = .General, }; const StructureHints = packed struct { @@ -119,12 +115,16 @@ pub const AllocationConfig = packed struct { /// VkAllocateMemory specifically for this allocation (renders most configuration moot) dedicated_alloc_policy: DedicatedAllocationPolicyBits = .Unspecified, }; - + + /// This is the final layout of configuration + /// required for the allocation algorithm to actually specify allocation pub const Resolved = packed struct { mem_props: vk.MemoryPropertyFlags, mem_reqs: vk.MemoryRequirements, general_flags: GeneralFlags, + resource_type: ResourceLayoutType, }; + /// Directly force an allocation to be for memory with /// the specified properties /// This will be prioritized over any other settings @@ -149,6 +149,13 @@ pub const AllocationConfig = packed struct { Image: vk.Image, } = null, + /// Whether or not the allocation is expected to be used + /// Defaults to null in which case the resource should be explicitly specified + /// Unfortunately, vulkan has very specific requirements on how memory between buffers + /// and images ought to be laid out so the allocator will need at least some knowledge of + /// what the allocation will actually be used for. + resource_type: ?ResourceLayoutType = null, + /// Structure hints /// This controls whether or not to use a structured memory pool /// based on given parameters @@ -168,11 +175,6 @@ pub const AllocationConfig = packed struct { } }; -const Allocation = common.Handle(AllocationData, .{ - .partition_bit = 12, -}); - -const ReifiedAllocation = Allocation.Reified; /// Manages top-level handles to instantiated /// heap allocations for all included memory types @@ -214,6 +216,10 @@ pub const VirtualAllocator = struct { }; } + /// Retrieves or creates a bookkeeping entry + /// to a given vulkan pool with specific properties (caller must provide pool) + pub fn bind(self: *VirtualAllocator, pool: *VulkanPool) Error!void { + } /// NOTE: This allocator doesn't support best fit re-indexing, /// that happens at a higher level. From c50a859d8d8931cfc03a8604a93547e09b7e797b Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Tue, 16 Sep 2025 19:15:15 -0700 Subject: [PATCH 33/46] chore(allocator): figure out how tf I'm gonna implement this thing --- src/api/memory/DeviceMemoryBlock.zig | 0 src/api/memory/VulkanPool.zig | 66 ++++++++++++++++++++++++---- 2 files changed, 58 insertions(+), 8 deletions(-) create mode 100644 src/api/memory/DeviceMemoryBlock.zig diff --git a/src/api/memory/DeviceMemoryBlock.zig b/src/api/memory/DeviceMemoryBlock.zig new file mode 100644 index 0000000..e69de29 diff --git a/src/api/memory/VulkanPool.zig b/src/api/memory/VulkanPool.zig index d562611..1ba86cc 100644 --- a/src/api/memory/VulkanPool.zig +++ b/src/api/memory/VulkanPool.zig @@ -1,13 +1,34 @@ -//! A pool represents a logical view into memory, and can be generated from any valid allocation. -//! Contains metadata about the allocation it references (and unlike allocations, this persists -//! even when not in debug mode) along with a list of host-allocated control blocks -//! for bookkeeping information regarding the memory allocation. +//! Contrary to popular belief, this is not a pool allocator, it is in fact +//! a TLSF allocator in disguise!!!!!!!! >:) \_O_O_/ +//! Additionally, this acts as the main virtualizer for raw GPU +//! memory obtained by the heap. Unlike raw heap allocations, this does +//! a better job fitting allocation requests to sanely proportioned memory blocks +//! in the respective memory type and is provided by the VirtualAllocator for user +//! allocation. +//! +//! Additionally, allocation algorithms store their bookkeeping data here, +//! to facilitate division of responsibility between algorithm and nasty +//! vulkan memory type handling. In this way an algorithm can just get their +//! respective control block and do stuff as normal. +//! +//! Do note, while a TLSF allocator gives great (near linear) performance +//! for small to large-ish sized allocations, users will likely still want to +//! use different allocation algorithms for a whole host of reasons, with this +//! (or a dedicated allocation) as the source for all that because of the lower +//! overall fragmentation. Examples include linear arena or stack allocators, +//! other free lists, or some form of buddy allocator, each of which +//! has it's own place where it would be best utilized. +//! +//! Honestly, the filthy casual can just get away with using the virtual allocator +//! for most cases tho... const common = @import("common"); const std = @import("std"); const allocation = @import("allocation.zig"); +const DeviceMemoryBlock = @import("DeviceMemoryBlock.zig"); + const AllocationData = allocation.AllocationData; const Allocation = allocation.Allocation; const ReifiedAllocation = allocation.ReifiedAllocation; @@ -15,8 +36,27 @@ const ReifiedAllocation = allocation.ReifiedAllocation; const ControlBlockTable = std.AutoHashMap(common.TypeId, ControlBlockHeader); const AllocationTable = common.ObjectPool(AllocationData, .{}); -const prealloc_size: usize = 64; -const SrcAllocationList = std.SegmentedList(ReifiedAllocaiton, prealloc_size); + +// somewhat arbitrarily chosen for 64-bit systems +// with respect to what one might expect for GPU heap sizes +// (which are generally not more than 64 gigs) +const exp_index_size: usize = @typeInfo(usize).int.bits; +const linear_index_size: usize = 8; + + +// Do note that the control block for the VulkanPool allocator +// can in fact be determined entirely at compile time using just system +// parameters for word sizes and a bit of heuristics... +// NOTE: FUTURE ME +const LinearControlBlock = struct { + free_list: std.SegmentedList(AllocationData, linear_index_size), + size_mapping: std.IntegerBitSet(usize), +}; + +const ExponentControlBlock = std.SegmentedList( + DeviceMemoryBlock, + exp_index_size, +); const Pool = @This(); @@ -38,7 +78,17 @@ control_arena: std.heap.ArenaAllocator, // since just guessing here is a pain // (luckily the partition bit works out in this case) allocation_table: AllocationTable, -src_allocations: SrcAllocationList, +pool_blocks: SrcAllocationList, + +/// This is just to maintain an invariant for additional allocations +/// Specifically that contiguous memory ranges ought to be part of the same +/// dedicated allocation. Since this is not true in rare cases on its own, +/// I provide a table +/// in order to maintain bounded coalescence of contiguous memory ranges. +/// +/// NOTE: Thinking of dropping this in release builds once I'm sure consuming code +/// maintains the invariant properly. +base_memory_handles: std.SegmentedList(vk.DeviceMemory, exp_index_size); type_index: u32, @@ -71,7 +121,7 @@ pub fn init(allocation: ReifiedAllocation, host_allocator: std.mem.Allocator) Er /// Technically, we could just get away with updating bookeeping information ad hoc /// since allocations are just offsets into a memory blob. pub fn extend(pool: *Pool, new_allocation: ReifiedAllocation) Error!Pool { - + const new_allocation = src_allocations.addOne(); } /// Most allocation algorithms will just call this when binding a memory pool From 3597eda98ca170b86ca6933af0a787d6c2764f70 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Tue, 7 Oct 2025 13:28:08 -0700 Subject: [PATCH 34/46] feat: changed something I guess --- src/api/memory/VulkanPool.zig | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/api/memory/VulkanPool.zig b/src/api/memory/VulkanPool.zig index 1ba86cc..cb31cba 100644 --- a/src/api/memory/VulkanPool.zig +++ b/src/api/memory/VulkanPool.zig @@ -48,15 +48,6 @@ const linear_index_size: usize = 8; // can in fact be determined entirely at compile time using just system // parameters for word sizes and a bit of heuristics... // NOTE: FUTURE ME -const LinearControlBlock = struct { - free_list: std.SegmentedList(AllocationData, linear_index_size), - size_mapping: std.IntegerBitSet(usize), -}; - -const ExponentControlBlock = std.SegmentedList( - DeviceMemoryBlock, - exp_index_size, -); const Pool = @This(); From 2ea676cdcdba0283fc98862c5bde2fe50bf767ba Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Tue, 7 Oct 2025 20:53:53 -0700 Subject: [PATCH 35/46] feat(sample): created a fragment shader viewer --- build.zig | 56 ++-- samples/common/render_quad.zig | 1 + samples/raymarch_fractals/main.zig | 272 ++++++++++++++++++ .../raymarch_fractals/shaders/hollow_boi.glsl | 161 +++++++++++ .../raymarch_fractals/shaders/mandelbulb.glsl | 144 ++++++++++ .../shaders/raymarch_template.glsl | 111 +++++++ 6 files changed, 722 insertions(+), 23 deletions(-) create mode 100644 samples/raymarch_fractals/main.zig create mode 100644 samples/raymarch_fractals/shaders/hollow_boi.glsl create mode 100644 samples/raymarch_fractals/shaders/mandelbulb.glsl create mode 100644 samples/raymarch_fractals/shaders/raymarch_template.glsl diff --git a/build.zig b/build.zig index db0955a..2a95704 100644 --- a/build.zig +++ b/build.zig @@ -85,16 +85,34 @@ fn buildLibrary( const SampleEntry = struct { name: []const u8, - path: []const u8, + desc: []const u8, + path: []const u8 = "(no description)", // these get populated later mod: *Module = undefined, exe: *Compile = undefined, }; var sample_files = [_]SampleEntry{ - .{ .name = "basic_planes", .path = "basic_planes.zig" }, - .{ .name = "compute_drawing", .path = "compute_drawing/main.zig" }, - .{ .name = "test_sample", .path = "test_sample.zig" }, + .{ + .name = "basic_planes", + .path = "basic_planes.zig", + .desc = "basic showcase of bootstrapping vulkan up to 3d rendering", + }, + .{ + .name = "compute_drawing", + .path = "compute_drawing/main.zig", + .desc = "drawing using compute shaders", + }, + .{ + .name = "test_sample", + .path = "test_sample.zig", + .desc = "test to see if the sample build steps work correctly", + }, + .{ + .name = "raymarch_fractals", + .path = "raymarch_fractals/main.zig", + .desc = "pick from a selection of raymarched fractals, all programmed within fragment shaders", + }, }; fn populateSampleModules( @@ -149,29 +167,21 @@ fn buildSamples( ) void { populateSampleModules(b, lib_mod, deps, opts); - const build_sample = b.option( - []const u8, - "sample", - "specify sample to build and run", - ); - if (build_sample) |sample_name| { - var entry: ?*SampleEntry = null; - - for (&sample_files) |*f| { - if (std.mem.order(u8, sample_name, f.name) == .eq) { - entry = f; - break; - } - } + for (sample_files) |entry| { + b.installArtifact(entry.exe); - if (entry == null) return; + const run_step = b.addRunArtifact(entry.exe); + run_step.addArgs(b.args orelse &.{}); - b.installArtifact(entry.?.exe); - - const run_step = b.addRunArtifact(entry.?.exe); run_step.step.dependOn(b.getInstallStep()); - const run_cmd = b.step("run", "run a sample executable"); + const step_name = std.fmt.allocPrint( + b.allocator, + "run-{s}", + .{entry.name}, + ) catch @panic("Achievement Get: How did we get here?"); + + const run_cmd = b.step(step_name, entry.desc); run_cmd.dependOn(&run_step.step); } } diff --git a/samples/common/render_quad.zig b/samples/common/render_quad.zig index 787753b..6fa246e 100644 --- a/samples/common/render_quad.zig +++ b/samples/common/render_quad.zig @@ -1,6 +1,7 @@ const std = @import("std"); const ray = @import("ray"); const api = ray.api; +const math = ray.math; const Allocator = std.mem.Allocator; diff --git a/samples/raymarch_fractals/main.zig b/samples/raymarch_fractals/main.zig new file mode 100644 index 0000000..9299fe3 --- /dev/null +++ b/samples/raymarch_fractals/main.zig @@ -0,0 +1,272 @@ +//! Basic example of compute shader initialization using the Low-Level +//! unmanaged Vulkan API. +//! NOTE: This example will likely be deprecated in favor of using the upcoming +//! Managed low level API (see milestone 0.1). +const std = @import("std"); +const ray = @import("ray"); +const glfw = @import("glfw"); +const helpers = @import("helpers"); +const vk = @import("vulkan"); + +const api = ray.api; +const math = ray.math; + +const Vec3 = math.Vec3; + +const RenderQuad = helpers.RenderQuad; + +const FixedBufferAllocator = std.heap.FixedBufferAllocator; +const Allocator = std.mem.Allocator; + +const Context = ray.Context; +const Swapchain = api.Swapchain; +const FrameBuffer = api.FrameBuffer; +const GraphicsPipeline = api.GraphicsPipeline; +const RenderPass = api.RenderPass; +const FixedFunctionState = api.FixedFunctionState; +const Descriptor = api.Descriptor; +const DescriptorBinding = api.ResolvedDescriptorBinding; +const CommandBuffer = api.CommandBuffer; + +const Semaphore = api.Semaphore; +const Fence = api.Fence; + +const GraphicsQueue = api.GraphicsQueue; +const PresentQueue = api.PresentQueue; + +const UniformBuffer = api.ComptimeUniformBuffer; +const StorageBuffer = api.ComptimeStorageBuffer; +const Image = api.Image; +const Compute = api.Compute; + +const log = std.log.scoped(.application); + +const GraphicsState = struct { + descriptor: Descriptor, + framebuffers: FrameBuffer, + render_quad: RenderQuad, + + cmd_buf: CommandBuffer, + + pub fn deinit(self: *GraphicsState) void { + self.render_quad.deinit(); + self.framebuffers.deinit(); + self.cmd_buf.deinit(); + self.descriptor.deinit(); + } +}; + +const ApplicationUniforms = extern struct { + transform: math.Mat4, + resolution: math.Vec2, + time: f32, + aspect: f32, +}; + +const GPUState = struct { + host_uniforms: ApplicationUniforms, + + // compute and graphics visible + uniforms: UniformBuffer(ApplicationUniforms), + + // compute and graphics visible (needs viewport quad) + // written to in the compute shader and simply mapped to the viewport + + pub fn deinit(self: *GPUState) void { + self.uniforms.deinit(); + } +}; + +const SyncState = struct { + sem_render: Semaphore, + sem_acquire_frame: Semaphore, + frame_fence: Fence, + + pub fn deinit(self: *const SyncState) void { + self.sem_render.deinit(); + self.sem_acquire_frame.deinit(); + self.frame_fence.deinit(); + } +}; + +const SampleState = struct { + ctx: *Context = undefined, + swapchain: Swapchain = undefined, + window: glfw.Window = undefined, + allocator: Allocator, + + graphics: GraphicsState = undefined, + gpu_state: GPUState = undefined, + + sync: SyncState = undefined, + + pub fn createContext(self: *SampleState) !void { + self.window = try helpers.makeBasicWindow(900, 600, "Sacred Geometry"); + self.ctx = try Context.init(self.allocator, .{ + .inst_extensions = helpers.glfwInstanceExtensions(), + .loader = glfw.glfwGetInstanceProcAddress, + .window = &self.window, + }); + } + + pub fn createSwapchain(self: *SampleState) !void { + self.swapchain = try Swapchain.init(self.ctx, self.allocator, .{ + .requested_extent = helpers.windowExtent(&self.window), + .requested_present_mode = .mailbox_khr, + .requested_format = .{ + .color_space = .srgb_nonlinear_khr, + .format = .r8g8b8a8_srgb, + }, + }); + } + + pub fn createGraphicsPipeline(self: *SampleState, file: []const u8) !void { + const frag_shader = try helpers.initSampleShader( + self.ctx, + self.allocator, + file, + .Fragment, + ); + + defer frag_shader.deinit(); + + const size = self.window.dimensions(); + // initialize uniforms + self.gpu_state.host_uniforms = .{ + .time = 0, + .transform = math.Mat4.identity(), + .resolution = math.vec(.{ 1.0, 1.0 }), + .aspect = @as(f32, @floatFromInt(size.height)) / @as(f32, @floatFromInt(size.width)), + }; + + self.gpu_state.uniforms = try UniformBuffer(ApplicationUniforms) + .create(self.ctx); + + try self.gpu_state.uniforms.setData(&self.gpu_state.host_uniforms); + + // create fragment-specific descriptors + self.graphics.descriptor = try Descriptor.init(self.ctx, self.allocator, .{ .bindings = &.{.{ + .data = .{ .Uniform = self.gpu_state.uniforms.buffer() }, + .stages = .{ .fragment_bit = true }, + }} }); + + try self.graphics.render_quad.initSelf(self.ctx, self.allocator, .{ + .frag_shader = &frag_shader, + .frag_descriptors = &self.graphics.descriptor, + .swapchain = &self.swapchain, + }); + + self.graphics.framebuffers = try FrameBuffer.initAlloc(self.ctx, self.allocator, .{ + .depth_view = null, + .swapchain = &self.swapchain, + .renderpass = &self.graphics.render_quad.renderpass, + }); + + self.graphics.cmd_buf = try CommandBuffer.init(self.ctx, .{}); + } + + pub fn createSyncObjects(self: *SampleState) !void { + self.sync.frame_fence = try Fence.init(self.ctx, true); + self.sync.sem_acquire_frame = try Semaphore.init(self.ctx); + self.sync.sem_render = try Semaphore.init(self.ctx); + + //compute sync objects + } + + pub fn active(self: *const SampleState) bool { + return !self.window.shouldClose(); + } + + fn updateUniforms(self: *SampleState) !void { + self.gpu_state.host_uniforms.time = @floatCast(glfw.getTime()); + try self.gpu_state.uniforms.setData(&self.gpu_state.host_uniforms); + } + + // intercepts errors and logs them + pub fn update(self: *SampleState) !void { + glfw.pollEvents(); + + // wait for v + try self.sync.frame_fence.wait(); + try self.sync.frame_fence.reset(); + + try self.updateUniforms(); + + _ = try self.swapchain.getNextImage(self.sync.sem_acquire_frame.h_sem, null); + + try self.graphics.cmd_buf.reset(); + try self.graphics.cmd_buf.begin(); + self.graphics.render_quad.drawOneShot( + &self.graphics.cmd_buf, + &self.graphics.framebuffers, + ); + + try self.graphics.cmd_buf.end(); + // submit the command buffer to a synchronized queue + try self.ctx.submitCommands(&self.graphics.cmd_buf, .Graphics, .{ + .fence_wait = self.sync.frame_fence.h_fence, + .sem_sig = self.sync.sem_render.h_sem, + .sem_wait = self.sync.sem_acquire_frame.h_sem, + }); + + try self.ctx.presentFrame(&self.swapchain, .{ + .sem_wait = self.sync.sem_render.h_sem, + }); + } + + pub fn deinit(self: *SampleState) void { + self.ctx.dev.waitIdle() catch {}; + + self.graphics.deinit(); + self.gpu_state.deinit(); + + self.swapchain.deinit(); + + self.sync.deinit(); + self.ctx.deinit(); + self.window.destroy(); + } +}; + +pub fn main() !void { + const mem = try std.heap.page_allocator.alloc(u8, 1_000_024); + var buf_alloc = FixedBufferAllocator.init(mem); + defer std.heap.page_allocator.free(mem); + + var args = try std.process.argsWithAllocator(buf_alloc.allocator()); + _ = args.next(); + + const shader_file = args.next() orelse { + log.err("Usage: raymarch_fractal ", .{}); + return error.RequiresArgument; + }; + + var state: SampleState = .{ + .allocator = buf_alloc.allocator(), + }; + + // figure out the full path + var path_builder = std.ArrayList(u8).init(buf_alloc.allocator()); + try path_builder.appendSlice("raymarch_fractals/shaders/"); + try path_builder.appendSlice(shader_file); + std.debug.print("Full path: {s}\n", .{path_builder.items}); + + try state.createContext(); + try state.createSyncObjects(); + try state.createSwapchain(); + try state.createGraphicsPipeline(path_builder.items); + + state.window.show(); + + while (state.active()) { + state.update() catch |err| { + log.err("An error occured while running: {!}\n ....Terminating", .{err}); + state.deinit(); + + return err; + }; + } + + state.deinit(); + log.info("You Win!", .{}); +} diff --git a/samples/raymarch_fractals/shaders/hollow_boi.glsl b/samples/raymarch_fractals/shaders/hollow_boi.glsl new file mode 100644 index 0000000..a3342f8 --- /dev/null +++ b/samples/raymarch_fractals/shaders/hollow_boi.glsl @@ -0,0 +1,161 @@ +#version 450 + +#define EPSILON 0.0001 +#define ITERATIONS 256 +#define MAX_DIST 1000.0 + +#define PI 3.14159265 + +//#define NORMALS_ONLY + +layout(location = 0) out vec4 fragColor; +layout(location = 0) in vec2 texCoord; + +const vec3 spos = vec3(0.0); +const vec3 light = normalize(vec3(1.0, 0.4, 2.3)); + +const float sp_radius = 5.0; + +layout(binding = 0) uniform FragUniforms { + mat4 transform; + vec2 resolution; + float time; + float aspect; +} u; + +const vec2 mouse = vec2(0, 0); + +float sdfSubtract(float d1, float d2) { + return max(-d2, d1); +} + +float sdfSmoothUnion(float d1, float d2, float r) { + float h = clamp( 0.5 + 0.5*(d2-d1)/r, 0.0, 1.0 ); + return mix( d2, d1, h ) - r*h*(1.0-h); +} + +float sdfSmooth(float d, float r) { + return d - r; +} + +vec3 sdfMirrorZ(vec3 pos, float offset) { + return vec3(pos.xy, abs(pos.z - offset)); +} + +float cylinder(vec3 p, float h, float r) { + vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(r,h); + return min(max(d.x,d.y),0.0) + length(max(d,0.0)); +} + +float sphere(vec3 p, vec3 sp, float r) { + return length(p - sp) - r; +} + + +float horns(vec3 pos) { + vec3 p = pos - vec3(0.0, 0.96, 0.0); + const float rad = 0.2; + + vec2 wut = vec2(length(p.yz) - 1.0, p.x); + float donut = length(wut) - rad; + + float mid = sphere(pos, vec3(0.0, 1.9, 0.0), 0.6); + + return sdfSubtract(donut, mid); +} + + + +float body(vec3 pos) { + return 0.0; +} + + + +float scene(in vec3 pos) { + float head_base = sdfSmooth(cylinder(pos, 0.4,0.5), 0.5); + float eye = sphere(sdfMirrorZ(pos, 0.0), vec3(0.75, 0.0, 0.4), 0.3); + + return sdfSmoothUnion( horns(pos), sdfSubtract(head_base, eye), 0.2); + //return horns(pos); +} + + + +float march(vec3 o, vec3 dir) { + float t = 0.0; + for (int i = 0; i < ITERATIONS; i++) { + vec3 ray = o + dir * t; + + float cd = scene(ray); + + t += cd; + + if (t <= EPSILON || t > MAX_DIST) { + break; + } + } + + return t; +} + +vec3 calcNormals(in vec3 pos) { + const float e = 0.0005; + const vec2 k = vec2(1, -1) * 0.5773 * e; + return normalize( + k.xyy*scene(pos+k.xyy) + + k.yyx*scene(pos+k.yyx) + + k.yxy*scene(pos+k.yxy) + + k.xxx*scene(pos+k.xxx) ); +} + + +vec3 render(float dist, vec3 pos) { + if (dist > MAX_DIST) return vec3(0.0); + + vec3 n = calcNormals(pos); + + #ifdef NORMALS_ONLY + return abs(n); + #endif + + float dif = 0.9 * clamp(dot(light, n), 0.0, 1.0); + + vec3 albedo = vec3(1.0); + vec3 ambient = vec3(0.1); + return albedo * dif + ambient; +} + +// check to make sure y is represented in the correct coordinate space +vec3 lookat(vec3 orig, vec3 eye, vec3 pos) { + const vec3 world_up = vec3(0.0, 1.0, 0.0); + + vec3 z = normalize(pos - eye); + vec3 x = normalize(cross(z, world_up)); + vec3 y = normalize(cross(x, z)); + + mat3 look = mat3(x, y, z); + + return orig * look; +} + +void main() { + // Normalized screen coordinates (from -1 to 1) + // quite helpful for figuring out ray direction without doing an explicit + // perspective projection + vec2 uv = (texCoord - 0.5 * u.resolution.xy)/u.resolution.y; + + // adjust for vulkan + uv.y = -uv.y * u.aspect; + + float ylook = 0.0; //4.0 * (iMouse.y - 0.5 * iResolution.y)/iResolution.y; + + float a = mouse.x / u.resolution.x * 2.0 * PI; + + vec3 pos = vec3(4.0 * cos(a), ylook, 4.0 * sin(a)); + vec3 dir = lookat(normalize(vec3(uv, 1.0)), pos, spos); + + float dist = march(pos, dir); + + fragColor = vec4(render(dist, pos + dir * dist), 1.0); +} diff --git a/samples/raymarch_fractals/shaders/mandelbulb.glsl b/samples/raymarch_fractals/shaders/mandelbulb.glsl new file mode 100644 index 0000000..1d56ca7 --- /dev/null +++ b/samples/raymarch_fractals/shaders/mandelbulb.glsl @@ -0,0 +1,144 @@ +#version 450 + +#define EPSILON 0.0001 +#define ITERATIONS 56 +#define MAX_DIST 1000.0 + +#define PI 3.14159265 + +//#define NORMALS_ONLY + +layout(location = 0) out vec4 fragColor; +layout(location = 0) in vec2 texCoord; + +const vec3 spos = vec3(0.0); +const vec3 light = normalize(vec3(1.0, 0.4, 2.3)); + +const float sp_radius = 5.0; + +layout(binding = 0) uniform FragUniforms { + mat4 transform; + vec2 resolution; + float time; + float aspect; +} u; + +const vec2 mouse = vec2(0, 0); + +const int fractal_iterations = 12; +const float yeet = 4.0; +const float power = 8.0; + +float freakyFractal(in vec3 pos) { + float dr = 1.0; + float r; + vec3 z = pos; + + for (int i = 0; i < fractal_iterations; i++) { + r = length(z); + if (r > yeet) break; + + float theta = acos(z.z / r) + u.time; + float phi = atan(z.y, z.x); + + dr = pow(r, power - 1) * power * dr + 1.0; + + float scaled_r = pow(r, power); + theta = theta * power; + phi = phi * power; + + z = scaled_r * vec3( + sin(theta) * cos(phi), + sin(phi) * sin(theta), + cos(theta) + ) + pos; + + } + + return 0.5 * log(r) * r / dr; +} + +float scene(in vec3 pos) { + return freakyFractal(pos); +} + + + +float march(vec3 o, vec3 dir) { + float t = 0.0; + for (int i = 0; i < ITERATIONS; i++) { + vec3 ray = o + dir * t; + + float cd = scene(ray); + + t += cd; + + if (t <= EPSILON || t > MAX_DIST) { + break; + } + } + + return t; +} + +vec3 calcNormals(in vec3 pos) { + const float e = 0.0005; + const vec2 k = vec2(1, -1) * 0.5773 * e; + return normalize( + k.xyy*scene(pos+k.xyy) + + k.yyx*scene(pos+k.yyx) + + k.yxy*scene(pos+k.yxy) + + k.xxx*scene(pos+k.xxx) ); +} + +// Basic ass phong lighting, replace with something fancier +// if you wish +vec3 render(float dist, vec3 pos) { + if (dist > MAX_DIST) return vec3(0.0); + + vec3 n = calcNormals(pos); + + #ifdef NORMALS_ONLY + return abs(n); + #endif + + float dif = 0.9 * clamp(dot(light, n), 0.0, 1.0); + + vec3 albedo = vec3(1.0); + vec3 ambient = vec3(0.1); + return albedo * dif + ambient; +} + +// check to make sure y is represented in the correct coordinate space +vec3 lookat(vec3 orig, vec3 eye, vec3 pos) { + const vec3 world_up = vec3(0.0, 1.0, 0.0); + + vec3 z = normalize(pos - eye); + vec3 x = normalize(cross(z, world_up)); + vec3 y = normalize(cross(x, z)); + + mat3 look = mat3(x, y, z); + + return orig * look; +} + +void main() { + // Normalized screen coordinates (from -1 to 1) + // quite helpful for figuring out ray direction without doing an explicit + // perspective projection + vec2 uv = (texCoord - 0.5 * u.resolution.xy)/u.resolution.y; + + // adjust for vulkan + uv.y = -uv.y * u.aspect; + + float ylook = 0.0; + + float a = mouse.x / u.resolution.x * 2.0 * PI; + + vec3 pos = vec3(4.0 * cos(u.time), ylook, 4.0 * sin(u.time)); + vec3 dir = lookat(normalize(vec3(uv, 1.0)), pos, spos); + + float dist = march(pos, dir); + + fragColor = vec4(render(dist, pos + dir * dist), 1.0); +} diff --git a/samples/raymarch_fractals/shaders/raymarch_template.glsl b/samples/raymarch_fractals/shaders/raymarch_template.glsl new file mode 100644 index 0000000..aa85d55 --- /dev/null +++ b/samples/raymarch_fractals/shaders/raymarch_template.glsl @@ -0,0 +1,111 @@ +#version 450 + +#define EPSILON 0.0001 +#define ITERATIONS 256 +#define MAX_DIST 1000.0 + +#define PI 3.14159265 + +//#define NORMALS_ONLY + +layout(location = 0) out vec4 fragColor; +layout(location = 0) in vec2 texCoord; + +const vec3 spos = vec3(0.0); +const vec3 light = normalize(vec3(1.0, 0.4, 2.3)); + +const float sp_radius = 5.0; + +layout(binding = 0) uniform FragUniforms { + mat4 transform; + vec2 resolution; + float time; + float aspect; +} u; + +const vec2 mouse = vec2(0, 0); + + +float scene(in vec3 pos) { + return length(pos) - 0.5; +} + + + +float march(vec3 o, vec3 dir) { + float t = 0.0; + for (int i = 0; i < ITERATIONS; i++) { + vec3 ray = o + dir * t; + + float cd = scene(ray); + + t += cd; + + if (t <= EPSILON || t > MAX_DIST) { + break; + } + } + + return t; +} + +vec3 calcNormals(in vec3 pos) { + const float e = 0.0005; + const vec2 k = vec2(1, -1) * 0.5773 * e; + return normalize( + k.xyy*scene(pos+k.xyy) + + k.yyx*scene(pos+k.yyx) + + k.yxy*scene(pos+k.yxy) + + k.xxx*scene(pos+k.xxx) ); +} + + +vec3 render(float dist, vec3 pos) { + if (dist > MAX_DIST) return vec3(0.0); + + vec3 n = calcNormals(pos); + + #ifdef NORMALS_ONLY + return abs(n); + #endif + + float dif = 0.9 * clamp(dot(light, n), 0.0, 1.0); + + vec3 albedo = vec3(1.0); + vec3 ambient = vec3(0.1); + return albedo * dif + ambient; +} + +// check to make sure y is represented in the correct coordinate space +vec3 lookat(vec3 orig, vec3 eye, vec3 pos) { + const vec3 world_up = vec3(0.0, 1.0, 0.0); + + vec3 z = normalize(pos - eye); + vec3 x = normalize(cross(z, world_up)); + vec3 y = normalize(cross(x, z)); + + mat3 look = mat3(x, y, z); + + return orig * look; +} + +void main() { + // Normalized screen coordinates (from -1 to 1) + // quite helpful for figuring out ray direction without doing an explicit + // perspective projection + vec2 uv = (texCoord - 0.5 * u.resolution.xy)/u.resolution.y; + + // adjust for vulkan + uv.y = -uv.y * u.aspect; + + float ylook = 0.0; //4.0 * (iMouse.y - 0.5 * iResolution.y)/iResolution.y; + + float a = mouse.x / u.resolution.x * 2.0 * PI; + + vec3 pos = vec3(4.0 * cos(a), ylook, 4.0 * sin(a)); + vec3 dir = lookat(normalize(vec3(uv, 1.0)), pos, spos); + + float dist = march(pos, dir); + + fragColor = vec4(render(dist, pos + dir * dist), 1.0); +} From 7f5af6fa456e5c85db52986a0d8f17dff3248c9b Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Thu, 9 Oct 2025 11:11:51 -0700 Subject: [PATCH 36/46] feat(sample): mandelbulb with shitty skybox --- .../raymarch_fractals/shaders/mandelbulb.glsl | 95 ++++++++++++++----- .../shaders/raymarch_template.glsl | 1 + 2 files changed, 72 insertions(+), 24 deletions(-) diff --git a/samples/raymarch_fractals/shaders/mandelbulb.glsl b/samples/raymarch_fractals/shaders/mandelbulb.glsl index 1d56ca7..fa327bc 100644 --- a/samples/raymarch_fractals/shaders/mandelbulb.glsl +++ b/samples/raymarch_fractals/shaders/mandelbulb.glsl @@ -1,8 +1,8 @@ #version 450 -#define EPSILON 0.0001 -#define ITERATIONS 56 -#define MAX_DIST 1000.0 +#define EPSILON 0.001 +#define ITERATIONS 48 +#define MAX_DIST 80.0 #define PI 3.14159265 @@ -12,7 +12,6 @@ layout(location = 0) out vec4 fragColor; layout(location = 0) in vec2 texCoord; const vec3 spos = vec3(0.0); -const vec3 light = normalize(vec3(1.0, 0.4, 2.3)); const float sp_radius = 5.0; @@ -23,22 +22,27 @@ layout(binding = 0) uniform FragUniforms { float aspect; } u; +#define TIME (u.time * 0.1) + const vec2 mouse = vec2(0, 0); const int fractal_iterations = 12; const float yeet = 4.0; const float power = 8.0; -float freakyFractal(in vec3 pos) { +vec4 freakyFractal(in vec3 pos) { float dr = 1.0; float r; + vec3 o = vec3(1.0); vec3 z = pos; for (int i = 0; i < fractal_iterations; i++) { r = length(z); + o = min(o, abs(z)); + if (r > yeet) break; - float theta = acos(z.z / r) + u.time; + float theta = acos(z.z / r) + TIME; float phi = atan(z.y, z.x); dr = pow(r, power - 1) * power * dr + 1.0; @@ -52,28 +56,30 @@ float freakyFractal(in vec3 pos) { sin(phi) * sin(theta), cos(theta) ) + pos; - } - return 0.5 * log(r) * r / dr; + return vec4(0.5 * log(r) * r / max(dr, 1e-6), abs(normalize(o))); } -float scene(in vec3 pos) { +vec4 vecScene(in vec3 pos) { return freakyFractal(pos); } - +float scene(in vec3 pos) { + return freakyFractal(pos).x; +} float march(vec3 o, vec3 dir) { float t = 0.0; for (int i = 0; i < ITERATIONS; i++) { + vec3 ray = o + dir * t; float cd = scene(ray); t += cd; - - if (t <= EPSILON || t > MAX_DIST) { + + if (cd < EPSILON * t || t > MAX_DIST) { break; } } @@ -82,7 +88,7 @@ float march(vec3 o, vec3 dir) { } vec3 calcNormals(in vec3 pos) { - const float e = 0.0005; + const float e = EPSILON; const vec2 k = vec2(1, -1) * 0.5773 * e; return normalize( k.xyy*scene(pos+k.xyy) + @@ -91,22 +97,57 @@ vec3 calcNormals(in vec3 pos) { k.xxx*scene(pos+k.xxx) ); } +vec3 calcNormals1(in vec3 pos) { + vec3 eps = vec3(0.001,0.0,0.0); + return normalize( vec3( + scene(pos+eps.xyy).x - scene(pos-eps.xyy).x, + scene(pos+eps.yxy).x - scene(pos-eps.yxy).x, + scene(pos+eps.yyx).x - scene(pos-eps.yyx).x ) ); +} + +const vec3 col_c = vec3(1.0, 0.03, 0.82); +const vec3 col_a = vec3(0.1, 1.0, 0.9); +const vec3 col_b = vec3(0.4, 0.05, 0.5); + +const vec3 sky_a = vec3(1.0, 0.95, 0.95); +const vec3 sky_b = vec3(0.3, 0.9, 1.0); +const vec3 sky_c = vec3(0.2, 0.2, 0.4); + // Basic ass phong lighting, replace with something fancier // if you wish -vec3 render(float dist, vec3 pos) { - if (dist > MAX_DIST) return vec3(0.0); +vec3 render(float dist, vec3 pos, vec3 look, vec3 dir, vec3 light) { + if (dist > MAX_DIST) + { + float sky = pow(dot(dir, vec3(0.0, 1.0, 0.0)), 2.0); + float sky2 = pow(dot(dir, vec3(0.0, -1.0, 0.0)), 2.0); + + vec3 sky_a = max(mix(sky_a, sky_b, sky), vec3(0.0)); + vec3 sky_b = max(mix(sky_a, sky_c, sky2), vec3(0.0)); + + return sky_a + sky_b; + } vec3 n = calcNormals(pos); + vec3 o = vecScene(pos).yzw; #ifdef NORMALS_ONLY return abs(n); #endif + + float trapMix = length(o); + vec3 base = vec3(0.2, 0.9, 1.0); + vec3 band = 0.25 + 0.5 * cos(6.2831 * (o + 0.2 * o)); + vec3 albedo = mix(col_a, col_b, band); - float dif = 0.9 * clamp(dot(light, n), 0.0, 1.0); - - vec3 albedo = vec3(1.0); - vec3 ambient = vec3(0.1); - return albedo * dif + ambient; + float dif = max(dot(n, light), 0.0); + + + float shine = 32.0; + vec3 halfa = normalize(light + look); + float spa = max(dot(halfa, n), 0.0); + float spec = pow(spa, shine); + + return albedo * dif / dist + albedo * 0.1 / dist + spec * vec3(1) / dist; } // check to make sure y is represented in the correct coordinate space @@ -131,14 +172,20 @@ void main() { // adjust for vulkan uv.y = -uv.y * u.aspect; - float ylook = 0.0; + float ylook = sin(TIME * 0.5) * 4.0; float a = mouse.x / u.resolution.x * 2.0 * PI; + + float dist = (sin(TIME) + 1.0) * 0.5 * 4.0 + 1.0; - vec3 pos = vec3(4.0 * cos(u.time), ylook, 4.0 * sin(u.time)); + vec3 pos = vec3(dist * cos(TIME), ylook, dist * sin(TIME)); + vec3 lpos = vec3(dist * cos(TIME * 3.0), ylook, dist * sin(TIME * 3.0)); + vec3 dir = lookat(normalize(vec3(uv, 1.0)), pos, spos); + vec3 look = lookat(normalize(vec3(uv, 1.0)), pos, spos); + vec3 light = lookat(normalize(vec3(0.0, 0.0, 1.0)), lpos, spos); - float dist = march(pos, dir); + float di = march(pos, dir); - fragColor = vec4(render(dist, pos + dir * dist), 1.0); + fragColor = vec4(render(di, pos + dir * di, look, dir, light), 1.0); } diff --git a/samples/raymarch_fractals/shaders/raymarch_template.glsl b/samples/raymarch_fractals/shaders/raymarch_template.glsl index aa85d55..86a843c 100644 --- a/samples/raymarch_fractals/shaders/raymarch_template.glsl +++ b/samples/raymarch_fractals/shaders/raymarch_template.glsl @@ -26,6 +26,7 @@ layout(binding = 0) uniform FragUniforms { const vec2 mouse = vec2(0, 0); +// boll circle float scene(in vec3 pos) { return length(pos) - 0.5; } From 8c919b78c668264cff6601d1e438f4f9f1cd044c Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 10 Oct 2025 10:59:32 -0700 Subject: [PATCH 37/46] feat(sampler): added a bunch of shaders and added optional texture support --- samples/raymarch_fractals/main.zig | 33 ++- .../raymarch_fractals/shaders/hollow_boi.glsl | 11 +- .../raymarch_fractals/shaders/juliabulb.glsl | 189 ++++++++++++++++++ .../raymarch_fractals/shaders/mandelbox.glsl | 112 +++++++++++ .../raymarch_fractals/shaders/mandelbulb.glsl | 11 +- src/math.zig | 9 + textures/clear.png | Bin 0 -> 1053093 bytes 7 files changed, 353 insertions(+), 12 deletions(-) create mode 100644 samples/raymarch_fractals/shaders/juliabulb.glsl create mode 100644 samples/raymarch_fractals/shaders/mandelbox.glsl create mode 100644 textures/clear.png diff --git a/samples/raymarch_fractals/main.zig b/samples/raymarch_fractals/main.zig index 9299fe3..4ec4fe9 100644 --- a/samples/raymarch_fractals/main.zig +++ b/samples/raymarch_fractals/main.zig @@ -37,6 +37,7 @@ const PresentQueue = api.PresentQueue; const UniformBuffer = api.ComptimeUniformBuffer; const StorageBuffer = api.ComptimeStorageBuffer; const Image = api.Image; +const Texture = api.TexImage; const Compute = api.Compute; const log = std.log.scoped(.application); @@ -68,12 +69,14 @@ const GPUState = struct { // compute and graphics visible uniforms: UniformBuffer(ApplicationUniforms), + texture: Texture, // compute and graphics visible (needs viewport quad) // written to in the compute shader and simply mapped to the viewport pub fn deinit(self: *GPUState) void { self.uniforms.deinit(); + self.texture.deinit(); } }; @@ -131,10 +134,18 @@ const SampleState = struct { defer frag_shader.deinit(); const size = self.window.dimensions(); + + // do the texture + self.gpu_state.texture = try Texture.fromFile( + self.ctx, + self.allocator, + "textures/clear.png", + ); + // initialize uniforms self.gpu_state.host_uniforms = .{ .time = 0, - .transform = math.Mat4.identity(), + .transform = math.Mat4.scale(math.vec(.{ 20.0, 1.0, 1.0 })), .resolution = math.vec(.{ 1.0, 1.0 }), .aspect = @as(f32, @floatFromInt(size.height)) / @as(f32, @floatFromInt(size.width)), }; @@ -145,10 +156,16 @@ const SampleState = struct { try self.gpu_state.uniforms.setData(&self.gpu_state.host_uniforms); // create fragment-specific descriptors - self.graphics.descriptor = try Descriptor.init(self.ctx, self.allocator, .{ .bindings = &.{.{ + self.graphics.descriptor = try Descriptor.init(self.ctx, self.allocator, .{ .bindings = &.{ .{ .data = .{ .Uniform = self.gpu_state.uniforms.buffer() }, .stages = .{ .fragment_bit = true }, - }} }); + }, .{ + .data = .{ .Sampler = .{ + .sampler = self.gpu_state.texture.h_sampler, + .view = self.gpu_state.texture.view.h_view, + } }, + .stages = .{ .fragment_bit = true }, + } } }); try self.graphics.render_quad.initSelf(self.ctx, self.allocator, .{ .frag_shader = &frag_shader, @@ -229,11 +246,12 @@ const SampleState = struct { }; pub fn main() !void { - const mem = try std.heap.page_allocator.alloc(u8, 1_000_024); - var buf_alloc = FixedBufferAllocator.init(mem); - defer std.heap.page_allocator.free(mem); + var buf_alloc = std.heap.GeneralPurposeAllocator(.{ + }).init; + defer _ = buf_alloc.deinit(); var args = try std.process.argsWithAllocator(buf_alloc.allocator()); + defer args.deinit(); _ = args.next(); const shader_file = args.next() orelse { @@ -247,9 +265,10 @@ pub fn main() !void { // figure out the full path var path_builder = std.ArrayList(u8).init(buf_alloc.allocator()); + defer path_builder.deinit(); + try path_builder.appendSlice("raymarch_fractals/shaders/"); try path_builder.appendSlice(shader_file); - std.debug.print("Full path: {s}\n", .{path_builder.items}); try state.createContext(); try state.createSyncObjects(); diff --git a/samples/raymarch_fractals/shaders/hollow_boi.glsl b/samples/raymarch_fractals/shaders/hollow_boi.glsl index a3342f8..cd8aa11 100644 --- a/samples/raymarch_fractals/shaders/hollow_boi.glsl +++ b/samples/raymarch_fractals/shaders/hollow_boi.glsl @@ -23,6 +23,8 @@ layout(binding = 0) uniform FragUniforms { float aspect; } u; +layout(binding = 1) uniform sampler2D main_tex; + const vec2 mouse = vec2(0, 0); float sdfSubtract(float d1, float d2) { @@ -120,8 +122,15 @@ vec3 render(float dist, vec3 pos) { #endif float dif = 0.9 * clamp(dot(light, n), 0.0, 1.0); + + float dotx = abs(dot(n, vec3(1.0, 0.0, 0.0))); + float doty = abs(dot(n, vec3(0.0, 1.0, 0.0))); + float dotz = abs(dot(n, vec3(0.0, 0.0, 1.0))); - vec3 albedo = vec3(1.0); + vec3 albedo = + texture(main_tex, normalize(pos.yz) + vec2(0.5)).rgb * dotx + + texture(main_tex, normalize(pos.xz) + vec2(0.5)).rgb * doty + + texture(main_tex, normalize(pos.xy) + vec2(0.5)).rgb * dotz; vec3 ambient = vec3(0.1); return albedo * dif + ambient; } diff --git a/samples/raymarch_fractals/shaders/juliabulb.glsl b/samples/raymarch_fractals/shaders/juliabulb.glsl new file mode 100644 index 0000000..b55da56 --- /dev/null +++ b/samples/raymarch_fractals/shaders/juliabulb.glsl @@ -0,0 +1,189 @@ +#version 450 + +#define EPSILON 0.001 +#define ITERATIONS 48 +#define MAX_DIST 80.0 + +#define PI 3.14159265 + +//#define NORMALS_ONLY + +layout(location = 0) out vec4 fragColor; +layout(location = 0) in vec2 texCoord; + +const float sp_radius = 5.0; + +layout(binding = 0) uniform FragUniforms { + mat4 transform; + vec2 resolution; + float time; + float aspect; +} u; + +#define TIME (u.time * 0.1) + +const vec2 mouse = vec2(0, 0); + +const int fractal_iterations = 4; +const float yeet = 4.0; +const float power = 8.0; + +vec4 freakyFractal(in vec3 pos) { + float dr = 1.0; + float r; + vec3 o = vec3(1.0); + vec3 z = pos; + vec3 c = vec3(sin(TIME), 1.0 - cos(TIME), cos(TIME)); + + for (int i = 0; i < fractal_iterations; i++) { + r = length(z); + o = min(o, abs(z)); + + if (r > yeet) break; + + float theta = 8.0 *acos(clamp(z.z / r, -1.0, 1.0)); + float phi = 8.0 * atan(z.y, z.x); + + dr = power * pow(r, 3.5) * dr; + + float scaled_r = pow(r, power); + + z = scaled_r * vec3( + sin(theta) * cos(phi), + sin(phi) * sin(theta), + cos(theta) + ) + c; + } + + return vec4(0.5 * log(r) * sqrt(r) / max(dr, 1e-6), abs(normalize(o))); +} + +const vec3 spos = vec3(0.0); + + +vec4 vecScene(in vec3 pos) { + return freakyFractal(pos); +} + +float scene(in vec3 pos) { + return freakyFractal(pos).x; +} + +float march(vec3 o, vec3 dir) { + float t = 0.0; + for (int i = 0; i < ITERATIONS; i++) { + + vec3 ray = o + dir * t; + + float cd = scene(ray); + + t += cd; + + if (cd < EPSILON * t || t > MAX_DIST) { + break; + } + } + + return t; +} + +vec3 calcNormals(in vec3 pos) { + const float e = EPSILON; + const vec2 k = vec2(1, -1) * 0.5773 * e; + return normalize( + k.xyy*scene(pos+k.xyy) + + k.yyx*scene(pos+k.yyx) + + k.yxy*scene(pos+k.yxy) + + k.xxx*scene(pos+k.xxx) ); +} + +vec3 calcNormals1(in vec3 pos) { + vec3 eps = vec3(0.001,0.0,0.0); + return normalize( vec3( + scene(pos+eps.xyy).x - scene(pos-eps.xyy).x, + scene(pos+eps.yxy).x - scene(pos-eps.yxy).x, + scene(pos+eps.yyx).x - scene(pos-eps.yyx).x ) ); +} + +const vec3 col_c = vec3(1.0, 0.03, 0.82); +const vec3 col_a = vec3(0.1, 1.0, 0.9); +const vec3 col_b = vec3(0.4, 0.05, 0.5); + +const vec3 sky_a = vec3(1.0, 0.95, 0.95); +const vec3 sky_b = vec3(0.3, 0.9, 1.0); +const vec3 sky_c = vec3(0.2, 0.2, 0.4); + +// Basic ass phong lighting, replace with something fancier +// if you wish +vec3 render(float dist, vec3 pos, vec3 look, vec3 dir, vec3 light) { + vec3 light1 = vec3( 0.577, 0.577, -0.577 ); + + if (dist > MAX_DIST) + { + vec3 col = 1.3*vec3(0.8,.95,1.0)*(0.7+0.3*dir.y); + col += vec3(0.8,0.7,0.5)*pow( clamp(dot(dir,light1),0.0,1.0), 32.0 ); + return col; + } + + vec3 n = calcNormals(pos); + vec3 o = vecScene(pos).yzw; + + #ifdef NORMALS_ONLY + return abs(n); + #endif + + float trapMix = length(o); + vec3 base = vec3(0.2, 0.9, 1.0); + vec3 band = 0.25 + 0.5 * cos(6.2831 * (o + 0.2 * o)); + vec3 albedo = mix(col_a, col_b, band); + + float dif = max(dot(n, light), 0.0); + + + float shine = 64.0; + vec3 halfa = normalize(light + look); + float spa = max(dot(halfa, n), 0.0); + float spec = pow(spa, shine); + + return albedo * dif / dist + albedo * 0.1 / dist + spec * vec3(1) / dist; +} + +// check to make sure y is represented in the correct coordinate space +vec3 lookat(vec3 orig, vec3 eye, vec3 pos) { + const vec3 world_up = vec3(0.0, 1.0, 0.0); + + vec3 z = normalize(pos - eye); + vec3 x = normalize(cross(z, world_up)); + vec3 y = normalize(cross(x, z)); + + mat3 look = mat3(x, y, z); + + return orig * look; +} + +void main() { + // Normalized screen coordinates (from -1 to 1) + // quite helpful for figuring out ray direction without doing an explicit + // perspective projection + vec2 uv = (texCoord - 0.5 * u.resolution.xy)/u.resolution.y; + + // adjust for vulkan + uv.y = -uv.y * u.aspect; + + float ylook = 0.0;//sin(TIME * 0.5) * 4.0; + + float a = mouse.x / u.resolution.x * 2.0 * PI; + + float dist = (sin(TIME) + 1.0) * 0.5 * 4.0 + 1.0; + + vec3 pos = vec3(dist * cos(TIME), ylook, dist * sin(TIME)); + vec3 lpos = vec3(dist * cos(TIME * 3.0), ylook, dist * sin(TIME * 3.0)); + + vec3 dir = lookat(normalize(vec3(uv, 1.0)), pos, spos); + vec3 look = lookat(normalize(vec3(uv, 1.0)), pos, spos); + vec3 light = lookat(normalize(vec3(0.0, 0.0, 1.0)), lpos, spos); + + float di = march(pos, dir); + + fragColor = vec4(render(di, pos + dir * di, look, dir, light), 1.0); +} diff --git a/samples/raymarch_fractals/shaders/mandelbox.glsl b/samples/raymarch_fractals/shaders/mandelbox.glsl new file mode 100644 index 0000000..86a843c --- /dev/null +++ b/samples/raymarch_fractals/shaders/mandelbox.glsl @@ -0,0 +1,112 @@ +#version 450 + +#define EPSILON 0.0001 +#define ITERATIONS 256 +#define MAX_DIST 1000.0 + +#define PI 3.14159265 + +//#define NORMALS_ONLY + +layout(location = 0) out vec4 fragColor; +layout(location = 0) in vec2 texCoord; + +const vec3 spos = vec3(0.0); +const vec3 light = normalize(vec3(1.0, 0.4, 2.3)); + +const float sp_radius = 5.0; + +layout(binding = 0) uniform FragUniforms { + mat4 transform; + vec2 resolution; + float time; + float aspect; +} u; + +const vec2 mouse = vec2(0, 0); + + +// boll circle +float scene(in vec3 pos) { + return length(pos) - 0.5; +} + + + +float march(vec3 o, vec3 dir) { + float t = 0.0; + for (int i = 0; i < ITERATIONS; i++) { + vec3 ray = o + dir * t; + + float cd = scene(ray); + + t += cd; + + if (t <= EPSILON || t > MAX_DIST) { + break; + } + } + + return t; +} + +vec3 calcNormals(in vec3 pos) { + const float e = 0.0005; + const vec2 k = vec2(1, -1) * 0.5773 * e; + return normalize( + k.xyy*scene(pos+k.xyy) + + k.yyx*scene(pos+k.yyx) + + k.yxy*scene(pos+k.yxy) + + k.xxx*scene(pos+k.xxx) ); +} + + +vec3 render(float dist, vec3 pos) { + if (dist > MAX_DIST) return vec3(0.0); + + vec3 n = calcNormals(pos); + + #ifdef NORMALS_ONLY + return abs(n); + #endif + + float dif = 0.9 * clamp(dot(light, n), 0.0, 1.0); + + vec3 albedo = vec3(1.0); + vec3 ambient = vec3(0.1); + return albedo * dif + ambient; +} + +// check to make sure y is represented in the correct coordinate space +vec3 lookat(vec3 orig, vec3 eye, vec3 pos) { + const vec3 world_up = vec3(0.0, 1.0, 0.0); + + vec3 z = normalize(pos - eye); + vec3 x = normalize(cross(z, world_up)); + vec3 y = normalize(cross(x, z)); + + mat3 look = mat3(x, y, z); + + return orig * look; +} + +void main() { + // Normalized screen coordinates (from -1 to 1) + // quite helpful for figuring out ray direction without doing an explicit + // perspective projection + vec2 uv = (texCoord - 0.5 * u.resolution.xy)/u.resolution.y; + + // adjust for vulkan + uv.y = -uv.y * u.aspect; + + float ylook = 0.0; //4.0 * (iMouse.y - 0.5 * iResolution.y)/iResolution.y; + + float a = mouse.x / u.resolution.x * 2.0 * PI; + + vec3 pos = vec3(4.0 * cos(a), ylook, 4.0 * sin(a)); + vec3 dir = lookat(normalize(vec3(uv, 1.0)), pos, spos); + + float dist = march(pos, dir); + + fragColor = vec4(render(dist, pos + dir * dist), 1.0); +} diff --git a/samples/raymarch_fractals/shaders/mandelbulb.glsl b/samples/raymarch_fractals/shaders/mandelbulb.glsl index fa327bc..5cc683b 100644 --- a/samples/raymarch_fractals/shaders/mandelbulb.glsl +++ b/samples/raymarch_fractals/shaders/mandelbulb.glsl @@ -11,8 +11,6 @@ layout(location = 0) out vec4 fragColor; layout(location = 0) in vec2 texCoord; -const vec3 spos = vec3(0.0); - const float sp_radius = 5.0; layout(binding = 0) uniform FragUniforms { @@ -42,7 +40,7 @@ vec4 freakyFractal(in vec3 pos) { if (r > yeet) break; - float theta = acos(z.z / r) + TIME; + float theta = acos(z.z / r); float phi = atan(z.y, z.x); dr = pow(r, power - 1) * power * dr + 1.0; @@ -56,11 +54,16 @@ vec4 freakyFractal(in vec3 pos) { sin(phi) * sin(theta), cos(theta) ) + pos; + + z.y = clamp(z.y, -1.0, 1.0); } return vec4(0.5 * log(r) * r / max(dr, 1e-6), abs(normalize(o))); } +const vec3 spos = vec3(0.0); + + vec4 vecScene(in vec3 pos) { return freakyFractal(pos); } @@ -172,7 +175,7 @@ void main() { // adjust for vulkan uv.y = -uv.y * u.aspect; - float ylook = sin(TIME * 0.5) * 4.0; + float ylook = 0.0;//sin(TIME * 0.5) * 4.0; float a = mouse.x / u.resolution.x * 2.0 * PI; diff --git a/src/math.zig b/src/math.zig index f05ce0b..2340c0c 100644 --- a/src/math.zig +++ b/src/math.zig @@ -369,4 +369,13 @@ pub const Mat4 = extern struct { return true; } + + pub fn scale(by: Vec3) Mat4 { + return create(.{ + .{by.x, 0, 0, 0}, + .{0, by.y, 0, 0}, + .{0, 0, by.z, 0}, + .{0, 0, 0, 1.0}, + }); + } }; diff --git a/textures/clear.png b/textures/clear.png new file mode 100644 index 0000000000000000000000000000000000000000..6d649b69753ccd696bc795135d1d2bfe9e4606f3 GIT binary patch literal 1053093 zcmeFZ_gj-^8#hj$`bcdRrO1%kMhX;B94wi&Wk|~?)c|1x1=&kbMgk=5V=E(!M-b2; zU;zOWAVSy>B87l}m@-1x5s(=|2q6Rlgzt50`@BDW|A6;B>d_pz!)os9KCkoqtUJj+ zI@lchRPj>@35jF2S1o^%kT}u_Jw7=MzH;u4zzjScxqTIJM?&H=8R+qm1pbMF#0d!r zTgxlgW1p<bLe(_Z1P{iNI5_kXeh1B0Kes=ihfAV21{#mZS zYT}>j`fDNn*(ZN3#6NB2uZ8%h3;(qc|ICxW7UG}r``1GJ10?=h2#J4y#9u4%50Ln4 zA^rgpe=WrS%|OE9JCYYwT+AeS9SrF18cDo0bovR-(A`z|>)hTlN4zvKyKnCu7t`o` zSMYsL@&BQ7+fm*kC5gS2nv1f3{XFI)yTp%wF0}X`W82e@UvHN@_;&KJ1Qq{3y0&ik zMe4^tdzt-@{%w=qe?jH{eBsoIu8&^o7XFXaVeVT-NUZmr{+s^&TzJ7rSz<5pe?;-^ z;>%Cr65BMHzxm}$`U5Q~2~0#Lfq)t7{_72brvrxF-+x3x;-8uS*TVcW^Z#0ie`fyQ zTjigb|JO?VGxPsii2wIzKGqYv2@SaI4C%k;hy+#zyIJS;(OZ}M|C>e<|9@TLZFuka zbqUO~|Ba=e4}SWW5%|K9zXi>o4-{dSB{07K`w0n&rC;}Q6W%ZJdf$fb!8~;mQQ3<` z2w?n9CqUe#2*stL(fw^g_O zX#v&NJ6LNsRC{$uYe?@b-_*+wQNJQU6I-Z`L#^N^_b9Ag6CyaXZO7f>q-}ZX>OBdG z57>YjEiOA)KFB^Nhimt)Uee9&YmaPt%@u>w8IKP)$V>ABZ!z+clA}fz@7Bdrj%7o< z5c3}0bLYIPT`dtgPA9EST1opNx+0rWYbul)=7VIxi=euc`N&g5hPE@Y`IviU@6{}A z0wG1G4=jSguS6;}rG@|wmjvhw%2KEMY7~whexPo9^zc0`XQHc)+=aY;?>aXteCdPI zz*`8pKzx^R7p_LKHcK9Ry8YYac?pS^ z^b|(9#9r?YYvPYppu*WJ+FvddFUMYdoJy*ys>k2pY-~ivTznkj;pG+Xs6kF!zT12` z-(i=(V+zhhXCbPj-c<)$NvD&cFPu+WSq{sLz@pb|MZ{5%I=OwXYIFz!x;{1ie#a}mDgMW^_CuqS zlc@~jTfvyHCJ*aO^#_ZBgPb~@lyX>+R?6t;XcB=C*3mkD(V%PY5q**4Q;h;ilGldZ1^D-$(ucw$m*xHWU37s@lI0~~L zf-WaGpz{^dtib`aT+K~QD1ESGd3kv*bG&UoAD=nD@NjM{^lYlix`n7uNdmvt$J(W^ zE>#2H0K*gCx$@*lgv8$9`rO{0se_|qu~v%fxm;=K(D;!>u&T+|eXj;P7rY(mywM*F_SOJbSS&wqIJEy=k3{mJzCmtoKR9ys%~l; zb9kA8kLo^d;ok{7ij-6l&6*8&sQSV6fY>Gjvoo)@8}WKz0KW6cq8af z-3!V>&od8)_(~&4Ec0-gCVj8PK)DAR)z#I~9W&<%Nl>{i-})Tv4nH!&t|}bXPu5~y zqYvt(O`|K9Kv%h1^Jv=68?NJh*=yLz3t!<=XPT*X+J0k6xC@#^YM0Ujf7=#(?UALf zya`^rq*`aO&2b+r)}p?lf%&DI9C;q5VK`)j5uO8oUmb2~DNC$L0$b9YN^WdzO{ICu z_03RL&&x-HbgNK71#JXGk0m^hRLA3o#54EFFbs&Hve@17eS z8%xfgs)U{@D=Ued%Bi8Ww6whZd`i|pfZo(pCDuY&%D>;3N!^V(2-~@XnE>sEM5exJ zz7F^nRqq2so8~WK#fv+UP0CP%@dS^rY=3e9J$hhZV1H<6ZkL3lh}JhZYq4mIba!`m z1PV1)#e2;+MN@P(^l*BWnm8-B#Oq_|Y`;!U^Pus=6od5OZ<`jVNK*PUGzEDbUL*B; z4yUB1CUtaF!64Ys=gyr=8>S?mO6{T)Sc;X(8(F7B=Y5O?=(RI9PDe*ad!HXq0w=O` z{IH<2K?gS$A}8-(7Ja`2s7~?K0AdGFiIn*S$TVJGo+IHlOZzbLlxw^JCt*olrHZeAKd17+>GHZIeO(CQEeaAFI zg^6OsZ&=c=KayC_vpXUAlJxKQgZpLpe=T;&)FsyBWC+sJljGs(8S3fbvFe2^;Og-v z!1kRH2%?@86m;FXn9OFgqn=*xx@(+9Ab8)oL(T_%5plhT^RAAdJsy=8Sn=JncLukA zfZ=ZK-|0{JbLOc$7`osMDz!gjpRdBaR?pNPfAReBxAo)(r8%CFburp_6nuMfa?-L{ z>N#vBRvU*_bgxbysE@AqF&a(c#kL|Ho5vgiLGOF>#$k44_9C>}3oF_w^V;<>F|$2G zW!2c&6Oy|v@4Hw0nZAn}S!}Ib;vv1tgkfZRx6DF z{YK;CH$F85j|}r2Ko_=h8on^)U7e(7Kaox9gHPd}Av!@-BB^Tg#__LfLR8)y8)4Qx z{>er1u2oa3XS-X@09!DwPwc#<5nlLioX#C*BRd}cZG-E8a?y` z6h=yrEP0v3R;bjJO}CyCVa61@#bQiIXebSI_04HYT=>@3)|)M%Fhdv}`Wp|DpzIQcK9bAjeIK|4GKGn z@>!4iH6jvFGMbv25fKs6U=U@NAUWuR_4DT9E<;eZ-2-Y;Fvqw7?&1KKIWyYTbsoH* z)9&3~EiEkr8r9dAbd)!nS`>Sjb$QZ*B8G7p}qC zzjHT!^6(uO(46x6SB}KFxC|(TSSrHfupwcLYJ_6L5X;&3lrO^ar{Nhl#M$v(qIQ<+ zS5_4{ebL??PA3QY!aAB-ZhFYl;&>jGmQMX(2#QnzX5qJ{ea1J0{$yBKP9zWsCR7v-2s&t>0Z-*UYT0LCa5(r57ZfLdU~1% zutI2fcwyc-Nichws9{GX|DHTQdtJlsbz@tx@$vBo{dq2q(`{zWSTq_P8xc``C*Fhf zs=_6vpgR&ldJqDuO=|RXY!;I>q=HLBrx=ztfq0u7fj2y7fX-hMtjHDv6vGkGp|K&T zi55-VIG?0m2@n&Qz*JVo%+vI@HG*r|R%Q`l&5vxHu7h>{|VyQ>n;IP+895g*$e>ztB??icv(&4p-ch}*aSv`#D@C_nZuu(htT*$-|>&-M4C|K(L+RlvCE zljF;Y*_zZ~W5cO! zU%u;>m=LH)3zF^kbe0UYH9?%Wttnp_i*dS6e6?1QAG$UNM_3`8AE*baw97^XJD-Fr z?de~eC0tB?1?wfG1i`J~XIY)O_@!N zk2i1cvkq8}*!yaqNl2^{-(~#q5Ol616?XrIh^qcNNz9;*8(Ubgu)AA=EW_|=Q}oWp ze4?&bn<^EvZ+!0D8}EycE6OSuU%J6%!5Bd}dg3bbtH88nM!1h#n-gmaq;h=$U?W}~ z+KZkFgjV|8M-9g?h3;uHKpU-Aq+^A5q&8e4J6j5}X`Bo3- zgH)U=XBYew0ctGGGS)c5B!1&hMwA3vwjqh=+qX|73e~z|O;eC0`95#izMZ1{pGHiv zpkSw;s=2$HKs-}V5iCo@-Mc601!lP7;)aOG$j@!US#`YYSfc=!zy*{ln5L>`@yaaG zRyd6%a>t&Dj%k?ai2+TuV9`k~>P8emPTXkr;KHzzvh0U#tuc+I~ zfu;pjpIErLJOq#^I2C4FPP?(Sa@t`|q3;9BTPQu5xgsrgPY7I=BDmm-nnnT|%@&mJ zBTeAv=^~Ey@G^S*2EH^R{;ndR`_n3FG&Yko$C+q=&N_U$H5qV+#^%OU@cz-?&qSWe zT8?_?dkR3Zs6TTV^npJ1+ZPDKiGb2Kva}jXZr-1vO$A!uqP0ZVUB-ez(WDLQUx}+j zi~;549i?`^`SGuf9+l%l>-|;V-BH0WUp=rMba@CO>Umf3AW3V|>l5CXRT{f?WfD#{S(GpRgVRG@88 zIP#H;)5!4yj6$thz5#yQVukBo3zGnle7qeLyhSD`K<+O)7bSZ z04{coym3%RC|Wsnh8W;_ZprbNLnzi{sRmKUm5^|*b!I74fENn8i7uqs9sVM3W1bI? zb;Z5s^8|CRK$R==D9T73a<^H!Fn%*)Z%f#wbX?UmpqT27=*B>h8H~)$O+9F2E^UVb zbjcw30-!^Zr(i6ATosbu9Rccco5K=wV)x$JhJO)tx0+0rX~}bk-n{8} z(oDIU(p*HUb@7sbFKT32^bkP$P$X~Ax}ox)Te8)NnqT~i;%% zB?h2OAg?@hs*7MTXue?XcK7tyw#aS0d#4Va5LBLk4`ubJSCKTFa^NRvgkvXgMM>>1 zVFFFLv1aiv8#{IQ${e_?CNB-?Qi%_a-D3uhDSk%PjTGlAw>D zCMBsCrTsGg+?^;A_U)JsB2_jv$)*Md2D1ajni1Ugd!r^ssbB`b8hJ1n-+>vj z-Xq=83x#jS|Exgzy3yjzGr-mL*X*v=mV4kV-B%P;mcf|uP?6Wa))*ZV;}hq9$sE0L z(=>kj{D$}i($=_;7GeNem#v)!+4by7c@>g5j%yE4Kuu?OBOqR)OWnIzU=}CGWahF1 zZwlNPqRZ@9qPgP^I&IZDBs`osG!h+C%w#iyE&R!k?89bfi_+`;$Y|p!@48f4QThfx zyB6p;XjHJ9 zY|ev+R_cL@(t7uq9sl$$~d0Y-i#aw^OTw_~7C(#hJ&Ag%5-L248v;YP{ zl-yi-0o{=_p-^?C5C26KDqJtvIZyZl-@M$XU%fX{);2m$3ab4Y^XVd>%oSFZ&H5r9 zGJt?3;uTTkK>Iv7kN(z&QGjzz%&S9-JemuPm|7`C2?th|uNV1{(yA=w6B7feBR-%x z0cJ5bP;A5gajnNi$Yo*q83#NIxn4j#`I}x!9s0od-TUK%T#iW>1A+Xa8JNx%#>UOq zyLUI=mt|#H+dP0e5eW$@{COB)jiYDj{OD)CP)(BpQ#SWN{!x%ZG`RT#G2HdNLjd3*X_}aN}d)}rimSo&bmC9-`7eZ9P7r% z5p?=q#oZGr>_&}_&?O%%ASeX}bf0kS88kvwQc~z07iVH%lNS*is~|kirFC^#udZ>e zEIWe|GU_9c&NjdG;|ERcr$5^!5Zah{L6a|n<;CA=O?YCkrPJqHxgsbBO%syPEG#mZ zBv#k_d{k>J4~A?*%i7r3L_|l+mH7jaDM}WM&xnLOr)+bqsvDEjX0#0Mca#&f4GaxW z57rh8*B7vzZAxe&%77iky(;6&k>5RQkTUMpb?LKsp= zh&T{;xL^;s2m5)2b2ds65>ymM?&cFMsh_<*`JkiFUwZA)yx#dDO0#-y@i#X&-!3gJ zi9w52ZHwj276aUwn%5H!>6nCqS$&10rIM z<;3$NA$X&&e;7=vO^zZM+z-<5fWu`GcEZz`DXHU7{YD)X zZoik2w%#}>_2)l%LgO#$&XMUBB<90{RvfLO;L{Pcqwlqz+Nfx>TcVRo)}uFJu)Z1* zRdjcFXaY@9NEL{`eUNoZT~0>Bo`__~j7W)CmEc>L0(Dn)B9`rn)YJ;=!E5P$KP zXvGq<#No3sSYgau`#niW+qgq{qC30OC(oNxJ1`P+sQV2(k$^2Mt<*n=W*+j}7no&f zz^_{&ye4W=z;KD(m?>_=-d337Y4z5mF4Dca1h?c2$vejHnvYfD*U#H#Ufn>3q#MA} z)N4$WYmfX}5@nJQYMgIfu;m>SV+ggVj^h@ofT^C8l$5NlYm)A`X_jBrR0g~fJ(8M* zBiUe~;xsjY4o_%fRs&0j)Nd`Pk%|g_Zt$?q5x|mlYW56%4fbx@aQG2O!$~#A)VTMF{oFk2 zkR@7hy$jWH-^g}obb30S!{NlPzimfzR_?{T@4QO`#ft!r#gbcE;ykr-^s+BN z^?se6o-VeIn54uBL5gSZ+YjwntSFw<6~in{OeVm?#MI2p%m_Tw${ z3En~)Eku=A6QI_Bs%ZJe%jsmpjHCJheQ0!i>U}pTf}NuN0~?-WYxZyMnkB^>VdEhPZq09F+F1m@i35BKps@m? z#`R#0$g{atCeMgFO;MUIq)xlA;yS-(7J!$)M4ZTThlWR-L$T6AoOYNBt{sa{mSWtf@@BjDdwlsW-6XkbV4`%4&C(rsJ#$ zb>E%0KGTt;1z@r%X4AzYd68b&%^O1jC(d9gsOpNPBGB{(TjfpM^91|9EqIn9HUu1@hIr# z@gm}P=5r&W<3IOG*s*$|QrJmDsSpba3akNZi-=&fC4yo;nz(}|cxgIbZfM&NnaDJ) zb%ub^7*�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ÖZ(o;*c?DXD;%P&}{$F5B@1(rLmZqssGx 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

p? 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 z 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

N0L0pFda>r^8_`3!->=FDRf*3l#d6@N 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%0Ds^Lm7bL5lc>_Vj7%Uvz)guH=nxw{ad#Z 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�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

)@DLw_O}1S8;Iq`Mo!cCnDqJPjg=Q9 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⪚IcjhZ)_-fSFf^<8tM!O#LJTq*Ac^uHA;PH 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

  • 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 gyl1%>MEHI6m(X1h?A(?A1?)bd0{{R3 literal 0 HcmV?d00001 From 8880471eb4a5a180edacd71ebfcb37c6d257d829 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Wed, 15 Oct 2025 21:10:30 -0700 Subject: [PATCH 38/46] feat(factory): implemented some of the infastructure required to get generalized initiailizers up and running --- build.zig | 8 +- src/api/api.zig | 8 +- src/api/command_buffer.zig | 29 +++-- src/common/util.zig | 38 ++++--- src/context.zig | 25 ----- src/factory.zig | 3 - src/resource_management/factory.zig | 159 +++++++++++++++++++++++++++ src/resource_management/registry.zig | 156 ++++++++++++++++++++------ 8 files changed, 330 insertions(+), 96 deletions(-) delete mode 100644 src/factory.zig create mode 100644 src/resource_management/factory.zig diff --git a/build.zig b/build.zig index 80f5115..47b83e1 100644 --- a/build.zig +++ b/build.zig @@ -105,22 +105,22 @@ const SampleEntry = struct { }; var sample_files = [_]SampleEntry{ .{ - .name = "basic_planes", + .name = "basic-planes", .path = "basic_planes.zig", .desc = "basic showcase of bootstrapping vulkan up to 3d rendering", }, .{ - .name = "compute_drawing", + .name = "compute-drawing", .path = "compute_drawing/main.zig", .desc = "drawing using compute shaders", }, .{ - .name = "test_sample", + .name = "test-sample", .path = "test_sample.zig", .desc = "test to see if the sample build steps work correctly", }, .{ - .name = "raymarch_fractals", + .name = "raymarch-fractals", .path = "raymarch_fractals/main.zig", .desc = "pick from a selection of raymarched fractals, all programmed within fragment shaders", }, diff --git a/src/api/api.zig b/src/api/api.zig index 8228f07..edeb429 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -77,7 +77,7 @@ pub fn initRegistry(reg: *Registry) !void { try CommandBuffer.addEntries(reg); } -comptime { - _ = @import("memory/allocator.zig"); - _ = @import("memory/Heap.zig"); -} +// comptime { +// _ = @import("memory/allocator.zig"); +// _ = @import("memory/Heap.zig"); +// } diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index f888255..ae9f2dd 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -114,8 +114,20 @@ pub fn deinit(self: *const Self) void { const res = @import("../resource_management/res.zig"); const common = @import("common"); +const Registry = res.Registry; pub const CommandBuffer = struct { + pub const entry_config = + Registry.EntryConfig{ + .State = CommandBuffer, + .Proxy = CommandBufferProxy, + .init_errors = CommandBufferInitErrors, + .config_type = Config, + .management = .Pooled, + .initFn = dummyInit, + .deinitFn = dummyDeinit, + }; + h_cmd_buffer: vk.CommandBuffer, h_cmd_pool: vk.CommandPool, @@ -123,7 +135,11 @@ pub const CommandBuffer = struct { one_shot: bool = false, }; -const CommandBufferInitErrors = error { +pub fn addEntries(reg: *Registry) !void { + reg.addEntry(CommandBuffer); +} + +const CommandBufferInitErrors = error{ Something, }; @@ -137,17 +153,6 @@ fn dummyDeinit(self: *const CommandBuffer) void { _ = self; } -const Registry = res.Registry; -pub fn addEntries(reg: *Registry) !void { - reg.addEntry(.{ - .state = CommandBuffer, - .proxy = CommandBufferProxy, - .init_errors =CommandBufferInitErrors, - .config_type = Config, - .management = .Pooled, - .requires_alloc = false, - }, dummyInit, dummyDeinit); -} pub const CommandBufferProxy = struct { const CommandBufferHandle = common.Handle(CommandBuffer, .{}); diff --git a/src/common/util.zig b/src/common/util.zig index 8c127aa..3774b47 100644 --- a/src/common/util.zig +++ b/src/common/util.zig @@ -1,5 +1,5 @@ //! TODO: Merge this into the common directory -//! Most of this is completely unused and useless, so +//! Most of this is completely unused and useless, so //! only a bit of this iwll be included... const std = @import("std"); const builtin = @import("builtin"); @@ -19,11 +19,11 @@ pub fn asManyPtr(comptime T: type, ptr: *const T) [*]const T { //FIXME: This is due for a BIG REFACTOR COMING SOON // (because it is much worse than just &.{} which I Didn't know was a thing oops. -// funilly enough, &.{1, 2, 3} is shorter than span(.{1, 2, 3}). I just don't +// funilly enough, &.{1, 2, 3} is shorter than span(.{1, 2, 3}). I just don't // like reading docs + idk how. -pub fn span(v: anytype) [] @TypeOf(v[0]) { +pub fn span(v: anytype) []@TypeOf(v[0]) { const T = @TypeOf(v[0]); - comptime var sp: [v.len] T = undefined; + comptime var sp: [v.len]T = undefined; for (v, 0..) |val, index| { sp[index] = val; } @@ -46,13 +46,30 @@ pub fn tryGetField(info: *const StructInfo, name: []const u8) ?*const StructFiel return null; } +pub fn fnSignatureMatches( + comptime A: type, + comptime B: type, +) bool { + const info_a = if (@typeInfo(A).@"fn") @typeInfo(A).@"fn" else + return false; + const info_b = if (@typeInfo(B).@"fn") @typeInfo(B).@"fn" else + return false; + + if (info_a.params.len != info_b.params.len) return false; + + for (info_a.params, info_b.params) |a, b| { + if (!std.meta.eql(a, b)) return false; + } + + return true; +} + /// returns the percentage of a number /// should work for all numeric types pub fn pct(num: anytype, percentage: @TypeOf(num)) @TypeOf(num) { return @divTrunc(num * percentage, 100); } - const BasicMemUnits = enum(usize) { Bytes, Kilobytes, @@ -60,15 +77,10 @@ const BasicMemUnits = enum(usize) { Gigabytes, }; - /// Obviously, val should be numerical, but should /// otherwise work with integral and floating points, /// illegal divisions notwithstanding. -pub inline fn transformMemUnits( - comptime from: BasicMemUnits, - comptime to: BasicMemUnits, - val: anytype -) @TypeOf(val) { +pub inline fn transformMemUnits(comptime from: BasicMemUnits, comptime to: BasicMemUnits, val: anytype) @TypeOf(val) { const ValueType = @TypeOf(val); const info = @typeInfo(ValueType); @@ -82,18 +94,16 @@ pub inline fn transformMemUnits( b *= 1024; } - if (info == .int) { return @divFloor(a, b) * val; } else { const fnum: ValueType = @floatFromInt(a); const fden: ValueType = @floatFromInt(b); - return (fnum / fden) * val; + return (fnum / fden) * val; } } - pub inline fn megabytes(val: anytype) @TypeOf(val) { return transformMemUnits(.Megabytes, .Bytes, val); } diff --git a/src/context.zig b/src/context.zig index 3134062..c11790c 100644 --- a/src/context.zig +++ b/src/context.zig @@ -274,28 +274,3 @@ pub fn EnvSubset(comptime fields: anytype) type { }, }); } - -//BUG: This cannot work since windowless contexts would require -//a lot more features that I currently support -// test "windowless context" { -// var allocator = std.heap.DebugAllocator(.{ -// .safety = true, -// }).init; -// defer { -// _ = allocator.detectLeaks(); -// if (allocator.deinit() != .ok) { -// std.debug.print("Oppsies\n", .{}); -// } -// } -// try glfw.init(); -// -// const extensions = glfw.instanceExtensions(); -// -// var ctx = try Self.init(allocator.allocator(), .{ -// .inst_extensions = extensions, -// .loader = glfw.glfwGetInstanceProcAddress, -// .management = .{ -// .allocator = allocator.allocator(), -// .pool_sizes = 1024, -// }, -// }); diff --git a/src/factory.zig b/src/factory.zig deleted file mode 100644 index ad118a8..0000000 --- a/src/factory.zig +++ /dev/null @@ -1,3 +0,0 @@ -//! low-level API factory -- contains initializers -//! for memory managed API types which are in turn wrappers -//! to their unmanaged versions... diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig new file mode 100644 index 0000000..a467231 --- /dev/null +++ b/src/resource_management/factory.zig @@ -0,0 +1,159 @@ +//! Creating and destroying API types with a unified context, +//! configuration parameters, and common configurable interfaces. +const std = @import("std"); + +const Context = @import("../context.zig"); +const Registry = @import("registry.zig"); +const Self = @This(); + +const testing = std.testing; +const common = @import("common"); +const cfg = common.config; +const api = @import("../api/api.zig"); + +const Config = struct {}; + +const FactoryVariant = enum { Managed, Unmanaged }; + + +const crapi = Registry.ComptimeAPI; + +pub fn APIFactory( + comptime variant: FactoryVariant, + comptime fac_config: Config, +) type { + // common set of functions + const FactoryBase = struct { + const FactoryBase = @This(); + ctx: *Context, + + pub fn createBase( + self: *FactoryBase, + comptime APIType: type, + inst: *APIType, + config: crapi.ResolveConfigType(APIType), + ) !*APIType { + const ConfigType = @TypeOf(config); + const EnvFields = crapi.ResolveEnv(APIType); + const ErrorType = crapi.ComptimeEntry(APIType).init_errors; + const InitFunc = *const fn ( + *APIType, + *Context, + *EnvFields, + ConfigType, + ) ErrorType!APIType; + + const reg_entry = self.ctx.registry.getEntry(common.typeId(APIType)) orelse + return error.InvalidAPIType; + + const populated_env = EnvFields.populate(self.ctx.ctx_env); + // nice and safe. + const initFn: InitFunc = @ptrCast(@alignCast(reg_entry.initFn)); + + try initFn(inst, self.ctx, populated_env, config); + return inst; + } + + + /// Used for lifecycle deinits, users can just directly call + /// deinit for the low-level API + pub fn deinitBase() void { + } + }; + + return switch(variant) { + .Managed => struct { + const Factory = @This(); + + base: FactoryBase, + + /// some management modes return different handle variants or just pointers. + /// This depends on the handle variant of the particular type + pub fn init( + self: *Factory, + comptime APIType: type, + config: crapi.ResolveConfigType(APIType), + ) !crapi.ManagedReturnType(APIType) { + } + + pub fn initPreconfig( + self: *Factory, + comptime APIType: type, + comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, + params: anytype, + ) !crapi.ManagedReturnType(APIType) { + } + }, + .Unmanaged => struct { + const Factory = @This(); + + base: FactoryBase, + + pub fn init( + self: *Factory, + comptime APIType: type, + allocator: std.mem.Allocator, + config: crapi.ResolveConfigType(APIType), + ) !*APIType { + } + + pub fn initPreconfig( + self: *Factory, + comptime APIType: type, + comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, + allocator: std.mem.Allocator, + params: anytype, + ) !*APIType { + } + + pub fn initInPlace( + self: *Factory, + comptime APIType: type, + inst: *APIType, + config: crapi.ResolveConfigType(APIType), + ) !void { + } + + pub fn initInPlacePreconfig( + self: *Factory, + comptime APIType: type, + comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, + inst: *APIType, + params: anytype, + ) !void { + } + }, + }; +} + +test "factory functionality" { + const app = try Context.init(testing.allocator, .{}); + + var managed_factory = app.getAPIFactory(.managed, .{}); + var unmanaged_factory = app.getAPIFactory(.unmanaged, .{}); + + const jerry_face_image1 = try managed_factory.init(api.Image, .{ + .some_image_config = .yadda_yadda, + }); + + const jerry_face_image12 = try unmanaged_factory.init( + api.Image, + testing.allocator, + .{ + .some_image_config = .yadda_yadda, + }, + ); + + var jerry_face_image121: api.Image = undefined; + try unmanaged_factory.initInPlace( // this variant only exists on unmanaged thingies + api.Image, + &jerry_face_image121, + .{ + .some_image_config = .yadda_yadda, + }, + ); + + const jerry_face_image2 = try managed_factory.initPreconfig(api.Image, .SomeProfileName, .{ + .extra_option = .yadda, + }); +} diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index 8cff2de..5bbac67 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -5,8 +5,23 @@ //! This is globally defined and not scoped to an application context const std = @import("std"); +// this is an example of how api functions should be signatured +// There are 2 possible signatures, one without an allocator, +// and the other with it. The expected signature is configured by +// How the entry is specified in the type registry at compile time. +// Due to the function pointery nature of this crap, error unions need to be explicitly specified +// For types that require ad-hoc initializatoin allocations, +// (This is usually I sign that I messed something up) +// pub fn exampleInit( +// self: *Self, +// ctx: *Context, +// env: SomeEnvSubset, +// config: Config, +// ) error{bitch}!Self {} + const common = @import("common"); const Context = @import("../context.zig"); +const cfg = common.config; const Allocator = std.mem.Allocator; const AnyPtr = common.AnyPtr; @@ -14,12 +29,21 @@ const TypeId = common.TypeId; const Self = @This(); +pub const PfnAddRegistryEntries = *const fn () []EntryConfig; + +pub const ManagementMode = enum { + Unmanaged, + Pooled, + Transient, + Streamed, +}; + pub const EntryConfig = struct { // type for storing data - state: type, + State: type, // type for associating and operating on data - proxy: type, + Proxy: type, // error set for init functions (omit for anyerror) init_errors: ?type, @@ -27,8 +51,60 @@ pub const EntryConfig = struct { // the type of the configuration struct (if any) config_type: ?type = null, // whether or not initialization depends on an allocator - requires_alloc: bool = false, management: ManagementMode = .Pooled, + + initFn: *const anyopaque, + deinitFn: *const anyopaque, +}; + +fn ManagedResourceType(comptime mode: ManagementMode, comptime T: type) type { + return switch(mode) { + .Pooled => common. + }; +} + +/// Comptime registry API +/// In comptime, the types themselves are the registries. +/// Hopefully, this doesn't slow compilation to a crawl... +/// The working of this registry API depends on a coherent +/// naming scheme for faster lookups +pub const ComptimeAPI = struct { + + // gets the config registry, cuz thats a generic + fn ConfigRegistryFor(comptime T: type) type { + return if (@hasDecl(T, "Registry")) @TypeOf(T.Registry) else + @compileError("Invalid type " ++ @typeName(T) ++ " (missing config registry)"); + } + + /// Resolves the handle type from the API type as well as the management mode + pub fn ManagedReturnType(comptime T: type) type { + const registry = GetRegistry(T) orelse + @compileError("Invalid type: " ++ @typeName(T) ++ " (missing type registry)"); + + return registry.Proxy; + } + + pub fn ResolveConfigRegistry(comptime ConfigType: type) ConfigRegistryFor(ConfigType) { + return ConfigType.Registry; + } + + pub fn ResolveConfigType(comptime APIType: type) ?type { + return if (@hasDecl(APIType, "Config")) APIType.Config else null; + } + + pub fn GetRegistry(comptime APIType: type) ?EntryConfig { + if (!@hasDecl(APIType, "entry_config")) return null; + return APIType.entry_config; + } + + pub fn ProxyFor(comptime T: type) type { + const entry_config = GetRegistry(T) orelse + @compileError("cannot create a proxy for: " ++ @typeName(T) ++ " (no entry config)"); + + return struct { + handle: entry_config. + }; + } }; // this returns the meta-information of the registry entry @@ -38,7 +114,7 @@ pub fn RegistryEntryType(comptime config: EntryConfig) type { // remember, these functions should be remapped first arguments to the proxy pub const InitFnType = InitFnTemplate(config); pub const DeinitFnType = DeinitFnTemplate(config); - pub const entry_id = common.typeId(config.state); + pub const entry_id = common.typeId(config.State); }; } @@ -50,24 +126,24 @@ fn InitFnTemplate(comptime config: EntryConfig) type { const error_type = config.init_errors orelse anyerror; if (config.config_type) |ct| { if (config.requires_alloc) { - return *const fn (*config.state, *const Context, Allocator, ct) error_type!void; + return *const fn (*config.State, *const Context, Allocator, ct) error_type!void; } else { - return *const fn (*config.state, *const Context, ct) error_type!void; + return *const fn (*config.State, *const Context, ct) error_type!void; } } else { if (config.requires_alloc) { - return *const fn (*config.state, *const Context, Allocator) error_type!void; + return *const fn (*config.State, *const Context, Allocator) error_type!void; } else { - return *const fn (*config.state, *const Context) error_type!void; + return *const fn (*config.State, *const Context) error_type!void; } } } fn DeinitFnTemplate(comptime config: EntryConfig) type { return if (config.requires_alloc) - (*const fn (*config.state, Allocator) void) + (*const fn (*config.State, Allocator) void) else - (*const fn (*config.state) void); + (*const fn (*config.State) void); } pub const RegistryEntry = struct { @@ -75,46 +151,59 @@ pub const RegistryEntry = struct { type_name: []const u8, size_bytes: usize, - initFn: AnyPtr, - deinitFn: AnyPtr, + initFn: *const anyopaque, + deinitFn: *const anyopaque, management: ManagementMode, }; -pub const ManagementMode = enum { - Unmanaged, - Pooled, - SomeThirdThing, -}; - entries: std.ArrayList(RegistryEntry), +typeid_index: std.AutoHashMap(TypeId, *const RegistryEntry), pub fn init(allocator: Allocator) !Self { return .{ .entries = std.ArrayList(RegistryEntry).init(allocator), + .typeid_index = std.AutoHashMap(TypeId, *const RegistryEntry).init(allocator), }; } +/// the type referenced by "T" must match the shape of +/// a configurable type as defined in the "CRAPI" +/// type specification pub fn addEntry( self: *Self, - comptime config: EntryConfig, - comptime initFn: InitFnTemplate(config), - comptime deinitFn: DeinitFnTemplate(config), + comptime T: type, ) void { - const EntryType = RegistryEntryType(config); + const entry_config = ComptimeAPI.GetRegistry(T) orelse + @compileError("cannot create a registry entry for type: " ++ @typeName(T) ++ " (no entry config)"); const entry = RegistryEntry{ - .initFn = AnyPtr.fromDirect(EntryType.InitFnType, initFn), - .deinitFn = AnyPtr.fromDirect(EntryType.DeinitFnType, deinitFn), + .initFn = entry_config.initFn, + .deinitFn = entry_config.deinitFn, - .type_id = common.typeId(config.state), - .type_name = @typeName(config.state), - .management = config.management, - .size_bytes = @sizeOf(config.state), + .type_id = common.typeId(entry_config.State), + .type_name = @typeName(entry_config.State), + .management = entry_config.management, + .size_bytes = @sizeOf(entry_config.State), }; - + // If the type registry fails to build, there is literally nothing to be done about it. - self.entries.append(entry) catch @panic("Failed to build type registry due to an allocation error!"); + // Probably shouldn't just panic tho :( + self.entries.append(entry) catch + @panic("Failed to build type registry due to an allocation error!"); + + self.typeid_index.put( + common.typeId(entry_config.State), + &self.entries.items[self.entries.items.len - 1], + ) catch + @panic("Failed to build type registry due to being out of memory"); +} + +pub fn getEntry( + self: *const Self, + id: TypeId, +) ?*const RegistryEntry { + return self.typeid_index.get(id); } pub const PredicateFn = *const fn (*const RegistryEntry) bool; @@ -167,13 +256,12 @@ pub const Query = struct { !self.matches(&self.entries[self.index])) : (self.index += 1) {} - if (self.index < self.entries.len){ - const tmp = &self.entries[self.index]; + if (self.index < self.entries.len) { + const tmp = &self.entries[self.index]; self.index += 1; return tmp; - } - else { + } else { return null; } } From da55c00043c58188682563f7fa9b0e879d6aa809 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 18 Oct 2025 06:19:32 +0200 Subject: [PATCH 39/46] feat(factory): Comptime resolution works end to end at least in typical cases --- src/api/command_buffer.zig | 23 ++++--- src/api/memory/heap.zig | 2 +- src/context.zig | 35 +--------- src/env.zig | 58 ++++++++++++++++- src/resource_management/factory.zig | 95 +++++++++++++++++----------- src/resource_management/registry.zig | 33 ++++++---- src/resource_management/res.zig | 6 ++ src/root.zig | 1 + 8 files changed, 159 insertions(+), 94 deletions(-) diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index ae9f2dd..e1c63d6 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -4,6 +4,7 @@ const vk = @import("vulkan"); const base = @import("base.zig"); const util = @import("common").util; const queue = @import("queue.zig"); +const env = @import("../env.zig"); const Context = @import("../context.zig"); const DeviceHandler = base.DeviceHandler; @@ -18,17 +19,13 @@ h_cmd_pool: vk.CommandPool, dev: *const DeviceHandler, one_shot: bool = false, -pub const Config = struct { - src_queue_family: queue.QueueFamily = .Graphics, - one_shot: bool = false, -}; -pub fn init(ctx: *const Context, config: Config) !Self { +pub fn init(ctx: *const Context, config: CommandBuffer.Config) !Self { const dev = ctx.env(.dev); return try initDev(dev, config); } -fn initDev(dev: *const DeviceHandler, config: Config) !Self { +fn initDev(dev: *const DeviceHandler, config: CommandBuffer.Config) !Self { var cmd_buffer: vk.CommandBuffer = undefined; dev.pr_dev.allocateCommandBuffers( &.{ @@ -56,7 +53,7 @@ fn initDev(dev: *const DeviceHandler, config: Config) !Self { return api_cmd_buf; } -pub fn oneShot(dev: *const DeviceHandler, config: Config) !Self { +pub fn oneShot(dev: *const DeviceHandler, config: CommandBuffer.Config) !Self { var buf = try initDev(dev, config); buf.one_shot = true; @@ -117,12 +114,17 @@ const common = @import("common"); const Registry = res.Registry; pub const CommandBuffer = struct { + pub const Config = struct { + src_queue_family: queue.QueueFamily = .Graphics, + one_shot: bool = false, + }; + pub const entry_config = Registry.EntryConfig{ .State = CommandBuffer, .Proxy = CommandBufferProxy, - .init_errors = CommandBufferInitErrors, - .config_type = Config, + .InitErrors = CommandBufferInitErrors, + .ConfigType = Config, .management = .Pooled, .initFn = dummyInit, .deinitFn = dummyDeinit, @@ -143,7 +145,8 @@ const CommandBufferInitErrors = error{ Something, }; -fn dummyInit(self: *CommandBuffer, ctx: *const Context, config: Config) CommandBufferInitErrors!void { +fn dummyInit(self: *CommandBuffer, ctx: *const Context, e: env.Empty(), config: CommandBuffer.Config) CommandBufferInitErrors!void { + _ = e; _ = self; _ = config; _ = ctx; diff --git a/src/api/memory/heap.zig b/src/api/memory/heap.zig index 4c77850..8fba658 100644 --- a/src/api/memory/heap.zig +++ b/src/api/memory/heap.zig @@ -18,7 +18,7 @@ const Heap = @This(); const Context = @import("../../context.zig"); -pub const Env = Context.EnvSubset(.{.mem_layout, .di}); +pub const Env = Context.Environment.EnvSubset(.{.mem_layout, .di}); pub const Error = error { IncompatibleProperties, diff --git a/src/context.zig b/src/context.zig index c11790c..ccb5b7a 100644 --- a/src/context.zig +++ b/src/context.zig @@ -241,36 +241,5 @@ pub fn presentFrame( try self.present_queue.present(swapchain, image, sync.sem_wait); } -const meta = std.meta; - -/// Defines an env subset type which can be automatically populated by a factory -pub fn EnvSubset(comptime fields: anytype) type { - const StructField = std.builtin.Type.StructField; - //const num_fields = fields.len; - - comptime var field_infos: []const StructField = &.{}; - for (fields) |enum_lit| { - const matching_field = meta.fieldInfo(EnvBacking, enum_lit); - const MatchingFieldType = matching_field.type; - - - // This is janky due to how the env system mapps fields oops - const mapped_field_info = StructField{ - .default_value_ptr = null, - .type = MatchingFieldType.InnerType, - .is_comptime = false, - .alignment = @alignOf(MatchingFieldType.InnerType), - .name = matching_field.name, - }; - field_infos = field_infos ++ [1]StructField{mapped_field_info}; - } - - return @Type(.{ - .@"struct" = .{ - .fields = field_infos, - .decls = &.{}, - .layout = .auto, - .is_tuple = false, - }, - }); -} + + diff --git a/src/env.zig b/src/env.zig index f1a6dea..4795a35 100644 --- a/src/env.zig +++ b/src/env.zig @@ -9,7 +9,7 @@ const RefConfig = struct { }; fn ResolveInnerType(comptime T: type, comptime config: RefConfig) type { - const AsPtr = if (!config.mutable) *const T else *T; + const AsPtr = if (!config.mutable) *const T else *T; return if (@typeInfo(T) == .pointer) T else AsPtr; } @@ -126,6 +126,17 @@ fn findParentFieldType(pt: type, fname: []const u8) type { unreachable; } +pub fn Empty() type { + return struct { + const Self = @This(); + pub fn populate(ctx: anytype) Self { + _ = ctx; + return .{}; + } + + }; +} + pub fn For(comptime T: type) type { validateType(T); @@ -134,6 +145,51 @@ pub fn For(comptime T: type) type { const Bindings = MakeRefBindings(T); const Self = @This(); + /// Defines an env subset type which can be automatically populated by a factory + pub fn EnvSubset(comptime fields: anytype) type { + const Declaration = std.builtin.Type.Declaration; + + comptime var field_infos: []const StructField = &.{}; + for (fields) |enum_lit| { + const matching_field = std.meta.fieldInfo(T, enum_lit); + const MatchingFieldType = matching_field.type; + + // This is janky due to how the env system mapps fields oops + const mapped_field_info = StructField{ + .default_value_ptr = null, + .type = MatchingFieldType.InnerType, + .is_comptime = false, + .alignment = @alignOf(MatchingFieldType.InnerType), + .name = matching_field.name, + }; + field_infos = field_infos ++ [1]StructField{mapped_field_info}; + } + + const populate_decl = Declaration{ .name = "populate" }; + + const SubsetType = @Type(.{ + .@"struct" = .{ + .fields = field_infos, + .decls = &.{populate_decl}, + .layout = .auto, + .is_tuple = false, + }, + }); + + const Populate = struct { + pub fn populate(ctx: anytype) SubsetType { + var new: SubsetType = undefined; + inline for (field_infos) |fld| { + @field(new, fld.name) = @field(ctx, fld.name); + } + } + }; + + SubsetType.populate = Populate.populate; + + return SubsetType; + } + inner: T, pub fn ResolveInner(comptime field: ContextEnum) type { diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig index a467231..e259f6c 100644 --- a/src/resource_management/factory.zig +++ b/src/resource_management/factory.zig @@ -22,6 +22,11 @@ pub fn APIFactory( comptime variant: FactoryVariant, comptime fac_config: Config, ) type { + + // Dunno why I put this as a parameter, but might use it later + // so I'll keep it. + _ = fac_config; + // common set of functions const FactoryBase = struct { const FactoryBase = @This(); @@ -32,16 +37,18 @@ pub fn APIFactory( comptime APIType: type, inst: *APIType, config: crapi.ResolveConfigType(APIType), - ) !*APIType { - const ConfigType = @TypeOf(config); - const EnvFields = crapi.ResolveEnv(APIType); - const ErrorType = crapi.ComptimeEntry(APIType).init_errors; + ) !void { + const entry_config = crapi.GetRegistry(APIType) orelse + @compileError("Invalid API type: " ++ @typeName(APIType) ++ " (could not find registry config)"); + const EnvFields = crapi.EnvFor(APIType); + const ConfigType = entry_config.ConfigType; + const ErrorType = entry_config.InitErrors; const InitFunc = *const fn ( *APIType, *Context, - *EnvFields, + EnvFields, ConfigType, - ) ErrorType!APIType; + ) ErrorType!void; const reg_entry = self.ctx.registry.getEntry(common.typeId(APIType)) orelse return error.InvalidAPIType; @@ -51,8 +58,8 @@ pub fn APIFactory( const initFn: InitFunc = @ptrCast(@alignCast(reg_entry.initFn)); try initFn(inst, self.ctx, populated_env, config); - return inst; } + /// Used for lifecycle deinits, users can just directly call @@ -67,21 +74,45 @@ pub fn APIFactory( base: FactoryBase, + fn allocManaged( + self: *Factory, + comptime APIType: type, + ) !std.meta.Tuple(&.{ + *APIType, + crapi.ManagedReturnType(APIType)} + ) { + _ = self; + const managed_info = @typeInfo(crapi.ManagedReturnType(APIType)); + _ = managed_info; + + return undefined; + } + /// some management modes return different handle variants or just pointers. /// This depends on the handle variant of the particular type - pub fn init( + pub fn create( self: *Factory, comptime APIType: type, config: crapi.ResolveConfigType(APIType), ) !crapi.ManagedReturnType(APIType) { + const ptr, const h = try self.allocManaged(APIType); + std.debug.print("Type of config: {s}\n", .{@typeName(@TypeOf(config))}); + try self.base.createBase(APIType, ptr, config); + + return h; } - pub fn initPreconfig( + /// Creates a new API type with a pre-populated configuration value. + /// Since, some vulkan objects can be heavy on parameterization. + pub fn createPreconfig( self: *Factory, comptime APIType: type, comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, params: anytype, ) !crapi.ManagedReturnType(APIType) { + _ = self; + _ = profile; + _ = params; } }, .Unmanaged => struct { @@ -95,6 +126,9 @@ pub fn APIFactory( allocator: std.mem.Allocator, config: crapi.ResolveConfigType(APIType), ) !*APIType { + _ = self; + _ = allocator; + _ = config; } pub fn initPreconfig( @@ -104,6 +138,10 @@ pub fn APIFactory( allocator: std.mem.Allocator, params: anytype, ) !*APIType { + _ = self; + _ = profile; + _ = allocator; + _ = params; } pub fn initInPlace( @@ -112,6 +150,9 @@ pub fn APIFactory( inst: *APIType, config: crapi.ResolveConfigType(APIType), ) !void { + _ = self; + _ = inst; + _ = config; } pub fn initInPlacePreconfig( @@ -121,39 +162,19 @@ pub fn APIFactory( inst: *APIType, params: anytype, ) !void { + _ = self; + _ = profile; + _ = inst; + _ = params; } }, }; } -test "factory functionality" { - const app = try Context.init(testing.allocator, .{}); - - var managed_factory = app.getAPIFactory(.managed, .{}); - var unmanaged_factory = app.getAPIFactory(.unmanaged, .{}); - - const jerry_face_image1 = try managed_factory.init(api.Image, .{ - .some_image_config = .yadda_yadda, - }); +const CommandBuffer = api.CommandBuffer.CommandBuffer; - const jerry_face_image12 = try unmanaged_factory.init( - api.Image, - testing.allocator, - .{ - .some_image_config = .yadda_yadda, - }, - ); - - var jerry_face_image121: api.Image = undefined; - try unmanaged_factory.initInPlace( // this variant only exists on unmanaged thingies - api.Image, - &jerry_face_image121, - .{ - .some_image_config = .yadda_yadda, - }, - ); +test "factory functionality" { + var factory_shit: APIFactory(.Managed, .{}) = undefined; - const jerry_face_image2 = try managed_factory.initPreconfig(api.Image, .SomeProfileName, .{ - .extra_option = .yadda, - }); + _ = try factory_shit.create(CommandBuffer, .{.one_shot = true}); } diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index 5bbac67..cbfa31d 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -22,6 +22,7 @@ const std = @import("std"); const common = @import("common"); const Context = @import("../context.zig"); const cfg = common.config; +const env = @import("../env.zig"); const Allocator = std.mem.Allocator; const AnyPtr = common.AnyPtr; @@ -46,10 +47,10 @@ pub const EntryConfig = struct { Proxy: type, // error set for init functions (omit for anyerror) - init_errors: ?type, + InitErrors: type = error{}, // the type of the configuration struct (if any) - config_type: ?type = null, + ConfigType: type = struct{}, // whether or not initialization depends on an allocator management: ManagementMode = .Pooled, @@ -57,9 +58,14 @@ pub const EntryConfig = struct { deinitFn: *const anyopaque, }; +const ObjectPool = common.ObjectPool; + fn ManagedResourceType(comptime mode: ManagementMode, comptime T: type) type { + const PoolType = ObjectPool(T, .{}); return switch(mode) { - .Pooled => common. + .Pooled => PoolType.ReifiedHandle, + .Streamed => PoolType.ReifiedHandle, + else => *T, }; } @@ -88,22 +94,25 @@ pub const ComptimeAPI = struct { return ConfigType.Registry; } - pub fn ResolveConfigType(comptime APIType: type) ?type { - return if (@hasDecl(APIType, "Config")) APIType.Config else null; + pub fn ResolveConfigType(comptime APIType: type) type { + return if (@hasDecl(APIType, "Config")) APIType.Config else struct {}; } pub fn GetRegistry(comptime APIType: type) ?EntryConfig { if (!@hasDecl(APIType, "entry_config")) return null; return APIType.entry_config; } - - pub fn ProxyFor(comptime T: type) type { + + /// Given the type's API registry entry, returns the corresponding handle type + /// which differs depending on the management mode. + pub fn HandleFor(comptime T: type) type { const entry_config = GetRegistry(T) orelse @compileError("cannot create a proxy for: " ++ @typeName(T) ++ " (no entry config)"); - - return struct { - handle: entry_config. - }; + return ManagedResourceType(entry_config.management, T); + } + + pub fn EnvFor(comptime T: type) type { + return if (@hasDecl(T, "Env")) T.Env else env.Empty(); } }; @@ -123,7 +132,7 @@ pub fn RegistryEntryType(comptime config: EntryConfig) type { /// by LSPs. I might redo this if it turns out this template doesn't /// get directly touched by user code. fn InitFnTemplate(comptime config: EntryConfig) type { - const error_type = config.init_errors orelse anyerror; + const error_type = config.InitErrors orelse anyerror; if (config.config_type) |ct| { if (config.requires_alloc) { return *const fn (*config.State, *const Context, Allocator, ct) error_type!void; diff --git a/src/resource_management/res.zig b/src/resource_management/res.zig index 37802cf..f96523a 100644 --- a/src/resource_management/res.zig +++ b/src/resource_management/res.zig @@ -1,3 +1,9 @@ pub const Registry = @import("registry.zig"); pub const ResourceManager = @import("resource_manager.zig"); +pub const APIFactory = @import("factory.zig").APIFactory; + + +comptime { + _ = @import("factory.zig"); +} diff --git a/src/root.zig b/src/root.zig index 2a76e92..d391e23 100644 --- a/src/root.zig +++ b/src/root.zig @@ -17,6 +17,7 @@ pub const testing = @import("tests/testing.zig"); // imports for testing comptime { _ = @import("resource_management/registry.zig"); + _ = @import("resource_management/res.zig"); _ = @import("context.zig"); _ = @import("api/api.zig"); } From 163f9e8f5c24fdbedbdae2bc6e17fb54f57f4a1d Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sun, 19 Oct 2025 21:05:51 +0200 Subject: [PATCH 40/46] feat(crapi): added some additional getter functions for the comptime registry API --- src/api/command_buffer.zig | 4 +- src/common/handle.zig | 8 ++++ src/context.zig | 2 +- src/resource_management/factory.zig | 42 +++++++++++++++----- src/resource_management/registry.zig | 36 ++++++++++------- src/resource_management/resource_manager.zig | 17 ++++++++ 6 files changed, 81 insertions(+), 28 deletions(-) diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index e1c63d6..b1b3eb1 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -156,9 +156,11 @@ fn dummyDeinit(self: *const CommandBuffer) void { _ = self; } +const crapi = @import("../resource_management/res.zig").Registry.ComptimeAPI; + pub const CommandBufferProxy = struct { - const CommandBufferHandle = common.Handle(CommandBuffer, .{}); + const CommandBufferHandle = crapi.HandleFor(CommandBuffer); handle: CommandBufferHandle, diff --git a/src/common/handle.zig b/src/common/handle.zig index a67d7b3..32d5220 100644 --- a/src/common/handle.zig +++ b/src/common/handle.zig @@ -54,6 +54,10 @@ pub fn Handle( return getter(self.p, self.h); } + pub fn getAssumeValid(self: @This()) *T { + return getter(self.p, self.h) catch unreachable; + } + pub fn init(h: Self, mem: *anyopaque) @This() { return .{ .h = h, @@ -85,6 +89,10 @@ pub fn Handle( return getter(self.p, self.h); } + pub fn getAssumeValid(self: @This()) *T { + return getter(self.p, self.h) catch unreachable; + } + pub fn init(h: Self, mem: *anyopaque) @This() { return .{ .h = h, diff --git a/src/context.zig b/src/context.zig index ccb5b7a..d1be91a 100644 --- a/src/context.zig +++ b/src/context.zig @@ -39,7 +39,7 @@ const EnvBacking = struct { mem_layout: Ref(api.DeviceMemoryLayout, .{}), }; -const Environment = e.For(EnvBacking); +pub const Environment = e.For(EnvBacking); const Self = @This(); diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig index e259f6c..5c9a0a9 100644 --- a/src/resource_management/factory.zig +++ b/src/resource_management/factory.zig @@ -20,13 +20,8 @@ const crapi = Registry.ComptimeAPI; pub fn APIFactory( comptime variant: FactoryVariant, - comptime fac_config: Config, ) type { - // Dunno why I put this as a parameter, but might use it later - // so I'll keep it. - _ = fac_config; - // common set of functions const FactoryBase = struct { const FactoryBase = @This(); @@ -81,11 +76,36 @@ pub fn APIFactory( *APIType, crapi.ManagedReturnType(APIType)} ) { - _ = self; - const managed_info = @typeInfo(crapi.ManagedReturnType(APIType)); - _ = managed_info; - - return undefined; + const ProxyType = crapi.ManagedReturnType(APIType); + const entry_config = crapi.GetRegistry(APIType) orelse + @compileError("Invalid registry"); + + var ptr: *APIType = undefined; + var proxy: ProxyType = undefined; + + switch (entry_config.management) { + //HACK: Technically, unmanaged types shouldn't + //be creatable from a managed factory + //For now, I just use the context allocator + .Unmanaged => { + ptr = try self.base.ctx.allocator.create(APIType); + proxy = .{.handle = ptr}; + }, + .Transient => { + ptr = try self.base.ctx.resources.createTransient(APIType); + proxy = .{.handle = ptr}; + }, + //TODO: Streamed allocations need an actual system + .Pooled, .Streamed => { + const handle = + try self.base.ctx.resources.reservePooledByType(APIType); + + ptr = handle.getAssumeValid(); + proxy = .{.handle = handle}; + }, + } + + return .{ptr, proxy}; } /// some management modes return different handle variants or just pointers. @@ -174,7 +194,7 @@ pub fn APIFactory( const CommandBuffer = api.CommandBuffer.CommandBuffer; test "factory functionality" { - var factory_shit: APIFactory(.Managed, .{}) = undefined; + var factory_shit: APIFactory(.Managed) = undefined; _ = try factory_shit.create(CommandBuffer, .{.one_shot = true}); } diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index cbfa31d..84dde85 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -50,7 +50,7 @@ pub const EntryConfig = struct { InitErrors: type = error{}, // the type of the configuration struct (if any) - ConfigType: type = struct{}, + ConfigType: type = struct {}, // whether or not initialization depends on an allocator management: ManagementMode = .Pooled, @@ -60,14 +60,6 @@ pub const EntryConfig = struct { const ObjectPool = common.ObjectPool; -fn ManagedResourceType(comptime mode: ManagementMode, comptime T: type) type { - const PoolType = ObjectPool(T, .{}); - return switch(mode) { - .Pooled => PoolType.ReifiedHandle, - .Streamed => PoolType.ReifiedHandle, - else => *T, - }; -} /// Comptime registry API /// In comptime, the types themselves are the registries. @@ -75,10 +67,19 @@ fn ManagedResourceType(comptime mode: ManagementMode, comptime T: type) type { /// The working of this registry API depends on a coherent /// naming scheme for faster lookups pub const ComptimeAPI = struct { + pub fn ManagedResourceType(comptime mode: ManagementMode, comptime T: type) type { + const PoolType = ObjectPool(T, .{}); + return switch (mode) { + .Pooled, .Streamed => PoolType.ReifiedHandle, + else => *T, + }; + } // gets the config registry, cuz thats a generic fn ConfigRegistryFor(comptime T: type) type { - return if (@hasDecl(T, "Registry")) @TypeOf(T.Registry) else + return if (@hasDecl(T, "Registry")) + @TypeOf(T.Registry) + else @compileError("Invalid type " ++ @typeName(T) ++ " (missing config registry)"); } @@ -90,6 +91,11 @@ pub const ComptimeAPI = struct { return registry.Proxy; } + pub fn ProxyAPIMixin(comptime T: type) type { + _ = T; + return u32; + } + pub fn ResolveConfigRegistry(comptime ConfigType: type) ConfigRegistryFor(ConfigType) { return ConfigType.Registry; } @@ -102,15 +108,15 @@ pub const ComptimeAPI = struct { if (!@hasDecl(APIType, "entry_config")) return null; return APIType.entry_config; } - + /// Given the type's API registry entry, returns the corresponding handle type /// which differs depending on the management mode. pub fn HandleFor(comptime T: type) type { const entry_config = GetRegistry(T) orelse - @compileError("cannot create a proxy for: " ++ @typeName(T) ++ " (no entry config)"); + @compileError("cannot create a proxy for: " ++ @typeName(T) ++ " (no entry config)"); return ManagedResourceType(entry_config.management, T); } - + pub fn EnvFor(comptime T: type) type { return if (@hasDecl(T, "Env")) T.Env else env.Empty(); } @@ -177,13 +183,13 @@ pub fn init(allocator: Allocator) !Self { } /// the type referenced by "T" must match the shape of -/// a configurable type as defined in the "CRAPI" +/// a configurable type as defined in the "CRAPI" /// type specification pub fn addEntry( self: *Self, comptime T: type, ) void { - const entry_config = ComptimeAPI.GetRegistry(T) orelse + const entry_config = ComptimeAPI.GetRegistry(T) orelse @compileError("cannot create a registry entry for type: " ++ @typeName(T) ++ " (no entry config)"); const entry = RegistryEntry{ diff --git a/src/resource_management/resource_manager.zig b/src/resource_management/resource_manager.zig index 6f1952e..196e6f4 100644 --- a/src/resource_management/resource_manager.zig +++ b/src/resource_management/resource_manager.zig @@ -17,6 +17,10 @@ pub const Config = struct { pool_sizes: usize, }; +fn PoolHandle(comptime T: type) type { + return common.ObjectPool(T, .{}).ReifiedHandle; +} + // pools: MemoryPoolsTable, pub fn init(config: Config, registry: *Registry) !Self { @@ -50,3 +54,16 @@ pub fn init(config: Config, registry: *Registry) !Self { // .pools = table, // }; } + +pub fn createTransient(self: *Self, comptime APIType: type) !*APIType { + _ = self; + + return undefined; +} + +pub fn reservePooledByType(self: *Self, comptime APIType: type) !PoolHandle(APIType) { + _ = self; + + return PoolHandle(APIType).init(undefined, undefined); +} + From 2600ccf93cb5bfb5f47b92bfc027f0a183c09330 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 20 Oct 2025 15:05:26 +0200 Subject: [PATCH 41/46] feat(factory): creation API finished and comptime side works --- src/api/command_buffer.zig | 3 +- src/context.zig | 5 + src/env.zig | 58 +++-- src/resource_management/factory.zig | 324 +++++++++++++--------------- 4 files changed, 201 insertions(+), 189 deletions(-) diff --git a/src/api/command_buffer.zig b/src/api/command_buffer.zig index b1b3eb1..7ebf280 100644 --- a/src/api/command_buffer.zig +++ b/src/api/command_buffer.zig @@ -145,11 +145,10 @@ const CommandBufferInitErrors = error{ Something, }; -fn dummyInit(self: *CommandBuffer, ctx: *const Context, e: env.Empty(), config: CommandBuffer.Config) CommandBufferInitErrors!void { +fn dummyInit(self: *CommandBuffer, e: env.Empty(), config: CommandBuffer.Config) CommandBufferInitErrors!void { _ = e; _ = self; _ = config; - _ = ctx; } fn dummyDeinit(self: *const CommandBuffer) void { diff --git a/src/context.zig b/src/context.zig index d1be91a..b3b69a7 100644 --- a/src/context.zig +++ b/src/context.zig @@ -31,12 +31,17 @@ const EnvBacking = struct { .field = "descriptor_pool", .mutable = true, }), + res: Ref(res.ResourceManager, .{ + .field = "resources", + .mutable = true, + }), gi: Ref(GlobalInterface, .{ .field = "global_interface" }), ii: Ref(InstanceInterface, .{ .field = "inst_interface" }), di: Ref(DeviceInterface, .{ .field = "dev_interface" }), mem_layout: Ref(api.DeviceMemoryLayout, .{}), + registry: Ref(res.Registry, .{}), }; pub const Environment = e.For(EnvBacking); diff --git a/src/env.zig b/src/env.zig index 4795a35..91766c4 100644 --- a/src/env.zig +++ b/src/env.zig @@ -133,10 +133,31 @@ pub fn Empty() type { _ = ctx; return .{}; } - }; } +/// Ensure LHS is a pointer +pub fn populate(lhs: anytype, rhs: anytype) void { + const lhs_info = @typeInfo(@TypeOf(lhs)); + const rhs_info = @typeInfo(@TypeOf(rhs)); + + switch (lhs_info) { + .pointer => {}, + else => + @compileError("lhs (" ++ @typeName(@TypeOf(lhs)) ++ ") must be a pointer"), + } + switch (rhs_info) { + .@"struct" => {}, + else => + @compileError("rhs (" ++ @typeName(@TypeOf(rhs)) ++ ") must be a struct type"), + } + + inline for (rhs_info.@"struct".fields) |fld| { + if (@hasField(lhs_info.pointer.child, fld.name)) + @field(lhs, fld.name) = @field(rhs, fld.name); + } +} + pub fn For(comptime T: type) type { validateType(T); @@ -147,8 +168,6 @@ pub fn For(comptime T: type) type { /// Defines an env subset type which can be automatically populated by a factory pub fn EnvSubset(comptime fields: anytype) type { - const Declaration = std.builtin.Type.Declaration; - comptime var field_infos: []const StructField = &.{}; for (fields) |enum_lit| { const matching_field = std.meta.fieldInfo(T, enum_lit); @@ -165,28 +184,15 @@ pub fn For(comptime T: type) type { field_infos = field_infos ++ [1]StructField{mapped_field_info}; } - const populate_decl = Declaration{ .name = "populate" }; - const SubsetType = @Type(.{ .@"struct" = .{ .fields = field_infos, - .decls = &.{populate_decl}, + .decls = &.{}, .layout = .auto, .is_tuple = false, }, }); - const Populate = struct { - pub fn populate(ctx: anytype) SubsetType { - var new: SubsetType = undefined; - inline for (field_infos) |fld| { - @field(new, fld.name) = @field(ctx, fld.name); - } - } - }; - - SubsetType.populate = Populate.populate; - return SubsetType; } @@ -252,5 +258,23 @@ pub fn For(comptime T: type) type { .inner = backing, }; } + + /// initialize the env fields directly from a structure + /// This is meant to be used mainly for testing purposes where creating + /// an entire context is unwieldy. + pub fn initRaw(val: anytype) Self { + var backing: T = undefined; + + inline for (Bindings.map) |bind| { + if (@hasField(@TypeOf(val), bind.backing_name)) { + @field(backing, bind.backing_name).inner = + @field(val, bind.backing_name); + } + } + + return Self{ + .inner = backing, + }; + } }; } diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig index 5c9a0a9..298c3e2 100644 --- a/src/resource_management/factory.zig +++ b/src/resource_management/factory.zig @@ -4,197 +4,181 @@ const std = @import("std"); const Context = @import("../context.zig"); const Registry = @import("registry.zig"); -const Self = @This(); const testing = std.testing; const common = @import("common"); const cfg = common.config; const api = @import("../api/api.zig"); +const env_api = @import("../env.zig"); const Config = struct {}; +const Factory = @This(); const FactoryVariant = enum { Managed, Unmanaged }; - const crapi = Registry.ComptimeAPI; -pub fn APIFactory( - comptime variant: FactoryVariant, -) type { - - // common set of functions - const FactoryBase = struct { - const FactoryBase = @This(); - ctx: *Context, - - pub fn createBase( - self: *FactoryBase, - comptime APIType: type, - inst: *APIType, - config: crapi.ResolveConfigType(APIType), - ) !void { - const entry_config = crapi.GetRegistry(APIType) orelse - @compileError("Invalid API type: " ++ @typeName(APIType) ++ " (could not find registry config)"); - const EnvFields = crapi.EnvFor(APIType); - const ConfigType = entry_config.ConfigType; - const ErrorType = entry_config.InitErrors; - const InitFunc = *const fn ( - *APIType, - *Context, - EnvFields, - ConfigType, - ) ErrorType!void; - - const reg_entry = self.ctx.registry.getEntry(common.typeId(APIType)) orelse - return error.InvalidAPIType; - - const populated_env = EnvFields.populate(self.ctx.ctx_env); - // nice and safe. - const initFn: InitFunc = @ptrCast(@alignCast(reg_entry.initFn)); - - try initFn(inst, self.ctx, populated_env, config); - } - - - - /// Used for lifecycle deinits, users can just directly call - /// deinit for the low-level API - pub fn deinitBase() void { - } +/// Since anything can be created, any sort of static resource +/// could be required from an application instance. +const Env = Context.Environment; + +env: Env, + +pub fn init(env: Env) Factory { + return Factory { + .env = env, }; +} + +fn createInPlace( + self: *Factory, + comptime APIType: type, + inst: *APIType, + config: crapi.ResolveConfigType(APIType), +) !void { + const entry_config = crapi.GetRegistry(APIType) orelse + @compileError("Invalid API type: " ++ @typeName(APIType) ++ " (could not find registry config)"); + const EnvFields = crapi.EnvFor(APIType); + const ConfigType = entry_config.ConfigType; + const ErrorType = entry_config.InitErrors; + const InitFunc = *const fn ( + *APIType, + EnvFields, + ConfigType, + ) ErrorType!void; + const registry = self.env.get(.registry); + + const reg_entry = registry.getEntry(common.typeId(APIType)) orelse + return error.InvalidAPIType; + + var populated_env: EnvFields = undefined; + + env_api.populate(&populated_env, self.env); + // nice and safe. + const initFn: InitFunc = @ptrCast(@alignCast(reg_entry.initFn)); + + try initFn(inst, populated_env, config); +} - return switch(variant) { - .Managed => struct { - const Factory = @This(); - - base: FactoryBase, - - fn allocManaged( - self: *Factory, - comptime APIType: type, - ) !std.meta.Tuple(&.{ - *APIType, - crapi.ManagedReturnType(APIType)} - ) { - const ProxyType = crapi.ManagedReturnType(APIType); - const entry_config = crapi.GetRegistry(APIType) orelse - @compileError("Invalid registry"); - - var ptr: *APIType = undefined; - var proxy: ProxyType = undefined; - - switch (entry_config.management) { - //HACK: Technically, unmanaged types shouldn't - //be creatable from a managed factory - //For now, I just use the context allocator - .Unmanaged => { - ptr = try self.base.ctx.allocator.create(APIType); - proxy = .{.handle = ptr}; - }, - .Transient => { - ptr = try self.base.ctx.resources.createTransient(APIType); - proxy = .{.handle = ptr}; - }, - //TODO: Streamed allocations need an actual system - .Pooled, .Streamed => { - const handle = - try self.base.ctx.resources.reservePooledByType(APIType); - - ptr = handle.getAssumeValid(); - proxy = .{.handle = handle}; - }, - } - - return .{ptr, proxy}; - } - - /// some management modes return different handle variants or just pointers. - /// This depends on the handle variant of the particular type - pub fn create( - self: *Factory, - comptime APIType: type, - config: crapi.ResolveConfigType(APIType), - ) !crapi.ManagedReturnType(APIType) { - const ptr, const h = try self.allocManaged(APIType); - std.debug.print("Type of config: {s}\n", .{@typeName(@TypeOf(config))}); - try self.base.createBase(APIType, ptr, config); - - return h; - } - - /// Creates a new API type with a pre-populated configuration value. - /// Since, some vulkan objects can be heavy on parameterization. - pub fn createPreconfig( - self: *Factory, - comptime APIType: type, - comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, - params: anytype, - ) !crapi.ManagedReturnType(APIType) { - _ = self; - _ = profile; - _ = params; - } +fn allocManaged( + self: *Factory, + comptime APIType: type, +) !std.meta.Tuple(&.{ + *APIType, + crapi.ManagedReturnType(APIType)} +) { + const ProxyType = crapi.ManagedReturnType(APIType); + const entry_config = crapi.GetRegistry(APIType) orelse + @compileError("Invalid registry"); + + // unmanaged resource shouldn't be created using managed functions + std.debug.assert(entry_config.management != .Unmanaged); + var res = self.env.get(.res); + + var ptr: *APIType = undefined; + var proxy: ProxyType = undefined; + + + switch (entry_config.management) { + .Transient => { + ptr = try res.createTransient(APIType); + proxy = .{.handle = ptr}; }, - .Unmanaged => struct { - const Factory = @This(); - - base: FactoryBase, - - pub fn init( - self: *Factory, - comptime APIType: type, - allocator: std.mem.Allocator, - config: crapi.ResolveConfigType(APIType), - ) !*APIType { - _ = self; - _ = allocator; - _ = config; - } - - pub fn initPreconfig( - self: *Factory, - comptime APIType: type, - comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, - allocator: std.mem.Allocator, - params: anytype, - ) !*APIType { - _ = self; - _ = profile; - _ = allocator; - _ = params; - } - - pub fn initInPlace( - self: *Factory, - comptime APIType: type, - inst: *APIType, - config: crapi.ResolveConfigType(APIType), - ) !void { - _ = self; - _ = inst; - _ = config; - } - - pub fn initInPlacePreconfig( - self: *Factory, - comptime APIType: type, - comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, - inst: *APIType, - params: anytype, - ) !void { - _ = self; - _ = profile; - _ = inst; - _ = params; - } + //TODO: Streamed allocations need an actual system + .Pooled, .Streamed => { + const handle = + try res.reservePooledByType(APIType); + + ptr = handle.getAssumeValid(); + proxy = .{.handle = handle}; }, - }; + + .Unmanaged => unreachable, + } + + return .{ptr, proxy}; +} + +/// some management modes return different handle variants or just pointers. +/// This depends on the handle variant of the particular type +pub fn create( + self: *Factory, + comptime APIType: type, + config: crapi.ResolveConfigType(APIType), +) !crapi.ManagedReturnType(APIType) { + const ptr, const h = try self.allocManaged(APIType); + try self.createInPlace(APIType, ptr, config); + + return h; +} + +/// Creates a new API type with a pre-populated configuration value. +/// Since, some vulkan objects can be heavy on parameterization. +pub fn createPreconfig( + self: *Factory, + comptime APIType: type, + comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, + params: anytype, +) !crapi.ManagedReturnType(APIType) { + const ConfigType = crapi.ResolveConfigType(APIType); + const config = ConfigType.profile(profile, params); + + return self.create(APIType, config); +} + +/// Creates a new object but with a user-provided allocator +pub fn createAllocated( + self: *Factory, + comptime APIType: type, + allocator: std.mem.Allocator, + config: crapi.ResolveConfigType(APIType), +) !*APIType { + const new = try allocator.create(APIType); + errdefer allocator.destroy(new); + + try self.createInPlace(APIType, new, config); + return new; +} + +pub fn createPreconfigAllocated( + self: *Factory, + comptime APIType: type, + comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, + allocator: std.mem.Allocator, + params: anytype, +) !*APIType { + const ConfigType = crapi.ResolveConfigType(APIType); + const config = ConfigType.profile(profile, params); + + return self.createAllocated(APIType, allocator, config); +} + +pub fn createInPlacePreconfig( + self: *Factory, + comptime APIType: type, + comptime profile: crapi.ResolveConfigRegistry(APIType).Profiles, + inst: *APIType, + params: anytype, +) !void { + const ConfigType = crapi.ResolveConfigType(APIType); + const config = ConfigType.profile(profile, params); + + try self.createInPlace(APIType, inst, config); } const CommandBuffer = api.CommandBuffer.CommandBuffer; +const ray_testing = @import("../root.zig").testing; + test "factory functionality" { - var factory_shit: APIFactory(.Managed) = undefined; + + const test_ctx = try ray_testing.MinimalVulkanContext.initMinimalVulkan( + testing.allocator, + .{.noscreen=true} + ); + var factory_shit = Factory.init(Env.initRaw(.{})); + + defer test_ctx.deinit(testing.allocator); _ = try factory_shit.create(CommandBuffer, .{.one_shot = true}); } From 389642c068cbdece6a89f6fcc8959b9376b9cfe4 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 20 Oct 2025 15:14:34 +0200 Subject: [PATCH 42/46] fix(env): questioning whether the empty env is even necessary at all... --- src/env.zig | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/env.zig b/src/env.zig index 91766c4..a0ec2e8 100644 --- a/src/env.zig +++ b/src/env.zig @@ -128,11 +128,6 @@ fn findParentFieldType(pt: type, fname: []const u8) type { pub fn Empty() type { return struct { - const Self = @This(); - pub fn populate(ctx: anytype) Self { - _ = ctx; - return .{}; - } }; } From 117994055db8669a04513f3c697c422c42eb7e46 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Fri, 24 Oct 2025 19:40:11 +0200 Subject: [PATCH 43/46] feat: improved testing context to be incremental in its initialization --- src/api/api.zig | 6 +- src/api/descriptor_pool.zig | 9 +- src/common/util.zig | 53 +++++++- src/env.zig | 6 +- src/glfw.zig | 4 +- src/resource_management/factory.zig | 9 +- src/resource_management/registry.zig | 7 +- src/tests/testing.zig | 177 +++++++++++++++++++++++++-- 8 files changed, 237 insertions(+), 34 deletions(-) diff --git a/src/api/api.zig b/src/api/api.zig index edeb429..b7565de 100644 --- a/src/api/api.zig +++ b/src/api/api.zig @@ -73,8 +73,10 @@ pub const ShaderModule = sh.Module; // Obtaining RTTI for vulkan API const Registry = @import("../resource_management/res.zig").Registry; -pub fn initRegistry(reg: *Registry) !void { - try CommandBuffer.addEntries(reg); +pub fn populateRegistry(reg: *Registry) !void { + // temporary, until I restructure this file to include + // data declarations rather than wrappers. + reg.registerType(CommandBuffer.CommandBuffer); } // comptime { diff --git a/src/api/descriptor_pool.zig b/src/api/descriptor_pool.zig index 23b157e..059938d 100644 --- a/src/api/descriptor_pool.zig +++ b/src/api/descriptor_pool.zig @@ -113,9 +113,9 @@ const PoolArena = struct { } h_desc_pool: vk.DescriptorPool, - di: *const api.DeviceInterface, + di: api.DeviceInterface, - pub fn init(di: *const api.DeviceInterface, size: usize) !PoolArena { + pub fn init(di: api.DeviceInterface, size: usize) !PoolArena { const pool_sizes = poolSizesForCount(size); const pool_create_info = vk.DescriptorPoolCreateInfo{ @@ -220,6 +220,7 @@ scene_pool: PoolArena, static_pool: PoolArena, const Self = @This(); +pub const Env = Context.Environment.EnvSubset(.{.di}); pub const PoolSizes = struct { transient: usize, @@ -232,8 +233,8 @@ fn poolByUsage(self: *Self, usage: UsageInfo) AnyPool { return self.pools_by_usage.get(usage.lifetime_bits) orelse unreachable; } -pub fn initSelf(self: *Self, ctx: *const Context, sizes: PoolSizes) !void { - const di = ctx.env(.di); +pub fn initSelf(self: *Self, env: Env, sizes: PoolSizes) !void { + const di: api.DeviceInterface = env.di; self.transient_pool = try PoolArena.init(di, sizes.transient); errdefer self.transient_pool.deinit(); diff --git a/src/common/util.zig b/src/common/util.zig index 3774b47..7e867a3 100644 --- a/src/common/util.zig +++ b/src/common/util.zig @@ -50,10 +50,8 @@ pub fn fnSignatureMatches( comptime A: type, comptime B: type, ) bool { - const info_a = if (@typeInfo(A).@"fn") @typeInfo(A).@"fn" else - return false; - const info_b = if (@typeInfo(B).@"fn") @typeInfo(B).@"fn" else - return false; + const info_a = if (@typeInfo(A).@"fn") @typeInfo(A).@"fn" else return false; + const info_b = if (@typeInfo(B).@"fn") @typeInfo(B).@"fn" else return false; if (info_a.params.len != info_b.params.len) return false; @@ -124,3 +122,50 @@ pub fn signatureMatches(a: *const Function, b: *const Function) bool { if (!a.calling_convention.eql(b)) return false; return true; } + +///TODO: Param for ordering fields in the bitset, +/// which I don't really need now, but could be useful later +pub fn EnumToBitfield(comptime E: type) type { + const e_info = @typeInfo(E); + const default_value: bool = false; + + if (e_info != .@"enum") + @compileError("Invalid type: " ++ @typeName(E) ++ " must be an enum to convert to bitfield"); + + comptime var bit_fields: []const StructField = &.{}; + for (e_info.@"enum".fields) |fld| { + bit_fields = bit_fields ++ &[_]StructField{.{ + .type = bool, + .alignment = 0, + .is_comptime = false, + .default_value_ptr = &default_value, + .name = fld.name, + }}; + } + + const InnerBitfield = @Type(.{.@"struct" = std.builtin.Type.Struct{ + .decls = &.{}, + .fields = bit_fields, + .layout = .@"packed", + .is_tuple = false, + }}); + + const BackingInt = @typeInfo(InnerBitfield).@"struct".backing_integer; + + return struct { + pub const EnumType = E; + pub const Bitfield = InnerBitfield; + const EnumBitfield = @This(); + + val: Bitfield = .{}, + pub fn initPopulated(vals: []const EnumType) EnumBitfield { + var new: EnumBitfield = .{}; + + for (vals) |v| { + new.set(v); + } + + return new; + } + }; +} diff --git a/src/env.zig b/src/env.zig index a0ec2e8..be9db49 100644 --- a/src/env.zig +++ b/src/env.zig @@ -116,14 +116,14 @@ fn MakeRefBindings(comptime T: type) type { }; } -fn findParentFieldType(pt: type, fname: []const u8) type { +fn FindParentFieldType(pt: type, fname: []const u8) type { const fields = @typeInfo(@typeInfo(pt).pointer.child); for (fields.@"struct".fields) |fld| { if (std.mem.order(u8, fname, fld.name) == .eq) return fld.type; } - unreachable; + @compileError("Could not find matching field for name: " ++ fname ++ " (FindParentFieldInType)"); } pub fn Empty() type { @@ -241,7 +241,7 @@ pub fn For(comptime T: type) type { const backing_name = bind.backing_name; const parent_name = bind.parent_name; // if the field is a pointer, simply copy it over to the inner struct - const pft = findParentFieldType(ParentType, parent_name); + const pft = FindParentFieldType(ParentType, parent_name); @field(backing, backing_name).inner = switch (@typeInfo(pft)) { .pointer => @field(val, parent_name), else => &@field(val, parent_name), diff --git a/src/glfw.zig b/src/glfw.zig index f07eba3..34dbc1e 100644 --- a/src/glfw.zig +++ b/src/glfw.zig @@ -36,7 +36,7 @@ fn ErrorOnFalse(comptime func: fn () callconv(.c) c_int, comptime err: anytype) } extern fn glfwGetInstanceProcAddress(instance: vk.Instance, name: [*:0]const u8) vk.PfnVoidFunction; -extern fn glfwCreateWindowSurface(instance: vk.Instance, window: *GLFWwindow, allocation_callbacks: ?*const vk.AllocationCallbacks, surface: *vk.SurfaceKHR) vk.Result; +pub extern fn glfwCreateWindowSurface(instance: vk.Instance, window: *GLFWwindow, allocation_callbacks: ?*const vk.AllocationCallbacks, surface: *vk.SurfaceKHR) vk.Result; pub const getInstanceProcAddress = glfwGetInstanceProcAddress; @@ -50,8 +50,6 @@ pub const setErrorCallback = c.glfwSetErrorCallback; pub const getTime = c.glfwGetTime; -pub const createWindowSurface = c.glfwCreateWindowSurface; - const glfwDestroyWindow = c.glfwDestroyWindow; const glfwWindowShouldClose = c.glfwWindowShouldClose; const glfwCreateWindow = c.glfwCreateWindow; diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig index 298c3e2..227015c 100644 --- a/src/resource_management/factory.zig +++ b/src/resource_management/factory.zig @@ -11,11 +11,8 @@ const cfg = common.config; const api = @import("../api/api.zig"); const env_api = @import("../env.zig"); -const Config = struct {}; const Factory = @This(); -const FactoryVariant = enum { Managed, Unmanaged }; - const crapi = Registry.ComptimeAPI; /// Since anything can be created, any sort of static resource @@ -172,10 +169,8 @@ const ray_testing = @import("../root.zig").testing; test "factory functionality" { - const test_ctx = try ray_testing.MinimalVulkanContext.initMinimalVulkan( - testing.allocator, - .{.noscreen=true} - ); + var test_ctx: ray_testing.TestingContext = undefined; + try test_ctx.initFor(.{}); var factory_shit = Factory.init(Env.initRaw(.{})); defer test_ctx.deinit(testing.allocator); diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index 84dde85..c365a4f 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -30,7 +30,7 @@ const TypeId = common.TypeId; const Self = @This(); -pub const PfnAddRegistryEntries = *const fn () []EntryConfig; +pub const PfnPopulateRegistry = *const fn(*Self) error{OutOfMemory}!void; pub const ManagementMode = enum { Unmanaged, @@ -182,10 +182,11 @@ pub fn init(allocator: Allocator) !Self { }; } + /// the type referenced by "T" must match the shape of /// a configurable type as defined in the "CRAPI" /// type specification -pub fn addEntry( +pub fn registerType( self: *Self, comptime T: type, ) void { @@ -329,7 +330,7 @@ test "api entries" { defer arena.deinit(); var reg = try Self.init(arena.allocator()); - try api.initRegistry(®); + try api.populateRegistry(®); var q1 = reg.select(); const item = q1 diff --git a/src/tests/testing.zig b/src/tests/testing.zig index 5e131ab..bb8e644 100644 --- a/src/tests/testing.zig +++ b/src/tests/testing.zig @@ -10,7 +10,10 @@ comptime { const std = @import("std"); const api = @import("../api/api.zig"); const glfw = @import("glfw"); +const env = @import("../env.zig"); +/// This sucks ass, replacing with an incremental context loader for now, +/// and a more configurable app context later. pub const MinimalVulkanContext = struct { const Config = struct { noscreen: bool = false, @@ -28,7 +31,7 @@ pub const MinimalVulkanContext = struct { /// vulkan context without most of the core rendering utilities. /// Do not use for normal rendering. pub fn initMinimalVulkan( - allocator: std.mem.Allocator, + allocator: std.mem.Allocator, config: Config, ) !*MinimalVulkanContext { const new_ctx = try allocator.create(MinimalVulkanContext); @@ -45,7 +48,6 @@ pub const MinimalVulkanContext = struct { api.extensions.khr_swapchain.name, }; - new_ctx.inst = try api.InstanceHandler.init(.{ .instance = .{ .required_extensions = min_inst_ext[0..], @@ -67,7 +69,7 @@ pub const MinimalVulkanContext = struct { new_ctx.gi = &new_ctx.inst.w_db; new_ctx.ii = &new_ctx.inst.pr_inst; new_ctx.di = &new_ctx.dev.pr_dev; - + new_ctx.mem_layout = api.DeviceMemoryLayout.init(.{ .dev = &new_ctx.dev, .ii = new_ctx.ii, @@ -77,13 +79,10 @@ pub const MinimalVulkanContext = struct { return new_ctx; } - + /// Allocator should be the same allocator used to initialize /// the structure - pub fn deinit( - ctx: *MinimalVulkanContext, - allocator: std.mem.Allocator - ) void { + pub fn deinit(ctx: *MinimalVulkanContext, allocator: std.mem.Allocator) void { ctx.dev.deinit(); ctx.inst.deinit(); @@ -93,4 +92,166 @@ pub const MinimalVulkanContext = struct { } }; +const Context = @import("../context.zig"); +const res = @import("../resource_management/res.zig"); +const util = @import("common").util; + +pub const TestingContext = struct { + const Environment = Context.Environment; + const ContextBitfield = util.EnumToBitfield(Environment.ContextEnum); + + const PfnCtxInit = *const fn (*TestingContext, *Config) anyerror!void; + + pub const Config = struct { + _selected: ContextBitfield = undefined, + populators: []const res.Registry.PfnPopulateRegistry = &.{ + api.populateRegistry, + }, + fields: []const Environment.ContextEnum = &.{ + .inst, + .dev, + .desc, + .registry, + .res, + .mem_layout, + }, + + validation_layers: []const [*:0]const u8 = &.{ + "VK_LAYER_KHRONOS_validation", + }, + window: ?glfw.Window = null, + desc_pool_sizes: api.DescriptorPool.PoolSizes = .{ + .transient = 1024, + .scene = 1024, + .static = 2048, + }, + }; + + const init_comp_dispatch = std.EnumMap(Environment.ContextEnum, PfnCtxInit).init(.{ + .inst = initInst, + .surf = initSurf, + .dev = initDev, + .desc = initDesc, + .registry = initRegistry, + .res = initRes, + .mem_layout = initMemLayout, + }); + + allocator: std.mem.Allocator, + + env: Environment, + + // backing fields + global_interface: api.GlobalInterface, + inst_interface: api.InstanceInterface, + dev_interface: api.DeviceInterface, + + dev: api.DeviceHandler, + inst: api.InstanceHandler, + surf: api.SurfaceHandler, + descriptor_pool: api.DescriptorPool, + mem_layout: api.DeviceMemoryLayout, + registry: res.Registry, + resources: res.ResourceManager, + + window: ?glfw.Window, + + fn initInst(ctx: *TestingContext, cfg: *Config) !void { + ctx.inst = try api.InstanceHandler.init(.{ + .allocator = ctx.allocator, + .enable_debug_log = true, + .loader = glfw.getInstanceProcAddress, + .instance = .{ + .validation_layers = cfg.validation_layers, + .required_extensions = &.{ + api.extensions.ext_debug_utils.name, + api.extensions.khr_surface.name, + //TODO: create proper platform window surface for non-windows users + api.extensions.khr_win_32_surface.name, + api.extensions.khr_get_physical_device_properties_2.name, + }, + } + }); + + ctx.global_interface = &ctx.inst.w_db; + ctx.inst_interface = &ctx.inst.pr_inst; + } + + fn initDev(ctx: *TestingContext, cfg: *Config) !void { + ctx.dev = try api.DeviceHandler.init(&ctx.inst, .{ + .required_extensions = &.{ + api.extensions.khr_swapchain.name, + }, + .surface = if (cfg._selected.has(.surf)) + &ctx.surf + else + null, + }); + + ctx.dev_interface = &ctx.dev.pr_dev; + } + + fn initSurf(ctx: *TestingContext, cfg: *Config) !void { + ctx.surf = try api.SurfaceHandler.init(if (ctx.window) |*w| + w + else + null, &ctx.inst); + + _ = cfg; + } + + fn initDesc(ctx: *TestingContext, cfg: *Config) !void { + var e: api.DescriptorPool.Env = undefined; + env.populate(&e, ctx.env); + + try ctx.descriptor_pool.initSelf(e, cfg.desc_pool_sizes); + } + + fn initRes(ctx: *TestingContext, cfg: *Config) !void { + // needs the resource manager to actually exist first + // THe type registry will need to be populated from config, + // as will the general configuration for resource manager + _ = ctx; + _ = cfg; + + @panic("Please implmenet the resource manager first!"); + } + + fn initMemLayout(ctx: *TestingContext, cfg: *Config) !void { + var e: api.DeviceMemoryLayout.Env = undefined; + env.populate(&e, ctx.env); + + ctx.mem_layout = api.DeviceMemoryLayout.init(e); + _ = cfg; + } + + fn initRegistry(ctx: *TestingContext, cfg: *Config) !void { + ctx.registry = try res.Registry.init(ctx.allocator); + + // populate registry with predefined sources + for (cfg.populators) |populator| { + try populator(&ctx.registry); + } + } + + /// Initializes only the specified env fields for a testing context + pub fn initFor(ctx: *TestingContext, cfg: Config) !void { + ctx.env = Environment.init(ctx); + + ctx.window = cfg.window; + + var cfg2 = cfg; + cfg2._selected = ContextBitfield.initPopulated(cfg.fields); + + for (cfg.fields) |fld| { + const initializer = init_comp_dispatch.getAssertContains(fld); + try initializer(ctx, &cfg2); + } + } + + pub fn deinit(ctx: *TestingContext, allocator: std.mem.Allocator) void { + _ = ctx; + _ = allocator; + } +}; From 9d77a5585f8e73570c5f505d81f4a3cda90ea104 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Sat, 25 Oct 2025 21:34:20 +0200 Subject: [PATCH 44/46] fix(test): fixed various issues in the initialization process for the testing context --- src/api/base.zig | 9 ++-- src/common/util.zig | 16 ++++++- src/env.zig | 16 +++---- src/glfw.zig | 1 + src/resource_management/factory.zig | 6 +-- src/tests/testing.zig | 66 ++++++++++++++++++++--------- 6 files changed, 79 insertions(+), 35 deletions(-) diff --git a/src/api/base.zig b/src/api/base.zig index fe440fa..84fd133 100644 --- a/src/api/base.zig +++ b/src/api/base.zig @@ -144,14 +144,14 @@ pub const InstanceHandler = struct { .application_version = @bitCast(vk.makeApiVersion(0, 0, 0, 0)), .p_engine_name = "No Engine", .engine_version = @bitCast(vk.makeApiVersion(0, 0, 0, 0)), - .api_version = @bitCast(vk.API_VERSION_1_4), + .api_version = @bitCast(vk.API_VERSION_1_3), }, .p_next = &defaultDebugConfig(), .enabled_extension_count = @intCast(config.instance.required_extensions.len), .pp_enabled_extension_names = config.instance.required_extensions.ptr, .enabled_layer_count = @intCast(config.instance.validation_layers.len), .pp_enabled_layer_names = config.instance.validation_layers.ptr, - .flags = .{ .enumerate_portability_bit_khr = true }, + .flags = .{}, }, null); self.w_di = try self.allocator.create(vk.InstanceWrapper); @@ -389,6 +389,7 @@ pub const DeviceHandler = struct { dev, allocator, ) catch { + log.err("Could not get queue family proprties while enumerating device\n", .{}); return found_indices; }; defer allocator.free(dev_queue_family_props); @@ -397,6 +398,7 @@ pub const DeviceHandler = struct { const i: u32 = @intCast(index); log.debug("Family {d}, Supports:\n {s}", .{i, props.queue_flags}); + if (props.queue_flags.contains(.{ .graphics_bit = true, })) { @@ -497,6 +499,7 @@ pub const DeviceHandler = struct { config.surface, parent.allocator, ); + std.debug.print("Got device queue indices?\n", .{}); //HACK: Extremely lazy fix for device being hardcoded //for a surface. Please replace this once proper featureset @@ -527,7 +530,7 @@ pub const DeviceHandler = struct { }, .{ .queue_family_index = dev_queue_indices.present_family orelse - undefined, + @panic("This is bad"), .queue_count = 1, .p_queue_priorities = &priority, }, diff --git a/src/common/util.zig b/src/common/util.zig index 7e867a3..b886c0a 100644 --- a/src/common/util.zig +++ b/src/common/util.zig @@ -150,7 +150,8 @@ pub fn EnumToBitfield(comptime E: type) type { .is_tuple = false, }}); - const BackingInt = @typeInfo(InnerBitfield).@"struct".backing_integer; + const BackingInt = @typeInfo(InnerBitfield).@"struct".backing_integer orelse + @compileError("Too many fields in enum: " ++ @typeName(E)); return struct { pub const EnumType = E; @@ -167,5 +168,18 @@ pub fn EnumToBitfield(comptime E: type) type { return new; } + + pub fn has(bits: EnumBitfield, val: EnumType) bool { + var dumbass_copy = bits.val; + const bit: usize = @intFromEnum(val); + const int_val: BackingInt = @as(*BackingInt, @ptrCast(@alignCast(&dumbass_copy))).*; + return (int_val >> @as(u4, @intCast(bit))) & 0x1 != 0; + } + + pub fn set(bits: *EnumBitfield, val: EnumType) void { + const bits_as_int = @as(*BackingInt, @ptrCast(@alignCast(&bits.val))); + const bit = @intFromEnum(val); + bits_as_int.* |= @as(BackingInt, 1) << @as(u4, @intCast(bit)); + } }; } diff --git a/src/env.zig b/src/env.zig index be9db49..e6fd647 100644 --- a/src/env.zig +++ b/src/env.zig @@ -127,29 +127,27 @@ fn FindParentFieldType(pt: type, fname: []const u8) type { } pub fn Empty() type { - return struct { - }; + return struct {}; } /// Ensure LHS is a pointer pub fn populate(lhs: anytype, rhs: anytype) void { const lhs_info = @typeInfo(@TypeOf(lhs)); - const rhs_info = @typeInfo(@TypeOf(rhs)); + const rhs_info = @typeInfo(@TypeOf(rhs.inner)); switch (lhs_info) { .pointer => {}, - else => - @compileError("lhs (" ++ @typeName(@TypeOf(lhs)) ++ ") must be a pointer"), + else => @compileError("lhs (" ++ @typeName(@TypeOf(lhs)) ++ ") must be a pointer"), } switch (rhs_info) { .@"struct" => {}, - else => - @compileError("rhs (" ++ @typeName(@TypeOf(rhs)) ++ ") must be a struct type"), + else => @compileError("rhs (" ++ @typeName(@TypeOf(rhs)) ++ ") must be a struct type"), } inline for (rhs_info.@"struct".fields) |fld| { - if (@hasField(lhs_info.pointer.child, fld.name)) - @field(lhs, fld.name) = @field(rhs, fld.name); + if (@hasField(lhs_info.pointer.child, fld.name)) { + @field(lhs, fld.name) = @field(rhs.inner, fld.name).inner; + } } } diff --git a/src/glfw.zig b/src/glfw.zig index 34dbc1e..160de98 100644 --- a/src/glfw.zig +++ b/src/glfw.zig @@ -18,6 +18,7 @@ pub const GetProcAddrHandler = *const (fn (vk.Instance, [*:0]const u8) callconv( pub const CLIENT_API = c.GLFW_CLIENT_API; pub const NO_API = c.GLFW_NO_API; pub const RESIZABLE = c.GLFW_RESIZABLE; +pub const VISIBLE = c.GLFW_VISIBLE; pub const GLFWwindow = c.GLFWwindow; diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig index 227015c..b52bddc 100644 --- a/src/resource_management/factory.zig +++ b/src/resource_management/factory.zig @@ -170,10 +170,10 @@ const ray_testing = @import("../root.zig").testing; test "factory functionality" { var test_ctx: ray_testing.TestingContext = undefined; - try test_ctx.initFor(.{}); - var factory_shit = Factory.init(Env.initRaw(.{})); - + try test_ctx.initFor(testing.allocator, .{}); defer test_ctx.deinit(testing.allocator); + var factory_shit = Factory.init(Env.initRaw(.{})); + _ = try factory_shit.create(CommandBuffer, .{.one_shot = true}); } diff --git a/src/tests/testing.zig b/src/tests/testing.zig index bb8e644..108845c 100644 --- a/src/tests/testing.zig +++ b/src/tests/testing.zig @@ -109,6 +109,7 @@ pub const TestingContext = struct { }, fields: []const Environment.ContextEnum = &.{ .inst, + .surf, .dev, .desc, .registry, @@ -158,21 +159,14 @@ pub const TestingContext = struct { window: ?glfw.Window, fn initInst(ctx: *TestingContext, cfg: *Config) !void { - ctx.inst = try api.InstanceHandler.init(.{ - .allocator = ctx.allocator, - .enable_debug_log = true, - .loader = glfw.getInstanceProcAddress, - .instance = .{ - .validation_layers = cfg.validation_layers, - .required_extensions = &.{ - api.extensions.ext_debug_utils.name, - api.extensions.khr_surface.name, - //TODO: create proper platform window surface for non-windows users - api.extensions.khr_win_32_surface.name, - api.extensions.khr_get_physical_device_properties_2.name, - }, - } - }); + ctx.inst = try api.InstanceHandler.init(.{ .allocator = ctx.allocator, .enable_debug_log = true, .loader = glfw.getInstanceProcAddress, .instance = .{ + .validation_layers = cfg.validation_layers, + .required_extensions = &.{ + api.extensions.ext_debug_utils.name, + api.extensions.khr_surface.name, + api.extensions.khr_win_32_surface.name, + }, + } }); ctx.global_interface = &ctx.inst.w_db; ctx.inst_interface = &ctx.inst.pr_inst; @@ -190,9 +184,21 @@ pub const TestingContext = struct { }); ctx.dev_interface = &ctx.dev.pr_dev; + + //HACK: Env initialization should NOT be order dependent on field initialization, + //because that suddenly couples parts of the initialization process together horribly. + ctx.env = Environment.init(ctx); } fn initSurf(ctx: *TestingContext, cfg: *Config) !void { + glfw.Window.hints(.{ + .{ glfw.CLIENT_API, glfw.NO_API }, + .{ glfw.VISIBLE, glfw.FALSE }, + }); + + ctx.window = try glfw.Window.create(100, 200, "Dummy", null, null); + errdefer ctx.window.?.destroy(); + ctx.surf = try api.SurfaceHandler.init(if (ctx.window) |*w| w else @@ -205,6 +211,18 @@ pub const TestingContext = struct { var e: api.DescriptorPool.Env = undefined; env.populate(&e, ctx.env); + _ = try ctx.dev_interface.createDescriptorPool(&.{ + // NOTE: In the future, pools and sets will be managed separately :) + .pool_size_count = 1, + .max_sets = 1, + .p_pool_sizes = &.{.{ + .type = .uniform_buffer, + .descriptor_count = 1, + }}, + }, null); + + std.debug.print("Addr: {*} vs {*}\n", .{e.di, ctx.dev_interface}); + try ctx.descriptor_pool.initSelf(e, cfg.desc_pool_sizes); } @@ -236,14 +254,19 @@ pub const TestingContext = struct { } /// Initializes only the specified env fields for a testing context - pub fn initFor(ctx: *TestingContext, cfg: Config) !void { - ctx.env = Environment.init(ctx); + pub fn initFor( + ctx: *TestingContext, + allocator: std.mem.Allocator, + cfg: Config, + ) !void { + try glfw.init(); - ctx.window = cfg.window; + ctx.allocator = allocator; var cfg2 = cfg; cfg2._selected = ContextBitfield.initPopulated(cfg.fields); + for (cfg.fields) |fld| { const initializer = init_comp_dispatch.getAssertContains(fld); try initializer(ctx, &cfg2); @@ -251,7 +274,12 @@ pub const TestingContext = struct { } pub fn deinit(ctx: *TestingContext, allocator: std.mem.Allocator) void { - _ = ctx; + if (ctx.window) |w| { + w.destroy(); + } + + glfw.deinit(); + _ = allocator; } }; From 3cc5db09b1a4fb754c314814af11f163a9566310 Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 27 Oct 2025 08:21:07 -0700 Subject: [PATCH 45/46] feat(factory): Implemented factory initializers at least to the point that a basic end-to-end doesnt' fail --- build.zig | 2 +- src/api/base.zig | 1 - src/resource_management/factory.zig | 10 +- src/resource_management/registry.zig | 18 +++ src/resource_management/res.zig | 7 + src/resource_management/resource_manager.zig | 132 ++++++++++++++----- src/tests/testing.zig | 27 ++-- 7 files changed, 148 insertions(+), 49 deletions(-) diff --git a/build.zig b/build.zig index 47b83e1..886d24f 100644 --- a/build.zig +++ b/build.zig @@ -216,7 +216,7 @@ fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies, opts: BuildOpts) const test_step = b.addRunArtifact(test_comp); const common_test_step = b.addRunArtifact(common_tests); - const test_cmd = b.step("run-tests", "run all unit tests"); + const test_cmd = b.step("test", "run all unit tests"); test_cmd.dependOn(&test_step.step); test_cmd.dependOn(&common_test_step.step); diff --git a/src/api/base.zig b/src/api/base.zig index 84fd133..de5526d 100644 --- a/src/api/base.zig +++ b/src/api/base.zig @@ -499,7 +499,6 @@ pub const DeviceHandler = struct { config.surface, parent.allocator, ); - std.debug.print("Got device queue indices?\n", .{}); //HACK: Extremely lazy fix for device being hardcoded //for a surface. Please replace this once proper featureset diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig index b52bddc..4095ba0 100644 --- a/src/resource_management/factory.zig +++ b/src/resource_management/factory.zig @@ -71,6 +71,7 @@ fn allocManaged( // unmanaged resource shouldn't be created using managed functions std.debug.assert(entry_config.management != .Unmanaged); var res = self.env.get(.res); + std.debug.print("Resource manager address in factory: {*}\n", .{res}); var ptr: *APIType = undefined; var proxy: ProxyType = undefined; @@ -169,11 +170,14 @@ const ray_testing = @import("../root.zig").testing; test "factory functionality" { + var butt = std.heap.DebugAllocator(.{}).init; + const allocator = butt.allocator(); + var test_ctx: ray_testing.TestingContext = undefined; - try test_ctx.initFor(testing.allocator, .{}); - defer test_ctx.deinit(testing.allocator); + try test_ctx.initFor(allocator, .{}); + defer test_ctx.deinit(allocator); - var factory_shit = Factory.init(Env.initRaw(.{})); + var factory_shit = Factory.init(test_ctx.env); _ = try factory_shit.create(CommandBuffer, .{.one_shot = true}); } diff --git a/src/resource_management/registry.zig b/src/resource_management/registry.zig index c365a4f..1b136a0 100644 --- a/src/resource_management/registry.zig +++ b/src/resource_management/registry.zig @@ -23,6 +23,7 @@ const common = @import("common"); const Context = @import("../context.zig"); const cfg = common.config; const env = @import("../env.zig"); +const util = common.util; const Allocator = std.mem.Allocator; const AnyPtr = common.AnyPtr; @@ -281,6 +282,23 @@ pub const Query = struct { return null; } } + + pub fn collect(self: *Iterator, allocator: Allocator) ?[]*const RegistryEntry { + _ = self; + _ = allocator; + @panic("Query.Iterator.collect: needs implementation"); + } + + pub fn getCount(self: *const Iterator) usize { + var dup = self.*; + var count: usize = 0; + + while (dup.next()) |_| { + count += 1; + } + + return count; + } }; pub fn where(self: *Query, predicate: PredicateFn) *Query { diff --git a/src/resource_management/res.zig b/src/resource_management/res.zig index f96523a..e1556c3 100644 --- a/src/resource_management/res.zig +++ b/src/resource_management/res.zig @@ -1,8 +1,15 @@ +const common = @import("common"); pub const Registry = @import("registry.zig"); pub const ResourceManager = @import("resource_manager.zig"); pub const APIFactory = @import("factory.zig").APIFactory; +/// Provides a single source of truth for normal object pools, +/// rather then just spamming the same (potentially complex) definition +/// everywhere +pub fn StandardObjectPool(comptime T: type) type { + return common.ObjectPool(T, .{}); +} comptime { _ = @import("factory.zig"); diff --git a/src/resource_management/resource_manager.zig b/src/resource_management/resource_manager.zig index 196e6f4..734f45f 100644 --- a/src/resource_management/resource_manager.zig +++ b/src/resource_management/resource_manager.zig @@ -2,6 +2,7 @@ const std = @import("std"); const Self = @This(); const common = @import("common"); +const res_api = @import("res.zig"); const Registry = @import("registry.zig"); const Allocator = std.mem.Allocator; @@ -11,6 +12,77 @@ const TypeId = common.TypeId; const Handle = common.Handle; const OpaqueHandle = common.OpaqueHandle; const Predicate = Registry.Predicate; +const crapi = Registry.ComptimeAPI; + +const MemoryPoolsTable = struct { + const PoolTypeMap = std.AutoArrayHashMapUnmanaged(common.TypeId, *anyopaque); + + cfg: Config, + ///NOTE: If it turns out the type id hack I used produces consecutive values, + ///this can be replaced with a sparse index + pool_ptrs: PoolTypeMap, + pool_arena: std.heap.ArenaAllocator, + + // the actual pools themselves are lazily initialized + pub fn init(cfg: Config, iter: Registry.Query.Iterator) !MemoryPoolsTable { + const count = iter.getCount(); + + var pool_map = try PoolTypeMap.init(cfg.allocator, &.{}, &.{}); + errdefer pool_map.deinit(cfg.allocator); + try pool_map.ensureUnusedCapacity(cfg.allocator, count); + + return MemoryPoolsTable{ + .cfg = cfg, + .pool_ptrs = pool_map, + .pool_arena = std.heap.ArenaAllocator.init(cfg.allocator), + }; + } + + /// null if API type is invalid, and panics on allocation failure since there isn't + /// much to be done recovery wise + pub fn getPool(table: *MemoryPoolsTable, comptime T: type) ?*res_api.StandardObjectPool(T) { + if (crapi.GetRegistry(T) == null) return null; + + const type_id = common.typeId(T); + std.debug.print("Did we survice?\n", .{}); + _ = table.pool_ptrs.count(); + std.debug.print("... Yup\n", .{}); + const pool = table.pool_ptrs.getOrPutAssumeCapacity( + type_id, + ); + + if (pool.found_existing) { + return @as(*res_api.StandardObjectPool(T), @ptrCast(@alignCast(pool.value_ptr.*))); + } else { + const new_pool = table.cfg.allocator.create( + res_api.StandardObjectPool(T), + ) catch @panic("Allocation failed (NOTE: check fixed buffer sizes/ratios)"); + new_pool.* = res_api.StandardObjectPool(T).initPreheated( + table.pool_arena.allocator(), + table.cfg.pool_sizes, + ) catch @panic("Pool initialization failed due to memory exhaustion (NOTE: check fixed buffer sizes/ratios)"); + + pool.value_ptr.* = new_pool; + + return new_pool; + } + } + + pub fn deinit(table: *MemoryPoolsTable) void { + // HACK: THis only works because all the memory is controlled by a linear arena allocator + // But we might want a better strategy + var iter = table.pool_ptrs.iterator(); + while (iter.next()) |i| { + if (i.value_ptr.*) |v| { + table.cfg.allocator.free(v); + } + } + table.pool_ptrs.deinit(table.cfg.allocator); + table.pool_arena.deinit(); + } +}; + +const HandleArena = struct {}; pub const Config = struct { allocator: Allocator, @@ -18,52 +90,42 @@ pub const Config = struct { }; fn PoolHandle(comptime T: type) type { - return common.ObjectPool(T, .{}).ReifiedHandle; + return res_api.StandardObjectPool(T).ReifiedHandle; } -// pools: MemoryPoolsTable, +pools: MemoryPoolsTable, +transients: HandleArena, pub fn init(config: Config, registry: *Registry) !Self { - _ = config; - _ = registry; - return undefined; // loop through each API registry entry // and initialize the table with a pool for each entry - // whose management strategy is tagged as "Pooled" - // var entries_iter = registry.select(); - // var entries = entries_iter - // .where(Predicate.ManagementModeIs(.Pooled)) - // .iterator(); - - // var table = MemoryPoolsTable.init(config.allocator); - - // while (entries.next()) |entry| { - // const pool_config = PoolAllocator.Config{ - // .elem_size = entry.size_bytes, - // .elem_count = config.pool_sizes, - // }; - - // try table.put( - // entry.type_id, - // try PoolAllocator.initAlloc(config.allocator, pool_config), - // ); - // } - - // return Self{ - // .pools = table, - // }; + // whose (default) management strategy is tagged as "Pooled" + var q_entries = registry.select(); + const entries_iter = q_entries + .where(Predicate.ManagementModeIs(.Pooled)) + .iterator(); + + const table = try MemoryPoolsTable.init(config, entries_iter); + + return Self{ + .pools = table, + .transients = undefined, + }; } -pub fn createTransient(self: *Self, comptime APIType: type) !*APIType { - _ = self; +pub fn deinit(res: *Self) void { + res.pools.deinit(); +} - return undefined; +pub fn reserveTransient(res: *Self, comptime T: type) !*T { + _ = res; + @panic("reserveTransient: needs implementation"); } -pub fn reservePooledByType(self: *Self, comptime APIType: type) !PoolHandle(APIType) { - _ = self; +pub fn reservePooledByType(res: *Self, comptime T: type) !PoolHandle(T) { + if (crapi.GetRegistry(T) == null) @compileError("Invalid type: " ++ @typeName(T) ++ " (missing registry)"); + const pool = res.pools.getPool(T) orelse unreachable; - return PoolHandle(APIType).init(undefined, undefined); + return pool.reserveReified(); } - diff --git a/src/tests/testing.zig b/src/tests/testing.zig index 108845c..034c342 100644 --- a/src/tests/testing.zig +++ b/src/tests/testing.zig @@ -123,10 +123,12 @@ pub const TestingContext = struct { window: ?glfw.Window = null, desc_pool_sizes: api.DescriptorPool.PoolSizes = .{ - .transient = 1024, - .scene = 1024, - .static = 2048, + .transient = 128, + .scene = 128, + .static = 256, }, + + res_pool_sizes: usize = 256, }; const init_comp_dispatch = std.EnumMap(Environment.ContextEnum, PfnCtxInit).init(.{ @@ -188,6 +190,8 @@ pub const TestingContext = struct { //HACK: Env initialization should NOT be order dependent on field initialization, //because that suddenly couples parts of the initialization process together horribly. ctx.env = Environment.init(ctx); + + std.debug.print("Address of res: {*} vs {*}\n", .{ctx.env.get(.res), &ctx.resources}); } fn initSurf(ctx: *TestingContext, cfg: *Config) !void { @@ -221,8 +225,6 @@ pub const TestingContext = struct { }}, }, null); - std.debug.print("Addr: {*} vs {*}\n", .{e.di, ctx.dev_interface}); - try ctx.descriptor_pool.initSelf(e, cfg.desc_pool_sizes); } @@ -230,10 +232,17 @@ pub const TestingContext = struct { // needs the resource manager to actually exist first // THe type registry will need to be populated from config, // as will the general configuration for resource manager - _ = ctx; - _ = cfg; - - @panic("Please implmenet the resource manager first!"); + + ctx.resources = try res.ResourceManager.init(.{ + .allocator = ctx.allocator, + .pool_sizes = cfg.res_pool_sizes, + }, &ctx.registry); + + std.debug.print("Address of res: {*} vs {*}\n", .{ctx.env.get(.res), &ctx.resources}); + _ = try ctx.resources.reservePooledByType(api.CommandBuffer.CommandBuffer); + std.debug.print("Survived A\n", .{}); + _ = try ctx.env.get(.res).reservePooledByType(api.CommandBuffer.CommandBuffer); + std.debug.print("Survived B\n", .{}); } fn initMemLayout(ctx: *TestingContext, cfg: *Config) !void { From a4811792c040c20e64ed74cc3948fa4bb183e75b Mon Sep 17 00:00:00 2001 From: johnnyboi12 <54293281+JohnSmoit@users.noreply.github.com> Date: Mon, 27 Oct 2025 08:55:42 -0700 Subject: [PATCH 46/46] build: make samples and test building optional --- build.zig | 18 +++++++++++++++--- src/resource_management/factory.zig | 17 ++++++++++------- 2 files changed, 25 insertions(+), 10 deletions(-) diff --git a/build.zig b/build.zig index 886d24f..6337402 100644 --- a/build.zig +++ b/build.zig @@ -217,7 +217,7 @@ fn buildTests(b: *Build, lib_mod: *Module, deps: Dependencies, opts: BuildOpts) const test_step = b.addRunArtifact(test_comp); const common_test_step = b.addRunArtifact(common_tests); const test_cmd = b.step("test", "run all unit tests"); - + test_cmd.dependOn(&test_step.step); test_cmd.dependOn(&common_test_step.step); } @@ -230,12 +230,24 @@ pub fn build(b: *Build) void { .optimize = b.standardOptimizeOption(.{}), }; + const opt_build_samples = b.option( + bool, + "build_samples", + "whether or not to build sample executables (defaults: true)", + ) orelse true; + + const opt_build_tests = b.option( + bool, + "build_tests", + "whether or not to build sample executables (defaults: true)", + ) orelse true; + const deps = buildDeps(b, opts); const lib_mod, const lib_exe = buildLibrary(b, deps, opts); // handle samples and testing if specified - buildSamples(b, lib_mod, deps, opts); - buildTests(b, lib_mod, deps, opts); + if (opt_build_samples) buildSamples(b, lib_mod, deps, opts); + if (opt_build_tests) buildTests(b, lib_mod, deps, opts); // zls-friendly check step // (which made all the rest of the code way grosser) diff --git a/src/resource_management/factory.zig b/src/resource_management/factory.zig index 4095ba0..8c72939 100644 --- a/src/resource_management/factory.zig +++ b/src/resource_management/factory.zig @@ -168,16 +168,19 @@ const CommandBuffer = api.CommandBuffer.CommandBuffer; const ray_testing = @import("../root.zig").testing; -test "factory functionality" { - - var butt = std.heap.DebugAllocator(.{}).init; - const allocator = butt.allocator(); +// Ideally, we'd get this working without memory leaks +test "factory basic functionality" { var test_ctx: ray_testing.TestingContext = undefined; - try test_ctx.initFor(allocator, .{}); - defer test_ctx.deinit(allocator); + try test_ctx.initFor(testing.allocator, .{}); + defer test_ctx.deinit(testing.allocator); var factory_shit = Factory.init(test_ctx.env); - _ = try factory_shit.create(CommandBuffer, .{.one_shot = true}); + const piss = try factory_shit.create(CommandBuffer, .{.one_shot = true}); + std.debug.print("The type name is: {s}\n", .{@typeName(@TypeOf(piss))}); +} + + +test "factory unmanaged functionality" { }