@weasel-js/core 1.7.0 → 1.7.2

package/dist/renderer/drawBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawBatch.js","names":["MAX_VERTICES_PER_BATCH","FLOATS_PER_VERTEX","INITIAL_VERTICES","INITIAL_INDICES","WHITE_U","WHITE_V","PLAIN_WHITE","packSlot","WHITE_SLOT","PAINT_MODE_PLAIN","SOLID_RING_SIZE","BATCH_TIERS","SOLID_RING_SLOT_VERTICES","SOLID_LARGE_RING_SIZE","doubledTo","capacity","from","need","quadIndices","out","quads","q","b","j","DrawBatch","aPos","prog","aColor","aUv","aPost","aSlot","gl","vertices","i","ma","m","mb","mc","md","mtx","mty","x1","x","w","y1","y","h","ax","ay","bx","by","cx","cy","dx","dy","P","r","g","a","slot","u0","v0","post","u1","v1","topShift","baselineY","y0","tanItalic","botShift","tx0","x0","tx1","bx0","bx1","mode","corner","at","uv","src","mesh","srcIdx","n","v","k","base","tier","t","set","ring","u","packed","needVerts","grown","needIdx","indices","existing","vao","vbo","ibo"],"sources":["../../src/renderer/drawBatch.ts"],"sourcesContent":["/**\n * Growable vertex staging for a run of solid-fill geometry, image quads and\n * glyphs.\n *\n * Geometry only: `draw.ts` owns when a run starts, what breaks it, and the\n * uniforms the flush draws under.\n *\n * **One batch for all three, because a page interleaves them.** A grid of\n * thumbnails is a ground rect under an atlas quad under a caption, per cell,\n * and while each kind staged separately every one had to drain the others\n * before it could stage — so a shape that batches perfectly in any one half\n * alone paid a flush per command. Everything a vertex needs to say which it is\n * fits in the same vertex: solids carry the UV of a 1x1 white texel and are\n * their own color, quads carry their atlas UV and a white color, glyphs carry\n * a font atlas UV, their text color, and a paint mode saying the texel is a\n * distance field rather than a color. Gradients join as a fourth off the ramp\n * atlas — a linear one without a mode of its own, since (ramp position, row) is\n * what the plain mode already samples, and a radial or conic one with a mode\n * that says its UV is a gradient-space coordinate to take a `length` or an\n * `atan` of. See `shaders/batchFill.ts`.\n *\n * Colors ride the vertices because shapes in a run differ in color and a merged\n * draw has one set of uniforms — and so does the model transform, applied here\n * rather than uploaded, so shapes under different transforms still share a\n * draw. The texture rides them too, as a slot index into the units the flush\n * binds: slot 0 is the white texel every solid samples, and `draw.ts` hands out\n * the rest per bitmap. A run holds as many bitmaps as there are slots, so an\n * atlas is what makes a wall of one sheet coalesce and a handful of loose\n * bitmaps no longer breaks a run per command.\n */\n\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport type { GlMat3 } from './math/mat3';\nimport type { ShaderProgram } from './shaders/ShaderProgram';\nimport { PAINT_MODE_PLAIN, WHITE_SLOT, packSlot } from './shaders/batchFill';\n\n/** Vertices per flush. Caps staging memory; a longer run flushes in chunks,\n *  which stays correct because painter's order survives a flush. */\nexport const MAX_VERTICES_PER_BATCH = 32768;\n\n/** vec2 a_position + vec4 a_vertexColor + vec2 a_uv + float a_post + float\n *  a_texSlot. Exported so the buffer-replay tests read fields by name rather\n *  than by a stride they repeat — a hard-coded one silently reads a different\n *  field when the vertex grows, instead of failing. */\nexport const FLOATS_PER_VERTEX = 10;\n\n/** Float offset of `a_texSlot` within a vertex, which carries the paint mode\n *  packed alongside the slot — `paintModeOf` unpacks it. */\nexport const TEX_SLOT_OFFSET = 9;\nconst INITIAL_VERTICES = 256;\nconst INITIAL_INDICES = 384;\n\n/** UV of the white texel bound at slot 0. Its texture is 1x1, so any\n *  coordinate lands on it; the center is the one that stays on it under either\n *  filter. */\nexport const WHITE_U = 0.5;\nexport const WHITE_V = 0.5;\n\n/**\n * A gradient vertex's `a_uv`, each channel affine in the coordinates the\n * geometry arrives in: `u = ux*x + uy*y + u0`, and the same for `v`.\n *\n * One shape for all three gradients. A linear one's `v` row is the constant\n * atlas row and its `u` row is the ramp position; a radial or conic one's two\n * rows are the gradient-space coordinate, and the row rides `a_post` instead.\n */\nexport interface GradientUV {\n  ux: number; uy: number; u0: number;\n  vx: number; vy: number; v0: number;\n}\n\n/** What `a_texSlot` carries on a vertex that is its own color: the white texel\n *  at the plain paint mode. */\nconst PLAIN_WHITE = packSlot(WHITE_SLOT, PAINT_MODE_PLAIN);\n\n/**\n * Flushes between one ring slot's write and its next.\n *\n * The driver tracks a write hazard per buffer object, so rewriting one buffer\n * before every flush makes each write wait on the draw still reading it — that\n * wait, not the draw, is what a flush costs. Measured per draw on an M2 Max via\n * ANGLE (`tests/perf/image-quad.spec.ts`): 40–80 us rewriting one buffer, 0.34\n * us for a ring of 64, 0.03 us for a buffer nothing writes. Writing disjoint\n * *ranges* of one buffer does not help — the hazard is per object.\n */\nexport const SOLID_RING_SIZE = 64;\n\n/**\n * Slot sizes, smallest first. A flush takes the first it fits in.\n *\n * **Tiered because the hazard costs what the buffer is worth, not what the\n * write is.** A flush writing one quad into a slot the GPU is still reading\n * waits on the whole buffer object, and resolving that on a 36 KB buffer is far\n * dearer than on a 576-byte one. Measured on a frame of 20,000 quads that\n * nothing merged (`tests/perf/image-quad.spec.ts`): 92 ms with a 256-quad\n * smallest slot against 53 ms with a one-quad one, and a merged run unmoved\n * either way. The run that most wants a small buffer — one command, because the\n * next broke it — is exactly the run a batch is otherwise pure overhead for.\n */\nexport const BATCH_TIERS: readonly { vertices: number; indices: number }[] = [\n  { vertices: 16, indices: 24 },\n  { vertices: 1024, indices: 3072 },\n];\n\n/** What a standard slot holds, named for the tests and the flush-cost specs. */\nexport const SOLID_RING_SLOT_VERTICES = BATCH_TIERS[BATCH_TIERS.length - 1].vertices;\n\n/** Slots for flushes past the largest tier. These grow to fit, so they are few:\n *  a run that big is a run few things broke, and there are not many of them in\n *  a frame to cycle between. */\nexport const SOLID_LARGE_RING_SIZE = 4;\n\n/** One VAO and the two buffers its attribute and element bindings name. */\ninterface BufferSet {\n  vao: WebGLVertexArrayObject;\n  vbo: WebGLBuffer;\n  ibo: WebGLBuffer;\n  /** What the GPU buffers are currently sized for. */\n  vertexCapacity: number;\n  indexCapacity: number;\n  /**\n   * Quads for which this slot's element buffer holds the canonical pattern,\n   * or 0 for contents that cannot be named that way (a mesh's rebased indices,\n   * or a buffer just respecified).\n   *\n   * The pattern for N quads is a prefix of the pattern for any larger N, so a\n   * slot written to its capacity serves every quad flush it ever takes and the\n   * upload happens once per slot rather than once per flush — 0.89 us of the\n   * 3.87 a flush costs (`tests/perf/flush-anatomy.spec.ts`). Rects and image\n   * quads share it: both wind 0-1-2 / 0-2-3.\n   */\n  canonicalQuads: number;\n}\n\nfunction doubledTo(from: number, need: number): number {\n  let capacity = from;\n  while (capacity < need) capacity *= 2;\n  return capacity;\n}\n\n/** The canonical quad index pattern for `quads` quads, as the push helpers\n *  wind them: two triangles over corners 0-1-2 and 0-2-3. */\nfunction quadIndices(quads: number): Uint32Array {\n  const out = new Uint32Array(quads * 6);\n  for (let q = 0; q < quads; q++) {\n    const b = q * 4;\n    const j = q * 6;\n    out[j] = b; out[j + 1] = b + 1; out[j + 2] = b + 2;\n    out[j + 3] = b; out[j + 4] = b + 2; out[j + 5] = b + 3;\n  }\n  return out;\n}\n\nexport class DrawBatch {\n  private readonly gl: WebGL2RenderingContext;\n  private readonly aPos: number;\n  private readonly aColor: number;\n  private readonly aUv: number;\n  private readonly aPost: number;\n  private readonly aSlot: number;\n\n  /** One ring per tier, cycled per flush. Slots are created on first use, so a\n   *  renderer that flushes rarely allocates as few as it flushes. */\n  private readonly rings: (BufferSet | undefined)[][] =\n    BATCH_TIERS.map(() => new Array(SOLID_RING_SIZE).fill(undefined));\n  private readonly nextInRing: number[] = BATCH_TIERS.map(() => 0);\n  /** The same, for flushes past the largest tier; these sets grow to fit. */\n  private readonly largeRing: (BufferSet | undefined)[] =\n    new Array(SOLID_LARGE_RING_SIZE).fill(undefined);\n  private nextLarge = 0;\n\n  private verts = new Float32Array(INITIAL_VERTICES * FLOATS_PER_VERTEX);\n  private idx = new Uint32Array(INITIAL_INDICES);\n  private nVerts = 0;\n  private nIdx = 0;\n  /** Whether the staged run is quads alone, so its indices are the canonical\n   *  pattern and a slot already holding that pattern needs no upload. */\n  private pureRects = true;\n\n  constructor(gl: WebGL2RenderingContext, prog: ShaderProgram) {\n    const aPos = prog.attribute('a_position');\n    const aColor = prog.attribute('a_vertexColor');\n    const aUv = prog.attribute('a_uv');\n    const aPost = prog.attribute('a_post');\n    const aSlot = prog.attribute('a_texSlot');\n    if (aPos === undefined || aColor === undefined || aUv === undefined\n        || aPost === undefined || aSlot === undefined) {\n      throw new Error(\n        'DrawBatch: batch program is missing a_position / a_vertexColor / a_uv / '\n        + 'a_post / a_texSlot',\n      );\n    }\n    this.gl = gl;\n    this.aPos = aPos;\n    this.aColor = aColor;\n    this.aUv = aUv;\n    this.aPost = aPost;\n    this.aSlot = aSlot;\n  }\n\n  get length(): number {\n    return this.nIdx;\n  }\n\n  /** Whether staging `vertices` more would put the run past the per-flush cap. */\n  wouldOverflow(vertices: number): boolean {\n    return this.nVerts + vertices > MAX_VERTICES_PER_BATCH;\n  }\n\n  /**\n   * Append one rect's four corners through `m`, all carrying `rgba` (straight\n   * alpha). An affine maps a rect to a parallelogram, so two triangles still\n   * cover it and the batch draws at `u_model` identity.\n   */\n  pushRect(\n    x: number, y: number, w: number, h: number, m: GlMat3,\n    r: number, g: number, b: number, a: number,\n  ): void {\n    this.reserve(4, 6);\n    let i = this.nVerts * FLOATS_PER_VERTEX;\n    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];\n    const x1 = x + w;\n    const y1 = y + h;\n    const ax = ma * x + mc * y + mtx,   ay = mb * x + md * y + mty;\n    const bx = ma * x1 + mc * y + mtx,  by = mb * x1 + md * y + mty;\n    const cx = ma * x1 + mc * y1 + mtx, cy = mb * x1 + md * y1 + mty;\n    const dx = ma * x + mc * y1 + mtx,  dy = mb * x + md * y1 + mty;\n    const P = PLAIN_WHITE;\n    i = this.writeVertex(i, ax, ay, r, g, b, a, WHITE_U, WHITE_V, 1, P);\n    i = this.writeVertex(i, bx, by, r, g, b, a, WHITE_U, WHITE_V, 1, P);\n    i = this.writeVertex(i, cx, cy, r, g, b, a, WHITE_U, WHITE_V, 1, P);\n    this.writeVertex(i, dx, dy, r, g, b, a, WHITE_U, WHITE_V, 1, P);\n    this.pushQuadIndices();\n  }\n\n  /**\n   * Append one image quad: the destination rect `(x, y, w, h)` mapped through\n   * `m`, sampling `(u0, v0)`-`(u1, v1)`, every corner carrying `post` as the\n   * after-the-color-matrix alpha factor.\n   *\n   * Corners wind top-left, top-right, bottom-right, bottom-left with UVs\n   * following — the same winding `pushRect` uses, which is what lets a run of\n   * mixed rects and quads keep the canonical index pattern. The flips a command\n   * asks for are already in the `u` / `v` the caller passes.\n   *\n   * `slot` is the texture unit the corners sample, which `draw.ts` assigns per\n   * bitmap within the run.\n   */\n  pushQuad(\n    x: number, y: number, w: number, h: number, m: GlMat3,\n    u0: number, v0: number, u1: number, v1: number,\n    post: number, slot: number,\n  ): void {\n    this.reserve(4, 6);\n    let i = this.nVerts * FLOATS_PER_VERTEX;\n    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];\n    const x1 = x + w;\n    const y1 = y + h;\n    const ax = ma * x + mc * y + mtx,   ay = mb * x + md * y + mty;\n    const bx = ma * x1 + mc * y + mtx,  by = mb * x1 + md * y + mty;\n    const cx = ma * x1 + mc * y1 + mtx, cy = mb * x1 + md * y1 + mty;\n    const dx = ma * x + mc * y1 + mtx,  dy = mb * x + md * y1 + mty;\n    const P = packSlot(slot, PAINT_MODE_PLAIN);\n    i = this.writeVertex(i, ax, ay, 1, 1, 1, 1, u0, v0, post, P);\n    i = this.writeVertex(i, bx, by, 1, 1, 1, 1, u1, v0, post, P);\n    i = this.writeVertex(i, cx, cy, 1, 1, 1, 1, u1, v1, post, P);\n    this.writeVertex(i, dx, dy, 1, 1, 1, 1, u0, v1, post, P);\n    this.pushQuadIndices();\n  }\n\n  /**\n   * Append one glyph quad: the box `(x0, y0)`-`(x1, y1)` mapped through `m`,\n   * sampling `(u0, v0)`-`(u1, v1)` of the font atlas at `slot`, painted in\n   * `rgba`.\n   *\n   * `mode` says which channels of that atlas carry the distance field, and\n   * rides the vertices packed into the slot — so a run off a baked MSDF atlas\n   * and one off the runtime canvas bake still share a draw. The synthetic-bold\n   * threshold does not: it is `u_synthBold`, and `draw.ts` breaks the run when\n   * it changes.\n   *\n   * **A synthetic oblique is sheared here rather than in the shader.** The old\n   * text program carried the baseline per vertex and skewed against\n   * `u_synthItalic`; the batch places its own corners, so the shear is one\n   * multiply while they are being placed, and `tanItalic` is 0 for an upright\n   * face. It has to happen before `m`, which is where the shader had it too.\n   *\n   * Corners wind top-left, top-right, bottom-right, bottom-left — `pushQuad`'s\n   * winding, which is what lets a run of mixed rects, image quads and glyphs\n   * keep the canonical index pattern.\n   */\n  pushGlyph(\n    x0: number, y0: number, x1: number, y1: number,\n    baselineY: number, tanItalic: number, m: GlMat3,\n    u0: number, v0: number, u1: number, v1: number,\n    r: number, g: number, b: number, a: number,\n    slot: number, mode: number,\n  ): void {\n    this.reserve(4, 6);\n    let i = this.nVerts * FLOATS_PER_VERTEX;\n    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];\n    // Above-baseline corners (lower y in screen coords) lean further right.\n    const topShift = (baselineY - y0) * tanItalic;\n    const botShift = (baselineY - y1) * tanItalic;\n    const tx0 = x0 + topShift, tx1 = x1 + topShift;\n    const bx0 = x0 + botShift, bx1 = x1 + botShift;\n    const ax = ma * tx0 + mc * y0 + mtx, ay = mb * tx0 + md * y0 + mty;\n    const bx = ma * tx1 + mc * y0 + mtx, by = mb * tx1 + md * y0 + mty;\n    const cx = ma * bx1 + mc * y1 + mtx, cy = mb * bx1 + md * y1 + mty;\n    const dx = ma * bx0 + mc * y1 + mtx, dy = mb * bx0 + md * y1 + mty;\n    const P = packSlot(slot, mode);\n    i = this.writeVertex(i, ax, ay, r, g, b, a, u0, v0, 1, P);\n    i = this.writeVertex(i, bx, by, r, g, b, a, u1, v0, 1, P);\n    i = this.writeVertex(i, cx, cy, r, g, b, a, u1, v1, 1, P);\n    this.writeVertex(i, dx, dy, r, g, b, a, u0, v1, 1, P);\n    this.pushQuadIndices();\n  }\n\n  /**\n   * Append one rect filled by a gradient: the corners of `(x, y, w, h)` mapped\n   * through `m`, sampling the ramp atlas at `slot`.\n   *\n   * `uv` gives each channel of `a_uv` as an affine function of the coordinates\n   * the corners arrive in, which is what lets a gradient ride the vertices at\n   * all: a linear one's ramp position is affine in position outright, and a\n   * radial or conic one's gradient-space *coordinate* is, even though the ramp\n   * position it yields is not. Either way the rasterizer's interpolation across\n   * a triangle is exact. `mode` says which of the two the fragment shader is\n   * looking at, and `post` carries the atlas row for the modes that read it —\n   * see `shaders/batchFill.ts`.\n   *\n   * Values outside 0..1 are the sampler's business; the atlas clamps to the\n   * edge texel, which is what the gradient shader's own `clamp` did.\n   */\n  pushGradientRect(\n    x: number, y: number, w: number, h: number, m: GlMat3,\n    uv: GradientUV, post: number, slot: number, mode: number,\n    r: number, g: number, b: number, a: number,\n  ): void {\n    this.reserve(4, 6);\n    let i = this.nVerts * FLOATS_PER_VERTEX;\n    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];\n    const x1 = x + w;\n    const y1 = y + h;\n    const P = packSlot(slot, mode);\n    const corner = (cx: number, cy: number): number => {\n      const at = i;\n      i = this.writeVertex(\n        at, ma * cx + mc * cy + mtx, mb * cx + md * cy + mty,\n        r, g, b, a,\n        uv.ux * cx + uv.uy * cy + uv.u0,\n        uv.vx * cx + uv.vy * cy + uv.v0,\n        post, P,\n      );\n      return i;\n    };\n    corner(x, y);\n    corner(x1, y);\n    corner(x1, y1);\n    corner(x, y1);\n    this.pushQuadIndices();\n  }\n\n  /** `pushMesh` for a mesh filled by a gradient — see `pushGradientRect` for\n   *  what `uv`, `post` and `mode` carry. */\n  pushGradientMesh(\n    mesh: Mesh, m: GlMat3,\n    uv: GradientUV, post: number, slot: number, mode: number,\n    r: number, g: number, b: number, a: number,\n  ): void {\n    const src = mesh.vertices;\n    const srcIdx = mesh.indices;\n    const n = src.length >> 1;\n    this.reserve(n, srcIdx.length);\n    this.pureRects = false;\n    const v = this.verts;\n    let i = this.nVerts * FLOATS_PER_VERTEX;\n    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];\n    const P = packSlot(slot, mode);\n    for (let k = 0; k < n; k++) {\n      const x = src[k * 2];\n      const y = src[k * 2 + 1];\n      v[i++] = ma * x + mc * y + mtx;\n      v[i++] = mb * x + md * y + mty;\n      v[i++] = r; v[i++] = g; v[i++] = b; v[i++] = a;\n      v[i++] = uv.ux * x + uv.uy * y + uv.u0;\n      v[i++] = uv.vx * x + uv.vy * y + uv.v0;\n      v[i++] = post; v[i++] = P;\n    }\n    const base = this.nVerts;\n    const out = this.idx;\n    let j = this.nIdx;\n    for (let k = 0; k < srcIdx.length; k++) out[j++] = base + srcIdx[k];\n    this.nVerts += n;\n    this.nIdx += srcIdx.length;\n  }\n\n  /**\n   * Append a tessellated mesh through `m`, all vertices carrying `rgba`. The\n   * mesh's own indices are rebased onto the staged vertices, which is why the\n   * index buffer is uploaded per flush rather than written once.\n   */\n  pushMesh(\n    mesh: Mesh, m: GlMat3,\n    r: number, g: number, b: number, a: number,\n  ): void {\n    const src = mesh.vertices;\n    const srcIdx = mesh.indices;\n    const n = src.length >> 1;\n    this.reserve(n, srcIdx.length);\n    this.pureRects = false;\n    const v = this.verts;\n    let i = this.nVerts * FLOATS_PER_VERTEX;\n    const ma = m[0], mb = m[1], mc = m[3], md = m[4], mtx = m[6], mty = m[7];\n    for (let k = 0; k < n; k++) {\n      const x = src[k * 2];\n      const y = src[k * 2 + 1];\n      v[i++] = ma * x + mc * y + mtx;\n      v[i++] = mb * x + md * y + mty;\n      v[i++] = r; v[i++] = g; v[i++] = b; v[i++] = a;\n      v[i++] = WHITE_U; v[i++] = WHITE_V; v[i++] = 1; v[i++] = PLAIN_WHITE;\n    }\n    const base = this.nVerts;\n    const out = this.idx;\n    let j = this.nIdx;\n    for (let k = 0; k < srcIdx.length; k++) out[j++] = base + srcIdx[k];\n    this.nVerts += n;\n    this.nIdx += srcIdx.length;\n  }\n\n  /** Upload the staged geometry into the next set of buffers and bind its VAO.\n   *  Returns the index count for the caller's `drawElements`. */\n  uploadAndBind(): number {\n    const gl = this.gl;\n    const tier = BATCH_TIERS.findIndex(\n      (t) => this.nVerts <= t.vertices && this.nIdx <= t.indices,\n    );\n    const set = tier < 0 ? this.nextLargeSlot() : this.nextRingSlot(tier);\n    gl.bindVertexArray(set.vao);\n    gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);\n    gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.verts, 0, this.nVerts * FLOATS_PER_VERTEX);\n    if (!this.pureRects) {\n      gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, this.idx, 0, this.nIdx);\n      set.canonicalQuads = 0;\n    } else if (set.canonicalQuads < this.nVerts >> 2) {\n      // Written to the slot's capacity, not this flush's length: the extra\n      // costs one upload the slot never repeats.\n      const quads = Math.min(set.vertexCapacity >> 2, Math.floor(set.indexCapacity / 6));\n      gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, quadIndices(quads));\n      set.canonicalQuads = quads;\n    }\n    return this.nIdx;\n  }\n\n  reset(): void {\n    this.nVerts = 0;\n    this.nIdx = 0;\n    this.pureRects = true;\n  }\n\n  dispose(): void {\n    for (const set of [...this.rings.flat(), ...this.largeRing]) {\n      if (set) this.deleteSet(set);\n    }\n    for (const ring of this.rings) ring.fill(undefined);\n    this.largeRing.fill(undefined);\n  }\n\n  private writeVertex(\n    i: number,\n    x: number, y: number,\n    r: number, g: number, b: number, a: number,\n    u: number, v: number, post: number, packed: number,\n  ): number {\n    const out = this.verts;\n    out[i] = x; out[i + 1] = y;\n    out[i + 2] = r; out[i + 3] = g; out[i + 4] = b; out[i + 5] = a;\n    out[i + 6] = u; out[i + 7] = v; out[i + 8] = post; out[i + 9] = packed;\n    return i + FLOATS_PER_VERTEX;\n  }\n\n  /** Two triangles over the four corners just written. */\n  private pushQuadIndices(): void {\n    const base = this.nVerts;\n    let j = this.nIdx;\n    this.idx[j++] = base;     this.idx[j++] = base + 1; this.idx[j++] = base + 2;\n    this.idx[j++] = base;     this.idx[j++] = base + 2; this.idx[j++] = base + 3;\n    this.nVerts += 4;\n    this.nIdx += 6;\n  }\n\n  /** Grow the CPU arrays so `vertices` / `indices` more fit. */\n  private reserve(vertices: number, indices: number): void {\n    const needVerts = (this.nVerts + vertices) * FLOATS_PER_VERTEX;\n    if (needVerts > this.verts.length) {\n      const grown = new Float32Array(doubledTo(this.verts.length, needVerts));\n      grown.set(this.verts);\n      this.verts = grown;\n    }\n    const needIdx = this.nIdx + indices;\n    if (needIdx > this.idx.length) {\n      const grown = new Uint32Array(doubledTo(this.idx.length, needIdx));\n      grown.set(this.idx);\n      this.idx = grown;\n    }\n  }\n\n  private nextRingSlot(tier: number): BufferSet {\n    const ring = this.rings[tier];\n    const slot = this.nextInRing[tier];\n    this.nextInRing[tier] = (slot + 1) % ring.length;\n    const existing = ring[slot];\n    if (existing) return existing;\n    const set = this.createSet(BATCH_TIERS[tier].vertices, BATCH_TIERS[tier].indices);\n    ring[slot] = set;\n    return set;\n  }\n\n  private nextLargeSlot(): BufferSet {\n    const gl = this.gl;\n    const slot = this.nextLarge;\n    this.nextLarge = (slot + 1) % SOLID_LARGE_RING_SIZE;\n    let set = this.largeRing[slot];\n    if (!set) {\n      set = this.createSet(\n        doubledTo(SOLID_RING_SLOT_VERTICES, this.nVerts),\n        doubledTo(BATCH_TIERS[BATCH_TIERS.length - 1].indices, this.nIdx),\n      );\n      this.largeRing[slot] = set;\n      return set;\n    }\n    if (this.nVerts > set.vertexCapacity) {\n      set.vertexCapacity = doubledTo(set.vertexCapacity, this.nVerts);\n      gl.bindBuffer(gl.ARRAY_BUFFER, set.vbo);\n      gl.bufferData(gl.ARRAY_BUFFER, set.vertexCapacity * FLOATS_PER_VERTEX * 4, gl.DYNAMIC_DRAW);\n    }\n    if (this.nIdx > set.indexCapacity) {\n      set.indexCapacity = doubledTo(set.indexCapacity, this.nIdx);\n      gl.bindVertexArray(set.vao);\n      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, set.ibo);\n      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, set.indexCapacity * 4, gl.DYNAMIC_DRAW);\n      gl.bindVertexArray(null);\n      // Respecified, so whatever pattern it held is gone.\n      set.canonicalQuads = 0;\n    }\n    return set;\n  }\n\n  private createSet(vertices: number, indices: number): BufferSet {\n    const gl = this.gl;\n    const vao = gl.createVertexArray();\n    const vbo = gl.createBuffer();\n    const ibo = gl.createBuffer();\n    if (!vao || !vbo || !ibo) throw new Error('DrawBatch: failed to create GL objects');\n    const stride = FLOATS_PER_VERTEX * 4;\n    gl.bindVertexArray(vao);\n    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);\n    gl.bufferData(gl.ARRAY_BUFFER, vertices * stride, gl.DYNAMIC_DRAW);\n    gl.enableVertexAttribArray(this.aPos);\n    gl.vertexAttribPointer(this.aPos, 2, gl.FLOAT, false, stride, 0);\n    gl.enableVertexAttribArray(this.aColor);\n    gl.vertexAttribPointer(this.aColor, 4, gl.FLOAT, false, stride, 8);\n    gl.enableVertexAttribArray(this.aUv);\n    gl.vertexAttribPointer(this.aUv, 2, gl.FLOAT, false, stride, 24);\n    gl.enableVertexAttribArray(this.aPost);\n    gl.vertexAttribPointer(this.aPost, 1, gl.FLOAT, false, stride, 32);\n    gl.enableVertexAttribArray(this.aSlot);\n    gl.vertexAttribPointer(this.aSlot, 1, gl.FLOAT, false, stride, 36);\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);\n    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices * 4, gl.DYNAMIC_DRAW);\n    gl.bindVertexArray(null);\n    return { vao, vbo, ibo, vertexCapacity: vertices, indexCapacity: indices, canonicalQuads: 0 };\n  }\n\n  private deleteSet(set: BufferSet): void {\n    const gl = this.gl;\n    gl.deleteBuffer(set.vbo);\n    gl.deleteBuffer(set.ibo);\n    gl.deleteVertexArray(set.vao);\n  }\n}\n"],"mappings":"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"}

