@weasel-js/core 1.9.2 → 1.9.4

package/dist/renderer/draw/drawTriangles.js

@@ -0,0 +1,8 @@
+//#region src/renderer/draw/drawTriangles.ts
+function e(e, t, n) {
+	e.gl.drawElements(e.gl.TRIANGLES, t, n, 0), e.stats && e.stats.drawCalls++;
+}
+//#endregion
+export { e as drawTriangles };
+
+//# sourceMappingURL=drawTriangles.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drawTriangles.js","names":["drawTriangles","ctx","count","type"],"sources":["../../../src/renderer/draw/drawTriangles.ts"],"sourcesContent":["import type { DrawContext } from './drawContext';\n\n/** Every GL draw the renderer issues goes through here, so the frame's\n *  draw-call count cannot miss one. */\nexport function drawTriangles(ctx: DrawContext, count: number, type: number): void {\n  ctx.gl.drawElements(ctx.gl.TRIANGLES, count, type, 0);\n  if (ctx.stats) ctx.stats.drawCalls++;\n}\n"],"mappings":";AAIA,SAAgBA,EAAc,GAAkB,GAAe,GAAoB;CAEjF,AADAC,EAAI,GAAG,aAAaA,EAAI,GAAG,WAAWC,GAAOC,GAAM,CAAC,GAChDF,EAAI,SAAO,EAAI,MAAM;AAC3B"}

package/dist/renderer/draw/effects.js

@@ -0,0 +1,28 @@
+import { drawTriangles as e } from "./drawTriangles.js";
+import { setUniforms as t } from "./customShader.js";
+import { setColorMatrixUniforms as n } from "./uniforms.js";
+//#region src/renderer/draw/effects.ts
+function r(e, t, n, r) {
+	let i = e.gl, a = e.renderTarget ?? null;
+	i.bindFramebuffer(i.FRAMEBUFFER, a ? a.fbo : null), a ? i.viewport(0, 0, t, n) : (e.restoreTargetRect?.(), r && i.enable(i.SCISSOR_TEST));
+}
+function i(r, i, a, o, s, c, l, u) {
+	let d = r.gl;
+	d.useProgram(i.handle);
+	let f = i.attribute("a_position"), p = i.attribute("a_uv");
+	d.bindBuffer(d.ARRAY_BUFFER, r.quadVbo), d.bindBuffer(d.ELEMENT_ARRAY_BUFFER, r.quadIbo), f !== void 0 && f >= 0 && (d.enableVertexAttribArray(f), d.vertexAttribPointer(f, 2, d.FLOAT, !1, 16, 0)), p !== void 0 && p >= 0 && (d.enableVertexAttribArray(p), d.vertexAttribPointer(p, 2, d.FLOAT, !1, 16, 8)), d.activeTexture(d.TEXTURE0), d.bindTexture(d.TEXTURE_2D, a);
+	let m = i.uniform("u_source");
+	m !== void 0 && d.uniform1i(m, 0);
+	let h = i.uniform("u_resolution");
+	h !== void 0 && d.uniform2f(h, o, s);
+	let g = i.uniform("u_texel");
+	if (g !== void 0 && d.uniform2f(g, 1 / o, 1 / s), l) {
+		let e = i.uniform("u_alpha");
+		e !== void 0 && d.uniform1f(e, l.alpha), n(r, i, l.colorMatrix);
+	}
+	c && t(d, i, u ?? "effect", c, r.textureCache, { value: 1 }), e(r, 6, r.gl.UNSIGNED_SHORT), f !== void 0 && f >= 0 && d.disableVertexAttribArray(f), p !== void 0 && p >= 0 && d.disableVertexAttribArray(p), d.bindBuffer(d.ARRAY_BUFFER, null), d.bindBuffer(d.ELEMENT_ARRAY_BUFFER, null);
+}
+//#endregion
+export { i as drawFullscreenQuad, r as returnToRenderTarget };
+
+//# sourceMappingURL=effects.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effects.js","names":["returnToRenderTarget","gl","ctx","target","width","height","scissorWasOn","drawFullscreenQuad","program","aPos","aUv","texture","source","resolution","texel","composite","alpha","setColorMatrixUniforms","uniforms","setUniforms","programId","drawTriangles"],"sources":["../../../src/renderer/draw/effects.ts"],"sourcesContent":["import type { ShaderUniform } from '../shaders/registerProgram';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { setColorMatrixUniforms } from './uniforms';\nimport { setUniforms } from './customShader';\n\n/** Rebind `ctx.renderTarget` after an offscreen pass: a pooled target takes\n *  the whole `width` × `height` buffer, the default framebuffer the renderer's\n *  own rect and the scissor it had. */\nexport function returnToRenderTarget(\n  ctx: DrawContext, width: number, height: number, scissorWasOn: boolean,\n): void {\n  const gl = ctx.gl;\n  const target = ctx.renderTarget ?? null;\n  gl.bindFramebuffer(gl.FRAMEBUFFER, target ? target.fbo : null);\n  if (target) {\n    gl.viewport(0, 0, width, height);\n  } else {\n    ctx.restoreTargetRect?.();\n    if (scissorWasOn) gl.enable(gl.SCISSOR_TEST);\n  }\n}\n\n/** One pass: the kit quad, `u_source` bound to `texture`, and whatever else\n *  the caller supplies. Leaves no attribute arrays or buffers bound. */\nexport function drawFullscreenQuad(\n  ctx: DrawContext,\n  program: ShaderProgram,\n  texture: WebGLTexture,\n  width: number,\n  height: number,\n  uniforms?: Record<string, ShaderUniform>,\n  composite?: { alpha: number; colorMatrix: Float32Array },\n  programId?: string,\n): void {\n  const gl = ctx.gl;\n  gl.useProgram(program.handle);\n\n  const aPos = program.attribute('a_position');\n  const aUv = program.attribute('a_uv');\n  gl.bindBuffer(gl.ARRAY_BUFFER, ctx.quadVbo);\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ctx.quadIbo);\n  if (aPos !== undefined && aPos >= 0) {\n    gl.enableVertexAttribArray(aPos);\n    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);\n  }\n  if (aUv !== undefined && aUv >= 0) {\n    gl.enableVertexAttribArray(aUv);\n    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);\n  }\n\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, texture);\n  const source = program.uniform('u_source');\n  if (source !== undefined) gl.uniform1i(source, 0);\n  const resolution = program.uniform('u_resolution');\n  if (resolution !== undefined) gl.uniform2f(resolution, width, height);\n  const texel = program.uniform('u_texel');\n  if (texel !== undefined) gl.uniform2f(texel, 1 / width, 1 / height);\n\n  if (composite) {\n    const alpha = program.uniform('u_alpha');\n    if (alpha !== undefined) gl.uniform1f(alpha, composite.alpha);\n    setColorMatrixUniforms(ctx, program, composite.colorMatrix);\n  }\n\n  // Unit 0 is `u_source`; a consumer texture starts above it.\n  if (uniforms) setUniforms(gl, program, programId ?? 'effect', uniforms, ctx.textureCache, { value: 1 });\n\n  drawTriangles(ctx, 6, ctx.gl.UNSIGNED_SHORT);\n\n  if (aPos !== undefined && aPos >= 0) gl.disableVertexAttribArray(aPos);\n  if (aUv !== undefined && aUv >= 0) gl.disableVertexAttribArray(aUv);\n  gl.bindBuffer(gl.ARRAY_BUFFER, null);\n  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);\n}\n"],"mappings":";;;;AAUA,SAAgBA,EACd,GAAkB,GAAe,GAAgB,GAC3C;CACN,IAAMC,IAAKC,EAAI,IACTC,IAASD,EAAI,gBAAgB;CAEnC,AADAD,EAAG,gBAAgBA,EAAG,aAAaE,IAASA,EAAO,MAAM,IAAI,GACzDA,IACFF,EAAG,SAAS,GAAG,GAAGG,GAAOC,CAAM,KAE/BH,EAAI,oBAAoB,GACpBI,KAAcL,EAAG,OAAOA,EAAG,YAAY;AAE/C;AAIA,SAAgBM,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMN,IAAKC,EAAI;CACf,EAAG,WAAWM,EAAQ,MAAM;CAE5B,IAAMC,IAAOD,EAAQ,UAAU,YAAY,GACrCE,IAAMF,EAAQ,UAAU,MAAM;CAapC,AAZAP,EAAG,WAAWA,EAAG,cAAcC,EAAI,OAAO,GAC1CD,EAAG,WAAWA,EAAG,sBAAsBC,EAAI,OAAO,GAC9CO,MAAS,KAAA,KAAaA,KAAQ,MAChCR,EAAG,wBAAwBQ,CAAI,GAC/BR,EAAG,oBAAoBQ,GAAM,GAAGR,EAAG,OAAO,IAAO,IAAI,CAAC,IAEpDS,MAAQ,KAAA,KAAaA,KAAO,MAC9BT,EAAG,wBAAwBS,CAAG,GAC9BT,EAAG,oBAAoBS,GAAK,GAAGT,EAAG,OAAO,IAAO,IAAI,CAAC,IAGvDA,EAAG,cAAcA,EAAG,QAAQ,GAC5BA,EAAG,YAAYA,EAAG,YAAYU,CAAO;CACrC,IAAMC,IAASJ,EAAQ,QAAQ,UAAU;CACzC,AAAII,MAAW,KAAA,KAAWX,EAAG,UAAUW,GAAQ,CAAC;CAChD,IAAMC,IAAaL,EAAQ,QAAQ,cAAc;CACjD,AAAIK,MAAe,KAAA,KAAWZ,EAAG,UAAUY,GAAYT,GAAOC,CAAM;CACpE,IAAMS,IAAQN,EAAQ,QAAQ,SAAS;CAGvC,IAFIM,MAAU,KAAA,KAAWb,EAAG,UAAUa,GAAO,IAAIV,GAAO,IAAIC,CAAM,GAE9DU,GAAW;EACb,IAAMC,IAAQR,EAAQ,QAAQ,SAAS;EAEvC,AADIQ,MAAU,KAAA,KAAWf,EAAG,UAAUe,GAAOD,EAAU,KAAK,GAC5DE,EAAuBf,GAAKM,GAASO,EAAU,WAAW;CAC5D;CAUA,AAPIG,KAAUC,EAAYlB,GAAIO,GAASY,KAAa,UAAUF,GAAUhB,EAAI,cAAc,EAAE,OAAO,EAAE,CAAC,GAEtGmB,EAAcnB,GAAK,GAAGA,EAAI,GAAG,cAAc,GAEvCO,MAAS,KAAA,KAAaA,KAAQ,KAAGR,EAAG,yBAAyBQ,CAAI,GACjEC,MAAQ,KAAA,KAAaA,KAAO,KAAGT,EAAG,yBAAyBS,CAAG,GAClET,EAAG,WAAWA,EAAG,cAAc,IAAI,GACnCA,EAAG,WAAWA,EAAG,sBAAsB,IAAI;AAC7C"}

package/dist/renderer/draw/flushBatch.js

