Skip to content

Write HTML. Render video. Built for agents.

25.7 KB
Raw Blame
{"html":"<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=1920, height=1080\" />\n    <title>Rack Focus</title>\n    <script src=\"https://cdn.jsdelivr.net/npm/[email protected]/dist/gsap.min.js\"></script>\n    <!--\n      RACK FOCUS: a focus pull with real aperture bokeh.\n\n      WHAT THIS NEEDS TO READ AT ALL\n      ------------------------------\n      A focus pull is a depth effect. It only reads when the frame holds\n      content at two clearly separated depths: something near the lens and\n      something far behind it. Point it at flat, single-plane content and\n      nothing happens, exactly like a dolly zoom on a flat card.\n\n      This block therefore carries its own depth-layered scene, a night\n      exterior built from light sources spread from 1.15 m to 90 m, so it\n      works standalone. Every depth is a variable: `nearfocus` is where the\n      pull starts, `farfocus` is where it ends, and the scene's two subjects\n      sit at those depths. Change them and the subjects move with them.\n\n      WHY THIS IS NOT A BLUR\n      ----------------------\n      A CSS/Gaussian blur softens everything uniformly. A real defocus turns\n      each point of light into an image of the APERTURE, scaled by its circle\n      of confusion, so a bright point becomes a hard-edged polygon disc whose\n      size grows with distance from the focal plane, and which clips to a\n      cat's-eye toward the frame corners. Every light in this scene is\n      splatted as an aperture-shaped sprite at its own circle of confusion.\n\n      CIRCLE OF CONFUSION, from three.js BokehShader2 (MIT), Martins Upitis\n      --------------------------------------------------------------------\n      Read from examples/jsm/shaders/BokehShader2.js:\n\n          float CoC = 0.03;              // circle of confusion in mm\n                                         // (35mm film = 0.03mm)\n          float f = focalLength;         // mm\n          float d = fDepth * 1000.0;     // focal plane in mm\n          float o = depth  * 1000.0;     // object depth in mm\n          float a = (o * f) / (o - f);\n          float b = (d * f) / (d - f);\n          float c = (d - f) / (d * fstop * CoC);\n          blur = abs(a - b) * c;\n\n      `blur` comes out in units of that 0.03 mm acceptable-sharpness circle,\n      so the defocus DIAMETER on the sensor is `blur * 0.03` mm, which this\n      block converts to pixels with the sensor width. Same constants, same\n      formula, independently written, no code copied. This agrees with the\n      Zeiss thin-lens form CoC = (f²/N)·|1/S - 1/U| for S >> f.\n\n      Aperture shape is the community-standard regular-polygon boundary\n      d(θ) = cos(π/n) / cos(mod(θ, 2π/n) - π/n), n = blade count (real\n      irises ship 5, 6, 8 or 9 blades). Cat's-eye clipping is the aperture\n      intersected with two barrel openings offset along the radial direction,\n      which is the actual mechanism of mechanical vignetting.\n\n      DETERMINISM\n      -----------\n      State at frame N is computed from N. The focal distance is a closed-form\n      function of t, every circle of confusion follows from a static depth and\n      that focal distance, and the scene point cloud is built once from a\n      seeded PRNG. No accumulation, no clocks, no unseeded randomness.\n    -->\n    <style>\n      *,\n      *::before,\n      *::after {\n        margin: 0;\n        padding: 0;\n        box-sizing: border-box;\n      }\n      body {\n        background: #000;\n        overflow: hidden;\n      }\n      #rf-root {\n        position: relative;\n        width: 1920px;\n        height: 1080px;\n        overflow: hidden;\n      }\n      #rf-backdrop {\n        position: absolute;\n        inset: 0;\n        background: #05060a;\n      }\n      #rf-canvas {\n        position: absolute;\n        top: 0;\n        left: 0;\n        width: 1920px;\n        height: 1080px;\n      }\n    </style>\n  </head>\n  <body>\n    <div\n      id=\"rf-root\"\n      data-composition-id=\"rack-focus\"\n      data-root=\"true\"\n      data-width=\"1920\"\n      data-height=\"1080\"\n      data-start=\"0\"\n      data-duration=\"6\"\n      data-composition-variables='[{\"id\":\"nearfocus\",\"type\":\"number\",\"label\":\"Near focal distance\",\"default\":1.2,\"min\":0.2,\"max\":100,\"step\":0.05,\"unit\":\"m\"},{\"id\":\"farfocus\",\"type\":\"number\",\"label\":\"Far focal distance\",\"default\":80,\"min\":0.3,\"max\":400,\"step\":0.5,\"unit\":\"m\"},{\"id\":\"focallength\",\"type\":\"number\",\"label\":\"Focal length\",\"default\":85,\"min\":12,\"max\":300,\"step\":1,\"unit\":\"mm\"},{\"id\":\"aperture\",\"type\":\"number\",\"label\":\"Aperture (f-number)\",\"default\":1.8,\"min\":0.95,\"max\":22,\"step\":0.05},{\"id\":\"blades\",\"type\":\"number\",\"label\":\"Aperture blades (bokeh shape)\",\"default\":6,\"min\":3,\"max\":14,\"step\":1},{\"id\":\"catseye\",\"type\":\"number\",\"label\":\"Cat eye clipping at the corners\",\"default\":0.62,\"min\":0,\"max\":1,\"step\":0.02},{\"id\":\"pullstart\",\"type\":\"number\",\"label\":\"Pull start\",\"default\":1.2,\"min\":0,\"max\":30,\"step\":0.05,\"unit\":\"s\"},{\"id\":\"pullduration\",\"type\":\"number\",\"label\":\"Pull duration\",\"default\":3.2,\"min\":0.1,\"max\":30,\"step\":0.05,\"unit\":\"s\"},{\"id\":\"pullease\",\"type\":\"string\",\"label\":\"Pull easing (GSAP ease)\",\"default\":\"power2.inOut\",\"placeholder\":\"power2.inOut\"},{\"id\":\"bokeh\",\"type\":\"number\",\"label\":\"Bokeh exposure\",\"default\":1,\"min\":0,\"max\":3,\"step\":0.05},{\"id\":\"backdrop\",\"type\":\"color\",\"label\":\"Backdrop\",\"default\":\"#05060a\"}]'\n    >\n      <div id=\"rf-backdrop\"></div>\n      <canvas id=\"rf-canvas\" width=\"1920\" height=\"1080\"></canvas>\n\n      <!-- Driver clip: gives HyperFrames a timed element to own on track 0. -->\n      <div\n        id=\"rf-drv\"\n        class=\"clip\"\n        data-start=\"0\"\n        data-duration=\"6\"\n        data-track-index=\"0\"\n        style=\"position: absolute; width: 1px; height: 1px; opacity: 0; pointer-events: none\"\n      ></div>\n    </div>\n\n    <script>\n      (function () {\n        var DUR = 6;\n        var W = 1920;\n        var H = 1080;\n\n        // 36mm-wide sensor, 16:9 active area. Pixels per millimetre is the\n        // only thing the projection needs, and it is the same on both axes.\n        var SENSOR_W_MM = 36;\n        var PX_PER_MM = W / SENSOR_W_MM;\n\n        // BokehShader2's acceptable-sharpness circle, in mm (35mm film).\n        var COC_MM = 0.03;\n\n        // Defocus is clamped so a wildly out-of-range focus setting cannot\n        // splat sprites the size of the frame. BokehShader2 clamps the same\n        // quantity with its `maxblur` uniform.\n        var MAX_COC_R_PX = 0.1 * H;\n        // Smallest sprite half-width. Below roughly one pixel a splat is an\n        // aliasing machine, so points in focus bottom out here.\n        var MIN_R_PX = 0.75;\n\n        var V = (window.__hyperframes && window.__hyperframes.getVariables()) || {};\n        var CS = getComputedStyle(document.getElementById(\"rf-root\"));\n\n        // The runtime defines every declared variable as `--<slug>` on the\n        // root (packages/core/src/tokenSlug.ts), so a host stylesheet can\n        // override one there too. Read the custom property first, fall back\n        // to the declared value when it is unset.\n        function raw(id) {\n          var css = CS.getPropertyValue(\"--\" + id.toLowerCase()).trim();\n          return css !== \"\" ? css : V[id];\n        }\n        function num(id, fallback) {\n          var n = parseFloat(raw(id));\n          return isFinite(n) ? n : fallback;\n        }\n\n        var NEAR = num(\"nearfocus\", 1.2);\n        var FAR = num(\"farfocus\", 80);\n        var FOCAL = num(\"focallength\", 85);\n        var FSTOP = num(\"aperture\", 1.8);\n        var BLADES = Math.max(3, Math.round(num(\"blades\", 6)));\n        var CATSEYE = num(\"catseye\", 0.62);\n        var PULL_START = num(\"pullstart\", 1.2);\n        var PULL_DUR = Math.max(0.001, num(\"pullduration\", 3.2));\n        var BOKEH = num(\"bokeh\", 1);\n        var EASE_NAME = String(raw(\"pullease\") || \"power2.inOut\");\n        var BACKDROP =\n          typeof raw(\"backdrop\") === \"string\" && raw(\"backdrop\") ? raw(\"backdrop\") : \"#05060a\";\n\n        document.getElementById(\"rf-backdrop\").style.background = BACKDROP;\n\n        var EASE = gsap.parseEase(EASE_NAME) || gsap.parseEase(\"power2.inOut\");\n\n        // A focus ring is roughly linear in dioptres, not in metres: a rack\n        // from 1.2m to 80m spends its first millimetre of barrel rotation\n        // crossing most of the distance. Interpolating 1/distance is what\n        // makes the pull travel evenly instead of snapping to the far plane.\n        function focusAt(t) {\n          var u = Math.min(1, Math.max(0, (t - PULL_START) / PULL_DUR));\n          var e = EASE(u);\n          var inv = 1 / NEAR + (1 / FAR - 1 / NEAR) * e;\n          return 1 / inv;\n        }\n\n        // ── Scene ────────────────────────────────────────────────────────\n        // A night exterior: a string of practical lights right in front of\n        // the lens, a lit city block far behind it, and scattered lights\n        // through every depth between so the pull reads as a continuous\n        // travel rather than a cut between two planes.\n\n        function mulberry32(a) {\n          return function () {\n            a |= 0;\n            a = (a + 0x6d2b79f5) | 0;\n            var t = Math.imul(a ^ (a >>> 15), 1 | a);\n            t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n            return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n          };\n        }\n        var rnd = mulberry32(0x5eed1a3);\n        function rr(lo, hi) {\n          return lo + (hi - lo) * rnd();\n        }\n\n        // x, y in metres (y up, origin on the optical axis), z in metres,\n        // r0 = the light's own physical radius in metres, b = peak\n        // brightness when perfectly in focus (values above 1 are highlights\n        // that clip, which is exactly why they stay visible once spread\n        // across a bokeh disc), rgb = colour.\n        var P = [];\n        function light(x, y, z, r0, b, c) {\n          P.push(x, y, z, r0, b, c[0], c[1], c[2]);\n        }\n\n        var TUNGSTEN = [1.0, 0.74, 0.45];\n        var FILAMENT = [1.0, 0.9, 0.74];\n        var WIRE = [0.86, 0.74, 0.6];\n        var WARM_WIN = [1.0, 0.79, 0.52];\n        var COOL_WIN = [0.6, 0.75, 1.0];\n        var SIGN_A = [0.35, 0.95, 1.0];\n        var SIGN_B = [1.0, 0.42, 0.72];\n\n        // Half the frame's width, in metres, at depth z. Both subjects are\n        // laid out against the reference framing (85mm, 1.2m / 80m) and then\n        // scaled by this, so retuning the lens or either focal distance moves\n        // the subjects with the frame instead of pushing them out of it.\n        function halfW(z) {\n          return (0.5 * SENSOR_W_MM * z) / FOCAL;\n        }\n\n        // Near subject: a catenary string of bulbs at `nearfocus`. The wire is\n        // what makes \"sharp\" unmistakable, a one-pixel line either resolves\n        // or it does not, and the filament inside each bulb is the second cue.\n        var NEAR_Z = NEAR;\n        var NS = halfW(NEAR_Z) / 0.25412;\n        var X_END = 0.4;\n        var SAG_A = 0.3;\n        var SAG = 0.1;\n        var COSH_END = Math.cosh(X_END / SAG_A);\n        function stringY(x) {\n          var s = (COSH_END - Math.cosh(x / SAG_A)) / (COSH_END - 1);\n          return 0.075 - SAG * s - 0.035 * (x / X_END);\n        }\n        function stringZ(x) {\n          return NEAR_Z + 0.05 * (x / X_END);\n        }\n        for (var i = 0; i < 1100; i++) {\n          var wx = -0.42 + (0.84 * i) / 1099;\n          light(wx * NS, stringY(wx) * NS, stringZ(wx), 0.0006 * NS, 1.4, WIRE);\n        }\n        for (var k = -5; k <= 5; k++) {\n          var bx = k * 0.085;\n          var by = stringY(bx) - 0.011;\n          var bz = stringZ(bx);\n          light(bx * NS, by * NS, bz, 0.006 * NS, 26, TUNGSTEN);\n          light((bx - 0.0022) * NS, by * NS, bz, 0.0006 * NS, 7, FILAMENT);\n          light(bx * NS, (by - 0.0022) * NS, bz, 0.0006 * NS, 7, FILAMENT);\n          light((bx + 0.0022) * NS, by * NS, bz, 0.0006 * NS, 7, FILAMENT);\n        }\n\n        // Far subject: three lit towers plus a dense LED sign strip, sitting\n        // around `farfocus`. The sign's pitch is fine enough that it only\n        // resolves into separate lamps when focus actually arrives.\n        var FAR_Z = FAR;\n        var FS = halfW(FAR_Z) / 16.941;\n        function tower(cx, hw, topY, botY, cols, rows, z, lit) {\n          for (var c = 0; c < cols; c++) {\n            for (var r = 0; r < rows; r++) {\n              if (rnd() > lit) continue;\n              var x = cx - hw + (2 * hw * (c + 0.5)) / cols;\n              var y = botY + ((topY - botY) * (r + 0.5)) / rows;\n              var cool = rnd() < 0.28;\n              light(x, y, z + rr(-0.4, 0.4) * FS, 0.24 * FS, rr(9, 20), cool ? COOL_WIN : WARM_WIN);\n            }\n          }\n        }\n        tower(-9.5 * FS, 3.5 * FS, 9.6 * FS, -4.0 * FS, 6, 14, FAR_Z * 1.03, 0.34);\n        tower(2.0 * FS, 4.5 * FS, 6.4 * FS, -4.0 * FS, 8, 12, FAR_Z * 0.98, 0.3);\n        tower(12.5 * FS, 3.0 * FS, 11.0 * FS, -4.0 * FS, 5, 15, FAR_Z * 1.08, 0.36);\n        for (var s = 0; s < 40; s++) {\n          var sx = (-5.5 + (11 * s) / 39) * FS;\n          var mixc = s / 39;\n          var sc = [\n            SIGN_A[0] + (SIGN_B[0] - SIGN_A[0]) * mixc,\n            SIGN_A[1] + (SIGN_B[1] - SIGN_A[1]) * mixc,\n            SIGN_A[2] + (SIGN_B[2] - SIGN_A[2]) * mixc,\n          ];\n          light(sx, -5.0 * FS, FAR_Z * 0.99, 0.1 * FS, 7, sc);\n          light(sx, -5.55 * FS, FAR_Z * 0.99, 0.1 * FS, 7, sc);\n        }\n\n        // Everything between. Depth is drawn log-uniform between the two\n        // subjects and the screen position is uniform, so the mid-ground\n        // stays evenly spread whatever the two focal distances are.\n        var Z_LO = Math.min(NEAR_Z, FAR_Z) * 1.9;\n        var Z_HI = Math.max(NEAR_Z, FAR_Z) * 0.85;\n        for (var m = 0; m < 90; m++) {\n          var z = Z_LO * Math.pow(Z_HI / Z_LO, rnd());\n          var halfWm = (0.5 * SENSOR_W_MM * z) / FOCAL;\n          var halfHm = (halfWm * H) / W;\n          var warm = rnd() < 0.66;\n          light(\n            rr(-1.05, 1.05) * halfWm,\n            rr(-1.0, 0.75) * halfHm,\n            z,\n            rr(0.006, 0.05) * (z / 12),\n            rr(5, 18),\n            warm ? WARM_WIN : COOL_WIN,\n          );\n        }\n\n        // ── GL ───────────────────────────────────────────────────────────\n        var canvas = document.getElementById(\"rf-canvas\");\n        var gl =\n          canvas.getContext(\"webgl\", {\n            alpha: true,\n            antialias: false,\n            depth: false,\n            stencil: false,\n            preserveDrawingBuffer: true,\n            powerPreference: \"high-performance\",\n          }) ||\n          canvas.getContext(\"experimental-webgl\", {\n            alpha: true,\n            preserveDrawingBuffer: true,\n          });\n\n        var VERT = [\n          \"precision highp float;\",\n          \"attribute vec2 aCorner;\", // -1..1 quad corner\n          \"attribute vec3 aPos;\", // metres, y up, z away from the lens\n          \"attribute vec2 aSize;\", // x = own radius (m), y = in-focus peak\n          \"attribute vec3 aColor;\",\n          \"uniform vec2 uRes;\",\n          \"uniform float uPxPerMm;\",\n          \"uniform float uFocal;\", // mm\n          \"uniform float uFocus;\", // metres\n          \"uniform float uFstop;\",\n          \"uniform float uCoCmm;\",\n          \"uniform float uMaxR;\",\n          \"uniform float uMinR;\",\n          \"uniform float uCatsEye;\",\n          \"uniform float uBokeh;\",\n          \"varying vec2 vQ;\",\n          \"varying vec3 vColor;\",\n          \"varying float vGain;\",\n          \"varying float vShape;\",\n          \"varying float vAA;\",\n          \"varying vec2 vRadial;\",\n          \"varying float vCat;\",\n          \"void main() {\",\n          \"  float z = max(aPos.z, 0.001);\",\n          \"  float ppm = uPxPerMm * uFocal / z;\", // pixels per metre at this depth\n          \"  vec2 centre = uRes * 0.5 + aPos.xy * ppm;\",\n          \"  float r0 = max(aSize.x * ppm, uMinR);\",\n          \"\",\n          \"  // BokehShader2's circle of confusion, in units of uCoCmm.\",\n          \"  float f = uFocal;\",\n          \"  float d = uFocus * 1000.0;\",\n          \"  float o = z * 1000.0;\",\n          \"  float a = (o * f) / max(o - f, 1e-4);\",\n          \"  float b = (d * f) / max(d - f, 1e-4);\",\n          \"  float c = (d - f) / max(d * uFstop * uCoCmm, 1e-6);\",\n          \"  float blur = abs(a - b) * c;\",\n          \"  // -> defocus diameter in mm -> pixels -> radius.\",\n          \"  float cocR = min(blur * uCoCmm * uPxPerMm * 0.5, uMaxR);\",\n          \"\",\n          \"  // A finite source convolved with the defocus disc: radii add in\",\n          \"  // quadrature. Flux is conserved, so peak brightness falls as the\",\n          \"  // inverse square of the radius. That single term is why an\",\n          \"  // in-focus lamp clips to white and a defocused one is a readable\",\n          \"  // disc instead of a smear.\",\n          \"  float R = sqrt(r0 * r0 + cocR * cocR);\",\n          \"  vGain = aSize.y * uBokeh * (r0 * r0) / (R * R);\",\n          \"  // Near focus the sprite is the lamp (round); far from it the\",\n          \"  // sprite is an image of the aperture (polygonal).\",\n          \"  vShape = (cocR * cocR) / (cocR * cocR + r0 * r0);\",\n          \"  vAA = 1.0 / max(R, 0.5);\",\n          \"  vColor = aColor;\",\n          \"  vQ = aCorner;\",\n          \"\",\n          \"  // Mechanical vignetting: the barrel openings clip the aperture\",\n          \"  // harder the further the sprite sits from the optical axis.\",\n          \"  vec2 off = centre - uRes * 0.5;\",\n          \"  float rad = length(off);\",\n          \"  vRadial = rad > 1.0 ? off / rad : vec2(1.0, 0.0);\",\n          \"  vCat = uCatsEye * min(1.0, rad / (length(uRes) * 0.5));\",\n          \"\",\n          \"  // A light spread thin enough to land under half a display code\",\n          \"  // value contributes nothing but fill rate. Culling it here is what\",\n          \"  // keeps a 900-point wire from splatting 900 invisible discs the\",\n          \"  // moment it goes out of focus.\",\n          \"  if (vGain < 0.0015) {\",\n          \"    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);\",\n          \"    return;\",\n          \"  }\",\n          \"\",\n          \"  vec2 p = centre + aCorner * R;\",\n          \"  gl_Position = vec4((p / uRes) * 2.0 - 1.0, 0.0, 1.0);\",\n          \"}\",\n        ].join(\"\\n\");\n\n        var FRAG = [\n          \"precision highp float;\",\n          \"varying vec2 vQ;\",\n          \"varying vec3 vColor;\",\n          \"varying float vGain;\",\n          \"varying float vShape;\",\n          \"varying float vAA;\",\n          \"varying vec2 vRadial;\",\n          \"varying float vCat;\",\n          \"uniform float uBlades;\",\n          \"const float PI = 3.14159265;\",\n          \"void main() {\",\n          \"  float r = length(vQ);\",\n          \"  if (r > 1.0) discard;\",\n          \"  float th = r > 1e-5 ? atan(vQ.y, vQ.x) : 0.0;\",\n          \"\",\n          \"  // Regular-polygon aperture boundary: circumradius 1 at a blade\",\n          \"  // vertex, cos(PI/n) at a blade midpoint.\",\n          \"  float n = uBlades;\",\n          \"  float seg = 2.0 * PI / n;\",\n          \"  float poly = cos(PI / n) / cos(mod(th, seg) - PI / n);\",\n          \"  float bound = mix(1.0, poly, vShape);\",\n          \"\",\n          \"  float cov = smoothstep(bound, bound - vAA, r);\",\n          \"  // Two offset barrel openings cut the disc from opposite sides,\",\n          \"  // which is what turns a corner bokeh into a cat's eye.\",\n          \"  float cut = vCat * vShape;\",\n          \"  cov *= smoothstep(1.0, 1.0 - vAA, length(vQ - vRadial * cut));\",\n          \"  cov *= smoothstep(1.0, 1.0 - vAA, length(vQ + vRadial * cut));\",\n          \"\",\n          \"  gl_FragColor = vec4(vColor * (vGain * cov), 1.0);\",\n          \"}\",\n        ].join(\"\\n\");\n\n        var uni = {};\n        var ready = false;\n        var count = 0;\n\n        function compile(type, src) {\n          var sh = gl.createShader(type);\n          gl.shaderSource(sh, src);\n          gl.compileShader(sh);\n          if (!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) {\n            throw new Error(\"rack-focus shader: \" + gl.getShaderInfoLog(sh));\n          }\n          return sh;\n        }\n\n        function hexToRgb(hex) {\n          var h = String(hex).trim().replace(\"#\", \"\");\n          if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];\n          var v = parseInt(h, 16);\n          if (!isFinite(v)) return [0.02, 0.024, 0.039];\n          return [((v >> 16) & 255) / 255, ((v >> 8) & 255) / 255, (v & 255) / 255];\n        }\n        var BG = hexToRgb(BACKDROP);\n\n        if (gl) {\n          var prog = gl.createProgram();\n          gl.attachShader(prog, compile(gl.VERTEX_SHADER, VERT));\n          gl.attachShader(prog, compile(gl.FRAGMENT_SHADER, FRAG));\n          gl.linkProgram(prog);\n          if (!gl.getProgramParameter(prog, gl.LINK_STATUS)) {\n            throw new Error(\"rack-focus link: \" + gl.getProgramInfoLog(prog));\n          }\n          gl.useProgram(prog);\n\n          // Six vertices per light: two triangles carrying the same point\n          // payload and four distinct corner offsets.\n          var CORNERS = [\n            [-1, -1],\n            [1, -1],\n            [1, 1],\n            [-1, -1],\n            [1, 1],\n            [-1, 1],\n          ];\n          var n = P.length / 8;\n          count = n * 6;\n          var STRIDE = 10;\n          var data = new Float32Array(count * STRIDE);\n          var w = 0;\n          for (var pi = 0; pi < n; pi++) {\n            var o = pi * 8;\n            for (var ci = 0; ci < 6; ci++) {\n              data[w++] = CORNERS[ci][0];\n              data[w++] = CORNERS[ci][1];\n              data[w++] = P[o];\n              data[w++] = P[o + 1];\n              data[w++] = P[o + 2];\n              data[w++] = P[o + 3];\n              data[w++] = P[o + 4];\n              data[w++] = P[o + 5];\n              data[w++] = P[o + 6];\n              data[w++] = P[o + 7];\n            }\n          }\n\n          var buf = gl.createBuffer();\n          gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n          gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);\n          var BYTES = STRIDE * 4;\n          [\n            [\"aCorner\", 2, 0],\n            [\"aPos\", 3, 8],\n            [\"aSize\", 2, 20],\n            [\"aColor\", 3, 28],\n          ].forEach(function (spec) {\n            var loc = gl.getAttribLocation(prog, spec[0]);\n            gl.enableVertexAttribArray(loc);\n            gl.vertexAttribPointer(loc, spec[1], gl.FLOAT, false, BYTES, spec[2]);\n          });\n\n          [\n            \"uRes\",\n            \"uPxPerMm\",\n            \"uFocal\",\n            \"uFocus\",\n            \"uFstop\",\n            \"uCoCmm\",\n            \"uMaxR\",\n            \"uMinR\",\n            \"uCatsEye\",\n            \"uBlades\",\n            \"uBokeh\",\n          ].forEach(function (nm) {\n            uni[nm] = gl.getUniformLocation(prog, nm);\n          });\n\n          gl.viewport(0, 0, W, H);\n          gl.uniform2f(uni.uRes, W, H);\n          gl.uniform1f(uni.uPxPerMm, PX_PER_MM);\n          gl.uniform1f(uni.uFocal, FOCAL);\n          gl.uniform1f(uni.uFstop, FSTOP);\n          gl.uniform1f(uni.uCoCmm, COC_MM);\n          gl.uniform1f(uni.uMaxR, MAX_COC_R_PX);\n          gl.uniform1f(uni.uMinR, MIN_R_PX);\n          gl.uniform1f(uni.uCatsEye, CATSEYE);\n          gl.uniform1f(uni.uBlades, BLADES);\n          gl.uniform1f(uni.uBokeh, BOKEH);\n\n          // Light adds to light. Overlapping bokeh discs are brighter where\n          // they cross, which is the whole texture of a bokeh field.\n          gl.disable(gl.DEPTH_TEST);\n          gl.enable(gl.BLEND);\n          gl.blendFunc(gl.ONE, gl.ONE);\n          ready = true;\n        }\n\n        // Every frame is computed from t alone: the focal distance is a\n        // closed-form function of t, and each sprite's circle of confusion\n        // falls out of its own static depth and that distance.\n        function draw(t) {\n          if (!ready) return;\n          gl.uniform1f(uni.uFocus, focusAt(t));\n          gl.clearColor(BG[0], BG[1], BG[2], 1);\n          gl.clear(gl.COLOR_BUFFER_BIT);\n          gl.drawArrays(gl.TRIANGLES, 0, count);\n          gl.flush();\n        }\n\n        window.__timelines = window.__timelines || {};\n        var tl = gsap.timeline({ paused: true });\n\n        // The canvas is repainted from a property SETTER, not from onUpdate:\n        // gsap's seek(t) suppresses events by default, so an onUpdate callback\n        // silently never fires on a scrub and the canvas freezes on frame 0.\n        // Tweened values are always written during render, suppressed or not,\n        // so this fires on every seek, and hands us the frame time directly.\n        var driver = { _t: 0 };\n        Object.defineProperty(driver, \"t\", {\n          get: function () {\n            return this._t;\n          },\n          set: function (v) {\n            this._t = v;\n            draw(v);\n          },\n        });\n        tl.to(driver, { t: DUR, duration: DUR, ease: \"none\" }, 0);\n        window.__timelines[\"rack-focus\"] = tl;\n\n        draw(0);\n      })();\n    </script>\n  </body>\n</html>\n"}