package/dist/renderer/effects/EffectTargets.js

@@ -0,0 +1,45 @@
+//#region src/renderer/effects/EffectTargets.ts
+var e = class {
+	gl;
+	all = [];
+	free = [];
+	width = 0;
+	height = 0;
+	constructor(e) {
+		this.gl = e;
+	}
+	get allocated() {
+		return this.all.length > 0;
+	}
+	acquire(e, t) {
+		(e !== this.width || t !== this.height) && (this.free = [], this.releaseAll(), this.width = e, this.height = t);
+		let n = this.free.pop();
+		if (n) return n;
+		let r = this.create(e, t);
+		return this.all.push(r), r;
+	}
+	release(e) {
+		this.free.push(e);
+	}
+	releaseAll() {
+		let e = this.gl;
+		for (let t of this.all) e.deleteFramebuffer(t.fbo), e.deleteTexture(t.texture), e.deleteRenderbuffer(t.stencil);
+		this.all.length = 0, this.free = [], this.width = 0, this.height = 0;
+	}
+	create(e, t) {
+		let n = this.gl, r = n.createTexture();
+		n.bindTexture(n.TEXTURE_2D, r), n.texImage2D(n.TEXTURE_2D, 0, n.RGBA8, e, t, 0, n.RGBA, n.UNSIGNED_BYTE, null), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MIN_FILTER, n.LINEAR), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_MAG_FILTER, n.LINEAR), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_S, n.CLAMP_TO_EDGE), n.texParameteri(n.TEXTURE_2D, n.TEXTURE_WRAP_T, n.CLAMP_TO_EDGE), n.bindTexture(n.TEXTURE_2D, null);
+		let i = n.createRenderbuffer();
+		n.bindRenderbuffer(n.RENDERBUFFER, i), n.renderbufferStorage(n.RENDERBUFFER, n.DEPTH24_STENCIL8, e, t), n.bindRenderbuffer(n.RENDERBUFFER, null);
+		let a = n.createFramebuffer();
+		return n.bindFramebuffer(n.FRAMEBUFFER, a), n.framebufferTexture2D(n.FRAMEBUFFER, n.COLOR_ATTACHMENT0, n.TEXTURE_2D, r, 0), n.framebufferRenderbuffer(n.FRAMEBUFFER, n.DEPTH_STENCIL_ATTACHMENT, n.RENDERBUFFER, i), n.bindFramebuffer(n.FRAMEBUFFER, null), {
+			fbo: a,
+			texture: r,
+			stencil: i
+		};
+	}
+};
+//#endregion
+export { e as EffectTargets };
+
+//# sourceMappingURL=EffectTargets.js.map

