@weasel-js/core 1.9.2 → 1.9.4

package/dist/renderer/draw/scratchPass.js

@@ -0,0 +1,83 @@
+import { drawTriangles as e } from "./drawTriangles.js";
+import { setProjAndModel as t } from "./uniforms.js";
+import { returnToRenderTarget as n } from "./effects.js";
+import { BATCH_MODEL as r } from "./flushBatch.js";
+import { getPaintKind as i } from "../../core/paintKinds.js";
+import { paintBindContext as a } from "./paintBind.js";
+//#region src/renderer/draw/scratchPass.ts
+var o = {
+	vertices: new Float32Array([
+		0,
+		0,
+		1,
+		0,
+		1,
+		1,
+		0,
+		1
+	]),
+	indices: new Uint32Array([
+		0,
+		1,
+		2,
+		0,
+		2,
+		3
+	])
+};
+function s(r, s, c) {
+	let l = r.paintScratch, u = i(s.fill)?.bind;
+	if (!l || !u) return null;
+	let d = r.deviceWidth && r.widthCss > 0 ? r.deviceWidth / r.widthCss : 1, f = r.deviceWidth ?? Math.round(r.widthCss), p = r.deviceHeight ?? Math.round(r.heightCss), m = Math.max(0, Math.floor(c.x0 * d)), h = Math.max(0, Math.floor(c.y0 * d)), g = r.imageCache.maxTextureSide, _ = Math.min(g, Math.min(f, Math.ceil(c.x1 * d)) - m), v = Math.min(g, Math.min(p, Math.ceil(c.y1 * d)) - h);
+	if (!(_ > 0 && v > 0)) return null;
+	let y = m / d, b = h / d, x = _ / d, S = v / d, C = new Float32Array([
+		x,
+		0,
+		0,
+		0,
+		S,
+		0,
+		y,
+		b,
+		1
+	]), w = new Float32Array([
+		2 / x,
+		0,
+		0,
+		0,
+		2 / S,
+		0,
+		-1 - 2 * y / x,
+		-1 - 2 * b / S,
+		1
+	]), T = a(r), E = {
+		...T,
+		alpha: r.state.alpha,
+		maxTextureSize: T.maxTextureSize,
+		setProjAndModel: (e) => t(r, e, C, w)
+	}, D = r.gl, O = l.acquire(_, v), k = D.isEnabled(D.SCISSOR_TEST);
+	D.activeTexture(D.TEXTURE0), D.bindTexture(D.TEXTURE_2D, null), D.bindFramebuffer(D.FRAMEBUFFER, O.fbo), D.viewport(0, 0, _, v), D.disable(D.SCISSOR_TEST), D.disable(D.STENCIL_TEST), D.clear(D.COLOR_BUFFER_BIT), D.disable(D.BLEND);
+	let A = u(E, s);
+	return A && (D.bindVertexArray(r.meshCache.uploadRecurring(o).vao), e(r, o.indices.length, D.UNSIGNED_INT), D.bindVertexArray(null)), D.enable(D.BLEND), n(r, f, p, k), A ? {
+		texture: O.texture,
+		uvFromScreen: new Float32Array([
+			d / O.width,
+			0,
+			0,
+			0,
+			d / O.height,
+			0,
+			-m / O.width,
+			-h / O.height,
+			1
+		])
+	} : null;
+}
+function c(e, n, i) {
+	let a = e.gl;
+	return a.useProgram(n.handle), t(e, n, r), a.uniformMatrix3fv(n.uniform("u_worldInv"), !1, i.uvFromScreen), a.activeTexture(a.TEXTURE0), a.bindTexture(a.TEXTURE_2D, i.texture), a.uniform1i(n.uniform("u_sampler"), 0), n;
+}
+//#endregion
+export { c as bindScratchPaint, s as renderPaintToScratch };
+
+//# sourceMappingURL=scratchPass.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scratchPass.js","names":["UNIT_QUAD","renderPaintToScratch","scratch","ctx","bind","getPaintKind","fill","ratio","deviceW","deviceH","px0","rect","py0","maxSide","pw","ph","x0","y0","w","h","model","proj","base","paintBindContext","bindCtx","setProjAndModel","prog","gl","target","scissorWasOn","drawTriangles","returnToRenderTarget","bindScratchPaint","BATCH_MODEL","painted"],"sources":["../../../src/renderer/draw/scratchPass.ts"],"sourcesContent":["import type { FillStyle } from '@weasel-js/paint';\nimport { getPaintKind, type PaintBindContext } from 'core/paintKinds';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport type { GlMat3 } from '../math/mat3';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { setProjAndModel } from './uniforms';\nimport { returnToRenderTarget } from './effects';\nimport { BATCH_MODEL } from './flushBatch';\nimport { paintBindContext } from './paintBind';\n\nexport interface ScreenRect { x0: number; y0: number; x1: number; y1: number }\n\n/** The unit square, stretched over the region a scratch paint covers. */\nconst UNIT_QUAD: Mesh = {\n  vertices: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),\n  indices: new Uint32Array([0, 1, 2, 0, 2, 3]),\n};\n\ninterface ScratchPaint {\n  texture: WebGLTexture;\n  /** Screen position → the texture coordinate the paint landed at there. */\n  uvFromScreen: GlMat3;\n}\n\n/**\n * Render a registered kind's paint over `rect` (screen px) into the renderer's\n * scratch buffer, through the kind's own `bind` — so any kind that paints a\n * path paints this, with nothing asked of it beyond what a path asks.\n *\n * The region is snapped out to the device-pixel grid and clamped to the\n * drawing buffer, so each texel is one device pixel of the target and a glyph\n * fragment reads its own. The kind sees the same transform, alpha and paint\n * space it would for a path here; only the projection differs, aimed at the\n * scratch buffer instead of the target. No clip and no scissor apply inside:\n * the glyphs that sample the result are drawn under both.\n *\n * `null` when there is no scratch buffer, the region is empty, or the kind\n * declines the paint — and the glyphs then draw nothing, as the outline tier\n * does for a paint no kind binds.\n */\nexport function renderPaintToScratch(ctx: DrawContext, fill: FillStyle, rect: ScreenRect): ScratchPaint | null {\n  const scratch = ctx.paintScratch;\n  const bind = getPaintKind(fill.fill)?.bind;\n  if (!scratch || !bind) return null;\n  const ratio = ctx.deviceWidth && ctx.widthCss > 0 ? ctx.deviceWidth / ctx.widthCss : 1;\n  const deviceW = ctx.deviceWidth ?? Math.round(ctx.widthCss);\n  const deviceH = ctx.deviceHeight ?? Math.round(ctx.heightCss);\n  const px0 = Math.max(0, Math.floor(rect.x0 * ratio));\n  const py0 = Math.max(0, Math.floor(rect.y0 * ratio));\n  const maxSide = ctx.imageCache.maxTextureSide;\n  const pw = Math.min(maxSide, Math.min(deviceW, Math.ceil(rect.x1 * ratio)) - px0);\n  const ph = Math.min(maxSide, Math.min(deviceH, Math.ceil(rect.y1 * ratio)) - py0);\n  if (!(pw > 0 && ph > 0)) return null;\n\n  // The region in screen px, and the two matrices a kind's vertex stage\n  // multiplies: the unit quad onto it, and it onto the whole of clip space.\n  const x0 = px0 / ratio, y0 = py0 / ratio, w = pw / ratio, h = ph / ratio;\n  const model = new Float32Array([w, 0, 0, 0, h, 0, x0, y0, 1]);\n  const proj = new Float32Array([2 / w, 0, 0, 0, 2 / h, 0, -1 - (2 * x0) / w, -1 - (2 * y0) / h, 1]);\n  const base = paintBindContext(ctx);\n  const bindCtx: PaintBindContext = {\n    ...base,\n    alpha: ctx.state.alpha,\n    maxTextureSize: base.maxTextureSize,\n    setProjAndModel: (prog) => setProjAndModel(ctx, prog, model, proj),\n  };\n\n  const gl = ctx.gl;\n  const target = scratch.acquire(pw, ph);\n  const scissorWasOn = gl.isEnabled(gl.SCISSOR_TEST);\n  // The last glyph pass left this texture bound to unit 0; a kind sampling a\n  // unit it never binds would read the buffer it is drawing into.\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, null);\n  gl.bindFramebuffer(gl.FRAMEBUFFER, target.fbo);\n  gl.viewport(0, 0, pw, ph);\n  gl.disable(gl.SCISSOR_TEST);\n  gl.disable(gl.STENCIL_TEST);\n  gl.clear(gl.COLOR_BUFFER_BIT);\n  gl.disable(gl.BLEND);\n\n  const prog = bind(bindCtx, fill);\n  if (prog) {\n    gl.bindVertexArray(ctx.meshCache.uploadRecurring(UNIT_QUAD).vao);\n    drawTriangles(ctx, UNIT_QUAD.indices.length, gl.UNSIGNED_INT);\n    gl.bindVertexArray(null);\n  }\n\n  gl.enable(gl.BLEND);\n  returnToRenderTarget(ctx, deviceW, deviceH, scissorWasOn);\n  if (!prog) return null;\n  return {\n    texture: target.texture,\n    uvFromScreen: new Float32Array([\n      ratio / target.width, 0, 0,\n      0, ratio / target.height, 0,\n      -px0 / target.width, -py0 / target.height, 1,\n    ]),\n  };\n}\n\n/** Bind the glyph program to sample `painted` as its paint. */\nexport function bindScratchPaint(ctx: DrawContext, prog: ShaderProgram, painted: ScratchPaint): ShaderProgram {\n  const gl = ctx.gl;\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog, BATCH_MODEL);\n  gl.uniformMatrix3fv(prog.uniform('u_worldInv')!, false, painted.uvFromScreen);\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, painted.texture);\n  gl.uniform1i(prog.uniform('u_sampler')!, 0);\n  return prog;\n}\n"],"mappings":"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"}

package/dist/renderer/draw/stencil.js

