@weasel-js/core 1.9.2 → 1.9.4

package/dist/renderer/cache/strokeMeshCache.js.map

@@ -1 +1 @@
-{"version":3,"file":"strokeMeshCache.js","names":["STROKE_CONFIGS_PER_PATH","PX_WIDTH_TOLERANCE","quantizeStrokeScale","px","scale","stepsPerOctave","cache","configKey","width","resolveStrokeWidth","stroke","insets","strokeInsets","ribbon","spaces","flattenTolerance","metricKey","strokeMesh","byConfig","path","key","entry","mesh","tessellateStroke","insetIn","head","length"],"sources":["../../../src/renderer/cache/strokeMeshCache.ts"],"sourcesContent":["/**\n * Tessellated stroke ribbons for scene paths, keyed on `Path` identity.\n *\n * The sibling of `cache.ts` (fills) and `outlineStrokeMeshCache.ts` (glyph\n * ribbons in em space), and it inherits their contract: identity, not content.\n * A `Path` rebuilt with equal coords is a distinct entry.\n *\n * Design: `docs/superpowers/specs/2026-08-15-stroke-ribbon-cache-design.md`.\n */\n\nimport type { Path } from '@weasel-js/core';\nimport type { Stroke } from '@weasel-js/paint';\nimport { tessellateStroke, resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { strokeInsets } from '../../core/markerInset';\nimport { metricKey, type ScreenSpace, type StrokeSpaces } from 'features/paths/tessellate/metric';\nimport type { InsetLength } from 'features/paths/tessellate/insets';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\n\n/**\n * Distinct stroke configurations kept per path before that path's map is\n * dropped wholesale. A document uses a handful; a width slider passes this on\n * its first drag and then degrades to tessellating every frame, which is what\n * it did before this cache existed.\n */\nexport const STROKE_CONFIGS_PER_PATH = 8;\n\n/** Screen-pixel bound on how far a quantized `{ px }` ribbon's width may\n *  drift from the width asked for: each edge moves at most half of it. */\nconst PX_WIDTH_TOLERANCE = 1 / 8;\n\n/**\n * `scale` snapped to a log-spaced grid, for resolving a `{ px }` width against.\n * Resolving against the raw scale gives a continuous zoom a new cache key every\n * frame. The grid is fine enough that the resolved ribbon stays within\n * `PX_WIDTH_TOLERANCE` screen pixels of `px`, so it is coarser for thin\n * strokes, and powers of two land on it exactly.\n */\nexport function quantizeStrokeScale(px: number, scale: number): number {\n  if (!(px > 0) || !(scale > 0) || !Number.isFinite(scale)) return scale;\n  const stepsPerOctave = Math.ceil(Math.LN2 / (2 * Math.log1p(PX_WIDTH_TOLERANCE / px)));\n  return 2 ** (Math.round(Math.log2(scale) * stepsPerOctave) / stepsPerOctave);\n}\n\ninterface StrokeEntry {\n  readonly mesh: Mesh;\n  /** Compared by reference — long enough that stringifying it per frame would\n   *  cost what the cache saves. */\n  readonly vertexWidths: number[] | undefined;\n}\n\nlet cache = new WeakMap<Path, Map<string, StrokeEntry>>();\n\n/** The stroke parameters that change the ribbon's geometry. `paint` and\n *  `vertexColors` are absent on purpose: both are applied over the same\n *  triangles at draw time. Marker *identity* is absent too — only the\n *  resolved trim distance affects these triangles, so two heads with the\n *  same inset share one entry. */\nfunction configKey(stroke: Stroke, flattenTolerance: number | undefined, spaces: StrokeSpaces): string {\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  const ribbon = spaces.ribbon?.metric;\n  return [\n    width,\n    stroke.cap ?? 'butt',\n    stroke.join ?? 'miter',\n    stroke.miterLimit ?? '',\n    stroke.align ?? 'center',\n    (stroke.dash ?? []).join(','),\n    stroke.varyingWidthJoinThreshold ?? '',\n    flattenTolerance ?? '',\n    insets.start,\n    insets.end,\n    metricKey(ribbon),\n    metricKey(spaces.start?.metric),\n    metricKey(spaces.end?.metric),\n  ].join('|');\n}\n\n/** The tessellated ribbon for `path` under `stroke`, built in the space\n *  `spaces` names for it, and stopped short of each head in that head's own.\n *  The same `Mesh` object comes back for as long as the entry lives. */\nexport function strokeMesh(\n  path: Path,\n  stroke: Stroke,\n  flattenTolerance: number | undefined,\n  spaces: StrokeSpaces = {},\n): Mesh {\n  let byConfig = cache.get(path);\n  if (byConfig === undefined) {\n    byConfig = new Map<string, StrokeEntry>();\n    cache.set(path, byConfig);\n  }\n\n  const key = configKey(stroke, flattenTolerance, spaces);\n  const entry = byConfig.get(key);\n  if (entry !== undefined && entry.vertexWidths === stroke.vertexWidths) {\n    return entry.mesh;\n  }\n\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  const mesh = tessellateStroke(path, stroke, {\n    flattenTolerance,\n    startInset: insetIn(insets.start, spaces.start, spaces.ribbon),\n    endInset: insetIn(insets.end, spaces.end, spaces.ribbon),\n    metric: spaces.ribbon?.metric,\n  });\n  // Only a new key grows the map; replacing one under a churning\n  // `vertexWidths` must not evict the other configurations alongside it.\n  if (entry === undefined && byConfig.size >= STROKE_CONFIGS_PER_PATH) byConfig.clear();\n  byConfig.set(key, { mesh, vertexWidths: stroke.vertexWidths });\n  return mesh;\n}\n\n/** `length`, measured in `head`'s space, as the tessellator reads it. */\nfunction insetIn(length: number, head: ScreenSpace | undefined, ribbon: ScreenSpace | undefined): InsetLength {\n  return head?.metric === ribbon?.metric ? length : { length, metric: head?.metric ?? null };\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetStrokeMeshCacheForTests(): void {\n  cache = new WeakMap();\n}\n"],"mappings":";;;;AAwBA,IAAaA,IAA0B,GAIjCC,IAAqB,IAAI;AAS/B,SAAgBC,EAAoB,GAAY,GAAuB;CACrE,IAAI,EAAEC,IAAK,MAAM,EAAEC,IAAQ,MAAM,CAAC,OAAO,SAASA,CAAK,GAAG,OAAOA;CACjE,IAAMC,IAAiB,KAAK,KAAK,KAAK,OAAO,IAAI,KAAK,MAAMJ,IAAqBE,CAAE,EAAE;CACrF,OAAO,MAAM,KAAK,MAAM,KAAK,KAAKC,CAAK,IAAIC,CAAc,IAAIA;AAC/D;AASA,IAAIC,oBAAQ,IAAI,QAAwC;AAOxD,SAASC,EAAU,GAAgB,GAAsC,GAA8B;CACrG,IAAMC,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK,GACnCK,IAASC,EAAO,QAAQ;CAC9B,OAAO;EACLN;EACAE,EAAO,OAAO;EACdA,EAAO,QAAQ;EACfA,EAAO,cAAc;EACrBA,EAAO,SAAS;GACfA,EAAO,QAAQ,CAAC,EAAA,CAAG,KAAK,GAAG;EAC5BA,EAAO,6BAA6B;EACpCK,KAAoB;EACpBJ,EAAO;EACPA,EAAO;EACPK,EAAUH,CAAM;EAChBG,EAAUF,EAAO,OAAO,MAAM;EAC9BE,EAAUF,EAAO,KAAK,MAAM;CAC9B,CAAC,CAAC,KAAK,GAAG;AACZ;AAKA,SAAgBG,EACd,GACA,GACA,GACA,IAAuB,CAAC,GAClB;CACN,IAAIC,IAAWZ,EAAM,IAAIa,CAAI;CAC7B,AAAID,MAAa,KAAA,MACf,oBAAW,IAAI,IAAyB,GACxCZ,EAAM,IAAIa,GAAMD,CAAQ;CAG1B,IAAME,IAAMb,EAAUG,GAAQK,GAAkBD,CAAM,GAChDO,IAAQH,EAAS,IAAIE,CAAG;CAC9B,IAAIC,MAAU,KAAA,KAAaA,EAAM,iBAAiBX,EAAO,cACvD,OAAOW,EAAM;CAGf,IAAMb,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK,GACnCc,IAAOC,EAAiBJ,GAAMT,GAAQ;EAC1C;EACA,YAAYc,EAAQb,EAAO,OAAOG,EAAO,OAAOA,EAAO,MAAM;EAC7D,UAAUU,EAAQb,EAAO,KAAKG,EAAO,KAAKA,EAAO,MAAM;EACvD,QAAQA,EAAO,QAAQ;CACzB,CAAC;CAKD,OAFIO,MAAU,KAAA,KAAaH,EAAS,QAAQlB,KAAyBkB,EAAS,MAAM,GACpFA,EAAS,IAAIE,GAAK;EAAE;EAAM,cAAcV,EAAO;CAAa,CAAC,GACtDY;AACT;AAGA,SAASE,EAAQ,GAAgB,GAA+B,GAA8C;CAC5G,OAAOC,GAAM,WAAWZ,GAAQ,SAASa,IAAS;EAAE;EAAQ,QAAQD,GAAM,UAAU;CAAK;AAC3F"}
+{"version":3,"file":"strokeMeshCache.js","names":["STROKE_CONFIGS_PER_PATH","PX_WIDTH_TOLERANCE","quantizeStrokeScale","px","scale","stepsPerOctave","cache","configKey","width","resolveStrokeWidth","stroke","insets","strokeInsets","ribbon","spaces","flattenTolerance","metricKey","strokeMesh","byConfig","path","key","entry","mesh","tessellateStroke","insetIn","head","length"],"sources":["../../../src/renderer/cache/strokeMeshCache.ts"],"sourcesContent":["/**\n * Tessellated stroke ribbons for scene paths, keyed on `Path` identity.\n *\n * The sibling of `cache.ts` (fills) and `outlineStrokeMeshCache.ts` (glyph\n * ribbons in em space), and it inherits their contract: identity, not content.\n * A `Path` rebuilt with equal coords is a distinct entry.\n *\n * Design: `docs/superpowers/specs/2026-08-15-stroke-ribbon-cache-design.md`.\n */\n\nimport type { Path } from '@weasel-js/geom';\nimport type { Stroke } from '@weasel-js/paint';\nimport { tessellateStroke, resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { strokeInsets } from '../../core/markerInset';\nimport { metricKey, type ScreenSpace, type StrokeSpaces } from 'features/paths/tessellate/metric';\nimport type { InsetLength } from 'features/paths/tessellate/insets';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\n\n/**\n * Distinct stroke configurations kept per path before that path's map is\n * dropped wholesale. A document uses a handful; a width slider passes this on\n * its first drag and then degrades to tessellating every frame, which is what\n * it did before this cache existed.\n */\nexport const STROKE_CONFIGS_PER_PATH = 8;\n\n/** Screen-pixel bound on how far a quantized `{ px }` ribbon's width may\n *  drift from the width asked for: each edge moves at most half of it. */\nconst PX_WIDTH_TOLERANCE = 1 / 8;\n\n/**\n * `scale` snapped to a log-spaced grid, for resolving a `{ px }` width against.\n * Resolving against the raw scale gives a continuous zoom a new cache key every\n * frame. The grid is fine enough that the resolved ribbon stays within\n * `PX_WIDTH_TOLERANCE` screen pixels of `px`, so it is coarser for thin\n * strokes, and powers of two land on it exactly.\n */\nexport function quantizeStrokeScale(px: number, scale: number): number {\n  if (!(px > 0) || !(scale > 0) || !Number.isFinite(scale)) return scale;\n  const stepsPerOctave = Math.ceil(Math.LN2 / (2 * Math.log1p(PX_WIDTH_TOLERANCE / px)));\n  return 2 ** (Math.round(Math.log2(scale) * stepsPerOctave) / stepsPerOctave);\n}\n\ninterface StrokeEntry {\n  readonly mesh: Mesh;\n  /** Compared by reference — long enough that stringifying it per frame would\n   *  cost what the cache saves. */\n  readonly vertexWidths: number[] | undefined;\n}\n\nlet cache = new WeakMap<Path, Map<string, StrokeEntry>>();\n\n/** The stroke parameters that change the ribbon's geometry. `paint` and\n *  `vertexColors` are absent on purpose: both are applied over the same\n *  triangles at draw time. Marker *identity* is absent too — only the\n *  resolved trim distance affects these triangles, so two heads with the\n *  same inset share one entry. */\nfunction configKey(stroke: Stroke, flattenTolerance: number | undefined, spaces: StrokeSpaces): string {\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  const ribbon = spaces.ribbon?.metric;\n  return [\n    width,\n    stroke.cap ?? 'butt',\n    stroke.join ?? 'miter',\n    stroke.miterLimit ?? '',\n    stroke.align ?? 'center',\n    (stroke.dash ?? []).join(','),\n    stroke.varyingWidthJoinThreshold ?? '',\n    flattenTolerance ?? '',\n    insets.start,\n    insets.end,\n    metricKey(ribbon),\n    metricKey(spaces.start?.metric),\n    metricKey(spaces.end?.metric),\n  ].join('|');\n}\n\n/** The tessellated ribbon for `path` under `stroke`, built in the space\n *  `spaces` names for it, and stopped short of each head in that head's own.\n *  The same `Mesh` object comes back for as long as the entry lives. */\nexport function strokeMesh(\n  path: Path,\n  stroke: Stroke,\n  flattenTolerance: number | undefined,\n  spaces: StrokeSpaces = {},\n): Mesh {\n  let byConfig = cache.get(path);\n  if (byConfig === undefined) {\n    byConfig = new Map<string, StrokeEntry>();\n    cache.set(path, byConfig);\n  }\n\n  const key = configKey(stroke, flattenTolerance, spaces);\n  const entry = byConfig.get(key);\n  if (entry !== undefined && entry.vertexWidths === stroke.vertexWidths) {\n    return entry.mesh;\n  }\n\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const insets = strokeInsets(stroke, width);\n  const mesh = tessellateStroke(path, stroke, {\n    flattenTolerance,\n    startInset: insetIn(insets.start, spaces.start, spaces.ribbon),\n    endInset: insetIn(insets.end, spaces.end, spaces.ribbon),\n    metric: spaces.ribbon?.metric,\n  });\n  // Only a new key grows the map; replacing one under a churning\n  // `vertexWidths` must not evict the other configurations alongside it.\n  if (entry === undefined && byConfig.size >= STROKE_CONFIGS_PER_PATH) byConfig.clear();\n  byConfig.set(key, { mesh, vertexWidths: stroke.vertexWidths });\n  return mesh;\n}\n\n/** `length`, measured in `head`'s space, as the tessellator reads it. */\nfunction insetIn(length: number, head: ScreenSpace | undefined, ribbon: ScreenSpace | undefined): InsetLength {\n  return head?.metric === ribbon?.metric ? length : { length, metric: head?.metric ?? null };\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetStrokeMeshCacheForTests(): void {\n  cache = new WeakMap();\n}\n"],"mappings":";;;;AAwBA,IAAaA,IAA0B,GAIjCC,IAAqB,IAAI;AAS/B,SAAgBC,EAAoB,GAAY,GAAuB;CACrE,IAAI,EAAEC,IAAK,MAAM,EAAEC,IAAQ,MAAM,CAAC,OAAO,SAASA,CAAK,GAAG,OAAOA;CACjE,IAAMC,IAAiB,KAAK,KAAK,KAAK,OAAO,IAAI,KAAK,MAAMJ,IAAqBE,CAAE,EAAE;CACrF,OAAO,MAAM,KAAK,MAAM,KAAK,KAAKC,CAAK,IAAIC,CAAc,IAAIA;AAC/D;AASA,IAAIC,oBAAQ,IAAI,QAAwC;AAOxD,SAASC,EAAU,GAAgB,GAAsC,GAA8B;CACrG,IAAMC,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK,GACnCK,IAASC,EAAO,QAAQ;CAC9B,OAAO;EACLN;EACAE,EAAO,OAAO;EACdA,EAAO,QAAQ;EACfA,EAAO,cAAc;EACrBA,EAAO,SAAS;GACfA,EAAO,QAAQ,CAAC,EAAA,CAAG,KAAK,GAAG;EAC5BA,EAAO,6BAA6B;EACpCK,KAAoB;EACpBJ,EAAO;EACPA,EAAO;EACPK,EAAUH,CAAM;EAChBG,EAAUF,EAAO,OAAO,MAAM;EAC9BE,EAAUF,EAAO,KAAK,MAAM;CAC9B,CAAC,CAAC,KAAK,GAAG;AACZ;AAKA,SAAgBG,EACd,GACA,GACA,GACA,IAAuB,CAAC,GAClB;CACN,IAAIC,IAAWZ,EAAM,IAAIa,CAAI;CAC7B,AAAID,MAAa,KAAA,MACf,oBAAW,IAAI,IAAyB,GACxCZ,EAAM,IAAIa,GAAMD,CAAQ;CAG1B,IAAME,IAAMb,EAAUG,GAAQK,GAAkBD,CAAM,GAChDO,IAAQH,EAAS,IAAIE,CAAG;CAC9B,IAAIC,MAAU,KAAA,KAAaA,EAAM,iBAAiBX,EAAO,cACvD,OAAOW,EAAM;CAGf,IAAMb,IAAQC,EAAmBC,EAAO,SAAS,GAAG,CAAC,GAC/CC,IAASC,EAAaF,GAAQF,CAAK,GACnCc,IAAOC,EAAiBJ,GAAMT,GAAQ;EAC1C;EACA,YAAYc,EAAQb,EAAO,OAAOG,EAAO,OAAOA,EAAO,MAAM;EAC7D,UAAUU,EAAQb,EAAO,KAAKG,EAAO,KAAKA,EAAO,MAAM;EACvD,QAAQA,EAAO,QAAQ;CACzB,CAAC;CAKD,OAFIO,MAAU,KAAA,KAAaH,EAAS,QAAQlB,KAAyBkB,EAAS,MAAM,GACpFA,EAAS,IAAIE,GAAK;EAAE;EAAM,cAAcV,EAAO;CAAa,CAAC,GACtDY;AACT;AAGA,SAASE,EAAQ,GAAgB,GAA+B,GAA8C;CAC5G,OAAOC,GAAM,WAAWZ,GAAQ,SAASa,IAAS;EAAE;EAAQ,QAAQD,GAAM,UAAU;CAAK;AAC3F"}

