@weasel-js/core 1.9.4 → 1.10.0

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

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

package/dist/renderer/draw/uniforms.js

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

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

package/dist/renderer/draw.js

@@ -1,79 +0,0 @@
-import "./math/mat3.js";
-import "./cache/cache.js";
-import { compositeProgramId as e } from "./effects/composite.js";
-import { applyClipTest as t } from "./draw/stencil.js";
-import { drawShader as n, warnOnceUniform as r } from "./draw/customShader.js";
-import { drawFullscreenQuad as i, returnToRenderTarget as a } from "./draw/effects.js";
-import { flushBatch as o } from "./draw/flushBatch.js";
-import { enterGroupClip as s, flushForOwnDraw as c, leaveClip as l } from "./draw/clip.js";
-import "./draw/batch.js";
-import { drawPath as u } from "./draw/pathPaint.js";
-import { OUTLINE_MIN_SCREEN_PX as d, drawText as f } from "./draw/text.js";
-import { drawImage as p, drawSprites as m } from "./draw/image.js";
-//#region src/renderer/draw.ts
-function h(e, t) {
-	switch (t.kind) {
-		case "group": return _(e, t);
-		case "path": return u(e, t);
-		case "text": return f(e, t);
-		case "image": return p(e, t);
-		case "sprites": return m(e, t);
-		case "shader": return c(e), n(e, t);
-	}
-}
-function g(n, s, l, u, d) {
-	let f = n.gl;
-	c(n);
-	let p = n.renderTarget ?? null, m = n.clipDepth, g = n.clipStack, _ = n.drawBatch.clip, v = f.isEnabled(f.SCISSOR_TEST), y = l.acquire(u, d), b = n.state.pushIsolated({
-		transform: s.transform,
-		alpha: s.alpha,
-		colorMatrix: s.colorMatrix
-	});
-	n.clipDepth = 0, n.clipStack = [], n.drawBatch.clip = null, f.bindFramebuffer(f.FRAMEBUFFER, y.fbo), n.renderTarget = y, f.viewport(0, 0, u, d), f.disable(f.SCISSOR_TEST), f.stencilMask(255), f.clear(f.COLOR_BUFFER_BIT | f.STENCIL_BUFFER_BIT);
-	for (let e of s.children) h(n, e);
-	o(n), f.disable(f.BLEND), f.disable(f.STENCIL_TEST);
-	for (let e of s.effects) {
-		let t = n.ensureProgram?.(e.program.id) ?? null;
-		if (!t) {
-			r(e.program.id, "(program)");
-			continue;
-		}
-		let a = l.acquire(u, d);
-		f.bindFramebuffer(f.FRAMEBUFFER, a.fbo), f.viewport(0, 0, u, d), f.clear(f.COLOR_BUFFER_BIT), i(n, t, y.texture, u, d, e.uniforms, void 0, e.program.id), l.release(y), y = a;
-	}
-	f.enable(f.BLEND), n.state.pop(), n.clipDepth = m, n.clipStack = g, n.drawBatch.clip = _, n.renderTarget = p, a(n, u, d, v);
-	let x = n.ensureProgram?.(e()) ?? null;
-	x && (t(n), i(n, x, y.texture, u, d, void 0, {
-		alpha: b.alpha,
-		colorMatrix: b.colorMatrix
-	})), l.release(y);
-}
-function _(e, t) {
-	if (t.effects && t.effects.length > 0 && e.effectTargets && e.deviceWidth && e.deviceHeight) {
-		if (t.clip) {
-			e.state.push({ transform: t.transform });
-			try {
-				s(e, t.clip);
-			} finally {
-				e.state.pop();
-			}
-		}
-		g(e, t, e.effectTargets, e.deviceWidth, e.deviceHeight), t.clip && l(e);
-		return;
-	}
-	if (e.state.push({
-		transform: t.transform,
-		alpha: t.alpha,
-		colorMatrix: t.colorMatrix
-	}), t.clip) try {
-		s(e, t.clip);
-	} catch (t) {
-		throw e.state.pop(), t;
-	}
-	for (let n of t.children) h(e, n);
-	t.clip && l(e), e.state.pop();
-}
-//#endregion
-export { d as OUTLINE_MIN_SCREEN_PX, h as dispatch, _ as drawGroup, o as flushBatch };
-
-//# sourceMappingURL=draw.js.map

