summaryrefslogtreecommitdiff
path: root/src/gpu
diff options
context:
space:
mode:
Diffstat (limited to 'src/gpu')
-rw-r--r--src/gpu/Cells.zig181
-rw-r--r--src/gpu/shaders/decor.frag.glsl26
-rw-r--r--src/gpu/shaders/image.frag.glsl17
-rw-r--r--src/gpu/shaders/image.vert.glsl33
-rw-r--r--src/gpu/shaders/overlay.frag.glsl17
-rw-r--r--src/gpu/shaders/overlay.vert.glsl11
-rw-r--r--src/gpu/shaders/prebuilt/decor.frag.spvbin0 -> 2176 bytes
-rw-r--r--src/gpu/shaders/prebuilt/image.frag.spvbin0 -> 1344 bytes
-rw-r--r--src/gpu/shaders/prebuilt/image.vert.spvbin0 -> 3152 bytes
-rw-r--r--src/gpu/shaders/prebuilt/overlay.frag.spvbin0 -> 1008 bytes
-rw-r--r--src/gpu/shaders/prebuilt/overlay.vert.spvbin0 -> 1040 bytes
-rw-r--r--src/gpu/shaders/prebuilt/ui.frag.spvbin0 -> 3184 bytes
-rw-r--r--src/gpu/shaders/prebuilt/ui.vert.spvbin0 -> 3848 bytes
-rw-r--r--src/gpu/shaders/ui.frag.glsl39
-rw-r--r--src/gpu/shaders/ui.vert.glsl53
15 files changed, 377 insertions, 0 deletions
diff --git a/src/gpu/Cells.zig b/src/gpu/Cells.zig
new file mode 100644
index 0000000..78d7f22
--- /dev/null
+++ b/src/gpu/Cells.zig
@@ -0,0 +1,181 @@
+//! pardes's cell renderer on SDL_GPU, part 1: the shaders' instance ABI
+//! (src/gpu/shaders/*.glsl), the pipelines over it and the resource helpers,
+//! moved from pardes's gui.zig as they were. `c` is the embedder's own SDL
+//! translation (pardes's: SDL3 and font.h), so the embedder's SDL is the one
+//! linked.
+const std = @import("std");
+const c = @import("c");
+
+pub const CellInstance = extern struct {
+ x0: f32,
+ y0: f32,
+ x1: f32,
+ y1: f32,
+ u0: f32,
+ v0: f32,
+ u1: f32,
+ v1: f32,
+ fr: f32,
+ fg: f32,
+ fb: f32,
+ br: f32,
+ bg: f32,
+ bb: f32,
+ /// The flags (the high bits, ui.vert.glsl).
+ effect: u32 = 0,
+ /// A clip rectangle in target pixels; x1 < x0 is none (ui.vert.glsl).
+ clip_x0: f32 = 0,
+ clip_y0: f32 = 0,
+ clip_x1: f32 = -1,
+ clip_y1: f32 = -1,
+};
+
+pub const OverlayVertex = extern struct {
+ x: f32,
+ y: f32,
+ r: f32,
+ g: f32,
+ b: f32,
+ a: f32,
+};
+
+pub const ImageInstance = extern struct {
+ x0: f32,
+ y0: f32,
+ x1: f32,
+ y1: f32,
+ u0: f32,
+ v0: f32,
+ u1: f32,
+ v1: f32,
+};
+
+pub const opaque_bg_bit: u32 = 0x2000_0000;
+
+/// A vertex buffer and its upload buffer holding at least `needed`
+/// elements of `stride` bytes: those there when they do, else twice as
+/// many again until they would (the old ones let go).
+pub fn growInstances(device: *c.SDL_GPUDevice, buffer: *?*c.SDL_GPUBuffer, transfer: *?*c.SDL_GPUTransferBuffer, capacity: *u32, needed: u32, stride: u32) !void {
+ if (needed <= capacity.* and buffer.* != null and transfer.* != null) return;
+ var grown = @max(@as(u32, 1), capacity.*);
+ while (grown < needed) grown = std.math.mul(u32, grown, 2) catch return error.GpuCapacity;
+ const size = std.math.mul(u32, grown, stride) catch return error.GpuCapacity;
+ var vb_info = c.SDL_GPUBufferCreateInfo{ .usage = c.SDL_GPU_BUFFERUSAGE_VERTEX, .size = size, .props = 0 };
+ const next_buffer = c.SDL_CreateGPUBuffer(device, &vb_info) orelse return error.GpuCreate;
+ errdefer c.SDL_ReleaseGPUBuffer(device, next_buffer);
+ var xf_info = c.SDL_GPUTransferBufferCreateInfo{ .usage = c.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, .size = size, .props = 0 };
+ const next_transfer = c.SDL_CreateGPUTransferBuffer(device, &xf_info) orelse return error.GpuCreate;
+ if (buffer.*) |old| c.SDL_ReleaseGPUBuffer(device, old);
+ if (transfer.*) |old| c.SDL_ReleaseGPUTransferBuffer(device, old);
+ buffer.* = next_buffer;
+ transfer.* = next_transfer;
+ capacity.* = grown;
+}
+
+/// One vertex buffer of a pipeline: `pitch` bytes an element, read per
+/// vertex or per instance through `attrs`.
+pub const VertexInput = struct { pitch: u32, rate: c.SDL_GPUVertexInputRate, attrs: []const c.SDL_GPUVertexAttribute };
+
+/// The cells' and the decor's instances (ui.vert.glsl).
+pub const cell_input: VertexInput = .{ .pitch = @sizeOf(CellInstance), .rate = c.SDL_GPU_VERTEXINPUTRATE_INSTANCE, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "x0") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "u0") },
+ .{ .location = 2, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, .offset = @offsetOf(CellInstance, "fr") },
+ .{ .location = 3, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, .offset = @offsetOf(CellInstance, "br") },
+ .{ .location = 4, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_UINT, .offset = @offsetOf(CellInstance, "effect") },
+ .{ .location = 5, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "clip_x0") },
+} };
+
+pub const overlay_input: VertexInput = .{ .pitch = @sizeOf(OverlayVertex), .rate = c.SDL_GPU_VERTEXINPUTRATE_VERTEX, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2, .offset = @offsetOf(OverlayVertex, "x") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(OverlayVertex, "r") },
+} };
+
+pub const image_input: VertexInput = .{ .pitch = @sizeOf(ImageInstance), .rate = c.SDL_GPU_VERTEXINPUTRATE_INSTANCE, .attrs = &.{
+ .{ .location = 0, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(ImageInstance, "x0") },
+ .{ .location = 1, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(ImageInstance, "u0") },
+} };
+
+/// A pipeline drawing triangles into `color_format`: `vert`, and `frag`
+/// with its samplers and uniform buffers, over one vertex buffer of
+/// `input` (none: the post chain's triangle over the whole frame).
+pub fn makePipeline(
+ device: *c.SDL_GPUDevice,
+ color_format: c.SDL_GPUTextureFormat,
+ vert: []const u8,
+ frag: []const u8,
+ samplers: u32,
+ uniforms: u32,
+ input: ?VertexInput,
+ blend: c.SDL_GPUColorTargetBlendState,
+) !*c.SDL_GPUGraphicsPipeline {
+ const vs = try makeShader(device, vert, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
+ defer c.SDL_ReleaseGPUShader(device, vs);
+ const fs = try makeShader(device, frag, c.SDL_GPU_SHADERSTAGE_FRAGMENT, samplers, uniforms);
+ defer c.SDL_ReleaseGPUShader(device, fs);
+ var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = blend };
+ var vbuf_desc: c.SDL_GPUVertexBufferDescription = undefined;
+ var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
+ info.vertex_shader = vs;
+ info.fragment_shader = fs;
+ info.primitive_type = c.SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+ if (input) |in| {
+ vbuf_desc = .{ .slot = 0, .pitch = in.pitch, .input_rate = in.rate, .instance_step_rate = 0 };
+ info.vertex_input_state = .{
+ .vertex_buffer_descriptions = &vbuf_desc,
+ .num_vertex_buffers = 1,
+ .vertex_attributes = in.attrs.ptr,
+ .num_vertex_attributes = @intCast(in.attrs.len),
+ };
+ }
+ info.rasterizer_state.fill_mode = c.SDL_GPU_FILLMODE_FILL;
+ info.rasterizer_state.cull_mode = c.SDL_GPU_CULLMODE_NONE;
+ info.multisample_state.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ info.target_info = .{ .color_target_descriptions = &col_desc, .num_color_targets = 1 };
+ return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
+}
+
+pub fn backgroundLayerBlend() c.SDL_GPUColorTargetBlendState {
+ var blend = std.mem.zeroes(c.SDL_GPUColorTargetBlendState);
+ blend.src_color_blendfactor = c.SDL_GPU_BLENDFACTOR_SRC_ALPHA;
+ blend.dst_color_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.color_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.src_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_CONSTANT_COLOR;
+ blend.dst_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.alpha_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.enable_blend = true;
+ return blend;
+}
+
+fn makeShader(device: *c.SDL_GPUDevice, code: []const u8, stage: c.SDL_GPUShaderStage, n_samplers: u32, n_uniform_buffers: u32) !*c.SDL_GPUShader {
+ var info = std.mem.zeroes(c.SDL_GPUShaderCreateInfo);
+ info.code = code.ptr;
+ info.code_size = code.len;
+ info.entrypoint = "main";
+ info.format = c.SDL_GPU_SHADERFORMAT_SPIRV;
+ info.stage = stage;
+ info.num_samplers = n_samplers;
+ info.num_uniform_buffers = n_uniform_buffers;
+ return c.SDL_CreateGPUShader(device, &info) orelse error.GpuCreate;
+}
+
+/// A 2D texture of one level, one layer and one sample.
+pub fn texture2d(device: *c.SDL_GPUDevice, format: c.SDL_GPUTextureFormat, usage: c.SDL_GPUTextureUsageFlags, width: u32, height: u32) ?*c.SDL_GPUTexture {
+ var info = std.mem.zeroes(c.SDL_GPUTextureCreateInfo);
+ info.type = c.SDL_GPU_TEXTURETYPE_2D;
+ info.format = format;
+ info.usage = usage;
+ info.width = width;
+ info.height = height;
+ info.layer_count_or_depth = 1;
+ info.num_levels = 1;
+ info.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
+ return c.SDL_CreateGPUTexture(device, &info);
+}
+
+test "the shader instance ABI: the flags after the colours, the clip after them" {
+ try std.testing.expectEqual(@as(usize, 76), @sizeOf(CellInstance));
+ try std.testing.expectEqual(@as(usize, 56), @offsetOf(CellInstance, "effect"));
+ try std.testing.expectEqual(@as(usize, 60), @offsetOf(CellInstance, "clip_x0"));
+ try std.testing.expectEqual(@as(usize, 32), @sizeOf(ImageInstance));
+}
diff --git a/src/gpu/shaders/decor.frag.glsl b/src/gpu/shaders/decor.frag.glsl
new file mode 100644
index 0000000..71bb12e
--- /dev/null
+++ b/src/gpu/shaders/decor.frag.glsl
@@ -0,0 +1,26 @@
+#version 450
+
+// Decor, drawn by ui.vert.glsl like a cell, and blended as the overlay
+// pipeline blends (backgroundLayerBlend). Ink (a cursor) is drawn with the
+// opacity uniform at 1.
+//
+// A hard-edged fill (a rule, a rail, a grip mark, a bar cursor): its colour
+// rides in the cell's ground (a_bg), its coverage in a_fg.r, so the result
+// is the overlay pipeline's exactly.
+
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 1) in vec3 v_fg;
+layout(location = 2) in vec3 v_bg;
+layout(location = 5) flat in vec4 v_clip;
+
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z ||
+ gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard;
+ float opacity = clamp(u_ui.background_opacity, 0.0, 1.0);
+ o_col = vec4(v_bg * opacity, v_fg.r);
+}
diff --git a/src/gpu/shaders/image.frag.glsl b/src/gpu/shaders/image.frag.glsl
new file mode 100644
index 0000000..38a95da
--- /dev/null
+++ b/src/gpu/shaders/image.frag.glsl
@@ -0,0 +1,17 @@
+#version 450
+
+layout(set = 2, binding = 0) uniform sampler2D u_image;
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ vec4 source = texture(u_image, v_uv);
+ // Keep source coverage for destination subtraction; the pipeline scales
+ // source alpha by the same opacity through its alpha blend constant.
+ source.rgb *= clamp(u_ui.background_opacity, 0.0, 1.0);
+ o_col = source;
+}
diff --git a/src/gpu/shaders/image.vert.glsl b/src/gpu/shaders/image.vert.glsl
new file mode 100644
index 0000000..ace55a5
--- /dev/null
+++ b/src/gpu/shaders/image.vert.glsl
@@ -0,0 +1,33 @@
+#version 450
+
+// One instance per Surface image attachment. The CPU has already converted
+// the pane's cell rectangle and the aspect-preserving contain fit to NDC.
+layout(location = 0) in vec4 a_rect; // x0, y0, x1, y1
+layout(location = 1) in vec4 a_uv_rect; // u0, v0, u1, v1
+
+layout(location = 0) out vec2 v_uv;
+
+void main() {
+ vec2 pos;
+ int corner = gl_VertexIndex % 6;
+ if (corner == 0) {
+ pos = vec2(a_rect.x, a_rect.y);
+ v_uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 1) {
+ pos = vec2(a_rect.z, a_rect.y);
+ v_uv = vec2(a_uv_rect.z, a_uv_rect.y);
+ } else if (corner == 2) {
+ pos = vec2(a_rect.z, a_rect.w);
+ v_uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else if (corner == 3) {
+ pos = vec2(a_rect.x, a_rect.y);
+ v_uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 4) {
+ pos = vec2(a_rect.z, a_rect.w);
+ v_uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else {
+ pos = vec2(a_rect.x, a_rect.w);
+ v_uv = vec2(a_uv_rect.x, a_uv_rect.w);
+ }
+ gl_Position = vec4(pos, 0.0, 1.0);
+}
diff --git a/src/gpu/shaders/overlay.frag.glsl b/src/gpu/shaders/overlay.frag.glsl
new file mode 100644
index 0000000..b5ac8d5
--- /dev/null
+++ b/src/gpu/shaders/overlay.frag.glsl
@@ -0,0 +1,17 @@
+#version 450
+
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 0) in vec4 v_color;
+
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ // Preserve shape coverage for destination subtraction. The pipeline uses
+ // the matching opacity blend constant for source alpha, so graphics laid
+ // over a background with the same opacity do not accumulate opaque seams.
+ // Text/cursor draw groups bind opacity 1 instead.
+ o_col = vec4(v_color.rgb * clamp(u_ui.background_opacity, 0.0, 1.0), v_color.a);
+}
diff --git a/src/gpu/shaders/overlay.vert.glsl b/src/gpu/shaders/overlay.vert.glsl
new file mode 100644
index 0000000..5f6be59
--- /dev/null
+++ b/src/gpu/shaders/overlay.vert.glsl
@@ -0,0 +1,11 @@
+#version 450
+
+layout(location = 0) in vec2 a_pos;
+layout(location = 1) in vec4 a_color;
+
+layout(location = 0) out vec4 v_color;
+
+void main() {
+ v_color = a_color;
+ gl_Position = vec4(a_pos, 0.0, 1.0);
+}
diff --git a/src/gpu/shaders/prebuilt/decor.frag.spv b/src/gpu/shaders/prebuilt/decor.frag.spv
new file mode 100644
index 0000000..0d5af9d
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/decor.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/image.frag.spv b/src/gpu/shaders/prebuilt/image.frag.spv
new file mode 100644
index 0000000..d663ed8
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/image.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/image.vert.spv b/src/gpu/shaders/prebuilt/image.vert.spv
new file mode 100644
index 0000000..1105bae
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/image.vert.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/overlay.frag.spv b/src/gpu/shaders/prebuilt/overlay.frag.spv
new file mode 100644
index 0000000..e296e99
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/overlay.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/overlay.vert.spv b/src/gpu/shaders/prebuilt/overlay.vert.spv
new file mode 100644
index 0000000..a518c57
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/overlay.vert.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/ui.frag.spv b/src/gpu/shaders/prebuilt/ui.frag.spv
new file mode 100644
index 0000000..91022fe
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/ui.frag.spv
Binary files differ
diff --git a/src/gpu/shaders/prebuilt/ui.vert.spv b/src/gpu/shaders/prebuilt/ui.vert.spv
new file mode 100644
index 0000000..ad132bf
--- /dev/null
+++ b/src/gpu/shaders/prebuilt/ui.vert.spv
Binary files differ
diff --git a/src/gpu/shaders/ui.frag.glsl b/src/gpu/shaders/ui.frag.glsl
new file mode 100644
index 0000000..7f70629
--- /dev/null
+++ b/src/gpu/shaders/ui.frag.glsl
@@ -0,0 +1,39 @@
+#version 450
+
+// Sample the glyph atlas (R = coverage 0..1) and mix the cell's bg up to its fg
+// by that coverage. Output is PREMULTIPLIED: an opaque cell is unchanged.
+// WindowOpacity changes only the ground's coverage, never the glyph's ink.
+
+layout(set = 2, binding = 0) uniform sampler2D u_atlas;
+layout(std140, set = 3, binding = 0) uniform UiUniforms {
+ float background_opacity;
+} u_ui;
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 1) in vec3 v_fg;
+layout(location = 2) in vec3 v_bg;
+layout(location = 4) flat in uint v_effect;
+layout(location = 5) flat in vec4 v_clip;
+
+layout(location = 0) out vec4 o_col;
+
+void main() {
+ if (v_clip.z >= v_clip.x && (gl_FragCoord.x < v_clip.x || gl_FragCoord.x >= v_clip.z ||
+ gl_FragCoord.y < v_clip.y || gl_FragCoord.y >= v_clip.w)) discard;
+ float a = texture(u_atlas, v_uv).r;
+ // A block cursor is foreground chrome even though its fill occupies the
+ // cell background: keep it visible at WindowOpacity 0. Otherwise the
+ // ground's coverage is the setting's. The flag is shared with
+ // ui.vert.glsl and src/gui/gui.zig.
+ float bgA = (v_effect & 0x20000000u) != 0u ? 1.0 : clamp(u_ui.background_opacity, 0.0, 1.0);
+
+ // Ink over ground, both premultiplied: v_fg*a + (v_bg*bgA)*(1-a), which is
+ // mix() with the ground already premultiplied. At bgA = 1 that is exactly
+ // the mix(v_bg, v_fg, a) at alpha 1 this shader always wrote.
+ vec4 under = vec4(v_bg * bgA, bgA);
+ vec4 cell = vec4(mix(under.rgb, v_fg, a), mix(under.a, 1.0, a));
+
+ // FreeType's hinted grayscale bitmap is already the intended coverage.
+ // Preserve it exactly; weight-changing gamma hacks blur small stems.
+ o_col = cell;
+}
diff --git a/src/gpu/shaders/ui.vert.glsl b/src/gpu/shaders/ui.vert.glsl
new file mode 100644
index 0000000..e3532e6
--- /dev/null
+++ b/src/gpu/shaders/ui.vert.glsl
@@ -0,0 +1,53 @@
+#version 450
+
+// Terminal cell renderer. The CPU uploads one instance per visible cell; this
+// shader expands each instance into a two-triangle quad with gl_VertexIndex.
+// The fragment shader mixes fg/bg by the atlas's alpha (a glyph mask in the R
+// channel), so background fills and glyph foregrounds draw in a single pass.
+
+layout(location = 0) in vec4 a_rect; // x0, y0, x1, y1
+layout(location = 1) in vec4 a_uv_rect; // u0, v0, u1, v1
+layout(location = 2) in vec3 a_fg;
+layout(location = 3) in vec3 a_bg;
+// Flags, the high bits: an opaque block-cursor fill (ui.frag.glsl).
+layout(location = 4) in uint a_effect;
+// A clip rectangle in target pixels (x0, y0, x1, y1): the fragment shader
+// drops what lies outside it. x1 < x0 is none.
+layout(location = 5) in vec4 a_clip;
+
+layout(location = 0) out vec2 v_uv;
+layout(location = 1) out vec3 v_fg;
+layout(location = 2) out vec3 v_bg;
+layout(location = 4) flat out uint v_effect;
+layout(location = 5) flat out vec4 v_clip;
+
+void main() {
+ vec2 pos;
+ vec2 uv;
+ int corner = gl_VertexIndex % 6;
+ if (corner == 0) {
+ pos = vec2(a_rect.x, a_rect.y);
+ uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 1) {
+ pos = vec2(a_rect.z, a_rect.y);
+ uv = vec2(a_uv_rect.z, a_uv_rect.y);
+ } else if (corner == 2) {
+ pos = vec2(a_rect.z, a_rect.w);
+ uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else if (corner == 3) {
+ pos = vec2(a_rect.x, a_rect.y);
+ uv = vec2(a_uv_rect.x, a_uv_rect.y);
+ } else if (corner == 4) {
+ pos = vec2(a_rect.z, a_rect.w);
+ uv = vec2(a_uv_rect.z, a_uv_rect.w);
+ } else {
+ pos = vec2(a_rect.x, a_rect.w);
+ uv = vec2(a_uv_rect.x, a_uv_rect.w);
+ }
+ v_uv = uv;
+ v_fg = a_fg;
+ v_bg = a_bg;
+ v_effect = a_effect;
+ v_clip = a_clip;
+ gl_Position = vec4(pos, 0.0, 1.0);
+}