@relu-interactives/spatial-ecs 0.5.2 → 0.8.0

package/dist/chunk-OHCNPPMX.js

@@ -0,0 +1,334 @@
+import { __name } from './chunk-XE4OXN2W.js';
+import * as THREE from 'three';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';
+import { DotScreenPass } from 'three/examples/jsm/postprocessing/DotScreenPass.js';
+import { GlitchPass } from 'three/examples/jsm/postprocessing/GlitchPass.js';
+import { FilmPass } from 'three/examples/jsm/postprocessing/FilmPass.js';
+import { BokehPass } from 'three/examples/jsm/postprocessing/BokehPass.js';
+import { SSAOPass } from 'three/examples/jsm/postprocessing/SSAOPass.js';
+import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
+import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
+import { SMAAPass } from 'three/examples/jsm/postprocessing/SMAAPass.js';
+import { HueSaturationShader } from 'three/examples/jsm/shaders/HueSaturationShader.js';
+import { RGBShiftShader } from 'three/examples/jsm/shaders/RGBShiftShader.js';
+import { SepiaShader } from 'three/examples/jsm/shaders/SepiaShader.js';
+import { VignetteShader } from 'three/examples/jsm/shaders/VignetteShader.js';
+
+var PixelationShader = {
+  name: "PixelationShader",
+  uniforms: {
+    tDiffuse: { value: null },
+    resolution: { value: new THREE.Vector2(1, 1) },
+    pixelSize: { value: 6 }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+    varying vec2 vUv;
+    void main() {
+      vUv = uv;
+      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+    }
+  `
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+    uniform sampler2D tDiffuse;
+    uniform vec2 resolution;
+    uniform float pixelSize;
+    varying vec2 vUv;
+    void main() {
+      vec2 block = max(pixelSize, 1.0) / resolution;
+      vec2 coord = block * (floor(vUv / block) + 0.5);
+      gl_FragColor = texture2D(tDiffuse, coord);
+    }
+  `
+  )
+};
+var _PixelationPass = class _PixelationPass extends ShaderPass {
+  constructor(granularity, getPixelRatio) {
+    super(PixelationShader);
+    this.granularity = Math.max(1, granularity);
+    this.getPixelRatio = getPixelRatio;
+    this.updatePixelSize();
+  }
+  updatePixelSize() {
+    const uniform = this.uniforms.pixelSize;
+    if (uniform) {
+      uniform.value = this.granularity * Math.max(1, this.getPixelRatio());
+    }
+  }
+  setSize(width, height) {
+    const resolution = this.uniforms.resolution;
+    if (resolution) {
+      resolution.value.set(Math.max(1, width), Math.max(1, height));
+    }
+    this.updatePixelSize();
+  }
+};
+__name(_PixelationPass, "PixelationPass");
+var PixelationPass = _PixelationPass;
+function createWebglPostprocessing({
+  renderer: rendererInput,
+  scene,
+  camera,
+  values
+}) {
+  const renderer = rendererInput;
+  const composer = new EffectComposer(renderer);
+  composer.addPass(new RenderPass(scene, camera));
+  if (values.dof.enabled) {
+    composer.addPass(
+      new BokehPass(scene, camera, {
+        focus: values.dof.focusDistance,
+        aperture: Math.max(0, values.dof.focalLength),
+        maxblur: Math.max(0, values.dof.bokehScale)
+      })
+    );
+  }
+  if (values.bloom.enabled) {
+    const size = renderer.getSize(new THREE.Vector2());
+    composer.addPass(
+      new UnrealBloomPass(
+        new THREE.Vector2(size.width, size.height),
+        values.bloom.intensity,
+        values.bloom.radius,
+        values.bloom.threshold
+      )
+    );
+  }
+  if (values.vignette.enabled) {
+    const pass = new ShaderPass(VignetteShader);
+    const offset = pass.uniforms.offset;
+    const darkness = pass.uniforms.darkness;
+    if (offset) {
+      offset.value = values.vignette.offset;
+    }
+    if (darkness) {
+      darkness.value = values.vignette.darkness;
+    }
+    composer.addPass(pass);
+  }
+  if (values.hueSaturation.enabled) {
+    const pass = new ShaderPass(HueSaturationShader);
+    const hue = pass.uniforms.hue;
+    const saturation = pass.uniforms.saturation;
+    if (hue) {
+      hue.value = values.hueSaturation.hue;
+    }
+    if (saturation) {
+      saturation.value = values.hueSaturation.saturation;
+    }
+    composer.addPass(pass);
+  }
+  if (values.sepia.enabled) {
+    const pass = new ShaderPass(SepiaShader);
+    const amount = pass.uniforms.amount;
+    if (amount) {
+      amount.value = values.sepia.intensity;
+    }
+    composer.addPass(pass);
+  }
+  if (values.noise.enabled) {
+    composer.addPass(new FilmPass(values.noise.opacity));
+  }
+  if (values.dotScreen.enabled) {
+    composer.addPass(
+      new DotScreenPass(
+        new THREE.Vector2(0, 0),
+        values.dotScreen.angle ?? values.dotScreen.dotScreenAngle,
+        values.dotScreen.scale ?? values.dotScreen.dotScreenScale
+      )
+    );
+  }
+  if (values.ssao.enabled) {
+    const pass = new SSAOPass(scene, camera);
+    pass.kernelRadius = values.ssao.radius;
+    pass.minDistance = 1e-3;
+    pass.maxDistance = Math.max(0.01, values.ssao.intensity);
+    composer.addPass(pass);
+  }
+  if (values.glitch.enabled) {
+    const pass = new GlitchPass();
+    pass.enabled = true;
+    pass.goWild = Boolean(values.glitch.active);
+    composer.addPass(pass);
+  }
+  if (values.chromAberration.enabled) {
+    const pass = new ShaderPass(RGBShiftShader);
+    const { offsetX, offsetY } = values.chromAberration;
+    const amount = pass.uniforms.amount;
+    const angle = pass.uniforms.angle;
+    if (amount) {
+      amount.value = Math.hypot(offsetX, offsetY);
+    }
+    if (angle) {
+      angle.value = Math.atan2(offsetY, offsetX);
+    }
+    composer.addPass(pass);
+  }
+  if (values.pixelation.enabled) {
+    composer.addPass(
+      new PixelationPass(
+        values.pixelation.granularity,
+        () => typeof renderer.getPixelRatio === "function" ? renderer.getPixelRatio() : 1
+      )
+    );
+  }
+  if (values.smaa.enabled) {
+    composer.addPass(new SMAAPass());
+  }
+  composer.addPass(new OutputPass());
+  return composer;
+}
+__name(createWebglPostprocessing, "createWebglPostprocessing");
+var CHROMA_KEY_FLAG = "ecsChromaKey";
+function createWebglChromaKeyMaterial(texture, options) {
+  const material = new THREE.ShaderMaterial({
+    uniforms: {
+      tex: { value: texture },
+      keyColor: { value: new THREE.Color(options.keyColor) },
+      similarity: { value: options.similarity },
+      smoothness: { value: options.smoothness },
+      spill: { value: options.spill }
+    },
+    vertexShader: `
+      varying vec2 vUv;
+      void main() {
+        vUv = uv;
+        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+      }
+    `,
+    fragmentShader: `
+      uniform sampler2D tex;
+      uniform vec3 keyColor;
+      uniform float similarity;
+      uniform float smoothness;
+      uniform float spill;
+      varying vec2 vUv;
+
+      void main() {
+        vec4 texel = texture2D(tex, vUv);
+        float chromaDist = distance(texel.rgb, keyColor);
+        float alpha = smoothstep(similarity, similarity + smoothness, chromaDist);
+
+        float spillFactor = smoothstep(similarity, similarity + spill + smoothness, chromaDist);
+        vec3 despilled = mix(vec3(dot(texel.rgb, vec3(0.299, 0.587, 0.114))), texel.rgb, spillFactor);
+
+        gl_FragColor = vec4(despilled, texel.a * alpha);
+      }
+    `,
+    transparent: true,
+    side: THREE.DoubleSide
+  });
+  material.userData[CHROMA_KEY_FLAG] = true;
+  return material;
+}
+__name(createWebglChromaKeyMaterial, "createWebglChromaKeyMaterial");
+function updateWebglChromaKeyMaterial(material, options) {
+  if (!(material instanceof THREE.ShaderMaterial)) return false;
+  const { keyColor, similarity, smoothness, spill } = material.uniforms;
+  if (!keyColor || !similarity || !smoothness || !spill) return false;
+  keyColor.value.set(options.keyColor);
+  similarity.value = options.similarity;
+  smoothness.value = options.smoothness;
+  spill.value = options.spill;
+  return true;
+}
+__name(updateWebglChromaKeyMaterial, "updateWebglChromaKeyMaterial");
+var areaLightTablesRequested = false;
+function prepareWebglAreaLights() {
+  if (areaLightTablesRequested) return;
+  areaLightTablesRequested = true;
+  import('three/examples/jsm/lights/RectAreaLightUniformsLib.js').then(
+    ({ RectAreaLightUniformsLib }) => {
+      RectAreaLightUniformsLib.init();
+    },
+    (error) => {
+      areaLightTablesRequested = false;
+      console.warn("[spatial-ecs] Could not load the area light tables.", error);
+    }
+  );
+}
+__name(prepareWebglAreaLights, "prepareWebglAreaLights");
+var webglBackend = {
+  kind: "webgl",
+  prepareAreaLights: prepareWebglAreaLights,
+  createPostprocessing: createWebglPostprocessing,
+  createChromaKeyMaterial: createWebglChromaKeyMaterial,
+  updateChromaKeyMaterial: updateWebglChromaKeyMaterial
+};
+
+// core/render/RenderBackend.ts
+function getRendererKindOf(renderer) {
+  return renderer?.isWebGPURenderer === true ? "webgpu" : "webgl";
+}
+__name(getRendererKindOf, "getRendererKindOf");
+function readWorldRendererKind(world) {
+  const candidate = world;
+  if (typeof candidate?.getRendererKind === "function") {
+    return candidate.getRendererKind();
+  }
+  if (typeof candidate?.getRenderer === "function") {
+    try {
+      return getRendererKindOf(candidate.getRenderer());
+    } catch {
+      return "webgl";
+    }
+  }
+  return "webgl";
+}
+__name(readWorldRendererKind, "readWorldRendererKind");
+var unsupportedWebGpuFallbackBackend = {
+  kind: "webgpu",
+  createPostprocessing: /* @__PURE__ */ __name(() => null, "createPostprocessing"),
+  createChromaKeyMaterial: /* @__PURE__ */ __name((texture) => new THREE.MeshBasicMaterial({
+    map: texture,
+    transparent: true,
+    side: THREE.DoubleSide
+  }), "createChromaKeyMaterial"),
+  updateChromaKeyMaterial: /* @__PURE__ */ __name(() => false, "updateChromaKeyMaterial")
+};
+
+// core/render/resolveBackend.ts
+var warnedRenderers = /* @__PURE__ */ new WeakSet();
+function warnOnce(renderer, message) {
+  if (warnedRenderers.has(renderer)) return;
+  warnedRenderers.add(renderer);
+  console.warn(message);
+}
+__name(warnOnce, "warnOnce");
+function resolveRenderBackend(renderer, requested) {
+  const kind = getRendererKindOf(renderer);
+  const backend = requested ?? webglBackend;
+  if (backend.kind === kind) return backend;
+  if (kind === "webgpu") {
+    warnOnce(
+      renderer,
+      "[spatial-ecs] This World has a WebGPURenderer but no WebGPU backend, so post-processing, green-screen keying and area lights are off. Pass `backend: webgpuBackend` from '@relu-interactives/spatial-ecs/webgpu'."
+    );
+    return unsupportedWebGpuFallbackBackend;
+  }
+  warnOnce(
+    renderer,
+    "[spatial-ecs] The WebGPU backend was passed with a WebGLRenderer; using the WebGL backend instead. Use `new WebGPURenderer()` from 'three/webgpu' to render with WebGPU."
+  );
+  return webglBackend;
+}
+__name(resolveRenderBackend, "resolveRenderBackend");
+function readWorldRenderBackend(world) {
+  const getter = world?.getRenderBackend;
+  if (typeof getter === "function") {
+    const backend = getter.call(world);
+    if (backend) return backend;
+  }
+  return webglBackend;
+}
+__name(readWorldRenderBackend, "readWorldRenderBackend");
+
+export { getRendererKindOf, readWorldRenderBackend, readWorldRendererKind, resolveRenderBackend, webglBackend };
+//# sourceMappingURL=chunk-OHCNPPMX.js.map
+//# sourceMappingURL=chunk-OHCNPPMX.js.map

