summaryrefslogtreecommitdiff
path: root/src/gpu
diff options
context:
space:
mode:
Diffstat (limited to 'src/gpu')
-rw-r--r--src/gpu/Executor.zig41
-rw-r--r--src/gpu/scene.zig55
2 files changed, 79 insertions, 17 deletions
diff --git a/src/gpu/Executor.zig b/src/gpu/Executor.zig
index 412d0ed..460b2d5 100644
--- a/src/gpu/Executor.zig
+++ b/src/gpu/Executor.zig
@@ -155,6 +155,8 @@ const Target = struct {
msaa_fresh: bool = true,
stencil_samples: u8 = 0,
stencil: ?*c.SDL_GPUTexture = null,
+ depth_valid: bool = false,
+ depth_sampleable: bool = false,
};
pub fn init(gpa: std.mem.Allocator, device: *c.SDL_GPUDevice) Gpu {
@@ -229,25 +231,41 @@ pub fn run(g: *Gpu, pass: abi.gpu.Pass) !void {
/// Records into the caller's command buffer; the caller submits it.
/// Uploads cycle their buffers, allowing several passes in one frame.
pub fn record(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass) !void {
- return g.recordWithInput(cmd, pass, null);
+ return g.recordWithInput(cmd, pass, &.{});
+}
+
+pub fn runPostProcess(g: *Gpu, source: abi.Image, target: abi.Image, post: abi.gpu.PostProcess) !void {
+ const start = g.startTiming();
+ const cmd = c.SDL_AcquireGPUCommandBuffer(g.device) orelse return error.GpuCommandBuffer;
+ errdefer _ = c.SDL_CancelGPUCommandBuffer(cmd);
+ try g.postProcess(cmd, source, target, post);
+ try g.submit(cmd, "postprocess", start);
}
/// A second pass on the same command buffer; input and output must differ.
pub fn postProcess(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, source: abi.Image, target: abi.Image, post: abi.gpu.PostProcess) !void {
if (source == target) return error.FeedbackLoop;
- const input = g.output(source) orelse return error.MissingImage;
+ const input = g.targets.get(source) orelse return error.MissingImage;
+ var textures: [2]*c.SDL_GPUTexture = undefined;
+ textures[0] = input.texture;
+ if (post.sample_depth) {
+ if (!input.depth_valid or input.stencil == null) return error.MissingDepthAttachment;
+ if (input.stencil_samples != 1) return error.MultisampleDepthUnsupported;
+ if (!input.depth_sampleable) return error.DepthSamplingUnsupported;
+ textures[1] = input.stencil.?;
+ }
try g.recordWithInput(cmd, .{
.image = target,
.width = input.width,
.height = input.height,
.pipelines = &.{.{ .vertex = post.vertex, .fragment = post.fragment, .stride = 0, .attributes = &.{}, .blend = .none }},
.draws = &.{.{ .pipeline = 0, .vertex_count = 3, .fragment_uniforms = post.fragment_uniforms }},
- }, input.texture);
+ }, textures[0 .. 1 + @as(usize, @intFromBool(post.sample_depth))]);
}
-fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, input: ?*c.SDL_GPUTexture) !void {
+fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, input: []const *c.SDL_GPUTexture) !void {
if (pass.width == 0 or pass.height == 0 or pass.draws.len == 0 and pass.clear == null) return;
- if (input != null and g.post_sampler == null) {
+ if (input.len != 0 and g.post_sampler == null) {
g.post_sampler = c.SDL_CreateGPUSampler(g.device, &std.mem.zeroInit(c.SDL_GPUSamplerCreateInfo, .{
.min_filter = c.SDL_GPU_FILTER_NEAREST,
.mag_filter = c.SDL_GPU_FILTER_NEAREST,
@@ -269,7 +287,7 @@ fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, in
if (d.pipeline >= pass.pipelines.len) return error.BadPipeline;
const p = pass.pipelines[d.pipeline];
if ((p.depth_test != null or p.depth_write) and !pass.depth) return error.MissingDepthAttachment;
- if (built[d.pipeline] == null) built[d.pipeline] = try g.pipeline(pass.pipelines[d.pipeline], samples, pass.stencil or pass.depth, @intFromBool(input != null));
+ if (built[d.pipeline] == null) built[d.pipeline] = try g.pipeline(pass.pipelines[d.pipeline], samples, pass.stencil or pass.depth, @intCast(input.len));
}
// Every draw's vertices go up in one copy.
@@ -314,13 +332,14 @@ fn recordWithInput(g: *Gpu, cmd: *c.SDL_GPUCommandBuffer, pass: abi.gpu.Pass, in
depth.texture = t.stencil;
depth.load_op = if (pass.depth) c.SDL_GPU_LOADOP_CLEAR else c.SDL_GPU_LOADOP_DONT_CARE;
depth.clear_depth = 1;
- depth.store_op = c.SDL_GPU_STOREOP_DONT_CARE;
+ depth.store_op = if (pass.depth) c.SDL_GPU_STOREOP_STORE else c.SDL_GPU_STOREOP_DONT_CARE;
depth.stencil_load_op = c.SDL_GPU_LOADOP_CLEAR;
depth.stencil_store_op = c.SDL_GPU_STOREOP_DONT_CARE;
depth.clear_stencil = 0;
}
const rp = c.SDL_BeginGPURenderPass(cmd, &color, 1, if (pass.stencil or pass.depth) &depth else null) orelse return error.GpuRenderPass;
- if (input) |texture_| c.SDL_BindGPUFragmentSamplers(rp, 0, &.{ .texture = texture_, .sampler = g.post_sampler.? }, 1);
+ t.depth_valid = pass.depth;
+ for (input, 0..) |texture_, slot| c.SDL_BindGPUFragmentSamplers(rp, @intCast(slot), &.{ .texture = texture_, .sampler = g.post_sampler.? }, 1);
var bound: ?*c.SDL_GPUGraphicsPipeline = null;
// State already set in this pass, so draws that repeat it skip the call.
var vertex_uniforms: ?[]const u8 = null;
@@ -575,9 +594,13 @@ fn renderTarget(g: *Gpu, image: abi.Image, w: u32, h: u32, samples: u8, stencil:
t.msaa_fresh = true;
}
if (stencil and (t.stencil == null or t.stencil_samples != samples)) {
+ const sampled_usage = c.SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | c.SDL_GPU_TEXTUREUSAGE_SAMPLER;
+ const sampleable = samples == 1 and c.SDL_GPUTextureSupportsFormat(g.device, g.stencil_format, c.SDL_GPU_TEXTURETYPE_2D, sampled_usage);
+ const replacement = try g.texture(w, h, g.stencil_format, if (sampleable) sampled_usage else c.SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, samples);
if (t.stencil) |s| c.SDL_ReleaseGPUTexture(g.device, s);
- t.stencil = try g.texture(w, h, g.stencil_format, c.SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, samples);
+ t.stencil = replacement;
t.stencil_samples = samples;
+ t.depth_sampleable = sampleable;
}
return t;
}
diff --git a/src/gpu/scene.zig b/src/gpu/scene.zig
index e5ff3d0..d5e1db5 100644
--- a/src/gpu/scene.zig
+++ b/src/gpu/scene.zig
@@ -2,6 +2,7 @@
//! Version 1: "SGPU", u32 version, then Pass fields in declaration order.
//! Version 2 appends one fullscreen PostProcess sampling that pass's output.
//! Version 3 adds depth fields and an optional PostProcess after the pass.
+//! Version 4 adds optional depth sampling to PostProcess.
//! Integers/enums/f32 are little endian; slices have a u32 count, optionals
//! and bools a byte (0 or 1). No pointers, native padding, or device handles.
//! Storage buffers are not part of this version: each frame stands alone.
@@ -22,11 +23,12 @@ pub fn encode(w: *std.Io.Writer, pass: abi.gpu.Pass) !void {
pub fn encodePostProcess(w: *std.Io.Writer, pass: abi.gpu.Pass, post: abi.gpu.PostProcess) !void {
try validate(pass);
try validatePostProcess(post);
+ if (post.sample_depth and (!pass.depth or pass.samples != 1)) return error.BadScene;
try w.writeAll("SGPU");
- const version: u32 = if (pass.depth) 3 else 2;
+ const version: u32 = if (post.sample_depth) 4 else if (pass.depth) 3 else 2;
try w.writeInt(u32, version, .little);
try put(w, pass, version);
- if (version == 3) try put(w, @as(?abi.gpu.PostProcess, post), version) else try put(w, post, version);
+ if (version >= 3) try put(w, @as(?abi.gpu.PostProcess, post), version) else try put(w, post, version);
}
/// Allocations belong to the caller's frame arena. Never run unvalidated
@@ -42,13 +44,16 @@ pub fn decodeFrame(arena: std.mem.Allocator, bytes: []const u8) !Frame {
var r: std.Io.Reader = .fixed(bytes);
if (!std.mem.eql(u8, try r.take(4), "SGPU")) return error.BadScene;
const version = try r.takeInt(u32, .little);
- if (version < 1 or version > 3) return error.BadScene;
+ if (version < 1 or version > 4) return error.BadScene;
var budget: usize = max_bytes * 4;
const pass = try get(abi.gpu.Pass, arena, &r, &budget, version);
- const post: ?abi.gpu.PostProcess = if (version == 3) try get(?abi.gpu.PostProcess, arena, &r, &budget, version) else if (version == 2) try get(abi.gpu.PostProcess, arena, &r, &budget, version) else null;
+ const post: ?abi.gpu.PostProcess = if (version >= 3) try get(?abi.gpu.PostProcess, arena, &r, &budget, version) else if (version == 2) try get(abi.gpu.PostProcess, arena, &r, &budget, version) else null;
if (r.end != r.seek) return error.BadScene;
try validate(pass);
- if (post) |p| try validatePostProcess(p);
+ if (post) |p| {
+ try validatePostProcess(p);
+ if (p.sample_depth and (!pass.depth or pass.samples != 1)) return error.BadScene;
+ }
return .{ .pass = pass, .post = post };
}
@@ -57,6 +62,11 @@ fn depthField(comptime T: type, comptime name: []const u8) bool {
(T == abi.gpu.Pipeline and (std.mem.eql(u8, name, "depth_test") or std.mem.eql(u8, name, "depth_write")));
}
+fn absentField(comptime T: type, comptime name: []const u8, version: u32) bool {
+ return (version < 3 and depthField(T, name)) or
+ (version < 4 and T == abi.gpu.PostProcess and std.mem.eql(u8, name, "sample_depth"));
+}
+
fn put(w: *std.Io.Writer, value: anytype, version: u32) anyerror!void {
const T = @TypeOf(value);
switch (@typeInfo(T)) {
@@ -74,7 +84,7 @@ fn put(w: *std.Io.Writer, value: anytype, version: u32) anyerror!void {
for (value) |v| try put(w, v, version);
},
.@"struct" => |s| inline for (s.field_names) |name| {
- if (version >= 3 or !depthField(T, name)) try put(w, @field(value, name), version);
+ if (!absentField(T, name, version)) try put(w, @field(value, name), version);
},
else => @compileError("unsupported scene field"),
}
@@ -117,7 +127,7 @@ fn get(comptime T: type, a: std.mem.Allocator, r: *std.Io.Reader, budget: *usize
.@"struct" => |s| {
var out: T = undefined;
inline for (s.field_names, s.field_types) |name, F| {
- @field(out, name) = if (version < 3 and comptime depthField(T, name)) std.mem.zeroes(F) else try get(F, a, r, budget, version);
+ @field(out, name) = if (absentField(T, name, version)) std.mem.zeroes(F) else try get(F, a, r, budget, version);
}
return out;
},
@@ -227,7 +237,7 @@ test "GPU postprocess keeps v1 readable and validates the complete second pass"
bad = post;
bad.fragment.storage_buffers = 1;
try std.testing.expectError(error.BadShader, validatePostProcess(bad));
- out.written()[4] = 4;
+ out.written()[4] = 5;
try std.testing.expectError(error.BadScene, decodeFrame(arena.allocator(), out.written()));
}
@@ -261,3 +271,32 @@ test "depth uses v3 and requires an attachment; legacy frames keep depth disable
const legacy = try decode(arena.allocator(), out.written());
try std.testing.expect(!legacy.depth and legacy.pipelines[0].depth_test == null and !legacy.pipelines[0].depth_write);
}
+
+test "depth postprocess uses v4 and rejects missing or multisampled source depth" {
+ const code = std.mem.asBytes(&[_]u32{ 0x07230203, 0, 0, 0, 0 });
+ const pipelines = [_]abi.gpu.Pipeline{.{ .vertex = .{ .code = code }, .fragment = .{ .code = code }, .stride = 0, .attributes = &.{} }};
+ var pass: abi.gpu.Pass = .{ .image = .none, .width = 32, .height = 24, .depth = true, .pipelines = &pipelines, .draws = &.{.{ .pipeline = 0, .vertex_count = 3 }} };
+ var post: abi.gpu.PostProcess = .{ .sample_depth = true, .vertex = .{ .code = code }, .fragment = .{ .code = code } };
+ var out: std.Io.Writer.Allocating = .init(std.testing.allocator);
+ defer out.deinit();
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ try encodePostProcess(&out.writer, pass, post);
+ try std.testing.expectEqual(4, out.written()[4]);
+ try std.testing.expect((try decodeFrame(arena.allocator(), out.written())).post.?.sample_depth);
+ for (0..out.written().len) |i| {
+ _ = decodeFrame(arena.allocator(), out.written()[0..i]) catch continue;
+ return error.AcceptedTruncatedScene;
+ }
+ pass.depth = false;
+ try std.testing.expectError(error.BadScene, encodePostProcess(&out.writer, pass, post));
+ pass.depth = true;
+ pass.samples = 4;
+ try std.testing.expectError(error.BadScene, encodePostProcess(&out.writer, pass, post));
+ pass.samples = 1;
+ post.sample_depth = false;
+ out.clearRetainingCapacity();
+ try encodePostProcess(&out.writer, pass, post);
+ try std.testing.expectEqual(3, out.written()[4]);
+ try std.testing.expect(!(try decodeFrame(arena.allocator(), out.written())).post.?.sample_depth);
+}