@@ -0,0 +1,28 @@
+import { drawTriangles as e } from "./drawTriangles.js";
+//#region src/renderer/draw/stencil.ts
+function t(e, t = e.clipDepth) {
+	let r = e.gl;
+	if (t === 0) {
+		r.disable(r.STENCIL_TEST);
+		return;
+	}
+	let i = n(t);
+	r.enable(r.STENCIL_TEST), r.stencilFunc(r.EQUAL, i, i), r.stencilOp(r.KEEP, r.KEEP, r.KEEP);
+}
+function n(e) {
+	return e === 0 ? 0 : (1 << e + 1) - 1 & 254;
+}
+function r(t, r) {
+	let i = t.gl;
+	i.enable(i.STENCIL_TEST), i.colorMask(!1, !1, !1, !1), i.stencilMask(1), i.stencilFunc(i.ALWAYS, 0, 1), i.stencilOp(i.KEEP, i.KEEP, i.INVERT), e(t, r, t.gl.UNSIGNED_INT);
+	let a = n(t.clipDepth);
+	i.colorMask(!0, !0, !0, !0), i.stencilFunc(i.EQUAL, a | 1, a | 1), i.stencilOp(i.KEEP, i.KEEP, i.KEEP);
+}
+function i(e) {
+	let t = e.gl;
+	t.stencilMask(1), t.clear(t.STENCIL_BUFFER_BIT), t.disable(t.STENCIL_TEST);
+}
+//#endregion
+export { n as ancestorMask, t as applyClipTest, r as beginParityMask, i as endParityMask };
+
+//# sourceMappingURL=stencil.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stencil.js","names":["applyClipTest","ctx","gl","depth","mask","ancestorMask","beginParityMask","drawTriangles","indexCount","clipMask","endParityMask"],"sources":["../../../src/renderer/draw/stencil.ts"],"sourcesContent":["import type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\n\n// ─── Per-fragment clip test ───────────────────────────────────────────────────\n\n/**\n * Set the stencil test for the current clip depth. Called by every\n * fragment-producing draw before its drawElements call when clipDepth > 0.\n * At clipDepth = 0, disables STENCIL_TEST (zero-overhead common case).\n *\n * Note: not called by drawPathFillStencil / drawPathStrokeStenciled, which\n * manage their own stencil state (evenodd / inner-outer stencil). Those paths\n * coexist with clip bits because they use bit 0 exclusively while clip levels\n * occupy bits 1-7.\n */\nexport function applyClipTest(ctx: DrawContext, depth: number = ctx.clipDepth): void {\n  const gl = ctx.gl;\n  if (depth === 0) {\n    gl.disable(gl.STENCIL_TEST);\n    return;\n  }\n  const mask = ancestorMask(depth);\n  gl.enable(gl.STENCIL_TEST);\n  gl.stencilFunc(gl.EQUAL, mask, mask);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);\n}\n\n// ─── Clip-stencil helpers ────────────────────────────────────────────────────\n\n/**\n * Bit-mask for ancestor clip levels.\n * Returns bits 1..depth (inclusive).\n * depth=0 → 0x00; depth=1 → 0x02; depth=3 → 0x0E.\n */\nexport function ancestorMask(depth: number): number {\n  return depth === 0 ? 0 : ((1 << (depth + 1)) - 1) & 0xFE;\n}\n\n/**\n * Write the bound even-odd mesh's parity to stencil bit 0, then leave the\n * test passing where that parity is odd and every enclosing clip holds. The\n * program, VAO, and model are the caller's, already bound.\n */\nexport function beginParityMask(ctx: DrawContext, indexCount: number): void {\n  const gl = ctx.gl;\n  gl.enable(gl.STENCIL_TEST);\n  gl.colorMask(false, false, false, false);\n  gl.stencilMask(0x01);\n  gl.stencilFunc(gl.ALWAYS, 0, 0x01);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);\n  drawTriangles(ctx, indexCount, ctx.gl.UNSIGNED_INT);\n\n  const clipMask = ancestorMask(ctx.clipDepth);\n  gl.colorMask(true, true, true, true);\n  gl.stencilFunc(gl.EQUAL, clipMask | 0x01, clipMask | 0x01);\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);\n}\n\nexport function endParityMask(ctx: DrawContext): void {\n  const gl = ctx.gl;\n  // Narrow to bit 0 first: clear only zeroes bits the mask enables, and\n  // pushClip owns bits 1-7.\n  gl.stencilMask(0x01);\n  gl.clear(gl.STENCIL_BUFFER_BIT);\n  gl.disable(gl.STENCIL_TEST);\n}\n"],"mappings":";;AAeA,SAAgBA,EAAc,GAAkB,IAAgBC,EAAI,WAAiB;CACnF,IAAMC,IAAKD,EAAI;CACf,IAAIE,MAAU,GAAG;EACf,EAAG,QAAQD,EAAG,YAAY;EAC1B;CACF;CACA,IAAME,IAAOC,EAAaF,CAAK;CAG/B,AAFAD,EAAG,OAAOA,EAAG,YAAY,GACzBA,EAAG,YAAYA,EAAG,OAAOE,GAAMA,CAAI,GACnCF,EAAG,UAAUA,EAAG,MAAMA,EAAG,MAAMA,EAAG,IAAI;AACxC;AASA,SAAgBG,EAAa,GAAuB;CAClD,OAAOF,MAAU,IAAI,KAAM,KAAMA,IAAQ,KAAM,IAAK;AACtD;AAOA,SAAgBG,EAAgB,GAAkB,GAA0B;CAC1E,IAAMJ,IAAKD,EAAI;CAMf,AALAC,EAAG,OAAOA,EAAG,YAAY,GACzBA,EAAG,UAAU,IAAO,IAAO,IAAO,EAAK,GACvCA,EAAG,YAAY,CAAI,GACnBA,EAAG,YAAYA,EAAG,QAAQ,GAAG,CAAI,GACjCA,EAAG,UAAUA,EAAG,MAAMA,EAAG,MAAMA,EAAG,MAAM,GACxCK,EAAcN,GAAKO,GAAYP,EAAI,GAAG,YAAY;CAElD,IAAMQ,IAAWJ,EAAaJ,EAAI,SAAS;CAG3C,AAFAC,EAAG,UAAU,IAAM,IAAM,IAAM,EAAI,GACnCA,EAAG,YAAYA,EAAG,OAAOO,IAAW,GAAMA,IAAW,CAAI,GACzDP,EAAG,UAAUA,EAAG,MAAMA,EAAG,MAAMA,EAAG,IAAI;AACxC;AAEA,SAAgBQ,EAAc,GAAwB;CACpD,IAAMR,IAAKD,EAAI;CAKf,AAFAC,EAAG,YAAY,CAAI,GACnBA,EAAG,MAAMA,EAAG,kBAAkB,GAC9BA,EAAG,QAAQA,EAAG,YAAY;AAC5B"}

package/dist/renderer/draw/text.js