@@ -0,0 +1,35 @@
+import { BATCH_TEXTURE_SLOTS as e } from "../shaders/batchFill.js";
+import { mat3 as t } from "../math/mat3.js";
+import { drawTriangles as n } from "./drawTriangles.js";
+import { applyClipTest as r } from "./stencil.js";
+import { setAlphaUniform as i, setColorMatrixUniforms as a, setColorUniform as o, setProjAndModel as s } from "./uniforms.js";
+//#region src/renderer/draw/flushBatch.ts
+var c = t.identity(), l = new Int32Array(Array.from({ length: e }, (e, t) => t)), u = new Float32Array(2 * e);
+function d(e) {
+	let t = e.drawBatch, d = e.batchState;
+	if (t.length === 0 || d === void 0) {
+		e.batchState = void 0;
+		return;
+	}
+	let f = e.gl, p = e.batchFill;
+	f.useProgram(p.handle);
+	let m = t.uploadAndBind();
+	s(e, p, c), o(e, p, 1, 1, 1, 1), i(e, p, d.alpha), f.uniform1f(p.uniform("u_synthBold"), d.synthBold), a(e, p, d.colorMatrix), f.activeTexture(f.TEXTURE0), f.bindTexture(f.TEXTURE_2D, e.whiteTexture);
+	for (let t = 0; t < d.textures.length; t++) {
+		let n = d.textures[t];
+		if (n.kind === "atlas") {
+			e.textureCache.bind(n.id, t + 1), u[2 * (t + 1)] = n.fieldScale[0], u[2 * (t + 1) + 1] = n.fieldScale[1];
+			continue;
+		}
+		if (n.kind === "ramps") {
+			e.gradRamps.bind(t + 1);
+			continue;
+		}
+		e.imageCache.bind(n.image, t + 1), e.imageCache.setMagFilter(n.image, n.sampling === "nearest" ? f.NEAREST : f.LINEAR);
+	}
+	f.uniform1iv(p.uniform("u_samplers"), l), f.uniform2fv(p.uniform("u_fieldScale"), u), r(e, d.clipDepth), n(e, m, e.gl.UNSIGNED_INT), f.activeTexture(f.TEXTURE0), f.bindVertexArray(null), t.reset(), e.batchState = void 0;
+}
+//#endregion
+export { c as BATCH_MODEL, d as flushBatch };
+
+//# sourceMappingURL=flushBatch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flushBatch.js","names":["BATCH_MODEL","mat3","SAMPLER_UNITS","BATCH_TEXTURE_SLOTS","i","FIELD_SCALES","flushBatch","batch","ctx","staged","gl","prog","indexCount","setProjAndModel","setColorUniform","setAlphaUniform","setColorMatrixUniforms","entry","applyClipTest","drawTriangles"],"sources":["../../../src/renderer/draw/flushBatch.ts"],"sourcesContent":["import { mat3 } from '../math/mat3';\nimport { BATCH_TEXTURE_SLOTS } from '../shaders/batchFill';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport {\n  setColorUniform,\n  setAlphaUniform,\n  setColorMatrixUniforms,\n  setProjAndModel,\n} from './uniforms';\nimport { applyClipTest } from './stencil';\n\n/** The rect batch transforms its own corners, so it draws at model identity. */\nexport const BATCH_MODEL = mat3.identity();\n\n/** `u_samplers[i] = i`, uploaded whole per flush. Built once: the mapping from\n *  slot to texture unit is the identity and never varies. */\nconst SAMPLER_UNITS = new Int32Array(\n  Array.from({ length: BATCH_TEXTURE_SLOTS }, (_, i) => i),\n);\n\n/** `u_fieldScale`, per slot: an atlas slot's `glyphFieldScale`. Slots that are\n *  not atlases keep whatever a previous flush wrote, which nothing reads. */\nconst FIELD_SCALES = new Float32Array(2 * BATCH_TEXTURE_SLOTS);\n\n/**\n * Draw the staged run as one `drawElements`, under the state it was staged\n * under. Callers that are about to bind a different program, or paint anything\n * that must land on top of the run, call this first; a group that only changes\n * the color matrix does not, because `pushRect` notices and flushes then, and\n * one that only changes transform or alpha does not break the run at all.\n *\n * Stencil clips are the exception: the stencil is real GL state that the\n * staged values cannot reconstruct, so `pushClip` flushes *before* writing a\n * bit, and `popClip` before clearing one a staged run tests. Rect clips never\n * reach the stencil while only staged geometry is inside them — see\n * `enterClip`.\n *\n * `u_color` stays white: the vertex-color program multiplies it by the\n * per-vertex color, so white makes the result bit-identical to the flat\n * program's `u_color`-only math. `u_model` stays identity for the same reason —\n * the corners arrive already transformed.\n */\nexport function flushBatch(ctx: DrawContext): void {\n  const batch = ctx.drawBatch;\n  const staged = ctx.batchState;\n  if (batch.length === 0 || staged === undefined) {\n    // An empty run's state still names a clip depth, and an item refused by\n    // the CPU cut is about to be staged again under a different one.\n    ctx.batchState = undefined;\n    return;\n  }\n  const gl = ctx.gl;\n  const prog = ctx.batchFill;\n  gl.useProgram(prog.handle);\n  const indexCount = batch.uploadAndBind();\n  setProjAndModel(ctx, prog, BATCH_MODEL);\n  setColorUniform(ctx, prog, 1, 1, 1, 1);\n  setAlphaUniform(ctx, prog, staged.alpha);\n  gl.uniform1f(prog.uniform('u_synthBold')!, staged.synthBold);\n  setColorMatrixUniforms(ctx, prog, staged.colorMatrix);\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, ctx.whiteTexture);\n  for (let i = 0; i < staged.textures.length; i++) {\n    const entry = staged.textures[i];\n    if (entry.kind === 'atlas') {\n      ctx.textureCache.bind(entry.id, i + 1);\n      FIELD_SCALES[2 * (i + 1)] = entry.fieldScale[0];\n      FIELD_SCALES[2 * (i + 1) + 1] = entry.fieldScale[1];\n      continue;\n    }\n    if (entry.kind === 'ramps') {\n      ctx.gradRamps.bind(i + 1);\n      continue;\n    }\n    ctx.imageCache.bind(entry.image, i + 1);\n    // Per flush, not at upload: the same bitmap can be drawn at both filters in\n    // one frame. The cache skips the write when the texture already carries the\n    // value, which is most flushes.\n    ctx.imageCache.setMagFilter(\n      entry.image,\n      entry.sampling === 'nearest' ? gl.NEAREST : gl.LINEAR,\n    );\n  }\n  gl.uniform1iv(prog.uniform('u_samplers')!, SAMPLER_UNITS);\n  gl.uniform2fv(prog.uniform('u_fieldScale')!, FIELD_SCALES);\n  applyClipTest(ctx, staged.clipDepth);\n  drawTriangles(ctx, indexCount, ctx.gl.UNSIGNED_INT);\n  // Everything else in the renderer binds its texture to unit 0 and some of it\n  // does so without an `activeTexture` of its own, so leaving unit 6 selected\n  // sends the next such bind to a unit nothing samples.\n  gl.activeTexture(gl.TEXTURE0);\n  // Not redundant: `drawShader` binds no VAO and points attributes at whatever\n  // is current, so a slot left bound here comes back corrupted a ring later.\n  gl.bindVertexArray(null);\n  batch.reset();\n  ctx.batchState = undefined;\n}\n"],"mappings":";;;;;;AAaA,IAAaA,IAAcC,EAAK,SAAS,GAInCC,IAAgB,IAAI,WACxB,MAAM,KAAK,EAAE,QAAQC,EAAoB,IAAI,GAAG,MAAMC,CAAC,CACzD,GAIMC,IAAe,IAAI,aAAa,IAAIF,CAAmB;AAoB7D,SAAgBG,EAAW,GAAwB;CACjD,IAAMC,IAAQC,EAAI,WACZC,IAASD,EAAI;CACnB,IAAID,EAAM,WAAW,KAAKE,MAAW,KAAA,GAAW;EAG9C,EAAI,aAAa,KAAA;EACjB;CACF;CACA,IAAMC,IAAKF,EAAI,IACTG,IAAOH,EAAI;CACjB,EAAG,WAAWG,EAAK,MAAM;CACzB,IAAMC,IAAaL,EAAM,cAAc;CAOvC,AANAM,EAAgBL,GAAKG,GAAMX,CAAW,GACtCc,EAAgBN,GAAKG,GAAM,GAAG,GAAG,GAAG,CAAC,GACrCI,EAAgBP,GAAKG,GAAMF,EAAO,KAAK,GACvCC,EAAG,UAAUC,EAAK,QAAQ,aAAa,GAAIF,EAAO,SAAS,GAC3DO,EAAuBR,GAAKG,GAAMF,EAAO,WAAW,GACpDC,EAAG,cAAcA,EAAG,QAAQ,GAC5BA,EAAG,YAAYA,EAAG,YAAYF,EAAI,YAAY;CAC9C,KAAK,IAAIJ,IAAI,GAAGA,IAAIK,EAAO,SAAS,QAAQ,KAAK;EAC/C,IAAMQ,IAAQR,EAAO,SAASL;EAC9B,IAAIa,EAAM,SAAS,SAAS;GAG1B,AAFAT,EAAI,aAAa,KAAKS,EAAM,IAAIb,IAAI,CAAC,GACrC,EAAa,KAAKA,IAAI,MAAMa,EAAM,WAAW,IAC7C,EAAa,KAAKb,IAAI,KAAK,KAAKa,EAAM,WAAW;GACjD;EACF;EACA,IAAIA,EAAM,SAAS,SAAS;GAC1B,EAAI,UAAU,KAAKb,IAAI,CAAC;GACxB;EACF;EAKA,AAJAI,EAAI,WAAW,KAAKS,EAAM,OAAOb,IAAI,CAAC,GAItCI,EAAI,WAAW,aACbS,EAAM,OACNA,EAAM,aAAa,YAAYP,EAAG,UAAUA,EAAG,MACjD;CACF;CAaA,AAZAA,EAAG,WAAWC,EAAK,QAAQ,YAAY,GAAIT,CAAa,GACxDQ,EAAG,WAAWC,EAAK,QAAQ,cAAc,GAAIN,CAAY,GACzDa,EAAcV,GAAKC,EAAO,SAAS,GACnCU,EAAcX,GAAKI,GAAYJ,EAAI,GAAG,YAAY,GAIlDE,EAAG,cAAcA,EAAG,QAAQ,GAG5BA,EAAG,gBAAgB,IAAI,GACvBH,EAAM,MAAM,GACZ,EAAI,aAAa,KAAA;AACnB"}

package/dist/renderer/draw/gradient.js

