diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-13 12:12:22 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-13 12:12:22 -0300 |
| commit | 409c1accefeb7a775c0914c888b469a1e78fc69a (patch) | |
| tree | 21af5f4b0e82e5c36d129421a7257be6d8bebd8d /src/host/gfx.zig | |
| parent | 91a34124880d932f97718b959b11bc5375c0dd79 (diff) | |
| download | sketchbook-409c1accefeb7a775c0914c888b469a1e78fc69a.tar.gz sketchbook-409c1accefeb7a775c0914c888b469a1e78fc69a.zip | |
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.
Diffstat (limited to 'src/host/gfx.zig')
| -rw-r--r-- | src/host/gfx.zig | 63 |
1 files changed, 63 insertions, 0 deletions
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); |
