@babylonjs/lite 1.6.0 → 1.8.0

package/index.d.ts

@@ -160,6 +160,10 @@ export declare function addSpriteRendererLayer(sr: SpriteRenderer, layer: Sprite
  *  or a SceneContext (the scene's default frame graph is used). */
 export declare function addTask(target: FrameGraph | SceneContext, task: Task): void;
 
+/** Insert a task immediately AFTER another task in execute order. Accepts a FrameGraph or a SceneContext.
+ *  If `after` is not found, the task is appended at the end (matching `addTaskBefore`'s fallback). */
+export declare function addTaskAfter(target: FrameGraph | SceneContext, task: Task, after: Task): void;
+
 /** Insert a task at the START of user execute order. Built-in system tasks that must
  *  precede all user work, such as the shadow adapter, keep their leading slot. */
 export declare function addTaskAtStart(target: FrameGraph | SceneContext, task: Task): void;
@@ -951,8 +955,9 @@ export declare function bakeTransformIntoVertices(mesh: GaussianSplattingMesh, t
  * @param engine - Engine context.
  * @param mesh   - The skinned source mesh (must have `mesh.skeleton`).
  * @param groups - The animation clips to bake (e.g. a creature's gait clips).
+ * @param opts   - Optional extras to capture during the bake (e.g. per-frame bone origins).
  */
-export declare function bakeVat(engine: EngineContext, mesh: Mesh, groups: AnimationGroup[]): VatBakeResult;
+export declare function bakeVat(engine: EngineContext, mesh: Mesh, groups: AnimationGroup[], opts?: VatBakeOptions): VatBakeResult;
 
 /**
  * Additive blending for world-space billboards. The billboard's RGB, scaled by its own alpha, is
@@ -1903,6 +1908,20 @@ export declare function createDefaultTextData(font: Font, fontSizePx: number, te
  */
 export declare function createDepthOfFieldPostProcessTask(config: DepthOfFieldPostProcessTaskConfig, engine: EngineContext, scene?: SceneContext): DepthOfFieldPostProcessTask;
 
+/** Create a hierarchical depth pyramid sized `width`×`height`. Build it each frame from the live depth texture
+ *  (via `createDepthPyramidTask`, or `build()` directly). Owns its COPY/REDUCE pipelines + the mipped texture. */
+export declare function createDepthPyramid(engine: EngineContext, opts: DepthPyramidOptions): DepthPyramid;
+
+/** Create a frame-graph task that rebuilds `pyramid` from `source()` into the FRAME command encoder each frame.
+ *  Order it right after the pass that produces the depth (e.g. `addTaskAfter(scene, task, depthPrepassTask)`) so
+ *  the pyramid reflects THIS frame's depth. Resize the pyramid to the source's size before the frame is recorded
+ *  (the source depth target only changes size on a canvas resize). */
+export declare function createDepthPyramidTask(engine: EngineContext, scene: SceneContext, opts: DepthPyramidTaskOptions): Task;
+
+/** Create a frame-graph task that resolves `sourceTexture`'s multisampled depth into `targetTexture`'s
+ *  single-sample depth. Add it AFTER the source render task and BEFORE any depth-sampling consumer. */
+export declare function createDepthResolveTask(config: DepthResolveTaskConfig, engine: EngineContext, scene: SceneContext): Task;
+
 /**
  * Creates a directional light shining along `direction` (a parallel light source, like the sun).
  * @param direction - World-space direction the light travels along.
@@ -2193,6 +2212,56 @@ export declare function createNavMeshFromSources(plugin: NavigationPlugin, sourc
 /** Create a no-color view over a NodeMaterial source. */
 export declare function createNodeNoColorMaterialView(source: NodeMaterial): MaterialView;
 
+/**
+ * Create a **null engine** — a device-less, surface-less {@link EngineContext} that runs the
+ * simulation half of Babylon Lite (physics stepping, animation evaluation, `onBeforeRender`
+ * callbacks, transform updates) **without any GPU device or canvas**.
+ *
+ * This is the Babylon Lite analogue of Babylon.js `NullEngine`: it lets a scene be driven
+ * headlessly on a server (plain Node, Deno, a Web Worker, a CI job) so you can run e.g. a Havok
+ * physics simulation and read back body transforms with zero rendering.
+ *
+ * ### What works
+ * - `createSceneContext(engine, { defaultRenderTask: false })` — a scene with **no** frame-graph
+ *   render task (so no swapchain / GPU resources are ever built).
+ * - `onBeforeRender(scene, cb)` callbacks (physics `createHavokWorld` registers its step this way).
+ * - `stepScene(engine, scene, deltaMs)` to advance one fixed step (replaces the browser
+ *   `requestAnimationFrame` loop that `startEngine` uses).
+ * - Physics with **primitive** collider shapes (box/sphere/capsule/cylinder) whose geometry is
+ *   given explicitly or derived from `mesh.boundMin`/`boundMax`.
+ *
+ * ### What is NOT supported (throws or is undefined behaviour)
+ * - Any rendering: `startEngine`, `renderFrame`, `captureScreenshot`, adding meshes **with
+ *   materials** (their deferred GPU builders dereference the absent `_device`), surfaces, RTTs.
+ * - Mesh/convex-hull colliders that require `node.worldMatrix` (needs the render-side world-matrix
+ *   pass). This is a follow-up.
+ * - High-precision / floating-origin matrices (they need the F64 allocator that `createEngine`
+ *   installs). This is a follow-up.
+ *
+ * @remarks
+ * The returned object is deliberately a **partial** {@link EngineContext}: only the fields the
+ * device-less simulation/update path reads are populated (`_device` is intentionally absent). The
+ * single localized cast below is the whole cost of not yet splitting `EngineContext` from its
+ * mandatory `_device`/`SurfaceContext` members — a larger, separate refactor. Every rendering code
+ * path is unreachable on a null engine, so the missing GPU fields are never dereferenced.
+ *
+ * @example
+ * ```ts
+ * import { createNullEngine, stepScene } from "babylon-lite";
+ * import { createSceneContext, onBeforeRender } from "babylon-lite";
+ *
+ * const engine = createNullEngine();
+ * const scene = createSceneContext(engine, { defaultRenderTask: false });
+ *
+ * // e.g. real Havok physics — createHavokWorld registers its step via onBeforeRender
+ * // const world = createHavokWorld(scene, await HavokPhysics());
+ *
+ * const stepMs = 1000 / 60;
+ * for (let i = 0; i < 180; i++) stepScene(engine, scene, stepMs); // 3s, no rendering
+ * ```
+ */
+export declare function createNullEngine(_options?: NullEngineOptions): EngineContext;
+
 /** Create a PbrMaterialProps with optional overrides. */
 export declare function createPbrMaterial(props?: Partial<PbrMaterialProps>): PbrMaterialProps;
 
@@ -2615,6 +2684,25 @@ export declare function createTextRenderer(surface: SurfaceContext, opts: TextRe
  */
 export declare function createTexture2DFromPixels(engine: EngineContext, data: Uint8Array, width: number, height: number, options?: PixelsTexture2DOptions): Texture2D;
 
+/**
+ * Create a **3D** texture from a tightly-packed RGBA8 byte buffer — the volumetric analog of
+ * `createTexture2DFromPixels`. The primary use is a colour-grading LUT (a `.cube`/HALD colour cube):
+ * upload the N×N×N RGBA volume once and sample it trilinearly with a single `textureSample`.
+ *
+ * The default sampler is linear with clamp-to-edge on all three axes — exactly what a LUT wants (linear
+ * = trilinear interpolation between grid points; clamp = no wrap at the cube faces). The returned handle
+ * is a `Texture2D` (so it drops straight into `setEffectTexture`) with an extra `depth` field; its `view`
+ * is created with `dimension:"3d"`.
+ *
+ * @param engine - Engine context.
+ * @param data - `width * height * depth * 4` bytes, RGBA8, ordered x fastest, then y, then z (slice-major).
+ * @param width - Cube size along R (\>= 1).
+ * @param height - Cube size along G (\>= 1).
+ * @param depth - Cube size along B (\>= 1).
+ * @param options - Sampler / format overrides.
+ */
+export declare function createTexture3DFromPixels(engine: EngineContext, data: Uint8Array, width: number, height: number, depth: number, options?: PixelsTexture3DOptions): Texture3D;
+
 /** Create a torus mesh. Caller must assign material. */
 export declare function createTorus(engine: EngineContext, options?: TorusOptions): Mesh;
 
@@ -2871,6 +2959,58 @@ export declare interface DepthOfFieldPostProcessTaskConfig extends PostProcessTa
     depthNotNormalized?: boolean;
 }
 
+/** A rebuildable hierarchical depth pyramid. Create with `createDepthPyramid`; drive its per-frame build with
+ *  `createDepthPyramidTask` (in-frame) or by calling `build()` yourself. */
+export declare interface DepthPyramid {
+    /** `r32float`, full mip chain, nearest sampler. Bind to a material; read `textureLoad(tex, coord, mip)`.
+     *  A `resize()` replaces this wrapper (new identity) — re-read it and re-bind after a resize. */
+    readonly texture: Texture2D;
+    /** Number of mip levels in the current pyramid. */
+    readonly mipCount: number;
+    /** Re-derive the pyramid from `depthTexture` (a `texture_depth_2d` of matching mip-0 size). Pass the frame
+     *  `encoder` to record the COPY/REDUCE passes in-frame (e.g. after a depth prepass, before the consumer that
+     *  samples the pyramid); omit it to run on a private encoder + submit immediately. */
+    build(depthTexture: Texture2D, encoder?: GPUCommandEncoder): void;
+    /** Reallocate the pyramid texture at a new mip-0 size (call when the source depth target resizes). No-op if
+     *  unchanged. Mint a new `texture` wrapper on a real change; safe to call any time (does not destroy the old
+     *  texture while a consumer still references it). */
+    resize(width: number, height: number): void;
+    /** Release the pyramid's base texture ref (frees the GPU texture once no consumer holds it). */
+    dispose(): void;
+}
+
+export declare interface DepthPyramidOptions {
+    /** Mip-0 width — match the source depth texture. */
+    width: number;
+    /** Mip-0 height — match the source depth texture. */
+    height: number;
+    /** Child-texel combine: `max` (default; reverse-Z nearest-surface Hi-Z) or `min` (forward-Z, or
+     *  reverse-Z farthest-occluder for occlusion culling). */
+    reduce?: DepthPyramidReduce;
+}
+
+/** How each coarser pyramid level combines its four child texels. */
+export declare type DepthPyramidReduce = "min" | "max";
+
+/** Options for `createDepthPyramidTask`. */
+export declare interface DepthPyramidTaskOptions {
+    /** The pyramid to build each frame. The task ADOPTS it — the frame graph disposes it on graph dispose, so do
+     *  not also dispose it yourself. */
+    pyramid: DepthPyramid;
+    /** The live source depth texture for this frame (e.g. a depth-prepass target). Return `null` to skip the
+     *  build this frame (e.g. before the source exists, or when nothing consumes the pyramid). */
+    source: () => Texture2D | null;
+}
+
+/** Options for a depth-resolve frame-graph task. */
+export declare interface DepthResolveTaskConfig {
+    name?: string;
+    /** Multisampled source render target whose DEPTH attachment is resolved (must have sampleCount \> 1). */
+    sourceTexture: RenderTarget;
+    /** Single-sample destination render target whose DEPTH attachment receives the resolved depth. */
+    targetTexture: RenderTarget;
+}
+
 /**
  * Detaches a spatial sound/bus — or the engine's listener — from its world
  * transform.
@@ -3462,6 +3602,13 @@ export declare interface FadeAnimationWeightOptions {
     readonly from?: number;
 }
 
+/** Snap a position to the closest point on the navmesh within a search box, or null when no part of the
+ *  mesh lies inside it. Unlike getClosestPoint — which does not inspect the query's success flag, so a
+ *  position outside its fixed ±1-unit box returns an UNSPECIFIED point (whatever the query left in its
+ *  output) rather than signalling a miss — the search extent is explicit here and a failed query is
+ *  reported as null, so callers can distinguish "snapped" from "nothing nearby". */
+export declare function findClosestPointWithin(plugin: NavigationPlugin, position: Vec3, halfExtents: Vec3): Vec3 | null;
+
 /** Return any random point on the navmesh. */
 export declare function findRandomPoint(plugin: NavigationPlugin): Vec3;
 
@@ -3943,12 +4090,21 @@ export declare function getPhysicsBodyLinearVelocity(world: PhysicsWorld, body:
 export declare function getPhysicsGravity(world: PhysicsWorld, worldPosition?: Vec3): Vec3;
 
 /**
- * Returns the world's fixed simulation timestep in seconds.
+ * Returns the world's fixed simulation timestep in **seconds** (`0` means the real per-frame delta
+ * is used). See {@link getPhysicsTimestepMs} for the millisecond-based equivalent.
  * @param world - The physics world.
- * @returns The timestep in seconds.
+ * @returns The fixed step in seconds.
  */
 export declare function getPhysicsTimestep(world: PhysicsWorld): number;
 
+/**
+ * Returns the world's fixed simulation timestep in **milliseconds** (`0` means the real per-frame
+ * delta is used). See {@link getPhysicsTimestep} for the seconds-based equivalent.
+ * @param world - The physics world.
+ * @returns The fixed step in milliseconds.
+ */
+export declare function getPhysicsTimestepMs(world: PhysicsWorld): number;
+
 /**
  * Returns the world's current maximum linear and angular speed limits.
  * @param world - The physics world.
@@ -5167,6 +5323,18 @@ export declare function normalizeVec3Object(v: Vec3): Vec3;
 /** Normalize `v` into `out`, writing zero for degenerate input. */
 export declare function normalizeVec3ToRef(v: Vec3, out: Vec3, epsilon?: number): Vec3;
 
+/**
+ * Options for {@link createNullEngine}.
+ */
+export declare interface NullEngineOptions {
+    /**
+     * Reserved for future headless-driver options (e.g. variable-timestep control). No options are
+     * consumed today; the property exists only to keep the option-bag shape stable and forbids
+     * passing unknown fields.
+     */
+    reserved?: never;
+}
+
 /**
  * A 4-component quaternion whose `x`/`y`/`z`/`w` setters fire an `onDirty` callback
  * when a component actually changes, letting the hierarchy system detect rotation updates.
@@ -5824,7 +5992,17 @@ export declare interface PhysicsViewerOptions {
 /** Pure-state handle to a Havok physics world: the WASM module, the native world, its bodies, and the timestep. */
 export declare interface PhysicsWorld {
 
-/** Pick the mesh at CSS-space canvas coordinates, matching Babylon.js Scene.pick. Returns a PickingInfo. */
+/**
+ * Pick the mesh at CSS-space canvas coordinates, matching Babylon.js Scene.pick. Returns a PickingInfo.
+ *
+ * A picker's 1×1 readback targets (`PickTargets1x1.colorStaging`/`depthStaging`) are lazily created ONCE
+ * and reused for every pick — cheap, but it means two overlapping `pickAsync` calls on the SAME picker
+ * race `mapAsync` on those shared buffers ("Buffer already has an outstanding map pending", since a
+ * GPUBuffer allows only one pending map at a time). This is easy to trigger from a consumer: e.g. a
+ * cursor-following hover preview that GPU-picks on every pointermove, racing a pick fired by a click that
+ * lands before the hover's pick has unmapped. Queue concurrent calls per-picker instead of rejecting: each
+ * pick's full map/unmap cycle completes before the next one starts.
+ */
 export declare function pickAsync(picker: GpuPicker, x: number, y: number, options?: PickOptions): Promise<PickingInfo>;
 
 /**
@@ -5911,6 +6089,17 @@ export declare interface PixelsTexture2DOptions {
     srgb?: boolean;
 }
 
+/** Sampler / format overrides for `createTexture3DFromPixels()`. */
+export declare interface PixelsTexture3DOptions {
+    /** Address mode U/V/W. Default 'clamp-to-edge' (the right choice for a colour LUT — the cube edges
+     *  must not wrap). */
+    addressMode?: GPUAddressMode;
+    /** Min/mag filter. Default 'linear' so a colour-grading LUT interpolates trilinearly in one sample. */
+    filter?: GPUFilterMode;
+    /** Use sRGB format (rgba8unorm-srgb). Leave false for a linear/display LUT. Default false. */
+    srgb?: boolean;
+}
+
 /** A viewport expressed in integer render-target pixels, with `y` measured from the top (WebGPU convention). */
 export declare interface PixelViewport {
     x: number;
@@ -6647,10 +6836,11 @@ export declare interface RenderTargetSignature {
 export declare interface RenderTask extends Task {
     readonly name: string;
     /** Render tasks are scene-bound because they consume scene camera, lights, and renderables. */
-    readonly scene: SceneContext;
    /** Add a mesh to this task's explicit render list with an optional per-pass material override.
-     *  Resolved at `record()` time via `material._buildGroup._rebuildSingle`,
-     *  so the mesh's material family must already have been registered with
-     *  the scene (so its batch builder has run). */
+    readonly scene: SceneContext;
    /** Add a mesh to this task's explicit render list with an optional per-pass material override. Resolved via
+     *  `material._buildGroup._rebuildSingle`, so the mesh's material family must already have been registered with the
+     *  scene (its batch builder has run). BEFORE the first `record()` the add is QUEUED and drained at record() time;
+     *  AFTER (a live/runtime add) it is resolved + re-bucketed into THIS task immediately, so the mesh renders on the
+     *  next frame without a `frameGraph.build()` (which would re-allocate shared GPU resources across all tasks). */
     addMesh(mesh: Mesh, opts?: {
         material?: Material;
     }): void;
@@ -6695,11 +6885,14 @@ export declare interface RenderTaskConfig {
     cs?: boolean;
     /** Scene-texture transmission settings. `copyCount: 0` copies before every transmissive draw.
      *  `generateMipmaps: false` allocates only mip 0 for the refraction texture and skips mip generation.
-     *  `mipLevelCount` caps the generated chain when a material only samples low explicit LODs. */
+     *  `mipLevelCount` caps the generated chain when a material only samples low explicit LODs.
+     *  `grabDepth: true` also snapshots the task's DEPTH attachment at the same mid-pass grab (see
+     *  `TransmissionOptions.grabDepth`). */
     transmission?: {
         copyCount?: number;
         generateMipmaps?: boolean;
         mipLevelCount?: number;
+        grabDepth?: boolean;
     };
 }
 
@@ -6820,6 +7013,17 @@ export declare interface RotationGizmoOptions {
     thickness?: number;
 }
 
+/**
+ * Convenience driver: advance a headless scene by a fixed number of steps at a fixed timestep.
+ * Equivalent to calling {@link stepScene} `steps` times.
+ *
+ * @param engine - A null engine from {@link createNullEngine}.
+ * @param scene - A scene created with `createSceneContext(engine, { defaultRenderTask: false })`.
+ * @param steps - Number of fixed steps to advance.
+ * @param deltaMs - The fixed timestep per step, in milliseconds (default `1000 / 60`).
+ */
+export declare function runHeadlessSteps(engine: EngineContext, scene: SceneContext, steps: number, deltaMs?: number): void;
+
 /** Composite scale gizmo made from X/Y/Z axis handles and a central uniform handle. */
 export declare interface ScaleGizmo {
     readonly xGizmo: AxisScaleGizmo;
@@ -6860,6 +7064,11 @@ export declare interface SceneColorGrab {
      *  (e.g. on resize), so consumers that bind it to a custom material should re-bind when it
      *  changes. */
     readonly texture: Texture2D | null;
+    /** The live opaque-scene DEPTH grab (`grabDepth: true`): the task's depth attachment as of the moment
+     *  the first transmissive surface draws, resolved to a single-sample `r32float` (raw NDC depth as
+     *  stored; a cleared texel means no geometry). Null before the target builds or when `grabDepth` is
+     *  off. Identity changes when the task rebuilds (e.g. on resize) — re-bind on change. */
+    readonly depthTexture: Texture2D | null;
 }
 
 /** Top-level scene context — pure state, no attached methods. */
@@ -7310,12 +7519,24 @@ export declare function setPhysicsShapeIsTrigger(world: PhysicsWorld, shape: Phy
 export declare function setPhysicsShapeMaterial(world: PhysicsWorld, shape: PhysicsShape, friction: number, restitution: number): void;
 
 /**
- * Sets the fixed simulation timestep used by each world step.
+ * Sets the fixed simulation timestep used by each world step, in **seconds**.
+ *
+ * Pass `0` to make the world step at the real per-frame delta instead of a fixed step.
+ * See {@link setPhysicsTimestepMs} for the millisecond-based equivalent.
  * @param world - The physics world.
- * @param dt - Timestep in seconds (e.g. `1 / 60`).
+ * @param dt - Fixed step in seconds (e.g. `1 / 60`), or `0` to use the frame delta.
  */
 export declare function setPhysicsTimestep(world: PhysicsWorld, dt: number): void;
 
+/**
+ * Sets the fixed simulation timestep used by each world step, in **milliseconds** (matching
+ * {@link SceneContext.fixedDeltaMs}). Pass `0` to make the world step at the real per-frame delta
+ * instead of a fixed step. See {@link setPhysicsTimestep} for the seconds-based equivalent.
+ * @param world - The physics world.
+ * @param fixedDeltaMs - Fixed step in milliseconds (e.g. `1000 / 60`), or `0` to use the frame delta.
+ */
+export declare function setPhysicsTimestepMs(world: PhysicsWorld, fixedDeltaMs: number): void;
+
 /**
  * Clamps the maximum linear and angular speeds of bodies in the world.
  * @param world - The physics world.
@@ -7545,6 +7766,20 @@ export declare function setThinInstanceColors(mesh: Mesh, colors: Float32Array):
  *  array the mesh already references. No-op if the mesh isn't thin-instanced yet. */
 export declare function setThinInstanceCount(mesh: Mesh, count: number): void;
 
+/** Set an extra WORLD-SPACE radius added to every instance's GPU-culling sphere.
+ *
+ * The culler derives each instance's sphere from the prototype's authored vertex bounds, so a
+ * vertex shader that DISPLACES geometry beyond them — terrain-following height offsets, tall wind
+ * sway, growth animations — can move a visible instance outside its sphere and pop it at the
+ * screen edge. The usual workaround is disabling culling for the whole mesh; padding the sphere
+ * by the maximum shader displacement instead keeps culling both correct and enabled.
+ *
+ * The pad is in world units, applied after per-instance scaling. 0 restores the exact authored
+ * bounds. Takes effect on the next culled pass (the culler reads it when writing its per-pass
+ * params), so it can be changed live.
+ */
+export declare function setThinInstanceCullBoundsPad(mesh: Mesh, pad: number): void;
+
 /** Update one instance's matrix. */
 export declare function setThinInstanceMatrix(mesh: Mesh, index: number, matrix: Mat4): void;
 
@@ -7566,8 +7801,10 @@ export declare function setUniformEffectUniforms(wrapper: UniformEffectWrapper,
  */
 export declare function setUnmuteUIEnabled(ui: UnmuteUI, enabled: boolean): void;
 
-/** Vertex attribute names a ShaderMaterial can bind. */
-export declare type ShaderAttributeName = "position" | "normal" | "uv" | "uv2" | "tangent" | "color";
+/** Vertex attribute names a ShaderMaterial can bind. `joints`/`weights` (and `joints1`/`weights1`
+ *  for \>4 bones/vertex) are the skinning attributes — bound from the mesh's skeleton/VAT buffers,
+ *  letting a custom material do vertex skinning (e.g. baked vertex-animation). */
+export declare type ShaderAttributeName = "position" | "normal" | "uv" | "uv2" | "tangent" | "color" | "joints" | "weights" | "joints1" | "weights1";
 
 /** A resolved WGSL preprocessor define (name + value). */
 export declare interface ShaderDefine {
@@ -8516,6 +8753,21 @@ export declare interface StencilState {
     readonly writeMask?: number;
 }
 
+/**
+ * Advance one fixed simulation step of a headless scene created against a {@link createNullEngine}
+ * engine. This is the server-side replacement for the `requestAnimationFrame` loop that
+ * `startEngine` runs in the browser.
+ *
+ * It sets the frame delta and runs the scene's per-frame update, which fires all
+ * `onBeforeRender(scene, …)` callbacks (physics step, animation evaluation, user logic). It does
+ * **not** record or submit any GPU work.
+ *
+ * @param engine - A null engine from {@link createNullEngine}.
+ * @param scene - A scene created with `createSceneContext(engine, { defaultRenderTask: false })`.
+ * @param deltaMs - The fixed timestep for this step, in milliseconds (e.g. `1000 / 60`).
+ */
+export declare function stepScene(engine: EngineContext, scene: SceneContext, deltaMs: number): void;
+
 /** Options for {@link enableStereo}. */
 export declare interface StereoSoundOptions {
     /** Stereo pan in the range `[-1, 1]` (`-1` = full left, `1` = full right). Defaults to `0`. */
@@ -8936,6 +9188,12 @@ export declare interface Texture2DOptions {
     premultiplyAlpha?: boolean;
 }
 
+/** A `Texture2D` handle whose underlying GPU texture is `dimension:"3d"`, plus its depth. Bind it to a
+ *  fullscreen effect with `viewDimension:"3d"` and sample it in WGSL as `texture_3d<f32>`. */
+export declare type Texture3D = Texture2D & {
+    depth: number;
+};
+
 /** Thickness sub-feature. Controls how thick the material is at each point. */
 export declare interface ThicknessProps {
     /** Thickness map texture. R channel is sampled by default (matches
@@ -9062,6 +9320,14 @@ export declare interface TransmissionOptions {
     /** Cap the scene-colour grab mip chain. Use this when the material samples explicit low LODs only, so
      *  unused tiny mips are not regenerated every frame. Ignored when `generateMipmaps` is false. */
     mipLevelCount?: number;
+    /** When true, ALSO snapshot the task's DEPTH attachment at the same mid-pass grab, into a single-sample
+     *  `r32float` texture exposed as `SceneColorGrab.depthTexture` — the opaque scene depth as of the moment
+     *  the first transmissive surface draws. Lets a transmissive material depth-ray-march the opaque scene
+     *  (screen-space reflection / refraction) without re-rendering a separate depth prepass: the depth
+     *  attachment itself cannot be sampled while the transmissive draw has it bound (a WebGPU feedback loop),
+     *  which is exactly why the snapshot is taken at the pass break. MSAA sources resolve sample 0 (matching
+     *  `createDepthResolveTask`). No-op when the task's render target carries no depth attachment. */
+    grabDepth?: boolean;
 }
 
 /** Options for `createTubeData`: a circular cross-section swept along a path. */
@@ -9284,6 +9550,14 @@ declare interface VariantMeshEntry {
 
 declare interface Varying {
 
+/** Optional extras to capture while baking (nothing is captured unless requested). */
+export declare interface VatBakeOptions {
+    /** Bone indices whose posed ORIGIN should be sampled per baked frame (e.g. a hand joint for a held
+     *  item, a muzzle, an FX socket). Bone index = position in the skeleton's joint list = the bone's row
+     *  block in the baked texture. See {@link VatBakeResult.boneOrigins}. */
+    readonly captureBoneOrigins?: readonly number[];
+}
+
 /** Result of baking — the GPU texture plus a per-clip row map for choosing playback params. */
 export declare interface VatBakeResult {
     readonly texture: GPUTexture;
@@ -9291,6 +9565,13 @@ export declare interface VatBakeResult {
     readonly frameCount: number;
     /** Clip name → row range, for building the per-mesh/per-instance (fromRow,toRow,offset,fps) params. */
     readonly clips: Record<string, VatClip>;
+    /** Present only when `captureBoneOrigins` was passed: bone index → the bone's posed origin per baked
+     *  frame, as `frameCount * 3` xyz floats (frame `row` at offset `row*3`, matching the texture rows /
+     *  `clips[].fromRow`). The point is in the mesh's SKIN output space — i.e. the space the VAT vertex path
+     *  produces before the `world` uniform — so a consumer gets world space with `instance · mesh.world · p`.
+     *  Lets a caller attach geometry to a moving joint (a carried prop, a socketed effect) without a live
+     *  skeleton. */
+    readonly boneOrigins?: Record<number, Float32Array>;
 }
 
 /** Where one clip landed in the baked texture: its first row, its frame count, and its native fps. */

package/lib/_chunks/vendor/{manifold-Sh8xE2da.js → manifold-DtI3BJoR.js}

@@ -16,7 +16,7 @@ var Module = (() => {
         typeof process.versions == 'object' &&
         typeof process.versions.node == 'string' && process.type != 'renderer';
     if (ENVIRONMENT_IS_NODE) {
-      const {createRequire} = await import('../__vite-browser-external-BFTKbDcV.js').then(n => n._);
+      const {createRequire} = await Promise.resolve({ createRequire: () => () => { throw new Error("require() is not available in the browser build of @babylonjs/lite"); } });
       var require = createRequire(import.meta.url);
     }
     var _ManifoldInitialized = false;
@@ -2999,4 +2999,4 @@ const manifold$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty
 }, Symbol.toStringTag, { value: 'Module' }));
 
 export { manifold$1 as a, manifold$2 as m };
-//# sourceMappingURL=manifold-Sh8xE2da.js.map
+//# sourceMappingURL=manifold-DtI3BJoR.js.map