@@ -0,0 +1,90 @@
+import { PAINT_MODE_CONIC as e, PAINT_MODE_PLAIN as t, PAINT_MODE_RADIAL as n } from "../shaders/batchFill.js";
+import { mat3 as r } from "../math/mat3.js";
+//#region src/renderer/draw/gradient.ts
+function i(r, i, u) {
+	if (u) return;
+	let d = i.fill ?? "solid";
+	if (d === "solid") {
+		let e = i;
+		return {
+			kind: "solid",
+			color: e.color,
+			opacity: e.opacity
+		};
+	}
+	if (d !== "linear-gradient" && d !== "radial-gradient" && d !== "conic-gradient") return;
+	let f = i, p = o(r, f.units);
+	return p ? f.fill === "linear-gradient" ? a(f, t, s(p, f)) : f.fill === "radial-gradient" ? a(f, n, c(p, f)) : a(f, e, l(p, f)) : null;
+}
+function a(e, t, n) {
+	return {
+		kind: "ramp",
+		stops: e.stops,
+		space: e.interpolate ?? "rgb",
+		opacity: e.opacity,
+		mode: t,
+		uv: n
+	};
+}
+function o(e, t) {
+	let n = d(e, t);
+	return n && r.multiply(n, e.state.transform);
+}
+function s(e, t) {
+	let n = t.to.x - t.from.x, r = t.to.y - t.from.y, i = Math.hypot(n, r) || 1, a = 1 / (i * i);
+	return {
+		ux: (e[0] * n + e[1] * r) * a,
+		uy: (e[3] * n + e[4] * r) * a,
+		u0: ((e[6] - t.from.x) * n + (e[7] - t.from.y) * r) * a,
+		vx: 0,
+		vy: 0,
+		v0: 0
+	};
+}
+function c(e, t) {
+	let n = 1 / Math.max(t.radius, 1e-4);
+	return {
+		ux: e[0] * n,
+		uy: e[3] * n,
+		u0: (e[6] - t.center.x) * n,
+		vx: e[1] * n,
+		vy: e[4] * n,
+		v0: (e[7] - t.center.y) * n
+	};
+}
+function l(e, t) {
+	let n = Math.cos(t.angle), r = Math.sin(t.angle), i = e[6] - t.center.x, a = e[7] - t.center.y;
+	return {
+		ux: n * e[0] + r * e[1],
+		uy: n * e[3] + r * e[4],
+		u0: n * i + r * a,
+		vx: n * e[1] - r * e[0],
+		vy: n * e[4] - r * e[3],
+		v0: n * a - r * i
+	};
+}
+function u(e, n) {
+	return e.mode === t ? {
+		uv: {
+			...e.uv,
+			v0: n
+		},
+		post: 1
+	} : {
+		uv: e.uv,
+		post: n
+	};
+}
+function d(e, t) {
+	return t === "local" ? r.invert(e.state.transform) : t === "world" && e.viewMatrix ? r.invert(e.viewMatrix) : r.identity();
+}
+function f(e, t) {
+	let n = d(e, t), i = n && r.invert(n);
+	if (!i) return null;
+	let a = e.deviceWidth && e.widthCss > 0 ? e.deviceWidth / e.widthCss : 1;
+	return r.multiply(r.scaled(r.identity(), a, a), i);
+}
+//#endregion
+export { i as batchPaint, d as gradientSpaceInverse, u as rampVertices, f as spaceToDevice };
+
+//# sourceMappingURL=gradient.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gradient.js","names":["batchPaint","hasVColors","kind","fill","solid","grad","g","gradientMap","ctx","ramp","PAINT_MODE_PLAIN","linearRampUV","PAINT_MODE_RADIAL","radialRampUV","PAINT_MODE_CONIC","conicRampUV","inverse","gradientSpaceInverse","units","mat3","dx","dy","len","k","cos","sin","dx0","dy0","rampVertices","paint","rowV","spaceToDevice","toScreen","ratio"],"sources":["../../../src/renderer/draw/gradient.ts"],"sourcesContent":["import type { ColorSpace, FillStyle, GradientUnits, GradStop } from '@weasel-js/paint';\nimport { mat3, type GlMat3 } from '../math/mat3';\nimport type { GradientUV } from '../drawBatch';\nimport { PAINT_MODE_PLAIN, PAINT_MODE_RADIAL, PAINT_MODE_CONIC } from '../shaders/batchFill';\nimport type { DrawContext } from './drawContext';\n\n/** A paint a run can express, resolved from a `FillStyle` by `batchPaint`. */\nexport type BatchPaint =\n  | { kind: 'solid'; color: string; opacity?: number }\n  | {\n      kind: 'ramp'; stops: GradStop[]; space: ColorSpace; opacity?: number;\n      /** `PAINT_MODE_PLAIN` for a linear gradient, whose ramp position a vertex\n       *  carries outright; `PAINT_MODE_RADIAL` / `PAINT_MODE_CONIC` otherwise. */\n      mode: number;\n      uv: GradientUV;\n    };\n\n/**\n * `fill` as something a run can carry, or `undefined` for a paint no run can\n * express — a pattern, a shader, per-vertex colors — and `null` for a gradient\n * whose space has no inverse under this transform, which draws nothing.\n *\n * **All three gradients qualify, and for the same reason,** which is not that\n * their ramp position is affine in position — only a linear gradient's is. It\n * is that the *coordinate* the ramp position is computed from is affine in all\n * three, so a vertex can carry that and the rasterizer's interpolation across a\n * triangle is exact. A linear gradient's coordinate is the ramp position\n * itself, which is why it needs no paint mode; the other two carry a\n * gradient-space point and the shader takes a `length` or an `atan` of it.\n */\nexport function batchPaint(\n  ctx: DrawContext, fill: FillStyle, hasVColors: boolean,\n): BatchPaint | undefined | null {\n  if (hasVColors) return undefined;\n  const kind = fill.fill ?? 'solid';\n  if (kind === 'solid') {\n    const solid = fill as { color: string; opacity?: number };\n    return { kind: 'solid', color: solid.color, opacity: solid.opacity };\n  }\n  if (kind !== 'linear-gradient' && kind !== 'radial-gradient' && kind !== 'conic-gradient') {\n    return undefined;\n  }\n  const grad = fill as Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>;\n  const g = gradientMap(ctx, grad.units);\n  if (!g) return null;\n  if (grad.fill === 'linear-gradient') return ramp(grad, PAINT_MODE_PLAIN, linearRampUV(g, grad));\n  if (grad.fill === 'radial-gradient') return ramp(grad, PAINT_MODE_RADIAL, radialRampUV(g, grad));\n  return ramp(grad, PAINT_MODE_CONIC, conicRampUV(g, grad));\n}\n\nfunction ramp(\n  fill: { stops: GradStop[]; interpolate?: ColorSpace; opacity?: number },\n  mode: number, uv: GradientUV,\n): BatchPaint {\n  return {\n    kind: 'ramp', stops: fill.stops, space: fill.interpolate ?? 'rgb',\n    opacity: fill.opacity, mode, uv,\n  };\n}\n\n/**\n * Geometry-space → gradient-space, as the one matrix a vertex is measured\n * through.\n *\n * `gradientSpaceInverse` maps a screen position back into the gradient's space\n * and the batch's vertices arrive before the model transform, so the two\n * compose. This is the composition `gradFill`'s vertex shader does in two\n * steps, and the pair have to agree: a radial gradient goes through that one\n * and a linear one through this.\n */\nfunction gradientMap(ctx: DrawContext, units: GradientUnits | undefined): GlMat3 | null {\n  const inverse = gradientSpaceInverse(ctx, units);\n  return inverse && mat3.multiply(inverse, ctx.state.transform);\n}\n\n/**\n * The gradient shader's `dot(p - from, dir) / len` folded into `u`, with `v`\n * left for the atlas row `stageRamps` fills in.\n */\nfunction linearRampUV(\n  g: GlMat3, fill: Extract<FillStyle, { fill: 'linear-gradient' }>,\n): GradientUV {\n  const dx = fill.to.x - fill.from.x;\n  const dy = fill.to.y - fill.from.y;\n  const len = Math.hypot(dx, dy) || 1;\n  // dir is (dx, dy)/len and the divisor is len, so the pair is 1/len².\n  const k = 1 / (len * len);\n  return {\n    ux: (g[0] * dx + g[1] * dy) * k,\n    uy: (g[3] * dx + g[4] * dy) * k,\n    u0: ((g[6] - fill.from.x) * dx + (g[7] - fill.from.y) * dy) * k,\n    vx: 0, vy: 0, v0: 0,\n  };\n}\n\n/** The gradient-space point scaled so its distance from the center *is* the\n *  ramp position, which is what makes the shader's half a `length`. */\nfunction radialRampUV(\n  g: GlMat3, fill: Extract<FillStyle, { fill: 'radial-gradient' }>,\n): GradientUV {\n  // The floor is `gradFill`'s own `max(u_gradRadius, 0.0001)`.\n  const k = 1 / Math.max(fill.radius, 1e-4);\n  return {\n    ux: g[0] * k, uy: g[3] * k, u0: (g[6] - fill.center.x) * k,\n    vx: g[1] * k, vy: g[4] * k, v0: (g[7] - fill.center.y) * k,\n  };\n}\n\n/**\n * The gradient-space point about the center, turned by `-angle` so the shader's\n * half is an `atan` of it and nothing else.\n *\n * `gradFill` subtracts the angle from the arctangent instead. The two agree\n * because rotating a point turns its arctangent by the same amount, and the\n * `fract` that follows takes care of the wrap either way.\n */\nfunction conicRampUV(\n  g: GlMat3, fill: Extract<FillStyle, { fill: 'conic-gradient' }>,\n): GradientUV {\n  const cos = Math.cos(fill.angle);\n  const sin = Math.sin(fill.angle);\n  const dx0 = g[6] - fill.center.x;\n  const dy0 = g[7] - fill.center.y;\n  return {\n    ux: cos * g[0] + sin * g[1],\n    uy: cos * g[3] + sin * g[4],\n    u0: cos * dx0 + sin * dy0,\n    vx: cos * g[1] - sin * g[0],\n    vy: cos * g[4] - sin * g[3],\n    v0: cos * dy0 - sin * dx0,\n  };\n}\n\n/**\n * What a gradient's vertices carry once its row is known.\n *\n * A linear gradient's `a_uv` is (ramp position, row) and its `a_post` is the\n * plain 1, because that is what the plain paint mode already samples. A radial\n * or conic one needs both `a_uv` channels for its coordinate, so its row goes\n * in `a_post` — which no gradient uses for alpha, its opacity riding the vertex\n * color instead.\n */\nexport function rampVertices(\n  paint: Extract<BatchPaint, { kind: 'ramp' }>, rowV: number,\n): { uv: GradientUV; post: number } {\n  return paint.mode === PAINT_MODE_PLAIN\n    ? { uv: { ...paint.uv, v0: rowV }, post: 1 }\n    : { uv: paint.uv, post: rowV };\n}\n\n/**\n * Screen→gradient-space matrix for `u_worldInv`, which the vertex shader\n * applies to each fragment's screen position to recover the coordinates the\n * gradient's geometry is expressed in.\n *\n * `'world'` silently degrades to screen space when no view matrix reached\n * the renderer — `render(commands)` without a view is a supported call, and\n * a missing view is not worth a thrown frame. `null` when the space has no\n * inverse; a paint measured in it draws nothing.\n */\nexport function gradientSpaceInverse(ctx: DrawContext, units: GradientUnits | undefined): GlMat3 | null {\n  if (units === 'local') return mat3.invert(ctx.state.transform);\n  if (units === 'world' && ctx.viewMatrix) return mat3.invert(ctx.viewMatrix);\n  return mat3.identity();\n}\n\n/** The paint space `units` names → device pixels: the forward transform\n *  `gradientSpaceInverse` undoes, scaled by the target's pixel ratio. */\nexport function spaceToDevice(ctx: DrawContext, units: GradientUnits | undefined): GlMat3 | null {\n  const inverse = gradientSpaceInverse(ctx, units);\n  const toScreen = inverse && mat3.invert(inverse);\n  if (!toScreen) return null;\n  const ratio = ctx.deviceWidth && ctx.widthCss > 0 ? ctx.deviceWidth / ctx.widthCss : 1;\n  return mat3.multiply(mat3.scaled(mat3.identity(), ratio, ratio), toScreen);\n}\n"],"mappings":"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"}

