gpu: implement CommandEncoder.beginComputePass

Signed-off-by: Stephen Gutekanst <stephen@hexops.com>

gpu/src/CommandEncoder.zig

@@ -1,3 +1,4 @@
+const ComputePassEncoder = @import("ComputePassEncoder.zig");
 const RenderPassEncoder = @import("RenderPassEncoder.zig");
 const CommandBuffer = @import("CommandBuffer.zig");
 const QuerySet = @import("QuerySet.zig");
@@ -12,9 +13,7 @@ vtable: *const VTable,
 pub const VTable = struct {
     reference: fn (ptr: *anyopaque) void,
     release: fn (ptr: *anyopaque) void,
-    // TODO:
+    beginComputePass: fn (ptr: *anyopaque, descriptor: *const ComputePassEncoder.Descriptor) ComputePassEncoder,
-    // beginComputePass: fn (ptr: *anyopaque, descriptor: *const ComputePassDescriptor) void,
-    // WGPU_EXPORT WGPUComputePassEncoder wgpuCommandEncoderBeginComputePass(WGPUCommandEncoder commandEncoder, WGPUComputePassDescriptor const * descriptor);
     beginRenderPass: fn (ptr: *anyopaque, descriptor: *const RenderPassEncoder.Descriptor) RenderPassEncoder,
     // clearBuffer: fn (ptr: *anyopaque, buffer: Buffer, offset: u64, size: u64) void,
     // WGPU_EXPORT void wgpuCommandEncoderClearBuffer(WGPUCommandEncoder commandEncoder, WGPUBuffer buffer, uint64_t offset, uint64_t size);
@@ -48,6 +47,10 @@ pub inline fn release(enc: CommandEncoder) void {
     enc.vtable.release(enc.ptr);
 }
 
+pub inline fn beginComputePass(enc: CommandEncoder, descriptor: *const ComputePassEncoder.Descriptor) ComputePassEncoder {
+    return enc.vtable.beginComputePass(enc.ptr, descriptor);
+}
+
 pub inline fn beginRenderPass(enc: CommandEncoder, descriptor: *const RenderPassEncoder.Descriptor) RenderPassEncoder {
     return enc.vtable.beginRenderPass(enc.ptr, descriptor);
 }
@@ -84,6 +87,7 @@ test {
     _ = VTable;
     _ = reference;
     _ = release;
+    _ = beginComputePass;
     _ = beginRenderPass;
     _ = finish;
     _ = insertDebugMarker;

gpu/src/NativeInstance.zig

@@ -1503,6 +1503,40 @@ const command_encoder_vtable = CommandEncoder.VTable{
             c.wgpuCommandEncoderSetLabel(@ptrCast(c.WGPUCommandEncoder, ptr), label);
         }
     }).setLabel,
+    .beginComputePass = (struct {
+        pub fn beginComputePass(ptr: *anyopaque, d: *const ComputePassEncoder.Descriptor) ComputePassEncoder {
+            var few_timestamp_writes: [8]c.WGPUComputePassTimestampWrite = undefined;
+            const timestamp_writes = if (d.timestamp_writes.len <= 8) blk: {
+                for (d.timestamp_writes) |v, i| {
+                    few_timestamp_writes[i] = c.WGPUComputePassTimestampWrite{
+                        .querySet = @ptrCast(c.WGPUQuerySet, v.query_set.ptr),
+                        .queryIndex = v.query_index,
+                        .location = @enumToInt(v.location),
+                    };
+                }
+                break :blk few_timestamp_writes[0..d.timestamp_writes.len];
+            } else blk: {
+                const mem = std.heap.page_allocator.alloc(c.WGPUComputePassTimestampWrite, d.timestamp_writes.len) catch unreachable;
+                for (d.timestamp_writes) |v, i| {
+                    mem[i] = c.WGPUComputePassTimestampWrite{
+                        .querySet = @ptrCast(c.WGPUQuerySet, v.query_set.ptr),
+                        .queryIndex = v.query_index,
+                        .location = @enumToInt(v.location),
+                    };
+                }
+                break :blk mem;
+            };
+            defer if (d.timestamp_writes.len > 8) std.heap.page_allocator.free(timestamp_writes);
+
+            const desc = c.WGPUComputePassDescriptor{
+                .nextInChain = null,
+                .label = if (d.label) |l| l else null,
+                .timestampWriteCount = @intCast(u32, timestamp_writes.len),
+                .timestampWrites = @ptrCast(*const c.WGPUComputePassTimestampWrite, &timestamp_writes[0]),
+            };
+            return wrapComputePassEncoder(c.wgpuCommandEncoderBeginComputePass(@ptrCast(c.WGPUCommandEncoder, ptr), &desc));
+        }
+    }).beginComputePass,
     .beginRenderPass = (struct {
         pub fn beginRenderPass(ptr: *anyopaque, d: *const RenderPassEncoder.Descriptor) RenderPassEncoder {
             var few_color_attachments: [8]c.WGPURenderPassColorAttachment = undefined;

gpu/src/main.zig

@@ -100,6 +100,8 @@ pub const StorageTextureBindingLayout = @import("structs.zig").StorageTextureBin
 pub const DepthStencilState = @import("structs.zig").DepthStencilState;
 pub const ConstantEntry = @import("structs.zig").ConstantEntry;
 pub const ProgrammableStageDescriptor = @import("structs.zig").ProgrammableStageDescriptor;
+// TODO: should these be moved into ComputePassEncoder / RenderPassEncoder? If not, should
+// WGPURenderPassDescriptor really be RenderPassEncoder.Descriptor?
 pub const ComputePassTimestampWrite = @import("structs.zig").ComputePassTimestampWrite;
 pub const RenderPassTimestampWrite = @import("structs.zig").RenderPassTimestampWrite;
 pub const RenderPassDepthStencilAttachment = @import("structs.zig").RenderPassDepthStencilAttachment;