@zinejs/core 0.3.0 → 0.4.0

package/dist/webglRenderer-Bg6VF4CW.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"webglRenderer-Bg6VF4CW.js","names":["#container","#canvas","#onContextLost","#onContextRestored","#onVisibilityChange","#gl","#buildGlResources","#clearRestoreTimer","#texCache","#blankTex","#quadVao","#curlVao","#flat","#curl","#cacheBytes","#content","#flip","#fatalHandler","#fill","#trackAspect","#render","#pageAspect","#flipT","#curlType","#anchor","#fromShiftUnit","#toShiftUnit","#view","#bookBox","#contentBox","#contextLost","#restoreTimer","#fatal","#fatalFired","#flatU","#curlU","#makeQuadVao","#buildCurlMesh","#makeBlankTexture","#idxCount","#posBuf","#normBuf","#mesh","#resize","#fitBook","#drawFlip","#drawStatic","#bookW","#bookH","#shiftX","#useFlat","#drawQuad","#bindFace","#dpr","#fillFade","#textureFor","#evictTextures"],"sources":["../src/geometry/curls/mesh.ts","../src/geometry/curls/roll.ts","../src/geometry/curls/cone.ts","../src/geometry/curls/leaf.ts","../src/geometry/curls/flick.ts","../src/geometry/curls/simple.ts","../src/geometry/curls/index.ts","../src/renderer/gl/context.ts","../src/renderer/gl/program.ts","../src/renderer/gl/texture.ts","../src/renderer/webglRenderer.ts"],"sourcesContent":["/**\n * Shared grid mesh + normal utilities for the page-curl models.\n *\n * A curl model fills `positions`/`normals` in place each frame; UVs are static grid\n * coordinates (no texture swimming). All models bend the same (cols+1)×(rows+1) grid.\n */\n\nexport interface PageMesh {\n  readonly cols: number;\n  readonly rows: number;\n  /** ((cols+1)*(rows+1))*2 — static grid UVs (u across width, v down height). */\n  readonly uvs: Float32Array;\n  /** *3 — deformed positions, updated by the curl model. */\n  readonly positions: Float32Array;\n  /** *3 — per-vertex normals, updated by the curl model. */\n  readonly normals: Float32Array;\n}\n\n/** Allocate a (cols+1)×(rows+1) grid mesh with static UVs (positions/normals filled by a curl). */\nexport function createPageMesh(cols: number, rows: number): PageMesh {\n  const nx = cols + 1;\n  const ny = rows + 1;\n  const count = nx * ny;\n  const uvs = new Float32Array(count * 2);\n  for (let j = 0; j < ny; j++) {\n    for (let i = 0; i < nx; i++) {\n      const k = j * nx + i;\n      uvs[k * 2] = i / cols;\n      uvs[k * 2 + 1] = j / rows;\n    }\n  }\n  return {\n    cols,\n    rows,\n    uvs,\n    positions: new Float32Array(count * 3),\n    normals: new Float32Array(count * 3),\n  };\n}\n\n/** Per-vertex normals from central differences of the deformed grid (front = +z when flat). */\nexport function computeNormals(mesh: PageMesh): void {\n  const nx = mesh.cols + 1;\n  const ny = mesh.rows + 1;\n  const pos = mesh.positions;\n  const nrm = mesh.normals;\n\n  for (let j = 0; j < ny; j++) {\n    for (let i = 0; i < nx; i++) {\n      const iPrev = i > 0 ? i - 1 : i;\n      const iNext = i < nx - 1 ? i + 1 : i;\n      const jPrev = j > 0 ? j - 1 : j;\n      const jNext = j < ny - 1 ? j + 1 : j;\n\n      const a = (j * nx + iNext) * 3;\n      const b = (j * nx + iPrev) * 3;\n      const c = (jNext * nx + i) * 3;\n      const e = (jPrev * nx + i) * 3;\n\n      const tuX = pos[a]! - pos[b]!;\n      const tuY = pos[a + 1]! - pos[b + 1]!;\n      const tuZ = pos[a + 2]! - pos[b + 2]!;\n      const tvX = pos[c]! - pos[e]!;\n      const tvY = pos[c + 1]! - pos[e + 1]!;\n      const tvZ = pos[c + 2]! - pos[e + 2]!;\n\n      let nx0 = tuY * tvZ - tuZ * tvY;\n      let ny0 = tuZ * tvX - tuX * tvZ;\n      let nz0 = tuX * tvY - tuY * tvX;\n      const l = Math.hypot(nx0, ny0, nz0) || 1;\n      nx0 /= l;\n      ny0 /= l;\n      nz0 /= l;\n\n      const k = (j * nx + i) * 3;\n      nrm[k] = nx0;\n      nrm[k + 1] = ny0;\n      nrm[k + 2] = nz0;\n    }\n  }\n}\n","import { computeNormals, type PageMesh } from './mesh';\n\n/**\n * Roll-and-flop. The leaf wraps a cylinder whose wrap angle grows 0→π over the first\n * half while its radius (= W/theta) shrinks, so the sheet rolls up off the surface in\n * place; over the second half it unwraps π→0 while rigidly rotating around the spine\n * 0→-π down onto the far side. Arc length across the width is exactly preserved.\n */\nexport function deformRoll(mesh: PageMesh, W: number, H: number, t: number): void {\n  const nx = mesh.cols + 1;\n  const ny = mesh.rows + 1;\n  const pos = mesh.positions;\n\n  const theta = Math.max(1e-6, t < 0.5 ? t * 2 * Math.PI : (1 - (t - 0.5) * 2) * Math.PI);\n  const radius = W / theta;\n  const rot = t < 0.5 ? 0 : -(t - 0.5) * 2 * Math.PI;\n  const cosR = Math.cos(rot);\n  const sinR = Math.sin(rot);\n\n  for (let i = 0; i < nx; i++) {\n    const rad = (i / mesh.cols) * theta;\n    const cx = Math.sin(rad) * radius;\n    const cz = (1 - Math.cos(rad)) * radius;\n    const X = cx * cosR + cz * sinR;\n    const Z = -cx * sinR + cz * cosR;\n    for (let j = 0; j < ny; j++) {\n      const k = (j * nx + i) * 3;\n      pos[k] = X;\n      pos[k + 1] = (j / mesh.rows) * H;\n      pos[k + 2] = Z;\n    }\n  }\n\n  computeNormals(mesh);\n}\n","import { computeNormals, type PageMesh } from './mesh';\nimport type { CurlAnchor } from './types';\n\n/**\n * Cone angle at peak curl. π/2 is flat; smaller values wind the sheet tighter.\n * ~30° gives a soft, paper-like ridge without self-intersection on typical page\n * aspect ratios (Hong / Nuon / Project Austin all land in the 18–35° band).\n */\nconst THETA_MIN = (30 * Math.PI) / 180;\n/** Gentler opening for full-width lone pages — a tight cone reads as a funnel when\n *  the leaf owns the whole viewport and hinges at the edge. */\nconst THETA_MIN_FILL = (44 * Math.PI) / 180;\n\n/**\n * How far past the page the cone apex sits, as a fraction of height, at rest.\n * Closer mid-turn sharpens the diagonal; farther reads more cylindrical.\n * Kept moderately distant so the sheet stays page-like without cloth-y sliding.\n */\nconst APEX_REST = 1.35;\nconst APEX_PEAK = 0.7;\n/** Farther apex on fill: softer diagonal, less cloth-y twist across the full leaf. */\nconst APEX_REST_FILL = 1.85;\nconst APEX_PEAK_FILL = 1.15;\n\n/**\n * Above this |anchor.y − 0.5| the deform is a pure cone; at the mid-edge it\n * blends fully to a cylinder (Project Austin’s conicContribution).\n */\nconst CORNER_PURE = 0.42;\n\n/**\n * Power on fill flop progress. Slightly >1 delays spine rotation so the cone develops\n * over the page before the leaf swings past the edge hinge — kept close to 1 so the\n * flop isn't packed into a late whip (lone pages dissolve rather than land).\n */\nconst FILL_RHO_POWER = 1.08;\n\n/**\n * Natural conical page curl — the Xerox PARC / iBooks model.\n *\n * The leaf wraps an imaginary right circular cone whose apex rides the spine and\n * whose opening angle θ breathes over the turn (Hong, Card & Chen, 2004). A corner\n * grab yields a diagonal cone; a mid-edge grab blends toward a cylinder so the\n * free edge lifts as one. The curled sheet then rotates about the spine and settles\n * flat on the far side. Arc length from the apex is preserved, so the paper never\n * stretches — the motion reads as stiff, premium stock rather than cloth.\n *\n * On a full-width lone page (`anchor.fill`) the hinge is the container edge with no\n * facing half to land on: the cone softens, the flop is delayed so the peel stays\n * over the page longer, and the renderer dissolves the sheet as it finishes.\n */\nexport function deformCone(mesh: PageMesh, W: number, H: number, t: number, anchor: CurlAnchor): void {\n  const nx = mesh.cols + 1;\n  const ny = mesh.rows + 1;\n  const pos = mesh.positions;\n  const fill = !!anchor.fill;\n\n  // Curl envelope: 0 at the ends (flat), 1 at mid-turn. Soft power keeps the\n  // ridge full through the middle third — paper holds its bend rather than\n  // peaking and collapsing.\n  const curl = Math.pow(Math.sin(Math.PI * t), 0.85);\n\n  // θ: π/2 (identity) → THETA_MIN (pronounced curl) → π/2.\n  const thetaMin = fill ? THETA_MIN_FILL : THETA_MIN;\n  const theta = Math.PI / 2 - curl * (Math.PI / 2 - thetaMin);\n  const sinTheta = Math.sin(theta);\n  const cosTheta = Math.cos(theta);\n  const invSinTheta = 1 / Math.max(sinTheta, 1e-6);\n\n  // Apex distance: pulled in as the curl develops for a tighter diagonal.\n  const apexRest = fill ? APEX_REST_FILL : APEX_REST;\n  const apexPeak = fill ? APEX_PEAK_FILL : APEX_PEAK;\n  const apexDist = H * (apexRest + (apexPeak - apexRest) * curl);\n\n  // Corner bias: −1 = top edge, +1 = bottom. Near 0 → cylinder blend.\n  const bias = (anchor.y - 0.5) * 2;\n  const fromBottom = bias >= 0;\n  const absBias = Math.abs(bias);\n  let conic = Math.min(1, absBias / CORNER_PURE);\n  const cylWeight = 1 - conic;\n\n  // Cylinder radius matched to the cone’s free-edge cross-section (Austin), so\n  // the blend is continuous as the grab slides from corner to mid-edge.\n  // Apex sits past the *leading* edge (below for a bottom grab, above for top).\n  const AyRef = fromBottom ? H + apexDist : -apexDist;\n  const cylR = Math.hypot(W, 0.5 * H - AyRef);\n  const cylRadius = Math.max(cylR * sinTheta, W / Math.PI);\n\n  // Spine rotation: concurrent with the cone so the page flops while it curls.\n  // Same x–z convention as `roll` (ρ: 0 → −π). On fill, delay the flop so the\n  // peel develops over the page before the leaf swings past the edge hinge.\n  const rhoT = fill ? Math.pow(t, FILL_RHO_POWER) : t;\n  const rho = -Math.PI * rhoT;\n  const cosR = Math.cos(rho);\n  const sinR = Math.sin(rho);\n\n  // Near the rests the cone is the identity plane. A finite-radius cylinder blend\n  // still carries a tiny residual arc — skip it and rotate the flat sheet.\n  if (curl < 1e-4) {\n    for (let j = 0; j < ny; j++) {\n      const y = (j / mesh.rows) * H;\n      for (let i = 0; i < nx; i++) {\n        const x0 = (i / mesh.cols) * W;\n        const k = (j * nx + i) * 3;\n        pos[k] = x0 * cosR;\n        pos[k + 1] = y;\n        pos[k + 2] = -x0 * sinR;\n      }\n    }\n    computeNormals(mesh);\n    return;\n  }\n\n  for (let j = 0; j < ny; j++) {\n    const y0 = (j / mesh.rows) * H;\n    for (let i = 0; i < nx; i++) {\n      const x0 = (i / mesh.cols) * W;\n\n      let cx = x0;\n      let cy = y0;\n      let cz = 0;\n\n      if (conic > 1e-5) {\n        // Canonical cone: apex above the page (A < 0) makes the *near* edge lead.\n        // In our y-down leaf, that means the top. For a bottom grab we flip into\n        // that space, deform, then flip back — one code path for both corners.\n        const yIn = fromBottom ? H - y0 : y0;\n        const A = -apexDist;\n        const R = Math.hypot(x0, yIn - A);\n        if (R > 1e-8) {\n          const r = R * sinTheta;\n          const beta = Math.asin(Math.min(1, Math.max(0, x0 / R))) * invSinTheta;\n          const oneCos = 1 - Math.cos(beta);\n          const yCone = R + A - r * oneCos * sinTheta;\n          cx = r * Math.sin(beta);\n          cy = fromBottom ? H - yCone : yCone;\n          cz = r * oneCos * cosTheta;\n        }\n      }\n\n      let bx = cx;\n      let by = cy;\n      let bz = cz;\n\n      if (cylWeight > 1e-5) {\n        const beta = x0 / cylRadius;\n        const sx = cylRadius * Math.sin(beta);\n        const sz = cylRadius * (1 - Math.cos(beta));\n        bx = conic * cx + cylWeight * sx;\n        by = conic * cy + cylWeight * y0;\n        bz = conic * cz + cylWeight * sz;\n      }\n\n      const k = (j * nx + i) * 3;\n      pos[k] = bx * cosR + bz * sinR;\n      pos[k + 1] = by;\n      pos[k + 2] = -bx * sinR + bz * cosR;\n    }\n  }\n\n  computeNormals(mesh);\n}\n","import { computeNormals, type PageMesh } from './mesh';\nimport type { CurlAnchor } from './types';\n\n/** Peak material width occupied by the bending wave. */\nconst MAX_BEND_LENGTH = 0.34;\n\n/** Maximum tilt of the rolling axis for a corner-led turn. */\nconst MAX_TILT = (11 * Math.PI) / 180;\n\nconst PROFILE_STEPS = 128;\n\n/**\n * Unit-length raised-cosine curvature profile.\n *\n * κ(s) = π(1 - cos(2πs)), so its integrated tangent angle is\n * θ(s) = πs - ½sin(2πs). Curvature is exactly zero at both ends and integrates\n * to π: the incoming and outgoing planes are flat, opposite-facing, and meet\n * the bend without a crease. X/Z are arc-length integrals of cos(θ)/sin(θ).\n */\nfunction makeProfile(): { x: Float64Array; z: Float64Array } {\n  const x = new Float64Array(PROFILE_STEPS + 1);\n  const z = new Float64Array(PROFILE_STEPS + 1);\n  const ds = 1 / PROFILE_STEPS;\n  const theta = (s: number): number => Math.PI * s - 0.5 * Math.sin(2 * Math.PI * s);\n  for (let i = 1; i <= PROFILE_STEPS; i++) {\n    const a = theta((i - 1) * ds);\n    const b = theta(i * ds);\n    x[i] = x[i - 1]! + 0.5 * (Math.cos(a) + Math.cos(b)) * ds;\n    z[i] = z[i - 1]! + 0.5 * (Math.sin(a) + Math.sin(b)) * ds;\n  }\n  // Symmetry makes this analytically zero; remove accumulated floating-point drift.\n  x[PROFILE_STEPS] = 0;\n  return { x, z };\n}\n\nconst PROFILE = makeProfile();\nconst PROFILE_HEIGHT = PROFILE.z[PROFILE_STEPS]!;\n\nfunction sampleProfile(s: number): [x: number, z: number] {\n  const p = Math.max(0, Math.min(1, s)) * PROFILE_STEPS;\n  const i = Math.min(PROFILE_STEPS - 1, Math.floor(p));\n  const f = p - i;\n  return [\n    PROFILE.x[i]! + (PROFILE.x[i + 1]! - PROFILE.x[i]!) * f,\n    PROFILE.z[i]! + (PROFILE.z[i + 1]! - PROFILE.z[i]!) * f,\n  ];\n}\n\n/**\n * Traveling smooth-curvature leaf curl.\n *\n * Inspired by rolling-cylinder page curls and modern developable-surface book\n * simulations, but with a compact raised-cosine curvature wave instead of a\n * constant-radius cylinder. The sheet has three regions:\n *\n *  1. untouched paper before the wave,\n *  2. an isometric bend whose curvature smoothly rises and falls,\n *  3. a flat, reflected flap after the wave.\n *\n * The wave travels from the free edge to just beyond the spine while its width grows\n * and collapses. Integrating a unit tangent preserves material length exactly; straight\n * ruling lines preserve distance along the curl axis. Curvature reaches zero at both\n * seams, eliminating the hard crease shared by circular/fold models.\n */\nexport function deformLeaf(mesh: PageMesh, W: number, H: number, t: number, anchor: CurlAnchor): void {\n  const nx = mesh.cols + 1;\n  const ny = mesh.rows + 1;\n  const pos = mesh.positions;\n\n  // Exact rest poses avoid the tiny numerical ridge left by a vanishing wave.\n  if (t <= 1e-7 || t >= 1 - 1e-7) {\n    const side = t < 0.5 ? 1 : -1;\n    for (let j = 0; j < ny; j++) {\n      const y = (j / mesh.rows) * H;\n      for (let i = 0; i < nx; i++) {\n        const k = (j * nx + i) * 3;\n        pos[k] = side * (i / mesh.cols) * W;\n        pos[k + 1] = y;\n        pos[k + 2] = 0;\n      }\n    }\n    computeNormals(mesh);\n    return;\n  }\n\n  // The wave broadens through the middle, then tightens as the leaf settles.\n  const envelope = Math.pow(Math.sin(Math.PI * t), 0.72);\n  const bendLength = Math.max(1e-6, W * MAX_BEND_LENGTH * envelope);\n\n  // Bottom grabs tilt the ruling clockwise in page coordinates; top grabs mirror it.\n  // The tilt fades at both rest states so the page lands exactly square.\n  const anchorBias = Math.max(-1, Math.min(1, (anchor.y - 0.5) * 2));\n  const tilt = anchorBias * MAX_TILT * Math.pow(Math.sin(Math.PI * t), 1.15);\n  const nX = Math.cos(tilt);\n  const nY = Math.sin(tilt);\n  const fX = -nY;\n  const fY = nX;\n\n  // Place the axis outside the whole rectangle at t=0 and beyond the spine at t=1.\n  // Accounting for tilt keeps every row in the correct physical region at the ends.\n  const diagonalReach = Math.abs(nY) * H * 0.5;\n  const startX = W + diagonalReach / nX;\n  const endX = -(bendLength + diagonalReach) / nX;\n  const axisX = startX + (endX - startX) * t;\n  const axisY = H * 0.5;\n\n  for (let j = 0; j < ny; j++) {\n    const y0 = (j / mesh.rows) * H;\n    for (let i = 0; i < nx; i++) {\n      const x0 = (i / mesh.cols) * W;\n      const relX = x0 - axisX;\n      const relY = y0 - axisY;\n      const d = relX * nX + relY * nY;\n      const e = relX * fX + relY * fY;\n      const k = (j * nx + i) * 3;\n\n      if (d <= 0) {\n        // The wave has not reached this point: untouched front-facing paper.\n        pos[k] = x0;\n        pos[k + 1] = y0;\n        pos[k + 2] = 0;\n        continue;\n      }\n\n      let normalDistance: number;\n      let z: number;\n      if (d < bendLength) {\n        // Scale the unit arc-length profile by the material width of this wave.\n        const [profileX, profileZ] = sampleProfile(d / bendLength);\n        normalDistance = bendLength * profileX;\n        z = bendLength * profileZ;\n      } else {\n        // The tangent has rotated by π; paper leaves the wave flat and reversed.\n        normalDistance = -(d - bendLength);\n        z = bendLength * PROFILE_HEIGHT;\n      }\n\n      pos[k] = axisX + fX * e + nX * normalDistance;\n      pos[k + 1] = axisY + fY * e + nY * normalDistance;\n      pos[k + 2] = z;\n    }\n  }\n\n  computeNormals(mesh);\n}\n","import { computeNormals, type PageMesh } from './mesh';\nimport type { CurlAnchor } from './types';\n\n/**\n * Peak inertial tip lag in radians (~30°). How far the free edge trails the\n * spine rotation at the height of the acceleration phase, and symmetrically how\n * far it follows through while the turn decelerates.\n */\nconst SWAY = 0.52;\n\n/**\n * Extra lag for rows far from the grabbed corner (0 = whole edge moves as one).\n * The driven corner is held; the diagonal remainder of the sheet trails it.\n */\nconst LAG = 0.45;\n\n/**\n * Inertial follow-through page flick.\n *\n * The leaf is a cantilever clamped at the spine and driven through a rotation\n * ρ(t) = πt. Paper inertia (the Euler force, ∝ −ρ̈) bends the sheet opposite the\n * angular acceleration with a first-mode-like profile — zero curvature at the\n * clamped spine, maximal at the free edge. Under an eased turn the acceleration\n * changes sign at mid-flight, so the free edge trails while the turn winds up,\n * swings through vertical, then overtakes and settles as the turn slows: the\n * follow-through/overlapping-action principle, grounded in base-rotated\n * cantilever dynamics. Tangent angles are integrated along the width, so the\n * sheet never stretches, and the curvature direction reversing over the turn is\n * what none of the wrap-style curls do.\n *\n * Rows far from the grabbed corner lag slightly more than the driven row, so a\n * corner grab pulls a soft living diagonal across the sheet.\n */\nexport function deformFlick(mesh: PageMesh, W: number, H: number, t: number, anchor: CurlAnchor): void {\n  const nx = mesh.cols + 1;\n  const ny = mesh.rows + 1;\n  const cols = mesh.cols;\n  const pos = mesh.positions;\n  const ds = W / cols;\n\n  // Base rotation about the spine, 0 → π (same landing convention as `simple`).\n  const rho = Math.PI * t;\n\n  // Inertial amplitude ∝ −ρ̈ of an eased unit turn: the tip trails (negative)\n  // while accelerating, leads (positive) while braking, and is zero at both\n  // rests and at peak speed mid-turn.\n  const amplitude = -SWAY * Math.sin(2 * Math.PI * t);\n\n  for (let j = 0; j < ny; j++) {\n    const v = j / mesh.rows;\n    // The grabbed row is driven directly; distance from it adds trailing inertia.\n    const rowAmplitude = amplitude * (1 + LAG * Math.abs(v - anchor.y));\n    const y = v * H;\n\n    // Integrate the unit tangent of θ(u) = ρ + A·u² across the width (trapezoid\n    // per grid cell). u² is the first-mode tangent shape: clamped flat at the\n    // spine, curving ever more freely toward the edge. Exact arc length.\n    let x = 0;\n    let z = 0;\n    let cosPrev = Math.cos(rho);\n    let sinPrev = Math.sin(rho);\n    pos[(j * nx) * 3] = 0;\n    pos[(j * nx) * 3 + 1] = y;\n    pos[(j * nx) * 3 + 2] = 0;\n    for (let i = 1; i < nx; i++) {\n      const u = i / cols;\n      const theta = rho + rowAmplitude * u * u;\n      const cosCur = Math.cos(theta);\n      const sinCur = Math.sin(theta);\n      x += 0.5 * (cosPrev + cosCur) * ds;\n      z += 0.5 * (sinPrev + sinCur) * ds;\n      cosPrev = cosCur;\n      sinPrev = sinCur;\n\n      const k = (j * nx + i) * 3;\n      pos[k] = x;\n      pos[k + 1] = y;\n      pos[k + 2] = z;\n    }\n  }\n\n  computeNormals(mesh);\n}\n","import { computeNormals, type PageMesh } from './mesh';\n\n/**\n * Flat page turn — the plainest flip, matching the CSS renderer. The leaf stays a rigid\n * flat sheet and rotates around the spine (angle 0→π), going edge-on at the midpoint. No\n * cylinder bend; GPU-rendered here with the shared perspective so it reads like the CSS fold.\n */\nexport function deformSimple(mesh: PageMesh, W: number, H: number, t: number): void {\n  const nx = mesh.cols + 1;\n  const ny = mesh.rows + 1;\n  const pos = mesh.positions;\n\n  const angle = t * Math.PI;\n  const cosA = Math.cos(angle);\n  const sinA = Math.sin(angle);\n\n  for (let i = 0; i < nx; i++) {\n    const x0 = (i / mesh.cols) * W; // distance from the spine\n    const X = x0 * cosA;\n    const Z = x0 * sinA;\n    for (let j = 0; j < ny; j++) {\n      const k = (j * nx + i) * 3;\n      pos[k] = X;\n      pos[k + 1] = (j / mesh.rows) * H;\n      pos[k + 2] = Z;\n    }\n  }\n\n  computeNormals(mesh);\n}\n","/**\n * Page-curl registry. Each model turns a 0→1 flip progress into a bent page mesh; the\n * WebGL2 renderer picks one by the `curl` option. `anchored` models fold from a corner\n * given by `anchor.y` (0 = top, 1 = bottom — where the reader tapped); the others roll\n * the whole free edge and ignore it.\n *\n * Importing this module pulls in the deform math, so only the WebGL2 renderer does.\n * The engine references the lightweight `./types` (union + validation list) instead.\n */\nimport { deformRoll } from './roll';\nimport { deformCone } from './cone';\nimport { deformLeaf } from './leaf';\nimport { deformFlick } from './flick';\nimport { deformSimple } from './simple';\nimport type { CurlModel, CurlType } from './types';\n\nexport { createPageMesh, computeNormals, type PageMesh } from './mesh';\nexport { CURL_TYPES, DEFAULT_CURL } from './types';\nexport type { CurlAnchor, CurlDeform, CurlModel, CurlType } from './types';\n\nexport const CURLS: Record<CurlType, CurlModel> = {\n  roll: { deform: deformRoll, anchored: false },\n  cone: { deform: deformCone, anchored: true },\n  leaf: { deform: deformLeaf, anchored: true },\n  flick: { deform: deformFlick, anchored: true },\n  simple: { deform: deformSimple, anchored: false },\n};\n","/** Create a WebGL2 context, or throw so the caller can fall back to CSS (§8.4). */\nexport function createGlContext(canvas: HTMLCanvasElement): WebGL2RenderingContext {\n  const gl = canvas.getContext('webgl2', {\n    alpha: true,\n    premultipliedAlpha: true,\n    antialias: true,\n    depth: false,\n    stencil: false,\n    // We render on demand (not every frame), so the buffer must persist between\n    // composites — otherwise the settled page flickers once the flip animation\n    // stops and nothing is redrawing each frame.\n    preserveDrawingBuffer: true,\n  });\n  if (gl === null) {\n    throw new Error('WebglRenderer: could not create a WebGL2 context.');\n  }\n  return gl;\n}\n","/** Compile + link a shader program; throws with the driver log on failure. */\nexport function createProgram(\n  gl: WebGL2RenderingContext,\n  vertexSrc: string,\n  fragmentSrc: string,\n): WebGLProgram {\n  const program = gl.createProgram();\n  if (program === null) throw new Error('WebglRenderer: could not create a program.');\n\n  const vs = compileShader(gl, gl.VERTEX_SHADER, vertexSrc);\n  const fs = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSrc);\n  gl.attachShader(program, vs);\n  gl.attachShader(program, fs);\n  gl.linkProgram(program);\n\n  // Shaders can be detached/deleted once linked.\n  gl.deleteShader(vs);\n  gl.deleteShader(fs);\n\n  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {\n    const log = gl.getProgramInfoLog(program);\n    gl.deleteProgram(program);\n    throw new Error(`WebglRenderer: program link failed: ${log ?? 'unknown error'}`);\n  }\n  return program;\n}\n\nfunction compileShader(gl: WebGL2RenderingContext, type: number, src: string): WebGLShader {\n  const shader = gl.createShader(type);\n  if (shader === null) throw new Error('WebglRenderer: could not create a shader.');\n  gl.shaderSource(shader, src);\n  gl.compileShader(shader);\n  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {\n    const log = gl.getShaderInfoLog(shader);\n    gl.deleteShader(shader);\n    throw new Error(`WebglRenderer: shader compile failed: ${log ?? 'unknown error'}`);\n  }\n  return shader;\n}\n","/** Create a page texture with clamp + linear filtering (no mipmaps — §8.3). */\nexport function createTexture(gl: WebGL2RenderingContext): WebGLTexture {\n  const tex = gl.createTexture();\n  if (tex === null) throw new Error('WebglRenderer: could not create a texture.');\n  gl.bindTexture(gl.TEXTURE_2D, tex);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n  return tex;\n}\n\n/** Upload a decoded page raster (ImageBitmap or canvas) into `tex`. */\nexport function uploadTexture(\n  gl: WebGL2RenderingContext,\n  tex: WebGLTexture,\n  source: TexImageSource,\n): void {\n  gl.bindTexture(gl.TEXTURE_2D, tex);\n  // No Y flip: the vertex shader maps aUnit.y=0 to the page top and samples the\n  // source's top row there. UNPACK_FLIP_Y is honored for <canvas> sources but\n  // IGNORED for ImageBitmap, so flipping would invert PDF (canvas) pages while\n  // leaving image (ImageBitmap) pages upright. Off keeps both consistent.\n  gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);\n  gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);\n  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);\n}\n","import {\n  CURLS,\n  createPageMesh,\n  DEFAULT_CURL,\n  type CurlAnchor,\n  type CurlType,\n  type PageMesh,\n} from '../geometry/curls';\nimport type { Spread } from '../engine/spread';\nimport type {\n  FlipDirection,\n  LayoutMetrics,\n  Renderer,\n  RenderOptions,\n  SpreadContent,\n} from './types';\nimport { createGlContext } from './gl/context';\nimport { createProgram } from './gl/program';\nimport { createTexture, uploadTexture } from './gl/texture';\n\n// Flat program: a page rect (device px, top-left origin) with zoom/pan and a soft\n// permanent gutter shadow toward the spine so the turning leaf's shadow lands into it.\nconst FLAT_VERT = `#version 300 es\nin vec2 aUnit;\nuniform vec2 uViewport;\nuniform vec4 uRect;\nuniform vec3 uView;\nout vec2 vUv;\nvoid main() {\n  vec2 px = uRect.xy + aUnit * uRect.zw;\n  px = px * uView.x + uView.yz;\n  vec2 clip = px / uViewport * 2.0 - 1.0;\n  gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n  vUv = aUnit;\n}`;\n\nconst FLAT_FRAG = `#version 300 es\nprecision mediump float;\nin vec2 vUv;\nuniform sampler2D uTex;\nuniform float uGutterSide; // +1 = spine at right edge, -1 = at left edge, 0 = none\nout vec4 outColor;\nvoid main() {\n  vec4 c = texture(uTex, vUv);\n  if (uGutterSide != 0.0) {\n    float d = uGutterSide > 0.0 ? (1.0 - vUv.x) : vUv.x;\n    c.rgb *= mix(0.72, 1.0, smoothstep(0.0, 0.10, d));\n  }\n  outColor = c;\n}`;\n\n// Curl program: a thin pass-through for the CPU-deformed page mesh (positions and\n// normals come from the selected curl model). It places the leaf, applies a top-safe depth\n// perspective, and lights from the true surface normal.\nconst CURL_VERT = `#version 300 es\nin vec3 aPos;    // leaf-local device px: x = bent offset from spine, y 0..H, z depth\nin vec3 aNormal;\nin vec2 aUv;\nuniform vec2 uViewport;\nuniform vec3 uView;   // scale, tx, ty\nuniform float uOriginX; // spine x in device px\nuniform float uDir;     // +1 leaf to the right of spine, -1 to the left\nuniform float uLeafW;   // leaf width in device px (perspective scale)\nout vec2 vUv;\nout float vFacing;\nout float vU;\nvoid main() {\n  float bookX = uOriginX + uDir * aPos.x;\n  float bookY = aPos.y;\n  float Z = aPos.z;\n  // Eye distance, in leaf widths. Keeps the perspective resolution-independent. 5.3 puts the\n  // roll's deepest point ~14% larger than flat; stronger than that (a nearer eye) balloons the\n  // turning sheet and reads more like a fisheye than a page lifting.\n  float D = uLeafW * 5.3;\n  float persp = D / max(D - Z, 1.0);\n  float cx = uViewport.x * 0.5;\n  float cy = uViewport.y * 0.5;\n  float px = cx + (bookX - cx) * persp;\n  float py = cy + (bookY - cy) * min(persp, 1.0); // Y only shrinks (top-safe)\n  vec2 p = vec2(px, py) * uView.x + uView.yz;\n  vec2 clip = p / uViewport * 2.0 - 1.0;\n  gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n  vUv = aUv;\n  vFacing = aNormal.z;\n  vU = aUv.x;\n}`;\n\nconst CURL_FRAG = `#version 300 es\nprecision mediump float;\nin vec2 vUv;\nin float vFacing;\nin float vU;\nuniform sampler2D uFront;\nuniform sampler2D uBack;\nuniform highp float uDir;\nuniform float uGloss; // 0 disables the specular highlight (e.g. the flat 'simple' curl)\nuniform float uAlpha; // leaf opacity; a lone page dissolves into the page landing beneath it\nout vec4 outColor;\nvoid main() {\n  // The turn mesh carries its own facing in the normal; the front points at the viewer\n  // (normal.z > 0) until the leaf passes vertical, for both flip directions. u->x still\n  // flips with uDir so a left-hand leaf reads spine-inward.\n  bool showFront = vFacing > 0.0;\n  float fx = uDir > 0.0 ? vUv.x : 1.0 - vUv.x;\n  vec4 c = showFront ? texture(uFront, vec2(fx, vUv.y)) : texture(uBack, vec2(1.0 - fx, vUv.y));\n\n  // Fold shading: the sheet darkens sharply where it curves away from the viewer, so the\n  // rolled edge reads as a deep crease with a soft highlight riding the ridge.\n  float diff = clamp(abs(vFacing), 0.0, 1.0);\n  float lit = mix(0.42, 1.0, diff);\n  lit *= mix(0.7, 1.0, smoothstep(0.0, 0.12, vU)); // spine crease matches the gutter shadow\n\n  // Glossy specular: brightest where the surface tilts ~30 deg from facing the viewer,\n  // so a thin glossy highlight rides across the sheet as it rolls.\n  float spec = pow(max(cos(acos(diff) - 0.52), 0.0), 220.0) * 0.22 * uGloss;\n\n  c.rgb = clamp(c.rgb * lit + spec, 0.0, 1.0);\n  // Premultiplied alpha (blendFunc ONE, ONE_MINUS_SRC_ALPHA): scale colour as well as alpha,\n  // or fading would brighten the sheet additively instead of dissolving it.\n  outColor = vec4(c.rgb * uAlpha, c.a * uAlpha);\n}`;\n\nconst GRID_COLS = 28;\nconst GRID_ROWS = 36;\n/** Progress at which a lone page starts dissolving. A full-width leaf has no facing half to\n *  flop onto, so instead of landing on empty space it fades into the page arriving beneath it\n *  over the rest of the turn. Roll is already flat by mid-turn; curling models stay bent\n *  longer, so they dissolve later. The fade itself eases so the leaf settles rather than\n *  vanishing while still swinging. */\nconst FILL_FADE_START_ROLL = 0.7;\nconst FILL_FADE_START_CURL = 0.8;\nconst RESTORE_TIMEOUT_MS = 4000;\nconst MAX_TEXTURE_CACHE_BYTES = 256 * 1024 * 1024;\n\ninterface Rect {\n  x: number;\n  y: number;\n  w: number;\n  h: number;\n}\n\ninterface FlipState {\n  underLeft: TexImageSource | null;\n  underRight: TexImageSource | null;\n  underFull: TexImageSource | null; // fill mode\n  front: TexImageSource | null;\n  back: TexImageSource | null;\n  dir: number; // +1 forward (leaf right of spine), -1 backward (left)\n  fill: boolean;\n}\n\n/** How far to shift a spread to centre a lone page, in units of a quarter container width:\n *  -1 = only a right page (cover), +1 = only a left page (back), 0 = a full spread. */\nfunction shiftUnit(content: SpreadContent): number {\n  const lone = (content.left === null) !== (content.right === null);\n  return lone ? (content.right !== null ? -1 : 1) : 0;\n}\n\n/**\n * GPU renderer (WebGL2, hand-written). The turning leaf is a dense grid deformed on\n * the CPU by the selected curl model (see geometry/curls) and\n * uploaded each frame, lit from real normals; the static pages are flat quads with a\n * gutter shadow. Restores\n * GL state on context loss; signals onFatal (→ CSS fallback) when unrecoverable.\n */\nexport class WebglRenderer implements Renderer {\n  #container: HTMLElement | null = null;\n  #canvas: HTMLCanvasElement | null = null;\n  #gl: WebGL2RenderingContext | null = null;\n\n  #flat: WebGLProgram | null = null;\n  #curl: WebGLProgram | null = null;\n  #quadVao: WebGLVertexArrayObject | null = null;\n  #curlVao: WebGLVertexArrayObject | null = null;\n  #posBuf: WebGLBuffer | null = null;\n  #normBuf: WebGLBuffer | null = null;\n  #idxCount = 0;\n  #mesh: PageMesh = createPageMesh(GRID_COLS, GRID_ROWS);\n\n  #texCache = new Map<TexImageSource, { tex: WebGLTexture; bytes: number }>();\n  #cacheBytes = 0;\n  #blankTex: WebGLTexture | null = null;\n\n  #flatU: Record<string, WebGLUniformLocation | null> = {};\n  #curlU: Record<string, WebGLUniformLocation | null> = {};\n\n  #view = { scale: 1, tx: 0, ty: 0 };\n  #dpr = 1;\n  #content: SpreadContent | null = null;\n  #fill = false;\n  #flip: FlipState | null = null;\n  #flipT = 0;\n  #curlType: CurlType = DEFAULT_CURL;\n  #anchor: CurlAnchor = { y: 0.5 };\n  // A lone page (cover / book front-back) sits on one half; these center it by shifting\n  // the view a quarter-width, interpolated across a flip so the open/close doesn't jump.\n  #shiftX = 0;\n  #fromShiftUnit = 0;\n  #toShiftUnit = 0;\n  // Book aspect fit: the 2-page spread is letterboxed to the pages' aspect, centered\n  // in the container, so pages fill their halves without stretching. 0 = aspect unknown.\n  #pageAspect = 0;\n  #bookW = 0;\n  #bookH = 0;\n\n  #contextLost = false;\n  #fatalFired = false;\n  #restoreTimer: ReturnType<typeof setTimeout> | null = null;\n  #fatalHandler: (() => void) | null = null;\n\n  mount(container: HTMLElement): Promise<void> {\n    this.#container = container;\n    const doc = container.ownerDocument;\n    const canvas = doc.createElement('canvas');\n    canvas.style.cssText = 'display:block;width:100%;height:100%;';\n    container.append(canvas);\n    this.#canvas = canvas;\n\n    canvas.addEventListener('webglcontextlost', this.#onContextLost as EventListener);\n    canvas.addEventListener('webglcontextrestored', this.#onContextRestored as EventListener);\n    doc.addEventListener('visibilitychange', this.#onVisibilityChange);\n\n    this.#gl = createGlContext(canvas); // throws if unavailable -> engine falls back (§8.4)\n    this.#buildGlResources();\n    return Promise.resolve();\n  }\n\n  destroy(): void {\n    this.#clearRestoreTimer();\n    const canvas = this.#canvas;\n    if (canvas !== null) {\n      canvas.removeEventListener('webglcontextlost', this.#onContextLost as EventListener);\n      canvas.removeEventListener('webglcontextrestored', this.#onContextRestored as EventListener);\n      canvas.ownerDocument.removeEventListener('visibilitychange', this.#onVisibilityChange);\n    }\n    const gl = this.#gl;\n    if (gl !== null) {\n      for (const cached of this.#texCache.values()) gl.deleteTexture(cached.tex);\n      if (this.#blankTex !== null) gl.deleteTexture(this.#blankTex);\n      if (this.#quadVao !== null) gl.deleteVertexArray(this.#quadVao);\n      if (this.#curlVao !== null) gl.deleteVertexArray(this.#curlVao);\n      if (this.#flat !== null) gl.deleteProgram(this.#flat);\n      if (this.#curl !== null) gl.deleteProgram(this.#curl);\n      gl.getExtension('WEBGL_lose_context')?.loseContext();\n    }\n    canvas?.remove();\n    this.#texCache.clear();\n    this.#cacheBytes = 0;\n    this.#blankTex = null;\n    this.#container = null;\n    this.#canvas = null;\n    this.#gl = null;\n    this.#content = null;\n    this.#flip = null;\n  }\n\n  onFatal(handler: () => void): void {\n    this.#fatalHandler = handler;\n  }\n\n  renderSpread(_spread: Spread, content: SpreadContent, options?: RenderOptions): void {\n    this.#content = content;\n    this.#fill = options?.fill ?? false;\n    this.#flip = null;\n    this.#trackAspect(content);\n    this.#render();\n  }\n\n  /** Remember the page aspect (width/height) so the book can be letterboxed to it. */\n  #trackAspect(content: SpreadContent): void {\n    const p = content.left ?? content.right;\n    if (p && p.height) this.#pageAspect = p.width / p.height;\n  }\n\n  beginFlip(\n    from: SpreadContent,\n    to: SpreadContent,\n    direction: FlipDirection,\n    options?: RenderOptions,\n  ): void {\n    const fill = options?.fill ?? false;\n    this.#flipT = 0;\n    if (options?.curl) this.#curlType = options.curl;\n    if (options?.anchor) this.#anchor = options.anchor;\n    this.#fromShiftUnit = fill ? 0 : shiftUnit(from);\n    this.#toShiftUnit = fill ? 0 : shiftUnit(to);\n    this.#trackAspect(to);\n    if (fill) {\n      this.#flip = {\n        underLeft: null,\n        underRight: null,\n        underFull: to.right ?? to.left,\n        front: from.right ?? from.left,\n        // A lone page has no facing \"next\" leaf on its back; show the same page mirrored\n        // (the shader flips the back UV) so it reads as the sheet's own reverse side.\n        back: from.right ?? from.left,\n        dir: direction === 'forward' ? 1 : -1,\n        fill: true,\n      };\n    } else if (direction === 'forward') {\n      this.#flip = {\n        underLeft: from.left,\n        underRight: to.right,\n        underFull: null,\n        front: from.right,\n        back: to.left,\n        dir: 1,\n        fill: false,\n      };\n    } else {\n      this.#flip = {\n        underLeft: to.left,\n        underRight: from.right,\n        underFull: null,\n        front: from.left,\n        back: to.right,\n        dir: -1,\n        fill: false,\n      };\n    }\n    this.#render();\n  }\n\n  setFlipProgress(t: number, _direction: FlipDirection): void {\n    this.#flipT = t;\n    this.#render();\n  }\n\n  setViewTransform(scale: number, x: number, y: number): void {\n    this.#view = { scale, tx: x, ty: y };\n    this.#render();\n  }\n\n  measure(): LayoutMetrics {\n    const el = this.#container;\n    const w = el?.clientWidth ?? 0;\n    const h = el?.clientHeight ?? 0;\n    const known = this.#pageAspect > 0;\n    const book = known ? this.#bookBox() : undefined;\n    const content = known ? this.#contentBox() : undefined;\n    return { containerWidth: w, containerHeight: h, pageWidth: w / 2, pageHeight: h, book, content };\n  }\n\n  /** The fitted book rect in container CSS px (letterbox aware) — a stable 2-page area. */\n  #bookBox(): { x: number; y: number; width: number; height: number } {\n    const el = this.#container;\n    const cw = el?.clientWidth ?? 0;\n    const ch = el?.clientHeight ?? 0;\n    if (this.#pageAspect <= 0 || cw <= 0 || ch <= 0) return { x: 0, y: 0, width: cw, height: ch };\n    const ba = (this.#fill ? 1 : 2) * this.#pageAspect;\n    let bw = cw;\n    let bh = ch;\n    if (ba > cw / ch) bh = cw / ba;\n    else bw = ch * ba;\n    return { x: (cw - bw) / 2, y: (ch - bh) / 2, width: bw, height: bh };\n  }\n\n  /** Where the current spread is actually painted: the book, or its centered half for a lone\n   *  page (mirrors the draw-time #shiftX centering). This is what the engine hit-tests against. */\n  #contentBox(): { x: number; y: number; width: number; height: number } {\n    const b = this.#bookBox();\n    const lone = !this.#fill && this.#content !== null && shiftUnit(this.#content) !== 0;\n    return lone ? { x: b.x + b.width / 4, y: b.y, width: b.width / 2, height: b.height } : b;\n  }\n\n  // --- context loss / restore ---------------------------------------------------\n\n  #onContextLost = (event: Event): void => {\n    event.preventDefault();\n    this.#contextLost = true;\n    if (this.#restoreTimer === null) {\n      this.#restoreTimer = setTimeout(() => this.#fatal(), RESTORE_TIMEOUT_MS);\n    }\n  };\n\n  #onContextRestored = (): void => {\n    this.#clearRestoreTimer();\n    this.#contextLost = false;\n    this.#buildGlResources();\n    this.#render();\n  };\n\n  #onVisibilityChange = (): void => {\n    if (this.#canvas?.ownerDocument.visibilityState === 'visible') this.#render();\n  };\n\n  #fatal(): void {\n    if (this.#fatalFired) return;\n    this.#fatalFired = true;\n    this.#fatalHandler?.();\n  }\n\n  #clearRestoreTimer(): void {\n    if (this.#restoreTimer !== null) {\n      clearTimeout(this.#restoreTimer);\n      this.#restoreTimer = null;\n    }\n  }\n\n  #buildGlResources(): void {\n    const gl = this.#gl;\n    if (gl === null) return;\n\n    this.#flat = createProgram(gl, FLAT_VERT, FLAT_FRAG);\n    this.#curl = createProgram(gl, CURL_VERT, CURL_FRAG);\n    for (const name of ['uViewport', 'uRect', 'uView', 'uTex', 'uGutterSide']) {\n      this.#flatU[name] = gl.getUniformLocation(this.#flat, name);\n    }\n    for (const name of ['uViewport', 'uView', 'uOriginX', 'uDir', 'uLeafW', 'uFront', 'uBack', 'uGloss', 'uAlpha']) {\n      this.#curlU[name] = gl.getUniformLocation(this.#curl, name);\n    }\n\n    this.#quadVao = this.#makeQuadVao(gl, this.#flat);\n    this.#buildCurlMesh(gl, this.#curl);\n\n    this.#texCache.clear();\n    this.#cacheBytes = 0;\n    this.#blankTex = this.#makeBlankTexture(gl);\n    gl.useProgram(this.#flat);\n    gl.uniform1i(this.#flatU.uTex ?? null, 0);\n    gl.useProgram(this.#curl);\n    gl.uniform1i(this.#curlU.uFront ?? null, 0);\n    gl.uniform1i(this.#curlU.uBack ?? null, 1);\n    gl.clearColor(0, 0, 0, 0);\n    gl.enable(gl.BLEND);\n    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA); // premultiplied alpha\n  }\n\n  #makeQuadVao(gl: WebGL2RenderingContext, program: WebGLProgram): WebGLVertexArrayObject {\n    const vao = gl.createVertexArray();\n    const buffer = gl.createBuffer();\n    if (vao === null || buffer === null) throw new Error('WebglRenderer: could not create buffers.');\n    gl.bindVertexArray(vao);\n    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 1, 1]), gl.STATIC_DRAW);\n    const aUnit = gl.getAttribLocation(program, 'aUnit');\n    gl.enableVertexAttribArray(aUnit);\n    gl.vertexAttribPointer(aUnit, 2, gl.FLOAT, false, 0, 0);\n    gl.bindVertexArray(null);\n    return vao;\n  }\n\n  #buildCurlMesh(gl: WebGL2RenderingContext, program: WebGLProgram): void {\n    const nx = GRID_COLS + 1;\n    const indices: number[] = [];\n    for (let j = 0; j < GRID_ROWS; j++) {\n      for (let i = 0; i < GRID_COLS; i++) {\n        const a = j * nx + i;\n        const b = a + 1;\n        const c = a + nx;\n        const d = c + 1;\n        indices.push(a, c, b, b, c, d);\n      }\n    }\n    this.#idxCount = indices.length;\n\n    const vao = gl.createVertexArray();\n    this.#posBuf = gl.createBuffer();\n    this.#normBuf = gl.createBuffer();\n    const uvBuf = gl.createBuffer();\n    const idxBuf = gl.createBuffer();\n    if (vao === null || this.#posBuf === null || this.#normBuf === null || uvBuf === null || idxBuf === null) {\n      throw new Error('WebglRenderer: could not create mesh buffers.');\n    }\n    gl.bindVertexArray(vao);\n\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.#posBuf);\n    gl.bufferData(gl.ARRAY_BUFFER, this.#mesh.positions, gl.DYNAMIC_DRAW);\n    const aPos = gl.getAttribLocation(program, 'aPos');\n    gl.enableVertexAttribArray(aPos);\n    gl.vertexAttribPointer(aPos, 3, gl.FLOAT, false, 0, 0);\n\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.#normBuf);\n    gl.bufferData(gl.ARRAY_BUFFER, this.#mesh.normals, gl.DYNAMIC_DRAW);\n    const aNormal = gl.getAttribLocation(program, 'aNormal');\n    gl.enableVertexAttribArray(aNormal);\n    gl.vertexAttribPointer(aNormal, 3, gl.FLOAT, false, 0, 0);\n\n    gl.bindBuffer(gl.ARRAY_BUFFER, uvBuf);\n    gl.bufferData(gl.ARRAY_BUFFER, this.#mesh.uvs, gl.STATIC_DRAW);\n    const aUv = gl.getAttribLocation(program, 'aUv');\n    gl.enableVertexAttribArray(aUv);\n    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 0, 0);\n\n    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, idxBuf);\n    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);\n\n    gl.bindVertexArray(null);\n    this.#curlVao = vao;\n  }\n\n  // --- drawing ------------------------------------------------------------------\n\n  #render(): void {\n    const gl = this.#gl;\n    const canvas = this.#canvas;\n    if (gl === null || canvas === null || this.#contextLost || gl.isContextLost()) return;\n    this.#resize();\n    gl.clear(gl.COLOR_BUFFER_BIT);\n    this.#fitBook();\n    if (this.#flip !== null) this.#drawFlip();\n    else if (this.#content !== null) this.#drawStatic();\n  }\n\n  /** Letterbox the 2-page book to the page aspect, centered; restricts the GL viewport\n   *  so pages fill their halves without stretching (the surround stays cleared). */\n  #fitBook(): void {\n    const gl = this.#gl!;\n    const canvas = this.#canvas!;\n    const cw = canvas.width;\n    const ch = canvas.height;\n    if (this.#pageAspect > 0) {\n      const bookAspect = (this.#fill ? 1 : 2) * this.#pageAspect;\n      if (bookAspect > cw / ch) {\n        this.#bookW = cw;\n        this.#bookH = Math.round(cw / bookAspect);\n      } else {\n        this.#bookH = ch;\n        this.#bookW = Math.round(ch * bookAspect);\n      }\n    } else {\n      this.#bookW = cw;\n      this.#bookH = ch;\n    }\n    const bx = Math.round((cw - this.#bookW) / 2);\n    const by = Math.round((ch - this.#bookH) / 2); // centered, so GL's bottom offset == by\n    gl.viewport(bx, by, this.#bookW, this.#bookH);\n  }\n\n  #drawStatic(): void {\n    const w = this.#bookW;\n    const h = this.#bookH;\n    const content = this.#content!;\n    this.#shiftX = this.#fill ? 0 : shiftUnit(content) * (w / 4);\n    this.#useFlat();\n    if (this.#fill) {\n      this.#drawQuad({ x: 0, y: 0, w, h }, content.right ?? content.left);\n    } else {\n      // A lone page (one side null) gets no gutter shadow — it's a standalone, centered page.\n      this.#drawQuad({ x: 0, y: 0, w: w / 2, h }, content.left, content.right ? 1 : 0);\n      this.#drawQuad({ x: w / 2, y: 0, w: w / 2, h }, content.right, content.left ? -1 : 0);\n    }\n  }\n\n  #drawFlip(): void {\n    const gl = this.#gl!;\n    const w = this.#bookW;\n    const h = this.#bookH;\n    const flip = this.#flip!;\n\n    // Interpolate the lone-page centering across the flip so an opening cover (or a\n    // closing back page) slides between centered and spread instead of jumping.\n    this.#shiftX = flip.fill\n      ? 0\n      : (this.#fromShiftUnit + (this.#toShiftUnit - this.#fromShiftUnit) * this.#flipT) * (w / 4);\n\n    // Static pages underneath (with gutter shadow).\n    this.#useFlat();\n    if (flip.fill) {\n      this.#drawQuad({ x: 0, y: 0, w, h }, flip.underFull);\n    } else {\n      this.#drawQuad({ x: 0, y: 0, w: w / 2, h }, flip.underLeft, 1);\n      this.#drawQuad({ x: w / 2, y: 0, w: w / 2, h }, flip.underRight, -1);\n    }\n\n    if (flip.front === null && flip.back === null) return;\n\n    // Deform the leaf mesh with the selected curl model on the CPU, upload it, then draw.\n    const leafW = flip.fill ? w : w / 2;\n    const originX = flip.fill ? (flip.dir > 0 ? 0 : w) : w / 2;\n    CURLS[this.#curlType].deform(this.#mesh, leafW, h, this.#flipT, {\n      y: this.#anchor.y,\n      fill: flip.fill,\n    });\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.#posBuf);\n    gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.#mesh.positions);\n    gl.bindBuffer(gl.ARRAY_BUFFER, this.#normBuf);\n    gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.#mesh.normals);\n\n    this.#bindFace(gl.TEXTURE0, flip.front);\n    this.#bindFace(gl.TEXTURE1, flip.back);\n    gl.activeTexture(gl.TEXTURE0);\n\n    gl.useProgram(this.#curl);\n    gl.bindVertexArray(this.#curlVao);\n    gl.uniform2f(this.#curlU.uViewport ?? null, w, h);\n    gl.uniform3f(\n      this.#curlU.uView ?? null,\n      this.#view.scale,\n      this.#view.tx * this.#dpr + this.#shiftX,\n      this.#view.ty * this.#dpr,\n    );\n    gl.uniform1f(this.#curlU.uOriginX ?? null, originX);\n    gl.uniform1f(this.#curlU.uDir ?? null, flip.dir);\n    gl.uniform1f(this.#curlU.uLeafW ?? null, leafW);\n    gl.uniform1f(this.#curlU.uGloss ?? null, this.#curlType === 'simple' ? 0 : 1); // flat curl = no shine\n    gl.uniform1f(this.#curlU.uAlpha ?? null, flip.fill ? this.#fillFade() : 1);\n    gl.drawElements(gl.TRIANGLES, this.#idxCount, gl.UNSIGNED_SHORT, 0);\n  }\n\n  /** Leaf opacity for a lone page: solid until the curl-appropriate fade start, then\n   *  dissolving to 0 as it lands, so the turn resolves into the destination page rather\n   *  than onto blank space. The fade eases so opacity hangs longer then finishes cleanly. */\n  #fillFade(): number {\n    const start =\n      this.#curlType === 'roll' || this.#curlType === 'simple'\n        ? FILL_FADE_START_ROLL\n        : FILL_FADE_START_CURL;\n    const over = (this.#flipT - start) / (1 - start);\n    if (over <= 0) return 1;\n    if (over >= 1) return 0;\n    // Ease-out the remaining opacity: stay readable through most of the window, then settle.\n    return Math.pow(1 - over, 1.5);\n  }\n\n  #useFlat(): void {\n    const gl = this.#gl!;\n    gl.useProgram(this.#flat);\n    gl.bindVertexArray(this.#quadVao);\n    gl.activeTexture(gl.TEXTURE0);\n    gl.uniform2f(this.#flatU.uViewport ?? null, this.#bookW, this.#bookH);\n    gl.uniform3f(\n      this.#flatU.uView ?? null,\n      this.#view.scale,\n      this.#view.tx * this.#dpr + this.#shiftX,\n      this.#view.ty * this.#dpr,\n    );\n  }\n\n  #drawQuad(rect: Rect, source: TexImageSource | null, gutterSide = 0): void {\n    const gl = this.#gl!;\n    if (source === null) return;\n    this.#bindFace(gl.TEXTURE0, source);\n    gl.uniform4f(this.#flatU.uRect ?? null, rect.x, rect.y, rect.w, rect.h);\n    gl.uniform1f(this.#flatU.uGutterSide ?? null, gutterSide);\n    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);\n  }\n\n  #bindFace(unit: number, source: TexImageSource | null): void {\n    const gl = this.#gl!;\n    gl.activeTexture(unit);\n    gl.bindTexture(gl.TEXTURE_2D, source !== null ? this.#textureFor(source) : this.#blankTex);\n  }\n\n  #textureFor(source: TexImageSource): WebGLTexture {\n    const gl = this.#gl!;\n    const existing = this.#texCache.get(source);\n    if (existing !== undefined) {\n      this.#texCache.delete(source);\n      this.#texCache.set(source, existing);\n      return existing.tex;\n    }\n    const tex = createTexture(gl);\n    uploadTexture(gl, tex, source);\n    const dims = source as unknown as { width: number; height: number };\n    const bytes = dims.width * dims.height * 4;\n    this.#texCache.set(source, { tex, bytes });\n    this.#cacheBytes += bytes;\n    this.#evictTextures();\n    return tex;\n  }\n\n  #evictTextures(): void {\n    const gl = this.#gl!;\n    for (const [src, cached] of this.#texCache) {\n      if (this.#cacheBytes <= MAX_TEXTURE_CACHE_BYTES || this.#texCache.size <= 4) break;\n      this.#texCache.delete(src);\n      this.#cacheBytes -= cached.bytes;\n      gl.deleteTexture(cached.tex);\n    }\n  }\n\n  #makeBlankTexture(gl: WebGL2RenderingContext): WebGLTexture {\n    const tex = createTexture(gl);\n    gl.bindTexture(gl.TEXTURE_2D, tex);\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array([0, 0, 0, 0]));\n    return tex;\n  }\n\n  #resize(): void {\n    const gl = this.#gl;\n    const canvas = this.#canvas;\n    const el = this.#container;\n    if (gl === null || canvas === null || el === null) return;\n    this.#dpr = typeof devicePixelRatio === 'number' ? devicePixelRatio : 1;\n    const w = Math.max(1, Math.round(el.clientWidth * this.#dpr));\n    const h = Math.max(1, Math.round(el.clientHeight * this.#dpr));\n    if (canvas.width !== w || canvas.height !== h) {\n      canvas.width = w;\n      canvas.height = h;\n      gl.viewport(0, 0, w, h);\n    }\n  }\n}\n"],"mappings":"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"}