@@ -0,0 +1,167 @@
+import { resolveColor as e } from "../math/color.js";
+import { drawTriangles as t } from "./drawTriangles.js";
+import { applyClipTest as n } from "./stencil.js";
+import { BATCH_MODEL as r, flushBatch as i } from "./flushBatch.js";
+import { enterUncut as a, flushForOwnDraw as o, leaveUncut as s } from "./clip.js";
+import { batchPaint as c } from "./gradient.js";
+import { stageGlyphs as l, stageSolid as u, tryStageFill as d } from "./batch.js";
+import { bindGradient as f, bindPattern as p } from "./paintBind.js";
+import { drawPathFillByKind as m } from "./pathPaint.js";
+import { SYNTHETIC_ITALIC_RADIANS as h } from "../syntheticItalic.js";
+import { outlineGroupMesh as g, outlineGroupStrokeMesh as _ } from "../glyphOutlineMesh.js";
+import { bindScratchPaint as v, renderPaintToScratch as y } from "./scratchPass.js";
+import { GLYPH_MODE_MSDF as b, GLYPH_MODE_R8 as x, dynamicPageTextureId as S, ensureFontTexture as C, glyphFieldScale as w, syncDynamicPageTexture as T, textureCacheKey as E } from "@weasel-js/font";
+import { cachedLayoutRuns as D, resolveTextStyle as O, verticalAlignOffset as k } from "@weasel-js/text";
+//#region src/renderer/draw/text.ts
+var A = 48;
+function j(e) {
+	let t = Math.hypot(e[0], e[1]), n = Math.hypot(e[3], e[4]);
+	return Math.sqrt(t * n) || 1;
+}
+function M(e, t) {
+	let n = O(t.style), r = n.lineHeight, i = t.align ?? n.align, a = t.direction ?? n.direction, o = t.maxWidth ?? Infinity, s = e.textOutlineMinScreenSize ?? A, c = Number.isFinite(s) ? s / j(e.state.transform) : void 0, l = D(t.runs, {
+		maxWidth: o,
+		alignWidth: t.width,
+		lineHeight: r,
+		align: i,
+		direction: a,
+		tabSize: n.tabSize,
+		justify: t.justify,
+		outlineMinSize: c
+	});
+	if (l.groups.length === 0 && l.decorations.length === 0) return;
+	let u = t.x, d = t.y + k(t.verticalAlign, t.height, l.bounds.height);
+	for (let t of l.groups) t.source === "outline" ? N(e, t, u, d) : R(e, t, u, d);
+	F(e, l.decorations, u, d);
+}
+function N(e, t, n, r) {
+	let i = t.fill;
+	if (i !== null) {
+		let a = g(t, n, r);
+		a && P(e, i, a);
+	}
+	let a = t.stroke?.paint;
+	if (!a) return;
+	let o = _(t, n, r, e.state.transform);
+	o && P(e, a, o);
+}
+function P(e, t, n) {
+	let r = c(e, t, !1);
+	r !== null && (d(e, n, r) || m(e, t, e.meshCache.uploadTransient(n)));
+}
+function F(t, n, r, i) {
+	for (let o of n) {
+		if (z(o.fill) !== null) {
+			P(t, o.fill, I(o.x0 + r, o.y0 + i, o.x1 + r, o.y1 + i));
+			continue;
+		}
+		let [n, c, l, d] = "color" in o.fill ? e(o.fill.color) : [
+			0,
+			0,
+			0,
+			1
+		], f;
+		for (;;) {
+			let e = u(t, 4);
+			if (t.drawBatch.pushRect(o.x0 + r, o.y0 + i, o.x1 - o.x0, o.y1 - o.y0, t.state.transform, n, c, l, d * (e.foldsAlpha ? t.state.alpha : 1))) break;
+			f = a(t);
+		}
+		f !== void 0 && s(t, f);
+	}
+}
+function I(e, t, n, r) {
+	return {
+		vertices: new Float32Array([
+			e,
+			t,
+			n,
+			t,
+			n,
+			r,
+			e,
+			r
+		]),
+		indices: new Uint32Array([
+			0,
+			1,
+			2,
+			0,
+			2,
+			3
+		])
+	};
+}
+var L = .08;
+function R(t, n, r, o) {
+	if (n.source === "canvas") {
+		if (!T(t.textureCache, n.page)) return;
+	} else if (!C(n.family, n.weight, n.style, t.textureCache)) return;
+	if (n.quads.length === 0) return;
+	let c = n.source === "canvas" ? S(n.page) : E(n.family, n.weight, n.style), u = n.source === "canvas" ? x : b, d = w(n.source === "canvas" ? "canvas" : "atlas", n.family, n.weight, n.style);
+	if (!d) return;
+	let f = n.synthetic.bold ? L : 0, p = n.synthetic.italic ? Math.tan(h) : 0, m = z(n.fill);
+	if (m !== null) {
+		V(t, n, r, o, m, c, u, f, p, d);
+		return;
+	}
+	let g = n.fill !== null && "color" in n.fill ? e(n.fill.color) : [
+		0,
+		0,
+		0,
+		1
+	], _ = t.drawBatch, v = t.state.transform, { staged: y, slot: D } = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1);
+	for (let e of n.quads) {
+		_.wouldOverflow(4) && (i(t), {staged: y, slot: D} = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1));
+		let n;
+		for (; !_.pushGlyph(e.x0 + r, e.y0 + o, e.x1 + r, e.y1 + o, e.baselineY + o, p, v, e.u0, e.v0, e.u1, e.v1, g[0], g[1], g[2], O, D, u);) n = a(t), {staged: y, slot: D} = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1);
+		n !== void 0 && (s(t, n), {staged: y, slot: D} = l(t, c, d, f), O = g[3] * (y.foldsAlpha ? t.state.alpha : 1));
+	}
+}
+function z(e) {
+	let t = e?.fill ?? "solid";
+	return t === "pattern" ? "pattern" : t === "linear-gradient" || t === "radial-gradient" || t === "conic-gradient" ? "gradient" : t === "solid" ? null : "texture";
+}
+var B = 1;
+function V(e, t, i, a, s, c, l, u, d, m) {
+	let h = e.glyphPaintProgram?.(s);
+	if (!h) return;
+	o(e);
+	let g = t.fill, _ = e.state.transform, b;
+	if (s === "pattern") b = p(e, h, g, r);
+	else if (s === "gradient") b = f(e, h, g, r);
+	else {
+		let n = y(e, g, U(t, i, a, d, _));
+		b = n && v(e, h, n);
+	}
+	if (!b) return;
+	let x = e.gl;
+	e.textureCache.bind(c, B), x.uniform1i(h.uniform("u_atlas"), B), x.uniform1f(h.uniform("u_synthBold"), u), x.uniform2f(h.uniform("u_fieldScale"), m[0], m[1]), n(e);
+	let S = e.drawBatch, C = S.clip;
+	S.clip = null;
+	for (let n of t.quads) S.wouldOverflow(4) && H(e), S.pushGlyph(n.x0 + i, n.y0 + a, n.x1 + i, n.y1 + a, n.baselineY + a, d, _, n.u0, n.v0, n.u1, n.v1, 1, 1, 1, 1, B, l);
+	H(e), S.clip = C, x.activeTexture(x.TEXTURE0), x.bindVertexArray(null);
+}
+function H(e) {
+	let n = e.drawBatch;
+	n.length !== 0 && (t(e, n.uploadAndBind(), e.gl.UNSIGNED_INT), n.reset());
+}
+function U(e, t, n, r, i) {
+	let a = {
+		x0: Infinity,
+		y0: Infinity,
+		x1: -Infinity,
+		y1: -Infinity
+	}, o = (e, t) => {
+		let n = i[0] * e + i[3] * t + i[6], r = i[1] * e + i[4] * t + i[7];
+		n < a.x0 && (a.x0 = n), n > a.x1 && (a.x1 = n), r < a.y0 && (a.y0 = r), r > a.y1 && (a.y1 = r);
+	};
+	for (let i of e.quads) {
+		let e = i.x0 + t, a = i.x1 + t, s = i.y0 + n, c = i.y1 + n, l = i.baselineY + n, u = (l - s) * r, d = (l - c) * r;
+		o(e + u, s), o(a + u, s), o(a + d, c), o(e + d, c);
+	}
+	return a;
+}
+//#endregion
+export { A as OUTLINE_MIN_SCREEN_PX, M as drawText };
+
+//# sourceMappingURL=text.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":["OUTLINE_MIN_SCREEN_PX","modelScale","sx","m","sy","drawText","style","resolveTextStyle","cmd","lineHeight","align","direction","maxWidth","minScreen","ctx","outlineMinSize","laid","cachedLayoutRuns","dx","dy","verticalAlignOffset","group","drawTextOutlineGroup","drawTextGroup","fill","mesh","outlineGroupMesh","drawOutlineMesh","strokePaint","ribbon","outlineGroupStrokeMesh","paint","batchPaint","tryStageFill","drawPathFillByKind","drawTextDecorations","d","decorations","glyphPaintKindOf","ruleMesh","r","g","b","a","resolveColor","cut","staged","stageSolid","enterUncut","leaveUncut","x0","y0","x1","y1","SYNTH_BOLD_AMOUNT","syncDynamicPageTexture","ensureFontTexture","atlasId","dynamicPageTextureId","textureCacheKey","mode","GLYPH_MODE_R8","GLYPH_MODE_MSDF","fieldScale","glyphFieldScale","bold","tanItalic","SYNTHETIC_ITALIC_RADIANS","paintKind","color","batch","stageGlyphs","alpha","q","flushBatch","slot","kind","GLYPH_PAINT_ATLAS_UNIT","drawPaintedGlyphs","prog","bound","bindPattern","BATCH_MODEL","bindGradient","painted","renderPaintToScratch","glyphScreenBounds","bindScratchPaint","gl","applyClipTest","drawStagedGlyphs","drawTriangles","add","x","y","base","top","bottom"],"sources":["../../../src/renderer/draw/text.ts"],"sourcesContent":["import type { FillStyle } from '@weasel-js/paint';\nimport {\n  resolveTextStyle,\n  type LaidOutGroup,\n  type LaidOutDecoration,\n  verticalAlignOffset,\n  cachedLayoutRuns,\n} from '@weasel-js/text';\nimport type { TextDrawCommand } from '../DrawCommand';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport type { GlMat3 } from '../math/mat3';\nimport type { Mesh } from '@weasel-js/geom/tessellate';\nimport { resolveColor } from '../math/color';\nimport {\n  ensureFontTexture,\n  textureCacheKey,\n  syncDynamicPageTexture,\n  dynamicPageTextureId,\n  GLYPH_MODE_MSDF,\n  GLYPH_MODE_R8,\n  glyphFieldScale,\n} from '@weasel-js/font';\nimport { outlineGroupMesh, outlineGroupStrokeMesh } from '../glyphOutlineMesh';\nimport type { ClipRect } from '../batchClip';\nimport { SYNTHETIC_ITALIC_RADIANS } from '../syntheticItalic';\nimport type { DrawContext, GlyphPaintKind } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { applyClipTest } from './stencil';\nimport { enterUncut, leaveUncut, flushForOwnDraw } from './clip';\nimport { BATCH_MODEL, flushBatch } from './flushBatch';\nimport { stageSolid, stageGlyphs, tryStageFill } from './batch';\nimport { batchPaint } from './gradient';\nimport { bindPattern, bindGradient } from './paintBind';\nimport { drawPathFillByKind } from './pathPaint';\nimport { type ScreenRect, renderPaintToScratch, bindScratchPaint } from './scratchPass';\n\n/**\n * On-screen glyph size (CSS px) at or above which a face with registered\n * outlines is drawn as geometry instead of sampled from a distance field.\n *\n * 48 is the dynamic tier's own `BAKE_SIZE`, which makes it the size at which\n * that tier stops being an interpolation and starts being a magnification:\n * `glyphRasterizer.ts` measures coverage error bottoming out *at* the bake\n * size and rising on both sides, and past a few times it the reconstructed\n * field shows the raster as contour wobble. The same number is a safe\n * crossing for the baked MSDF atlas, which is still crisp here — outlines are\n * exact, so switching early costs nothing but the tessellation, and the\n * hinting the atlas has and outlines don't stopped mattering well below this.\n */\nexport const OUTLINE_MIN_SCREEN_PX = 48;\n\n/**\n * Uniform scale the model matrix applies, as the geometric mean of its two\n * axis lengths. Used to turn a screen-pixel threshold into the world-space\n * size layout compares against.\n *\n * The mean rather than either axis alone so a non-uniform scale answers with\n * something between the two instead of picking a side; anisotropy that\n * extreme is not a case this threshold needs to be exact about, since being\n * one glyph-size late or early only changes which of two correct renderings\n * is used.\n */\nfunction modelScale(m: GlMat3): number {\n  const sx = Math.hypot(m[0], m[1]);\n  const sy = Math.hypot(m[3], m[4]);\n  return Math.sqrt(sx * sy) || 1;\n}\n\nexport function drawText(ctx: DrawContext, cmd: TextDrawCommand): void {\n  const style = resolveTextStyle(cmd.style);\n  const lineHeight = style.lineHeight;\n  const align = cmd.align ?? style.align;\n  const direction = cmd.direction ?? style.direction;\n  const maxWidth = cmd.maxWidth ?? Infinity;\n\n  // Screen threshold → world threshold. Zooming in lowers the world size that\n  // qualifies, which is the whole point: a 12px label at 8× zoom is 96 screen\n  // pixels of text and wants outlines exactly as much as a 96px heading does.\n  const minScreen = ctx.textOutlineMinScreenSize ?? OUTLINE_MIN_SCREEN_PX;\n  const outlineMinSize = Number.isFinite(minScreen)\n    ? minScreen / modelScale(ctx.state.transform)\n    : undefined;\n\n  const laid = cachedLayoutRuns(cmd.runs, {\n    maxWidth, alignWidth: cmd.width, lineHeight, align, direction, tabSize: style.tabSize, justify: cmd.justify, outlineMinSize,\n  });\n  // Decorations are checked too: text whose glyphs are all ink-free — every\n  // one still awaiting a dynamic-atlas bake, say — produces no groups at all\n  // while still carrying a rule that has to be drawn.\n  if (laid.groups.length === 0 && laid.decorations.length === 0) return;\n\n  // `laid` is origin-relative, so this is the command's position plus the\n  // verticalAlign shift. Applied at upload time, not baked in: the layout is\n  // shared and not ours to edit — a cached layout that absorbed either offset\n  // would gain another one every frame and slide off the page. Every consumer\n  // below adds them while packing vertices, which costs one addition inside\n  // loops that are already walking every vertex.\n  const dx = cmd.x;\n  const dy = cmd.y + verticalAlignOffset(cmd.verticalAlign, cmd.height, laid.bounds.height);\n\n  for (const group of laid.groups) {\n    if (group.source === 'outline') drawTextOutlineGroup(ctx, group, dx, dy);\n    else drawTextGroup(ctx, group, dx, dy);\n  }\n\n  drawTextDecorations(ctx, laid.decorations, dx, dy);\n}\n\n/**\n * Paint one group of tessellated glyph outlines.\n *\n * The whole group becomes a single mesh: cached em-space triangles are\n * transformed on the CPU into world space and appended to one buffer, so a\n * paragraph set in one face and color is one draw call — the same batching\n * the atlas tier gets from packing glyphs into one texture. The alternative,\n * a model matrix per glyph, would be a draw call per glyph.\n *\n * Going through `drawPathFillByKind` rather than straight to `pathFill` is\n * what makes gradient- and pattern-filled text fall out for free: a glyph\n * here is geometry like any other, and those programs shade in world space,\n * so they need nothing from the text pipeline.\n */\nfunction drawTextOutlineGroup(ctx: DrawContext, group: LaidOutGroup, dx: number, dy: number): void {\n  const fill = group.fill;\n  if (fill !== null) {\n    const mesh = outlineGroupMesh(group, dx, dy);\n    if (mesh) drawOutlineMesh(ctx, fill, mesh);\n  }\n\n  // Stroke after fill — Canvas2D's fillText-then-strokeText convention, and\n  // SVG's default paint-order. A second batched draw call over the same\n  // group, not a call per glyph.\n  const strokePaint = group.stroke?.paint;\n  if (!strokePaint) return;\n  const ribbon = outlineGroupStrokeMesh(group, dx, dy, ctx.state.transform);\n  if (ribbon) drawOutlineMesh(ctx, strokePaint, ribbon);\n}\n\n/**\n * Paint one merged glyph-outline mesh, staging it where it fits.\n *\n * Through `tryStageFill` rather than straight to `drawPathFillByKind`,\n * because a paragraph can mix tiers: a heading drawn as outlines and a caption\n * drawn from the atlas are groups of one command, and the atlas half now\n * stages. An outline that painted itself while glyphs sat staged behind it\n * would come out under them.\n */\nfunction drawOutlineMesh(ctx: DrawContext, fill: FillStyle, mesh: Mesh): void {\n  const paint = batchPaint(ctx, fill, false);\n  if (paint === null) return;\n  if (tryStageFill(ctx, mesh, paint)) return;\n  drawPathFillByKind(ctx, fill, ctx.meshCache.uploadTransient(mesh));\n}\n\n/**\n * Stage the rules an underline, strikethrough or overline asks for.\n *\n * Color resolution matches `drawTextGroup` exactly — including its ignoring\n * of `fill.opacity` — so a rule can never disagree with the glyphs it\n * underlines. They stage as ordinary rects, which is what keeps them in the\n * run their glyphs are in. A rule under a texture paint is geometry under it,\n * the way an outline glyph is.\n */\nfunction drawTextDecorations(\n  ctx: DrawContext, decorations: readonly LaidOutDecoration[], dx: number, dy: number,\n): void {\n  for (const d of decorations) {\n    if (glyphPaintKindOf(d.fill) !== null) {\n      drawOutlineMesh(ctx, d.fill, ruleMesh(d.x0 + dx, d.y0 + dy, d.x1 + dx, d.y1 + dy));\n      continue;\n    }\n    const [r, g, b, a] = 'color' in d.fill ? resolveColor(d.fill.color) : [0, 0, 0, 1];\n    let cut: ClipRect | null | undefined;\n    for (;;) {\n      const staged = stageSolid(ctx, 4);\n      if (ctx.drawBatch.pushRect(\n        d.x0 + dx, d.y0 + dy, d.x1 - d.x0, d.y1 - d.y0, ctx.state.transform,\n        r, g, b, a * (staged.foldsAlpha ? ctx.state.alpha : 1),\n      )) break;\n      cut = enterUncut(ctx);\n    }\n    if (cut !== undefined) leaveUncut(ctx, cut);\n  }\n}\n\nfunction ruleMesh(x0: number, y0: number, x1: number, y1: number): Mesh {\n  return {\n    vertices: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),\n    indices: new Uint32Array([0, 1, 2, 0, 2, 3]),\n  };\n}\n\n/**\n * Amount `a_synthBold` shifts the SDF threshold by when the resolver fell back\n * from a missing bold variant to the regular atlas. Tuned on Inter: it\n * thickens strokes about a pixel at 16px without breaking glyph topology.\n */\nconst SYNTH_BOLD_AMOUNT = 0.08;\n\n/**\n * Stage one group of atlas glyphs into the batch.\n *\n * Everything that used to be a uniform per group rides the vertices instead —\n * the text color, and the atlas as a slot index packed with the paint mode — so\n * a run off a baked MSDF atlas and one off the runtime canvas bake belong to\n * the same draw, and so does whatever else the page put around them. The\n * synthetic-bold threshold is the exception, and `StagedBatchState.synthBold`\n * says why.\n *\n * The synthetic oblique is the one that changes shape rather than home: the\n * old program skewed in the vertex stage against `u_synthItalic`, and the\n * batch places its own corners, so `pushGlyph` shears them as it places them.\n */\nfunction drawTextGroup(\n  ctx: DrawContext, group: LaidOutGroup, dx: number, dy: number,\n): void {\n  if (group.source === 'canvas') {\n    if (!syncDynamicPageTexture(ctx.textureCache, group.page)) return;\n  } else {\n    if (!ensureFontTexture(group.family, group.weight, group.style, ctx.textureCache)) return;\n  }\n  if (group.quads.length === 0) return;\n\n  const atlasId = group.source === 'canvas'\n    ? dynamicPageTextureId(group.page)\n    : textureCacheKey(group.family, group.weight, group.style);\n  const mode = group.source === 'canvas' ? GLYPH_MODE_R8 : GLYPH_MODE_MSDF;\n  const fieldScale = glyphFieldScale(\n    group.source === 'canvas' ? 'canvas' : 'atlas', group.family, group.weight, group.style,\n  );\n  if (!fieldScale) return;\n  const bold = group.synthetic.bold ? SYNTH_BOLD_AMOUNT : 0;\n  const tanItalic = group.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;\n  const paintKind = glyphPaintKindOf(group.fill);\n  if (paintKind !== null) {\n    drawPaintedGlyphs(ctx, group, dx, dy, paintKind, atlasId, mode, bold, tanItalic, fieldScale);\n    return;\n  }\n  const color = group.fill !== null && 'color' in group.fill\n    ? resolveColor(group.fill.color)\n    : [0, 0, 0, 1];\n\n  const batch = ctx.drawBatch;\n  const m = ctx.state.transform;\n  let { staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold);\n  let alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);\n\n  for (const q of group.quads) {\n    if (batch.wouldOverflow(4)) {\n      flushBatch(ctx);\n      ({ staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold));\n      alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);\n    }\n    let cut: ClipRect | null | undefined;\n    while (!batch.pushGlyph(\n      q.x0 + dx, q.y0 + dy, q.x1 + dx, q.y1 + dy, q.baselineY + dy, tanItalic, m,\n      q.u0, q.v0, q.u1, q.v1,\n      color[0], color[1], color[2], alpha,\n      slot, mode,\n    )) {\n      cut = enterUncut(ctx);\n      ({ staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold));\n      alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);\n    }\n    if (cut !== undefined) {\n      leaveUncut(ctx, cut);\n      ({ staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold));\n      alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);\n    }\n  }\n}\n\n/** Which glyph-paint program `fill` needs, or `null` for a paint the batch\n *  draws as one color. */\nfunction glyphPaintKindOf(fill: FillStyle | null): GlyphPaintKind | null {\n  const kind = fill?.fill ?? 'solid';\n  if (kind === 'pattern') return 'pattern';\n  if (kind === 'linear-gradient' || kind === 'radial-gradient' || kind === 'conic-gradient') {\n    return 'gradient';\n  }\n  return kind === 'solid' ? null : 'texture';\n}\n\n/** The atlas's unit while a glyph-paint run draws; the paint has unit 0. */\nconst GLYPH_PAINT_ATLAS_UNIT = 1;\n\n/**\n * Draw one group of atlas glyphs with a texture paint, its coverage masking\n * the paint — see `shaders/glyphPaint.ts`.\n *\n * Its own draw, as a pattern-filled path is: the glyph vertex has no room for\n * a paint coordinate beside its atlas one, and widening it would cost every\n * vertex in every run. The quads still stage through `DrawBatch`, drained\n * first, and are drawn from it here before anything else can stage behind\n * them, so no run ever holds them and nothing outside this function has to\n * know they exist.\n */\nfunction drawPaintedGlyphs(\n  ctx: DrawContext, group: LaidOutGroup, dx: number, dy: number,\n  kind: GlyphPaintKind, atlasId: string, mode: number, bold: number, tanItalic: number,\n  fieldScale: readonly [number, number],\n): void {\n  const prog = ctx.glyphPaintProgram?.(kind);\n  if (!prog) return;\n  flushForOwnDraw(ctx);\n  const fill = group.fill!;\n  const m = ctx.state.transform;\n  let bound: ShaderProgram | null;\n  if (kind === 'pattern') {\n    bound = bindPattern(ctx, prog, fill as Extract<FillStyle, { fill: 'pattern' }>, BATCH_MODEL);\n  } else if (kind === 'gradient') {\n    bound = bindGradient(ctx, prog, fill as Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>, BATCH_MODEL);\n  } else {\n    const painted = renderPaintToScratch(ctx, fill, glyphScreenBounds(group, dx, dy, tanItalic, m));\n    bound = painted && bindScratchPaint(ctx, prog, painted);\n  }\n  if (!bound) return;\n  const gl = ctx.gl;\n  ctx.textureCache.bind(atlasId, GLYPH_PAINT_ATLAS_UNIT);\n  gl.uniform1i(prog.uniform('u_atlas')!, GLYPH_PAINT_ATLAS_UNIT);\n  gl.uniform1f(prog.uniform('u_synthBold')!, bold);\n  gl.uniform2f(prog.uniform('u_fieldScale')!, fieldScale[0], fieldScale[1]);\n  applyClipTest(ctx);\n\n  const batch = ctx.drawBatch;\n  // `flushForOwnDraw` put every clip on the stencil, which this draw tests.\n  const cut = batch.clip;\n  batch.clip = null;\n  for (const q of group.quads) {\n    if (batch.wouldOverflow(4)) drawStagedGlyphs(ctx);\n    batch.pushGlyph(\n      q.x0 + dx, q.y0 + dy, q.x1 + dx, q.y1 + dy, q.baselineY + dy, tanItalic, m,\n      q.u0, q.v0, q.u1, q.v1,\n      1, 1, 1, 1,\n      GLYPH_PAINT_ATLAS_UNIT, mode,\n    );\n  }\n  drawStagedGlyphs(ctx);\n  batch.clip = cut;\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindVertexArray(null);\n}\n\nfunction drawStagedGlyphs(ctx: DrawContext): void {\n  const batch = ctx.drawBatch;\n  if (batch.length === 0) return;\n  drawTriangles(ctx, batch.uploadAndBind(), ctx.gl.UNSIGNED_INT);\n  batch.reset();\n}\n\n/** The screen-space box of a group's glyph quads, corner for corner as\n *  `DrawBatch.pushGlyph` places them. */\nfunction glyphScreenBounds(\n  group: LaidOutGroup, dx: number, dy: number, tanItalic: number, m: GlMat3,\n): ScreenRect {\n  const b = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };\n  const add = (x: number, y: number) => {\n    const sx = m[0] * x + m[3] * y + m[6];\n    const sy = m[1] * x + m[4] * y + m[7];\n    if (sx < b.x0) b.x0 = sx;\n    if (sx > b.x1) b.x1 = sx;\n    if (sy < b.y0) b.y0 = sy;\n    if (sy > b.y1) b.y1 = sy;\n  };\n  for (const q of group.quads) {\n    const x0 = q.x0 + dx, x1 = q.x1 + dx, y0 = q.y0 + dy, y1 = q.y1 + dy;\n    const base = q.baselineY + dy;\n    const top = (base - y0) * tanItalic;\n    const bottom = (base - y1) * tanItalic;\n    add(x0 + top, y0);\n    add(x1 + top, y0);\n    add(x1 + bottom, y1);\n    add(x0 + bottom, y1);\n  }\n  return b;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAiDA,IAAaA,IAAwB;AAarC,SAASC,EAAW,GAAmB;CACrC,IAAMC,IAAK,KAAK,MAAMC,EAAE,IAAIA,EAAE,EAAE,GAC1BC,IAAK,KAAK,MAAMD,EAAE,IAAIA,EAAE,EAAE;CAChC,OAAO,KAAK,KAAKD,IAAKE,CAAE,KAAK;AAC/B;AAEA,SAAgBC,EAAS,GAAkB,GAA4B;CACrE,IAAMC,IAAQC,EAAiBC,EAAI,KAAK,GAClCC,IAAaH,EAAM,YACnBI,IAAQF,EAAI,SAASF,EAAM,OAC3BK,IAAYH,EAAI,aAAaF,EAAM,WACnCM,IAAWJ,EAAI,YAAY,UAK3BK,IAAYC,EAAI,4BAA4Bd,GAC5Ce,IAAiB,OAAO,SAASF,CAAS,IAC5CA,IAAYZ,EAAWa,EAAI,MAAM,SAAS,IAC1C,KAAA,GAEEE,IAAOC,EAAiBT,EAAI,MAAM;EACtC;EAAU,YAAYA,EAAI;EAAO;EAAY;EAAO;EAAW,SAASF,EAAM;EAAS,SAASE,EAAI;EAAS;CAC/G,CAAC;CAID,IAAIQ,EAAK,OAAO,WAAW,KAAKA,EAAK,YAAY,WAAW,GAAG;CAQ/D,IAAME,IAAKV,EAAI,GACTW,IAAKX,EAAI,IAAIY,EAAoBZ,EAAI,eAAeA,EAAI,QAAQQ,EAAK,OAAO,MAAM;CAExF,KAAK,IAAMK,KAASL,EAAK,QACvB,AAAIK,EAAM,WAAW,YAAWC,EAAqBR,GAAKO,GAAOH,GAAIC,CAAE,IAClEI,EAAcT,GAAKO,GAAOH,GAAIC,CAAE;CAGvC,EAAoBL,GAAKE,EAAK,aAAaE,GAAIC,CAAE;AACnD;AAgBA,SAASG,EAAqB,GAAkB,GAAqB,GAAY,GAAkB;CACjG,IAAME,IAAOH,EAAM;CACnB,IAAIG,MAAS,MAAM;EACjB,IAAMC,IAAOC,EAAiBL,GAAOH,GAAIC,CAAE;EAC3C,AAAIM,KAAME,EAAgBb,GAAKU,GAAMC,CAAI;CAC3C;CAKA,IAAMG,IAAcP,EAAM,QAAQ;CAClC,IAAI,CAACO,GAAa;CAClB,IAAMC,IAASC,EAAuBT,GAAOH,GAAIC,GAAIL,EAAI,MAAM,SAAS;CACxE,AAAIe,KAAQF,EAAgBb,GAAKc,GAAaC,CAAM;AACtD;AAWA,SAASF,EAAgB,GAAkB,GAAiB,GAAkB;CAC5E,IAAMI,IAAQC,EAAWlB,GAAKU,GAAM,EAAK;CACzC,AAAIO,MAAU,SACVE,EAAanB,GAAKW,GAAMM,CAAK,KACjCG,EAAmBpB,GAAKU,GAAMV,EAAI,UAAU,gBAAgBW,CAAI,CAAC;AACnE;AAWA,SAASU,EACP,GAAkB,GAA2C,GAAY,GACnE;CACN,KAAK,IAAMC,KAAKC,GAAa;EAC3B,IAAIC,EAAiBF,EAAE,IAAI,MAAM,MAAM;GACrC,EAAgBtB,GAAKsB,EAAE,MAAMG,EAASH,EAAE,KAAKlB,GAAIkB,EAAE,KAAKjB,GAAIiB,EAAE,KAAKlB,GAAIkB,EAAE,KAAKjB,CAAE,CAAC;GACjF;EACF;EACA,IAAM,CAACqB,GAAGC,GAAGC,GAAGC,KAAK,WAAWP,EAAE,OAAOQ,EAAaR,EAAE,KAAK,KAAK,IAAI;GAAC;GAAG;GAAG;GAAG;EAAC,GAC7ES;EACJ,SAAS;GACP,IAAMC,IAASC,EAAWjC,GAAK,CAAC;GAChC,IAAIA,EAAI,UAAU,SAChBsB,EAAE,KAAKlB,GAAIkB,EAAE,KAAKjB,GAAIiB,EAAE,KAAKA,EAAE,IAAIA,EAAE,KAAKA,EAAE,IAAItB,EAAI,MAAM,WAC1D0B,GAAGC,GAAGC,GAAGC,KAAKG,EAAO,aAAahC,EAAI,MAAM,QAAQ,EACtD,GAAG;GACH,IAAMkC,EAAWlC,CAAG;EACtB;EACA,AAAI+B,MAAQ,KAAA,KAAWI,EAAWnC,GAAK+B,CAAG;CAC5C;AACF;AAEA,SAASN,EAAS,GAAY,GAAY,GAAY,GAAkB;CACtE,OAAO;EACL,UAAU,IAAI,aAAa;GAACW;GAAIC;GAAIC;GAAID;GAAIC;GAAIC;GAAIH;GAAIG;EAAE,CAAC;EAC3D,SAAS,IAAI,YAAY;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;EAAC,CAAC;CAC7C;AACF;AAOA,IAAMC,IAAoB;AAgB1B,SAAS/B,EACP,GAAkB,GAAqB,GAAY,GAC7C;CACN,IAAIF,EAAM,WAAW,UACf;MAAA,CAACkC,EAAuBzC,EAAI,cAAcO,EAAM,IAAI,GAAG;CAAA,OAE3D,IAAI,CAACmC,EAAkBnC,EAAM,QAAQA,EAAM,QAAQA,EAAM,OAAOP,EAAI,YAAY,GAAG;CAErF,IAAIO,EAAM,MAAM,WAAW,GAAG;CAE9B,IAAMoC,IAAUpC,EAAM,WAAW,WAC7BqC,EAAqBrC,EAAM,IAAI,IAC/BsC,EAAgBtC,EAAM,QAAQA,EAAM,QAAQA,EAAM,KAAK,GACrDuC,IAAOvC,EAAM,WAAW,WAAWwC,IAAgBC,GACnDC,IAAaC,EACjB3C,EAAM,WAAW,WAAW,WAAW,SAASA,EAAM,QAAQA,EAAM,QAAQA,EAAM,KACpF;CACA,IAAI,CAAC0C,GAAY;CACjB,IAAME,IAAO5C,EAAM,UAAU,OAAOiC,IAAoB,GAClDY,IAAY7C,EAAM,UAAU,SAAS,KAAK,IAAI8C,CAAwB,IAAI,GAC1EC,IAAY9B,EAAiBjB,EAAM,IAAI;CAC7C,IAAI+C,MAAc,MAAM;EACtB,EAAkBtD,GAAKO,GAAOH,GAAIC,GAAIiD,GAAWX,GAASG,GAAMK,GAAMC,GAAWH,CAAU;EAC3F;CACF;CACA,IAAMM,IAAQhD,EAAM,SAAS,QAAQ,WAAWA,EAAM,OAClDuB,EAAavB,EAAM,KAAK,KAAK,IAC7B;EAAC;EAAG;EAAG;EAAG;CAAC,GAETiD,IAAQxD,EAAI,WACZX,IAAIW,EAAI,MAAM,WAChB,EAAE,WAAQ,YAASyD,EAAYzD,GAAK2C,GAASM,GAAYE,CAAI,GAC7DO,IAAQH,EAAM,MAAMvB,EAAO,aAAahC,EAAI,MAAM,QAAQ;CAE9D,KAAK,IAAM2D,KAAKpD,EAAM,OAAO;EAC3B,AAAIiD,EAAM,cAAc,CAAC,MACvBI,EAAW5D,CAAG,GACb,uBAAmByD,EAAYzD,GAAK2C,GAASM,GAAYE,CAAI,GAC9D,IAAQI,EAAM,MAAMvB,EAAO,aAAahC,EAAI,MAAM,QAAQ;EAE5D,IAAI+B;EACJ,OAAO,CAACyB,EAAM,UACZG,EAAE,KAAKvD,GAAIuD,EAAE,KAAKtD,GAAIsD,EAAE,KAAKvD,GAAIuD,EAAE,KAAKtD,GAAIsD,EAAE,YAAYtD,GAAI+C,GAAW/D,GACzEsE,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE,IACpBJ,EAAM,IAAIA,EAAM,IAAIA,EAAM,IAAIG,GAC9BG,GAAMf,CACR,IAGE,AAFA,IAAMZ,EAAWlC,CAAG,GACnB,uBAAmByD,EAAYzD,GAAK2C,GAASM,GAAYE,CAAI,GAC9D,IAAQI,EAAM,MAAMvB,EAAO,aAAahC,EAAI,MAAM,QAAQ;EAE5D,AAAI+B,MAAQ,KAAA,MACVI,EAAWnC,GAAK+B,CAAG,GAClB,uBAAmB0B,EAAYzD,GAAK2C,GAASM,GAAYE,CAAI,GAC9D,IAAQI,EAAM,MAAMvB,EAAO,aAAahC,EAAI,MAAM,QAAQ;CAE9D;AACF;AAIA,SAASwB,EAAiB,GAA+C;CACvE,IAAMsC,IAAOpD,GAAM,QAAQ;CAK3B,OAJIoD,MAAS,YAAkB,YAC3BA,MAAS,qBAAqBA,MAAS,qBAAqBA,MAAS,mBAChE,aAEFA,MAAS,UAAU,OAAO;AACnC;AAGA,IAAMC,IAAyB;AAa/B,SAASC,EACP,GAAkB,GAAqB,GAAY,GACnD,GAAsB,GAAiB,GAAc,GAAc,GACnE,GACM;CACN,IAAMC,IAAOjE,EAAI,oBAAoB8D,CAAI;CACzC,IAAI,CAACG,GAAM;CACX,EAAgBjE,CAAG;CACnB,IAAMU,IAAOH,EAAM,MACblB,IAAIW,EAAI,MAAM,WAChBkE;CACJ,IAAIJ,MAAS,WACX,IAAQK,EAAYnE,GAAKiE,GAAMvD,GAAiD0D,CAAW;MACtF,IAAIN,MAAS,YAClB,IAAQO,EAAarE,GAAKiE,GAAMvD,GAAgG0D,CAAW;MACtI;EACL,IAAME,IAAUC,EAAqBvE,GAAKU,GAAM8D,EAAkBjE,GAAOH,GAAIC,GAAI+C,GAAW/D,CAAC,CAAC;EAC9F,IAAQiF,KAAWG,EAAiBzE,GAAKiE,GAAMK,CAAO;CACxD;CACA,IAAI,CAACJ,GAAO;CACZ,IAAMQ,IAAK1E,EAAI;CAKf,AAJAA,EAAI,aAAa,KAAK2C,GAASoB,CAAsB,GACrDW,EAAG,UAAUT,EAAK,QAAQ,SAAS,GAAIF,CAAsB,GAC7DW,EAAG,UAAUT,EAAK,QAAQ,aAAa,GAAId,CAAI,GAC/CuB,EAAG,UAAUT,EAAK,QAAQ,cAAc,GAAIhB,EAAW,IAAIA,EAAW,EAAE,GACxE0B,EAAc3E,CAAG;CAEjB,IAAMwD,IAAQxD,EAAI,WAEZ+B,IAAMyB,EAAM;CAClB,EAAM,OAAO;CACb,KAAK,IAAMG,KAAKpD,EAAM,OAEpB,AADIiD,EAAM,cAAc,CAAC,KAAGoB,EAAiB5E,CAAG,GAChDwD,EAAM,UACJG,EAAE,KAAKvD,GAAIuD,EAAE,KAAKtD,GAAIsD,EAAE,KAAKvD,GAAIuD,EAAE,KAAKtD,GAAIsD,EAAE,YAAYtD,GAAI+C,GAAW/D,GACzEsE,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE,IACpB,GAAG,GAAG,GAAG,GACTI,GAAwBjB,CAC1B;CAKF,AAHA8B,EAAiB5E,CAAG,GACpB,EAAM,OAAO+B,GACb2C,EAAG,cAAcA,EAAG,QAAQ,GAC5BA,EAAG,gBAAgB,IAAI;AACzB;AAEA,SAASE,EAAiB,GAAwB;CAChD,IAAMpB,IAAQxD,EAAI;CAClB,AAAIwD,EAAM,WAAW,MACrBqB,EAAc7E,GAAKwD,EAAM,cAAc,GAAGxD,EAAI,GAAG,YAAY,GAC7DwD,EAAM,MAAM;AACd;AAIA,SAASgB,EACP,GAAqB,GAAY,GAAY,GAAmB,GACpD;CACZ,IAAM5C,IAAI;EAAE,IAAI;EAAU,IAAI;EAAU,IAAI;EAAW,IAAI;CAAU,GAC/DkD,KAAO,GAAW,MAAc;EACpC,IAAM1F,IAAKC,EAAE,KAAK0F,IAAI1F,EAAE,KAAK2F,IAAI3F,EAAE,IAC7BC,IAAKD,EAAE,KAAK0F,IAAI1F,EAAE,KAAK2F,IAAI3F,EAAE;EAInC,AAHID,IAAKwC,EAAE,OAAI,EAAE,KAAKxC,IAClBA,IAAKwC,EAAE,OAAI,EAAE,KAAKxC,IAClBE,IAAKsC,EAAE,OAAI,EAAE,KAAKtC,IAClBA,IAAKsC,EAAE,OAAI,EAAE,KAAKtC;CACxB;CACA,KAAK,IAAMqE,KAAKpD,EAAM,OAAO;EAC3B,IAAM6B,IAAKuB,EAAE,KAAKvD,GAAIkC,IAAKqB,EAAE,KAAKvD,GAAIiC,IAAKsB,EAAE,KAAKtD,GAAIkC,IAAKoB,EAAE,KAAKtD,GAC5D4E,IAAOtB,EAAE,YAAYtD,GACrB6E,KAAOD,IAAO5C,KAAMe,GACpB+B,KAAUF,IAAO1C,KAAMa;EAI7B,AAHA0B,EAAI1C,IAAK8C,GAAK7C,CAAE,GAChByC,EAAIxC,IAAK4C,GAAK7C,CAAE,GAChByC,EAAIxC,IAAK6C,GAAQ5C,CAAE,GACnBuC,EAAI1C,IAAK+C,GAAQ5C,CAAE;CACrB;CACA,OAAOX;AACT"}

