@swf2es/player 0.0.0-stage → 0.1.0

package/dist/render/saffron.js

@@ -0,0 +1,725 @@
+import { Buffer, BufferImageSource, BufferUsage, Geometry, GlProgram, Mesh, RendererType, Shader, UniformGroup, } from "pixi.js";
+import { CURVE, LINE, MOVE, shapeLayers } from "../display/shapes.js";
+/** Most table entries a text's uniforms hold. */
+const ENTRIES = 48;
+/**
+ * Chords a curve is cut into stray from it by this fraction of the em at
+ * most: a 2048th, a hundredth of a pixel at 20 pixels, and few chords.
+ */
+const TOLERANCE = 2048;
+// uView.x: Flash's pixels to a unit of the world, on whose grid they lie, whatever the target.
+// uMode: gridFitType (0 none, 1 pixel, 2 subpixel), thickness, sharpness, and whether a Flash
+// colour transform (uMul, uAdd) replaces Pixi's colour. uWorldOffset (the Pixi fork's): what a
+// filter's input took off the world's translation. uTable: the tables' entries, size, inside,
+// outside. A glyph's aOrigin is its pen and its light and dark tables, each its first entry plus
+// 64 times its entries; aGlyph a corner of its outline's bounds and the way out from it; aRun its
+// segments, first and count, the pixels of a unit of its outline, and its size.
+const vertex = `#version 300 es
+in vec2 aPosition;
+in vec4 aOrigin;
+in vec4 aGlyph;
+in vec4 aRun;
+in vec4 aColor;
+out vec2 vPixel;
+flat out vec2 vPen;
+flat out vec4 vToGlyph;
+flat out vec4 vToPixel;
+flat out vec4 vCut;
+flat out vec4 vShown;
+uniform mat3 uProjectionMatrix;
+uniform mat3 uWorldTransformMatrix;
+uniform vec4 uWorldColorAlpha;
+uniform mat3 uTransformMatrix;
+uniform vec4 uColor;
+uniform vec2 uWorldOffset;
+uniform vec4 uView;
+uniform vec4 uMode;
+uniform vec4 uMul;
+uniform vec4 uAdd;
+uniform vec4 uTable[${ENTRIES}];
+
+// The cutoffs at ppem by the table of entries start to start + count, as text/csm.ts' cutoffs.
+vec2 cutoffs(int start, int count, float ppem) {
+  vec4 first = uTable[start];
+  vec4 last = uTable[start + count - 1];
+  vec2 c = first.yz;
+  if (ppem >= last.x) {
+    c = last.yz;
+  } else if (ppem > first.x) {
+    for (int i = 1; i < ${ENTRIES}; i++) {
+      if (i >= count) {
+        break;
+      }
+
+      vec4 b = uTable[start + i];
+      if (ppem <= b.x) {
+        vec4 a = uTable[start + i - 1];
+        c = mix(a.yz, b.yz, (ppem - a.x) / (b.x - a.x));
+        break;
+      }
+    }
+  }
+
+  float unit = 0.0001 * ppem;
+  float t = clamp(uMode.y, -200.0, 200.0);
+  float s = clamp(uMode.z, -400.0, 400.0);
+  c -= unit * vec2(t + s * 0.5, t - s * 0.5);
+  if (c.x < c.y) {
+    c = vec2((c.x + c.y) * 0.5);
+  }
+
+  return c;
+}
+
+void main(void) {
+  // The local space to Flash's pixels, in the world's space: their grid is the stage's (or a
+  // BitmapData's) wherever the target lies on it, as a filter's does.
+  float unit = uView.x;
+  mat3 m = mat3(unit, 0.0, 0.0, 0.0, unit, 0.0, uWorldOffset * unit, 1.0)
+    * uWorldTransformMatrix * uTransformMatrix;
+  mat2 linear = mat2(m[0].xy, m[1].xy);
+  vec2 origin = m[2].xy;
+  vec2 pen = (m * vec3(aOrigin.xy, 1.0)).xy + roundEven(origin) - origin;
+  float across = max(abs(linear[0][1]), abs(linear[1][0]));
+  if (across > max(abs(linear[0][0]), abs(linear[1][1])) / 65536.0) {
+    // Turned or skewed: no grid.
+  } else if (uMode.x == 1.0) {
+    pen = vec2(roundEven(pen.x * 8.0) / 8.0 + 0.5, roundEven(pen.y));
+  } else if (uMode.x == 2.0) {
+    pen = vec2(roundEven(pen.x * 4.0) / 4.0 + 0.5, roundEven(pen.y));
+  } else {
+    pen = roundEven(pen * 4.0) / 4.0 + vec2(0.5, 0.0);
+  }
+
+  float ppem = aRun.w * sqrt(abs(determinant(linear)));
+  // The colour as drawn, straight: light or dark by it, as adl chooses.
+  vec4 tint = uColor * uWorldColorAlpha;
+  vec4 shown = uMode.w < 0.5
+    ? vec4(aColor.rgb * (tint.a > 0.0 ? tint.rgb / tint.a : vec3(0.0)), aColor.a * tint.a)
+    : clamp(aColor * uMul + uAdd, 0.0, 1.0);
+  bool light = dot(floor(shown.rgb * 255.0 + 0.5), vec3(30.0, 59.0, 11.0)) > 20000.0;
+  int table = int(light ? aOrigin.z : aOrigin.w);
+  vec2 cut = cutoffs(table & 63, table >> 6, ppem);
+  mat2 toPixel = linear * aRun.z;
+  float margin = max(abs(cut.x), abs(cut.y)) + 1.0;
+  float det = determinant(toPixel);
+  mat2 inverse = det != 0.0
+    ? mat2(toPixel[1][1], -toPixel[0][1], -toPixel[1][0], toPixel[0][0]) / det
+    : mat2(0.0);
+  // Expand in glyph space so the margin stays outside under reflections and rotations.
+  // Each inverse row gives the glyph units needed for a pixel perpendicular to that edge.
+  vec2 reach = vec2(length(vec2(inverse[0][0], inverse[1][0])),
+                    length(vec2(inverse[0][1], inverse[1][1]))) * margin;
+  vec2 p = pen + toPixel * (aGlyph.xy + aGlyph.zw * reach);
+  vPixel = p;
+  vPen = pen;
+  vToGlyph = vec4(inverse[0], inverse[1]);
+  vToPixel = vec4(toPixel[0], toPixel[1]);
+  vCut = vec4(cut, aRun.xy);
+  vShown = shown;
+  gl_Position = vec4((uProjectionMatrix * vec3(p / unit - uWorldOffset, 1.0)).xy, 0.0, 1.0);
+}
+`;
+const fragment = `#version 300 es
+precision highp float;
+precision highp int;
+in vec2 vPixel;
+flat in vec2 vPen;
+flat in vec4 vToGlyph;
+flat in vec4 vToPixel;
+flat in vec4 vCut;
+flat in vec4 vShown;
+out vec4 finalColor;
+uniform highp sampler2D uSegments;
+
+void main(void) {
+  vec2 centre = floor(vPixel) + 0.5;
+  mat2 toGlyph = mat2(vToGlyph.xy, vToGlyph.zw);
+  mat2 toPixel = mat2(vToPixel.xy, vToPixel.zw);
+  vec2 g = toGlyph * (centre - vPen);
+  int start = int(vCut.z);
+  int count = int(vCut.w);
+  float nearest = 3.4e38;
+  vec2 along = vec2(1.0, 0.0);
+  bool inside = false;
+  for (int i = 0; i < count; i++) {
+    int k = start + i;
+    vec4 s = texelFetch(uSegments, ivec2(k & 1023, k >> 10), 0);
+    vec2 a = s.xy;
+    vec2 e = s.zw - a;
+    vec2 w = g - a;
+    float t = clamp(dot(w, e) / max(dot(e, e), 1e-20), 0.0, 1.0);
+    vec2 off = w - e * t;
+    float d = dot(off, off);
+    if (d < nearest) {
+      nearest = d;
+      along = e;
+    }
+
+    if ((a.y > g.y) != (s.w > g.y) && a.x + (g.y - a.y) * e.x / e.y > g.x) {
+      inside = !inside;
+    }
+  }
+
+  // In Flash's pixels, across the nearest edge as the transform stretches it.
+  float stretch = length(toPixel * along);
+  float d = stretch > 0.0
+    ? sqrt(nearest) * abs(determinant(toPixel)) * length(along) / stretch
+    : 0.0;
+  d = inside ? d : -d;
+  float coverage = vCut.x > vCut.y
+    ? clamp((d - vCut.y) / (vCut.x - vCut.y), 0.0, 1.0)
+    : step(vCut.x, d);
+  // Nothing outside: as a mask, which writes the stencil wherever it draws, a glyph is its shape.
+  if (coverage <= 0.0) {
+    discard;
+  }
+
+  finalColor = vec4(vShown.rgb * vShown.a, vShown.a) * coverage;
+}
+`;
+let program = null;
+/** Segments to a row of the texture. */
+const ROW = 1024;
+/** The most segments kept: 16 bytes each, 16 MB. Past it the store starts again. */
+export const MOST = ROW * 1024;
+/**
+ * The most segments a glyph may have: every pixel of its quad goes through
+ * them all, so a glyph past this is drawn as normal text is.
+ */
+export const GLYPH_MOST = 2048;
+/**
+ * The most a field may ask of the shader, its glyphs' segments times the
+ * pixels of their quads: past it, the field is drawn as normal text, so
+ * that no SWF has the GPU go through millions of segments a pixel.
+ */
+export const FIELD_BUDGET = 2 ** 25;
+/**
+ * The glyphs' outlines as segments, x0 y0 x1 y1 a texel, in the font's
+ * units over 20 (as shapeLayers reads them), each glyph's a run of its
+ * own: added as a glyph is first drawn, kept until the store is full, when
+ * it starts again and the texts drawn from it are drawn again, or until the
+ * last view that draws them goes.
+ */
+let data = new Float32Array(ROW * 4 * 16);
+let used = 0;
+let source = null;
+/** Bumped as the store starts again, grows or goes: each renderer then uploads it whole. */
+let epoch = 0;
+/** Each renderer's upload of the store: of which epoch, and how many segments of it. */
+const uploads = new WeakMap();
+/** What a glyph of more segments than GLYPH_MOST is known by, so that it is not cut again. */
+const TOO_MANY = { start: 0, count: 0, xMin: 0, yMin: 0, xMax: 0, yMax: 0 };
+/** Each glyph's outline in the store as it now is; null for an empty one. */
+let outlines = new WeakMap();
+/** The texts drawn from the store, each with what draws it again. */
+const live = new Map();
+/** The segments' texture, made on first use; its contents go up as renderers draw (uploadSegments). */
+function segments() {
+    source ??= new BufferImageSource({
+        resource: data,
+        width: ROW,
+        height: data.length / 4 / ROW,
+        format: "rgba32float",
+        scaleMode: "nearest",
+        alphaMode: "no-premultiply-alpha",
+        autoGenerateMipmaps: false,
+    });
+    return source;
+}
+/**
+ * Upload what `renderer` has not of the store: the rows added since it last
+ * did, or the whole after the store started again or grew. A view calls it
+ * after it syncs, before it draws.
+ */
+export function uploadSegments(renderer) {
+    if (!source || renderer.type !== RendererType.WEBGL) {
+        return;
+    }
+    let upload = uploads.get(renderer);
+    if (!upload) {
+        // Its first bind uploads the texture whole.
+        upload = { epoch, segments: used };
+        uploads.set(renderer, upload);
+        return;
+    }
+    const from = upload.epoch === epoch ? upload.segments : 0;
+    if (from >= used) {
+        return;
+    }
+    const gl = renderer.gl;
+    const first = Math.floor(from / ROW);
+    const rows = Math.ceil(used / ROW) - first;
+    renderer.texture.bindForUpload(source);
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, first, ROW, rows, gl.RGBA, gl.FLOAT, data, first * ROW * 4);
+    upload.epoch = epoch;
+    upload.segments = used;
+}
+/**
+ * Start the store again: every outline is cut again on its next draw, and
+ * every text drawn from the store hidden till it is drawn again.
+ */
+export function resetSegments() {
+    used = 0;
+    epoch++;
+    outlines = new WeakMap();
+    for (const [text, again] of live) {
+        text.visible = false;
+        again();
+    }
+    live.clear();
+}
+/** How many segments the store holds, for tests. */
+export function segmentsUsed() {
+    return used;
+}
+/** Room for `count` more segments, the store grown to hold them: false past MOST. */
+function room(count) {
+    if (used + count > MOST) {
+        return false;
+    }
+    if ((used + count) * 4 > data.length) {
+        let length = data.length;
+        while ((used + count) * 4 > length) {
+            length *= 2;
+        }
+        const grown = new Float32Array(length);
+        grown.set(data.subarray(0, used * 4));
+        data = grown;
+        if (source) {
+            source.resource = data;
+            source.resize(ROW, length / 4 / ROW, 1);
+        }
+        epoch++;
+    }
+    return true;
+}
+/**
+ * A glyph's outline cut into segments, its curves into chords that stray
+ * from them by `tolerance` at most, as x0 y0 x1 y1 each.
+ */
+export function chordsOf(glyph, tolerance) {
+    const shape = {
+        id: 0,
+        bounds: { xMin: 0, xMax: 0, yMin: 0, yMax: 0 },
+        edgeBounds: null,
+        fills: [{ type: "solid", color: 0xffffffff }],
+        lines: [],
+        records: glyph.records,
+        truncated: false,
+    };
+    const layers = shapeLayers(shape);
+    const points = [];
+    const contours = layers.length > 0 ? layers[0].fills.flatMap((f) => f.contours) : [];
+    for (const path of contours) {
+        let x = 0;
+        let y = 0;
+        let startX = 0;
+        let startY = 0;
+        for (let i = 0; i < path.length;) {
+            switch (path[i]) {
+                case MOVE:
+                    if (x !== startX || y !== startY) {
+                        points.push(x, y, startX, startY);
+                    }
+                    x = startX = path[i + 1];
+                    y = startY = path[i + 2];
+                    i += 3;
+                    break;
+                case LINE:
+                    points.push(x, y, path[i + 1], path[i + 2]);
+                    x = path[i + 1];
+                    y = path[i + 2];
+                    i += 3;
+                    break;
+                case CURVE: {
+                    const cx = path[i + 1];
+                    const cy = path[i + 2];
+                    const ax = path[i + 3];
+                    const ay = path[i + 4];
+                    // A quadratic strays from its chords of a nth of it by |p0 - 2c + p1| / 4n² at most.
+                    const bend = Math.hypot(x - 2 * cx + ax, y - 2 * cy + ay);
+                    const n = Math.max(1, Math.min(64, Math.ceil(Math.sqrt(bend / (4 * tolerance)))));
+                    let px = x;
+                    let py = y;
+                    for (let k = 1; k <= n; k++) {
+                        const t = k / n;
+                        const u = 1 - t;
+                        const qx = u * u * x + 2 * u * t * cx + t * t * ax;
+                        const qy = u * u * y + 2 * u * t * cy + t * t * ay;
+                        points.push(px, py, qx, qy);
+                        px = qx;
+                        py = qy;
+                    }
+                    x = ax;
+                    y = ay;
+                    i += 5;
+                    break;
+                }
+                default:
+                    // A cubic, which no glyph has.
+                    i += 7;
+            }
+        }
+        if (x !== startX || y !== startY) {
+            points.push(x, y, startX, startY);
+        }
+    }
+    return points;
+}
+/**
+ * A glyph's outline in the store, cut on its first draw: null for an empty
+ * glyph, undefined for one of more segments than GLYPH_MOST or past the
+ * store's room.
+ */
+function outlineOf(glyph, tolerance) {
+    const known = outlines.get(glyph);
+    if (known !== undefined) {
+        return known === TOO_MANY ? undefined : known;
+    }
+    const points = chordsOf(glyph, tolerance);
+    const count = points.length / 4;
+    if (count === 0) {
+        outlines.set(glyph, null);
+        return null;
+    }
+    if (count > GLYPH_MOST) {
+        outlines.set(glyph, TOO_MANY);
+        return undefined;
+    }
+    if (!room(count)) {
+        return undefined;
+    }
+    const outline = {
+        start: used,
+        count,
+        xMin: Number.POSITIVE_INFINITY,
+        yMin: Number.POSITIVE_INFINITY,
+        xMax: Number.NEGATIVE_INFINITY,
+        yMax: Number.NEGATIVE_INFINITY,
+    };
+    for (let i = 0; i < points.length; i += 2) {
+        outline.xMin = Math.min(outline.xMin, points[i]);
+        outline.xMax = Math.max(outline.xMax, points[i]);
+        outline.yMin = Math.min(outline.yMin, points[i + 1]);
+        outline.yMax = Math.max(outline.yMax, points[i + 1]);
+    }
+    data.set(points, used * 4);
+    used += count;
+    outlines.set(glyph, outline);
+    return outline;
+}
+/** The views that draw on the stage, by which the store is kept: it goes with the last. */
+let views = 0;
+const viewsGone = new FinalizationRegistry(() => {
+    views--;
+    if (views === 0) {
+        resetSegments();
+        source?.destroy();
+        source = null;
+        data = new Float32Array(ROW * 4 * 16);
+    }
+});
+/**
+ * What every advanced text a view draws shares: Flash's pixels to a unit
+ * of its world, and whether its renderer draws them at all (WebGL 2, as
+ * the shader is GLSL ES 3.0; elsewhere text is drawn as normal text).
+ */
+export class SaffronView {
+    uniforms = new UniformGroup({
+        uView: { value: new Float32Array([1, 0, 0, 0]), type: "vec4<f32>" },
+    });
+    enabled;
+    constructor(renderer, keeps) {
+        this.enabled =
+            renderer.type === RendererType.WEBGL &&
+                renderer.context?.webGLVersion === 2;
+        if (keeps) {
+            views++;
+            viewsGone.register(this, null);
+        }
+    }
+    get unit() {
+        return this.uniforms.uniforms.uView[0];
+    }
+    set unit(unit) {
+        const view = this.uniforms.uniforms.uView;
+        if (view[0] !== unit) {
+            view[0] = unit;
+            this.uniforms.update();
+        }
+    }
+}
+/** The corners of a glyph's quad, as signs: the margin goes out from it so. */
+const CORNERS = [-1, -1, 1, -1, 1, 1, -1, 1];
+/** Floats a vertex: aPosition 2, then aOrigin, aGlyph, aRun and aColor 4 each. */
+const STRIDE = 18;
+/** The vertices a builder writes, reused by the next: builders build one at a time. */
+let scratch = new Float32Array(STRIDE * 4 * 64);
+/** Indices of quads in order, two triangles each: views of one array, which only grows. */
+let quads = new Uint32Array(0);
+function quadIndices(count) {
+    if (quads.length < count * 6) {
+        const n = Math.max(count, quads.length / 3);
+        quads = new Uint32Array(n * 6);
+        for (let i = 0; i < n; i++) {
+            const v = i * 4;
+            const at = i * 6;
+            quads[at] = v;
+            quads[at + 1] = v + 1;
+            quads[at + 2] = v + 2;
+            quads[at + 3] = v;
+            quads[at + 4] = v + 2;
+            quads[at + 5] = v + 3;
+        }
+    }
+    return quads.subarray(0, count * 6);
+}
+/** The finite value of `v`, 0 for NaN or an infinity, as a field's settings reach the shader. */
+const finite = (v) => (Number.isFinite(v) ? v : 0);
+/** The table's furthest cutoff from the outline, in pixels. */
+function reachOf(table) {
+    let reach = 0;
+    for (let i = 0; i < table.length; i += 3) {
+        reach = Math.max(reach, Math.abs(table[i + 1]), Math.abs(table[i + 2]));
+    }
+    return reach;
+}
+/**
+ * The glyphs of a text drawn with advanced anti-aliasing: each glyph first
+ * reserved (reserve), which cuts its outline and counts what it asks of
+ * the shader, then, if all fit, added (add) and made into one mesh
+ * (done). One builds at a time: they share the vertices they write.
+ */
+export class SaffronBuilder {
+    view;
+    grid;
+    scale;
+    again;
+    glyphs = 0;
+    tables = [];
+    starts = [];
+    entries = 0;
+    cost = 0;
+    thickness;
+    sharpness;
+    /** The epoch the reserved glyphs' outlines are of. */
+    reserved = epoch;
+    constructor(view, 
+    /** 0 none, 1 pixel, 2 subpixel. */
+    grid, thickness, sharpness, 
+    /** Flash's pixels to a pixel of the text, as it is placed now, for the quads' reach and cost. */
+    scale, 
+    /** Draws the text again, when the store it is drawn from starts again. */
+    again) {
+        this.view = view;
+        this.grid = grid;
+        this.scale = scale;
+        this.again = again;
+        this.thickness = finite(thickness);
+        this.sharpness = finite(sharpness);
+    }
+    /** Flash's pixels the shader may reach past the outline, at `size` pixels to the em, by `tables`. */
+    reach(size, tables) {
+        const ppem = size * this.scale;
+        const moved = 0.0001 * ppem * (Math.abs(this.thickness) + Math.abs(this.sharpness) / 2);
+        // And a pixel round, and two for the pen's snapping.
+        return Math.max(reachOf(tables[0]), reachOf(tables[1])) + moved + 3;
+    }
+    /**
+     * Cut a glyph of a font of `em` units and count it at `size` pixels to the
+     * em: false where the text cannot be drawn so, a glyph past GLYPH_MOST
+     * or the field past FIELD_BUDGET, for the whole text to be drawn as
+     * normal text. The store may start again here: reserving every glyph
+     * then goes again (reserveAll).
+     */
+    reserve(glyph, em, size, tables) {
+        const units = em / 20;
+        let outline = outlineOf(glyph, units / TOLERANCE);
+        if (outline === undefined && outlines.get(glyph) !== TOO_MANY) {
+            resetSegments();
+            outline = outlineOf(glyph, units / TOLERANCE);
+        }
+        if (outline === undefined) {
+            return false;
+        }
+        if (outline === null) {
+            return true;
+        }
+        const s = (size / units) * this.scale;
+        const margin = 2 * this.reach(size, tables);
+        const area = ((outline.xMax - outline.xMin) * s + margin) * ((outline.yMax - outline.yMin) * s + margin);
+        this.cost += outline.count * area;
+        return this.cost <= FIELD_BUDGET;
+    }
+    /**
+     * Whether every glyph reserved since restart is still in the store as it
+     * was: false where the store started again while they were reserved.
+     */
+    intact() {
+        return this.reserved === epoch;
+    }
+    /** Reserve afresh, the store's epoch now. */
+    restart() {
+        this.cost = 0;
+        this.reserved = epoch;
+    }
+    /**
+     * Add a reserved glyph, its pen at (x, y) in the text's pixels, `size`
+     * pixels to the em, in 0xRRGGBB and `alpha`, by the light or the dark of
+     * `tables` as its colour is drawn: false where the tables' room is full,
+     * which leaves the text to be drawn as normal text.
+     */
+    add(glyph, em, x, y, size, color, alpha, tables) {
+        const units = em / 20;
+        const outline = outlineOf(glyph, units / TOLERANCE);
+        if (outline === null) {
+            return true;
+        }
+        if (outline === undefined) {
+            return false;
+        }
+        const light = this.code(tables[0]);
+        const dark = this.code(tables[1]);
+        if (light < 0 || dark < 0) {
+            return false;
+        }
+        if ((this.glyphs + 1) * 4 * STRIDE > scratch.length) {
+            const grown = new Float32Array(scratch.length * 2);
+            grown.set(scratch.subarray(0, this.glyphs * 4 * STRIDE));
+            scratch = grown;
+        }
+        const scale = size / units;
+        // Where the quad reaches in the text's pixels, for Pixi's bounds (filters, culling): the
+        // shader moves it out by the cutoffs from where the pen snaps.
+        const out = this.reach(size, tables) / Math.max(this.scale, 1 / 64);
+        const r = ((color >> 16) & 0xff) / 255;
+        const g = ((color >> 8) & 0xff) / 255;
+        const b = (color & 0xff) / 255;
+        let at = this.glyphs * 4 * STRIDE;
+        for (let k = 0; k < 8; k += 2) {
+            const sx = CORNERS[k];
+            const sy = CORNERS[k + 1];
+            const gx = sx < 0 ? outline.xMin : outline.xMax;
+            const gy = sy < 0 ? outline.yMin : outline.yMax;
+            scratch[at] = x + gx * scale + sx * out;
+            scratch[at + 1] = y + gy * scale + sy * out;
+            scratch[at + 2] = x;
+            scratch[at + 3] = y;
+            scratch[at + 4] = light;
+            scratch[at + 5] = dark;
+            scratch[at + 6] = gx;
+            scratch[at + 7] = gy;
+            scratch[at + 8] = sx;
+            scratch[at + 9] = sy;
+            scratch[at + 10] = outline.start;
+            scratch[at + 11] = outline.count;
+            scratch[at + 12] = scale;
+            scratch[at + 13] = size;
+            scratch[at + 14] = r;
+            scratch[at + 15] = g;
+            scratch[at + 16] = b;
+            scratch[at + 17] = alpha;
+            at += STRIDE;
+        }
+        this.glyphs++;
+        return true;
+    }
+    /** A table's place in the uniforms, its first entry plus 64 times its entries, added where new; -1 past their room. */
+    code(table) {
+        let t = this.tables.indexOf(table);
+        if (t < 0) {
+            if (this.entries + table.length / 3 > ENTRIES) {
+                return -1;
+            }
+            t = this.tables.length;
+            this.tables.push(table);
+            this.starts.push(this.entries);
+            this.entries += table.length / 3;
+        }
+        return this.starts[t] + (table.length / 3) * 64;
+    }
+    /** The mesh of the glyphs added, null for none. */
+    done() {
+        if (this.glyphs === 0) {
+            return null;
+        }
+        const buffer = new Buffer({
+            data: scratch.slice(0, this.glyphs * 4 * STRIDE),
+            usage: BufferUsage.VERTEX | BufferUsage.COPY_DST,
+        });
+        const bytes = STRIDE * 4;
+        const geometry = new Geometry({
+            attributes: {
+                aPosition: { buffer, format: "float32x2", stride: bytes, offset: 0 },
+                aOrigin: { buffer, format: "float32x4", stride: bytes, offset: 8 },
+                aGlyph: { buffer, format: "float32x4", stride: bytes, offset: 24 },
+                aRun: { buffer, format: "float32x4", stride: bytes, offset: 40 },
+                aColor: { buffer, format: "float32x4", stride: bytes, offset: 56 },
+            },
+            indexBuffer: quadIndices(this.glyphs),
+        });
+        const table = new Float32Array(ENTRIES * 4);
+        for (let t = 0; t < this.tables.length; t++) {
+            const entries = this.tables[t];
+            for (let i = 0; i < entries.length; i += 3) {
+                const at = (this.starts[t] + i / 3) * 4;
+                table[at] = entries[i];
+                table[at + 1] = entries[i + 1];
+                table[at + 2] = entries[i + 2];
+            }
+        }
+        const text = new SaffronText(geometry, this.view, new Float32Array([this.grid, this.thickness, this.sharpness, 0]), table);
+        live.set(text, this.again);
+        return text;
+    }
+}
+/**
+ * A text's glyphs drawn with advanced anti-aliasing: a mesh of their
+ * quads under its own shader, one draw. It destroys its geometry and its
+ * shader with itself, and leaves the segments' texture, which every one
+ * shares.
+ */
+export class SaffronText extends Mesh {
+    uniforms;
+    flash = null;
+    constructor(geometry, view, mode, table) {
+        program ??= new GlProgram({ vertex, fragment, name: "flash-saffron" });
+        const uniforms = new UniformGroup({
+            uMode: { value: mode, type: "vec4<f32>" },
+            uMul: { value: new Float32Array([1, 1, 1, 1]), type: "vec4<f32>" },
+            uAdd: { value: new Float32Array(4), type: "vec4<f32>" },
+            uTable: { value: table, type: "vec4<f32>", size: ENTRIES },
+        });
+        const shader = new Shader({
+            glProgram: program,
+            resources: { uSegments: segments(), saffronView: view.uniforms, saffronText: uniforms },
+        });
+        super({ geometry, shader });
+        this.uniforms = uniforms;
+    }
+    /** The Flash colour transform it draws under, in place of Pixi's colour (render/color.ts). */
+    get flashColor() {
+        return this.flash;
+    }
+    set flashColor(ct) {
+        this.flash = ct;
+        const { uMode, uMul, uAdd } = this.uniforms.uniforms;
+        uMode[3] = ct ? 1 : 0;
+        if (ct) {
+            uMul.set([ct.rMul, ct.gMul, ct.bMul, ct.aMul]);
+            uAdd.set([ct.rAdd / 255, ct.gAdd / 255, ct.bAdd / 255, ct.aAdd / 255]);
+        }
+        this.uniforms.update();
+    }
+    destroy() {
+        const geometry = this.geometry;
+        const shader = this.shader;
+        live.delete(this);
+        super.destroy();
+        // Its buffers too: the renderer holds a buffer, and its data, till the buffer goes.
+        geometry.destroy(true);
+        shader.destroy();
+    }
+}
+//# sourceMappingURL=saffron.js.map