ac9180076c
The cooperative-load section already streams each item into shared memory
once per workgroup, but the per-pixel inner loop then recomputed values
that are constant for the whole item/glyph. The compiler can't hoist them
itself — they read shared memory at a varying index.
Precompute them once per item at load time into new shared slots:
- ui-images / ui-text / ui-fused (images+text phases): invRectSize =
1.0/rect.zw, turning the per-pixel `(sp-rect.xy)/rect.zw` vec2 divide
into a multiply.
- ui-text / ui-fused (text phase): the SDF AA `band` (a vec2 divide +
two maxes depending only on the glyph's uv span and rect size).
In ui-fused the new slots (s_inv, s_band) are reused across phases like
the existing s_v* scratch, so the LDS bump is per-category, not summed.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
120 lines
4.7 KiB
GLSL
120 lines
4.7 KiB
GLSL
#version 460
|
||
#extension GL_GOOGLE_include_directive : enable
|
||
#include "ui-shared.glsl"
|
||
|
||
// One workgroup per 8×8 screen tile. The workgroup cooperatively streams the
|
||
// GlyphItem list in chunks of 64 (see ui-shared.glsl), culling each chunk
|
||
// against the tile and compacting survivors — in buffer order — into shared
|
||
// memory; every thread then accumulates over only those survivors.
|
||
layout(push_constant) uniform PC {
|
||
UIDispatchHeader hdr;
|
||
uint fontTextureSlot;
|
||
uint fontSamplerSlot;
|
||
uint _p0;
|
||
uint _p1;
|
||
} pc;
|
||
|
||
layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
|
||
|
||
// SDF tuning — must match Crafter::FontAtlas::kOnEdgeValue / kPixelDistScale.
|
||
const float ON_EDGE = 128.0 / 255.0;
|
||
const float DIST_SCALE = 32.0;
|
||
|
||
shared vec4 s_rect[UI_CHUNK];
|
||
shared vec4 s_uv[UI_CHUNK];
|
||
shared vec4 s_color[UI_CHUNK];
|
||
// Per-glyph constants precomputed once at cooperative-load time and read by the
|
||
// per-pixel inner loop, instead of being recomputed for every pixel × glyph:
|
||
// s_invRectSize = 1.0/rect.zw (turns the per-pixel divide into a multiply)
|
||
// s_band = the SDF AA scale (a divide + two maxes that depend only on
|
||
// the glyph's uv span and rect size — fully loop-invariant)
|
||
shared vec2 s_invRectSize[UI_CHUNK];
|
||
shared float s_band[UI_CHUNK];
|
||
shared uint s_keep[UI_CHUNK];
|
||
shared uint s_order[UI_CHUNK];
|
||
shared uint s_count;
|
||
|
||
void main() {
|
||
ivec2 screenPx;
|
||
bool valid = uiResolveScreenPixel(pc.hdr, screenPx);
|
||
|
||
vec4 dst = vec4(0.0);
|
||
vec2 sp = vec2(0.0);
|
||
if (valid) {
|
||
dst = imageLoad(uiImages[pc.hdr.outImage], screenPx);
|
||
sp = vec2(screenPx) + 0.5;
|
||
}
|
||
|
||
vec2 tileMin, tileMax;
|
||
uiTileBounds(tileMin, tileMax);
|
||
|
||
uint lid = gl_LocalInvocationIndex;
|
||
for (uint base = 0u; base < pc.hdr.itemCount; base += UI_CHUNK) {
|
||
uint idx = base + lid;
|
||
bool keep = false;
|
||
if (idx < pc.hdr.itemCount) {
|
||
s_rect[lid] = uiGlyphHeap[pc.hdr.itemBuffer].items[idx].rect;
|
||
s_uv[lid] = uiGlyphHeap[pc.hdr.itemBuffer].items[idx].uv;
|
||
s_color[lid] = uiGlyphHeap[pc.hdr.itemBuffer].items[idx].color;
|
||
s_invRectSize[lid] = 1.0 / s_rect[lid].zw;
|
||
// Atlas-px per screen-px along this glyph's transform — keeps AA
|
||
// crisp at any rendering size. uvSpan * atlasSize / screenSpan,
|
||
// with FontAtlas::kAtlasSize = 1024. Constant for the whole glyph.
|
||
vec2 uvSpan = s_uv[lid].zw - s_uv[lid].xy;
|
||
vec2 atlasPerScreen = (uvSpan * 1024.0) * s_invRectSize[lid];
|
||
float scalePx = max(atlasPerScreen.x, atlasPerScreen.y);
|
||
// 1-screen-px AA band, expressed in atlas-pixel units of dAtlas.
|
||
s_band[lid] = max(scalePx, 0.0001);
|
||
keep = uiAabbOverlapsTile(s_rect[lid].xy, s_rect[lid].xy + s_rect[lid].zw,
|
||
tileMin, tileMax);
|
||
}
|
||
s_keep[lid] = keep ? 1u : 0u;
|
||
barrier();
|
||
|
||
if (lid == 0u) {
|
||
uint n = 0u;
|
||
uint lim = min(UI_CHUNK, pc.hdr.itemCount - base);
|
||
for (uint k = 0u; k < lim; ++k)
|
||
if (s_keep[k] != 0u) s_order[n++] = k;
|
||
s_count = n;
|
||
}
|
||
barrier();
|
||
|
||
if (valid) {
|
||
for (uint j = 0u; j < s_count; ++j) {
|
||
uint c = s_order[j];
|
||
|
||
vec2 lo = s_rect[c].xy;
|
||
vec2 hi = s_rect[c].xy + s_rect[c].zw;
|
||
if (sp.x < lo.x || sp.y < lo.y) continue;
|
||
if (sp.x >= hi.x || sp.y >= hi.y) continue;
|
||
|
||
vec2 t = (sp - s_rect[c].xy) * s_invRectSize[c];
|
||
vec2 uv = mix(s_uv[c].xy, s_uv[c].zw, t);
|
||
|
||
// Font slots are push constants — provably dynamically uniform, so no
|
||
// nonuniformEXT: lets the compiler hoist the descriptor load out of the
|
||
// per-pixel glyph loop and avoid the divergent-descriptor path.
|
||
float sdf = texture(
|
||
sampler2D(uiTextures[pc.fontTextureSlot],
|
||
uiSamplers[pc.fontSamplerSlot]),
|
||
uv
|
||
).r;
|
||
|
||
// Distance in atlas-pixels (negative inside the glyph).
|
||
float dAtlas = (ON_EDGE - sdf) * DIST_SCALE;
|
||
|
||
// band (the AA scale) was precomputed once per glyph at load.
|
||
float a = clamp(0.5 - dAtlas / s_band[c], 0.0, 1.0);
|
||
if (a <= 0.0) continue;
|
||
|
||
vec4 col = s_color[c];
|
||
vec4 src = vec4(col.rgb, col.a * a);
|
||
dst = uiBlendOver(dst, src);
|
||
}
|
||
}
|
||
barrier();
|
||
}
|
||
|
||
if (valid) imageStore(uiImages[pc.hdr.outImage], screenPx, dst);
|
||
}
|