@weasel-js/core 1.9.3 → 1.10.0

package/dist/renderer/drawBatch.js.map

@@ -1 +0,0 @@
-{"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","F","minX","maxX","minY","maxY","rect","i0","clipConvexPolygon","poly","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';\nimport { clipConvexPolygon, type ClipRect } from './batchClip';\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 * Sized for a driver that tracks a write hazard per buffer object, where\n * rewriting one buffer before every flush makes each write wait on the draw\n * still reading it. That was measured on an M2 Max by timing blocks of frames,\n * a method since retired (`tests/perf/README.md`, \"Timing a frame\"), and on\n * teitou (M5 Max, ANGLE Metal, 2026-10-05) one frame a task does not show it:\n * `tests/perf/image-quad.spec.ts` puts a quad through a ring of 64 at 3.3–5.2 us\n * over two sittings, through one buffer rewritten each time at 2.5–3.0, and\n * through a buffer nothing writes at 0.16–0.22.\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 a write into a big slot costs more than the same write into\n * a small one.** On teitou (M5 Max, ANGLE Metal, 2026-10-05), a frame of 20,000\n * quads each drawn alone (`tests/perf/image-quad.spec.ts`, `renderer/unmerged`)\n * costs 19.2–19.9 us a quad with these tiers against 21.0 with 1,024 vertices\n * as the smallest slot, and a merged run is unmoved either way. The 92 ms\n * against 53 recorded before came from timing blocks of frames, a method since\n * retired. 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. 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  /** The rect every push is cut to, or `null`. `draw.ts` sets it as rect\n   *  clips enter and leave — see `batchClip.ts`. A push returns `false`, having\n   *  staged nothing, for geometry it cannot cut exactly; see `clipQuad`. */\n  clip: ClipRect | null = null;\n  /** Polygon scratch for `clip`: a quad cut by four edges has at most eight\n   *  corners. */\n  private readonly polyIn = new Float32Array(8 * FLOATS_PER_VERTEX);\n  private readonly polyOut = new Float32Array(8 * FLOATS_PER_VERTEX);\n  private readonly polyTmp = new Float32Array(8 * FLOATS_PER_VERTEX);\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  ): boolean {\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    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);\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  ): boolean {\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    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);\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  ): boolean {\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    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);\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  ): boolean {\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    return this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);\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  ): boolean {\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    return this.clip === null || this.clipMesh(base, this.nIdx - srcIdx.length, this.clip);\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  ): boolean {\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    return this.clip === null || this.clipMesh(base, this.nIdx - srcIdx.length, this.clip);\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  /**\n   * Fit the quad just written at `v0` to `rect`: keep it if it lies inside,\n   * drop it if it misses, and cut it if it crosses — but only if its edges\n   * run along the axes. Cutting a slanted edge moves its endpoint off the\n   * subpixel grid the rasterizer snaps to, and the shortened edge then covers\n   * different samples than the whole one did; along an axis the cut edge is\n   * the same line exactly. So a slanted quad that crosses is rolled back and\n   * refused, for `draw.ts` to clip through the stencil instead.\n   *\n   * A cut axis-aligned quad is still four corners, so the run stays pure.\n   */\n  private clipQuad(v0: number, i0: number, rect: ClipRect): boolean {\n    const v = this.verts;\n    const at = v0 * FLOATS_PER_VERTEX;\n    const F = FLOATS_PER_VERTEX;\n    const ax = v[at], ay = v[at + 1], bx = v[at + F], by = v[at + F + 1];\n    const cx = v[at + 2 * F], cy = v[at + 2 * F + 1], dx = v[at + 3 * F], dy = v[at + 3 * F + 1];\n    const minX = Math.min(ax, bx, cx, dx), maxX = Math.max(ax, bx, cx, dx);\n    const minY = Math.min(ay, by, cy, dy), maxY = Math.max(ay, by, cy, dy);\n    if (minX >= rect.x0 && maxX <= rect.x1 && minY >= rect.y0 && maxY <= rect.y1) return true;\n    this.nVerts = v0;\n    this.nIdx = i0;\n    if (maxX <= rect.x0 || minX >= rect.x1 || maxY <= rect.y0 || minY >= rect.y1) return true;\n    const alongAxes = (ay === by && bx === cx && cy === dy && dx === ax)\n      || (ax === bx && by === cy && cx === dx && dy === ay);\n    if (!alongAxes) return false;\n    this.polyIn.set(v.subarray(at, at + 4 * F));\n    const n = clipConvexPolygon(this.polyIn, 4, F, rect, this.polyOut, this.polyTmp);\n    this.appendFan(this.polyOut, n);\n    return true;\n  }\n\n  /** `clipQuad` for a mesh staged from `v0`. A mesh's edges are slanted in\n   *  general, so one that crosses is refused rather than cut. */\n  private clipMesh(v0: number, i0: number, rect: ClipRect): boolean {\n    const v = this.verts;\n    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n    for (let i = v0 * FLOATS_PER_VERTEX; i < this.nVerts * FLOATS_PER_VERTEX; i += FLOATS_PER_VERTEX) {\n      const x = v[i];\n      const y = v[i + 1];\n      if (x < minX) minX = x; if (x > maxX) maxX = x;\n      if (y < minY) minY = y; if (y > maxY) maxY = y;\n    }\n    if (minX >= rect.x0 && maxX <= rect.x1 && minY >= rect.y0 && maxY <= rect.y1) return true;\n    this.nVerts = v0;\n    this.nIdx = i0;\n    return maxX <= rect.x0 || minX >= rect.x1 || maxY <= rect.y0 || minY >= rect.y1;\n  }\n\n  /** Append the `n`-corner convex polygon in `poly` as a triangle fan. */\n  private appendFan(poly: Float32Array, n: number): void {\n    if (n < 3) return;\n    this.reserve(n, (n - 2) * 3);\n    if (n !== 4) this.pureRects = false;\n    const base = this.nVerts;\n    this.verts.set(poly.subarray(0, n * FLOATS_PER_VERTEX), base * FLOATS_PER_VERTEX);\n    let j = this.nIdx;\n    for (let k = 1; k < n - 1; k++) {\n      this.idx[j++] = base; this.idx[j++] = base + k; this.idx[j++] = base + k + 1;\n    }\n    this.nVerts += n;\n    this.nIdx = j;\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

@@ -1,45 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,31 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,10 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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/glyphOutlineMesh.js

@@ -1,67 +0,0 @@
-import { strokeSpaceOf as e } from "../features/paths/tessellate/metric.js";
-import { quantizeStrokeScale as t } from "./cache/strokeMeshCache.js";
-import { outlineMesh as n } from "./cache/outlineMeshCache.js";
-import { outlineStrokeMesh as r, quantizeEmWidth as i } from "./cache/outlineStrokeMeshCache.js";
-import { SYNTHETIC_ITALIC_RADIANS as a } from "./syntheticItalic.js";
-//#region src/renderer/glyphOutlineMesh.ts
-function o(e, t, r) {
-	return l(e, t, r, (e) => n(e.key, e.d));
-}
-function s(n, a, o, s) {
-	let u = n.stroke;
-	if (!u) return null;
-	let d = u.width ?? 1;
-	if (typeof d == "object") {
-		if (!(d.px > 0)) return null;
-		let i = c(n), [f, p, m, h] = [
-			s[0],
-			s[1],
-			s[3],
-			s[4]
-		];
-		return l(n, a, o, (n) => {
-			if (!(n.scale > 0)) return null;
-			let a = n.scale, o = e(a * f, a * p, a * (m - f * i), a * (h - p * i)), s = t(d.px, o.scale);
-			if (!(s > 0)) return null;
-			let c = u.dash?.map((e) => e / s);
-			return r(n.key, n.d, d.px / s, {
-				...u,
-				dash: c
-			}, o.metric ?? void 0);
-		});
-	}
-	return d > 0 ? l(n, a, o, (e) => e.scale > 0 ? r(e.key, e.d, i(d / e.scale), {
-		...u,
-		dash: u.dash?.map((t) => t / e.scale)
-	}) : null) : null;
-}
-var c = (e) => e.synthetic.italic ? Math.tan(a) : 0;
-function l(e, t, n, r) {
-	let i = [], a = 0, o = 0;
-	for (let t of e.glyphs) {
-		let e = r(t);
-		e && e.indices.length !== 0 && (i.push({
-			mesh: e,
-			glyph: t
-		}), a += e.vertices.length, o += e.indices.length);
-	}
-	if (i.length === 0) return null;
-	let s = c(e), l = new Float32Array(a), u = new Uint32Array(o), d = 0, f = 0, p = 0;
-	for (let { mesh: e, glyph: r } of i) {
-		let { x: i, baselineY: a, scale: o } = r;
-		for (let r = 0; r < e.vertices.length; r += 2) {
-			let c = e.vertices[r], u = e.vertices[r + 1];
-			l[d++] = i + t + (c - u * s) * o, l[d++] = a + n + u * o;
-		}
-		for (let t = 0; t < e.indices.length; t++) u[f++] = p + e.indices[t];
-		p += e.vertices.length / 2;
-	}
-	return {
-		vertices: l,
-		indices: u
-	};
-}
-//#endregion
-export { o as outlineGroupMesh, s as outlineGroupStrokeMesh };
-
-//# sourceMappingURL=glyphOutlineMesh.js.map

package/dist/renderer/glyphOutlineMesh.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"glyphOutlineMesh.js","names":["outlineGroupMesh","mergeGlyphMeshes","group","dx","dy","outlineMesh","glyph","outlineGroupStrokeMesh","stroke","width","shear","shearOf","a","b","c","d","transform","s","space","strokeSpaceOf","pxPerEm","quantizeStrokeScale","dash","v","outlineStrokeMesh","quantizeEmWidth","SYNTHETIC_ITALIC_RADIANS","parts","vertexFloats","indexCount","mesh","meshFor","vertices","indices","vi","ii","base","k","ex","ey","x","scale","baselineY"],"sources":["../../src/renderer/glyphOutlineMesh.ts"],"sourcesContent":["/**\n * Glyph outlines as world-space meshes: each glyph's em-space fill or stroke\n * mesh, placed and concatenated so a run of outlined text is one draw.\n */\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport type { LaidOutGroup, LaidOutOutlineGlyph } from '@weasel-js/text';\nimport { strokeSpaceOf } from 'features/paths/tessellate/metric';\nimport type { GlMat3 } from './math/mat3';\nimport { quantizeStrokeScale } from './cache/strokeMeshCache';\nimport { outlineMesh } from './cache/outlineMeshCache';\nimport { outlineStrokeMesh, quantizeEmWidth } from './cache/outlineStrokeMeshCache';\nimport { SYNTHETIC_ITALIC_RADIANS } from './syntheticItalic';\n\n/**\n * Merge a group's glyphs into one world-space mesh, or `null` when nothing in\n * it has area.\n *\n * Every glyph mesh here is `'nonzero'` (that is what `pathFromD` produces and\n * what a font outline means), so none of them sets `requiresStencil` and\n * concatenating their triangles is sound — an even-odd mesh would be a naive\n * per-contour fan that only resolves correctly through a stencil pass, and\n * merging one into a batch would fill its counters solid.\n */\nexport function outlineGroupMesh(group: LaidOutGroup, dx: number, dy: number): Mesh | null {\n  return mergeGlyphMeshes(group, dx, dy, (glyph) => outlineMesh(glyph.key, glyph.d));\n}\n\n/**\n * The same merge for the group's stroke: one ribbon per glyph, tessellated in\n * em space and batched into one buffer, so a stroked paragraph is one extra\n * draw call rather than one per glyph.\n *\n * A world width crosses into em space by dividing by the glyph's `scale`,\n * which is world units per em — so `stroke.width` stays a world-unit measure\n * and does not grow with `fontSize`, matching every other stroke in the kit.\n * Dashes cross with it.\n *\n * A synthetic oblique shears a world-width ribbon along with the glyph. That\n * is a real (small) distortion — a sheared circle is an ellipse, so the\n * outline is marginally thicker across the lean than along it — and it is\n * deliberate: shearing the finished ribbon is what keeps the outline glued to\n * the glyph it outlines, which re-tessellating in sheared space would not.\n *\n * A `{ px }` ribbon is built in the stretch of the whole em-to-screen map,\n * shear included, as a path's is in its transform's (see `metric.ts`), so it\n * is that many pixels wide in every direction on every glyph.\n */\nexport function outlineGroupStrokeMesh(\n  group: LaidOutGroup,\n  dx: number,\n  dy: number,\n  transform: GlMat3,\n): Mesh | null {\n  const stroke = group.stroke;\n  if (!stroke) return null;\n  const width = stroke.width ?? 1;\n  if (typeof width === 'object') {\n    if (!(width.px > 0)) return null;\n    const shear = shearOf(group);\n    const [a, b, c, d] = [transform[0], transform[1], transform[3], transform[4]];\n    return mergeGlyphMeshes(group, dx, dy, (glyph) => {\n      if (!(glyph.scale > 0)) return null;\n      const s = glyph.scale;\n      const space = strokeSpaceOf(s * a, s * b, s * (c - a * shear), s * (d - b * shear));\n      const pxPerEm = quantizeStrokeScale(width.px, space.scale);\n      if (!(pxPerEm > 0)) return null;\n      const dash = stroke.dash?.map((v) => v / pxPerEm);\n      return outlineStrokeMesh(\n        glyph.key, glyph.d, width.px / pxPerEm, { ...stroke, dash }, space.metric ?? undefined,\n      );\n    });\n  }\n  if (!(width > 0)) return null;\n  return mergeGlyphMeshes(group, dx, dy, (glyph) =>\n    glyph.scale > 0\n      ? outlineStrokeMesh(\n        glyph.key, glyph.d, quantizeEmWidth(width / glyph.scale),\n        { ...stroke, dash: stroke.dash?.map((v) => v / glyph.scale) },\n      )\n      : null);\n}\n\nconst shearOf = (group: LaidOutGroup): number =>\n  group.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;\n\n/**\n * Transform each glyph's em-space mesh into world space and concatenate.\n * Shared by the fill and stroke paths, which differ only in which mesh they\n * ask for per glyph — the placement math must not fork, or an outline would\n * drift off the glyph it outlines.\n */\nfunction mergeGlyphMeshes(\n  group: LaidOutGroup,\n  dx: number,\n  dy: number,\n  meshFor: (glyph: LaidOutOutlineGlyph) => Mesh | null,\n): Mesh | null {\n  const parts: { mesh: Mesh; glyph: LaidOutOutlineGlyph }[] = [];\n  let vertexFloats = 0;\n  let indexCount = 0;\n  for (const glyph of group.glyphs) {\n    const mesh = meshFor(glyph);\n    if (!mesh || mesh.indices.length === 0) continue;\n    parts.push({ mesh, glyph });\n    vertexFloats += mesh.vertices.length;\n    indexCount += mesh.indices.length;\n  }\n  if (parts.length === 0) return null;\n\n  // Matches the SDF vertex shader's skew exactly: x moves by\n  // `(baselineY - y) * tan(angle)`, and in em space `baselineY - y` is\n  // `-ey * scale`, so above-baseline vertices (negative ey) lean right.\n  const shear = shearOf(group);\n\n  const vertices = new Float32Array(vertexFloats);\n  const indices = new Uint32Array(indexCount);\n  let vi = 0;\n  let ii = 0;\n  let base = 0;\n  for (const { mesh, glyph } of parts) {\n    const { x, baselineY, scale } = glyph;\n    for (let k = 0; k < mesh.vertices.length; k += 2) {\n      const ex = mesh.vertices[k];\n      const ey = mesh.vertices[k + 1];\n      vertices[vi++] = x + dx + (ex - ey * shear) * scale;\n      vertices[vi++] = baselineY + dy + ey * scale;\n    }\n    for (let k = 0; k < mesh.indices.length; k++) indices[ii++] = base + mesh.indices[k];\n    base += mesh.vertices.length / 2;\n  }\n  return { vertices, indices };\n}\n"],"mappings":";;;;;;AAuBA,SAAgBA,EAAiB,GAAqB,GAAY,GAAyB;CACzF,OAAOC,EAAiBC,GAAOC,GAAIC,IAAK,MAAUC,EAAYC,EAAM,KAAKA,EAAM,CAAC,CAAC;AACnF;AAsBA,SAAgBC,EACd,GACA,GACA,GACA,GACa;CACb,IAAMC,IAASN,EAAM;CACrB,IAAI,CAACM,GAAQ,OAAO;CACpB,IAAMC,IAAQD,EAAO,SAAS;CAC9B,IAAI,OAAOC,KAAU,UAAU;EAC7B,IAAI,EAAEA,EAAM,KAAK,IAAI,OAAO;EAC5B,IAAMC,IAAQC,EAAQT,CAAK,GACrB,CAACU,GAAGC,GAAGC,GAAGC,KAAK;GAACC,EAAU;GAAIA,EAAU;GAAIA,EAAU;GAAIA,EAAU;EAAE;EAC5E,OAAOf,EAAiBC,GAAOC,GAAIC,IAAK,MAAU;GAChD,IAAI,EAAEE,EAAM,QAAQ,IAAI,OAAO;GAC/B,IAAMW,IAAIX,EAAM,OACVY,IAAQC,EAAcF,IAAIL,GAAGK,IAAIJ,GAAGI,KAAKH,IAAIF,IAAIF,IAAQO,KAAKF,IAAIF,IAAIH,EAAM,GAC5EU,IAAUC,EAAoBZ,EAAM,IAAIS,EAAM,KAAK;GACzD,IAAI,EAAEE,IAAU,IAAI,OAAO;GAC3B,IAAME,IAAOd,EAAO,MAAM,KAAK,MAAMe,IAAIH,CAAO;GAChD,OAAOI,EACLlB,EAAM,KAAKA,EAAM,GAAGG,EAAM,KAAKW,GAAS;IAAE,GAAGZ;IAAQ;GAAK,GAAGU,EAAM,UAAU,KAAA,CAC/E;EACF,CAAC;CACH;CAEA,OADMT,IAAQ,IACPR,EAAiBC,GAAOC,GAAIC,IAAK,MACtCE,EAAM,QAAQ,IACVkB,EACAlB,EAAM,KAAKA,EAAM,GAAGmB,EAAgBhB,IAAQH,EAAM,KAAK,GACvD;EAAE,GAAGE;EAAQ,MAAMA,EAAO,MAAM,KAAK,MAAMe,IAAIjB,EAAM,KAAK;CAAE,CAC9D,IACE,IAAI,IAPe;AAQ3B;AAEA,IAAMK,KAAW,MACfT,EAAM,UAAU,SAAS,KAAK,IAAIwB,CAAwB,IAAI;AAQhE,SAASzB,EACP,GACA,GACA,GACA,GACa;CACb,IAAM0B,IAAsD,CAAC,GACzDC,IAAe,GACfC,IAAa;CACjB,KAAK,IAAMvB,KAASJ,EAAM,QAAQ;EAChC,IAAM4B,IAAOC,EAAQzB,CAAK;EAC1B,AAAKwB,KAAQA,EAAK,QAAQ,WAAW,MACrCH,EAAM,KAAK;GAAE;GAAM;EAAM,CAAC,GAC1B,KAAgBG,EAAK,SAAS,QAC9B,KAAcA,EAAK,QAAQ;CAC7B;CACA,IAAIH,EAAM,WAAW,GAAG,OAAO;CAK/B,IAAMjB,IAAQC,EAAQT,CAAK,GAErB8B,IAAW,IAAI,aAAaJ,CAAY,GACxCK,IAAU,IAAI,YAAYJ,CAAU,GACtCK,IAAK,GACLC,IAAK,GACLC,IAAO;CACX,KAAK,IAAM,EAAE,SAAM,cAAWT,GAAO;EACnC,IAAM,EAAE,MAAG,cAAW,aAAUrB;EAChC,KAAK,IAAI+B,IAAI,GAAGA,IAAIP,EAAK,SAAS,QAAQ,KAAK,GAAG;GAChD,IAAMQ,IAAKR,EAAK,SAASO,IACnBE,IAAKT,EAAK,SAASO,IAAI;GAE7B,AADA,EAAS,OAAQG,IAAIrC,KAAMmC,IAAKC,IAAK7B,KAAS+B,GAC9C,EAAS,OAAQC,IAAYtC,IAAKmC,IAAKE;EACzC;EACA,KAAK,IAAIJ,IAAI,GAAGA,IAAIP,EAAK,QAAQ,QAAQ,KAAK,EAAQ,OAAQM,IAAON,EAAK,QAAQO;EAClF,KAAQP,EAAK,SAAS,SAAS;CACjC;CACA,OAAO;EAAE;EAAU;CAAQ;AAC7B"}

package/dist/renderer/index.js

@@ -1,19 +0,0 @@
-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 };