package/dist/renderer/cullDrawCommands.js

@@ -1,7 +1,7 @@
 import { mat3 as e } from "./math/mat3.js";
-import { SPRITE_STRIDE as t } from "./DrawCommand.js";
-import { resolveStrokeWidth as n } from "../features/paths/tessellate/stroke.js";
-import { markerReach as r } from "../features/paths/markerCommands.js";
+import { resolveStrokeWidth as t } from "../features/paths/tessellate/stroke.js";
+import { markerReach as n } from "../features/paths/markerCommands.js";
+import { SPRITE_STRIDE as r } from "./DrawCommand.js";
 import { resolveScreenLength as i } from "@weasel-js/paint";
 //#region src/renderer/cullDrawCommands.ts
 var a = 1, o = 4;
@@ -54,19 +54,19 @@ function u(e, t, n, r) {
 function d(t, n) {
 	return f(t, e.meanScaleOf(n), e.minScaleOf(n));
 }
-function f(e, t, a = t) {
-	let s = a > 0 ? a : t, c = n(e.width ?? 1, typeof e.width == "object" ? s : t);
+function f(e, r, a = r) {
+	let s = a > 0 ? a : r, c = t(e.width ?? 1, typeof e.width == "object" ? s : r);
 	if (e.vertexWidths) for (let t of e.vertexWidths) t > c && (c = t);
-	let l = Math.max(e.miterLimit ?? o, Math.SQRT2), u = r(e);
+	let l = Math.max(e.miterLimit ?? o, Math.SQRT2), u = n(e);
 	return Math.max(Math.abs(c) * l, u.world, i({ px: u.px }, s));
 }
-function p(e, n, r) {
+function p(e, t, n) {
 	let i = Infinity, a = Infinity, o = -Infinity, s = -Infinity;
-	for (let n = 0; n + t <= e.length; n += t) {
-		let t = e[n], r = e[n + 1], c = t + e[n + 2], l = r + e[n + 3];
-		i = Math.min(i, t, c), o = Math.max(o, t, c), a = Math.min(a, r, l), s = Math.max(s, r, l);
+	for (let t = 0; t + r <= e.length; t += r) {
+		let n = e[t], r = e[t + 1], c = n + e[t + 2], l = r + e[t + 3];
+		i = Math.min(i, n, c), o = Math.max(o, n, c), a = Math.min(a, r, l), s = Math.max(s, r, l);
 	}
-	return i !== Infinity && g(i, a, o, s, n, r);
+	return i !== Infinity && g(i, a, o, s, t, n);
 }
 function m(e, t, n) {
 	let r = Math.min(e.x, e.x + e.width), i = Math.max(e.x, e.x + e.width);

package/dist/renderer/draw/batch.js

@@ -0,0 +1,133 @@
+import { BATCH_TEXTURE_SLOTS as e } from "../shaders/batchFill.js";
+import { resolveColor as t } from "../math/color.js";
+import { IDENTITY_COLOR_MATRIX as n } from "../state/GroupState.js";
+import { sameValues as r } from "./uniforms.js";
+import { flushBatch as i } from "./flushBatch.js";
+import { flushForOwnDraw as a, retryUncut as o, runClipDepth as s } from "./clip.js";
+import { rampVertices as c } from "./gradient.js";
+//#region src/renderer/draw/batch.ts
+function l(e) {
+	return e === n || r(n, e);
+}
+function u(e, t, n, i, a = 0) {
+	if (t.clipDepth !== (e.clipStack.length === 0 ? e.clipDepth : s(e)) || t.synthBold !== a || !t.foldsAlpha && t.alpha !== e.state.alpha || n !== void 0 && d(t, n, i) < 0) return !1;
+	let o = e.state.colorMatrix;
+	return t.colorMatrix === o || r(t.colorMatrix, o);
+}
+function d(e, t, n) {
+	for (let r = 0; r < e.textures.length; r++) {
+		let i = e.textures[r];
+		if (i.kind === "bitmap" && i.image === t) return i.sampling === n ? r + 1 : -1;
+	}
+	return m(e);
+}
+function f(e) {
+	for (let t = 0; t < e.textures.length; t++) if (e.textures[t].kind === "ramps") return t + 1;
+	return m(e);
+}
+function p(e, t) {
+	for (let n = 0; n < e.textures.length; n++) {
+		let r = e.textures[n];
+		if (r.kind === "atlas" && r.id === t) return n + 1;
+	}
+	return m(e);
+}
+function m(t) {
+	return t.textures.length + 1 < e ? t.textures.length + 1 : -1;
+}
+var h = {
+	maxVertices: 96,
+	maxVerticesInRun: 1024
+};
+function g(e, t) {
+	if (t.requiresStencil) return !1;
+	let n = e.drawBatch.length > 0 ? h.maxVerticesInRun : h.maxVertices;
+	return t.vertices.length >> 1 <= n;
+}
+function _(e, t) {
+	return e.batchState !== void 0 && !u(e, e.batchState) && i(e), e.drawBatch.wouldOverflow(t) && i(e), v(e);
+}
+function v(e) {
+	if (e.batchState === void 0) {
+		let t = e.state.colorMatrix, n = l(t);
+		e.batchState = {
+			alpha: n ? 1 : e.state.alpha,
+			colorMatrix: t,
+			clipDepth: s(e),
+			synthBold: 0,
+			foldsAlpha: n,
+			textures: []
+		};
+	}
+	return e.batchState;
+}
+function y(e, t, n) {
+	e.batchState !== void 0 && !u(e, e.batchState, t, n) && i(e), e.drawBatch.wouldOverflow(4) && i(e);
+	let r = v(e), a = d(r, t, n);
+	return a > r.textures.length && (r.textures.push({
+		kind: "bitmap",
+		image: t,
+		sampling: n
+	}), a = r.textures.length), {
+		staged: r,
+		slot: a
+	};
+}
+function b(e, t, n, r) {
+	e.batchState !== void 0 && (!u(e, e.batchState, void 0, void 0, r) || p(e.batchState, t) < 0) && i(e), e.drawBatch.wouldOverflow(4) && i(e);
+	let a = v(e);
+	a.synthBold = r;
+	let o = p(a, t);
+	return o > a.textures.length && (a.textures.push({
+		kind: "atlas",
+		id: t,
+		fieldScale: n
+	}), o = a.textures.length), {
+		staged: a,
+		slot: o
+	};
+}
+function x(e, t, n, r) {
+	e.gradRamps.wouldReshape(t, n) && i(e), e.batchState !== void 0 && (!u(e, e.batchState) || f(e.batchState) < 0) && i(e), e.drawBatch.wouldOverflow(r) && i(e);
+	let a = v(e), o = f(a);
+	return o > a.textures.length && (a.textures.push({ kind: "ramps" }), o = a.textures.length), {
+		staged: a,
+		slot: o,
+		rowV: e.gradRamps.rowV(e.gradRamps.upload(t, n))
+	};
+}
+function S(e, t, n) {
+	return (n ?? 1) * (t.foldsAlpha ? e.state.alpha : 1);
+}
+function C(e, n, r) {
+	let [i, a, o, s] = t(r.color);
+	return [
+		i,
+		a,
+		o,
+		s * S(e, n, r.opacity)
+	];
+}
+function w(e, t, n) {
+	let [r, i, a, s] = C(e, _(e, 4), n);
+	e.drawBatch.pushRect(t.x, t.y, t.width, t.height, e.state.transform, r, i, a, s) || o(e, t, n, w);
+}
+function T(e, t, n) {
+	let [r, i, a, s] = C(e, _(e, t.vertices.length >> 1), n);
+	e.drawBatch.pushMesh(t, e.state.transform, r, i, a, s) || o(e, t, n, T);
+}
+function E(e, t, n) {
+	let { staged: r, slot: i, rowV: a } = x(e, n.stops, n.space, 4), { uv: s, post: l } = c(n, a);
+	e.drawBatch.pushGradientRect(t.x, t.y, t.width, t.height, e.state.transform, s, l, i, n.mode, 1, 1, 1, S(e, r, n.opacity)) || o(e, t, n, E);
+}
+function D(e, t, n) {
+	let { staged: r, slot: i, rowV: a } = x(e, n.stops, n.space, t.vertices.length >> 1), { uv: s, post: l } = c(n, a);
+	e.drawBatch.pushGradientMesh(t, e.state.transform, s, l, i, n.mode, 1, 1, 1, S(e, r, n.opacity)) || o(e, t, n, D);
+}
+function O(e, t, n) {
+	return n !== void 0 && g(e, t) ? (n.kind === "ramp" ? D(e, t, n) : T(e, t, n), !0) : (a(e), !1);
+}
+//#endregion
+export { h as meshBatching, E as pushRampRect, w as pushRect, b as stageGlyphs, y as stageImage, _ as stageSolid, O as tryStageFill };
+
+//# sourceMappingURL=batch.js.map

package/dist/renderer/draw/batch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.js","names":["isIdentityColorMatrix","cm","IDENTITY_COLOR_MATRIX","sameValues","stagedStateIsLive","staged","ctx","runClipDepth","synthBold","image","slotForBitmap","sampling","colorMatrix","i","entry","nextFreeSlot","slotForRamps","slotForAtlas","id","BATCH_TEXTURE_SLOTS","meshBatching","canBatchMesh","mesh","cap","stageSolid","flushBatch","vertices","openRun","foldsAlpha","stageImage","slot","stageGlyphs","atlasId","stageRamps","stops","space","stagedAlpha","opacity","stagedColor","r","g","b","a","resolveColor","paint","pushRect","fill","rect","retryUncut","pushMesh","pushRampRect","rampVertices","rowV","uv","post","pushRampMesh","tryStageFill","flushForOwnDraw"],"sources":["../../../src/renderer/draw/batch.ts"],"sourcesContent":["import type { ColorSpace, GradStop } from '@weasel-js/paint';\nimport { IDENTITY_COLOR_MATRIX } from '../state/GroupState';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport { resolveColor } from '../math/color';\nimport { BATCH_TEXTURE_SLOTS } from '../shaders/batchFill';\nimport type { DrawContext } from './drawContext';\nimport { sameValues } from './uniforms';\nimport { runClipDepth, retryUncut, flushForOwnDraw } from './clip';\nimport { flushBatch } from './flushBatch';\nimport { type BatchPaint, rampVertices } from './gradient';\n\n/**\n * The group state a staged run was built under.\n *\n * A run outlives the group it started in, so the state live when the flush\n * happens is not the state the rects belong to — the flush draws with these\n * values instead. Transform is absent because it rides the vertices; `alpha`\n * is 1 whenever it rode them too.\n */\nexport interface StagedBatchState {\n  alpha: number;\n  colorMatrix: Float32Array;\n  clipDepth: number;\n  /**\n   * The SDF threshold shift `u_synthBold` draws this run under.\n   *\n   * A uniform rather than a vertex attribute, and so a thing that breaks a run.\n   * A per-vertex float costs every rect and quad in the run (see \"Mode and slot\n   * share one attribute\" in `shaders/batchFill.ts`): the batch's whole point is\n   * one cheap buffer write a frame, and a float only glyphs read still widens the write\n   * for every rect and quad beside them. What it costs instead is a break\n   * wherever faked-bold text meets text that is not, which is a fallback path:\n   * a registered bold face never sets this at all.\n   */\n  synthBold: number;\n  /** Whether group alpha folded into the vertex colors. */\n  foldsAlpha: boolean;\n  /**\n   * The textures this run samples, in the order they joined. A quad's vertices\n   * carry `index + 1`, because slot 0 is the white texel every solid samples.\n   *\n   * Two kinds, because two caches own them: an image quad names an\n   * `ImageBitmap` that `GLImageCache` keys by identity, a glyph names the\n   * string id of a font atlas in `GLTextureCache`. They share the slot list so\n   * a caption and the thumbnail above it share a draw.\n   *\n   * A bitmap's `sampling` is per entry and set per flush rather than at upload:\n   * MAG_FILTER is state on the texture object, so the same bitmap drawn at both\n   * filters in one frame needs two flushes, not two slots. An atlas carries no\n   * sampling because `GLTextureCache` owns its filtering — and must keep\n   * owning it: filtering a distance field destroys it, so a font atlas is\n   * never mipmapped and never joins a shared image atlas.\n   */\n  textures: BatchTexture[];\n}\n\n/** One entry in a run's slot list. */\ntype BatchTexture =\n  | { kind: 'bitmap'; image: ImageBitmap; sampling: 'linear' | 'nearest' }\n  | { kind: 'atlas'; id: string; fieldScale: readonly [number, number] }\n  | { kind: 'ramps' };\n\n/** Identity in row-major 4×5 leaves `src` untouched *and* leaves the shader's\n *  clamp with nothing to do, which is what makes the alpha fold exact. */\nfunction isIdentityColorMatrix(cm: Float32Array): boolean {\n  return cm === IDENTITY_COLOR_MATRIX || sameValues(IDENTITY_COLOR_MATRIX, cm);\n}\n\n/**\n * Whether the live group state would draw the staged run identically.\n *\n * By value, not by reference: a group carrying an identity color matrix still\n * goes through `compose4x5`, which allocates a new array holding equal numbers.\n * Twenty float compares are nothing against the draw call they save.\n */\nfunction stagedStateIsLive(\n  ctx: DrawContext, staged: StagedBatchState,\n  image?: ImageBitmap, sampling?: 'linear' | 'nearest',\n  synthBold = 0,\n): boolean {\n  if (staged.clipDepth !== (ctx.clipStack.length === 0 ? ctx.clipDepth : runClipDepth(ctx))) return false;\n  // Solids and image quads ask with 0, which is what a run of them carries, so\n  // this only ever breaks between two kinds of glyph.\n  if (staged.synthBold !== synthBold) return false;\n  if (!staged.foldsAlpha && staged.alpha !== ctx.state.alpha) return false;\n  if (image !== undefined && slotForBitmap(staged, image, sampling!) < 0) return false;\n  const colorMatrix = ctx.state.colorMatrix;\n  return staged.colorMatrix === colorMatrix || sameValues(staged.colorMatrix, colorMatrix);\n}\n\n/**\n * The slot `image` would sample from in this run, or -1 if it cannot join.\n *\n * A bitmap already in the run reuses its slot — but only at the filter it went\n * in under, since MAG_FILTER belongs to the texture object and one draw cannot\n * have it both ways. Otherwise it takes the next free slot, and a run with none\n * left is a run this quad has to break.\n */\nfunction slotForBitmap(\n  staged: StagedBatchState, image: ImageBitmap, sampling: 'linear' | 'nearest',\n): number {\n  for (let i = 0; i < staged.textures.length; i++) {\n    const entry = staged.textures[i];\n    if (entry.kind !== 'bitmap' || entry.image !== image) continue;\n    return entry.sampling === sampling ? i + 1 : -1;\n  }\n  return nextFreeSlot(staged);\n}\n\n/** The same for the ramp atlas, of which there is one — so every gradient in a\n *  run shares the slot, however many distinct ramps they are. */\nfunction slotForRamps(staged: StagedBatchState): number {\n  for (let i = 0; i < staged.textures.length; i++) {\n    if (staged.textures[i].kind === 'ramps') return i + 1;\n  }\n  return nextFreeSlot(staged);\n}\n\n/** The same for a font atlas, which has no filter to disagree about. */\nfunction slotForAtlas(staged: StagedBatchState, id: string): number {\n  for (let i = 0; i < staged.textures.length; i++) {\n    const entry = staged.textures[i];\n    if (entry.kind === 'atlas' && entry.id === id) return i + 1;\n  }\n  return nextFreeSlot(staged);\n}\n\n/** The slot a texture new to this run would take, or -1 if it is full. */\nfunction nextFreeSlot(staged: StagedBatchState): number {\n  return staged.textures.length + 1 < BATCH_TEXTURE_SLOTS ? staged.textures.length + 1 : -1;\n}\n\n/**\n * Vertices above which a mesh keeps its own draw, by whether a run is open.\n *\n * Batching trades a draw call for copying and re-uploading the mesh every\n * frame, where a mesh already in the persistent cache costs nothing per frame\n * beyond the draw. Drawn alone with a run open, a mesh also closes that run and\n * switches program twice, so it breaks even far later there. Both values sit\n * below what `tests/perf/mesh-batch.spec.ts` measured, recorded in\n * `docs/TODO.md`: being wrong on the open-run side costs ten times more.\n */\nconst MAX_BATCHED_MESH_VERTICES = 96;\n\nconst MAX_BATCHED_MESH_VERTICES_IN_RUN = 1024;\n\n/** The caps {@link canBatchMesh} reads. Mutable only so `mesh-batch.spec.ts`\n *  can time both sides of them in one page; the barrel does not export it. */\nexport const meshBatching = {\n  maxVertices: MAX_BATCHED_MESH_VERTICES,\n  maxVerticesInRun: MAX_BATCHED_MESH_VERTICES_IN_RUN,\n};\n\n/** Whether a mesh can join a run. Stencil fills need their own two-pass dance,\n *  and a mesh past the cap is cheaper as its own draw. */\nfunction canBatchMesh(ctx: DrawContext, mesh: Mesh): boolean {\n  if (mesh.requiresStencil) return false;\n  const cap = ctx.drawBatch.length > 0 ? meshBatching.maxVerticesInRun : meshBatching.maxVertices;\n  return (mesh.vertices.length >> 1) <= cap;\n}\n\n/**\n * Open or continue a run for `vertices` more, flushing first if the run would\n * overflow or if the live group state no longer matches what it was staged\n * under. Returns the staged state, which the caller reads to resolve alpha.\n *\n * Fill opacity folds into the vertex alpha, exactly as `u_color` carried it\n * when each shape was its own draw. Group alpha folds in too, but only under an\n * identity color matrix: the shader is `a = clamp(CM * src + bias).a * u_alpha`,\n * so with a real matrix between them a pre-multiplied vertex alpha is a\n * different number. There it stays a uniform, and a differing alpha breaks the\n * run as before.\n */\nexport function stageSolid(ctx: DrawContext, vertices: number): StagedBatchState {\n  if (ctx.batchState !== undefined && !stagedStateIsLive(ctx, ctx.batchState)) flushBatch(ctx);\n  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);\n  return openRun(ctx);\n}\n\n/** The staged state, opening a run under the live group state if none is. */\nfunction openRun(ctx: DrawContext): StagedBatchState {\n  if (ctx.batchState === undefined) {\n    const colorMatrix = ctx.state.colorMatrix;\n    const foldsAlpha = isIdentityColorMatrix(colorMatrix);\n    ctx.batchState = {\n      alpha: foldsAlpha ? 1 : ctx.state.alpha,\n      colorMatrix,\n      clipDepth: runClipDepth(ctx),\n      synthBold: 0,\n      foldsAlpha,\n      textures: [],\n    };\n  }\n  return ctx.batchState;\n}\n\n/**\n * Open or continue a run for one more image quad, flushing first if the run\n * would overflow or cannot give this bitmap a slot.\n *\n * A run adopts a bitmap it has not seen rather than breaking, which is what\n * lets a wall's ground rect and its atlas quad share a draw, and what lets a\n * cell's art and its badge share one too. Returns the staged state and the slot\n * the quad's vertices must carry.\n */\nexport function stageImage(\n  ctx: DrawContext, image: ImageBitmap, sampling: 'linear' | 'nearest',\n): { staged: StagedBatchState; slot: number } {\n  if (ctx.batchState !== undefined\n      && !stagedStateIsLive(ctx, ctx.batchState, image, sampling)) {\n    flushBatch(ctx);\n  }\n  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);\n  const staged = openRun(ctx);\n  let slot = slotForBitmap(staged, image, sampling);\n  if (slot > staged.textures.length) {\n    staged.textures.push({ kind: 'bitmap', image, sampling });\n    slot = staged.textures.length;\n  }\n  return { staged, slot };\n}\n\n/**\n * Open or continue a run for a glyph off the font atlas `atlasId`, flushing\n * first if the run would overflow or has no slot left for it.\n *\n * The atlas is the unit of coalescing the way a sprite sheet is: every glyph a\n * face contributes to a frame shares one texture, so a paragraph is one run\n * however many glyphs it is, and a second face costs one more slot rather than\n * a flush per word.\n */\nexport function stageGlyphs(\n  ctx: DrawContext, atlasId: string, fieldScale: readonly [number, number], synthBold: number,\n): { staged: StagedBatchState; slot: number } {\n  if (ctx.batchState !== undefined\n      && (!stagedStateIsLive(ctx, ctx.batchState, undefined, undefined, synthBold)\n          || slotForAtlas(ctx.batchState, atlasId) < 0)) {\n    flushBatch(ctx);\n  }\n  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);\n  const staged = openRun(ctx);\n  // An empty run adopts the threshold; one that already has vertices agreed to\n  // it above, since a mismatch flushed.\n  staged.synthBold = synthBold;\n  let slot = slotForAtlas(staged, atlasId);\n  if (slot > staged.textures.length) {\n    staged.textures.push({ kind: 'atlas', id: atlasId, fieldScale });\n    slot = staged.textures.length;\n  }\n  return { staged, slot };\n}\n\n/**\n * Open or continue a run for geometry filled from the ramp atlas, flushing\n * first if the run would overflow, has no slot left, or if baking `stops` would\n * move the rows already staged.\n *\n * **That last one is the trap.** A staged vertex names its ramp by where the\n * row sits, so growing the atlas — which changes every row's `v` — or recycling\n * a row repaints geometry already staged with somebody else's gradient. Both\n * are irreversible once done, so the question is asked before the bake, not\n * after.\n */\nfunction stageRamps(\n  ctx: DrawContext, stops: GradStop[], space: ColorSpace, vertices: number,\n): { staged: StagedBatchState; slot: number; rowV: number } {\n  if (ctx.gradRamps.wouldReshape(stops, space)) flushBatch(ctx);\n  if (ctx.batchState !== undefined\n      && (!stagedStateIsLive(ctx, ctx.batchState) || slotForRamps(ctx.batchState) < 0)) {\n    flushBatch(ctx);\n  }\n  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);\n  const staged = openRun(ctx);\n  let slot = slotForRamps(staged);\n  if (slot > staged.textures.length) {\n    staged.textures.push({ kind: 'ramps' });\n    slot = staged.textures.length;\n  }\n  return { staged, slot, rowV: ctx.gradRamps.rowV(ctx.gradRamps.upload(stops, space)) };\n}\n\n/** Alpha a batched paint's vertices carry: its own opacity, and the group's\n *  under an identity color matrix. */\nfunction stagedAlpha(\n  ctx: DrawContext, staged: StagedBatchState, opacity: number | undefined,\n): number {\n  return (opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1);\n}\n\n/** Straight-alpha rgba for a solid paint under the staged state. */\nfunction stagedColor(\n  ctx: DrawContext, staged: StagedBatchState,\n  paint: { color: string; opacity?: number },\n): [number, number, number, number] {\n  const [r, g, b, a] = resolveColor(paint.color);\n  return [r, g, b, a * stagedAlpha(ctx, staged, paint.opacity)];\n}\n\nexport function pushRect(\n  ctx: DrawContext,\n  rect: { x: number; y: number; width: number; height: number },\n  fill: { color: string; opacity?: number },\n): void {\n  const staged = stageSolid(ctx, 4);\n  const [r, g, b, a] = stagedColor(ctx, staged, fill);\n  if (!ctx.drawBatch.pushRect(\n    rect.x, rect.y, rect.width, rect.height, ctx.state.transform, r, g, b, a,\n  )) retryUncut(ctx, rect, fill, pushRect);\n}\n\nfunction pushMesh(\n  ctx: DrawContext,\n  mesh: Mesh,\n  paint: { color: string; opacity?: number },\n): void {\n  const staged = stageSolid(ctx, mesh.vertices.length >> 1);\n  const [r, g, b, a] = stagedColor(ctx, staged, paint);\n  if (!ctx.drawBatch.pushMesh(mesh, ctx.state.transform, r, g, b, a)) {\n    retryUncut(ctx, mesh, paint, pushMesh);\n  }\n}\n\nexport function pushRampRect(\n  ctx: DrawContext,\n  rect: { x: number; y: number; width: number; height: number },\n  paint: Extract<BatchPaint, { kind: 'ramp' }>,\n): void {\n  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, paint.space, 4);\n  const { uv, post } = rampVertices(paint, rowV);\n  // White vertices, so the ramp texel passes through as its own color and the\n  // alpha channel carries what `u_opacity` and `u_alpha` used to.\n  if (!ctx.drawBatch.pushGradientRect(\n    rect.x, rect.y, rect.width, rect.height, ctx.state.transform,\n    uv, post, slot, paint.mode, 1, 1, 1, stagedAlpha(ctx, staged, paint.opacity),\n  )) retryUncut(ctx, rect, paint, pushRampRect);\n}\n\nfunction pushRampMesh(\n  ctx: DrawContext, mesh: Mesh, paint: Extract<BatchPaint, { kind: 'ramp' }>,\n): void {\n  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, paint.space, mesh.vertices.length >> 1);\n  const { uv, post } = rampVertices(paint, rowV);\n  if (!ctx.drawBatch.pushGradientMesh(\n    mesh, ctx.state.transform,\n    uv, post, slot, paint.mode, 1, 1, 1, stagedAlpha(ctx, staged, paint.opacity),\n  )) retryUncut(ctx, mesh, paint, pushRampMesh);\n}\n\n/**\n * Stage `mesh` into the run, or drain the run so the caller can draw it itself.\n *\n * `true` means the mesh is in the batch and the caller is done. `false` comes\n * back only *after* a flush, so an emitter cannot earn permission to draw for\n * itself without also draining the batch. `paint` is `undefined` when it is one\n * no run can express — see `batchPaint`.\n */\nexport function tryStageFill(\n  ctx: DrawContext,\n  mesh: Mesh,\n  paint: BatchPaint | undefined,\n): boolean {\n  if (paint !== undefined && canBatchMesh(ctx, mesh)) {\n    if (paint.kind === 'ramp') pushRampMesh(ctx, mesh, paint);\n    else pushMesh(ctx, mesh, paint);\n    return true;\n  }\n  flushForOwnDraw(ctx);\n  return false;\n}\n"],"mappings":";;;;;;;;AAgEA,SAASA,EAAsB,GAA2B;CACxD,OAAOC,MAAOC,KAAyBC,EAAWD,GAAuBD,CAAE;AAC7E;AASA,SAASG,EACP,GAAkB,GAClB,GAAqB,GACrB,IAAY,GACH;CAMT,IALIC,EAAO,eAAeC,EAAI,UAAU,WAAW,IAAIA,EAAI,YAAYC,EAAaD,CAAG,MAGnFD,EAAO,cAAcG,KACrB,CAACH,EAAO,cAAcA,EAAO,UAAUC,EAAI,MAAM,SACjDG,MAAU,KAAA,KAAaC,EAAcL,GAAQI,GAAOE,CAAS,IAAI,GAAG,OAAO;CAC/E,IAAMC,IAAcN,EAAI,MAAM;CAC9B,OAAOD,EAAO,gBAAgBO,KAAeT,EAAWE,EAAO,aAAaO,CAAW;AACzF;AAUA,SAASF,EACP,GAA0B,GAAoB,GACtC;CACR,KAAK,IAAIG,IAAI,GAAGA,IAAIR,EAAO,SAAS,QAAQ,KAAK;EAC/C,IAAMS,IAAQT,EAAO,SAASQ;EAC9B,IAAIC,EAAM,SAAS,YAAYA,EAAM,UAAUL,GAC/C,OAAOK,EAAM,aAAaH,IAAWE,IAAI,IAAI;CAC/C;CACA,OAAOE,EAAaV,CAAM;AAC5B;AAIA,SAASW,EAAa,GAAkC;CACtD,KAAK,IAAIH,IAAI,GAAGA,IAAIR,EAAO,SAAS,QAAQ,KAC1C,IAAIA,EAAO,SAASQ,EAAE,CAAC,SAAS,SAAS,OAAOA,IAAI;CAEtD,OAAOE,EAAaV,CAAM;AAC5B;AAGA,SAASY,EAAa,GAA0B,GAAoB;CAClE,KAAK,IAAIJ,IAAI,GAAGA,IAAIR,EAAO,SAAS,QAAQ,KAAK;EAC/C,IAAMS,IAAQT,EAAO,SAASQ;EAC9B,IAAIC,EAAM,SAAS,WAAWA,EAAM,OAAOI,GAAI,OAAOL,IAAI;CAC5D;CACA,OAAOE,EAAaV,CAAM;AAC5B;AAGA,SAASU,EAAa,GAAkC;CACtD,OAAOV,EAAO,SAAS,SAAS,IAAIc,IAAsBd,EAAO,SAAS,SAAS,IAAI;AACzF;AAkBA,IAAae,IAAe;CAC1B,aAAa;CACb,kBAAkB;AACpB;AAIA,SAASC,EAAa,GAAkB,GAAqB;CAC3D,IAAIC,EAAK,iBAAiB,OAAO;CACjC,IAAMC,IAAMjB,EAAI,UAAU,SAAS,IAAIc,EAAa,mBAAmBA,EAAa;CACpF,OAAQE,EAAK,SAAS,UAAU,KAAMC;AACxC;AAcA,SAAgBC,EAAW,GAAkB,GAAoC;CAG/E,OAFIlB,EAAI,eAAe,KAAA,KAAa,CAACF,EAAkBE,GAAKA,EAAI,UAAU,KAAGmB,EAAWnB,CAAG,GACvFA,EAAI,UAAU,cAAcoB,CAAQ,KAAGD,EAAWnB,CAAG,GAClDqB,EAAQrB,CAAG;AACpB;AAGA,SAASqB,EAAQ,GAAoC;CACnD,IAAIrB,EAAI,eAAe,KAAA,GAAW;EAChC,IAAMM,IAAcN,EAAI,MAAM,aACxBsB,IAAa5B,EAAsBY,CAAW;EACpD,EAAI,aAAa;GACf,OAAOgB,IAAa,IAAItB,EAAI,MAAM;GAClC;GACA,WAAWC,EAAaD,CAAG;GAC3B,WAAW;GACX;GACA,UAAU,CAAC;EACb;CACF;CACA,OAAOA,EAAI;AACb;AAWA,SAAgBuB,EACd,GAAkB,GAAoB,GACM;CAK5C,AAJIvB,EAAI,eAAe,KAAA,KAChB,CAACF,EAAkBE,GAAKA,EAAI,YAAYG,GAAOE,CAAQ,KAC5Dc,EAAWnB,CAAG,GAEZA,EAAI,UAAU,cAAc,CAAC,KAAGmB,EAAWnB,CAAG;CAClD,IAAMD,IAASsB,EAAQrB,CAAG,GACtBwB,IAAOpB,EAAcL,GAAQI,GAAOE,CAAQ;CAKhD,OAJImB,IAAOzB,EAAO,SAAS,WACzBA,EAAO,SAAS,KAAK;EAAE,MAAM;EAAU;EAAO;CAAS,CAAC,GACxD,IAAOA,EAAO,SAAS,SAElB;EAAE;EAAQ;CAAK;AACxB;AAWA,SAAgB0B,EACd,GAAkB,GAAiB,GAAuC,GAC9B;CAM5C,AALIzB,EAAI,eAAe,KAAA,MACf,CAACF,EAAkBE,GAAKA,EAAI,YAAY,KAAA,GAAW,KAAA,GAAWE,CAAS,KACpES,EAAaX,EAAI,YAAY0B,CAAO,IAAI,MACjDP,EAAWnB,CAAG,GAEZA,EAAI,UAAU,cAAc,CAAC,KAAGmB,EAAWnB,CAAG;CAClD,IAAMD,IAASsB,EAAQrB,CAAG;CAG1B,EAAO,YAAYE;CACnB,IAAIsB,IAAOb,EAAaZ,GAAQ2B,CAAO;CAKvC,OAJIF,IAAOzB,EAAO,SAAS,WACzBA,EAAO,SAAS,KAAK;EAAE,MAAM;EAAS,IAAI2B;EAAS;CAAW,CAAC,GAC/D,IAAO3B,EAAO,SAAS,SAElB;EAAE;EAAQ;CAAK;AACxB;AAaA,SAAS4B,EACP,GAAkB,GAAmB,GAAmB,GACE;CAM1D,AALI3B,EAAI,UAAU,aAAa4B,GAAOC,CAAK,KAAGV,EAAWnB,CAAG,GACxDA,EAAI,eAAe,KAAA,MACf,CAACF,EAAkBE,GAAKA,EAAI,UAAU,KAAKU,EAAaV,EAAI,UAAU,IAAI,MAChFmB,EAAWnB,CAAG,GAEZA,EAAI,UAAU,cAAcoB,CAAQ,KAAGD,EAAWnB,CAAG;CACzD,IAAMD,IAASsB,EAAQrB,CAAG,GACtBwB,IAAOd,EAAaX,CAAM;CAK9B,OAJIyB,IAAOzB,EAAO,SAAS,WACzBA,EAAO,SAAS,KAAK,EAAE,MAAM,QAAQ,CAAC,GACtC,IAAOA,EAAO,SAAS,SAElB;EAAE;EAAQ;EAAM,MAAMC,EAAI,UAAU,KAAKA,EAAI,UAAU,OAAO4B,GAAOC,CAAK,CAAC;CAAE;AACtF;AAIA,SAASC,EACP,GAAkB,GAA0B,GACpC;CACR,QAAQC,KAAW,MAAMhC,EAAO,aAAaC,EAAI,MAAM,QAAQ;AACjE;AAGA,SAASgC,EACP,GAAkB,GAClB,GACkC;CAClC,IAAM,CAACC,GAAGC,GAAGC,GAAGC,KAAKC,EAAaC,EAAM,KAAK;CAC7C,OAAO;EAACL;EAAGC;EAAGC;EAAGC,IAAIN,EAAY9B,GAAKD,GAAQuC,EAAM,OAAO;CAAC;AAC9D;AAEA,SAAgBC,EACd,GACA,GACA,GACM;CAEN,IAAM,CAAC,GAAGL,GAAGC,GAAGC,KAAKJ,EAAYhC,GADlBkB,EAAWlB,GAAK,CACO,GAAQwC,CAAI;CAClD,AAAKxC,EAAI,UAAU,SACjByC,EAAK,GAAGA,EAAK,GAAGA,EAAK,OAAOA,EAAK,QAAQzC,EAAI,MAAM,WAAW,GAAGkC,GAAGC,GAAGC,CACzE,KAAGM,EAAW1C,GAAKyC,GAAMD,GAAMD,CAAQ;AACzC;AAEA,SAASI,EACP,GACA,GACA,GACM;CAEN,IAAM,CAAC,GAAGT,GAAGC,GAAGC,KAAKJ,EAAYhC,GADlBkB,EAAWlB,GAAKgB,EAAK,SAAS,UAAU,CACjB,GAAQsB,CAAK;CACnD,AAAKtC,EAAI,UAAU,SAASgB,GAAMhB,EAAI,MAAM,WAAW,GAAGkC,GAAGC,GAAGC,CAAC,KAC/DM,EAAW1C,GAAKgB,GAAMsB,GAAOK,CAAQ;AAEzC;AAEA,SAAgBC,EACd,GACA,GACA,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,YAASjB,EAAW3B,GAAKsC,EAAM,OAAOA,EAAM,OAAO,CAAC,GACpE,EAAE,OAAI,YAASO,EAAaP,GAAOQ,CAAI;CAG7C,AAAK9C,EAAI,UAAU,iBACjByC,EAAK,GAAGA,EAAK,GAAGA,EAAK,OAAOA,EAAK,QAAQzC,EAAI,MAAM,WACnD+C,GAAIC,GAAMxB,GAAMc,EAAM,MAAM,GAAG,GAAG,GAAGR,EAAY9B,GAAKD,GAAQuC,EAAM,OAAO,CAC7E,KAAGI,EAAW1C,GAAKyC,GAAMH,GAAOM,CAAY;AAC9C;AAEA,SAASK,EACP,GAAkB,GAAY,GACxB;CACN,IAAM,EAAE,WAAQ,SAAM,YAAStB,EAAW3B,GAAKsC,EAAM,OAAOA,EAAM,OAAOtB,EAAK,SAAS,UAAU,CAAC,GAC5F,EAAE,OAAI,YAAS6B,EAAaP,GAAOQ,CAAI;CAC7C,AAAK9C,EAAI,UAAU,iBACjBgB,GAAMhB,EAAI,MAAM,WAChB+C,GAAIC,GAAMxB,GAAMc,EAAM,MAAM,GAAG,GAAG,GAAGR,EAAY9B,GAAKD,GAAQuC,EAAM,OAAO,CAC7E,KAAGI,EAAW1C,GAAKgB,GAAMsB,GAAOW,CAAY;AAC9C;AAUA,SAAgBC,EACd,GACA,GACA,GACS;CAOT,OANIZ,MAAU,KAAA,KAAavB,EAAaf,GAAKgB,CAAI,KAC3CsB,EAAM,SAAS,SAAQW,EAAajD,GAAKgB,GAAMsB,CAAK,IACnDK,EAAS3C,GAAKgB,GAAMsB,CAAK,GACvB,OAETa,EAAgBnD,CAAG,GACZ;AACT"}

package/dist/renderer/draw/clip.js

@@ -0,0 +1,89 @@
+import { drawTriangles as e } from "./drawTriangles.js";
+import { ancestorMask as t } from "./stencil.js";
+import { setProjAndModel as n } from "./uniforms.js";
+import { axisAlignedClipRect as r, intersectClipRects as i } from "../batchClip.js";
+import { fillMeshHandle as a } from "./mesh.js";
+import { flushBatch as o } from "./flushBatch.js";
+//#region src/renderer/draw/clip.ts
+function s(e, t) {
+	let n = e.clipStack.reduce((e, t) => e + +(t.depth === 0), 0);
+	if (e.clipDepth + n + 1 > 7) throw Error("weasel: clip nesting depth exceeded (max 7). You can't nest more than 7 levels of clipped containers in a single draw tree. Flatten the hierarchy or compose poses outside the scene graph.");
+	c(e, t);
+}
+function c(e, t) {
+	let n = e.state.transform, i = r(t, n);
+	if (i === null) {
+		u(e);
+		let r = e.clipDepth + 1;
+		v(e, t, r), e.clipDepth = r, e.clipStack.push({
+			path: t,
+			transform: n,
+			rect: null,
+			depth: r
+		});
+	} else e.clipStack.push({
+		path: t,
+		transform: n,
+		rect: i,
+		depth: 0
+	});
+	d(e);
+}
+function l(e) {
+	let t = e.clipStack.pop();
+	t.depth > 0 && (y(e, t.path, t.depth - 1, t.transform), e.clipDepth = t.depth - 1), d(e);
+}
+function u(e) {
+	for (let t of e.clipStack) {
+		if (t.depth !== 0) continue;
+		let n = e.clipDepth + 1;
+		v(e, t.path, n, t.transform), t.depth = n, e.clipDepth = n;
+	}
+}
+function d(e) {
+	let t = null;
+	for (let n of e.clipStack) n.rect && (t = t ? i(t, n.rect) : n.rect);
+	e.drawBatch.clip = t;
+}
+function f(e) {
+	let t = e.clipStack;
+	if (t.length === 0 || e.uncut) return e.clipDepth;
+	for (let e = t.length - 1; e >= 0; e--) if (t[e].rect === null) return t[e].depth;
+	for (let e of t) if (e.depth > 0) return e.depth - 1;
+	return e.clipDepth;
+}
+function p(e) {
+	u(e);
+	let t = e.drawBatch.clip;
+	return e.drawBatch.clip = null, e.uncut = !0, t;
+}
+function m(e, t) {
+	e.drawBatch.clip = t, e.uncut = !1;
+}
+function h(e, t, n, r) {
+	let i = p(e);
+	r(e, t, n), m(e, i);
+}
+function g(e) {
+	o(e), e.clipStack.length > 0 && u(e);
+}
+function _(t, r, i) {
+	let o = t.gl, s = a(t, r);
+	o.useProgram(t.pathFill.handle), o.bindVertexArray(s.vao), n(t, t.pathFill, i), e(t, s.indexCount, t.gl.UNSIGNED_INT), o.bindVertexArray(null);
+}
+function v(e, n, r, i = e.state.transform) {
+	o(e);
+	let s = e.gl, c = t(r - 1), l = 1 << r, u = c | l;
+	s.enable(s.STENCIL_TEST), s.colorMask(!1, !1, !1, !1), a(e, n).requiresStencil ? (s.stencilMask(1), s.stencilFunc(s.ALWAYS, 0, 1), s.stencilOp(s.KEEP, s.KEEP, s.INVERT), _(e, n, i), s.stencilMask(l), s.stencilFunc(s.EQUAL, u | 1, c | 1), s.stencilOp(s.KEEP, s.KEEP, s.REPLACE), _(e, n, i), s.stencilMask(1), s.stencilFunc(s.ALWAYS, 0, 1), s.stencilOp(s.KEEP, s.KEEP, s.INVERT), _(e, n, i)) : (s.stencilMask(l), s.stencilFunc(s.EQUAL, u, c), s.stencilOp(s.KEEP, s.KEEP, s.REPLACE), _(e, n, i)), s.colorMask(!0, !0, !0, !0), s.stencilMask(255);
+}
+function y(e, n, r, i = e.state.transform) {
+	e.batchState !== void 0 && e.batchState.clipDepth > r && o(e);
+	let a = e.gl;
+	a.enable(a.STENCIL_TEST);
+	let s = 1 << r + 1, c = t(r) | s;
+	a.colorMask(!1, !1, !1, !1), a.stencilMask(s), a.stencilFunc(a.EQUAL, c, c), a.stencilOp(a.KEEP, a.KEEP, a.ZERO), _(e, n, i), a.colorMask(!0, !0, !0, !0), a.stencilMask(255);
+}
+//#endregion
+export { s as enterGroupClip, p as enterUncut, g as flushForOwnDraw, l as leaveClip, m as leaveUncut, y as popClip, v as pushClip, h as retryUncut, f as runClipDepth };
+
+//# sourceMappingURL=clip.js.map

package/dist/renderer/draw/clip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip.js","names":["enterGroupClip","pending","ctx","n","clip","enterClip","transform","rect","axisAlignedClipRect","path","depth","pushClip","leaveClip","entry","popClip","syncBatchClip","materializeClips","intersectClipRects","runClipDepth","stack","i","enterUncut","cut","leaveUncut","retryUncut","fn","a","b","flushForOwnDraw","flushBatch","rasterizePathToStencil","gl","handle","fillMeshHandle","setProjAndModel","model","drawTriangles","ancestors","ancestorMask","newDepth","newBit","ref","oldDepth","oldBit"],"sources":["../../../src/renderer/draw/clip.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport type { GlMat3 } from '../math/mat3';\nimport { axisAlignedClipRect, intersectClipRects, type ClipRect } from '../batchClip';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { fillMeshHandle } from './mesh';\nimport { setProjAndModel } from './uniforms';\nimport { ancestorMask } from './stencil';\nimport { flushBatch } from './flushBatch';\n\n/** `enterClip` for a group command, refusing one past the stencil's budget. */\nexport function enterGroupClip(ctx: DrawContext, clip: Path): void {\n  const pending = ctx.clipStack.reduce((n, e) => n + (e.depth === 0 ? 1 : 0), 0);\n  if (ctx.clipDepth + pending + 1 > 7) {\n    throw new Error(\n      'weasel: clip nesting depth exceeded (max 7). You can\\'t nest more than 7 levels ' +\n      'of clipped containers in a single draw tree. Flatten the hierarchy or compose ' +\n      'poses outside the scene graph.',\n    );\n  }\n  enterClip(ctx, clip);\n}\n\n/**\n * Push a group's clip.\n *\n * A clip only the stencil can express takes its bit now. An axis-aligned rect\n * takes none: staged geometry is cut to it on the CPU (`batchClip.ts`), so\n * content inside it joins the run outside it instead of costing a flush on\n * the way in and another on the way out. It takes a bit only if something that\n * draws for itself turns up inside it — see `flushForOwnDraw`.\n */\nfunction enterClip(ctx: DrawContext, path: Path): void {\n  const transform = ctx.state.transform;\n  const rect = axisAlignedClipRect(path, transform);\n  if (rect === null) {\n    // Bits nest in stack order, so any rect clip still without one takes it\n    // first.\n    materializeClips(ctx);\n    const depth = ctx.clipDepth + 1;\n    pushClip(ctx, path, depth);\n    ctx.clipDepth = depth;\n    ctx.clipStack.push({ path, transform, rect: null, depth });\n  } else {\n    ctx.clipStack.push({ path, transform, rect, depth: 0 });\n  }\n  syncBatchClip(ctx);\n}\n\nexport function leaveClip(ctx: DrawContext): void {\n  const entry = ctx.clipStack.pop()!;\n  if (entry.depth > 0) {\n    popClip(ctx, entry.path, entry.depth - 1, entry.transform);\n    ctx.clipDepth = entry.depth - 1;\n  }\n  syncBatchClip(ctx);\n}\n\n/** Give every rect clip on the stack its stencil bit, for a draw the CPU cut\n *  cannot reach. */\nfunction materializeClips(ctx: DrawContext): void {\n  for (const entry of ctx.clipStack) {\n    if (entry.depth !== 0) continue;\n    const depth = ctx.clipDepth + 1;\n    pushClip(ctx, entry.path, depth, entry.transform);\n    entry.depth = depth;\n    ctx.clipDepth = depth;\n  }\n}\n\nfunction syncBatchClip(ctx: DrawContext): void {\n  let rect: ClipRect | null = null;\n  for (const entry of ctx.clipStack) {\n    if (entry.rect) rect = rect ? intersectClipRects(rect, entry.rect) : entry.rect;\n  }\n  ctx.drawBatch.clip = rect;\n}\n\n/**\n * The clip depth a run is staged and drawn at: the innermost clip only the\n * stencil can express. Rect clips are left out whether or not they hold a bit,\n * because the CPU cut already applies them — which is what lets a run cross\n * them.\n */\nexport function runClipDepth(ctx: DrawContext): number {\n  const stack = ctx.clipStack;\n  if (stack.length === 0 || ctx.uncut) return ctx.clipDepth;\n  for (let i = stack.length - 1; i >= 0; i--) {\n    if (stack[i].rect === null) return stack[i].depth;\n  }\n  // Only rect clips: whatever depth held before the first of them took a bit.\n  for (const entry of stack) if (entry.depth > 0) return entry.depth - 1;\n  return ctx.clipDepth;\n}\n\n/**\n * Put the rect clips on the stencil and stop cutting, for an item the batch\n * refused to cut — one with a slanted edge across a clip (see\n * `DrawBatch.clipQuad`). Staged again between this and `leaveUncut`, the item\n * sees the full stencil depth and lands in a run of its own under every clip.\n * Returns the cut to hand back.\n *\n * A pair rather than a callback: the staging paths are hot, and a closure\n * over their arguments would cost an allocation on every call, refused or not.\n */\nexport function enterUncut(ctx: DrawContext): ClipRect | null {\n  materializeClips(ctx);\n  const cut = ctx.drawBatch.clip;\n  ctx.drawBatch.clip = null;\n  ctx.uncut = true;\n  return cut;\n}\n\nexport function leaveUncut(ctx: DrawContext, cut: ClipRect | null): void {\n  ctx.drawBatch.clip = cut;\n  ctx.uncut = false;\n}\n\n/** `fn(ctx, a, b)` again, uncut — for the stage-and-push helpers, which pass\n *  themselves. */\nexport function retryUncut<A, B>(\n  ctx: DrawContext, a: A, b: B, fn: (ctx: DrawContext, a: A, b: B) => void,\n): void {\n  const cut = enterUncut(ctx);\n  fn(ctx, a, b);\n  leaveUncut(ctx, cut);\n}\n\n/**\n * Drain the run before a draw that does not go through it, and give that draw\n * the stencil it tests against. Every such draw starts here or behind a\n * `tryStageFill` that returned `false`, which ends the same way.\n */\nexport function flushForOwnDraw(ctx: DrawContext): void {\n  flushBatch(ctx);\n  if (ctx.clipStack.length > 0) materializeClips(ctx);\n}\n\n/**\n * Rasterize a path into the stencil buffer using the pathFill shader geometry.\n * The caller is responsible for setting stencilFunc / stencilOp / stencilMask\n * and colorMask before calling.\n */\nfunction rasterizePathToStencil(ctx: DrawContext, path: Path, model: GlMat3): void {\n  const gl = ctx.gl;\n  const handle = fillMeshHandle(ctx, path);\n  gl.useProgram(ctx.pathFill.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, ctx.pathFill, model);\n  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  gl.bindVertexArray(null);\n}\n\n/**\n * Push a clip level. Rasterizes the clip path into the stencil buffer,\n * setting bit `newDepth` where (a) the path's fragment passes AND (b) all\n * ancestor clip bits are already set.\n *\n * Invariant: restores stencilMask(0xFF) on exit so callers (draw functions)\n * can rely on an unnarrowed mask after clip ops complete.\n */\nexport function pushClip(\n  ctx: DrawContext, path: Path, newDepth: number, model: GlMat3 = ctx.state.transform,\n): void {\n  // First, not last: a run staged outside the clip would otherwise draw under\n  // a mask it never had.\n  flushBatch(ctx);\n  const gl = ctx.gl;\n  const ancestors = ancestorMask(newDepth - 1);\n  const newBit = 1 << newDepth;\n  const ref = ancestors | newBit;\n\n  gl.enable(gl.STENCIL_TEST);\n  gl.colorMask(false, false, false, false);\n  if (fillMeshHandle(ctx, path).requiresStencil) {\n    // Fans, one per contour: their union is not the path. Parity goes on\n    // bit 0, the clip bit is written where parity is odd, and drawing the\n    // fans a third time returns bit 0 to zero.\n    gl.stencilMask(0x01);\n    gl.stencilFunc(gl.ALWAYS, 0, 0x01);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);\n    rasterizePathToStencil(ctx, path, model);\n    gl.stencilMask(newBit);\n    gl.stencilFunc(gl.EQUAL, ref | 0x01, ancestors | 0x01);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);\n    rasterizePathToStencil(ctx, path, model);\n    gl.stencilMask(0x01);\n    gl.stencilFunc(gl.ALWAYS, 0, 0x01);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);\n    rasterizePathToStencil(ctx, path, model);\n  } else {\n    gl.stencilMask(newBit);\n    gl.stencilFunc(gl.EQUAL, ref, ancestors);\n    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);\n    rasterizePathToStencil(ctx, path, model);\n  }\n\n  gl.colorMask(true, true, true, true);\n  // Restore full mask so subsequent draw functions don't inherit a narrowed mask.\n  gl.stencilMask(0xFF);\n}\n\n/**\n * Pop a clip level. Rasterizes the same path again, clearing bit\n * `oldDepth + 1` where it was set during the matching push.\n *\n * Must re-enable STENCIL_TEST because child draw functions (drawPathFillStencil,\n * drawPathStrokeStenciled) call gl.disable(STENCIL_TEST) at their end. If\n * one of those was the last child before popClip runs, the test would be off\n * and rasterizePathToStencil would write nothing.\n *\n * Invariant: restores stencilMask(0xFF) on exit so callers are not left with\n * a narrowed mask.\n */\nexport function popClip(\n  ctx: DrawContext, path: Path, oldDepth: number, model: GlMat3 = ctx.state.transform,\n): void {\n  // First, not last: past here the mask is gone, and these pixels belonged\n  // inside it. A run staged below this bit does not test it, so it lives on.\n  if (ctx.batchState !== undefined && ctx.batchState.clipDepth > oldDepth) flushBatch(ctx);\n  const gl = ctx.gl;\n  // Re-enable stencil: child draw functions (evenodd/stenciled-stroke) disable\n  // it at their end; we must set it before writing the clear pass.\n  gl.enable(gl.STENCIL_TEST);\n\n  const oldBit = 1 << (oldDepth + 1);\n  const ref = ancestorMask(oldDepth) | oldBit;\n\n  gl.colorMask(false, false, false, false);\n  gl.stencilMask(oldBit);\n  gl.stencilFunc(gl.EQUAL, ref, ref);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.ZERO);\n\n  rasterizePathToStencil(ctx, path, model);\n\n  gl.colorMask(true, true, true, true);\n  // Restore full mask so subsequent draw functions don't inherit a narrowed mask.\n  gl.stencilMask(0xFF);\n}\n"],"mappings":"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"}

package/dist/renderer/draw/customShader.js

@@ -0,0 +1,230 @@
+import { getTexture as e } from "../textures/registerTexture.js";
+import { mat3 as t } from "../math/mat3.js";
+import { drawTriangles as n } from "./drawTriangles.js";
+import { applyClipTest as r } from "./stencil.js";
+//#region src/renderer/draw/customShader.ts
+var i = /* @__PURE__ */ new Set();
+function a(e, t) {
+	let n = `${e}:${t}`;
+	i.has(n) || (i.add(n), (typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel drawShader: uniform "${t}" not found in program "${e}". Check spelling, ensure it's used in the shader (unused uniforms are optimized away by the driver).`));
+}
+function o(t, n, r, i, a) {
+	if (typeof r == "object" && r && !Array.isArray(r) && !(r instanceof Float32Array) && "id" in r && typeof r.id == "string") {
+		let o = r, s = e(o.id);
+		if (!s) {
+			(typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel setUniform: TextureHandle "${o.id}" not registered`);
+			return;
+		}
+		let c = a.value++;
+		t.activeTexture(t.TEXTURE0 + c), i.uploadRegistered(o.id, s.source), i.bind(o.id, c), t.uniform1i(n, c);
+		return;
+	}
+	if (r instanceof Float64Array && (r = Float32Array.from(r)), r instanceof Float32Array) {
+		if (r.length === 9) t.uniformMatrix3fv(n, !1, r);
+		else if (r.length === 16) t.uniformMatrix4fv(n, !1, r);
+		else if (typeof process > "u" || process.env.NODE_ENV !== "production") throw TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${r.length}`);
+		return;
+	}
+	if (Array.isArray(r)) {
+		let e = r;
+		switch (e.length) {
+			case 2:
+				t.uniform2fv(n, e);
+				break;
+			case 3:
+				t.uniform3fv(n, e);
+				break;
+			case 4:
+				t.uniform4fv(n, e);
+				break;
+			default: if (typeof process > "u" || process.env.NODE_ENV !== "production") throw TypeError(`weasel setUniform: array length ${e.length} not supported`);
+		}
+		return;
+	}
+	if (typeof r == "number") {
+		t.uniform1f(n, r);
+		return;
+	}
+}
+var s = {
+	float: {
+		fn: "uniform1fv",
+		n: 1
+	},
+	vec2: {
+		fn: "uniform2fv",
+		n: 2
+	},
+	vec3: {
+		fn: "uniform3fv",
+		n: 3
+	},
+	vec4: {
+		fn: "uniform4fv",
+		n: 4
+	},
+	int: {
+		fn: "uniform1iv",
+		n: 1
+	},
+	ivec2: {
+		fn: "uniform2iv",
+		n: 2
+	},
+	ivec3: {
+		fn: "uniform3iv",
+		n: 3
+	},
+	ivec4: {
+		fn: "uniform4iv",
+		n: 4
+	},
+	bool: {
+		fn: "uniform1iv",
+		n: 1
+	},
+	bvec2: {
+		fn: "uniform2iv",
+		n: 2
+	},
+	bvec3: {
+		fn: "uniform3iv",
+		n: 3
+	},
+	bvec4: {
+		fn: "uniform4iv",
+		n: 4
+	},
+	uint: {
+		fn: "uniform1uiv",
+		n: 1
+	},
+	uvec2: {
+		fn: "uniform2uiv",
+		n: 2
+	},
+	uvec3: {
+		fn: "uniform3uiv",
+		n: 3
+	},
+	uvec4: {
+		fn: "uniform4uiv",
+		n: 4
+	},
+	mat2: {
+		fn: "uniformMatrix2fv",
+		n: 4,
+		matrix: !0
+	},
+	mat3: {
+		fn: "uniformMatrix3fv",
+		n: 9,
+		matrix: !0
+	},
+	mat4: {
+		fn: "uniformMatrix4fv",
+		n: 16,
+		matrix: !0
+	},
+	mat2x2: {
+		fn: "uniformMatrix2fv",
+		n: 4,
+		matrix: !0
+	},
+	mat3x3: {
+		fn: "uniformMatrix3fv",
+		n: 9,
+		matrix: !0
+	},
+	mat4x4: {
+		fn: "uniformMatrix4fv",
+		n: 16,
+		matrix: !0
+	},
+	mat2x3: {
+		fn: "uniformMatrix2x3fv",
+		n: 6,
+		matrix: !0
+	},
+	mat2x4: {
+		fn: "uniformMatrix2x4fv",
+		n: 8,
+		matrix: !0
+	},
+	mat3x2: {
+		fn: "uniformMatrix3x2fv",
+		n: 6,
+		matrix: !0
+	},
+	mat3x4: {
+		fn: "uniformMatrix3x4fv",
+		n: 12,
+		matrix: !0
+	},
+	mat4x2: {
+		fn: "uniformMatrix4x2fv",
+		n: 8,
+		matrix: !0
+	},
+	mat4x3: {
+		fn: "uniformMatrix4x3fv",
+		n: 12,
+		matrix: !0
+	}
+};
+function c(e) {
+	return Array.isArray(e) || e instanceof Float32Array || e instanceof Int32Array || e instanceof Uint32Array;
+}
+function l(e, t, n, r) {
+	let i = typeof process < "u" ? process.env.NODE_ENV !== "production" : !0, a = s[n.type];
+	if (!a) {
+		i && console.warn(`weasel setUniform: array uniform "${t}" has type ${n.type}, which cannot be written as a whole`);
+		return;
+	}
+	if (r.length % a.n !== 0 || r.length > a.n * n.size) {
+		if (i) throw TypeError(`weasel setUniform: "${t}" is ${n.type}[${n.size}], so its value must hold a multiple of ${a.n} numbers, at most ${a.n * n.size}; got ${r.length}`);
+		return;
+	}
+	if (r.length === 0) return;
+	let o = e[a.fn];
+	a.matrix ? o.call(e, n.location, !1, r) : o.call(e, n.location, r);
+}
+function u(e, t, n, r, i, s) {
+	for (let [u, d] of Object.entries(r)) {
+		let r = t.uniformArray(u);
+		if (r && c(d)) {
+			l(e, u, r, d);
+			continue;
+		}
+		let f = t.uniform(u);
+		if (f === void 0) {
+			a(n, u);
+			continue;
+		}
+		o(e, f, d, i, s);
+	}
+}
+function d(e, i) {
+	let { gl: a, programRegistry: o, quadVbo: s, quadIbo: c, textureCache: l } = e, d = o.get(i.program.id);
+	if (!d) {
+		console.warn(`weasel drawShader: program "${i.program.id}" not compiled on this renderer. Call renderer.registerProgram(handle) after the module-level registerProgram().`);
+		return;
+	}
+	if (!s || !c) {
+		console.warn("weasel drawShader: quad geometry not initialized");
+		return;
+	}
+	a.useProgram(d.handle);
+	let f = d.attribute("a_position"), p = d.attribute("a_uv");
+	a.bindBuffer(a.ARRAY_BUFFER, s), f !== void 0 && (a.enableVertexAttribArray(f), a.vertexAttribPointer(f, 2, a.FLOAT, !1, 16, 0)), p !== void 0 && (a.enableVertexAttribArray(p), a.vertexAttribPointer(p, 2, a.FLOAT, !1, 16, 8)), a.bindBuffer(a.ELEMENT_ARRAY_BUFFER, c);
+	let m = t.screenToClip(e.widthCss, e.heightCss), h = d.uniform("u_proj");
+	h !== void 0 && a.uniformMatrix3fv(h, !1, t.toUniform(m));
+	let g = d.uniform("u_bounds");
+	g !== void 0 && a.uniform4f(g, i.bounds.x, i.bounds.y, i.bounds.w, i.bounds.h);
+	let _ = d.uniform("u_view");
+	_ !== void 0 && a.uniformMatrix3fv(_, !1, t.toUniform(e.state.transform)), u(a, d, i.program.id, i.uniforms, l, { value: 1 }), r(e), n(e, 6, e.gl.UNSIGNED_SHORT), f !== void 0 && a.disableVertexAttribArray(f), p !== void 0 && a.disableVertexAttribArray(p), a.bindBuffer(a.ARRAY_BUFFER, null), a.bindBuffer(a.ELEMENT_ARRAY_BUFFER, null);
+}
+//#endregion
+export { d as drawShader, o as setUniform, u as setUniforms, a as warnOnceUniform };
+
+//# sourceMappingURL=customShader.js.map

package/dist/renderer/draw/customShader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"customShader.js","names":["warnedUniforms","warnOnceUniform","key","programId","name","setUniform","value","handle","entry","getTexture","unit","gl","textureCache","loc","arr","ARRAY_UPLOADS","isArrayValue","setUniformArray","isDev","upload","fn","setUniforms","uniforms","program","nextTexUnit","drawShader","ctx","programRegistry","cmd","quadVbo","quadIbo","aPosLoc","aUvLoc","proj","mat3","uProj","uBounds","uView","applyClipTest","drawTriangles"],"sources":["../../../src/renderer/draw/customShader.ts"],"sourcesContent":["import type { ShaderDrawCommand } from '../DrawCommand';\nimport { getTexture, type TextureHandle } from '../textures/registerTexture';\nimport type { ShaderUniform } from '../shaders/registerProgram';\nimport type { GLTextureCache } from '../cache/GLTextureCache';\nimport type { ShaderProgram, UniformArray } from '../shaders/ShaderProgram';\nimport { mat3 } from '../math/mat3';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { applyClipTest } from './stencil';\n\nconst warnedUniforms = new Set<string>();\n\nexport function warnOnceUniform(programId: string, name: string): void {\n  const key = `${programId}:${name}`;\n  if (warnedUniforms.has(key)) return;\n  warnedUniforms.add(key);\n  const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n  if (isDev) {\n    console.warn(`weasel drawShader: uniform \"${name}\" not found in program \"${programId}\". ` +\n      `Check spelling, ensure it's used in the shader (unused uniforms are optimized away by the driver).`);\n  }\n}\n\n/**\n * Bind a single ShaderUniform value to a GL uniform location.\n *\n * Type detection order:\n *   1. TextureHandle (object with string `.id`) — bind to next tex unit, set sampler.\n *   2. Float32Array — length 9 → mat3, length 16 → mat4. Other lengths throw in dev.\n *   3. Array — uniform2fv / uniform3fv / uniform4fv based on length.\n *   4. number — uniform1f.\n */\nexport function setUniform(\n  gl: WebGL2RenderingContext,\n  loc: WebGLUniformLocation,\n  value: ShaderUniform,\n  textureCache: GLTextureCache,\n  nextTexUnit: { value: number },\n): void {\n  if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Float32Array)\n      && 'id' in value && typeof (value as TextureHandle).id === 'string') {\n    const handle = value as TextureHandle;\n    const entry = getTexture(handle.id);\n    if (!entry) {\n      const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n      if (isDev) console.warn(`weasel setUniform: TextureHandle \"${handle.id}\" not registered`);\n      return;\n    }\n    const unit = nextTexUnit.value++;\n    // An upload binds and unbinds on the active unit, so it has to be this\n    // uniform's own unit and not one an earlier sampler already holds.\n    gl.activeTexture(gl.TEXTURE0 + unit);\n    textureCache.uploadRegistered(handle.id, entry.source);\n    textureCache.bind(handle.id, unit);\n    gl.uniform1i(loc, unit);\n    return;\n  }\n\n  // A kit matrix is in doubles; GL wants float32.\n  if (value instanceof Float64Array) value = Float32Array.from(value);\n\n  if (value instanceof Float32Array) {\n    if (value.length === 9) {\n      gl.uniformMatrix3fv(loc, false, value);\n    } else if (value.length === 16) {\n      gl.uniformMatrix4fv(loc, false, value);\n    } else {\n      const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n      if (isDev) throw new TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${value.length}`);\n    }\n    return;\n  }\n\n  if (Array.isArray(value)) {\n    const arr = value as readonly number[];\n    switch (arr.length) {\n      case 2: gl.uniform2fv(loc, arr as [number, number]); break;\n      case 3: gl.uniform3fv(loc, arr as [number, number, number]); break;\n      case 4: gl.uniform4fv(loc, arr as [number, number, number, number]); break;\n      default: {\n        const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n        if (isDev) throw new TypeError(`weasel setUniform: array length ${arr.length} not supported`);\n      }\n    }\n    return;\n  }\n\n  if (typeof value === 'number') {\n    gl.uniform1f(loc, value);\n    return;\n  }\n}\n\n/** How an array's element type is uploaded: the `uniform*v` call and the\n *  number of components per element. */\nconst ARRAY_UPLOADS: Readonly<Record<string, { fn: string; n: number; matrix?: true }>> = {\n  float: { fn: 'uniform1fv', n: 1 }, vec2: { fn: 'uniform2fv', n: 2 },\n  vec3: { fn: 'uniform3fv', n: 3 }, vec4: { fn: 'uniform4fv', n: 4 },\n  int: { fn: 'uniform1iv', n: 1 }, ivec2: { fn: 'uniform2iv', n: 2 },\n  ivec3: { fn: 'uniform3iv', n: 3 }, ivec4: { fn: 'uniform4iv', n: 4 },\n  bool: { fn: 'uniform1iv', n: 1 }, bvec2: { fn: 'uniform2iv', n: 2 },\n  bvec3: { fn: 'uniform3iv', n: 3 }, bvec4: { fn: 'uniform4iv', n: 4 },\n  uint: { fn: 'uniform1uiv', n: 1 }, uvec2: { fn: 'uniform2uiv', n: 2 },\n  uvec3: { fn: 'uniform3uiv', n: 3 }, uvec4: { fn: 'uniform4uiv', n: 4 },\n  mat2: { fn: 'uniformMatrix2fv', n: 4, matrix: true },\n  mat3: { fn: 'uniformMatrix3fv', n: 9, matrix: true },\n  mat4: { fn: 'uniformMatrix4fv', n: 16, matrix: true },\n  mat2x2: { fn: 'uniformMatrix2fv', n: 4, matrix: true },\n  mat3x3: { fn: 'uniformMatrix3fv', n: 9, matrix: true },\n  mat4x4: { fn: 'uniformMatrix4fv', n: 16, matrix: true },\n  mat2x3: { fn: 'uniformMatrix2x3fv', n: 6, matrix: true },\n  mat2x4: { fn: 'uniformMatrix2x4fv', n: 8, matrix: true },\n  mat3x2: { fn: 'uniformMatrix3x2fv', n: 6, matrix: true },\n  mat3x4: { fn: 'uniformMatrix3x4fv', n: 12, matrix: true },\n  mat4x2: { fn: 'uniformMatrix4x2fv', n: 8, matrix: true },\n  mat4x3: { fn: 'uniformMatrix4x3fv', n: 12, matrix: true },\n};\n\ntype ArrayValue = readonly number[] | Float32Array | Int32Array | Uint32Array;\n\nfunction isArrayValue(value: ShaderUniform): value is ArrayValue {\n  return Array.isArray(value) || value instanceof Float32Array\n    || value instanceof Int32Array || value instanceof Uint32Array;\n}\n\n/** Fill an array uniform from slot 0 with one call. Throws in dev on a value\n *  that is not a whole number of elements or overruns the declaration. */\nfunction setUniformArray(\n  gl: WebGL2RenderingContext,\n  name: string,\n  arr: UniformArray,\n  value: ArrayValue,\n): void {\n  const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n  const upload = ARRAY_UPLOADS[arr.type];\n  if (!upload) {\n    if (isDev) console.warn(`weasel setUniform: array uniform \"${name}\" has type ${arr.type}, which cannot be written as a whole`);\n    return;\n  }\n  if (value.length % upload.n !== 0 || value.length > upload.n * arr.size) {\n    if (isDev) {\n      throw new TypeError(\n        `weasel setUniform: \"${name}\" is ${arr.type}[${arr.size}], so its value must hold a multiple of ${upload.n} `\n        + `numbers, at most ${upload.n * arr.size}; got ${value.length}`,\n      );\n    }\n    return;\n  }\n  if (value.length === 0) return;\n  const fn = (gl as unknown as Record<string, (...args: unknown[]) => void>)[upload.fn];\n  if (upload.matrix) fn.call(gl, arr.location, false, value);\n  else fn.call(gl, arr.location, value);\n}\n\n/** Write every entry of a command's `uniforms` map. A key naming an array\n *  uniform with an array value fills the array; anything else goes to the\n *  location of that exact name. */\nexport function setUniforms(\n  gl: WebGL2RenderingContext,\n  program: ShaderProgram,\n  programId: string,\n  uniforms: Record<string, ShaderUniform>,\n  textureCache: GLTextureCache,\n  nextTexUnit: { value: number },\n): void {\n  for (const [name, value] of Object.entries(uniforms)) {\n    const arr = program.uniformArray(name);\n    if (arr && isArrayValue(value)) {\n      setUniformArray(gl, name, arr, value);\n      continue;\n    }\n    const loc = program.uniform(name);\n    if (loc === undefined) {\n      warnOnceUniform(programId, name);\n      continue;\n    }\n    setUniform(gl, loc, value, textureCache, nextTexUnit);\n  }\n}\n\nexport function drawShader(ctx: DrawContext, cmd: ShaderDrawCommand): void {\n  const { gl, programRegistry, quadVbo, quadIbo, textureCache } = ctx;\n\n  const program = programRegistry.get(cmd.program.id);\n  if (!program) {\n    console.warn(\n      `weasel drawShader: program \"${cmd.program.id}\" not compiled on this renderer. ` +\n      `Call renderer.registerProgram(handle) after the module-level registerProgram().`,\n    );\n    return;\n  }\n  if (!quadVbo || !quadIbo) {\n    console.warn('weasel drawShader: quad geometry not initialized');\n    return;\n  }\n\n  gl.useProgram(program.handle);\n\n  const aPosLoc = program.attribute('a_position');\n  const aUvLoc  = program.attribute('a_uv');\n\n  gl.bindBuffer(gl.ARRAY_BUFFER, quadVbo);\n  if (aPosLoc !== undefined) {\n    gl.enableVertexAttribArray(aPosLoc);\n    gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, 16, 0);\n  }\n  if (aUvLoc !== undefined) {\n    gl.enableVertexAttribArray(aUvLoc);\n    gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, 16, 8);\n  }\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, quadIbo);\n\n  const proj = mat3.screenToClip(ctx.widthCss, ctx.heightCss);\n  const uProj = program.uniform('u_proj');\n  if (uProj !== undefined) gl.uniformMatrix3fv(uProj, false, mat3.toUniform(proj));\n\n  const uBounds = program.uniform('u_bounds');\n  if (uBounds !== undefined) {\n    gl.uniform4f(uBounds, cmd.bounds.x, cmd.bounds.y, cmd.bounds.w, cmd.bounds.h);\n  }\n\n  const uView = program.uniform('u_view');\n  if (uView !== undefined) gl.uniformMatrix3fv(uView, false, mat3.toUniform(ctx.state.transform));\n\n  setUniforms(gl, program, cmd.program.id, cmd.uniforms, textureCache, { value: 1 });\n\n  applyClipTest(ctx);\n  drawTriangles(ctx, 6, ctx.gl.UNSIGNED_SHORT);\n\n  if (aPosLoc !== undefined) gl.disableVertexAttribArray(aPosLoc);\n  if (aUvLoc  !== undefined) gl.disableVertexAttribArray(aUvLoc);\n  gl.bindBuffer(gl.ARRAY_BUFFER, null);\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n}\n"],"mappings":"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"}