From 409c1accefeb7a775c0914c888b469a1e78fc69a Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Fri, 13 Nov 2026 12:12:22 -0300 Subject: Add reusable GPU backdrop filtering to the shared canvas Draw native GPU frames through the same bounded canvas used by headless capture. Backdrop commands reuse one snapshot and shader state, with an unchanged fallback on unsupported renderers. Verified through native debugger lenses, restart, and repeated font zoom checks. --- src/abi.zig | 4 ++++ src/host/Host.zig | 15 ++++++++----- src/host/gfx.zig | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/sketch/root.zig | 3 +++ src/sketch/web.zig | 2 +- 5 files changed, 81 insertions(+), 6 deletions(-) (limited to 'src') diff --git a/src/abi.zig b/src/abi.zig index a7a5cce..77a737d 100644 --- a/src/abi.zig +++ b/src/abi.zig @@ -335,6 +335,10 @@ pub const Command = union(enum) { /// is unused. Native samples nearest; the web antialiases the edges of /// a turned image. image: struct { image: Image, dst: Rect, src: Rect = .{}, tint: Color = .white, corners: ?Corners = null }, + /// Filter the canvas underneath `dst`. Native GPU renderer only; other + /// renderers leave the backdrop unchanged. The fragment shader receives + /// color at location 0, UV at 1, sampler at set 2/binding 0 and uniforms at set 3. + backdrop: struct { dst: Rect, fragment: []const u8, uniforms: []const u8 }, /// Where the 2D commands after it draw: an image made by /// `Host.newImage` (an offscreen target, kept between frames), or /// `.none` for the canvas. Each frame starts on the canvas. Switching diff --git a/src/host/Host.zig b/src/host/Host.zig index 86e1873..43f030a 100644 --- a/src/host/Host.zig +++ b/src/host/Host.zig @@ -49,8 +49,7 @@ renderer: *c.SDL_Renderer, /// Null when the machine has no usable GPU driver. gpu: ?*c.SDL_GPUDevice, passes: ?Gpu = null, -/// Headless with a GPU: the renderer has no window and draws into this -/// canvas-sized texture, which screenshots read. +/// GPU canvas, shared by native/headless drawing, backdrop filters and screenshots. offscreen: ?*c.SDL_Texture = null, pointer_cursor: ?*c.SDL_Cursor = null, images: gfx.Images, @@ -350,6 +349,7 @@ fn draw(self: *Host, now: u64) !void { const ctx = self.context(); self.sketch.draw(&ctx, self.live().ptr); + _ = c.SDL_SetRenderTarget(self.renderer, self.offscreen); _ = c.SDL_SetRenderClipRect(self.renderer, null); _ = c.SDL_SetRenderDrawColor(self.renderer, 0, 0, 0, 255); _ = c.SDL_RenderClear(self.renderer); @@ -399,6 +399,11 @@ fn draw(self: *Host, now: u64) !void { } if (self.options.export_to) |to| try self.exportFrame(surface, to); } + if (!self.options.headless) if (self.offscreen) |canvas| { + _ = c.SDL_SetRenderTarget(self.renderer, null); + _ = c.SDL_SetTextureBlendMode(canvas, c.SDL_BLENDMODE_NONE); + _ = c.SDL_RenderTexture(self.renderer, canvas, null, null); + }; _ = c.SDL_RenderPresent(self.renderer); if (self.passes) |*g| g.endFrame(); } @@ -640,12 +645,12 @@ fn forget(list: anytype, handle: anytype) void { fn setCanvas(self: *Host, w: u32, h: u32) void { if (w == 0 or h == 0 or (self.canvas[0] == w and self.canvas[1] == h)) return; self.canvas = .{ w, h }; - if (self.options.headless and self.gpu != null) { + _ = c.SDL_SetRenderTarget(self.renderer, null); + _ = c.SDL_SetRenderLogicalPresentation(self.renderer, @intCast(w), @intCast(h), c.SDL_LOGICAL_PRESENTATION_LETTERBOX); + if (self.gpu != null) { if (self.offscreen) |texture| c.SDL_DestroyTexture(texture); self.offscreen = c.SDL_CreateTexture(self.renderer, c.SDL_PIXELFORMAT_RGBA32, c.SDL_TEXTUREACCESS_TARGET, @intCast(w), @intCast(h)); _ = c.SDL_SetRenderTarget(self.renderer, self.offscreen); - } else { - _ = c.SDL_SetRenderLogicalPresentation(self.renderer, @intCast(w), @intCast(h), c.SDL_LOGICAL_PRESENTATION_LETTERBOX); } _ = c.SDL_SetWindowSize(self.window, @intCast(w), @intCast(h)); } diff --git a/src/host/gfx.zig b/src/host/gfx.zig index 95c3ecc..a7ebd05 100644 --- a/src/host/gfx.zig +++ b/src/host/gfx.zig @@ -164,6 +164,11 @@ pub const Painter = struct { /// Half-way through averaging (2x), shared; `half_size` in its pixels. half: ?*c.SDL_Texture = null, half_size: [2]u32 = .{ 0, 0 }, + backdrop_texture: ?*c.SDL_Texture = null, + backdrop_size: [2]u32 = .{ 0, 0 }, + backdrop_state: ?*c.SDL_GPURenderState = null, + backdrop_shader: ?*c.SDL_GPUShader = null, + backdrop_hash: u64 = 0, const Layer = struct { big: ?*c.SDL_Texture = null, @@ -191,6 +196,9 @@ pub const Painter = struct { } pub fn deinit(p: *Painter) void { + if (p.backdrop_texture) |t| c.SDL_DestroyTexture(t); + if (p.backdrop_state) |state| c.SDL_DestroyGPURenderState(state); + if (p.backdrop_shader) |shader| if (c.SDL_GetGPURendererDevice(p.renderer)) |device| c.SDL_ReleaseGPUShader(device, shader); if (p.layer.big) |t| c.SDL_DestroyTexture(t); if (p.half) |t| c.SDL_DestroyTexture(t); p.layer = .{}; @@ -237,6 +245,7 @@ pub const Painter = struct { }, .shape => |s| p.shape(s.color, s.points, s.ends, s.indices, s.colors), .image => |img| p.drawImage(img.image, img.dst, img.src, img.tint, img.corners), + .backdrop => |b| p.backdrop(b.dst, b.fragment, b.uniforms), .text => |text| { _ = c.SDL_SetRenderDrawBlendMode(renderer, c.SDL_BLENDMODE_BLEND); drawText(renderer, text.x, text.y, text.scale, text.bytes, text.color, text.face, if (text.raster > 0) text.raster else text.scale); @@ -344,6 +353,60 @@ pub const Painter = struct { return .{ entry.w, entry.h }; } + fn backdrop(p: *Painter, dst: abi.Rect, fragment: []const u8, uniforms: []const u8) void { + if (p.target != .none or p.canvas == null or dst.w <= 0 or dst.h <= 0) return; + const device = c.SDL_GetGPURendererDevice(p.renderer) orelse return; + const hash = std.hash.Wyhash.hash(0, fragment); + if (p.backdrop_hash != hash) { + if (p.backdrop_state) |state| c.SDL_DestroyGPURenderState(state); + if (p.backdrop_shader) |shader| c.SDL_ReleaseGPUShader(device, shader); + p.backdrop_state = null; + p.backdrop_hash = hash; + var info: c.SDL_GPUShaderCreateInfo = std.mem.zeroes(c.SDL_GPUShaderCreateInfo); + info.code = fragment.ptr; + info.code_size = fragment.len; + info.entrypoint = "main"; + info.format = c.SDL_GPU_SHADERFORMAT_SPIRV; + info.stage = c.SDL_GPU_SHADERSTAGE_FRAGMENT; + info.num_samplers = 1; + info.num_uniform_buffers = 1; + p.backdrop_shader = c.SDL_CreateGPUShader(device, &info); + if (p.backdrop_shader) |shader| { + var state_info: c.SDL_GPURenderStateCreateInfo = std.mem.zeroes(c.SDL_GPURenderStateCreateInfo); + state_info.fragment_shader = shader; + p.backdrop_state = c.SDL_CreateGPURenderState(p.renderer, &state_info); + } + if (p.backdrop_state == null) std.log.warn("backdrop shader: {s}", .{c.SDL_GetError()}); + } + const state = p.backdrop_state orelse return; + // One snapshot, bounded by the canvas and reused by every backdrop. + const size: [2]u32 = .{ @intFromFloat(@ceil(@min(dst.w, @as(f32, @floatFromInt(p.canvas_size[0]))))), @intFromFloat(@ceil(@min(dst.h, @as(f32, @floatFromInt(p.canvas_size[1]))))) }; + if (size[0] == 0 or size[1] == 0) return; + if (!std.meta.eql(size, p.backdrop_size)) { + if (p.backdrop_texture) |t| c.SDL_DestroyTexture(t); + p.backdrop_texture = c.SDL_CreateTexture(p.renderer, c.SDL_PIXELFORMAT_RGBA32, c.SDL_TEXTUREACCESS_TARGET, @intCast(size[0]), @intCast(size[1])); + p.backdrop_size = size; + } + const snapshot = p.backdrop_texture orelse return; + var clip: c.SDL_Rect = undefined; + const clipped = c.SDL_RenderClipEnabled(p.renderer); + _ = c.SDL_GetRenderClipRect(p.renderer, &clip); + _ = c.SDL_SetRenderTarget(p.renderer, snapshot); + _ = c.SDL_SetRenderClipRect(p.renderer, null); + _ = c.SDL_SetRenderDrawColor(p.renderer, 0, 0, 0, 255); + _ = c.SDL_RenderClear(p.renderer); + _ = c.SDL_SetTextureBlendMode(p.canvas, c.SDL_BLENDMODE_NONE); + _ = c.SDL_RenderTexture(p.renderer, p.canvas, &frect(dst), null); + _ = c.SDL_SetRenderTarget(p.renderer, p.canvas); + _ = c.SDL_SetRenderClipRect(p.renderer, if (clipped) &clip else null); + _ = c.SDL_SetTextureScaleMode(snapshot, c.SDL_SCALEMODE_LINEAR); + _ = c.SDL_SetTextureBlendMode(snapshot, c.SDL_BLENDMODE_BLEND); + if (!c.SDL_SetGPURenderStateFragmentUniforms(state, 0, uniforms.ptr, @intCast(uniforms.len))) return; + _ = c.SDL_SetGPURenderState(p.renderer, state); + _ = c.SDL_RenderTexture(p.renderer, snapshot, null, &frect(dst)); + _ = c.SDL_SetGPURenderState(p.renderer, null); + } + fn drawImage(p: *Painter, handle: abi.Image, dst: abi.Rect, src_rect: abi.Rect, tint: abi.Color, corners: ?abi.Corners) void { const renderer = p.renderer; const entry = p.images.get(handle); diff --git a/src/sketch/root.zig b/src/sketch/root.zig index b2f9136..52f05b2 100644 --- a/src/sketch/root.zig +++ b/src/sketch/root.zig @@ -142,6 +142,9 @@ pub const Frame = struct { pub fn target(f: *Frame, img: Image) void { f.emit(.{ .target = img }); } + pub fn backdrop(f: *Frame, dst: Rect, fragment: []const u8, uniforms: []const u8) void { + f.emit(.{ .backdrop = .{ .dst = dst, .fragment = fragment, .uniforms = f.keep(u8, uniforms) } }); + } /// How the 2D commands after it blend, until the next `blend` or the /// frame ends (which goes back to `.alpha`). pub fn blend(f: *Frame, mode: BlendMode) void { diff --git a/src/sketch/web.zig b/src/sketch/web.zig index db9d9a8..3e102ad 100644 --- a/src/sketch/web.zig +++ b/src/sketch/web.zig @@ -232,7 +232,7 @@ fn Driver(comptime App: type) type { .open_file => |v| js.openFile(v.command.ptr, v.command.len, v.pattern.ptr, v.pattern.len), // Synthesised voices are not on the web yet; quitting a page // means nothing; `run` lines go after the frame. - .voice, .quit, .run => {}, + .voice, .quit, .run, .backdrop => {}, } } -- cgit v1.3