package/dist/renderer/effects/EffectTargets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectTargets.js","names":["EffectTargets","gl","width","height","pooled","made","target","texture","stencil","fbo"],"sources":["../../../src/renderer/effects/EffectTargets.ts"],"sourcesContent":["/**\n * Offscreen colour buffers for effect passes, pooled per renderer.\n *\n * Nothing is allocated until a group with effects asks for one, so a canvas\n * with no effects pays nothing — which is the whole cost story for a feature\n * that would otherwise carry a device-resolution buffer per frame.\n *\n * Every target is the size of the drawing buffer. A group's effects run in\n * screen space, so a smaller buffer would have to reason about where the\n * group's content lands and how far a kernel reaches past it; that is a real\n * optimisation and not the first version of one.\n *\n * The stencil is the part that is easy to get wrong. Clips and even-odd fills\n * live in the stencil buffer, and an FBO does not inherit the default\n * framebuffer's — one without its own attachment renders even-odd paths with\n * their holes filled and clips that do not clip, with no GL error and nothing\n * in a call-sequence test to catch it. Every target here gets a\n * DEPTH24_STENCIL8 renderbuffer of its own.\n */\n\nexport interface EffectTarget {\n  readonly fbo: WebGLFramebuffer;\n  readonly texture: WebGLTexture;\n  /** @internal — the pool's own bookkeeping. */\n  readonly stencil: WebGLRenderbuffer;\n}\n\nexport class EffectTargets {\n  private readonly gl: WebGL2RenderingContext;\n  private readonly all: EffectTarget[] = [];\n  private free: EffectTarget[] = [];\n  private width = 0;\n  private height = 0;\n\n  constructor(gl: WebGL2RenderingContext) {\n    this.gl = gl;\n  }\n\n  /** True once anything has been allocated — what a test asks instead of\n   *  reaching for the private arrays. */\n  get allocated(): boolean {\n    return this.all.length > 0;\n  }\n\n  /**\n   * Borrow a target sized `width` × `height` device pixels. A size change\n   * drops every pooled buffer rather than resizing in place: a borrowed one\n   * cannot be resized under its holder, and a resize is not a per-frame event.\n   */\n  acquire(width: number, height: number): EffectTarget {\n    if (width !== this.width || height !== this.height) {\n      this.free = [];\n      this.releaseAll();\n      this.width = width;\n      this.height = height;\n    }\n    const pooled = this.free.pop();\n    if (pooled) return pooled;\n    const made = this.create(width, height);\n    this.all.push(made);\n    return made;\n  }\n\n  /** Hand one back. Order does not matter — every target is interchangeable. */\n  release(target: EffectTarget): void {\n    this.free.push(target);\n  }\n\n  /** Drop every buffer. Called on dispose and on context loss, where the\n   *  handles are already invalid and only the bookkeeping has to go. */\n  releaseAll(): void {\n    const gl = this.gl;\n    for (const t of this.all) {\n      gl.deleteFramebuffer(t.fbo);\n      gl.deleteTexture(t.texture);\n      gl.deleteRenderbuffer(t.stencil);\n    }\n    this.all.length = 0;\n    this.free = [];\n    this.width = 0;\n    this.height = 0;\n  }\n\n  private create(width: number, height: number): EffectTarget {\n    const gl = this.gl;\n    const texture = gl.createTexture()!;\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);\n    // LINEAR so an effect can sample between texels; CLAMP_TO_EDGE so a kernel\n    // reaching past the edge repeats the border instead of wrapping the\n    // opposite side of the screen into frame.\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n    gl.bindTexture(gl.TEXTURE_2D, null);\n\n    const stencil = gl.createRenderbuffer()!;\n    gl.bindRenderbuffer(gl.RENDERBUFFER, stencil);\n    gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, width, height);\n    gl.bindRenderbuffer(gl.RENDERBUFFER, null);\n\n    const fbo = gl.createFramebuffer()!;\n    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);\n    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, stencil);\n    gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n\n    return { fbo, texture, stencil };\n  }\n}\n"],"mappings":";AA2BA,IAAaA,IAAb,MAA2B;CACzB;CACA,MAAuC,CAAC;CACxC,OAA+B,CAAC;CAChC,QAAgB;CAChB,SAAiB;CAEjB,YAAY,GAA4B;EACtC,KAAK,KAAKC;CACZ;CAIA,IAAI,YAAqB;EACvB,OAAO,KAAK,IAAI,SAAS;CAC3B;CAOA,QAAQ,GAAe,GAA8B;EACnD,CAAIC,MAAU,KAAK,SAASC,MAAW,KAAK,YAC1C,KAAK,OAAO,CAAC,GACb,KAAK,WAAW,GAChB,KAAK,QAAQD,GACb,KAAK,SAASC;EAEhB,IAAMC,IAAS,KAAK,KAAK,IAAI;EAC7B,IAAIA,GAAQ,OAAOA;EACnB,IAAMC,IAAO,KAAK,OAAOH,GAAOC,CAAM;EAEtC,OADA,KAAK,IAAI,KAAKE,CAAI,GACXA;CACT;CAGA,QAAQ,GAA4B;EAClC,KAAK,KAAK,KAAKC,CAAM;CACvB;CAIA,aAAmB;EACjB,IAAML,IAAK,KAAK;EAChB,KAAK,IAAM,KAAK,KAAK,KAGnB,AAFAA,EAAG,kBAAkB,EAAE,GAAG,GAC1BA,EAAG,cAAc,EAAE,OAAO,GAC1BA,EAAG,mBAAmB,EAAE,OAAO;EAKjC,AAHA,KAAK,IAAI,SAAS,GAClB,KAAK,OAAO,CAAC,GACb,KAAK,QAAQ,GACb,KAAK,SAAS;CAChB;CAEA,OAAe,GAAe,GAA8B;EAC1D,IAAMA,IAAK,KAAK,IACVM,IAAUN,EAAG,cAAc;EAUjC,AATAA,EAAG,YAAYA,EAAG,YAAYM,CAAO,GACrCN,EAAG,WAAWA,EAAG,YAAY,GAAGA,EAAG,OAAOC,GAAOC,GAAQ,GAAGF,EAAG,MAAMA,EAAG,eAAe,IAAI,GAI3FA,EAAG,cAAcA,EAAG,YAAYA,EAAG,oBAAoBA,EAAG,MAAM,GAChEA,EAAG,cAAcA,EAAG,YAAYA,EAAG,oBAAoBA,EAAG,MAAM,GAChEA,EAAG,cAAcA,EAAG,YAAYA,EAAG,gBAAgBA,EAAG,aAAa,GACnEA,EAAG,cAAcA,EAAG,YAAYA,EAAG,gBAAgBA,EAAG,aAAa,GACnEA,EAAG,YAAYA,EAAG,YAAY,IAAI;EAElC,IAAMO,IAAUP,EAAG,mBAAmB;EAGtC,AAFAA,EAAG,iBAAiBA,EAAG,cAAcO,CAAO,GAC5CP,EAAG,oBAAoBA,EAAG,cAAcA,EAAG,kBAAkBC,GAAOC,CAAM,GAC1EF,EAAG,iBAAiBA,EAAG,cAAc,IAAI;EAEzC,IAAMQ,IAAMR,EAAG,kBAAkB;EAMjC,OALAA,EAAG,gBAAgBA,EAAG,aAAaQ,CAAG,GACtCR,EAAG,qBAAqBA,EAAG,aAAaA,EAAG,mBAAmBA,EAAG,YAAYM,GAAS,CAAC,GACvFN,EAAG,wBAAwBA,EAAG,aAAaA,EAAG,0BAA0BA,EAAG,cAAcO,CAAO,GAChGP,EAAG,gBAAgBA,EAAG,aAAa,IAAI,GAEhC;GAAE;GAAK;GAAS;EAAQ;CACjC;AACF"}

package/dist/renderer/effects/builtins.js

@@ -0,0 +1,31 @@
+import { registerEffect as e } from "./types.js";
+//#region src/renderer/effects/builtins.ts
+var t = "#version 300 es\nprecision highp float;\nin vec2 v_uv;\nuniform sampler2D u_source;\nuniform vec2 u_texel;\nuniform vec2 u_direction;\nuniform float u_radius;\nout vec4 outColor;\n\nvoid main() {\n  // Nine taps on a Gaussian, spread across the requested radius. The weights\n  // are a normalized binomial row, so a radius of 0 collapses to a copy.\n  const float W[5] = float[5](0.2270270, 0.1945946, 0.1216216, 0.0540541, 0.0162162);\n  vec2 step = u_direction * u_texel * (u_radius / 4.0);\n  vec4 sum = texture(u_source, v_uv) * W[0];\n  for (int i = 1; i < 5; i++) {\n    vec2 off = step * float(i);\n    sum += texture(u_source, v_uv + off) * W[i];\n    sum += texture(u_source, v_uv - off) * W[i];\n  }\n  outColor = sum;\n}\n", n = "#version 300 es\nprecision highp float;\nin vec2 v_uv;\nuniform sampler2D u_source;\nuniform float u_amount;\nuniform float u_feather;\nout vec4 outColor;\n\nvoid main() {\n  vec4 src = texture(u_source, v_uv);\n  float d = distance(v_uv, vec2(0.5)) * 1.41421356;\n  float shade = 1.0 - u_amount * smoothstep(1.0 - u_feather, 1.0, d);\n  // Premultiplied in, premultiplied out: scaling all four channels darkens\n  // toward transparent black, which is what a vignette over a transparent\n  // canvas should do.\n  outColor = src * shade;\n}\n", r = e("weasel:blur", t), i = e("weasel:vignette", n);
+function a({ radius: e }) {
+	return [{
+		program: r,
+		uniforms: {
+			u_direction: [1, 0],
+			u_radius: e
+		}
+	}, {
+		program: r,
+		uniforms: {
+			u_direction: [0, 1],
+			u_radius: e
+		}
+	}];
+}
+function o({ amount: e, feather: t = .6 }) {
+	return [{
+		program: i,
+		uniforms: {
+			u_amount: e,
+			u_feather: t
+		}
+	}];
+}
+//#endregion
+export { a as blur, o as vignette };
+
+//# sourceMappingURL=builtins.js.map

package/dist/renderer/effects/builtins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtins.js","names":["BLUR_FRAG","VIGNETTE_FRAG","BLUR","registerEffect","VIGNETTE","blur","radius","vignette","amount","feather"],"sources":["../../../src/renderer/effects/builtins.ts"],"sourcesContent":["/**\n * Effects that ship with the kit.\n *\n * Each is a function returning `Effect[]`, not a single `Effect`, because a\n * separable kernel is genuinely two passes and hiding that behind one entry\n * would make the cost invisible at the callsite:\n *\n *   effects={[...blur({ radius: 4 }), ...vignette({ amount: 0.6 })]}\n */\nimport type { Effect } from './types';\nimport { registerEffect } from './types';\n\nconst BLUR_FRAG = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_uv;\nuniform sampler2D u_source;\nuniform vec2 u_texel;\nuniform vec2 u_direction;\nuniform float u_radius;\nout vec4 outColor;\n\nvoid main() {\n  // Nine taps on a Gaussian, spread across the requested radius. The weights\n  // are a normalized binomial row, so a radius of 0 collapses to a copy.\n  const float W[5] = float[5](0.2270270, 0.1945946, 0.1216216, 0.0540541, 0.0162162);\n  vec2 step = u_direction * u_texel * (u_radius / 4.0);\n  vec4 sum = texture(u_source, v_uv) * W[0];\n  for (int i = 1; i < 5; i++) {\n    vec2 off = step * float(i);\n    sum += texture(u_source, v_uv + off) * W[i];\n    sum += texture(u_source, v_uv - off) * W[i];\n  }\n  outColor = sum;\n}\n`;\n\nconst VIGNETTE_FRAG = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_uv;\nuniform sampler2D u_source;\nuniform float u_amount;\nuniform float u_feather;\nout vec4 outColor;\n\nvoid main() {\n  vec4 src = texture(u_source, v_uv);\n  float d = distance(v_uv, vec2(0.5)) * 1.41421356;\n  float shade = 1.0 - u_amount * smoothstep(1.0 - u_feather, 1.0, d);\n  // Premultiplied in, premultiplied out: scaling all four channels darkens\n  // toward transparent black, which is what a vignette over a transparent\n  // canvas should do.\n  outColor = src * shade;\n}\n`;\n\nconst BLUR = registerEffect('weasel:blur', BLUR_FRAG);\nconst VIGNETTE = registerEffect('weasel:vignette', VIGNETTE_FRAG);\n\n/**\n * Gaussian blur, as a horizontal pass followed by a vertical one.\n *\n * `radius` is in device pixels and is the distance of the outermost tap, not a\n * standard deviation — 0 is a copy, and the falloff is the same nine-tap\n * kernel at every radius, so a large one is a wide blur rather than a better\n * one. Two passes at O(9) beat one at O(81) and look the same.\n */\nexport function blur({ radius }: { radius: number }): Effect[] {\n  return [\n    { program: BLUR, uniforms: { u_direction: [1, 0], u_radius: radius } },\n    { program: BLUR, uniforms: { u_direction: [0, 1], u_radius: radius } },\n  ];\n}\n\n/**\n * Darken toward the corners. `amount` is how dark the corner gets (0..1) and\n * `feather` how much of the radius the falloff occupies.\n */\nexport function vignette(\n  { amount, feather = 0.6 }: { amount: number; feather?: number },\n): Effect[] {\n  return [{ program: VIGNETTE, uniforms: { u_amount: amount, u_feather: feather } }];\n}\n"],"mappings":";;AAYA,IAAMA,IAAuB,kuBAwBvBC,IAA2B,miBAmB3BC,IAAOC,EAAe,eAAeH,CAAS,GAC9CI,IAAWD,EAAe,mBAAmBF,CAAa;AAUhE,SAAgBI,EAAK,EAAE,aAAwC;CAC7D,OAAO,CACL;EAAE,SAASH;EAAM,UAAU;GAAE,aAAa,CAAC,GAAG,CAAC;GAAG,UAAUI;EAAO;CAAE,GACrE;EAAE,SAASJ;EAAM,UAAU;GAAE,aAAa,CAAC,GAAG,CAAC;GAAG,UAAUI;EAAO;CAAE,CACvE;AACF;AAMA,SAAgBC,EACd,EAAE,WAAQ,aAAU,MACV;CACV,OAAO,CAAC;EAAE,SAASH;EAAU,UAAU;GAAE,UAAUI;GAAQ,WAAWC;EAAQ;CAAE,CAAC;AACnF"}

package/dist/renderer/effects/composite.js

@@ -0,0 +1,9 @@
+import { registerProgram as e } from "../shaders/registerProgram.js";
+import { COMPOSITE_FRAG_SRC as t, EFFECT_VERT_SRC as n } from "./effectPrelude.js";
+//#region src/renderer/effects/composite.ts
+var r = "weasel:effect-composite";
+e(r, n, t);
+//#endregion
+export { r as COMPOSITE_PROGRAM_ID };
+
+//# sourceMappingURL=composite.js.map

package/dist/renderer/effects/composite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite.js","names":["COMPOSITE_PROGRAM_ID","registerProgram","EFFECT_VERT_SRC","COMPOSITE_FRAG_SRC"],"sources":["../../../src/renderer/effects/composite.ts"],"sourcesContent":["/**\n * The pass that puts a group's finished texture back into its parent, and the\n * shared mechanics every effect pass uses to draw a full-screen quad.\n *\n * Registered as an ordinary program so it compiles through the same\n * `ensureProgram` path a consumer's effect does — one compile path, one place\n * a compile failure is reported.\n */\nimport { registerProgram } from '../shaders/registerProgram';\nimport { EFFECT_VERT_SRC, COMPOSITE_FRAG_SRC } from './effectPrelude';\n\n/** Reserved id. The `weasel:` prefix is not enforced anywhere; it is here so a\n *  consumer reading a shader-compile error knows whose program it is. */\nexport const COMPOSITE_PROGRAM_ID = 'weasel:effect-composite';\n\nregisterProgram(COMPOSITE_PROGRAM_ID, EFFECT_VERT_SRC, COMPOSITE_FRAG_SRC);\n"],"mappings":";;;AAaA,IAAaA,IAAuB;AAEpCC,EAAgBD,GAAsBE,GAAiBC,CAAkB"}

package/dist/renderer/effects/effectPrelude.js

@@ -0,0 +1,10 @@
+//#region src/renderer/effects/effectPrelude.ts
+var e = "#version 300 es\nin vec2 a_position;\nin vec2 a_uv;\nout vec2 v_uv;\n\nvoid main() {\n  v_uv = a_uv;\n  gl_Position = vec4(a_position, 0.0, 1.0);\n}\n", t = [
+	"u_source",
+	"u_resolution",
+	"u_texel"
+], n = "#version 300 es\nprecision highp float;\nin vec2 v_uv;\nuniform sampler2D u_source;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\n\nvoid main() {\n  vec4 src = texture(u_source, v_uv);\n  // Undo premultiplication before the colour matrix, which is defined on\n  // straight alpha, then put it back for the blend.\n  float a = src.a;\n  vec3 rgb = a > 0.0 ? src.rgb / a : vec3(0.0);\n  vec4 c = u_colorMatrix * vec4(rgb, a) + u_colorBias;\n  c.a *= u_alpha;\n  outColor = vec4(clamp(c.rgb, 0.0, 1.0) * c.a, c.a);\n}\n";
+//#endregion
+export { n as COMPOSITE_FRAG_SRC, t as EFFECT_KIT_UNIFORMS, e as EFFECT_VERT_SRC };
+
+//# sourceMappingURL=effectPrelude.js.map

package/dist/renderer/effects/effectPrelude.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectPrelude.js","names":["EFFECT_VERT_SRC","EFFECT_KIT_UNIFORMS","COMPOSITE_FRAG_SRC"],"sources":["../../../src/renderer/effects/effectPrelude.ts"],"sourcesContent":["/**\n * Kit-supplied vertex shader for a full-screen effect pass.\n *\n * Distinct from `CUSTOM_VERT_SRC` on purpose. That one places its quad through\n * `u_bounds` and `u_proj`, so its `v_uv` runs top-down in *screen* space; an\n * effect samples a texture the scene was just rendered into, whose v axis runs\n * the other way. Passing `a_position` straight to `gl_Position` and `a_uv`\n * straight out keeps the two aligned — `QUAD_VERTICES` already carries\n * `a_uv == (a_position + 1) / 2` on both axes.\n *\n * PUBLIC CONTRACT — what every effect fragment shader may read:\n *\n *   in  vec2      v_uv           0..1 across the source texture\n *   uniform sampler2D u_source   what has been drawn so far\n *   uniform vec2  u_resolution   source size in device pixels\n *   uniform vec2  u_texel        1.0 / u_resolution — one texel step\n *\n * PREMULTIPLIED ALPHA: `u_source` holds premultiplied RGBA, because that is\n * what the scene blends into it. An effect that weights neighbouring samples\n * (a blur) is doing the right thing on premultiplied values; one that\n * manipulates rgb against a must premultiply its own output the same way the\n * custom-shader prelude requires.\n */\nexport const EFFECT_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nin vec2 a_uv;\nout vec2 v_uv;\n\nvoid main() {\n  v_uv = a_uv;\n  gl_Position = vec4(a_position, 0.0, 1.0);\n}\n`;\n\n/** Attribute names the effect vertex shader binds. Same layout as the custom\n *  prelude's, so `QUAD_VERTICES` serves both. */\nexport const EFFECT_ATTRIBUTES = ['a_position', 'a_uv'] as const;\n\n/** Uniforms the renderer sets on every effect pass. An effect must not\n *  redeclare them with different meanings; it may leave any of them out. */\nexport const EFFECT_KIT_UNIFORMS = ['u_source', 'u_resolution', 'u_texel'] as const;\n\n/** The pass that puts a group's finished texture back into its parent. Not an\n *  effect — no consumer registers it — but it runs on the same quad and the\n *  same vertex shader. `u_alpha` and the colour matrix are the parent group's,\n *  applied here rather than inside the offscreen render, so an effect samples\n *  the group's own pixels rather than pixels the parent has already faded. */\nexport const COMPOSITE_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_uv;\nuniform sampler2D u_source;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\n\nvoid main() {\n  vec4 src = texture(u_source, v_uv);\n  // Undo premultiplication before the colour matrix, which is defined on\n  // straight alpha, then put it back for the blend.\n  float a = src.a;\n  vec3 rgb = a > 0.0 ? src.rgb / a : vec3(0.0);\n  vec4 c = u_colorMatrix * vec4(rgb, a) + u_colorBias;\n  c.a *= u_alpha;\n  outColor = vec4(clamp(c.rgb, 0.0, 1.0) * c.a, c.a);\n}\n`;\n"],"mappings":";AAuBA,IAAaA,IAA6B,0JAiB7BC,IAAsB;CAAC;CAAY;CAAgB;AAAS,GAO5DC,IAAgC"}

package/dist/renderer/effects/types.js

@@ -0,0 +1,10 @@
+import { registerProgram as e } from "../shaders/registerProgram.js";
+import { EFFECT_VERT_SRC as t } from "./effectPrelude.js";
+//#region src/renderer/effects/types.ts
+function n(n, r) {
+	return e(n, t, r);
+}
+//#endregion
+export { n as registerEffect };
+
+//# sourceMappingURL=types.js.map

package/dist/renderer/effects/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":["registerEffect","registerProgram","id","EFFECT_VERT_SRC","frag"],"sources":["../../../src/renderer/effects/types.ts"],"sourcesContent":["import { registerProgram, type ShaderProgramHandle, type ShaderUniform } from '../shaders/registerProgram';\nimport { EFFECT_VERT_SRC } from './effectPrelude';\n\n/**\n * One full-screen pass over what a group has already drawn.\n *\n * The renderer runs a group's effects in order, each reading the previous\n * one's output through `u_source` and writing a whole new buffer — so an\n * effect is free to read neighbouring pixels, which is the entire point and\n * the one thing `colorMatrix` can never do.\n *\n * `uniforms` are the effect's own; `u_source`, `u_resolution` and `u_texel`\n * come from the renderer and must not be passed here.\n */\nexport interface Effect {\n  program: ShaderProgramHandle;\n  uniforms?: Record<string, ShaderUniform>;\n}\n\n/**\n * Register a fragment shader as an effect. Sugar over `registerProgram` with\n * the effect vertex shader, and the reason a consumer never imports the\n * prelude: an effect that registers with the *custom-shader* vertex shader\n * compiles, runs, and samples its source upside down.\n *\n * The fragment shader reads `v_uv` and `u_source`, and may declare\n * `u_resolution` / `u_texel`. See `effectPrelude.ts` for the full contract,\n * including the premultiplied-alpha requirement.\n *\n * @experimental\n */\nexport function registerEffect(id: string, frag: string): ShaderProgramHandle {\n  return registerProgram(id, EFFECT_VERT_SRC, frag);\n}\n"],"mappings":";;;AA+BA,SAAgBA,EAAe,GAAY,GAAmC;CAC5E,OAAOC,EAAgBC,GAAIC,GAAiBC,CAAI;AAClD"}

package/dist/renderer/index.js

@@ -0,0 +1,19 @@
+import { ShaderCompileError as e } from "./shaders/ShaderProgram.js";
+import { buildGradientRamp as t } from "./cache/GradientRampAtlas.js";
+import { mat3 as n } from "./math/mat3.js";
+import { IDENTITY_COLOR_MATRIX as r } from "./state/GroupState.js";
+import { registerTexture as i, textureRegistry as a } from "./textures/registerTexture.js";
+import { programSourceRegistry as o, registerProgram as s } from "./shaders/registerProgram.js";
+import { SPRITE_STRIDE as c } from "./DrawCommand.js";
+import { tessellateStroke as l } from "../features/paths/tessellate/stroke.js";
+import { EFFECT_KIT_UNIFORMS as u, EFFECT_VERT_SRC as d } from "./effects/effectPrelude.js";
+import { OUTLINE_MIN_SCREEN_PX as f } from "./draw.js";
+import { WeaselRenderer as p } from "./WeaselRenderer.js";
+import { frameRect as m } from "./spriteSheet.js";
+import { viewToMat3 as h } from "./math/viewToMat3.js";
+import { cullDrawCommands as g } from "./cullDrawCommands.js";
+import { registerEffect as _ } from "./effects/types.js";
+import { blur as v, vignette as y } from "./effects/builtins.js";
+import { canQueryLocalFonts as b, cssFontFamily as x, cssFontFamilyLoading as S, enableLocalFontOutlines as C, fontOutlineRegistry as w, fontRegistry as T, hasFontOutlines as E, isCanvasFont as D, listFontOutlines as O, loadFontOutlines as k, outlineStatus as A, registerCanvasFont as j, registerFont as M, registerFontOutlines as N, subscribeGlyphReady as P, unregisterCanvasFont as F, unregisterFontOutlines as I } from "@weasel-js/font";
+import { tessellate as L } from "@weasel-js/geom/tessellate";
+export { u as EFFECT_KIT_UNIFORMS, d as EFFECT_VERT_SRC, r as IDENTITY_COLOR_MATRIX, f as OUTLINE_MIN_SCREEN_PX, c as SPRITE_STRIDE, e as ShaderCompileError, p as WeaselRenderer, v as blur, t as buildGradientRamp, b as canQueryLocalFonts, x as cssFontFamily, S as cssFontFamilyLoading, g as cullDrawCommands, C as enableLocalFontOutlines, w as fontOutlineRegistry, T as fontRegistry, m as frameRect, E as hasFontOutlines, D as isCanvasFont, O as listFontOutlines, k as loadFontOutlines, n as mat3, A as outlineStatus, o as programSourceRegistry, j as registerCanvasFont, _ as registerEffect, M as registerFont, N as registerFontOutlines, s as registerProgram, i as registerTexture, P as subscribeGlyphReady, L as tessellate, l as tessellateStroke, a as textureRegistry, F as unregisterCanvasFont, I as unregisterFontOutlines, h as viewToMat3, y as vignette };

package/dist/renderer/math/color.js

@@ -0,0 +1,341 @@
+import { hslToSrgb as e } from "@weasel-js/paint";
+//#region src/renderer/math/color.ts
+function t(e) {
+	let t = n.get(e);
+	if (t !== void 0) return t;
+	let a = i(e);
+	return n.size >= r && n.clear(), n.set(e, a), a;
+}
+var n = /* @__PURE__ */ new Map(), r = 1024;
+function i(e) {
+	let t = e.trim();
+	if (t.startsWith("#")) return f(t);
+	let n = t.toLowerCase(), r = C[n];
+	if (r !== void 0) return r;
+	if (n.startsWith("rgb")) {
+		let e = _(n);
+		if (e) return e;
+	}
+	if (n.startsWith("hsl")) {
+		let e = v(n);
+		if (e) return e;
+	}
+	throw Error(`parseColor: unrecognized color "${e}"`);
+}
+var a = 1024, o = /* @__PURE__ */ new Map();
+function s(e) {
+	let n = o.get(e);
+	if (n) return n;
+	o.size >= a && o.clear();
+	let r = t(e);
+	return o.set(e, r), r;
+}
+function c(e) {
+	let [n, r, i, a] = t(e);
+	return [
+		Math.round(n * 255),
+		Math.round(r * 255),
+		Math.round(i * 255),
+		Math.round(a * 255)
+	];
+}
+function l(e) {
+	let t = e.trim(), n = (t.startsWith("#") ? t.slice(1) : t).toLowerCase();
+	if (!/^[0-9a-f]+$/.test(n)) throw Error(`normalizeHex: invalid hex "${e}"`);
+	if (n.length === 3) return `#${n[0]}${n[0]}${n[1]}${n[1]}${n[2]}${n[2]}`;
+	if (n.length === 4) return `#${n[0]}${n[0]}${n[1]}${n[1]}${n[2]}${n[2]}${n[3]}${n[3]}`;
+	if (n.length === 6 || n.length === 8) return `#${n}`;
+	throw Error(`normalizeHex: invalid hex "${e}"`);
+}
+function u(e) {
+	return f(l(e));
+}
+function d(e) {
+	let [t, n, r] = e, i = e.length === 4 ? e[3] : 1, a = (e) => Math.max(0, Math.min(255, Math.round(e * 255))).toString(16).padStart(2, "0"), o = `#${a(t)}${a(n)}${a(r)}`;
+	return i >= 1 ? o : `${o}${a(i)}`;
+}
+function f(e) {
+	let t = e.slice(1);
+	if (t.length === 3) return [
+		parseInt(t[0] + t[0], 16) / 255,
+		parseInt(t[1] + t[1], 16) / 255,
+		parseInt(t[2] + t[2], 16) / 255,
+		1
+	];
+	if (t.length === 4) return [
+		parseInt(t[0] + t[0], 16) / 255,
+		parseInt(t[1] + t[1], 16) / 255,
+		parseInt(t[2] + t[2], 16) / 255,
+		parseInt(t[3] + t[3], 16) / 255
+	];
+	if (t.length === 6) return [
+		parseInt(t.slice(0, 2), 16) / 255,
+		parseInt(t.slice(2, 4), 16) / 255,
+		parseInt(t.slice(4, 6), 16) / 255,
+		1
+	];
+	if (t.length === 8) return [
+		parseInt(t.slice(0, 2), 16) / 255,
+		parseInt(t.slice(2, 4), 16) / 255,
+		parseInt(t.slice(4, 6), 16) / 255,
+		parseInt(t.slice(6, 8), 16) / 255
+	];
+	throw Error(`parseColor: invalid hex "${e}"`);
+}
+function p(e, t) {
+	return !e.startsWith(t + "(") || !e.endsWith(")") ? null : e.slice(t.length + 1, -1).trim();
+}
+function m(e) {
+	if (e.includes(",")) {
+		let t = e.split(",").map((e) => e.trim());
+		return t.length !== 3 && t.length !== 4 ? null : {
+			rgb: [
+				t[0],
+				t[1],
+				t[2]
+			],
+			alpha: t.length === 4 ? t[3] : null
+		};
+	}
+	let t = e.indexOf("/"), n = (t === -1 ? e : e.slice(0, t)).trim(), r = t === -1 ? null : e.slice(t + 1).trim(), i = n.split(/\s+/);
+	return i.length !== 3 || r !== null && r === "" ? null : {
+		rgb: [
+			i[0],
+			i[1],
+			i[2]
+		],
+		alpha: r
+	};
+}
+function h(e, t) {
+	if (e.endsWith("%")) {
+		let t = Number(e.slice(0, -1));
+		return Number.isFinite(t) ? S(t / 100) : null;
+	}
+	let n = Number(e);
+	return Number.isFinite(n) ? S(n / t) : null;
+}
+function g(e) {
+	if (e === null) return 1;
+	if (e.endsWith("%")) {
+		let t = Number(e.slice(0, -1));
+		return Number.isFinite(t) ? S(t / 100) : 1;
+	}
+	let t = Number(e);
+	return Number.isFinite(t) ? S(t) : 1;
+}
+function _(e) {
+	let t = p(e, "rgba") ?? p(e, "rgb");
+	if (t === null) return null;
+	let n = m(t);
+	if (!n) return null;
+	let r = h(n.rgb[0], 255), i = h(n.rgb[1], 255), a = h(n.rgb[2], 255);
+	return r === null || i === null || a === null ? null : [
+		r,
+		i,
+		a,
+		g(n.alpha)
+	];
+}
+function v(e) {
+	let t = p(e, "hsla") ?? p(e, "hsl");
+	if (t === null) return null;
+	let n = m(t);
+	if (!n) return null;
+	let r = y(n.rgb[0]), i = b(n.rgb[1]), a = b(n.rgb[2]);
+	if (r === null || i === null || a === null) return null;
+	let [o, s, c] = x(r, i, a);
+	return [
+		o,
+		s,
+		c,
+		g(n.alpha)
+	];
+}
+function y(e) {
+	let t;
+	return t = e.endsWith("deg") ? Number(e.slice(0, -3)) : e.endsWith("grad") ? Number(e.slice(0, -4)) * .9 : e.endsWith("rad") ? Number(e.slice(0, -3)) * (180 / Math.PI) : e.endsWith("turn") ? Number(e.slice(0, -4)) * 360 : Number(e), Number.isFinite(t) ? (t % 360 + 360) % 360 : null;
+}
+function b(e) {
+	if (e.endsWith("%")) {
+		let t = Number(e.slice(0, -1));
+		return Number.isFinite(t) ? S(t / 100) : null;
+	}
+	let t = Number(e);
+	return Number.isFinite(t) ? S(t) : null;
+}
+var x = e;
+function S(e) {
+	return e < 0 ? 0 : e > 1 ? 1 : e;
+}
+var C = (() => {
+	let e = {
+		aliceblue: 15792383,
+		antiquewhite: 16444375,
+		aqua: 65535,
+		aquamarine: 8388564,
+		azure: 15794175,
+		beige: 16119260,
+		bisque: 16770244,
+		black: 0,
+		blanchedalmond: 16772045,
+		blue: 255,
+		blueviolet: 9055202,
+		brown: 10824234,
+		burlywood: 14596231,
+		cadetblue: 6266528,
+		chartreuse: 8388352,
+		chocolate: 13789470,
+		coral: 16744272,
+		cornflowerblue: 6591981,
+		cornsilk: 16775388,
+		crimson: 14423100,
+		cyan: 65535,
+		darkblue: 139,
+		darkcyan: 35723,
+		darkgoldenrod: 12092939,
+		darkgray: 11119017,
+		darkgreen: 25600,
+		darkgrey: 11119017,
+		darkkhaki: 12433259,
+		darkmagenta: 9109643,
+		darkolivegreen: 5597999,
+		darkorange: 16747520,
+		darkorchid: 10040012,
+		darkred: 9109504,
+		darksalmon: 15308410,
+		darkseagreen: 9419919,
+		darkslateblue: 4734347,
+		darkslategray: 3100495,
+		darkslategrey: 3100495,
+		darkturquoise: 52945,
+		darkviolet: 9699539,
+		deeppink: 16716947,
+		deepskyblue: 49151,
+		dimgray: 6908265,
+		dimgrey: 6908265,
+		dodgerblue: 2003199,
+		firebrick: 11674146,
+		floralwhite: 16775920,
+		forestgreen: 2263842,
+		fuchsia: 16711935,
+		gainsboro: 14474460,
+		ghostwhite: 16316671,
+		gold: 16766720,
+		goldenrod: 14329120,
+		gray: 8421504,
+		green: 32768,
+		greenyellow: 11403055,
+		grey: 8421504,
+		honeydew: 15794160,
+		hotpink: 16738740,
+		indianred: 13458524,
+		indigo: 4915330,
+		ivory: 16777200,
+		khaki: 15787660,
+		lavender: 15132410,
+		lavenderblush: 16773365,
+		lawngreen: 8190976,
+		lemonchiffon: 16775885,
+		lightblue: 11393254,
+		lightcoral: 15761536,
+		lightcyan: 14745599,
+		lightgoldenrodyellow: 16448210,
+		lightgray: 13882323,
+		lightgreen: 9498256,
+		lightgrey: 13882323,
+		lightpink: 16758465,
+		lightsalmon: 16752762,
+		lightseagreen: 2142890,
+		lightskyblue: 8900346,
+		lightslategray: 7833753,
+		lightslategrey: 7833753,
+		lightsteelblue: 11584734,
+		lightyellow: 16777184,
+		lime: 65280,
+		limegreen: 3329330,
+		linen: 16445670,
+		magenta: 16711935,
+		maroon: 8388608,
+		mediumaquamarine: 6737322,
+		mediumblue: 205,
+		mediumorchid: 12211667,
+		mediumpurple: 9662683,
+		mediumseagreen: 3978097,
+		mediumslateblue: 8087790,
+		mediumspringgreen: 64154,
+		mediumturquoise: 4772300,
+		mediumvioletred: 13047173,
+		midnightblue: 1644912,
+		mintcream: 16121850,
+		mistyrose: 16770273,
+		moccasin: 16770229,
+		navajowhite: 16768685,
+		navy: 128,
+		oldlace: 16643558,
+		olive: 8421376,
+		olivedrab: 7048739,
+		orange: 16753920,
+		orangered: 16729344,
+		orchid: 14315734,
+		palegoldenrod: 15657130,
+		palegreen: 10025880,
+		paleturquoise: 11529966,
+		palevioletred: 14381203,
+		papayawhip: 16773077,
+		peachpuff: 16767673,
+		peru: 13468991,
+		pink: 16761035,
+		plum: 14524637,
+		powderblue: 11591910,
+		purple: 8388736,
+		rebeccapurple: 6697881,
+		red: 16711680,
+		rosybrown: 12357519,
+		royalblue: 4286945,
+		saddlebrown: 9127187,
+		salmon: 16416882,
+		sandybrown: 16032864,
+		seagreen: 3050327,
+		seashell: 16774638,
+		sienna: 10506797,
+		silver: 12632256,
+		skyblue: 8900331,
+		slateblue: 6970061,
+		slategray: 7372944,
+		slategrey: 7372944,
+		snow: 16775930,
+		springgreen: 65407,
+		steelblue: 4620980,
+		tan: 13808780,
+		teal: 32896,
+		thistle: 14204888,
+		tomato: 16737095,
+		turquoise: 4251856,
+		violet: 15631086,
+		wheat: 16113331,
+		white: 16777215,
+		whitesmoke: 16119285,
+		yellow: 16776960,
+		yellowgreen: 10145074
+	}, t = { transparent: [
+		0,
+		0,
+		0,
+		0
+	] };
+	for (let n in e) {
+		let r = e[n];
+		t[n] = [
+			(r >> 16 & 255) / 255,
+			(r >> 8 & 255) / 255,
+			(r & 255) / 255,
+			1
+		];
+	}
+	return t;
+})();
+//#endregion
+export { u as hexToRgba, x as hslToRgb, l as normalizeHex, t as parseColor, c as parseColorToRgba255, s as resolveColor, d as rgbaToHex };
+
+//# sourceMappingURL=color.js.map