gpu: make Buffer.get*MappedRange a friendlier slice API

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

gpu/README.md

@@ -152,6 +152,8 @@ Some WebGPU APIs expose slices as pointers and lengths, we either wrap these to
 The slice helpers are:
 
 * `Adapter.enumerateFeaturesOwned`
+* `Buffer.getConstMappedRange`
+* `Buffer.getMappedRange`
 * `CommandEncoder.writeBuffer`
 * `Queue.writeTexture`
 * `Queue.writeBuffer`
@@ -216,8 +218,6 @@ There may be other opportunities for helpers, to improve the existing APIs, or a
 
 The following are definitive candidates for helpers we haven't implemented yet:
 
-* `gpu.Buffer.getConstMappedRange` (slices)
-* `gpu.Buffer.getMappedRange` (slices)
 * `gpu.ComputePassEncoder.setBindGroup` (slice param)
 * `gpu.Device.enumerateFeatures` (owned slice)
 * `gpu.RenderBundleEncoder.setBindGroup` (slice param)

gpu/src/buffer.zig

@@ -69,16 +69,38 @@ pub const Buffer = opaque {
         Impl.bufferDestroy(buffer);
     }
 
-    /// Default `offset`: 0
-    /// Default `size`: `gpu.whole_map_size`
-    pub inline fn getConstMappedRange(buffer: *Buffer, offset: usize, size: usize) ?*const anyopaque {
-        return Impl.bufferGetConstMappedRange(buffer, offset, size);
+    /// Default `offset_bytes`: 0
+    /// Default `len`: `gpu.whole_map_size` / `std.math.maxint(usize)` (whole range)
+    pub inline fn getConstMappedRange(
+        buffer: *Buffer,
+        comptime T: type,
+        offset_bytes: usize,
+        len: usize,
+    ) ?[]const T {
+        const size = @sizeOf(T) * len;
+        const data = Impl.bufferGetConstMappedRange(
+            buffer,
+            offset_bytes,
+            size + size % 4,
+        );
+        return if (data) |d| @ptrCast([*]const T, @alignCast(@alignOf(T), d.ptr))[0..len] else null;
     }
 
-    /// Default `offset`: 0
-    /// Default `size`: `gpu.whole_map_size`
-    pub inline fn getMappedRange(buffer: *Buffer, offset: usize, size: usize) ?*anyopaque {
-        return Impl.bufferGetMappedRange(buffer, offset, size);
+    /// Default `offset_bytes`: 0
+    /// Default `len`: `gpu.whole_map_size` / `std.math.maxint(usize)` (whole range)
+    pub inline fn getMappedRange(
+        buffer: *Buffer,
+        comptime T: type,
+        offset_bytes: usize,
+        len: usize,
+    ) ?[]T {
+        const size = @sizeOf(T) * len;
+        const data = Impl.bufferGetMappedRange(
+            buffer,
+            offset_bytes,
+            size + size % 4,
+        );
+        return if (data) |d| @ptrCast([*]T, @alignCast(@alignOf(T), d.ptr))[0..len] else null;
     }
 
     pub inline fn getSize(buffer: *Buffer) u64 {

gpu/src/command_encoder.zig

@@ -1,3 +1,4 @@
+const std = @import("std");
 const ComputePassEncoder = @import("compute_pass_encoder.zig").ComputePassEncoder;
 const RenderPassEncoder = @import("render_pass_encoder.zig").RenderPassEncoder;
 const CommandBuffer = @import("command_buffer.zig").CommandBuffer;
@@ -91,8 +92,6 @@ pub const CommandEncoder = opaque {
             command_encoder,
             buffer,
             buffer_offset_bytes,
-            data,
-            size,
             @ptrCast([*]const u8, data_slice.ptr),
             @intCast(u64, data_slice.len) * @sizeOf(std.meta.Elem(@TypeOf(data_slice))),
         );

gpu/src/queue.zig

@@ -1,3 +1,4 @@
+const std = @import("std");
 const CommandBuffer = @import("command_buffer.zig").CommandBuffer;
 const Buffer = @import("buffer.zig").Buffer;
 const Texture = @import("texture.zig").Texture;