@babylonjs/lite 0.1.1 → 0.2.0

package/{index-C8HOR2sB.js → index-B7Qhw0xL.js}

@@ -1,6 +1,16 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function _defaultAllocate() {
+  return new Float32Array(16);
+}
+let _allocate;
+function allocateMat4() {
+  return (_allocate ?? _defaultAllocate)();
+}
+function _setHpmAllocator(allocate) {
+  _allocate = allocate;
+}
 const VERSION = "0.1.0";
 let _vis = 0;
 function bumpVisibilityEpoch() {
@@ -56,6 +66,25 @@ async function createEngine(canvas, options) {
     canvas.setAttribute("data-engine", versionToLog);
   }
   const msaaSamples = (options == null ? void 0 : options.msaaSamples) === 1 ? 1 : 4;
+  const useHpm = (options == null ? void 0 : options.useHighPrecisionMatrix) === true;
+  const useFO = (options == null ? void 0 : options.useFloatingOrigin) === true;
+  if (useFO && !useHpm) {
+    throw new Error("Babylon Lite: useFloatingOrigin requires useHighPrecisionMatrix on the engine.");
+  }
+  if (useHpm) {
+    const { allocateF64Mat4 } = await import("./_mat4-storage-f64-Bvh5TymE.js");
+    _setHpmAllocator(allocateF64Mat4);
+  }
+  let _wrapRenderableForFO;
+  let _makePackMeshWorld;
+  if (useFO) {
+    const [{ wrapRenderableForFO: wrapRenderableForFO2 }, { makePackMeshWorld }] = await Promise.all([
+      Promise.resolve().then(() => floatingOrigin),
+      import("./pack-mat4-with-offset-BqB8Jqo7.js")
+    ]);
+    _wrapRenderableForFO = wrapRenderableForFO2;
+    _makePackMeshWorld = makePackMeshWorld;
+  }
   const engine = {
     _device: device,
     _context: context,
@@ -64,6 +93,8 @@ async function createEngine(canvas, options) {
     canvas,
     msaaSamples,
     drawCallCount: 0,
+    useHighPrecisionMatrix: useHpm,
+    useFloatingOrigin: useFO,
     maxDevicePixelRatio: (options == null ? void 0 : options.maxDevicePixelRatio) ?? Infinity,
     _animFrameId: 0,
     _renderFn: null,
@@ -71,7 +102,9 @@ async function createEngine(canvas, options) {
     _currentEncoder: void 0,
     _swapchainView: void 0,
     _currentDelta: 0,
-    _cbs: []
+    _cbs: [],
+    _wrapRenderableForFO,
+    _makePackMeshWorld
   };
   resizeEngine(engine);
   return engine;
@@ -287,7 +320,9 @@ function disposeRenderTarget(rt) {
     rt._colorView = null;
   }
   if (rt._depthTexture) {
-    rt._depthTexture.destroy();
+    if (rt._ownsDepthTexture !== false) {
+      rt._depthTexture.destroy();
+    }
     rt._depthTexture = null;
     rt._depthView = null;
   }
@@ -346,14 +381,15 @@ function mat4PerspectiveLHToRef(out, fov, aspect, near, far) {
 }
 function getViewMatrix(camera) {
   const ver = camera.worldMatrixVersion;
-  if (camera._viewVer === ver && camera._viewCache) {
+  if (camera._viewVer === ver) {
     return camera._viewCache;
   }
-  if (!camera._viewCache) {
-    camera._viewCache = new Float32Array(16);
-  }
   const v = camera._viewCache;
   const w = camera.worldMatrix;
+  const useFO = camera._useFloatingOrigin;
+  const cx = useFO ? 0 : w[12];
+  const cy = useFO ? 0 : w[13];
+  const cz = useFO ? 0 : w[14];
   v[0] = w[0];
   v[1] = w[4];
   v[2] = w[8];
@@ -366,38 +402,34 @@ function getViewMatrix(camera) {
   v[9] = w[6];
   v[10] = w[10];
   v[11] = 0;
-  v[12] = -(w[0] * w[12] + w[1] * w[13] + w[2] * w[14]);
-  v[13] = -(w[4] * w[12] + w[5] * w[13] + w[6] * w[14]);
-  v[14] = -(w[8] * w[12] + w[9] * w[13] + w[10] * w[14]);
+  v[12] = -(w[0] * cx + w[1] * cy + w[2] * cz);
+  v[13] = -(w[4] * cx + w[5] * cy + w[6] * cz);
+  v[14] = -(w[8] * cx + w[9] * cy + w[10] * cz);
   v[15] = 1;
   camera._viewVer = ver;
   return v;
 }
 function getProjectionMatrix(camera, aspectRatio) {
   const ver = camera.worldMatrixVersion;
-  if (camera._projVer === ver && camera._projAspect === aspectRatio && camera._projCache) {
+  if (camera._projVer === ver && camera._projAspect === aspectRatio) {
     return camera._projCache;
   }
-  if (!camera._projCache) {
-    camera._projCache = new Float32Array(16);
-  }
-  mat4PerspectiveLHToRef(camera._projCache, camera.fov, aspectRatio, camera.nearPlane, camera.farPlane);
+  const p = camera._projCache;
+  mat4PerspectiveLHToRef(p, camera.fov, aspectRatio, camera.nearPlane, camera.farPlane);
   camera._projVer = ver;
   camera._projAspect = aspectRatio;
-  return camera._projCache;
+  return p;
 }
 function getViewProjectionMatrix(camera, aspectRatio) {
   const ver = camera.worldMatrixVersion;
-  if (camera._vpVer === ver && camera._vpAspect === aspectRatio && camera._vpCache) {
+  if (camera._vpVer === ver && camera._vpAspect === aspectRatio) {
     return camera._vpCache;
   }
-  if (!camera._vpCache) {
-    camera._vpCache = new Float32Array(16);
-  }
-  mat4MultiplyInto(camera._vpCache, 0, getProjectionMatrix(camera, aspectRatio), 0, getViewMatrix(camera), 0);
+  const vp = camera._vpCache;
+  mat4MultiplyInto(vp, 0, getProjectionMatrix(camera, aspectRatio), 0, getViewMatrix(camera), 0);
   camera._vpVer = ver;
   camera._vpAspect = aspectRatio;
-  return camera._vpCache;
+  return vp;
 }
 function getCameraPosition(camera) {
   const w = camera.worldMatrix;
@@ -444,6 +476,31 @@ function createDefaultPipelineDescriptor(opts) {
     primitive: { topology: "triangle-list", cullMode: opts._cullMode ?? "back", frontFace: opts._flipY ? "cw" : "ccw" }
   };
 }
+function packMat4IntoF32(view, mat, offsetFloats = 0, srcOffsetFloats = 0) {
+  const src = mat;
+  if (srcOffsetFloats === 0 && src.length === 16) {
+    view.set(src, offsetFloats);
+    return;
+  }
+  const s = srcOffsetFloats;
+  const o = offsetFloats;
+  view[o + 0] = src[s + 0];
+  view[o + 1] = src[s + 1];
+  view[o + 2] = src[s + 2];
+  view[o + 3] = src[s + 3];
+  view[o + 4] = src[s + 4];
+  view[o + 5] = src[s + 5];
+  view[o + 6] = src[s + 6];
+  view[o + 7] = src[s + 7];
+  view[o + 8] = src[s + 8];
+  view[o + 9] = src[s + 9];
+  view[o + 10] = src[s + 10];
+  view[o + 11] = src[s + 11];
+  view[o + 12] = src[s + 12];
+  view[o + 13] = src[s + 13];
+  view[o + 14] = src[s + 14];
+  view[o + 15] = src[s + 15];
+}
 function align(n, to) {
   return n + to - 1 & ~(to - 1);
 }
@@ -688,6 +745,9 @@ function createRenderTask(config, engine, scene) {
   return task;
 }
 function removeMeshFromTask(task, mesh) {
+  if (!task._renderables) {
+    return;
+  }
   let removed = false;
   for (let i = task._renderables.length - 1; i >= 0; i--) {
     if (task._renderables[i].mesh === mesh) {
@@ -855,7 +915,7 @@ function executePassBody(task, pass) {
       sampleCount: desc.sampleCount ?? 1
     });
     be.setBindGroup(0, sceneBG);
-    drawList(be, opaqueBindings, eng);
+    drawList$1(be, opaqueBindings, eng);
     opaqueBundles[0] = be.finish();
     task._lastVersion = scene._renderableVersion;
     task._lastVis = _vis;
@@ -863,8 +923,8 @@ function executePassBody(task, pass) {
   let draws = opaqueBindings.length;
   pass.executeBundles(opaqueBundles);
   pass.setBindGroup(0, sceneBG);
-  draws += drawList(pass, task._directBindings, eng);
-  draws += drawList(pass, task._transparentBindings, eng);
+  draws += drawList$1(pass, task._directBindings, eng);
+  draws += drawList$1(pass, task._transparentBindings, eng);
   return draws;
 }
 function refreshTaskSceneBindGroup(task, eng) {
@@ -911,41 +971,35 @@ function writePassSceneUBO(task, eng, scene, camera, flipY) {
   const viewProj = getViewProjectionMatrix(camera, aspect);
   const viewMat = getViewMatrix(camera);
   const wm = camera.worldMatrix;
-  data.set(viewProj, 0);
+  packMat4IntoF32(data, viewProj, 0);
   if (flipY) {
     data[1] = -data[1];
     data[5] = -data[5];
     data[9] = -data[9];
     data[13] = -data[13];
   }
-  data.set(viewMat, 16);
-  data[32] = wm[12];
-  data[33] = wm[13];
-  data[34] = wm[14];
-  if (fog) {
-    data[80] = fog.mode;
-    data[81] = fog.start;
-    data[82] = fog.end;
-    data[83] = fog.density;
-    data[84] = fog.color[0];
-    data[85] = fog.color[1];
-    data[86] = fog.color[2];
+  packMat4IntoF32(data, viewMat, 16);
+  if (eng.useFloatingOrigin) {
+    data[32] = 0;
+    data[33] = 0;
+    data[34] = 0;
+  } else {
+    data[32] = wm[12];
+    data[33] = wm[13];
+    data[34] = wm[14];
   }
   data[87] = eng.canvas.width;
   data[36] = envRotationY;
-  if (envTextures == null ? void 0 : envTextures.sphericalHarmonics) {
-    data.set(envTextures.sphericalHarmonics, 40);
-  }
   data[76] = img.exposure;
   data[77] = img.contrast;
   data[78] = (envTextures == null ? void 0 : envTextures.lodGenerationScale) ?? 0.8;
   data[79] = +img.toneMappingEnabled;
   data[37] = eng.canvas.height;
-  if (scene.clipPlane) {
-    data[88] = scene.clipPlane[0];
-    data[89] = scene.clipPlane[1];
-    data[90] = scene.clipPlane[2];
-    data[91] = scene.clipPlane[3];
+  const contribs = scene._sceneUboContributors;
+  if (contribs) {
+    for (const c of contribs) {
+      c(data, scene);
+    }
   }
   eng._device.queue.writeBuffer(task._sceneUBO, 0, data);
 }
@@ -955,7 +1009,7 @@ function updateBindings(list, context) {
     (_a = b.update) == null ? void 0 : _a.call(b, context);
   }
 }
-function drawList(enc, list, engine) {
+function drawList$1(enc, list, engine) {
   let lp = null;
   let draws = 0;
   for (const b of list) {
@@ -1029,6 +1083,11 @@ function createSceneContext(engine, options) {
     _drawCallsPre: 0,
     _update() {
       var _a;
+      if (eng.useFloatingOrigin && ctx.camera && !ctx.camera._useFloatingOrigin) {
+        ctx.camera._useFloatingOrigin = true;
+        ctx.camera._viewVer = -1;
+        ctx.camera._vpVer = -1;
+      }
       const d = ctx.fixedDeltaMs > 0 ? ctx.fixedDeltaMs : eng._currentDelta;
       const encoder = eng._currentEncoder;
       let draws = 0;
@@ -1101,7 +1160,7 @@ function addDeferredSceneRenderables(scene, build) {
   });
 }
 function addToScene(scene, entity) {
-  var _a, _b;
+  var _a;
   const ctx = scene;
   if ("entities" in entity) {
     const result = entity;
@@ -1132,7 +1191,7 @@ function addToScene(scene, entity) {
     const mesh = entity;
     ctx.meshes.push(mesh);
     installMaterialSetter(ctx, mesh);
-    const build = (_b = mesh.material) == null ? void 0 : _b._buildGroup;
+    const build = mesh.material ? mesh.material._buildGroup : void 0;
     if (build) {
       let group = ctx._groups.get(build);
       if (!group) {
@@ -1319,7 +1378,7 @@ function createWorldMatrixState(getLocalMatrix) {
   let _worldVersion = 0;
   let _lastSeenParentVersion = -1;
   let _cachedWorld = null;
-  const _ownedWorld = new Float32Array(16);
+  const _ownedWorld = allocateMat4();
   let _parent = null;
   let _parentState = null;
   const _children = [];
@@ -1467,10 +1526,28 @@ function createArcRotateCamera(alpha, beta, radius, target) {
       z: cam.target.z + cam.radius * sinA * sinB
     };
   }
+  const _localMat = allocateMat4();
   function cameraLocalWorldMatrix() {
     const eye = localEyePosition();
     const v = mat4LookAtLH(eye, cam.target, Vec3Up);
-    return new Float32Array([v[0], v[4], v[8], 0, v[1], v[5], v[9], 0, v[2], v[6], v[10], 0, eye.x, eye.y, eye.z, 1]);
+    const m = _localMat;
+    m[0] = v[0];
+    m[1] = v[4];
+    m[2] = v[8];
+    m[3] = 0;
+    m[4] = v[1];
+    m[5] = v[5];
+    m[6] = v[9];
+    m[7] = 0;
+    m[8] = v[2];
+    m[9] = v[6];
+    m[10] = v[10];
+    m[11] = 0;
+    m[12] = eye.x;
+    m[13] = eye.y;
+    m[14] = eye.z;
+    m[15] = 1;
+    return _localMat;
   }
   const wm = createWorldMatrixState(cameraLocalWorldMatrix);
   const onDirty = () => wm.markLocalDirty();
@@ -1492,6 +1569,12 @@ function createArcRotateCamera(alpha, beta, radius, target) {
     inertialRadiusOffset: 0,
     inertialPanningX: 0,
     inertialPanningY: 0,
+    // Matrix caches use the process-global allocator — F32 by default,
+    // F64 after an HPM engine is created. Same backing as the camera world
+    // matrix above, so the camera's storage precision is uniform.
+    _viewCache: allocateMat4(),
+    _projCache: allocateMat4(),
+    _vpCache: allocateMat4(),
     get parent() {
       return wm.parent;
     },
@@ -1509,9 +1592,11 @@ function createArcRotateCamera(alpha, beta, radius, target) {
     Object.defineProperty(cam, key, {
       get: () => scalars[key],
       set: (v) => {
+        var _a;
         if (scalars[key] !== v) {
           scalars[key] = v;
           onDirty();
+          (_a = cam._clampToLimits) == null ? void 0 : _a.call(cam);
         }
       },
       configurable: true,
@@ -1608,7 +1693,7 @@ function removeFromScene(scene, mesh) {
   mesh._materialDirty = false;
   mesh.parent = null;
   for (const task of scene._frameGraph._tasks) {
-    if ("_config" in task) {
+    if ("_renderables" in task) {
       removeMeshFromTask(task, mesh);
     }
   }
@@ -1625,6 +1710,75 @@ function cascade(node, v) {
     cascade(kids[i], v);
   }
 }
+function writeFogUbo(data, scene) {
+  const fog = scene.fog;
+  if (fog) {
+    data[80] = fog.mode;
+    data[81] = fog.start;
+    data[82] = fog.end;
+    data[83] = fog.density;
+    data[84] = fog.color[0];
+    data[85] = fog.color[1];
+    data[86] = fog.color[2];
+  }
+}
+function writeClipPlaneUbo(data, scene) {
+  const clipPlane = scene.clipPlane;
+  if (clipPlane) {
+    data[88] = clipPlane[0];
+    data[89] = clipPlane[1];
+    data[90] = clipPlane[2];
+    data[91] = clipPlane[3];
+  }
+}
+function writeEnvShUbo(data, scene) {
+  var _a;
+  const sh = (_a = scene._envTextures) == null ? void 0 : _a.sphericalHarmonics;
+  if (sh) {
+    data.set(sh, 40);
+  }
+}
+function registerContributor(scene, contributor) {
+  const list = scene._sceneUboContributors ?? (scene._sceneUboContributors = []);
+  if (!list.includes(contributor)) {
+    list.push(contributor);
+  }
+}
+function setFog(scene, config) {
+  scene.fog = config;
+  registerContributor(scene, writeFogUbo);
+}
+function setClipPlane(scene, plane) {
+  scene.clipPlane = plane;
+  registerContributor(scene, writeClipPlaneUbo);
+}
+function registerEnvSceneUniforms(scene) {
+  registerContributor(scene, writeEnvShUbo);
+}
+function getFloatingOriginOffset(scene) {
+  const cam = scene.camera;
+  if (!cam) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  const w = cam.worldMatrix;
+  return { x: w[12], y: w[13], z: w[14] };
+}
+function wrapRenderableForFO(inner, scene, invalidate) {
+  let _lastCameraVersion = -1;
+  return () => {
+    const cv = scene.camera ? scene.camera.worldMatrixVersion : -1;
+    if (cv !== _lastCameraVersion) {
+      invalidate();
+      _lastCameraVersion = cv;
+    }
+    inner();
+  };
+}
+const floatingOrigin = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getFloatingOriginOffset,
+  wrapRenderableForFO
+}, Symbol.toStringTag, { value: "Module" }));
 function addPassDependencies(pass, deps) {
   if (Array.isArray(deps)) {
     for (const dep of deps) {
@@ -2118,115 +2272,616 @@ function createRenderTargetTexture(engine, descriptor) {
   };
   return { rt, texture };
 }
-const DEFAULT_VERTEX_WGSL$1 = `struct EffectVertexOutput{@builtin(position) position:vec4<f32>,@location(0) uv:vec2<f32>};
-@vertex fn effectFullscreenVertex(@builtin(vertex_index) vertexIndex:u32)->EffectVertexOutput{var positions=array<vec2<f32>,3>(vec2<f32>(-1.0,-1.0),vec2<f32>(3.0,-1.0),vec2<f32>(-1.0,3.0));let p=positions[vertexIndex];var out:EffectVertexOutput;out.position=vec4<f32>(p,0.0,1.0);out.uv=p*0.5+vec2<f32>(0.5,0.5);return out;}`;
-function createEffectWrapper(engine, options) {
-  const eng = engine;
-  const wrapper = {
-    name: options.name ?? "effect-wrapper",
-    options,
-    _engine: eng,
-    _shader: null,
-    _bindGroupLayout: null,
-    _pipelineLayout: null,
-    _bindGroup: null,
-    _bindGroupDirty: true,
-    _pipelines: null,
-    _uniforms: [],
-    _textures: []
-  };
-  createBindingSlots(wrapper);
-  return wrapper;
+const _trilinearAnisotropicDesc = {
+  magFilter: "linear",
+  minFilter: "linear",
+  mipmapFilter: "linear",
+  addressModeU: "repeat",
+  addressModeV: "repeat",
+  addressModeW: "repeat",
+  maxAnisotropy: 4
+};
+function getTrilinearAnisotropicSampler(engine) {
+  return getOrCreateSampler(engine, _trilinearAnisotropicDesc);
 }
-function setEffectUniforms(wrapper, data) {
-  const internal = wrapper;
-  if (isBufferData(data)) {
-    const slot = internal._uniforms[0];
-    if (!slot) {
-      throw new Error("setEffectUniforms: wrapper has no uniform binding.");
-    }
-    writeUniformSlot(internal, slot, data);
+const BLIT_SHADER$1 = `@group(0)@binding(0)var t:texture_2d<f32>;@group(0)@binding(1)var s:sampler;
+struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};
+@vertex fn vs(@builtin(vertex_index)i:u32)->V{let p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3))[i];return V(vec4f(p,0,1),p*vec2f(.5,-.5)+.5);}
+@fragment fn fs(v:V)->@location(0)vec4f{return textureSample(t,s,v.u);}`;
+let pipelineCache = null;
+let shaderModule = null;
+let linearSampler = null;
+let bindGroupLayout = null;
+let cachedDevice = null;
+function clearCache() {
+  pipelineCache == null ? void 0 : pipelineCache.clear();
+  pipelineCache = null;
+  shaderModule = null;
+  linearSampler = null;
+  bindGroupLayout = null;
+  cachedDevice = null;
+}
+function ensureResources(engine) {
+  const device = engine._device;
+  if (device !== cachedDevice) {
+    clearCache();
+    cachedDevice = device;
+  }
+  shaderModule ?? (shaderModule = device.createShaderModule({ code: BLIT_SHADER$1 }));
+  linearSampler ?? (linearSampler = getBilinearSampler(engine));
+  bindGroupLayout ?? (bindGroupLayout = device.createBindGroupLayout({
+    entries: [
+      { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+      { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: {} }
+    ]
+  }));
+}
+function getPipeline(engine, format) {
+  const device = engine._device;
+  ensureResources(engine);
+  pipelineCache ?? (pipelineCache = /* @__PURE__ */ new Map());
+  let pipeline = pipelineCache.get(format);
+  if (!pipeline) {
+    pipeline = device.createRenderPipeline({
+      layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
+      vertex: { module: shaderModule, entryPoint: "vs" },
+      fragment: { module: shaderModule, entryPoint: "fs", targets: [{ format }] },
+      primitive: { topology: "triangle-list" }
+    });
+    pipelineCache.set(format, pipeline);
+  }
+  return pipeline;
+}
+function generateMipmaps(engine, texture, face) {
+  const device = engine._device;
+  const encoder = device.createCommandEncoder();
+  recordMipmaps(engine, texture, encoder, face);
+  device.queue.submit([encoder.finish()]);
+}
+function recordMipmaps(engine, texture, encoder, face) {
+  if (texture.mipLevelCount <= 1) {
     return;
   }
-  for (const key of Object.keys(data)) {
-    const slot = findUniformSlot(internal, key);
-    if (!slot) {
-      throw new Error(`setEffectUniforms: unknown uniform binding "${key}".`);
-    }
-    writeUniformSlot(internal, slot, data[key]);
+  const device = engine._device;
+  const pipeline = getPipeline(engine, texture.format);
+  const vp = face != null ? { dimension: "2d", baseArrayLayer: face, arrayLayerCount: 1 } : {};
+  for (let mip = 1; mip < texture.mipLevelCount; mip++) {
+    const srcView = texture.createView({ baseMipLevel: mip - 1, mipLevelCount: 1, ...vp });
+    const dstView = texture.createView({ baseMipLevel: mip, mipLevelCount: 1, ...vp });
+    const bindGroup = device.createBindGroup({
+      layout: bindGroupLayout,
+      entries: [
+        { binding: 0, resource: srcView },
+        { binding: 1, resource: linearSampler }
+      ]
+    });
+    const pass = encoder.beginRenderPass({
+      colorAttachments: [{ view: dstView, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }]
+    });
+    pass.setPipeline(pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.draw(3);
+    pass.end();
   }
 }
-function setEffectTexture(wrapper, bindingNameOrIndex, texture) {
-  const internal = wrapper;
-  const slot = findTextureSlot(internal, bindingNameOrIndex);
-  if (!slot) {
-    throw new Error(`setEffectTexture: unknown texture binding "${String(bindingNameOrIndex)}".`);
+const generateMipmaps$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  generateMipmaps,
+  recordMipmaps
+}, Symbol.toStringTag, { value: "Module" }));
+function mipLevelCount(width, height) {
+  return Math.floor(Math.log2(Math.max(width, height))) + 1;
+}
+function biasedMipLevelCount(width, height, lodBias) {
+  const maxDim = Math.max(width, height);
+  return Math.max(1, Math.floor(Math.log2(maxDim) - lodBias) + 1);
+}
+const BLIT_SHADER = `@group(0)@binding(0)var t:texture_2d<f32>;@group(0)@binding(1)var s:sampler;struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};@vertex fn vs(@builtin(vertex_index)i:u32)->V{var p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));var u=array<vec2f,3>(vec2f(0,1),vec2f(2,1),vec2f(0,-1));return V(vec4f(p[i],0,1),u[i]);}@fragment fn fs(v:V)->@location(0)vec4f{return textureSample(t,s,v.u);}`;
+const BLIT_MSAA_SHADER = `@group(0)@binding(0)var t:texture_multisampled_2d<f32>;struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};@vertex fn vs(@builtin(vertex_index)i:u32)->V{var p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3));var u=array<vec2f,3>(vec2f(0,1),vec2f(2,1),vec2f(0,-1));return V(vec4f(p[i],0,1),u[i]);}fn l(p:vec2i)->vec4f{let n=textureNumSamples(t);var c=vec4f(0);for(var i=0u;i<n;i++){c+=textureLoad(t,p,i);}return c/f32(n);}@fragment fn fs(v:V)->@location(0)vec4f{let d=vec2i(textureDimensions(t));let q=clamp(v.u*vec2f(d)-.5,vec2f(0),vec2f(d-vec2i(1)));let p=vec2i(floor(q));let f=fract(q);let p1=min(p+vec2i(1),d-vec2i(1));return mix(mix(l(p),l(vec2i(p1.x,p.y)),f.x),mix(l(vec2i(p.x,p1.y)),l(p1),f.x),f.y);}`;
+const REFRACTION_LOD_BIAS = 4;
+let blitPipelines = null;
+let blitShader = null;
+let blitMsaaShader = null;
+let blitBgl = null;
+let blitMsaaBgl = null;
+let blitDevice = null;
+function enableSceneTransmission(scene, engine) {
+  markPbrMaterialsLinear(scene);
+  let lastRenderTask = null;
+  for (const task of scene._frameGraph._tasks) {
+    if ("_renderables" in task) {
+      const renderTask = task;
+      enableRenderTaskTransmission(renderTask, engine);
+      lastRenderTask = renderTask;
+    }
+  }
+  if (lastRenderTask && !scene._frameGraph._tasks.some((task) => task.name === "transmission-image-processing")) {
+    scene._frameGraph._tasks.push(createImageProcessingTask({ name: "transmission-image-processing", source: lastRenderTask._config.rt }, engine, scene));
   }
-  slot.texture = texture;
-  internal._bindGroupDirty = true;
 }
-function createEffectRenderTask(config, engine, scene) {
-  const eng = engine;
-  const effect = config.effect;
-  const rt = config.target;
-  config.clearColor ?? (config.clearColor = { r: 0, g: 0, b: 0, a: 1 });
-  const sampleCount = rt._descriptor.sampleCount ?? 1;
-  const targetSignature = {
-    _colorFormat: rt._descriptor.colorFormat,
-    _sampleCount: sampleCount
-  };
-  const colorAttachment = { loadOp: "clear", storeOp: "store" };
-  const task = {
-    name: config.name,
-    _config: config,
-    engine: eng,
-    scene,
-    _passes: [],
-    _rt: rt,
-    _targetSignature: targetSignature,
-    _renderPassDescriptor: { label: config.name, colorAttachments: [colorAttachment] },
-    _colorAttachment: colorAttachment,
-    _pipeline: null,
-    _bindGroup: null,
-    record() {
-      buildRenderTarget(rt, eng);
-      task._pipeline = getEffectPipeline(effect, task._targetSignature);
-      task._bindGroup = getEffectBindGroup(effect);
-    },
-    execute() {
-      const pipeline = task._pipeline;
-      if (!pipeline) {
-        throw new Error(`EffectRenderTask "${task.name}" executed before record().`);
-      }
-      task._bindGroup = getEffectBindGroup(effect);
-      applyColorAttachmentState$2(task._colorAttachment, rt, eng, task._config.clear !== false, task._config.clearColor);
-      const pass = eng._currentEncoder.beginRenderPass(task._renderPassDescriptor);
-      pass.setPipeline(pipeline);
-      if (task._bindGroup) {
-        pass.setBindGroup(0, task._bindGroup);
-      }
-      pass.draw(3);
-      pass.end();
-      return 1;
-    },
-    dispose() {
-      task._passes.length = 0;
-      disposeRenderTarget(task._rt);
-      task._pipeline = null;
-      task._bindGroup = null;
+function enableRenderTaskTransmission(task, engine, options) {
+  var _a, _b;
+  const linear = (options == null ? void 0 : options.linear) !== false;
+  const grab = {
+    get texture() {
+      return task._targetSignature._transmissionTexture ?? null;
     }
   };
-  return task;
-}
-function disposeEffectWrapper(wrapper) {
-  var _a;
-  const internal = wrapper;
-  for (const slot of internal._uniforms) {
-    slot.buffer.destroy();
+  if (task._executeWithTransmission) {
+    return grab;
   }
-  internal._uniforms.length = 0;
-  internal._textures.length = 0;
-  (_a = internal._pipelines) == null ? void 0 : _a.clear();
+  if (linear) {
+    retargetRenderTaskToLinearOffscreen(task, engine);
+  }
+  let state = null;
+  const record = task.record.bind(task);
+  const execute = (_a = task.execute) == null ? void 0 : _a.bind(task);
+  const dispose = (_b = task.dispose) == null ? void 0 : _b.bind(task);
+  task.record = () => {
+    disposeRenderTaskTransmission(state);
+    state = createRenderTaskTransmission(task, engine);
+    task._targetSignature._transmissionTexture = state.texture;
+    record();
+    configureTransmissionSource(state, task, engine);
+  };
+  if (linear && execute) {
+    task.execute = () => executeRenderTaskLinear(task.scene, execute);
+  }
+  task.dispose = () => {
+    disposeRenderTaskTransmission(state);
+    state = null;
+    dispose == null ? void 0 : dispose();
+  };
+  task._executeWithTransmission = (sampleCount) => executePassWithTransmission(task, engine, state, sampleCount);
+  return grab;
+}
+function retargetRenderTaskToLinearOffscreen(task, engine) {
+  const desc = task._config.rt._descriptor;
+  if (desc.resolveToSwapchain) {
+    desc.resolveToSwapchain = false;
+    desc.colorFormat = "rgba16float";
+    desc.flipY = false;
+    task._opaqueBundles.length = 0;
+    task._lastVersion = -1;
+  } else if (!desc.colorFormat) {
+    desc.colorFormat = "rgba16float";
+  }
+  desc.sampleCount = engine.msaaSamples;
+  const sig = task._targetSignature;
+  sig._colorFormat = desc.colorFormat;
+  sig._depthStencilFormat = desc.depthStencilFormat;
+  sig._depthCompare = desc._depthCompare;
+  sig._sampleCount = desc.sampleCount;
+  sig._flipY = desc.flipY ?? true;
+}
+function executeRenderTaskLinear(scene, execute) {
+  const imageProcessing = scene.imageProcessing;
+  const toneMappingEnabled = imageProcessing.toneMappingEnabled;
+  const clearColor = scene.clearColor;
+  const linearClearColor = inverseImageProcessedColor(clearColor, imageProcessing.exposure, imageProcessing.contrast, toneMappingEnabled === true);
+  imageProcessing.toneMappingEnabled = -1;
+  scene.clearColor = linearClearColor;
+  try {
+    return execute();
+  } finally {
+    scene.clearColor = clearColor;
+    imageProcessing.toneMappingEnabled = toneMappingEnabled;
+  }
+}
+function inverseImageProcessedColor(color, exposure, contrast, toneMapping) {
+  return {
+    r: inverseImageProcessedChannel(color.r, exposure, contrast, toneMapping),
+    g: inverseImageProcessedChannel(color.g, exposure, contrast, toneMapping),
+    b: inverseImageProcessedChannel(color.b, exposure, contrast, toneMapping),
+    a: color.a
+  };
+}
+function inverseImageProcessedChannel(value, exposure, contrast, toneMapping) {
+  let c = clamp01$1(value);
+  if (contrast < 1) {
+    c = contrast > 0 ? clamp01$1((c - 0.5 * (1 - contrast)) / contrast) : 0.5;
+  } else if (contrast > 1) {
+    const mixAmount = contrast - 1;
+    let lo = 0;
+    let hi = 1;
+    for (let i = 0; i < 16; i++) {
+      const mid = (lo + hi) * 0.5;
+      const high = mid * mid * (3 - 2 * mid);
+      const out = mid + (high - mid) * mixAmount;
+      if (out < c) {
+        lo = mid;
+      } else {
+        hi = mid;
+      }
+    }
+    c = (lo + hi) * 0.5;
+  }
+  c = c ** 2.2;
+  if (toneMapping) {
+    c = -Math.log2(Math.max(1 - c, 1e-6)) / 1.5905790328979492;
+  }
+  return exposure > 0 ? c / exposure : c;
+}
+function clamp01$1(v) {
+  return Math.min(Math.max(v, 0), 1);
+}
+function markPbrMaterialsLinear(scene) {
+  for (const mesh of scene.meshes) {
+    const mat = mesh.material;
+    if (mat) {
+      mat._linearImageProcessing = true;
+      mat._renderFeatures = void 0;
+    }
+  }
+}
+function createRenderTaskTransmission(task, engine) {
+  const rt = task._config.rt;
+  const width = 1024;
+  const height = 1024;
+  const format = "rgba16float";
+  const generateMipmaps2 = shouldGenerateMipmaps(task._config.transmission);
+  const texture = engine._device.createTexture({
+    label: task.name,
+    size: { width, height },
+    format,
+    mipLevelCount: generateMipmaps2 ? biasedMipLevelCount(width, height, REFRACTION_LOD_BIAS) : 1,
+    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+  });
+  const tex = {
+    texture,
+    view: texture.createView(),
+    sampler: getTrilinearAnisotropicSampler(engine),
+    width,
+    height,
+    invertY: false
+  };
+  return {
+    texture: tex,
+    _baseView: texture.createView({ baseMipLevel: 0, mipLevelCount: 1 }),
+    _sourceWidth: rt._width,
+    _sourceHeight: rt._height,
+    _sourceTexture: null,
+    _blit: null,
+    _copyCount: normalizeCopyCount(task._config.transmission),
+    _generateMipmaps: generateMipmaps2,
+    _copies: 0
+  };
+}
+function configureTransmissionSource(state, task, engine) {
+  const rt = task._config.rt;
+  state._sourceWidth = rt._width;
+  state._sourceHeight = rt._height;
+  state._sourceTexture = rt._colorTexture;
+  const sampleCount = task._targetSignature._sampleCount;
+  if (!state._sourceTexture) {
+    return;
+  }
+  state._blit = shouldBlitTransmission(state, sampleCount) ? createTransmissionBlit(state, engine, state._sourceTexture, sampleCount > 1) : null;
+}
+function disposeRenderTaskTransmission(state) {
+  state == null ? void 0 : state.texture.texture.destroy();
+}
+function executePassWithTransmission(task, engine, state, sampleCount) {
+  var _a;
+  state._copies = 0;
+  const transparent = task._transparentBindings;
+  let pass = beginTaskPass(task, null, sampleCount, false);
+  let draws = drawBaseTask(task, pass);
+  let lastPipeline = null;
+  let overlay = null;
+  for (let i = 0; i < transparent.length; i++) {
+    const binding = transparent[i];
+    if (((_a = binding.renderable.mesh) == null ? void 0 : _a.renderOnTop) === true) {
+      (overlay ?? (overlay = [])).push(binding);
+      continue;
+    }
+    const transmissive = binding.renderable._transmissive === true;
+    if (transmissive && canUpdateTransmission(state)) {
+      pass.end();
+      updateTransmissionTexture(state, engine);
+      pass = beginTaskPass(task, null, sampleCount, true);
+      setPassState(task, pass);
+      lastPipeline = null;
+    }
+    const mesh = binding.renderable.mesh;
+    if (mesh && mesh.visible === false) {
+      continue;
+    }
+    if (binding.pipeline !== lastPipeline) {
+      pass.setPipeline(binding.pipeline);
+      lastPipeline = binding.pipeline;
+    }
+    draws += binding.draw(pass, engine);
+  }
+  if (overlay) {
+    draws += drawList(pass, overlay, engine);
+  }
+  pass.end();
+  return draws;
+}
+function updateTransmissionTexture(state, engine) {
+  if (!state._sourceTexture) {
+    throw new Error("No transmission source");
+  }
+  if (state._blit) {
+    blitToTransmission(state, engine);
+  } else {
+    engine._currentEncoder.copyTextureToTexture(
+      { texture: state._sourceTexture },
+      { texture: state.texture.texture },
+      { width: state.texture.width, height: state.texture.height }
+    );
+  }
+  if (state._generateMipmaps) {
+    recordMipmaps(engine, state.texture.texture, engine._currentEncoder);
+  }
+  state._copies++;
+}
+function getBlitPipeline(engine, format, multisampled) {
+  const device = engine._device;
+  if (device !== blitDevice) {
+    blitPipelines == null ? void 0 : blitPipelines.clear();
+    blitPipelines = null;
+    blitShader = null;
+    blitMsaaShader = null;
+    blitBgl = null;
+    blitMsaaBgl = null;
+    blitDevice = device;
+  }
+  if (multisampled) {
+    blitMsaaShader ?? (blitMsaaShader = device.createShaderModule({ code: BLIT_MSAA_SHADER }));
+    blitMsaaBgl ?? (blitMsaaBgl = device.createBindGroupLayout({
+      entries: [{ binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "unfilterable-float", multisampled: true } }]
+    }));
+  } else {
+    blitShader ?? (blitShader = device.createShaderModule({ code: BLIT_SHADER }));
+    blitBgl ?? (blitBgl = device.createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
+        { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: {} }
+      ]
+    }));
+  }
+  blitPipelines ?? (blitPipelines = /* @__PURE__ */ new Map());
+  const key = `${format}:${multisampled ? "msaa" : ""}`;
+  let pipeline = blitPipelines.get(key);
+  if (!pipeline) {
+    const bgl = multisampled ? blitMsaaBgl : blitBgl;
+    pipeline = device.createRenderPipeline({
+      label: "transmission-copy",
+      layout: device.createPipelineLayout({ bindGroupLayouts: [bgl] }),
+      vertex: { module: multisampled ? blitMsaaShader : blitShader, entryPoint: "vs" },
+      fragment: { module: multisampled ? blitMsaaShader : blitShader, entryPoint: "fs", targets: [{ format }] },
+      primitive: { topology: "triangle-list" }
+    });
+    blitPipelines.set(key, pipeline);
+  }
+  return pipeline;
+}
+function shouldBlitTransmission(state, sampleCount) {
+  return sampleCount > 1 || state._sourceWidth !== state.texture.width || state._sourceHeight !== state.texture.height;
+}
+function createTransmissionBlit(state, engine, source, multisampled) {
+  const device = engine._device;
+  const pipeline = getBlitPipeline(engine, state.texture.texture.format, multisampled);
+  const bindGroup = device.createBindGroup({
+    layout: multisampled ? blitMsaaBgl : blitBgl,
+    entries: multisampled ? [{ binding: 0, resource: source.createView() }] : [
+      { binding: 0, resource: source.createView() },
+      { binding: 1, resource: getBilinearSampler(engine) }
+    ]
+  });
+  return { _pipeline: pipeline, _bindGroup: bindGroup };
+}
+function blitToTransmission(state, engine) {
+  const blit = state._blit;
+  const pass = engine._currentEncoder.beginRenderPass({
+    colorAttachments: [{ view: state._baseView, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }]
+  });
+  pass.setPipeline(blit._pipeline);
+  pass.setBindGroup(0, blit._bindGroup);
+  pass.draw(3);
+  pass.end();
+}
+function canUpdateTransmission(state) {
+  return state._copyCount === 0 || state._copies < state._copyCount;
+}
+function beginTaskPass(task, resolveTarget, sampleCount, load) {
+  const att = task._colorAttachment;
+  const depthLoadOp = load || !task._config.clr ? "load" : "clear";
+  if (load) {
+    att.loadOp = "load";
+  }
+  const depthAttachment = task._renderPassDescriptor.depthStencilAttachment;
+  if (depthAttachment) {
+    depthAttachment.depthLoadOp = depthLoadOp;
+    if (depthAttachment.stencilLoadOp) {
+      depthAttachment.stencilLoadOp = depthLoadOp;
+    }
+  }
+  if (sampleCount > 1) {
+    att.resolveTarget = void 0;
+  } else {
+    att.resolveTarget = void 0;
+  }
+  return task.engine._currentEncoder.beginRenderPass(task._renderPassDescriptor);
+}
+function setPassState(task, pass) {
+  const cfg = task._config;
+  const rt = cfg.rt;
+  const scene = task.scene;
+  const camera = cfg.cam ?? scene.camera;
+  const v = camera == null ? void 0 : camera.viewport;
+  if (v) {
+    const rw = rt._width;
+    const rh = rt._height;
+    const x = Math.floor(v.x * rw);
+    const y = Math.floor((1 - v.y - v.height) * rh);
+    const w = Math.ceil((v.x + v.width) * rw) - x;
+    const h = Math.ceil((1 - v.y) * rh) - y;
+    pass.setViewport(x, y, w, h, 0, 1);
+    pass.setScissorRect(x, y, w, h);
+  }
+  pass.setBindGroup(0, task._sceneBG);
+}
+function drawBaseTask(task, pass) {
+  const eng = task.engine;
+  const rt = task._config.rt;
+  const scene = task.scene;
+  const opaqueBindings = task._opaqueBindings;
+  const opaqueBundles = task._opaqueBundles;
+  setPassState(task, pass);
+  if (task._lastVersion !== scene._renderableVersion || task._lastVis !== _vis || opaqueBundles.length === 0) {
+    const desc = rt._descriptor;
+    const be = eng._device.createRenderBundleEncoder({
+      colorFormats: desc.colorFormat ? [desc.colorFormat] : [],
+      depthStencilFormat: desc.depthStencilFormat,
+      sampleCount: desc.sampleCount ?? 1
+    });
+    be.setBindGroup(0, task._sceneBG);
+    drawList(be, opaqueBindings, eng);
+    opaqueBundles[0] = be.finish();
+    task._lastVersion = scene._renderableVersion;
+    task._lastVis = _vis;
+  }
+  let draws = opaqueBindings.length;
+  pass.executeBundles(opaqueBundles);
+  pass.setBindGroup(0, task._sceneBG);
+  draws += drawList(pass, task._directBindings, eng);
+  return draws;
+}
+function drawList(enc, list, engine) {
+  let lp = null;
+  let draws = 0;
+  for (const b of list) {
+    const mesh = b.renderable.mesh;
+    if (mesh && mesh.visible === false) {
+      continue;
+    }
+    if (b.pipeline !== lp) {
+      enc.setPipeline(b.pipeline);
+      lp = b.pipeline;
+    }
+    draws += b.draw(enc, engine);
+  }
+  return draws;
+}
+function normalizeCopyCount(cfg) {
+  const count = (cfg == null ? void 0 : cfg.copyCount) ?? 1;
+  return count === Infinity ? 0 : Math.max(0, count | 0);
+}
+function shouldGenerateMipmaps(cfg) {
+  return (cfg == null ? void 0 : cfg.generateMipmaps) !== false;
+}
+const DEFAULT_VERTEX_WGSL$1 = `struct EffectVertexOutput{@builtin(position) position:vec4<f32>,@location(0) uv:vec2<f32>};
+@vertex fn effectFullscreenVertex(@builtin(vertex_index) vertexIndex:u32)->EffectVertexOutput{var positions=array<vec2<f32>,3>(vec2<f32>(-1.0,-1.0),vec2<f32>(3.0,-1.0),vec2<f32>(-1.0,3.0));let p=positions[vertexIndex];var out:EffectVertexOutput;out.position=vec4<f32>(p,0.0,1.0);out.uv=p*0.5+vec2<f32>(0.5,0.5);return out;}`;
+function createEffectWrapper(engine, options) {
+  const eng = engine;
+  const wrapper = {
+    name: options.name ?? "effect-wrapper",
+    options,
+    _engine: eng,
+    _shader: null,
+    _bindGroupLayout: null,
+    _pipelineLayout: null,
+    _bindGroup: null,
+    _bindGroupDirty: true,
+    _pipelines: null,
+    _uniforms: [],
+    _textures: []
+  };
+  createBindingSlots(wrapper);
+  return wrapper;
+}
+function setEffectUniforms(wrapper, data) {
+  const internal = wrapper;
+  if (isBufferData(data)) {
+    const slot = internal._uniforms[0];
+    if (!slot) {
+      throw new Error("setEffectUniforms: wrapper has no uniform binding.");
+    }
+    writeUniformSlot(internal, slot, data);
+    return;
+  }
+  for (const key of Object.keys(data)) {
+    const slot = findUniformSlot(internal, key);
+    if (!slot) {
+      throw new Error(`setEffectUniforms: unknown uniform binding "${key}".`);
+    }
+    writeUniformSlot(internal, slot, data[key]);
+  }
+}
+function setEffectTexture(wrapper, bindingNameOrIndex, texture) {
+  const internal = wrapper;
+  const slot = findTextureSlot(internal, bindingNameOrIndex);
+  if (!slot) {
+    throw new Error(`setEffectTexture: unknown texture binding "${String(bindingNameOrIndex)}".`);
+  }
+  slot.texture = texture;
+  internal._bindGroupDirty = true;
+}
+function createEffectRenderTask(config, engine, scene) {
+  const eng = engine;
+  const effect = config.effect;
+  const rt = config.target;
+  config.clearColor ?? (config.clearColor = { r: 0, g: 0, b: 0, a: 1 });
+  const sampleCount = rt._descriptor.sampleCount ?? 1;
+  const targetSignature = {
+    _colorFormat: rt._descriptor.colorFormat,
+    _sampleCount: sampleCount
+  };
+  const colorAttachment = { loadOp: "clear", storeOp: "store" };
+  const task = {
+    name: config.name,
+    _config: config,
+    engine: eng,
+    scene,
+    _passes: [],
+    _rt: rt,
+    _targetSignature: targetSignature,
+    _renderPassDescriptor: { label: config.name, colorAttachments: [colorAttachment] },
+    _colorAttachment: colorAttachment,
+    _pipeline: null,
+    _bindGroup: null,
+    record() {
+      buildRenderTarget(rt, eng);
+      task._pipeline = getEffectPipeline(effect, task._targetSignature);
+      task._bindGroup = getEffectBindGroup(effect);
+    },
+    execute() {
+      const pipeline = task._pipeline;
+      if (!pipeline) {
+        throw new Error(`EffectRenderTask "${task.name}" executed before record().`);
+      }
+      task._bindGroup = getEffectBindGroup(effect);
+      applyColorAttachmentState$2(task._colorAttachment, rt, eng, task._config.clear !== false, task._config.clearColor);
+      const pass = eng._currentEncoder.beginRenderPass(task._renderPassDescriptor);
+      pass.setPipeline(pipeline);
+      if (task._bindGroup) {
+        pass.setBindGroup(0, task._bindGroup);
+      }
+      pass.draw(3);
+      pass.end();
+      return 1;
+    },
+    dispose() {
+      task._passes.length = 0;
+      disposeRenderTarget(task._rt);
+      task._pipeline = null;
+      task._bindGroup = null;
+    }
+  };
+  return task;
+}
+function disposeEffectWrapper(wrapper) {
+  var _a;
+  const internal = wrapper;
+  for (const slot of internal._uniforms) {
+    slot.buffer.destroy();
+  }
+  internal._uniforms.length = 0;
+  internal._textures.length = 0;
+  (_a = internal._pipelines) == null ? void 0 : _a.clear();
   internal._pipelines = null;
   internal._shader = null;
   internal._bindGroupLayout = null;
@@ -3508,6 +4163,57 @@ function resolveSourceSize(source, engine) {
   }
   return desc.size;
 }
+function clampCameraToLimits(camera) {
+  if (camera.lowerRadiusLimit !== void 0 && camera.radius < camera.lowerRadiusLimit) {
+    camera.radius = camera.lowerRadiusLimit;
+    camera.inertialRadiusOffset = 0;
+  } else if (camera.upperRadiusLimit !== void 0 && camera.radius > camera.upperRadiusLimit) {
+    camera.radius = camera.upperRadiusLimit;
+    camera.inertialRadiusOffset = 0;
+  }
+  if (camera.lowerBetaLimit !== void 0 && camera.beta < camera.lowerBetaLimit) {
+    camera.beta = camera.lowerBetaLimit;
+    camera.inertialBetaOffset = 0;
+  } else if (camera.upperBetaLimit !== void 0 && camera.beta > camera.upperBetaLimit) {
+    camera.beta = camera.upperBetaLimit;
+    camera.inertialBetaOffset = 0;
+  }
+  if (camera.lowerAlphaLimit !== void 0 && camera.alpha < camera.lowerAlphaLimit) {
+    camera.alpha = camera.lowerAlphaLimit;
+    camera.inertialAlphaOffset = 0;
+  } else if (camera.upperAlphaLimit !== void 0 && camera.alpha > camera.upperAlphaLimit) {
+    camera.alpha = camera.upperAlphaLimit;
+    camera.inertialAlphaOffset = 0;
+  }
+}
+function setCameraLimits(camera, limits, scene) {
+  if ("lowerAlphaLimit" in limits) {
+    camera.lowerAlphaLimit = limits.lowerAlphaLimit;
+  }
+  if ("upperAlphaLimit" in limits) {
+    camera.upperAlphaLimit = limits.upperAlphaLimit;
+  }
+  if ("lowerBetaLimit" in limits) {
+    camera.lowerBetaLimit = limits.lowerBetaLimit;
+  }
+  if ("upperBetaLimit" in limits) {
+    camera.upperBetaLimit = limits.upperBetaLimit;
+  }
+  if ("lowerRadiusLimit" in limits) {
+    camera.lowerRadiusLimit = limits.lowerRadiusLimit;
+  }
+  if ("upperRadiusLimit" in limits) {
+    camera.upperRadiusLimit = limits.upperRadiusLimit;
+  }
+  const enforce = () => clampCameraToLimits(camera);
+  camera._clampToLimits = enforce;
+  enforce();
+  return () => {
+    if (camera._clampToLimits === enforce) {
+      camera._clampToLimits = void 0;
+    }
+  };
+}
 function attachControl(camera, canvas, scene) {
   const angularSensibility = 1e3;
   const panningSensibility = 50;
@@ -3519,7 +4225,6 @@ function attachControl(camera, canvas, scene) {
   let isPanning = false;
   let lastX = 0;
   let lastY = 0;
-  let animFrameId = 0;
   const activeTouches = /* @__PURE__ */ new Map();
   let pinchStartDist = 0;
   let pinchStartRadius = 0;
@@ -3536,13 +4241,16 @@ function attachControl(camera, canvas, scene) {
     }
   }
   function onPointerMove(e) {
-    if (!isDragging && !isPanning) {
-      return;
-    }
     const dx = e.clientX - lastX;
     const dy = e.clientY - lastY;
     lastX = e.clientX;
     lastY = e.clientY;
+    if (activeTouches.size >= 2) {
+      return;
+    }
+    if (!isDragging && !isPanning) {
+      return;
+    }
     if (isDragging) {
       camera.inertialAlphaOffset -= dx / angularSensibility;
       camera.inertialBetaOffset -= dy / angularSensibility;
@@ -3569,12 +4277,15 @@ function attachControl(camera, canvas, scene) {
       const touch = e.changedTouches[i];
       activeTouches.set(touch.identifier, { x: touch.clientX, y: touch.clientY });
     }
-    if (activeTouches.size === 2) {
+    if (activeTouches.size >= 2) {
+      isDragging = false;
+      isPanning = false;
       const iter = activeTouches.values();
       const p0 = iter.next().value;
       const p1 = iter.next().value;
       pinchStartDist = Math.hypot(p1.x - p0.x, p1.y - p0.y);
       pinchStartRadius = camera.radius;
+      e.preventDefault();
     }
   }
   function onTouchMove(e) {
@@ -3582,12 +4293,13 @@ function attachControl(camera, canvas, scene) {
       const touch = e.changedTouches[i];
       activeTouches.set(touch.identifier, { x: touch.clientX, y: touch.clientY });
     }
-    if (activeTouches.size === 2) {
+    if (activeTouches.size >= 2) {
+      e.preventDefault();
       const iter = activeTouches.values();
       const p0 = iter.next().value;
       const p1 = iter.next().value;
       const dist = Math.hypot(p1.x - p0.x, p1.y - p0.y);
-      if (pinchStartDist > 0) {
+      if (pinchStartDist > 0 && dist > 0) {
         camera.radius = pinchStartRadius * (pinchStartDist / dist);
         camera.radius = Math.max(0.01, camera.radius);
       }
@@ -3597,6 +4309,17 @@ function attachControl(camera, canvas, scene) {
     for (let i = 0; i < e.changedTouches.length; i++) {
       activeTouches.delete(e.changedTouches[i].identifier);
     }
+    if (activeTouches.size === 1) {
+      const p = activeTouches.values().next().value;
+      lastX = p.x;
+      lastY = p.y;
+    }
+    if (activeTouches.size < 2) {
+      pinchStartDist = 0;
+    }
+  }
+  function onGesture(e) {
+    e.preventDefault();
   }
   function applyInertia() {
     if (camera.inertialAlphaOffset !== 0 || camera.inertialBetaOffset !== 0) {
@@ -3639,14 +4362,9 @@ function attachControl(camera, canvas, scene) {
         camera.inertialPanningY = 0;
       }
     }
-    if (!scene) {
-      animFrameId = requestAnimationFrame(applyInertia);
-    }
   }
   if (scene) {
     scene._beforeRender.push(applyInertia);
-  } else {
-    animFrameId = requestAnimationFrame(applyInertia);
   }
   const listeners = [
     ["pointerdown", onPointerDown],
@@ -3654,17 +4372,17 @@ function attachControl(camera, canvas, scene) {
     ["pointerup", onPointerUp],
     ["wheel", onWheel, { passive: false }],
     ["contextmenu", onContextMenu],
-    ["touchstart", onTouchStart, { passive: true }],
-    ["touchmove", onTouchMove, { passive: true }],
-    ["touchend", onTouchEnd]
+    ["touchstart", onTouchStart, { passive: false }],
+    ["touchmove", onTouchMove, { passive: false }],
+    ["touchend", onTouchEnd],
+    ["gesturestart", onGesture, { passive: false }],
+    ["gesturechange", onGesture, { passive: false }],
+    ["gestureend", onGesture, { passive: false }]
   ];
   for (const [ev, h, opts] of listeners) {
     canvas.addEventListener(ev, h, opts);
   }
   return () => {
-    if (animFrameId) {
-      cancelAnimationFrame(animFrameId);
-    }
     if (scene) {
       const idx = scene._beforeRender.indexOf(applyInertia);
       if (idx >= 0) {
@@ -3680,25 +4398,26 @@ function createFreeCamera(position, target) {
   const dx = target.x - position.x;
   const dy = target.y - position.y;
   const dz = target.z - position.z;
-  const _localMat = new Float32Array(16);
+  const _localMat = allocateMat4();
   function cameraLocalWorldMatrix() {
     const view = mat4LookAtLH(cam.position, cam.target, Vec3Up);
-    _localMat[0] = view[0];
-    _localMat[1] = view[4];
-    _localMat[2] = view[8];
-    _localMat[3] = 0;
-    _localMat[4] = view[1];
-    _localMat[5] = view[5];
-    _localMat[6] = view[9];
-    _localMat[7] = 0;
-    _localMat[8] = view[2];
-    _localMat[9] = view[6];
-    _localMat[10] = view[10];
-    _localMat[11] = 0;
-    _localMat[12] = cam.position.x;
-    _localMat[13] = cam.position.y;
-    _localMat[14] = cam.position.z;
-    _localMat[15] = 1;
+    const m = _localMat;
+    m[0] = view[0];
+    m[1] = view[4];
+    m[2] = view[8];
+    m[3] = 0;
+    m[4] = view[1];
+    m[5] = view[5];
+    m[6] = view[9];
+    m[7] = 0;
+    m[8] = view[2];
+    m[9] = view[6];
+    m[10] = view[10];
+    m[11] = 0;
+    m[12] = cam.position.x;
+    m[13] = cam.position.y;
+    m[14] = cam.position.z;
+    m[15] = 1;
     return _localMat;
   }
   const wm = createWorldMatrixState(cameraLocalWorldMatrix);
@@ -3715,6 +4434,10 @@ function createFreeCamera(position, target) {
     angularSensitivity: 2e3,
     inertia: 0.9,
     children: [],
+    // Matrix caches use the process-global allocator.
+    _viewCache: allocateMat4(),
+    _projCache: allocateMat4(),
+    _vpCache: allocateMat4(),
     get parent() {
       return wm.parent;
     },
@@ -3953,7 +4676,8 @@ function localMatrixFromDirection(dx, dy, dz, px = 0, py = 0, pz = 0, out) {
   rx /= rlen;
   rz /= rlen;
   const ux = fy * rz - fz * ry, uy = fz * rx - fx * rz, uz = fx * ry - fy * rx;
-  const m = out ?? new Float32Array(16);
+  const out4 = out ?? new Float32Array(16);
+  const m = out4;
   m[0] = rx;
   m[1] = ry;
   m[2] = rz;
@@ -3970,11 +4694,13 @@ function localMatrixFromDirection(dx, dy, dz, px = 0, py = 0, pz = 0, out) {
   m[13] = py;
   m[14] = pz;
   m[15] = 1;
-  return m;
+  return out4;
 }
 function createHemisphericLight(direction = [0, 1, 0], intensity = 1) {
-  const _localMatrix = new Float32Array(16);
-  const { wm, onDirty, lvs } = createLightBase(() => localMatrixFromDirection(light.direction.x, light.direction.y, light.direction.z, 0, 0, 0, _localMatrix));
+  const _localMatrix = allocateMat4();
+  const { wm, onDirty, lvs } = createLightBase(() => {
+    return localMatrixFromDirection(light.direction.x, light.direction.y, light.direction.z, 0, 0, 0, _localMatrix);
+  });
   const light = applyWorldMatrixAccessors(
     {
       lightType: "hemispheric",
@@ -4007,15 +4733,19 @@ function createHemisphericLight(direction = [0, 1, 0], intensity = 1) {
   );
   return light;
 }
-function mat4Translation(x, y, z) {
-  const out = mat4Identity();
-  out[12] = x;
-  out[13] = y;
-  out[14] = z;
-  return out;
-}
 function createPointLight(position, intensity = 1) {
-  const { wm, onDirty, lvs } = createLightBase(() => mat4Translation(light.position.x, light.position.y, light.position.z));
+  const m = allocateMat4();
+  m[0] = 1;
+  m[5] = 1;
+  m[10] = 1;
+  m[15] = 1;
+  const _localMatrix = m;
+  const { wm, onDirty, lvs } = createLightBase(() => {
+    m[12] = light.position.x;
+    m[13] = light.position.y;
+    m[14] = light.position.z;
+    return _localMatrix;
+  });
   const light = applyWorldMatrixAccessors(
     {
       lightType: "point",
@@ -4051,10 +4781,10 @@ const pointLight = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   createPointLight
 }, Symbol.toStringTag, { value: "Module" }));
 function createDirectionalLight(direction, intensity = 1) {
-  const _localMatrix = new Float32Array(16);
-  const { wm, onDirty, lvs } = createLightBase(
-    () => localMatrixFromDirection(light.direction.x, light.direction.y, light.direction.z, light.position.x, light.position.y, light.position.z, _localMatrix)
-  );
+  const _localMatrix = allocateMat4();
+  const { wm, onDirty, lvs } = createLightBase(() => {
+    return localMatrixFromDirection(light.direction.x, light.direction.y, light.direction.z, light.position.x, light.position.y, light.position.z, _localMatrix);
+  });
   const light = applyWorldMatrixAccessors(
     {
       lightType: "directional",
@@ -4090,10 +4820,10 @@ const directionalLight = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
   createDirectionalLight
 }, Symbol.toStringTag, { value: "Module" }));
 function createSpotLight(position, direction, angle, exponent, intensity = 1) {
-  const _localMatrix = new Float32Array(16);
-  const { wm, onDirty, lvs } = createLightBase(
-    () => localMatrixFromDirection(light.direction.x, light.direction.y, light.direction.z, light.position.x, light.position.y, light.position.z, _localMatrix)
-  );
+  const _localMatrix = allocateMat4();
+  const { wm, onDirty, lvs } = createLightBase(() => {
+    return localMatrixFromDirection(light.direction.x, light.direction.y, light.direction.z, light.position.x, light.position.y, light.position.z, _localMatrix);
+  });
   let _angle = angle;
   let _cosHalfAngle = Math.cos(angle * 0.5);
   const light = applyWorldMatrixAccessors(
@@ -4153,6 +4883,420 @@ const spotLight = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePro
   __proto__: null,
   createSpotLight
 }, Symbol.toStringTag, { value: "Module" }));
+const PBR_HAS_NORMAL_MAP = 1 << 0;
+const PBR_HAS_EMISSIVE = 1 << 1;
+const PBR_HAS_ENV = 1 << 2;
+const PBR_HAS_ALPHA_TEST = 1 << 3;
+const PBR_HAS_TONEMAP = 1 << 4;
+const PBR_HAS_FOG = 1 << 5;
+const PBR_HAS_ALPHA_BLEND = 1 << 6;
+const PBR_HAS_SPEC_GLOSS = 1 << 7;
+const PBR_HAS_DOUBLE_SIDED = 1 << 8;
+const PBR_HAS_METALLIC_REFLECTANCE_MAP = 1 << 10;
+const PBR_HAS_REFLECTANCE_MAP = 1 << 11;
+const PBR_HAS_USE_ALPHA_ONLY_MR = 1 << 12;
+const PBR_HAS_OCCLUSION = 1 << 15;
+const PBR_HAS_SPECULAR_AA = 1 << 17;
+const PBR_HAS_CLEARCOAT = 1 << 20;
+const PBR_HAS_EMISSIVE_COLOR = 1 << 21;
+const PBR_HAS_SHEEN = 1 << 22;
+const PBR_HAS_SHEEN_TEXTURE = 1 << 23;
+const PBR_HAS_GAMMA_ALBEDO = 1 << 25;
+const PBR_HAS_ANISOTROPY = 1 << 26;
+const PBR_HAS_SUBSURFACE = 1 << 27;
+const PBR_HAS_THICKNESS_MAP = 1 << 28;
+const PBR_HAS_SKYBOX = 1 << 29;
+const PBR_HAS_SHEEN_ALBEDO_SCALING = 1 << 30;
+const PBR2_CC_INT_MAP = 1 << 0;
+const PBR2_CC_ROUGH_MAP = 1 << 1;
+const PBR2_CC_NORMAL_MAP = 1 << 2;
+const PBR2_CC_F0_REMAP_OFF = 1 << 3;
+const PBR2_HAS_REFRACTION = 1 << 4;
+const PBR2_HAS_VOLUME = 1 << 5;
+const PBR2_HAS_REFRACTION_MAP = 1 << 6;
+const PBR2_HAS_THICKNESS_GLTF_CHANNEL = 1 << 7;
+const PBR2_HAS_UNLIT = 1 << 8;
+const PBR2_HAS_UV_TRANSFORM = 1 << 9;
+const PBR2_HAS_REFLECTANCE_FACTORS = 1 << 10;
+const PBR2_HAS_UV2 = 1 << 11;
+const PBR2_HAS_BASE_COLOR_FACTOR = 1 << 12;
+const PBR2_HAS_SHEEN_UV_TX = 1 << 13;
+const PBR2_LINEAR_IMAGE_PROCESSING = 1 << 14;
+const PBR2_NO_COLOR_OUTPUT = 1 << 15;
+const PBR2_ESM_SHADOW_OUTPUT = 1 << 16;
+const PBR2_HAS_IRIDESCENCE = 1 << 17;
+const PBR2_HAS_IRIDESCENCE_MAP = 1 << 18;
+const PBR2_HAS_IRIDESCENCE_THICKNESS_MAP = 1 << 19;
+const PBR2_HAS_DISPERSION = 1 << 20;
+let _pbrExts = null;
+let _pbrExtsSorted = null;
+function _registerPbrExt(ext) {
+  (_pbrExts ?? (_pbrExts = /* @__PURE__ */ new Map())).set(ext.id, ext);
+  _pbrExtsSorted = null;
+}
+function _getPbrExts() {
+  return _pbrExts ?? (_pbrExts = /* @__PURE__ */ new Map());
+}
+function _getPbrExtsSorted() {
+  if (!_pbrExtsSorted) {
+    const map = _pbrExts;
+    _pbrExtsSorted = map ? Array.from(map.values()).sort((a, b) => a.id.localeCompare(b.id)) : [];
+  }
+  return _pbrExtsSorted;
+}
+const CLUSTERED_LIGHT_STRUCTS = `
+struct clusteredLightParamsUniforms {
+tileCountX: u32,
+tileCountY: u32,
+zSlices: u32,
+lightCount: u32,
+sliceScale: f32,
+sliceBias: f32,
+dataTextureWidth: u32,
+batchCount: u32,
+};
+fn clusteredTexel(index:u32)->vec2<u32>{return vec2<u32>(index%clusteredLightParams.dataTextureWidth,index/clusteredLightParams.dataTextureWidth);}
+`;
+const CLUSTERED_LIGHT_BLOCK = `
+{
+let clip=scene.viewProjection*vec4<f32>(input.worldPos,1.0);
+let ndc=clip.xyz/clip.w;
+let tx=clamp(u32((ndc.x*0.5+0.5)*f32(clusteredLightParams.tileCountX)),0u,clusteredLightParams.tileCountX-1u);
+let ty=clamp(u32((0.5-ndc.y*0.5)*f32(clusteredLightParams.tileCountY)),0u,clusteredLightParams.tileCountY-1u);
+let viewPos=scene.view*vec4<f32>(input.worldPos,1.0);
+let tzi=clamp(i32(log(max(viewPos.z,0.0001))*clusteredLightParams.sliceScale+clusteredLightParams.sliceBias),0,i32(clusteredLightParams.zSlices)-1);
+let slice=textureLoad(clusteredCells,clusteredTexel(u32(tzi)),0);
+let directRoughnessCluster=max(roughness,AA_factor_x);
+let directAlphaGCluster=directRoughnessCluster*directRoughnessCluster+0.0005;
+if(slice.x<=slice.y){
+let firstLight=slice.x;
+let lastLight=min(slice.y,clusteredLightParams.lightCount-1u);
+let firstBatch=firstLight/32u;
+let lastBatch=lastLight/32u;
+for(var batch=firstBatch;batch<=lastBatch;batch++){
+let batchOffset=batch*32u;
+let tileMaskIndex=(tx*clusteredLightParams.tileCountY+ty)*clusteredLightParams.batchCount+batch;
+var mask=textureLoad(clusteredIndices,clusteredTexel(tileMaskIndex),0).x;
+let maskOffset=max(firstLight,batchOffset)-batchOffset;
+let maskWidth=min(lastLight-batchOffset+1u,32u);
+mask=extractBits(mask,maskOffset,maskWidth);
+while(mask!=0u){
+let trailing=firstTrailingBit(mask);
+mask^=1u<<trailing;
+let li=batchOffset+maskOffset+trailing;
+let lightTexel=li*2u;
+let positionRange=textureLoad(clusteredLights,clusteredTexel(lightTexel),0);
+let colorIntensity=textureLoad(clusteredLights,clusteredTexel(lightTexel+1u),0);
+let toLight=positionRange.xyz-input.worldPos;
+let d2=dot(toLight,toLight);
+let dist=sqrt(d2);
+let range=max(positionRange.w,0.0001);
+if(dist<range){
+let Lc=toLight/max(dist,0.0001);
+let NdotLc=max(dot(N,Lc),0.0);
+let range2=max(range*range,0.0000001);
+let falloffFactor=d2/range2;
+var rangeAtt=1.0/max(d2,0.0000001);
+var smoothRange=saturate(1.0-falloffFactor*falloffFactor);
+smoothRange*=smoothRange;
+rangeAtt*=smoothRange;
+let lightRadiance=colorIntensity.rgb*colorIntensity.a*rangeAtt*material.directIntensity;
+directDiffuse+=surfaceAlbedo*(1.0/PI)*NdotLc*lightRadiance;
+if(NdotLc>0.0){
+let Hc=normalize(V+Lc);
+let NdotHc=clamp(dot(N,Hc),0.0000001,1.0);
+let VdotHc=saturate(dot(V,Hc));
+let Dc=distributionGGX(NdotHc,directAlphaGCluster);
+let Gc=geometrySmithGGX(NdotLc,NdotV,directAlphaGCluster);
+let Fc=fresnelSchlick(VdotHc,colorF0,colorF90);
+directSpecular+=Fc*Dc*Gc*NdotLc*lightRadiance;
+}
+}
+}
+}
+}
+}
+`;
+const PBR2_HAS_CLUSTERED_LIGHTS = 1 << 17;
+const MAX_DATA_TEXTURE_WIDTH = 8192;
+const CLUSTER_BATCH_SIZE = 32;
+const EMPTY_SLICE_FIRST = 4294967295;
+function createClusteredLightContainer(options) {
+  return {
+    kind: "clusteredLightContainer",
+    pointLights: [],
+    horizontalTiles: (options == null ? void 0 : options.horizontalTiles) ?? 64,
+    verticalTiles: (options == null ? void 0 : options.verticalTiles) ?? 64,
+    zSlices: (options == null ? void 0 : options.zSlices) ?? 16,
+    _version: 0
+  };
+}
+function createClusteredPointLight(container, options) {
+  const light = {
+    position: options.position,
+    diffuse: options.diffuse,
+    range: options.range ?? 1,
+    intensity: options.intensity ?? 1
+  };
+  container.pointLights.push(light);
+  container._version++;
+  return light;
+}
+function markClusteredLightContainerDirty(container) {
+  container._version++;
+}
+function addClusteredLightContainer(scene, container) {
+  const ctx = scene;
+  ctx._clusteredLightContainer = container;
+  _registerPbrExt(clusteredPbrExt);
+  const state = buildClusteredLightGpuState(ctx.engine, ctx, container);
+  ctx._clusteredLightUpdater = (camera, targetWidth, targetHeight) => state.refresh(camera, targetWidth, targetHeight);
+  ctx._disposables.push(() => state.dispose());
+  for (const mesh of ctx.meshes) {
+    if (mesh.material) {
+      const mat = mesh.material;
+      mat._clusteredLightState = state;
+      mat._renderFeatures = void 0;
+    }
+  }
+}
+const clusteredPbrExt = {
+  id: "clustered-lights",
+  phase: "fragment",
+  detect(mat) {
+    return mat._clusteredLightState ? { f: 0, f2: PBR2_HAS_CLUSTERED_LIGHTS } : { f: 0, f2: 0 };
+  },
+  frag(ctx) {
+    if ((ctx._features2 & PBR2_HAS_CLUSTERED_LIGHTS) === 0) {
+      return null;
+    }
+    return {
+      _id: "clustered-lights",
+      _bindings: [
+        { _name: "clusteredLightParams", _type: { _kind: "uniform-buffer" }, _visibility: GPUShaderStage.FRAGMENT },
+        { _name: "clusteredLights", _type: { _kind: "texture", _textureType: "texture_2d<f32>", _sampleType: "unfilterable-float" }, _visibility: GPUShaderStage.FRAGMENT },
+        { _name: "clusteredCells", _type: { _kind: "texture", _textureType: "texture_2d<u32>" }, _visibility: GPUShaderStage.FRAGMENT },
+        { _name: "clusteredIndices", _type: { _kind: "texture", _textureType: "texture_2d<u32>" }, _visibility: GPUShaderStage.FRAGMENT }
+      ],
+      _helperFunctions: CLUSTERED_LIGHT_STRUCTS,
+      _fragmentSlots: { AD: CLUSTERED_LIGHT_BLOCK, BL: CLUSTERED_LIGHT_BLOCK }
+    };
+  },
+  bind(ctx, entries, b) {
+    const state = ctx._material._clusteredLightState;
+    if (!state) {
+      return b;
+    }
+    entries.push({ binding: b++, resource: { buffer: state.paramsBuffer } });
+    entries.push({ binding: b++, resource: state.lightsView });
+    entries.push({ binding: b++, resource: state.cellsView });
+    entries.push({ binding: b++, resource: state.indicesView });
+    return b;
+  }
+};
+function buildClusteredLightGpuState(engine, scene, container) {
+  const camera = scene.camera;
+  if (!camera) {
+    throw new Error("buildClusteredLightGpuState: scene.camera is required");
+  }
+  const width = Math.max(1, engine.canvas.width);
+  const height = Math.max(1, engine.canvas.height);
+  const tileCountX = Math.max(1, container.horizontalTiles | 0);
+  const tileCountY = Math.max(1, container.verticalTiles | 0);
+  const zSlices = Math.max(1, container.zSlices | 0);
+  const dataTextureWidth = Math.max(1, Math.min(MAX_DATA_TEXTURE_WIDTH, engine._device.limits.maxTextureDimension2D));
+  const batchCount = Math.max(1, Math.ceil(container.pointLights.length / CLUSTER_BATCH_SIZE));
+  const lightTexels = Math.max(1, container.pointLights.length * 2);
+  const lightData = new Float32Array(textureElementCount(lightTexels, 4, dataTextureWidth));
+  const sliceData = new Uint32Array(textureElementCount(zSlices, 4, dataTextureWidth));
+  const maskTexels = Math.max(1, tileCountX * tileCountY * batchCount);
+  const maskData = new Uint32Array(textureElementCount(maskTexels, 1, dataTextureWidth));
+  const params = new ArrayBuffer(32);
+  const paramsU = new Uint32Array(params);
+  const paramsF = new Float32Array(params);
+  paramsU[0] = tileCountX;
+  paramsU[1] = tileCountY;
+  paramsU[2] = zSlices;
+  paramsU[3] = container.pointLights.length;
+  paramsF[4] = camera.nearPlane;
+  paramsF[5] = camera.farPlane;
+  paramsU[6] = dataTextureWidth;
+  paramsU[7] = batchCount;
+  const paramsBuffer = createUniformBuffer$1(engine, paramsF, "clustered-light-params");
+  const lightsTexture = createDataTexture(engine, lightData, "rgba32float", 4, lightTexels, "clustered-light-data", dataTextureWidth);
+  const cellsTexture = createDataTexture(engine, sliceData, "rgba32uint", 4, zSlices, "clustered-slice-data", dataTextureWidth);
+  const indicesTexture = createDataTexture(engine, maskData, "r32uint", 1, maskTexels, "clustered-tile-mask-data", dataTextureWidth);
+  let lastCamera;
+  let lastCameraVersion = -1;
+  let lastTargetWidth = 0;
+  let lastTargetHeight = 0;
+  let lastContainerVersion = -1;
+  const state = {
+    paramsBuffer,
+    lightsView: lightsTexture.createView(),
+    cellsView: cellsTexture.createView(),
+    indicesView: indicesTexture.createView(),
+    refresh(activeCamera, targetWidth, targetHeight) {
+      if (!activeCamera) {
+        return;
+      }
+      const safeWidth = Math.max(1, targetWidth);
+      const safeHeight = Math.max(1, targetHeight);
+      if (activeCamera === lastCamera && activeCamera.worldMatrixVersion === lastCameraVersion && safeWidth === lastTargetWidth && safeHeight === lastTargetHeight && container._version === lastContainerVersion) {
+        return;
+      }
+      if (container.pointLights.length * 2 > lightTexels || Math.ceil(container.pointLights.length / CLUSTER_BATCH_SIZE) > batchCount) {
+        throw new Error("ClusteredLightContainer: light count cannot grow after GPU state creation.");
+      }
+      sliceData.fill(0);
+      maskData.fill(0);
+      const aspect = safeWidth / safeHeight;
+      const view = getViewMatrix(activeCamera);
+      const proj = getProjectionMatrix(activeCamera, aspect);
+      const nearZ = activeCamera.nearPlane;
+      const farZ = activeCamera.farPlane;
+      const logFarNear = Math.log(farZ / nearZ);
+      const sliceScale = zSlices / logFarNear;
+      const sliceBias = -(zSlices * Math.log(nearZ)) / logFarNear;
+      const sortedLights = container.pointLights.map((light) => ({ light, depth: viewZ(light.position, view) })).sort((a, b) => a.depth - b.depth);
+      for (let i = 0; i < zSlices; i++) {
+        const off = i * 4;
+        sliceData[off] = EMPTY_SLICE_FIRST;
+        sliceData[off + 1] = 0;
+      }
+      for (let i = 0; i < sortedLights.length; i++) {
+        const { light, depth } = sortedLights[i];
+        const off = i * 8;
+        lightData[off] = light.position[0];
+        lightData[off + 1] = light.position[1];
+        lightData[off + 2] = light.position[2];
+        lightData[off + 3] = light.range;
+        lightData[off + 4] = light.diffuse[0];
+        lightData[off + 5] = light.diffuse[1];
+        lightData[off + 6] = light.diffuse[2];
+        lightData[off + 7] = light.intensity;
+        addLightToClusters(sliceData, maskData, light, depth, i, view, proj, tileCountX, tileCountY, zSlices, sliceScale, sliceBias, batchCount);
+      }
+      paramsU[0] = tileCountX;
+      paramsU[1] = tileCountY;
+      paramsU[2] = zSlices;
+      paramsU[3] = sortedLights.length;
+      paramsF[4] = sliceScale;
+      paramsF[5] = sliceBias;
+      paramsU[7] = batchCount;
+      engine._device.queue.writeBuffer(paramsBuffer, 0, paramsF);
+      writeDataTexture(engine, lightsTexture, lightData, 4, lightTexels, dataTextureWidth);
+      writeDataTexture(engine, cellsTexture, sliceData, 4, zSlices, dataTextureWidth);
+      writeDataTexture(engine, indicesTexture, maskData, 1, maskTexels, dataTextureWidth);
+      lastCamera = activeCamera;
+      lastCameraVersion = activeCamera.worldMatrixVersion;
+      lastTargetWidth = safeWidth;
+      lastTargetHeight = safeHeight;
+      lastContainerVersion = container._version;
+    },
+    dispose() {
+      paramsBuffer.destroy();
+      lightsTexture.destroy();
+      cellsTexture.destroy();
+      indicesTexture.destroy();
+    }
+  };
+  state.refresh(camera, width, height);
+  return state;
+}
+function textureElementCount(texels, components, dataTextureWidth) {
+  return dataTextureWidth * Math.max(1, Math.ceil(texels / dataTextureWidth)) * components;
+}
+function createDataTexture(engine, data, format, components, texels, label, dataTextureWidth) {
+  const height = Math.max(1, Math.ceil(texels / dataTextureWidth));
+  const texture = engine._device.createTexture({
+    label,
+    size: { width: dataTextureWidth, height },
+    format,
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+  });
+  writeDataTexture(engine, texture, data, components, texels, dataTextureWidth);
+  return texture;
+}
+function writeDataTexture(engine, texture, data, components, texels, dataTextureWidth) {
+  const height = Math.max(1, Math.ceil(texels / dataTextureWidth));
+  engine._device.queue.writeTexture({ texture }, data.buffer, { bytesPerRow: dataTextureWidth * components * 4, rowsPerImage: height }, { width: dataTextureWidth, height });
+}
+function addLightToClusters(sliceData, maskData, light, viewDepth, lightIndex, view, proj, tileCountX, tileCountY, zSlices, sliceScale, sliceBias, batchCount) {
+  const vx = view[0] * light.position[0] + view[4] * light.position[1] + view[8] * light.position[2] + view[12];
+  const vy = view[1] * light.position[0] + view[5] * light.position[1] + view[9] * light.position[2] + view[13];
+  const vz = viewDepth;
+  const range = Math.max(0, light.range);
+  const firstSlice = getSliceIndex(vz - range, sliceScale, sliceBias);
+  const lastSlice = getSliceIndex(vz + range, sliceScale, sliceBias);
+  if (lastSlice < 0 || firstSlice >= zSlices) {
+    return;
+  }
+  const bounds = projectedSphereBounds(vx, vy, vz, range, proj, tileCountX, tileCountY);
+  const minX = bounds[0];
+  const maxX = bounds[1];
+  const minY = bounds[2];
+  const maxY = bounds[3];
+  const z0 = clampInt(firstSlice, 0, zSlices - 1);
+  const z1 = clampInt(lastSlice, 0, zSlices - 1);
+  for (let z = z0; z <= z1; z++) {
+    const off = z * 4;
+    sliceData[off] = Math.min(sliceData[off], lightIndex);
+    sliceData[off + 1] = Math.max(sliceData[off + 1], lightIndex);
+  }
+  const batch = Math.floor(lightIndex / CLUSTER_BATCH_SIZE);
+  const bit = 1 << lightIndex % CLUSTER_BATCH_SIZE;
+  for (let y = minY; y <= maxY; y++) {
+    for (let x = minX; x <= maxX; x++) {
+      const maskIndex = (x * tileCountY + y) * batchCount + batch;
+      maskData[maskIndex] = maskData[maskIndex] | bit;
+    }
+  }
+}
+function viewZ(position, view) {
+  return view[2] * position[0] + view[6] * position[1] + view[10] * position[2] + view[14];
+}
+function getSliceIndex(depth, sliceScale, sliceBias) {
+  return depth > 0 ? Math.floor(Math.log(depth) * sliceScale + sliceBias) : -1;
+}
+function clampInt(v, min, max) {
+  return v < min ? min : v > max ? max : v;
+}
+function projectedSphereBounds(vx, vy, vz, range, proj, tileCountX, tileCountY) {
+  const rangeSq = range * range;
+  let minNdcX = -1;
+  let maxNdcX = 1;
+  let minNdcY = -1;
+  let maxNdcY = 1;
+  if (vz > range) {
+    const x0 = projectedSphereEdge(vx, vz, rangeSq, proj[0], -1);
+    const x1 = projectedSphereEdge(vx, vz, rangeSq, proj[0], 1);
+    minNdcX = Math.min(x0, x1);
+    maxNdcX = Math.max(x0, x1);
+    const y0 = projectedSphereEdge(vy, vz, rangeSq, proj[5], -1);
+    const y1 = projectedSphereEdge(vy, vz, rangeSq, proj[5], 1);
+    minNdcY = Math.min(y0, y1);
+    maxNdcY = Math.max(y0, y1);
+  }
+  return [
+    clampInt(Math.floor((minNdcX * 0.5 + 0.5) * tileCountX) - 1, 0, tileCountX - 1),
+    clampInt(Math.floor((maxNdcX * 0.5 + 0.5) * tileCountX) + 1, 0, tileCountX - 1),
+    clampInt(Math.floor((0.5 - maxNdcY * 0.5) * tileCountY) - 1, 0, tileCountY - 1),
+    clampInt(Math.floor((0.5 - minNdcY * 0.5) * tileCountY) + 1, 0, tileCountY - 1)
+  ];
+}
+function projectedSphereEdge(axis, depth, rangeSq, projectionScale, side) {
+  const distSq = axis * axis + depth * depth;
+  if (distSq <= rangeSq) {
+    return side;
+  }
+  const sinSq = rangeSq / distSq;
+  const cosSq = Math.max(1 - sinSq, 0.01);
+  const sinCos = side * Math.sqrt(sinSq * cosSq);
+  const rotatedAxis = cosSq * axis + sinCos * depth;
+  const rotatedDepth = -sinCos * axis + cosSq * depth;
+  return projectionScale * rotatedAxis / Math.max(rotatedDepth, 0.01);
+}
 function mat4ComposeInto(dst, off, tx, ty, tz, qx, qy, qz, qw, sx, sy, sz) {
   const xx = qx * qx, yy = qy * qy, zz = qz * qz;
   const xy = qx * qy, xz = qx * qz, yz = qy * qz;
@@ -4186,18 +5330,26 @@ class ObservableQuat {
     __publicField(this, "_z");
     __publicField(this, "_w");
     __publicField(this, "_onDirty");
+    /** Bumped on every value change. Lets derived caches (e.g. the Euler proxy) detect
+     *  external quaternion writes and re-sync only when needed. */
+    __publicField(this, "_version", 0);
     this._x = x;
     this._y = y;
     this._z = z;
     this._w = w;
     this._onDirty = onDirty;
   }
+  /** Monotonic change counter — incremented whenever any component changes. */
+  get version() {
+    return this._version;
+  }
   get x() {
     return this._x;
   }
   set x(v) {
     if (this._x !== v) {
       this._x = v;
+      this._version++;
       this._onDirty();
     }
   }
@@ -4207,6 +5359,7 @@ class ObservableQuat {
   set y(v) {
     if (this._y !== v) {
       this._y = v;
+      this._version++;
       this._onDirty();
     }
   }
@@ -4216,6 +5369,7 @@ class ObservableQuat {
   set z(v) {
     if (this._z !== v) {
       this._z = v;
+      this._version++;
       this._onDirty();
     }
   }
@@ -4225,6 +5379,7 @@ class ObservableQuat {
   set w(v) {
     if (this._w !== v) {
       this._w = v;
+      this._version++;
       this._onDirty();
     }
   }
@@ -4234,6 +5389,7 @@ class ObservableQuat {
     this._y = y;
     this._z = z;
     this._w = w;
+    this._version++;
     this._onDirty();
   }
   /** Copy values from another quaternion. */
@@ -4262,34 +5418,53 @@ function quatToEulerXYZ(qx, qy, qz, qw) {
   return [rx, ry, rz];
 }
 function createEulerProxy(rq) {
-  const e = () => quatToEulerXYZ(rq.x, rq.y, rq.z, rq.w);
-  const s = (x, y, z) => {
+  let ex = 0;
+  let ey = 0;
+  let ez = 0;
+  let syncedVersion = -1;
+  const sync = () => {
+    if (rq.version !== syncedVersion) {
+      const e = quatToEulerXYZ(rq.x, rq.y, rq.z, rq.w);
+      ex = e[0];
+      ey = e[1];
+      ez = e[2];
+      syncedVersion = rq.version;
+    }
+  };
+  const apply = (x, y, z) => {
+    ex = x;
+    ey = y;
+    ez = z;
     const [a, b, c, d] = eulerToQuat(x, y, z);
     rq.set(a, b, c, d);
+    syncedVersion = rq.version;
   };
   return {
     get x() {
-      return e()[0];
+      sync();
+      return ex;
     },
     set x(v) {
-      const r = e();
-      s(v, r[1], r[2]);
+      sync();
+      apply(v, ey, ez);
     },
     get y() {
-      return e()[1];
+      sync();
+      return ey;
     },
     set y(v) {
-      const r = e();
-      s(r[0], v, r[2]);
+      sync();
+      apply(ex, v, ez);
     },
     get z() {
-      return e()[2];
+      sync();
+      return ez;
     },
     set z(v) {
-      const r = e();
-      s(r[0], r[1], v);
+      sync();
+      apply(ex, ey, v);
     },
-    set: s
+    set: apply
   };
 }
 function createSceneNode(name, px = 0, py = 0, pz = 0, qx = 0, qy = 0, qz = 0, qw = 1, sx = 1, sy = 1, sz = 1) {
@@ -4867,6 +6042,150 @@ function createTorusData(opts = {}) {
   }
   return { positions, normals, uvs, indices };
 }
+function computeNormals(positions, indices) {
+  const n = positions.length;
+  const pos = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    pos[i] = positions[i];
+  }
+  const idx = new Uint32Array(indices.length);
+  for (let i = 0; i < indices.length; i++) {
+    idx[i] = indices[i];
+  }
+  const normals = new Float64Array(n);
+  const nbFaces = indices.length / 3 | 0;
+  for (let f = 0; f < nbFaces; f++) {
+    const v1x = idx[f * 3] * 3;
+    const v2x = idx[f * 3 + 1] * 3;
+    const v3x = idx[f * 3 + 2] * 3;
+    const p1p2x = pos[v1x] - pos[v2x];
+    const p1p2y = pos[v1x + 1] - pos[v2x + 1];
+    const p1p2z = pos[v1x + 2] - pos[v2x + 2];
+    const p3p2x = pos[v3x] - pos[v2x];
+    const p3p2y = pos[v3x + 1] - pos[v2x + 1];
+    const p3p2z = pos[v3x + 2] - pos[v2x + 2];
+    let nx = p1p2y * p3p2z - p1p2z * p3p2y;
+    let ny = p1p2z * p3p2x - p1p2x * p3p2z;
+    let nz = p1p2x * p3p2y - p1p2y * p3p2x;
+    let len2 = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len2 === 0) {
+      len2 = 1;
+    }
+    nx /= len2;
+    ny /= len2;
+    nz /= len2;
+    normals[v1x] = normals[v1x] + nx;
+    normals[v1x + 1] = normals[v1x + 1] + ny;
+    normals[v1x + 2] = normals[v1x + 2] + nz;
+    normals[v2x] = normals[v2x] + nx;
+    normals[v2x + 1] = normals[v2x + 1] + ny;
+    normals[v2x + 2] = normals[v2x + 2] + nz;
+    normals[v3x] = normals[v3x] + nx;
+    normals[v3x + 1] = normals[v3x + 1] + ny;
+    normals[v3x + 2] = normals[v3x + 2] + nz;
+  }
+  const nVerts = n / 3 | 0;
+  const out = new Array(n);
+  for (let i = 0; i < nVerts; i++) {
+    const x = normals[i * 3];
+    const y = normals[i * 3 + 1];
+    const z = normals[i * 3 + 2];
+    let len2 = Math.sqrt(x * x + y * y + z * z);
+    if (len2 === 0) {
+      len2 = 1;
+    }
+    out[i * 3] = x / len2;
+    out[i * 3 + 1] = y / len2;
+    out[i * 3 + 2] = z / len2;
+  }
+  return out;
+}
+function createTorusKnotData(opts = {}) {
+  const radius = opts.radius ?? 2;
+  const tube = opts.tube ?? 0.5;
+  const radialSegments = opts.radialSegments ?? 32;
+  const tubularSegments = opts.tubularSegments ?? 32;
+  const p = opts.p ?? 2;
+  const q = opts.q ?? 3;
+  const positions = [];
+  const uvs = [];
+  const indices = [];
+  const getPos = (angle) => {
+    const cu = Math.cos(angle);
+    const su = Math.sin(angle);
+    const quOverP = q / p * angle;
+    const cs = Math.cos(quOverP);
+    const tx = radius * (2 + cs) * 0.5 * cu;
+    const ty = radius * (2 + cs) * su * 0.5;
+    const tz = radius * Math.sin(quOverP) * 0.5;
+    return [tx, ty, tz];
+  };
+  for (let i = 0; i <= radialSegments; i++) {
+    const modI = i % radialSegments;
+    const u = modI / radialSegments * 2 * p * Math.PI;
+    const p1 = getPos(u);
+    const p2 = getPos(u + 0.01);
+    const tangX = p2[0] - p1[0];
+    const tangY = p2[1] - p1[1];
+    const tangZ = p2[2] - p1[2];
+    let nX = p2[0] + p1[0];
+    let nY = p2[1] + p1[1];
+    let nZ = p2[2] + p1[2];
+    let bitanX = tangY * nZ - tangZ * nY;
+    let bitanY = tangZ * nX - tangX * nZ;
+    let bitanZ = tangX * nY - tangY * nX;
+    nX = bitanY * tangZ - bitanZ * tangY;
+    nY = bitanZ * tangX - bitanX * tangZ;
+    nZ = bitanX * tangY - bitanY * tangX;
+    let bitanLen = Math.sqrt(bitanX * bitanX + bitanY * bitanY + bitanZ * bitanZ);
+    if (bitanLen === 0) {
+      bitanLen = 1;
+    }
+    bitanX /= bitanLen;
+    bitanY /= bitanLen;
+    bitanZ /= bitanLen;
+    let nLen = Math.sqrt(nX * nX + nY * nY + nZ * nZ);
+    if (nLen === 0) {
+      nLen = 1;
+    }
+    nX /= nLen;
+    nY /= nLen;
+    nZ /= nLen;
+    for (let j = 0; j < tubularSegments; j++) {
+      const modJ = j % tubularSegments;
+      const v = modJ / tubularSegments * 2 * Math.PI;
+      const cx = -tube * Math.cos(v);
+      const cy = tube * Math.sin(v);
+      positions.push(p1[0] + cx * nX + cy * bitanX);
+      positions.push(p1[1] + cx * nY + cy * bitanY);
+      positions.push(p1[2] + cx * nZ + cy * bitanZ);
+      uvs.push(i / radialSegments);
+      uvs.push(j / tubularSegments);
+    }
+  }
+  for (let i = 0; i < radialSegments; i++) {
+    for (let j = 0; j < tubularSegments; j++) {
+      const jNext = (j + 1) % tubularSegments;
+      const a = i * tubularSegments + j;
+      const b = (i + 1) * tubularSegments + j;
+      const c = (i + 1) * tubularSegments + jNext;
+      const d = i * tubularSegments + jNext;
+      indices.push(d);
+      indices.push(b);
+      indices.push(a);
+      indices.push(d);
+      indices.push(c);
+      indices.push(b);
+    }
+  }
+  const normals = computeNormals(positions, indices);
+  return {
+    positions: new Float32Array(positions),
+    normals: new Float32Array(normals),
+    uvs: new Float32Array(uvs),
+    indices: new Uint32Array(indices)
+  };
+}
 function createFlatGroundData(opts = {}) {
   var _a, _b;
   const width = opts.width ?? 1;
@@ -5615,64 +6934,6 @@ const POLYHEDRA = [
     ]
   }
 ];
-function computeNormals(positions, indices) {
-  const n = positions.length;
-  const pos = new Float64Array(n);
-  for (let i = 0; i < n; i++) {
-    pos[i] = positions[i];
-  }
-  const idx = new Uint32Array(indices.length);
-  for (let i = 0; i < indices.length; i++) {
-    idx[i] = indices[i];
-  }
-  const normals = new Float64Array(n);
-  const nbFaces = indices.length / 3 | 0;
-  for (let f = 0; f < nbFaces; f++) {
-    const v1x = idx[f * 3] * 3;
-    const v2x = idx[f * 3 + 1] * 3;
-    const v3x = idx[f * 3 + 2] * 3;
-    const p1p2x = pos[v1x] - pos[v2x];
-    const p1p2y = pos[v1x + 1] - pos[v2x + 1];
-    const p1p2z = pos[v1x + 2] - pos[v2x + 2];
-    const p3p2x = pos[v3x] - pos[v2x];
-    const p3p2y = pos[v3x + 1] - pos[v2x + 1];
-    const p3p2z = pos[v3x + 2] - pos[v2x + 2];
-    let nx = p1p2y * p3p2z - p1p2z * p3p2y;
-    let ny = p1p2z * p3p2x - p1p2x * p3p2z;
-    let nz = p1p2x * p3p2y - p1p2y * p3p2x;
-    let len2 = Math.sqrt(nx * nx + ny * ny + nz * nz);
-    if (len2 === 0) {
-      len2 = 1;
-    }
-    nx /= len2;
-    ny /= len2;
-    nz /= len2;
-    normals[v1x] = normals[v1x] + nx;
-    normals[v1x + 1] = normals[v1x + 1] + ny;
-    normals[v1x + 2] = normals[v1x + 2] + nz;
-    normals[v2x] = normals[v2x] + nx;
-    normals[v2x + 1] = normals[v2x + 1] + ny;
-    normals[v2x + 2] = normals[v2x + 2] + nz;
-    normals[v3x] = normals[v3x] + nx;
-    normals[v3x + 1] = normals[v3x + 1] + ny;
-    normals[v3x + 2] = normals[v3x + 2] + nz;
-  }
-  const nVerts = n / 3 | 0;
-  const out = new Array(n);
-  for (let i = 0; i < nVerts; i++) {
-    const x = normals[i * 3];
-    const y = normals[i * 3 + 1];
-    const z = normals[i * 3 + 2];
-    let len2 = Math.sqrt(x * x + y * y + z * z);
-    if (len2 === 0) {
-      len2 = 1;
-    }
-    out[i * 3] = x / len2;
-    out[i * 3 + 1] = y / len2;
-    out[i * 3 + 2] = z / len2;
-  }
-  return out;
-}
 function createPolyhedronData(options = {}) {
   const type = options.type !== void 0 && (options.type < 0 || options.type >= POLYHEDRA.length) ? 0 : options.type ?? 0;
   const size = options.size;
@@ -6178,6 +7439,10 @@ function createTorus(engine, options) {
   const data = createTorusData(options);
   return createMeshFromData(engine, "torus", data.positions, data.normals, data.indices, data.uvs);
 }
+function createTorusKnot(engine, options) {
+  const data = createTorusKnotData(options);
+  return createMeshFromData(engine, "torusKnot", data.positions, data.normals, data.indices, data.uvs);
+}
 async function createGroundFromHeightMap(engine, url, options) {
   const data = await createGroundFromHeightMap$1(url, options);
   return createMeshFromData(engine, "ground", data.positions, data.normals, data.indices, data.uvs);
@@ -6214,7 +7479,8 @@ function createExtrudeShape(engine, options) {
   const data = createExtrudeShapeData(options);
   return createMeshFromData(engine, "extrude", data.positions, data.normals, data.indices, data.uvs);
 }
-function mat4Invert(m) {
+function mat4Invert(input) {
+  const m = input;
   const a00 = m[0], a01 = m[1], a02 = m[2], a03 = m[3];
   const a10 = m[4], a11 = m[5], a12 = m[6], a13 = m[7];
   const a20 = m[8], a21 = m[9], a22 = m[10], a23 = m[11];
@@ -6842,6 +8108,21 @@ function createTexture2DFromPixels(engine, data, width, height, options = {}) {
   acquireTexture(tex);
   return tex;
 }
+function updateTexture2DFromPixels(engine, tex, data, x = 0, y = 0, width = tex.width, height = tex.height) {
+  if (width < 1 || height < 1) {
+    throw new Error(`updateTexture2DFromPixels: width/height must be >= 1 (got ${width}x${height})`);
+  }
+  const expected = width * height * 4;
+  if (data.length < expected) {
+    throw new Error(`updateTexture2DFromPixels: data too short — need ${expected} bytes for ${width}x${height} RGBA, got ${data.length}`);
+  }
+  engine._device.queue.writeTexture(
+    { texture: tex.texture, origin: { x, y } },
+    data,
+    { bytesPerRow: width * 4, rowsPerImage: height },
+    { width, height }
+  );
+}
 function cloneTexture2D(base, transform) {
   return { ...base, ...transform };
 }
@@ -7072,7 +8353,9 @@ function uploadCompressed(engine, parsed, opts) {
     const mip = parsed.mips[i];
     const blocksPerRow = Math.ceil(mip.width / fmt.blockW);
     const rowBytes = blocksPerRow * fmt.blockBytes;
-    device.queue.writeTexture({ texture, mipLevel: i }, mip.data, { bytesPerRow: rowBytes }, { width: mip.width, height: mip.height });
+    const copyW = blocksPerRow * fmt.blockW;
+    const copyH = Math.ceil(mip.height / fmt.blockH) * fmt.blockH;
+    device.queue.writeTexture({ texture, mipLevel: i }, mip.data, { bytesPerRow: rowBytes }, { width: copyW, height: copyH });
   }
   const minF = opts.minFilter ?? "linear";
   const magF = opts.magFilter ?? "linear";
@@ -7354,35 +8637,47 @@ function _getStdExtsSorted() {
 const NEEDS_UV = HAS_DIFFUSE_TEXTURE | HAS_EMISSIVE_TEXTURE | HAS_BUMP_TEXTURE | HAS_SPECULAR_TEXTURE | HAS_AMBIENT_TEXTURE | HAS_LIGHTMAP_TEXTURE | HAS_OPACITY_TEXTURE;
 const NEEDS_UV2 = LIGHTMAP_USES_UV2 | AMBIENT_USES_UV2 | DIFFUSE_USES_UV2 | SPECULAR_USES_UV2;
 const _STD_MAT_EXTS = [
-  ["bumpTexture", () => import("./normal-map-fragment-DpsIXrJf.js"), "bumpStdExt"],
-  ["emissiveTexture", () => import("./std-emissive-fragment-DNGj1HdQ.js"), "stdEmissiveExt"],
-  ["specularTexture", () => import("./std-specular-fragment-CE-6scqd.js"), "stdSpecularExt"],
-  ["ambientTexture", () => import("./std-ambient-fragment-BoUsD06w.js"), "stdAmbientExt"],
-  ["lightmapTexture", () => import("./std-lightmap-fragment-Bqj89aIe.js"), "stdLightmapExt"],
-  ["opacityTexture", () => import("./std-opacity-fragment-KuPh5N2Z.js"), "stdOpacityExt"],
-  ["reflectionTexture", () => import("./std-reflection-fragment-BA5Ghn_M.js"), "stdReflectionExt"],
-  ["reflectionCubeTexture", () => import("./std-cube-reflection-fragment-ulqc3bsP.js"), "stdCubeReflectionExt"]
+  ["bumpTexture", () => import("./normal-map-fragment-DradEMl-.js"), "bumpStdExt"],
+  ["emissiveTexture", () => import("./std-emissive-fragment-B-A83rqX.js"), "stdEmissiveExt"],
+  ["specularTexture", () => import("./std-specular-fragment-C2ZOss-t.js"), "stdSpecularExt"],
+  ["ambientTexture", () => import("./std-ambient-fragment-C6WNm8dQ.js"), "stdAmbientExt"],
+  ["lightmapTexture", () => import("./std-lightmap-fragment-Df7KJezh.js"), "stdLightmapExt"],
+  ["opacityTexture", () => import("./std-opacity-fragment-D9et2jip.js"), "stdOpacityExt"],
+  ["reflectionTexture", () => import("./std-reflection-fragment-DBJeT-yg.js"), "stdReflectionExt"],
+  ["reflectionCubeTexture", () => import("./std-cube-reflection-fragment-Bqutpy2q.js"), "stdCubeReflectionExt"]
 ];
 const standardGroupBuilder = async (scene, meshes) => {
   const hasTI = meshes.some((m) => !!m.thinInstances);
+  const hasCulling = meshes.some((m) => {
+    var _a;
+    return !!((_a = m.thinInstances) == null ? void 0 : _a._gpuCullingEnabled);
+  });
   const hasShadow = meshes.some((m) => m.receiveShadows) && scene.lights.some((l) => !!l.shadowGenerator);
   let tiSync;
   let tiFragment;
   let shadowFragment;
+  let cull;
   const imports = [];
   if (hasTI) {
     imports.push(
-      import("./thin-instance-gpu-C9Gv_Z1w.js").then((m) => {
+      import("./thin-instance-gpu-E8DBd8XL.js").then((m) => {
         tiSync = m.syncThinInstanceBuffers;
       }),
       import("./thin-instance-fragment-hsv-RyDs.js").then((m) => {
         tiFragment = m.createThinInstanceFragment;
       })
     );
+    if (hasCulling) {
+      imports.push(
+        import("./thin-instance-cull-binding-CCxrPNO6.js").then((m) => {
+          cull = m;
+        })
+      );
+    }
   }
   if (hasShadow) {
     imports.push(
-      import("./std-shadow-fragment-FNQfrJuC.js").then((m) => {
+      import("./std-shadow-fragment-C6fD8rW-.js").then((m) => {
         shadowFragment = m.createStdShadowFragment;
       })
     );
@@ -7395,12 +8690,8 @@ const standardGroupBuilder = async (scene, meshes) => {
   if (imports.length > 0) {
     await Promise.all(imports);
   }
-  const renderableMod = await import("./standard-renderable-GjxL9xSf.js");
-  const result = renderableMod.buildStandardMeshRenderables(scene, meshes, {
-    tiSync,
-    tiFragment,
-    shadowFragment
-  });
+  const renderableMod = await import("./standard-renderable-D1bhoF0K.js");
+  const result = renderableMod.buildStandardMeshRenderables(scene, meshes, { tiSync, tiFragment, shadowFragment, cull });
   standardGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
 };
@@ -7472,69 +8763,9 @@ const noColorView$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defin
   __proto__: null,
   createStandardNoColorMaterialView: createStandardNoColorMaterialView$1
 }, Symbol.toStringTag, { value: "Module" }));
-const PBR_HAS_NORMAL_MAP = 1 << 0;
-const PBR_HAS_EMISSIVE = 1 << 1;
-const PBR_HAS_ENV = 1 << 2;
-const PBR_HAS_ALPHA_TEST = 1 << 3;
-const PBR_HAS_TONEMAP = 1 << 4;
-const PBR_HAS_ALPHA_BLEND = 1 << 6;
-const PBR_HAS_SPEC_GLOSS = 1 << 7;
-const PBR_HAS_DOUBLE_SIDED = 1 << 8;
-const PBR_HAS_METALLIC_REFLECTANCE_MAP = 1 << 10;
-const PBR_HAS_REFLECTANCE_MAP = 1 << 11;
-const PBR_HAS_USE_ALPHA_ONLY_MR = 1 << 12;
-const PBR_HAS_OCCLUSION = 1 << 15;
-const PBR_HAS_SPECULAR_AA = 1 << 17;
-const PBR_HAS_CLEARCOAT = 1 << 20;
-const PBR_HAS_EMISSIVE_COLOR = 1 << 21;
-const PBR_HAS_SHEEN = 1 << 22;
-const PBR_HAS_SHEEN_TEXTURE = 1 << 23;
-const PBR_HAS_GAMMA_ALBEDO = 1 << 25;
-const PBR_HAS_ANISOTROPY = 1 << 26;
-const PBR_HAS_SUBSURFACE = 1 << 27;
-const PBR_HAS_THICKNESS_MAP = 1 << 28;
-const PBR_HAS_SKYBOX = 1 << 29;
-const PBR_HAS_SHEEN_ALBEDO_SCALING = 1 << 30;
-const PBR2_CC_INT_MAP = 1 << 0;
-const PBR2_CC_ROUGH_MAP = 1 << 1;
-const PBR2_CC_NORMAL_MAP = 1 << 2;
-const PBR2_CC_F0_REMAP_OFF = 1 << 3;
-const PBR2_HAS_REFRACTION = 1 << 4;
-const PBR2_HAS_VOLUME = 1 << 5;
-const PBR2_HAS_REFRACTION_MAP = 1 << 6;
-const PBR2_HAS_THICKNESS_GLTF_CHANNEL = 1 << 7;
-const PBR2_HAS_UNLIT = 1 << 8;
-const PBR2_HAS_UV_TRANSFORM = 1 << 9;
-const PBR2_HAS_REFLECTANCE_FACTORS = 1 << 10;
-const PBR2_HAS_UV2 = 1 << 11;
-const PBR2_HAS_BASE_COLOR_FACTOR = 1 << 12;
-const PBR2_HAS_SHEEN_UV_TX = 1 << 13;
-const PBR2_LINEAR_IMAGE_PROCESSING = 1 << 14;
-const PBR2_NO_COLOR_OUTPUT = 1 << 15;
-const PBR2_ESM_SHADOW_OUTPUT = 1 << 16;
-const PBR2_HAS_IRIDESCENCE = 1 << 17;
-const PBR2_HAS_IRIDESCENCE_MAP = 1 << 18;
-const PBR2_HAS_IRIDESCENCE_THICKNESS_MAP = 1 << 19;
-const PBR2_HAS_DISPERSION = 1 << 20;
-let _pbrExts = null;
-let _pbrExtsSorted = null;
-function _registerPbrExt(ext) {
-  (_pbrExts ?? (_pbrExts = /* @__PURE__ */ new Map())).set(ext.id, ext);
-  _pbrExtsSorted = null;
-}
-function _getPbrExts() {
-  return _pbrExts ?? (_pbrExts = /* @__PURE__ */ new Map());
-}
-function _getPbrExtsSorted() {
-  if (!_pbrExtsSorted) {
-    const map = _pbrExts;
-    _pbrExtsSorted = map ? Array.from(map.values()).sort((a, b) => a.id.localeCompare(b.id)) : [];
-  }
-  return _pbrExtsSorted;
-}
 const pbrGroupBuilder = async (scene, meshes) => {
   const envTex = scene._envTextures;
-  const renderableMod = await import("./pbr-renderable-BJxUtPBb.js");
+  const renderableMod = await import("./pbr-renderable-BHAdF5Vw.js");
   const result = await renderableMod.buildPbrRenderables(scene, meshes, envTex);
   pbrGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
@@ -7612,11 +8843,12 @@ function collectPbrBoundTextures(mat) {
   return t;
 }
 const shaderGroupBuilder = async (scene, meshes) => {
-  const { buildShaderMaterialRenderables } = await import("./shader-renderable-D-6796KR.js");
-  const result = buildShaderMaterialRenderables(scene, meshes);
+  const { buildShaderGroup } = await import("./shader-renderable-BMf_vvO0.js");
+  const result = await buildShaderGroup(scene, meshes);
   shaderGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
 };
+shaderGroupBuilder._materialFamily = "shader";
 function isIdentifier(name) {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
 }
@@ -7677,7 +8909,12 @@ function createShaderMaterial(options) {
   const samplerDecls = [];
   const textureSlots = /* @__PURE__ */ new Map();
   for (const opt of options.samplers ?? []) {
-    const decl = typeof opt === "string" ? { name: opt, sampleType: "float" } : { name: opt.name, sampleType: opt.sampleType ?? "float" };
+    const decl = typeof opt === "string" ? { name: opt, sampleType: "float" } : {
+      name: opt.name,
+      sampleType: opt.sampleType ?? (opt.comparison ? "depth" : "float"),
+      viewDimension: opt.viewDimension ?? "2d",
+      comparison: opt.comparison ?? false
+    };
     assertIdentifier("sampler", decl.name);
     assertUniqueName(usedNames, "sampler", decl.name);
     assertUniqueName(usedNames, "sampler", `${decl.name}Sampler`);
@@ -7694,6 +8931,9 @@ function createShaderMaterial(options) {
     defines.push({ name, value });
   }
   defines.sort((a, b) => a.name.localeCompare(b.name));
+  if (options.transmissive && !(options.needAlphaBlending ?? false)) {
+    throw new Error("ShaderMaterial: `transmissive` requires `needAlphaBlending` (the surface composites over the grabbed opaque scene color).");
+  }
   return {
     name: options.name,
     vertexSource: options.vertexSource,
@@ -7704,6 +8944,7 @@ function createShaderMaterial(options) {
     defines,
     needAlphaBlending: options.needAlphaBlending ?? false,
     blendMode: options.blendMode ?? "alpha",
+    transmissive: options.transmissive ?? false,
     needAlphaTesting: options.needAlphaTesting ?? false,
     backFaceCulling: options.backFaceCulling ?? true,
     depthWrite: options.depthWrite ?? true,
@@ -7784,7 +9025,7 @@ function setShaderTexture(material, name, texture) {
     throw new Error(`ShaderMaterial: sampler "${name}" was not declared.`);
   }
   if (texture) {
-    const expectsDepth = slot.decl.sampleType === "depth";
+    const expectsDepth = slot.decl.sampleType === "depth" || slot.decl.comparison === true;
     const isDepthTexture = texture._sampleType === "depth";
     if (expectsDepth && !isDepthTexture) {
       throw new Error(`ShaderMaterial: sampler "${name}" expects a depth Texture2D.`);
@@ -7803,7 +9044,7 @@ function setShaderVector3(material, name, value) {
   setShaderUniform(material, name, value);
 }
 function setShaderMatrix(material, name, value) {
-  setShaderUniform(material, name, value);
+  setShaderUniform(material, name, value instanceof Float32Array ? value : Array.from(value));
 }
 function buildVertexOutputStruct(hasOpacity) {
   return `struct VertexOutput{@builtin(position) position:vec4<f32>,@location(0) vPosition:vec3<f32>,@location(1) vNormal:vec3<f32>,${hasOpacity ? "@location(2) vUv:vec2<f32>," : ""}};`;
@@ -8098,7 +9339,7 @@ function bridgeVarying(state, varyingName, value, from, to) {
 }
 let defaultRegistry = null;
 async function defaultBlockLoader(className) {
-  defaultRegistry ?? (defaultRegistry = import("./node-registry-DwgC4yth.js"));
+  defaultRegistry ?? (defaultRegistry = import("./node-registry-Bd-AlrgC.js"));
   return (await defaultRegistry).loadBlockEmitter(className);
 }
 function pbrMrBlockNeedsFullEmitter(block) {
@@ -8589,7 +9830,7 @@ async function parseNodeMaterialFromSnippet(engine, snippetId, options = {}) {
   }
   let _shadowEmitter;
   if (options.shadowGenerators && options.shadowGenerators.length > 0) {
-    _shadowEmitter = (await import("./node-shadow-DKrcqmNg.js")).emitShadow;
+    _shadowEmitter = (await import("./node-shadow-CpnrdvtJ.js")).emitShadow;
   }
   const compile = compileNodePipeline(state, vertexWgsl, fragmentWgsl, {
     _engine: engine,
@@ -8678,7 +9919,7 @@ async function parseNodeMaterialFromSnippet(engine, snippetId, options = {}) {
     inputs[tb._name] = handle;
   }
   const _buildGroup = async (scene, meshes) => {
-    const { buildNodeMeshRenderables } = await import("./node-renderable-DlLIdBmd.js");
+    const { buildNodeMeshRenderables } = await import("./node-renderable-CS0CmsSp.js");
     const result = buildNodeMeshRenderables(scene, meshes);
     _buildGroup._rebuildSingle = result.rebuildSingle;
     return result;
@@ -8715,7 +9956,7 @@ async function resolvePbrMrHelpers(state) {
   if (state.pbrMrHelperRequests.some((request) => !isCorePbrMrRequest(request))) {
     throw new Error("NodeMaterial: advanced PBR-MR helper request must be emitted by the full PBR-MR block");
   }
-  const core = await import("./pbr-mr-helper-core-CIwm-T1G.js");
+  const core = await import("./pbr-mr-helper-core-R5tOZ8Ap.js");
   for (const request of state.pbrMrHelperRequests) {
     state.fragment.helpers.set(request.key, core.buildPbrMrHelperCore(request));
   }
@@ -8884,13 +10125,355 @@ function rebuildSceneMesh(ctx, mesh) {
   }
   ctx._renderables.splice(i, 0, renderable);
 }
+const STAGE_FRAGMENT$1 = 2;
+const STD_PLUGIN_UBO = "pluginUbo";
+const FRAG_POINT_TO_SLOTS = {
+  CUSTOM_FRAGMENT_MAIN_BEGIN: ["SV"],
+  CUSTOM_FRAGMENT_UPDATE_ALPHA: ["AT"],
+  CUSTOM_FRAGMENT_UPDATE_DIFFUSE: ["AC"],
+  CUSTOM_FRAGMENT_BEFORE_LIGHTS: ["MF"],
+  CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION: ["AI", "NI"],
+  CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: ["BC"]
+};
+const VERT_POINT_TO_SLOT = {
+  CUSTOM_VERTEX_MAIN_BEGIN: "VR",
+  CUSTOM_VERTEX_UPDATE_WORLDPOS: "VW",
+  CUSTOM_VERTEX_MAIN_END: "VB"
+};
+function enabledPlugins(plugins) {
+  return plugins.filter((p) => p.isEnabled !== false).sort((a, b) => (a.priority ?? 500) - (b.priority ?? 500));
+}
+function pluginSignature(plugins) {
+  var _a, _b, _c, _d;
+  const parts = [];
+  for (const p of plugins) {
+    const on = p.isEnabled !== false;
+    parts.push(`${p.name}${on ? "+" : "-"}${p.priority ?? 500}:${JSON.stringify(p.defines ?? null)}`);
+    if (on) {
+      parts.push(JSON.stringify(((_a = p.getCustomCode) == null ? void 0 : _a.call(p, "fragment")) ?? null));
+      parts.push(JSON.stringify(((_b = p.getCustomCode) == null ? void 0 : _b.call(p, "vertex")) ?? null));
+      parts.push(JSON.stringify(((_c = p.getUniforms) == null ? void 0 : _c.call(p)) ?? null));
+      parts.push(JSON.stringify(((_d = p.getSamplers) == null ? void 0 : _d.call(p)) ?? null));
+    }
+  }
+  return parts.join("|");
+}
+function buildPluginFragment(plugins, index, forStandard) {
+  var _a, _b, _c, _d, _e;
+  const enabled = enabledPlugins(plugins);
+  if (enabled.length === 0) {
+    return { _fragment: { _id: `plugin-${index}` }, _stdUboSpec: null };
+  }
+  let helpers = "";
+  const fragmentSlots = {};
+  const vertexSlots = {};
+  const uboFields = [];
+  const bindings = [];
+  const append = (bucket, key, code) => {
+    bucket[key] = (bucket[key] ?? "") + "\n" + code;
+  };
+  for (const p of enabled) {
+    const frag = (_a = p.getCustomCode) == null ? void 0 : _a.call(p, "fragment");
+    if (frag) {
+      for (const point of Object.keys(frag)) {
+        const code = frag[point];
+        if (!code) {
+          continue;
+        }
+        if (point === "CUSTOM_FRAGMENT_DEFINITIONS") {
+          helpers += "\n" + code;
+          continue;
+        }
+        const slots = FRAG_POINT_TO_SLOTS[point];
+        if (slots) {
+          for (const s of slots) {
+            append(fragmentSlots, s, code);
+          }
+        }
+      }
+    }
+    const vert = (_b = p.getCustomCode) == null ? void 0 : _b.call(p, "vertex");
+    if (vert) {
+      for (const point of Object.keys(vert)) {
+        const code = vert[point];
+        const slot = VERT_POINT_TO_SLOT[point];
+        if (code && slot) {
+          append(vertexSlots, slot, code);
+        }
+      }
+    }
+    const ubo = (_d = (_c = p.getUniforms) == null ? void 0 : _c.call(p)) == null ? void 0 : _d.ubo;
+    if (ubo) {
+      for (const f of ubo) {
+        uboFields.push({ _name: f.name, _type: f.type });
+      }
+    }
+    const samplers = (_e = p.getSamplers) == null ? void 0 : _e.call(p);
+    if (samplers) {
+      for (const s of samplers) {
+        bindings.push(
+          { _name: s.texture, _type: { _kind: "texture", _textureType: s.textureType ?? "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT$1 },
+          { _name: s.sampler, _type: { _kind: "sampler", _samplerType: s.samplerType ?? "sampler" }, _visibility: STAGE_FRAGMENT$1 }
+        );
+      }
+    }
+  }
+  let stdUboSpec = null;
+  let stdUboFields = uboFields.length ? uboFields : void 0;
+  if (forStandard && uboFields.length) {
+    stdUboSpec = computeUboLayout(uboFields);
+    helpers = `struct ${STD_PLUGIN_UBO}Uniforms{
+${stdUboSpec._structBody}
+}
+` + helpers;
+    bindings.unshift({ _name: STD_PLUGIN_UBO, _type: { _kind: "uniform-buffer" }, _group: "mesh", _visibility: STAGE_FRAGMENT$1 });
+    stdUboFields = void 0;
+  }
+  return {
+    _fragment: {
+      _id: `plugin-${index}`,
+      _helperFunctions: helpers || void 0,
+      _fragmentSlots: Object.keys(fragmentSlots).length ? fragmentSlots : void 0,
+      _vertexSlots: Object.keys(vertexSlots).length ? vertexSlots : void 0,
+      _uboFields: stdUboFields,
+      _bindings: bindings.length ? bindings : void 0
+    },
+    _stdUboSpec: stdUboSpec
+  };
+}
+function writePluginUbo(plugins, data, offsets) {
+  var _a;
+  for (const p of enabledPlugins(plugins)) {
+    (_a = p.writeUbo) == null ? void 0 : _a.call(p, data, offsets);
+  }
+}
+function bindPluginTextures(plugins, entries, b) {
+  for (const p of enabledPlugins(plugins)) {
+    if (!p.bindTextures) {
+      continue;
+    }
+    const out = [];
+    p.bindTextures(out);
+    for (const binding of out) {
+      entries.push({ binding: b++, resource: binding.texture.view });
+      entries.push({ binding: b++, resource: binding.texture.sampler });
+    }
+  }
+  return b;
+}
+const PLUGIN_INDEX_SHIFT$1 = 24;
+let _sigToIndex$1 = null;
+let _indexToEntry$1 = null;
+let _counter$1 = 0;
+function _resetState$1() {
+  _sigToIndex$1 = /* @__PURE__ */ new Map();
+  _indexToEntry$1 = /* @__PURE__ */ new Map();
+  _counter$1 = 0;
+}
+function _indexFor$1(plugins) {
+  const sig = pluginSignature(plugins);
+  const map = _sigToIndex$1 ?? (_sigToIndex$1 = /* @__PURE__ */ new Map());
+  let idx = map.get(sig);
+  if (idx === void 0) {
+    idx = ++_counter$1;
+    map.set(sig, idx);
+    (_indexToEntry$1 ?? (_indexToEntry$1 = /* @__PURE__ */ new Map())).set(idx, { _plugins: plugins, _fragment: buildPluginFragment(plugins, idx, false)._fragment });
+  }
+  return idx;
+}
+const pbrPluginExt = {
+  id: "plugin",
+  phase: "fragment",
+  detect(mat) {
+    const plugins = mat.plugins;
+    if (!(plugins == null ? void 0 : plugins.length)) {
+      return { f: 0, f2: 0 };
+    }
+    return { f: 0, f2: _indexFor$1(plugins) << PLUGIN_INDEX_SHIFT$1 };
+  },
+  frag(ctx) {
+    var _a;
+    const idx = ctx._features2 >>> PLUGIN_INDEX_SHIFT$1 & 255;
+    if (!idx) {
+      return null;
+    }
+    return ((_a = _indexToEntry$1 == null ? void 0 : _indexToEntry$1.get(idx)) == null ? void 0 : _a._fragment) ?? null;
+  },
+  writeUbo(data, mat, offsets) {
+    const plugins = mat.plugins;
+    if (plugins == null ? void 0 : plugins.length) {
+      writePluginUbo(plugins, data, offsets);
+    }
+  },
+  bind(ctx, entries, b) {
+    const plugins = ctx._material.plugins;
+    return (plugins == null ? void 0 : plugins.length) ? bindPluginTextures(plugins, entries, b) : b;
+  },
+  textures(mat, out) {
+    var _a;
+    const plugins = mat.plugins;
+    if (!(plugins == null ? void 0 : plugins.length)) {
+      return;
+    }
+    for (const p of enabledPlugins(plugins)) {
+      (_a = p.getActiveTextures) == null ? void 0 : _a.call(p, out);
+    }
+  }
+};
+function registerPbrPlugins(register) {
+  _resetState$1();
+  register(pbrPluginExt);
+}
+function _computeStandardMaterialFeatures(m) {
+  let f = 0;
+  if (m.diffuseTexture) {
+    f |= HAS_DIFFUSE_TEXTURE;
+    if (m.diffuseCoordIndex === 1) {
+      f |= DIFFUSE_USES_UV2;
+    }
+  }
+  if (m.emissiveTexture) {
+    f |= HAS_EMISSIVE_TEXTURE;
+    if (m.emissiveTexture._sampleType === "depth") {
+      f |= HAS_DEPTH_EMISSIVE_TEXTURE;
+    }
+  }
+  if (m.bumpTexture) {
+    f |= HAS_BUMP_TEXTURE;
+  }
+  if (m.specularTexture) {
+    f |= HAS_SPECULAR_TEXTURE;
+    if (m.specularCoordIndex === 1) {
+      f |= SPECULAR_USES_UV2;
+    }
+  }
+  if (m.ambientTexture) {
+    f |= HAS_AMBIENT_TEXTURE;
+    if (m.ambientCoordIndex === 1) {
+      f |= AMBIENT_USES_UV2;
+    }
+  }
+  if (m.lightmapTexture) {
+    f |= HAS_LIGHTMAP_TEXTURE;
+    if (m.lightmapCoordIndex === 1) {
+      f |= LIGHTMAP_USES_UV2;
+    }
+  }
+  if (m.opacityTexture) {
+    f |= HAS_OPACITY_TEXTURE;
+    if (m.opacityFromRGB) {
+      f |= OPACITY_FROM_RGB;
+    }
+  }
+  if (!m.backFaceCulling) {
+    f |= DOUBLE_SIDED;
+  }
+  if (m.reflectionTexture) {
+    f |= HAS_REFLECTION_TEXTURE;
+  }
+  if (m.reflectionCubeTexture) {
+    f |= HAS_CUBE_REFLECTION;
+  }
+  if (m.disableLighting) {
+    f |= DISABLE_LIGHTING;
+  }
+  if (m.alpha < 1) {
+    f |= MATERIAL_ALPHA_BLEND;
+  }
+  return f;
+}
+function _standardFeatureKey(features, meshFeatures, variant = "") {
+  return variant ? `${features}:${meshFeatures}:${variant}` : `${features}:${meshFeatures}`;
+}
+function _standardShaderVariantKey(shadowLights) {
+  return shadowLights.length === 0 ? "" : shadowLights.map((sl) => `${sl.lightIndex}${sl.shadowType === "pcf" ? "p" : "e"}`).join(",");
+}
+const PLUGIN_INDEX_SHIFT = 24;
+const PLUGIN_INDEX_MASK = 127;
+let _sigToIndex = null;
+let _indexToEntry = null;
+let _counter = 0;
+function _resetState() {
+  _sigToIndex = /* @__PURE__ */ new Map();
+  _indexToEntry = /* @__PURE__ */ new Map();
+  _counter = 0;
+}
+function _indexFor(plugins, engine) {
+  const sig = pluginSignature(plugins);
+  const map = _sigToIndex ?? (_sigToIndex = /* @__PURE__ */ new Map());
+  let idx = map.get(sig);
+  if (idx === void 0) {
+    idx = ++_counter;
+    map.set(sig, idx);
+    const built = buildPluginFragment(plugins, idx, true);
+    let uboBuffer = null;
+    if (built._stdUboSpec && built._stdUboSpec._totalBytes > 0) {
+      const data = new Float32Array(built._stdUboSpec._totalBytes / 4);
+      writePluginUbo(plugins, data, built._stdUboSpec._offsets);
+      uboBuffer = createUniformBuffer$1(engine, data, "plugin-ubo");
+    }
+    (_indexToEntry ?? (_indexToEntry = /* @__PURE__ */ new Map())).set(idx, { _plugins: plugins, _fragment: built._fragment, _uboBuffer: uboBuffer });
+  }
+  return idx;
+}
+function _entryFor(plugins) {
+  const idx = _sigToIndex == null ? void 0 : _sigToIndex.get(pluginSignature(plugins));
+  return idx ? _indexToEntry == null ? void 0 : _indexToEntry.get(idx) : void 0;
+}
+const stdPluginExt = {
+  _id: "plugin",
+  _phase: "mesh",
+  _feature: PLUGIN_INDEX_MASK << PLUGIN_INDEX_SHIFT,
+  _frag(features) {
+    var _a;
+    const idx = features >>> PLUGIN_INDEX_SHIFT & PLUGIN_INDEX_MASK;
+    return ((_a = _indexToEntry == null ? void 0 : _indexToEntry.get(idx)) == null ? void 0 : _a._fragment) ?? { _id: "plugin-0" };
+  },
+  _bind(mat, entries, b) {
+    const plugins = mat.plugins;
+    if (!(plugins == null ? void 0 : plugins.length)) {
+      return b;
+    }
+    const entry = _entryFor(plugins);
+    if (entry == null ? void 0 : entry._uboBuffer) {
+      entries.push({ binding: b++, resource: { buffer: entry._uboBuffer } });
+    }
+    return bindPluginTextures(plugins, entries, b);
+  },
+  _textures(mat, out) {
+    var _a;
+    const plugins = mat.plugins;
+    if (!(plugins == null ? void 0 : plugins.length)) {
+      return;
+    }
+    for (const p of enabledPlugins(plugins)) {
+      (_a = p.getActiveTextures) == null ? void 0 : _a.call(p, out);
+    }
+  }
+};
+function registerStdPlugins(meshes, engine, register) {
+  var _a;
+  _resetState();
+  register(stdPluginExt);
+  for (const m of meshes) {
+    const mat = m.material;
+    if (((_a = mat == null ? void 0 : mat.plugins) == null ? void 0 : _a.length) && mat._buildGroup === standardGroupBuilder) {
+      const idx = _indexFor(mat.plugins, engine);
+      mat._renderFeatures = { features: _computeStandardMaterialFeatures(mat) | idx << PLUGIN_INDEX_SHIFT };
+    }
+  }
+}
+function enableMaterialPlugins(scene) {
+  registerPbrPlugins(_registerPbrExt);
+  registerStdPlugins(scene.meshes, scene.engine, _registerStdExt);
+}
 async function enableMaterialTracking(material) {
   const source = getMaterialSource(material);
   if ("specularPower" in source) {
-    const { installStdTracking } = await import("./std-tracking-CNKZ-hJN.js");
+    const { installStdTracking } = await import("./std-tracking-C4L4nQGc.js");
     installStdTracking(source);
   } else {
-    const { installPbrTracking } = await import("./pbr-tracking-B3alzn91.js");
+    const { installPbrTracking } = await import("./pbr-tracking-D6i3yPb7.js");
     installPbrTracking(source);
   }
 }
@@ -8946,6 +10529,18 @@ function cloneTransformNode(src) {
   }
   return clone;
 }
+let _tmpLocal = null;
+let _tmpAnim = null;
+let _tmpInstance = null;
+function getLoaderTmpLocal() {
+  return _tmpLocal ?? (_tmpLocal = allocateMat4());
+}
+function getLoaderTmpAnim() {
+  return _tmpAnim ?? (_tmpAnim = allocateMat4());
+}
+function getLoaderTmpInstance() {
+  return _tmpInstance ?? (_tmpInstance = allocateMat4());
+}
 const FLOAT = 5126;
 const UNSIGNED_SHORT = 5123;
 const UNSIGNED_INT = 5125;
@@ -8984,6 +10579,29 @@ function getTextureImageIndex(tex) {
   var _a, _b;
   return ((_b = (_a = tex.extensions) == null ? void 0 : _a.EXT_texture_webp) == null ? void 0 : _b.source) ?? tex.source;
 }
+function anyPrimitive(json, pred) {
+  for (const m of json.meshes ?? []) {
+    for (const p of m.primitives ?? []) {
+      if (pred(p)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function needsOrmComposite(json) {
+  var _a;
+  const mats = json.materials ?? [];
+  const textures = json.textures ?? [];
+  for (const m of mats) {
+    const mr = (_a = m.pbrMetallicRoughness) == null ? void 0 : _a.metallicRoughnessTexture;
+    const occ = m.occlusionTexture;
+    if (mr && occ && textures[mr.index] && textures[occ.index] && getTextureImageIndex(textures[mr.index]) !== getTextureImageIndex(textures[occ.index])) {
+      return true;
+    }
+  }
+  return false;
+}
 async function resolveImage(json, binChunk, imageIdx, baseUrl) {
   const image = json.images[imageIdx];
   if (image.bufferView !== void 0) {
@@ -9037,22 +10655,15 @@ function computeNodeWorldMatrix(json, nodeIdx, parentMap, cache) {
     const t = node.translation ?? [0, 0, 0];
     const r = node.rotation ?? [0, 0, 0, 1];
     const s = node.scale ?? [1, 1, 1];
-    const scratch = _getLocalScratch();
-    mat4ComposeInto(scratch, 0, t[0], t[1], t[2], r[0], r[1], r[2], r[3], s[0], s[1], s[2]);
-    localBuf = scratch;
+    const local = getLoaderTmpLocal();
+    mat4ComposeInto(local, 0, t[0], t[1], t[2], r[0], r[1], r[2], r[3], s[0], s[1], s[2]);
+    localBuf = local;
   }
   const world = new Float32Array(16);
   mat4MultiplyInto(world, 0, parentWorld, 0, localBuf, 0);
   cache.set(nodeIdx, world);
   return world;
 }
-let _localScratch = null;
-function _getLocalScratch() {
-  if (!_localScratch) {
-    _localScratch = new Float32Array(16);
-  }
-  return _localScratch;
-}
 async function assembleMaterial(json, binChunk, materialIdx, baseUrl, imageCache) {
   var _a, _b, _c;
   const mat = (_a = json.materials) == null ? void 0 : _a[materialIdx];
@@ -9118,13 +10729,6 @@ function makeImageFetcher(json, binChunk, baseUrl, imageCache) {
     return resolveImage(json, binChunk, imgIdx, baseUrl);
   };
 }
-function mipLevelCount(width, height) {
-  return Math.floor(Math.log2(Math.max(width, height))) + 1;
-}
-function biasedMipLevelCount(width, height, lodBias) {
-  const maxDim = Math.max(width, height);
-  return Math.max(1, Math.floor(Math.log2(maxDim) - lodBias) + 1);
-}
 function linearToSrgbByte(v) {
   const c = Math.max(0, Math.min(1, v));
   return Math.round((c <= 31308e-7 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - 0.055) * 255);
@@ -9228,14 +10832,14 @@ async function runMatExts(mat, exts, ctx) {
 }
 let _interleavePromise;
 function loadInterleave() {
-  return _interleavePromise ?? (_interleavePromise = import("./gltf-interleave-DGnUlz28.js"));
+  return _interleavePromise ?? (_interleavePromise = import("./gltf-interleave-C9eBqH_F.js"));
 }
 async function loadGltf(engine, url) {
   var _a;
   const { json, binChunk, baseUrl } = await fetchGltfAsset(url);
   const parentMap = buildParentMap(json);
   const worldMatrixCache = /* @__PURE__ */ new Map();
-  const features = await loadGltfFeatures(json);
+  const features = assetUsesGltfFeatures(json) ? await (await import("./gltf-feature-registry-97sY_x5O.js")).loadGltfFeatures(json) : [];
   let activeBin = binChunk;
   for (const f of features) {
     if (f.preParse) {
@@ -9278,108 +10882,37 @@ async function loadGltf(engine, url) {
     Object.assign(container, rest);
   }
   return container;
-}
-async function fetchGltfAsset(url) {
-  var _a;
-  const baseUrl = url.substring(0, url.lastIndexOf("/") + 1);
-  if (url.toLowerCase().endsWith(".glb")) {
-    const buffer = await fetch(url).then((r) => r.arrayBuffer());
-    const { parseGlbContainer } = await import("./gltf-glb-parser-D6UZWFuC.js");
-    const { json: json2, binChunk: binChunk2 } = parseGlbContainer(buffer);
-    return { json: json2, binChunk: binChunk2, baseUrl };
-  }
-  const json = await fetch(url).then((r) => r.json());
-  const bufferDef = (_a = json.buffers) == null ? void 0 : _a[0];
-  let binChunk;
-  if (bufferDef == null ? void 0 : bufferDef.uri) {
-    const binUrl = new URL(bufferDef.uri, baseUrl + "x").href;
-    const binBuffer = await fetch(binUrl).then((r) => r.arrayBuffer());
-    binChunk = new DataView(binBuffer);
-  } else {
-    binChunk = new DataView(new ArrayBuffer(0));
-  }
-  return { json, binChunk, baseUrl };
-}
-function anyPrimitive(json, pred) {
-  for (const m of json.meshes ?? []) {
-    for (const p of m.primitives ?? []) {
-      if (pred(p)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-const _MAT_EXT = "KHR_materials_";
-const hasMatExt = (suffix) => (json) => {
-  var _a;
-  return (_a = json.extensionsUsed) == null ? void 0 : _a.includes(_MAT_EXT + suffix);
-};
-const hasExt = (name) => (json) => {
-  var _a;
-  return (_a = json.extensionsUsed) == null ? void 0 : _a.includes(name);
-};
-function needsOrmComposite(json) {
-  var _a;
-  const mats = json.materials ?? [];
-  const textures = json.textures ?? [];
-  for (const m of mats) {
-    const mr = (_a = m.pbrMetallicRoughness) == null ? void 0 : _a.metallicRoughnessTexture;
-    const occ = m.occlusionTexture;
-    if (mr && occ && textures[mr.index] && textures[occ.index] && getTextureImageIndex(textures[mr.index]) !== getTextureImageIndex(textures[occ.index])) {
-      return true;
-    }
+}
+async function fetchGltfAsset(url) {
+  var _a;
+  const baseUrl = url.substring(0, url.lastIndexOf("/") + 1);
+  if (url.toLowerCase().endsWith(".glb")) {
+    const buffer = await fetch(url).then((r) => r.arrayBuffer());
+    const { parseGlbContainer } = await import("./gltf-glb-parser-D6UZWFuC.js");
+    const { json: json2, binChunk: binChunk2 } = parseGlbContainer(buffer);
+    return { json: json2, binChunk: binChunk2, baseUrl };
   }
-  return false;
+  const json = await fetch(url).then((r) => r.json());
+  const bufferDef = (_a = json.buffers) == null ? void 0 : _a[0];
+  let binChunk;
+  if (bufferDef == null ? void 0 : bufferDef.uri) {
+    const binUrl = new URL(bufferDef.uri, baseUrl + "x").href;
+    const binBuffer = await fetch(binUrl).then((r) => r.arrayBuffer());
+    binChunk = new DataView(binBuffer);
+  } else {
+    binChunk = new DataView(new ArrayBuffer(0));
+  }
+  return { json, binChunk, baseUrl };
 }
-const _features = [
-  // Pre-parse features (buffer-level): order matters — meshopt decompresses
-  // bufferViews first, then quantization dequantizes the resulting accessors.
-  [hasExt("EXT_meshopt_compression"), () => import("./gltf-feature-meshopt-Des96YFI.js")],
-  [hasExt("KHR_mesh_quantization"), () => import("./gltf-ext-quantization-CpZyLDIz.js")],
-  // Pre-mesh features (geometry decompression)
-  [hasExt("KHR_draco_mesh_compression"), () => import("./gltf-feature-draco-yGSMGTE3.js")],
-  // Material extensions
-  [hasMatExt("clearcoat"), () => import("./gltf-ext-clearcoat-CLH2SVph.js")],
-  [hasMatExt("iridescence"), () => import("./gltf-ext-iridescence-C6bq7jiM.js")],
-  [hasMatExt("emissive_strength"), () => import("./gltf-ext-emissive-strength-nzGZXZVK.js")],
-  [hasMatExt("sheen"), () => import("./gltf-ext-sheen-BgIxUzyZ.js")],
-  [hasMatExt("anisotropy"), () => import("./gltf-ext-anisotropy-CknJiJK8.js")],
-  [hasMatExt("unlit"), () => import("./gltf-ext-unlit-D2ANui0V.js")],
-  [hasMatExt("pbrSpecularGlossiness"), () => import("./gltf-ext-spec-gloss-D0LJLBUM.js")],
-  // Dielectric cluster (ior/specular/transmission/volume) — any of the four triggers the loader;
-  // transmission refraction is wired dynamically by the PBR material path when the loaded material needs it.
-  [(j) => ["transmission", "volume", "ior", "specular", "dispersion"].some((e) => hasMatExt(e)(j)), () => import("./gltf-ext-dielectric-qHzlnvdl.js")],
-  [hasExt("KHR_texture_transform"), () => import("./gltf-ext-uv-transform-CE_-T1Tr.js")],
-  [hasExt("KHR_texture_basisu"), () => import("./gltf-ext-basisu-CPg5kPrx.js")],
-  [needsOrmComposite, () => import("./gltf-ext-orm-CT18G_vQ.js")],
-  // Per-mesh features (predicates inlined to avoid eager imports)
-  [(json) => {
-    var _a;
-    return !!((_a = json.skins) == null ? void 0 : _a.length) && anyPrimitive(json, (p) => {
-      var _a2;
-      return ((_a2 = p.attributes) == null ? void 0 : _a2.JOINTS_0) !== void 0;
-    });
-  }, () => import("./gltf-feature-skeleton-D8hWLqi2.js")],
-  [(json) => anyPrimitive(json, (p) => {
-    var _a;
-    return !!((_a = p.targets) == null ? void 0 : _a.length);
-  }), () => import("./gltf-feature-morph-CKCw6tkX.js")],
-  // Per-asset features
-  [hasExt("KHR_lights_punctual"), () => import("./gltf-feature-lights-punctual-DDDg4j0U.js")],
-  [(json) => {
-    var _a;
-    return !!((_a = json.animations) == null ? void 0 : _a.length);
-  }, () => import("./gltf-feature-animations-CCizegp8.js")],
-  [hasMatExt("variants"), () => import("./gltf-feature-variants-Ds6v9byg.js")],
-  [hasExt("KHR_node_visibility"), () => import("./gltf-ext-node-visibility-MafA9ot2.js")],
-  [hasExt("KHR_animation_pointer"), () => import("./gltf-feature-animation-pointer-BjpwOOqo.js")],
-  [hasExt("EXT_mesh_gpu_instancing"), () => import("./gltf-feature-gpu-instancing-2e_CFQnl.js")],
-  [hasExt("KHR_xmp_json_ld"), () => import("./gltf-feature-xmp-BUfq_IVG.js")]
-];
-async function loadGltfFeatures(json) {
-  const mods = await Promise.all(_features.flatMap(([needs, load]) => needs(json) ? [load()] : []));
-  return mods.map((m) => m.default);
+function assetUsesGltfFeatures(json) {
+  var _a, _b, _c;
+  return !!(((_a = json.extensionsUsed) == null ? void 0 : _a.length) || ((_b = json.animations) == null ? void 0 : _b.length) || ((_c = json.skins) == null ? void 0 : _c.length) && anyPrimitive(json, (p) => {
+    var _a2;
+    return ((_a2 = p.attributes) == null ? void 0 : _a2.JOINTS_0) !== void 0;
+  }) || anyPrimitive(json, (p) => {
+    var _a2;
+    return !!((_a2 = p.targets) == null ? void 0 : _a2.length);
+  }) || needsOrmComposite(json));
 }
 function buildNodeHierarchy(json, meshes, meshDatas) {
   var _a, _b, _c;
@@ -9482,16 +11015,18 @@ async function extractAllMeshes(json, binChunk, baseUrl, parentMap, worldMatrixC
       const uv2Data = resolveAttr("TEXCOORD_1");
       const tanData = resolveAttr("TANGENT");
       const colorData = resolveAttr("COLOR_0");
+      const colors = colorData ? (await import("./gltf-color-normalize-Qxl-9C48.js")).normalizeColorToVec3(colorData._data, colorData._count, colorData._componentCount) : null;
       const idxData = decoded ? { _data: decoded._indices, _count: decoded._indexCount } : primitive.indices !== void 0 ? resolveAccessor(json, binChunk, primitive.indices) : null;
       const indices = idxData ? idxData._data instanceof Uint32Array ? new Uint32Array(idxData._data) : idxData._data instanceof Uint8Array ? Uint16Array.from(idxData._data) : new Uint16Array(idxData._data.buffer, idxData._data.byteOffset, idxData._count) : new Uint16Array(0);
       matPromises.push(getMat(primitive.material));
+      const normals = normData ? normData._data : (await import("./gltf-normals-b2h74380.js")).computeSmoothNormals(posData._data, indices, posData._count);
       partials.push({
         _positions: posData._data,
-        _normals: normData._data,
+        _normals: normals,
         _tangents: tanData ? tanData._data : null,
         _uvs: uvData ? uvData._data : new Float32Array(posData._count * 2),
         _uv2s: uv2Data ? uv2Data._data : null,
-        _colors: colorData ? colorData._data : null,
+        _colors: colors,
         _indices: indices,
         _vertexCount: posData._count,
         _indexCount: (idxData == null ? void 0 : idxData._count) ?? 0,
@@ -9562,7 +11097,7 @@ async function uploadMeshes(meshDatas, features, ctx) {
     }
   }
   let _pbrExtPromise = null;
-  const _ensurePbrExt = () => _pbrExtPromise ?? (_pbrExtPromise = import("./gltf-pbr-builder-ext-BFOxOCnQ.js"));
+  const _ensurePbrExt = () => _pbrExtPromise ?? (_pbrExtPromise = import("./gltf-pbr-builder-ext-DPC0zg_u.js"));
   const builtMaterialCache = /* @__PURE__ */ new Map();
   async function buildPbrFromGltfMat(mat) {
     let cached = builtMaterialCache.get(mat);
@@ -10001,7 +11536,7 @@ async function loadBabylon(engine, url, opts = {}) {
     }
   }
   const camData = opts.loadCamera !== false && ((_v = data.cameras) == null ? void 0 : _v.length) ? (data.activeCameraID ? data.cameras.find((c) => c.id === data.activeCameraID) : null) ?? data.cameras[0] : null;
-  const camera = camData ? (await import("./parse-camera-DM3oJJeT.js")).parseBabylonCamera(camData) : void 0;
+  const camera = camData ? (await import("./parse-camera-CgV4bWc0.js")).parseBabylonCamera(camData) : void 0;
   const rootMeshes = allMeshes.filter((m) => !childNodeIds.has(m.id));
   const rootTransformNodes = [];
   for (const [id, node] of nodeMap) {
@@ -10108,6 +11643,7 @@ async function loadEnvironment(scene, url, options) {
   brdfImage.close();
   const textures = assembleEnvironmentTextures(specularCube, brdfLut, irradianceSH, 0.8, engine);
   scene._envTextures = textures;
+  registerEnvSceneUniforms(scene);
   acquireGPUTexture(specularCube);
   acquireGPUTexture(brdfLut);
   scene._disposables.push(() => {
@@ -10131,19 +11667,19 @@ async function loadEnvironment(scene, url, options) {
     const { groundSize, skyboxSize: autoSkyboxSize, rootPosition } = computeSceneSize(scene, options == null ? void 0 : options.skyboxSize);
     const skyHalfSize = autoSkyboxSize / 2;
     if (!bgOptions.skipSkybox) {
-      const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-DPGBpPbm.js");
+      const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-fjXlnWaD.js");
       scene._renderables.push(buildSolidSkyboxRenderable(scene, textures, skyHalfSize, rootPosition, primaryColor));
     }
     if (!bgOptions.skipGround) {
-      const { buildGroundRenderable } = await import("./background-ground-DIw6D3qf.js");
+      const { buildGroundRenderable } = await import("./background-ground-B2Mie-MI.js");
       scene._renderables.push(await buildGroundRenderable(engine, groundSize, rootPosition, primaryColor, groundUrl, groundTexPromise));
     }
     if (skyboxIsDds) {
-      const { buildDdsSkyboxRenderable } = await import("./background-dds-skybox-yHTqabU3.js");
+      const { buildDdsSkyboxRenderable } = await import("./background-dds-skybox-ZjrSIxrT.js");
       scene._renderables.push(await buildDdsSkyboxRenderable(scene, skyHalfSize, rootPosition, primaryColor, skyboxUrl));
     }
     if (skyboxIsEnv) {
-      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-c4uuTmkP.js");
+      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-DDRJYuT2.js");
       scene._renderables.push(buildHdrSkyboxRenderable(scene, textures, skyHalfSize, rootPosition, primaryColor));
     }
   });
@@ -10530,6 +12066,7 @@ async function loadHdrEnvironment(scene, url, options) {
   const brdfLut = generateBrdfLut(engine);
   const textures = assembleEnvironmentTextures(specularCube, brdfLut, irradianceSH, 1, engine);
   scene._envTextures = textures;
+  registerEnvSceneUniforms(scene);
   acquireGPUTexture(specularCube);
   acquireGPUTexture(brdfLut);
   scene._disposables.push(() => {
@@ -10546,7 +12083,7 @@ async function loadHdrEnvironment(scene, url, options) {
       const { computeSceneSize: computeSceneSize2 } = await Promise.resolve().then(() => sceneSize);
       const { skyboxSize: autoSkyboxSize, rootPosition } = computeSceneSize2(scene, options == null ? void 0 : options.skyboxSize);
       const primaryColor = scene.environmentPrimaryColor ?? [0.08697355964132344, 0.08697355964132344, 0.2122208331110881];
-      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-c4uuTmkP.js");
+      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-DDRJYuT2.js");
       scene._renderables.push(buildHdrSkyboxRenderable(scene, textures, autoSkyboxSize / 2, rootPosition, primaryColor));
     }
     if (!useHdr || !skipGround) {
@@ -10554,102 +12091,17 @@ async function loadHdrEnvironment(scene, url, options) {
       const { computeSceneSize: computeSceneSize2 } = await Promise.resolve().then(() => sceneSize);
       const { groundSize, skyboxSize: autoSkyboxSize, rootPosition } = computeSceneSize2(scene, options == null ? void 0 : options.skyboxSize);
       if (!useHdr) {
-        const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-DPGBpPbm.js");
+        const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox-fjXlnWaD.js");
         scene._renderables.push(buildSolidSkyboxRenderable(scene, textures, autoSkyboxSize / 2, rootPosition, primaryColor));
       }
       if (!skipGround) {
-        const { buildGroundRenderable } = await import("./background-ground-DIw6D3qf.js");
+        const { buildGroundRenderable } = await import("./background-ground-B2Mie-MI.js");
         scene._renderables.push(await buildGroundRenderable(engine, groundSize, rootPosition, primaryColor));
       }
     }
   });
   return textures;
 }
-const BLIT_SHADER = `@group(0)@binding(0)var t:texture_2d<f32>;@group(0)@binding(1)var s:sampler;
-struct V{@builtin(position)p:vec4f,@location(0)u:vec2f};
-@vertex fn vs(@builtin(vertex_index)i:u32)->V{let p=array<vec2f,3>(vec2f(-1,-1),vec2f(3,-1),vec2f(-1,3))[i];return V(vec4f(p,0,1),p*vec2f(.5,-.5)+.5);}
-@fragment fn fs(v:V)->@location(0)vec4f{return textureSample(t,s,v.u);}`;
-let pipelineCache = null;
-let shaderModule = null;
-let linearSampler = null;
-let bindGroupLayout = null;
-let cachedDevice = null;
-function clearCache() {
-  pipelineCache == null ? void 0 : pipelineCache.clear();
-  pipelineCache = null;
-  shaderModule = null;
-  linearSampler = null;
-  bindGroupLayout = null;
-  cachedDevice = null;
-}
-function ensureResources(engine) {
-  const device = engine._device;
-  if (device !== cachedDevice) {
-    clearCache();
-    cachedDevice = device;
-  }
-  shaderModule ?? (shaderModule = device.createShaderModule({ code: BLIT_SHADER }));
-  linearSampler ?? (linearSampler = getBilinearSampler(engine));
-  bindGroupLayout ?? (bindGroupLayout = device.createBindGroupLayout({
-    entries: [
-      { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
-      { binding: 1, visibility: GPUShaderStage.FRAGMENT, sampler: {} }
-    ]
-  }));
-}
-function getPipeline(engine, format) {
-  const device = engine._device;
-  ensureResources(engine);
-  pipelineCache ?? (pipelineCache = /* @__PURE__ */ new Map());
-  let pipeline = pipelineCache.get(format);
-  if (!pipeline) {
-    pipeline = device.createRenderPipeline({
-      layout: device.createPipelineLayout({ bindGroupLayouts: [bindGroupLayout] }),
-      vertex: { module: shaderModule, entryPoint: "vs" },
-      fragment: { module: shaderModule, entryPoint: "fs", targets: [{ format }] },
-      primitive: { topology: "triangle-list" }
-    });
-    pipelineCache.set(format, pipeline);
-  }
-  return pipeline;
-}
-function generateMipmaps(engine, texture, face) {
-  const device = engine._device;
-  const encoder = device.createCommandEncoder();
-  recordMipmaps(engine, texture, encoder, face);
-  device.queue.submit([encoder.finish()]);
-}
-function recordMipmaps(engine, texture, encoder, face) {
-  if (texture.mipLevelCount <= 1) {
-    return;
-  }
-  const device = engine._device;
-  const pipeline = getPipeline(engine, texture.format);
-  const vp = face != null ? { dimension: "2d", baseArrayLayer: face, arrayLayerCount: 1 } : {};
-  for (let mip = 1; mip < texture.mipLevelCount; mip++) {
-    const srcView = texture.createView({ baseMipLevel: mip - 1, mipLevelCount: 1, ...vp });
-    const dstView = texture.createView({ baseMipLevel: mip, mipLevelCount: 1, ...vp });
-    const bindGroup = device.createBindGroup({
-      layout: bindGroupLayout,
-      entries: [
-        { binding: 0, resource: srcView },
-        { binding: 1, resource: linearSampler }
-      ]
-    });
-    const pass = encoder.beginRenderPass({
-      colorAttachments: [{ view: dstView, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }]
-    });
-    pass.setPipeline(pipeline);
-    pass.setBindGroup(0, bindGroup);
-    pass.draw(3);
-    pass.end();
-  }
-}
-const generateMipmaps$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  generateMipmaps,
-  recordMipmaps
-}, Symbol.toStringTag, { value: "Module" }));
 let _cc = null;
 function loadCubeTexture(engine, baseUrl, ext = ".jpg") {
   const device = engine._device;
@@ -10724,7 +12176,7 @@ async function loadSkybox(scene, baseUrl, ext, size = 100) {
     idxCount: boxData.indices.length,
     worldMatrix: world
   };
-  const { buildSkyboxRenderable } = await import("./skybox-renderable-DDwzu-PT.js");
+  const { buildSkyboxRenderable } = await import("./skybox-renderable-DDcCPSly.js");
   scene._renderables.push(buildSkyboxRenderable(scene, skyboxData));
 }
 const SH_C0$2 = 0.28209479177387814;
@@ -11005,6 +12457,14 @@ function mat4Scale(x, y, z) {
   out[15] = 1;
   return out;
 }
+function mat4Translation(x, y, z) {
+  const out = mat4Identity();
+  const s = out;
+  s[12] = x;
+  s[13] = y;
+  s[14] = z;
+  return out;
+}
 function createGaussianSplattingMesh(engine, name, geom, worker, parsed) {
   const device = engine._device;
   const queue = device.queue;
@@ -11464,7 +12924,7 @@ async function attachParsedSplat(scene, name, parsed, fragments) {
   const eng = scene.engine;
   const mesh = createGaussianSplattingMesh(eng, name, geom, worker, parsed);
   if (parsed.sh && parsed.shDegree && parsed.shDegree > 0) {
-    const { attachGaussianSplattingMeshSH } = await import("./gaussian-splatting-pipeline-sh-DgJl7l56.js");
+    const { attachGaussianSplattingMeshSH } = await import("./gaussian-splatting-pipeline-sh-BvkUhA9V.js");
     attachGaussianSplattingMeshSH(scene, mesh, parsed.sh, fragments);
   } else {
     attachGaussianSplattingMesh(scene, mesh, fragments);
@@ -12162,7 +13622,7 @@ function createLinearDepthMaterial(options = {}) {
   });
 }
 function writeShadowUboFields(out, sg) {
-  out.set(sg._lightMatrix, 0);
+  packMat4IntoF32(out, sg._lightMatrix, 0);
   out[16] = sg._depthValues[0];
   out[17] = sg._depthValues[1];
   out[18] = 0;
@@ -12234,7 +13694,10 @@ function createShadowRenderTarget(sg, colorTexture = null, depthTexture = sg._de
     _depthView: depthTexture.createView(),
     _width: mapSize,
     _height: mapSize,
-    _eager: true
+    _eager: true,
+    // Borrowed: the depth map is the generator's shared shadow map (persists for the generator's
+    // lifetime); per-task render-target disposal must NOT destroy it (it's reused after rebuilds).
+    _ownsDepthTexture: false
   };
 }
 function createSharedShadowUBO(engine, _lightMatrix, _depthValues, _shadowsInfo) {
@@ -12256,6 +13719,9 @@ function createShadowCamera(sg) {
     nearPlane: 1,
     farPlane: 1,
     children: [],
+    _viewCache: allocateMat4(),
+    _projCache: allocateMat4(),
+    _vpCache: allocateMat4(),
     get worldMatrix() {
       return sg._light.worldMatrix;
     },
@@ -12304,21 +13770,21 @@ async function preloadEsmShadowTaskState(casterMeshes) {
   }
   if (needsStandard && !createStandardEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-Dk9NFtLq.js").then((module) => {
+      import("./esm-shadow-view-DHVS9r7H.js").then((module) => {
         createStandardEsmShadowMaterialView = module.createStandardEsmShadowMaterialView;
       })
     );
   }
   if (needsPbr && !createPbrEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-DGKdF1NI.js").then((module) => {
+      import("./esm-shadow-view-15S4JK6p.js").then((module) => {
         createPbrEsmShadowMaterialView = module.createPbrEsmShadowMaterialView;
       })
     );
   }
   if (needsNode && !createNodeEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-DN9HIaM4.js").then((module) => {
+      import("./esm-shadow-view-DYAc62Kl.js").then((module) => {
         createNodeEsmShadowMaterialView = module.createNodeEsmShadowMaterialView;
       })
     );
@@ -12492,7 +13958,7 @@ function renderEsmShadowMap(engine, sg, state) {
   }
   const matrix = _computeDirectionalLightMatrix$1(sg._light, casterMeshes, sg._config._orthoMinZ, sg._config._orthoMaxZ);
   if (shadowMatrixChanged(sg._lightMatrix, matrix._viewProj)) {
-    sg._lightMatrix.set(matrix._viewProj);
+    packMat4IntoF32(sg._lightMatrix, matrix._viewProj, 0);
     sg._version++;
     writeShadowUboFields(resources._shadowUboData, sg);
     engine._device.queue.writeBuffer(sg._shadowUBO, 0, resources._shadowUboData);
@@ -12681,17 +14147,20 @@ function createEsmDirectionalShadowGenerator(engine, _light, cfg = {}) {
 let createStandardNoColorMaterialView;
 let createPbrNoColorMaterialView;
 let createNodeNoColorMaterialView;
+let createShaderNoColorMaterialView;
 async function preloadPcfShadowTaskState(casterMeshes) {
   var _a;
   const loads = [];
   let needsStandard = false;
   let needsPbr = false;
   let needsNode = false;
+  let needsShader = false;
   for (const mesh of casterMeshes) {
     const family = (_a = mesh.material) == null ? void 0 : _a._buildGroup._materialFamily;
     needsStandard || (needsStandard = family === "standard");
     needsPbr || (needsPbr = family === "pbr");
     needsNode || (needsNode = family === "node");
+    needsShader || (needsShader = family === "shader");
   }
   if (needsStandard && !createStandardNoColorMaterialView) {
     loads.push(
@@ -12714,6 +14183,13 @@ async function preloadPcfShadowTaskState(casterMeshes) {
       })
     );
   }
+  if (needsShader && !createShaderNoColorMaterialView) {
+    loads.push(
+      import("./no-color-view-DsyLSL-W.js").then((module) => {
+        createShaderNoColorMaterialView = module.createShaderNoColorMaterialView;
+      })
+    );
+  }
   await Promise.all(loads);
 }
 function ensurePcfShadowTaskState(engine, scene, sg, casterMeshes, existingState) {
@@ -12764,7 +14240,7 @@ function renderPcfShadowMap(engine, sg, state, computeLightMatrix) {
   const matrix = computeLightMatrix(casterMeshes);
   const matrixChanged = sg._light.lightType === "directional" || lightVersion !== state._lastLightVersion;
   if (matrixChanged) {
-    sg._lightMatrix.set(matrix._viewProj);
+    packMat4IntoF32(sg._lightMatrix, matrix._viewProj, 0);
     sg._version++;
     writeShadowUboFields(state._shadowUboData, sg);
     engine._device.queue.writeBuffer(sg._shadowUBO, 0, state._shadowUboData);
@@ -12802,6 +14278,8 @@ function getNoColorView(material, cache) {
     view = createPbrNoColorMaterialView(material);
   } else if (family === "node") {
     view = createNodeNoColorMaterialView(material);
+  } else if (family === "shader") {
+    view = createShaderNoColorMaterialView(material);
   }
   cache.set(material, view);
   return view;
@@ -12965,6 +14443,513 @@ function createPcfDirectionalShadowGenerator(engine, _light, cfg = {}) {
   };
   return sg;
 }
+const preloadCsmShadowTaskState = preloadPcfShadowTaskState;
+function ensureCsmShadowTaskState(engine, scene, sg, cfg, casterMeshes, existingState) {
+  const existing = existingState;
+  if (existing) {
+    if (existing._casterMeshes === casterMeshes) {
+      return existing;
+    }
+    existing._task.dispose();
+  }
+  const materialViews = /* @__PURE__ */ new Map();
+  const n = cfg._numCascades;
+  const tasks = [];
+  const cameras = [];
+  for (let i = 0; i < n; i++) {
+    const layerView = sg._depthTexture.createView({ dimension: "2d", baseArrayLayer: i, arrayLayerCount: 1 });
+    const rt = {
+      _descriptor: {
+        size: { width: cfg._mapSize, height: cfg._mapSize },
+        depthStencilFormat: "depth32float",
+        _depthClearValue: 1,
+        _depthCompare: "less-equal",
+        sampleCount: 1,
+        flipY: false
+      },
+      _colorTexture: null,
+      _colorView: null,
+      _depthTexture: sg._depthTexture,
+      _depthView: layerView,
+      _width: cfg._mapSize,
+      _height: cfg._mapSize,
+      _eager: true,
+      _ownsDepthTexture: false
+      // borrowed: the shared CSM depth array is owned by the generator
+    };
+    const camera = createShadowCamera(sg);
+    const task = createRenderTask({ name: `csm${i}`, rt, clr: true, cam: camera }, engine, scene);
+    for (const mesh of casterMeshes) {
+      const material = mesh.material;
+      if (material) {
+        task.addMesh(mesh, { material: getNoColorView(material, materialViews) });
+      }
+    }
+    tasks.push(task);
+    cameras.push(camera);
+  }
+  const compositeTask = {
+    record() {
+      for (const t of tasks) {
+        t.record();
+      }
+    },
+    execute() {
+      var _a;
+      let draws = 0;
+      for (const t of tasks) {
+        draws += ((_a = t.execute) == null ? void 0 : _a.call(t)) ?? 0;
+      }
+      return draws;
+    },
+    dispose() {
+      for (const t of tasks) {
+        t.dispose();
+      }
+    }
+  };
+  return {
+    _task: compositeTask,
+    _tasks: tasks,
+    _cameras: cameras,
+    _scene: scene,
+    _cameraVersion: 0,
+    _lastCasterVersion: -1,
+    _lastLightVersion: -1,
+    _lastCamVersion: -1,
+    _uboData: new Float32Array(80),
+    _casterMeshes: casterMeshes
+  };
+}
+function renderCsmShadowMap(engine, sg, state, cfg) {
+  var _a, _b;
+  const casterMeshes = state._casterMeshes;
+  const camera = state._scene.camera;
+  if (!camera) {
+    return 0;
+  }
+  const casterVersion = casterVersionSum(casterMeshes);
+  const lightVersion = sg._light.worldMatrixVersion;
+  const camVersion = camera.worldMatrixVersion;
+  if (!cfg._forceRefreshEveryFrame && casterVersion === state._lastCasterVersion && lightVersion === state._lastLightVersion && camVersion === state._lastCamVersion) {
+    return 0;
+  }
+  const cascades = _computeCsmCascades(engine, camera, sg._light, cfg, casterMeshes);
+  _writeCsmUbo(state._uboData, cascades, cfg);
+  sg._version++;
+  engine._device.queue.writeBuffer(sg._shadowUBO, 0, state._uboData);
+  const receiverCbs = sg._onReceiverData;
+  if (receiverCbs) {
+    for (let i = 0; i < receiverCbs.length; i++) {
+      receiverCbs[i](state._uboData);
+    }
+  }
+  state._cameraVersion++;
+  for (let i = 0; i < cascades._transforms.length; i++) {
+    const cam = state._cameras[i];
+    cam.fov = 1;
+    updateShadowCameraBase(cam, state._cameraVersion, cascades._near[i], cascades._far[i], cascades._views[i], _biasViewProjection(cascades._biased[i], cfg._bias));
+  }
+  state._lastCasterVersion = casterVersion;
+  state._lastLightVersion = lightVersion;
+  state._lastCamVersion = camVersion;
+  return ((_b = (_a = state._task).execute) == null ? void 0 : _b.call(_a)) ?? 0;
+}
+const FRUSTUM_NDC = [
+  [-1, 1, 1],
+  [1, 1, 1],
+  [1, -1, 1],
+  [-1, -1, 1],
+  [-1, 1, 0],
+  [1, 1, 0],
+  [1, -1, 0],
+  [-1, -1, 0]
+];
+function transformCoord(m, x, y, z) {
+  const X = m[0] * x + m[4] * y + m[8] * z + m[12];
+  const Y = m[1] * x + m[5] * y + m[9] * z + m[13];
+  const Z = m[2] * x + m[6] * y + m[10] * z + m[14];
+  const W = m[3] * x + m[7] * y + m[11] * z + m[15];
+  return [X / W, Y / W, Z / W];
+}
+function orthoOffCenterLH(l, r, b, t, n, f) {
+  const m = new Float32Array(16);
+  m[0] = 2 / (r - l);
+  m[5] = 2 / (t - b);
+  m[10] = 1 / (f - n);
+  m[12] = -(r + l) / (r - l);
+  m[13] = -(t + b) / (t - b);
+  m[14] = -n / (f - n);
+  m[15] = 1;
+  return m;
+}
+function _computeCsmCascades(engine, camera, light, cfg, casterMeshes) {
+  const near = camera.nearPlane;
+  const far = camera.farPlane;
+  const cameraRange = far - near;
+  const shadowMaxZ = cfg._shadowMaxZ ?? far;
+  const maxDistance = shadowMaxZ < far && shadowMaxZ >= near ? Math.min((shadowMaxZ - near) / (far - near), 1) : 1;
+  const minDistance = 0;
+  const minZ = near + minDistance * cameraRange;
+  const maxZ = near + maxDistance * cameraRange;
+  const range = maxZ - minZ;
+  const ratio = maxZ / minZ;
+  const n = cfg._numCascades;
+  const breakDist = [];
+  const viewFrustumZ = [];
+  const frustumLengths = [];
+  for (let i = 0; i < n; i++) {
+    const p = (i + 1) / n;
+    const log = minZ * ratio ** p;
+    const uniform = minZ + range * p;
+    const d = cfg._lambda * (log - uniform) + uniform;
+    const prevBreak = i === 0 ? minDistance : breakDist[i - 1];
+    breakDist[i] = (d - near) / cameraRange;
+    viewFrustumZ[i] = d;
+    frustumLengths[i] = (breakDist[i] - prevBreak) * cameraRange;
+  }
+  let dx = light.direction.x;
+  let dy = light.direction.y;
+  let dz = light.direction.z;
+  const dl = Math.hypot(dx, dy, dz) || 1;
+  dx /= dl;
+  dy /= dl;
+  dz /= dl;
+  if (Math.abs(dy) >= 1) {
+    dz = 1e-13;
+  }
+  const aspect = engine.canvas.width / engine.canvas.height;
+  const vp = getViewProjectionMatrix(camera, aspect);
+  const inv = mat4Invert(vp);
+  const invViewProj = inv ?? vp;
+  const aabb = _castersWorldAabb(casterMeshes);
+  const transforms = [];
+  const views = [];
+  const nearOut = [];
+  const farOut = [];
+  for (let c = 0; c < n; c++) {
+    const prevSplit = c === 0 ? 0 : breakDist[c - 1];
+    const split = breakDist[c];
+    const corners = [];
+    for (let k = 0; k < 8; k++) {
+      const ndc = FRUSTUM_NDC[k];
+      corners.push(transformCoord(invViewProj, ndc[0], ndc[1], ndc[2]));
+    }
+    for (let k = 0; k < 4; k++) {
+      const nearC = corners[k];
+      const farC = corners[k + 4];
+      const rx = farC[0] - nearC[0];
+      const ry = farC[1] - nearC[1];
+      const rz = farC[2] - nearC[2];
+      corners[k + 4] = [nearC[0] + rx * split, nearC[1] + ry * split, nearC[2] + rz * split];
+      corners[k] = [nearC[0] + rx * prevSplit, nearC[1] + ry * prevSplit, nearC[2] + rz * prevSplit];
+    }
+    let cx = 0, cy = 0, cz = 0;
+    for (const p of corners) {
+      cx += p[0];
+      cy += p[1];
+      cz += p[2];
+    }
+    cx /= 8;
+    cy /= 8;
+    cz /= 8;
+    let minX, maxX, minY, maxY, minEz, maxEz;
+    if (cfg._stabilizeCascades) {
+      let radius = 0;
+      for (const p of corners) {
+        radius = Math.max(radius, Math.hypot(p[0] - cx, p[1] - cy, p[2] - cz));
+      }
+      radius = Math.ceil(radius * 16) / 16;
+      minX = minY = minEz = -radius;
+      maxX = maxY = maxEz = radius;
+    } else {
+      const tmpView = buildLightViewMatrix(dx, dy, dz, cx, cy, cz);
+      minX = minY = minEz = Infinity;
+      maxX = maxY = maxEz = -Infinity;
+      for (const p of corners) {
+        const lp = transformCoord(tmpView, p[0], p[1], p[2]);
+        minX = Math.min(minX, lp[0]);
+        maxX = Math.max(maxX, lp[0]);
+        minY = Math.min(minY, lp[1]);
+        maxY = Math.max(maxY, lp[1]);
+        minEz = Math.min(minEz, lp[2]);
+        maxEz = Math.max(maxEz, lp[2]);
+      }
+    }
+    const eyeX = cx + dx * minEz;
+    const eyeY = cy + dy * minEz;
+    const eyeZ = cz + dz * minEz;
+    const view = buildLightViewMatrix(dx, dy, dz, eyeX, eyeY, eyeZ);
+    let viewMinZ = 0;
+    let viewMaxZ = maxEz - minEz;
+    if (aabb) {
+      let cMinZ = Infinity;
+      let cMaxZ = -Infinity;
+      for (let k = 0; k < 8; k++) {
+        const wx = k & 1 ? aabb._max[0] : aabb._min[0];
+        const wy = k & 2 ? aabb._max[1] : aabb._min[1];
+        const wz = k & 4 ? aabb._max[2] : aabb._min[2];
+        const lz = view[2] * wx + view[6] * wy + view[10] * wz + view[14];
+        cMinZ = Math.min(cMinZ, lz);
+        cMaxZ = Math.max(cMaxZ, lz);
+      }
+      if (cMinZ <= viewMaxZ) {
+        viewMinZ = Math.min(viewMinZ, cMinZ);
+        viewMaxZ = Math.min(viewMaxZ, cMaxZ);
+      }
+    }
+    const proj0 = orthoOffCenterLH(minX, maxX, minY, maxY, viewMinZ, viewMaxZ);
+    let transform = multiply4x4(proj0, view);
+    const ox = transform[12] * (cfg._mapSize / 2);
+    const oy = transform[13] * (cfg._mapSize / 2);
+    const offX = (Math.round(ox) - ox) * (2 / cfg._mapSize);
+    const offY = (Math.round(oy) - oy) * (2 / cfg._mapSize);
+    const snap = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, offX, offY, 0, 1]);
+    const proj = multiply4x4(snap, proj0);
+    transform = multiply4x4(proj, view);
+    transforms.push(transform);
+    views.push(view);
+    nearOut.push(viewMinZ);
+    farOut.push(viewMaxZ);
+  }
+  return {
+    _transforms: transforms,
+    _biased: transforms.map((t) => new Float32Array(t)),
+    _views: views,
+    _near: nearOut,
+    _far: farOut,
+    _viewFrustumZ: viewFrustumZ,
+    _frustumLengths: frustumLengths
+  };
+}
+function _castersWorldAabb(casterMeshes) {
+  let minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (const mesh of casterMeshes) {
+    const world = mesh.worldMatrix;
+    const bmin = mesh.boundMin ?? [-0.5, -0.5, -0.5];
+    const bmax = mesh.boundMax ?? [0.5, 0.5, 0.5];
+    for (let k = 0; k < 8; k++) {
+      const lx = k & 1 ? bmax[0] : bmin[0];
+      const ly = k & 2 ? bmax[1] : bmin[1];
+      const lz = k & 4 ? bmax[2] : bmin[2];
+      const wx = world[0] * lx + world[4] * ly + world[8] * lz + world[12];
+      const wy = world[1] * lx + world[5] * ly + world[9] * lz + world[13];
+      const wz = world[2] * lx + world[6] * ly + world[10] * lz + world[14];
+      minX = Math.min(minX, wx);
+      maxX = Math.max(maxX, wx);
+      minY = Math.min(minY, wy);
+      maxY = Math.max(maxY, wy);
+      minZ = Math.min(minZ, wz);
+      maxZ = Math.max(maxZ, wz);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    return null;
+  }
+  return { _min: [minX, minY, minZ], _max: [maxX, maxY, maxZ] };
+}
+function _writeCsmUbo(out, cascades, cfg) {
+  out.fill(0);
+  const n = cascades._transforms.length;
+  for (let i = 0; i < n; i++) {
+    out.set(cascades._transforms[i], i * 16);
+  }
+  for (let i = 0; i < n; i++) {
+    out[64 + i] = cascades._viewFrustumZ[i];
+    out[68 + i] = cascades._frustumLengths[i];
+  }
+  out[72] = cfg._darkness;
+  out[73] = cfg._mapSize;
+  out[74] = 1 / cfg._mapSize;
+  out[75] = cfg._frustumEdgeFalloff;
+  out[76] = n;
+  out[77] = cfg._cascadeBlendPercentage === 0 ? 1e4 : 1 / cfg._cascadeBlendPercentage;
+}
+function _biasViewProjection(viewProj, bias) {
+  const biased = new Float32Array(viewProj);
+  const b = bias * 0.5;
+  for (let col = 0; col < 4; col++) {
+    const z = 2 + col * 4;
+    const w = 3 + col * 4;
+    biased[z] = biased[z] + b * biased[w];
+  }
+  return biased;
+}
+let _stdFactory = null;
+function setCsmStdReceiverFactory(f) {
+  _stdFactory = f;
+}
+function getCsmStdReceiverFactory() {
+  return _stdFactory;
+}
+let _pbrFactory = null;
+function setCsmPbrReceiverFactory(f) {
+  _pbrFactory = f;
+}
+function getCsmPbrReceiverFactory() {
+  return _pbrFactory;
+}
+const STAGE_FRAGMENT = 2;
+function createCsmShadowFragment(id, shadowLights, opts = {}) {
+  const worldPosExpr = opts.worldPosExpr ?? "input.vp";
+  const viewZExpr = opts.viewZExpr ?? "input.vf.z";
+  const outputSlot = opts.outputSlot ?? "AD";
+  const varyings = [];
+  const bindings = [];
+  const fragmentLines = [];
+  const helperParts = [];
+  for (const slot of shadowLights) {
+    const li = slot.lightIndex;
+    const suffix = `_${li}`;
+    bindings.push(
+      { _name: `csmTex${suffix}`, _type: { _kind: "texture", _textureType: "texture_depth_2d_array", _sampleType: "depth" }, _group: "shadow", _visibility: STAGE_FRAGMENT },
+      { _name: `csmComp${suffix}`, _type: { _kind: "sampler", _samplerType: "sampler_comparison" }, _group: "shadow", _visibility: STAGE_FRAGMENT },
+      { _name: `csmInfo${suffix}`, _type: { _kind: "uniform-buffer" }, _group: "shadow", _visibility: STAGE_FRAGMENT }
+    );
+    helperParts.push(
+      `struct csmInfo${suffix}Uniforms { cascadeTransforms: array<mat4x4<f32>, 4>, viewFrustumZ: vec4<f32>, frustumLengths: vec4<f32>, shadowsInfo: vec4<f32>, csmParams: vec4<f32> };`
+    );
+    helperParts.push(`
+fn computeFallOffCsm${suffix}(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {
+let mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));
+return mix(value, 1.0, mask);
+}
+fn csmSample${suffix}(layer: i32, worldPos: vec4<f32>) -> f32 {
+let posFromLight = csmInfo${suffix}.cascadeTransforms[layer] * worldPos;
+let clipSpace = posFromLight.xyz / posFromLight.w;
+let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);
+let depthRef = clamp(clipSpace.z, 0.0, 0.99999994);
+let mapSz = csmInfo${suffix}.shadowsInfo.y;
+let invMapSz = csmInfo${suffix}.shadowsInfo.z;
+var tc = uv * mapSz + 0.5;
+let st = fract(tc);
+let base = (floor(tc) - 0.5) * invMapSz;
+let uvw0 = 4.0 - 3.0 * st;
+let uvw1 = vec2<f32>(7.0);
+let uvw2 = 1.0 + 3.0 * st;
+let u = vec3<f32>((3.0 - 2.0 * st.x) / uvw0.x - 2.0, (3.0 + st.x) / uvw1.x, st.x / uvw2.x + 2.0) * invMapSz;
+let v = vec3<f32>((3.0 - 2.0 * st.y) / uvw0.y - 2.0, (3.0 + st.y) / uvw1.y, st.y / uvw2.y + 2.0) * invMapSz;
+var sh = 0.0;
+sh += uvw0.x * uvw0.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[0], v[0]), layer, depthRef);
+sh += uvw1.x * uvw0.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[1], v[0]), layer, depthRef);
+sh += uvw2.x * uvw0.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[2], v[0]), layer, depthRef);
+sh += uvw0.x * uvw1.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[0], v[1]), layer, depthRef);
+sh += uvw1.x * uvw1.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[1], v[1]), layer, depthRef);
+sh += uvw2.x * uvw1.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[2], v[1]), layer, depthRef);
+sh += uvw0.x * uvw2.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[0], v[2]), layer, depthRef);
+sh += uvw1.x * uvw2.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[1], v[2]), layer, depthRef);
+sh += uvw2.x * uvw2.y * textureSampleCompareLevel(csmTex${suffix}, csmComp${suffix}, base + vec2<f32>(u[2], v[2]), layer, depthRef);
+sh /= 144.0;
+sh = mix(csmInfo${suffix}.shadowsInfo.x, 1.0, sh);
+return computeFallOffCsm${suffix}(sh, clipSpace.xy, csmInfo${suffix}.shadowsInfo.w);
+}
+fn computeShadowCSM${suffix}(worldPos: vec4<f32>, viewZ: f32) -> f32 {
+let nCascades = i32(csmInfo${suffix}.csmParams.x);
+var idx = -1;
+var diff = 0.0;
+for (var i = 0; i < nCascades; i = i + 1) {
+diff = csmInfo${suffix}.viewFrustumZ[i] - viewZ;
+if (diff >= 0.0) { idx = i; break; }
+}
+if (idx < 0) { idx = nCascades - 1; }
+var shadow = csmSample${suffix}(idx, worldPos);
+let frustumLength = csmInfo${suffix}.frustumLengths[idx];
+let diffRatio = clamp(diff / frustumLength, 0.0, 1.0) * csmInfo${suffix}.csmParams.y;
+if (idx < nCascades - 1 && diffRatio < 1.0) {
+let nextShadow = csmSample${suffix}(idx + 1, worldPos);
+shadow = mix(nextShadow, shadow, diffRatio);
+}
+return shadow;
+}`);
+    fragmentLines.push(`shadowFactors[${li}] = computeShadowCSM${suffix}(vec4<f32>(${worldPosExpr}, 1.0), ${viewZExpr});`);
+  }
+  return {
+    _id: id,
+    _varyings: varyings,
+    _bindings: bindings,
+    _helperFunctions: helperParts.join("\n"),
+    _fragmentSlots: {
+      [outputSlot]: fragmentLines.join("\n")
+    }
+  };
+}
+function createStdCsmShadowFragment(shadowLights) {
+  return createCsmShadowFragment("std-csm-shadow", shadowLights);
+}
+function createPbrCsmShadowFragment(shadowLights) {
+  return createCsmShadowFragment("pbr-csm-shadow", shadowLights, {
+    worldPosExpr: "input.worldPos",
+    viewZExpr: "(scene.view * vec4<f32>(input.worldPos, 1.0)).z",
+    outputSlot: "AS"
+  });
+}
+function createCsmDirectionalShadowGenerator(engine, _light, cfg = {}) {
+  setCsmStdReceiverFactory(createStdCsmShadowFragment);
+  setCsmPbrReceiverFactory(createPbrCsmShadowFragment);
+  const device = engine._device;
+  const mapSize = cfg.mapSize ?? 1024;
+  const numCascades = Math.min(cfg.numCascades ?? 4, 4);
+  const bias = cfg.bias ?? 5e-5;
+  const darkness = cfg.darkness ?? 0;
+  const frustumEdgeFalloff = cfg.frustumEdgeFalloff ?? 0;
+  const csmCfg = {
+    _numCascades: numCascades,
+    _lambda: cfg.lambda ?? 0.5,
+    _cascadeBlendPercentage: cfg.cascadeBlendPercentage ?? 0.1,
+    _stabilizeCascades: cfg.stabilizeCascades ?? false,
+    _shadowMaxZ: cfg.shadowMaxZ ?? null,
+    _bias: bias,
+    _darkness: darkness,
+    _frustumEdgeFalloff: frustumEdgeFalloff,
+    _mapSize: mapSize,
+    _forceRefreshEveryFrame: cfg.forceRefreshEveryFrame ?? false
+  };
+  const depthTexture = device.createTexture({
+    size: { width: mapSize, height: mapSize, depthOrArrayLayers: numCascades },
+    format: "depth32float",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+  });
+  const _shadowsInfo = new Float32Array([darkness, mapSize, 1 / mapSize, frustumEdgeFalloff]);
+  const sg = {
+    _shadowType: "csm",
+    _light,
+    _depthTexture: depthTexture,
+    _depthSampler: device.createSampler({ compare: "less", magFilter: "linear", minFilter: "linear" }),
+    _lightMatrix: new Float32Array(16),
+    _shadowsInfo,
+    _depthValues: new Float32Array([0, 1]),
+    _shadowParamsUBO: createShadowParamsUBO(engine, bias, 1 / mapSize),
+    _shadowUBO: createUniformBuffer$1(engine, new Float32Array(80)),
+    _config: {
+      _mapSize: mapSize,
+      _bias: bias,
+      _forceRefreshEveryFrame: csmCfg._forceRefreshEveryFrame
+    },
+    _version: 0,
+    _csmCascadeCount: numCascades
+  };
+  sg._preloadShadowTask = preloadCsmShadowTaskState;
+  sg._ensureShadowTaskState = (eng, scene, casterMeshes) => {
+    const state = ensureCsmShadowTaskState(eng, scene, sg, csmCfg, casterMeshes, sg._shadowTaskState ?? null);
+    sg._shadowTaskState = state;
+    return state;
+  };
+  sg._renderShadowMap = (eng, state) => renderCsmShadowMap(eng, sg, state, csmCfg);
+  return sg;
+}
+function onCsmReceiverUpdate(sg, cb) {
+  (sg._onReceiverData ?? (sg._onReceiverData = [])).push(cb);
+  return () => {
+    const list = sg._onReceiverData;
+    if (!list) {
+      return;
+    }
+    const i = list.indexOf(cb);
+    if (i >= 0) {
+      list.splice(i, 1);
+    }
+  };
+}
 const INTERP_LINEAR = 0;
 const INTERP_STEP = 1;
 const INTERP_CUBICSPLINE = 2;
@@ -14990,7 +16975,7 @@ async function pickAsync(picker, x, y) {
   const gsMeshCount = gsMeshes.length;
   const gsNextIdStart = nextId;
   if (gsMeshCount > 0) {
-    const gsModule = await import("./gs-picking-pipeline-DzfMASL9.js");
+    const gsModule = await import("./gs-picking-pipeline-Bx8LTav6.js");
     gsModule.computeGsPickMatrix(_gsPickMatrix, px, py, w, h);
     gsModule.gsPickWritePickMatrixAndBind(pass, engine, _gsPickMatrix);
     const resMap = picker._gsMeshResources ?? (picker._gsMeshResources = /* @__PURE__ */ new Map());
@@ -15097,7 +17082,7 @@ function disposePicker(picker) {
     picker._sceneBG = null;
   }
   if (picker._gsMeshResources) {
-    void import("./gs-picking-pipeline-DzfMASL9.js").then((m) => {
+    void import("./gs-picking-pipeline-Bx8LTav6.js").then((m) => {
       if (!picker._gsMeshResources) {
         return;
       }
@@ -17504,7 +19489,7 @@ function isBillboardSpriteHandleAlive(handle) {
 }
 function addBillboardSystem(scene, system) {
   addDeferredSceneRenderables(scene, async (engine) => {
-    const { buildBillboardRenderable } = await import("./billboard-renderable-D8mlVGCd.js");
+    const { buildBillboardRenderable } = await import("./billboard-renderable-DKmlOgbM.js");
     const built = buildBillboardRenderable(engine, system);
     return { renderables: [built.renderable], dispose: built.dispose };
   });
@@ -18762,461 +20747,486 @@ function _assertTileCache(plugin) {
   }
 }
 export {
-  BILLBOARD_SYSTEM_UBO_BYTES as $,
-  uploadTex as A,
-  linearToSrgbByte as B,
-  createFreeCamera as C,
-  targetSignatureKey as D,
-  createDefaultPipelineDescriptor as E,
-  getSceneBindGroupLayout as F,
-  disposeGaussianSplattingMesh as G,
-  applyGsFragments as H,
-  INTERP_CUBICSPLINE as I,
-  getRenderTargetSize as J,
-  getViewMatrix as K,
-  getProjectionMatrix as L,
+  HAS_EMISSIVE_TEXTURE as $,
+  createMaterialView as A,
+  MATERIAL_ALPHA_BLEND as B,
+  PBR_HAS_ALPHA_BLEND as C,
+  encodeIdToColor as D,
+  ESM_SHADOW_OUTPUT as E,
+  getPickingSceneBGL as F,
+  gsGpuPickingFragment as G,
+  BILLBOARD_INDEX_DATA as H,
+  createEmptyUniformBuffer as I,
+  BILLBOARD_SYSTEM_UBO_BYTES as J,
+  createBillboardInstanceBuffer as K,
+  createBillboardInstanceSortScratch as L,
   MAX_LIGHTS as M,
   NODE_ESM_SHADOW_OUTPUT as N,
-  getCameraPosition as O,
-  PATH_WEIGHTS as P,
-  createMaterialView as Q,
-  ESM_SHADOW_OUTPUT as R,
-  MATERIAL_ALPHA_BLEND as S,
+  getOrCreateBillboardPipeline as O,
+  PBR2_ESM_SHADOW_OUTPUT as P,
+  createBillboardSystemBindGroup as Q,
+  resetBillboardPipelineCache as R,
+  ensureBillboardInstanceBuffer as S,
   TYPE_SIZES as T,
-  PBR2_ESM_SHADOW_OUTPUT as U,
-  PBR_HAS_ALPHA_BLEND as V,
-  encodeIdToColor as W,
-  getPickingSceneBGL as X,
-  gsGpuPickingFragment as Y,
-  BILLBOARD_INDEX_DATA as Z,
-  createEmptyUniformBuffer as _,
+  uploadSortedBillboardInstances as U,
+  uploadBillboardInstances as V,
+  buildBillboardSystemUbo as W,
+  writeBillboardSystemUboIfDirty as X,
+  createBillboardPipelineCache as Y,
+  HAS_BUMP_TEXTURE as Z,
+  _getBillboardFxHook as _,
   writeMeshLightSelection as a,
-  getEffectiveAspectRatio as a$,
-  createBillboardInstanceBuffer as a0,
-  _getBillboardFxHook as a1,
-  createBillboardInstanceSortScratch as a2,
-  getOrCreateBillboardPipeline as a3,
-  createBillboardSystemBindGroup as a4,
-  resetBillboardPipelineCache as a5,
-  ensureBillboardInstanceBuffer as a6,
-  uploadSortedBillboardInstances as a7,
-  uploadBillboardInstances as a8,
-  buildBillboardSystemUbo as a9,
-  PBR_HAS_SHEEN_TEXTURE as aA,
-  PBR_HAS_SHEEN as aB,
-  PBR2_HAS_SHEEN_UV_TX as aC,
-  PBR_HAS_SHEEN_ALBEDO_SCALING as aD,
-  PBR2_HAS_IRIDESCENCE_MAP as aE,
-  PBR2_HAS_IRIDESCENCE_THICKNESS_MAP as aF,
-  PBR2_HAS_IRIDESCENCE as aG,
-  PBR_HAS_THICKNESS_MAP as aH,
-  PBR_HAS_SUBSURFACE as aI,
-  PBR2_HAS_THICKNESS_GLTF_CHANNEL as aJ,
-  PBR_HAS_EMISSIVE_COLOR as aK,
-  PBR_HAS_EMISSIVE as aL,
-  PBR2_HAS_UNLIT as aM,
-  identityTexWrap as aN,
-  getOrCreateSampler as aO,
-  assembleMaterial as aP,
-  runMatExts as aQ,
-  makeImageFetcher as aR,
-  WGSL$1 as aS,
-  getCompressedFormat as aT,
-  acquireTexture as aU,
-  computeUboLayout as aV,
-  SCENE_UBO_WGSL as aW,
-  PATH_POINTER as aX,
-  createUniformBuffer$1 as aY,
-  createSingleUniformBGL as aZ,
-  _isShaderSystemUniform as a_,
-  writeBillboardSystemUboIfDirty as aa,
-  createBillboardPipelineCache as ab,
-  HAS_BUMP_TEXTURE as ac,
-  HAS_EMISSIVE_TEXTURE as ad,
-  HAS_DEPTH_EMISSIVE_TEXTURE as ae,
-  HAS_SPECULAR_TEXTURE as af,
-  SPECULAR_USES_UV2 as ag,
-  HAS_AMBIENT_TEXTURE as ah,
-  AMBIENT_USES_UV2 as ai,
-  HAS_LIGHTMAP_TEXTURE as aj,
-  LIGHTMAP_USES_UV2 as ak,
-  HAS_OPACITY_TEXTURE as al,
-  OPACITY_FROM_RGB as am,
-  HAS_REFLECTION_TEXTURE as an,
-  HAS_CUBE_REFLECTION as ao,
-  PBR_HAS_ALPHA_TEST as ap,
-  PBR_HAS_METALLIC_REFLECTANCE_MAP as aq,
-  PBR_HAS_REFLECTANCE_MAP as ar,
-  PBR2_HAS_REFLECTANCE_FACTORS as as,
-  PBR2_HAS_UV2 as at,
-  PBR_HAS_USE_ALPHA_ONLY_MR as au,
-  PBR_HAS_CLEARCOAT as av,
-  PBR2_CC_INT_MAP as aw,
-  PBR2_CC_ROUGH_MAP as ax,
-  PBR2_CC_NORMAL_MAP as ay,
-  PBR2_CC_F0_REMAP_OFF as az,
+  SCENE_UBO_WGSL as a$,
+  HAS_DEPTH_EMISSIVE_TEXTURE as a0,
+  HAS_SPECULAR_TEXTURE as a1,
+  SPECULAR_USES_UV2 as a2,
+  HAS_AMBIENT_TEXTURE as a3,
+  AMBIENT_USES_UV2 as a4,
+  HAS_LIGHTMAP_TEXTURE as a5,
+  LIGHTMAP_USES_UV2 as a6,
+  HAS_OPACITY_TEXTURE as a7,
+  OPACITY_FROM_RGB as a8,
+  HAS_REFLECTION_TEXTURE as a9,
+  PBR2_HAS_UNLIT as aA,
+  setMaxLights as aB,
+  computeNodeWorldMatrix as aC,
+  setSubtreeVisible as aD,
+  mat4Invert as aE,
+  mat4Identity as aF,
+  getLoaderTmpAnim as aG,
+  mat4MultiplyInto as aH,
+  INTERP_CUBICSPLINE as aI,
+  INTERP_STEP as aJ,
+  INTERP_LINEAR as aK,
+  PATH_WEIGHTS as aL,
+  PATH_SCALE as aM,
+  PATH_ROTATION as aN,
+  PATH_TRANSLATION as aO,
+  findParent as aP,
+  setThinInstances as aQ,
+  mat4ComposeInto as aR,
+  getLoaderTmpInstance as aS,
+  mat4Multiply as aT,
+  WGSL$1 as aU,
+  identityTexWrap as aV,
+  getOrCreateSampler as aW,
+  assembleMaterial as aX,
+  runMatExts as aY,
+  makeImageFetcher as aZ,
+  createUniformBuffer$1 as a_,
+  HAS_CUBE_REFLECTION as aa,
+  getCsmStdReceiverFactory as ab,
+  getCsmPbrReceiverFactory as ac,
+  PBR_HAS_ALPHA_TEST as ad,
+  PBR_HAS_METALLIC_REFLECTANCE_MAP as ae,
+  PBR_HAS_REFLECTANCE_MAP as af,
+  PBR2_HAS_REFLECTANCE_FACTORS as ag,
+  PBR2_HAS_UV2 as ah,
+  PBR_HAS_USE_ALPHA_ONLY_MR as ai,
+  PBR_HAS_CLEARCOAT as aj,
+  PBR2_CC_INT_MAP as ak,
+  PBR2_CC_ROUGH_MAP as al,
+  PBR2_CC_NORMAL_MAP as am,
+  PBR2_CC_F0_REMAP_OFF as an,
+  PBR_HAS_SHEEN_TEXTURE as ao,
+  PBR_HAS_SHEEN as ap,
+  PBR2_HAS_SHEEN_UV_TX as aq,
+  PBR_HAS_SHEEN_ALBEDO_SCALING as ar,
+  PBR2_HAS_IRIDESCENCE_MAP as as,
+  PBR2_HAS_IRIDESCENCE_THICKNESS_MAP as at,
+  PBR2_HAS_IRIDESCENCE as au,
+  PBR_HAS_THICKNESS_MAP as av,
+  PBR_HAS_SUBSURFACE as aw,
+  PBR2_HAS_THICKNESS_GLTF_CHANNEL as ax,
+  PBR_HAS_EMISSIVE_COLOR as ay,
+  PBR_HAS_EMISSIVE as az,
   NODE_NO_COLOR_OUTPUT as b,
-  addFacingBillboardSystem as b$,
-  getViewProjectionMatrix as b0,
-  releaseTexture as b1,
-  getBilinearSampler as b2,
-  _getPbrExtsSorted as b3,
-  PBR_HAS_SPEC_GLOSS as b4,
-  REVERSE_DEPTH_COMPARE as b5,
-  PBR_HAS_NORMAL_MAP as b6,
-  PBR2_NO_COLOR_OUTPUT as b7,
-  PBR_HAS_DOUBLE_SIDED as b8,
-  appendMeshLightUboFields as b9,
-  DIFFUSE_USES_UV2 as bA,
-  DOUBLE_SIDED as bB,
-  DISABLE_LIGHTING as bC,
-  clearSceneBGLCache as bD,
-  _getStdExtsSorted as bE,
-  NEEDS_UV as bF,
-  NO_COLOR_OUTPUT as bG,
-  NEEDS_UV2 as bH,
-  CAP_ALL as bI,
-  CAP_END as bJ,
-  CAP_NONE as bK,
-  CAP_START as bL,
-  ObservableQuat as bM,
-  ObservableVec3 as bN,
-  PhysicsMotionType as bO,
-  PhysicsShapeType as bP,
-  VERSION as bQ,
-  addAgent as bR,
-  addAnimationGroup as bS,
-  addAnimationGroups as bT,
-  addAnimationTask as bU,
-  addAxisLockedBillboardSystem as bV,
-  addBillboardSprite as bW,
-  addBillboardSpriteIndex as bX,
-  addBoxObstacle as bY,
-  addCylinderObstacle as bZ,
-  addDepthHostedSpriteLayer as b_,
-  meshLightIndexWGSL as ba,
-  _getPbrExts as bb,
-  PBR2_HAS_UV_TRANSFORM as bc,
-  PBR_HAS_ANISOTROPY as bd,
-  PBR_HAS_SKYBOX as be,
-  PBR_HAS_SPECULAR_AA as bf,
-  PBR_HAS_ENV as bg,
-  PBR_HAS_OCCLUSION as bh,
-  PBR2_HAS_BASE_COLOR_FACTOR as bi,
-  PBR_HAS_GAMMA_ALBEDO as bj,
-  PBR_HAS_TONEMAP as bk,
-  _registerPbrExt as bl,
-  clearSamplerCache as bm,
-  _computePbrMaterialFeatures as bn,
-  PBR2_HAS_REFRACTION as bo,
-  collectPbrBoundTextures as bp,
-  createImageProcessingTask as bq,
-  biasedMipLevelCount as br,
-  _vis as bs,
-  recordMipmaps as bt,
-  PBR2_HAS_REFRACTION_MAP as bu,
-  PBR2_LINEAR_IMAGE_PROCESSING as bv,
-  PBR2_HAS_DISPERSION as bw,
-  PBR2_HAS_VOLUME as bx,
-  _getStdExts as by,
-  HAS_DIFFUSE_TEXTURE as bz,
+  addAnimationGroup as b$,
+  createSingleUniformBGL as b0,
+  computeUboLayout as b1,
+  getViewProjectionMatrix as b2,
+  _isShaderSystemUniform as b3,
+  acquireTexture as b4,
+  releaseTexture as b5,
+  getEffectiveAspectRatio as b6,
+  getCompressedFormat as b7,
+  PATH_POINTER as b8,
+  PBR2_HAS_REFRACTION as b9,
+  _registerPbrExt as bA,
+  clearSamplerCache as bB,
+  _computePbrMaterialFeatures as bC,
+  collectPbrBoundTextures as bD,
+  _getStdExts as bE,
+  clearSceneBGLCache as bF,
+  _getStdExtsSorted as bG,
+  _standardFeatureKey as bH,
+  HAS_DIFFUSE_TEXTURE as bI,
+  NEEDS_UV as bJ,
+  DOUBLE_SIDED as bK,
+  NO_COLOR_OUTPUT as bL,
+  DISABLE_LIGHTING as bM,
+  DIFFUSE_USES_UV2 as bN,
+  NEEDS_UV2 as bO,
+  _computeStandardMaterialFeatures as bP,
+  _standardShaderVariantKey as bQ,
+  CAP_ALL as bR,
+  CAP_END as bS,
+  CAP_NONE as bT,
+  CAP_START as bU,
+  ObservableQuat as bV,
+  ObservableVec3 as bW,
+  PhysicsMotionType as bX,
+  PhysicsShapeType as bY,
+  VERSION as bZ,
+  addAgent as b_,
+  PBR2_HAS_REFRACTION_MAP as ba,
+  getTrilinearAnisotropicSampler as bb,
+  PBR2_LINEAR_IMAGE_PROCESSING as bc,
+  PBR2_HAS_DISPERSION as bd,
+  PBR2_HAS_VOLUME as be,
+  enableSceneTransmission as bf,
+  getBilinearSampler as bg,
+  _getPbrExtsSorted as bh,
+  PBR_HAS_SPEC_GLOSS as bi,
+  REVERSE_DEPTH_COMPARE as bj,
+  PBR_HAS_NORMAL_MAP as bk,
+  PBR2_NO_COLOR_OUTPUT as bl,
+  PBR_HAS_DOUBLE_SIDED as bm,
+  appendMeshLightUboFields as bn,
+  meshLightIndexWGSL as bo,
+  _getPbrExts as bp,
+  PBR2_HAS_UV_TRANSFORM as bq,
+  PBR_HAS_ANISOTROPY as br,
+  PBR_HAS_SKYBOX as bs,
+  PBR_HAS_SPECULAR_AA as bt,
+  PBR_HAS_ENV as bu,
+  PBR_HAS_FOG as bv,
+  PBR_HAS_OCCLUSION as bw,
+  PBR2_HAS_BASE_COLOR_FACTOR as bx,
+  PBR_HAS_GAMMA_ALBEDO as by,
+  PBR_HAS_TONEMAP as bz,
   compileNodePipeline as c,
-  createHavokWorld as c$,
-  addPassDependencies as c0,
-  addRenderPass as c1,
-  addSprite2D as c2,
-  addSprite2DIndex as c3,
-  addSpriteAnimation as c4,
-  addSpriteAnimationManager as c5,
-  addSpriteRendererLayer as c6,
-  addTask as c7,
-  addTaskAtStart as c8,
-  addTaskBefore as c9,
-  createBillboardCustomShader as cA,
-  createBlackAndWhitePostProcessTask as cB,
-  createBloomPostProcessTask as cC,
-  createBlurPostProcessTask as cD,
-  createBox as cE,
-  createChromaticAberrationPostProcessTask as cF,
-  createCsg2FromMesh as cG,
-  createCsgFromMesh as cH,
-  createCylinder as cI,
-  createDebugNavMeshGeometry as cJ,
-  createDefaultCamera as cK,
-  createDirectionalLight as cL,
-  createDisc as cM,
-  createEffectRenderTask as cN,
-  createEffectRenderer as cO,
-  createEffectWrapper as cP,
-  createEngine as cQ,
-  createEsmDirectionalShadowGenerator as cR,
-  createExtractHighlightsPostProcessTask as cS,
-  createExtrudeShape as cT,
-  createFacingBillboardSystem as cU,
-  createFrameGraphContext as cV,
-  createGpuPicker as cW,
-  createGridMaterial as cX,
-  createGridSpriteAtlas as cY,
-  createGround as cZ,
-  createGroundFromHeightMap as c_,
-  addThinInstance as ca,
-  addToScene as cb,
-  agentGoto as cc,
-  attachControl as cd,
-  attachFreeControl as ce,
-  attachSpriteAnimationsToRenderer as cf,
-  attachSpriteAnimationsToScene as cg,
-  bakeCurrentTransformIntoVertices as ch,
-  bakeTransformIntoVertices as ci,
-  billboardBlendAdditive as cj,
-  billboardBlendAlpha as ck,
-  billboardBlendCutout as cl,
-  billboardBlendPremultiplied as cm,
-  clearAnimationManager as cn,
-  clearBillboardSprites as co,
-  clearSprite2DLayer as cp,
-  clearSpriteAnimations as cq,
-  cloneTransformNode as cr,
-  computePath as cs,
-  createAnaglyphPostProcessTask as ct,
-  createAnimationController as cu,
-  createAnimationGroups as cv,
-  createAnimationManager as cw,
-  createAnimationTask as cx,
-  createArcRotateCamera as cy,
-  createAxisLockedBillboardSystem as cz,
+  createEffectRenderer as c$,
+  addAnimationGroups as c0,
+  addAnimationTask as c1,
+  addAxisLockedBillboardSystem as c2,
+  addBillboardSprite as c3,
+  addBillboardSpriteIndex as c4,
+  addBoxObstacle as c5,
+  addClusteredLightContainer as c6,
+  addCylinderObstacle as c7,
+  addDepthHostedSpriteLayer as c8,
+  addFacingBillboardSystem as c9,
+  clearSpriteAnimations as cA,
+  cloneTransformNode as cB,
+  computePath as cC,
+  createAnaglyphPostProcessTask as cD,
+  createAnimationController as cE,
+  createAnimationGroups as cF,
+  createAnimationManager as cG,
+  createAnimationTask as cH,
+  createArcRotateCamera as cI,
+  createAxisLockedBillboardSystem as cJ,
+  createBillboardCustomShader as cK,
+  createBlackAndWhitePostProcessTask as cL,
+  createBloomPostProcessTask as cM,
+  createBlurPostProcessTask as cN,
+  createBox as cO,
+  createChromaticAberrationPostProcessTask as cP,
+  createClusteredLightContainer as cQ,
+  createClusteredPointLight as cR,
+  createCsg2FromMesh as cS,
+  createCsgFromMesh as cT,
+  createCsmDirectionalShadowGenerator as cU,
+  createCylinder as cV,
+  createDebugNavMeshGeometry as cW,
+  createDefaultCamera as cX,
+  createDirectionalLight as cY,
+  createDisc as cZ,
+  createEffectRenderTask as c_,
+  addPassDependencies as ca,
+  addRenderPass as cb,
+  addSprite2D as cc,
+  addSprite2DIndex as cd,
+  addSpriteAnimation as ce,
+  addSpriteAnimationManager as cf,
+  addSpriteRendererLayer as cg,
+  addTask as ch,
+  addTaskAtStart as ci,
+  addTaskBefore as cj,
+  addThinInstance as ck,
+  addToScene as cl,
+  agentGoto as cm,
+  attachControl as cn,
+  attachFreeControl as co,
+  attachSpriteAnimationsToRenderer as cp,
+  attachSpriteAnimationsToScene as cq,
+  bakeCurrentTransformIntoVertices as cr,
+  bakeTransformIntoVertices as cs,
+  billboardBlendAdditive as ct,
+  billboardBlendAlpha as cu,
+  billboardBlendCutout as cv,
+  billboardBlendPremultiplied as cw,
+  clearAnimationManager as cx,
+  clearBillboardSprites as cy,
+  clearSprite2DLayer as cz,
   computeAabb as d,
-  disposePicker as d$,
-  createHemisphericLight as d0,
-  createLinearDepthMaterial as d1,
-  createMeshFromCsg as d2,
-  createMeshFromCsg2 as d3,
-  createMeshFromData as d4,
-  createMeshesFromCsg2 as d5,
-  createMorphTargets as d6,
-  createNavCrowd as d7,
-  createNavMesh as d8,
-  createNavigationPluginAsync as d9,
-  createSprite2DCustomShader as dA,
-  createSprite2DLayer as dB,
-  createSpriteAnimationManager as dC,
-  createSpriteAtlasFromFrames as dD,
-  createSpriteFrameAnimation as dE,
-  createSpriteRenderer as dF,
-  createStandardMaterial as dG,
-  createStandardNoColorMaterialView$1 as dH,
-  createTexture2DFromPixels as dI,
-  createTorus as dJ,
-  createTransformNode as dK,
-  createTube as dL,
-  createUniformEffectRenderTask as dM,
-  createUniformEffectWrapper as dN,
-  crossFadeAnimationGroups as dO,
-  csg2Add as dP,
-  csg2Intersect as dQ,
-  csg2Subtract as dR,
-  csgIntersect as dS,
-  csgSubtract as dT,
-  csgUnion as dU,
-  disposeCsg2 as dV,
-  disposeEffectRenderer as dW,
-  disposeEffectWrapper as dX,
-  disposeEngine as dY,
-  disposeFrameGraphContext as dZ,
-  disposePhysics as d_,
-  createNodeNoColorMaterialView$1 as da,
-  createPbrMaterial as db,
-  createPbrNoColorMaterialView$1 as dc,
-  createPcfDirectionalShadowGenerator as dd,
-  createPcfSpotlightShadowGenerator as de,
-  createPhysicsAggregate as df,
-  createPhysicsBody as dg,
-  createPhysicsShape as dh,
-  createPlane as di,
-  createPointLight as dj,
-  createPolyhedron as dk,
-  createProceduralGaussianSplattingMesh as dl,
-  createPropertyAnimationClip as dm,
-  createPropertyAnimationGroup as dn,
-  createRenderTarget as dp,
-  createRenderTargetTexture as dq,
-  createRenderTask as dr,
-  createRibbon as ds,
-  createSceneContext as dt,
-  createShaderMaterial as du,
-  createShadowTask as dv,
-  createSolidTexture2D as dw,
-  createSphere as dx,
-  createSphereData as dy,
-  createSpotLight as dz,
+  createTube as d$,
+  createEffectWrapper as d0,
+  createEngine as d1,
+  createEsmDirectionalShadowGenerator as d2,
+  createExtractHighlightsPostProcessTask as d3,
+  createExtrudeShape as d4,
+  createFacingBillboardSystem as d5,
+  createFrameGraphContext as d6,
+  createGpuPicker as d7,
+  createGridMaterial as d8,
+  createGridSpriteAtlas as d9,
+  createProceduralGaussianSplattingMesh as dA,
+  createPropertyAnimationClip as dB,
+  createPropertyAnimationGroup as dC,
+  createRenderTarget as dD,
+  createRenderTargetTexture as dE,
+  createRenderTask as dF,
+  createRibbon as dG,
+  createSceneContext as dH,
+  createShaderMaterial as dI,
+  createShadowTask as dJ,
+  createSolidTexture2D as dK,
+  createSphere as dL,
+  createSphereData as dM,
+  createSpotLight as dN,
+  createSprite2DCustomShader as dO,
+  createSprite2DLayer as dP,
+  createSpriteAnimationManager as dQ,
+  createSpriteAtlasFromFrames as dR,
+  createSpriteFrameAnimation as dS,
+  createSpriteRenderer as dT,
+  createStandardMaterial as dU,
+  createStandardNoColorMaterialView$1 as dV,
+  createTexture2DFromPixels as dW,
+  createTorus as dX,
+  createTorusKnot as dY,
+  createTorusKnotData as dZ,
+  createTransformNode as d_,
+  createGround as da,
+  createGroundFromHeightMap as db,
+  createHavokWorld as dc,
+  createHemisphericLight as dd,
+  createImageProcessingTask as de,
+  createLinearDepthMaterial as df,
+  createMeshFromCsg as dg,
+  createMeshFromCsg2 as dh,
+  createMeshFromData as di,
+  createMeshesFromCsg2 as dj,
+  createMorphTargets as dk,
+  createNavCrowd as dl,
+  createNavMesh as dm,
+  createNavigationPluginAsync as dn,
+  createNodeNoColorMaterialView$1 as dp,
+  createPbrMaterial as dq,
+  createPbrNoColorMaterialView$1 as dr,
+  createPcfDirectionalShadowGenerator as ds,
+  createPcfSpotlightShadowGenerator as dt,
+  createPhysicsAggregate as du,
+  createPhysicsBody as dv,
+  createPhysicsShape as dw,
+  createPlane as dx,
+  createPointLight as dy,
+  createPolyhedron as dz,
   createMappedBuffer as e,
-  registerEffectRenderer as e$,
-  disposeScene as e0,
-  disposeSpriteAnimationBinding as e1,
-  disposeSpriteRenderer as e2,
-  disposeUniformEffectWrapper as e3,
-  enableAnimationBlending as e4,
-  enableDetailedPicking as e5,
-  enableMaterialTracking as e6,
-  enablePropertyAnimationBlending as e7,
-  enableThinInstanceGpuCulling as e8,
-  fadeAnimationWeight as e9,
-  loadEnvironment as eA,
-  loadGltf as eB,
-  loadHdrEnvironment as eC,
-  loadKtxTexture2D as eD,
-  loadSOG as eE,
-  loadSPZ as eF,
-  loadSkybox as eG,
-  loadSplat as eH,
-  loadSpriteAtlas as eI,
-  loadTexture2D as eJ,
-  mat4Compose as eK,
-  mat4Scale as eL,
-  mat4Translation as eM,
-  normalizeVec3 as eN,
-  onBeforeRender as eO,
-  onSceneDispose as eP,
-  parseNodeMaterialFromSnippet as eQ,
-  pauseAnimation as eR,
-  pickAsync as eS,
-  playAnimation as eT,
-  playBillboardSpriteAnimation as eU,
-  playBillboardSpriteIndexAnimation as eV,
-  playSprite2DAnimation as eW,
-  playSprite2DIndexAnimation as eX,
-  playSpriteFrameAnimation as eY,
-  raycast as eZ,
-  rebuildMaterial as e_,
-  findRandomPoint as ea,
-  findRandomPointAroundCircle as eb,
-  flushThinInstances as ec,
-  getAgentPosition as ed,
-  getAgentVelocity as ee,
-  getAnimationGroups as ef,
-  getBillboardSpriteHandleIndex as eg,
-  getClosestPoint as eh,
-  getFrameGraph as ei,
-  getNavigationRandomSeed as ej,
-  getPhysicsGravity as ek,
-  getPhysicsTimestep as el,
-  getPhysicsVelocityLimits as em,
-  getPickedNormal as en,
-  getPickedUV as eo,
-  getSprite2DHandleIndex as ep,
-  getVariantNames as eq,
-  goToFrame as er,
-  gsAlphaBlendedDepthFragment as es,
-  gsLinearDepthFragment as et,
-  initializeCsg2Async as eu,
-  isBillboardSpriteHandleAlive as ev,
-  isCsg2Ready as ew,
-  isSprite2DHandleAlive as ex,
-  loadBabylon as ey,
-  loadBasisTexture2D as ez,
-  cloneTexture2D as f,
-  stopSpriteAnimationManager as f$,
-  registerFrameGraphContext as f0,
-  registerScene as f1,
-  registerSceneWithShadowSupport as f2,
-  registerSpriteRenderer as f3,
-  removeAnimationGroup as f4,
-  removeAnimationTask as f5,
-  removeBillboardSprite as f6,
-  removeBillboardSpriteIndex as f7,
-  removeFromScene as f8,
-  removeMeshFromTask as f9,
-  setPhysicsShapeMaterial as fA,
-  setPhysicsTimestep as fB,
-  setPhysicsVelocityLimits as fC,
-  setShaderFloat as fD,
-  setShaderMatrix as fE,
-  setShaderTexture as fF,
-  setShaderUniform as fG,
-  setShaderVector3 as fH,
-  setShadowTaskCasterMeshes as fI,
-  setSprite2DFrame as fJ,
-  setSprite2DFrameIndex as fK,
-  setSprite2DShaderParams as fL,
-  setSprite2DUvOffset as fM,
-  setThinInstanceColors as fN,
-  setThinInstanceMatrix as fO,
-  setUniformEffectUniforms as fP,
-  spriteBlendAdditive as fQ,
-  spriteBlendAlpha as fR,
-  spriteBlendMultiply as fS,
-  spriteBlendPremultiplied as fT,
-  startAnimationManager as fU,
-  startEngine as fV,
-  startSpriteAnimationManager as fW,
-  stopAnimation as fX,
-  stopAnimationManager as fY,
-  stopEngine as fZ,
-  stopSpriteAnimation as f_,
-  removeObstacle as fa,
-  removeSprite2D as fb,
-  removeSprite2DIndex as fc,
-  removeSpriteAnimation as fd,
-  removeSpriteAnimationManager as fe,
-  removeSpriteRendererLayer as ff,
-  removeThinInstance as fg,
-  resetVariant as fh,
-  resizeEngine as fi,
-  resolveCameraViewport as fj,
-  selectVariant as fk,
-  setAnimationAdditive as fl,
-  setAnimationTaskCategoryHandler as fm,
-  setAnimationWeight as fn,
-  setBillboardShaderParams as fo,
-  setBillboardSpriteFrame as fp,
-  setBillboardSpriteFrameIndex as fq,
-  setEffectTexture as fr,
-  setEffectUniforms as fs,
-  setEngineSize as ft,
-  setMorphTargetWeights as fu,
-  setNavigationRandomSeed as fv,
-  setParent as fw,
-  setPhysicsBodyMass as fx,
-  setPhysicsBodyShape as fy,
-  setPhysicsGravity as fz,
-  computeNodeWorldMatrix as g,
-  unregisterEffectRenderer as g0,
-  unregisterFrameGraphContext as g1,
-  unregisterScene as g2,
-  unregisterSpriteRenderer as g3,
-  updateAnimationManager as g4,
-  updateBillboardSprite as g5,
-  updateBillboardSpriteIndex as g6,
-  updateMeshPositions as g7,
-  updateNavCrowd as g8,
-  updateNavMeshObstacles as g9,
-  updateSprite2D as ga,
-  updateSprite2DIndex as gb,
-  updateSpriteAnimationManager as gc,
-  pointLight as gd,
-  directionalLight as ge,
-  spotLight as gf,
-  generateMipmaps$1 as gg,
-  animationGroup as gh,
-  createMorphTargets$1 as gi,
-  setSubtreeVisible as h,
+  loadSpriteAtlas as e$,
+  createUniformEffectRenderTask as e0,
+  createUniformEffectWrapper as e1,
+  crossFadeAnimationGroups as e2,
+  csg2Add as e3,
+  csg2Intersect as e4,
+  csg2Subtract as e5,
+  csgIntersect as e6,
+  csgSubtract as e7,
+  csgUnion as e8,
+  disposeCsg2 as e9,
+  getFloatingOriginOffset as eA,
+  getFrameGraph as eB,
+  getNavigationRandomSeed as eC,
+  getPhysicsGravity as eD,
+  getPhysicsTimestep as eE,
+  getPhysicsVelocityLimits as eF,
+  getPickedNormal as eG,
+  getPickedUV as eH,
+  getSprite2DHandleIndex as eI,
+  getVariantNames as eJ,
+  goToFrame as eK,
+  gsAlphaBlendedDepthFragment as eL,
+  gsLinearDepthFragment as eM,
+  initializeCsg2Async as eN,
+  isBillboardSpriteHandleAlive as eO,
+  isCsg2Ready as eP,
+  isSprite2DHandleAlive as eQ,
+  loadBabylon as eR,
+  loadBasisTexture2D as eS,
+  loadEnvironment as eT,
+  loadGltf as eU,
+  loadHdrEnvironment as eV,
+  loadKtxTexture2D as eW,
+  loadSOG as eX,
+  loadSPZ as eY,
+  loadSkybox as eZ,
+  loadSplat as e_,
+  disposeEffectRenderer as ea,
+  disposeEffectWrapper as eb,
+  disposeEngine as ec,
+  disposeFrameGraphContext as ed,
+  disposePhysics as ee,
+  disposePicker as ef,
+  disposeScene as eg,
+  disposeSpriteAnimationBinding as eh,
+  disposeSpriteRenderer as ei,
+  disposeUniformEffectWrapper as ej,
+  enableAnimationBlending as ek,
+  enableDetailedPicking as el,
+  enableMaterialPlugins as em,
+  enableMaterialTracking as en,
+  enablePropertyAnimationBlending as eo,
+  enableRenderTaskTransmission as ep,
+  enableThinInstanceGpuCulling as eq,
+  fadeAnimationWeight as er,
+  findRandomPoint as es,
+  findRandomPointAroundCircle as et,
+  flushThinInstances as eu,
+  getAgentPosition as ev,
+  getAgentVelocity as ew,
+  getAnimationGroups as ex,
+  getBillboardSpriteHandleIndex as ey,
+  getClosestPoint as ez,
+  anyPrimitive as f,
+  setShaderFloat as f$,
+  loadTexture2D as f0,
+  markClusteredLightContainerDirty as f1,
+  mat4Compose as f2,
+  mat4Scale as f3,
+  mat4Translation as f4,
+  normalizeVec3 as f5,
+  onBeforeRender as f6,
+  onCsmReceiverUpdate as f7,
+  onSceneDispose as f8,
+  parseNodeMaterialFromSnippet as f9,
+  removeSpriteRendererLayer as fA,
+  removeThinInstance as fB,
+  resetVariant as fC,
+  resizeEngine as fD,
+  resolveCameraViewport as fE,
+  selectVariant as fF,
+  setAnimationAdditive as fG,
+  setAnimationTaskCategoryHandler as fH,
+  setAnimationWeight as fI,
+  setBillboardShaderParams as fJ,
+  setBillboardSpriteFrame as fK,
+  setBillboardSpriteFrameIndex as fL,
+  setCameraLimits as fM,
+  setClipPlane as fN,
+  setEffectTexture as fO,
+  setEffectUniforms as fP,
+  setEngineSize as fQ,
+  setFog as fR,
+  setMorphTargetWeights as fS,
+  setNavigationRandomSeed as fT,
+  setParent as fU,
+  setPhysicsBodyMass as fV,
+  setPhysicsBodyShape as fW,
+  setPhysicsGravity as fX,
+  setPhysicsShapeMaterial as fY,
+  setPhysicsTimestep as fZ,
+  setPhysicsVelocityLimits as f_,
+  pauseAnimation as fa,
+  pickAsync as fb,
+  playAnimation as fc,
+  playBillboardSpriteAnimation as fd,
+  playBillboardSpriteIndexAnimation as fe,
+  playSprite2DAnimation as ff,
+  playSprite2DIndexAnimation as fg,
+  playSpriteFrameAnimation as fh,
+  raycast as fi,
+  rebuildMaterial as fj,
+  registerEffectRenderer as fk,
+  registerFrameGraphContext as fl,
+  registerScene as fm,
+  registerSceneWithShadowSupport as fn,
+  registerSpriteRenderer as fo,
+  removeAnimationGroup as fp,
+  removeAnimationTask as fq,
+  removeBillboardSprite as fr,
+  removeBillboardSpriteIndex as fs,
+  removeFromScene as ft,
+  removeMeshFromTask as fu,
+  removeObstacle as fv,
+  removeSprite2D as fw,
+  removeSprite2DIndex as fx,
+  removeSpriteAnimation as fy,
+  removeSpriteAnimationManager as fz,
+  createFreeCamera as g,
+  setShaderMatrix as g0,
+  setShaderTexture as g1,
+  setShaderUniform as g2,
+  setShaderVector3 as g3,
+  setShadowTaskCasterMeshes as g4,
+  setSprite2DFrame as g5,
+  setSprite2DFrameIndex as g6,
+  setSprite2DShaderParams as g7,
+  setSprite2DUvOffset as g8,
+  setThinInstanceColors as g9,
+  updateSpriteAnimationManager as gA,
+  updateTexture2DFromPixels as gB,
+  generateMipmaps$1 as gC,
+  pointLight as gD,
+  directionalLight as gE,
+  spotLight as gF,
+  animationGroup as gG,
+  createMorphTargets$1 as gH,
+  setThinInstanceMatrix as ga,
+  setUniformEffectUniforms as gb,
+  spriteBlendAdditive as gc,
+  spriteBlendAlpha as gd,
+  spriteBlendMultiply as ge,
+  spriteBlendPremultiplied as gf,
+  startAnimationManager as gg,
+  startEngine as gh,
+  startSpriteAnimationManager as gi,
+  stopAnimation as gj,
+  stopAnimationManager as gk,
+  stopEngine as gl,
+  stopSpriteAnimation as gm,
+  stopSpriteAnimationManager as gn,
+  unregisterEffectRenderer as go,
+  unregisterFrameGraphContext as gp,
+  unregisterScene as gq,
+  unregisterSpriteRenderer as gr,
+  updateAnimationManager as gs,
+  updateBillboardSprite as gt,
+  updateBillboardSpriteIndex as gu,
+  updateMeshPositions as gv,
+  updateNavCrowd as gw,
+  updateNavMeshObstacles as gx,
+  updateSprite2D as gy,
+  updateSprite2DIndex as gz,
+  createDefaultPipelineDescriptor as h,
   initMeshTransform as i,
-  mat4Invert as j,
-  mat4Identity as k,
-  mat4MultiplyInto as l,
+  getSceneBindGroupLayout as j,
+  pbrGroupBuilder as k,
+  linearToSrgbByte as l,
   markMaterialUboDirty as m,
-  INTERP_STEP as n,
-  INTERP_LINEAR as o,
-  PATH_SCALE as p,
-  PATH_ROTATION as q,
+  needsOrmComposite as n,
+  cloneTexture2D as o,
+  packMat4IntoF32 as p,
+  disposeGaussianSplattingMesh as q,
   resolveAccessor as r,
-  setMaxLights as s,
-  PATH_TRANSLATION as t,
-  findParent as u,
-  setThinInstances as v,
+  applyGsFragments as s,
+  targetSignatureKey as t,
+  uploadTex as u,
+  getRenderTargetSize as v,
   writeNodeUBO as w,
-  mat4ComposeInto as x,
-  mat4Multiply as y,
-  pbrGroupBuilder as z
+  getViewMatrix as x,
+  getProjectionMatrix as y,
+  getCameraPosition as z
 };
-//# sourceMappingURL=index-C8HOR2sB.js.map
+//# sourceMappingURL=index-B7Qhw0xL.js.map