summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/abi.zig4
-rw-r--r--src/host/Host.zig15
-rw-r--r--src/host/gfx.zig63
-rw-r--r--src/sketch/root.zig3
-rw-r--r--src/sketch/web.zig2
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 => {},
}
}