@babylonjs/lite 1.11.0 → 1.13.0

package/index.d.ts

@@ -594,6 +594,14 @@ export declare interface ArcRotateInterpolationOptions {
     interpolationFactor?: number;
 }
 
+/** Per-layer upload options for `uploadImageToArrayLayer()` / `loadImageToArrayLayer()`. */
+export declare interface ArrayLayerUploadOptions {
+    /** Flip Y during upload. Default true (matches Babylon.js convention). */
+    invertY?: boolean;
+    /** Treat the destination as premultiplied-alpha. Default false (straight RGBA). */
+    premultiplyAlpha?: boolean;
+}
+
 /**
  * Result returned by loadGltf / loadBabylon.
  * Pass directly to addToScene() — it handles all fields automatically.
@@ -853,6 +861,11 @@ export declare interface AudioEngine {
     /** Fires on every qualifying user gesture (click), not just the first. */
     readonly onUserGesture: AudioSignal<void>;
 
+/** Pure-state handle for a MediaStream carrying the audio engine's final master mix. */
+export declare interface AudioEngineMediaStream {
+    /** One live audio track containing the post-master engine output. */
+    readonly stream: MediaStream;
+
 /** Options for {@link createAudioEngineAsync}. */
 export declare interface AudioEngineOptions {
     /**
@@ -1552,6 +1565,11 @@ export declare function clearSprite2DLayer(layer: Sprite2DLayer): void;
  */
 export declare function clearSpriteAnimations(manager: SpriteAnimationManager): void;
 
+/** Dissolve a `setThinInstanceLodPartner` pairing: `fullMesh` culling reverts to its single-bucket output and
+ * the former partner returns to independent rendering (drawing its own instance count again after the next
+ * renderable rebuild; GPU culling auto-enabled by the pairing is switched back off). */
+export declare function clearThinInstanceLodPartner(fullMesh: Mesh): void;
+
 /** A clipping plane expressed as the coefficients `[a, b, c, d]` of `a·x + b·y + c·z + d`. */
 export declare type ClipPlane = readonly [number, number, number, number];
 
@@ -1830,6 +1848,14 @@ export declare function createAudioBusAsync(engine: AudioEngine, name: string, o
  */
 export declare function createAudioEngineAsync(options?: AudioEngineOptions): Promise<AudioEngine>;
 
+/**
+ * Mirrors an engine's final master output into a MediaStream.
+ *
+ * Real-time Web Audio is required because OfflineAudioContext has no
+ * MediaStream destination. The engine's audible destination remains connected.
+ */
+export declare function createAudioEngineMediaStream(engine: AudioEngine): AudioEngineMediaStream;
+
 /**
  * Creates a real-time visualizer that taps the host's analyzer and draws to the
  * given canvas. Enables the analyzer on the host if it is not already enabled.
@@ -2844,6 +2870,36 @@ export declare function createTextRenderable(data: TextData, options?: TextRende
  *  @returns A rendering context that can be registered with the engine. */
 export declare function createTextRenderer(surface: SurfaceContext, opts: TextRendererOptions): TextRenderer;
 
+/**
+ * Create an empty 2D texture array of `layers` same-size RGBA8 layers, ready to
+ * be filled with `uploadImageToArrayLayer()` / `loadImageToArrayLayer()`.
+ *
+ * The texture is created with `TEXTURE_BINDING | COPY_DST | RENDER_ATTACHMENT`
+ * usage — `copyExternalImageToTexture` (used by the upload helpers) requires
+ * both `COPY_DST` and `RENDER_ATTACHMENT` on the destination, and the render
+ * attachment is also what the mipmap-blit pass writes into.
+ *
+ * @param engine - Engine context.
+ * @param width - Layer width in texels (\>= 1).
+ * @param height - Layer height in texels (\>= 1).
+ * @param layers - Number of array layers (\>= 1).
+ * @param options - Sampler / format overrides.
+ */
+export declare function createTexture2DArray(engine: EngineContext, width: number, height: number, layers: number, options?: TextureArrayOptions): Texture2DArray;
+
+/**
+ * Create a 2D texture array and populate every layer from a list of image URLs
+ * — one URL per layer, in order. All images must decode to the same dimensions
+ * (the array's `width`/`height` are taken from the first). This is the
+ * highest-level, most ergonomic entry point.
+ *
+ * @param engine - Engine context.
+ * @param urls - One image URL per layer (`urls.length` \>= 1).
+ * @param options - Sampler / format overrides.
+ * @returns A promise resolving to the populated `Texture2DArray`.
+ */
+export declare function createTexture2DArrayFromUrls(engine: EngineContext, urls: readonly [string, ...string[]], options?: TextureArrayOptions): Promise<Texture2DArray>;
+
 /**
  * Create a `Texture2D` from a tightly-packed RGBA8 byte buffer.
  *
@@ -3228,6 +3284,12 @@ export declare function disposeAudioBus(bus: AudioBus): void;
  */
 export declare function disposeAudioEngine(engine: AudioEngine): void;
 
+/**
+ * Disconnects a media-stream tap and stops every track owned by its stream.
+ * Safe to call more than once.
+ */
+export declare function disposeAudioEngineMediaStream(output: AudioEngineMediaStream): void;
+
 /**
  * Stops the render loop and releases the visualizer. The underlying analyzer tap
  * stays on the host (dispose the host to release it).
@@ -4279,6 +4341,18 @@ export declare function getClosestPoint(plugin: NavigationPlugin, position: Vec3
  */
 export declare function getContainerMeshes(container: AssetContainer): Mesh[];
 
+/**
+ * Returns the borrowed depth-array texture wrapper used by a custom CSM receiver.
+ *
+ * The wrapper shares the generator's texture and comparison sampler, is cached per
+ * generator, and remains valid for the generator's lifetime. Callers must not dispose
+ * or release it independently.
+ *
+ * @param sg - A cascaded-shadow generator from {@link createCsmDirectionalShadowGenerator}.
+ * @returns A stable `Texture2D` with a 2d-array depth view.
+ */
+export declare function getCsmReceiverTexture(sg: ShadowGenerator): Texture2D;
+
 /** Returns the render-target aspect ratio adjusted for the camera's normalized viewport, or the raw ratio if none. */
 export declare function getEffectiveAspectRatio(camera: Camera | null | undefined, targetWidth: number, targetHeight: number): number;
 
@@ -4354,6 +4428,18 @@ export declare function getMasterVolume(engine: AudioEngine): number;
  *  values above as the documented set to match against. */
 export declare function getMaterialFamily(material: Material): string | undefined;
 
+/** Return caller-owned copies of the CPU geometry retained by a mesh.
+ *  Returns `null` when positions, normals, or indices are unavailable. */
+export declare function getMeshGeometry(mesh: Mesh): {
+    positions: Float32Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    uvs?: Float32Array;
+    uvs2?: Float32Array;
+    tangents?: Float32Array;
+    colors?: Float32Array;
+} | null;
+
 /** Get the current seed used by Recast's randomized queries. */
 export declare function getNavigationRandomSeed(plugin: NavigationPlugin): number;
 
@@ -5088,6 +5174,20 @@ export declare function loadGltf(engine: EngineContext, source: string | ArrayBu
  */
 export declare function loadHdrEnvironment(scene: SceneContext, url: string, options?: HdrLoadOptions): Promise<EnvironmentTextures>;
 
+/**
+ * Fetch an image from `url`, decode it to an `ImageBitmap`, and upload it into
+ * `layer` of a texture array. This is the optional URL-loading counterpart to
+ * `uploadImageToArrayLayer()`; keeping it a separate function means apps that
+ * already hold a decoded source never pull in the fetch/decode path.
+ *
+ * @param engine - Engine context.
+ * @param tex - Target texture array (from `createTexture2DArray`).
+ * @param layer - Destination layer index in `[0, tex.layers)`.
+ * @param url - Image URL to fetch and decode.
+ * @param opts - Flip-Y / premultiply overrides.
+ */
+export declare function loadImageToArrayLayer(engine: EngineContext, tex: Texture2DArray, layer: number, url: string, opts?: ArrayLayerUploadOptions): Promise<void>;
+
 /** Fetch and decode a standalone KTX2 (Basis Universal) texture from a URL into a Texture2D, transcoded to the
  *  device's best GPU-compressed format (BC7/ETC2/ASTC) so it STAYS compressed in VRAM (a few times less than the
  *  uncompressed RGBA8 `loadTexture2D` always uploads). Mirrors `loadKtxTexture2D` (KTX1) for app textures that
@@ -5571,6 +5671,10 @@ declare interface NodeEmitContext {
     readonly temp: (state: NodeBuildState, prefix?: string) => string;
     /** Cast a typed expression to a target WGSL type when the shapes differ. */
     readonly cast: (value: NodeExpr, target: NodeValueType) => NodeExpr;
+    /** Sanitize a block/input name for use as a WGSL identifier. */
+    readonly sanitize: (name: string) => string;
+    /** Map Babylon.js connection-point flags to Lite's node value types. */
+    readonly bjsTypeToNodeType: (type: number, source?: string) => NodeValueType;
     /** Access the surrounding graph (so emitters can find upstream blocks). */
     readonly graph: NodeGraph;
 
@@ -6080,7 +6184,27 @@ export declare interface PbrMaterialProps extends Material {
     /** Linear-RGB tint applied to baseColor when `unlit` is true (i.e. glTF
      *  `baseColorFactor`). When omitted or [1,1,1], no tint is applied.
      *  Only bundled/bound when the unlit extension is active. */
-    unlitColor?: [number, number, number];
    /** Optional stencil-test state baked into the main-pass pipeline. Lets this material write the stencil buffer
+    unlitColor?: [number, number, number];
+    /** When true, the material is a shadow-only receiver: the surface is invisible
+     *  except where a shadow is cast on it, where it appears in `shadowOnlyColor` (or
+     *  black when omitted). Mirrors BJS `BackgroundMaterial.shadowOnly`. Requires
+     *  `receiveShadows` on the mesh and at least one shadow-casting light in the scene.
+     *  Implies alpha-blended rendering. Only bundled/bound when at least one mesh in
+     *  the scene uses it. */
+    shadowOnly?: boolean;
+    /** Linear-RGB color shown where the shadow falls when `shadowOnly` is true.
+     *  Defaults to black (`[0, 0, 0]`). */
+    shadowOnlyColor?: [number, number, number];
+    /** Maximum opacity at the darkest part of the shadow (when `shadowOnly` is true).
+     *  Range [0, 1]. Default 1.0 (fully opaque at full shadow). Lower values produce
+     *  a lighter, more transparent shadow. Mirrors the `shadowLevel` parameter on BJS
+     *  `BackgroundMaterial.shadowOnly`. */
+    shadowOnlyOpacity?: number;
+    /** Falloff sharpness for the shadow's soft edges (when `shadowOnly` is true).
+     *  Default 1.0 (the natural ESM/PCF falloff from the shadow generator). Higher
+     *  values steepen the falloff (saturating closer to the model silhouette), giving
+     *  crisper visible edges. Mathematically: `alpha = saturate((1 - shadowFactor) * falloff) * opacity`. */
+    shadowOnlyFalloff?: number;
    /** Optional stencil-test state baked into the main-pass pipeline. Lets this material write the stencil buffer
      *  where it draws (mask) or discard where another material wrote it. Default none. See `StencilState`. */
     stencil?: StencilState;
 }
@@ -6548,9 +6672,11 @@ export declare interface PickOptions {
      *
      *  `fn shouldDiscardPick(input: PickDiscardInput) -> bool`
      *
-     *  The input exposes only generic picker data: `worldPos`, `pickId`, `thinInstanceIndex`,
-     *  `hasThinInstance`, and `instanceExtras` (the original thin-instance matrix w lanes, zero for
-     *  non-instanced meshes). Storage entries are uploaded and bound by Lite for the current pick only. */
+     *  The input exposes only generic picker data: `worldPos`, `fragmentCoord` (the selected pixel
+     *  centre in the original backing framebuffer), `pickId`, `thinInstanceIndex`,
+     *  `hasThinInstance`, and `instanceExtras` (the
+     *  original thin-instance matrix w lanes, zero for non-instanced meshes). Storage entries are
+     *  uploaded and bound by Lite for the current pick only. */
     discard?: PickDiscardRule;
     /** Dev-only diagnostics: logs the pick ray, pixel, pick id/depth and resolved mesh. */
     debugLabel?: string;
@@ -7220,9 +7346,12 @@ export declare function removeBillboardSprite(handle: BillboardSpriteHandle): vo
  */
 export declare function removeBillboardSpriteIndex(system: BillboardSpriteSystem, index: number): void;
 
-/** Remove a mesh from the scene and destroy its GPU resources.
+/** Remove an entity from the scene, undoing what `addToScene` did. Accepts the same
+ *  union as {@link addToScene}: a Mesh, light, camera, shadow generator, transform node,
+ *  or a whole AssetContainer. Safe to call more than once (idempotent).
+ *
  *  Standalone function for tree-shaking — only included when actually used. */
-export declare function removeFromScene(scene: SceneContext, mesh: Mesh): void;
+export declare function removeFromScene(scene: SceneContext, entity: Mesh | LightBase | Camera | ShadowGenerator | TransformNode | AssetContainer): void;
 
 /**
  * Remove one logical hierarchy instance with O(1) swap-remove semantics.
@@ -8164,6 +8293,18 @@ export declare function setShaderUniform(material: ShaderMaterial, name: string,
 /** Set a declared `vec3<f32>` uniform. Convenience wrapper over `setShaderUniform()`. */
 export declare function setShaderVector3(material: ShaderMaterial, name: string, value: readonly [number, number, number]): void;
 
+/**
+ * Cap the cascades a caster mesh renders into: the mesh casts only into cascade layers `0..maxCascade`
+ * (0 = the nearest). Lets a scene keep small casters out of the far cascades, where their shadows are
+ * sub-texel anyway — each excluded layer saves that caster's draw + pipeline switch per frame.
+ *
+ * Unset (the default) casts into every cascade. Pass `Infinity` to restore that.
+ * The cap is read when a generator's caster set is (re)supplied through
+ * {@link setShadowTaskCasterMeshes}; to change it for an already-registered caster, re-supply the
+ * caster list (a new array) afterwards. Non-cascaded (single-map) generators ignore the cap.
+ */
+export declare function setShadowCasterMaxCascade(mesh: Mesh, maxCascade: number): void;
+
 /** Register scene-owned shadow caster inputs for a generator. */
 export declare function setShadowTaskCasterMeshes(shadowGenerator: ShadowGenerator, casterMeshes: readonly Mesh[]): void;
 
@@ -8366,6 +8507,17 @@ export declare function setThinInstanceCullBoundsPad(mesh: Mesh, pad: number): v
  * must have completed an initial full-capacity GPU synchronization. */
 export declare function setThinInstanceDrawCount(mesh: Mesh, count: number): void;
 
+/** Pair a GPU-culled thin-instanced mesh with a lower-detail partner: when `fullMesh`'s compute cull runs,
+ * in-frustum instances closer than `options.distance` keep drawing through `fullMesh` while farther ones are
+ * compacted into a second bucket drawn by `lodMesh` instead. `lodMesh` must be a normal scene mesh sharing the
+ * same thin-instance matrix layout (it may reference the same matrices array); while paired it draws ONLY the
+ * far bucket — never its own instance count — so when culling is disabled, unavailable, or the instance count
+ * is 0, `fullMesh` falls back to drawing ALL instances and `lodMesh` draws nothing. `options.band` dithers the
+ * threshold per instance by ±band/2 via a deterministic hash of the instance index. Like
+ * `enableThinInstanceGpuCulling`, call after `setThinInstances()` and before `registerScene()`;
+ * `distance`/`band` may be re-set live by calling again with the same pair. */
+export declare function setThinInstanceLodPartner(fullMesh: Mesh, lodMesh: Mesh, options: ThinInstanceLodPartnerOptions): void;
+
 /** Update one instance's matrix. */
 export declare function setThinInstanceMatrix(mesh: Mesh, index: number, matrix: Mat4): void;
 
@@ -9793,6 +9945,15 @@ export declare interface Texture2D {
      *  in-place row flipping is impractical) remain correct. */
     invertY?: boolean;
 
+/** A 2D texture array handle. It is a `Texture2D` (so it drops straight into
+ *  `setEffectTexture` / material sampler bindings) whose `view` is created with
+ *  `dimension:"2d-array"`, plus a `layers` count. Bind it to a shader sampler
+ *  declared `viewDimension:"2d-array"` and sample it in WGSL as
+ *  `texture_2d_array<f32>`. */
+export declare interface Texture2DArray extends Texture2D {
+    layers: number;
+}
+
 /** Sampler, format, and decode options for `loadTexture2D()`. */
 export declare interface Texture2DOptions {
     /** Generate mipmaps. Default true. */
@@ -9823,6 +9984,23 @@ export declare type Texture3D = Texture2D & {
     depth: number;
 };
 
+/** Sampler and format options for `createTexture2DArray()`. */
+export declare interface TextureArrayOptions {
+    /** Generate a full mip chain for each layer on upload. Default true. */
+    mipMaps?: boolean;
+    /** Use sRGB format (rgba8unorm-srgb) so the hardware converts to linear on
+     *  sample. Use for color/albedo layers in PBR workflows. Default false. */
+    srgb?: boolean;
+    /** Address mode U. Default 'repeat'. */
+    addressModeU?: GPUAddressMode;
+    /** Address mode V. Default 'repeat'. */
+    addressModeV?: GPUAddressMode;
+    /** Min filter. Default 'linear'. */
+    minFilter?: GPUFilterMode;
+    /** Mag filter. Default 'linear'. */
+    magFilter?: GPUFilterMode;
+}
+
 /** 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
@@ -9849,6 +10027,14 @@ export declare interface ThinInstanceData {
     count: number;
    /** Optional per-instance RGBA colors (4 floats per instance). */
     colors?: Float32Array | null;
 
+/** Options for `setThinInstanceLodPartner`. */
+export declare interface ThinInstanceLodPartnerOptions {
+    /** Camera distance (world units) at which an in-frustum instance switches from `fullMesh` to the LOD partner. */
+    distance: number;
+    /** Width (world units) of a per-instance threshold dither window centered on `distance` (default 0 — hard cut). */
+    band?: number;
+}
+
 /** Tint sub-feature. Controls absorption tint color for transmittance. */
 export declare interface TintProps {
     /** Tint color (linear RGB). Default [1,1,1]. */
@@ -10201,6 +10387,22 @@ export declare function updateTextData(data: TextData, update: TextDataUpdate):
  */
 export declare function updateTexture2DFromPixels(engine: EngineContext, tex: Texture2D, data: Uint8Array, x?: number, y?: number, width?: number, height?: number): void;
 
+/**
+ * Fill one layer of a texture array from an already-decoded external image
+ * source — an `ImageBitmap`, `ImageData`, canvas (`HTMLCanvasElement` /
+ * `OffscreenCanvas`), `HTMLImageElement`, `HTMLVideoElement`, or `VideoFrame`.
+ * All of these are accepted directly by WebGPU's `copyExternalImageToTexture`,
+ * so this is a single GPU copy with no per-source-type branching. If the array
+ * was created with mipmaps, the layer's mip chain is regenerated after upload.
+ *
+ * @param engine - Engine context.
+ * @param tex - Target texture array (from `createTexture2DArray`).
+ * @param layer - Destination layer index in `[0, tex.layers)`.
+ * @param source - Any WebGPU external-image source sized `tex.width`×`tex.height`.
+ * @param opts - Flip-Y / premultiply overrides.
+ */
+export declare function uploadImageToArrayLayer(engine: EngineContext, tex: Texture2DArray, layer: number, source: GPUCopyExternalImageSource, opts?: ArrayLayerUploadOptions): void;
+
 /** UtilityLayer handle. The `scene` field is a regular `SceneContext` — pass it
  *  to gizmo factories so their meshes are added there instead of the main
  *  scene. */

package/lib/asset-container.js.map

@@ -1 +1 @@
-{"version":3,"file":"asset-container.js","sources":["../../src/asset-container.ts"],"sourcesContent":["import type { SceneNode } from \"./scene/scene-node.js\";\nimport type { LightBase } from \"./light/types.js\";\nimport type { AnimationGroup } from \"./animation/animation-group.js\";\nimport type { MaterialVariantData } from \"./loader-gltf/material-variants.js\";\nimport type { Mesh } from \"./mesh/mesh.js\";\nimport type { Skeleton } from \"./skeleton/bone-control.js\";\nimport type { SceneContext } from \"./scene/scene-core.js\";\n\n/**\n * Result returned by loadGltf / loadBabylon.\n * Pass directly to addToScene() — it handles all fields automatically.\n *\n * - glTF: entities = [root TransformNode], animationGroups = loaded clips\n * - .babylon: entities = root SceneNodes (Mesh/TransformNode) + LightBase, clearColor from file\n */\nexport interface AssetContainer {\n    /** Scene entities. glTF: [root TransformNode]. .babylon: root nodes + lights. */\n    entities: Array<SceneNode | LightBase>;\n    /** Animation groups from the file. addToScene() registers them with the scene-owned AnimationManager by default. */\n    animationGroups?: AnimationGroup[];\n    /** Scene background color declared in the file. addToScene() applies it to scene.clearColor. */\n    clearColor?: GPUColorDict;\n    /** Camera parsed from the file. addToScene() sets it as scene.camera when present. */\n    camera?: import(\"./camera/camera.js\").Camera;\n    /** KHR_materials_variants data. Use selectVariant() / getVariantNames() to interact. */\n    materialVariants?: MaterialVariantData;\n    /** KHR_xmp_json_ld metadata. `packets` are the JSON-LD packets declared at the\n     *  document level; `assetPacket` is the packet referenced by `asset` (if any). */\n    xmpMetadata?: { packets: unknown[]; assetPacket?: unknown };\n    /** Bone-control handles, one per glTF skin. Present only when\n     *  `enableBoneControl()` was called before loading; otherwise `undefined`.\n     *  Drive bones via `getBoneByName()` + the `setBone*` functions. */\n    skeletons?: Skeleton[];\n    /** Deferred scene-wiring hook contributed by a loader feature that needs the\n     *  target `SceneContext` (which the loader itself never sees). `addToScene()`\n     *  invokes it once, synchronously, while processing the container. Used by\n     *  `EXT_lights_image_based` to install its image-based-light environment\n     *  (spherical harmonics + specular cubemap) onto the scene. Lazy features own\n     *  the closure so the core loader/scene stay feature-agnostic.\n     *  @internal */\n    _sceneSetup?: (scene: SceneContext) => void;\n}\n\n/**\n * Flatten a loaded asset container's entity tree to its renderable `Mesh` nodes\n * (those carrying GPU geometry), matching the flat `meshes` array Babylon.js\n * loaders return. Useful for camera-framing and per-mesh inspection after a load.\n *\n * Tree-shakeable: only callers that import this pull it into their bundle.\n */\nexport function getContainerMeshes(container: AssetContainer): Mesh[] {\n    const meshes: Mesh[] = [];\n    const seen = new Set<unknown>();\n    const visit = (node: SceneNode): void => {\n        if (seen.has(node)) {\n            return;\n        }\n        seen.add(node);\n        if ((node as unknown as { _gpu?: unknown })._gpu) {\n            meshes.push(node as unknown as Mesh);\n        }\n        const children = (node as unknown as { children?: SceneNode[] }).children;\n        if (children) {\n            for (const child of children) {\n                visit(child);\n            }\n        }\n    };\n    for (const entity of container.entities) {\n        // Lights have no scene-graph children to walk; skip them.\n        if (\"lightType\" in (entity as object)) {\n            continue;\n        }\n        visit(entity as SceneNode);\n    }\n    return meshes;\n}\n"],"names":[],"mappings":"AAkDO,SAAS,mBAAmB,SAAA,EAAmC;AAClE,EAAA,MAAM,SAAiB,EAAC;AACxB,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAa;AAC9B,EAAA,MAAM,KAAA,GAAQ,CAAC,IAAA,KAA0B;AACrC,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,IAAI,CAAA,EAAG;AAChB,MAAA;AAAA,IACJ;AACA,IAAA,IAAA,CAAK,IAAI,IAAI,CAAA;AACb,IAAA,IAAK,KAAuC,IAAA,EAAM;AAC9C,MAAA,MAAA,CAAO,KAAK,IAAuB,CAAA;AAAA,IACvC;AACA,IAAA,MAAM,WAAY,IAAA,CAA+C,QAAA;AACjE,IAAA,IAAI,QAAA,EAAU;AACV,MAAA,KAAA,MAAW,SAAS,QAAA,EAAU;AAC1B,QAAA,KAAA,CAAM,KAAK,CAAA;AAAA,MACf;AAAA,IACJ;AAAA,EACJ,CAAA;AACA,EAAA,KAAA,MAAW,MAAA,IAAU,UAAU,QAAA,EAAU;AAErC,IAAA,IAAI,eAAgB,MAAA,EAAmB;AACnC,MAAA;AAAA,IACJ;AACA,IAAA,KAAA,CAAM,MAAmB,CAAA;AAAA,EAC7B;AACA,EAAA,OAAO,MAAA;AACX;;;;"}
+{"version":3,"file":"asset-container.js","sources":["../../src/asset-container.ts"],"sourcesContent":["import type { SceneNode } from \"./scene/scene-node.js\";\nimport type { LightBase } from \"./light/types.js\";\nimport type { AnimationGroup } from \"./animation/animation-group.js\";\nimport type { MaterialVariantData } from \"./loader-gltf/material-variants.js\";\nimport type { Mesh } from \"./mesh/mesh.js\";\nimport type { Skeleton } from \"./skeleton/bone-control.js\";\nimport type { SceneContext } from \"./scene/scene-core.js\";\n\n/**\n * Result returned by loadGltf / loadBabylon.\n * Pass directly to addToScene() — it handles all fields automatically.\n *\n * - glTF: entities = [root TransformNode], animationGroups = loaded clips\n * - .babylon: entities = root SceneNodes (Mesh/TransformNode) + LightBase, clearColor from file\n */\nexport interface AssetContainer {\n    /** Scene entities. glTF: [root TransformNode]. .babylon: root nodes + lights. */\n    entities: Array<SceneNode | LightBase>;\n    /** Animation groups from the file. addToScene() registers them with the scene-owned AnimationManager by default. */\n    animationGroups?: AnimationGroup[];\n    /** Scene background color declared in the file. addToScene() applies it to scene.clearColor. */\n    clearColor?: GPUColorDict;\n    /** Camera parsed from the file. addToScene() sets it as scene.camera when present. */\n    camera?: import(\"./camera/camera.js\").Camera;\n    /** KHR_materials_variants data. Use selectVariant() / getVariantNames() to interact. */\n    materialVariants?: MaterialVariantData;\n    /** KHR_xmp_json_ld metadata. `packets` are the JSON-LD packets declared at the\n     *  document level; `assetPacket` is the packet referenced by `asset` (if any). */\n    xmpMetadata?: { packets: unknown[]; assetPacket?: unknown };\n    /** Bone-control handles, one per glTF skin. Present only when\n     *  `enableBoneControl()` was called before loading; otherwise `undefined`.\n     *  Drive bones via `getBoneByName()` + the `setBone*` functions. */\n    skeletons?: Skeleton[];\n    /** @internal Per-frame animation tick closure pushed onto `scene._beforeRender` by\n     *  `addToScene(scene, container)`. Stored so `removeFromScene(scene, container)` can\n     *  splice it back out, keeping the two calls symmetric. */\n    _beforeRenderHook?: (deltaMs: number) => void;\n    /** Deferred scene-wiring hook contributed by a loader feature that needs the\n     *  target `SceneContext` (which the loader itself never sees). `addToScene()`\n     *  invokes it once, synchronously, while processing the container. Used by\n     *  `EXT_lights_image_based` to install its image-based-light environment\n     *  (spherical harmonics + specular cubemap) onto the scene. Lazy features own\n     *  the closure so the core loader/scene stay feature-agnostic.\n     *  @internal */\n    _sceneSetup?: (scene: SceneContext) => void;\n}\n\n/**\n * Flatten a loaded asset container's entity tree to its renderable `Mesh` nodes\n * (those carrying GPU geometry), matching the flat `meshes` array Babylon.js\n * loaders return. Useful for camera-framing and per-mesh inspection after a load.\n *\n * Tree-shakeable: only callers that import this pull it into their bundle.\n */\nexport function getContainerMeshes(container: AssetContainer): Mesh[] {\n    const meshes: Mesh[] = [];\n    const seen = new Set<unknown>();\n    const visit = (node: SceneNode): void => {\n        if (seen.has(node)) {\n            return;\n        }\n        seen.add(node);\n        if ((node as unknown as { _gpu?: unknown })._gpu) {\n            meshes.push(node as unknown as Mesh);\n        }\n        const children = (node as unknown as { children?: SceneNode[] }).children;\n        if (children) {\n            for (const child of children) {\n                visit(child);\n            }\n        }\n    };\n    for (const entity of container.entities) {\n        // Lights have no scene-graph children to walk; skip them.\n        if (\"lightType\" in (entity as object)) {\n            continue;\n        }\n        visit(entity as SceneNode);\n    }\n    return meshes;\n}\n"],"names":[],"mappings":"AAsDO,SAAS,mBAAmB,SAAA,EAAmC;AAClE,EAAA,MAAM,SAAiB,EAAC;AACxB,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAa;AAC9B,EAAA,MAAM,KAAA,GAAQ,CAAC,IAAA,KAA0B;AACrC,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,IAAI,CAAA,EAAG;AAChB,MAAA;AAAA,IACJ;AACA,IAAA,IAAA,CAAK,IAAI,IAAI,CAAA;AACb,IAAA,IAAK,KAAuC,IAAA,EAAM;AAC9C,MAAA,MAAA,CAAO,KAAK,IAAuB,CAAA;AAAA,IACvC;AACA,IAAA,MAAM,WAAY,IAAA,CAA+C,QAAA;AACjE,IAAA,IAAI,QAAA,EAAU;AACV,MAAA,KAAA,MAAW,SAAS,QAAA,EAAU;AAC1B,QAAA,KAAA,CAAM,KAAK,CAAA;AAAA,MACf;AAAA,IACJ;AAAA,EACJ,CAAA;AACA,EAAA,KAAA,MAAW,MAAA,IAAU,UAAU,QAAA,EAAU;AAErC,IAAA,IAAI,eAAgB,MAAA,EAAmB;AACnC,MAAA;AAAA,IACJ;AACA,IAAA,KAAA,CAAM,MAAmB,CAAA;AAAA,EAC7B;AACA,EAAA,OAAO,MAAA;AACX;;;;"}

package/lib/audio/index.js

@@ -1,4 +1,5 @@
 export { createAudioEngineAsync, disposeAudioEngine, getMasterVolume, setMasterVolume, unlockAudioEngineAsync } from './audio-engine.js';
+export { createAudioEngineMediaStream, disposeAudioEngineMediaStream } from './media-stream-output.js';
 export { SoundState, createSoundAsync, disposeSound, pauseSound, playSound, resumeSound, setSoundVolume, stopSound } from './static-sound.js';
 export { createStreamingSoundAsync, disposeStreamingSound, pauseStreamingSound, playStreamingSound, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, resumeStreamingSound, setStreamingSoundVolume, stopStreamingSound } from './streaming-sound.js';
 export { createAudioBusAsync, disposeAudioBus, setBusVolume } from './audio-bus.js';

package/lib/audio/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;"}

package/lib/audio/media-stream-output.js

@@ -0,0 +1,44 @@
+function createAudioEngineMediaStream(engine) {
+  const context = engine._ctx;
+  if (engine._isOffline || typeof context.createMediaStreamDestination !== "function") {
+    throw new Error("Audio engine media streams require a real-time AudioContext.");
+  }
+  const source = engine._mainOut._gain;
+  const destination = context.createMediaStreamDestination();
+  source.connect(destination);
+  const output = {
+    stream: destination.stream,
+    _engine: engine,
+    _source: source,
+    _destination: destination,
+    _engineDisposer: () => {
+      output._registered = false;
+      disposeAudioEngineMediaStream(output);
+    },
+    _registered: true,
+    _disposed: false,
+    _dispose: () => disposeAudioEngineMediaStream(output)
+  };
+  engine._disposers.push(output._engineDisposer);
+  return output;
+}
+function disposeAudioEngineMediaStream(output) {
+  if (output._disposed) {
+    return;
+  }
+  output._disposed = true;
+  if (output._registered) {
+    output._registered = false;
+    const disposerIndex = output._engine._disposers.indexOf(output._engineDisposer);
+    if (disposerIndex !== -1) {
+      output._engine._disposers.splice(disposerIndex, 1);
+    }
+  }
+  output._source.disconnect(output._destination);
+  for (const track of output.stream.getTracks()) {
+    track.stop();
+  }
+}
+
+export { createAudioEngineMediaStream, disposeAudioEngineMediaStream };
+//# sourceMappingURL=media-stream-output.js.map

package/lib/audio/media-stream-output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-stream-output.js","sources":["../../../src/audio/media-stream-output.ts"],"sourcesContent":["/**\n * Media-stream output — opt-in tap of the audio engine's final master mix.\n *\n * The tap mirrors the post-master signal into a MediaStream without changing\n * the normal speaker output. Consumers can use that stream for recording,\n * WebRTC, or other browser media pipelines, then dispose the tap independently.\n */\n\nimport type { AudioEngine } from \"./audio-engine.js\";\n\n/** Pure-state handle for a MediaStream carrying the audio engine's final master mix. */\nexport interface AudioEngineMediaStream {\n    /** One live audio track containing the post-master engine output. */\n    readonly stream: MediaStream;\n    /** @internal */ readonly _engine: AudioEngine;\n    /** @internal */ readonly _source: GainNode;\n    /** @internal */ readonly _destination: MediaStreamAudioDestinationNode;\n    /** @internal */ readonly _engineDisposer: () => void;\n    /** @internal */ _registered: boolean;\n    /** @internal */ _disposed: boolean;\n    /** @internal */ _dispose(): void;\n}\n\n/**\n * Mirrors an engine's final master output into a MediaStream.\n *\n * Real-time Web Audio is required because OfflineAudioContext has no\n * MediaStream destination. The engine's audible destination remains connected.\n */\nexport function createAudioEngineMediaStream(engine: AudioEngine): AudioEngineMediaStream {\n    const context = engine._ctx;\n    if (engine._isOffline || typeof (context as AudioContext).createMediaStreamDestination !== \"function\") {\n        throw new Error(\"Audio engine media streams require a real-time AudioContext.\");\n    }\n\n    const source = engine._mainOut._gain;\n    const destination = (context as AudioContext).createMediaStreamDestination();\n    source.connect(destination);\n\n    const output: AudioEngineMediaStream = {\n        stream: destination.stream,\n        _engine: engine,\n        _source: source,\n        _destination: destination,\n        _engineDisposer: () => {\n            output._registered = false;\n            disposeAudioEngineMediaStream(output);\n        },\n        _registered: true,\n        _disposed: false,\n        _dispose: () => disposeAudioEngineMediaStream(output),\n    };\n\n    engine._disposers.push(output._engineDisposer);\n    return output;\n}\n\n/**\n * Disconnects a media-stream tap and stops every track owned by its stream.\n * Safe to call more than once.\n */\nexport function disposeAudioEngineMediaStream(output: AudioEngineMediaStream): void {\n    if (output._disposed) {\n        return;\n    }\n\n    output._disposed = true;\n    if (output._registered) {\n        output._registered = false;\n        const disposerIndex = output._engine._disposers.indexOf(output._engineDisposer);\n        if (disposerIndex !== -1) {\n            output._engine._disposers.splice(disposerIndex, 1);\n        }\n    }\n    output._source.disconnect(output._destination);\n    for (const track of output.stream.getTracks()) {\n        track.stop();\n    }\n}\n"],"names":[],"mappings":"AA6BO,SAAS,6BAA6B,MAAA,EAA6C;AACtF,EAAA,MAAM,UAAU,MAAA,CAAO,IAAA;AACvB,EAAA,IAAI,MAAA,CAAO,UAAA,IAAc,OAAQ,OAAA,CAAyB,iCAAiC,UAAA,EAAY;AACnG,IAAA,MAAM,IAAI,MAAM,8DAA8D,CAAA;AAAA,EAClF;AAEA,EAAA,MAAM,MAAA,GAAS,OAAO,QAAA,CAAS,KAAA;AAC/B,EAAA,MAAM,WAAA,GAAe,QAAyB,4BAAA,EAA6B;AAC3E,EAAA,MAAA,CAAO,QAAQ,WAAW,CAAA;AAE1B,EAAA,MAAM,MAAA,GAAiC;AAAA,IACnC,QAAQ,WAAA,CAAY,MAAA;AAAA,IACpB,OAAA,EAAS,MAAA;AAAA,IACT,OAAA,EAAS,MAAA;AAAA,IACT,YAAA,EAAc,WAAA;AAAA,IACd,iBAAiB,MAAM;AACnB,MAAA,MAAA,CAAO,WAAA,GAAc,KAAA;AACrB,MAAA,6BAAA,CAA8B,MAAM,CAAA;AAAA,IACxC,CAAA;AAAA,IACA,WAAA,EAAa,IAAA;AAAA,IACb,SAAA,EAAW,KAAA;AAAA,IACX,QAAA,EAAU,MAAM,6BAAA,CAA8B,MAAM;AAAA,GACxD;AAEA,EAAA,MAAA,CAAO,UAAA,CAAW,IAAA,CAAK,MAAA,CAAO,eAAe,CAAA;AAC7C,EAAA,OAAO,MAAA;AACX;AAMO,SAAS,8BAA8B,MAAA,EAAsC;AAChF,EAAA,IAAI,OAAO,SAAA,EAAW;AAClB,IAAA;AAAA,EACJ;AAEA,EAAA,MAAA,CAAO,SAAA,GAAY,IAAA;AACnB,EAAA,IAAI,OAAO,WAAA,EAAa;AACpB,IAAA,MAAA,CAAO,WAAA,GAAc,KAAA;AACrB,IAAA,MAAM,gBAAgB,MAAA,CAAO,OAAA,CAAQ,UAAA,CAAW,OAAA,CAAQ,OAAO,eAAe,CAAA;AAC9E,IAAA,IAAI,kBAAkB,EAAA,EAAI;AACtB,MAAA,MAAA,CAAO,OAAA,CAAQ,UAAA,CAAW,MAAA,CAAO,aAAA,EAAe,CAAC,CAAA;AAAA,IACrD;AAAA,EACJ;AACA,EAAA,MAAA,CAAO,OAAA,CAAQ,UAAA,CAAW,MAAA,CAAO,YAAY,CAAA;AAC7C,EAAA,KAAA,MAAW,KAAA,IAAS,MAAA,CAAO,MAAA,CAAO,SAAA,EAAU,EAAG;AAC3C,IAAA,KAAA,CAAM,IAAA,EAAK;AAAA,EACf;AACJ;;;;"}

package/lib/engine/engine.js

@@ -2,7 +2,7 @@ import { _setHpmAllocator } from '../math/_matrix-allocator.js';
 import { isDomCanvas, _buildSurface, resizeSurface, _refreshScRT, setSurfaceSize } from './surface.js';
 import { disposeGpuResourceRetirements } from './gpu-resource-retirement.js';
 
-const VERSION = /* @__PURE__ */ (() => "1.11.0" )();
+const VERSION = /* @__PURE__ */ (() => "1.13.0" )();
 let _vis = 0;
 function bumpVisibilityEpoch() {
   _vis = _vis + 1 | 0;

package/lib/frame-graph/render-task.js

@@ -392,5 +392,5 @@ function drawList(enc, list, engine) {
   return draws;
 }
 
-export { _writePassSceneUBO, createRenderTask, removeMeshFromTask };
+export { _writePassSceneUBO, createRenderTask, drawList, removeMeshFromTask };
 //# sourceMappingURL=render-task.js.map