summaryrefslogtreecommitdiff
path: root/src/host/gfx.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/host/gfx.zig')
-rw-r--r--src/host/gfx.zig63
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);