diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-17 03:44:32 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-17 12:15:01 -0300 |
| commit | 7100c95a2a42e69fac9e834ddcca4524ee026b1f (patch) | |
| tree | fd0718dce6a930dd119df1d15395623ea27fdb61 /src | |
| parent | 85452cbb28ec78913d72017fdcb666c40e2fc153 (diff) | |
| parent | 6af3c07190e7aec46596e00afb3c6b613c9e02eb (diff) | |
| download | sketchbook-7100c95a2a42e69fac9e834ddcca4524ee026b1f.tar.gz sketchbook-7100c95a2a42e69fac9e834ddcca4524ee026b1f.zip | |
Merge the GPU move's font shim, glyph atlas and cell shaders
sketchbook-next with gpu-s2 (vendor/font.{c,h}, src/font/Atlas.zig, src/gpu/Cells.zig, src/gpu/shaders/): no conflicts. Nothing of sketchbook's own uses them yet.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
Diffstat (limited to 'src')
| -rw-r--r-- | src/font/Atlas.zig | 510 | ||||
| -rw-r--r-- | src/gpu/Cells.zig | 181 | ||||
| -rw-r--r-- | src/gpu/shaders/decor.frag.glsl | 26 | ||||
| -rw-r--r-- | src/gpu/shaders/image.frag.glsl | 17 | ||||
| -rw-r--r-- | src/gpu/shaders/image.vert.glsl | 33 | ||||
| -rw-r--r-- | src/gpu/shaders/overlay.frag.glsl | 17 | ||||
| -rw-r--r-- | src/gpu/shaders/overlay.vert.glsl | 11 | ||||
| -rw-r--r-- | src/gpu/shaders/prebuilt/decor.frag.spv | bin | 0 -> 2176 bytes | |||
| -rw-r--r-- | src/gpu/shaders/prebuilt/image.frag.spv | bin | 0 -> 1344 bytes | |||
| -rw-r--r-- | src/gpu/shaders/prebuilt/image.vert.spv | bin | 0 -> 3152 bytes | |||
| -rw-r--r-- | src/gpu/shaders/prebuilt/overlay.frag.spv | bin | 0 -> 1008 bytes | |||
| -rw-r--r-- | src/gpu/shaders/prebuilt/overlay.vert.spv | bin | 0 -> 1040 bytes | |||
| -rw-r--r-- | src/gpu/shaders/prebuilt/ui.frag.spv | bin | 0 -> 3184 bytes | |||
| -rw-r--r-- | src/gpu/shaders/prebuilt/ui.vert.spv | bin | 0 -> 3848 bytes | |||
| -rw-r--r-- | src/gpu/shaders/ui.frag.glsl | 39 | ||||
| -rw-r--r-- | src/gpu/shaders/ui.vert.glsl | 53 |
16 files changed, 887 insertions, 0 deletions
diff --git a/src/font/Atlas.zig b/src/font/Atlas.zig new file mode 100644 index 0000000..d05bff4 --- /dev/null +++ b/src/font/Atlas.zig @@ -0,0 +1,510 @@ +//! pardes's glyph atlas: its faces (a primary and fallbacks over vendor/font.c, +//! FreeType and HarfBuzz), one 2048x2048 R8 stage filled pen-style a cell row +//! at a time, the slot of every glyph drawn, and the rows drawn since the +//! last upload; moved from pardes's gui.zig as it was. CPU only: uploading the +//! rows is the owner's. `c` is the embedder's translation of vendor/font.h, +//! so the embedder's FreeType and HarfBuzz are the ones linked, and the +//! embedder exports ui_malloc and friends (font.h) over its allocator. +//! What a glyph is drawn at (the sizes, a centred glyph's cells, the line +//! thickness) is the caller's, passed to each `cachedGlyph`. +const Atlas = @This(); +const std = @import("std"); +const c = @import("c"); + +pub const atlas_w: u32 = 2048; +pub const atlas_h: u32 = 2048; +pub const Slot = struct { u: u32, v: u32 }; +/// An atlas entry is a glyph of a face (0 the primary font, i the fallback +/// i - 1) at a role's size, drawn `span` cells wide with its own cell `lead` +/// cells in: a ligature is one strip whose cells sample their own slices. +/// Packed, so the atlas map hashes one word instead of walking fields. +pub const Key = packed struct(u64) { + face: u8, + glyph: u32, + role: Role, + decoration: Decoration = .{}, + centered: bool = false, + lead: u4 = 0, + span: u4 = 1, + /// A light box-drawing rule (`ruleArms`), drawn edge to edge rather + /// than from the font; `glyph` is its codepoint. + rule: bool = false, + _: u1 = 0, +}; + +/// The size a glyph is drawn at: the body's, or the tagline's (pardes's +/// FontRole, in its order). +pub const Role = enum(u8) { body, tagline }; +/// pardes's CellStyle.ul, in its order. +pub const Underline = enum(u3) { off, single, double, curly, dotted, dashed }; +pub const Decoration = packed struct(u5) { + bold: bool = false, + underline: Underline = .off, + strikethrough: bool = false, +}; + +/// A role's raster size: the face's pixel size, the width of its cell, the +/// height of its band and its baseline from the band's top. +pub const Size = struct { px: f32, cell_w: u32, height: u32, baseline: i32 }; + +/// The light box-drawing rules drawn by hand, as Ghostty and kitty draw +/// them: a logical pixel thick through the cell's middle, out to its edges, +/// so a markdown table's `|` (Tables.zig) joins the rows above and below it +/// and its delimiter row is one line across, at any line height a font's +/// own glyph would leave gaps in. The arms each one has: left, right, up, down. +pub fn ruleArms(cp: u32) ?[4]bool { + return switch (cp) { + 0x2500 => .{ true, true, false, false }, // ─ + 0x2502 => .{ false, false, true, true }, // │ + 0x250c => .{ false, true, false, true }, // ┌ + 0x2510 => .{ true, false, false, true }, // ┐ + 0x2514 => .{ false, true, true, false }, // └ + 0x2518 => .{ true, false, true, false }, // ┘ + 0x251c => .{ false, true, true, true }, // ├ + 0x2524 => .{ true, false, true, true }, // ┤ + 0x252c => .{ true, true, false, true }, // ┬ + 0x2534 => .{ true, true, true, false }, // ┴ + 0x253c => .{ true, true, true, true }, // ┼ + else => null, + }; +} + +/// `line_px`: the rule's thickness, the caller's logical pixel (pardes: dp(1)). +fn drawRule(out: [*]u8, stride: usize, width: usize, height: usize, arms: [4]bool, line_px: usize) void { + if (width == 0 or height == 0) return; + const t: usize = @min(@max(1, line_px), @min(width, height)); + const mx = (width - t) / 2; + const my = (height - t) / 2; + for (0..height) |y| @memset(out[y * stride ..][0..width], 0); + if (arms[0] or arms[1]) for (0..t) |k| { + const from: usize = if (arms[0]) 0 else mx; + const to: usize = if (arms[1]) width else mx + t; + @memset(out[(my + k) * stride + from ..][0 .. to - from], 255); + }; + if (arms[2] or arms[3]) { + const from: usize = if (arms[2]) 0 else my; + const to: usize = if (arms[3]) height else my + t; + for (from..to) |y| @memset(out[y * stride + mx ..][0..t], 255); + } +} + +pub const InkBounds = struct { min_x: usize, min_y: usize, max_x: usize, max_y: usize }; + +pub fn inkBounds(bitmap: []const u8, stride: usize, w: usize, h: usize) ?InkBounds { + var bounds: ?InkBounds = null; + for (0..h) |y| for (0..w) |x| { + if (bitmap[y * stride + x] == 0) continue; + if (bounds) |*b| { + b.min_x = @min(b.min_x, x); + b.min_y = @min(b.min_y, y); + b.max_x = @max(b.max_x, x); + b.max_y = @max(b.max_y, y); + } else bounds = .{ .min_x = x, .min_y = y, .max_x = x, .max_y = y }; + }; + return bounds; +} + +pub const max_fallbacks = 15; +pub const LoadedFallback = struct { + face: *c.UIFont, + bytes: []u8 = &.{}, +}; + +/// The primary face (Key.face 0) and its bytes, the atlas's when not empty. +font: *c.UIFont, +font_bytes: []u8 = &.{}, +fallbacks: [max_fallbacks]?LoadedFallback = @splat(null), +fallback_count: usize = 0, + +atlas_stage: []u8, +glyphs: std.AutoHashMap(Key, Slot), +pen_x: u32 = 0, +pen_y: u32 = 0, +/// The atlas rows drawn into since the last upload, [top, bottom): the +/// whole atlas at first, since the texture starts undefined. +atlas_dirty_top: u32 = 0, +atlas_dirty_bottom: u32 = atlas_h, +space_slot: Slot = .{ .u = 0, .v = 0 }, + +/// An atlas over the primary face in `bytes`, borrowed for the face's life, +/// its stage cleared; `reset` puts the pen after the space slot. +pub fn init(gpa: std.mem.Allocator, bytes: []const u8) !Atlas { + const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit; + errdefer c.ui_font_free(font); + const atlas_stage = try gpa.alloc(u8, atlas_w * atlas_h); + @memset(atlas_stage, 0); + return .{ .font = font, .atlas_stage = atlas_stage, .glyphs = std.AutoHashMap(Key, Slot).init(gpa) }; +} + +pub fn deinit(a: *Atlas, gpa: std.mem.Allocator) void { + for (a.fallbacks[0..a.fallback_count]) |loaded| { + const fallback = loaded.?; + c.ui_font_free(fallback.face); + if (fallback.bytes.len != 0) gpa.free(fallback.bytes); + } + c.ui_font_free(a.font); + if (a.font_bytes.len != 0) gpa.free(a.font_bytes); + a.glyphs.deinit(); + gpa.free(a.atlas_stage); +} + +/// The primary face from `bytes`, made with `gpa` and now the atlas's +/// (FreeType borrows them for the face lifetime): false, and `bytes` freed, +/// when FreeType refuses them. What was drawn stays until `reset`. +pub fn setFont(a: *Atlas, gpa: std.mem.Allocator, bytes: []u8) bool { + const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse { + gpa.free(bytes); + return false; + }; + c.ui_font_free(a.font); + if (a.font_bytes.len != 0) gpa.free(a.font_bytes); + a.font = font; + a.font_bytes = bytes; // FreeType borrows them for the face lifetime + return true; +} + +/// The next fallback face, from `bytes`: borrowed, or the atlas's to free +/// with `gpa` when `owned`. False (owned bytes freed) when FreeType refuses +/// them or every fallback is taken. +pub fn addFallback(a: *Atlas, gpa: std.mem.Allocator, bytes: []const u8, owned: bool) bool { + const len = std.math.cast(c_int, bytes.len); + const face = if (a.fallback_count < a.fallbacks.len and len != null) c.ui_font_new(bytes.ptr, len.?) else null; + if (face == null) { + if (owned) gpa.free(bytes); + return false; + } + a.fallbacks[a.fallback_count] = .{ .face = face.?, .bytes = if (owned) @constCast(bytes) else &.{} }; + a.fallback_count += 1; + return true; +} + +/// HarfBuzz's process-wide objects, made with the primary face (font.h's +/// ui_font_prime): the caller says what allocates them. +pub fn prime(a: *Atlas) void { + c.ui_font_prime(a.font); +} + +/// The primary face's PostScript name, else its family's (font.h). +pub fn fontName(a: *const Atlas) [*c]const u8 { + return c.ui_font_name(a.font); +} + +/// The primary face's cell at `px`: its width, height and ascent (font.h). +pub fn cellMetrics(a: *const Atlas, px: f32, cell_w: *c_int, cell_h: *c_int, ascent: *c_int) void { + c.ui_font_cell_metrics(a.font, px, cell_w, cell_h, ascent); +} + +pub const FaceGlyph = struct { face: u8, glyph: u32 }; + +/// The face and glyph that draw `cp`, the face as a Key face: 0 is the +/// primary font and i the fallback i - 1. A codepoint no face has draws the +/// primary's .notdef. +pub fn glyphForCodepoint(a: *const Atlas, cp: u32) FaceGlyph { + const primary = c.ui_font_glyph(a.font, @intCast(cp)); + if (primary != 0) return .{ .face = 0, .glyph = primary }; + for (a.fallbacks[0..a.fallback_count], 1..) |loaded, face| { + const glyph = c.ui_font_glyph(loaded.?.face, @intCast(cp)); + if (glyph != 0) return .{ .face = @intCast(face), .glyph = glyph }; + } + return .{ .face = 0, .glyph = 0 }; +} + +/// Whether shaping could replace `glyph` of the face `face` (a Key face): +/// font.h's ui_font_substitutes. +pub fn substitutes(a: *const Atlas, face: u8, glyph: u32) bool { + const font = if (face == 0) a.font else a.fallbacks[face - 1].?.face; + return c.ui_font_substitutes(font, glyph) != 0; +} + +/// A run of codepoints all of the face `face`, one cell each, shaped at `px` +/// on a grid `cell_w` wide into `out`: font.h's ui_font_shape. +pub fn shape(a: *const Atlas, face: u8, px: f32, cell_w: u32, cps: []const u32, out: []c.UIShapedCell) void { + const font = if (face == 0) a.font else a.fallbacks[face - 1].?.face; + c.ui_font_shape(font, px, @intCast(cell_w), cps.ptr, @intCast(cps.len), out.ptr); +} + +// The first cell of the cleared atlas stays blank: the space slot, `cell_w` +// wide (the body's). +pub fn reset(a: *Atlas, cell_w: u32) void { + a.glyphs.clearRetainingCapacity(); + @memset(a.atlas_stage, 0); + a.space_slot = .{ .u = 0, .v = 0 }; + a.pen_x = cell_w; + a.pen_y = 0; + a.atlas_dirty_top = 0; + a.atlas_dirty_bottom = atlas_h; +} + +/// The atlas slot of `key`, rasterized on first use at `body`'s or +/// `tagline`'s size (Key.role). A strip is `span` cells wide (a grip glyph +/// `centered_cells` cells, centered); a cell samples its slice of it. Pen +/// rows are `body`'s cell tall. Rules and decorations are `line_px` thick. +/// Null when the atlas is full. +pub fn cachedGlyph(a: *Atlas, key: Key, body: Size, tagline: Size, centered_cells: u32, line_px: usize) ?Slot { + if (a.glyphs.get(key)) |s| return s; + const slot_w = body.cell_w * (if (key.centered) centered_cells else key.span); + if (a.pen_x + slot_w > atlas_w) { + a.pen_x = 0; + a.pen_y += body.height; + } + if (a.pen_y + body.height > atlas_h) return null; // atlas full: fall back + const s = Slot{ .u = a.pen_x, .v = a.pen_y }; + const out = a.atlas_stage.ptr + @as(usize, s.v) * atlas_w + s.u; + const face = if (key.face == 0) a.font else a.fallbacks[key.face - 1].?.face; + const px = if (key.role == .tagline) tagline.px else body.px; + const baseline = if (key.role == .tagline) tagline.baseline else body.baseline; + const cell_w = if (key.role == .tagline) tagline.cell_w else body.cell_w; + const raster_w = if (key.centered) slot_w else cell_w * key.span; + const raster_h = if (key.role == .tagline) tagline.height else body.height; + const bold = @intFromBool(key.decoration.bold); + if (key.rule) { + drawRule(out, atlas_w, raster_w, raster_h, ruleArms(key.glyph).?, line_px); + } else if (key.centered) { + _ = c.ui_font_raster_centered(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h)); + } else { + _ = c.ui_font_raster(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h), @intCast(cell_w * key.lead), @intCast(cell_w), baseline); + } + decorateLine(out, atlas_w, raster_w, raster_h, baseline, key.decoration, line_px); + if (key.centered) centerGlyphInk(out, raster_w, raster_h); + a.atlas_dirty_top = @min(a.atlas_dirty_top, s.v); + a.atlas_dirty_bottom = @max(a.atlas_dirty_bottom, s.v + raster_h); + a.glyphs.put(key, s) catch return null; + a.pen_x += slot_w; + return s; +} + +// Run once when a grip glyph enters the atlas, after decorations. Copy only +// visible ink so bearings, empty bitmap margins and bold all share one center. +fn centerGlyphInk(out: [*]u8, width: usize, height: usize) void { + const b = inkBounds(out[0 .. (height - 1) * atlas_w + width], atlas_w, width, height) orelse return; + const w = b.max_x - b.min_x + 1; + const h = b.max_y - b.min_y + 1; + const left = (width - w) / 2; + const top = (height - h) / 2; + var scratch: [atlas_w]u8 = undefined; + for (0..h) |step| { + const row = if (top > b.min_y) h - 1 - step else step; + const source = (b.min_y + row) * atlas_w + b.min_x; + const target = (top + row) * atlas_w; + @memcpy(scratch[0..w], out[source..][0..w]); + @memset(out[target..][0..width], 0); + @memcpy(out[target + left ..][0..w], scratch[0..w]); + } + for (0..height) |row| { + if (row < top or row >= top + h) @memset(out[row * atlas_w ..][0..width], 0); + } +} + +// Underline and strikethrough stay inside the existing atlas slot, so text +// advance, caret and selection geometry are identical to the regular glyph. +// The cached mask keeps this work out of steady-state rendering and also +// decorates terminal spaces. Bold is not drawn here: the rasterizer emboldens +// the outline. +fn decorateLine(out: [*]u8, stride: usize, width: usize, height: usize, baseline: i32, decoration: Decoration, line_px: usize) void { + if (width == 0 or height == 0) return; + // A line is a logical pixel thick, its dots and waves as long: the same + // weight at any density (`line_px`, pardes's dp(1)). + const t: usize = line_px; + if (decoration.underline != .off) { + const base: usize = @intCast(@max(0, baseline)); + const row = @min(base + 1, height -| t); + for (0..width) |x| { + const top = switch (decoration.underline) { + .off => unreachable, + .single => row, + .double => { + const upper = @min(base + 1, height -| 3 * t); + for (0..t) |k| { + out[@min(upper + k, height - 1) * stride + x] = 255; + out[@min(upper + 2 * t + k, height - 1) * stride + x] = 255; + } + continue; + }, + .curly => row -| @as(usize, if (x % (4 * t) < 2 * t) t else 0), + .dotted => if (x % (3 * t) < t) row else continue, + .dashed => if (x % (6 * t) < 4 * t) row else continue, + }; + for (0..t) |k| out[@min(top + k, height - 1) * stride + x] = 255; + } + } + if (decoration.strikethrough) { + const row = @min(height -| t, @as(usize, @intCast(@max(0, baseline))) * 2 / 3); + for (0..t) |k| @memset(out[@min(row + k, height - 1) * stride ..][0..width], 255); + } +} + +/// ui_malloc and friends for this file's own test binary, which has no +/// embedder to export them: C's heap. A test that reaches FreeType or +/// HarfBuzz names it, so only that binary exports them. +const TestHeap = struct { + fn malloc(size: usize) callconv(.c) ?*anyopaque { + return std.c.malloc(size); + } + fn calloc(count: usize, size: usize) callconv(.c) ?*anyopaque { + return std.c.calloc(count, size); + } + fn realloc(block: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque { + return std.c.realloc(block, size); + } + fn free(block: ?*anyopaque) callconv(.c) void { + std.c.free(block); + } + comptime { + @export(&malloc, .{ .name = "ui_malloc" }); + @export(&calloc, .{ .name = "ui_calloc" }); + @export(&realloc, .{ .name = "ui_realloc" }); + @export(&free, .{ .name = "ui_free" }); + } +}; + +test "FreeType atlas raster is grayscale, bounded, and clears blank cells" { + _ = TestHeap; + const font_ttf = @embedFile("AdwaitaMono-Regular.ttf"); + const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?; + defer c.ui_font_free(font); + const h = c.ui_font_glyph(font, 'H'); + try std.testing.expect(h != 0); + try std.testing.expectEqual(@as(u32, 0), c.ui_font_glyph(font, 0x10ffff)); + + const size: f32 = 13.0; + var cell_w: c_int = 0; + var cell_h: c_int = 0; + var ascent: c_int = 0; + c.ui_font_cell_metrics(font, size, &cell_w, &cell_h, &ascent); + try std.testing.expect(cell_w > 0 and cell_w <= 128); + try std.testing.expect(cell_h > 0 and cell_h <= 128); + + const stride: c_int = 128; + var bitmap: [128 * 128]u8 = @splat(0xaa); + try std.testing.expectEqual( + @as(c_int, 1), + c.ui_font_raster(font, size, h, 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent), + ); + + var ink: usize = 0; + var soft: usize = 0; + var regular_coverage: usize = 0; + for (0..@intCast(cell_h)) |y| { + for (0..@intCast(cell_w)) |x| { + const coverage = bitmap[y * @as(usize, @intCast(stride)) + x]; + if (coverage > 0) ink += 1; + if (coverage > 0 and coverage < 255) soft += 1; + regular_coverage += coverage; + } + } + try std.testing.expect(ink > 0); + try std.testing.expect(soft > 0); + // Synthetic bold thickens the outline inside the same cell. + try std.testing.expectEqual( + @as(c_int, 1), + c.ui_font_raster(font, size, h, 1, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent), + ); + var bold_coverage: usize = 0; + for (0..@intCast(cell_h)) |y| { + for (0..@intCast(cell_w)) |x| bold_coverage += bitmap[y * @as(usize, @intCast(stride)) + x]; + for (bitmap[y * @as(usize, @intCast(stride)) + @as(usize, @intCast(cell_w)) ..][0..@intCast(stride - cell_w)]) |guard| + try std.testing.expectEqual(@as(u8, 0xaa), guard); + } + try std.testing.expect(bold_coverage > regular_coverage); + + try std.testing.expectEqual( + @as(c_int, 0), + c.ui_font_raster(font, size, c.ui_font_glyph(font, ' '), 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent), + ); + for (0..@intCast(cell_h)) |y| + for (0..@intCast(cell_w)) |x| + try std.testing.expectEqual( + @as(u8, 0), + bitmap[y * @as(usize, @intCast(stride)) + x], + ); +} + +test "a box-drawing rule reaches its cell's edges, and only its arms do" { + const stride = 12; + const width = 9; + const height = 15; + var mask: [stride * height]u8 = @splat(0xa5); + drawRule(&mask, stride, width, height, ruleArms(0x253c).?, 1); + // ┼: ink on all four edges, none in the corners, nothing past the slot. + try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]); + try std.testing.expectEqual(@as(u8, 255), mask[(height - 1) * stride + width / 2]); + try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride]); + try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride + width - 1]); + try std.testing.expectEqual(@as(u8, 0), mask[0]); + for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard| try std.testing.expectEqual(@as(u8, 0xa5), guard); + drawRule(&mask, stride, width, height, ruleArms(0x2502).?, 1); + try std.testing.expectEqual(@as(u8, 0), mask[(height / 2) * stride]); + try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]); + try std.testing.expect(ruleArms('|') == null); +} + +test "glyph decorations render spaces and stay inside their atlas slot" { + const stride = 9; + const width = 5; + const height = 7; + for ([_]Decoration{ + .{ .underline = .single }, + .{ .underline = .double }, + .{ .underline = .curly }, + .{ .underline = .dotted }, + .{ .underline = .dashed }, + .{ .strikethrough = true }, + }) |decoration| { + var mask: [stride * (height + 1)]u8 = @splat(0xa5); + for (0..height) |y| @memset(mask[y * stride ..][0..width], 0); + decorateLine(&mask, stride, width, height, 5, decoration, 1); + try std.testing.expect(inkBounds(&mask, stride, width, height) != null); + for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard| + try std.testing.expectEqual(@as(u8, 0xa5), guard); + for (mask[stride * height ..]) |guard| try std.testing.expectEqual(@as(u8, 0xa5), guard); + } +} + +test "the atlas's dirty rows hold every row a new glyph draws into, and a reset dirties them all" { + _ = TestHeap; + var a = try Atlas.init(std.testing.allocator, @embedFile("AdwaitaMono-Regular.ttf")); + defer a.deinit(std.testing.allocator); + // The body at 18 px, the tagline at 14 px in the body's cell (pardes + // sizes it so, at its tagline percent). + var cell_w: c_int = 0; + var cell_h: c_int = 0; + var ascent: c_int = 0; + a.cellMetrics(18, &cell_w, &cell_h, &ascent); + const body: Size = .{ .px = 18, .cell_w = @intCast(cell_w), .height = @intCast(cell_h), .baseline = ascent }; + a.cellMetrics(14, &cell_w, &cell_h, &ascent); + const tagline: Size = .{ .px = 14, .cell_w = @intCast(@min(cell_w, body.cell_w)), .height = @intCast(@min(cell_h, body.height)), .baseline = @min(ascent, cell_h) }; + a.reset(body.cell_w); + // The texture as an upload of the dirty rows leaves it, which starts undefined. + const texture = try std.testing.allocator.alloc(u8, atlas_w * atlas_h); + defer std.testing.allocator.free(texture); + @memset(texture, 0xa5); + var glyph: u32 = 0; + for (0..40) |frame| { + if (frame == 30) a.reset(body.cell_w); // a font change + // Plain glyphs, strips, taglines, grip glyphs and decorations. + for (0..25) |_| { + glyph += 1; + const span: u4 = @intCast(1 + glyph % 3); + _ = a.cachedGlyph(.{ + .face = 0, + .glyph = glyph, + .role = if (glyph % 4 == 0) .tagline else .body, + .decoration = .{ .bold = glyph % 2 == 0, .underline = if (glyph % 5 == 0) .curly else .off, .strikethrough = glyph % 11 == 0 }, + .centered = glyph % 13 == 0, + .lead = @intCast(glyph % span), + .span = span, + }, body, tagline, 2, 1) orelse return error.AtlasFull; + } + for (0..atlas_h) |row| { + const stage = a.atlas_stage[row * atlas_w ..][0..atlas_w]; + const uploaded = texture[row * atlas_w ..][0..atlas_w]; + if (row >= a.atlas_dirty_top and row < a.atlas_dirty_bottom) + @memcpy(uploaded, stage) + else + try std.testing.expect(std.mem.eql(u8, stage, uploaded)); + } + a.atlas_dirty_top = atlas_h; + a.atlas_dirty_bottom = 0; + } + try std.testing.expect(a.pen_y >= 2 * body.height); +} 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 Binary files differnew file mode 100644 index 0000000..0d5af9d --- /dev/null +++ b/src/gpu/shaders/prebuilt/decor.frag.spv diff --git a/src/gpu/shaders/prebuilt/image.frag.spv b/src/gpu/shaders/prebuilt/image.frag.spv Binary files differnew file mode 100644 index 0000000..d663ed8 --- /dev/null +++ b/src/gpu/shaders/prebuilt/image.frag.spv diff --git a/src/gpu/shaders/prebuilt/image.vert.spv b/src/gpu/shaders/prebuilt/image.vert.spv Binary files differnew file mode 100644 index 0000000..1105bae --- /dev/null +++ b/src/gpu/shaders/prebuilt/image.vert.spv diff --git a/src/gpu/shaders/prebuilt/overlay.frag.spv b/src/gpu/shaders/prebuilt/overlay.frag.spv Binary files differnew file mode 100644 index 0000000..e296e99 --- /dev/null +++ b/src/gpu/shaders/prebuilt/overlay.frag.spv diff --git a/src/gpu/shaders/prebuilt/overlay.vert.spv b/src/gpu/shaders/prebuilt/overlay.vert.spv Binary files differnew file mode 100644 index 0000000..a518c57 --- /dev/null +++ b/src/gpu/shaders/prebuilt/overlay.vert.spv diff --git a/src/gpu/shaders/prebuilt/ui.frag.spv b/src/gpu/shaders/prebuilt/ui.frag.spv Binary files differnew file mode 100644 index 0000000..91022fe --- /dev/null +++ b/src/gpu/shaders/prebuilt/ui.frag.spv diff --git a/src/gpu/shaders/prebuilt/ui.vert.spv b/src/gpu/shaders/prebuilt/ui.vert.spv Binary files differnew file mode 100644 index 0000000..ad132bf --- /dev/null +++ b/src/gpu/shaders/prebuilt/ui.vert.spv 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); +} |
