From a75252b68fdbd1634cbb6177a30f73b1005970b0 Mon Sep 17 00:00:00 2001 From: AdrienBouvais Date: Wed, 27 May 2026 08:27:36 +0200 Subject: [PATCH] Renamed gloc with glloc --- README.md | 60 ++++++++++++++++++++++++------------------ examples/bench_cp.zig | 32 +++++++++++----------- examples/circle.zig | 12 ++++----- examples/compute.zig | 12 ++++----- src/GpuBuffer.zig | 24 ++++++++--------- src/GpuCompute.zig | 30 ++++++++++----------- src/GpuRender.zig | 20 +++++++------- src/GpuTexture.zig | 28 ++++++++++---------- src/GpuTextureView.zig | 10 +++---- 9 files changed, 118 insertions(+), 110 deletions(-) diff --git a/README.md b/README.md index 172b4c5..f52e3d8 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ The library exports the following primary components: * **`GpuDevice`**: Initializes the WebGPU instance, adapter, device, and queue. It is configured to prioritize high performance and automatically requests the `ShaderF16` feature if the adapter supports it. It provides the base `GpuAllocator` for raw VRAM allocations. * **`GpuArenaAllocator`**: A memory management layer that wraps a base allocator to track and automatically destroy all allocated WebGPU buffers, textures, views, and pipelines when deinitialized. -* **`GpuBuffer`**: Wraps native WebGPU buffers. It provides a `.load()` method for CPU-to-GPU data transfers and a `.read()` method that utilizes a staging buffer to map GPU data back to the CPU. +* **`GpuBuffer`**: Wraps native WebGPU buffers. It provides a `.load()` method for CPU-to-GPU data transfers and a `.read()` method to map GPU data back to the CPU. * **`GpuCompute`**: Compiles WGSL source code into a compute pipeline and dispatches compute workgroups. * **`GpuRender` / `GpuTexture` / `GpuTextureView`**: Components used to initialize render pipelines, set up render attachments (textures), and bind render targets for offscreen drawing. @@ -36,17 +36,20 @@ pub fn main(init: std.process.Init) !void { // 2. Create a GPU Arena to manage VRAM var grena = GpuArenaAllocator.init(allocator, device.gpuAllocator()); defer grena.deinit(); - const gloc = grena.gpuAllocator(); + const glloc = grena.gpuAllocator(); // 3. Load the WGSL compute pipeline const add_cp = try GpuCompute.init( - gloc, + glloc, @embedFile("shaders/add.wgsl"), - .{ .bindings = &.{ - .{ .element_size = @sizeOf(f16) }, - .{ .element_size = @sizeOf(f16) }, - .{ .element_size = @sizeOf(f16) }, - } }, + .{ + .label = "add", + .bindings = &.{ + .{ .element_size = @sizeOf(f16) }, + .{ .element_size = @sizeOf(f16) }, + .{ .element_size = @sizeOf(f16) }, + }, + }, ); // 4. Setup CPU data @@ -63,19 +66,20 @@ pub fn main(init: std.process.Init) !void { // 5. Initialize raw GPU Buffers const byte_size = len * @sizeOf(f16); - const buf_a = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc })); - const buf_b = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc })); - const buf_out = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc })); + const buf_a = try GpuBuffer.init(glloc, .{ .label = "a", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); + const buf_b = try GpuBuffer.init(glloc, .{ .label = "b", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); + const buf_out = try GpuBuffer.init(glloc, .{ .label = "out", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); - // Note: Buffers, pipelines, and other objects initialized with 'gloc' - // are safely tied to the GpuArenaAllocator and will automatically release. + // Note: Buffers are safely tied to the GpuArenaAllocator which will automatically + // release them at the end. You can also manually call buf_x.deinit() if desired. + // This will also release pipelines, textures, ect. Everything using a GpuAllocator to init. // 6. Transfer data from CPU slices to GPU Buffers try buf_a.load(f16, data_a); try buf_b.load(f16, data_b); // 7. Dispatch the Compute - try add_cp.run(gloc, .{ buf_a, buf_b, buf_out }); + try add_cp.run(glloc, .{ buf_a, buf_b, buf_out }); // 8. Map and copy the resulting buffer back to the CPU const out = try buf_out.read(allocator, f16); @@ -96,6 +100,7 @@ and pull the frame pixels back to the CPU to write a standard image file: const std = @import("std"); const gpu = @import("gpu"); const GpuDevice = gpu.GpuDevice; +const GpuArenaAllocator = gpu.GpuArenaAllocator; const GpuBuffer = gpu.GpuBuffer; const GpuRender = gpu.GpuRender; const GpuTexture = gpu.GpuTexture; @@ -111,19 +116,21 @@ pub fn main(init: std.process.Init) !void { const device = try GpuDevice.init(.{}); defer device.deinit(); - // 2. Get base device GPU Allocator - const gloc = device.gpuAllocator(); + // 2. Init VRAM Arena + var grena = GpuArenaAllocator.init(allocator, device.gpuAllocator()); + defer grena.deinit(); + const glloc = grena.gpuAllocator(); // 3. Load Render Pipeline const circle_rp = try GpuRender.init( - gloc, + glloc, @embedFile("shaders/circle.wgsl"), .{ .bindings = &.{}, .texture_format = .RGBA8Unorm, .topology = .TriangleStrip }, ); defer circle_rp.deinit(); // 4. Create VRAM texture to render into - const texture = try GpuTexture.init(gloc, .{ + const texture = try GpuTexture.init(glloc, .{ .format = .RGBA8Unorm, .size = .{ .width = width, .height = height, .depthOrArrayLayers = 1 }, .usage = .initMany(&.{ .RenderAttachment, .CopySrc }), @@ -131,21 +138,22 @@ pub fn main(init: std.process.Init) !void { defer texture.deinit(); // 5. Create a view from texture - const view = try GpuTextureView.init(gloc, texture, .{}); + const view = try GpuTextureView.init(glloc, texture, .{}); defer view.deinit(); // 6. Run the rendering pipeline - try circle_rp.draw(gloc, view, 4, .{}); + try circle_rp.draw(glloc, view, 4, .{}); - // 7. Copy Texture into a readable GPU staging buffer - const cpu_staging_buf = try texture.buffCopy(gloc); - defer cpu_staging_buf.deinit(); + // 7. Load Texture into GpuBuffer + const cpu_staging_cpu = try texture.buffCopy(glloc); + defer cpu_staging_cpu.deinit(); - // 8. Read GpuBuffer to CPU memory - const pixels = try cpu_staging_buf.read(allocator, u8); + // 8. Read GpuBuffer to CPU + // This need to be free manually because CPU memory + const pixels = try cpu_staging_cpu.read(allocator, u8); defer allocator.free(pixels); - // 9. Write out to a simple PPM image + // 9. Write a simple ppm image try savePpm(init.io, "circle.ppm", width, height, pixels); } diff --git a/examples/bench_cp.zig b/examples/bench_cp.zig index a3a8dba..19c2da2 100644 --- a/examples/bench_cp.zig +++ b/examples/bench_cp.zig @@ -13,10 +13,10 @@ const Vec = struct { buf: GpuBuffer, len: usize, - // Changed: gloc is passed by value (const) - pub fn initZero(gloc: GpuAllocator, len: usize) !Vec { + // Changed: glloc is passed by value (const) + pub fn initZero(glloc: GpuAllocator, len: usize) !Vec { return .{ - .buf = try GpuBuffer.init(gloc, .{ + .buf = try GpuBuffer.init(glloc, .{ .size = len * @sizeOf(f16), .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }), }), @@ -24,9 +24,9 @@ const Vec = struct { }; } - // Changed: gloc is passed by value - pub fn initLoad(gloc: GpuAllocator, data: []const f16) !Vec { - var self = try initZero(gloc, data.len); + // Changed: glloc is passed by value + pub fn initLoad(glloc: GpuAllocator, data: []const f16) !Vec { + var self = try initZero(glloc, data.len); try self.load(data); // Direct access via the interface copy return self; } @@ -40,18 +40,18 @@ const Vec = struct { try self.buf.load(f16, data); } - // Changed: gloc is passed by value instead of *GpuAllocator - pub fn run(self: Vec, gloc: GpuAllocator, other: Vec, process: GpuCompute) !Vec { + // Changed: glloc is passed by value instead of *GpuAllocator + pub fn run(self: Vec, glloc: GpuAllocator, other: Vec, process: GpuCompute) !Vec { std.debug.assert(self.len == other.len); - const result = try Vec.initZero(gloc, self.len); + const result = try Vec.initZero(glloc, self.len); errdefer result.deinit(); - try process.run(gloc, .{ self.buf, other.buf, result.buf }); + try process.run(glloc, .{ self.buf, other.buf, result.buf }); return result; } - // Changed: gloc is passed by value instead of *GpuAllocator + // Changed: glloc is passed by value instead of *GpuAllocator pub fn read(self: Vec, alloc: std.mem.Allocator) ![]f16 { return self.buf.read(alloc, f16); } @@ -63,9 +63,9 @@ pub fn main(init: std.process.Init) !void { var grena = GpuArenaAllocator.init(init.gpa, device.gpuAllocator()); defer grena.deinit(); - const gloc = grena.gpuAllocator(); + const glloc = grena.gpuAllocator(); - const add_pip = try GpuCompute.init(gloc, @embedFile("shaders/add.wgsl"), .{ .bindings = &.{ + const add_pip = try GpuCompute.init(glloc, @embedFile("shaders/add.wgsl"), .{ .bindings = &.{ .{ .element_size = @sizeOf(f16) }, .{ .element_size = @sizeOf(f16) }, .{ .element_size = @sizeOf(f16) }, @@ -120,9 +120,9 @@ pub fn main(init: std.process.Init) !void { // --- 1. GPU ALLOCATION PHASE --- const alloc_start = std.Io.Clock.awake.now(init.io); - const a = try Vec.initLoad(gloc, data_a); + const a = try Vec.initLoad(glloc, data_a); defer a.deinit(); - const b = try Vec.initLoad(gloc, data_b); + const b = try Vec.initLoad(glloc, data_b); defer b.deinit(); const alloc_duration = alloc_start.durationTo(std.Io.Clock.awake.now(init.io)); @@ -132,7 +132,7 @@ pub fn main(init: std.process.Init) !void { // --- 2. COMPUTE PHASE --- const compute_start = std.Io.Clock.awake.now(init.io); - const sum = try a.run(gloc, b, add_pip); + const sum = try a.run(glloc, b, add_pip); defer sum.deinit(); // All 3 buffers (a, b, sum) are currently resident in VRAM here. diff --git a/examples/circle.zig b/examples/circle.zig index 26a60c3..3d73bb1 100644 --- a/examples/circle.zig +++ b/examples/circle.zig @@ -20,18 +20,18 @@ pub fn main(init: std.process.Init) !void { // 2. Init VRAM Arena var grena = GpuArenaAllocator.init(allocator, device.gpuAllocator()); defer grena.deinit(); - const gloc = grena.gpuAllocator(); + const glloc = grena.gpuAllocator(); // 3. Load Render Pipeline const circle_rp = try GpuRender.init( - gloc, + glloc, @embedFile("shaders/circle.wgsl"), .{ .bindings = &.{}, .texture_format = .RGBA8Unorm, .topology = .TriangleStrip }, ); defer circle_rp.deinit(); // 4. Create VRAM texture to render into - const texture = try GpuTexture.init(gloc, .{ + const texture = try GpuTexture.init(glloc, .{ .format = .RGBA8Unorm, .size = .{ .width = width, .height = height, .depthOrArrayLayers = 1 }, .usage = .initMany(&.{ .RenderAttachment, .CopySrc }), @@ -39,14 +39,14 @@ pub fn main(init: std.process.Init) !void { defer texture.deinit(); // 5. Create a view from texture - const view = try GpuTextureView.init(gloc, texture, .{}); + const view = try GpuTextureView.init(glloc, texture, .{}); defer view.deinit(); // 6. Run the rendering pipeline - try circle_rp.draw(gloc, view, 4, .{}); + try circle_rp.draw(glloc, view, 4, .{}); // 7. Load Texture into GpuBuffer - const cpu_staging_cpu = try texture.buffCopy(gloc); + const cpu_staging_cpu = try texture.buffCopy(glloc); defer cpu_staging_cpu.deinit(); // 8. Read GpuBuffer to CPU diff --git a/examples/compute.zig b/examples/compute.zig index 14f2312..7975772 100644 --- a/examples/compute.zig +++ b/examples/compute.zig @@ -15,11 +15,11 @@ pub fn main(init: std.process.Init) !void { // 2. Create a GPU Arena to manage VRAM var grena = GpuArenaAllocator.init(allocator, device.gpuAllocator()); defer grena.deinit(); - const gloc = grena.gpuAllocator(); + const glloc = grena.gpuAllocator(); // 3. Load the WGSL compute pipeline const add_cp = try GpuCompute.init( - gloc, + glloc, @embedFile("shaders/add.wgsl"), .{ .label = "add", @@ -45,9 +45,9 @@ pub fn main(init: std.process.Init) !void { // 5. Initialize raw GPU Buffers const byte_size = len * @sizeOf(f16); - const buf_a = try GpuBuffer.init(gloc, .{ .label = "a", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); - const buf_b = try GpuBuffer.init(gloc, .{ .label = "b", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); - const buf_out = try GpuBuffer.init(gloc, .{ .label = "out", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); + const buf_a = try GpuBuffer.init(glloc, .{ .label = "a", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); + const buf_b = try GpuBuffer.init(glloc, .{ .label = "b", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); + const buf_out = try GpuBuffer.init(glloc, .{ .label = "out", .size = byte_size, .usage = .initMany(&.{ .Storage, .CopyDst, .CopySrc }) }); // Note: Buffers are safely tied to the GpuArenaAllocator which will automatically // release them at the end. You can also manually call buf_x.deinit() if desired. @@ -58,7 +58,7 @@ pub fn main(init: std.process.Init) !void { try buf_b.load(f16, data_b); // 7. Dispatch the Compute - try add_cp.run(gloc, .{ buf_a, buf_b, buf_out }); + try add_cp.run(glloc, .{ buf_a, buf_b, buf_out }); // 8. Map and copy the resulting buffer back to the CPU const out = try buf_out.read(allocator, f16); diff --git a/src/GpuBuffer.zig b/src/GpuBuffer.zig index 9640229..c2001c0 100644 --- a/src/GpuBuffer.zig +++ b/src/GpuBuffer.zig @@ -6,7 +6,7 @@ const svOpt = @import("utils.zig").svOpt; raw: c.WGPUBuffer, size: u64, usage: c.WGPUBufferUsage, -gloc: GpuAllocator, +glloc: GpuAllocator, const BufferUsage = enum(u64) { None = 0x0000000000000000, @@ -28,7 +28,7 @@ const GpuBufferDef = struct { usage: std.EnumSet(BufferUsage), }; -pub fn init(gloc: GpuAllocator, def: GpuBufferDef) !@This() { +pub fn init(glloc: GpuAllocator, def: GpuBufferDef) !@This() { var use: u64 = 0; var iter = def.usage.iterator(); while (iter.next()) |flag| use |= @intFromEnum(flag); @@ -36,7 +36,7 @@ pub fn init(gloc: GpuAllocator, def: GpuBufferDef) !@This() { // Automatically align the buffer size forward to a multiple of 4 bytes under the hood const aligned_size = std.mem.alignForward(u64, def.size, 4); - const raw_handle = try gloc.allocBuffer(.{ + const raw_handle = try glloc.allocBuffer(.{ .size = aligned_size, .usage = use, .label = svOpt(def.label), @@ -45,12 +45,12 @@ pub fn init(gloc: GpuAllocator, def: GpuBufferDef) !@This() { .raw = raw_handle, .size = aligned_size, .usage = use, - .gloc = gloc, + .glloc = glloc, }; } pub fn deinit(self: @This()) void { - self.gloc.freeBuffer(self.raw); + self.glloc.freeBuffer(self.raw); } pub fn getConstMappedRange(self: @This(), offset: u64, size: u64) ?*const anyopaque { @@ -81,20 +81,20 @@ pub fn load( if (bytes == self.size) { // Aligned path: direct download - c.wgpuQueueWriteBuffer(self.gloc.device.queue, self.raw, 0, data.ptr, self.size); + c.wgpuQueueWriteBuffer(self.glloc.device.queue, self.raw, 0, data.ptr, self.size); } else { // Unaligned path: Split the write into an aligned chunk and a padded remainder // to support arbitrary lengths without any allocations or large stack arrays. const aligned_part = (bytes / 4) * 4; if (aligned_part > 0) { - c.wgpuQueueWriteBuffer(self.gloc.device.queue, self.raw, 0, data.ptr, aligned_part); + c.wgpuQueueWriteBuffer(self.glloc.device.queue, self.raw, 0, data.ptr, aligned_part); } var remainder_buf: [4]u8 = .{ 0, 0, 0, 0 }; const data_bytes = std.mem.sliceAsBytes(data); @memcpy(remainder_buf[0 .. bytes - aligned_part], data_bytes[aligned_part..bytes]); - c.wgpuQueueWriteBuffer(self.gloc.device.queue, self.raw, aligned_part, &remainder_buf, 4); + c.wgpuQueueWriteBuffer(self.glloc.device.queue, self.raw, aligned_part, &remainder_buf, 4); } } @@ -102,19 +102,19 @@ pub fn load( pub fn read(self: @This(), alloc: std.mem.Allocator, T: type) ![]T { const out = try alloc.alloc(T, @divExact(self.size, @sizeOf(T))); - const staging = try init(self.gloc, .{ + const staging = try init(self.glloc, .{ .size = self.size, .usage = .initMany(&.{ .MapRead, .CopyDst }), .label = "staging_read_buffer", }); defer staging.deinit(); - const enc = c.wgpuDeviceCreateCommandEncoder(self.gloc.device.device, null) orelse return error.Encoder; + const enc = c.wgpuDeviceCreateCommandEncoder(self.glloc.device.device, null) orelse return error.Encoder; c.wgpuCommandEncoderCopyBufferToBuffer(enc, self.raw, 0, staging.raw, 0, self.size); const cmd = c.wgpuCommandEncoderFinish(enc, null); defer c.wgpuCommandEncoderRelease(enc); defer c.wgpuCommandBufferRelease(cmd); - c.wgpuQueueSubmit(self.gloc.device.queue, 1, &cmd); + c.wgpuQueueSubmit(self.glloc.device.queue, 1, &cmd); var mapped = false; staging.mapAsync( @@ -123,7 +123,7 @@ pub fn read(self: @This(), alloc: std.mem.Allocator, T: type) ![]T { self.size, .{ .callback = onMapped, .userdata1 = &mapped }, ); - while (!mapped) self.gloc.device.poll(); + while (!mapped) self.glloc.device.poll(); const ptr: [*]const T = @ptrCast(@alignCast( staging.getConstMappedRange(0, self.size), diff --git a/src/GpuCompute.zig b/src/GpuCompute.zig index c678059..960d6a2 100644 --- a/src/GpuCompute.zig +++ b/src/GpuCompute.zig @@ -22,40 +22,40 @@ pub const ComputeDef = struct { }; pip: c.WGPUComputePipeline, -gloc: GpuAllocator, +glloc: GpuAllocator, def: ComputeDef, -pub fn init(gloc: GpuAllocator, wgsl: []const u8, def: ComputeDef) !@This() { +pub fn init(glloc: GpuAllocator, wgsl: []const u8, def: ComputeDef) !@This() { var wgsl_src = c.WGPUShaderSourceWGSL{ .chain = .{ .sType = c.WGPUSType_ShaderSourceWGSL }, .code = sv(wgsl), }; - const shader = c.wgpuDeviceCreateShaderModule(gloc.device.device, &.{ + const shader = c.wgpuDeviceCreateShaderModule(glloc.device.device, &.{ .nextInChain = @ptrCast(&wgsl_src), }) orelse return error.Shader; defer c.wgpuShaderModuleRelease(shader); - const pip = try gloc.allocComputePipeline(.{ + const pip = try glloc.allocComputePipeline(.{ .label = svOpt(def.label), .compute = .{ .module = shader, .entryPoint = sv("main") }, }); return .{ - .gloc = gloc, + .glloc = glloc, .pip = pip, .def = def, }; } pub fn deinit(self: @This()) void { - self.gloc.freeComputePipeline(self.pip); + self.glloc.freeComputePipeline(self.pip); } /// Execute the compute pass with arbitrary buffer bindings via a tuple. -/// Example: `try proc.run(gloc, .{ buf_a, buf_b, buf_out });` +/// Example: `try proc.run(glloc, .{ buf_a, buf_b, buf_out });` pub fn run( self: @This(), - gloc: GpuAllocator, + glloc: GpuAllocator, args: anytype, ) !void { const type_info = @typeInfo(@TypeOf(args)); @@ -113,12 +113,12 @@ pub fn run( defer if (info_buf) |b| b.deinit(); if (self.def.append_info_buffer) { - info_buf = try GpuBuffer.init(gloc, .{ + info_buf = try GpuBuffer.init(glloc, .{ .size = @sizeOf(u32), .usage = .initMany(&.{ .Uniform, .CopyDst }), .label = "compute_info_buffer", }); - c.wgpuQueueWriteBuffer(gloc.device.queue, info_buf.?.raw, 0, &elements_count, @sizeOf(u32)); + c.wgpuQueueWriteBuffer(glloc.device.queue, info_buf.?.raw, 0, &elements_count, @sizeOf(u32)); entries_buf[entry_count] = .{ .binding = @intCast(entry_count), @@ -130,11 +130,11 @@ pub fn run( } const entries = entries_buf[0..entry_count]; - try submitPass(gloc, self.pip, entries, elements_count, self.def.workgroup_size, self.def.max_workgroups); + try submitPass(glloc, self.pip, entries, elements_count, self.def.workgroup_size, self.def.max_workgroups); } fn submitPass( - gloc: GpuAllocator, + glloc: GpuAllocator, pipeline: c.WGPUComputePipeline, entries: []const c.WGPUBindGroupEntry, n: usize, @@ -146,14 +146,14 @@ fn submitPass( const bgl = c.wgpuComputePipelineGetBindGroupLayout(pipeline, 0); defer c.wgpuBindGroupLayoutRelease(bgl); - const bg = c.wgpuDeviceCreateBindGroup(gloc.device.device, &.{ + const bg = c.wgpuDeviceCreateBindGroup(glloc.device.device, &.{ .layout = bgl, .entries = entries.ptr, .entryCount = entries.len, }) orelse return error.BindGroup; defer c.wgpuBindGroupRelease(bg); - const enc = c.wgpuDeviceCreateCommandEncoder(gloc.device.device, null) orelse return error.Encoder; + const enc = c.wgpuDeviceCreateCommandEncoder(glloc.device.device, null) orelse return error.Encoder; const pass = c.wgpuCommandEncoderBeginComputePass(enc, null); c.wgpuComputePassEncoderSetPipeline(pass, pipeline); c.wgpuComputePassEncoderSetBindGroup(pass, 0, bg, 0, null); @@ -168,7 +168,7 @@ fn submitPass( const cmd = c.wgpuCommandEncoderFinish(enc, null); defer c.wgpuCommandEncoderRelease(enc); defer c.wgpuCommandBufferRelease(cmd); - c.wgpuQueueSubmit(gloc.device.queue, 1, &cmd); + c.wgpuQueueSubmit(glloc.device.queue, 1, &cmd); } fn ceilDiv(n: usize, d: usize) usize { diff --git a/src/GpuRender.zig b/src/GpuRender.zig index 71d7e1f..d53f15f 100644 --- a/src/GpuRender.zig +++ b/src/GpuRender.zig @@ -34,16 +34,16 @@ const GpuPrimitiveTopology = enum(c_uint) { Force32 = 0x7FFFFFFF, }; -gloc: GpuAllocator, +glloc: GpuAllocator, pip: c.WGPURenderPipeline, def: GpuRenderDef, -pub fn init(gloc: GpuAllocator, wgsl: []const u8, def: GpuRenderDef) !@This() { +pub fn init(glloc: GpuAllocator, wgsl: []const u8, def: GpuRenderDef) !@This() { var wgsl_src = c.WGPUShaderSourceWGSL{ .chain = .{ .sType = c.WGPUSType_ShaderSourceWGSL }, .code = sv(wgsl), }; - const shader = c.wgpuDeviceCreateShaderModule(gloc.device.device, &.{ + const shader = c.wgpuDeviceCreateShaderModule(glloc.device.device, &.{ .nextInChain = @ptrCast(&wgsl_src), }) orelse return error.Shader; defer c.wgpuShaderModuleRelease(shader); @@ -69,7 +69,7 @@ pub fn init(gloc: GpuAllocator, wgsl: []const u8, def: GpuRenderDef) !@This() { }; // 3. Compile the Complete Render Pipeline - const pip = try gloc.allocRenderPipeline(.{ + const pip = try glloc.allocRenderPipeline(.{ .label = svOpt(def.label), .vertex = .{ .module = shader, @@ -90,21 +90,21 @@ pub fn init(gloc: GpuAllocator, wgsl: []const u8, def: GpuRenderDef) !@This() { }); return .{ - .gloc = gloc, + .glloc = glloc, .pip = pip, .def = def, }; } pub fn deinit(self: @This()) void { - self.gloc.freeRenderPipeline(self.pip); + self.glloc.freeRenderPipeline(self.pip); } /// Execute the render pass targeting a specific frame texture view. /// Passes bind groups via a tuple exactly like your original compute setup. pub fn draw( self: @This(), - gloc: GpuAllocator, + glloc: GpuAllocator, target_view: GpuTextureView, vertex_count: u32, args: anytype, @@ -138,7 +138,7 @@ pub fn draw( const bgl = c.wgpuRenderPipelineGetBindGroupLayout(self.pip, 0); defer c.wgpuBindGroupLayoutRelease(bgl); - const bg = c.wgpuDeviceCreateBindGroup(gloc.device.device, &.{ + const bg = c.wgpuDeviceCreateBindGroup(glloc.device.device, &.{ .layout = bgl, .entries = entries.ptr, .entryCount = @intCast(entries.len), @@ -146,7 +146,7 @@ pub fn draw( defer c.wgpuBindGroupRelease(bg); // Encode Render Command - const enc = c.wgpuDeviceCreateCommandEncoder(gloc.device.device, null) orelse return error.Encoder; + const enc = c.wgpuDeviceCreateCommandEncoder(glloc.device.device, null) orelse return error.Encoder; defer c.wgpuCommandEncoderRelease(enc); const color_attachment = c.WGPURenderPassColorAttachment{ @@ -180,5 +180,5 @@ pub fn draw( const cmd = c.wgpuCommandEncoderFinish(enc, null); defer c.wgpuCommandBufferRelease(cmd); - c.wgpuQueueSubmit(gloc.device.queue, 1, &cmd); + c.wgpuQueueSubmit(glloc.device.queue, 1, &cmd); } diff --git a/src/GpuTexture.zig b/src/GpuTexture.zig index cbc727a..2efba1a 100644 --- a/src/GpuTexture.zig +++ b/src/GpuTexture.zig @@ -14,10 +14,10 @@ pub const GpuTextureDef = struct { }; raw: c.WGPUTexture, -gloc: GpuAllocator, +glloc: GpuAllocator, def: GpuTextureDef, -pub fn init(gloc: GpuAllocator, def: GpuTextureDef) !@This() { +pub fn init(glloc: GpuAllocator, def: GpuTextureDef) !@This() { var use: u64 = 0; var iter = def.usage.iterator(); while (iter.next()) |flag| use |= @intFromEnum(flag); @@ -31,13 +31,13 @@ pub fn init(gloc: GpuAllocator, def: GpuTextureDef) !@This() { .mipLevelCount = 1, .sampleCount = 1, }; - const raw = try gloc.allocTexture(desc); + const raw = try glloc.allocTexture(desc); - return .{ .gloc = gloc, .raw = raw, .def = def }; + return .{ .glloc = glloc, .raw = raw, .def = def }; } pub fn deinit(self: @This()) void { - self.gloc.freeTexture(self.raw); + self.glloc.freeTexture(self.raw); } pub fn getConstMappedRange(self: @This(), offset: u64, size: u64) ?*const anyopaque { @@ -53,14 +53,14 @@ pub fn bytesSizeRow(self: @This()) u32 { } /// Return a GpuBuffer containing a copy of the texture. -pub fn buffCopy(self: @This(), gloc: GpuAllocator) !GpuBuffer { - const buf = try GpuBuffer.init(gloc, .{ +pub fn buffCopy(self: @This(), glloc: GpuAllocator) !GpuBuffer { + const buf = try GpuBuffer.init(glloc, .{ .size = self.bytesSize(), .usage = .initMany(&.{ .CopyDst, .CopySrc }), .label = "texture_copy_buffer", }); - const enc = c.wgpuDeviceCreateCommandEncoder(gloc.device.device, null) orelse return error.Encoder; + const enc = c.wgpuDeviceCreateCommandEncoder(glloc.device.device, null) orelse return error.Encoder; defer c.wgpuCommandEncoderRelease(enc); const src_copy = c.WGPUTexelCopyTextureInfo{ @@ -82,7 +82,7 @@ pub fn buffCopy(self: @This(), gloc: GpuAllocator) !GpuBuffer { const cmd = c.wgpuCommandEncoderFinish(enc, null); defer c.wgpuCommandBufferRelease(cmd); - c.wgpuQueueSubmit(gloc.device.queue, 1, &cmd); + c.wgpuQueueSubmit(glloc.device.queue, 1, &cmd); return buf; } @@ -110,7 +110,7 @@ pub fn load( const bytes = data.len * @sizeOf(T); c.wgpuQueueWriteTexture( - self.gloc.device.queue, + self.glloc.device.queue, &.{ .texture = self.raw, .mipLevel = 0, @@ -132,14 +132,14 @@ pub fn load( pub fn read(self: @This(), alloc: std.mem.Allocator, T: type) ![]T { const out = try alloc.alloc(T, @divExact(self.size, @sizeOf(T))); - const staging = try init(self.gloc, .{ + const staging = try init(self.glloc, .{ .size = self.size, .usage = .initMany(&.{ .MapRead, .CopyDst }), .label = "texture_read_staging", }); defer staging.deinit(); - const enc = c.wgpuDeviceCreateCommandEncoder(self.gloc.device.device, null) orelse return error.Encoder; + const enc = c.wgpuDeviceCreateCommandEncoder(self.glloc.device.device, null) orelse return error.Encoder; const src_copy = c.WGPUTexelCopyTextureInfo{ .texture = self.raw, .mipLevel = 0, @@ -158,7 +158,7 @@ pub fn read(self: @This(), alloc: std.mem.Allocator, T: type) ![]T { const cmd = c.wgpuCommandEncoderFinish(enc, null); defer c.wgpuCommandEncoderRelease(enc); defer c.wgpuCommandBufferRelease(cmd); - c.wgpuQueueSubmit(self.gloc.device.queue, 1, &cmd); + c.wgpuQueueSubmit(self.glloc.device.queue, 1, &cmd); var mapped = false; staging.mapAsync( @@ -167,7 +167,7 @@ pub fn read(self: @This(), alloc: std.mem.Allocator, T: type) ![]T { self.size, .{ .callback = onMapped, .userdata1 = &mapped }, ); - while (!mapped) self.gloc.device.poll(); + while (!mapped) self.glloc.device.poll(); const ptr: [*]const T = @ptrCast(@alignCast( staging.getConstMappedRange(0, self.size), diff --git a/src/GpuTextureView.zig b/src/GpuTextureView.zig index 11b0f96..3b72d2a 100644 --- a/src/GpuTextureView.zig +++ b/src/GpuTextureView.zig @@ -13,23 +13,23 @@ pub const GpuViewDef = struct { }; raw: c.WGPUTextureView, -gloc: GpuAllocator, +glloc: GpuAllocator, -pub fn init(gloc: GpuAllocator, texture: GpuTexture, def: GpuViewDef) !@This() { +pub fn init(glloc: GpuAllocator, texture: GpuTexture, def: GpuViewDef) !@This() { var use: u64 = 0; var iter = def.usage.iterator(); while (iter.next()) |flag| use |= @intFromEnum(flag); - const raw = try gloc.allocTextureView(texture.raw, .{ + const raw = try glloc.allocTextureView(texture.raw, .{ .label = svOpt(def.label), .format = @intFromEnum(def.format), .usage = use, .mipLevelCount = 1, .arrayLayerCount = 1, }); - return .{ .gloc = gloc, .raw = raw }; + return .{ .glloc = glloc, .raw = raw }; } pub fn deinit(self: @This()) void { - self.gloc.freeTextureView(self.raw); + self.glloc.freeTextureView(self.raw); }