@flare-engine/render 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -533,6 +533,15 @@ function fire(opts) {
     intensity: opts.intensity ?? 0.8
   };
 }
+function dropShadow(opts) {
+  return {
+    type: "drop-shadow",
+    color: opts.color,
+    offsetX: opts.offsetX ?? 0,
+    offsetY: opts.offsetY ?? 6,
+    blur: opts.blur ?? 4
+  };
+}
 function roofsCity(opts) {
   return {
     type: "roofs-city",
@@ -928,6 +937,616 @@ half4 main(float2 coord) {
 `
 );
 
+// src/frame-renderer.ts
+var BLEND_SRC_OVER = 3;
+var BLEND_SRC_IN = 5;
+var OUTLINE_OFFSETS = [
+  [1, 0],
+  [-1, 0],
+  [0, 1],
+  [0, -1],
+  [Math.SQRT1_2, Math.SQRT1_2],
+  [Math.SQRT1_2, -Math.SQRT1_2],
+  [-Math.SQRT1_2, Math.SQRT1_2],
+  [-Math.SQRT1_2, -Math.SQRT1_2]
+];
+function createFrameRenderer(Skia) {
+  const defaultPaint = Skia.Paint();
+  let tintPaint = null;
+  let flashPaint = null;
+  let grayscalePaint = null;
+  let outlinePaint = null;
+  let customPaint = null;
+  let waterPaint = null;
+  let waterRuntimeEffect = null;
+  let fogPaint = null;
+  let fogRuntimeEffect = null;
+  let firePaint = null;
+  let fireRuntimeEffect = null;
+  let dropShadowPaint = null;
+  let roofsCityPaint = null;
+  let roofsCityEffect = null;
+  let forestCanopyPaint = null;
+  let forestCanopyEffect = null;
+  let riverWavePaint = null;
+  let riverWaveEffect = null;
+  let moonCraterPaint = null;
+  let moonCraterEffect = null;
+  let caveInteriorPaint = null;
+  let caveInteriorEffect = null;
+  let mountainHillsPaint = null;
+  let mountainHillsEffect = null;
+  const roofsCityUniforms = new Array(10).fill(0);
+  const forestCanopyUniforms = new Array(10).fill(0);
+  const riverWaveUniforms = new Array(10).fill(0);
+  const moonCraterUniforms = new Array(10).fill(0);
+  const caveInteriorUniforms = new Array(10).fill(0);
+  const mountainHillsUniforms = new Array(10).fill(0);
+  const recorder = Skia.PictureRecorder();
+  const recordingBounds = Skia.XYWHRect(0, 0, 0, 0);
+  const srcRects = [];
+  const xforms = [];
+  const stretchSrcRects = [];
+  const stretchDstRects = [];
+  let stretchPaint = null;
+  const zoneBgRects = [];
+  let _cachedSrcSlice = null;
+  let _cachedSrcSliceLen = 0;
+  let _cachedXformSlice = null;
+  let _cachedXformSliceLen = 0;
+  const clearColor = new Float32Array(4);
+  const tintColor = new Float32Array(4);
+  const flashColor = new Float32Array(4);
+  const outlineColor = new Float32Array(4);
+  const dropShadowColor = new Float32Array(4);
+  const grayMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
+  const customUniforms = [];
+  const waterUniforms = new Array(11).fill(0);
+  const fogUniforms = new Array(9).fill(0);
+  const fireUniforms = new Array(11).fill(0);
+  let currentFrameTime = 0;
+  let current = null;
+  let _boundRuntime = null;
+  let _boundChain = null;
+  const _loggedOnce = /* @__PURE__ */ new Set();
+  function logOnce(msg) {
+    if (_loggedOnce.has(msg)) return;
+    _loggedOnce.add(msg);
+    console.warn(`[postfx] ${msg}`);
+  }
+  const canvas = {
+    save: () => current?.save() ?? 0,
+    restore: () => {
+      current?.restore();
+    },
+    translate: (x, y) => {
+      current?.translate(x, y);
+    },
+    scale: (sx, sy) => {
+      current?.scale(sx, sy);
+    },
+    rotate: (radians, cx, cy) => {
+      current?.rotate(radians, cx, cy);
+    },
+    clear: (argb) => {
+      if (current === null) return;
+      clearColor[0] = (argb >>> 16 & 255) / 255;
+      clearColor[1] = (argb >>> 8 & 255) / 255;
+      clearColor[2] = (argb & 255) / 255;
+      clearColor[3] = (argb >>> 24 & 255) / 255;
+      current.clear(clearColor);
+    }
+  };
+  function ensurePoolCapacity(n) {
+    while (srcRects.length < n) {
+      srcRects.push(Skia.XYWHRect(0, 0, 0, 0));
+      xforms.push(Skia.RSXform(1, 0, 0, 0));
+    }
+  }
+  function ensureStretchPoolCapacity(n) {
+    while (stretchSrcRects.length < n) {
+      stretchSrcRects.push(Skia.XYWHRect(0, 0, 0, 0));
+      stretchDstRects.push(Skia.XYWHRect(0, 0, 0, 0));
+    }
+  }
+  function ensureZoneBgPoolCapacity(n) {
+    while (zoneBgRects.length < n) {
+      zoneBgRects.push(Skia.XYWHRect(0, 0, 0, 0));
+    }
+  }
+  function getCachedSrcSlice(n) {
+    if (_cachedSrcSlice !== null && _cachedSrcSliceLen === n) return _cachedSrcSlice;
+    _cachedSrcSlice = srcRects.length === n ? srcRects : srcRects.slice(0, n);
+    _cachedSrcSliceLen = n;
+    return _cachedSrcSlice;
+  }
+  function getCachedXformSlice(n) {
+    if (_cachedXformSlice !== null && _cachedXformSliceLen === n) return _cachedXformSlice;
+    _cachedXformSlice = xforms.length === n ? xforms : xforms.slice(0, n);
+    _cachedXformSliceLen = n;
+    return _cachedXformSlice;
+  }
+  function fillSrcRects(commands, n) {
+    for (let i = 0; i < n; i++) {
+      const cmd = commands[i];
+      srcRects[i]?.setXYWH(cmd.srcX, cmd.srcY, cmd.srcW, cmd.srcH);
+    }
+  }
+  function fillXforms(commands, n, dx, dy) {
+    for (let i = 0; i < n; i++) {
+      const cmd = commands[i];
+      const scale = cmd.srcW === 0 ? 1 : cmd.dstW / cmd.srcW;
+      if (cmd.rotation === 0) {
+        xforms[i]?.set(scale, 0, cmd.dstX + dx, cmd.dstY + dy);
+      } else {
+        const c = Math.cos(cmd.rotation);
+        const s = Math.sin(cmd.rotation);
+        const scos = scale * c;
+        const ssin = scale * s;
+        const px = cmd.dstX + cmd.anchorX * cmd.dstW + dx;
+        const py = cmd.dstY + cmd.anchorY * cmd.dstH + dy;
+        const axSrc = cmd.anchorX * cmd.srcW;
+        const aySrc = cmd.anchorY * cmd.srcH;
+        xforms[i]?.set(
+          scos,
+          ssin,
+          px - scos * axSrc + ssin * aySrc,
+          py - ssin * axSrc - scos * aySrc
+        );
+      }
+    }
+  }
+  function applyTint(effect) {
+    if (tintPaint === null) tintPaint = Skia.Paint();
+    writeColor(tintColor, effect.color, effect.amount);
+    tintPaint.setColorFilter(Skia.ColorFilter.MakeBlend(tintColor, BLEND_SRC_OVER));
+    return tintPaint;
+  }
+  function applyFlash(effect) {
+    if (flashPaint === null) flashPaint = Skia.Paint();
+    writeColor(flashColor, effect.color, flashIntensity(effect));
+    flashPaint.setColorFilter(Skia.ColorFilter.MakeBlend(flashColor, BLEND_SRC_OVER));
+    return flashPaint;
+  }
+  function applyGrayscale(effect) {
+    if (grayscalePaint === null) grayscalePaint = Skia.Paint();
+    writeGrayscaleMatrix(grayMatrix, effect.amount);
+    grayscalePaint.setColorFilter(Skia.ColorFilter.MakeMatrix(grayMatrix));
+    return grayscalePaint;
+  }
+  function applyOutlinePaint(effect) {
+    if (outlinePaint === null) outlinePaint = Skia.Paint();
+    writeColor(outlineColor, effect.color, 1);
+    outlinePaint.setColorFilter(Skia.ColorFilter.MakeBlend(outlineColor, BLEND_SRC_IN));
+    return outlinePaint;
+  }
+  function applyCustom(effect) {
+    if (customPaint === null) customPaint = Skia.Paint();
+    const shader = effect.shader;
+    const floatCount = shader.getUniformFloatCount();
+    while (customUniforms.length < floatCount) customUniforms.push(0);
+    customUniforms.length = floatCount;
+    fillCustomUniforms(effect, shader, customUniforms);
+    customPaint.setShader(shader.makeShader(customUniforms));
+    return customPaint;
+  }
+  function applyWater(effect, time) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (waterRuntimeEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(WATER_SKSL);
+      if (compiled === null) return defaultPaint;
+      waterRuntimeEffect = compiled;
+    }
+    if (waterPaint === null) waterPaint = Skia.Paint();
+    waterUniforms[0] = 0;
+    waterUniforms[1] = 0;
+    waterUniforms[2] = effect.color.r;
+    waterUniforms[3] = effect.color.g;
+    waterUniforms[4] = effect.color.b;
+    waterUniforms[5] = effect.foamColor.r;
+    waterUniforms[6] = effect.foamColor.g;
+    waterUniforms[7] = effect.foamColor.b;
+    waterUniforms[8] = effect.waveSpeed;
+    waterUniforms[9] = effect.waveAmplitude;
+    waterUniforms[10] = time;
+    waterPaint.setShader(waterRuntimeEffect.makeShader(waterUniforms));
+    return waterPaint;
+  }
+  function applyFog(effect, time) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (fogRuntimeEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(FOG_SKSL);
+      if (compiled === null) return defaultPaint;
+      fogRuntimeEffect = compiled;
+    }
+    if (fogPaint === null) fogPaint = Skia.Paint();
+    fogUniforms[0] = 0;
+    fogUniforms[1] = 0;
+    fogUniforms[2] = effect.color.r;
+    fogUniforms[3] = effect.color.g;
+    fogUniforms[4] = effect.color.b;
+    fogUniforms[5] = effect.density;
+    fogUniforms[6] = effect.speed;
+    fogUniforms[7] = effect.scale;
+    fogUniforms[8] = time;
+    fogPaint.setShader(fogRuntimeEffect.makeShader(fogUniforms));
+    return fogPaint;
+  }
+  function applyFire(effect, time) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (fireRuntimeEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(FIRE_SKSL);
+      if (compiled === null) return defaultPaint;
+      fireRuntimeEffect = compiled;
+    }
+    if (firePaint === null) firePaint = Skia.Paint();
+    fireUniforms[0] = 0;
+    fireUniforms[1] = 0;
+    fireUniforms[2] = effect.color.r;
+    fireUniforms[3] = effect.color.g;
+    fireUniforms[4] = effect.color.b;
+    fireUniforms[5] = effect.tipColor.r;
+    fireUniforms[6] = effect.tipColor.g;
+    fireUniforms[7] = effect.tipColor.b;
+    fireUniforms[8] = effect.speed;
+    fireUniforms[9] = effect.intensity;
+    fireUniforms[10] = time;
+    firePaint.setShader(fireRuntimeEffect.makeShader(fireUniforms));
+    return firePaint;
+  }
+  function applyDropShadow(effect) {
+    if (Skia.ImageFilter === void 0) return defaultPaint;
+    if (dropShadowPaint === null) dropShadowPaint = Skia.Paint();
+    writeColor(dropShadowColor, effect.color, 1);
+    dropShadowPaint.setImageFilter(
+      Skia.ImageFilter.MakeDropShadow(
+        effect.offsetX,
+        effect.offsetY,
+        effect.blur,
+        effect.blur,
+        dropShadowColor,
+        null
+      )
+    );
+    return dropShadowPaint;
+  }
+  function applyRoofsCity(effect) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (roofsCityEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(ROOFS_CITY_SKSL);
+      if (compiled === null) return defaultPaint;
+      roofsCityEffect = compiled;
+    }
+    if (roofsCityPaint === null) roofsCityPaint = Skia.Paint();
+    roofsCityUniforms[0] = effect.resolutionW;
+    roofsCityUniforms[1] = effect.resolutionH;
+    roofsCityUniforms[2] = effect.skyColor.r;
+    roofsCityUniforms[3] = effect.skyColor.g;
+    roofsCityUniforms[4] = effect.skyColor.b;
+    roofsCityUniforms[5] = effect.roofColor.r;
+    roofsCityUniforms[6] = effect.roofColor.g;
+    roofsCityUniforms[7] = effect.roofColor.b;
+    roofsCityUniforms[8] = effect.scrollOffsetY;
+    roofsCityUniforms[9] = effect.density;
+    roofsCityPaint.setShader(roofsCityEffect.makeShader(roofsCityUniforms));
+    return roofsCityPaint;
+  }
+  function applyForestCanopy(effect) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (forestCanopyEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(FOREST_CANOPY_SKSL);
+      if (compiled === null) return defaultPaint;
+      forestCanopyEffect = compiled;
+    }
+    if (forestCanopyPaint === null) forestCanopyPaint = Skia.Paint();
+    forestCanopyUniforms[0] = effect.resolutionW;
+    forestCanopyUniforms[1] = effect.resolutionH;
+    forestCanopyUniforms[2] = effect.skyColor.r;
+    forestCanopyUniforms[3] = effect.skyColor.g;
+    forestCanopyUniforms[4] = effect.skyColor.b;
+    forestCanopyUniforms[5] = effect.leafColor.r;
+    forestCanopyUniforms[6] = effect.leafColor.g;
+    forestCanopyUniforms[7] = effect.leafColor.b;
+    forestCanopyUniforms[8] = effect.scrollOffsetY;
+    forestCanopyUniforms[9] = effect.density;
+    forestCanopyPaint.setShader(forestCanopyEffect.makeShader(forestCanopyUniforms));
+    return forestCanopyPaint;
+  }
+  function applyRiverWave(effect) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (riverWaveEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(RIVER_WAVE_SKSL);
+      if (compiled === null) return defaultPaint;
+      riverWaveEffect = compiled;
+    }
+    if (riverWavePaint === null) riverWavePaint = Skia.Paint();
+    riverWaveUniforms[0] = effect.resolutionW;
+    riverWaveUniforms[1] = effect.resolutionH;
+    riverWaveUniforms[2] = effect.waterColor.r;
+    riverWaveUniforms[3] = effect.waterColor.g;
+    riverWaveUniforms[4] = effect.waterColor.b;
+    riverWaveUniforms[5] = effect.foamColor.r;
+    riverWaveUniforms[6] = effect.foamColor.g;
+    riverWaveUniforms[7] = effect.foamColor.b;
+    riverWaveUniforms[8] = effect.scrollOffsetY;
+    riverWaveUniforms[9] = effect.waveScale;
+    riverWavePaint.setShader(riverWaveEffect.makeShader(riverWaveUniforms));
+    return riverWavePaint;
+  }
+  function applyMoonCrater(effect) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (moonCraterEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(MOON_CRATER_SKSL);
+      if (compiled === null) return defaultPaint;
+      moonCraterEffect = compiled;
+    }
+    if (moonCraterPaint === null) moonCraterPaint = Skia.Paint();
+    moonCraterUniforms[0] = effect.resolutionW;
+    moonCraterUniforms[1] = effect.resolutionH;
+    moonCraterUniforms[2] = effect.moonColor.r;
+    moonCraterUniforms[3] = effect.moonColor.g;
+    moonCraterUniforms[4] = effect.moonColor.b;
+    moonCraterUniforms[5] = effect.craterColor.r;
+    moonCraterUniforms[6] = effect.craterColor.g;
+    moonCraterUniforms[7] = effect.craterColor.b;
+    moonCraterUniforms[8] = effect.scrollOffsetY;
+    moonCraterUniforms[9] = effect.craterCount;
+    moonCraterPaint.setShader(moonCraterEffect.makeShader(moonCraterUniforms));
+    return moonCraterPaint;
+  }
+  function applyCaveInterior(effect) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (caveInteriorEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(CAVE_INTERIOR_SKSL);
+      if (compiled === null) return defaultPaint;
+      caveInteriorEffect = compiled;
+    }
+    if (caveInteriorPaint === null) caveInteriorPaint = Skia.Paint();
+    caveInteriorUniforms[0] = effect.resolutionW;
+    caveInteriorUniforms[1] = effect.resolutionH;
+    caveInteriorUniforms[2] = effect.caveColor.r;
+    caveInteriorUniforms[3] = effect.caveColor.g;
+    caveInteriorUniforms[4] = effect.caveColor.b;
+    caveInteriorUniforms[5] = effect.glowColor.r;
+    caveInteriorUniforms[6] = effect.glowColor.g;
+    caveInteriorUniforms[7] = effect.glowColor.b;
+    caveInteriorUniforms[8] = effect.scrollOffsetY;
+    caveInteriorUniforms[9] = effect.stalactiteCount;
+    caveInteriorPaint.setShader(caveInteriorEffect.makeShader(caveInteriorUniforms));
+    return caveInteriorPaint;
+  }
+  function applyMountainHills(effect) {
+    if (Skia.RuntimeEffect === void 0) return defaultPaint;
+    if (mountainHillsEffect === null) {
+      const compiled = Skia.RuntimeEffect.Make(MOUNTAIN_HILLS_SKSL);
+      if (compiled === null) return defaultPaint;
+      mountainHillsEffect = compiled;
+    }
+    if (mountainHillsPaint === null) mountainHillsPaint = Skia.Paint();
+    mountainHillsUniforms[0] = effect.resolutionW;
+    mountainHillsUniforms[1] = effect.resolutionH;
+    mountainHillsUniforms[2] = effect.skyColor.r;
+    mountainHillsUniforms[3] = effect.skyColor.g;
+    mountainHillsUniforms[4] = effect.skyColor.b;
+    mountainHillsUniforms[5] = effect.hillColor.r;
+    mountainHillsUniforms[6] = effect.hillColor.g;
+    mountainHillsUniforms[7] = effect.hillColor.b;
+    mountainHillsUniforms[8] = effect.scrollOffsetY;
+    mountainHillsUniforms[9] = effect.ridgeScale;
+    mountainHillsPaint.setShader(mountainHillsEffect.makeShader(mountainHillsUniforms));
+    return mountainHillsPaint;
+  }
+  function drawOutlined(cvs, image, commands, n, effect, alpha) {
+    const paint = applyOutlinePaint(effect);
+    paint.setAlphaf(alpha);
+    const srcs = getCachedSrcSlice(n);
+    for (let k = 0; k < OUTLINE_OFFSETS.length; k++) {
+      const offset = OUTLINE_OFFSETS[k];
+      fillXforms(commands, n, offset[0] * effect.width, offset[1] * effect.width);
+      const dsts = getCachedXformSlice(n);
+      cvs.drawAtlas(image, srcs, dsts, paint);
+    }
+    paint.setAlphaf(1);
+    defaultPaint.setAlphaf(alpha);
+    fillXforms(commands, n, 0, 0);
+    const mainDsts = getCachedXformSlice(n);
+    cvs.drawAtlas(image, srcs, mainDsts, defaultPaint);
+    defaultPaint.setAlphaf(1);
+  }
+  function resolveEffectPaint(effect) {
+    switch (effect.type) {
+      case "tint":
+        return applyTint(effect);
+      case "flash":
+        return applyFlash(effect);
+      case "grayscale":
+        return applyGrayscale(effect);
+      case "custom":
+        return applyCustom(effect);
+      case "water":
+        return applyWater(effect, currentFrameTime);
+      case "fog":
+        return applyFog(effect, currentFrameTime);
+      case "fire":
+        return applyFire(effect, currentFrameTime);
+      case "drop-shadow":
+        return applyDropShadow(effect);
+      case "outline":
+        return applyOutlinePaint(effect);
+      case "roofs-city":
+        return applyRoofsCity(effect);
+      case "forest-canopy":
+        return applyForestCanopy(effect);
+      case "river-wave":
+        return applyRiverWave(effect);
+      case "moon-crater":
+        return applyMoonCrater(effect);
+      case "cave-interior":
+        return applyCaveInterior(effect);
+      case "mountain-hills":
+        return applyMountainHills(effect);
+    }
+  }
+  return {
+    canvas,
+    beginFrame(viewportWidth, viewportHeight, time = 0, pixelDensity = 1) {
+      if (viewportWidth === 0 || viewportHeight === 0) return;
+      _boundRuntime = null;
+      _boundChain = null;
+      currentFrameTime = time;
+      const pd = pixelDensity;
+      recordingBounds.setXYWH(0, 0, viewportWidth * pd, viewportHeight * pd);
+      current = recorder.beginRecording(recordingBounds);
+      if (pd !== 1) current.scale(pd, pd);
+    },
+    drawAtlas(image, commands) {
+      if (current === null) return;
+      const n = commands.length;
+      if (n === 0) return;
+      const effect = commands[0]?.effect;
+      const alpha = commands[0]?.alpha ?? 1;
+      if (effect?.type === "roofs-city" || effect?.type === "forest-canopy" || effect?.type === "river-wave" || effect?.type === "moon-crater" || effect?.type === "cave-interior" || effect?.type === "mountain-hills") {
+        const paint2 = resolveEffectPaint(effect);
+        paint2.setAlphaf(alpha);
+        ensureZoneBgPoolCapacity(n);
+        for (let i = 0; i < n; i++) {
+          const cmd = commands[i];
+          zoneBgRects[i].setXYWH(cmd.dstX, cmd.dstY, cmd.dstW, cmd.dstH);
+          current.drawRect(zoneBgRects[i], paint2);
+        }
+        paint2.setAlphaf(1);
+        return;
+      }
+      if (commands[0]?.stretch) {
+        if (stretchPaint === null) stretchPaint = Skia.Paint();
+        ensureStretchPoolCapacity(n);
+        stretchPaint.setAlphaf(alpha);
+        for (let i = 0; i < n; i++) {
+          const cmd = commands[i];
+          const srcR = stretchSrcRects[i];
+          const dstR = stretchDstRects[i];
+          srcR.setXYWH(cmd.srcX, cmd.srcY, cmd.srcW, cmd.srcH);
+          dstR.setXYWH(cmd.dstX, cmd.dstY, cmd.dstW, cmd.dstH);
+          current.drawImageRect(image, srcR, dstR, stretchPaint);
+        }
+        stretchPaint.setAlphaf(1);
+        return;
+      }
+      ensurePoolCapacity(n);
+      fillSrcRects(commands, n);
+      if (effect?.type === "outline") {
+        drawOutlined(current, image, commands, n, effect, alpha);
+        return;
+      }
+      fillXforms(commands, n, 0, 0);
+      const srcs = getCachedSrcSlice(n);
+      const dsts = getCachedXformSlice(n);
+      const paint = effect === void 0 ? defaultPaint : resolveEffectPaint(effect);
+      paint.setAlphaf(alpha);
+      current.drawAtlas(image, srcs, dsts, paint);
+      paint.setAlphaf(1);
+    },
+    setPostFxBinding(runtime, chain) {
+      _boundRuntime = runtime;
+      _boundChain = chain;
+    },
+    buildPostFxPasses(runtime, chain, width, height) {
+      const rt = runtime ?? _boundRuntime;
+      const ch = chain ?? _boundChain;
+      if (rt === null || !rt.supported) return [];
+      if (rt.buildPass === void 0) {
+        logOnce("buildPostFxPasses: runtime.supported but buildPass absent \u2014 no passes");
+        return [];
+      }
+      if (ch === null) return [];
+      const passes = rt.buildPass(ch, width, height);
+      if (passes.length === 0) return [];
+      const out = [];
+      for (const pass of passes) {
+        const shader = pass.shader;
+        const uniformCount = typeof shader.getUniformCount === "function" ? shader.getUniformCount() : 0;
+        const uniforms = {};
+        for (let i = 0; i < uniformCount; i++) {
+          const name = typeof shader.getUniformName === "function" ? shader.getUniformName(i) : String(i);
+          const info = typeof shader.getUniform === "function" ? shader.getUniform(i) : { columns: 1, rows: 1, slot: i };
+          const size = info.columns * info.rows;
+          if (size === 1) {
+            uniforms[name] = pass.uniforms[info.slot] ?? 0;
+          } else {
+            const vec = [];
+            for (let k = 0; k < size; k++) {
+              vec.push(pass.uniforms[info.slot + k] ?? 0);
+            }
+            uniforms[name] = vec;
+          }
+        }
+        out.push({
+          id: pass.id,
+          source: shader,
+          uniforms,
+          children: pass.children
+        });
+      }
+      return out;
+    },
+    endFrame() {
+      if (current === null) return null;
+      current = null;
+      return recorder.finishRecordingAsPicture();
+    }
+  };
+}
+function writeColor(out, color, alphaMul) {
+  out[0] = color.r;
+  out[1] = color.g;
+  out[2] = color.b;
+  out[3] = color.a * alphaMul;
+}
+function writeGrayscaleMatrix(out, amount) {
+  const inv = 1 - amount;
+  const lr = 0.299 * amount;
+  const lg = 0.587 * amount;
+  const lb = 0.114 * amount;
+  out[0] = inv + lr;
+  out[1] = lg;
+  out[2] = lb;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = lr;
+  out[6] = inv + lg;
+  out[7] = lb;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = lr;
+  out[11] = lg;
+  out[12] = inv + lb;
+  out[13] = 0;
+  out[14] = 0;
+  out[15] = 0;
+  out[16] = 0;
+  out[17] = 0;
+  out[18] = 1;
+  out[19] = 0;
+}
+function fillCustomUniforms(effect, shader, out) {
+  const count = shader.getUniformCount();
+  for (let i = 0; i < out.length; i++) out[i] = 0;
+  for (let i = 0; i < count; i++) {
+    const info = shader.getUniform(i);
+    const name = shader.getUniformName(i);
+    const value = effect.uniforms[name];
+    const size = info.columns * info.rows;
+    if (value === void 0) continue;
+    if (typeof value === "number") {
+      out[info.slot] = value;
+      continue;
+    }
+    for (let k = 0; k < size; k++) {
+      out[info.slot + k] = value[k] ?? 0;
+    }
+  }
+}
+
 // src/sprite-font.ts
 function parseBMFontJSON(json) {
   const data = json;
@@ -1066,10 +1685,12 @@ export {
   SpriteBatch,
   WATER_SKSL,
   caveInterior,
+  createFrameRenderer,
   createRenderSystem,
   custom,
   drawOrderCompare,
   drawText,
+  dropShadow,
   fire,
   flash,
   flashIntensity,