package/dist/renderer/draw.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"draw.js","names":["dispatch","cmd","drawGroup","ctx","drawPath","drawText","drawImage","drawSprites","flushForOwnDraw","drawShader","drawGroupWithEffects","gl","parentTarget","parentClipDepth","parentClipStack","parentBatchClip","scissorWasOn","front","targets","width","height","composited","child","flushBatch","effect","program","back","drawFullscreenQuad","returnToRenderTarget","composite","compositeProgramId","applyClipTest","leaveClip","err","OUTLINE_MIN_SCREEN_PX"],"sources":["../../src/renderer/draw.ts"],"sourcesContent":["import type { DrawCommand, GroupDrawCommand } from './DrawCommand';\nimport { mat3 } from './math/mat3';\nimport { getMesh } from './cache/cache';\nimport type { EffectTargets } from './effects/EffectTargets';\nimport { compositeProgramId } from './effects/composite';\nimport type { DrawContext } from './draw/drawContext';\nimport { warnOnceUniform, drawShader } from './draw/customShader';\nimport { returnToRenderTarget, drawFullscreenQuad } from './draw/effects';\nimport { applyClipTest } from './draw/stencil';\nimport { enterGroupClip, leaveClip, flushForOwnDraw } from './draw/clip';\nimport { flushBatch } from './draw/flushBatch';\nimport { drawPath } from './draw/pathPaint';\nimport { drawText } from './draw/text';\nimport { drawImage, drawSprites } from './draw/image';\n\nexport function dispatch(ctx: DrawContext, cmd: DrawCommand): void {\n  switch (cmd.kind) {\n    case 'group':  return drawGroup(ctx, cmd);\n    case 'path':   return drawPath(ctx, cmd);\n    case 'text':   return drawText(ctx, cmd);\n    case 'image':  return drawImage(ctx, cmd);\n    case 'sprites': return drawSprites(ctx, cmd);\n    case 'shader': flushForOwnDraw(ctx); return drawShader(ctx, cmd);\n  }\n}\n\n/**\n * Draw a group's children into a buffer of their own, run its effects over\n * that buffer, and composite the result back where the group sits.\n *\n * Three things are deliberately not inherited by the offscreen render:\n *\n * - **The clip.** A fresh buffer's stencil is empty, so a child drawn at the\n *   enclosing clip depth would test against bits that were never written and\n *   paint nothing. The enclosing clip belongs on the composite anyway — it\n *   clips the group's result, not the pixels an effect reads — so `clipDepth`\n *   restarts at 0 inside, which also hands nested clips a fresh budget.\n * - **Alpha and color**, for the same reason from the other end: fading on\n *   the way in would give the effect faded pixels to read, and fade them\n *   again on the way out. `pushIsolated` returns what the composite owes.\n * - **The scissor**, which belongs to the renderer's sub-rect within the\n *   default framebuffer and means nothing in a buffer sized to the whole\n *   drawing buffer.\n */\nfunction drawGroupWithEffects(\n  ctx: DrawContext,\n  cmd: GroupDrawCommand,\n  targets: EffectTargets,\n  width: number,\n  height: number,\n): void {\n  const gl = ctx.gl;\n  // Anything staged belongs to the parent's buffer, not this one, and the\n  // composite below draws under the parent's clips.\n  flushForOwnDraw(ctx);\n\n  const parentTarget = ctx.renderTarget ?? null;\n  const parentClipDepth = ctx.clipDepth;\n  const parentClipStack = ctx.clipStack;\n  const parentBatchClip = ctx.drawBatch.clip;\n  const scissorWasOn = gl.isEnabled(gl.SCISSOR_TEST);\n\n  let front = targets.acquire(width, height);\n  const composited = ctx.state.pushIsolated({\n    transform: cmd.transform,\n    alpha: cmd.alpha,\n    colorMatrix: cmd.colorMatrix,\n  });\n  ctx.clipDepth = 0;\n  ctx.clipStack = [];\n  ctx.drawBatch.clip = null;\n\n  gl.bindFramebuffer(gl.FRAMEBUFFER, front.fbo);\n  ctx.renderTarget = front;\n  gl.viewport(0, 0, width, height);\n  gl.disable(gl.SCISSOR_TEST);\n  gl.stencilMask(0xFF);\n  gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);\n\n  for (const child of cmd.children) dispatch(ctx, child);\n  flushBatch(ctx);\n\n  // Passes replace rather than blend: each writes every texel of its target\n  // from the whole of its source. A child that ended by popping a stencil\n  // clip leaves the test on, and no pass target has that clip's bits.\n  gl.disable(gl.BLEND);\n  gl.disable(gl.STENCIL_TEST);\n  for (const effect of cmd.effects!) {\n    const program = ctx.ensureProgram?.(effect.program.id) ?? null;\n    if (!program) {\n      warnOnceUniform(effect.program.id, '(program)');\n      continue;\n    }\n    const back = targets.acquire(width, height);\n    gl.bindFramebuffer(gl.FRAMEBUFFER, back.fbo);\n    gl.viewport(0, 0, width, height);\n    gl.clear(gl.COLOR_BUFFER_BIT);\n    drawFullscreenQuad(ctx, program, front.texture, width, height, effect.uniforms,\n      undefined, effect.program.id);\n    targets.release(front);\n    front = back;\n  }\n  gl.enable(gl.BLEND);\n\n  // Back to the parent's buffer, and back under its rules.\n  ctx.state.pop();\n  ctx.clipDepth = parentClipDepth;\n  ctx.clipStack = parentClipStack;\n  ctx.drawBatch.clip = parentBatchClip;\n  ctx.renderTarget = parentTarget;\n  returnToRenderTarget(ctx, width, height, scissorWasOn);\n\n  const composite = ctx.ensureProgram?.(compositeProgramId()) ?? null;\n  if (composite) {\n    applyClipTest(ctx);\n    drawFullscreenQuad(ctx, composite, front.texture, width, height, undefined, {\n      alpha: composited.alpha,\n      colorMatrix: composited.colorMatrix,\n    });\n  }\n  targets.release(front);\n}\n\nexport function drawGroup(ctx: DrawContext, cmd: GroupDrawCommand): void {\n  // A group with effects is a render-target boundary rather than another\n  // accumulating frame. Without a renderer's buffer pool behind the context\n  // there is nowhere to draw, so the effects are skipped and the children\n  // paint straight through — a frame missing its blur, not a frame missing.\n  if (cmd.effects && cmd.effects.length > 0 && ctx.effectTargets\n      && ctx.deviceWidth && ctx.deviceHeight) {\n    // The clip cuts the composite, so it goes on the parent's buffer, in the\n    // group's own space.\n    if (cmd.clip) {\n      ctx.state.push({ transform: cmd.transform });\n      try {\n        enterGroupClip(ctx, cmd.clip);\n      } finally {\n        ctx.state.pop();\n      }\n    }\n    drawGroupWithEffects(ctx, cmd, ctx.effectTargets, ctx.deviceWidth, ctx.deviceHeight);\n    if (cmd.clip) leaveClip(ctx);\n    return;\n  }\n  ctx.state.push({\n    transform: cmd.transform,\n    alpha: cmd.alpha,\n    colorMatrix: cmd.colorMatrix,\n  });\n  if (cmd.clip) {\n    try {\n      enterGroupClip(ctx, cmd.clip);\n    } catch (err) {\n      ctx.state.pop();\n      throw err;\n    }\n  }\n  for (const child of cmd.children) dispatch(ctx, child);\n  if (cmd.clip) leaveClip(ctx);\n  ctx.state.pop();\n}\n\nexport { mat3, getMesh };\nexport type { DrawContext, ClipEntry, GlyphPaintKind } from './draw/drawContext';\nexport { setUniform } from './draw/customShader';\nexport { meshBatching, tryStageFill } from './draw/batch';\nexport { flushBatch } from './draw/flushBatch';\nexport { pushClip, popClip } from './draw/clip';\nexport { OUTLINE_MIN_SCREEN_PX } from './draw/text';\n"],"mappings":"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"}

