@babylonjs/lite-compat 1.33.0-preview → 1.35.0-preview
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +6 -6
- package/index.d.ts +308 -25
- package/index.js +410 -54
- package/index.js.map +1 -1
- package/{meshes-BLcUDvXV.js → meshes-zeNif9yt.js} +96 -2
- package/meshes-zeNif9yt.js.map +1 -0
- package/navigation.d.ts +50 -7
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-BLcUDvXV.js.map +0 -1
package/README.md
CHANGED
|
@@ -117,18 +117,18 @@ overloads within a supported area may still be absent.
|
|
|
117
117
|
|
|
118
118
|
| Feature area | Status | Notes |
|
|
119
119
|
| ----------------------------------------------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
120
|
-
| Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | `Angle` / `Curve3` / `Path3D` partial
|
|
120
|
+
| Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | Includes handedness-correct `LookDirection` matrices/quaternions; `Angle` / `Curve3` / `Path3D` partial |
|
|
121
121
|
| Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `currentSampleCount` reports the active surface's MSAA count; `beginFrame`/`endFrame`, occlusion queries, engine-wide alpha-to-coverage, and manual `scene.render()` unsupported |
|
|
122
122
|
| Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported |
|
|
123
|
-
| Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` forwards to Lite's CPU triangle picker with thin-instance, predicate, normal, and UV detail;
|
|
123
|
+
| Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | `Node.accessibilityTag` forwards description, role, and ARIA metadata to Lite (DOM event handlers remain unsupported); sync `scene.pick` forwards to Lite's CPU triangle picker with thin-instance, predicate, normal, and UV detail; `scene.meshes` + `getMeshBy*`/`getNodeBy*` enumerate every mesh via a canonical wrapper registry; exposure/contrast/tone mapping are forwarded, while white balance and fluid rendering throw because Lite lacks their cross-cutting shader/render-pass subsystems |
|
|
124
124
|
| Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | arc controls include pointer, wheel, touch, and BJS-default Arrow-key input; orthographic bounds and projection-mode switching forward to Lite; fully unconfigured orthographic extents use Lite's `halfHeight` + aspect-ratio derivation rather than Babylon.js render dimensions; XR / device-orientation / stereoscopic rigs unsupported |
|
|
125
|
-
| Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported
|
|
125
|
+
| Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters unshadowed point lights before engine start (⚡ partial); clustered spot lights and `RectAreaLight` unsupported |
|
|
126
126
|
| Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
|
|
127
127
|
| Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `CreateDashedLines` supports uniform-color dashed line lists; mesh-blending tag helpers and validated mesh metadata forward to native Lite; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; polygon/extruded-polygon, decal/text/tiled builders, `GreasedLine*` (thick lines), `InstancedMesh`, LOD/edges/outline, and hardware instances unsupported |
|
|
128
128
|
| CSG / CSG2 | ✅ | over Lite boolean ops |
|
|
129
129
|
| Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
|
|
130
|
-
| Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while `DitheredTileFadeMaterialPlugin`,
|
|
131
|
-
| Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `
|
|
130
|
+
| Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while Gaussian-splat visualization plugins, `DitheredTileFadeMaterialPlugin`, BJS-preprocessed `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
|
|
131
|
+
| Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `ExternalTexture`, cube textures) | ⚡ | `ExternalTexture` wraps Lite's native external-video texture; `HDRCubeTexture` routes to native `loadHdrEnvironment`; `RawTexture2DArray` supports raw bytes, image sources/URLs, and single-file KTX2 arrays; `RawTexture3D` supports base-level RGBA8 volumes but not mip generation; `HtmlTexture` forwards native Lite DOM capture/update; `RenderTargetTexture` / `MirrorTexture` unsupported |
|
|
132
132
|
| Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported; root-motion analysis/controller APIs throw |
|
|
133
133
|
| Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets |
|
|
134
134
|
| Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
|
|
@@ -149,7 +149,7 @@ overloads within a supported area may still be absent.
|
|
|
149
149
|
| OpenPBR glTF material adapter | ❌ | exported at root and under `GLTF2`; throws because Lite has no OpenPBR material subsystem |
|
|
150
150
|
| OpenUSD (`USDFileLoader`) | ⚡ | delegates binary import, virtual files, callbacks, diagnostics, asset containers, and disposal to Lite; all four custom runtime assets must share one directory |
|
|
151
151
|
| `SceneLoader` (`ImportMeshAsync` / `AppendAsync` / `LoadAssetContainerAsync`), `AssetsManager` | ⚡ | `AssetContainer` partial |
|
|
152
|
-
| Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ |
|
|
152
|
+
| Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | `GaussianSplattingMesh` wraps eager Lite loaders; BJS `GaussianSplattingStream` resolves to a named stub because Lite's URL-only streamer has different budget, transform, cancellation, and compound-hosting semantics |
|
|
153
153
|
| `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
|
|
154
154
|
|
|
155
155
|
### `@babylonjs/addons` · `@recast-navigation/*`
|
package/index.d.ts
CHANGED
|
@@ -132,11 +132,11 @@ export declare abstract class AbstractEngine {
|
|
|
132
132
|
*/
|
|
133
133
|
useReverseDepthBuffer: boolean;
|
|
134
134
|
/** Babylon.js `engine.onResizeObservable` — fires after `resize()` / `setSize()`. */
|
|
135
|
-
readonly onResizeObservable: Observable<AbstractEngine>;
|
|
136
135
|
constructor(canvas: RenderCanvas, options?: ({
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
136
|
+
readonly onResizeObservable: Observable<AbstractEngine>;
|
|
137
|
+
/** Babylon.js context-loss signal, forwarded from Lite's device-loss subscription. */
|
|
138
|
+
readonly onContextLostObservable: Observable<AbstractEngine>;
|
|
139
|
+
/** Babylon.js context-restored signal. Lite does not expose a completed-recovery event, so this remains shape-only. */
|
|
140
|
+
readonly onContextRestoredObservable: Observable<AbstractEngine>;
|
|
141
141
|
constructor(canvas: RenderCanvas, options?: WebGPUEngineOptions | boolean);
|
|
142
142
|
/** Acquire the GPU device and build the Lite engine context. */
|
|
143
143
|
initAsync(): Promise<void>;
|
|
144
144
|
getRenderingCanvas(): RenderCanvas;
|
|
@@ -532,6 +532,10 @@ export declare class AbstractStereoAudio {
|
|
|
532
532
|
set pan(value: number);
|
|
533
533
|
}
|
|
534
534
|
|
|
535
|
+
declare type AccessibilityAria = "aria-autocomplete" | "aria-checked" | "aria-disabled" | "aria-errormessage" | "aria-expanded" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-label" | "aria-level" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-placeholder" | "aria-pressed" | "aria-readonly" | "aria-required" | "aria-selected" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "aria-busy" | "aria-live" | "aria-relevant" | "aria-atomic" | "aria-dropeffect" | "aria-grabbed" | "aria-activedescendant" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-describedby" | "aria-description" | "aria-details" | "aria-flowto" | "aria-labelledby" | "aria-owns" | "aria-posinset" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-setsize";
|
|
536
|
+
|
|
537
|
+
declare type AccessibilityRole = "toolbar" | "tooltip" | "feed" | "math" | "presentation" | "none" | "note" | "application" | "article" | "cell" | "columnheader" | "definition" | "directory" | "document" | "figure" | "group" | "heading" | "img" | "list" | "listitem" | "meter" | "row" | "rowgroup" | "rowheader" | "separator" | "table" | "term" | "scrollbar" | "searchbox" | "slider" | "spinbutton" | "switch" | "tab" | "tabpanel" | "treeitem" | "combobox" | "menu" | "menubar" | "tablist" | "tree" | "treegrid" | "banner" | "complementary" | "contentinfo" | "form" | "main" | "navigation" | "region" | "search" | "alert" | "log" | "marquee" | "status" | "timer" | "alertdialog" | "dialog";
|
|
538
|
+
|
|
535
539
|
/** Base class for actions. `execute` is implemented by subclasses. */
|
|
536
540
|
export declare abstract class Action {
|
|
537
541
|
trigger: number;
|
|
@@ -595,11 +599,9 @@ export declare const ActionManagerTriggers: {
|
|
|
595
599
|
readonly OnEveryFrameTrigger: 14;
|
|
596
600
|
};
|
|
597
601
|
|
|
598
|
-
|
|
599
|
-
export declare function AddGaussianSplattingStreamPart(..._args: unknown[]): never;
|
|
602
|
+
export declare function AddGaussianSplattingStreamPart(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): never;
|
|
600
603
|
|
|
601
|
-
|
|
602
|
-
export declare function AddGaussianSplattingStreamPartAsync(..._args: unknown[]): never;
|
|
604
|
+
export declare function AddGaussianSplattingStreamPartAsync(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): Promise<GaussianSplattingPartProxyMesh>;
|
|
603
605
|
|
|
604
606
|
export declare class AmmoJSPlugin {
|
|
605
607
|
constructor();
|
|
@@ -1314,15 +1316,14 @@ export declare class CircleEase extends EasingFunction {
|
|
|
1314
1316
|
export declare class ClusteredLightContainer extends Light {
|
|
1315
1317
|
private _maxRange;
|
|
1316
1318
|
private _selfIntensity;
|
|
1317
1319
|
/**
|
|
1318
|
-
* True if
|
|
1319
|
-
* clusters point lights only.
|
|
1320
|
+
* True if this point light can be represented by Lite's clustered payload.
|
|
1320
1321
|
*/
|
|
1321
1322
|
static IsLightSupported(light: Light): boolean;
|
|
1322
1323
|
/**
|
|
1323
1324
|
* Creates a new clustered light container.
|
|
1324
1325
|
*
|
|
1325
1326
|
* @param name - The container's node name.
|
|
1326
|
-
* @param lights - Initial lights to cluster
|
|
1327
|
+
* @param lights - Initial point lights to cluster.
|
|
1327
1328
|
* @param scene - Owning scene; when supplied the container is registered and
|
|
1328
1329
|
* built into the Lite scene at engine start.
|
|
1329
1330
|
*/
|
|
@@ -1350,7 +1351,7 @@ export declare class ClusteredLightContainer extends Light {
|
|
|
1350
1351
|
private _maxRan
|
|
1351
1352
|
*/
|
|
1352
1353
|
get maxRange(): number;
|
|
1353
1354
|
set maxRange(value: number);
|
|
1354
|
-
/** Babylon.js `container.addLight(light)`.
|
|
1355
|
+
/** Babylon.js `container.addLight(light)`. */
|
|
1355
1356
|
addLight(light: Light): void;
|
|
1356
1357
|
/**
|
|
1357
1358
|
* Babylon.js `container.removeLight(light)`. Returns the index the light held
|
|
@@ -1910,10 +1911,57 @@ export declare class EdgesRenderer {
|
|
|
1910
1911
|
constructor();
|
|
1911
1912
|
}
|
|
1912
1913
|
|
|
1914
|
+
export declare class Effect {
|
|
1915
|
+
constructor();
|
|
1916
|
+
isReady(): never;
|
|
1917
|
+
getEngine(): AbstractEngine;
|
|
1918
|
+
getCompilationError(): string;
|
|
1919
|
+
setTexture(_channel: string, _texture: BaseTexture): never;
|
|
1920
|
+
setFloat(_uniformName: string, _value: number): never;
|
|
1921
|
+
}
|
|
1922
|
+
|
|
1913
1923
|
export declare class EffectLayer {
|
|
1914
1924
|
constructor();
|
|
1915
1925
|
}
|
|
1916
1926
|
|
|
1927
|
+
export declare class EffectWrapper {
|
|
1928
|
+
static ForceGLSL: boolean;
|
|
1929
|
+
static RegisterShaderCodeProcessing(_effectWrapperName: string | null, _customShaderCodeProcessing?: EffectWrapperCustomShaderCodeProcessing): never;
|
|
1930
|
+
constructor(_options: EffectWrapperCreationOptions);
|
|
1931
|
+
}
|
|
1932
|
+
|
|
1933
|
+
export declare interface EffectWrapperCreationOptions {
|
|
1934
|
+
engine?: AbstractEngine;
|
|
1935
|
+
fragmentShader?: string;
|
|
1936
|
+
useShaderStore?: boolean;
|
|
1937
|
+
vertexShader?: string;
|
|
1938
|
+
vertexUrl?: string;
|
|
1939
|
+
attributeNames?: string[];
|
|
1940
|
+
uniformNames?: string[];
|
|
1941
|
+
uniforms?: string[] | null;
|
|
1942
|
+
samplerNames?: string[];
|
|
1943
|
+
samplers?: string[] | null;
|
|
1944
|
+
uniformBuffers?: string[] | null;
|
|
1945
|
+
defines?: string | string[] | null;
|
|
1946
|
+
indexParameters?: any;
|
|
1947
|
+
blockCompilation?: boolean;
|
|
1948
|
+
onCompiled?: ((effect: Effect) => void) | null;
|
|
1949
|
+
onError?: (effect: Effect, errors: string) => void;
|
|
1950
|
+
name?: string;
|
|
1951
|
+
shaderLanguage?: ShaderLanguage;
|
|
1952
|
+
extraInitializations?: (useWebGPU: boolean, list: Promise<any>[]) => void;
|
|
1953
|
+
extraInitializationsAsync?: () => Promise<void>;
|
|
1954
|
+
useAsPostProcess?: boolean;
|
|
1955
|
+
allowEmptySourceTexture?: boolean;
|
|
1956
|
+
}
|
|
1957
|
+
|
|
1958
|
+
export declare type EffectWrapperCustomShaderCodeProcessing = {
|
|
1959
|
+
processCodeAfterIncludes?: (postProcessName: string, shaderType: string, code: string) => string;
|
|
1960
|
+
processFinalCode?: (postProcessName: string, shaderType: string, code: string) => string;
|
|
1961
|
+
defineCustomBindings?: (postProcessName: string, defines: string | null, uniforms: string[], samplers: string[]) => string | null;
|
|
1962
|
+
bindCustomBindings?: (postProcessName: string, effect: Effect) => void;
|
|
1963
|
+
};
|
|
1964
|
+
|
|
1917
1965
|
export declare class ElasticEase extends EasingFunction {
|
|
1918
1966
|
oscillations: number;
|
|
1919
1967
|
springiness: number;
|
|
@@ -1946,6 +1994,20 @@ export declare class ExponentialEase extends EasingFunction {
|
|
|
1946
1994
|
easeInCore(gradient: number): number;
|
|
1947
1995
|
}
|
|
1948
1996
|
|
|
1997
|
+
/** Babylon.js `ExternalTexture` over Lite's caller-owned video wrapper. */
|
|
1998
|
+
export declare class ExternalTexture {
|
|
1999
|
+
private readonly _video;
|
|
1949
2000
|
useMipMaps: boolean;
|
|
2001
|
+
readonly type = 16;
|
|
2002
|
+
readonly format = 4294967295;
|
|
2003
|
+
readonly uniqueId: number;
|
|
2004
|
+
static IsExternalTexture(texture: unknown): texture is ExternalTexture;
|
|
2005
|
+
constructor(_video: HTMLVideoElement);
|
|
2006
|
+
getClassName(): string;
|
|
2007
|
+
get underlyingResource(): HTMLVideoElement;
|
|
2008
|
+
isReady(): boolean;
|
|
2009
|
+
dispose(): void;
|
|
2010
|
+
}
|
|
2011
|
+
|
|
1950
2012
|
/** Babylon.js `ExtrudePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.ExtrudePolygon`). */
|
|
1951
2013
|
export declare function ExtrudePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
|
|
1952
2014
|
|
|
@@ -2141,6 +2203,11 @@ export declare class FrameGraphMeshBlendingTask {
|
|
|
2141
2203
|
constructor(..._args: unknown[]);
|
|
2142
2204
|
}
|
|
2143
2205
|
|
|
2206
|
+
/** Babylon.js 9.29 frame-graph min/max reduction task. */
|
|
2207
|
+
export declare class FrameGraphMinMaxReducerTask {
|
|
2208
|
+
constructor(..._args: unknown[]);
|
|
2209
|
+
}
|
|
2210
|
+
|
|
2144
2211
|
/** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
|
|
2145
2212
|
export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
|
|
2146
2213
|
readonly name = "Framing";
|
|
@@ -2177,6 +2244,19 @@ export declare class GamepadCamera extends UniversalCamera {
|
|
|
2177
2244
|
getClassName(): string;
|
|
2178
2245
|
}
|
|
2179
2246
|
|
|
2247
|
+
export declare class GaussianSplattingDebugMaterialPlugin extends MaterialPluginBase {
|
|
2180
2248
|
constructor(material: GaussianSplattingMaterial);
|
|
2249
|
+
}
|
|
2250
|
+
|
|
2251
|
+
export declare class GaussianSplattingGpuPickingMaterialPlugin extends MaterialPluginBase {
|
|
2252
|
+
static EncodeIdToColor(id: number): [number, number, number];
|
|
2181
2253
|
constructor(material: GaussianSplattingMaterial, _maxPartCount?: number);
|
|
2254
|
+
}
|
|
2255
|
+
|
|
2256
|
+
export declare class GaussianSplattingMaterial extends PushMaterial {
|
|
2182
2257
|
constructor(name: string, scene?: Scene);
|
|
2258
|
+
clone(_name: string): GaussianSplattingMaterial;
|
|
2259
|
+
}
|
|
2260
|
+
|
|
2261
|
+
export declare const GaussianSplattingMaxPartCount = 128;
|
|
2262
|
+
|
|
2183
2263
|
/**
|
|
2184
2264
|
* Babylon.js `GaussianSplattingMesh`. Derives from `TransformNode` so the loaded
|
|
2185
2265
|
* cloud's `position` / `rotation` / `scaling` proxy onto the Lite splat node.
|
|
@@ -2221,15 +2301,71 @@ export declare class GaussianSplattingMesh extends TransformNode {
|
|
|
2221
2301
|
/**
|
|
2222
2302
|
/** Babylon.js `gs.bakeCurrentTransformIntoVertices()` — fold the node transform into the splat data. */
|
|
2223
2303
|
bakeCurrentTransformIntoVertices(): void;
|
|
2224
2304
|
|
|
2225
|
-
export declare class
|
|
2226
|
-
constructor(..._args: unknown[]);
|
|
2305
|
+
export declare class GaussianSplattingOverdrawMaterialPlugin extends MaterialPluginBase {
|
|
2227
2306
|
constructor(material: GaussianSplattingMaterial);
|
|
2307
|
+
get isEnabled(): boolean;
|
|
2308
|
+
set isEnabled(_value: boolean);
|
|
2309
|
+
get intensity(): number;
|
|
2310
|
+
set intensity(_value: number);
|
|
2311
|
+
}
|
|
2312
|
+
|
|
2313
|
+
export declare class GaussianSplattingPartProxyMesh extends Mesh {
|
|
2314
|
+
readonly compoundSplatMesh: GaussianSplattingMesh;
|
|
2228
2315
|
private readonly _partIndex;
|
|
2316
|
+
private _visibility;
|
|
2317
|
+
constructor(name: string, _scene: Scene | null, compoundSplatMesh: GaussianSplattingMesh, partIndex: number, _boundingInfo: BoundingInfo, vertexCount: number, splatsDataOffset: number, shDataOffset?: number);
|
|
2318
|
+
get partIndex(): number;
|
|
2319
|
+
get proxiedMesh(): GaussianSplattingMesh;
|
|
2320
|
+
getClassName(): string;
|
|
2321
|
+
get isVisible(): boolean;
|
|
2322
|
+
set isVisible(value: boolean);
|
|
2323
|
+
get visibility(): number;
|
|
2324
|
+
set visibility(value: number);
|
|
2325
|
+
updateBoundingInfoFromPartData(): never;
|
|
2326
|
+
updateBoundingInfoFromProxiedMesh(): never;
|
|
2327
|
+
updatePartIndex(_newPartIndex: number): never;
|
|
2328
|
+
updatePartMetadata(_vertexCount: number, _splatsDataOffset: number, _shDataOffset?: number): never;
|
|
2329
|
+
}
|
|
2330
|
+
|
|
2331
|
+
export declare class GaussianSplattingSizeMaterialPlugin extends MaterialPluginBase {
|
|
2229
2332
|
constructor(material: GaussianSplattingMaterial);
|
|
2333
|
+
get isEnabled(): boolean;
|
|
2334
|
+
set isEnabled(_value: boolean);
|
|
2335
|
+
get sizeScale(): number;
|
|
2336
|
+
set sizeScale(_value: number);
|
|
2337
|
+
}
|
|
2338
|
+
|
|
2339
|
+
export declare class GaussianSplattingSolidColorMaterialPlugin extends MaterialPluginBase {
|
|
2230
2340
|
constructor(material: GaussianSplattingMaterial, _partColors: Color3[], _maxPartCount?: number);
|
|
2341
|
+
}
|
|
2342
|
+
|
|
2343
|
+
/** Babylon.js `GaussianSplattingStream` exact-shape stub pending a compatible Lite construction contract. */
|
|
2344
|
+
export declare class GaussianSplattingStream extends GaussianSplattingMesh {
|
|
2345
|
+
static IsLODMetadata(data: unknown): data is ISOGLODMetadata;
|
|
2346
|
+
constructor(name: string, _metadata: ISOGLODMetadata, _rootUrl: string, scene: Scene, _options?: IGaussianSplattingStreamOptions);
|
|
2347
|
+
getClassName(): string;
|
|
2348
|
+
isReady(_completeCheck?: boolean): never;
|
|
2349
|
+
get streamingPartProxy(): never;
|
|
2350
|
+
whenPartReadyAsync(): Promise<never>;
|
|
2351
|
+
whenSettledAsync(_stableFrames?: number): Promise<never>;
|
|
2352
|
+
get maxDetailLod(): never;
|
|
2353
|
+
set maxDetailLod(_value: number);
|
|
2354
|
+
get splatBudget(): never;
|
|
2355
|
+
set splatBudget(_value: number);
|
|
2356
|
+
get effectiveSplatBudget(): never;
|
|
2357
|
+
get residentSplatBudget(): never;
|
|
2231
2358
|
get minimumResidentSplats(): never;
|
|
2359
|
+
get lod0SplatCount(): GaussianSplattingStreamLod0SplatCount;
|
|
2360
|
+
getBudgetDemand(): never;
|
|
2361
|
+
setBudgetAllocation(_splats: number | null): never;
|
|
2362
|
+
get maxLodLevel(): never;
|
|
2363
|
+
get frustumCulling(): never;
|
|
2364
|
+
set frustumCulling(_value: boolean);
|
|
2365
|
+
get debugDisplay(): never;
|
|
2366
|
+
set debugDisplay(_value: boolean);
|
|
2367
|
+
get debugLodSource(): never;
|
|
2368
|
+
set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
|
|
2369
|
+
evaluateOptimalLods(_camera?: unknown): never;
|
|
2232
2370
|
}
|
|
2233
2371
|
|
|
2234
|
-
/** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
|
|
2235
2372
|
export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
|
|
2236
2373
|
|
|
2237
|
-
/** Babylon.js finest-LOD splat-count resolution state. */
|
|
2238
2374
|
export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
|
|
2239
2375
|
status: "pending";
|
|
2240
2376
|
}> | Readonly<{
|
|
@@ -2278,6 +2414,10 @@ export declare class GeospatialClippingBehavior {
|
|
|
2278
2414
|
/** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
|
|
2279
2415
|
export declare function GetElementPixelFromUv(): never;
|
|
2280
2416
|
|
|
2417
|
+
export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
|
|
2418
|
+
|
|
2419
|
+
export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
|
|
2420
|
+
|
|
2281
2421
|
export declare function GetPointsCount(..._args: unknown[]): never;
|
|
2282
2422
|
|
|
2283
2423
|
/**
|
|
@@ -2746,6 +2886,17 @@ export declare interface IAbstractSoundOptions extends Partial<IVolumeAudioOptio
|
|
|
2746
2886
|
outBus?: PrimaryAudioBus;
|
|
2747
2887
|
}
|
|
2748
2888
|
|
|
2889
|
+
export declare interface IAccessibilityTag {
|
|
2890
|
+
description?: string;
|
|
2891
|
+
eventHandler?: {
|
|
2892
|
+
[K in keyof HTMLElementEventMap]: (event?: Event) => void;
|
|
2893
|
+
};
|
|
2894
|
+
role?: AccessibilityRole;
|
|
2895
|
+
aria?: {
|
|
2896
|
+
[K in AccessibilityAria]: any;
|
|
2897
|
+
};
|
|
2898
|
+
}
|
|
2899
|
+
|
|
2749
2900
|
export declare interface IAnimationKey {
|
|
2750
2901
|
frame: number;
|
|
2751
2902
|
value: AnimationValue;
|
|
@@ -2886,14 +3037,80 @@ export declare interface IFlowGraphValidationResult {
|
|
|
2886
3037
|
issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
|
|
2887
3038
|
}
|
|
2888
3039
|
|
|
2889
|
-
|
|
3040
|
+
export declare interface IGaussianSplattingDebugOptions {
|
|
3041
|
+
clippingBox: {
|
|
3042
|
+
min: Vector3;
|
|
3043
|
+
max: Vector3;
|
|
3044
|
+
} | null;
|
|
3045
|
+
opacityCulling: {
|
|
3046
|
+
min: number;
|
|
3047
|
+
max: number;
|
|
3048
|
+
} | null;
|
|
3049
|
+
sizeCulling: {
|
|
3050
|
+
min: number;
|
|
3051
|
+
max: number;
|
|
3052
|
+
} | null;
|
|
3053
|
+
opacityScale: number;
|
|
3054
|
+
opacitySaturate: boolean;
|
|
3055
|
+
shDc: boolean;
|
|
3056
|
+
shOrder1: boolean;
|
|
3057
|
+
shOrder2: boolean;
|
|
3058
|
+
shOrder3: boolean;
|
|
3059
|
+
shOrder4: boolean;
|
|
3060
|
+
}
|
|
3061
|
+
|
|
2890
3062
|
export declare interface IGaussianSplattingStreamingPart {
|
|
2891
|
-
|
|
3063
|
+
readonly proxy: GaussianSplattingPartProxyMesh;
|
|
3064
|
+
readonly partIndex: number;
|
|
3065
|
+
readonly base: number;
|
|
3066
|
+
readonly capacity: number;
|
|
3067
|
+
readonly centersTexture: BaseTexture | null;
|
|
3068
|
+
readonly covariancesATexture: BaseTexture | null;
|
|
3069
|
+
readonly covariancesBTexture: BaseTexture | null;
|
|
3070
|
+
readonly colorsTexture: BaseTexture | null;
|
|
3071
|
+
readonly splatPositions: Float32Array | null;
|
|
3072
|
+
readonly mrtAtlas: unknown | null;
|
|
3073
|
+
readonly shMrtAtlas: unknown[] | null;
|
|
3074
|
+
readonly rotMrtAtlas: unknown | null;
|
|
3075
|
+
readonly atlasWidth: number;
|
|
3076
|
+
readonly isDepthSortSettled: boolean;
|
|
3077
|
+
setActiveRanges(localRanges: readonly {
|
|
3078
|
+
offset: number;
|
|
3079
|
+
count: number;
|
|
3080
|
+
}[] | null): void;
|
|
3081
|
+
writeSplats(localOffset: number, count: number, splatsData: ArrayBuffer | ArrayBufferView): void;
|
|
3082
|
+
postPositionsRange(localOffset: number, count: number): void;
|
|
3083
|
+
expandBounds(min: Vector3, max: Vector3): void;
|
|
3084
|
+
notifyDataChanged(): void;
|
|
3085
|
+
onBeforeAtlasRebuild(callback: (oldAtlas: unknown) => void): () => void;
|
|
3086
|
+
onAfterAtlasRebuild(callback: (newAtlas: unknown) => void): () => void;
|
|
2892
3087
|
}
|
|
2893
3088
|
|
|
2894
|
-
/** Babylon.js `IGaussianSplattingStreamOptions` — GS LOD stream options (shape-only stub for type parity). */
|
|
2895
3089
|
export declare interface IGaussianSplattingStreamOptions {
|
|
2896
|
-
|
|
3090
|
+
deflateURL?: string;
|
|
3091
|
+
fflate?: unknown;
|
|
3092
|
+
debugDisplay?: boolean;
|
|
3093
|
+
debugLodSource?: GaussianSplattingStreamDebugLodSource;
|
|
3094
|
+
lodBaseDistance?: number;
|
|
3095
|
+
lodMultiplier?: number;
|
|
3096
|
+
lodBehindPenalty?: number;
|
|
3097
|
+
lodRangeMin?: number;
|
|
3098
|
+
lodRangeMax?: number;
|
|
3099
|
+
maxDecodesPerFrame?: number;
|
|
3100
|
+
lodCooldownFrames?: number;
|
|
3101
|
+
lodUpdateInterval?: number;
|
|
3102
|
+
lodUpdateDistance?: number;
|
|
3103
|
+
maxDetailLod?: number;
|
|
3104
|
+
frustumCulling?: boolean;
|
|
3105
|
+
maxConcurrentDownloads?: number;
|
|
3106
|
+
maxDownloadRetries?: number;
|
|
3107
|
+
memoryBudgetMb?: number;
|
|
3108
|
+
maxResidentSplats?: number;
|
|
3109
|
+
evictionCooldownFrames?: number;
|
|
3110
|
+
splatBudget?: number | "auto";
|
|
3111
|
+
hostCompound?: GaussianSplattingMesh;
|
|
3112
|
+
decodeSh?: boolean;
|
|
3113
|
+
needsRotationScale?: boolean;
|
|
2897
3114
|
}
|
|
2898
3115
|
|
|
2899
3116
|
/** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
|
|
@@ -3101,9 +3318,27 @@ export declare function IsHtmlInCanvasSupportedNatively(): never;
|
|
|
3101
3318
|
/** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
|
|
3102
3319
|
export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
|
|
3103
3320
|
|
|
3104
|
-
|
|
3321
|
+
declare interface ISOGLODEntry {
|
|
3322
|
+
file: number;
|
|
3323
|
+
offset: number;
|
|
3324
|
+
count: number;
|
|
3325
|
+
}
|
|
3326
|
+
|
|
3327
|
+
/** Babylon.js parsed PlayCanvas-style `lod-meta.json` shape. */
|
|
3105
3328
|
export declare interface ISOGLODMetadata {
|
|
3106
|
-
|
|
3329
|
+
lodLevels: number;
|
|
3330
|
+
filenames: string[];
|
|
3331
|
+
environment?: string;
|
|
3332
|
+
tree: ISOGLODNode;
|
|
3333
|
+
}
|
|
3334
|
+
|
|
3335
|
+
declare interface ISOGLODNode {
|
|
3336
|
+
bound: {
|
|
3337
|
+
min: number[];
|
|
3338
|
+
max: number[];
|
|
3339
|
+
};
|
|
3340
|
+
children?: ISOGLODNode[];
|
|
3341
|
+
lods?: Record<string, ISOGLODEntry>;
|
|
3107
3342
|
}
|
|
3108
3343
|
|
|
3109
3344
|
/** Babylon.js `ISoundSourceOptions` (subset). */
|
|
@@ -3549,6 +3784,14 @@ export declare class Matrix {
|
|
|
3549
3784
|
static RotationZ(angle: number): Matrix;
|
|
3550
3785
|
/** Babylon.js `Matrix.LookAtLH(eye, target, up)` — left-handed view matrix. */
|
|
3551
3786
|
static LookAtLH(eye: Vector3, target: Vector3, up: Vector3): Matrix;
|
|
3787
|
+
/** Babylon.js `Matrix.LookDirectionLH(forward, up)` orientation matrix. */
|
|
3788
|
+
static LookDirectionLH(forward: Vector3, up: Vector3): Matrix;
|
|
3789
|
+
/** Babylon.js `Matrix.LookDirectionLHToRef(forward, up, result)`. */
|
|
3790
|
+
static LookDirectionLHToRef<T extends Matrix>(forward: Vector3, up: Vector3, result: T): T;
|
|
3791
|
+
/** Babylon.js `Matrix.LookDirectionRH(forward, up)` orientation matrix. */
|
|
3792
|
+
static LookDirectionRH(forward: Vector3, up: Vector3): Matrix;
|
|
3793
|
+
/** Babylon.js `Matrix.LookDirectionRHToRef(forward, up, result)`. */
|
|
3794
|
+
static LookDirectionRHToRef<T extends Matrix>(forward: Vector3, up: Vector3, result: T): T;
|
|
3552
3795
|
/** Babylon.js `Matrix.OrthoOffCenterLH(left, right, bottom, top, znear, zfar, halfZRange?)` — LH ortho projection. */
|
|
3553
3796
|
static OrthoOffCenterLH(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, _halfZRange?: boolean): Matrix;
|
|
3554
3797
|
/**
|
|
@@ -3803,14 +4046,16 @@ declare abstract class Node_2 {
|
|
|
3803
4046
|
readonly uniqueId: number;
|
|
3804
4047
|
/** Free-form user data slot (Babylon.js `Node.metadata`). */
|
|
3805
4048
|
metadata: unknown;
|
|
3806
|
-
readonly onDisposeObservable: Observable<Node_2>;
|
|
3807
4049
|
protected constructor(name: string, scene?: Scene);
|
|
4050
|
+
readonly onDisposeObservable: Observable<Node_2>;
|
|
4051
|
+
onAccessibilityTagChangedObservable: Observable<IAccessibilityTag | null>;
|
|
3808
4052
|
protected constructor(name: string, scene?: Scene);
|
|
3809
4053
|
/** The runtime class name (overridden by each subclass). */
|
|
3810
4054
|
getClassName(): string;
|
|
3811
4055
|
/** The scene this node belongs to, if any. */
|
|
3812
4056
|
getScene(): Scene | undefined;
|
|
3813
4057
|
/** The engine backing this node's scene, if any. */
|
|
3814
4058
|
getEngine(): WebGPUEngine | undefined;
|
|
3815
|
-
get
|
|
4059
|
+
get accessibilityTag(): IAccessibilityTag | null;
|
|
4060
|
+
set accessibilityTag(value: IAccessibilityTag | null);
|
|
3816
4061
|
get parent(): Node_2 | null;
|
|
3817
4062
|
set parent(value: Node_2 | null);
|
|
3818
4063
|
/**
|
|
3819
4064
|
* Babylon.js `node.getDescendants(directDescendantsOnly?, predicate?)` — the
|
|
3820
4065
|
* nodes parented (directly or transitively) under this one, optionally filtered.
|
|
@@ -3916,6 +4161,11 @@ export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
|
|
|
3916
4161
|
constructor(..._args: unknown[]);
|
|
3917
4162
|
}
|
|
3918
4163
|
|
|
4164
|
+
/** Babylon.js 9.29 node-render-graph min/max reduction block. */
|
|
4165
|
+
export declare class NodeRenderGraphMinMaxReducerBlock {
|
|
4166
|
+
constructor(..._args: unknown[]);
|
|
4167
|
+
}
|
|
4168
|
+
|
|
3919
4169
|
/**
|
|
3920
4170
|
* Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
|
|
3921
4171
|
* scene logic (animations, observables, physics stepping, frame timing) without
|
|
@@ -4864,6 +5114,15 @@ export declare class Quaternion {
|
|
|
4864
5114
|
* `matrix` into `result`. Backed by Lite's `createQuatFromRotationMat4`.
|
|
4865
5115
|
*/
|
|
4866
5116
|
static FromRotationMatrixToRef(matrix: Matrix, result: Quaternion): Quaternion;
|
|
5117
|
+
/** Babylon.js `Quaternion.FromLookDirectionLH(forward, up)`. */
|
|
5118
|
+
static FromLookDirectionLH(forward: Vector3, up: Vector3): Quaternion;
|
|
5119
|
+
/** Babylon.js `Quaternion.FromLookDirectionLHToRef(forward, up, result)`. */
|
|
5120
|
+
static FromLookDirectionLHToRef<T extends Quaternion>(forward: Vector3, up: Vector3, result: T): T;
|
|
5121
|
+
/** Babylon.js `Quaternion.FromLookDirectionRH(forward, up)`. */
|
|
5122
|
+
static FromLookDirectionRH(forward: Vector3, up: Vector3): Quaternion;
|
|
5123
|
+
/** Babylon.js `Quaternion.FromLookDirectionRHToRef(forward, up, result)`. */
|
|
5124
|
+
static FromLookDirectionRHToRef<T extends Quaternion>(forward: Vector3, up: Vector3, result: T): T;
|
|
5125
|
+
private static _FromRotationStorageToRef;
|
|
4867
5126
|
static FromEulerAngles(x: number, y: number, z: number): Quaternion;
|
|
4868
5127
|
static RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Quaternion;
|
|
4869
5128
|
static RotationAxis(axis: Vector3, angle: number): Quaternion;
|
|
@@ -5026,6 +5285,18 @@ export declare function RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImage
|
|
|
5026
5285
|
|
|
5027
5286
|
export declare function RegisterFluidRenderer(): void;
|
|
5028
5287
|
|
|
5288
|
+
export declare function RegisterGaussianSplattingDebugMaterialPlugin(): void;
|
|
5289
|
+
|
|
5290
|
+
export declare function RegisterGaussianSplattingGpuPickingMaterialPlugin(): void;
|
|
5291
|
+
|
|
5292
|
+
export declare function RegisterGaussianSplattingMaterial(): void;
|
|
5293
|
+
|
|
5294
|
+
export declare function RegisterGaussianSplattingOverdrawMaterialPlugin(): void;
|
|
5295
|
+
|
|
5296
|
+
export declare function RegisterGaussianSplattingSizeMaterialPlugin(): void;
|
|
5297
|
+
|
|
5298
|
+
export declare function RegisterGaussianSplattingSolidColorMaterialPlugin(): void;
|
|
5299
|
+
|
|
5029
5300
|
export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
|
|
5030
5301
|
|
|
5031
5302
|
/** Babylon.js pure-module registration hook. */
|
|
@@ -5033,6 +5304,9 @@ export declare function RegisterImageProcessingConfiguration(): void;
|
|
|
5033
5304
|
|
|
5034
5305
|
export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
5035
5306
|
|
|
5307
|
+
/** Babylon.js 9.29 node-render-graph registration function. */
|
|
5308
|
+
export declare function RegisterMinMaxReducerBlock(): never;
|
|
5309
|
+
|
|
5036
5310
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
5037
5311
|
|
|
5038
5312
|
/**
|
|
@@ -6609,6 +6883,15 @@ export declare class VirtualJoystick {
|
|
|
6609
6883
|
export declare class WebGPUEngine extends AbstractEngine {
|
|
6610
6884
|
}
|
|
6611
6885
|
|
|
6886
|
+
/** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
|
|
6887
|
+
export declare interface WebGPUEngineOptions extends EngineOptions {
|
|
6888
|
+
antialias?: boolean;
|
|
6889
|
+
adaptToDeviceRatio?: boolean;
|
|
6890
|
+
useLargeWorldRendering?: boolean;
|
|
6891
|
+
canvasToneMapping?: GPUCanvasToneMapping;
|
|
6892
|
+
canvasColorSpace?: PredefinedColorSpace;
|
|
6893
|
+
}
|
|
6894
|
+
|
|
6612
6895
|
/** Babylon.js `WebXRCamera` — WebXR is not part of Babylon Lite. */
|
|
6613
6896
|
export declare class WebXRCamera {
|
|
6614
6897
|
constructor();
|