diff options
| -rw-r--r-- | src/abi.zig | 4 | ||||
| -rw-r--r-- | src/host/Host.zig | 15 | ||||
| -rw-r--r-- | src/host/gfx.zig | 63 | ||||
| -rw-r--r-- | src/sketch/root.zig | 3 | ||||
| -rw-r--r-- | src/sketch/web.zig | 2 |
5 files changed, 81 insertions, 6 deletions
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 => {}, } } |