package/dist/renderer/drawBatch.js

@@ -1,198 +0,0 @@
-import { PAINT_MODE_PLAIN as e, WHITE_SLOT as t, packSlot as n } from "./shaders/batchFill.js";
-import { clipConvexPolygon as r } from "./batchClip.js";
-//#region src/renderer/drawBatch.ts
-var i = 32768, a = 10, o = 256, s = 384, c = .5, l = .5, u = n(t, e), d = 64, f = [{
-	vertices: 16,
-	indices: 24
-}, {
-	vertices: 1024,
-	indices: 3072
-}], p = f[f.length - 1].vertices, m = 4;
-function h(e, t) {
-	let n = e;
-	for (; n < t;) n *= 2;
-	return n;
-}
-function g(e) {
-	let t = new Uint32Array(e * 6);
-	for (let n = 0; n < e; n++) {
-		let e = n * 4, r = n * 6;
-		t[r] = e, t[r + 1] = e + 1, t[r + 2] = e + 2, t[r + 3] = e, t[r + 4] = e + 2, t[r + 5] = e + 3;
-	}
-	return t;
-}
-var _ = class {
-	gl;
-	aPos;
-	aColor;
-	aUv;
-	aPost;
-	aSlot;
-	rings = f.map(() => Array(d).fill(void 0));
-	nextInRing = f.map(() => 0);
-	largeRing = Array(m).fill(void 0);
-	nextLarge = 0;
-	verts = new Float32Array(o * a);
-	idx = new Uint32Array(s);
-	nVerts = 0;
-	nIdx = 0;
-	pureRects = !0;
-	clip = null;
-	polyIn = /* @__PURE__ */ new Float32Array(80);
-	polyOut = /* @__PURE__ */ new Float32Array(80);
-	polyTmp = /* @__PURE__ */ new Float32Array(80);
-	constructor(e, t) {
-		let n = t.attribute("a_position"), r = t.attribute("a_vertexColor"), i = t.attribute("a_uv"), a = t.attribute("a_post"), o = t.attribute("a_texSlot");
-		if (n === void 0 || r === void 0 || i === void 0 || a === void 0 || o === void 0) throw Error("DrawBatch: batch program is missing a_position / a_vertexColor / a_uv / a_post / a_texSlot");
-		this.gl = e, this.aPos = n, this.aColor = r, this.aUv = i, this.aPost = a, this.aSlot = o;
-	}
-	get length() {
-		return this.nIdx;
-	}
-	wouldOverflow(e) {
-		return this.nVerts + e > i;
-	}
-	pushRect(e, t, n, r, i, o, s, d, f) {
-		this.reserve(4, 6);
-		let p = this.nVerts * a, m = i[0], h = i[1], g = i[3], _ = i[4], v = i[6], y = i[7], b = e + n, x = t + r, S = m * e + g * t + v, C = h * e + _ * t + y, w = m * b + g * t + v, T = h * b + _ * t + y, E = m * b + g * x + v, D = h * b + _ * x + y, O = m * e + g * x + v, k = h * e + _ * x + y, A = u;
-		return p = this.writeVertex(p, S, C, o, s, d, f, c, l, 1, A), p = this.writeVertex(p, w, T, o, s, d, f, c, l, 1, A), p = this.writeVertex(p, E, D, o, s, d, f, c, l, 1, A), this.writeVertex(p, O, k, o, s, d, f, c, l, 1, A), this.pushQuadIndices(), this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
-	}
-	pushQuad(t, r, i, o, s, c, l, u, d, f, p) {
-		this.reserve(4, 6);
-		let m = this.nVerts * a, h = s[0], g = s[1], _ = s[3], v = s[4], y = s[6], b = s[7], x = t + i, S = r + o, C = h * t + _ * r + y, w = g * t + v * r + b, T = h * x + _ * r + y, E = g * x + v * r + b, D = h * x + _ * S + y, O = g * x + v * S + b, k = h * t + _ * S + y, A = g * t + v * S + b, j = n(p, e);
-		return m = this.writeVertex(m, C, w, 1, 1, 1, 1, c, l, f, j), m = this.writeVertex(m, T, E, 1, 1, 1, 1, u, l, f, j), m = this.writeVertex(m, D, O, 1, 1, 1, 1, u, d, f, j), this.writeVertex(m, k, A, 1, 1, 1, 1, c, d, f, j), this.pushQuadIndices(), this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
-	}
-	pushGlyph(e, t, r, i, o, s, c, l, u, d, f, p, m, h, g, _, v) {
-		this.reserve(4, 6);
-		let y = this.nVerts * a, b = c[0], x = c[1], S = c[3], C = c[4], w = c[6], T = c[7], E = (o - t) * s, D = (o - i) * s, O = e + E, k = r + E, A = e + D, j = r + D, M = b * O + S * t + w, N = x * O + C * t + T, P = b * k + S * t + w, F = x * k + C * t + T, I = b * j + S * i + w, L = x * j + C * i + T, R = b * A + S * i + w, z = x * A + C * i + T, B = n(_, v);
-		return y = this.writeVertex(y, M, N, p, m, h, g, l, u, 1, B), y = this.writeVertex(y, P, F, p, m, h, g, d, u, 1, B), y = this.writeVertex(y, I, L, p, m, h, g, d, f, 1, B), this.writeVertex(y, R, z, p, m, h, g, l, f, 1, B), this.pushQuadIndices(), this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
-	}
-	pushGradientRect(e, t, r, i, o, s, c, l, u, d, f, p, m) {
-		this.reserve(4, 6);
-		let h = this.nVerts * a, g = o[0], _ = o[1], v = o[3], y = o[4], b = o[6], x = o[7], S = e + r, C = t + i, w = n(l, u), T = (e, t) => {
-			let n = h;
-			return h = this.writeVertex(n, g * e + v * t + b, _ * e + y * t + x, d, f, p, m, s.ux * e + s.uy * t + s.u0, s.vx * e + s.vy * t + s.v0, c, w), h;
-		};
-		return T(e, t), T(S, t), T(S, C), T(e, C), this.pushQuadIndices(), this.clip === null || this.clipQuad(this.nVerts - 4, this.nIdx - 6, this.clip);
-	}
-	pushGradientMesh(e, t, r, i, o, s, c, l, u, d) {
-		let f = e.vertices, p = e.indices, m = f.length >> 1;
-		this.reserve(m, p.length), this.pureRects = !1;
-		let h = this.verts, g = this.nVerts * a, _ = t[0], v = t[1], y = t[3], b = t[4], x = t[6], S = t[7], C = n(o, s);
-		for (let e = 0; e < m; e++) {
-			let t = f[e * 2], n = f[e * 2 + 1];
-			h[g++] = _ * t + y * n + x, h[g++] = v * t + b * n + S, h[g++] = c, h[g++] = l, h[g++] = u, h[g++] = d, h[g++] = r.ux * t + r.uy * n + r.u0, h[g++] = r.vx * t + r.vy * n + r.v0, h[g++] = i, h[g++] = C;
-		}
-		let w = this.nVerts, T = this.idx, E = this.nIdx;
-		for (let e = 0; e < p.length; e++) T[E++] = w + p[e];
-		return this.nVerts += m, this.nIdx += p.length, this.clip === null || this.clipMesh(w, this.nIdx - p.length, this.clip);
-	}
-	pushMesh(e, t, n, r, i, o) {
-		let s = e.vertices, d = e.indices, f = s.length >> 1;
-		this.reserve(f, d.length), this.pureRects = !1;
-		let p = this.verts, m = this.nVerts * a, h = t[0], g = t[1], _ = t[3], v = t[4], y = t[6], b = t[7];
-		for (let e = 0; e < f; e++) {
-			let t = s[e * 2], a = s[e * 2 + 1];
-			p[m++] = h * t + _ * a + y, p[m++] = g * t + v * a + b, p[m++] = n, p[m++] = r, p[m++] = i, p[m++] = o, p[m++] = c, p[m++] = l, p[m++] = 1, p[m++] = u;
-		}
-		let x = this.nVerts, S = this.idx, C = this.nIdx;
-		for (let e = 0; e < d.length; e++) S[C++] = x + d[e];
-		return this.nVerts += f, this.nIdx += d.length, this.clip === null || this.clipMesh(x, this.nIdx - d.length, this.clip);
-	}
-	uploadAndBind() {
-		let e = this.gl, t = f.findIndex((e) => this.nVerts <= e.vertices && this.nIdx <= e.indices), n = t < 0 ? this.nextLargeSlot() : this.nextRingSlot(t);
-		if (e.bindVertexArray(n.vao), e.bindBuffer(e.ARRAY_BUFFER, n.vbo), e.bufferSubData(e.ARRAY_BUFFER, 0, this.verts, 0, this.nVerts * a), !this.pureRects) e.bufferSubData(e.ELEMENT_ARRAY_BUFFER, 0, this.idx, 0, this.nIdx), n.canonicalQuads = 0;
-		else if (n.canonicalQuads < this.nVerts >> 2) {
-			let t = Math.min(n.vertexCapacity >> 2, Math.floor(n.indexCapacity / 6));
-			e.bufferSubData(e.ELEMENT_ARRAY_BUFFER, 0, g(t)), n.canonicalQuads = t;
-		}
-		return this.nIdx;
-	}
-	reset() {
-		this.nVerts = 0, this.nIdx = 0, this.pureRects = !0;
-	}
-	dispose() {
-		for (let e of [...this.rings.flat(), ...this.largeRing]) e && this.deleteSet(e);
-		for (let e of this.rings) e.fill(void 0);
-		this.largeRing.fill(void 0);
-	}
-	writeVertex(e, t, n, r, i, o, s, c, l, u, d) {
-		let f = this.verts;
-		return f[e] = t, f[e + 1] = n, f[e + 2] = r, f[e + 3] = i, f[e + 4] = o, f[e + 5] = s, f[e + 6] = c, f[e + 7] = l, f[e + 8] = u, f[e + 9] = d, e + a;
-	}
-	clipQuad(e, t, n) {
-		let i = this.verts, o = e * a, s = a, c = i[o], l = i[o + 1], u = i[o + s], d = i[o + s + 1], f = i[o + 20], p = i[o + 20 + 1], m = i[o + 30], h = i[o + 30 + 1], g = Math.min(c, u, f, m), _ = Math.max(c, u, f, m), v = Math.min(l, d, p, h), y = Math.max(l, d, p, h);
-		if (g >= n.x0 && _ <= n.x1 && v >= n.y0 && y <= n.y1 || (this.nVerts = e, this.nIdx = t, _ <= n.x0 || g >= n.x1 || y <= n.y0 || v >= n.y1)) return !0;
-		if (!(l === d && u === f && p === h && m === c || c === u && d === p && f === m && h === l)) return !1;
-		this.polyIn.set(i.subarray(o, o + 40));
-		let b = r(this.polyIn, 4, s, n, this.polyOut, this.polyTmp);
-		return this.appendFan(this.polyOut, b), !0;
-	}
-	clipMesh(e, t, n) {
-		let r = this.verts, i = Infinity, o = Infinity, s = -Infinity, c = -Infinity;
-		for (let t = e * a; t < this.nVerts * a; t += a) {
-			let e = r[t], n = r[t + 1];
-			e < i && (i = e), e > s && (s = e), n < o && (o = n), n > c && (c = n);
-		}
-		return i >= n.x0 && s <= n.x1 && o >= n.y0 && c <= n.y1 || (this.nVerts = e, this.nIdx = t, s <= n.x0 || i >= n.x1 || c <= n.y0 || o >= n.y1);
-	}
-	appendFan(e, t) {
-		if (t < 3) return;
-		this.reserve(t, (t - 2) * 3), t !== 4 && (this.pureRects = !1);
-		let n = this.nVerts;
-		this.verts.set(e.subarray(0, t * a), n * a);
-		let r = this.nIdx;
-		for (let e = 1; e < t - 1; e++) this.idx[r++] = n, this.idx[r++] = n + e, this.idx[r++] = n + e + 1;
-		this.nVerts += t, this.nIdx = r;
-	}
-	pushQuadIndices() {
-		let e = this.nVerts, t = this.nIdx;
-		this.idx[t++] = e, this.idx[t++] = e + 1, this.idx[t++] = e + 2, this.idx[t++] = e, this.idx[t++] = e + 2, this.idx[t++] = e + 3, this.nVerts += 4, this.nIdx += 6;
-	}
-	reserve(e, t) {
-		let n = (this.nVerts + e) * a;
-		if (n > this.verts.length) {
-			let e = new Float32Array(h(this.verts.length, n));
-			e.set(this.verts), this.verts = e;
-		}
-		let r = this.nIdx + t;
-		if (r > this.idx.length) {
-			let e = new Uint32Array(h(this.idx.length, r));
-			e.set(this.idx), this.idx = e;
-		}
-	}
-	nextRingSlot(e) {
-		let t = this.rings[e], n = this.nextInRing[e];
-		this.nextInRing[e] = (n + 1) % t.length;
-		let r = t[n];
-		if (r) return r;
-		let i = this.createSet(f[e].vertices, f[e].indices);
-		return t[n] = i, i;
-	}
-	nextLargeSlot() {
-		let e = this.gl, t = this.nextLarge;
-		this.nextLarge = (t + 1) % m;
-		let n = this.largeRing[t];
-		return n ? (this.nVerts > n.vertexCapacity && (n.vertexCapacity = h(n.vertexCapacity, this.nVerts), e.bindBuffer(e.ARRAY_BUFFER, n.vbo), e.bufferData(e.ARRAY_BUFFER, n.vertexCapacity * a * 4, e.DYNAMIC_DRAW)), this.nIdx > n.indexCapacity && (n.indexCapacity = h(n.indexCapacity, this.nIdx), e.bindVertexArray(n.vao), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, n.ibo), e.bufferData(e.ELEMENT_ARRAY_BUFFER, n.indexCapacity * 4, e.DYNAMIC_DRAW), e.bindVertexArray(null), n.canonicalQuads = 0), n) : (n = this.createSet(h(p, this.nVerts), h(f[f.length - 1].indices, this.nIdx)), this.largeRing[t] = n, n);
-	}
-	createSet(e, t) {
-		let n = this.gl, r = n.createVertexArray(), i = n.createBuffer(), a = n.createBuffer();
-		if (!r || !i || !a) throw Error("DrawBatch: failed to create GL objects");
-		return n.bindVertexArray(r), n.bindBuffer(n.ARRAY_BUFFER, i), n.bufferData(n.ARRAY_BUFFER, e * 40, n.DYNAMIC_DRAW), n.enableVertexAttribArray(this.aPos), n.vertexAttribPointer(this.aPos, 2, n.FLOAT, !1, 40, 0), n.enableVertexAttribArray(this.aColor), n.vertexAttribPointer(this.aColor, 4, n.FLOAT, !1, 40, 8), n.enableVertexAttribArray(this.aUv), n.vertexAttribPointer(this.aUv, 2, n.FLOAT, !1, 40, 24), n.enableVertexAttribArray(this.aPost), n.vertexAttribPointer(this.aPost, 1, n.FLOAT, !1, 40, 32), n.enableVertexAttribArray(this.aSlot), n.vertexAttribPointer(this.aSlot, 1, n.FLOAT, !1, 40, 36), n.bindBuffer(n.ELEMENT_ARRAY_BUFFER, a), n.bufferData(n.ELEMENT_ARRAY_BUFFER, t * 4, n.DYNAMIC_DRAW), n.bindVertexArray(null), {
-			vao: r,
-			vbo: i,
-			ibo: a,
-			vertexCapacity: e,
-			indexCapacity: t,
-			canonicalQuads: 0
-		};
-	}
-	deleteSet(e) {
-		let t = this.gl;
-		t.deleteBuffer(e.vbo), t.deleteBuffer(e.ibo), t.deleteVertexArray(e.vao);
-	}
-};
-//#endregion
-export { f as BATCH_TIERS, _ as DrawBatch, a as FLOATS_PER_VERTEX, i as MAX_VERTICES_PER_BATCH, m as SOLID_LARGE_RING_SIZE, d as SOLID_RING_SIZE, p as SOLID_RING_SLOT_VERTICES, c as WHITE_U, l as WHITE_V };
-
-//# sourceMappingURL=drawBatch.js.map

package/dist/renderer/drawBatch.js.map

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

package/dist/renderer/effects/EffectTargets.js

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