kbz_8/VulkanDriver
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

yets
Test / build_and_test (push) Successful in 26s
Details
Build / build (push) Successful in 58s
Details

Browse Source
This commit is contained in:
kbz_8
2026-05-29 00:45:07 +02:00
parent fc2407d10d
commit b26c4ff9e6
3 changed files with 187 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/soft/device/ComputeDispatcher.zig
+8
View File
@@ -58,6 +58,14 @@ pub fn dispatch(self: *Self, group_count_x: u32, group_count_y: u32, group_count
self.invocation_index.store(0, .monotonic);
const io = self.device.interface.io();
const timer = std.Io.Timestamp.now(io, .real);
defer if (comptime base.config.logs != .none) {
const duration = timer.untilNow(io, .real);
const ms: f32 = @floatFromInt(duration.toMicroseconds());
std.log.scoped(.ComputeDispatcher).debug("Compute dispatch took {}ms", .{ms / 1000});
};
var wg: std.Io.Group = .init;
for (0..@min(self.batch_size, group_count)) |batch_id| {
const run_data: RunData = .{
src/soft/device/blitter.zig
+34 -21
View File
@@ -804,20 +804,22 @@ pub fn readFloat4(map: []const u8, src_format: vk.Format) F32x4 {
return c;
}
pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
pub fn writeFloat4(c: F32x4, map: []u8, dst_format: vk.Format) void {
const color = std.math.clamp(c, zm.f32x4s(base.format.minElementValue(dst_format)), zm.f32x4s(base.format.maxElementValue(dst_format)));
switch (dst_format) {
.r8_unorm,
.r8_srgb,
.s8_uint,
=> map[0] = @intFromFloat(@round(color[0] * std.math.maxInt(u8))),
.r8_snorm => map[0] = @intFromFloat(@round(color[0] * std.math.maxInt(i8))),
.r8_snorm => map[0] = @bitCast(@as(i8, @intFromFloat(@round(color[0] * std.math.maxInt(i8))))),
.r16_sint,
.r16_uint,
=> std.mem.bytesAsValue(u16, map).* = @intFromFloat(@round(color[0])),
.r16_snorm => std.mem.bytesAsValue(u16, map).* = @intFromFloat(@round(color[0] * std.math.maxInt(i16))),
.r16_snorm => std.mem.bytesAsValue(u16, map).* = @bitCast(@as(i16, @intFromFloat(@round(color[0] * std.math.maxInt(i16))))),
.r16_unorm,
.d16_unorm,
@@ -834,8 +836,8 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
=> std.mem.bytesAsValue(f32, map).* = color[0],
.r8g8_snorm => {
map[0] = @intFromFloat(@round(color[0] * std.math.maxInt(i8)));
map[1] = @intFromFloat(@round(color[1] * std.math.maxInt(i8)));
map[0] = @bitCast(@as(i8, @intFromFloat(@round(color[0] * std.math.maxInt(i8)))));
map[1] = @bitCast(@as(i8, @intFromFloat(@round(color[1] * std.math.maxInt(i8)))));
},
.r8g8_unorm,
@@ -846,8 +848,8 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
},
.r16g16_snorm => {
std.mem.bytesAsValue(u16, map[0..]).* = @intFromFloat(@round(color[0] * std.math.maxInt(i16)));
std.mem.bytesAsValue(u16, map[2..]).* = @intFromFloat(@round(color[1] * std.math.maxInt(i16)));
std.mem.bytesAsValue(u16, map[0..]).* = @bitCast(@as(i16, @intFromFloat(@round(color[0] * std.math.maxInt(i16)))));
std.mem.bytesAsValue(u16, map[2..]).* = @bitCast(@as(i16, @intFromFloat(@round(color[1] * std.math.maxInt(i16)))));
},
.r16g16_unorm => {
@@ -855,6 +857,11 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
std.mem.bytesAsValue(u16, map[2..]).* = @intFromFloat(@round(color[1] * std.math.maxInt(u16)));
},
.r16g16_uint => {
std.mem.bytesAsValue(u16, map[0..]).* = @intFromFloat(@round(color[0]));
std.mem.bytesAsValue(u16, map[2..]).* = @intFromFloat(@round(color[1]));
},
.r16g16_sfloat => {
std.mem.bytesAsValue(f16, map[0..]).* = @floatCast(color[0]);
std.mem.bytesAsValue(f16, map[2..]).* = @floatCast(color[1]);
@@ -865,7 +872,6 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
std.mem.bytesAsValue(f32, map[4..]).* = color[1];
},
.r16g16b16a16_sint,
.r16g16b16a16_uint,
.r16g16b16a16_unorm,
=> {
@@ -875,11 +881,13 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
std.mem.bytesAsValue(u16, map[6..]).* = @intFromFloat(@round(color[3] * std.math.maxInt(u16)));
},
.r16g16b16a16_snorm => {
std.mem.bytesAsValue(u16, map[0..]).* = @intFromFloat(@round(color[0] * std.math.maxInt(i16)));
std.mem.bytesAsValue(u16, map[2..]).* = @intFromFloat(@round(color[1] * std.math.maxInt(i16)));
std.mem.bytesAsValue(u16, map[4..]).* = @intFromFloat(@round(color[2] * std.math.maxInt(i16)));
std.mem.bytesAsValue(u16, map[6..]).* = @intFromFloat(@round(color[3] * std.math.maxInt(i16)));
.r16g16b16a16_sint,
.r16g16b16a16_snorm,
=> {
std.mem.bytesAsValue(u16, map[0..]).* = @bitCast(@as(i16, @intFromFloat(@round(color[0] * std.math.maxInt(i16)))));
std.mem.bytesAsValue(u16, map[2..]).* = @bitCast(@as(i16, @intFromFloat(@round(color[1] * std.math.maxInt(i16)))));
std.mem.bytesAsValue(u16, map[4..]).* = @bitCast(@as(i16, @intFromFloat(@round(color[2] * std.math.maxInt(i16)))));
std.mem.bytesAsValue(u16, map[6..]).* = @bitCast(@as(i16, @intFromFloat(@round(color[3] * std.math.maxInt(i16)))));
},
.r16g16b16a16_sfloat => {
@@ -964,17 +972,17 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
.a8b8g8r8_sint_pack32,
.a8b8g8r8_snorm_pack32,
=> {
map[0] = @intFromFloat(@round(color[0] * std.math.maxInt(i8)));
map[1] = @intFromFloat(@round(color[1] * std.math.maxInt(i8)));
map[2] = @intFromFloat(@round(color[2] * std.math.maxInt(i8)));
map[3] = @intFromFloat(@round(color[3] * std.math.maxInt(i8)));
map[0] = @bitCast(@as(i8, @intFromFloat(@round(color[0] * std.math.maxInt(i8)))));
map[1] = @bitCast(@as(i8, @intFromFloat(@round(color[1] * std.math.maxInt(i8)))));
map[2] = @bitCast(@as(i8, @intFromFloat(@round(color[2] * std.math.maxInt(i8)))));
map[3] = @bitCast(@as(i8, @intFromFloat(@round(color[3] * std.math.maxInt(i8)))));
},
.r8g8b8a8_snorm => {
map[0] = @intFromFloat(@round(color[0] * std.math.maxInt(i8)));
map[1] = @intFromFloat(@round(color[1] * std.math.maxInt(i8)));
map[2] = @intFromFloat(@round(color[2] * std.math.maxInt(i8)));
map[3] = @intFromFloat(@round(color[3] * std.math.maxInt(i8)));
map[0] = @bitCast(@as(i8, @intFromFloat(@round(color[0] * std.math.maxInt(i8)))));
map[1] = @bitCast(@as(i8, @intFromFloat(@round(color[1] * std.math.maxInt(i8)))));
map[2] = @bitCast(@as(i8, @intFromFloat(@round(color[2] * std.math.maxInt(i8)))));
map[3] = @bitCast(@as(i8, @intFromFloat(@round(color[3] * std.math.maxInt(i8)))));
},
.a2r10g10b10_uint_pack32,
@@ -1005,6 +1013,11 @@ pub fn writeFloat4(color: F32x4, map: []u8, dst_format: vk.Format) void {
(@as(u32, a) << 30);
},
.r32g32b32a32_uint => {
std.debug.print("{}\n", .{@as(@Vector(4, f64), color) * @as(@Vector(4, f64), @splat(std.math.maxInt(u32)))});
std.mem.bytesAsValue(U32x4, map).* = @intFromFloat(@round(@as(@Vector(4, f64), color) * @as(@Vector(4, f64), @splat(std.math.maxInt(u32)))));
},
.r32g32b32a32_sfloat => std.mem.bytesAsValue(F32x4, map).* = color,
.r5g6b5_unorm_pack16 => {
src/vulkan/format.zig
+145
View File
@@ -427,3 +427,148 @@ pub inline fn isUnsigned(format: vk.Format) bool {
pub inline fn isUnnormalizedInteger(format: vk.Format) bool {
return isSint(format) or isUint(format);
}
pub inline fn isSscaled(format: vk.Format) bool {
return lib.c.vkuFormatIsSSCALED(@intCast(@intFromEnum(format)));
}
pub inline fn isUscaled(format: vk.Format) bool {
return lib.c.vkuFormatIsUSCALED(@intCast(@intFromEnum(format)));
}
fn maxComponentBits(format: vk.Format) u32 {
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 64)) return 64;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 32)) return 32;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 24)) return 24;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 16)) return 16;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 11)) return 11;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 10)) return 10;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 8)) return 8;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 6)) return 6;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 5)) return 5;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 4)) return 4;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 2)) return 2;
if (lib.c.vkuFormatHasComponentSize(@intCast(@intFromEnum(format)), 1)) return 1;
lib.unsupported("format component bits {any}", .{format});
return 0;
}
fn maxUnsignedValue(bits: u32) f32 {
return switch (bits) {
1 => 1.0,
2 => 3.0,
4 => 15.0,
5 => 31.0,
6 => 63.0,
8 => @as(f32, @floatFromInt(std.math.maxInt(u8))),
10 => 1023.0,
11 => 2047.0,
16 => @as(f32, @floatFromInt(std.math.maxInt(u16))),
24 => 0xffffff,
32 => @as(f32, @floatFromInt(std.math.maxInt(u32))),
64 => @as(f32, @floatFromInt(std.math.maxInt(u64))),
else => blk: {
lib.unsupported("format component bits {d}", .{bits});
break :blk 1.0;
},
};
}
fn maxSignedValue(bits: u32) f32 {
return switch (bits) {
2 => 1.0,
4 => 7.0,
5 => 15.0,
6 => 31.0,
8 => @as(f32, @floatFromInt(std.math.maxInt(i8))),
10 => 511.0,
11 => 1023.0,
16 => @as(f32, @floatFromInt(std.math.maxInt(i16))),
24 => 0x7fffff,
32 => @as(f32, @floatFromInt(std.math.maxInt(i32))),
64 => @as(f32, @floatFromInt(std.math.maxInt(i64))),
else => blk: {
lib.unsupported("format component bits {d}", .{bits});
break :blk 1.0;
},
};
}
fn minSignedValue(bits: u32) f32 {
return switch (bits) {
2 => -2.0,
4 => -8.0,
5 => -16.0,
6 => -32.0,
8 => @as(f32, @floatFromInt(std.math.minInt(i8))),
10 => -512.0,
11 => -1024.0,
16 => @as(f32, @floatFromInt(std.math.minInt(i16))),
24 => -0x800000,
32 => @as(f32, @floatFromInt(std.math.minInt(i32))),
64 => @as(f32, @floatFromInt(std.math.minInt(i64))),
else => blk: {
lib.unsupported("format component bits {d}", .{bits});
break :blk -1.0;
},
};
}
fn maxFloatValue(format: vk.Format) f32 {
return switch (format) {
.r16_sfloat,
.r16g16_sfloat,
.r16g16b16_sfloat,
.r16g16b16a16_sfloat,
.b10g11r11_ufloat_pack32,
.e5b9g9r9_ufloat_pack32,
.bc6h_ufloat_block,
.bc6h_sfloat_block,
=> std.math.floatMax(f16),
else => std.math.floatMax(f32),
};
}
pub fn maxElementValue(format: vk.Format) f32 {
if (isDepth(format))
return 1.0;
if (isStencil(format))
return maxUnsignedValue(8);
if (isSnorm(format) or isUnorm(format) or isSrgb(format))
return 1.0;
if (isUscaled(format) or isUint(format))
return maxUnsignedValue(maxComponentBits(format));
if (isSscaled(format) or isSint(format))
return maxSignedValue(maxComponentBits(format));
if (isUfloat(format) or isSfloat(format))
return maxFloatValue(format);
lib.unsupported("format max element value {any}", .{format});
return 1.0;
}
pub fn minElementValue(format: vk.Format) f32 {
if (isDepth(format) or isStencil(format))
return 0.0;
if (isSnorm(format))
return -1.0;
if (isUnorm(format) or isSrgb(format) or isUscaled(format) or isUint(format) or isUfloat(format))
return 0.0;
if (isSscaled(format) or isSint(format))
return minSignedValue(maxComponentBits(format));
if (isSfloat(format))
return -maxFloatValue(format);
lib.unsupported("format min element value {any}", .{format});
return 0.0;
}