From 36243b2871b95fe9b3225b3711f1b5f1c10f5d8f Mon Sep 17 00:00:00 2001 From: Stephen Gutekanst Date: Wed, 16 Mar 2022 20:54:33 -0700 Subject: [PATCH] gpu: implement RenderBundleEncoder.draw Signed-off-by: Stephen Gutekanst --- gpu/src/NativeInstance.zig | 202 ++++++++++++++++++++++++++++++++ gpu/src/RenderBundleEncoder.zig | 133 +++++++++++++++++++-- 2 files changed, 328 insertions(+), 7 deletions(-) diff --git a/gpu/src/NativeInstance.zig b/gpu/src/NativeInstance.zig index 89143fd1..5187054d 100644 --- a/gpu/src/NativeInstance.zig +++ b/gpu/src/NativeInstance.zig @@ -1117,6 +1117,208 @@ const render_bundle_encoder_vtable = RenderBundleEncoder.VTable{ c.wgpuRenderBundleEncoderSetLabel(@ptrCast(c.WGPURenderBundleEncoder, ptr), label); } }).setLabel, + // .setPipeline = (struct { + // pub fn setPipeline(ptr: *anyopaque, pipeline: RenderPipeline) void { + // c.wgpuRenderBundleEncoderSetPipeline(@ptrCast(c.WGPURenderBundleEncoder, ptr), @ptrCast(c.WGPURenderPipeline, pipeline.ptr)); + // } + // }).setPipeline, + .draw = (struct { + pub fn draw(ptr: *anyopaque, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) void { + c.wgpuRenderBundleEncoderDraw(@ptrCast(c.WGPURenderBundleEncoder, ptr), vertex_count, instance_count, first_vertex, first_instance); + } + }).draw, + // .drawIndexed = (struct { + // pub fn drawIndexed( + // ptr: *anyopaque, + // index_count: u32, + // instance_count: u32, + // first_index: u32, + // base_vertex: i32, + // first_instance: u32, + // ) void { + // c.wgpuRenderBundleEncoderDrawIndexed( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // index_count, + // instance_count, + // first_index, + // base_vertex, + // first_instance, + // ); + // } + // }).drawIndexed, + // .drawIndexedIndirect = (struct { + // pub fn drawIndexedIndirect(ptr: *anyopaque, indirect_buffer: Buffer, indirect_offset: u64) void { + // c.wgpuRenderBundleEncoderDrawIndexedIndirect( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // @ptrCast(c.WGPUBuffer, indirect_buffer.ptr), + // indirect_offset, + // ); + // } + // }).drawIndexedIndirect, + // .drawIndirect = (struct { + // pub fn drawIndirect(ptr: *anyopaque, indirect_buffer: Buffer, indirect_offset: u64) void { + // c.wgpuRenderBundleEncoderDrawIndexedIndirect( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // @ptrCast(c.WGPUBuffer, indirect_buffer.ptr), + // indirect_offset, + // ); + // } + // }).drawIndirect, + // .beginOcclusionQuery = (struct { + // pub fn beginOcclusionQuery(ptr: *anyopaque, query_index: u32) void { + // c.wgpuRenderBundleEncoderBeginOcclusionQuery(@ptrCast(c.WGPURenderBundleEncoder, ptr), query_index); + // } + // }).beginOcclusionQuery, + // .endOcclusionQuery = (struct { + // pub fn endOcclusionQuery(ptr: *anyopaque) void { + // c.wgpuRenderBundleEncoderEndOcclusionQuery(@ptrCast(c.WGPURenderBundleEncoder, ptr)); + // } + // }).endOcclusionQuery, + // .end = (struct { + // pub fn end(ptr: *anyopaque) void { + // c.wgpuRenderBundleEncoderEnd(@ptrCast(c.WGPURenderBundleEncoder, ptr)); + // } + // }).end, + // .executeBundles = (struct { + // pub fn executeBundles(ptr: *anyopaque, bundles: []RenderBundle) void { + // var few_bundles: [16]c.WGPURenderBundle = undefined; + // const c_bundles = if (bundles.len <= 8) blk: { + // for (bundles) |bundle, i| { + // few_bundles[i] = @ptrCast(c.WGPURenderBundle, bundle.ptr); + // } + // break :blk few_bundles[0..bundles.len]; + // } else blk: { + // const mem = std.heap.page_allocator.alloc(c.WGPURenderBundle, bundles.len) catch unreachable; + // for (bundles) |bundle, i| { + // mem[i] = @ptrCast(c.WGPURenderBundle, bundle.ptr); + // } + // break :blk mem; + // }; + // defer if (bundles.len > 8) std.heap.page_allocator.free(c_bundles); + + // c.wgpuRenderBundleEncoderExecuteBundles( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // @intCast(u32, c_bundles.len), + // &c_bundles[0], + // ); + // } + // }).executeBundles, + // .insertDebugMarker = (struct { + // pub fn insertDebugMarker(ptr: *anyopaque, marker_label: [*:0]const u8) void { + // c.wgpuRenderBundleEncoderInsertDebugMarker(@ptrCast(c.WGPURenderBundleEncoder, ptr), marker_label); + // } + // }).insertDebugMarker, + // .popDebugGroup = (struct { + // pub fn popDebugGroup(ptr: *anyopaque) void { + // c.wgpuRenderBundleEncoderPopDebugGroup(@ptrCast(c.WGPURenderBundleEncoder, ptr)); + // } + // }).popDebugGroup, + // .pushDebugGroup = (struct { + // pub fn pushDebugGroup(ptr: *anyopaque, group_label: [*:0]const u8) void { + // c.wgpuRenderBundleEncoderPushDebugGroup(@ptrCast(c.WGPURenderBundleEncoder, ptr), group_label); + // } + // }).pushDebugGroup, + // .setBindGroup = (struct { + // pub fn setBindGroup( + // ptr: *anyopaque, + // group_index: u32, + // group: BindGroup, + // dynamic_offsets: []u32, + // ) void { + // c.wgpuRenderBundleEncoderSetBindGroup( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // group_index, + // @ptrCast(c.WGPUBindGroup, group.ptr), + // @intCast(u32, dynamic_offsets.len), + // &dynamic_offsets[0], + // ); + // } + // }).setBindGroup, + // .setBlendConstant = (struct { + // pub fn setBlendConstant(ptr: *anyopaque, color: *const Color) void { + // c.wgpuRenderBundleEncoderSetBlendConstant( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // @ptrCast(*const c.WGPUColor, color), + // ); + // } + // }).setBlendConstant, + // .setIndexBuffer = (struct { + // pub fn setIndexBuffer( + // ptr: *anyopaque, + // buffer: Buffer, + // format: IndexFormat, + // offset: u64, + // size: u64, + // ) void { + // c.wgpuRenderBundleEncoderSetIndexBuffer( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // @ptrCast(c.WGPUBuffer, buffer.ptr), + // @enumToInt(format), + // offset, + // size, + // ); + // } + // }).setIndexBuffer, + // .setScissorRect = (struct { + // pub fn setScissorRect(ptr: *anyopaque, x: u32, y: u32, width: u32, height: u32) void { + // c.wgpuRenderBundleEncoderSetScissorRect( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // x, + // y, + // width, + // height, + // ); + // } + // }).setScissorRect, + // .setStencilReference = (struct { + // pub fn setStencilReference(ptr: *anyopaque, reference: u32) void { + // c.wgpuRenderBundleEncoderSetStencilReference( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // reference, + // ); + // } + // }).setStencilReference, + // .setVertexBuffer = (struct { + // pub fn setVertexBuffer(ptr: *anyopaque, slot: u32, buffer: Buffer, offset: u64, size: u64) void { + // c.wgpuRenderBundleEncoderSetVertexBuffer( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // slot, + // @ptrCast(c.WGPUBuffer, buffer.ptr), + // offset, + // size, + // ); + // } + // }).setVertexBuffer, + // .setViewport = (struct { + // pub fn setViewport( + // ptr: *anyopaque, + // x: f32, + // y: f32, + // width: f32, + // height: f32, + // min_depth: f32, + // max_depth: f32, + // ) void { + // c.wgpuRenderBundleEncoderSetViewport( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // x, + // y, + // width, + // height, + // min_depth, + // max_depth, + // ); + // } + // }).setViewport, + // .writeTimestamp = (struct { + // pub fn writeTimestamp(ptr: *anyopaque, query_set: QuerySet, query_index: u32) void { + // c.wgpuRenderBundleEncoderWriteTimestamp( + // @ptrCast(c.WGPURenderBundleEncoder, ptr), + // @ptrCast(c.WGPUQuerySet, query_set.ptr), + // query_index, + // ); + // } + // }).writeTimestamp, }; fn wrapRenderBundle(bundle: c.WGPURenderBundle) RenderBundle { diff --git a/gpu/src/RenderBundleEncoder.zig b/gpu/src/RenderBundleEncoder.zig index 304e9adc..6e094cf6 100644 --- a/gpu/src/RenderBundleEncoder.zig +++ b/gpu/src/RenderBundleEncoder.zig @@ -10,13 +10,13 @@ vtable: *const VTable, pub const VTable = struct { reference: fn (ptr: *anyopaque) void, release: fn (ptr: *anyopaque) void, - // draw: fn ( - // ptr: *anyopaque, - // vertex_count: u32, - // instance_count: u32, - // first_vertex: u32, - // first_instance: u32, - // ) void, + draw: fn ( + ptr: *anyopaque, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, + ) void, // WGPU_EXPORT void wgpuRenderBundleEncoderDraw(WGPURenderBundleEncoder renderBundleEncoder, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); // drawIndexed: fn ( // ptr: *anyopaque, @@ -58,10 +58,128 @@ pub inline fn release(enc: RenderBundleEncoder) void { enc.vtable.release(enc.ptr); } +pub inline fn draw( + enc: RenderBundleEncoder, + vertex_count: u32, + instance_count: u32, + first_vertex: u32, + first_instance: u32, +) void { + enc.vtable.draw(enc.ptr, vertex_count, instance_count, first_vertex, first_instance); +} + +// pub inline fn drawIndexed( +// enc: RenderPassEncoder, +// index_count: u32, +// instance_count: u32, +// first_index: u32, +// base_vertex: i32, +// first_instance: u32, +// ) void { +// enc.vtable.drawIndexed(enc.ptr, index_count, instance_count, first_index, base_vertex, first_instance); +// } + +// pub inline fn drawIndexedIndirect(enc: RenderPassEncoder, indirect_buffer: Buffer, indirect_offset: u64) void { +// enc.vtable.drawIndexedIndirect(enc.ptr, indirect_buffer, indirect_offset); +// } + +// pub inline fn drawIndirect(enc: RenderPassEncoder, indirect_buffer: Buffer, indirect_offset: u64) void { +// enc.vtable.drawIndirect(enc.ptr, indirect_buffer, indirect_offset); +// } + +// pub inline fn beginOcclusionQuery(enc: RenderPassEncoder, query_index: u32) void { +// enc.vtable.beginOcclusionQuery(enc.ptr, query_index); +// } + +// pub inline fn endOcclusionQuery(enc: RenderPassEncoder) void { +// enc.vtable.endOcclusionQuery(enc.ptr); +// } + +// pub inline fn end(enc: RenderPassEncoder) void { +// enc.vtable.end(enc.ptr); +// } + +// pub inline fn executeBundles(enc: RenderPassEncoder, bundles: []RenderBundle) void { +// enc.vtable.executeBundles(enc.ptr, bundles); +// } + +// pub inline fn insertDebugMarker(enc: RenderPassEncoder, marker_label: [*:0]const u8) void { +// enc.vtable.insertDebugMarker(enc.ptr, marker_label); +// } + +// pub inline fn popDebugGroup(enc: RenderPassEncoder) void { +// enc.vtable.popDebugGroup(enc.ptr); +// } + +// pub inline fn pushDebugGroup(enc: RenderPassEncoder, group_label: [*:0]const u8) void { +// enc.vtable.pushDebugGroup(enc.ptr, group_label); +// } + +// pub inline fn setBindGroup( +// enc: RenderPassEncoder, +// group_index: u32, +// group: BindGroup, +// dynamic_offsets: []u32, +// ) void { +// enc.vtable.setBindGroup(enc.ptr, group_index, group, dynamic_offsets); +// } + +// pub inline fn setBlendConstant(enc: RenderPassEncoder, color: *const Color) void { +// enc.vtable.setBlendConstant(enc.ptr, color); +// } + +// pub inline fn setIndexBuffer( +// enc: RenderPassEncoder, +// buffer: Buffer, +// format: IndexFormat, +// offset: u64, +// size: u64, +// ) void { +// enc.vtable.setIndexBuffer(enc.ptr, buffer, format, offset, size); +// } + pub inline fn setLabel(enc: RenderBundleEncoder, label: [:0]const u8) void { enc.vtable.setLabel(enc.ptr, label); } +// pub inline fn setPipeline(enc: RenderPassEncoder, pipeline: RenderPipeline) void { +// enc.vtable.setPipeline(enc.ptr, pipeline); +// } + +// pub inline fn setScissorRect(enc: RenderPassEncoder, x: u32, y: u32, width: u32, height: u32) void { +// enc.vtable.setScissorRect(enc.ptr, x, y, width, height); +// } + +// pub inline fn setStencilReference(enc: RenderPassEncoder, ref: u32) void { +// enc.vtable.setStencilReference(enc.ptr, ref); +// } + +// pub inline fn setVertexBuffer( +// enc: RenderPassEncoder, +// slot: u32, +// buffer: Buffer, +// offset: u64, +// size: u64, +// ) void { +// enc.vtable.setVertexBuffer(enc.ptr, slot, buffer, offset, size); +// } + +// pub inline fn setViewport( +// enc: RenderPassEncoder, +// x: f32, +// y: f32, +// width: f32, +// height: f32, +// min_depth: f32, +// max_depth: f32, +// ) void { +// enc.vtable.setViewport(enc.ptr, x, y, width, height, min_depth, max_depth); +// } + +// pub inline fn writeTimestamp(enc: RenderPassEncoder, query_set: QuerySet, query_index: u32) void { +// enc.vtable.writeTimestamp(enc.ptr, query_set, query_index); +// } + pub const Descriptor = struct { label: ?[*:0]const u8 = null, color_formats: []Texture.Format, @@ -75,5 +193,6 @@ test { _ = VTable; _ = reference; _ = release; + _ = draw; _ = Descriptor; }