package/dist/renderer/draw/image.js

@@ -0,0 +1,38 @@
+import { flushBatch as e } from "./flushBatch.js";
+import { enterUncut as t, leaveUncut as n, retryUncut as r } from "./clip.js";
+import { stageImage as i } from "./batch.js";
+import { SPRITE_STRIDE as a } from "../DrawCommand.js";
+//#region src/renderer/draw/image.ts
+function o(e, t) {
+	e.imageCache.upload(t.image, t.image);
+	let { staged: n, slot: a } = i(e, t.image, t.sampling ?? "linear"), s = t.source, c = 0, l = 0, u = 1, d = 1;
+	if (s) {
+		let e = t.image.width, n = t.image.height;
+		c = s.x / e, u = (s.x + s.w) / e, l = s.y / n, d = (s.y + s.h) / n;
+	}
+	if (t.flipX) {
+		let e = c;
+		c = u, u = e;
+	}
+	if (t.flipY) {
+		let e = l;
+		l = d, d = e;
+	}
+	e.drawBatch.pushQuad(t.x, t.y, t.w, t.h, e.state.transform, c, l, u, d, (t.opacity ?? 1) * (n.foldsAlpha ? e.state.alpha : 1), a) || r(e, t, void 0, o);
+}
+function s(r, o) {
+	let s = o.sprites, c = Math.floor(s.length / a);
+	if (c === 0) return;
+	r.imageCache.upload(o.image, o.image);
+	let l = o.sampling ?? "linear", { staged: u, slot: d } = i(r, o.image, l), f = r.drawBatch, p = r.state.transform, m = u.foldsAlpha ? r.state.alpha : 1, h = o.image.width, g = o.image.height;
+	for (let _ = 0, v = 0; _ < c; _++, v += a) {
+		f.wouldOverflow(4) && (e(r), {staged: u, slot: d} = i(r, o.image, l), m = u.foldsAlpha ? r.state.alpha : 1);
+		let a = s[v + 4], c = s[v + 5], _ = s[v + 6], y = s[v + 7], b;
+		for (; !f.pushQuad(s[v], s[v + 1], s[v + 2], s[v + 3], p, a / h, c / g, (a + _) / h, (c + y) / g, s[v + 8] * m, d);) b = t(r), {staged: u, slot: d} = i(r, o.image, l), m = u.foldsAlpha ? r.state.alpha : 1;
+		b !== void 0 && (n(r, b), {staged: u, slot: d} = i(r, o.image, l), m = u.foldsAlpha ? r.state.alpha : 1);
+	}
+}
+//#endregion
+export { o as drawImage, s as drawSprites };
+
+//# sourceMappingURL=image.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","names":["drawImage","cmd","stageImage","ctx","src","u0","v0","u1","v1","tw","th","t","staged","slot","retryUncut","drawSprites","data","count","SPRITE_STRIDE","sampling","batch","m","groupAlpha","s","i","flushBatch","sx","sy","sw","sh","cut","enterUncut","leaveUncut"],"sources":["../../../src/renderer/draw/image.ts"],"sourcesContent":["import { type ImageDrawCommand, type SpritesDrawCommand, SPRITE_STRIDE } from '../DrawCommand';\nimport type { ClipRect } from '../batchClip';\nimport type { DrawContext } from './drawContext';\nimport { enterUncut, leaveUncut, retryUncut } from './clip';\nimport { flushBatch } from './flushBatch';\nimport { stageImage } from './batch';\n\n/**\n * Stage one image quad. Nothing reaches the GPU here — `flushBatch` draws the\n * run this joins.\n *\n * The upload has to happen now rather than at flush: a run is keyed on bitmap\n * identity, and `flushBatch` binds a texture it assumes already exists.\n */\nexport function drawImage(ctx: DrawContext, cmd: ImageDrawCommand): void {\n  ctx.imageCache.upload(cmd.image, cmd.image);\n  const { staged, slot } = stageImage(ctx, cmd.image, cmd.sampling ?? 'linear');\n\n  // Sampling window: the whole bitmap unless `source` narrows it, with the\n  // flips applied by swapping the ends rather than moving the quad.\n  const src = cmd.source;\n  let u0 = 0, v0 = 0, u1 = 1, v1 = 1;\n  if (src) {\n    const tw = cmd.image.width, th = cmd.image.height;\n    u0 = src.x / tw; u1 = (src.x + src.w) / tw;\n    v0 = src.y / th; v1 = (src.y + src.h) / th;\n  }\n  if (cmd.flipX) { const t = u0; u0 = u1; u1 = t; }\n  if (cmd.flipY) { const t = v0; v0 = v1; v1 = t; }\n\n  if (!ctx.drawBatch.pushQuad(\n    cmd.x, cmd.y, cmd.w, cmd.h, ctx.state.transform,\n    u0, v0, u1, v1,\n    // Group alpha rides the vertices only where it rode the solid colors too:\n    // with a real color matrix in the run it is `u_alpha`, and folding it here\n    // as well would apply it twice.\n    (cmd.opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1),\n    slot,\n  )) retryUncut(ctx, cmd, undefined, drawImage);\n}\n\n/**\n * Stage a packed run of sprites. The same staging `drawImage` does, minus a\n * command object per quad — see `SpritesDrawCommand`.\n *\n * The run is opened once and reopened only when the per-flush cap forces a\n * chunk, so the state check that costs a command its own run happens twice in\n * a frame rather than twenty thousand times.\n */\nexport function drawSprites(ctx: DrawContext, cmd: SpritesDrawCommand): void {\n  const data = cmd.sprites;\n  const count = Math.floor(data.length / SPRITE_STRIDE);\n  if (count === 0) return;\n\n  ctx.imageCache.upload(cmd.image, cmd.image);\n  const sampling = cmd.sampling ?? 'linear';\n  let { staged, slot } = stageImage(ctx, cmd.image, sampling);\n\n  const batch = ctx.drawBatch;\n  const m = ctx.state.transform;\n  let groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n  const tw = cmd.image.width;\n  const th = cmd.image.height;\n\n  for (let s = 0, i = 0; s < count; s++, i += SPRITE_STRIDE) {\n    if (batch.wouldOverflow(4)) {\n      flushBatch(ctx);\n      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));\n      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n    }\n    const sx = data[i + 4], sy = data[i + 5], sw = data[i + 6], sh = data[i + 7];\n    let cut: ClipRect | null | undefined;\n    while (!batch.pushQuad(\n      data[i], data[i + 1], data[i + 2], data[i + 3], m,\n      sx / tw, sy / th, (sx + sw) / tw, (sy + sh) / th,\n      data[i + 8] * groupAlpha, slot,\n    )) {\n      cut = enterUncut(ctx);\n      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));\n      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n    }\n    if (cut !== undefined) {\n      leaveUncut(ctx, cut);\n      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));\n      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;\n    }\n  }\n}\n"],"mappings":";;;;;AAcA,SAAgBA,EAAU,GAAkB,GAA6B;CACvE,EAAI,WAAW,OAAOC,EAAI,OAAOA,EAAI,KAAK;CAC1C,IAAM,EAAE,WAAQ,YAASC,EAAWC,GAAKF,EAAI,OAAOA,EAAI,YAAY,QAAQ,GAItEG,IAAMH,EAAI,QACZI,IAAK,GAAGC,IAAK,GAAGC,IAAK,GAAGC,IAAK;CACjC,IAAIJ,GAAK;EACP,IAAMK,IAAKR,EAAI,MAAM,OAAOS,IAAKT,EAAI,MAAM;EAE1B,AADjB,IAAKG,EAAI,IAAIK,GAAI,KAAML,EAAI,IAAIA,EAAI,KAAKK,GACxC,IAAKL,EAAI,IAAIM,GAAI,KAAMN,EAAI,IAAIA,EAAI,KAAKM;CAC1C;CACA,IAAIT,EAAI,OAAO;EAAE,IAAMU,IAAIN;EAAa,AAAT,IAAKE,GAAI,IAAKI;CAAG;CAChD,IAAIV,EAAI,OAAO;EAAE,IAAMU,IAAIL;EAAa,AAAT,IAAKE,GAAI,IAAKG;CAAG;CAEhD,AAAKR,EAAI,UAAU,SACjBF,EAAI,GAAGA,EAAI,GAAGA,EAAI,GAAGA,EAAI,GAAGE,EAAI,MAAM,WACtCE,GAAIC,GAAIC,GAAIC,IAIXP,EAAI,WAAW,MAAMW,EAAO,aAAaT,EAAI,MAAM,QAAQ,IAC5DU,CACF,KAAGC,EAAWX,GAAKF,GAAK,KAAA,GAAWD,CAAS;AAC9C;AAUA,SAAgBe,EAAY,GAAkB,GAA+B;CAC3E,IAAMC,IAAOf,EAAI,SACXgB,IAAQ,KAAK,MAAMD,EAAK,SAASE,CAAa;CACpD,IAAID,MAAU,GAAG;CAEjB,EAAI,WAAW,OAAOhB,EAAI,OAAOA,EAAI,KAAK;CAC1C,IAAMkB,IAAWlB,EAAI,YAAY,UAC7B,EAAE,WAAQ,YAASC,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GAEpDC,IAAQjB,EAAI,WACZkB,IAAIlB,EAAI,MAAM,WAChBmB,IAAaV,EAAO,aAAaT,EAAI,MAAM,QAAQ,GACjDM,IAAKR,EAAI,MAAM,OACfS,IAAKT,EAAI,MAAM;CAErB,KAAK,IAAIsB,IAAI,GAAGC,IAAI,GAAGD,IAAIN,GAAO,KAAK,KAAKC,GAAe;EACzD,AAAIE,EAAM,cAAc,CAAC,MACvBK,EAAWtB,CAAG,GACb,uBAAmBD,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GACvD,IAAaP,EAAO,aAAaT,EAAI,MAAM,QAAQ;EAErD,IAAMuB,IAAKV,EAAKQ,IAAI,IAAIG,IAAKX,EAAKQ,IAAI,IAAII,IAAKZ,EAAKQ,IAAI,IAAIK,IAAKb,EAAKQ,IAAI,IACtEM;EACJ,OAAO,CAACV,EAAM,SACZJ,EAAKQ,IAAIR,EAAKQ,IAAI,IAAIR,EAAKQ,IAAI,IAAIR,EAAKQ,IAAI,IAAIH,GAChDK,IAAKjB,GAAIkB,IAAKjB,IAAKgB,IAAKE,KAAMnB,IAAKkB,IAAKE,KAAMnB,GAC9CM,EAAKQ,IAAI,KAAKF,GAAYT,CAC5B,IAGE,AAFA,IAAMkB,EAAW5B,CAAG,GACnB,uBAAmBD,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GACvD,IAAaP,EAAO,aAAaT,EAAI,MAAM,QAAQ;EAErD,AAAI2B,MAAQ,KAAA,MACVE,EAAW7B,GAAK2B,CAAG,GAClB,uBAAmB5B,EAAWC,GAAKF,EAAI,OAAOkB,CAAQ,GACvD,IAAaP,EAAO,aAAaT,EAAI,MAAM,QAAQ;CAEvD;AACF"}

package/dist/renderer/draw/mesh.js

