zig/mach
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gpu: prepare for full-scale rewrite of library

Browse source 
Signed-off-by: Stephen Gutekanst <stephen@hexops.com>
This commit is contained in:
Stephen Gutekanst 2022-07-10 18:02:19 -07:00 • committed by Stephen Gutekanst
parent 9d05e7c656
commit 2174936469
30 changed files with 0 additions and 5865 deletions
Download patch file Download diff file Expand all files Collapse all files

142
gpu/src/Buffer.zig
View file

@ -1,142 +0,0 @@
const std = @import("std");
const BufferUsage = @import("enums.zig").BufferUsage;
const Buffer = @This();
/// The type erased pointer to the Buffer implementation
/// Equal to c.WGPUBuffer for NativeInstance.
ptr: *anyopaque,
vtable: *const VTable,
pub const VTable = struct {
reference: fn (ptr: *anyopaque) void,
release: fn (ptr: *anyopaque) void,
destroy: fn (ptr: *anyopaque) void,
getConstMappedRange: fn (ptr: *anyopaque, offset: usize, size: usize) []const u8,
getMappedRange: fn (ptr: *anyopaque, offset: usize, size: usize) []u8,
setLabel: fn (ptr: *anyopaque, label: [:0]const u8) void,
mapAsync: fn (
ptr: *anyopaque,
mode: MapMode,
offset: usize,
size: usize,
callback: *MapCallback,
) void,
unmap: fn (ptr: *anyopaque) void,
};
pub inline fn reference(buf: Buffer) void {
buf.vtable.reference(buf.ptr);
}
pub inline fn release(buf: Buffer) void {
buf.vtable.release(buf.ptr);
}
pub inline fn destroy(buf: Buffer) void {
buf.vtable.destroy(buf.ptr);
}
pub inline fn getConstMappedRange(buf: Buffer, comptime T: type, offset: usize, len: usize) []const T {
const size = @sizeOf(T) * len;
const data = buf.vtable.getConstMappedRange(buf.ptr, offset, size + size % 4);
return @ptrCast([*]const T, @alignCast(@alignOf(T), data.ptr))[0..len];
}
pub inline fn getMappedRange(buf: Buffer, comptime T: type, offset: usize, len: usize) []T {
const size = @sizeOf(T) * len;
const data = buf.vtable.getMappedRange(buf.ptr, offset, size + size % 4);
return @ptrCast([*]T, @alignCast(@alignOf(T), data.ptr))[0..len];
}
pub inline fn setLabel(buf: Buffer, label: [:0]const u8) void {
buf.vtable.setLabel(buf.ptr, label);
}
pub inline fn mapAsync(
buf: Buffer,
mode: MapMode,
offset: usize,
size: usize,
callback: *MapCallback,
) void {
buf.vtable.mapAsync(buf.ptr, mode, offset, size, callback);
}
pub const MapCallback = struct {
type_erased_ctx: *anyopaque,
type_erased_callback: fn (ctx: *anyopaque, status: MapAsyncStatus) callconv(.Inline) void,
pub fn init(
comptime Context: type,
ctx: Context,
comptime callback: fn (ctx: Context, status: MapAsyncStatus) void,
) MapCallback {
const erased = (struct {
pub inline fn erased(type_erased_ctx: *anyopaque, status: MapAsyncStatus) void {
callback(if (Context == void) {} else @ptrCast(Context, @alignCast(std.meta.alignment(Context), type_erased_ctx)), status);
}
}).erased;
return .{
.type_erased_ctx = if (Context == void) undefined else ctx,
.type_erased_callback = erased,
};
}
};
pub inline fn unmap(buf: Buffer) void {
buf.vtable.unmap(buf.ptr);
}
pub const Descriptor = extern struct {
reserved: ?*anyopaque = null,
label: ?[*:0]const u8 = null,
usage: BufferUsage,
size: usize,
mapped_at_creation: bool = false,
};
pub const BindingType = enum(u32) {
none = 0x00000000,
uniform = 0x00000001,
storage = 0x00000002,
read_only_storage = 0x00000003,
};
pub const BindingLayout = extern struct {
reserved: ?*anyopaque = null,
type: BindingType = .uniform,
has_dynamic_offset: bool = false,
min_binding_size: u64 = 0,
};
pub const MapAsyncStatus = enum(u32) {
success = 0x00000000,
err = 0x00000001,
unknown = 0x00000002,
device_lost = 0x00000003,
destroyed_before_callback = 0x00000004,
unmapped_before_callback = 0x00000005,
};
pub const MapMode = enum(u32) {
none = 0x00000000,
read = 0x00000001,
write = 0x00000002,
};
test {
_ = VTable;
_ = reference;
_ = release;
_ = destroy;
_ = getConstMappedRange;
_ = getMappedRange;
_ = setLabel;
_ = Descriptor;
_ = BindingType;
_ = BindingLayout;
_ = MapAsyncStatus;
_ = MapMode;
}