@babylonjs/lite 1.0.0 → 1.0.1

package/{index-CLElg2Bo.js → index-C-tEgwbZ.js}

@@ -221,7 +221,7 @@ async function createEngine(canvas, options) {
   if (adapter.features.has("float32-filterable")) {
     features.push("float32-filterable");
   }
-  for (const f of ["texture-compression-astc", "texture-compression-bc", "texture-compression-etc2"]) {
+  for (const f of ["texture-compression-astc", "texture-compression-bc", "texture-compression-etc2", "timestamp-query"]) {
     if (adapter.features.has(f)) {
       features.push(f);
     }
@@ -238,7 +238,7 @@ async function createEngine(canvas, options) {
     throw new Error("Babylon Lite: useFloatingOrigin requires useHighPrecisionMatrix on the engine.");
   }
   if (useHpm) {
-    const { allocateF64Mat4 } = await import("./_mat4-storage-f64-CjDoht2w.js");
+    const { allocateF64Mat4 } = await import("./_mat4-storage-f64-BW9sTaVh.js");
     _setHpmAllocator(allocateF64Mat4);
   }
   let _wrapRenderableForFO;
@@ -267,6 +267,7 @@ async function createEngine(canvas, options) {
       _surfaces: surfaces,
       _device: device,
       drawCallCount: 0,
+      gpuFrameTimeMs: 0,
       useHighPrecisionMatrix: useHpm,
       useFloatingOrigin: useFO,
       _animFrameId: 0,
@@ -333,7 +334,7 @@ function disposeEngine(engine) {
   engine._device.destroy();
 }
 function renderFrame(engine, delta) {
-  var _a, _b2;
+  var _a, _b2, _c, _d, _e;
   const surfaces = engine.surfaces;
   let total = 0;
   for (let i = 0; i < surfaces.length; i++) {
@@ -345,10 +346,11 @@ function renderFrame(engine, delta) {
   const encoder = engine._device.createCommandEncoder({ label: "frame" });
   engine._currentEncoder = encoder;
   engine._currentDelta = delta;
+  (_a = engine._gpuTimerBegin) == null ? void 0 : _a.call(engine, encoder);
   let drawCalls = 0;
   for (let i = 0; i < surfaces.length; i++) {
     const surface = surfaces[i];
-    (_a = surface._capturePreFrame) == null ? void 0 : _a.call(surface, surface);
+    (_b2 = surface._capturePreFrame) == null ? void 0 : _b2.call(surface, surface);
     _refreshScRT(surface);
     const ctxs = surface._renderingContexts;
     for (let j = 0; j < ctxs.length; j++) {
@@ -361,18 +363,115 @@ function renderFrame(engine, delta) {
   const finalEncoder = engine._currentEncoder;
   for (let i = 0; i < surfaces.length; i++) {
     const surface = surfaces[i];
-    (_b2 = surface._captureService) == null ? void 0 : _b2.call(surface, surface, finalEncoder);
+    (_c = surface._captureService) == null ? void 0 : _c.call(surface, surface, finalEncoder);
   }
+  (_d = engine._gpuTimerEnd) == null ? void 0 : _d.call(engine, finalEncoder);
   engine._cbs[0] = finalEncoder.finish();
   engine._device.queue.submit(engine._cbs);
   engine.drawCallCount = drawCalls;
+  (_e = engine._gpuTimerResolve) == null ? void 0 : _e.call(engine);
+}
+function isGpuTimingSupported(engine) {
+  return engine._device.features.has("timestamp-query");
+}
+function setGpuTimingEnabled(engine, enabled) {
+  if (!enabled) {
+    engine._gpuTimerWanted = false;
+    engine.gpuFrameTimeMs = 0;
+    engine._gpuTimerBegin = void 0;
+    engine._gpuTimerEnd = void 0;
+    engine._gpuTimerResolve = engine._gpuTaskTimerResolve;
+    return;
+  }
+  if (!isGpuTimingSupported(engine)) {
+    return;
+  }
+  engine._gpuTimerWanted = true;
+  void import("./gpu-timer-CUpqT_hK.js").then(({ createGpuFrameTimer, gpuFrameTimerBegin, gpuFrameTimerEnd, gpuFrameTimerResolve }) => {
+    if (engine._gpuTimer === void 0) {
+      engine._gpuTimer = createGpuFrameTimer(engine._device);
+    }
+    const timer = engine._gpuTimer;
+    if (timer && engine._gpuTimerWanted) {
+      engine._gpuTimerBegin = (encoder) => gpuFrameTimerBegin(timer, encoder);
+      engine._gpuTimerEnd = (encoder) => gpuFrameTimerEnd(timer, encoder);
+      engine._gpuTimerResolve = () => {
+        var _a;
+        gpuFrameTimerResolve(timer);
+        engine.gpuFrameTimeMs = timer.lastMs;
+        (_a = engine._gpuTaskTimerResolve) == null ? void 0 : _a.call(engine);
+      };
+    }
+  });
+}
+function isRenderTaskGpuTimingSupported(engine) {
+  return engine._device.features.has("timestamp-query");
+}
+function getRenderTaskGpuTimings(engine) {
+  if (!isRenderTaskGpuTimingSupported(engine)) {
+    return makeTimingSnapshot("unsupported", false, false, 0, [], 0);
+  }
+  const snapshot = engine._gpuTaskTimingResult;
+  if (snapshot) {
+    return snapshot;
+  }
+  if (engine._gpuTaskTimerWanted) {
+    return makeTimingSnapshot("pending", true, true, 0, [], 0);
+  }
+  return makeTimingSnapshot("disabled", true, false, 0, [], 0);
+}
+async function setRenderTaskGpuTimingEnabled(engine, enabled) {
+  var _a;
+  if (!enabled) {
+    engine._gpuTaskTimerEpoch = (engine._gpuTaskTimerEpoch ?? 0) + 1;
+    engine._gpuTaskTimerWanted = false;
+    (_a = engine._gpuTaskTimerDisable) == null ? void 0 : _a.call(engine);
+    engine._gpuTaskTimerDisable = void 0;
+    const supported = isRenderTaskGpuTimingSupported(engine);
+    engine._gpuTaskTimingResult = makeTimingSnapshot(supported ? "disabled" : "unsupported", supported, false, 0, [], 0);
+    return engine._gpuTaskTimingResult;
+  }
+  if (!isRenderTaskGpuTimingSupported(engine)) {
+    engine._gpuTaskTimerWanted = false;
+    engine._gpuTaskTimingResult = makeTimingSnapshot("unsupported", false, false, 0, [], 0);
+    return engine._gpuTaskTimingResult;
+  }
+  if (engine._gpuTaskTimerWanted) {
+    return getRenderTaskGpuTimings(engine);
+  }
+  const epoch = (engine._gpuTaskTimerEpoch ?? 0) + 1;
+  engine._gpuTaskTimerEpoch = epoch;
+  engine._gpuTaskTimerWanted = true;
+  engine._gpuTaskTimingResult = makeTimingSnapshot("pending", true, true, 0, [], 0);
+  const { createGpuTaskTimer, installGpuTaskTimer } = await import("./gpu-task-timer-Dgkff80h.js");
+  if (!engine._gpuTaskTimerWanted || engine._gpuTaskTimerEpoch !== epoch) {
+    return getRenderTaskGpuTimings(engine);
+  }
+  if (engine._gpuTaskTimer === void 0) {
+    engine._gpuTaskTimer = createGpuTaskTimer(engine._device);
+  }
+  const timer = engine._gpuTaskTimer;
+  if (!timer) {
+    engine._gpuTaskTimerWanted = false;
+    engine._gpuTaskTimingResult = makeTimingSnapshot("unsupported", false, false, 0, [], 0);
+    return engine._gpuTaskTimingResult;
+  }
+  engine._gpuTaskTimerDisable = installGpuTaskTimer(timer, engine, (snapshot) => {
+    if (engine._gpuTaskTimerWanted && engine._gpuTaskTimerEpoch === epoch) {
+      engine._gpuTaskTimingResult = snapshot;
+    }
+  });
+  return getRenderTaskGpuTimings(engine);
+}
+function makeTimingSnapshot(status, supported, enabled, frameIndex, tasks, droppedTaskCount, error) {
+  return { status, supported, enabled, frameIndex, tasks, droppedTaskCount, error };
 }
 function captureScreenshot(surface) {
   const promise = new Promise((resolve, reject) => {
     (surface._captureQueue ?? (surface._captureQueue = [])).push({ resolve, reject });
   });
   if (!surface._captureService) {
-    void import("./screenshot-readback-D0Sj9qq3.js").then(({ createCaptureService, createCapturePreFrame }) => {
+    void import("./screenshot-readback-avr_tYGZ.js").then(({ createCaptureService, createCapturePreFrame }) => {
       surface._captureService ?? (surface._captureService = createCaptureService());
       surface._capturePreFrame ?? (surface._capturePreFrame = createCapturePreFrame());
     });
@@ -403,6 +502,56 @@ function disposeMeshGpu(mesh) {
     mesh.morphTargets.weightsBuffer.destroy();
   }
 }
+let _meshScenes = null;
+function enqueueMaterialSwap(scene, mesh) {
+  if (scene._materialSwapQueue.indexOf(mesh) >= 0) {
+    return;
+  }
+  scene._materialSwapQueue.push(mesh);
+  if (!scene._processSwaps) {
+    void import("./scene-material-swap-4qM0tpBK.js").then((m2) => {
+      scene._processSwaps = m2.processMaterialSwaps;
+    });
+  }
+}
+function installMaterialSetter(mesh) {
+  let _mat = mesh.material;
+  Object.defineProperty(mesh, "material", {
+    get() {
+      return _mat;
+    },
+    set(v) {
+      if (v !== _mat) {
+        _mat = v;
+        const scenes = _meshScenes == null ? void 0 : _meshScenes.get(mesh);
+        if (scenes) {
+          for (const scene of scenes) {
+            enqueueMaterialSwap(scene, mesh);
+          }
+        }
+      }
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+function registerMeshScene(scene, mesh) {
+  const map = _meshScenes ?? (_meshScenes = /* @__PURE__ */ new WeakMap());
+  let scenes = map.get(mesh);
+  if (!scenes) {
+    map.set(mesh, scenes = /* @__PURE__ */ new Set());
+    installMaterialSetter(mesh);
+  }
+  scenes.add(scene);
+}
+function unregisterMeshScene(scene, mesh) {
+  const scenes = _meshScenes == null ? void 0 : _meshScenes.get(mesh);
+  if (!scenes) {
+    return true;
+  }
+  scenes.delete(scene);
+  return scenes.size === 0;
+}
 function createFrameGraph(_engine) {
   const fg = {
     _tasks: [],
@@ -553,13 +702,13 @@ function getEffectiveAspectRatio(camera, targetWidth, targetHeight) {
   return targetWidth / targetHeight * (v ? v.width / v.height : 1);
 }
 let _cachedSceneBGL = null;
-let _cachedDevice$2 = null;
+let _cachedDevice$3 = null;
 function getSceneBindGroupLayout(engine) {
   const device = engine._device;
-  if (_cachedSceneBGL && _cachedDevice$2 === device) {
+  if (_cachedSceneBGL && _cachedDevice$3 === device) {
     return _cachedSceneBGL;
   }
-  _cachedDevice$2 = device;
+  _cachedDevice$3 = device;
   _cachedSceneBGL = device.createBindGroupLayout({
     label: "scene",
     entries: [
@@ -571,7 +720,7 @@ function getSceneBindGroupLayout(engine) {
 }
 function clearSceneBGLCache() {
   _cachedSceneBGL = null;
-  _cachedDevice$2 = null;
+  _cachedDevice$3 = null;
 }
 function createDefaultPipelineDescriptor(opts) {
   const target = opts._blend ? { format: opts._format, blend: opts._blend } : { format: opts._format };
@@ -1156,35 +1305,6 @@ function drawList$1(enc, list, engine) {
   }
   return draws;
 }
-function enqueueMaterialSwap(scene, mesh) {
-  const mi = mesh;
-  if (mi._materialDirty) {
-    return;
-  }
-  mi._materialDirty = true;
-  scene._materialSwapQueue.push(mesh);
-  if (!scene._processSwaps) {
-    void import("./scene-material-swap-nNUH4nGn.js").then((m2) => {
-      scene._processSwaps = m2.processMaterialSwaps;
-    });
-  }
-}
-function installMaterialSetter(scene, mesh) {
-  let _mat = mesh.material;
-  Object.defineProperty(mesh, "material", {
-    get() {
-      return _mat;
-    },
-    set(v) {
-      if (v !== _mat) {
-        _mat = v;
-        enqueueMaterialSwap(scene, mesh);
-      }
-    },
-    configurable: true,
-    enumerable: true
-  });
-}
 function createSceneContext(surface, options) {
   const eng = surface.engine;
   const ctxLocal = {
@@ -1305,7 +1425,7 @@ function addToScene(scene, entity) {
   if ("_gpu" in entity && "material" in entity) {
     const mesh = entity;
     ctx.meshes.push(mesh);
-    installMaterialSetter(ctx, mesh);
+    registerMeshScene(ctx, mesh);
     const build = mesh.material ? mesh.material._buildGroup : void 0;
     if (build) {
       let group = ctx._groups.get(build);
@@ -1349,7 +1469,9 @@ function disposeScene(scene) {
   }
   ctx._meshDisposables.clear();
   for (const mesh of ctx.meshes) {
-    disposeMeshGpu(mesh);
+    if (unregisterMeshScene(ctx, mesh)) {
+      disposeMeshGpu(mesh);
+    }
   }
   ctx.meshes.length = 0;
   ctx._renderables.length = 0;
@@ -1372,9 +1494,6 @@ async function buildScene(scene) {
     ctx._deferredBuilders = [];
     await Promise.all(builders.map(async (b) => b()));
   }
-  for (const mesh of ctx._materialSwapQueue) {
-    mesh._materialDirty = false;
-  }
   ctx._materialSwapQueue.length = 0;
   ctx._renderableVersion++;
   ctx._built = true;
@@ -1807,14 +1926,15 @@ function removeFromScene(scene, mesh) {
   if (qi >= 0) {
     scene._materialSwapQueue.splice(qi, 1);
   }
-  mesh._materialDirty = false;
   mesh.parent = null;
   for (const task of scene._frameGraph._tasks) {
     if ("_renderables" in task) {
       removeMeshFromTask(task, mesh);
     }
   }
-  disposeMeshGpu(mesh);
+  if (unregisterMeshScene(scene, mesh)) {
+    disposeMeshGpu(mesh);
+  }
 }
 function setSubtreeVisible(node, v) {
   cascade(node, v);
@@ -2927,7 +3047,7 @@ function createGeometryRendererTask(config, engine, scene) {
       if (hasStandard) {
         loads.push(
           (async () => {
-            const [viewMod, matMod] = await Promise.all([import("./geometry-view-BsFJpBJa.js"), Promise.resolve().then(() => standardMaterial)]);
+            const [viewMod, matMod] = await Promise.all([import("./geometry-view-xWZmq799.js"), Promise.resolve().then(() => standardMaterial)]);
             task._createStandardGeometryView = viewMod.createStandardGeometryMaterialView;
             task._computeStandardFeatures = matMod._computeStandardMaterialFeatures;
           })()
@@ -2936,7 +3056,7 @@ function createGeometryRendererTask(config, engine, scene) {
       if (hasPbr) {
         loads.push(
           (async () => {
-            const [viewMod, matMod] = await Promise.all([import("./pbr-geometry-view-NiZY_juX.js"), Promise.resolve().then(() => pbrMaterial)]);
+            const [viewMod, matMod] = await Promise.all([import("./pbr-geometry-view-T3vMABM8.js"), Promise.resolve().then(() => pbrMaterial)]);
             task._createPbrGeometryView = viewMod.createPbrGeometryMaterialView;
             task._computePbrFeatures = matMod._computePbrMaterialFeatures;
           })()
@@ -2945,7 +3065,7 @@ function createGeometryRendererTask(config, engine, scene) {
       if (hasNode) {
         loads.push(
           (async () => {
-            const viewMod = await import("./node-geometry-view-COmWsRXK.js");
+            const viewMod = await import("./node-geometry-view-CSXlEAhG.js");
             task._createNodeGeometryView = viewMod.createNodeGeometryMaterialView;
           })()
         );
@@ -3477,6 +3597,7 @@ function enableSceneTransmission(scene, engine) {
 function enableRenderTaskTransmission(task, engine, options) {
   var _a, _b2;
   const linear = (options == null ? void 0 : options.linear) !== false;
+  applyTransmissionOptions(task, options);
   const grab = {
     get texture() {
       return task._targetSignature._transmissionTexture ?? null;
@@ -3559,9 +3680,9 @@ function inverseImageProcessedColor(color, exposure, contrast, toneMapping) {
   };
 }
 function inverseImageProcessedChannel(value, exposure, contrast, toneMapping) {
-  let c2 = clamp01$1(value);
+  let c2 = clamp01$2(value);
   if (contrast < 1) {
-    c2 = contrast > 0 ? clamp01$1((c2 - 0.5 * (1 - contrast)) / contrast) : 0.5;
+    c2 = contrast > 0 ? clamp01$2((c2 - 0.5 * (1 - contrast)) / contrast) : 0.5;
   } else if (contrast > 1) {
     const mixAmount = contrast - 1;
     let lo = 0;
@@ -3584,7 +3705,7 @@ function inverseImageProcessedChannel(value, exposure, contrast, toneMapping) {
   }
   return exposure > 0 ? c2 / exposure : c2;
 }
-function clamp01$1(v) {
+function clamp01$2(v) {
   return Math.min(Math.max(v, 0), 1);
 }
 function markPbrMaterialsLinear(scene) {
@@ -3601,12 +3722,13 @@ function createRenderTaskTransmission(task, engine) {
   const width = 1024;
   const height = 1024;
   const format = "rgba16float";
-  const generateMipmaps2 = shouldGenerateMipmaps(task._config.transmission);
+  const mipLevelCount2 = transmissionMipLevelCount(task._config.transmission, width, height);
+  const generateMipmaps2 = mipLevelCount2 > 1;
   const texture = engine._device.createTexture({
     label: task.name,
     size: { width, height },
     format,
-    mipLevelCount: generateMipmaps2 ? biasedMipLevelCount(width, height, REFRACTION_LOD_BIAS) : 1,
+    mipLevelCount: mipLevelCount2,
     usage: TU.RENDER_ATTACHMENT | TU.TEXTURE_BINDING | TU.COPY_DST
   });
   const tex = {
@@ -3852,8 +3974,37 @@ 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;
+function applyTransmissionOptions(task, options) {
+  if (!options) {
+    return;
+  }
+  let next = task._config.transmission;
+  let changed = false;
+  const set = (key, value) => {
+    if (value === void 0) {
+      return;
+    }
+    next = { ...next, [key]: value };
+    changed = true;
+  };
+  set("copyCount", options.copyCount);
+  set("generateMipmaps", options.generateMipmaps);
+  set("mipLevelCount", options.mipLevelCount);
+  if (changed) {
+    task._config.transmission = next;
+  }
+}
+function transmissionMipLevelCount(cfg, width, height) {
+  if ((cfg == null ? void 0 : cfg.generateMipmaps) === false) {
+    return 1;
+  }
+  const full = Math.floor(Math.log2(Math.max(width, height))) + 1;
+  const defaultCount = biasedMipLevelCount(width, height, REFRACTION_LOD_BIAS);
+  const requested = cfg == null ? void 0 : cfg.mipLevelCount;
+  if (requested === void 0) {
+    return Math.min(full, defaultCount);
+  }
+  return Math.min(full, Math.max(1, requested | 0));
 }
 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;}`;
@@ -6234,12 +6385,12 @@ function computeLocalBasis(worldPos, refEast, refNorth, refUp) {
   refUp.x = worldPos.x / upLen;
   refUp.y = worldPos.y / upLen;
   refUp.z = worldPos.z / upLen;
-  cross(refUp, WORLD_NORTH, refEast);
+  cross$1(refUp, WORLD_NORTH, refEast);
   if (lengthSq(refEast) < GEO_EPSILON) {
-    cross(refUp, WORLD_RIGHT, refEast);
+    cross$1(refUp, WORLD_RIGHT, refEast);
   }
   normalizeInPlace(refEast);
-  cross(refEast, refUp, refNorth);
+  cross$1(refEast, refUp, refNorth);
   normalizeInPlace(refNorth);
 }
 function computeLookAtFromYawPitch(yaw, pitch, center, result) {
@@ -6352,15 +6503,15 @@ function createGeospatialCamera(options) {
     computeLocalBasis(center, east, north, up);
     computeLookAtFromYawPitch(scalars.yaw, scalars.pitch, center, lookAt);
     const right = { x: 0, y: 0, z: 0 };
-    cross(up, lookAt, right);
+    cross$1(up, lookAt, right);
     if (lengthSq(right) < GEO_EPSILON) {
       const cy = Math.cos(scalars.yaw);
       const sy = Math.sin(scalars.yaw);
       const horiz = { x: north.x * cy + east.x * sy, y: north.y * cy + east.y * sy, z: north.z * cy + east.z * sy };
-      cross(horiz, lookAt, right);
+      cross$1(horiz, lookAt, right);
     }
     normalizeInPlace(right);
-    cross(lookAt, right, upVector);
+    cross$1(lookAt, right, upVector);
     normalizeInPlace(upVector);
     position.x = center.x - lookAt.x * scalars.radius;
     position.y = center.y - lookAt.y * scalars.radius;
@@ -6428,7 +6579,7 @@ function createGeospatialCamera(options) {
   applyOrientation(0, 0, restingRadius, center);
   return cam;
 }
-function cross(a, b, out) {
+function cross$1(a, b, out) {
   const x = a.y * b.z - a.z * b.y;
   const y = a.z * b.x - a.x * b.z;
   const z = a.x * b.y - a.y * b.x;
@@ -6523,6 +6674,41 @@ function unprojectPoint(invVP, ndcX, ndcY, depth) {
   return [x * invW, y * invW, z * invW];
 }
 const REFERENCE_FRAME_RATE = 60;
+const REFERENCE_FRAME_MS = 1e3 / REFERENCE_FRAME_RATE;
+function frameDecay(inertia, effMs, referenceFrameMs = REFERENCE_FRAME_MS) {
+  return Math.pow(inertia, effMs / referenceFrameMs);
+}
+function integrateInertialVelocity(velocity, pixelDelta, inertia, effMs, hasActiveInput) {
+  if (effMs === 0) {
+    return velocity;
+  }
+  const decay = frameDecay(inertia, effMs);
+  let v = velocity * decay;
+  if (pixelDelta !== 0 || hasActiveInput) {
+    const oneMinus = 1 - inertia;
+    const inputScale = oneMinus > 0 ? (1 - decay) / oneMinus : 1;
+    v += pixelDelta / effMs * inputScale;
+  } else if (Math.abs(v) < 1e-6) {
+    v = 0;
+  }
+  return v;
+}
+function clamp01$1(v) {
+  return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function computePanSpeedMultiplier(center, position) {
+  const centerRadius = Math.hypot(center.x, center.y, center.z);
+  const currentRadius = Math.hypot(position.x, position.y, position.z);
+  const sinLat = centerRadius > 0 ? center.z / centerRadius : 0;
+  const cosLat = Math.sqrt(1 - Math.min(1, sinLat * sinLat));
+  const latDamp = Math.sqrt(Math.abs(cosLat));
+  const height = Math.max(currentRadius - centerRadius, GEO_EPSILON);
+  const altitudeScale = Math.max(1, centerRadius / height);
+  return clamp01$1(altitudeScale * latDamp);
+}
+function computeZoomSpeedMultiplier(distanceToTarget) {
+  return distanceToTarget * 0.01;
+}
 function attachGeospatialControls(camera, canvas, scene, options) {
   const zoomToCursor = (options == null ? void 0 : options.zoomToCursor) ?? true;
   const checkCollisions = (options == null ? void 0 : options.checkCollisions) ?? false;
@@ -6559,6 +6745,13 @@ function attachGeospatialControls(camera, canvas, scene, options) {
   let lastX = 0;
   let lastY = 0;
   const keysDown = /* @__PURE__ */ new Set();
+  const activeTouches = /* @__PURE__ */ new Map();
+  let pinchPrevDist = 0;
+  let pinchStartCentroidX = 0;
+  let pinchStartCentroidY = 0;
+  let pinchPanning = false;
+  const PINCH_PAN_THRESHOLD = 20;
+  const PINCH_ZOOM_SCALE = 0.05;
   function rectSize() {
     const r = canvas.getBoundingClientRect();
     return { width: r.width || canvas.width, height: r.height || canvas.height };
@@ -6815,26 +7008,8 @@ function attachGeospatialControls(camera, canvas, scene, options) {
     }
     return 1e3 / REFERENCE_FRAME_RATE;
   }
-  function frameDecay(inertia, dt) {
-    const eff = effectiveDeltaMs(dt);
-    const refMs = 1e3 / REFERENCE_FRAME_RATE;
-    return Math.pow(inertia, eff / refMs);
-  }
   function nextVelocity(vel, pixelDelta, inertia, dt) {
-    const eff = effectiveDeltaMs(dt);
-    if (eff === 0) {
-      return vel;
-    }
-    const decay = frameDecay(inertia, dt);
-    let v = vel * decay;
-    if (pixelDelta !== 0 || activeInput) {
-      const oneMinus = 1 - inertia;
-      const inputScale = oneMinus > 0 ? (1 - decay) / oneMinus : 1;
-      v += pixelDelta / eff * inputScale;
-    } else if (Math.abs(v) < 1e-6) {
-      v = 0;
-    }
-    return v;
+    return integrateInertialVelocity(vel, pixelDelta, inertia, effectiveDeltaMs(dt), activeInput);
   }
   function isDragging() {
     return hitPointRadius !== void 0;
@@ -6842,14 +7017,7 @@ function attachGeospatialControls(camera, canvas, scene, options) {
   function computeFrameDeltas(dt) {
     const center = camera.center;
     if (panAccumulated.x !== 0 || panAccumulated.y !== 0 || panAccumulated.z !== 0) {
-      const centerRadius = Math.hypot(center.x, center.y, center.z);
-      const currentRadius = Math.hypot(camera.position.x, camera.position.y, camera.position.z);
-      const upZ = centerRadius > 0 ? center.z / centerRadius : 0;
-      const cosLat = Math.sqrt(1 - Math.min(1, upZ * upZ));
-      const latDamp = Math.sqrt(Math.abs(cosLat));
-      const height = Math.max(currentRadius - centerRadius, GEO_EPSILON);
-      const latDampScale = Math.max(1, centerRadius / height);
-      panSpeedMultiplier = clampNum(latDampScale * latDamp, 0, 1);
+      panSpeedMultiplier = computePanSpeedMultiplier(center, camera.position);
     } else {
       panSpeedMultiplier = 1;
     }
@@ -6858,7 +7026,7 @@ function attachGeospatialControls(camera, canvas, scene, options) {
       zoomVelocity = 0;
     } else {
       const target = computedZoomPickPoint ? dist(camera.position, computedZoomPickPoint) : dist(camera.position, center);
-      zoomSpeedMultiplier = target * 0.01;
+      zoomSpeedMultiplier = computeZoomSpeedMultiplier(target);
     }
     const eff = effectiveDeltaMs(dt);
     panVelocity.x = nextVelocity(panVelocity.x, panAccumulated.x, panInertia, dt);
@@ -6912,39 +7080,45 @@ function attachGeospatialControls(camera, canvas, scene, options) {
     const rotateStep = 6;
     const zoomStep = 4;
     const panStep = camera.radius * 15e-4;
-    if (keysDown.has("ArrowLeft")) {
-      rotationAccumulated.y -= rotateStep;
-    }
-    if (keysDown.has("ArrowRight")) {
-      rotationAccumulated.y += rotateStep;
-    }
-    if (keysDown.has("ArrowUp")) {
-      rotationAccumulated.x += rotateStep;
-    }
-    if (keysDown.has("ArrowDown")) {
-      rotationAccumulated.x -= rotateStep;
-    }
+    const ctrl = keysDown.has("ControlLeft") || keysDown.has("ControlRight");
     if (keysDown.has("Equal") || keysDown.has("NumpadAdd")) {
       zoomAccumulated += zoomStep;
+      computedZoomPickPoint = null;
     }
     if (keysDown.has("Minus") || keysDown.has("NumpadSubtract")) {
       zoomAccumulated -= zoomStep;
+      computedZoomPickPoint = null;
+    }
+    if (ctrl) {
+      if (keysDown.has("ArrowLeft")) {
+        rotationAccumulated.y -= rotateStep;
+      }
+      if (keysDown.has("ArrowRight")) {
+        rotationAccumulated.y += rotateStep;
+      }
+      if (keysDown.has("ArrowUp")) {
+        rotationAccumulated.x += rotateStep;
+      }
+      if (keysDown.has("ArrowDown")) {
+        rotationAccumulated.x -= rotateStep;
+      }
+      return;
     }
     const east = { x: 0, y: 0, z: 0 };
     const north = { x: 0, y: 0, z: 0 };
     const up = { x: 0, y: 0, z: 0 };
     let dn = 0;
     let de = 0;
-    if (keysDown.has("KeyW")) {
+    if (keysDown.has("ArrowUp")) {
       dn += 1;
     }
-    if (keysDown.has("KeyS")) {
+    if (keysDown.has("ArrowDown")) {
       dn -= 1;
     }
-    if (keysDown.has("KeyD")) {
+    if (keysDown.has("ArrowRight")) {
       de += 1;
     }
-    if (keysDown.has("KeyA")) {
+    if (keysDown.has("ArrowLeft")) {
       de -= 1;
     }
     if (dn !== 0 || de !== 0) {
@@ -6972,6 +7146,9 @@ function attachGeospatialControls(camera, canvas, scene, options) {
     const dy = e.clientY - lastY;
     lastX = e.clientX;
     lastY = e.clientY;
+    if (activeTouches.size >= 2) {
+      return;
+    }
     if (mode === "none") {
       return;
     }
@@ -7004,6 +7181,86 @@ function attachGeospatialControls(camera, canvas, scene, options) {
   function onKeyUp(e) {
     keysDown.delete(e.code);
   }
+  function firstTwoTouches() {
+    const it = activeTouches.values();
+    const a = it.next().value;
+    const b = it.next().value;
+    return [a, b];
+  }
+  function onTouchStart(e) {
+    for (let i = 0; i < e.changedTouches.length; i++) {
+      const t = e.changedTouches[i];
+      activeTouches.set(t.identifier, { x: t.clientX, y: t.clientY });
+    }
+    if (activeTouches.size >= 2) {
+      e.preventDefault();
+      if (mode === "pan") {
+        stopDrag();
+      }
+      mode = "none";
+      const [p0, p1] = firstTwoTouches();
+      pinchPrevDist = Math.hypot(p1.x - p0.x, p1.y - p0.y);
+      pinchStartCentroidX = (p0.x + p1.x) / 2;
+      pinchStartCentroidY = (p0.y + p1.y) / 2;
+      pinchPanning = false;
+    }
+  }
+  function onTouchMove(e) {
+    for (let i = 0; i < e.changedTouches.length; i++) {
+      const t = e.changedTouches[i];
+      if (activeTouches.has(t.identifier)) {
+        activeTouches.set(t.identifier, { x: t.clientX, y: t.clientY });
+      }
+    }
+    if (activeTouches.size < 2) {
+      return;
+    }
+    e.preventDefault();
+    activeInput = true;
+    const [p0, p1] = firstTwoTouches();
+    const dist2 = Math.hypot(p1.x - p0.x, p1.y - p0.y);
+    const centroidClientX = (p0.x + p1.x) / 2;
+    const centroidClientY = (p0.y + p1.y) / 2;
+    const rect = canvas.getBoundingClientRect();
+    pointerX = centroidClientX - rect.left;
+    pointerY = centroidClientY - rect.top;
+    const centroidDrift = Math.hypot(centroidClientX - pinchStartCentroidX, centroidClientY - pinchStartCentroidY);
+    if (!pinchPanning && centroidDrift > PINCH_PAN_THRESHOLD) {
+      pinchPanning = true;
+      startDrag(pointerX, pointerY);
+    }
+    if (pinchPanning) {
+      handleDrag(pointerX, pointerY);
+    } else if (pinchPrevDist > 0) {
+      const dDist = dist2 - pinchPrevDist;
+      if (dDist !== 0) {
+        zoomAccumulated += dDist * PINCH_ZOOM_SCALE;
+        const pick = pickScreen(pointerX, pointerY);
+        computedZoomPickPoint = pick.hit && pick.point && zoomToCursor ? pick.point : pickAlongVector(camera._lookAt);
+      }
+    }
+    pinchPrevDist = dist2;
+  }
+  function onTouchEnd(e) {
+    for (let i = 0; i < e.changedTouches.length; i++) {
+      activeTouches.delete(e.changedTouches[i].identifier);
+    }
+    if (activeTouches.size < 2) {
+      if (pinchPanning) {
+        stopDrag();
+        pinchPanning = false;
+      }
+      pinchPrevDist = 0;
+    }
+    if (activeTouches.size === 1) {
+      const p3 = activeTouches.values().next().value;
+      lastX = p3.x;
+      lastY = p3.y;
+    }
+  }
+  function onGesture(e) {
+    e.preventDefault();
+  }
   scene._beforeRender.push(onBeforeRenderTick);
   const listeners = [
     [canvas, "pointerdown", onPointerDown],
@@ -7011,6 +7268,12 @@ function attachGeospatialControls(camera, canvas, scene, options) {
     [canvas, "pointerup", onPointerUp],
     [canvas, "wheel", onWheel, { passive: false }],
     [canvas, "contextmenu", onContextMenu],
+    [canvas, "touchstart", onTouchStart, { passive: false }],
+    [canvas, "touchmove", onTouchMove, { passive: false }],
+    [canvas, "touchend", onTouchEnd],
+    [canvas, "gesturestart", onGesture, { passive: false }],
+    [canvas, "gesturechange", onGesture, { passive: false }],
+    [canvas, "gestureend", onGesture, { passive: false }],
     [window, "keydown", onKeyDown],
     [window, "keyup", onKeyUp]
   ];
@@ -8951,6 +9214,117 @@ function createCylinderData(options = {}) {
     indices: new U32(indices)
   };
 }
+function createCapsuleData(options = {}) {
+  const subdivisions = Math.max(options.subdivisions ? options.subdivisions : 2, 1) | 0;
+  const tessellation = Math.max(options.tessellation ? options.tessellation : 16, 3) | 0;
+  const height = Math.max(options.height ? options.height : 1, 0);
+  const radius = Math.max(options.radius ? options.radius : 0.25, 0);
+  const capDetail = Math.max(options.capSubdivisions ? options.capSubdivisions : 6, 1) | 0;
+  const radialSegments = tessellation;
+  const heightSegments = subdivisions;
+  const radiusTop = Math.max(options.radiusTop ? options.radiusTop : radius, 0);
+  const radiusBottom = Math.max(options.radiusBottom ? options.radiusBottom : radius, 0);
+  const heightMinusCaps = height - (radiusTop + radiusBottom);
+  const thetaStart = 0;
+  const thetaLength = 2 * Math.PI;
+  const capsTopSegments = Math.max(options.topCapSubdivisions ? options.topCapSubdivisions : capDetail, 1);
+  const capsBottomSegments = Math.max(options.bottomCapSubdivisions ? options.bottomCapSubdivisions : capDetail, 1);
+  const alpha = Math.acos((radiusBottom - radiusTop) / height);
+  let indices = [];
+  const vertices = [];
+  const normals = [];
+  const uvs = [];
+  let index = 0;
+  const indexArray = [];
+  const halfHeight = heightMinusCaps * 0.5;
+  const pi2 = Math.PI * 0.5;
+  let x;
+  let y;
+  const cosAlpha = Math.cos(alpha);
+  const sinAlpha = Math.sin(alpha);
+  const coneLengthX = radiusTop * sinAlpha - radiusBottom * sinAlpha;
+  const coneLengthY = halfHeight + radiusTop * cosAlpha - (-halfHeight + radiusBottom * cosAlpha);
+  const coneLength = Math.sqrt(coneLengthX * coneLengthX + coneLengthY * coneLengthY);
+  const vl = radiusTop * alpha + coneLength + radiusBottom * (pi2 - alpha);
+  let v = 0;
+  for (y = 0; y <= capsTopSegments; y++) {
+    const indexRow = [];
+    const a = pi2 - alpha * (y / capsTopSegments);
+    v += radiusTop * alpha / capsTopSegments;
+    const cosA = Math.cos(a);
+    const sinA = Math.sin(a);
+    const ringRadius = cosA * radiusTop;
+    for (x = 0; x <= radialSegments; x++) {
+      const u = x / radialSegments;
+      const theta = u * thetaLength + thetaStart;
+      const sinTheta = Math.sin(theta);
+      const cosTheta = Math.cos(theta);
+      vertices.push(ringRadius * sinTheta, halfHeight + sinA * radiusTop, ringRadius * cosTheta);
+      normals.push(cosA * sinTheta, sinA, cosA * cosTheta);
+      uvs.push(u, 1 - v / vl);
+      indexRow.push(index);
+      index++;
+    }
+    indexArray.push(indexRow);
+  }
+  const coneHeight = height - radiusTop - radiusBottom + cosAlpha * radiusTop - cosAlpha * radiusBottom;
+  const slope = sinAlpha * (radiusBottom - radiusTop) / coneHeight;
+  for (y = 1; y <= heightSegments; y++) {
+    const indexRow = [];
+    v += coneLength / heightSegments;
+    const ringRadius = sinAlpha * (y * (radiusBottom - radiusTop) / heightSegments + radiusTop);
+    for (x = 0; x <= radialSegments; x++) {
+      const u = x / radialSegments;
+      const theta = u * thetaLength + thetaStart;
+      const sinTheta = Math.sin(theta);
+      const cosTheta = Math.cos(theta);
+      vertices.push(ringRadius * sinTheta, halfHeight + cosAlpha * radiusTop - y * coneHeight / heightSegments, ringRadius * cosTheta);
+      const inv = 1 / Math.sqrt(sinTheta * sinTheta + slope * slope + cosTheta * cosTheta);
+      normals.push(sinTheta * inv, slope * inv, cosTheta * inv);
+      uvs.push(u, 1 - v / vl);
+      indexRow.push(index);
+      index++;
+    }
+    indexArray.push(indexRow);
+  }
+  for (y = 1; y <= capsBottomSegments; y++) {
+    const indexRow = [];
+    const a = pi2 - alpha - (Math.PI - alpha) * (y / capsBottomSegments);
+    v += radiusBottom * alpha / capsBottomSegments;
+    const cosA = Math.cos(a);
+    const sinA = Math.sin(a);
+    const ringRadius = cosA * radiusBottom;
+    for (x = 0; x <= radialSegments; x++) {
+      const u = x / radialSegments;
+      const theta = u * thetaLength + thetaStart;
+      const sinTheta = Math.sin(theta);
+      const cosTheta = Math.cos(theta);
+      vertices.push(ringRadius * sinTheta, -halfHeight + sinA * radiusBottom, ringRadius * cosTheta);
+      normals.push(cosA * sinTheta, sinA, cosA * cosTheta);
+      uvs.push(u, 1 - v / vl);
+      indexRow.push(index);
+      index++;
+    }
+    indexArray.push(indexRow);
+  }
+  for (x = 0; x < radialSegments; x++) {
+    for (y = 0; y < capsTopSegments + heightSegments + capsBottomSegments; y++) {
+      const i1 = indexArray[y][x];
+      const i22 = indexArray[y + 1][x];
+      const i3 = indexArray[y + 1][x + 1];
+      const i42 = indexArray[y][x + 1];
+      indices.push(i1, i22, i42);
+      indices.push(i22, i3, i42);
+    }
+  }
+  indices = indices.reverse();
+  return {
+    positions: new F32(vertices),
+    normals: new F32(normals),
+    uvs: new F32(uvs),
+    indices: new U32(indices)
+  };
+}
 function createPlaneData(options = {}) {
   const size = options.size ?? 1;
   const width = options.width ?? size;
@@ -9686,7 +10060,7 @@ function crossVec3(a, b) {
 function lengthVec3(v) {
   return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
 }
-function normalizeVec3$1(v) {
+function normalizeVec3$2(v) {
   const len2 = lengthVec3(v);
   if (len2 < 1e-10) {
     return { x: 0, y: 0, z: 0 };
@@ -9741,7 +10115,7 @@ function normalVector(vt, va) {
     const c2 = crossVec3(vt, va);
     n3 = crossVec3(c2, vt);
   }
-  return normalizeVec3$1(n3);
+  return normalizeVec3$2(n3);
 }
 function computePath3D(curve, firstNormal = null) {
   const l = curve.length;
@@ -9752,18 +10126,18 @@ function computePath3D(curve, firstNormal = null) {
   if (l < 2) {
     return { tangents, normals, binormals, distances };
   }
-  tangents[0] = normalizeVec3$1(getFirstNonNullVector(curve, 0));
-  tangents[l - 1] = normalizeVec3$1(subVec3(curve[l - 1], curve[l - 2]));
-  const pp0 = normalizeVec3$1(normalVector(tangents[0], firstNormal));
+  tangents[0] = normalizeVec3$2(getFirstNonNullVector(curve, 0));
+  tangents[l - 1] = normalizeVec3$2(subVec3(curve[l - 1], curve[l - 2]));
+  const pp0 = normalizeVec3$2(normalVector(tangents[0], firstNormal));
   normals[0] = pp0;
-  binormals[0] = normalizeVec3$1(crossVec3(tangents[0], normals[0]));
+  binormals[0] = normalizeVec3$2(crossVec3(tangents[0], normals[0]));
   distances[0] = 0;
   for (let i = 1; i < l; i++) {
     const prev = getLastNonNullVector(curve, i);
     if (i < l - 1) {
       const cur = getFirstNonNullVector(curve, i);
       const sum = { x: prev.x + cur.x, y: prev.y + cur.y, z: prev.z + cur.z };
-      tangents[i] = normalizeVec3$1(sum);
+      tangents[i] = normalizeVec3$2(sum);
     }
     distances[i] = distances[i - 1] + lengthVec3(subVec3(curve[i], curve[i - 1]));
     const curTang = tangents[i];
@@ -9773,10 +10147,10 @@ function computePath3D(curve, firstNormal = null) {
       const prevN = normals[i - 1];
       n3 = { x: prevN.x, y: prevN.y, z: prevN.z };
     } else {
-      n3 = normalizeVec3$1(n3);
+      n3 = normalizeVec3$2(n3);
     }
     normals[i] = n3;
-    binormals[i] = normalizeVec3$1(crossVec3(curTang, n3));
+    binormals[i] = normalizeVec3$2(crossVec3(curTang, n3));
   }
   return { tangents, normals, binormals, distances };
 }
@@ -9936,7 +10310,6 @@ function createMeshFromData(engine, name, positions, normals, indices, uvs, uvs2
     receiveShadows: false,
     boundMin: isFinite(min[0]) ? min : void 0,
     boundMax: isFinite(max[0]) ? max : void 0,
-    _materialDirty: false,
     _gpu: uploadMeshToGPU(engine, positions, normals, indices, uvs, uvs2, tangents, colors)
   };
   initMeshTransform(mesh);
@@ -10055,6 +10428,10 @@ function createCylinder(engine, options) {
   const data = createCylinderData(options);
   return createMeshFromData(engine, "cylinder", data.positions, data.normals, data.indices, data.uvs);
 }
+function createCapsule(engine, options) {
+  const data = createCapsuleData(options);
+  return createMeshFromData(engine, "capsule", data.positions, data.normals, data.indices, data.uvs);
+}
 function createPlane(engine, options) {
   const data = createPlaneData(options);
   return createMeshFromData(engine, "plane", data.positions, data.normals, data.indices, data.uvs);
@@ -10079,7 +10456,7 @@ function createExtrudeShape(engine, options) {
   const data = createExtrudeShapeData(options);
   return createMeshFromData(engine, "extrude", data.positions, data.normals, data.indices, data.uvs);
 }
-function normalizeVec3(x, y, z, epsilon = 1e-10) {
+function normalizeVec3$1(x, y, z, epsilon = 1e-10) {
   const len2 = Math.hypot(x, y, z);
   if (len2 <= epsilon) {
     return [0, 1, 0];
@@ -10226,7 +10603,7 @@ function planeFromVertices(a, b, c2) {
   const cax = c2.x - a.x;
   const cay = c2.y - a.y;
   const caz = c2.z - a.z;
-  const [nx, ny, nz] = normalizeVec3(cay * baz - caz * bay, caz * bax - cax * baz, cax * bay - cay * bax, 1e-20);
+  const [nx, ny, nz] = normalizeVec3$1(cay * baz - caz * bay, caz * bax - cax * baz, cax * bay - cay * bax, 1e-20);
   return new CsgPlane(nx, ny, nz, nx * a.x + ny * a.y + nz * a.z);
 }
 function triangleArea2(a, b, c2) {
@@ -10245,7 +10622,7 @@ function interpolateVertex(a, b, t) {
   const nx = a.nx + (b.nx - a.nx) * t;
   const ny = a.ny + (b.ny - a.ny) * t;
   const nz = a.nz + (b.nz - a.nz) * t;
-  const [nnx, nny, nnz] = normalizeVec3(nx, ny, nz, 1e-20);
+  const [nnx, nny, nnz] = normalizeVec3$1(nx, ny, nz, 1e-20);
   return {
     x: a.x + (b.x - a.x) * t,
     y: a.y + (b.y - a.y) * t,
@@ -10321,9 +10698,9 @@ function transformPoint$1(m2, x, y, z) {
 }
 function transformNormal$1(m2, inv, x, y, z) {
   if (inv) {
-    return normalizeVec3(inv[0] * x + inv[1] * y + inv[2] * z, inv[4] * x + inv[5] * y + inv[6] * z, inv[8] * x + inv[9] * y + inv[10] * z, 1e-20);
+    return normalizeVec3$1(inv[0] * x + inv[1] * y + inv[2] * z, inv[4] * x + inv[5] * y + inv[6] * z, inv[8] * x + inv[9] * y + inv[10] * z, 1e-20);
   }
-  return normalizeVec3(m2[0] * x + m2[4] * y + m2[8] * z, m2[1] * x + m2[5] * y + m2[9] * z, m2[2] * x + m2[6] * y + m2[10] * z, 1e-20);
+  return normalizeVec3$1(m2[0] * x + m2[4] * y + m2[8] * z, m2[1] * x + m2[5] * y + m2[9] * z, m2[2] * x + m2[6] * y + m2[10] * z, 1e-20);
 }
 function requireCpuGeometry$1(mesh) {
   if (!mesh._cpuPositions) {
@@ -10473,9 +10850,9 @@ function transformPoint(m2, x, y, z) {
 }
 function transformNormal(m2, inv, x, y, z) {
   if (inv) {
-    return normalizeVec3(inv[0] * x + inv[1] * y + inv[2] * z, inv[4] * x + inv[5] * y + inv[6] * z, inv[8] * x + inv[9] * y + inv[10] * z, 1e-20);
+    return normalizeVec3$1(inv[0] * x + inv[1] * y + inv[2] * z, inv[4] * x + inv[5] * y + inv[6] * z, inv[8] * x + inv[9] * y + inv[10] * z, 1e-20);
   }
-  return normalizeVec3(m2[0] * x + m2[4] * y + m2[8] * z, m2[1] * x + m2[5] * y + m2[9] * z, m2[2] * x + m2[6] * y + m2[10] * z, 1e-20);
+  return normalizeVec3$1(m2[0] * x + m2[4] * y + m2[8] * z, m2[1] * x + m2[5] * y + m2[9] * z, m2[2] * x + m2[6] * y + m2[10] * z, 1e-20);
 }
 function requireCpuGeometry(mesh) {
   if (!mesh._cpuPositions) {
@@ -10919,7 +11296,7 @@ function parseKtx1(buffer) {
   }
   return { format, width, height, mips };
 }
-function uploadCompressed(engine, parsed, opts) {
+function uploadCompressed$1(engine, parsed, opts) {
   const device = engine._device;
   const fmt = parsed.format;
   const texture = device.createTexture({
@@ -10985,7 +11362,7 @@ async function loadKtxTexture2D(engine, baseUrl, suffixes, opts = {}) {
         throw new Error(`KTX fetch failed: ${resp.status}`);
       }
       const parsed = parseKtx1(await resp.arrayBuffer());
-      return uploadCompressed(engine, parsed, opts);
+      return uploadCompressed$1(engine, parsed, opts);
     } catch (e) {
       console.warn(`KTX load failed for suffix "${suffix}":`, e);
     }
@@ -11177,6 +11554,222 @@ async function loadBasisTexture2D(engine, url, opts = {}) {
     file.delete();
   }
 }
+let _ktx2DecoderUrl = "https://cdn.babylonjs.com/babylon.ktx2Decoder.js";
+let _ktx2WasmUrls = null;
+function setKtx2DecoderUrl(url, wasmUrls) {
+  _ktx2DecoderUrl = url;
+  _ktx2WasmUrls = wasmUrls ?? null;
+}
+let _ktx2DecoderPromise = null;
+const GL_RGBA8 = 32856;
+const GL_R8 = 33321;
+const GL_RG8 = 33323;
+const RGBA_CAPS = { astc: false, bptc: false, s3tc: false, pvrtc: false, etc2: false, etc1: false };
+function loadKtx2Decoder() {
+  if (_ktx2DecoderPromise) {
+    return _ktx2DecoderPromise;
+  }
+  _ktx2DecoderPromise = new Promise((resolve, reject) => {
+    const w = globalThis;
+    const init = () => {
+      const mod = w.KTX2DECODER;
+      if (!mod) {
+        reject(new Error("KTX2: decoder global KTX2DECODER not found after script load"));
+        return;
+      }
+      mod.MSCTranscoder.UseFromWorkerThread = false;
+      mod.WASMMemoryManager.LoadBinariesFromCurrentThread = true;
+      if (_ktx2WasmUrls) {
+        const m2 = mod;
+        for (const tName of Object.keys(_ktx2WasmUrls)) {
+          const t = m2[tName];
+          if (t) {
+            for (const prop of Object.keys(_ktx2WasmUrls[tName])) {
+              t[prop] = _ktx2WasmUrls[tName][prop];
+            }
+          }
+        }
+      }
+      resolve(new mod.KTX2Decoder());
+    };
+    if (w.KTX2DECODER) {
+      init();
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = _ktx2DecoderUrl;
+    script.async = true;
+    script.onload = init;
+    script.onerror = () => reject(new Error(`KTX2: failed to load ${script.src}`));
+    document.head.appendChild(script);
+  });
+  _ktx2DecoderPromise.catch(() => {
+    _ktx2DecoderPromise = null;
+  });
+  return _ktx2DecoderPromise;
+}
+function srgbFormat(format) {
+  switch (format) {
+    case "rgba8unorm":
+      return "rgba8unorm-srgb";
+    case "bc1-rgba-unorm":
+      return "bc1-rgba-unorm-srgb";
+    case "bc2-rgba-unorm":
+      return "bc2-rgba-unorm-srgb";
+    case "bc3-rgba-unorm":
+      return "bc3-rgba-unorm-srgb";
+    case "bc7-rgba-unorm":
+      return "bc7-rgba-unorm-srgb";
+    case "etc2-rgb8unorm":
+      return "etc2-rgb8unorm-srgb";
+    case "etc2-rgb8a1unorm":
+      return "etc2-rgb8a1unorm-srgb";
+    case "etc2-rgba8unorm":
+      return "etc2-rgba8unorm-srgb";
+    case "astc-4x4-unorm":
+      return "astc-4x4-unorm-srgb";
+    case "astc-5x4-unorm":
+      return "astc-5x4-unorm-srgb";
+    case "astc-5x5-unorm":
+      return "astc-5x5-unorm-srgb";
+    case "astc-6x5-unorm":
+      return "astc-6x5-unorm-srgb";
+    case "astc-6x6-unorm":
+      return "astc-6x6-unorm-srgb";
+    case "astc-8x5-unorm":
+      return "astc-8x5-unorm-srgb";
+    case "astc-8x6-unorm":
+      return "astc-8x6-unorm-srgb";
+    case "astc-8x8-unorm":
+      return "astc-8x8-unorm-srgb";
+    case "astc-10x5-unorm":
+      return "astc-10x5-unorm-srgb";
+    case "astc-10x6-unorm":
+      return "astc-10x6-unorm-srgb";
+    case "astc-10x8-unorm":
+      return "astc-10x8-unorm-srgb";
+    case "astc-10x10-unorm":
+      return "astc-10x10-unorm-srgb";
+    case "astc-12x10-unorm":
+      return "astc-12x10-unorm-srgb";
+    case "astc-12x12-unorm":
+      return "astc-12x12-unorm-srgb";
+    default:
+      return format;
+  }
+}
+function uncompressedInfo(glFormat) {
+  switch (glFormat) {
+    case GL_RGBA8:
+      return { format: "rgba8unorm", bytesPerPixel: 4 };
+    case GL_R8:
+      return { format: "r8unorm", bytesPerPixel: 1 };
+    case GL_RG8:
+      return { format: "rg8unorm", bytesPerPixel: 2 };
+    default:
+      return null;
+  }
+}
+function validateDecoded(decoded) {
+  var _a;
+  if (decoded.errors) {
+    throw new Error(`KTX2: ${decoded.errors}`);
+  }
+  if (!decoded.mipmaps.length) {
+    throw new Error("KTX2: decoder produced no mipmaps");
+  }
+  for (let i = 0; i < decoded.mipmaps.length; i++) {
+    if (!((_a = decoded.mipmaps[i]) == null ? void 0 : _a.data)) {
+      throw new Error(`KTX2: decoder produced an empty mip ${i}`);
+    }
+  }
+  return decoded.mipmaps;
+}
+function makeSampler(engine, mipCount) {
+  return getOrCreateSampler(engine, {
+    addressModeU: "repeat",
+    addressModeV: "repeat",
+    minFilter: "linear",
+    magFilter: "linear",
+    mipmapFilter: mipCount > 1 ? "linear" : "nearest",
+    maxAnisotropy: mipCount > 1 ? 4 : 1
+  });
+}
+function uploadCompressed(engine, mips, format, sRGB) {
+  if (!engine._device.features.has(format.feature)) {
+    throw new Error(`KTX2: device does not support ${format.feature}`);
+  }
+  const width = mips[0].width;
+  const height = mips[0].height;
+  const texture = engine._device.createTexture({
+    size: { width, height },
+    format: sRGB ? srgbFormat(format.gpuFormat) : format.gpuFormat,
+    mipLevelCount: mips.length,
+    usage: TU.TEXTURE_BINDING | TU.COPY_DST
+  });
+  for (let level = 0; level < mips.length; level++) {
+    const mip = mips[level];
+    const blocksPerRow = Math.ceil(mip.width / format.blockW);
+    const rowBytes = blocksPerRow * format.blockBytes;
+    const copyW = blocksPerRow * format.blockW;
+    const copyH = Math.ceil(mip.height / format.blockH) * format.blockH;
+    engine._device.queue.writeTexture({ texture, mipLevel: level }, mip.data, { bytesPerRow: rowBytes }, { width: copyW, height: copyH });
+  }
+  const tex2d = { texture, view: texture.createView(), sampler: makeSampler(engine, mips.length), width, height, invertY: true };
+  acquireTexture(tex2d);
+  return tex2d;
+}
+function uploadUncompressed(engine, mips, info, sRGB) {
+  const width = mips[0].width;
+  const height = mips[0].height;
+  const texture = engine._device.createTexture({
+    size: { width, height },
+    format: sRGB ? srgbFormat(info.format) : info.format,
+    mipLevelCount: mips.length,
+    usage: TU.TEXTURE_BINDING | TU.COPY_DST
+  });
+  for (let level = 0; level < mips.length; level++) {
+    const mip = mips[level];
+    const expected = mip.width * mip.height * info.bytesPerPixel;
+    if (mip.data.length !== expected) {
+      throw new Error(`KTX2: uncompressed mip ${level} has ${mip.data.length} bytes, expected ${expected}`);
+    }
+    engine._device.queue.writeTexture(
+      { texture, mipLevel: level },
+      mip.data,
+      { bytesPerRow: mip.width * info.bytesPerPixel },
+      { width: mip.width, height: mip.height }
+    );
+  }
+  const tex2d = { texture, view: texture.createView(), sampler: makeSampler(engine, mips.length), width, height, invertY: true };
+  acquireTexture(tex2d);
+  return tex2d;
+}
+async function uploadKtx2Texture2D(engine, buffer, sRGB) {
+  const decoder = await loadKtx2Decoder();
+  const decoded = await decoder.decode(new U8(buffer), RGBA_CAPS, { forceRGBA: true });
+  const mips = validateDecoded(decoded);
+  const compressed = getCompressedFormat(decoded.transcodedFormat);
+  if (compressed) {
+    return uploadCompressed(engine, mips, compressed, sRGB);
+  }
+  const uncompressed = uncompressedInfo(decoded.transcodedFormat);
+  if (uncompressed) {
+    return uploadUncompressed(engine, mips, uncompressed, sRGB);
+  }
+  throw new Error(`KTX2: unsupported transcoded format 0x${decoded.transcodedFormat.toString(16)}`);
+}
+async function decodeKtx2ImageBitmapFromBuffer(buffer) {
+  const decoder = await loadKtx2Decoder();
+  const decoded = await decoder.decode(new U8(buffer), RGBA_CAPS, { forceRGBA: true });
+  const mip0 = validateDecoded(decoded)[0];
+  if (mip0.data.length !== mip0.width * mip0.height * 4) {
+    throw new Error("KTX2: RGBA decode size does not match image dimensions");
+  }
+  const pixels = new U8C(mip0.data.length);
+  pixels.set(mip0.data);
+  return createImageBitmap(new ImageData(pixels, mip0.width, mip0.height));
+}
 const HAS_DIFFUSE_TEXTURE = 1 << 0;
 const HAS_EMISSIVE_TEXTURE = 1 << 1;
 const HAS_BUMP_TEXTURE = 1 << 2;
@@ -11217,14 +11810,14 @@ 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-CQSxhjCy.js"), "bumpStdExt"],
-  ["emissiveTexture", () => import("./std-emissive-fragment-C8Lnmojh.js"), "stdEmissiveExt"],
-  ["specularTexture", () => import("./std-specular-fragment-CM5R5j2g.js"), "stdSpecularExt"],
-  ["ambientTexture", () => import("./std-ambient-fragment-Bjx3VFrr.js"), "stdAmbientExt"],
-  ["lightmapTexture", () => import("./std-lightmap-fragment-DFxGcoA5.js"), "stdLightmapExt"],
-  ["opacityTexture", () => import("./std-opacity-fragment-EXzFWiSp.js"), "stdOpacityExt"],
-  ["reflectionTexture", () => import("./std-reflection-fragment-BoJORqpG.js"), "stdReflectionExt"],
-  ["reflectionCubeTexture", () => import("./std-cube-reflection-fragment-y9WWdXUt.js"), "stdCubeReflectionExt"]
+  ["bumpTexture", () => import("./normal-map-fragment-sE3TjF4U.js"), "bumpStdExt"],
+  ["emissiveTexture", () => import("./std-emissive-fragment-Bj62X4Np.js"), "stdEmissiveExt"],
+  ["specularTexture", () => import("./std-specular-fragment-Bio681OG.js"), "stdSpecularExt"],
+  ["ambientTexture", () => import("./std-ambient-fragment-__F1KTEu.js"), "stdAmbientExt"],
+  ["lightmapTexture", () => import("./std-lightmap-fragment-DXvfWvKc.js"), "stdLightmapExt"],
+  ["opacityTexture", () => import("./std-opacity-fragment-BzMMb1K_.js"), "stdOpacityExt"],
+  ["reflectionTexture", () => import("./std-reflection-fragment-DC9Kvu1C.js"), "stdReflectionExt"],
+  ["reflectionCubeTexture", () => import("./std-cube-reflection-fragment-DidM0byH.js"), "stdCubeReflectionExt"]
 ];
 const standardGroupBuilder = async (scene, meshes) => {
   const hasTI = meshes.some((m2) => !!m2.thinInstances);
@@ -11240,7 +11833,7 @@ const standardGroupBuilder = async (scene, meshes) => {
   const imports = [];
   if (hasTI) {
     imports.push(
-      import("./thin-instance-gpu-BDdRcNAh.js").then((m2) => {
+      import("./thin-instance-gpu-uY2NOv0J.js").then((m2) => {
         tiSync = m2.syncThinInstanceBuffers;
       }),
       import("./thin-instance-fragment-hsv-RyDs.js").then((m2) => {
@@ -11249,7 +11842,7 @@ const standardGroupBuilder = async (scene, meshes) => {
     );
     if (hasCulling) {
       imports.push(
-        import("./thin-instance-cull-binding-DWKUt5ZN.js").then((m2) => {
+        import("./thin-instance-cull-binding-DwZi7mlE.js").then((m2) => {
           cull = m2;
         })
       );
@@ -11257,7 +11850,7 @@ const standardGroupBuilder = async (scene, meshes) => {
   }
   if (hasShadow) {
     imports.push(
-      import("./std-shadow-fragment-Bq-Wc8UJ.js").then((m2) => {
+      import("./std-shadow-fragment-BnMHeF1-.js").then((m2) => {
         shadowFragment = m2.createStdShadowFragment;
       })
     );
@@ -11270,7 +11863,7 @@ const standardGroupBuilder = async (scene, meshes) => {
   if (imports.length > 0) {
     await Promise.all(imports);
   }
-  const renderableMod = await import("./standard-renderable-CREWLNHI.js");
+  const renderableMod = await import("./standard-renderable-1Q3zemys.js");
   const result = renderableMod.buildStandardMeshRenderables(scene, meshes, { tiSync, tiFragment, shadowFragment, cull });
   standardGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
@@ -11322,7 +11915,7 @@ const noColorView$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defin
 }, Symbol.toStringTag, { value: "Module" }));
 const pbrGroupBuilder = async (scene, meshes) => {
   const envTex = scene._envTextures;
-  const renderableMod = await import("./pbr-renderable-DzUF2QIk.js").then((n3) => n3.p);
+  const renderableMod = await import("./pbr-renderable-CaHKHU0g.js").then((n3) => n3.p);
   const result = await renderableMod.buildPbrRenderables(scene, meshes, envTex);
   pbrGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
@@ -11407,7 +12000,7 @@ const pbrMaterial = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   pbrGroupBuilder
 }, Symbol.toStringTag, { value: "Module" }));
 const shaderGroupBuilder = async (scene, meshes) => {
-  const { buildShaderGroup } = await import("./shader-renderable-D7-RyVxa.js");
+  const { buildShaderGroup } = await import("./shader-renderable-D5sbgzxt.js");
   const result = await buildShaderGroup(scene, meshes);
   shaderGroupBuilder._rebuildSingle = result.rebuildSingle;
   return result;
@@ -11485,6 +12078,14 @@ function createShaderMaterial(options) {
     samplerDecls.push(decl);
     textureSlots.set(decl.name, { decl, current: null });
   }
+  const storageBufferDecls = [];
+  const storageBufferSlots = /* @__PURE__ */ new Map();
+  for (const opt of options.storageBuffers ?? []) {
+    assertIdentifier("storage buffer", opt.name);
+    assertUniqueName(usedNames, "storage buffer", opt.name);
+    storageBufferDecls.push(opt);
+    storageBufferSlots.set(opt.name, { decl: opt, current: null });
+  }
   const defines = [];
   for (const [name, value] of Object.entries(options.defines ?? {})) {
     assertIdentifier("define", name);
@@ -11505,6 +12106,7 @@ function createShaderMaterial(options) {
     attributes,
     uniformDecls,
     samplerDecls,
+    storageBufferDecls,
     defines,
     needAlphaBlending: options.needAlphaBlending ?? false,
     blendMode: options.blendMode ?? "alpha",
@@ -11513,12 +12115,14 @@ function createShaderMaterial(options) {
     backFaceCulling: options.backFaceCulling ?? true,
     depthWrite: options.depthWrite ?? true,
     depthCompare: options.depthCompare ?? "greater-equal",
+    depthOnlyFragment: options.depthOnlyFragment ?? false,
     depthBias: options.depthBias ?? 0,
     depthBiasSlopeScale: options.depthBiasSlopeScale ?? 0,
     _buildGroup: shaderGroupBuilder,
     _uboVersion: 0,
     _uniformValues: uniformValues,
     _textureSlots: textureSlots,
+    _storageBufferSlots: storageBufferSlots,
     _uniformVersion: 0,
     _resourceVersion: 0
   };
@@ -11603,6 +12207,14 @@ function setShaderTexture(material, name, texture) {
   slot.current = texture;
   material._resourceVersion++;
 }
+function setShaderStorageBuffer(material, name, buffer) {
+  const slot = material._storageBufferSlots.get(name);
+  if (!slot) {
+    throw new Error(`ShaderMaterial: storage buffer "${name}" was not declared.`);
+  }
+  slot.current = buffer;
+  material._resourceVersion++;
+}
 function setShaderFloat(material, name, value) {
   setShaderUniform(material, name, value);
 }
@@ -12073,11 +12685,11 @@ const SENTINEL_FRONT_FACING = "_NME_FRONT_FACING_";
 const SENTINEL_FRAG_COORD = "_NME_FRAG_COORD_";
 const SENTINEL_SCREEN_SIZE = "_NME_SCREEN_SIZE_";
 let _cache$2 = null;
-let _cachedDevice$1 = null;
+let _cachedDevice$2 = null;
 function getCache(engine) {
-  if (!_cache$2 || _cachedDevice$1 !== engine._device) {
+  if (!_cache$2 || _cachedDevice$2 !== engine._device) {
     _cache$2 = /* @__PURE__ */ new Map();
-    _cachedDevice$1 = engine._device;
+    _cachedDevice$2 = engine._device;
   }
   return _cache$2;
 }
@@ -12435,12 +13047,12 @@ async function parseNodeMaterialFromSnippet(engine, snippetId, options = {}) {
   let envHelpers = null;
   let _envEmitter;
   if (state.usesEnv) {
-    envHelpers = await import("./node-env-Bc559GmY.js");
+    envHelpers = await import("./node-env-B2bjGcMS.js");
     _envEmitter = envHelpers.emitEnv;
   }
   let _shadowEmitter;
   if (options.shadowGenerators && options.shadowGenerators.length > 0) {
-    _shadowEmitter = (await import("./node-shadow-CVIUlNf0.js")).emitShadow;
+    _shadowEmitter = (await import("./node-shadow-BRiz7CT1.js")).emitShadow;
   }
   const compile = compileNodePipeline(state, vertexWgsl, fragmentWgsl, {
     _engine: engine,
@@ -12529,7 +13141,7 @@ async function parseNodeMaterialFromSnippet(engine, snippetId, options = {}) {
     inputs[tb._name] = handle;
   }
   const _buildGroup = async (scene, meshes) => {
-    const { buildNodeMeshRenderables } = await import("./node-renderable-B5G8WcdH.js");
+    const { buildNodeMeshRenderables } = await import("./node-renderable-BMHny4tC.js");
     const result = buildNodeMeshRenderables(scene, meshes);
     _buildGroup._rebuildSingle = result.rebuildSingle;
     return result;
@@ -12569,7 +13181,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-BVWNR08D.js");
+  const core = await import("./pbr-mr-helper-core-DGRgbRXl.js");
   for (const request of state.pbrMrHelperRequests) {
     state.fragment.helpers.set(request.key, core.buildPbrMrHelperCore(request));
   }
@@ -12687,7 +13299,7 @@ function hasBlockEmitter(key) {
 function baseBlockLoader(key) {
   switch (key) {
     case "InputBlock":
-      return () => import("./input-block-DqEedWF2.js");
+      return () => import("./input-block-DbRYCnet.js");
     case "VectorMergerBlock":
       return () => import("./vector-merger-CrW-ONB0.js");
     case "FragmentOutputBlock":
@@ -12719,7 +13331,7 @@ function baseBlockLoader(key) {
     case "LerpBlock":
       return () => import("./lerp-block-DjI2SfmI.js");
     case "ClampBlock":
-      return () => import("./clamp-block-DqbwnQGW.js");
+      return () => import("./clamp-block-XHdUk2Va.js");
     case "SmoothStepBlock":
       return () => import("./smoothstep-block-Di4t37x-.js");
     case "RemapBlock":
@@ -12743,7 +13355,7 @@ function baseBlockLoader(key) {
     case "ViewDirectionBlock":
       return () => import("./view-direction-CWVucfnT.js");
     case "LightBlock":
-      return () => import("./light-block-Bv37V8vl.js");
+      return () => import("./light-block-CAqWkucp.js");
     case "LightInformationBlock":
       return () => import("./light-information-VJbW0jbs.js");
     case "FogBlock":
@@ -12763,9 +13375,9 @@ function baseBlockLoader(key) {
     case "ReflectionTextureBlock":
       return () => import("./reflection-texture-block-C3QtzoV8.js");
     case "PBRMetallicRoughnessBlock":
-      return () => import("./pbr-metallic-roughness-block-JBSi-tQN.js");
+      return () => import("./pbr-metallic-roughness-block-DbozMlHU.js");
     case "PBRMetallicRoughnessBlock__full":
-      return () => import("./pbr-metallic-roughness-block-full-Ta9lR2cz.js");
+      return () => import("./pbr-metallic-roughness-block-full-CHC8w-Uv.js");
     case "ReflectionBlock":
       return () => import("./reflection-block-DqcwyYqr.js");
     case "ClearCoatBlock":
@@ -12807,7 +13419,7 @@ function extraRegistryLoader(key) {
     case "CurveBlock":
     case "WaveBlock":
     case "RandomNumberBlock":
-      return () => import("./node-registry-extra-math-Bn854sX9.js");
+      return () => import("./node-registry-extra-math-Bm32WBAa.js");
     case "ColorMergerBlock":
     case "ColorConverterBlock":
     case "DesaturateBlock":
@@ -12850,7 +13462,7 @@ function extraRegistryLoader(key) {
     case "LoopBlock":
     case "StorageReadBlock":
     case "StorageWriteBlock":
-      return () => import("./node-registry-extra-compat-dWrv7gpS.js");
+      return () => import("./node-registry-extra-compat-BEQH_ksg.js");
     default:
       return null;
   }
@@ -12862,7 +13474,7 @@ const nodeRegistry = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.define
 }, Symbol.toStringTag, { value: "Module" }));
 async function loadNodeBlockEmitterWithGeometry(className) {
   if (className === "GeometryTextureOutputBlock") {
-    return (await import("./geometry-texture-output-dXk4E9uu.js")).emitter;
+    return (await import("./geometry-texture-output-BmuAquio.js")).emitter;
   }
   return loadBlockEmitter(className);
 }
@@ -13300,10 +13912,10 @@ function enableMaterialPlugins(scene) {
 async function enableMaterialTracking(material) {
   const source = getMaterialSource(material);
   if ("specularPower" in source) {
-    const { installStdTracking } = await import("./std-tracking-Cif_wXeT.js");
+    const { installStdTracking } = await import("./std-tracking-BTcrry2o.js");
     installStdTracking(source);
   } else {
-    const { installPbrTracking } = await import("./pbr-tracking-3tU1kqea.js");
+    const { installPbrTracking } = await import("./pbr-tracking-Bo7RTANK.js");
     installPbrTracking(source);
   }
 }
@@ -13311,6 +13923,9 @@ function createTransformNode(name, px2 = 0, py = 0, pz = 0, qx2 = 0, qy = 0, qz
   return createSceneNode(name, px2, py, pz, qx2, qy, qz, qw, sx, sy, sz);
 }
 function cloneTransformNode(src) {
+  if ("_gpu" in src) {
+    return cloneMeshNode(src);
+  }
   const clone = src._localMatrix ? createSceneNodeFromMatrix(src.name + "_clone", src._localMatrix) : createTransformNode(
     src.name + "_clone",
     src.position.x,
@@ -13325,32 +13940,10 @@ function cloneTransformNode(src) {
     src.scaling.z
   );
   for (const child of src.children) {
-    if (!("_gpu" in child) && !("lightType" in child)) {
+    if (!("lightType" in child)) {
       const childClone = cloneTransformNode(child);
       childClone.parent = clone;
       clone.children.push(childClone);
-    } else if ("_gpu" in child) {
-      const mesh = child;
-      const meshClone = {
-        ...mesh,
-        name: mesh.name + "_clone",
-        _materialDirty: false,
-        _gpu: { ...mesh._gpu }
-      };
-      initMeshTransform(
-        meshClone,
-        mesh.position.x,
-        mesh.position.y,
-        mesh.position.z,
-        mesh.rotation.x,
-        mesh.rotation.y,
-        mesh.rotation.z,
-        mesh.scaling.x,
-        mesh.scaling.y,
-        mesh.scaling.z
-      );
-      meshClone.parent = clone;
-      clone.children.push(meshClone);
     } else {
       const childClone = { ...child, name: child.name + "_clone", children: [] };
       childClone.parent = clone;
@@ -13359,6 +13952,23 @@ function cloneTransformNode(src) {
   }
   return clone;
 }
+function cloneMeshNode(mesh) {
+  const meshClone = {
+    ...mesh,
+    name: mesh.name + "_clone",
+    children: [],
+    _gpu: { ...mesh._gpu }
+  };
+  initMeshTransform(meshClone, mesh.position.x, mesh.position.y, mesh.position.z, 0, 0, 0, mesh.scaling.x, mesh.scaling.y, mesh.scaling.z);
+  const rq = mesh.rotationQuaternion;
+  meshClone.rotationQuaternion.set(rq.x, rq.y, rq.z, rq.w);
+  for (const child of mesh.children) {
+    const childClone = cloneTransformNode(child);
+    childClone.parent = meshClone;
+    meshClone.children.push(childClone);
+  }
+  return meshClone;
+}
 let _tmpLocal = null;
 let _tmpAnim = null;
 let _tmpInstance = null;
@@ -13669,14 +14279,14 @@ async function runMatExts(mat, exts, ctx) {
 }
 let _interleavePromise;
 function loadInterleave() {
-  return _interleavePromise ?? (_interleavePromise = import("./gltf-interleave-gHf9_t0i.js"));
+  return _interleavePromise ?? (_interleavePromise = import("./gltf-interleave-DWf27t-h.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 = assetUsesGltfFeatures(json) ? await (await import("./gltf-feature-registry-C63Hjp9w.js")).loadGltfFeatures(json) : [];
+  const features = assetUsesGltfFeatures(json) ? await (await import("./gltf-feature-registry-DeYdy3DV.js")).loadGltfFeatures(json) : [];
   let activeBin = binChunk;
   for (const f of features) {
     if (f.preParse) {
@@ -13725,7 +14335,7 @@ async function fetchGltfAsset(url) {
   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-Cj5MHS-v.js");
+    const { parseGlbContainer } = await import("./gltf-glb-parser-CqOeXFOz.js");
     const { json: json2, binChunk: binChunk2 } = parseGlbContainer(buffer);
     return { json: json2, binChunk: binChunk2, baseUrl };
   }
@@ -13934,7 +14544,7 @@ async function uploadMeshes(meshDatas, features, ctx) {
     }
   }
   let _pbrExtPromise = null;
-  const _ensurePbrExt = () => _pbrExtPromise ?? (_pbrExtPromise = import("./gltf-pbr-builder-ext-edNcjwPf.js"));
+  const _ensurePbrExt = () => _pbrExtPromise ?? (_pbrExtPromise = import("./gltf-pbr-builder-ext-DvFxuOqN.js"));
   const builtMaterialCache = /* @__PURE__ */ new Map();
   async function buildPbrFromGltfMat(mat) {
     let cached = builtMaterialCache.get(mat);
@@ -13982,7 +14592,6 @@ async function uploadMeshes(meshDatas, features, ctx) {
           boundMax,
           skeleton: null,
           morphTargets: null,
-          _materialDirty: false,
           _gpu: gpu
         };
         initMeshTransform(mesh);
@@ -14292,7 +14901,6 @@ async function loadBabylon(engine, url, opts = {}) {
             id: md.id,
             material: mat,
             receiveShadows: false,
-            _materialDirty: false,
             _gpu: gpu
           };
           mesh._cpuPositions = positions;
@@ -14373,7 +14981,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((c2) => c2.id === data.activeCameraID) : null) ?? data.cameras[0] : null;
-  const camera = camData ? (await import("./parse-camera-pBRT_6i5.js")).parseBabylonCamera(camData) : void 0;
+  const camera = camData ? (await import("./parse-camera-CmZBS423.js")).parseBabylonCamera(camData) : void 0;
   const rootMeshes = allMeshes.filter((m2) => !childNodeIds.has(m2.id));
   const rootTransformNodes = [];
   for (const [id, node] of nodeMap) {
@@ -14470,7 +15078,7 @@ async function loadEnvironment(scene, url, options) {
   const envBuffer = await envPromise;
   const { faceBlobs, irradianceSH, width, mipCount } = parseEnvFile(envBuffer);
   const faceImages = await Promise.all(faceBlobs.map((blob2) => createImageBitmap(blob2, { premultiplyAlpha: "none", colorSpaceConversion: "none" })));
-  const { uploadCubemapRGBD, decodeBrdfPng } = await import("./rgbd-decode-DoyUquy3.js");
+  const { uploadCubemapRGBD, decodeBrdfPng } = await import("./rgbd-decode-DkiiiIlt.js");
   const specularCube = uploadCubemapRGBD(engine, faceImages, width, mipCount);
   for (const img of faceImages) {
     img.close();
@@ -14504,19 +15112,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-BrH2fXSu.js");
+      const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox--fqHdan_.js");
       scene._renderables.push(buildSolidSkyboxRenderable(scene, textures, skyHalfSize, rootPosition, primaryColor));
     }
     if (!bgOptions.skipGround) {
-      const { buildGroundRenderable } = await import("./background-ground-BU0HOcM4.js");
+      const { buildGroundRenderable } = await import("./background-ground-DiFpKJzF.js");
       scene._renderables.push(await buildGroundRenderable(engine, groundSize, rootPosition, primaryColor, groundUrl, groundTexPromise));
     }
     if (skyboxIsDds) {
-      const { buildDdsSkyboxRenderable } = await import("./background-dds-skybox-BEX309u3.js");
+      const { buildDdsSkyboxRenderable } = await import("./background-dds-skybox-BwG0kYQP.js");
       scene._renderables.push(await buildDdsSkyboxRenderable(scene, skyHalfSize, rootPosition, primaryColor, skyboxUrl));
     }
     if (skyboxIsEnv) {
-      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox--RRRic_K.js");
+      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-DIgJhvfj.js");
       scene._renderables.push(buildHdrSkyboxRenderable(scene, textures, skyHalfSize, rootPosition, primaryColor));
     }
   });
@@ -14920,7 +15528,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--RRRic_K.js");
+      const { buildHdrSkyboxRenderable } = await import("./background-hdr-skybox-DIgJhvfj.js");
       scene._renderables.push(buildHdrSkyboxRenderable(scene, textures, autoSkyboxSize / 2, rootPosition, primaryColor));
     }
     if (!useHdr || !skipGround) {
@@ -14928,11 +15536,11 @@ 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-BrH2fXSu.js");
+        const { buildSolidSkyboxRenderable } = await import("./background-solid-skybox--fqHdan_.js");
         scene._renderables.push(buildSolidSkyboxRenderable(scene, textures, autoSkyboxSize / 2, rootPosition, primaryColor));
       }
       if (!skipGround) {
-        const { buildGroundRenderable } = await import("./background-ground-BU0HOcM4.js");
+        const { buildGroundRenderable } = await import("./background-ground-DiFpKJzF.js");
         scene._renderables.push(await buildGroundRenderable(engine, groundSize, rootPosition, primaryColor));
       }
     }
@@ -15013,7 +15621,7 @@ async function loadSkybox(scene, baseUrl, ext, size = 100) {
     idxCount: boxData.indices.length,
     worldMatrix: world
   };
-  const { buildSkyboxRenderable } = await import("./skybox-renderable-CJD4XmX5.js");
+  const { buildSkyboxRenderable } = await import("./skybox-renderable-BH6uUkal.js");
   scene._renderables.push(buildSkyboxRenderable(scene, skyboxData));
 }
 const SH_C0$2 = 0.28209479177387814;
@@ -15766,7 +16374,7 @@ async function attachParsedSplat(scene, name, parsed, fragments) {
   const eng = scene.surface.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-7J31V23x.js");
+    const { attachGaussianSplattingMeshSH } = await import("./gaussian-splatting-pipeline-sh-DDo7QQ8l.js");
     attachGaussianSplattingMeshSH(scene, mesh, parsed.sh, fragments);
   } else {
     attachGaussianSplattingMesh(scene, mesh, fragments);
@@ -15782,7 +16390,7 @@ async function loadSplat(scene, url, fragments) {
   let parsed;
   if (isPly(data)) {
     if (isPlyCompressedOrSH(data)) {
-      const { convertCompressedPlyToParsedSplat } = await import("./splat-ply-compressed-DHjyiVmI.js");
+      const { convertCompressedPlyToParsedSplat } = await import("./splat-ply-compressed-BGNK6dnh.js");
       parsed = convertCompressedPlyToParsedSplat(data);
     } else {
       parsed = convertPlyToSplat(data);
@@ -16611,21 +17219,21 @@ async function preloadEsmShadowTaskState(casterMeshes) {
   }
   if (needsStandard && !createStandardEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-Gtd1LWRP.js").then((module) => {
+      import("./esm-shadow-view-CUwxbnMR.js").then((module) => {
         createStandardEsmShadowMaterialView = module.createStandardEsmShadowMaterialView;
       })
     );
   }
   if (needsPbr && !createPbrEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-c5YV4Eg9.js").then((module) => {
+      import("./esm-shadow-view-Cl36rOrK.js").then((module) => {
         createPbrEsmShadowMaterialView = module.createPbrEsmShadowMaterialView;
       })
     );
   }
   if (needsNode && !createNodeEsmShadowMaterialView) {
     loads.push(
-      import("./esm-shadow-view-Cl3rPGof.js").then((module) => {
+      import("./esm-shadow-view-DKQ-FSoV.js").then((module) => {
         createNodeEsmShadowMaterialView = module.createNodeEsmShadowMaterialView;
       })
     );
@@ -19792,12 +20400,33 @@ function createEmptyPickingInfo() {
     ray: null
   };
 }
+const PICK_SHARED = (
+  /* wgsl */
+  `
+fn pickClipOne(wp: vec3f, a: vec4f, b: vec4f, c: vec4f) -> bool {
+let q = wp.xz - a.xy;
+let ds = dot(q, a.zw);
+let dp = dot(q, vec2f(-a.w, a.z));
+if (abs(dp) > c.y) { return false; }
+let y = wp.y - b.x;
+let outerHW = b.y + c.x;
+if (c.z > 0.5) { return y <= b.z + c.x && abs(ds) <= outerHW; }
+if (y <= b.z) { return abs(ds) <= outerHW; }
+let outerRise = b.w + c.x;
+if (y > b.z + outerRise || outerRise <= 0.0) { return false; }
+let ex = ds / max(outerHW, 0.001);
+let ey = (y - b.z) / max(outerRise, 0.001);
+return ex * ex + ey * ey <= 1.0;
+}
+`
+);
 const PICK_FS = (
   /* wgsl */
   `
-struct VsOut { @builtin(position) position: vec4f, @location(0) @interpolate(flat) pickId: u32 };
+struct VsOut { @builtin(position) position: vec4f, @location(0) @interpolate(flat) pickId: u32, @location(1) worldPos: vec3f, @location(2) clipSkip: f32 };
 struct FsOut { @location(0) color: vec4f, @location(1) depth: vec4f };
 @fragment fn fs(input: VsOut) -> FsOut {
+if (input.clipSkip < 0.5 && pickClipHit(input.worldPos)) { discard; }
 let id = input.pickId;
 let r = f32((id >> 16u) & 0xFFu) / 255.0;
 let g = f32((id >> 8u) & 0xFFu) / 255.0;
@@ -19810,14 +20439,30 @@ const pickingShaderSource = (
   /* wgsl */
   `
 struct SceneUniforms { viewProjection: mat4x4f };
-struct MeshUniforms { world: mat4x4f, pickId: u32 };
+struct MeshUniforms {
+world: mat4x4f,
+pickId: u32,
+};
 @group(0) @binding(0) var<uniform> scene: SceneUniforms;
 @group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+@group(1) @binding(1) var<storage, read> clipData: array<vec4f>;
+${PICK_SHARED}
+fn pickClipHit(wp: vec3f) -> bool {
+let n = i32(clipData[0].x);
+for (var i = 0; i < n; i = i + 1) {
+let base = 1 + i * 3;
+if (pickClipOne(wp, clipData[base], clipData[base + 1], clipData[base + 2])) { return true; }
+}
+return false;
+}
 ${PICK_FS}
 @vertex fn vs(@location(0) position: vec3f) -> VsOut {
 var out: VsOut;
-out.position = scene.viewProjection * mesh.world * vec4f(position, 1.0);
+let wp = (mesh.world * vec4f(position, 1.0)).xyz;
+out.position = scene.viewProjection * vec4f(wp, 1.0);
 out.pickId = mesh.pickId;
+out.worldPos = wp;
+out.clipSkip = 0.0;
 return out;
 }
 `
@@ -19826,10 +20471,22 @@ const pickingThinInstanceShaderSource = (
   /* wgsl */
   `
 struct SceneUniforms { viewProjection: mat4x4f };
-struct TIMeshUniforms { baseMeshPickId: u32 };
+struct TIMeshUniforms {
+baseMeshPickId: u32,
+};
 @group(0) @binding(0) var<uniform> scene: SceneUniforms;
 @group(1) @binding(0) var<uniform> tiMesh: TIMeshUniforms;
 @group(1) @binding(1) var<storage, read> instances: array<mat4x4f>;
+@group(1) @binding(2) var<storage, read> clipData: array<vec4f>;
+${PICK_SHARED}
+fn pickClipHit(wp: vec3f) -> bool {
+let n = i32(clipData[0].x);
+for (var i = 0; i < n; i = i + 1) {
+let base = 1 + i * 3;
+if (pickClipOne(wp, clipData[base], clipData[base + 1], clipData[base + 2])) { return true; }
+}
+return false;
+}
 ${PICK_FS}
 @vertex fn vs(@location(0) position: vec3f, @builtin(instance_index) instanceIndex: u32) -> VsOut {
 let m = instances[instanceIndex];
@@ -19845,8 +20502,11 @@ vec4f(m[2].xyz, 0.0),
 vec4f(m[3].xyz, 1.0),
 );
 var out: VsOut;
-out.position = scene.viewProjection * world * vec4f(position, 1.0);
+let wp = (world * vec4f(position, 1.0)).xyz;
+out.position = scene.viewProjection * vec4f(wp, 1.0);
 out.pickId = tiMesh.baseMeshPickId + instanceIndex;
+out.worldPos = wp;
+out.clipSkip = clamp(floor(max(m[2].w, 0.0) * 0.25), 0.0, 1.0);
 return out;
 }
 `
@@ -19857,21 +20517,21 @@ function createSingleUniformBGL(engine, label, visibility) {
     entries: [{ binding: 0, visibility, buffer: { type: "uniform" } }]
   });
 }
-let _cachedDevice = null;
+let _cachedDevice$1 = null;
 let _pipeline = null;
 let _tiPipeline = null;
 let _sceneBGL = null;
-let _meshBGL = null;
+let _meshBGL$1 = null;
 let _tiMeshBGL = null;
 function invalidateIfNeeded(engine) {
   const device = engine._device;
-  if (device !== _cachedDevice) {
+  if (device !== _cachedDevice$1) {
     _pipeline = null;
     _tiPipeline = null;
     _sceneBGL = null;
-    _meshBGL = null;
+    _meshBGL$1 = null;
     _tiMeshBGL = null;
-    _cachedDevice = device;
+    _cachedDevice$1 = device;
   }
 }
 function getPickingSceneBGL(engine) {
@@ -19883,10 +20543,16 @@ function getPickingSceneBGL(engine) {
 }
 function getPickingMeshBGL(engine) {
   invalidateIfNeeded(engine);
-  if (!_meshBGL) {
-    _meshBGL = createSingleUniformBGL(engine, "picking-mesh-bgl", SS.VERTEX | SS.FRAGMENT);
+  if (!_meshBGL$1) {
+    _meshBGL$1 = engine._device.createBindGroupLayout({
+      label: "picking-mesh-bgl",
+      entries: [
+        { binding: 0, visibility: SS.VERTEX | SS.FRAGMENT, buffer: { type: "uniform" } },
+        { binding: 1, visibility: SS.FRAGMENT, buffer: { type: "read-only-storage" } }
+      ]
+    });
   }
-  return _meshBGL;
+  return _meshBGL$1;
 }
 function getPickingTIMeshBGL(engine) {
   const device = engine._device;
@@ -19904,6 +20570,11 @@ function getPickingTIMeshBGL(engine) {
           binding: 1,
           visibility: SS.VERTEX,
           buffer: { type: "read-only-storage" }
+        },
+        {
+          binding: 2,
+          visibility: SS.FRAGMENT,
+          buffer: { type: "read-only-storage" }
         }
       ]
     });
@@ -19976,11 +20647,30 @@ function getPickingTIPipeline(engine) {
 }
 const _pickVP = new F32(16);
 const _gsPickMatrix = new F32(16);
-const _uboScratch = new ArrayBuffer(80);
-const _uboF32 = new F32(_uboScratch, 0, 16);
-const _uboU32 = new U32(_uboScratch, 64, 1);
+const PICK_MESH_UBO_BYTES = 80;
+const PICK_TI_UBO_BYTES = 16;
+const _uboScratch = new ArrayBuffer(PICK_MESH_UBO_BYTES);
+const _uboF32 = new F32(_uboScratch);
+const _uboU32 = new U32(_uboScratch);
 const _uboView = new U8(_uboScratch);
-const _tiUboScratch = new U32(4);
+const _tiUboScratch = new ArrayBuffer(PICK_TI_UBO_BYTES);
+const _tiUboU32 = new U32(_tiUboScratch);
+const _tiUboView = new U8(_tiUboScratch);
+function createPickClipBuffer(engine, mesh, tempBuffers) {
+  const clips = mesh.pickingClipVolumes;
+  const count = (clips == null ? void 0 : clips.length) ?? 0;
+  const data = new F32((1 + count * 3) * 4);
+  data[0] = count;
+  for (let i = 0; i < count; i++) {
+    const off = 4 + i * 12;
+    data.set(clips[i].a, off);
+    data.set(clips[i].b, off + 4);
+    data.set(clips[i].c, off + 8);
+  }
+  const buf = createMappedBuffer(engine, data, BU.STORAGE);
+  tempBuffers.push(buf);
+  return buf;
+}
 function createGpuPicker(scene) {
   return {
     _detailedPick: null,
@@ -20040,6 +20730,7 @@ function computePickVP(out, vp, px2, py, w, h) {
 async function pickAsync(picker, x, y, options) {
   const scene = picker._scene;
   const pickFilter = (options == null ? void 0 : options.filter) ?? null;
+  const debugLabel = options == null ? void 0 : options.debugLabel;
   const engine = scene.surface.engine;
   const device = engine._device;
   const canvas = scene.surface.canvas;
@@ -20068,6 +20759,7 @@ async function pickAsync(picker, x, y, options) {
   const py = Math.max(0, Math.min(Math.floor(pickY - viewport.y), h - 1));
   const aspect = w / h;
   const vp = getViewProjectionMatrix(camera, aspect);
+  const debugRay = debugLabel ? createPickingRay(px2, py, vp, w, h) : null;
   computePickVP(_pickVP, vp, px2, py, w, h);
   const rt = ensureTargets(engine, picker);
   const sceneUbo = ensureSceneUbo(engine, picker);
@@ -20106,9 +20798,13 @@ async function pickAsync(picker, x, y, options) {
     }
     const gpu = mesh._gpu;
     const ti = mesh.thinInstances;
-    if (ti && ti.count > 0 && ti._gpuBuffer) {
-      _tiUboScratch[0] = nextId;
-      const tiUbo = createUniformBuffer$1(engine, _tiUboScratch);
+    if (ti) {
+      if (ti.count <= 0 || !ti._gpuBuffer) {
+        continue;
+      }
+      _tiUboU32[0] = nextId;
+      const tiUbo = createUniformBuffer$1(engine, _tiUboView);
+      const clipBuffer = createPickClipBuffer(engine, mesh, tempBuffers);
       tempBuffers.push(tiUbo);
       pass.setPipeline(tiPipeline);
       pass.setBindGroup(0, picker._sceneBG);
@@ -20118,7 +20814,8 @@ async function pickAsync(picker, x, y, options) {
           layout: tiMeshBGL,
           entries: [
             { binding: 0, resource: { buffer: tiUbo } },
-            { binding: 1, resource: { buffer: ti._gpuBuffer } }
+            { binding: 1, resource: { buffer: ti._gpuBuffer } },
+            { binding: 2, resource: { buffer: clipBuffer } }
           ]
         })
       );
@@ -20127,9 +20824,10 @@ async function pickAsync(picker, x, y, options) {
       pass.drawIndexed(gpu.indexCount, ti.count);
       nextId += ti.count;
     } else {
-      _uboF32.set(mesh.worldMatrix);
-      _uboU32[0] = nextId;
+      _uboF32.set(mesh.worldMatrix, 0);
+      _uboU32[16] = nextId;
       const meshUbo = createUniformBuffer$1(engine, _uboView);
+      const clipBuffer = createPickClipBuffer(engine, mesh, tempBuffers);
       tempBuffers.push(meshUbo);
       let positionBuffer = gpu.positionBuffer;
       if (deformedGeometry$1 && (mesh.morphTargets || mesh.skeleton) && mesh._cpuPositions) {
@@ -20141,7 +20839,16 @@ async function pickAsync(picker, x, y, options) {
       }
       pass.setPipeline(regularPipeline);
       pass.setBindGroup(0, picker._sceneBG);
-      pass.setBindGroup(1, device.createBindGroup({ layout: meshBGL, entries: [{ binding: 0, resource: { buffer: meshUbo } }] }));
+      pass.setBindGroup(
+        1,
+        device.createBindGroup({
+          layout: meshBGL,
+          entries: [
+            { binding: 0, resource: { buffer: meshUbo } },
+            { binding: 1, resource: { buffer: clipBuffer } }
+          ]
+        })
+      );
       pass.setVertexBuffer(0, positionBuffer);
       pass.setIndexBuffer(gpu.indexBuffer, gpu.indexFormat);
       pass.drawIndexed(gpu.indexCount);
@@ -20152,7 +20859,7 @@ async function pickAsync(picker, x, y, options) {
   const gsMeshCount = gsMeshes.length;
   const gsNextIdStart = nextId;
   if (gsMeshCount > 0) {
-    const gsModule = await import("./gs-picking-pipeline-DYaW_Lg3.js");
+    const gsModule = await import("./gs-picking-pipeline-55sM5LzV.js");
     gsModule.computeGsPickMatrix(_gsPickMatrix, px2, py, w, h);
     gsModule.gsPickWritePickMatrixAndBind(pass, engine, _gsPickMatrix);
     const resMap = picker._gsMeshResources ?? (picker._gsMeshResources = /* @__PURE__ */ new Map());
@@ -20181,6 +20888,16 @@ async function pickAsync(picker, x, y, options) {
     tempBuffers[i].destroy();
   }
   if (pickId === 0) {
+    if (debugLabel) {
+      console.trace("pick-debug", {
+        label: debugLabel,
+        input: { x, y, pickX, pickY, px: px2, py, backingWidth, backingHeight, clientWidth, clientHeight, viewport },
+        ray: debugRay,
+        pickId,
+        depth,
+        hit: false
+      });
+    }
     return createEmptyPickingInfo();
   }
   let hitMesh = null;
@@ -20196,7 +20913,10 @@ async function pickAsync(picker, x, y, options) {
       continue;
     }
     const ti = mesh.thinInstances;
-    if (ti && ti.count > 0 && ti._gpuBuffer) {
+    if (ti) {
+      if (ti.count <= 0 || !ti._gpuBuffer) {
+        continue;
+      }
       if (pickId >= scanId && pickId < scanId + ti.count) {
         hitMesh = mesh;
         hitThinIdx = pickId - scanId;
@@ -20219,6 +20939,17 @@ async function pickAsync(picker, x, y, options) {
     }
   }
   if (!hitMesh) {
+    if (debugLabel) {
+      console.trace("pick-debug", {
+        label: debugLabel,
+        input: { x, y, pickX, pickY, px: px2, py, backingWidth, backingHeight, clientWidth, clientHeight, viewport },
+        ray: debugRay,
+        pickId,
+        depth,
+        hit: false,
+        unresolved: true
+      });
+    }
     return createEmptyPickingInfo();
   }
   const info = createEmptyPickingInfo();
@@ -20248,6 +20979,20 @@ async function pickAsync(picker, x, y, options) {
       await picker._detailedPick(info, ray);
     }
   }
+  if (debugLabel) {
+    console.trace("pick-debug", {
+      label: debugLabel,
+      input: { x, y, pickX, pickY, px: px2, py, backingWidth, backingHeight, clientWidth, clientHeight, viewport },
+      ray: info.ray ?? debugRay,
+      pickId,
+      depth,
+      hit: true,
+      mesh: hitMesh.name ?? "(unnamed)",
+      thinInstanceIndex: hitThinIdx,
+      pickedPoint: info.pickedPoint,
+      distance: info.distance
+    });
+  }
   return info;
 }
 function disposePicker(picker) {
@@ -20265,7 +21010,7 @@ function disposePicker(picker) {
     picker._sceneBG = null;
   }
   if (picker._gsMeshResources) {
-    void import("./gs-picking-pipeline-DYaW_Lg3.js").then((m2) => {
+    void import("./gs-picking-pipeline-55sM5LzV.js").then((m2) => {
       if (!picker._gsMeshResources) {
         return;
       }
@@ -20496,12 +21241,12 @@ async function detailedPick(info, ray) {
       const i12 = indices[closestFace * 3 + 1];
       const i222 = indices[closestFace * 3 + 2];
       const bw = 1 - info.bu - info.bv;
-      const localNormal = normalizeVec3(
+      const localNormal = normalizeVec3$1(
         info.bu * normals[i02 * 3] + info.bv * normals[i12 * 3] + bw * normals[i222 * 3],
         info.bu * normals[i02 * 3 + 1] + info.bv * normals[i12 * 3 + 1] + bw * normals[i222 * 3 + 1],
         info.bu * normals[i02 * 3 + 2] + info.bv * normals[i12 * 3 + 2] + bw * normals[i222 * 3 + 2]
       );
-      const worldNormal = normalizeVec3(
+      const worldNormal = normalizeVec3$1(
         worldMatrix[0] * localNormal[0] + worldMatrix[4] * localNormal[1] + worldMatrix[8] * localNormal[2],
         worldMatrix[1] * localNormal[0] + worldMatrix[5] * localNormal[1] + worldMatrix[9] * localNormal[2],
         worldMatrix[2] * localNormal[0] + worldMatrix[6] * localNormal[1] + worldMatrix[10] * localNormal[2]
@@ -20522,12 +21267,12 @@ async function detailedPick(info, ray) {
     const cx = positions[i22 * 3];
     const cy = positions[i22 * 3 + 1];
     const cz = positions[i22 * 3 + 2];
-    const faceNormal = normalizeVec3(
+    const faceNormal = normalizeVec3$1(
       (by - ay) * (cz - az) - (bz - az) * (cy - ay),
       (bz - az) * (cx - ax2) - (bx2 - ax2) * (cz - az),
       (bx2 - ax2) * (cy - ay) - (by - ay) * (cx - ax2)
     );
-    const faceWorldNormal = normalizeVec3(
+    const faceWorldNormal = normalizeVec3$1(
       worldMatrix[0] * faceNormal[0] + worldMatrix[4] * faceNormal[1] + worldMatrix[8] * faceNormal[2],
       worldMatrix[1] * faceNormal[0] + worldMatrix[5] * faceNormal[1] + worldMatrix[9] * faceNormal[2],
       worldMatrix[2] * faceNormal[0] + worldMatrix[6] * faceNormal[1] + worldMatrix[10] * faceNormal[2]
@@ -20596,12 +21341,12 @@ function getPickedNormal(info, useWorldCoordinates = false) {
   const nx = info.bu * normals[i0 * 3] + info.bv * normals[i1 * 3] + bw * normals[i22 * 3];
   const ny = info.bu * normals[i0 * 3 + 1] + info.bv * normals[i1 * 3 + 1] + bw * normals[i22 * 3 + 1];
   const nz = info.bu * normals[i0 * 3 + 2] + info.bv * normals[i1 * 3 + 2] + bw * normals[i22 * 3 + 2];
-  const localNormal = normalizeVec3(nx, ny, nz);
+  const localNormal = normalizeVec3$1(nx, ny, nz);
   const wm = mi.worldMatrix;
   const wnx = wm[0] * localNormal[0] + wm[4] * localNormal[1] + wm[8] * localNormal[2];
   const wny = wm[1] * localNormal[0] + wm[5] * localNormal[1] + wm[9] * localNormal[2];
   const wnz = wm[2] * localNormal[0] + wm[6] * localNormal[1] + wm[10] * localNormal[2];
-  const worldNormal = normalizeVec3(wnx, wny, wnz);
+  const worldNormal = normalizeVec3$1(wnx, wny, wnz);
   const flip = info.ray ? worldNormal[0] * info.ray.direction[0] + worldNormal[1] * info.ray.direction[1] + worldNormal[2] * info.ray.direction[2] > 0 : false;
   if (!useWorldCoordinates) {
     return flip ? [-localNormal[0], -localNormal[1], -localNormal[2]] : localNormal;
@@ -20650,7 +21395,7 @@ function disposeUtilityLayer(utility) {
 function dotVec3(a, b) {
   return a.x * b.x + a.y * b.y + a.z * b.z;
 }
-const normalizeVec3Obj = normalizeVec3$1;
+const normalizeVec3Obj = normalizeVec3$2;
 function rayPlaneIntersect(rayOrigin, rayDir, planePoint, planeNormal) {
   const denom = dotVec3(rayDir, planeNormal);
   if (Math.abs(denom) < 1e-6) {
@@ -20729,7 +21474,7 @@ function transformDirectionByWorld(wm, dir) {
   const x = wm[0] * dir.x + wm[4] * dir.y + wm[8] * dir.z;
   const y = wm[1] * dir.x + wm[5] * dir.y + wm[9] * dir.z;
   const z = wm[2] * dir.x + wm[6] * dir.y + wm[10] * dir.z;
-  return normalizeVec3$1({ x, y, z });
+  return normalizeVec3$2({ x, y, z });
 }
 function worldDeltaToLocal(node, dx, dy, dz) {
   const parent = node.parent;
@@ -25214,7 +25959,7 @@ function isBillboardSpriteHandleAlive(handle) {
 }
 function addBillboardSystem(scene, system) {
   addDeferredSceneRenderables(scene, async (engine) => {
-    const { buildBillboardRenderable } = await import("./billboard-renderable-BHWryAeC.js");
+    const { buildBillboardRenderable } = await import("./billboard-renderable-HY2XCd52.js");
     const built = buildBillboardRenderable(engine, system);
     return { renderables: [built.renderable], dispose: built.dispose };
   });
@@ -37867,6 +38612,26 @@ var PhysicsMotionType = /* @__PURE__ */ ((PhysicsMotionType2) => {
   PhysicsMotionType2[PhysicsMotionType2["DYNAMIC"] = 2] = "DYNAMIC";
   return PhysicsMotionType2;
 })(PhysicsMotionType || {});
+var PhysicsConstraintType = /* @__PURE__ */ ((PhysicsConstraintType2) => {
+  PhysicsConstraintType2[PhysicsConstraintType2["BALL_AND_SOCKET"] = 1] = "BALL_AND_SOCKET";
+  PhysicsConstraintType2[PhysicsConstraintType2["DISTANCE"] = 2] = "DISTANCE";
+  PhysicsConstraintType2[PhysicsConstraintType2["HINGE"] = 3] = "HINGE";
+  PhysicsConstraintType2[PhysicsConstraintType2["SLIDER"] = 4] = "SLIDER";
+  PhysicsConstraintType2[PhysicsConstraintType2["LOCK"] = 5] = "LOCK";
+  PhysicsConstraintType2[PhysicsConstraintType2["PRISMATIC"] = 6] = "PRISMATIC";
+  PhysicsConstraintType2[PhysicsConstraintType2["SIX_DOF"] = 7] = "SIX_DOF";
+  return PhysicsConstraintType2;
+})(PhysicsConstraintType || {});
+var PhysicsConstraintAxis = /* @__PURE__ */ ((PhysicsConstraintAxis2) => {
+  PhysicsConstraintAxis2[PhysicsConstraintAxis2["LINEAR_X"] = 0] = "LINEAR_X";
+  PhysicsConstraintAxis2[PhysicsConstraintAxis2["LINEAR_Y"] = 1] = "LINEAR_Y";
+  PhysicsConstraintAxis2[PhysicsConstraintAxis2["LINEAR_Z"] = 2] = "LINEAR_Z";
+  PhysicsConstraintAxis2[PhysicsConstraintAxis2["ANGULAR_X"] = 3] = "ANGULAR_X";
+  PhysicsConstraintAxis2[PhysicsConstraintAxis2["ANGULAR_Y"] = 4] = "ANGULAR_Y";
+  PhysicsConstraintAxis2[PhysicsConstraintAxis2["ANGULAR_Z"] = 5] = "ANGULAR_Z";
+  PhysicsConstraintAxis2[PhysicsConstraintAxis2["LINEAR_DISTANCE"] = 6] = "LINEAR_DISTANCE";
+  return PhysicsConstraintAxis2;
+})(PhysicsConstraintAxis || {});
 function createHavokWorld(scene, hknp, gravity) {
   const hkWorld = hknp.HP_World_Create()[1];
   const g = gravity ?? { x: 0, y: -9.81, z: 0 };
@@ -37884,7 +38649,7 @@ function createHavokWorld(scene, hknp, gravity) {
   return world;
 }
 async function enableHavokFloatingOrigin(world, floatingOriginWorldRadius = 1e5) {
-  const fo = await import("./havok-floating-origin-Dr-18Nds.js");
+  const fo = await import("./havok-floating-origin-5xp32P-C.js");
   world._fo = fo.createHavokFloatingOriginContext(world._hkWorld, world._gravity, floatingOriginWorldRadius);
 }
 function _stepWorld(world, deltaMs) {
@@ -37899,7 +38664,7 @@ function _stepWorld(world, deltaMs) {
   }
   for (let i = 0; i < bodies.length; i++) {
     const b = bodies[i];
-    if (b.motionType === 1) {
+    if (b.motionType === 1 || b._preStep) {
       _syncNodeToBody(hknp, b);
     }
   }
@@ -37910,6 +38675,15 @@ function _stepWorld(world, deltaMs) {
       _syncBodyToNode(hknp, b);
     }
   }
+  if (world._afterStep) {
+    const cbs = world._afterStep;
+    for (let i = 0; i < cbs.length; i++) {
+      cbs[i](world._timestep);
+    }
+  }
+}
+function onPhysicsAfterStep(world, cb2) {
+  (world._afterStep ?? (world._afterStep = [])).push(cb2);
 }
 function _syncBodyToNode(hknp, body) {
   const t = hknp.HP_Body_GetQTransform(body._hkBody)[1];
@@ -37967,6 +38741,9 @@ function createPhysicsBody(world, node, motionType, startsAsleep = false) {
   hknp.HP_Body_SetMotionType(hkBody, hkMotion);
   const body = {
     _hkBody: hkBody,
+    _shape: null,
+    _preStep: false,
+    _world: world,
     node,
     motionType
   };
@@ -37984,48 +38761,331 @@ function createPhysicsBody(world, node, motionType, startsAsleep = false) {
   world._bodies.push(body);
   return body;
 }
+function setPhysicsBodyPreStep(body, enabled) {
+  body._preStep = enabled;
+}
+function applyPhysicsBodyImpulse(body, impulse, location) {
+  const hknp = body._world._hknp;
+  hknp.HP_Body_ApplyImpulse(body._hkBody, [location.x, location.y, location.z], [impulse.x, impulse.y, impulse.z]);
+}
+function applyPhysicsBodyForce(world, body, force, location) {
+  applyPhysicsBodyImpulse(body, { x: force.x * world._timestep, y: force.y * world._timestep, z: force.z * world._timestep }, location);
+}
+function createPhysicsConstraint(world, bodyA, bodyB, type, options = {}, limits = []) {
+  const hknp = world._hknp;
+  const joint = hknp.HP_Constraint_Create()[1];
+  hknp.HP_Constraint_SetParentBody(joint, bodyA._hkBody);
+  hknp.HP_Constraint_SetChildBody(joint, bodyB._hkBody);
+  const pivotA = options.pivotA ?? ZERO_VEC3;
+  const pivotB = options.pivotB ?? ZERO_VEC3;
+  const axisA = options.axisA ?? X_AXIS;
+  const axisB = options.axisB ?? X_AXIS;
+  const perpAxisA = options.perpAxisA ?? normalTo$1(axisA);
+  const perpAxisB = options.perpAxisB ?? normalTo$1(axisB);
+  hknp.HP_Constraint_SetAnchorInParent(joint, vec3Array(pivotA), vec3Array(axisA), vec3Array(perpAxisA));
+  hknp.HP_Constraint_SetAnchorInChild(joint, vec3Array(pivotB), vec3Array(axisB), vec3Array(perpAxisB));
+  configureConstraintAxes(hknp, joint, type, options, limits);
+  hknp.HP_Constraint_SetCollisionsEnabled(joint, !!options.collision);
+  hknp.HP_Constraint_SetEnabled(joint, true);
+  return { _hkConstraint: joint, bodyA, bodyB, type, options: { ...options, axisA, axisB, perpAxisA, perpAxisB }, limits };
+}
+function setPhysicsShapeFilterMembershipMask(world, shape, membershipMask) {
+  const info = world._hknp.HP_Shape_GetFilterInfo(shape._hkShape)[1];
+  world._hknp.HP_Shape_SetFilterInfo(shape._hkShape, [membershipMask, info[1]]);
+}
+function setPhysicsShapeFilterCollideMask(world, shape, collideMask) {
+  const info = world._hknp.HP_Shape_GetFilterInfo(shape._hkShape)[1];
+  world._hknp.HP_Shape_SetFilterInfo(shape._hkShape, [info[0], collideMask]);
+}
+const ZERO_VEC3 = { x: 0, y: 0, z: 0 };
+const X_AXIS = { x: 1, y: 0, z: 0 };
+function vec3Array(v) {
+  return [v.x, v.y, v.z];
+}
+function normalTo$1(axis) {
+  const ax2 = Math.abs(axis.x);
+  const ay = Math.abs(axis.y);
+  const az = Math.abs(axis.z);
+  if (ax2 <= ay && ax2 <= az) {
+    return normalizeVec3({ x: 0, y: -axis.z, z: axis.y });
+  }
+  if (ay <= ax2 && ay <= az) {
+    return normalizeVec3({ x: -axis.z, y: 0, z: axis.x });
+  }
+  return normalizeVec3({ x: -axis.y, y: axis.x, z: 0 });
+}
+function normalizeVec3(v) {
+  const inv = 1 / Math.max(1e-8, Math.hypot(v.x, v.y, v.z));
+  return { x: v.x * inv, y: v.y * inv, z: v.z * inv };
+}
+function configureConstraintAxes(hknp, joint, type, options, limits) {
+  const axis = hknp.ConstraintAxis;
+  const mode = hknp.ConstraintAxisLimitMode;
+  const lock = (a) => hknp.HP_Constraint_SetAxisMode(joint, a, mode.LOCKED);
+  const limit = (a, min, max) => {
+    hknp.HP_Constraint_SetAxisMode(joint, a, mode.LIMITED);
+    hknp.HP_Constraint_SetAxisMinLimit(joint, a, min);
+    hknp.HP_Constraint_SetAxisMaxLimit(joint, a, max);
+  };
+  switch (type) {
+    case 5:
+      lock(axis.LINEAR_X);
+      lock(axis.LINEAR_Y);
+      lock(axis.LINEAR_Z);
+      lock(axis.ANGULAR_X);
+      lock(axis.ANGULAR_Y);
+      lock(axis.ANGULAR_Z);
+      break;
+    case 2: {
+      const d = options.maxDistance ?? 0;
+      limit(axis.LINEAR_DISTANCE, d, d);
+      break;
+    }
+    case 3:
+      lock(axis.LINEAR_X);
+      lock(axis.LINEAR_Y);
+      lock(axis.LINEAR_Z);
+      lock(axis.ANGULAR_Y);
+      lock(axis.ANGULAR_Z);
+      break;
+    case 6:
+      lock(axis.LINEAR_Y);
+      lock(axis.LINEAR_Z);
+      lock(axis.ANGULAR_X);
+      lock(axis.ANGULAR_Y);
+      lock(axis.ANGULAR_Z);
+      break;
+    case 4:
+      lock(axis.LINEAR_Y);
+      lock(axis.LINEAR_Z);
+      lock(axis.ANGULAR_Y);
+      lock(axis.ANGULAR_Z);
+      break;
+    case 1:
+      lock(axis.LINEAR_X);
+      lock(axis.LINEAR_Y);
+      lock(axis.LINEAR_Z);
+      break;
+    case 7:
+      for (const l of limits) {
+        const nativeAxis = constraintAxisToNative(axis, l.axis);
+        if ((l.minLimit ?? -1) === 0 && (l.maxLimit ?? -1) === 0) {
+          lock(nativeAxis);
+        } else {
+          if (l.minLimit !== void 0 || l.maxLimit !== void 0) {
+            hknp.HP_Constraint_SetAxisMode(joint, nativeAxis, mode.LIMITED);
+          }
+          if (l.minLimit !== void 0) {
+            hknp.HP_Constraint_SetAxisMinLimit(joint, nativeAxis, l.minLimit);
+          }
+          if (l.maxLimit !== void 0) {
+            hknp.HP_Constraint_SetAxisMaxLimit(joint, nativeAxis, l.maxLimit);
+          }
+        }
+        if (l.stiffness !== void 0) {
+          hknp.HP_Constraint_SetAxisStiffness(joint, nativeAxis, l.stiffness);
+        }
+        if (l.damping !== void 0) {
+          hknp.HP_Constraint_SetAxisDamping(joint, nativeAxis, l.damping);
+        }
+      }
+      break;
+  }
+}
+function constraintAxisToNative(axis, value) {
+  switch (value) {
+    case 0:
+      return axis.LINEAR_X;
+    case 1:
+      return axis.LINEAR_Y;
+    case 2:
+      return axis.LINEAR_Z;
+    case 3:
+      return axis.ANGULAR_X;
+    case 4:
+      return axis.ANGULAR_Y;
+    case 5:
+      return axis.ANGULAR_Z;
+    case 6:
+      return axis.LINEAR_DISTANCE;
+  }
+}
+class MeshAccumulator {
+  constructor(collectIndices) {
+    __publicField(this, "_vertices", []);
+    __publicField(this, "_indices", []);
+    __publicField(this, "_collectIndices");
+    this._collectIndices = collectIndices;
+  }
+  addNodeMeshes(root, includeChildren) {
+    const invRoot = mat4Invert(root.worldMatrix);
+    if (!invRoot) {
+      throw new Error("Cannot create physics mesh shape from a singular root transform.");
+    }
+    const rootScale = mat4Scale(root.scaling.x, root.scaling.y, root.scaling.z);
+    const rootToBody = mat4Multiply(rootScale, invRoot);
+    this._addNodeMesh(root, rootToBody);
+    if (includeChildren) {
+      for (const child of root.children) {
+        this._addDescendantMeshes(child, rootToBody);
+      }
+    }
+    if (this._vertices.length === 0) {
+      throw new Error("Cannot create physics mesh shape without vertex positions.");
+    }
+    if (this._collectIndices && this._indices.length === 0) {
+      throw new Error("Cannot create physics mesh shape without triangle indices.");
+    }
+  }
+  getVertices(hknp) {
+    const numObjects = this._vertices.length;
+    const offset = hknp._malloc(numObjects * 4);
+    new Float32Array(hknp.HEAPU8.buffer, offset, numObjects).set(this._vertices);
+    return { offset, numObjects };
+  }
+  getTriangles(hknp) {
+    const numObjects = this._indices.length;
+    const offset = hknp._malloc(numObjects * 4);
+    new Int32Array(hknp.HEAPU8.buffer, offset, numObjects).set(this._indices);
+    return { offset, numObjects };
+  }
+  freeBuffer(hknp, buffer) {
+    hknp._free(buffer.offset);
+  }
+  _addDescendantMeshes(node, rootToBody) {
+    this._addNodeMesh(node, rootToBody);
+    for (const child of node.children) {
+      this._addDescendantMeshes(child, rootToBody);
+    }
+  }
+  _addNodeMesh(node, rootToBody) {
+    if (!isMesh(node)) {
+      return;
+    }
+    const positions = node._cpuPositions;
+    if (!positions || positions.length === 0) {
+      return;
+    }
+    const meshToBody = mat4Multiply(rootToBody, node.worldMatrix);
+    const indexOffset = this._vertices.length / 3;
+    for (let i = 0; i < positions.length; i += 3) {
+      transformPositionInto(this._vertices, meshToBody, positions[i], positions[i + 1], positions[i + 2]);
+    }
+    if (!this._collectIndices) {
+      return;
+    }
+    const indices = node._cpuIndices;
+    if (!indices) {
+      return;
+    }
+    for (let i = 0; i < indices.length; i += 3) {
+      const a = indices[i] + indexOffset;
+      const b = indices[i + 1] + indexOffset;
+      const c2 = indices[i + 2] + indexOffset;
+      this._indices.push(c2, b, a);
+    }
+  }
+}
+function isMesh(node) {
+  return "_gpu" in node && "_cpuPositions" in node;
+}
+function transformPositionInto(dst, m2, x, y, z) {
+  dst.push(m2[0] * x + m2[4] * y + m2[8] * z + m2[12], m2[1] * x + m2[5] * y + m2[9] * z + m2[13], m2[2] * x + m2[6] * y + m2[10] * z + m2[14]);
+}
 function createPhysicsShape(world, options) {
   const { _hknp: hknp } = world;
   const params = options.parameters ?? {};
   let hkShape;
+  const primitiveShape = createPrimitivePhysicsShapeHandle(hknp, options.type, params);
+  if (primitiveShape !== null) {
+    return { _hkShape: primitiveShape, _type: options.type };
+  }
   switch (options.type) {
+    case 5: {
+      hkShape = hknp.HP_Shape_CreateContainer()[1];
+      break;
+    }
+    case 4:
+    case 6: {
+      if (!options.mesh) {
+        throw new Error("Physics mesh shapes require a mesh or transform hierarchy.");
+      }
+      const collectIndices = options.type === 6;
+      const accum = new MeshAccumulator(collectIndices);
+      accum.addNodeMeshes(options.mesh, options.includeChildMeshes ?? false);
+      const positions = accum.getVertices(hknp);
+      const numVec3s = positions.numObjects / 3;
+      if (options.type === 4) {
+        hkShape = hknp.HP_Shape_CreateConvexHull(positions.offset, numVec3s)[1];
+      } else {
+        const triangles = accum.getTriangles(hknp);
+        const numTriangles = triangles.numObjects / 3;
+        hkShape = hknp.HP_Shape_CreateMesh(positions.offset, numVec3s, triangles.offset, numTriangles)[1];
+        accum.freeBuffer(hknp, triangles);
+      }
+      accum.freeBuffer(hknp, positions);
+      break;
+    }
+    default:
+      throw new Error(`Unsupported shape type: ${options.type}`);
+  }
+  return { _hkShape: hkShape, _type: options.type };
+}
+function createPrimitivePhysicsShapeHandle(hknp, type, params) {
+  switch (type) {
     case 0: {
       const c2 = params.center ?? { x: 0, y: 0, z: 0 };
       const r = params.radius ?? 0.5;
-      hkShape = hknp.HP_Shape_CreateSphere([c2.x, c2.y, c2.z], r)[1];
-      break;
+      return hknp.HP_Shape_CreateSphere([c2.x, c2.y, c2.z], r)[1];
     }
     case 3: {
       const c2 = params.center ?? { x: 0, y: 0, z: 0 };
       const q = params.rotation ?? { x: 0, y: 0, z: 0, w: 1 };
       const e = params.extents ?? { x: 1, y: 1, z: 1 };
-      hkShape = hknp.HP_Shape_CreateBox([c2.x, c2.y, c2.z], [q.x, q.y, q.z, q.w], [e.x, e.y, e.z])[1];
-      break;
+      return hknp.HP_Shape_CreateBox([c2.x, c2.y, c2.z], [q.x, q.y, q.z, q.w], [e.x, e.y, e.z])[1];
     }
     case 1: {
       const a = params.pointA ?? { x: 0, y: 0, z: 0 };
       const b = params.pointB ?? { x: 0, y: 1, z: 0 };
       const r = params.radius ?? 0.5;
-      hkShape = hknp.HP_Shape_CreateCapsule([a.x, a.y, a.z], [b.x, b.y, b.z], r)[1];
-      break;
+      return hknp.HP_Shape_CreateCapsule([a.x, a.y, a.z], [b.x, b.y, b.z], r)[1];
     }
     case 2: {
       const a = params.pointA ?? { x: 0, y: 0, z: 0 };
       const b = params.pointB ?? { x: 0, y: 1, z: 0 };
       const r = params.radius ?? 0.5;
-      hkShape = hknp.HP_Shape_CreateCylinder([a.x, a.y, a.z], [b.x, b.y, b.z], r)[1];
-      break;
+      return hknp.HP_Shape_CreateCylinder([a.x, a.y, a.z], [b.x, b.y, b.z], r)[1];
     }
     default:
-      throw new Error(`Unsupported shape type: ${options.type}`);
+      return null;
   }
-  return { _hkShape: hkShape };
 }
 function setPhysicsBodyShape(world, body, shape) {
   world._hknp.HP_Body_SetShape(body._hkBody, shape._hkShape);
+  body._shape = shape;
+}
+function addPhysicsShapeChild(world, container, child, translation, rotation, scale) {
+  const t = translation ?? { x: 0, y: 0, z: 0 };
+  const r = rotation ?? { x: 0, y: 0, z: 0, w: 1 };
+  const s = scale ?? { x: 1, y: 1, z: 1 };
+  world._hknp.HP_Shape_AddChild(container._hkShape, child._hkShape, [
+    [t.x, t.y, t.z],
+    [r.x, r.y, r.z, r.w],
+    [s.x, s.y, s.z]
+  ]);
+}
+function addPhysicsShapeChildFromParent(world, container, parentNode, child, childNode) {
+  const invParent = mat4Invert(parentNode.worldMatrix);
+  if (!invParent) {
+    throw new Error("Cannot add physics child shape from a singular parent transform.");
+  }
+  const childToParent = mat4Multiply(invParent, childNode.worldMatrix);
+  const transform = decomposeMatrix(childToParent);
+  addPhysicsShapeChild(world, container, child, transform.translation, transform.rotation, transform.scale);
 }
 function setPhysicsShapeMaterial(world, shape, friction, restitution) {
-  const material = [friction, friction, restitution, 0, 2];
+  const combines = world._hknp.MaterialCombine;
+  const material = [friction, friction, restitution, combines.MINIMUM, combines.MAXIMUM];
   world._hknp.HP_Shape_SetMaterial(shape._hkShape, material);
 }
 function setPhysicsBodyMass(world, body, mass, centerOfMass) {
@@ -38033,6 +39093,88 @@ function setPhysicsBodyMass(world, body, mass, centerOfMass) {
   const massProps = [[com.x, com.y, com.z], mass, [mass, mass, mass], [0, 0, 0, 1]];
   world._hknp.HP_Body_SetMassProperties(body._hkBody, massProps);
 }
+function setPhysicsBodyMassProperties(world, body, properties) {
+  const massProps = buildMassProperties(world, body);
+  if (properties.centerOfMass) {
+    massProps[0] = [properties.centerOfMass.x, properties.centerOfMass.y, properties.centerOfMass.z];
+  }
+  if (properties.mass !== void 0) {
+    massProps[1] = properties.mass;
+  }
+  if (properties.inertia) {
+    massProps[2] = [properties.inertia.x, properties.inertia.y, properties.inertia.z];
+  }
+  if (properties.inertiaOrientation) {
+    massProps[3] = [properties.inertiaOrientation.x, properties.inertiaOrientation.y, properties.inertiaOrientation.z, properties.inertiaOrientation.w];
+  }
+  world._hknp.HP_Body_SetMassProperties(body._hkBody, massProps);
+}
+function buildMassProperties(world, body) {
+  var _a;
+  const hknp = world._hknp;
+  const ok = ((_a = hknp.Result) == null ? void 0 : _a.RESULT_OK) ?? 0;
+  const shape = hknp.HP_Body_GetShape(body._hkBody);
+  if (shape[0] === ok) {
+    const shapeMass = hknp.HP_Shape_BuildMassProperties(shape[1]);
+    if (shapeMass[0] === ok) {
+      return shapeMass[1];
+    }
+  }
+  return [[0, 0, 0], 1, [1, 1, 1], [0, 0, 0, 1]];
+}
+function decomposeMatrix(m2) {
+  const sx = Math.hypot(m2[0], m2[1], m2[2]);
+  const sy = Math.hypot(m2[4], m2[5], m2[6]);
+  const sz = Math.hypot(m2[8], m2[9], m2[10]);
+  const invSx = sx > 1e-8 ? 1 / sx : 0;
+  const invSy = sy > 1e-8 ? 1 / sy : 0;
+  const invSz = sz > 1e-8 ? 1 / sz : 0;
+  const r00 = m2[0] * invSx;
+  const r01 = m2[4] * invSy;
+  const r02 = m2[8] * invSz;
+  const r10 = m2[1] * invSx;
+  const r11 = m2[5] * invSy;
+  const r12 = m2[9] * invSz;
+  const r20 = m2[2] * invSx;
+  const r21 = m2[6] * invSy;
+  const r22 = m2[10] * invSz;
+  let x;
+  let y;
+  let z;
+  let w;
+  const trace = r00 + r11 + r22;
+  if (trace > 0) {
+    const s = Math.sqrt(trace + 1) * 2;
+    w = 0.25 * s;
+    x = (r21 - r12) / s;
+    y = (r02 - r20) / s;
+    z = (r10 - r01) / s;
+  } else if (r00 > r11 && r00 > r22) {
+    const s = Math.sqrt(1 + r00 - r11 - r22) * 2;
+    w = (r21 - r12) / s;
+    x = 0.25 * s;
+    y = (r01 + r10) / s;
+    z = (r02 + r20) / s;
+  } else if (r11 > r22) {
+    const s = Math.sqrt(1 + r11 - r00 - r22) * 2;
+    w = (r02 - r20) / s;
+    x = (r01 + r10) / s;
+    y = 0.25 * s;
+    z = (r12 + r21) / s;
+  } else {
+    const s = Math.sqrt(1 + r22 - r00 - r11) * 2;
+    w = (r10 - r01) / s;
+    x = (r02 + r20) / s;
+    y = (r12 + r21) / s;
+    z = 0.25 * s;
+  }
+  const invLen = 1 / Math.hypot(x, y, z, w);
+  return {
+    translation: { x: m2[12], y: m2[13], z: m2[14] },
+    rotation: { x: x * invLen, y: y * invLen, z: z * invLen, w: w * invLen },
+    scale: { x: sx, y: sy, z: sz }
+  };
+}
 function applyPhysicsImpulse(world, body, impulse, point) {
   const hknp = world._hknp;
   let loc = point;
@@ -38081,13 +39223,20 @@ function releasePhysicsShape(world, shape) {
 }
 function createPhysicsAggregate(world, node, type, options) {
   const motionType = options.mass === 0 ? 0 : 2;
-  const shapeParams = _buildShapeParams(node, type, options);
-  const shape = createPhysicsShape(world, { type, parameters: shapeParams });
-  const friction = options.friction ?? 0.5;
-  const restitution = options.restitution ?? 0;
-  setPhysicsShapeMaterial(world, shape, friction, restitution);
+  let shape = options.shape;
+  if (!shape) {
+    const shapeParams = _buildShapeParams(node, type, options);
+    const hkShape = createPrimitivePhysicsShapeHandle(world._hknp, type, shapeParams);
+    if (hkShape === null) {
+      throw new Error("createPhysicsAggregate supports only primitive physics shapes.");
+    }
+    shape = { _hkShape: hkShape, _type: type };
+  }
   const body = createPhysicsBody(world, node, motionType, options.startAsleep);
   setPhysicsBodyShape(world, body, shape);
+  const friction = options.friction ?? 0.2;
+  const restitution = options.restitution ?? 0.2;
+  setPhysicsShapeMaterial(world, shape, friction, restitution);
   if (options.mass > 0) {
     setPhysicsBodyMass(world, body, options.mass);
   }
@@ -38151,6 +39300,26 @@ function _boundingRadius(mesh) {
   }
   return 0.5;
 }
+function getPhysicsBodyDebugGeometry(world, body) {
+  var _a;
+  const hknp = world._hknp;
+  const shapeResult = hknp.HP_Body_GetShape(body._hkBody);
+  const ok = ((_a = hknp.Result) == null ? void 0 : _a.RESULT_OK) ?? 0;
+  if (shapeResult[0] !== ok || !shapeResult[1]) {
+    return { positions: new Float32Array(0), indices: new Uint32Array(0) };
+  }
+  const geometryResult = hknp.HP_Shape_CreateDebugDisplayGeometry(shapeResult[1]);
+  if (geometryResult[0] !== ok) {
+    return { positions: new Float32Array(0), indices: new Uint32Array(0) };
+  }
+  const geometryInfo = hknp.HP_DebugGeometry_GetInfo(geometryResult[1])[1];
+  const positionsInPlugin = new Float32Array(hknp.HEAPU8.buffer, geometryInfo[0], geometryInfo[1] * 3);
+  const indicesInPlugin = new Uint32Array(hknp.HEAPU8.buffer, geometryInfo[2], geometryInfo[3] * 3);
+  const positions = positionsInPlugin.slice(0);
+  const indices = indicesInPlugin.slice(0);
+  hknp.HP_DebugGeometry_Release(geometryResult[1]);
+  return { positions, indices };
+}
 function disposePhysics(world) {
   if (world._fo) {
     world._fo.dispose(world);
@@ -38165,6 +39334,653 @@ function disposePhysics(world) {
   bodies.length = 0;
   hknp.HP_World_Release(hkWorld);
 }
+function createHeightFieldShape(world, options) {
+  const { _hknp: hknp } = world;
+  const resolved = options.groundMesh ? optionsFromGroundMesh(options.groundMesh) : resolveExplicit(options);
+  const { numX, numZ, sizeX, sizeZ, data } = resolved;
+  const totalNumHeights = numX * numZ;
+  const bufferBegin = hknp._malloc(totalNumHeights * 4);
+  const heightBuffer = new Float32Array(hknp.HEAPU8.buffer, bufferBegin, totalNumHeights);
+  for (let x = 0; x < numX; x++) {
+    for (let z = 0; z < numZ; z++) {
+      const hkIndex = z * numX + x;
+      const bjsIndex = (numX - 1 - x) * numZ + z;
+      heightBuffer[hkIndex] = data[bjsIndex];
+    }
+  }
+  const scaleX = sizeX / (numX - 1);
+  const scaleZ = sizeZ / (numZ - 1);
+  const hkShape = hknp.HP_Shape_CreateHeightField(numX, numZ, [scaleX, 1, scaleZ], bufferBegin)[1];
+  hknp._free(bufferBegin);
+  return { _hkShape: hkShape, _type: PhysicsShapeType.HEIGHTFIELD };
+}
+function resolveExplicit(options) {
+  if (options.numHeightFieldSamplesX === void 0 || options.numHeightFieldSamplesZ === void 0 || options.heightFieldSizeX === void 0 || options.heightFieldSizeZ === void 0 || options.heightFieldData === void 0) {
+    throw new Error("createHeightFieldShape requires either a groundMesh or full explicit heightfield parameters.");
+  }
+  return {
+    numX: options.numHeightFieldSamplesX,
+    numZ: options.numHeightFieldSamplesZ,
+    sizeX: options.heightFieldSizeX,
+    sizeZ: options.heightFieldSizeZ,
+    data: options.heightFieldData
+  };
+}
+function optionsFromGroundMesh(mesh) {
+  const localPositions = mesh._cpuPositions;
+  if (!localPositions || localPositions.length === 0) {
+    throw new Error("createHeightFieldShape ground mesh has no vertex positions.");
+  }
+  const world = mesh.worldMatrix;
+  const vertexCount = localPositions.length / 3;
+  const pos = new Float32Array(localPositions.length);
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxZ = -Infinity;
+  for (let i = 0; i < localPositions.length; i += 3) {
+    const lx = localPositions[i];
+    const ly = localPositions[i + 1];
+    const lz = localPositions[i + 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];
+    pos[i] = wx;
+    pos[i + 1] = wy;
+    pos[i + 2] = wz;
+    if (wx < minX) {
+      minX = wx;
+    }
+    if (wy < minY) {
+      minY = wy;
+    }
+    if (wz < minZ) {
+      minZ = wz;
+    }
+    if (wx > maxX) {
+      maxX = wx;
+    }
+    if (wz > maxZ) {
+      maxZ = wz;
+    }
+  }
+  const sideSamples = Math.sqrt(vertexCount);
+  if (!Number.isInteger(sideSamples) || sideSamples < 2) {
+    throw new Error(
+      `createHeightFieldShape requires a regular (N+1)×(N+1) grid mesh (e.g. from createGroundFromHeightMap); got ${vertexCount} vertices, which is not the square of an integer ≥ 2.`
+    );
+  }
+  const arraySize = sideSamples - 1;
+  const extendX = (maxX - minX) / 2;
+  const extendZ = (maxZ - minZ) / 2;
+  const dim = Math.min(extendX, extendZ);
+  if (dim <= 0) {
+    throw new Error("createHeightFieldShape ground mesh has zero extent in X or Z; cannot build a heightfield.");
+  }
+  const elementSize = dim * 2 / arraySize;
+  const samples = arraySize + 1;
+  const matrix = new Float32Array(samples * samples);
+  matrix.fill(minY);
+  for (let i = 0; i < pos.length; i += 3) {
+    const x = Math.round((pos[i] - minX) / elementSize);
+    const z = arraySize - Math.round((pos[i + 2] - minZ) / elementSize);
+    const y = pos[i + 1] - minY;
+    matrix[z * samples + x] = y;
+  }
+  return {
+    numX: samples,
+    numZ: samples,
+    sizeX: extendX * 2,
+    sizeZ: extendZ * 2,
+    data: matrix
+  };
+}
+const IGNORE_NONE = [BigInt(0)];
+function getCollector(world) {
+  if (!world._queryCollector) {
+    world._queryCollector = world._hknp.HP_QueryCollector_Create(1)[1];
+  }
+  return world._queryCollector;
+}
+function hitVec(slot) {
+  return { x: slot[0], y: slot[1], z: slot[2] };
+}
+function shapeProximity(world, query) {
+  const hknp = world._hknp;
+  const collector = getCollector(world);
+  const { position: p3, rotation: r } = query;
+  const hkQuery = [query.shape._hkShape, [p3.x, p3.y, p3.z], [r.x, r.y, r.z, r.w], query.maxDistance, query.shouldHitTriggers ?? false, IGNORE_NONE];
+  hknp.HP_World_ShapeProximityWithCollector(world._hkWorld, collector, hkQuery);
+  if (hknp.HP_QueryCollector_GetNumHits(collector)[1] > 0) {
+    const [distance, hitInputData, hitShapeData] = hknp.HP_QueryCollector_GetShapeProximityResult(collector, 0)[1];
+    return {
+      hasHit: true,
+      distance,
+      inputHitPoint: hitVec(hitInputData[3]),
+      hitPoint: hitVec(hitShapeData[3]),
+      inputHitNormal: hitVec(hitInputData[4]),
+      hitNormal: hitVec(hitShapeData[4])
+    };
+  }
+  return emptyResult();
+}
+function shapeCast(world, query) {
+  const hknp = world._hknp;
+  const collector = getCollector(world);
+  const { rotation: r, startPosition: s, endPosition: e } = query;
+  const hkQuery = [query.shape._hkShape, [r.x, r.y, r.z, r.w], [s.x, s.y, s.z], [e.x, e.y, e.z], query.shouldHitTriggers ?? false, IGNORE_NONE];
+  hknp.HP_World_ShapeCastWithCollector(world._hkWorld, collector, hkQuery);
+  if (hknp.HP_QueryCollector_GetNumHits(collector)[1] > 0) {
+    const [fraction, hitInputData, hitShapeData] = hknp.HP_QueryCollector_GetShapeCastResult(collector, 0)[1];
+    return {
+      hasHit: true,
+      fraction,
+      inputHitPoint: hitVec(hitInputData[3]),
+      hitPoint: hitVec(hitShapeData[3]),
+      inputHitNormal: hitVec(hitInputData[4]),
+      hitNormal: hitVec(hitShapeData[4])
+    };
+  }
+  return emptyResult();
+}
+function emptyResult() {
+  const zero = () => ({ x: 0, y: 0, z: 0 });
+  return {
+    hasHit: false,
+    distance: 0,
+    fraction: 0,
+    inputHitPoint: zero(),
+    hitPoint: zero(),
+    inputHitNormal: zero(),
+    hitNormal: zero()
+  };
+}
+const LINE_WGSL = `
+struct SceneUniforms { viewProjection: mat4x4<f32>, };
+struct MeshUniforms { world: mat4x4<f32>, };
+struct MaterialUniforms { color: vec4<f32>, };
+@group(0) @binding(0) var<uniform> scene: SceneUniforms;
+@group(1) @binding(0) var<uniform> mesh: MeshUniforms;
+@group(1) @binding(1) var<uniform> mat: MaterialUniforms;
+struct VertexOutput { @builtin(position) clipPos: vec4<f32>, };
+@vertex fn vsMain(@location(0) position: vec3<f32>) -> VertexOutput {
+var out: VertexOutput;
+out.clipPos = scene.viewProjection * mesh.world * vec4<f32>(position, 1.0);
+return out;
+}
+@fragment fn fsMain() -> @location(0) vec4<f32> {
+return mat.color;
+}`;
+let _cachedDevice = null;
+let _meshBGL = null;
+let _pipelineCache = null;
+function ensureDevice(engine) {
+  if (_cachedDevice !== engine._device) {
+    _cachedDevice = engine._device;
+    _meshBGL = null;
+    _pipelineCache = null;
+  }
+}
+function getMeshBindGroupLayout(engine) {
+  ensureDevice(engine);
+  if (!_meshBGL) {
+    _meshBGL = engine._device.createBindGroupLayout({
+      label: "physics-debug-line-mesh",
+      entries: [
+        { binding: 0, visibility: SS.VERTEX, buffer: { type: "uniform" } },
+        { binding: 1, visibility: SS.FRAGMENT, buffer: { type: "uniform" } }
+      ]
+    });
+  }
+  return _meshBGL;
+}
+function getPipelineCache() {
+  if (!_pipelineCache) {
+    _pipelineCache = /* @__PURE__ */ new Map();
+  }
+  return _pipelineCache;
+}
+function getOrCreateLinePipeline(engine, sig) {
+  ensureDevice(engine);
+  const key = targetSignatureKey(sig);
+  const cache = getPipelineCache();
+  const cached = cache.get(key);
+  if (cached) {
+    return cached;
+  }
+  if (!sig._colorFormat) {
+    throw new Error("Physics debug lines require a color render target.");
+  }
+  const device = engine._device;
+  const module = device.createShaderModule({ code: LINE_WGSL });
+  const pipeline = device.createRenderPipeline({
+    layout: device.createPipelineLayout({ bindGroupLayouts: [getSceneBindGroupLayout(engine), getMeshBindGroupLayout(engine)] }),
+    vertex: {
+      module,
+      entryPoint: "vsMain",
+      buffers: [
+        {
+          arrayStride: 12,
+          attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }]
+        }
+      ]
+    },
+    fragment: {
+      module,
+      entryPoint: "fsMain",
+      targets: [{ format: sig._colorFormat }]
+    },
+    depthStencil: sig._depthStencilFormat ? {
+      format: sig._depthStencilFormat,
+      depthCompare: "always",
+      depthWriteEnabled: false
+    } : void 0,
+    multisample: { count: sig._sampleCount },
+    primitive: { topology: "line-list" }
+  });
+  cache.set(key, pipeline);
+  return pipeline;
+}
+function clearPhysicsDebugLinePipelineCache() {
+  _pipelineCache = null;
+  _meshBGL = null;
+  _cachedDevice = null;
+}
+function buildLineRenderable(scene, mesh, materialOverride) {
+  const engine = scene.surface.engine;
+  const material = materialOverride ?? mesh.material;
+  const meshData = new F32(16);
+  packMat4IntoF32(meshData, mesh.worldMatrix);
+  const meshUBO = createUniformBuffer$1(engine, meshData);
+  const materialData = new F32(4);
+  materialData.set(material.color);
+  const materialUBO = createUniformBuffer$1(engine, materialData);
+  const bindGroup = engine._device.createBindGroup({
+    layout: getMeshBindGroupLayout(engine),
+    entries: [
+      { binding: 0, resource: { buffer: meshUBO } },
+      { binding: 1, resource: { buffer: materialUBO } }
+    ]
+  });
+  let lastWorldVersion = mesh.worldMatrixVersion;
+  const update = () => {
+    if (mesh.worldMatrixVersion !== lastWorldVersion) {
+      packMat4IntoF32(meshData, mesh.worldMatrix);
+      engine._device.queue.writeBuffer(meshUBO, 0, meshData);
+      lastWorldVersion = mesh.worldMatrixVersion;
+    }
+  };
+  const renderable = {
+    order: mesh.renderOrder ?? 1e3,
+    isTransparent: false,
+    _direct: true,
+    mesh,
+    bind(eng, sig) {
+      return {
+        renderable,
+        pipeline: getOrCreateLinePipeline(eng, sig),
+        update,
+        draw(pass) {
+          const gpu = mesh._gpu;
+          pass.setVertexBuffer(0, gpu.positionBuffer);
+          pass.setIndexBuffer(gpu.indexBuffer, gpu.indexFormat);
+          pass.setBindGroup(1, bindGroup);
+          pass.drawIndexed(gpu.indexCount);
+          return 1;
+        }
+      };
+    }
+  };
+  renderable._worldCenter = [mesh.worldMatrix[12], mesh.worldMatrix[13], mesh.worldMatrix[14]];
+  return renderable;
+}
+const physicsDebugLineGroupBuilder = async (scene, meshes) => {
+  const rebuildSingle = (s, mesh, materialOverride) => buildLineRenderable(s, mesh, materialOverride);
+  physicsDebugLineGroupBuilder._rebuildSingle = rebuildSingle;
+  scene._disposables.push(clearPhysicsDebugLinePipelineCache);
+  return {
+    renderables: meshes.map((mesh) => rebuildSingle(scene, mesh)),
+    rebuildSingle
+  };
+};
+function createPhysicsDebugLineMaterial(color) {
+  return {
+    _buildGroup: physicsDebugLineGroupBuilder,
+    _uboVersion: 0,
+    color: [color[0], color[1], color[2], color[3]]
+  };
+}
+const CONSTRAINT_BALL_AND_SOCKET = 1;
+const CONSTRAINT_DISTANCE = 2;
+const CONSTRAINT_HINGE = 3;
+const CONSTRAINT_SLIDER = 4;
+const CONSTRAINT_LOCK = 5;
+const CONSTRAINT_PRISMATIC = 6;
+const CONSTRAINT_SIX_DOF = 7;
+function createPhysicsViewer(scene, world, options = {}) {
+  const viewer = {
+    scene,
+    world,
+    _bodies: [],
+    _meshes: [],
+    _constraintMeshes: [],
+    _constraintLines: [],
+    _constraintDisks: [],
+    _constraintArrowheads: [],
+    _color: options.color ?? [1, 1, 1, 1],
+    _registered: false,
+    _update: () => {
+      updatePhysicsViewer(viewer);
+    }
+  };
+  return viewer;
+}
+function showPhysicsConstraint(viewer, constraint) {
+  const axisLen = 0.4;
+  const diskRadius = 0.6;
+  const axisA = constraint.axisA ?? { x: 1, y: 0, z: 0 };
+  const axisB = constraint.axisB ?? { x: 1, y: 0, z: 0 };
+  const perpAxisA = constraint.perpAxisA ?? normalTo(axisA);
+  const perpAxisB = constraint.perpAxisB ?? normalTo(axisB);
+  const thirdAxisA = normalize(cross(axisA, perpAxisA));
+  const thirdAxisB = normalize(cross(axisB, perpAxisB));
+  const meshes = [
+    createConstraintAxisMesh(viewer, constraint.bodyA, constraint.pivotA, axisA, axisLen, [1, 0, 0, 1], "constraintAxisAX"),
+    createConstraintAxisMesh(viewer, constraint.bodyA, constraint.pivotA, perpAxisA, axisLen, [0, 1, 0, 1], "constraintAxisAY"),
+    createConstraintAxisMesh(viewer, constraint.bodyA, constraint.pivotA, thirdAxisA, axisLen, [0, 0.35, 1, 1], "constraintAxisAZ"),
+    createConstraintAxisMesh(viewer, constraint.bodyB, constraint.pivotB, axisB, axisLen, [1, 0, 0, 1], "constraintAxisBX"),
+    createConstraintAxisMesh(viewer, constraint.bodyB, constraint.pivotB, perpAxisB, axisLen, [0, 1, 0, 1], "constraintAxisBY"),
+    createConstraintAxisMesh(viewer, constraint.bodyB, constraint.pivotB, thirdAxisB, axisLen, [0, 0.35, 1, 1], "constraintAxisBZ")
+  ];
+  const diskAxes = [axisB, perpAxisB, thirdAxisB];
+  const diskColors = [
+    [1, 0, 0, 1],
+    [0, 1, 0, 1],
+    [0, 0.35, 1, 1]
+  ];
+  for (const axisIndex of angularDiskAxes(constraint.type)) {
+    const color = diskColors[axisIndex];
+    meshes.push(
+      createConstraintDiskMesh(
+        viewer,
+        constraint.bodyB,
+        constraint.pivotB,
+        diskAxes[axisIndex],
+        diskRadius,
+        [color[0], color[1], color[2], color[3]],
+        `constraintAngle${axisIndex}`
+      )
+    );
+  }
+  for (const mesh of meshes) {
+    viewer._constraintMeshes.push(mesh);
+    addToScene(viewer.scene, mesh);
+  }
+  registerViewerUpdate(viewer);
+  return meshes;
+}
+function showPhysicsBody(viewer, body) {
+  for (let i = 0; i < viewer._bodies.length; i++) {
+    if (viewer._bodies[i] === body) {
+      return null;
+    }
+  }
+  const geometry = getPhysicsBodyDebugGeometry(viewer.world, body);
+  if (geometry.positions.length === 0 || geometry.indices.length === 0) {
+    return null;
+  }
+  const lineIndices = createLineListIndices(geometry.indices);
+  const normals = new Float32Array(geometry.positions.length);
+  const debugMesh = createMeshFromData(viewer.scene.surface.engine, "physicsBodyDebug", geometry.positions, normals, lineIndices);
+  debugMesh.material = createPhysicsDebugLineMaterial(viewer._color);
+  debugMesh.pickable = false;
+  debugMesh.renderOrder = 1e3;
+  copyBodyTransform(body, debugMesh);
+  viewer._bodies.push(body);
+  viewer._meshes.push(debugMesh);
+  addToScene(viewer.scene, debugMesh);
+  registerViewerUpdate(viewer);
+  return debugMesh;
+}
+function hidePhysicsBody(viewer, body) {
+  const index = viewer._bodies.indexOf(body);
+  if (index < 0) {
+    return false;
+  }
+  const mesh = viewer._meshes[index];
+  viewer._bodies.splice(index, 1);
+  viewer._meshes.splice(index, 1);
+  removeFromScene(viewer.scene, mesh);
+  unregisterViewerUpdateIfEmpty(viewer);
+  return true;
+}
+function disposePhysicsViewer(viewer) {
+  while (viewer._bodies.length > 0) {
+    hidePhysicsBody(viewer, viewer._bodies[0]);
+  }
+  while (viewer._constraintMeshes.length > 0) {
+    removeFromScene(viewer.scene, viewer._constraintMeshes.pop());
+  }
+  viewer._constraintLines.length = 0;
+  viewer._constraintDisks.length = 0;
+  viewer._constraintArrowheads.length = 0;
+  unregisterViewerUpdate(viewer);
+}
+function registerViewerUpdate(viewer) {
+  if (viewer._registered) {
+    return;
+  }
+  viewer.scene._beforeRender.push(viewer._update);
+  viewer._registered = true;
+}
+function unregisterViewerUpdateIfEmpty(viewer) {
+  if (viewer._bodies.length === 0 && viewer._constraintLines.length === 0 && viewer._constraintDisks.length === 0 && viewer._constraintArrowheads.length === 0) {
+    unregisterViewerUpdate(viewer);
+  }
+}
+function unregisterViewerUpdate(viewer) {
+  if (!viewer._registered) {
+    return;
+  }
+  const index = viewer.scene._beforeRender.indexOf(viewer._update);
+  if (index >= 0) {
+    viewer.scene._beforeRender.splice(index, 1);
+  }
+  viewer._registered = false;
+}
+function updatePhysicsViewer(viewer) {
+  for (let i = 0; i < viewer._bodies.length; i++) {
+    copyBodyTransform(viewer._bodies[i], viewer._meshes[i]);
+  }
+  for (let i = 0; i < viewer._constraintLines.length; i++) {
+    updateConstraintLine(viewer, viewer._constraintLines[i]);
+  }
+  for (let i = 0; i < viewer._constraintDisks.length; i++) {
+    updateConstraintDisk(viewer._constraintDisks[i]);
+  }
+  for (let i = 0; i < viewer._constraintArrowheads.length; i++) {
+    updateConstraintArrowhead(viewer._constraintArrowheads[i]);
+  }
+}
+function copyBodyTransform(body, mesh) {
+  const node = body.node;
+  mesh.position.set(node.position.x, node.position.y, node.position.z);
+  mesh.rotationQuaternion.set(node.rotationQuaternion.x, node.rotationQuaternion.y, node.rotationQuaternion.z, node.rotationQuaternion.w);
+  mesh.scaling.set(1, 1, 1);
+}
+function createLineListIndices(triangleIndices) {
+  const lines = new Uint32Array(triangleIndices.length * 2);
+  let o3 = 0;
+  for (let i = 0; i < triangleIndices.length; i += 3) {
+    const a = triangleIndices[i];
+    const b = triangleIndices[i + 1];
+    const c2 = triangleIndices[i + 2];
+    lines[o3++] = a;
+    lines[o3++] = b;
+    lines[o3++] = b;
+    lines[o3++] = c2;
+    lines[o3++] = c2;
+    lines[o3++] = a;
+  }
+  return lines;
+}
+function createConstraintAxisMesh(viewer, body, pivot, axis, len2, color, name) {
+  const tip = { body, pivot, axis, axisLength: len2 };
+  const line = createConstraintLineMesh(viewer, color, name, { body, pivot }, tip);
+  const head = createConstraintArrowheadMesh(viewer, color, `${name}Head`, tip);
+  viewer._constraintMeshes.push(head);
+  addToScene(viewer.scene, head);
+  return line;
+}
+function createConstraintArrowheadMesh(viewer, color, name, endpoint) {
+  const mesh = createCylinder(viewer.scene.surface.engine, { height: 0.13, diameterTop: 0, diameterBottom: 0.08, tessellation: 12 });
+  mesh.name = name;
+  const material = createStandardMaterial();
+  material.disableLighting = true;
+  material.emissiveColor = [color[0], color[1], color[2]];
+  material.diffuseColor = [color[0], color[1], color[2]];
+  mesh.material = material;
+  mesh.pickable = false;
+  mesh.renderOrder = 1001;
+  const arrowhead = { mesh, endpoint };
+  updateConstraintArrowhead(arrowhead);
+  viewer._constraintArrowheads.push(arrowhead);
+  return mesh;
+}
+function createConstraintDiskMesh(viewer, body, pivot, axis, radius, color, name) {
+  const mesh = createDisc(viewer.scene.surface.engine, { radius, tessellation: 48 });
+  mesh.name = name;
+  const material = createStandardMaterial();
+  material.disableLighting = true;
+  material.emissiveColor = [color[0], color[1], color[2]];
+  material.diffuseColor = [color[0], color[1], color[2]];
+  mesh.material = material;
+  mesh.pickable = false;
+  mesh.renderOrder = 999;
+  const disk = { mesh, endpoint: { body, pivot }, axis };
+  updateConstraintDisk(disk);
+  viewer._constraintDisks.push(disk);
+  return mesh;
+}
+function createConstraintLineMesh(viewer, color, name, a, b) {
+  const positions = new Float32Array(6);
+  writeEndpoint(positions, 0, a);
+  writeEndpoint(positions, 3, b);
+  const normals = new Float32Array(positions.length);
+  const indices = new Uint32Array([0, 1]);
+  const mesh = createMeshFromData(viewer.scene.surface.engine, name, positions, normals, indices);
+  mesh.material = createPhysicsDebugLineMaterial(color);
+  mesh.pickable = false;
+  mesh.renderOrder = 1e3;
+  viewer._constraintLines.push({ mesh, positions, a, b });
+  return mesh;
+}
+function updateConstraintLine(viewer, line) {
+  writeEndpoint(line.positions, 0, line.a);
+  writeEndpoint(line.positions, 3, line.b);
+  updateMeshPositions(viewer.scene.surface.engine, line.mesh, line.positions);
+}
+function updateConstraintDisk(disk) {
+  const p3 = localToWorld(disk.endpoint.body.node.worldMatrix, disk.endpoint.pivot);
+  const axis = normalize(transformDirection(disk.endpoint.body.node.worldMatrix, disk.axis));
+  disk.mesh.position.set(p3.x, p3.y, p3.z);
+  const q = quatFromZTo(axis);
+  disk.mesh.rotationQuaternion.set(q.x, q.y, q.z, q.w);
+}
+function updateConstraintArrowhead(arrowhead) {
+  const tip = endpointWorld(arrowhead.endpoint);
+  const axis = arrowhead.endpoint.axis ? normalize(transformDirection(arrowhead.endpoint.body.node.worldMatrix, arrowhead.endpoint.axis)) : { x: 0, y: 1, z: 0 };
+  arrowhead.mesh.position.set(tip.x, tip.y, tip.z);
+  const q = quatFromYTo(axis);
+  arrowhead.mesh.rotationQuaternion.set(q.x, q.y, q.z, q.w);
+}
+function writeEndpoint(out, offset, endpoint) {
+  const p3 = endpointWorld(endpoint);
+  out[offset] = p3.x;
+  out[offset + 1] = p3.y;
+  out[offset + 2] = p3.z;
+}
+function endpointWorld(endpoint) {
+  const pivot = endpoint.axis ? {
+    x: endpoint.pivot.x + endpoint.axis.x * (endpoint.axisLength ?? 1),
+    y: endpoint.pivot.y + endpoint.axis.y * (endpoint.axisLength ?? 1),
+    z: endpoint.pivot.z + endpoint.axis.z * (endpoint.axisLength ?? 1)
+  } : endpoint.pivot;
+  return localToWorld(endpoint.body.node.worldMatrix, pivot);
+}
+function localToWorld(m2, p3) {
+  return {
+    x: m2[0] * p3.x + m2[4] * p3.y + m2[8] * p3.z + m2[12],
+    y: m2[1] * p3.x + m2[5] * p3.y + m2[9] * p3.z + m2[13],
+    z: m2[2] * p3.x + m2[6] * p3.y + m2[10] * p3.z + m2[14]
+  };
+}
+function transformDirection(m2, v) {
+  return {
+    x: m2[0] * v.x + m2[4] * v.y + m2[8] * v.z,
+    y: m2[1] * v.x + m2[5] * v.y + m2[9] * v.z,
+    z: m2[2] * v.x + m2[6] * v.y + m2[10] * v.z
+  };
+}
+function quatFromZTo(axis) {
+  const target = normalize(axis);
+  if (target.z < -0.999999) {
+    return { x: 1, y: 0, z: 0, w: 0 };
+  }
+  const x = -target.y;
+  const y = target.x;
+  const z = 0;
+  const w = 1 + target.z;
+  const inv = 1 / Math.max(1e-8, Math.hypot(x, y, z, w));
+  return { x: x * inv, y: y * inv, z: z * inv, w: w * inv };
+}
+function quatFromYTo(axis) {
+  const target = normalize(axis);
+  if (target.y < -0.999999) {
+    return { x: 0, y: 0, z: 1, w: 0 };
+  }
+  const x = target.z;
+  const y = 0;
+  const z = -target.x;
+  const w = 1 + target.y;
+  const inv = 1 / Math.max(1e-8, Math.hypot(x, y, z, w));
+  return { x: x * inv, y: y * inv, z: z * inv, w: w * inv };
+}
+function cross(a, b) {
+  return { x: a.y * b.z - a.z * b.y, y: a.z * b.x - a.x * b.z, z: a.x * b.y - a.y * b.x };
+}
+function normalize(v) {
+  const inv = 1 / Math.max(1e-8, Math.hypot(v.x, v.y, v.z));
+  return { x: v.x * inv, y: v.y * inv, z: v.z * inv };
+}
+function normalTo(axis) {
+  const ax2 = Math.abs(axis.x);
+  const ay = Math.abs(axis.y);
+  const az = Math.abs(axis.z);
+  if (ax2 <= ay && ax2 <= az) {
+    return normalize({ x: 0, y: -axis.z, z: axis.y });
+  }
+  if (ay <= ax2 && ay <= az) {
+    return normalize({ x: -axis.z, y: 0, z: axis.x });
+  }
+  return normalize({ x: -axis.y, y: axis.x, z: 0 });
+}
+function angularDiskAxes(type) {
+  switch (type) {
+    case CONSTRAINT_LOCK:
+    case CONSTRAINT_PRISMATIC:
+      return [];
+    case CONSTRAINT_HINGE:
+    case CONSTRAINT_SLIDER:
+      return [0];
+    case CONSTRAINT_BALL_AND_SOCKET:
+    case CONSTRAINT_DISTANCE:
+    case CONSTRAINT_SIX_DOF:
+    default:
+      return [0, 1, 2];
+  }
+}
 let _coreModule = null;
 let _generatorsModule = null;
 let _initPromise = null;
@@ -38571,627 +40387,658 @@ function _assertTileCache(plugin) {
   }
 }
 export {
-  BILLBOARD_SYSTEM_UBO_BYTES as $,
-  disposeGaussianSplattingMesh as A,
+  createEmptyUniformBuffer as $,
+  getSceneBindGroupLayout as A,
   BU as B,
-  applyGsFragments as C,
+  disposeGaussianSplattingMesh as C,
   DV$1 as D,
-  CW$1 as E,
+  applyGsFragments as E,
   F64 as F,
   GeometryTextureType as G,
-  getRenderTargetSize as H,
-  getViewMatrix as I,
-  getProjectionMatrix as J,
-  getCameraPosition as K,
-  U8C as L,
+  CW$1 as H,
+  getRenderTargetSize as I,
+  getViewMatrix as J,
+  getProjectionMatrix as K,
+  getCameraPosition as L,
   MAX_LIGHTS as M,
   NODE_ESM_SHADOW_OUTPUT as N,
-  createMaterialView as O,
-  ESM_SHADOW_OUTPUT as P,
-  MATERIAL_ALPHA_BLEND as Q,
-  PBR2_ESM_SHADOW_OUTPUT as R,
+  U8C as O,
+  createMaterialView as P,
+  ESM_SHADOW_OUTPUT as Q,
+  MATERIAL_ALPHA_BLEND as R,
   SS as S,
   TU as T,
   U32 as U,
-  PBR_HAS_ALPHA_BLEND as V,
-  encodeIdToColor as W,
-  getPickingSceneBGL as X,
-  gsGpuPickingFragment as Y,
-  BILLBOARD_INDEX_DATA as Z,
-  createEmptyUniformBuffer as _,
+  PBR2_ESM_SHADOW_OUTPUT as V,
+  PBR_HAS_ALPHA_BLEND as W,
+  encodeIdToColor as X,
+  getPickingSceneBGL as Y,
+  gsGpuPickingFragment as Z,
+  BILLBOARD_INDEX_DATA as _,
   F32 as a,
-  PBR_HAS_SUBSURFACE 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,
-  NEEDS_UV as aA,
-  MSH_HAS_INSTANCE_COLOR as aB,
-  NEEDS_UV2 as aC,
-  MSH_HAS_THIN_INSTANCES as aD,
-  MSH_RECEIVE_SHADOWS as aE,
-  _standardShaderVariantKey as aF,
-  WGSL$1 as aG,
-  getCsmPbrReceiverFactory as aH,
-  PBR_HAS_ALPHA_TEST as aI,
-  PBR_HAS_METALLIC_REFLECTANCE_MAP as aJ,
-  PBR_HAS_REFLECTANCE_MAP as aK,
-  PBR2_HAS_REFLECTANCE_FACTORS as aL,
-  PBR2_HAS_UV2 as aM,
-  PBR_HAS_USE_ALPHA_ONLY_MR as aN,
-  PBR_HAS_CLEARCOAT as aO,
-  PBR2_CC_INT_MAP as aP,
-  PBR2_CC_ROUGH_MAP as aQ,
-  PBR2_CC_NORMAL_MAP as aR,
-  PBR2_CC_F0_REMAP_OFF as aS,
-  PBR_HAS_SHEEN_TEXTURE as aT,
-  PBR_HAS_SHEEN as aU,
-  PBR2_HAS_SHEEN_UV_TX as aV,
-  PBR_HAS_SHEEN_ALBEDO_SCALING as aW,
-  PBR2_HAS_IRIDESCENCE_MAP as aX,
-  PBR2_HAS_IRIDESCENCE_THICKNESS_MAP as aY,
-  PBR2_HAS_IRIDESCENCE as aZ,
-  PBR_HAS_THICKNESS_MAP as a_,
-  writeBillboardSystemUboIfDirty as aa,
-  createBillboardPipelineCache as ab,
-  PhysicsMotionType as ac,
-  HAS_BUMP_TEXTURE as ad,
-  HAS_EMISSIVE_TEXTURE as ae,
-  HAS_DEPTH_EMISSIVE_TEXTURE as af,
-  HAS_SPECULAR_TEXTURE as ag,
-  SPECULAR_USES_UV2 as ah,
-  HAS_AMBIENT_TEXTURE as ai,
-  AMBIENT_USES_UV2 as aj,
-  HAS_LIGHTMAP_TEXTURE as ak,
-  LIGHTMAP_USES_UV2 as al,
-  HAS_OPACITY_TEXTURE as am,
-  OPACITY_FROM_RGB as an,
-  HAS_REFLECTION_TEXTURE as ao,
-  HAS_CUBE_REFLECTION as ap,
-  getCsmStdReceiverFactory as aq,
-  clearSamplerCache as ar,
-  _computeStandardMaterialFeatures as as,
-  _computeMeshFeatures as at,
-  _getStdExts as au,
-  createUniformBuffer$1 as av,
-  collectStdBoundTextures as aw,
-  acquireTexture as ax,
-  releaseTexture as ay,
-  NO_COLOR_OUTPUT as az,
+  PBR_HAS_THICKNESS_MAP as a$,
+  BILLBOARD_SYSTEM_UBO_BYTES as a0,
+  createBillboardInstanceBuffer as a1,
+  _getBillboardFxHook as a2,
+  createBillboardInstanceSortScratch as a3,
+  getOrCreateBillboardPipeline as a4,
+  createBillboardSystemBindGroup as a5,
+  resetBillboardPipelineCache as a6,
+  ensureBillboardInstanceBuffer as a7,
+  uploadSortedBillboardInstances as a8,
+  uploadBillboardInstances as a9,
+  NO_COLOR_OUTPUT as aA,
+  NEEDS_UV as aB,
+  MSH_HAS_INSTANCE_COLOR as aC,
+  NEEDS_UV2 as aD,
+  MSH_HAS_THIN_INSTANCES as aE,
+  MSH_RECEIVE_SHADOWS as aF,
+  _standardShaderVariantKey as aG,
+  WGSL$1 as aH,
+  getCsmPbrReceiverFactory as aI,
+  PBR_HAS_ALPHA_TEST as aJ,
+  PBR_HAS_METALLIC_REFLECTANCE_MAP as aK,
+  PBR_HAS_REFLECTANCE_MAP as aL,
+  PBR2_HAS_REFLECTANCE_FACTORS as aM,
+  PBR2_HAS_UV2 as aN,
+  PBR_HAS_USE_ALPHA_ONLY_MR as aO,
+  PBR_HAS_CLEARCOAT as aP,
+  PBR2_CC_INT_MAP as aQ,
+  PBR2_CC_ROUGH_MAP as aR,
+  PBR2_CC_NORMAL_MAP as aS,
+  PBR2_CC_F0_REMAP_OFF as aT,
+  PBR_HAS_SHEEN_TEXTURE as aU,
+  PBR_HAS_SHEEN as aV,
+  PBR2_HAS_SHEEN_UV_TX as aW,
+  PBR_HAS_SHEEN_ALBEDO_SCALING as aX,
+  PBR2_HAS_IRIDESCENCE_MAP as aY,
+  PBR2_HAS_IRIDESCENCE_THICKNESS_MAP as aZ,
+  PBR2_HAS_IRIDESCENCE as a_,
+  buildBillboardSystemUbo as aa,
+  writeBillboardSystemUboIfDirty as ab,
+  createBillboardPipelineCache as ac,
+  PhysicsMotionType as ad,
+  HAS_BUMP_TEXTURE as ae,
+  HAS_EMISSIVE_TEXTURE as af,
+  HAS_DEPTH_EMISSIVE_TEXTURE as ag,
+  HAS_SPECULAR_TEXTURE as ah,
+  SPECULAR_USES_UV2 as ai,
+  HAS_AMBIENT_TEXTURE as aj,
+  AMBIENT_USES_UV2 as ak,
+  HAS_LIGHTMAP_TEXTURE as al,
+  LIGHTMAP_USES_UV2 as am,
+  HAS_OPACITY_TEXTURE as an,
+  OPACITY_FROM_RGB as ao,
+  HAS_REFLECTION_TEXTURE as ap,
+  HAS_CUBE_REFLECTION as aq,
+  getCsmStdReceiverFactory as ar,
+  clearSamplerCache as as,
+  _computeStandardMaterialFeatures as at,
+  _computeMeshFeatures as au,
+  _getStdExts as av,
+  createUniformBuffer$1 as aw,
+  collectStdBoundTextures as ax,
+  acquireTexture as ay,
+  releaseTexture as az,
   writeMeshLightSelection as b,
-  enableSceneTransmission as b$,
-  PBR2_HAS_THICKNESS_GLTF_CHANNEL as b0,
-  PBR_HAS_EMISSIVE_COLOR as b1,
-  PBR_HAS_EMISSIVE as b2,
-  PBR2_HAS_UNLIT as b3,
-  MSH_HAS_SKELETON as b4,
-  MSH_HAS_SKELETON_8 as b5,
-  MSH_HAS_MORPH_TARGETS as b6,
-  setMaxLights as b7,
-  computeNodeWorldMatrix as b8,
-  setSubtreeVisible as b9,
-  floatCount as bA,
-  NODE_GEOMETRY_OUTPUT as bB,
-  appendMeshLightUboFields as bC,
-  meshLightIndexWGSL as bD,
-  clearSceneBGLCache as bE,
-  _getStdExtsSorted as bF,
-  _standardFeatureKey as bG,
-  HAS_DIFFUSE_TEXTURE as bH,
-  REVERSE_DEPTH_COMPARE as bI,
-  DOUBLE_SIDED as bJ,
-  DISABLE_LIGHTING as bK,
-  DIFFUSE_USES_UV2 as bL,
-  createSingleUniformBGL as bM,
-  getViewProjectionMatrix as bN,
-  _isShaderSystemUniform as bO,
-  getEffectiveAspectRatio as bP,
-  I32 as bQ,
-  getCompressedFormat as bR,
-  I8 as bS,
-  I16 as bT,
-  PATH_POINTER as bU,
-  PBR2_HAS_REFRACTION as bV,
-  PBR2_HAS_REFRACTION_MAP as bW,
-  getTrilinearAnisotropicSampler as bX,
-  PBR2_LINEAR_IMAGE_PROCESSING as bY,
-  PBR2_HAS_DISPERSION as bZ,
-  PBR2_HAS_VOLUME as b_,
-  mat4Invert as ba,
-  mat4Identity as bb,
-  getLoaderTmpAnim as bc,
-  mat4MultiplyInto as bd,
-  INTERP_CUBICSPLINE as be,
-  INTERP_STEP as bf,
-  INTERP_LINEAR as bg,
-  PATH_WEIGHTS as bh,
-  PATH_SCALE as bi,
-  PATH_ROTATION as bj,
-  PATH_TRANSLATION as bk,
-  findParent as bl,
-  setThinInstances as bm,
-  mat4ComposeInto as bn,
-  getLoaderTmpInstance as bo,
-  mat4Multiply as bp,
-  identityTexWrap as bq,
-  getOrCreateSampler as br,
-  assembleMaterial as bs,
-  runMatExts as bt,
-  makeImageFetcher as bu,
-  findBlockByClassName as bv,
-  emitGraph as bw,
-  sanitize as bx,
-  bjsTypeToNodeType as by,
-  extractDefault as bz,
+  PBR2_HAS_DISPERSION as b$,
+  PBR_HAS_SUBSURFACE as b0,
+  PBR2_HAS_THICKNESS_GLTF_CHANNEL as b1,
+  PBR_HAS_EMISSIVE_COLOR as b2,
+  PBR_HAS_EMISSIVE as b3,
+  PBR2_HAS_UNLIT as b4,
+  MSH_HAS_SKELETON as b5,
+  MSH_HAS_SKELETON_8 as b6,
+  MSH_HAS_MORPH_TARGETS as b7,
+  uploadKtx2Texture2D as b8,
+  decodeKtx2ImageBitmapFromBuffer as b9,
+  sanitize as bA,
+  bjsTypeToNodeType as bB,
+  extractDefault as bC,
+  floatCount as bD,
+  NODE_GEOMETRY_OUTPUT as bE,
+  appendMeshLightUboFields as bF,
+  meshLightIndexWGSL as bG,
+  clearSceneBGLCache as bH,
+  _getStdExtsSorted as bI,
+  _standardFeatureKey as bJ,
+  HAS_DIFFUSE_TEXTURE as bK,
+  REVERSE_DEPTH_COMPARE as bL,
+  DOUBLE_SIDED as bM,
+  DISABLE_LIGHTING as bN,
+  DIFFUSE_USES_UV2 as bO,
+  createSingleUniformBGL as bP,
+  getViewProjectionMatrix as bQ,
+  _isShaderSystemUniform as bR,
+  getEffectiveAspectRatio as bS,
+  I32 as bT,
+  I8 as bU,
+  I16 as bV,
+  PATH_POINTER as bW,
+  PBR2_HAS_REFRACTION as bX,
+  PBR2_HAS_REFRACTION_MAP as bY,
+  getTrilinearAnisotropicSampler as bZ,
+  PBR2_LINEAR_IMAGE_PROCESSING as b_,
+  setMaxLights as ba,
+  computeNodeWorldMatrix as bb,
+  setSubtreeVisible as bc,
+  mat4Invert as bd,
+  mat4Identity as be,
+  getLoaderTmpAnim as bf,
+  mat4MultiplyInto as bg,
+  INTERP_CUBICSPLINE as bh,
+  INTERP_STEP as bi,
+  INTERP_LINEAR as bj,
+  PATH_WEIGHTS as bk,
+  PATH_SCALE as bl,
+  PATH_ROTATION as bm,
+  PATH_TRANSLATION as bn,
+  findParent as bo,
+  setThinInstances as bp,
+  mat4ComposeInto as bq,
+  getLoaderTmpInstance as br,
+  mat4Multiply as bs,
+  identityTexWrap as bt,
+  getOrCreateSampler as bu,
+  assembleMaterial as bv,
+  runMatExts as bw,
+  makeImageFetcher as bx,
+  findBlockByClassName as by,
+  emitGraph as bz,
   compileNodePipeline as c,
-  attachAxisDragGizmoToNode as c$,
-  GEOMETRY_OUTPUT as c0,
-  _registerPbrExt as c1,
-  PBR2_GEOMETRY_OUTPUT as c2,
-  PBR_HAS_ENV as c3,
-  _computePbrMaterialFeatures as c4,
-  collectPbrBoundTextures as c5,
-  PBR_HAS_NORMAL_MAP as c6,
-  MSH_HAS_TANGENTS as c7,
-  MSH_HAS_UV2 as c8,
-  MSH_HAS_VERTEX_COLOR as c9,
-  addAnimationGroups as cA,
-  addAnimationTask as cB,
-  addAxisLockedBillboardSystem as cC,
-  addBillboardSprite as cD,
-  addBillboardSpriteIndex as cE,
-  addBoxObstacle as cF,
-  addClusteredLightContainer as cG,
-  addCylinderObstacle as cH,
-  addDepthHostedSpriteLayer as cI,
-  addFacingBillboardSystem as cJ,
-  addPassDependencies as cK,
-  addRenderPass as cL,
-  addSprite2D as cM,
-  addSprite2DIndex as cN,
-  addSpriteAnimation as cO,
-  addSpriteAnimationManager as cP,
-  addSpriteRendererLayer as cQ,
-  addTask as cR,
-  addTaskAtStart as cS,
-  addTaskBefore as cT,
-  addTextRenderable as cU,
-  addTextRendererLayer as cV,
-  addThinInstance as cW,
-  addToScene as cX,
-  agentGoto as cY,
-  appendSpriteAtlasFrames as cZ,
-  applyPhysicsImpulse as c_,
-  PBR_HAS_DOUBLE_SIDED as ca,
-  getBilinearSampler as cb,
-  _getPbrExtsSorted as cc,
-  PBR_HAS_SPEC_GLOSS as cd,
-  PBR2_NO_COLOR_OUTPUT as ce,
-  _getPbrExts as cf,
-  PBR2_HAS_UV_TRANSFORM as cg,
-  PBR_HAS_ANISOTROPY as ch,
-  PBR_HAS_SKYBOX as ci,
-  PBR_HAS_SPECULAR_AA as cj,
-  PBR_HAS_FOG as ck,
-  PBR_HAS_OCCLUSION as cl,
-  PBR2_HAS_BASE_COLOR_FACTOR as cm,
-  PBR_HAS_GAMMA_ALBEDO as cn,
-  PBR_HAS_TONEMAP as co,
-  CAP_ALL as cp,
-  CAP_END as cq,
-  CAP_NONE as cr,
-  CAP_START as cs,
-  DepthOfFieldBlurLevel as ct,
-  ObservableQuat as cu,
-  ObservableVec3 as cv,
-  PhysicsShapeType as cw,
-  VERSION as cx,
-  addAgent as cy,
-  addAnimationGroup as cz,
+  addTextRendererLayer as c$,
+  PBR2_HAS_VOLUME as c0,
+  enableSceneTransmission as c1,
+  GEOMETRY_OUTPUT as c2,
+  _registerPbrExt as c3,
+  PBR2_GEOMETRY_OUTPUT as c4,
+  PBR_HAS_ENV as c5,
+  _computePbrMaterialFeatures as c6,
+  collectPbrBoundTextures as c7,
+  PBR_HAS_NORMAL_MAP as c8,
+  MSH_HAS_TANGENTS as c9,
+  PhysicsShapeType as cA,
+  VERSION as cB,
+  addAgent as cC,
+  addAnimationGroup as cD,
+  addAnimationGroups as cE,
+  addAnimationTask as cF,
+  addAxisLockedBillboardSystem as cG,
+  addBillboardSprite as cH,
+  addBillboardSpriteIndex as cI,
+  addBoxObstacle as cJ,
+  addClusteredLightContainer as cK,
+  addCylinderObstacle as cL,
+  addDepthHostedSpriteLayer as cM,
+  addFacingBillboardSystem as cN,
+  addPassDependencies as cO,
+  addPhysicsShapeChild as cP,
+  addPhysicsShapeChildFromParent as cQ,
+  addRenderPass as cR,
+  addSprite2D as cS,
+  addSprite2DIndex as cT,
+  addSpriteAnimation as cU,
+  addSpriteAnimationManager as cV,
+  addSpriteRendererLayer as cW,
+  addTask as cX,
+  addTaskAtStart as cY,
+  addTaskBefore as cZ,
+  addTextRenderable as c_,
+  MSH_HAS_UV2 as ca,
+  MSH_HAS_VERTEX_COLOR as cb,
+  PBR_HAS_DOUBLE_SIDED as cc,
+  getBilinearSampler as cd,
+  _getPbrExtsSorted as ce,
+  PBR_HAS_SPEC_GLOSS as cf,
+  PBR2_NO_COLOR_OUTPUT as cg,
+  _getPbrExts as ch,
+  PBR2_HAS_UV_TRANSFORM as ci,
+  PBR_HAS_ANISOTROPY as cj,
+  PBR_HAS_SKYBOX as ck,
+  PBR_HAS_SPECULAR_AA as cl,
+  PBR_HAS_FOG as cm,
+  PBR_HAS_OCCLUSION as cn,
+  PBR2_HAS_BASE_COLOR_FACTOR as co,
+  PBR_HAS_GAMMA_ALBEDO as cp,
+  PBR_HAS_TONEMAP as cq,
+  CAP_ALL as cr,
+  CAP_END as cs,
+  CAP_NONE as ct,
+  CAP_START as cu,
+  DepthOfFieldBlurLevel as cv,
+  ObservableQuat as cw,
+  ObservableVec3 as cx,
+  PhysicsConstraintAxis as cy,
+  PhysicsConstraintType as cz,
   NODE_NO_COLOR_OUTPUT as d,
-  createDefaultTextData as d$,
-  attachAxisScaleGizmoToNode as d0,
-  attachBoundingBoxGizmoToNode as d1,
-  attachCameraGizmoToCamera as d2,
-  attachControl as d3,
-  attachFreeControl as d4,
-  attachGeospatialControls as d5,
-  attachLightGizmoToLight as d6,
-  attachPlaneDragGizmoToNode as d7,
-  attachPlaneRotationGizmoToNode as d8,
-  attachPositionGizmoToNode as d9,
-  createAnimationController as dA,
-  createAnimationGroups as dB,
-  createAnimationManager as dC,
-  createAnimationTask as dD,
-  createArcRotateCamera as dE,
-  createAxisDragGizmo as dF,
-  createAxisLockedBillboardSystem as dG,
-  createAxisScaleGizmo as dH,
-  createBillboardCustomShader as dI,
-  createBlackAndWhitePostProcessTask as dJ,
-  createBloomPostProcessTask as dK,
-  createBlurPostProcessTask as dL,
-  createBoundingBoxGizmo as dM,
-  createBox as dN,
-  createCameraGizmo as dO,
-  createChromaticAberrationPostProcessTask as dP,
-  createCircleOfConfusionPostProcessTask as dQ,
-  createClusteredLightContainer as dR,
-  createClusteredPointLight as dS,
-  createCopyToTextureTask as dT,
-  createCsg2FromMesh as dU,
-  createCsgFromMesh as dV,
-  createCsmDirectionalShadowGenerator as dW,
-  createCylinder as dX,
-  createCylinderData as dY,
-  createDebugNavMeshGeometry as dZ,
-  createDefaultCamera as d_,
-  attachRotationGizmoToNode as da,
-  attachScaleGizmoToNode as db,
-  attachSpriteAnimationsToRenderer as dc,
-  attachSpriteAnimationsToScene as dd,
-  attachVat as de,
-  bakeCurrentTransformIntoVertices as df,
-  bakeTransformIntoVertices as dg,
-  bakeVat as dh,
-  billboardBlendAdditive as di,
-  billboardBlendAlpha as dj,
-  billboardBlendCutout as dk,
-  billboardBlendPremultiplied as dl,
-  captureScreenshot as dm,
-  clampCenterFromPoles as dn,
-  clampZoomDistance as dp,
-  clearAnimationManager as dq,
-  clearBillboardSprites as dr,
-  clearSprite2DLayer as ds,
-  clearSpriteAnimations as dt,
-  cloneTransformNode as du,
-  computeLocalBasis as dv,
-  computeLookAtFromYawPitch as dw,
-  computePath as dx,
-  computeYawPitchFromLookAt as dy,
-  createAnaglyphPostProcessTask as dz,
+  createClusteredLightContainer as d$,
+  addThinInstance as d0,
+  addToScene as d1,
+  agentGoto as d2,
+  appendSpriteAtlasFrames as d3,
+  applyPhysicsBodyForce as d4,
+  applyPhysicsBodyImpulse as d5,
+  applyPhysicsImpulse as d6,
+  attachAxisDragGizmoToNode as d7,
+  attachAxisScaleGizmoToNode as d8,
+  attachBoundingBoxGizmoToNode as d9,
+  clearSprite2DLayer as dA,
+  clearSpriteAnimations as dB,
+  cloneTransformNode as dC,
+  computeLocalBasis as dD,
+  computeLookAtFromYawPitch as dE,
+  computePath as dF,
+  computeYawPitchFromLookAt as dG,
+  createAnaglyphPostProcessTask as dH,
+  createAnimationController as dI,
+  createAnimationGroups as dJ,
+  createAnimationManager as dK,
+  createAnimationTask as dL,
+  createArcRotateCamera as dM,
+  createAxisDragGizmo as dN,
+  createAxisLockedBillboardSystem as dO,
+  createAxisScaleGizmo as dP,
+  createBillboardCustomShader as dQ,
+  createBlackAndWhitePostProcessTask as dR,
+  createBloomPostProcessTask as dS,
+  createBlurPostProcessTask as dT,
+  createBoundingBoxGizmo as dU,
+  createBox as dV,
+  createCameraGizmo as dW,
+  createCapsule as dX,
+  createCapsuleData as dY,
+  createChromaticAberrationPostProcessTask as dZ,
+  createCircleOfConfusionPostProcessTask as d_,
+  attachCameraGizmoToCamera as da,
+  attachControl as db,
+  attachFreeControl as dc,
+  attachGeospatialControls as dd,
+  attachLightGizmoToLight as de,
+  attachPlaneDragGizmoToNode as df,
+  attachPlaneRotationGizmoToNode as dg,
+  attachPositionGizmoToNode as dh,
+  attachRotationGizmoToNode as di,
+  attachScaleGizmoToNode as dj,
+  attachSpriteAnimationsToRenderer as dk,
+  attachSpriteAnimationsToScene as dl,
+  attachVat as dm,
+  bakeCurrentTransformIntoVertices as dn,
+  bakeTransformIntoVertices as dp,
+  bakeVat as dq,
+  billboardBlendAdditive as dr,
+  billboardBlendAlpha as ds,
+  billboardBlendCutout as dt,
+  billboardBlendPremultiplied as du,
+  captureScreenshot as dv,
+  clampCenterFromPoles as dw,
+  clampZoomDistance as dx,
+  clearAnimationManager as dy,
+  clearBillboardSprites as dz,
   U8 as e,
-  createShaderNoColorMaterialView$1 as e$,
-  createDepthOfFieldPostProcessTask as e0,
-  createDirectionalLight as e1,
-  createDisc as e2,
-  createEffectRenderTask as e3,
-  createEffectRenderer as e4,
-  createEffectWrapper as e5,
-  createEngine as e6,
-  createEsmDirectionalShadowGenerator as e7,
-  createExtractHighlightsPostProcessTask as e8,
-  createExtrudeShape as e9,
-  createNodeNoColorMaterialView$1 as eA,
-  createPbrMaterial as eB,
-  createPbrNoColorMaterialView$1 as eC,
-  createPcfDirectionalShadowGenerator as eD,
-  createPcfSpotlightShadowGenerator as eE,
-  createPhysicsAggregate as eF,
-  createPhysicsBody as eG,
-  createPhysicsShape as eH,
-  createPlane as eI,
-  createPlaneDragGizmo as eJ,
-  createPlaneRotationGizmo as eK,
-  createPointLight as eL,
-  createPointerDrag as eM,
-  createPolyhedron as eN,
-  createPositionGizmo as eO,
-  createProceduralGaussianSplattingMesh as eP,
-  createPropertyAnimationClip as eQ,
-  createPropertyAnimationGroup as eR,
-  createRenderTarget as eS,
-  createRenderTargetTexture as eT,
-  createRenderTask as eU,
-  createRenderTexture2D as eV,
-  createRibbon as eW,
-  createRotationGizmo as eX,
-  createScaleGizmo as eY,
-  createSceneContext as eZ,
-  createShaderMaterial as e_,
-  createFacingBillboardSystem as ea,
-  createFontFromBuffer as eb,
-  createFrameGraphContext as ec,
-  createGeometryRendererTask as ed,
-  createGeospatialCamera as ee,
-  createGeospatialLimits as ef,
-  createGlyphStorage as eg,
-  createGpuPicker as eh,
-  createGridMaterial as ei,
-  createGridSpriteAtlas as ej,
-  createGround as ek,
-  createGroundFromHeightMap as el,
-  createHavokWorld as em,
-  createHemisphericLight as en,
-  createImageProcessingTask as eo,
-  createLightGizmo as ep,
-  createLinearDepthMaterial as eq,
-  createMeshFromCsg as er,
-  createMeshFromCsg2 as es,
-  createMeshFromData as et,
-  createMeshesFromCsg2 as eu,
-  createMorphTargets as ev,
-  createNavCrowd as ew,
-  createNavMesh as ex,
-  createNavMeshFromSources as ey,
-  createNavigationPluginAsync as ez,
-  TYPE_SIZES as f,
-  disposeUtilityLayer as f$,
-  createShaderNormalMaterialView as f0,
-  createShadowTask as f1,
-  createSolidTexture2D as f2,
-  createSphere as f3,
-  createSphereData as f4,
-  createSpotLight as f5,
-  createSprite2DCustomShader as f6,
-  createSprite2DLayer as f7,
-  createSpriteAnimationManager as f8,
-  createSpriteAtlasFromFrames as f9,
-  disposeAxisDragGizmo as fA,
-  disposeAxisScaleGizmo as fB,
-  disposeBoundingBoxGizmo as fC,
-  disposeCameraGizmo as fD,
-  disposeCsg2 as fE,
-  disposeDefaultTextData as fF,
-  disposeEffectRenderer as fG,
-  disposeEffectWrapper as fH,
-  disposeEngine as fI,
-  disposeFrameGraphContext as fJ,
-  disposeGlyphStorage as fK,
-  disposeLightGizmo as fL,
-  disposePhysics as fM,
-  disposePicker as fN,
-  disposePlaneDragGizmo as fO,
-  disposePlaneRotationGizmo as fP,
-  disposePositionGizmo as fQ,
-  disposeRotationGizmo as fR,
-  disposeScaleGizmo as fS,
-  disposeScene as fT,
-  disposeSpriteAnimationBinding as fU,
-  disposeSpriteRenderer as fV,
-  disposeSurface as fW,
-  disposeTextData as fX,
-  disposeTextRenderable as fY,
-  disposeTextRenderer as fZ,
-  disposeUniformEffectWrapper as f_,
-  createSpriteFrameAnimation as fa,
-  createSpriteRenderer as fb,
-  createStandardMaterial as fc,
-  createStandardNoColorMaterialView$1 as fd,
-  createSurface as fe,
-  createTextData as ff,
-  createTextLayer as fg,
-  createTextRenderable as fh,
-  createTextRenderer as fi,
-  createTexture2DFromPixels as fj,
-  createTorus as fk,
-  createTorusKnot as fl,
-  createTorusKnotData as fm,
-  createTransformNode as fn,
-  createTube as fo,
-  createUniformEffectRenderTask as fp,
-  createUniformEffectWrapper as fq,
-  createUtilityLayer as fr,
-  crossFadeAnimationGroups as fs,
-  csg2Add as ft,
-  csg2Intersect as fu,
-  csg2Subtract as fv,
-  csgIntersect as fw,
-  csgSubtract as fx,
-  csgUnion as fy,
-  cubicToQuadratics as fz,
-  computeAabb as g,
-  onCsmReceiverUpdate as g$,
-  enableAnimationBlending as g0,
-  enableDetailedPicking as g1,
-  enableHavokFloatingOrigin as g2,
-  enableMaterialPlugins as g3,
-  enableMaterialTracking as g4,
-  enablePropertyAnimationBlending as g5,
-  enableRenderTaskTransmission as g6,
-  enableThinInstanceGpuCulling as g7,
-  extractGlyphCurves as g8,
-  fadeAnimationWeight as g9,
-  isBillboardSpriteHandleAlive as gA,
-  isCsg2Ready as gB,
-  isGizmoDragging as gC,
-  isGizmoInteracting as gD,
-  isGizmoPickPending as gE,
-  isSprite2DHandleAlive as gF,
-  loadBabylon as gG,
-  loadBasisTexture2D as gH,
-  loadEnvironment as gI,
-  loadFont as gJ,
-  loadGltf as gK,
-  loadHdrEnvironment as gL,
-  loadKtxTexture2D as gM,
-  loadNodeBlockEmitterWithGeometry as gN,
-  loadSOG as gO,
-  loadSPZ as gP,
-  loadSkybox as gQ,
-  loadSplat as gR,
-  loadSpriteAtlas as gS,
-  loadTexture2D as gT,
-  markClusteredLightContainerDirty as gU,
-  mat4Compose as gV,
-  mat4Scale as gW,
-  mat4Translation as gX,
-  normalizeRadians as gY,
-  normalizeVec3 as gZ,
-  onBeforeRender as g_,
-  findRandomPoint as ga,
-  findRandomPointAroundCircle as gb,
-  flushThinInstances as gc,
-  flyGeospatialCameraToAsync as gd,
-  getAgentPosition as ge,
-  getAgentVelocity as gf,
-  getAnimationGroups as gg,
-  getBillboardSpriteHandleIndex as gh,
-  getClosestPoint as gi,
-  getEffectivePitchMax as gj,
-  getFloatingOriginOffset as gk,
-  getFrameGraph as gl,
-  getNavigationRandomSeed as gm,
-  getPhysicsBodyLinearVelocity as gn,
-  getPhysicsGravity as go,
-  getPhysicsTimestep as gp,
-  getPhysicsVelocityLimits as gq,
-  getPickedNormal as gr,
-  getPickedUV as gs,
-  getSprite2DHandleIndex as gt,
-  getVariantNames as gu,
-  goToFrame as gv,
-  gsAlphaBlendedDepthFragment as gw,
-  gsLinearDepthFragment as gx,
-  initializeCsg2Async as gy,
-  invalidateRenderBundles as gz,
-  U16 as h,
-  setPhysicsBodyMotionType as h$,
-  onSceneDispose as h0,
-  packedSrgbToLinearRgba as h1,
-  parseNodeMaterialFromSnippet as h2,
-  pauseAnimation as h3,
-  pickAsync as h4,
-  playAnimation as h5,
-  playBillboardSpriteAnimation as h6,
-  playBillboardSpriteIndexAnimation as h7,
-  playSprite2DAnimation as h8,
-  playSprite2DIndexAnimation as h9,
-  removeThinInstance as hA,
-  renderFrame as hB,
-  resetVariant as hC,
-  resizeEngine as hD,
-  resizeMeshGeometry as hE,
-  resizeSurface as hF,
-  resolveCameraViewport as hG,
-  selectVariant as hH,
-  setAnimationAdditive as hI,
-  setAnimationTaskCategoryHandler as hJ,
-  setAnimationWeight as hK,
-  setBillboardShaderParams as hL,
-  setBillboardSpriteFrame as hM,
-  setBillboardSpriteFrameIndex as hN,
-  setCameraLimits as hO,
-  setClipPlane as hP,
-  setEffectTexture as hQ,
-  setEffectUniforms as hR,
-  setEngineSize as hS,
-  setFog as hT,
-  setGeospatialOrientation as hU,
-  setMorphTargetWeights as hV,
-  setNavigationRandomSeed as hW,
-  setParent as hX,
-  setPhysicsBodyAngularVelocity as hY,
-  setPhysicsBodyLinearVelocity as hZ,
-  setPhysicsBodyMass as h_,
-  playSpriteFrameAnimation as ha,
-  raycast as hb,
-  rebuildMaterial as hc,
-  registerEffectRenderer as hd,
-  registerFrameGraphContext as he,
-  registerPointerDrag as hf,
-  registerScene as hg,
-  registerSceneWithShadowSupport as hh,
-  registerSpriteRenderer as hi,
-  registerTextRenderer as hj,
-  registerUtilityLayer as hk,
-  releasePhysicsShape as hl,
-  removeAnimationGroup as hm,
-  removeAnimationTask as hn,
-  removeBillboardSprite as ho,
-  removeBillboardSpriteIndex as hp,
-  removeFromScene as hq,
-  removeMeshFromTask as hr,
-  removeObstacle as hs,
-  removePhysicsBody as ht,
-  removeSprite2D as hu,
-  removeSprite2DIndex as hv,
-  removeSpriteAnimation as hw,
-  removeSpriteAnimationManager as hx,
-  removeSpriteRendererLayer as hy,
-  removeTextRendererLayer as hz,
+  createPositionGizmo as e$,
+  createClusteredPointLight as e0,
+  createCopyToTextureTask as e1,
+  createCsg2FromMesh as e2,
+  createCsgFromMesh as e3,
+  createCsmDirectionalShadowGenerator as e4,
+  createCylinder as e5,
+  createCylinderData as e6,
+  createDebugNavMeshGeometry as e7,
+  createDefaultCamera as e8,
+  createDefaultTextData as e9,
+  createLightGizmo as eA,
+  createLinearDepthMaterial as eB,
+  createMeshFromCsg as eC,
+  createMeshFromCsg2 as eD,
+  createMeshFromData as eE,
+  createMeshesFromCsg2 as eF,
+  createMorphTargets as eG,
+  createNavCrowd as eH,
+  createNavMesh as eI,
+  createNavMeshFromSources as eJ,
+  createNavigationPluginAsync as eK,
+  createNodeNoColorMaterialView$1 as eL,
+  createPbrMaterial as eM,
+  createPbrNoColorMaterialView$1 as eN,
+  createPcfDirectionalShadowGenerator as eO,
+  createPcfSpotlightShadowGenerator as eP,
+  createPhysicsAggregate as eQ,
+  createPhysicsBody as eR,
+  createPhysicsConstraint as eS,
+  createPhysicsShape as eT,
+  createPhysicsViewer as eU,
+  createPlane as eV,
+  createPlaneDragGizmo as eW,
+  createPlaneRotationGizmo as eX,
+  createPointLight as eY,
+  createPointerDrag as eZ,
+  createPolyhedron as e_,
+  createDepthOfFieldPostProcessTask as ea,
+  createDirectionalLight as eb,
+  createDisc as ec,
+  createEffectRenderTask as ed,
+  createEffectRenderer as ee,
+  createEffectWrapper as ef,
+  createEngine as eg,
+  createEsmDirectionalShadowGenerator as eh,
+  createExtractHighlightsPostProcessTask as ei,
+  createExtrudeShape as ej,
+  createFacingBillboardSystem as ek,
+  createFontFromBuffer as el,
+  createFrameGraphContext as em,
+  createGeometryRendererTask as en,
+  createGeospatialCamera as eo,
+  createGeospatialLimits as ep,
+  createGlyphStorage as eq,
+  createGpuPicker as er,
+  createGridMaterial as es,
+  createGridSpriteAtlas as et,
+  createGround as eu,
+  createGroundFromHeightMap as ev,
+  createHavokWorld as ew,
+  createHeightFieldShape as ex,
+  createHemisphericLight as ey,
+  createImageProcessingTask as ez,
+  markMaterialUboDirty as f,
+  disposePicker as f$,
+  createProceduralGaussianSplattingMesh as f0,
+  createPropertyAnimationClip as f1,
+  createPropertyAnimationGroup as f2,
+  createRenderTarget as f3,
+  createRenderTargetTexture as f4,
+  createRenderTask as f5,
+  createRenderTexture2D as f6,
+  createRibbon as f7,
+  createRotationGizmo as f8,
+  createScaleGizmo as f9,
+  createTransformNode as fA,
+  createTube as fB,
+  createUniformEffectRenderTask as fC,
+  createUniformEffectWrapper as fD,
+  createUtilityLayer as fE,
+  crossFadeAnimationGroups as fF,
+  csg2Add as fG,
+  csg2Intersect as fH,
+  csg2Subtract as fI,
+  csgIntersect as fJ,
+  csgSubtract as fK,
+  csgUnion as fL,
+  cubicToQuadratics as fM,
+  disposeAxisDragGizmo as fN,
+  disposeAxisScaleGizmo as fO,
+  disposeBoundingBoxGizmo as fP,
+  disposeCameraGizmo as fQ,
+  disposeCsg2 as fR,
+  disposeDefaultTextData as fS,
+  disposeEffectRenderer as fT,
+  disposeEffectWrapper as fU,
+  disposeEngine as fV,
+  disposeFrameGraphContext as fW,
+  disposeGlyphStorage as fX,
+  disposeLightGizmo as fY,
+  disposePhysics as fZ,
+  disposePhysicsViewer as f_,
+  createSceneContext as fa,
+  createShaderMaterial as fb,
+  createShaderNoColorMaterialView$1 as fc,
+  createShaderNormalMaterialView as fd,
+  createShadowTask as fe,
+  createSolidTexture2D as ff,
+  createSphere as fg,
+  createSphereData as fh,
+  createSpotLight as fi,
+  createSprite2DCustomShader as fj,
+  createSprite2DLayer as fk,
+  createSpriteAnimationManager as fl,
+  createSpriteAtlasFromFrames as fm,
+  createSpriteFrameAnimation as fn,
+  createSpriteRenderer as fo,
+  createStandardMaterial as fp,
+  createStandardNoColorMaterialView$1 as fq,
+  createSurface as fr,
+  createTextData as fs,
+  createTextLayer as ft,
+  createTextRenderable as fu,
+  createTextRenderer as fv,
+  createTexture2DFromPixels as fw,
+  createTorus as fx,
+  createTorusKnot as fy,
+  createTorusKnotData as fz,
+  TYPE_SIZES as g,
+  loadFont as g$,
+  disposePlaneDragGizmo as g0,
+  disposePlaneRotationGizmo as g1,
+  disposePositionGizmo as g2,
+  disposeRotationGizmo as g3,
+  disposeScaleGizmo as g4,
+  disposeScene as g5,
+  disposeSpriteAnimationBinding as g6,
+  disposeSpriteRenderer as g7,
+  disposeSurface as g8,
+  disposeTextData as g9,
+  getNavigationRandomSeed as gA,
+  getPhysicsBodyLinearVelocity as gB,
+  getPhysicsGravity as gC,
+  getPhysicsTimestep as gD,
+  getPhysicsVelocityLimits as gE,
+  getPickedNormal as gF,
+  getPickedUV as gG,
+  getRenderTaskGpuTimings as gH,
+  getSprite2DHandleIndex as gI,
+  getVariantNames as gJ,
+  goToFrame as gK,
+  gsAlphaBlendedDepthFragment as gL,
+  gsLinearDepthFragment as gM,
+  hidePhysicsBody as gN,
+  initializeCsg2Async as gO,
+  invalidateRenderBundles as gP,
+  isBillboardSpriteHandleAlive as gQ,
+  isCsg2Ready as gR,
+  isGizmoDragging as gS,
+  isGizmoInteracting as gT,
+  isGizmoPickPending as gU,
+  isGpuTimingSupported as gV,
+  isRenderTaskGpuTimingSupported as gW,
+  isSprite2DHandleAlive as gX,
+  loadBabylon as gY,
+  loadBasisTexture2D as gZ,
+  loadEnvironment as g_,
+  disposeTextRenderable as ga,
+  disposeTextRenderer as gb,
+  disposeUniformEffectWrapper as gc,
+  disposeUtilityLayer as gd,
+  enableAnimationBlending as ge,
+  enableDetailedPicking as gf,
+  enableHavokFloatingOrigin as gg,
+  enableMaterialPlugins as gh,
+  enableMaterialTracking as gi,
+  enablePropertyAnimationBlending as gj,
+  enableRenderTaskTransmission as gk,
+  enableThinInstanceGpuCulling as gl,
+  extractGlyphCurves as gm,
+  fadeAnimationWeight as gn,
+  findRandomPoint as go,
+  findRandomPointAroundCircle as gp,
+  flushThinInstances as gq,
+  flyGeospatialCameraToAsync as gr,
+  getAgentPosition as gs,
+  getAgentVelocity as gt,
+  getAnimationGroups as gu,
+  getBillboardSpriteHandleIndex as gv,
+  getClosestPoint as gw,
+  getEffectivePitchMax as gx,
+  getFloatingOriginOffset as gy,
+  getFrameGraph as gz,
+  computeAabb as h,
+  setAnimationAdditive as h$,
+  loadGltf as h0,
+  loadHdrEnvironment as h1,
+  loadKtxTexture2D as h2,
+  loadNodeBlockEmitterWithGeometry as h3,
+  loadSOG as h4,
+  loadSPZ as h5,
+  loadSkybox as h6,
+  loadSplat as h7,
+  loadSpriteAtlas as h8,
+  loadTexture2D as h9,
+  registerSceneWithShadowSupport as hA,
+  registerSpriteRenderer as hB,
+  registerTextRenderer as hC,
+  registerUtilityLayer as hD,
+  releasePhysicsShape as hE,
+  removeAnimationGroup as hF,
+  removeAnimationTask as hG,
+  removeBillboardSprite as hH,
+  removeBillboardSpriteIndex as hI,
+  removeFromScene as hJ,
+  removeMeshFromTask as hK,
+  removeObstacle as hL,
+  removePhysicsBody as hM,
+  removeSprite2D as hN,
+  removeSprite2DIndex as hO,
+  removeSpriteAnimation as hP,
+  removeSpriteAnimationManager as hQ,
+  removeSpriteRendererLayer as hR,
+  removeTextRendererLayer as hS,
+  removeThinInstance as hT,
+  renderFrame as hU,
+  resetVariant as hV,
+  resizeEngine as hW,
+  resizeMeshGeometry as hX,
+  resizeSurface as hY,
+  resolveCameraViewport as hZ,
+  selectVariant as h_,
+  markClusteredLightContainerDirty as ha,
+  mat4Compose as hb,
+  mat4Scale as hc,
+  mat4Translation as hd,
+  normalizeRadians as he,
+  normalizeVec3$1 as hf,
+  onBeforeRender as hg,
+  onCsmReceiverUpdate as hh,
+  onPhysicsAfterStep as hi,
+  onSceneDispose as hj,
+  packedSrgbToLinearRgba as hk,
+  parseNodeMaterialFromSnippet as hl,
+  pauseAnimation as hm,
+  pickAsync as hn,
+  playAnimation as ho,
+  playBillboardSpriteAnimation as hp,
+  playBillboardSpriteIndexAnimation as hq,
+  playSprite2DAnimation as hr,
+  playSprite2DIndexAnimation as hs,
+  playSpriteFrameAnimation as ht,
+  raycast as hu,
+  rebuildMaterial as hv,
+  registerEffectRenderer as hw,
+  registerFrameGraphContext as hx,
+  registerPointerDrag as hy,
+  registerScene as hz,
   initMeshTransform as i,
-  updateTextData as i$,
-  setPhysicsBodyShape as i0,
-  setPhysicsBodyTransform as i1,
-  setPhysicsGravity as i2,
-  setPhysicsShapeMaterial as i3,
-  setPhysicsTimestep as i4,
-  setPhysicsVelocityLimits as i5,
-  setPositionGizmoLocalCoordinates as i6,
-  setRotationGizmoLocalCoordinates as i7,
-  setScaleGizmoLocalCoordinates as i8,
-  setShaderFloat as i9,
-  startSpriteAnimationManager as iA,
-  stopAnimation as iB,
-  stopAnimationManager as iC,
-  stopEngine as iD,
-  stopSpriteAnimation as iE,
-  stopSpriteAnimationManager as iF,
-  unregisterEffectRenderer as iG,
-  unregisterFrameGraphContext as iH,
-  unregisterScene as iI,
-  unregisterSpriteRenderer as iJ,
-  unregisterTextRenderer as iK,
-  updateAnimationManager as iL,
-  updateBillboardSprite as iM,
-  updateBillboardSpriteIndex as iN,
-  updateDefaultTextData as iO,
-  updateGlyphStorage as iP,
-  updateMeshColors as iQ,
-  updateMeshNormals as iR,
-  updateMeshPositions as iS,
-  updateMeshTangents as iT,
-  updateMeshUv2 as iU,
-  updateMeshUvs as iV,
-  updateNavCrowd as iW,
-  updateNavMeshObstacles as iX,
-  updateSprite2D as iY,
-  updateSprite2DIndex as iZ,
-  updateSpriteAnimationManager as i_,
-  setShaderMatrix as ia,
-  setShaderTexture as ib,
-  setShaderUniform as ic,
-  setShaderVector3 as id,
-  setShadowTaskCasterMeshes as ie,
-  setSprite2DFrame as ig,
-  setSprite2DFrameIndex as ih,
-  setSprite2DShaderParams as ii,
-  setSprite2DUvOffset as ij,
-  setSpriteRendererTarget as ik,
-  setSurfaceSize as il,
-  setTextLayerPosition as im,
-  setThinInstanceColor as io,
-  setThinInstanceColors as ip,
-  setThinInstanceCount as iq,
-  setThinInstanceMatrix as ir,
-  setUniformEffectUniforms as is,
-  spriteBlendAdditive as it,
-  spriteBlendAlpha as iu,
-  spriteBlendMultiply as iv,
-  spriteBlendPremultiplied as iw,
-  srgbByteToLinear as ix,
-  startAnimationManager as iy,
-  startEngine as iz,
-  createMappedBuffer as j,
-  updateTexture2DFromPixels as j0,
-  generateMipmaps$1 as j1,
-  pointLight as j2,
-  directionalLight as j3,
-  spotLight as j4,
-  animationGroup as j5,
-  createMorphTargets$1 as j6,
-  anyPrimitive as k,
-  createFreeCamera as l,
-  markMaterialUboDirty as m,
+  spriteBlendPremultiplied as i$,
+  setAnimationTaskCategoryHandler as i0,
+  setAnimationWeight as i1,
+  setBillboardShaderParams as i2,
+  setBillboardSpriteFrame as i3,
+  setBillboardSpriteFrameIndex as i4,
+  setCameraLimits as i5,
+  setClipPlane as i6,
+  setEffectTexture as i7,
+  setEffectUniforms as i8,
+  setEngineSize as i9,
+  setScaleGizmoLocalCoordinates as iA,
+  setShaderFloat as iB,
+  setShaderMatrix as iC,
+  setShaderStorageBuffer as iD,
+  setShaderTexture as iE,
+  setShaderUniform as iF,
+  setShaderVector3 as iG,
+  setShadowTaskCasterMeshes as iH,
+  setSprite2DFrame as iI,
+  setSprite2DFrameIndex as iJ,
+  setSprite2DShaderParams as iK,
+  setSprite2DUvOffset as iL,
+  setSpriteRendererTarget as iM,
+  setSurfaceSize as iN,
+  setTextLayerPosition as iO,
+  setThinInstanceColor as iP,
+  setThinInstanceColors as iQ,
+  setThinInstanceCount as iR,
+  setThinInstanceMatrix as iS,
+  setUniformEffectUniforms as iT,
+  shapeCast as iU,
+  shapeProximity as iV,
+  showPhysicsBody as iW,
+  showPhysicsConstraint as iX,
+  spriteBlendAdditive as iY,
+  spriteBlendAlpha as iZ,
+  spriteBlendMultiply as i_,
+  setFog as ia,
+  setGeospatialOrientation as ib,
+  setGpuTimingEnabled as ic,
+  setKtx2DecoderUrl as id,
+  setMorphTargetWeights as ie,
+  setNavigationRandomSeed as ig,
+  setParent as ih,
+  setPhysicsBodyAngularVelocity as ii,
+  setPhysicsBodyLinearVelocity as ij,
+  setPhysicsBodyMass as ik,
+  setPhysicsBodyMassProperties as il,
+  setPhysicsBodyMotionType as im,
+  setPhysicsBodyPreStep as io,
+  setPhysicsBodyShape as ip,
+  setPhysicsBodyTransform as iq,
+  setPhysicsGravity as ir,
+  setPhysicsShapeFilterCollideMask as is,
+  setPhysicsShapeFilterMembershipMask as it,
+  setPhysicsShapeMaterial as iu,
+  setPhysicsTimestep as iv,
+  setPhysicsVelocityLimits as iw,
+  setPositionGizmoLocalCoordinates as ix,
+  setRenderTaskGpuTimingEnabled as iy,
+  setRotationGizmoLocalCoordinates as iz,
+  U16 as j,
+  srgbByteToLinear as j0,
+  startAnimationManager as j1,
+  startEngine as j2,
+  startSpriteAnimationManager as j3,
+  stopAnimation as j4,
+  stopAnimationManager as j5,
+  stopEngine as j6,
+  stopSpriteAnimation as j7,
+  stopSpriteAnimationManager as j8,
+  unregisterEffectRenderer as j9,
+  animationGroup as jA,
+  createMorphTargets$1 as jB,
+  unregisterFrameGraphContext as ja,
+  unregisterScene as jb,
+  unregisterSpriteRenderer as jc,
+  unregisterTextRenderer as jd,
+  updateAnimationManager as je,
+  updateBillboardSprite as jf,
+  updateBillboardSpriteIndex as jg,
+  updateDefaultTextData as jh,
+  updateGlyphStorage as ji,
+  updateMeshColors as jj,
+  updateMeshNormals as jk,
+  updateMeshPositions as jl,
+  updateMeshTangents as jm,
+  updateMeshUv2 as jn,
+  updateMeshUvs as jo,
+  updateNavCrowd as jp,
+  updateNavMeshObstacles as jq,
+  updateSprite2D as jr,
+  updateSprite2DIndex as js,
+  updateSpriteAnimationManager as jt,
+  updateTextData as ju,
+  updateTexture2DFromPixels as jv,
+  generateMipmaps$1 as jw,
+  pointLight as jx,
+  directionalLight as jy,
+  spotLight as jz,
+  createMappedBuffer as k,
+  anyPrimitive as l,
+  makeTimingSnapshot as m,
   needsOrmComposite as n,
   computeUboLayout as o,
   packMat4IntoF32 as p,
@@ -39202,8 +41049,8 @@ export {
   uploadTex as u,
   cloneTexture2D as v,
   writeNodeUBO as w,
-  targetSignatureKey as x,
-  createDefaultPipelineDescriptor as y,
-  getSceneBindGroupLayout as z
+  createFreeCamera as x,
+  targetSignatureKey as y,
+  createDefaultPipelineDescriptor as z
 };
-//# sourceMappingURL=index-CLElg2Bo.js.map
+//# sourceMappingURL=index-C-tEgwbZ.js.map