Skip to content

Write HTML. Render video. Built for agents.

14.4 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>Anamorphic Streak Flare</title>\n    <script src=\"https://cdn.jsdelivr.net/npm/[email protected]/dist/gsap.min.js\"></script>\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      #af-root {\n        position: relative;\n        width: 1920px;\n        height: 1080px;\n        overflow: hidden;\n      }\n      #af-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=\"af-root\"\n      data-composition-id=\"vfx-anamorphic-flare\"\n      data-root=\"true\"\n      data-width=\"1920\"\n      data-height=\"1080\"\n      data-start=\"0\"\n      data-duration=\"10\"\n      data-composition-variables='[{\"id\":\"intensity\",\"type\":\"number\",\"label\":\"Streak intensity\",\"default\":5,\"min\":0,\"max\":20,\"step\":0.1},{\"id\":\"threshold\",\"type\":\"number\",\"label\":\"High-pass threshold\",\"default\":0.3,\"min\":0,\"max\":1,\"step\":0.01},{\"id\":\"streakLength\",\"type\":\"number\",\"label\":\"Streak length gain\",\"default\":1,\"min\":0.1,\"max\":6,\"step\":0.05},{\"id\":\"tint\",\"type\":\"color\",\"label\":\"Streak tint\",\"default\":\"#7a8aff\"},{\"id\":\"bloomRadius\",\"type\":\"number\",\"label\":\"Bloom radius\",\"default\":0,\"min\":0,\"max\":80,\"step\":1,\"unit\":\"px\"},{\"id\":\"timeScale\",\"type\":\"number\",\"label\":\"Drift rate\",\"default\":0.5,\"min\":0,\"max\":3,\"step\":0.05},{\"id\":\"emitters\",\"type\":\"number\",\"label\":\"Emitter count\",\"default\":140,\"min\":1,\"max\":400,\"step\":1},{\"id\":\"backdrop\",\"type\":\"color\",\"label\":\"Backdrop\",\"default\":\"#04040a\"}]'\n    >\n      <canvas id=\"af-canvas\" width=\"1920\" height=\"1080\"></canvas>\n\n      <!-- Driver clip: gives HyperFrames a timed element to own on track 0. -->\n      <div\n        id=\"af-drv\"\n        class=\"clip\"\n        data-start=\"0\"\n        data-duration=\"10\"\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 = 10;\n        var W = 1920;\n        var H = 1080;\n\n        var root = document.getElementById(\"af-root\");\n        var V = (window.__hyperframes && window.__hyperframes.getVariables()) || {};\n        var CS = getComputedStyle(root);\n\n        // A declared variable reaches CSS as a custom property on the root.\n        // Read that first so a host stylesheet can retheme the block, then\n        // fall back to the declared value. Both the namespaced and the bare\n        // property name are probed: which one the runtime emits has changed\n        // across versions, and the block should not care.\n        function raw(id) {\n          var slug = id.toLowerCase();\n          var css =\n            CS.getPropertyValue(\"--hf-var-\" + slug).trim() ||\n            CS.getPropertyValue(\"--\" + slug).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        function str(id, fallback) {\n          var s = raw(id);\n          return typeof s === \"string\" && s !== \"\" ? s : fallback;\n        }\n\n        // ---------------------------------------------------------------\n        // Measured constants.\n        //\n        // Read from the three.js anamorphic post-processing example (MIT),\n        // cross-checked against a live capture of that demo's own GUI:\n        //\n        //   tint 0x7a8aff, threshold 0.3, intensity 5, bloom radius 0,\n        //   samples 80, time scale 0.5, resolution scale 0.25.\n        //\n        // The filter walks samples/2 taps in each direction HORIZONTALLY\n        // only, weights each tap by 1 - |i| / halfSamples (a tent), and\n        // normalises the sum by samples / 3.0. Dividing by samples/3 rather\n        // than by the weight sum is deliberate: it is a gain above 1, not\n        // an average, which is why a dim highlight still throws a readable\n        // streak.\n        //\n        // This implementation evaluates that convolution in closed form\n        // instead of running the 80-tap loop. For a small bright source the\n        // tent-weighted horizontal blur has an exact analytic result: the\n        // tent itself, centred on the source. So one horizontal gradient\n        // per highlight is the same arithmetic the loop would perform, at\n        // a fraction of the cost, and with no dependence on WebGL surviving\n        // seek capture.\n        // ---------------------------------------------------------------\n        var SAMPLES = 80;\n        var HALF_SAMPLES = SAMPLES / 2; // 40 taps each side\n        var RES_SCALE = 0.25; // the streak buffer runs at quarter resolution\n        var NORM = SAMPLES / 3; // total / (samples / 3.0)\n        var REF_W = 1280; // width the constants were measured at\n\n        // 40 taps of a 1/(0.25 * 1280) texel step = 12.5% of frame width per\n        // side. Held as a fraction rather than as absolute pixels so the look\n        // matches the reference at any output size.\n        var HALF_FRAC = HALF_SAMPLES / (RES_SCALE * REF_W);\n\n        var INTENSITY = num(\"intensity\", 5);\n        var THRESHOLD = num(\"threshold\", 0.3);\n        var STREAK_LEN = num(\"streakLength\", 1);\n        var BLOOM_R = num(\"bloomRadius\", 0);\n        var TIME_SCALE = num(\"timeScale\", 0.5);\n        var COUNT = Math.max(1, Math.round(num(\"emitters\", 140)));\n        var BACKDROP = str(\"backdrop\", \"#04040a\");\n        var TINT = hexRgb(str(\"tint\", \"#7a8aff\"), [0.478, 0.541, 1.0]);\n\n        function hexRgb(hex, fallback) {\n          var m = /^#?([0-9a-f]{6})$/i.exec(String(hex).trim());\n          if (!m) return fallback;\n          var n = parseInt(m[1], 16);\n          return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];\n        }\n\n        function mulberry32(seed) {\n          return function () {\n            seed |= 0;\n            seed = (seed + 0x6d2b79f5) | 0;\n            var t = Math.imul(seed ^ (seed >>> 15), 1 | seed);\n            t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n            return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n          };\n        }\n\n        function hsv(h, s, v) {\n          var hh = ((((h % 360) + 360) % 360) / 60) % 6;\n          var c = v * s;\n          var x = c * (1 - Math.abs((hh % 2) - 1));\n          var m = v - c;\n          var r = 0;\n          var g = 0;\n          var b = 0;\n          if (hh < 1) {\n            r = c;\n            g = x;\n          } else if (hh < 2) {\n            r = x;\n            g = c;\n          } else if (hh < 3) {\n            g = c;\n            b = x;\n          } else if (hh < 4) {\n            g = x;\n            b = c;\n          } else if (hh < 5) {\n            r = x;\n            b = c;\n          } else {\n            r = c;\n            b = x;\n          }\n          return [r + m, g + m, b + m];\n        }\n\n        // ---------------------------------------------------------------\n        // The emitter field. Every emitter is a closed-form function of t:\n        // two incommensurate sinusoids for position and one for brightness.\n        // The seeded PRNG runs once, at setup, so the field is identical on\n        // every load and every seek.\n        // ---------------------------------------------------------------\n        var rng = mulberry32(1337);\n        var EM = [];\n        for (var i = 0; i < COUNT; i++) {\n          EM.push({\n            x0: rng() * W,\n            y0: rng() * H,\n            ax: 24 + rng() * 90,\n            ay: 12 + rng() * 48,\n            fx: 0.018 + rng() * 0.05,\n            fy: 0.015 + rng() * 0.045,\n            px: rng(),\n            py: rng(),\n            r: 3 + Math.pow(rng(), 1.6) * 10,\n            h: rng() * 360,\n            s: 0.62 + rng() * 0.38,\n            v: 0.7 + rng() * 0.3,\n            fb: 0.03 + rng() * 0.09,\n            pb: rng(),\n          });\n        }\n\n        var TAU = Math.PI * 2;\n        var canvas = document.getElementById(\"af-canvas\");\n        var ctx = canvas.getContext(\"2d\");\n\n        // Streaks are accumulated in a quarter-resolution buffer, matching\n        // the reference's setResolutionScale(0.25). Upscaling it bilinearly\n        // is what gives the streak its soft vertical falloff, and it is the\n        // reason the streak reads as smooth rather than as a hard bar.\n        var SW = Math.round(W * RES_SCALE);\n        var SH = Math.round(H * RES_SCALE);\n        var sbuf = document.createElement(\"canvas\");\n        sbuf.width = SW;\n        sbuf.height = SH;\n        var sctx = sbuf.getContext(\"2d\");\n\n        function rgba(c, a) {\n          return (\n            \"rgba(\" +\n            Math.round(Math.min(1, Math.max(0, c[0])) * 255) +\n            \",\" +\n            Math.round(Math.min(1, Math.max(0, c[1])) * 255) +\n            \",\" +\n            Math.round(Math.min(1, Math.max(0, c[2])) * 255) +\n            \",\" +\n            Math.min(1, Math.max(0, a)) +\n            \")\"\n          );\n        }\n\n        // A slow swell across the clip so the field reads as a shot rather\n        // than as a loop. Closed form in t, like everything else here.\n        function gainAt(t) {\n          var u = Math.min(1, Math.max(0, t / DUR));\n          return 0.75 + 0.35 * Math.sin(Math.PI * u);\n        }\n\n        function draw(t) {\n          var tau = t * TIME_SCALE;\n          var gain = gainAt(t);\n          var halfLen = HALF_FRAC * W * STREAK_LEN;\n\n          sctx.setTransform(1, 0, 0, 1, 0, 0);\n          sctx.clearRect(0, 0, SW, SH);\n          sctx.globalCompositeOperation = \"lighter\";\n\n          var e;\n          var k;\n          var col;\n          var bright;\n          var x;\n          var y;\n          for (k = 0; k < EM.length; k++) {\n            e = EM[k];\n            x = e.x0 + e.ax * Math.sin(TAU * (e.fx * tau + e.px));\n            y = e.y0 + e.ay * Math.sin(TAU * (e.fy * tau + e.py));\n            bright = e.v * (0.62 + 0.38 * Math.sin(TAU * (e.fb * tau + e.pb)));\n            col = hsv(e.h, e.s, Math.max(0, bright));\n\n            // High pass, then tint, exactly as the reference filter does:\n            // max(colour - threshold, 0) * tint. Below threshold there is no\n            // streak at all, which is what keeps the field from smearing.\n            var hp = [\n              Math.max(0, col[0] - THRESHOLD) * TINT[0],\n              Math.max(0, col[1] - THRESHOLD) * TINT[1],\n              Math.max(0, col[2] - THRESHOLD) * TINT[2],\n            ];\n            var peak = Math.max(hp[0], Math.max(hp[1], hp[2]));\n            if (peak <= 0.0001) continue;\n\n            // Peak of the tent equals the source value times intensity over\n            // the samples/3 normaliser. Magnitude is carried in alpha so the\n            // hue keeps full 8-bit precision at low brightness.\n            var alpha = (peak * INTENSITY * gain) / NORM;\n            if (alpha < 0.003) continue;\n            var hue = [hp[0] / peak, hp[1] / peak, hp[2] / peak];\n\n            var bx = x * RES_SCALE;\n            var by = y * RES_SCALE;\n            var bh = Math.max(1, e.r * 2 * RES_SCALE);\n            var bl = halfLen * RES_SCALE;\n\n            var g = sctx.createLinearGradient(bx - bl, 0, bx + bl, 0);\n            g.addColorStop(0, rgba(hue, 0));\n            g.addColorStop(0.5, rgba(hue, alpha));\n            g.addColorStop(1, rgba(hue, 0));\n            sctx.fillStyle = g;\n            sctx.fillRect(bx - bl, by - bh / 2, bl * 2, bh);\n          }\n\n          ctx.setTransform(1, 0, 0, 1, 0, 0);\n          ctx.globalCompositeOperation = \"source-over\";\n          ctx.fillStyle = BACKDROP;\n          ctx.fillRect(0, 0, W, H);\n\n          ctx.globalCompositeOperation = \"lighter\";\n          ctx.imageSmoothingEnabled = true;\n          ctx.imageSmoothingQuality = \"high\";\n          ctx.drawImage(sbuf, 0, 0, SW, SH, 0, 0, W, H);\n\n          // The highlights themselves, drawn at full resolution on top.\n          for (k = 0; k < EM.length; k++) {\n            e = EM[k];\n            x = e.x0 + e.ax * Math.sin(TAU * (e.fx * tau + e.px));\n            y = e.y0 + e.ay * Math.sin(TAU * (e.fy * tau + e.py));\n            bright = e.v * (0.62 + 0.38 * Math.sin(TAU * (e.fb * tau + e.pb)));\n            col = hsv(e.h, e.s, Math.max(0, bright));\n\n            if (BLOOM_R > 0) {\n              var br = e.r + BLOOM_R;\n              var gb = ctx.createRadialGradient(x, y, 0, x, y, br);\n              gb.addColorStop(0, rgba(col, 0.5 * gain));\n              gb.addColorStop(0.35, rgba(col, 0.16 * gain));\n              gb.addColorStop(1, rgba(col, 0));\n              ctx.fillStyle = gb;\n              ctx.fillRect(x - br, y - br, br * 2, br * 2);\n            }\n\n            var core = ctx.createRadialGradient(x, y, 0, x, y, e.r);\n            core.addColorStop(\n              0,\n              rgba([col[0] * 0.88 + 0.12, col[1] * 0.88 + 0.12, col[2] * 0.88 + 0.12], 1),\n            );\n            core.addColorStop(0.72, rgba(col, 0.96));\n            core.addColorStop(1, rgba(col, 0));\n            ctx.fillStyle = core;\n            ctx.fillRect(x - e.r, y - e.r, e.r * 2, e.r * 2);\n          }\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 a\n        // timeline onUpdate callback: gsap suppresses events on seek(), so a\n        // callback-driven canvas silently freezes on frame 0 under any\n        // consumer that scrubs. Tweened values are written on every render,\n        // suppressed or not, so the setter fires on seek and hands us the\n        // 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[\"vfx-anamorphic-flare\"] = tl;\n\n        draw(0);\n      })();\n    </script>\n  </body>\n</html>\n"}