package/dist/renderer/draw/uniforms.js

@@ -0,0 +1,77 @@
+import { resolveColor as e } from "../math/color.js";
+import { mat3 as t } from "../math/mat3.js";
+//#region src/renderer/draw/uniforms.ts
+var n = /* @__PURE__ */ new WeakMap(), r = /* @__PURE__ */ new WeakMap();
+function i(e, t) {
+	let r = n.get(e);
+	r || (r = /* @__PURE__ */ new WeakMap(), n.set(e, r));
+	let i = r.get(t);
+	return i || (i = {}, r.set(t, i)), i;
+}
+function a(e, t) {
+	if (e === void 0 || e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+function o(e, t, n, r, a, o) {
+	let s = t.uniform("u_color");
+	if (s === void 0) return;
+	let c = i(e, t), l = c.color;
+	(l === void 0 || l[0] !== n || l[1] !== r || l[2] !== a || l[3] !== o) && (e.gl.uniform4f(s, n, r, a, o), c.color = [
+		n,
+		r,
+		a,
+		o
+	]);
+}
+function s(e, t, n) {
+	let r = t.uniform("u_alpha");
+	if (r === void 0) return;
+	let a = i(e, t);
+	a.alpha !== n && (e.gl.uniform1f(r, n), a.alpha = n);
+}
+function c(e) {
+	let n = r.get(e);
+	return n || (n = t.toUniform(t.screenToClip(e.widthCss, e.heightCss)), r.set(e, n)), n;
+}
+var l = /* @__PURE__ */ new Float32Array(16);
+function u(e, t, n = e.state.colorMatrix) {
+	let r = e.gl, o = i(e, t), s = t.uniform("u_colorMatrix");
+	if (s !== void 0) {
+		for (let e = 0; e < 4; e++) for (let t = 0; t < 4; t++) l[t * 4 + e] = n[e * 5 + t];
+		a(o.colorMatrix, l) || (r.uniformMatrix4fv(s, !1, l), o.colorMatrix = Float32Array.from(l));
+	}
+	let c = t.uniform("u_colorBias");
+	if (c !== void 0) {
+		let e = [
+			n[4],
+			n[9],
+			n[14],
+			n[19]
+		];
+		a(o.colorBias, e) || (r.uniform4f(c, e[0], e[1], e[2], e[3]), o.colorBias = Float32Array.from(e));
+	}
+}
+var d = 65536, f = /* @__PURE__ */ new Float32Array(9), p = /* @__PURE__ */ new Float32Array(9);
+function m(e, t, n = e.state.transform, r = c(e)) {
+	let o = e.gl, s = i(e, t);
+	p.set(r), a(s.proj, p) || (o.uniformMatrix3fv(t.uniform("u_proj"), !1, p), s.proj = Float32Array.from(p)), f.set(n);
+	let l = t.uniform("u_origin");
+	if (l !== void 0) {
+		let e = 0, t = 0, r = n[6], i = n[7];
+		if (Math.abs(r) >= d || Math.abs(i) >= d) {
+			let a = n[0], o = n[1], s = n[3], c = n[4], l = a * c - o * s, u = Math.fround((s * i - c * r) / l), d = Math.fround((o * r - a * i) / l);
+			Number.isFinite(u) && Number.isFinite(d) && (e = u, t = d, f[6] = a * e + s * t + r, f[7] = o * e + c * t + i);
+		}
+		(s.originX !== e || s.originY !== t) && (o.uniform2f(l, e, t), s.originX = e, s.originY = t);
+	}
+	a(s.model, f) || (o.uniformMatrix3fv(t.uniform("u_model"), !1, f), s.model = Float32Array.from(f));
+}
+function h(t, n, r, i) {
+	let [a, c, l, u] = e(r);
+	o(t, n, a, c, l, u * (i ?? 1)), s(t, n, t.state.alpha);
+}
+//#endregion
+export { d as REBASE_TRANSLATION_PX, a as sameValues, s as setAlphaUniform, u as setColorMatrixUniforms, o as setColorUniform, m as setProjAndModel, h as setSolidPaintUniforms };
+
+//# sourceMappingURL=uniforms.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uniforms.js","names":["FRAME_UPLOADS","FRAME_PROJ","uploadedFor","byProgram","ctx","uploaded","prog","sameValues","prev","next","i","setColorUniform","loc","r","g","b","a","setAlphaUniform","alpha","projFor","proj","mat3","COLOR_MATRIX_SCRATCH","setColorMatrixUniforms","gl","mLoc","row","col","cm","bLoc","bias","REBASE_TRANSLATION_PX","MODEL_SCRATCH","PROJ_SCRATCH","setProjAndModel","model","originLoc","ox","oy","tx","ty","c","d","det","lx","ly","setSolidPaintUniforms","resolveColor","color","opacity"],"sources":["../../../src/renderer/draw/uniforms.ts"],"sourcesContent":["import type { ShaderProgram } from '../shaders/ShaderProgram';\nimport { mat3, type GlMat3 } from '../math/mat3';\nimport { resolveColor } from '../math/color';\nimport type { DrawContext } from './drawContext';\n\n/**\n * Uniform values a program already holds this frame.\n *\n * GL keeps uniform state per program object, so re-sending a value the program\n * already has buys nothing. `u_proj` is constant for the whole frame and\n * `u_colorMatrix` is the identity in every scene that does not use one, yet\n * both were re-sent for every command: at a few thousand commands the two were\n * most of the frame.\n *\n * Keyed on the `DrawContext`, which `WeaselRenderer.render` builds fresh per\n * frame, so the cache cannot outlive a frame and go stale against GL state\n * that changed between them.\n *\n * **Only for uniforms this module is the sole writer of.** `u_color` and\n * `u_alpha` qualify because every write of them goes through `setColorUniform`\n * / `setAlphaUniform` — keep it that way. A `gl.uniform4f(… 'u_color' …)` added\n * anywhere else leaves the cache believing a value the program no longer has,\n * and the wrong color is drawn until something else moves it.\n */\ninterface UploadedUniforms {\n  proj?: Float32Array;\n  model?: Float32Array;\n  colorMatrix?: Float32Array;\n  colorBias?: Float32Array;\n  originX?: number;\n  originY?: number;\n  /** Held as plain numbers, not a `Float32Array`: the caller's values are\n   *  doubles, and round-tripping them through float32 would compare unequal\n   *  every time and never skip an upload. */\n  color?: [number, number, number, number];\n  alpha?: number;\n}\n\nconst FRAME_UPLOADS = new WeakMap<DrawContext, WeakMap<ShaderProgram, UploadedUniforms>>();\n\nconst FRAME_PROJ = new WeakMap<DrawContext, GlMat3>();\n\nfunction uploadedFor(ctx: DrawContext, prog: ShaderProgram): UploadedUniforms {\n  let byProgram = FRAME_UPLOADS.get(ctx);\n  if (!byProgram) {\n    byProgram = new WeakMap();\n    FRAME_UPLOADS.set(ctx, byProgram);\n  }\n  let uploaded = byProgram.get(prog);\n  if (!uploaded) {\n    uploaded = {};\n    byProgram.set(prog, uploaded);\n  }\n  return uploaded;\n}\n\n/** Element-wise, so a caller that mutates a shared array in place is still\n *  compared by value. A NaN anywhere compares unequal and re-uploads, which is\n *  the safe direction. */\nexport function sameValues(prev: Float32Array | undefined, next: ArrayLike<number>): boolean {\n  if (prev === undefined || prev.length !== next.length) return false;\n  for (let i = 0; i < prev.length; i++) if (prev[i] !== next[i]) return false;\n  return true;\n}\n\n/**\n * `u_color`, skipped when the program already holds it.\n *\n * Every writer of `u_color` goes through here — see `UploadedUniforms`. The\n * solid batch is what makes it worth caching: it holds the uniform at white\n * forever and flushed once per state change, so a mixed document re-sent the\n * same white a few hundred times a frame.\n */\nexport function setColorUniform(\n  ctx: DrawContext, prog: ShaderProgram,\n  r: number, g: number, b: number, a: number,\n): void {\n  const loc = prog.uniform('u_color');\n  if (loc === undefined) return;\n  const uploaded = uploadedFor(ctx, prog);\n  const prev = uploaded.color;\n  if (prev !== undefined && prev[0] === r && prev[1] === g && prev[2] === b && prev[3] === a) {\n    return;\n  }\n  ctx.gl.uniform4f(loc, r, g, b, a);\n  uploaded.color = [r, g, b, a];\n}\n\n/** `u_alpha`, on the same terms as `setColorUniform`. */\nexport function setAlphaUniform(ctx: DrawContext, prog: ShaderProgram, alpha: number): void {\n  const loc = prog.uniform('u_alpha');\n  if (loc === undefined) return;\n  const uploaded = uploadedFor(ctx, prog);\n  if (uploaded.alpha === alpha) return;\n  ctx.gl.uniform1f(loc, alpha);\n  uploaded.alpha = alpha;\n}\n\n/** The screen→clip matrix depends only on the frame's dimensions. */\nfunction projFor(ctx: DrawContext): GlMat3 {\n  let proj = FRAME_PROJ.get(ctx);\n  if (!proj) {\n    proj = mat3.toUniform(mat3.screenToClip(ctx.widthCss, ctx.heightCss));\n    FRAME_PROJ.set(ctx, proj);\n  }\n  return proj;\n}\n\n/** Reused across draws: the transpose below rebuilt this every command. */\nconst COLOR_MATRIX_SCRATCH = new Float32Array(16);\n\nexport function setColorMatrixUniforms(\n  ctx: DrawContext, prog: ShaderProgram,\n  cm: Float32Array = ctx.state.colorMatrix, // row-major 4×5\n): void {\n  const gl = ctx.gl;\n  const uploaded = uploadedFor(ctx, prog);\n\n  const mLoc = prog.uniform('u_colorMatrix');\n  if (mLoc !== undefined) {\n    for (let row = 0; row < 4; row++) {\n      for (let col = 0; col < 4; col++) {\n        COLOR_MATRIX_SCRATCH[col * 4 + row] = cm[row * 5 + col];\n      }\n    }\n    if (!sameValues(uploaded.colorMatrix, COLOR_MATRIX_SCRATCH)) {\n      gl.uniformMatrix4fv(mLoc, false, COLOR_MATRIX_SCRATCH);\n      uploaded.colorMatrix = Float32Array.from(COLOR_MATRIX_SCRATCH);\n    }\n  }\n\n  const bLoc = prog.uniform('u_colorBias');\n  if (bLoc !== undefined) {\n    const bias = [cm[4], cm[9], cm[14], cm[19]];\n    if (!sameValues(uploaded.colorBias, bias)) {\n      gl.uniform4f(bLoc, bias[0], bias[1], bias[2], bias[3]);\n      uploaded.colorBias = Float32Array.from(bias);\n    }\n  }\n}\n\n/** A model translation at or past this many pixels is rebased before upload:\n *  a float32 there is coarser than 1/128 px, and at 2^24 than a whole one. */\nexport const REBASE_TRANSLATION_PX = 65536;\n\nconst MODEL_SCRATCH = new Float32Array(9);\nconst PROJ_SCRATCH = new Float32Array(9);\n\n/**\n * `u_proj` and `u_model`, each skipped when the program already holds it.\n *\n * `model` is in doubles and the uniform is not. Far from the origin at high\n * zoom its translation is millions of pixels, which a float32 holds to a\n * whole pixel at best, and the shader then adds that to vertex coordinates\n * just as large. A program that declares `u_origin` computes\n * `u_model * (a_position - u_origin)`, so for a large translation this sends\n * the local point that lands on the screen's corner as `u_origin` and a model\n * whose translation is what is left over, a few pixels. Any origin draws the\n * same place; this one keeps every number the GPU touches screen-sized.\n */\nexport function setProjAndModel(\n  ctx: DrawContext, prog: ShaderProgram,\n  model: GlMat3 = ctx.state.transform,\n  proj: GlMat3 = projFor(ctx),\n): void {\n  const gl = ctx.gl;\n  const uploaded = uploadedFor(ctx, prog);\n\n  PROJ_SCRATCH.set(proj);\n  if (!sameValues(uploaded.proj, PROJ_SCRATCH)) {\n    gl.uniformMatrix3fv(prog.uniform('u_proj')!, false, PROJ_SCRATCH);\n    uploaded.proj = Float32Array.from(PROJ_SCRATCH);\n  }\n\n  MODEL_SCRATCH.set(model);\n  const originLoc = prog.uniform('u_origin');\n  if (originLoc !== undefined) {\n    let ox = 0;\n    let oy = 0;\n    const tx = model[6], ty = model[7];\n    if (Math.abs(tx) >= REBASE_TRANSLATION_PX || Math.abs(ty) >= REBASE_TRANSLATION_PX) {\n      const a = model[0], b = model[1], c = model[3], d = model[4];\n      const det = a * d - b * c;\n      // Rounded first: the shader subtracts the float32 it was sent.\n      const lx = Math.fround((c * ty - d * tx) / det);\n      const ly = Math.fround((b * tx - a * ty) / det);\n      if (Number.isFinite(lx) && Number.isFinite(ly)) {\n        ox = lx;\n        oy = ly;\n        MODEL_SCRATCH[6] = a * ox + c * oy + tx;\n        MODEL_SCRATCH[7] = b * ox + d * oy + ty;\n      }\n    }\n    if (uploaded.originX !== ox || uploaded.originY !== oy) {\n      gl.uniform2f(originLoc, ox, oy);\n      uploaded.originX = ox;\n      uploaded.originY = oy;\n    }\n  }\n\n  if (!sameValues(uploaded.model, MODEL_SCRATCH)) {\n    gl.uniformMatrix3fv(prog.uniform('u_model')!, false, MODEL_SCRATCH);\n    uploaded.model = Float32Array.from(MODEL_SCRATCH);\n  }\n}\n\nexport function setSolidPaintUniforms(\n  ctx: DrawContext, prog: ShaderProgram,\n  color: string, opacity: number | undefined,\n): void {\n  const [r, g, b, a] = resolveColor(color);\n  setColorUniform(ctx, prog, r, g, b, a * (opacity ?? 1));\n  setAlphaUniform(ctx, prog, ctx.state.alpha);\n}\n"],"mappings":";;;AAsCA,IAAMA,oBAAgB,IAAI,QAA+D,GAEnFC,oBAAa,IAAI,QAA6B;AAEpD,SAASC,EAAY,GAAkB,GAAuC;CAC5E,IAAIC,IAAYH,EAAc,IAAII,CAAG;CACrC,AAAKD,MACH,oBAAY,IAAI,QAAQ,GACxBH,EAAc,IAAII,GAAKD,CAAS;CAElC,IAAIE,IAAWF,EAAU,IAAIG,CAAI;CAKjC,OAJKD,MACH,IAAW,CAAC,GACZF,EAAU,IAAIG,GAAMD,CAAQ,IAEvBA;AACT;AAKA,SAAgBE,EAAW,GAAgC,GAAkC;CAC3F,IAAIC,MAAS,KAAA,KAAaA,EAAK,WAAWC,EAAK,QAAQ,OAAO;CAC9D,KAAK,IAAIC,IAAI,GAAGA,IAAIF,EAAK,QAAQ,KAAK,IAAIA,EAAKE,OAAOD,EAAKC,IAAI,OAAO;CACtE,OAAO;AACT;AAUA,SAAgBC,EACd,GAAkB,GAClB,GAAW,GAAW,GAAW,GAC3B;CACN,IAAMC,IAAMN,EAAK,QAAQ,SAAS;CAClC,IAAIM,MAAQ,KAAA,GAAW;CACvB,IAAMP,IAAWH,EAAYE,GAAKE,CAAI,GAChCE,IAAOH,EAAS;CACtB,CAAIG,MAAS,KAAA,KAAaA,EAAK,OAAOK,KAAKL,EAAK,OAAOM,KAAKN,EAAK,OAAOO,KAAKP,EAAK,OAAOQ,OAGzFZ,EAAI,GAAG,UAAUQ,GAAKC,GAAGC,GAAGC,GAAGC,CAAC,GAChC,EAAS,QAAQ;EAACH;EAAGC;EAAGC;EAAGC;CAAC;AAC9B;AAGA,SAAgBC,EAAgB,GAAkB,GAAqB,GAAqB;CAC1F,IAAML,IAAMN,EAAK,QAAQ,SAAS;CAClC,IAAIM,MAAQ,KAAA,GAAW;CACvB,IAAMP,IAAWH,EAAYE,GAAKE,CAAI;CACtC,AAAID,EAAS,UAAUa,MACvBd,EAAI,GAAG,UAAUQ,GAAKM,CAAK,GAC3B,EAAS,QAAQA;AACnB;AAGA,SAASC,EAAQ,GAA0B;CACzC,IAAIC,IAAOnB,EAAW,IAAIG,CAAG;CAK7B,OAJKgB,MACH,IAAOC,EAAK,UAAUA,EAAK,aAAajB,EAAI,UAAUA,EAAI,SAAS,CAAC,GACpEH,EAAW,IAAIG,GAAKgB,CAAI,IAEnBA;AACT;AAGA,IAAME,oBAAuB,IAAI,aAAa,EAAE;AAEhD,SAAgBC,EACd,GAAkB,GAClB,IAAmBnB,EAAI,MAAM,aACvB;CACN,IAAMoB,IAAKpB,EAAI,IACTC,IAAWH,EAAYE,GAAKE,CAAI,GAEhCmB,IAAOnB,EAAK,QAAQ,eAAe;CACzC,IAAImB,MAAS,KAAA,GAAW;EACtB,KAAK,IAAIC,IAAM,GAAGA,IAAM,GAAG,KACzB,KAAK,IAAIC,IAAM,GAAGA,IAAM,GAAG,KACzB,EAAqBA,IAAM,IAAID,KAAOE,EAAGF,IAAM,IAAIC;EAGvD,AAAKpB,EAAWF,EAAS,aAAaiB,CAAoB,MACxDE,EAAG,iBAAiBC,GAAM,IAAOH,CAAoB,GACrD,EAAS,cAAc,aAAa,KAAKA,CAAoB;CAEjE;CAEA,IAAMO,IAAOvB,EAAK,QAAQ,aAAa;CACvC,IAAIuB,MAAS,KAAA,GAAW;EACtB,IAAMC,IAAO;GAACF,EAAG;GAAIA,EAAG;GAAIA,EAAG;GAAKA,EAAG;EAAG;EAC1C,AAAKrB,EAAWF,EAAS,WAAWyB,CAAI,MACtCN,EAAG,UAAUK,GAAMC,EAAK,IAAIA,EAAK,IAAIA,EAAK,IAAIA,EAAK,EAAE,GACrD,EAAS,YAAY,aAAa,KAAKA,CAAI;CAE/C;AACF;AAIA,IAAaC,IAAwB,OAE/BC,oBAAgB,IAAI,aAAa,CAAC,GAClCC,oBAAe,IAAI,aAAa,CAAC;AAcvC,SAAgBC,EACd,GAAkB,GAClB,IAAgB9B,EAAI,MAAM,WAC1B,IAAee,EAAQf,CAAG,GACpB;CACN,IAAMoB,IAAKpB,EAAI,IACTC,IAAWH,EAAYE,GAAKE,CAAI;CAQtC,AANA2B,EAAa,IAAIb,CAAI,GAChBb,EAAWF,EAAS,MAAM4B,CAAY,MACzCT,EAAG,iBAAiBlB,EAAK,QAAQ,QAAQ,GAAI,IAAO2B,CAAY,GAChE,EAAS,OAAO,aAAa,KAAKA,CAAY,IAGhDD,EAAc,IAAIG,CAAK;CACvB,IAAMC,IAAY9B,EAAK,QAAQ,UAAU;CACzC,IAAI8B,MAAc,KAAA,GAAW;EAC3B,IAAIC,IAAK,GACLC,IAAK,GACHC,IAAKJ,EAAM,IAAIK,IAAKL,EAAM;EAChC,IAAI,KAAK,IAAII,CAAE,KAAKR,KAAyB,KAAK,IAAIS,CAAE,KAAKT,GAAuB;GAClF,IAAM,IAAII,EAAM,IAAIpB,IAAIoB,EAAM,IAAIM,IAAIN,EAAM,IAAIO,IAAIP,EAAM,IACpDQ,IAAM,IAAID,IAAI3B,IAAI0B,GAElBG,IAAK,KAAK,QAAQH,IAAID,IAAKE,IAAIH,KAAMI,CAAG,GACxCE,IAAK,KAAK,QAAQ9B,IAAIwB,IAAK,IAAIC,KAAMG,CAAG;GAC9C,AAAI,OAAO,SAASC,CAAE,KAAK,OAAO,SAASC,CAAE,MAC3C,IAAKD,GACL,IAAKC,GACL,EAAc,KAAK,IAAIR,IAAKI,IAAIH,IAAKC,GACrC,EAAc,KAAKxB,IAAIsB,IAAKK,IAAIJ,IAAKE;EAEzC;EACA,CAAInC,EAAS,YAAYgC,KAAMhC,EAAS,YAAYiC,OAClDd,EAAG,UAAUY,GAAWC,GAAIC,CAAE,GAC9B,EAAS,UAAUD,GACnB,EAAS,UAAUC;CAEvB;CAEA,AAAK/B,EAAWF,EAAS,OAAO2B,CAAa,MAC3CR,EAAG,iBAAiBlB,EAAK,QAAQ,SAAS,GAAI,IAAO0B,CAAa,GAClE,EAAS,QAAQ,aAAa,KAAKA,CAAa;AAEpD;AAEA,SAAgBc,EACd,GAAkB,GAClB,GAAe,GACT;CACN,IAAM,CAACjC,GAAGC,GAAGC,GAAGC,KAAK+B,EAAaC,CAAK;CAEvC,AADArC,EAAgBP,GAAKE,GAAMO,GAAGC,GAAGC,GAAGC,KAAKiC,KAAW,EAAE,GACtDhC,EAAgBb,GAAKE,GAAMF,EAAI,MAAM,KAAK;AAC5C"}