@@ -0,0 +1,16 @@
+import { getMesh as e } from "../cache/cache.js";
+import { tessellate as t } from "@weasel-js/geom/tessellate";
+//#region src/renderer/draw/mesh.ts
+function n(n, r) {
+	return n.flattenTolerance === void 0 ? e(r) : t(r, { flattenTolerance: n.flattenTolerance });
+}
+function r(e, t) {
+	return e.flattenTolerance === void 0 ? e.meshCache.handleFor(t) : e.meshCache.uploadTransient(t);
+}
+function i(e, t) {
+	return r(e, n(e, t));
+}
+//#endregion
+export { n as fillMesh, i as fillMeshHandle, r as meshHandle };
+
+//# sourceMappingURL=mesh.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mesh.js","names":["fillMesh","ctx","getMesh","path","tessellate","meshHandle","mesh","fillMeshHandle"],"sources":["../../../src/renderer/draw/mesh.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport type { GLMeshHandle } from '../cache/GLMeshCache';\nimport { getMesh } from '../cache/cache';\nimport { tessellate, type Mesh } from '@weasel-js/geom/tessellate';\nimport type { DrawContext } from './drawContext';\n\n/**\n * Tessellate a fill honoring ctx.flattenTolerance: default route is the\n * persistent Path-identity cache; a custom tolerance tessellates fresh, because\n * the persistent cache's key does not include tolerance.\n */\nexport function fillMesh(ctx: DrawContext, path: Path): Mesh {\n  if (ctx.flattenTolerance !== undefined) {\n    return tessellate(path, { flattenTolerance: ctx.flattenTolerance });\n  }\n  return getMesh(path);\n}\n\n/** Upload a mesh for its own draw. A freshly tessellated one rides the\n *  transient pool, freed at end of frame. */\nexport function meshHandle(ctx: DrawContext, mesh: Mesh): GLMeshHandle {\n  if (ctx.flattenTolerance !== undefined) return ctx.meshCache.uploadTransient(mesh);\n  return ctx.meshCache.handleFor(mesh);\n}\n\nexport function fillMeshHandle(ctx: DrawContext, path: Path): GLMeshHandle {\n  return meshHandle(ctx, fillMesh(ctx, path));\n}\n"],"mappings":";;;AAWA,SAAgBA,EAAS,GAAkB,GAAkB;CAI3D,OAHIC,EAAI,qBAAqB,KAAA,IAGtBC,EAAQC,CAAI,IAFVC,EAAWD,GAAM,EAAE,kBAAkBF,EAAI,iBAAiB,CAAC;AAGtE;AAIA,SAAgBI,EAAW,GAAkB,GAA0B;CAErE,OADIJ,EAAI,qBAAqB,KAAA,IACtBA,EAAI,UAAU,UAAUK,CAAI,IADYL,EAAI,UAAU,gBAAgBK,CAAI;AAEnF;AAEA,SAAgBC,EAAe,GAAkB,GAA0B;CACzE,OAAOF,EAAWJ,GAAKD,EAASC,GAAKE,CAAI,CAAC;AAC5C"}

package/dist/renderer/draw/paintBind.js

@@ -0,0 +1,70 @@
+import { createPaintResources as e } from "../paintResources.js";
+import { getTexture as t } from "../textures/registerTexture.js";
+import { mat3 as n } from "../math/mat3.js";
+import { setAlphaUniform as r, setColorMatrixUniforms as i, setProjAndModel as a } from "./uniforms.js";
+import { gradientSpaceInverse as o, spaceToDevice as s } from "./gradient.js";
+import { patternTileSpace as c } from "../math/patternSpace.js";
+//#region src/renderer/draw/paintBind.ts
+function l(e) {
+	let t = u.get(e);
+	if (t) return t;
+	let n = {
+		gl: e.gl,
+		get alpha() {
+			return e.state.alpha;
+		},
+		program: (t) => e.ensureProgram?.(t) ?? e.programRegistry.get(t) ?? null,
+		setProjAndModel: (t) => a(e, t),
+		spaceInverse: (t) => o(e, t),
+		spaceToDevice: (t) => s(e, t),
+		get maxTextureSize() {
+			return e.imageCache.maxTextureSide;
+		},
+		resources: e.paintResources ?? f(e.gl),
+		bindRamp: (t, n, r) => {
+			let i = e.gradRamps.upload(t, r);
+			return e.gradRamps.bind(n), e.gradRamps.rowV(i);
+		}
+	};
+	return u.set(e, n), n;
+}
+var u = /* @__PURE__ */ new WeakMap(), d = /* @__PURE__ */ new WeakMap();
+function f(t) {
+	let n = d.get(t);
+	return n || (n = e(), d.set(t, n)), n;
+}
+function p(e, s, l, u) {
+	let d = l.pattern, f = t(d.id);
+	if (!f) return (typeof process > "u" || process.env.NODE_ENV !== "production") && console.warn(`weasel: pattern TextureHandle "${d.id}" not registered`), null;
+	let p = o(e, l.units);
+	if (!p) return null;
+	let h = c(p, l.origin ?? {
+		x: 0,
+		y: 0
+	}, l.transform);
+	if (!h) return null;
+	e.textureCache.uploadRegistered(d.id, f.source, "repeat");
+	let g = e.gl;
+	g.useProgram(s.handle), a(e, s, u), i(e, s), g.uniformMatrix3fv(s.uniform("u_worldInv"), !1, n.toUniform(h));
+	let [_, v] = m(f.source);
+	return g.uniform2f(s.uniform("u_tileSize"), _, v), e.textureCache.bind(d.id, 0), g.uniform1i(s.uniform("u_sampler"), 0), g.uniform1f(s.uniform("u_opacity"), l.opacity ?? 1), r(e, s, e.state.alpha), s;
+}
+function m(e) {
+	let t = "naturalWidth" in e ? e.naturalWidth : e.width, n = "naturalHeight" in e ? e.naturalHeight : e.height;
+	return [t || 1, n || 1];
+}
+function h(e, t, s, c) {
+	let l = o(e, s.units);
+	if (!l) return null;
+	let u = e.gl, d = e.gradRamps.upload(s.stops, s.interpolate ?? "rgb");
+	if (u.useProgram(t.handle), a(e, t, c), u.uniformMatrix3fv(t.uniform("u_worldInv"), !1, n.toUniform(l)), i(e, t), e.gradRamps.bind(0), u.uniform1i(t.uniform("u_ramp"), 0), u.uniform1f(t.uniform("u_rampV"), e.gradRamps.rowV(d)), r(e, t, e.state.alpha), u.uniform1f(t.uniform("u_opacity"), s.opacity ?? 1), s.fill === "linear-gradient") {
+		u.uniform1i(t.uniform("u_gradKind"), 0);
+		let e = s.to.x - s.from.x, n = s.to.y - s.from.y, r = Math.hypot(e, n) || 1;
+		u.uniform2f(t.uniform("u_gradP0"), s.from.x, s.from.y), u.uniform2f(t.uniform("u_gradDir"), e / r, n / r), u.uniform1f(t.uniform("u_gradLen"), r), u.uniform1f(t.uniform("u_gradRadius"), 0), u.uniform1f(t.uniform("u_gradAngle"), 0);
+	} else s.fill === "radial-gradient" ? (u.uniform1i(t.uniform("u_gradKind"), 1), u.uniform2f(t.uniform("u_gradP0"), s.center.x, s.center.y), u.uniform2f(t.uniform("u_gradDir"), 0, 0), u.uniform1f(t.uniform("u_gradLen"), 0), u.uniform1f(t.uniform("u_gradRadius"), s.radius), u.uniform1f(t.uniform("u_gradAngle"), 0)) : (u.uniform1i(t.uniform("u_gradKind"), 2), u.uniform2f(t.uniform("u_gradP0"), s.center.x, s.center.y), u.uniform2f(t.uniform("u_gradDir"), 0, 0), u.uniform1f(t.uniform("u_gradLen"), 0), u.uniform1f(t.uniform("u_gradRadius"), 0), u.uniform1f(t.uniform("u_gradAngle"), s.angle));
+	return t;
+}
+//#endregion
+export { h as bindGradient, p as bindPattern, l as paintBindContext };
+
+//# sourceMappingURL=paintBind.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paintBind.js","names":["paintBindContext","cached","BIND_CONTEXTS","ctx","made","id","setProjAndModel","prog","gradientSpaceInverse","units","spaceToDevice","unownedPaintResources","row","stops","space","unit","UNOWNED_RESOURCES","gl","createPaintResources","bindPattern","tex","fill","entry","getTexture","inverse","tileSpace","patternTileSpace","model","setColorMatrixUniforms","mat3","tw","th","textureSize","setAlphaUniform","w","source","h","bindGradient","dx","dy","len"],"sources":["../../../src/renderer/draw/paintBind.ts"],"sourcesContent":["import type { FillStyle } from '@weasel-js/paint';\nimport type { PaintBindContext, PaintResources } from 'core/paintKinds';\nimport { createPaintResources } from '../paintResources';\nimport { getTexture, type TextureHandle } from '../textures/registerTexture';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport { mat3, type GlMat3 } from '../math/mat3';\nimport { patternTileSpace } from '../math/patternSpace';\nimport type { DrawContext } from './drawContext';\nimport { setAlphaUniform, setColorMatrixUniforms, setProjAndModel } from './uniforms';\nimport { gradientSpaceInverse, spaceToDevice } from './gradient';\n\n/** The narrow renderer surface a registered paint kind binds against, built\n *  once per frame context. `DrawContext` is not consumer surface. */\nexport function paintBindContext(ctx: DrawContext): PaintBindContext {\n  const cached = BIND_CONTEXTS.get(ctx);\n  if (cached) return cached;\n  const made: PaintBindContext = {\n    gl: ctx.gl,\n    get alpha() { return ctx.state.alpha; },\n    program: (id) => ctx.ensureProgram?.(id) ?? ctx.programRegistry.get(id) ?? null,\n    setProjAndModel: (prog) => setProjAndModel(ctx, prog),\n    spaceInverse: (units) => gradientSpaceInverse(ctx, units),\n    spaceToDevice: (units) => spaceToDevice(ctx, units),\n    get maxTextureSize() { return ctx.imageCache.maxTextureSide; },\n    resources: ctx.paintResources ?? unownedPaintResources(ctx.gl),\n    bindRamp: (stops, unit, space) => {\n      const row = ctx.gradRamps.upload(stops, space);\n      ctx.gradRamps.bind(unit);\n      return ctx.gradRamps.rowV(row);\n    },\n  };\n  BIND_CONTEXTS.set(ctx, made);\n  return made;\n}\n\nconst BIND_CONTEXTS = new WeakMap<DrawContext, PaintBindContext>();\n\nconst UNOWNED_RESOURCES = new WeakMap<WebGL2RenderingContext, PaintResources>();\n\nfunction unownedPaintResources(gl: WebGL2RenderingContext): PaintResources {\n  let made = UNOWNED_RESOURCES.get(gl);\n  if (!made) {\n    made = createPaintResources();\n    UNOWNED_RESOURCES.set(gl, made);\n  }\n  return made;\n}\n\n/** Bind `prog` — the path program or the glyph one, which share every paint\n *  uniform — to draw `fill` under `model`. */\nexport function bindPattern(\n  ctx: DrawContext,\n  prog: ShaderProgram,\n  fill: Extract<FillStyle, { fill: 'pattern' }>,\n  model: GlMat3,\n): ShaderProgram | null {\n  const tex = fill.pattern as TextureHandle;\n  const entry = getTexture(tex.id);\n  if (!entry) {\n    const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n    if (isDev) console.warn(`weasel: pattern TextureHandle \"${tex.id}\" not registered`);\n    return null;\n  }\n  const inverse = gradientSpaceInverse(ctx, fill.units);\n  if (!inverse) return null;\n  const tileSpace = patternTileSpace(inverse, fill.origin ?? { x: 0, y: 0 }, fill.transform);\n  if (!tileSpace) return null;\n  ctx.textureCache.uploadRegistered(tex.id, entry.source, 'repeat');\n\n  // A path fill mesh carries a_position only, so the tile coordinate is\n  // recovered per fragment from the screen position — the same route\n  // gradients take through `u_worldInv`, and the reason this can't reuse\n  // the image-fill shader, whose a_uv such a mesh leaves unbound.\n  const gl = ctx.gl;\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog, model);\n  setColorMatrixUniforms(ctx, prog);\n  gl.uniformMatrix3fv(prog.uniform('u_worldInv')!, false, mat3.toUniform(tileSpace));\n  const [tw, th] = textureSize(entry.source);\n  gl.uniform2f(prog.uniform('u_tileSize')!, tw, th);\n  ctx.textureCache.bind(tex.id, 0);\n  gl.uniform1i(prog.uniform('u_sampler')!, 0);\n  gl.uniform1f(prog.uniform('u_opacity')!, fill.opacity ?? 1);\n  setAlphaUniform(ctx, prog, ctx.state.alpha);\n  return prog;\n}\n\n/** Tile extent in paint-space units — one tile spans this many units of\n *  whatever space `units` names. */\nfunction textureSize(source: HTMLImageElement | ImageBitmap): [number, number] {\n  const w = 'naturalWidth' in source ? source.naturalWidth : source.width;\n  const h = 'naturalHeight' in source ? source.naturalHeight : source.height;\n  return [w || 1, h || 1];\n}\n\n/** The gradient counterpart of `bindPattern`. */\nexport function bindGradient(\n  ctx: DrawContext,\n  prog: ShaderProgram,\n  fill: Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>,\n  model: GlMat3,\n): ShaderProgram | null {\n  const inverse = gradientSpaceInverse(ctx, fill.units);\n  if (!inverse) return null;\n  const gl = ctx.gl;\n  const row = ctx.gradRamps.upload(fill.stops, fill.interpolate ?? 'rgb');\n\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog, model);\n\n  gl.uniformMatrix3fv(prog.uniform('u_worldInv')!, false, mat3.toUniform(inverse));\n  setColorMatrixUniforms(ctx, prog);\n\n  ctx.gradRamps.bind(0);\n  gl.uniform1i(prog.uniform('u_ramp')!, 0);\n  gl.uniform1f(prog.uniform('u_rampV')!, ctx.gradRamps.rowV(row));\n  setAlphaUniform(ctx, prog, ctx.state.alpha);\n  gl.uniform1f(prog.uniform('u_opacity')!, fill.opacity ?? 1);\n\n  if (fill.fill === 'linear-gradient') {\n    gl.uniform1i(prog.uniform('u_gradKind')!, 0);\n    const dx = fill.to.x - fill.from.x;\n    const dy = fill.to.y - fill.from.y;\n    const len = Math.hypot(dx, dy) || 1;\n    gl.uniform2f(prog.uniform('u_gradP0')!, fill.from.x, fill.from.y);\n    gl.uniform2f(prog.uniform('u_gradDir')!, dx / len, dy / len);\n    gl.uniform1f(prog.uniform('u_gradLen')!, len);\n    gl.uniform1f(prog.uniform('u_gradRadius')!, 0);\n    gl.uniform1f(prog.uniform('u_gradAngle')!, 0);\n  } else if (fill.fill === 'radial-gradient') {\n    gl.uniform1i(prog.uniform('u_gradKind')!, 1);\n    gl.uniform2f(prog.uniform('u_gradP0')!, fill.center.x, fill.center.y);\n    gl.uniform2f(prog.uniform('u_gradDir')!, 0, 0);\n    gl.uniform1f(prog.uniform('u_gradLen')!, 0);\n    gl.uniform1f(prog.uniform('u_gradRadius')!, fill.radius);\n    gl.uniform1f(prog.uniform('u_gradAngle')!, 0);\n  } else {\n    // conic\n    gl.uniform1i(prog.uniform('u_gradKind')!, 2);\n    gl.uniform2f(prog.uniform('u_gradP0')!, fill.center.x, fill.center.y);\n    gl.uniform2f(prog.uniform('u_gradDir')!, 0, 0);\n    gl.uniform1f(prog.uniform('u_gradLen')!, 0);\n    gl.uniform1f(prog.uniform('u_gradRadius')!, 0);\n    gl.uniform1f(prog.uniform('u_gradAngle')!, fill.angle);\n  }\n\n  return prog;\n}\n"],"mappings":"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"}

