| /* |
| * Copyright (C) 2026 Behdad Esfahbod |
| * |
| * This is part of HarfBuzz, a text shaping library. |
| * |
| * Permission is hereby granted, without written agreement and without |
| * license or royalty fees, to use, copy, modify, and distribute this |
| * software and its documentation for any purpose, provided that the |
| * above copyright notice and the following two paragraphs appear in |
| * all copies of this software. |
| * |
| * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
| * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
| * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
| * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
| * DAMAGE. |
| * |
| * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
| * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
| * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| */ |
| |
| |
| /* Paint-renderer fragment shader (WGSL). |
| * |
| * Assumes the shared fragment helpers (hb-gpu-fragment.wgsl) and |
| * the draw-renderer fragment helpers (hb-gpu-draw-fragment.wgsl) |
| * are prepended to this source. |
| * |
| * atlas is passed as an explicit storage-buffer pointer parameter, |
| * matching WGSL's scoping rules. |
| */ |
| |
| |
| fn _hb_gpu_stop_color (hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>, |
| stops_base: i32, i: i32, foreground: vec4f, |
| offset: ptr<function, f32>) -> vec4f |
| { |
| let a = hb_gpu_fetch (hb_gpu_atlas, stops_base + i * 2); |
| *offset = f32 (a.r) / 32767.0; |
| let b = hb_gpu_fetch (hb_gpu_atlas, stops_base + i * 2 + 1); |
| if ((a.g & 1) != 0) { |
| return vec4f (foreground.rgb, foreground.a * (f32 (b.a) / 32767.0)); |
| } |
| return vec4f (b) / 32767.0; |
| } |
| |
| fn _hb_gpu_extend_t (t: f32, extend: i32) -> f32 |
| { |
| if (extend == 1) { return t - floor (t); } |
| if (extend == 2) { |
| let u = t - 2.0 * floor (t * 0.5); |
| if (u > 1.0) { return 2.0 - u; } |
| return u; |
| } |
| return clamp (t, 0.0, 1.0); |
| } |
| |
| fn _hb_gpu_eval_stops (hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>, |
| stops_base: i32, stop_count: i32, |
| t: f32, foreground: vec4f) -> vec4f |
| { |
| var off_prev: f32; |
| var col_prev = _hb_gpu_stop_color (hb_gpu_atlas, stops_base, 0, foreground, &off_prev); |
| if (t <= off_prev) { return col_prev; } |
| for (var i: i32 = 1; i < stop_count; i = i + 1) |
| { |
| var off: f32; |
| let col = _hb_gpu_stop_color (hb_gpu_atlas, stops_base, i, foreground, &off); |
| if (t <= off) |
| { |
| let span = off - off_prev; |
| var f: f32 = 0.0; |
| if (span > 1e-6) { f = (t - off_prev) / span; } |
| let p0 = vec4f (col_prev.rgb * col_prev.a, col_prev.a); |
| let p1 = vec4f (col.rgb * col.a, col.a); |
| let pm = mix (p0, p1, f); |
| if (pm.a > 1e-6) { return vec4f (pm.rgb / pm.a, pm.a); } |
| return vec4f (0.0); |
| } |
| col_prev = col; |
| off_prev = off; |
| } |
| return col_prev; |
| } |
| |
| /* Apply the stored 2x2 M^-1 (row-major i16 Q10) to a vector. */ |
| fn _hb_gpu_apply_minv (m: vec4<i32>, v: vec2f) -> vec2f |
| { |
| let mf = vec4f (m) * (1.0 / 1024.0); |
| return vec2f (mf.x * v.x + mf.y * v.y, |
| mf.z * v.x + mf.w * v.y); |
| } |
| |
| fn _hb_gpu_sample_linear (renderCoord: vec2f, grad_base: i32, |
| stop_count: i32, extend: i32, foreground: vec4f, |
| hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>) -> vec4f |
| { |
| let t0 = hb_gpu_fetch (hb_gpu_atlas, grad_base); |
| let m = hb_gpu_fetch (hb_gpu_atlas, grad_base + 1); |
| let p0_r = vec2f (f32 (t0.r), f32 (t0.g)); |
| let d = vec2f (f32 (t0.b), f32 (t0.a)); |
| let denom = dot (d, d); |
| if (denom < 1e-6) { return vec4f (0.0); } |
| let p = _hb_gpu_apply_minv (m, renderCoord - p0_r); |
| var t = dot (p, d) / denom; |
| t = _hb_gpu_extend_t (t, extend); |
| return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 2, stop_count, t, foreground); |
| } |
| |
| fn _hb_gpu_sample_radial (renderCoord: vec2f, grad_base: i32, |
| stop_count: i32, extend: i32, foreground: vec4f, |
| hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>) -> vec4f |
| { |
| let t0 = hb_gpu_fetch (hb_gpu_atlas, grad_base); |
| let t1 = hb_gpu_fetch (hb_gpu_atlas, grad_base + 1); |
| let m = hb_gpu_fetch (hb_gpu_atlas, grad_base + 2); |
| let c0_r = vec2f (f32 (t0.r), f32 (t0.g)); |
| let cd = vec2f (f32 (t0.b), f32 (t0.a)); |
| let r0 = f32 (t1.r); |
| let r1 = f32 (t1.g); |
| |
| let dr = r1 - r0; |
| let p = _hb_gpu_apply_minv (m, renderCoord - c0_r); |
| |
| let A = dot (cd, cd) - dr * dr; |
| let B = -2.0 * (dot (p, cd) + r0 * dr); |
| let C = dot (p, p) - r0 * r0; |
| |
| var t: f32; |
| if (abs (A) > 1e-6) |
| { |
| let disc = B * B - 4.0 * A * C; |
| if (disc < 0.0) { return vec4f (0.0); } |
| let sq = sqrt (disc); |
| let t1r = (-B + sq) / (2.0 * A); |
| let t2r = (-B - sq) / (2.0 * A); |
| if (r0 + t1r * dr >= 0.0) { t = t1r; } else { t = t2r; } |
| } |
| else |
| { |
| if (abs (B) < 1e-6) { return vec4f (0.0); } |
| t = -C / B; |
| } |
| t = _hb_gpu_extend_t (t, extend); |
| return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 3, stop_count, t, foreground); |
| } |
| |
| fn _hb_gpu_sample_sweep (renderCoord: vec2f, grad_base: i32, |
| stop_count: i32, extend: i32, foreground: vec4f, |
| hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>) -> vec4f |
| { |
| let t0 = hb_gpu_fetch (hb_gpu_atlas, grad_base); |
| let m = hb_gpu_fetch (hb_gpu_atlas, grad_base + 1); |
| let c_r = vec2f (f32 (t0.r), f32 (t0.g)); |
| let a0 = f32 (t0.b) / 16384.0; |
| let a1 = f32 (t0.a) / 16384.0; |
| let span = a1 - a0; |
| if (abs (span) < 1e-6) { return vec4f (0.0); } |
| |
| let p = _hb_gpu_apply_minv (m, renderCoord - c_r); |
| var ang = atan2 (p.y, p.x) / 3.14159265358979; |
| if (ang < 0.0) { ang = ang + 2.0; } |
| var t = (ang - a0) / span; |
| t = _hb_gpu_extend_t (t, extend); |
| return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 2, stop_count, t, foreground); |
| } |
| |
| fn _hb_gpu_composite (src: vec4f, dst: vec4f, mode_in: i32) -> vec4f |
| { |
| var r = src + dst * (1.0 - src.a); /* SRC_OVER default */ |
| |
| /* Mode numbers match hb_paint_composite_mode_t. Approximate |
| * unsupported modes with the nearest Porter-Duff mode we do |
| * implement; DIFFERENCE / EXCLUSION / HSL_* still fall through to |
| * SRC_OVER below. */ |
| var mode = mode_in; |
| if (mode == 14 || mode == 18 || mode == 19) { mode = 23; } /* OVERLAY / COLOR_BURN / HARD_LIGHT -> MULTIPLY */ |
| else if (mode == 17 || mode == 20) { mode = 13; } /* COLOR_DODGE / SOFT_LIGHT -> SCREEN */ |
| |
| if (mode == 0) { r = vec4f (0.0); } /* CLEAR */ |
| else if (mode == 1) { r = src; } /* SRC */ |
| else if (mode == 2) { r = dst; } /* DST */ |
| else if (mode == 4) { r = dst + src * (1.0 - dst.a); } /* DST_OVER */ |
| else if (mode == 5) { r = src * dst.a; } /* SRC_IN */ |
| else if (mode == 6) { r = dst * src.a; } /* DST_IN */ |
| else if (mode == 7) { r = src * (1.0 - dst.a); } /* SRC_OUT */ |
| else if (mode == 8) { r = dst * (1.0 - src.a); } /* DST_OUT */ |
| else if (mode == 9) { r = src * dst.a + dst * (1.0 - src.a); } /* SRC_ATOP */ |
| else if (mode == 10) { r = dst * src.a + src * (1.0 - dst.a); } /* DST_ATOP */ |
| else if (mode == 11) { r = src * (1.0 - dst.a) + dst * (1.0 - src.a); } /* XOR */ |
| else if (mode == 12) { r = min (src + dst, vec4f (1.0)); } /* PLUS */ |
| else if (mode == 13) { /* SCREEN (premul) */ |
| r = vec4f (src.rgb + dst.rgb - src.rgb * dst.rgb, |
| src.a + dst.a - src.a * dst.a); |
| } |
| else if (mode == 15) { /* DARKEN */ |
| r = vec4f (min (src.rgb * dst.a, dst.rgb * src.a) |
| + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a), |
| src.a + dst.a - src.a * dst.a); |
| } |
| else if (mode == 16) { /* LIGHTEN */ |
| r = vec4f (max (src.rgb * dst.a, dst.rgb * src.a) |
| + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a), |
| src.a + dst.a - src.a * dst.a); |
| } |
| else if (mode == 23) { /* MULTIPLY (premul) */ |
| r = vec4f (src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a) |
| + src.rgb * dst.rgb, |
| src.a + dst.a - src.a * dst.a); |
| } |
| /* SRC_OVER (3) and DIFFERENCE / EXCLUSION / HSL_* (21, 22, 24-27) |
| * fall through to the SRC_OVER default. */ |
| return r; |
| } |
| |
| /* Wrap _hb_gpu_slug with a sub-glyph extents bail-out. Many |
| * paint layers cover a small region of the outer glyph quad; for |
| * fragments outside the layer's bbox (with an AA + MSAA-spread |
| * margin) the slug coverage is exactly 0, so we can skip the |
| * band/curve walk entirely. */ |
| fn _hb_gpu_slug_clipped (renderCoord: vec2f, pixelsPerEm: vec2f, glyphLoc_: u32, |
| hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>) -> f32 |
| { |
| let header0 = hb_gpu_fetch (hb_gpu_atlas, i32 (glyphLoc_)); |
| let ext = vec4f (header0) * HB_GPU_INV_UNITS; |
| let margin = 2.0 / pixelsPerEm; |
| if (any (renderCoord < ext.xy - margin) || |
| any (renderCoord > ext.zw + margin)) { |
| return 0.0; |
| } |
| return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_, hb_gpu_atlas); |
| } |
| |
| /* Combine slug coverages from all clip outlines on the layer. |
| * Factored so the shader has one set of inlined slug walks |
| * instead of two (one per LAYER op type). flags bits: 0x100 = |
| * HAS_CLIP2; 0x200 = HAS_CLIP3 (HAS_CLIP3 implies HAS_CLIP2). */ |
| fn _hb_gpu_layer_coverage (renderCoord: vec2f, pixelsPerEm: vec2f, |
| base: i32, flags: i32, |
| clip1_payload: i32, clip2_payload: i32, clip3_payload: i32, |
| hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>) -> f32 |
| { |
| var cov = _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, |
| u32 (base + clip1_payload), hb_gpu_atlas); |
| if ((flags & 0x100) != 0) { |
| cov = cov * _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, |
| u32 (base + clip2_payload), hb_gpu_atlas); |
| if ((flags & 0x200) != 0) { |
| cov = cov * _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, |
| u32 (base + clip3_payload), hb_gpu_atlas); |
| } |
| } |
| return cov; |
| } |
| |
| const HB_GPU_PAINT_GROUP_DEPTH: i32 = 4; |
| |
| fn hb_gpu_paint (renderCoord: vec2f, glyphLoc_: u32, foreground: vec4f, |
| hb_gpu_atlas: ptr<storage, array<vec4<i32>>, read>, |
| coverage: ptr<function, f32>) -> vec4f |
| { |
| /* Compute pixelsPerEm once here at uniform control flow. WGSL |
| * rejects fwidth inside a loop-conditional branch, so we call |
| * _hb_gpu_slug (the MSAA-aware implementation that takes a |
| * pre-computed pixelsPerEm) instead of the top-level |
| * hb_gpu_draw() which would re-call fwidth. */ |
| let emsPerPixel = fwidth (renderCoord); |
| let pixelsPerEm = 1.0 / emsPerPixel; |
| |
| let base = i32 (glyphLoc_); |
| let h0 = hb_gpu_fetch (hb_gpu_atlas, base); // (num_ops, _, _, _) |
| let h2 = hb_gpu_fetch (hb_gpu_atlas, base + 2); // (ops_offset, _, _, _) |
| let num_ops = h0.r; |
| var cursor = base + h2.r; |
| |
| var acc = vec4f (0.0); |
| var group_stack: array<vec4f, HB_GPU_PAINT_GROUP_DEPTH>; |
| var sp: i32 = 0; |
| *coverage = 0.0; |
| |
| for (var i: i32 = 0; i < num_ops; i = i + 1) |
| { |
| let op = hb_gpu_fetch (hb_gpu_atlas, cursor); |
| let op_type = op.r; |
| let aux = op.g; |
| let payload = (op.b << 16) | (op.a & 0xffff); |
| |
| if (op_type == 0) { // LAYER_SOLID |
| // texel 1: (clip2_hi, clip2_lo, clip3_hi, clip3_lo) -- valid |
| // per HAS_CLIP2 / HAS_CLIP3 flag bits. |
| // texel 2: RGBA as signed Q15. |
| let op2 = hb_gpu_fetch (hb_gpu_atlas, cursor + 1); |
| let clip2_payload = (op2.r << 16) | (op2.g & 0xffff); |
| let clip3_payload = (op2.b << 16) | (op2.a & 0xffff); |
| let ct = hb_gpu_fetch (hb_gpu_atlas, cursor + 2); |
| var col: vec4f; |
| if ((aux & 1) != 0) { |
| col = vec4f (foreground.rgb, foreground.a * (f32 (ct.a) / 32767.0)); |
| } else { |
| col = vec4f (ct) / 32767.0; |
| } |
| |
| let cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, |
| base, aux, |
| payload, clip2_payload, clip3_payload, |
| hb_gpu_atlas); |
| *coverage = max (*coverage, cov); |
| let src = vec4f (col.rgb * col.a, col.a) * cov; |
| acc = src + acc * (1.0 - src.a); |
| |
| cursor = cursor + 3; |
| } else if (op_type == 1) { // LAYER_GRADIENT |
| let op2 = hb_gpu_fetch (hb_gpu_atlas, cursor + 1); |
| let clip2_payload = (op2.r << 16) | (op2.g & 0xffff); |
| let clip3_payload = (op2.b << 16) | (op2.a & 0xffff); |
| let op3 = hb_gpu_fetch (hb_gpu_atlas, cursor + 2); |
| let grad_payload = (op3.r << 16) | (op3.g & 0xffff); |
| let extend = op3.b; |
| let stop_count = op3.a; |
| let subtype = aux & 0xff; |
| |
| var col = vec4f (0.0); |
| if (subtype == 0) { |
| col = _hb_gpu_sample_linear (renderCoord, |
| base + grad_payload, |
| stop_count, extend, foreground, |
| hb_gpu_atlas); |
| } else if (subtype == 1) { |
| col = _hb_gpu_sample_radial (renderCoord, |
| base + grad_payload, |
| stop_count, extend, foreground, |
| hb_gpu_atlas); |
| } else if (subtype == 2) { |
| col = _hb_gpu_sample_sweep (renderCoord, |
| base + grad_payload, |
| stop_count, extend, foreground, |
| hb_gpu_atlas); |
| } |
| |
| let cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, |
| base, aux, |
| payload, clip2_payload, clip3_payload, |
| hb_gpu_atlas); |
| *coverage = max (*coverage, cov); |
| let src = vec4f (col.rgb * col.a, col.a) * cov; |
| acc = src + acc * (1.0 - src.a); |
| |
| cursor = cursor + 3; |
| } else if (op_type == 2) { // PUSH_GROUP |
| if (sp < HB_GPU_PAINT_GROUP_DEPTH) { |
| group_stack[sp] = acc; |
| sp = sp + 1; |
| } |
| acc = vec4f (0.0); |
| cursor = cursor + 1; |
| } else if (op_type == 3) { // POP_GROUP |
| if (sp > 0) { |
| sp = sp - 1; |
| let src = acc; |
| let dst = group_stack[sp]; |
| acc = _hb_gpu_composite (src, dst, aux); |
| } |
| cursor = cursor + 1; |
| } else { |
| break; |
| } |
| } |
| |
| return acc; |
| } |