package/dist/chunk-OHCNPPMX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../core/render/webglBackend.ts","../core/render/RenderBackend.ts","../core/render/fallbackBackend.ts","../core/render/resolveBackend.ts"],"names":["THREE2"],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,IAAM,gBAAA,GAAmB;AAAA,EACvB,IAAA,EAAM,kBAAA;AAAA,EACN,QAAA,EAAU;AAAA,IACR,QAAA,EAAU,EAAE,KAAA,EAAO,IAAA,EAA6B;AAAA,IAChD,YAAY,EAAE,KAAA,EAAO,IAAU,KAAA,CAAA,OAAA,CAAQ,CAAA,EAAG,CAAC,CAAA,EAAE;AAAA,IAC7C,SAAA,EAAW,EAAE,KAAA,EAAO,CAAA;AAAE,GACxB;AAAA,EACA,YAAA;AAAA;AAAA,IAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAAA,GAAA;AAAA,EAOzB,cAAA;AAAA;AAAA,IAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAAA;AAW7B,CAAA;AAOA,IAAM,eAAA,GAAN,MAAM,eAAA,SAAuB,UAAA,CAAW;AAAA,EAItC,WAAA,CAAY,aAAqB,aAAA,EAA6B;AAC5D,IAAA,KAAA,CAAM,gBAAgB,CAAA;AACtB,IAAA,IAAA,CAAK,WAAA,GAAc,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,WAAW,CAAA;AAC1C,IAAA,IAAA,CAAK,aAAA,GAAgB,aAAA;AACrB,IAAA,IAAA,CAAK,eAAA,EAAgB;AAAA,EACvB;AAAA,EAEQ,eAAA,GAAwB;AAC9B,IAAA,MAAM,OAAA,GAAU,KAAK,QAAA,CAAS,SAAA;AAC9B,IAAA,IAAI,OAAA,EAAS;AAEX,MAAA,OAAA,CAAQ,KAAA,GAAQ,KAAK,WAAA,GAAc,IAAA,CAAK,IAAI,CAAA,EAAG,IAAA,CAAK,eAAe,CAAA;AAAA,IACrE;AAAA,EACF;AAAA,EAEA,OAAA,CAAQ,OAAe,MAAA,EAAsB;AAC3C,IAAA,MAAM,UAAA,GAAa,KAAK,QAAA,CAAS,UAAA;AACjC,IAAA,IAAI,UAAA,EAAY;AACd,MAAC,UAAA,CAAW,KAAA,CAAwB,GAAA,CAAI,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,KAAK,CAAA,EAAG,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,MAAM,CAAC,CAAA;AAAA,IACjF;AACA,IAAA,IAAA,CAAK,eAAA,EAAgB;AAAA,EACvB;AACF,CAAA;AA1BwC,MAAA,CAAA,eAAA,EAAA,gBAAA,CAAA;AAAxC,IAAM,cAAA,GAAN,eAAA;AAsCA,SAAS,yBAAA,CAA0B;AAAA,EACjC,QAAA,EAAU,aAAA;AAAA,EACV,KAAA;AAAA,EACA,MAAA;AAAA,EACA;AACF,CAAA,EAAuD;AACrD,EAAA,MAAM,QAAA,GAAW,aAAA;AACjB,EAAA,MAAM,QAAA,GAAW,IAAI,cAAA,CAAe,QAAQ,CAAA;AAC5C,EAAA,QAAA,CAAS,OAAA,CAAQ,IAAI,UAAA,CAAW,KAAA,EAAO,MAAM,CAAC,CAAA;AAE9C,EAAA,IAAI,MAAA,CAAO,IAAI,OAAA,EAAS;AACtB,IAAA,QAAA,CAAS,OAAA;AAAA,MACP,IAAI,SAAA,CAAU,KAAA,EAAO,MAAA,EAAQ;AAAA,QAC3B,KAAA,EAAO,OAAO,GAAA,CAAI,aAAA;AAAA,QAClB,UAAU,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,MAAA,CAAO,IAAI,WAAW,CAAA;AAAA,QAC5C,SAAS,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,MAAA,CAAO,IAAI,UAAU;AAAA,OAC3C;AAAA,KACH;AAAA,EACF;AAEA,EAAA,IAAI,MAAA,CAAO,MAAM,OAAA,EAAS;AACxB,IAAA,MAAM,IAAA,GAAO,QAAA,CAAS,OAAA,CAAQ,IAAU,eAAS,CAAA;AACjD,IAAA,QAAA,CAAS,OAAA;AAAA,MACP,IAAI,eAAA;AAAA,QACF,IAAU,KAAA,CAAA,OAAA,CAAQ,IAAA,CAAK,KAAA,EAAO,KAAK,MAAM,CAAA;AAAA,QACzC,OAAO,KAAA,CAAM,SAAA;AAAA,QACb,OAAO,KAAA,CAAM,MAAA;AAAA,QACb,OAAO,KAAA,CAAM;AAAA;AACf,KACF;AAAA,EACF;AAEA,EAAA,IAAI,MAAA,CAAO,SAAS,OAAA,EAAS;AAC3B,IAAA,MAAM,IAAA,GAAO,IAAI,UAAA,CAAW,cAAc,CAAA;AAC1C,IAAA,MAAM,MAAA,GAAS,KAAK,QAAA,CAAS,MAAA;AAC7B,IAAA,MAAM,QAAA,GAAW,KAAK,QAAA,CAAS,QAAA;AAC/B,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,MAAA,CAAO,KAAA,GAAQ,OAAO,QAAA,CAAS,MAAA;AAAA,IACjC;AACA,IAAA,IAAI,QAAA,EAAU;AACZ,MAAA,QAAA,CAAS,KAAA,GAAQ,OAAO,QAAA,CAAS,QAAA;AAAA,IACnC;AACA,IAAA,QAAA,CAAS,QAAQ,IAAI,CAAA;AAAA,EACvB;AAEA,EAAA,IAAI,MAAA,CAAO,cAAc,OAAA,EAAS;AAChC,IAAA,MAAM,IAAA,GAAO,IAAI,UAAA,CAAW,mBAAmB,CAAA;AAC/C,IAAA,MAAM,GAAA,GAAM,KAAK,QAAA,CAAS,GAAA;AAC1B,IAAA,MAAM,UAAA,GAAa,KAAK,QAAA,CAAS,UAAA;AACjC,IAAA,IAAI,GAAA,EAAK;AACP,MAAA,GAAA,CAAI,KAAA,GAAQ,OAAO,aAAA,CAAc,GAAA;AAAA,IACnC;AACA,IAAA,IAAI,UAAA,EAAY;AACd,MAAA,UAAA,CAAW,KAAA,GAAQ,OAAO,aAAA,CAAc,UAAA;AAAA,IAC1C;AACA,IAAA,QAAA,CAAS,QAAQ,IAAI,CAAA;AAAA,EACvB;AAEA,EAAA,IAAI,MAAA,CAAO,MAAM,OAAA,EAAS;AACxB,IAAA,MAAM,IAAA,GAAO,IAAI,UAAA,CAAW,WAAW,CAAA;AACvC,IAAA,MAAM,MAAA,GAAS,KAAK,QAAA,CAAS,MAAA;AAC7B,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,MAAA,CAAO,KAAA,GAAQ,OAAO,KAAA,CAAM,SAAA;AAAA,IAC9B;AACA,IAAA,QAAA,CAAS,QAAQ,IAAI,CAAA;AAAA,EACvB;AAEA,EAAA,IAAI,MAAA,CAAO,MAAM,OAAA,EAAS;AACxB,IAAA,QAAA,CAAS,QAAQ,IAAI,QAAA,CAAS,MAAA,CAAO,KAAA,CAAM,OAAO,CAAC,CAAA;AAAA,EACrD;AAEA,EAAA,IAAI,MAAA,CAAO,UAAU,OAAA,EAAS;AAC5B,IAAA,QAAA,CAAS,OAAA;AAAA,MACP,IAAI,aAAA;AAAA,QACF,IAAU,KAAA,CAAA,OAAA,CAAQ,CAAA,EAAG,CAAC,CAAA;AAAA,QACtB,MAAA,CAAO,SAAA,CAAU,KAAA,IAAS,MAAA,CAAO,SAAA,CAAU,cAAA;AAAA,QAC3C,MAAA,CAAO,SAAA,CAAU,KAAA,IAAS,MAAA,CAAO,SAAA,CAAU;AAAA;AAC7C,KACF;AAAA,EACF;AAEA,EAAA,IAAI,MAAA,CAAO,KAAK,OAAA,EAAS;AACvB,IAAA,MAAM,IAAA,GAAO,IAAI,QAAA,CAAS,KAAA,EAAO,MAAM,CAAA;AACvC,IAAA,IAAA,CAAK,YAAA,GAAe,OAAO,IAAA,CAAK,MAAA;AAChC,IAAA,IAAA,CAAK,WAAA,GAAc,IAAA;AACnB,IAAA,IAAA,CAAK,cAAc,IAAA,CAAK,GAAA,CAAI,IAAA,EAAM,MAAA,CAAO,KAAK,SAAS,CAAA;AACvD,IAAA,QAAA,CAAS,QAAQ,IAAI,CAAA;AAAA,EACvB;AAEA,EAAA,IAAI,MAAA,CAAO,OAAO,OAAA,EAAS;AACzB,IAAA,MAAM,IAAA,GAAO,IAAI,UAAA,EAAW;AAC5B,IAAA,IAAA,CAAK,OAAA,GAAU,IAAA;AACf,IAAA,IAAA,CAAK,MAAA,GAAS,OAAA,CAAQ,MAAA,CAAO,MAAA,CAAO,MAAM,CAAA;AAC1C,IAAA,QAAA,CAAS,QAAQ,IAAI,CAAA;AAAA,EACvB;AAEA,EAAA,IAAI,MAAA,CAAO,gBAAgB,OAAA,EAAS;AAGlC,IAAA,MAAM,IAAA,GAAO,IAAI,UAAA,CAAW,cAAc,CAAA;AAC1C,IAAA,MAAM,EAAE,OAAA,EAAS,OAAA,EAAQ,GAAI,MAAA,CAAO,eAAA;AACpC,IAAA,MAAM,MAAA,GAAS,KAAK,QAAA,CAAS,MAAA;AAC7B,IAAA,MAAM,KAAA,GAAQ,KAAK,QAAA,CAAS,KAAA;AAC5B,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,MAAA,CAAO,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,OAAA,EAAS,OAAO,CAAA;AAAA,IAC5C;AACA,IAAA,IAAI,KAAA,EAAO;AACT,MAAA,KAAA,CAAM,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,OAAA,EAAS,OAAO,CAAA;AAAA,IAC3C;AACA,IAAA,QAAA,CAAS,QAAQ,IAAI,CAAA;AAAA,EACvB;AAEA,EAAA,IAAI,MAAA,CAAO,WAAW,OAAA,EAAS;AAC7B,IAAA,QAAA,CAAS,OAAA;AAAA,MACP,IAAI,cAAA;AAAA,QAAe,OAAO,UAAA,CAAW,WAAA;AAAA,QAAa,MAChD,OAAO,QAAA,CAAS,kBAAkB,UAAA,GAAa,QAAA,CAAS,eAAc,GAAI;AAAA;AAC5E,KACF;AAAA,EACF;AAEA,EAAA,IAAI,MAAA,CAAO,KAAK,OAAA,EAAS;AACvB,IAAA,QAAA,CAAS,OAAA,CAAQ,IAAI,QAAA,EAAU,CAAA;AAAA,EACjC;AAEA,EAAA,QAAA,CAAS,OAAA,CAAQ,IAAI,UAAA,EAAY,CAAA;AACjC,EAAA,OAAO,QAAA;AACT;AA9HS,MAAA,CAAA,yBAAA,EAAA,2BAAA,CAAA;AAkIT,IAAM,eAAA,GAAkB,cAAA;AAExB,SAAS,4BAAA,CACP,SACA,OAAA,EACsB;AACtB,EAAA,MAAM,QAAA,GAAW,IAAU,KAAA,CAAA,cAAA,CAAe;AAAA,IACxC,QAAA,EAAU;AAAA,MACR,GAAA,EAAK,EAAE,KAAA,EAAO,OAAA,EAAQ;AAAA,MACtB,UAAU,EAAE,KAAA,EAAO,IAAU,KAAA,CAAA,KAAA,CAAM,OAAA,CAAQ,QAAQ,CAAA,EAAE;AAAA,MACrD,UAAA,EAAY,EAAE,KAAA,EAAO,OAAA,CAAQ,UAAA,EAAW;AAAA,MACxC,UAAA,EAAY,EAAE,KAAA,EAAO,OAAA,CAAQ,UAAA,EAAW;AAAA,MACxC,KAAA,EAAO,EAAE,KAAA,EAAO,OAAA,CAAQ,KAAA;AAAM,KAChC;AAAA,IACA,YAAA,EAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA,CAAA;AAAA,IAOd,cAAA,EAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA,IAAA,CAAA;AAAA,IAmBhB,WAAA,EAAa,IAAA;AAAA,IACb,IAAA,EAAY,KAAA,CAAA;AAAA,GACb,CAAA;AACD,EAAA,QAAA,CAAS,QAAA,CAAS,eAAe,CAAA,GAAI,IAAA;AACrC,EAAA,OAAO,QAAA;AACT;AA3CS,MAAA,CAAA,4BAAA,EAAA,8BAAA,CAAA;AA6CT,SAAS,4BAAA,CACP,UACA,OAAA,EACS;AACT,EAAA,IAAI,EAAE,QAAA,YAA0B,KAAA,CAAA,cAAA,CAAA,EAAiB,OAAO,KAAA;AACxD,EAAA,MAAM,EAAE,QAAA,EAAU,UAAA,EAAY,UAAA,EAAY,KAAA,KAAU,QAAA,CAAS,QAAA;AAC7D,EAAA,IAAI,CAAC,YAAY,CAAC,UAAA,IAAc,CAAC,UAAA,IAAc,CAAC,OAAO,OAAO,KAAA;AAC9D,EAAC,QAAA,CAAS,KAAA,CAAsB,GAAA,CAAI,OAAA,CAAQ,QAAQ,CAAA;AACpD,EAAA,UAAA,CAAW,QAAQ,OAAA,CAAQ,UAAA;AAC3B,EAAA,UAAA,CAAW,QAAQ,OAAA,CAAQ,UAAA;AAC3B,EAAA,KAAA,CAAM,QAAQ,OAAA,CAAQ,KAAA;AACtB,EAAA,OAAO,IAAA;AACT;AAZS,MAAA,CAAA,4BAAA,EAAA,8BAAA,CAAA;AAgBT,IAAI,wBAAA,GAA2B,KAAA;AAS/B,SAAS,sBAAA,GAA+B;AACtC,EAAA,IAAI,wBAAA,EAA0B;AAC9B,EAAA,wBAAA,GAA2B,IAAA;AAC3B,EAAA,OAAO,uDAAuD,CAAA,CAAE,IAAA;AAAA,IAC9D,CAAC,EAAE,wBAAA,EAAyB,KAAM;AAChC,MAAA,wBAAA,CAAyB,IAAA,EAAK;AAAA,IAChC,CAAA;AAAA,IACA,CAAC,KAAA,KAAU;AACT,MAAA,wBAAA,GAA2B,KAAA;AAC3B,MAAA,OAAA,CAAQ,IAAA,CAAK,uDAAuD,KAAK,CAAA;AAAA,IAC3E;AAAA,GACF;AACF;AAZS,MAAA,CAAA,sBAAA,EAAA,wBAAA,CAAA;AAkBF,IAAM,YAAA,GAA8B;AAAA,EACzC,IAAA,EAAM,OAAA;AAAA,EACN,iBAAA,EAAmB,sBAAA;AAAA,EACnB,oBAAA,EAAsB,yBAAA;AAAA,EACtB,uBAAA,EAAyB,4BAAA;AAAA,EACzB,uBAAA,EAAyB;AAC3B;;;ACzNO,SAAS,kBAAkB,QAAA,EAAiC;AACjE,EAAA,OAAQ,QAAA,EACJ,gBAAA,KAAqB,IAAA,GACrB,QAAA,GACA,OAAA;AACN;AALgB,MAAA,CAAA,iBAAA,EAAA,mBAAA,CAAA;AAWT,SAAS,sBAAsB,KAAA,EAA8B;AAClE,EAAA,MAAM,SAAA,GAAY,KAAA;AAIlB,EAAA,IAAI,OAAO,SAAA,EAAW,eAAA,KAAoB,UAAA,EAAY;AACpD,IAAA,OAAO,UAAU,eAAA,EAAgB;AAAA,EACnC;AACA,EAAA,IAAI,OAAO,SAAA,EAAW,WAAA,KAAgB,UAAA,EAAY;AAChD,IAAA,IAAI;AACF,MAAA,OAAO,iBAAA,CAAkB,SAAA,CAAU,WAAA,EAAa,CAAA;AAAA,IAClD,CAAA,CAAA,MAAQ;AACN,MAAA,OAAO,OAAA;AAAA,IACT;AAAA,EACF;AACA,EAAA,OAAO,OAAA;AACT;AAhBgB,MAAA,CAAA,qBAAA,EAAA,uBAAA,CAAA;AChGT,IAAM,gCAAA,GAAkD;AAAA,EAC7D,IAAA,EAAM,QAAA;AAAA,EACN,oBAAA,+BAA4B,IAAA,EAAN,sBAAA,CAAA;AAAA,EACtB,uBAAA,kBAAyB,MAAA,CAAA,CAAC,OAAA,KACxB,IAAUA,KAAA,CAAA,iBAAA,CAAkB;AAAA,IAC1B,GAAA,EAAK,OAAA;AAAA,IACL,WAAA,EAAa,IAAA;AAAA,IACb,IAAA,EAAYA,KAAA,CAAA;AAAA,GACb,CAAA,EALsB,yBAAA,CAAA;AAAA,EAMzB,uBAAA,+BAA+B,KAAA,EAAN,yBAAA;AAC3B,CAAA;;;ACpBA,IAAM,eAAA,uBAAsB,OAAA,EAAgB;AAE5C,SAAS,QAAA,CAAS,UAAkB,OAAA,EAAuB;AACzD,EAAA,IAAI,eAAA,CAAgB,GAAA,CAAI,QAAQ,CAAA,EAAG;AACnC,EAAA,eAAA,CAAgB,IAAI,QAAQ,CAAA;AAC5B,EAAA,OAAA,CAAQ,KAAK,OAAO,CAAA;AACtB;AAJS,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA;AAeF,SAAS,oBAAA,CACd,UACA,SAAA,EACe;AACf,EAAA,MAAM,IAAA,GAAO,kBAAkB,QAAQ,CAAA;AACvC,EAAA,MAAM,UAAU,SAAA,IAAa,YAAA;AAC7B,EAAA,IAAI,OAAA,CAAQ,IAAA,KAAS,IAAA,EAAM,OAAO,OAAA;AAElC,EAAA,IAAI,SAAS,QAAA,EAAU;AACrB,IAAA,QAAA;AAAA,MACE,QAAA;AAAA,MACA;AAAA,KAGF;AACA,IAAA,OAAO,gCAAA;AAAA,EACT;AAEA,EAAA,QAAA;AAAA,IACE,QAAA;AAAA,IACA;AAAA,GAGF;AACA,EAAA,OAAO,YAAA;AACT;AAzBgB,MAAA,CAAA,oBAAA,EAAA,sBAAA,CAAA;AA+BT,SAAS,uBAAuB,KAAA,EAA+B;AACpE,EAAA,MAAM,SAAU,KAAA,EACZ,gBAAA;AACJ,EAAA,IAAI,OAAO,WAAW,UAAA,EAAY;AAChC,IAAA,MAAM,OAAA,GAAU,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA;AACjC,IAAA,IAAI,SAAS,OAAO,OAAA;AAAA,EACtB;AACA,EAAA,OAAO,YAAA;AACT;AARgB,MAAA,CAAA,sBAAA,EAAA,wBAAA,CAAA","file":"chunk-OHCNPPMX.js","sourcesContent":["import * as THREE from \"three\";\nimport { EffectComposer } from \"three/examples/jsm/postprocessing/EffectComposer.js\";\nimport { RenderPass } from \"three/examples/jsm/postprocessing/RenderPass.js\";\nimport { UnrealBloomPass } from \"three/examples/jsm/postprocessing/UnrealBloomPass.js\";\nimport { DotScreenPass } from \"three/examples/jsm/postprocessing/DotScreenPass.js\";\nimport { GlitchPass } from \"three/examples/jsm/postprocessing/GlitchPass.js\";\nimport { FilmPass } from \"three/examples/jsm/postprocessing/FilmPass.js\";\nimport { BokehPass } from \"three/examples/jsm/postprocessing/BokehPass.js\";\nimport { SSAOPass } from \"three/examples/jsm/postprocessing/SSAOPass.js\";\nimport { ShaderPass } from \"three/examples/jsm/postprocessing/ShaderPass.js\";\nimport { OutputPass } from \"three/examples/jsm/postprocessing/OutputPass.js\";\nimport { SMAAPass } from \"three/examples/jsm/postprocessing/SMAAPass.js\";\nimport { HueSaturationShader } from \"three/examples/jsm/shaders/HueSaturationShader.js\";\nimport { RGBShiftShader } from \"three/examples/jsm/shaders/RGBShiftShader.js\";\nimport { SepiaShader } from \"three/examples/jsm/shaders/SepiaShader.js\";\nimport { VignetteShader } from \"three/examples/jsm/shaders/VignetteShader.js\";\n\nimport type {\n  ChromaKeyOptions,\n  PostprocessingBuildContext,\n  PostprocessingPipeline,\n  RenderBackend,\n} from \"./RenderBackend\";\n\n/** Mosaic shader: samples the centre of each `pixelSize`-texel block. */\nconst PixelationShader = {\n  name: \"PixelationShader\",\n  uniforms: {\n    tDiffuse: { value: null as THREE.Texture | null },\n    resolution: { value: new THREE.Vector2(1, 1) },\n    pixelSize: { value: 6 },\n  },\n  vertexShader: /* glsl */ `\n    varying vec2 vUv;\n    void main() {\n      vUv = uv;\n      gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n    }\n  `,\n  fragmentShader: /* glsl */ `\n    uniform sampler2D tDiffuse;\n    uniform vec2 resolution;\n    uniform float pixelSize;\n    varying vec2 vUv;\n    void main() {\n      vec2 block = max(pixelSize, 1.0) / resolution;\n      vec2 coord = block * (floor(vUv / block) + 0.5);\n      gl_FragColor = texture2D(tDiffuse, coord);\n    }\n  `,\n};\n\n/**\n * Full-screen pixelation. A post pass rather than `RenderPixelatedPass` so it\n * pixelates whatever the chain produced so far and costs one texture fetch per\n * pixel instead of an extra scene + normals render.\n */\nclass PixelationPass extends ShaderPass {\n  private readonly granularity: number;\n  private readonly getPixelRatio: () => number;\n\n  constructor(granularity: number, getPixelRatio: () => number) {\n    super(PixelationShader);\n    this.granularity = Math.max(1, granularity);\n    this.getPixelRatio = getPixelRatio;\n    this.updatePixelSize();\n  }\n\n  private updatePixelSize(): void {\n    const uniform = this.uniforms.pixelSize;\n    if (uniform) {\n      // `granularity` is in CSS pixels; the composer works in device pixels.\n      uniform.value = this.granularity * Math.max(1, this.getPixelRatio());\n    }\n  }\n\n  setSize(width: number, height: number): void {\n    const resolution = this.uniforms.resolution;\n    if (resolution) {\n      (resolution.value as THREE.Vector2).set(Math.max(1, width), Math.max(1, height));\n    }\n    this.updatePixelSize();\n  }\n}\n\n/**\n * Build the WebGL `EffectComposer` for `values`.\n *\n * Pass order: scene render → depth of field → bloom → vignette →\n * hue/saturation → sepia → film noise → dot screen → SSAO → glitch →\n * chromatic aberration → pixelation → SMAA → output (tone mapping + sRGB).\n *\n * The returned object IS the `EffectComposer`, so scripts that read\n * `scene.userData.ecsPostprocessingComposer.passes` keep working.\n */\nfunction createWebglPostprocessing({\n  renderer: rendererInput,\n  scene,\n  camera,\n  values,\n}: PostprocessingBuildContext): PostprocessingPipeline {\n  const renderer = rendererInput as THREE.WebGLRenderer;\n  const composer = new EffectComposer(renderer);\n  composer.addPass(new RenderPass(scene, camera));\n\n  if (values.dof.enabled) {\n    composer.addPass(\n      new BokehPass(scene, camera, {\n        focus: values.dof.focusDistance,\n        aperture: Math.max(0, values.dof.focalLength),\n        maxblur: Math.max(0, values.dof.bokehScale),\n      }),\n    );\n  }\n\n  if (values.bloom.enabled) {\n    const size = renderer.getSize(new THREE.Vector2());\n    composer.addPass(\n      new UnrealBloomPass(\n        new THREE.Vector2(size.width, size.height),\n        values.bloom.intensity,\n        values.bloom.radius,\n        values.bloom.threshold,\n      ),\n    );\n  }\n\n  if (values.vignette.enabled) {\n    const pass = new ShaderPass(VignetteShader);\n    const offset = pass.uniforms.offset;\n    const darkness = pass.uniforms.darkness;\n    if (offset) {\n      offset.value = values.vignette.offset;\n    }\n    if (darkness) {\n      darkness.value = values.vignette.darkness;\n    }\n    composer.addPass(pass);\n  }\n\n  if (values.hueSaturation.enabled) {\n    const pass = new ShaderPass(HueSaturationShader);\n    const hue = pass.uniforms.hue;\n    const saturation = pass.uniforms.saturation;\n    if (hue) {\n      hue.value = values.hueSaturation.hue;\n    }\n    if (saturation) {\n      saturation.value = values.hueSaturation.saturation;\n    }\n    composer.addPass(pass);\n  }\n\n  if (values.sepia.enabled) {\n    const pass = new ShaderPass(SepiaShader);\n    const amount = pass.uniforms.amount;\n    if (amount) {\n      amount.value = values.sepia.intensity;\n    }\n    composer.addPass(pass);\n  }\n\n  if (values.noise.enabled) {\n    composer.addPass(new FilmPass(values.noise.opacity));\n  }\n\n  if (values.dotScreen.enabled) {\n    composer.addPass(\n      new DotScreenPass(\n        new THREE.Vector2(0, 0),\n        values.dotScreen.angle ?? values.dotScreen.dotScreenAngle,\n        values.dotScreen.scale ?? values.dotScreen.dotScreenScale,\n      ),\n    );\n  }\n\n  if (values.ssao.enabled) {\n    const pass = new SSAOPass(scene, camera);\n    pass.kernelRadius = values.ssao.radius;\n    pass.minDistance = 0.001;\n    pass.maxDistance = Math.max(0.01, values.ssao.intensity);\n    composer.addPass(pass);\n  }\n\n  if (values.glitch.enabled) {\n    const pass = new GlitchPass();\n    pass.enabled = true;\n    pass.goWild = Boolean(values.glitch.active);\n    composer.addPass(pass);\n  }\n\n  if (values.chromAberration.enabled) {\n    // RGBShift offsets red by +amount and blue by -amount along `angle`, so\n    // the authored (x, y) offset maps to its length and direction.\n    const pass = new ShaderPass(RGBShiftShader);\n    const { offsetX, offsetY } = values.chromAberration;\n    const amount = pass.uniforms.amount;\n    const angle = pass.uniforms.angle;\n    if (amount) {\n      amount.value = Math.hypot(offsetX, offsetY);\n    }\n    if (angle) {\n      angle.value = Math.atan2(offsetY, offsetX);\n    }\n    composer.addPass(pass);\n  }\n\n  if (values.pixelation.enabled) {\n    composer.addPass(\n      new PixelationPass(values.pixelation.granularity, () =>\n        typeof renderer.getPixelRatio === \"function\" ? renderer.getPixelRatio() : 1,\n      ),\n    );\n  }\n\n  if (values.smaa.enabled) {\n    composer.addPass(new SMAAPass());\n  }\n\n  composer.addPass(new OutputPass());\n  return composer;\n}\n\n// ── Chroma key ────────────────────────────────────────────────────────────\n\nconst CHROMA_KEY_FLAG = \"ecsChromaKey\";\n\nfunction createWebglChromaKeyMaterial(\n  texture: THREE.Texture,\n  options: ChromaKeyOptions,\n): THREE.ShaderMaterial {\n  const material = new THREE.ShaderMaterial({\n    uniforms: {\n      tex: { value: texture },\n      keyColor: { value: new THREE.Color(options.keyColor) },\n      similarity: { value: options.similarity },\n      smoothness: { value: options.smoothness },\n      spill: { value: options.spill },\n    },\n    vertexShader: `\n      varying vec2 vUv;\n      void main() {\n        vUv = uv;\n        gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n      }\n    `,\n    fragmentShader: `\n      uniform sampler2D tex;\n      uniform vec3 keyColor;\n      uniform float similarity;\n      uniform float smoothness;\n      uniform float spill;\n      varying vec2 vUv;\n\n      void main() {\n        vec4 texel = texture2D(tex, vUv);\n        float chromaDist = distance(texel.rgb, keyColor);\n        float alpha = smoothstep(similarity, similarity + smoothness, chromaDist);\n\n        float spillFactor = smoothstep(similarity, similarity + spill + smoothness, chromaDist);\n        vec3 despilled = mix(vec3(dot(texel.rgb, vec3(0.299, 0.587, 0.114))), texel.rgb, spillFactor);\n\n        gl_FragColor = vec4(despilled, texel.a * alpha);\n      }\n    `,\n    transparent: true,\n    side: THREE.DoubleSide,\n  });\n  material.userData[CHROMA_KEY_FLAG] = true;\n  return material;\n}\n\nfunction updateWebglChromaKeyMaterial(\n  material: THREE.Material,\n  options: ChromaKeyOptions,\n): boolean {\n  if (!(material instanceof THREE.ShaderMaterial)) return false;\n  const { keyColor, similarity, smoothness, spill } = material.uniforms;\n  if (!keyColor || !similarity || !smoothness || !spill) return false;\n  (keyColor.value as THREE.Color).set(options.keyColor);\n  similarity.value = options.similarity;\n  smoothness.value = options.smoothness;\n  spill.value = options.spill;\n  return true;\n}\n\n// ── Area lights ───────────────────────────────────────────────────────────\n\nlet areaLightTablesRequested = false;\n\n/**\n * `RectAreaLight` shading needs lookup tables in `UniformsLib`; without them\n * area lights render black. The tables are ~300 KB of source, so they load on\n * demand the first time an area light is created rather than with every\n * WebGL bundle. WebGL reads them at render time, so a light created before\n * the import resolves lights up on the next frame.\n */\nfunction prepareWebglAreaLights(): void {\n  if (areaLightTablesRequested) return;\n  areaLightTablesRequested = true;\n  import(\"three/examples/jsm/lights/RectAreaLightUniformsLib.js\").then(\n    ({ RectAreaLightUniformsLib }) => {\n      RectAreaLightUniformsLib.init();\n    },\n    (error) => {\n      areaLightTablesRequested = false;\n      console.warn(\"[spatial-ecs] Could not load the area light tables.\", error);\n    },\n  );\n}\n\n/**\n * The default {@link RenderBackend}: three's `WebGLRenderer`, post-processing\n * through `EffectComposer`, GLSL chroma key.\n */\nexport const webglBackend: RenderBackend = {\n  kind: \"webgl\",\n  prepareAreaLights: prepareWebglAreaLights,\n  createPostprocessing: createWebglPostprocessing,\n  createChromaKeyMaterial: createWebglChromaKeyMaterial,\n  updateChromaKeyMaterial: updateWebglChromaKeyMaterial,\n};\n","import type * as THREE from \"three\";\n// Type-only: the default entry must never load `three/webgpu` at runtime.\nimport type { WebGPURenderer } from \"three/webgpu\";\n\nimport type { PostprocessingState } from \"../components/Postprocessing\";\nimport type { World } from \"../World\";\n\n/**\n * A renderer a {@link World} can run on: three's classic `WebGLRenderer`, or\n * `WebGPURenderer` from `three/webgpu` (which falls back to WebGL 2 on its own\n * when the browser has no WebGPU).\n */\nexport type EcsRenderer = THREE.WebGLRenderer | WebGPURenderer;\n\n/** Which renderer family a world is drawing with. */\nexport type RendererKind = \"webgl\" | \"webgpu\";\n\n/**\n * A built post-processing chain. `RenderSystem` calls `render()` in place of\n * `renderer.render()` while it is active.\n *\n * `setSize` / `setPixelRatio` are optional: a WebGL `EffectComposer` needs\n * them, while a WebGPU `RenderPipeline` reads the renderer's size every frame.\n */\nexport interface PostprocessingPipeline {\n  render(): void;\n  setSize?(width: number, height: number): void;\n  setPixelRatio?(pixelRatio: number): void;\n  dispose(): void;\n}\n\n/** Everything a backend needs to build a post-processing chain. */\nexport interface PostprocessingBuildContext {\n  renderer: EcsRenderer;\n  scene: THREE.Scene;\n  camera: THREE.PerspectiveCamera;\n  /** The scene's current `Postprocessing.values` (`postEnabled` is `true`). */\n  values: PostprocessingState;\n  /** The world being rendered, when known (used to scope one-time warnings). */\n  world?: World;\n}\n\n/** Green-screen settings, in the same units as `VideoComponent.options`. */\nexport interface ChromaKeyOptions {\n  /** Colour to key out (any three.js colour representation, e.g. `\"#00ff00\"`). */\n  keyColor: THREE.ColorRepresentation;\n  /** Colour distance below which a pixel is fully transparent. */\n  similarity: number;\n  /** Width of the soft edge above `similarity`. */\n  smoothness: number;\n  /** How far past the edge the key colour is desaturated (spill removal). */\n  spill: number;\n}\n\n/**\n * Everything renderer-specific the engine does, behind one small interface so\n * a {@link World} can run on WebGL or WebGPU.\n *\n * The default is `webglBackend` (exported from the package root). For a\n * `WebGPURenderer`, pass `webgpuBackend` from\n * `@relu-interactives/spatial-ecs/webgpu`.\n */\nexport interface RenderBackend {\n  /** Renderer family this backend drives. */\n  readonly kind: RendererKind;\n  /** One-time renderer setup, called once from the `World` constructor. */\n  install?(world: World): void;\n  /**\n   * Called the first time an area light (`RectAreaLight`) is created, so the\n   * backend can load the lookup tables those lights need. Optional.\n   */\n  prepareAreaLights?(world: World): void;\n  /**\n   * Build the post-processing chain for `context.values`. Return `null` to\n   * render the scene directly (no chain).\n   */\n  createPostprocessing(\n    context: PostprocessingBuildContext,\n  ): PostprocessingPipeline | null;\n  /**\n   * Apply a values change to an existing chain without rebuilding it. Return\n   * `true` when the chain was updated in place, `false` when the change is\n   * structural (an effect switched on or off) and the caller must rebuild.\n   * When omitted, every change rebuilds.\n   */\n  updatePostprocessing?(\n    pipeline: PostprocessingPipeline,\n    previous: PostprocessingState,\n    next: PostprocessingState,\n  ): boolean;\n  /** Material that renders `texture` with `options.keyColor` keyed out. */\n  createChromaKeyMaterial(\n    texture: THREE.Texture,\n    options: ChromaKeyOptions,\n  ): THREE.Material;\n  /**\n   * Push new options into a material made by {@link createChromaKeyMaterial}.\n   * Returns `false` when `material` is not one of this backend's chroma-key\n   * materials.\n   */\n  updateChromaKeyMaterial(material: THREE.Material, options: ChromaKeyOptions): boolean;\n}\n\n/** `\"webgpu\"` for a `WebGPURenderer`, otherwise `\"webgl\"`. */\nexport function getRendererKindOf(renderer: unknown): RendererKind {\n  return (renderer as { isWebGPURenderer?: unknown } | null | undefined)\n    ?.isWebGPURenderer === true\n    ? \"webgpu\"\n    : \"webgl\";\n}\n\n/**\n * The renderer kind of `world`, tolerating partial worlds (test doubles and\n * worlds from older builds without `getRendererKind`).\n */\nexport function readWorldRendererKind(world: unknown): RendererKind {\n  const candidate = world as {\n    getRendererKind?: () => RendererKind;\n    getRenderer?: () => unknown;\n  } | null;\n  if (typeof candidate?.getRendererKind === \"function\") {\n    return candidate.getRendererKind();\n  }\n  if (typeof candidate?.getRenderer === \"function\") {\n    try {\n      return getRendererKindOf(candidate.getRenderer());\n    } catch {\n      return \"webgl\";\n    }\n  }\n  return \"webgl\";\n}\n","import * as THREE from \"three\";\n\nimport type { RenderBackend } from \"./RenderBackend\";\n\n/**\n * What a `World` uses when it is handed a `WebGPURenderer` but no WebGPU\n * backend. Nothing here may touch WebGL-only APIs (`EffectComposer`, GLSL\n * `ShaderMaterial`), and the default entry may not import `three/webgpu`, so\n * it does the safe minimum:\n *\n * - no post-processing (the scene renders directly; tone mapping from\n *   `Environment`/`Postprocessing` still applies through the renderer),\n * - green-screen videos play un-keyed through a plain `MeshBasicMaterial`,\n *   which `WebGPURenderer` converts to a node material by itself.\n *\n * Area lights need lookup tables that only the WebGPU backend installs, so\n * they cannot render here either. Pass `webgpuBackend` from\n * `@relu-interactives/spatial-ecs/webgpu` to get all of it.\n */\nexport const unsupportedWebGpuFallbackBackend: RenderBackend = {\n  kind: \"webgpu\",\n  createPostprocessing: () => null,\n  createChromaKeyMaterial: (texture) =>\n    new THREE.MeshBasicMaterial({\n      map: texture,\n      transparent: true,\n      side: THREE.DoubleSide,\n    }),\n  updateChromaKeyMaterial: () => false,\n};\n","import { unsupportedWebGpuFallbackBackend } from \"./fallbackBackend\";\nimport {\n  getRendererKindOf,\n  type EcsRenderer,\n  type RenderBackend,\n} from \"./RenderBackend\";\nimport { webglBackend } from \"./webglBackend\";\n\n/** Renderers already warned about, so each mismatch is reported once. */\nconst warnedRenderers = new WeakSet<object>();\n\nfunction warnOnce(renderer: object, message: string): void {\n  if (warnedRenderers.has(renderer)) return;\n  warnedRenderers.add(renderer);\n  console.warn(message);\n}\n\n/**\n * Pick the backend a world runs with. `requested` wins when it matches the\n * renderer. A mismatch is warned about once per renderer and resolved to\n * something that cannot crash:\n *\n * - `WebGPURenderer` without a WebGPU backend → no post-processing,\n *   un-keyed green screen (never `EffectComposer` or GLSL on WebGPU).\n * - `WebGLRenderer` with a WebGPU backend → the WebGL backend.\n */\nexport function resolveRenderBackend(\n  renderer: EcsRenderer,\n  requested: RenderBackend | undefined,\n): RenderBackend {\n  const kind = getRendererKindOf(renderer);\n  const backend = requested ?? webglBackend;\n  if (backend.kind === kind) return backend;\n\n  if (kind === \"webgpu\") {\n    warnOnce(\n      renderer,\n      \"[spatial-ecs] This World has a WebGPURenderer but no WebGPU backend, so \" +\n        \"post-processing, green-screen keying and area lights are off. Pass \" +\n        \"`backend: webgpuBackend` from '@relu-interactives/spatial-ecs/webgpu'.\",\n    );\n    return unsupportedWebGpuFallbackBackend;\n  }\n\n  warnOnce(\n    renderer,\n    \"[spatial-ecs] The WebGPU backend was passed with a WebGLRenderer; using \" +\n      \"the WebGL backend instead. Use `new WebGPURenderer()` from 'three/webgpu' \" +\n      \"to render with WebGPU.\",\n  );\n  return webglBackend;\n}\n\n/**\n * The backend of `world`, tolerating partial worlds (test doubles) by falling\n * back to the WebGL backend.\n */\nexport function readWorldRenderBackend(world: unknown): RenderBackend {\n  const getter = (world as { getRenderBackend?: () => RenderBackend } | null)\n    ?.getRenderBackend;\n  if (typeof getter === \"function\") {\n    const backend = getter.call(world);\n    if (backend) return backend;\n  }\n  return webglBackend;\n}\n"]}