package/dist/renderer/draw/pathPaint.js

@@ -0,0 +1,142 @@
+import { drawTriangles as e } from "./drawTriangles.js";
+import { ancestorMask as t, applyClipTest as n, beginParityMask as r, endParityMask as i } from "./stencil.js";
+import { setColorMatrixUniforms as a, setProjAndModel as o, setSolidPaintUniforms as s } from "./uniforms.js";
+import { fillMesh as c, fillMeshHandle as l, meshHandle as u } from "./mesh.js";
+import { flushForOwnDraw as d } from "./clip.js";
+import { getPaintKind as f } from "../../core/paintKinds.js";
+import { metricKeepsRects as p } from "../../features/paths/tessellate/metric.js";
+import { resolveStrokeWidth as m } from "../../features/paths/tessellate/stroke.js";
+import { strokeMesh as h } from "../cache/strokeMeshCache.js";
+import { resolveStrokeLengths as g } from "../strokeLengths.js";
+import { cachedMarkerCommands as _ } from "../cache/markerCommandCache.js";
+import { batchPaint as v } from "./gradient.js";
+import { pushRampRect as y, pushRect as b, tryStageFill as x } from "./batch.js";
+import { bindGradient as S, bindPattern as C, paintBindContext as w } from "./paintBind.js";
+//#region src/renderer/draw/pathPaint.ts
+function T(e, t) {
+	t.fill && E(e, t), t.stroke?.paint && L(e, t);
+}
+function E(e, t) {
+	let n = t.fill, r = n.fill === void 0 || n.fill === "solid", i = !!(t.vertexColors && t.vertexColors.length > 0), a = n, o = v(e, n, i);
+	if (o === null) return;
+	if (o !== void 0 && t.path.kind === "rect") {
+		o.kind === "ramp" ? y(e, t.path, o) : b(e, t.path, o);
+		return;
+	}
+	let s = c(e, t.path);
+	if (x(e, s, o)) return;
+	let l = u(e, s);
+	r && i ? A(e, t, a, l) : l.requiresStencil ? I(e, n, l) : M(e, n, l);
+}
+function D(e, t, n, r) {
+	let i = e.createBuffer();
+	if (!i) throw Error("attachVertexColors: createBuffer returned null");
+	e.bindBuffer(e.ARRAY_BUFFER, i), e.bufferData(e.ARRAY_BUFFER, k(n, r), e.DYNAMIC_DRAW);
+	let a = t.attribute("a_vertexColor");
+	return a !== void 0 && (e.enableVertexAttribArray(a), e.vertexAttribPointer(a, 4, e.FLOAT, !1, 0, 0)), {
+		vbo: i,
+		location: a
+	};
+}
+function O(e, { vbo: t, location: n }) {
+	n !== void 0 && e.disableVertexAttribArray(n), e.deleteBuffer(t);
+}
+function k(e, t) {
+	let n = t.anchorA, r = t.anchorB, i = t.anchorT;
+	if (!n || !r || !i) return new Float32Array(e);
+	let a = n.length, o = new Float32Array(a * 4);
+	for (let t = 0; t < a; t++) {
+		let a = n[t] * 4, s = r[t] * 4, c = i[t];
+		o[t * 4 + 0] = e[a + 0] + (e[s + 0] - e[a + 0]) * c, o[t * 4 + 1] = e[a + 1] + (e[s + 1] - e[a + 1]) * c, o[t * 4 + 2] = e[a + 2] + (e[s + 2] - e[a + 2]) * c, o[t * 4 + 3] = e[a + 3] + (e[s + 3] - e[a + 3]) * c;
+	}
+	return o;
+}
+function A(t, c, l, u) {
+	let d = t.gl, f = t.pathFillVColor;
+	d.useProgram(f.handle), d.bindVertexArray(u.vao), o(t, f), s(t, f, l.color, l.opacity), a(t, f);
+	let p = D(d, f, c.vertexColors, u);
+	u.requiresStencil ? (r(t, u.indexCount), e(t, u.indexCount, t.gl.UNSIGNED_INT), i(t)) : (n(t), e(t, u.indexCount, t.gl.UNSIGNED_INT)), O(d, p), d.bindVertexArray(null);
+}
+function j(e, t) {
+	let n = t.fill ?? "solid";
+	if (n === "solid") return N(e, t);
+	if (n === "pattern") return P(e, t);
+	if (n === "linear-gradient" || n === "radial-gradient" || n === "conic-gradient") return F(e, t);
+	let r = f(n)?.bind;
+	return r ? r(w(e), t) : null;
+}
+function M(t, r, i) {
+	if (!j(t, r)) return;
+	let a = t.gl;
+	a.bindVertexArray(i.vao), n(t), e(t, i.indexCount, t.gl.UNSIGNED_INT), a.bindVertexArray(null);
+}
+function N(e, t) {
+	let n = e.pathFill;
+	return e.gl.useProgram(n.handle), o(e, n), s(e, n, t.color, t.opacity), a(e, n), n;
+}
+function P(e, t) {
+	return C(e, e.patternFill, t, e.state.transform);
+}
+function F(e, t) {
+	return S(e, e.gradFill, t, e.state.transform);
+}
+function I(t, n, a) {
+	let s = t.gl;
+	s.useProgram(t.pathFill.handle), s.bindVertexArray(a.vao), o(t, t.pathFill), r(t, a.indexCount), j(t, n) && e(t, a.indexCount, t.gl.UNSIGNED_INT), i(t), s.bindVertexArray(null);
+}
+function L(e, t) {
+	let { cmd: n, spaces: r } = g(e.state.transform, t), i = n.stroke, a = i.align ?? "center", o = r.ribbon?.metric;
+	(n.path.kind === "polygon" || o !== void 0 && !p(o)) && a !== "center" ? (d(e), V(e, n, a, r)) : R(e, n, r);
+	let s = m(i.width ?? 1, 1), c = _(n.path, t.stroke, i, s, e.flattenTolerance, r);
+	for (let t of c) T(e, t);
+}
+function R(t, r, i) {
+	let c = r.stroke, l = c.paint, u = l.fill === void 0 || l.fill === "solid", d = l, f = h(r.path, c, t.flattenTolerance, i);
+	if (f.indices.length === 0) return;
+	let p = !!(c.vertexColors && c.vertexColors.length > 0), m = v(t, l, p);
+	if (m === null || x(t, f, m)) return;
+	let g = p ? t.meshCache.uploadTransient(f) : t.meshCache.uploadRecurring(f);
+	if (!u && !p) {
+		M(t, l, g);
+		return;
+	}
+	let _ = t.gl;
+	if (p) {
+		let r = t.pathFillVColor;
+		_.useProgram(r.handle), _.bindVertexArray(g.vao), o(t, r), s(t, r, u ? d.color : "#ffffff", l.opacity), a(t, r);
+		let i = D(_, r, c.vertexColors, g);
+		n(t), e(t, g.indexCount, t.gl.UNSIGNED_INT), O(_, i), _.bindVertexArray(null);
+		return;
+	}
+	_.useProgram(t.pathFill.handle), _.bindVertexArray(g.vao), o(t, t.pathFill), s(t, t.pathFill, d.color, d.opacity), a(t, t.pathFill), n(t), e(t, g.indexCount, t.gl.UNSIGNED_INT), _.bindVertexArray(null);
+}
+var z = /* @__PURE__ */ new WeakMap();
+function B(e) {
+	let t = z.get(e);
+	return t === void 0 && (t = e.map((e) => e * 2), z.set(e, t)), t;
+}
+function V(n, r, i, c) {
+	let u = r.stroke, d = u.paint, f = d.fill === void 0 || d.fill === "solid", p = d, g = {
+		...u,
+		width: m(u.width ?? 1, 1) * 2,
+		...u.vertexWidths ? { vertexWidths: B(u.vertexWidths) } : {},
+		align: "center"
+	}, _ = !!(u.vertexColors && u.vertexColors.length > 0), v = l(n, r.path), y = h(r.path, g, n.flattenTolerance, c);
+	if (y.indices.length === 0) return;
+	let b = _ ? n.meshCache.uploadTransient(y) : n.meshCache.uploadRecurring(y), x = n.gl, S = _ ? n.pathFillVColor : n.pathFill;
+	x.useProgram(S.handle), o(n, S), x.enable(x.STENCIL_TEST), x.colorMask(!1, !1, !1, !1), x.stencilMask(1), x.stencilFunc(x.ALWAYS, 1, 1), x.stencilOp(x.KEEP, x.KEEP, v.requiresStencil ? x.INVERT : x.REPLACE), x.bindVertexArray(v.vao), e(n, v.indexCount, n.gl.UNSIGNED_INT);
+	let C = t(n.clipDepth);
+	x.colorMask(!0, !0, !0, !0), i === "inner" ? x.stencilFunc(x.EQUAL, C | 1, C | 1) : x.stencilFunc(x.EQUAL, C, C | 1), x.stencilOp(x.KEEP, x.KEEP, x.KEEP);
+	let w = S;
+	if (_ ? (s(n, S, f ? p.color : "#ffffff", d.opacity), a(n, S)) : w = j(n, d), !w) {
+		x.stencilMask(1), x.clear(x.STENCIL_BUFFER_BIT), x.disable(x.STENCIL_TEST), x.bindVertexArray(null);
+		return;
+	}
+	x.bindVertexArray(b.vao);
+	let T = _ ? D(x, w, u.vertexColors, b) : null;
+	e(n, b.indexCount, n.gl.UNSIGNED_INT), x.stencilMask(1), x.clear(x.STENCIL_BUFFER_BIT), x.disable(x.STENCIL_TEST), T && O(x, T), x.bindVertexArray(null);
+}
+//#endregion
+export { T as drawPath, M as drawPathFillByKind };
+
+//# sourceMappingURL=pathPaint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pathPaint.js","names":["drawPath","cmd","drawPathFill","ctx","drawPathStroke","fill","isSolid","hasVColors","solid","paint","batchPaint","pushRampRect","pushRect","mesh","fillMesh","tryStageFill","handle","meshHandle","drawPathFillVColor","drawPathFillStencil","drawPathFillByKind","attachVertexColors","vbo","gl","expandAnchorColors","perAnchor","location","prog","detachVertexColors","aA","aB","aT","n","out","i","a4","b4","t","setProjAndModel","setSolidPaintUniforms","setColorMatrixUniforms","colors","beginParityMask","drawTriangles","endParityMask","applyClipTest","bindPathFillByKind","kind","bindPathFillSolid","bindPathFillPattern","bindPathFillGradient","bind","getPaintKind","paintBindContext","bindPattern","bindGradient","resolveStrokeLengths","rawCmd","stroke","align","metric","spaces","metricKeepsRects","flushForOwnDraw","drawPathStrokeStenciled","drawPathStrokeUnclipped","width","resolveStrokeWidth","heads","cachedMarkerCommands","marker","strokeMesh","batched","DOUBLED_VERTEX_WIDTHS","doubledVertexWidths","doubled","widths","w","widerStroke","useVColor","fillHandle","fillMeshHandle","ribbonMesh","ribbonHandle","clipMask","ancestorMask","ribbonProg"],"sources":["../../../src/renderer/draw/pathPaint.ts"],"sourcesContent":["import type { Stroke, FillStyle } from '@weasel-js/paint';\nimport { getPaintKind } from 'core/paintKinds';\nimport type { PathDrawCommand } from '../DrawCommand';\nimport type { GLMeshHandle } from '../cache/GLMeshCache';\nimport type { ShaderProgram } from '../shaders/ShaderProgram';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport { strokeMesh } from '../cache/strokeMeshCache';\nimport { resolveStrokeLengths, type StrokedPathCommand } from '../strokeLengths';\nimport { metricKeepsRects, type StrokeSpaces } from 'features/paths/tessellate/metric';\nimport { cachedMarkerCommands } from '../cache/markerCommandCache';\nimport type { DrawContext } from './drawContext';\nimport { drawTriangles } from './drawTriangles';\nimport { fillMesh, meshHandle, fillMeshHandle } from './mesh';\nimport { setColorMatrixUniforms, setProjAndModel, setSolidPaintUniforms } from './uniforms';\nimport { applyClipTest, ancestorMask, beginParityMask, endParityMask } from './stencil';\nimport { flushForOwnDraw } from './clip';\nimport { pushRect, pushRampRect, tryStageFill } from './batch';\nimport { batchPaint } from './gradient';\nimport { paintBindContext, bindPattern, bindGradient } from './paintBind';\n\nexport function drawPath(ctx: DrawContext, cmd: PathDrawCommand): void {\n  if (cmd.fill) drawPathFill(ctx, cmd);\n  // A stroke with no `paint` paints nothing, the way a node's `fill: null`\n  // does. Commands arriving from a consumer painter or overlay can carry one.\n  if (cmd.stroke?.paint) drawPathStroke(ctx, cmd as StrokedPathCommand);\n}\n\nfunction drawPathFill(ctx: DrawContext, cmd: PathDrawCommand): void {\n  const fill = cmd.fill!;\n  // Batchable: see `batchPaint`. A rect skips tessellation entirely; anything\n  // else stages its mesh. Both also keep animated demos that mint a fresh Path\n  // every frame from allocating a GL buffer per frame.\n  const isSolid = fill.fill === undefined || fill.fill === 'solid';\n  const hasVColors = !!(cmd.vertexColors && cmd.vertexColors.length > 0);\n  const solid = fill as { color: string; opacity?: number };\n  const paint = batchPaint(ctx, fill, hasVColors);\n  if (paint === null) return;\n\n  if (paint !== undefined && cmd.path.kind === 'rect') {\n    if (paint.kind === 'ramp') pushRampRect(ctx, cmd.path, paint);\n    else pushRect(ctx, cmd.path, paint);\n    return;\n  }\n\n  const mesh = fillMesh(ctx, cmd.path);\n  if (tryStageFill(ctx, mesh, paint)) return;\n\n  const handle = meshHandle(ctx, mesh);\n  if (isSolid && hasVColors) {\n    drawPathFillVColor(ctx, cmd, solid, handle);\n  } else if (handle.requiresStencil) {\n    drawPathFillStencil(ctx, fill, handle);\n  } else {\n    drawPathFillByKind(ctx, fill, handle);\n  }\n}\n\ninterface VertexColorBinding { vbo: WebGLBuffer; location: number | undefined }\n\n/** Point the bound mesh VAO's a_vertexColor at a fresh buffer of per-vertex\n *  colors. Pair with `detachVertexColors` before the VAO is unbound. */\nfunction attachVertexColors(\n  gl: WebGL2RenderingContext, prog: ShaderProgram, perAnchor: number[], handle: GLMeshHandle,\n): VertexColorBinding {\n  const vbo = gl.createBuffer();\n  if (!vbo) throw new Error('attachVertexColors: createBuffer returned null');\n  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);\n  gl.bufferData(gl.ARRAY_BUFFER, expandAnchorColors(perAnchor, handle), gl.DYNAMIC_DRAW);\n  const location = prog.attribute('a_vertexColor');\n  if (location !== undefined) {\n    gl.enableVertexAttribArray(location);\n    gl.vertexAttribPointer(location, 4, gl.FLOAT, false, 0, 0);\n  }\n  return { vbo, location };\n}\n\n// Order matters: a buffer deleted after its VAO is unbound stays attached to\n// that VAO and is not freed until the mesh is, and one deleted while its\n// attribute is still enabled leaves the VAO unable to draw.\nfunction detachVertexColors(gl: WebGL2RenderingContext, { vbo, location }: VertexColorBinding): void {\n  if (location !== undefined) gl.disableVertexAttribArray(location);\n  gl.deleteBuffer(vbo);\n}\n\nfunction expandAnchorColors(perAnchor: number[], handle: GLMeshHandle): Float32Array {\n  const aA = handle.anchorA;\n  const aB = handle.anchorB;\n  const aT = handle.anchorT;\n  if (!aA || !aB || !aT) {\n    // Legacy fallback: mesh lacks anchor params (e.g. non-path mesh). Treat\n    // the caller-provided array as already per-vertex.\n    return new Float32Array(perAnchor);\n  }\n  const n = aA.length;\n  const out = new Float32Array(n * 4);\n  for (let i = 0; i < n; i++) {\n    const a4 = aA[i] * 4;\n    const b4 = aB[i] * 4;\n    const t = aT[i];\n    out[i * 4 + 0] = perAnchor[a4 + 0] + (perAnchor[b4 + 0] - perAnchor[a4 + 0]) * t;\n    out[i * 4 + 1] = perAnchor[a4 + 1] + (perAnchor[b4 + 1] - perAnchor[a4 + 1]) * t;\n    out[i * 4 + 2] = perAnchor[a4 + 2] + (perAnchor[b4 + 2] - perAnchor[a4 + 2]) * t;\n    out[i * 4 + 3] = perAnchor[a4 + 3] + (perAnchor[b4 + 3] - perAnchor[a4 + 3]) * t;\n  }\n  return out;\n}\n\nfunction drawPathFillVColor(\n  ctx: DrawContext,\n  cmd: PathDrawCommand,\n  fill: { color: string; opacity?: number },\n  handle: GLMeshHandle,\n): void {\n  const gl = ctx.gl;\n  const prog = ctx.pathFillVColor;\n  gl.useProgram(prog.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, prog);\n  setSolidPaintUniforms(ctx, prog, fill.color, fill.opacity);\n  setColorMatrixUniforms(ctx, prog);\n\n  const colors = attachVertexColors(gl, prog, cmd.vertexColors!, handle);\n\n  if (handle.requiresStencil) {\n    beginParityMask(ctx, handle.indexCount);\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n    endParityMask(ctx);\n  } else {\n    applyClipTest(ctx);\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  }\n  detachVertexColors(gl, colors);\n  gl.bindVertexArray(null);\n}\n\n/**\n * Bind the program, uniforms and textures for `fill`, and return the program.\n *\n * Split from the draw so a caller owning its own stencil state can paint\n * without `applyClipTest` clobbering it — `drawPathStrokeStenciled` clips a\n * doubled ribbon to one side of the silhouette, and `applyClipTest` at depth 0\n * disables the stencil test outright.\n */\nfunction bindPathFillByKind(ctx: DrawContext, fill: FillStyle): ShaderProgram | null {\n  const kind = fill.fill ?? 'solid';\n  if (kind === 'solid') return bindPathFillSolid(ctx, fill as { color: string; opacity?: number });\n  if (kind === 'pattern') return bindPathFillPattern(ctx, fill as Extract<FillStyle, { fill: 'pattern' }>);\n  if (kind === 'linear-gradient' || kind === 'radial-gradient' || kind === 'conic-gradient') {\n    return bindPathFillGradient(ctx, fill as Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>);\n  }\n  const bind = getPaintKind(kind)?.bind;\n  return bind ? bind(paintBindContext(ctx), fill) : null;\n}\n\nexport function drawPathFillByKind(ctx: DrawContext, fill: FillStyle, handle: GLMeshHandle): void {\n  const prog = bindPathFillByKind(ctx, fill);\n  if (!prog) return;\n  const gl = ctx.gl;\n  gl.bindVertexArray(handle.vao);\n  applyClipTest(ctx);\n  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  gl.bindVertexArray(null);\n}\n\nfunction bindPathFillSolid(\n  ctx: DrawContext,\n  fill: { color: string; opacity?: number },\n): ShaderProgram {\n  const prog = ctx.pathFill;\n  ctx.gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog);\n  setSolidPaintUniforms(ctx, prog, fill.color, fill.opacity);\n  setColorMatrixUniforms(ctx, prog);\n  return prog;\n}\n\nfunction bindPathFillPattern(\n  ctx: DrawContext,\n  fill: Extract<FillStyle, { fill: 'pattern' }>,\n): ShaderProgram | null {\n  return bindPattern(ctx, ctx.patternFill, fill, ctx.state.transform);\n}\n\nfunction bindPathFillGradient(\n  ctx: DrawContext,\n  fill: Extract<FillStyle, { fill: 'linear-gradient' | 'radial-gradient' | 'conic-gradient' }>,\n): ShaderProgram | null {\n  return bindGradient(ctx, ctx.gradFill, fill, ctx.state.transform);\n}\n\nfunction drawPathFillStencil(ctx: DrawContext, fill: FillStyle, handle: GLMeshHandle): void {\n  const gl = ctx.gl;\n  gl.useProgram(ctx.pathFill.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, ctx.pathFill);\n\n  beginParityMask(ctx, handle.indexCount);\n  // The paint binds here, not above: pass 1 runs under a false colorMask, so a\n  // uniform missed here renders black while the GL-recorder tests still pass.\n  // Not `drawPathFillByKind` — its `applyClipTest` would disable this stencil.\n  if (bindPathFillByKind(ctx, fill)) {\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  }\n\n  endParityMask(ctx);\n  gl.bindVertexArray(null);\n}\n\nfunction drawPathStroke(ctx: DrawContext, rawCmd: StrokedPathCommand): void {\n  const { cmd, spaces } = resolveStrokeLengths(ctx.state.transform, rawCmd);\n  const stroke = cmd.stroke;\n  const align = stroke.align ?? 'center';\n  const metric = spaces.ribbon?.metric;\n  // A rect the metric turns is no longer a rect in the space its ribbon is\n  // built in, so it aligns through the stencil like any polygon.\n  const stenciled = cmd.path.kind === 'polygon' || (metric !== undefined && !metricKeepsRects(metric));\n  if (stenciled && align !== 'center') {\n    flushForOwnDraw(ctx);\n    drawPathStrokeStenciled(ctx, cmd, align, spaces);\n  } else {\n    drawPathStrokeUnclipped(ctx, cmd, spaces);\n  }\n  // After the ribbon, so a head sits on top of the line it caps.\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  const heads = cachedMarkerCommands(cmd.path, rawCmd.stroke, stroke, width, ctx.flattenTolerance, spaces);\n  for (const marker of heads) drawPath(ctx, marker);\n}\n\nfunction drawPathStrokeUnclipped(ctx: DrawContext, cmd: StrokedPathCommand, spaces: StrokeSpaces): void {\n  const stroke = cmd.stroke;\n  const paint = stroke.paint;\n  const isSolid = paint.fill === undefined || paint.fill === 'solid';\n  const solid = paint as { color: string; opacity?: number };\n  const mesh = strokeMesh(cmd.path, stroke, ctx.flattenTolerance, spaces);\n  if (mesh.indices.length === 0) return;\n\n  // Staged, a ribbon allocates nothing and joins the fill it sits on.\n  const hasVColors = !!(stroke.vertexColors && stroke.vertexColors.length > 0);\n  const batched = batchPaint(ctx, paint, hasVColors);\n  if (batched === null) return;\n  if (tryStageFill(ctx, mesh, batched)) return;\n\n  // The VAO records the per-draw color attribute, so a vertex-colored draw\n  // cannot share a persistent one with a draw that has no vertex colors.\n  const handle = hasVColors\n    ? ctx.meshCache.uploadTransient(mesh)\n    : ctx.meshCache.uploadRecurring(mesh);\n\n  if (!isSolid && !hasVColors) {\n    drawPathFillByKind(ctx, paint, handle);\n    return;\n  }\n\n  const gl = ctx.gl;\n  if (hasVColors) {\n    const prog = ctx.pathFillVColor;\n    gl.useProgram(prog.handle);\n    gl.bindVertexArray(handle.vao);\n    setProjAndModel(ctx, prog);\n    // Per-vertex colors are the paint here; a non-solid base has no single\n    // color to multiply by, so white leaves the vertex colors unmodified.\n    setSolidPaintUniforms(ctx, prog, isSolid ? solid.color : '#ffffff', paint.opacity);\n    setColorMatrixUniforms(ctx, prog);\n\n    const colors = attachVertexColors(gl, prog, stroke.vertexColors!, handle);\n    applyClipTest(ctx);\n    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n    detachVertexColors(gl, colors);\n    gl.bindVertexArray(null);\n    return;\n  }\n\n  gl.useProgram(ctx.pathFill.handle);\n  gl.bindVertexArray(handle.vao);\n  setProjAndModel(ctx, ctx.pathFill);\n  setSolidPaintUniforms(ctx, ctx.pathFill, solid.color, solid.opacity);\n  setColorMatrixUniforms(ctx, ctx.pathFill);\n  applyClipTest(ctx);\n  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);\n  gl.bindVertexArray(null);\n}\n\n/** The ribbon cache compares `vertexWidths` by reference, so the doubled copy\n *  has to be the same array on every frame the source array is. */\nconst DOUBLED_VERTEX_WIDTHS = new WeakMap<number[], number[]>();\n\nfunction doubledVertexWidths(widths: number[]): number[] {\n  let doubled = DOUBLED_VERTEX_WIDTHS.get(widths);\n  if (doubled === undefined) {\n    doubled = widths.map((w) => w * 2);\n    DOUBLED_VERTEX_WIDTHS.set(widths, doubled);\n  }\n  return doubled;\n}\n\nfunction drawPathStrokeStenciled(\n  ctx: DrawContext,\n  cmd: StrokedPathCommand,\n  align: 'inner' | 'outer',\n  spaces: StrokeSpaces,\n): void {\n  const stroke = cmd.stroke;\n  const paint = stroke.paint;\n  const isSolid = paint.fill === undefined || paint.fill === 'solid';\n  const solid = paint as { color: string; opacity?: number };\n  const widerStroke: Stroke = {\n    ...stroke,\n    width: resolveStrokeWidth(stroke.width ?? 1, 1) * 2,\n    ...(stroke.vertexWidths ? { vertexWidths: doubledVertexWidths(stroke.vertexWidths) } : {}),\n    align: 'center',\n  };\n\n  const useVColor = !!(stroke.vertexColors && stroke.vertexColors.length > 0);\n\n  const fillHandle = fillMeshHandle(ctx, cmd.path);\n  const ribbonMesh = strokeMesh(cmd.path, widerStroke, ctx.flattenTolerance, spaces);\n  if (ribbonMesh.indices.length === 0) return;\n  // The VAO records the per-draw color attribute, so a vertex-colored draw\n  // cannot share a persistent one with a draw that has no vertex colors.\n  const ribbonHandle = useVColor\n    ? ctx.meshCache.uploadTransient(ribbonMesh)\n    : ctx.meshCache.uploadRecurring(ribbonMesh);\n\n  const gl = ctx.gl;\n  const prog = useVColor ? ctx.pathFillVColor : ctx.pathFill;\n  gl.useProgram(prog.handle);\n  setProjAndModel(ctx, prog);\n\n  gl.enable(gl.STENCIL_TEST);\n  gl.colorMask(false, false, false, false);\n  gl.stencilMask(0x01);\n  gl.stencilFunc(gl.ALWAYS, 1, 0x01);\n  // An even-odd fill is one fan per contour, and only parity cuts its holes.\n  gl.stencilOp(gl.KEEP, gl.KEEP, fillHandle.requiresStencil ? gl.INVERT : gl.REPLACE);\n  gl.bindVertexArray(fillHandle.vao);\n  drawTriangles(ctx, fillHandle.indexCount, ctx.gl.UNSIGNED_INT);\n\n  const clipMask = ancestorMask(ctx.clipDepth);\n  gl.colorMask(true, true, true, true);\n  if (align === 'inner') {\n    gl.stencilFunc(gl.EQUAL, clipMask | 0x01, clipMask | 0x01);\n  } else {\n    gl.stencilFunc(gl.EQUAL, clipMask, clipMask | 0x01);\n  }\n  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);\n  // Bind the paint here rather than through `drawPathFillByKind`: that calls\n  // `applyClipTest`, which at clip depth 0 disables the stencil test this\n  // function just set up to clip the ribbon to one side.\n  let ribbonProg: ShaderProgram | null = prog;\n  if (useVColor) {\n    // Per-vertex colors are the paint here; a non-solid base has no single\n    // color to multiply by, so white leaves the vertex colors unmodified.\n    setSolidPaintUniforms(ctx, prog, isSolid ? solid.color : '#ffffff', paint.opacity);\n    setColorMatrixUniforms(ctx, prog);\n  } else {\n    ribbonProg = bindPathFillByKind(ctx, paint);\n  }\n  if (!ribbonProg) {\n    gl.stencilMask(0x01);\n    gl.clear(gl.STENCIL_BUFFER_BIT);\n    gl.disable(gl.STENCIL_TEST);\n    gl.bindVertexArray(null);\n    return;\n  }\n  gl.bindVertexArray(ribbonHandle.vao);\n\n  const colors = useVColor\n    ? attachVertexColors(gl, ribbonProg, stroke.vertexColors!, ribbonHandle)\n    : null;\n\n  drawTriangles(ctx, ribbonHandle.indexCount, ctx.gl.UNSIGNED_INT);\n\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  if (colors) detachVertexColors(gl, colors);\n  gl.bindVertexArray(null);\n}\n"],"mappings":"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"}