@babylonjs/lite-compat 1.32.0-preview → 1.34.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 +5 -5
- package/index.d.ts +257 -25
- package/index.js +258 -33
- package/index.js.map +1 -1
- package/{meshes-Ds66ewr9.js → meshes-BLcUDvXV.js} +42 -2
- package/meshes-BLcUDvXV.js.map +1 -0
- package/navigation.d.ts +29 -9
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-Ds66ewr9.js.map +0 -1
package/README.md
CHANGED
|
@@ -120,15 +120,15 @@ overloads within a supported area may still be absent.
|
|
|
120
120
|
| Math (`Vector*`, `Color*`, `Quaternion`, `Matrix`, `Plane`, `Ray`, `Frustum`, `Scalar`, `Axis`/`Space`, color temperature/white balance) | ✅ | `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
|
|
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; actively deformed meshes still require async `GPUPicker`; `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
125
|
| Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
|
|
126
126
|
| Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
|
|
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;
|
|
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 `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;
|
|
@@ -595,11 +595,9 @@ export declare const ActionManagerTriggers: {
|
|
|
595
595
|
readonly OnEveryFrameTrigger: 14;
|
|
596
596
|
};
|
|
597
597
|
|
|
598
|
-
|
|
599
|
-
export declare function AddGaussianSplattingStreamPart(..._args: unknown[]): never;
|
|
598
|
+
export declare function AddGaussianSplattingStreamPart(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): never;
|
|
600
599
|
|
|
601
|
-
|
|
602
|
-
export declare function AddGaussianSplattingStreamPartAsync(..._args: unknown[]): never;
|
|
600
|
+
export declare function AddGaussianSplattingStreamPartAsync(_compound: GaussianSplattingMesh, _name: string, _metadata: ISOGLODMetadata, _rootUrl: string, _options?: IGaussianSplattingStreamOptions): Promise<GaussianSplattingPartProxyMesh>;
|
|
603
601
|
|
|
604
602
|
export declare class AmmoJSPlugin {
|
|
605
603
|
constructor();
|
|
@@ -1586,6 +1584,12 @@ export declare function CreateMicrophoneSoundSourceAsync(name: string, options?:
|
|
|
1586
1584
|
/** Babylon.js `CreatePlane(name, options, scene)` (planeBuilder). */
|
|
1587
1585
|
export declare function CreatePlane(name: string, options: PlaneOptions, scene: Scene): Mesh;
|
|
1588
1586
|
|
|
1587
|
+
/** Babylon.js `CreatePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.CreatePolygon`). */
|
|
1588
|
+
export declare function CreatePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
|
|
1589
|
+
|
|
1590
|
+
/** Babylon.js `CreatePolygonVertexData` — the polygon geometry generator requires the unsupported polygon subsystem. */
|
|
1591
|
+
export declare function CreatePolygonVertexData(_polygon: Mesh, _sideOrientation: number, _faceUV?: Vector4[], _faceColors?: Color4[], _frontUVs?: Vector4, _backUVs?: Vector4, _wrap?: boolean): never;
|
|
1592
|
+
|
|
1589
1593
|
/** Babylon.js `CreateSoundAsync`. */
|
|
1590
1594
|
export declare function CreateSoundAsync(name: string, source: StaticSoundSource, options?: Partial<IStaticSoundOptions>, engine?: AudioEngineV2 | null): Promise<StaticSound>;
|
|
1591
1595
|
|
|
@@ -1904,10 +1908,57 @@ export declare class EdgesRenderer {
|
|
|
1904
1908
|
constructor();
|
|
1905
1909
|
}
|
|
1906
1910
|
|
|
1911
|
+
export declare class Effect {
|
|
1912
|
+
constructor();
|
|
1913
|
+
isReady(): never;
|
|
1914
|
+
getEngine(): AbstractEngine;
|
|
1915
|
+
getCompilationError(): string;
|
|
1916
|
+
setTexture(_channel: string, _texture: BaseTexture): never;
|
|
1917
|
+
setFloat(_uniformName: string, _value: number): never;
|
|
1918
|
+
}
|
|
1919
|
+
|
|
1907
1920
|
export declare class EffectLayer {
|
|
1908
1921
|
constructor();
|
|
1909
1922
|
}
|
|
1910
1923
|
|
|
1924
|
+
export declare class EffectWrapper {
|
|
1925
|
+
static ForceGLSL: boolean;
|
|
1926
|
+
static RegisterShaderCodeProcessing(_effectWrapperName: string | null, _customShaderCodeProcessing?: EffectWrapperCustomShaderCodeProcessing): never;
|
|
1927
|
+
constructor(_options: EffectWrapperCreationOptions);
|
|
1928
|
+
}
|
|
1929
|
+
|
|
1930
|
+
export declare interface EffectWrapperCreationOptions {
|
|
1931
|
+
engine?: AbstractEngine;
|
|
1932
|
+
fragmentShader?: string;
|
|
1933
|
+
useShaderStore?: boolean;
|
|
1934
|
+
vertexShader?: string;
|
|
1935
|
+
vertexUrl?: string;
|
|
1936
|
+
attributeNames?: string[];
|
|
1937
|
+
uniformNames?: string[];
|
|
1938
|
+
uniforms?: string[] | null;
|
|
1939
|
+
samplerNames?: string[];
|
|
1940
|
+
samplers?: string[] | null;
|
|
1941
|
+
uniformBuffers?: string[] | null;
|
|
1942
|
+
defines?: string | string[] | null;
|
|
1943
|
+
indexParameters?: any;
|
|
1944
|
+
blockCompilation?: boolean;
|
|
1945
|
+
onCompiled?: ((effect: Effect) => void) | null;
|
|
1946
|
+
onError?: (effect: Effect, errors: string) => void;
|
|
1947
|
+
name?: string;
|
|
1948
|
+
shaderLanguage?: ShaderLanguage;
|
|
1949
|
+
extraInitializations?: (useWebGPU: boolean, list: Promise<any>[]) => void;
|
|
1950
|
+
extraInitializationsAsync?: () => Promise<void>;
|
|
1951
|
+
useAsPostProcess?: boolean;
|
|
1952
|
+
allowEmptySourceTexture?: boolean;
|
|
1953
|
+
}
|
|
1954
|
+
|
|
1955
|
+
export declare type EffectWrapperCustomShaderCodeProcessing = {
|
|
1956
|
+
processCodeAfterIncludes?: (postProcessName: string, shaderType: string, code: string) => string;
|
|
1957
|
+
processFinalCode?: (postProcessName: string, shaderType: string, code: string) => string;
|
|
1958
|
+
defineCustomBindings?: (postProcessName: string, defines: string | null, uniforms: string[], samplers: string[]) => string | null;
|
|
1959
|
+
bindCustomBindings?: (postProcessName: string, effect: Effect) => void;
|
|
1960
|
+
};
|
|
1961
|
+
|
|
1911
1962
|
export declare class ElasticEase extends EasingFunction {
|
|
1912
1963
|
oscillations: number;
|
|
1913
1964
|
springiness: number;
|
|
@@ -1940,6 +1991,23 @@ export declare class ExponentialEase extends EasingFunction {
|
|
|
1940
1991
|
easeInCore(gradient: number): number;
|
|
1941
1992
|
}
|
|
1942
1993
|
|
|
1994
|
+
/** Babylon.js `ExternalTexture` over Lite's caller-owned video wrapper. */
|
|
1995
|
+
export declare class ExternalTexture {
|
|
1996
|
+
private readonly _video;
|
|
1943
1997
|
useMipMaps: boolean;
|
|
1998
|
+
readonly type = 16;
|
|
1999
|
+
readonly format = 4294967295;
|
|
2000
|
+
readonly uniqueId: number;
|
|
2001
|
+
static IsExternalTexture(texture: unknown): texture is ExternalTexture;
|
|
2002
|
+
constructor(_video: HTMLVideoElement);
|
|
2003
|
+
getClassName(): string;
|
|
2004
|
+
get underlyingResource(): HTMLVideoElement;
|
|
2005
|
+
isReady(): boolean;
|
|
2006
|
+
dispose(): void;
|
|
2007
|
+
}
|
|
2008
|
+
|
|
2009
|
+
/** Babylon.js `ExtrudePolygon(name, options, scene?, earcutInjection?)` — throwing stub (see `MeshBuilder.ExtrudePolygon`). */
|
|
2010
|
+
export declare function ExtrudePolygon(name: string, options: PolygonBuilderOptions, scene?: Scene | null, earcutInjection?: unknown): never;
|
|
2011
|
+
|
|
1944
2012
|
/** A gradient value bound to a [0, 1] position (Babylon.js `FactorGradient`). */
|
|
1945
2013
|
export declare class FactorGradient {
|
|
1946
2014
|
gradient: number;
|
|
@@ -2132,6 +2200,11 @@ export declare class FrameGraphMeshBlendingTask {
|
|
|
2132
2200
|
constructor(..._args: unknown[]);
|
|
2133
2201
|
}
|
|
2134
2202
|
|
|
2203
|
+
/** Babylon.js 9.29 frame-graph min/max reduction task. */
|
|
2204
|
+
export declare class FrameGraphMinMaxReducerTask {
|
|
2205
|
+
constructor(..._args: unknown[]);
|
|
2206
|
+
}
|
|
2207
|
+
|
|
2135
2208
|
/** Frames an `ArcRotateCamera` on a target by setting its radius (no zoom tween). */
|
|
2136
2209
|
export declare class FramingBehavior implements Behavior<ArcRotateCamera> {
|
|
2137
2210
|
readonly name = "Framing";
|
|
@@ -2212,15 +2285,54 @@ export declare class GaussianSplattingMesh extends TransformNode {
|
|
|
2212
2285
|
/**
|
|
2213
2286
|
/** Babylon.js `gs.bakeCurrentTransformIntoVertices()` — fold the node transform into the splat data. */
|
|
2214
2287
|
bakeCurrentTransformIntoVertices(): void;
|
|
2215
2288
|
|
|
2216
|
-
export declare class
|
|
2217
|
-
|
|
2289
|
+
export declare class GaussianSplattingPartProxyMesh extends Mesh {
|
|
2290
|
+
readonly compoundSplatMesh: GaussianSplattingMesh;
|
|
2218
2291
|
private readonly _partIndex;
|
|
2292
|
+
private _visibility;
|
|
2293
|
+
constructor(name: string, _scene: Scene | null, compoundSplatMesh: GaussianSplattingMesh, partIndex: number, _boundingInfo: BoundingInfo, vertexCount: number, splatsDataOffset: number, shDataOffset?: number);
|
|
2294
|
+
get partIndex(): number;
|
|
2295
|
+
get proxiedMesh(): GaussianSplattingMesh;
|
|
2296
|
+
getClassName(): string;
|
|
2297
|
+
get isVisible(): boolean;
|
|
2298
|
+
set isVisible(value: boolean);
|
|
2299
|
+
get visibility(): number;
|
|
2300
|
+
set visibility(value: number);
|
|
2301
|
+
updateBoundingInfoFromPartData(): never;
|
|
2302
|
+
updateBoundingInfoFromProxiedMesh(): never;
|
|
2303
|
+
updatePartIndex(_newPartIndex: number): never;
|
|
2304
|
+
updatePartMetadata(_vertexCount: number, _splatsDataOffset: number, _shDataOffset?: number): never;
|
|
2305
|
+
}
|
|
2306
|
+
|
|
2307
|
+
/** Babylon.js `GaussianSplattingStream` exact-shape stub pending a compatible Lite construction contract. */
|
|
2308
|
+
export declare class GaussianSplattingStream extends GaussianSplattingMesh {
|
|
2309
|
+
static IsLODMetadata(data: unknown): data is ISOGLODMetadata;
|
|
2310
|
+
constructor(name: string, _metadata: ISOGLODMetadata, _rootUrl: string, scene: Scene, _options?: IGaussianSplattingStreamOptions);
|
|
2311
|
+
getClassName(): string;
|
|
2312
|
+
isReady(_completeCheck?: boolean): never;
|
|
2313
|
+
get streamingPartProxy(): never;
|
|
2314
|
+
whenPartReadyAsync(): Promise<never>;
|
|
2315
|
+
whenSettledAsync(_stableFrames?: number): Promise<never>;
|
|
2316
|
+
get maxDetailLod(): never;
|
|
2317
|
+
set maxDetailLod(_value: number);
|
|
2318
|
+
get splatBudget(): never;
|
|
2319
|
+
set splatBudget(_value: number);
|
|
2320
|
+
get effectiveSplatBudget(): never;
|
|
2321
|
+
get residentSplatBudget(): never;
|
|
2219
2322
|
get minimumResidentSplats(): never;
|
|
2323
|
+
get lod0SplatCount(): GaussianSplattingStreamLod0SplatCount;
|
|
2324
|
+
getBudgetDemand(): never;
|
|
2325
|
+
setBudgetAllocation(_splats: number | null): never;
|
|
2326
|
+
get maxLodLevel(): never;
|
|
2327
|
+
get frustumCulling(): never;
|
|
2328
|
+
set frustumCulling(_value: boolean);
|
|
2329
|
+
get debugDisplay(): never;
|
|
2330
|
+
set debugDisplay(_value: boolean);
|
|
2331
|
+
get debugLodSource(): never;
|
|
2332
|
+
set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
|
|
2333
|
+
evaluateOptimalLods(_camera?: unknown): never;
|
|
2220
2334
|
}
|
|
2221
2335
|
|
|
2222
|
-
/** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
|
|
2223
2336
|
export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
|
|
2224
2337
|
|
|
2225
|
-
/** Babylon.js finest-LOD splat-count resolution state. */
|
|
2226
2338
|
export declare type GaussianSplattingStreamLod0SplatCount = Readonly<{
|
|
2227
2339
|
status: "pending";
|
|
2228
2340
|
}> | Readonly<{
|
|
@@ -2877,14 +2989,58 @@ export declare interface IFlowGraphValidationResult {
|
|
|
2877
2989
|
issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
|
|
2878
2990
|
}
|
|
2879
2991
|
|
|
2880
|
-
/** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
|
|
2881
2992
|
export declare interface IGaussianSplattingStreamingPart {
|
|
2882
|
-
|
|
2993
|
+
readonly proxy: GaussianSplattingPartProxyMesh;
|
|
2994
|
+
readonly partIndex: number;
|
|
2995
|
+
readonly base: number;
|
|
2996
|
+
readonly capacity: number;
|
|
2997
|
+
readonly centersTexture: BaseTexture | null;
|
|
2998
|
+
readonly covariancesATexture: BaseTexture | null;
|
|
2999
|
+
readonly covariancesBTexture: BaseTexture | null;
|
|
3000
|
+
readonly colorsTexture: BaseTexture | null;
|
|
3001
|
+
readonly splatPositions: Float32Array | null;
|
|
3002
|
+
readonly mrtAtlas: unknown | null;
|
|
3003
|
+
readonly shMrtAtlas: unknown[] | null;
|
|
3004
|
+
readonly rotMrtAtlas: unknown | null;
|
|
3005
|
+
readonly atlasWidth: number;
|
|
3006
|
+
readonly isDepthSortSettled: boolean;
|
|
3007
|
+
setActiveRanges(localRanges: readonly {
|
|
3008
|
+
offset: number;
|
|
3009
|
+
count: number;
|
|
3010
|
+
}[] | null): void;
|
|
3011
|
+
writeSplats(localOffset: number, count: number, splatsData: ArrayBuffer | ArrayBufferView): void;
|
|
3012
|
+
postPositionsRange(localOffset: number, count: number): void;
|
|
3013
|
+
expandBounds(min: Vector3, max: Vector3): void;
|
|
3014
|
+
notifyDataChanged(): void;
|
|
3015
|
+
onBeforeAtlasRebuild(callback: (oldAtlas: unknown) => void): () => void;
|
|
3016
|
+
onAfterAtlasRebuild(callback: (newAtlas: unknown) => void): () => void;
|
|
2883
3017
|
}
|
|
2884
3018
|
|
|
2885
|
-
/** Babylon.js `IGaussianSplattingStreamOptions` — GS LOD stream options (shape-only stub for type parity). */
|
|
2886
3019
|
export declare interface IGaussianSplattingStreamOptions {
|
|
2887
|
-
|
|
3020
|
+
deflateURL?: string;
|
|
3021
|
+
fflate?: unknown;
|
|
3022
|
+
debugDisplay?: boolean;
|
|
3023
|
+
debugLodSource?: GaussianSplattingStreamDebugLodSource;
|
|
3024
|
+
lodBaseDistance?: number;
|
|
3025
|
+
lodMultiplier?: number;
|
|
3026
|
+
lodBehindPenalty?: number;
|
|
3027
|
+
lodRangeMin?: number;
|
|
3028
|
+
lodRangeMax?: number;
|
|
3029
|
+
maxDecodesPerFrame?: number;
|
|
3030
|
+
lodCooldownFrames?: number;
|
|
3031
|
+
lodUpdateInterval?: number;
|
|
3032
|
+
lodUpdateDistance?: number;
|
|
3033
|
+
maxDetailLod?: number;
|
|
3034
|
+
frustumCulling?: boolean;
|
|
3035
|
+
maxConcurrentDownloads?: number;
|
|
3036
|
+
maxDownloadRetries?: number;
|
|
3037
|
+
memoryBudgetMb?: number;
|
|
3038
|
+
maxResidentSplats?: number;
|
|
3039
|
+
evictionCooldownFrames?: number;
|
|
3040
|
+
splatBudget?: number | "auto";
|
|
3041
|
+
hostCompound?: GaussianSplattingMesh;
|
|
3042
|
+
decodeSh?: boolean;
|
|
3043
|
+
needsRotationScale?: boolean;
|
|
2888
3044
|
}
|
|
2889
3045
|
|
|
2890
3046
|
/** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
|
|
@@ -3092,9 +3248,27 @@ export declare function IsHtmlInCanvasSupportedNatively(): never;
|
|
|
3092
3248
|
/** Babylon.js `IsHtmlInCanvasUploadSupported` — kept in lockstep with the unavailable upload helper. */
|
|
3093
3249
|
export declare function IsHtmlInCanvasUploadSupported(engine: AbstractEngine): boolean;
|
|
3094
3250
|
|
|
3095
|
-
|
|
3251
|
+
declare interface ISOGLODEntry {
|
|
3252
|
+
file: number;
|
|
3253
|
+
offset: number;
|
|
3254
|
+
count: number;
|
|
3255
|
+
}
|
|
3256
|
+
|
|
3257
|
+
/** Babylon.js parsed PlayCanvas-style `lod-meta.json` shape. */
|
|
3096
3258
|
export declare interface ISOGLODMetadata {
|
|
3097
|
-
|
|
3259
|
+
lodLevels: number;
|
|
3260
|
+
filenames: string[];
|
|
3261
|
+
environment?: string;
|
|
3262
|
+
tree: ISOGLODNode;
|
|
3263
|
+
}
|
|
3264
|
+
|
|
3265
|
+
declare interface ISOGLODNode {
|
|
3266
|
+
bound: {
|
|
3267
|
+
min: number[];
|
|
3268
|
+
max: number[];
|
|
3269
|
+
};
|
|
3270
|
+
children?: ISOGLODNode[];
|
|
3271
|
+
lods?: Record<string, ISOGLODEntry>;
|
|
3098
3272
|
}
|
|
3099
3273
|
|
|
3100
3274
|
/** Babylon.js `ISoundSourceOptions` (subset). */
|
|
@@ -3588,6 +3762,10 @@ export declare class Mesh extends AbstractMesh {
|
|
|
3588
3762
|
static CreateCylinder(name: string, height: number, diameterTop: number, diameterBottom: number, tessellation: number, _subdivisions: number, scene: Scene): Mesh;
|
|
3589
3763
|
/** Legacy `Mesh.CreateTorus(name, diameter, thickness, tessellation, scene)`. */
|
|
3590
3764
|
static CreateTorus(name: string, diameter: number, thickness: number, tessellation: number, scene: Scene): Mesh;
|
|
3765
|
+
/** Legacy `Mesh.CreatePolygon(name, shape, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
|
|
3766
|
+
static CreatePolygon(_name: string, _shape: Vector3[], _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
|
|
3767
|
+
/** Legacy `Mesh.ExtrudePolygon(name, shape, depth, scene, holes?, updatable?, sideOrientation?, earcutInjection?)`. */
|
|
3768
|
+
static ExtrudePolygon(_name: string, _shape: Vector3[], _depth: number, _scene: Scene, _holes?: Vector3[][], _updatable?: boolean, _sideOrientation?: number, _earcutInjection?: unknown): never;
|
|
3591
3769
|
/** Hardware-instanced copy — unsupported. Use native thin instances instead. */
|
|
3592
3770
|
createInstance(): never;
|
|
3593
3771
|
/**
|
|
@@ -3706,11 +3884,13 @@ export declare const MeshBuilder: {
|
|
|
3706
3884
|
CreateText(): never;
|
|
3707
3885
|
CreateTiledBox(_name?: string, _options?: object, _scene?: Scene): never;
|
|
3708
3886
|
CreateTiledPlane(_name?: string, _options?: object, _scene?: Scene): never;
|
|
3887
|
+
CreatePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
|
|
3888
|
+
ExtrudePolygon(_name: string, _options: PolygonBuilderOptions, _scene?: Scene | null, _earcutInjection?: unknown): never;
|
|
3709
3889
|
};
|
|
3710
3890
|
|
|
3711
3891
|
/** A compat mesh exposes its backing Lite mesh as `_lite`. */
|
|
3712
3892
|
declare interface MeshLike {
|
|
3713
|
-
_lite:
|
|
3893
|
+
_lite: Mesh;
|
|
3714
3894
|
}
|
|
3715
3895
|
|
|
3716
3896
|
/**
|
|
@@ -3740,6 +3920,8 @@ export declare class MeshoptCompression {
|
|
|
3740
3920
|
static get Default(): MeshoptCompression;
|
|
3741
3921
|
}
|
|
3742
3922
|
|
|
3923
|
+
export declare type MeshPredicate = (mesh: AbstractMesh, thinInstanceIndex: number) => boolean;
|
|
3924
|
+
|
|
3743
3925
|
export { MinTemperatureKelvin }
|
|
3744
3926
|
|
|
3745
3927
|
export declare class MirrorTexture {
|
|
@@ -3899,6 +4081,11 @@ export declare class NodeRenderGraphMeshBlendingPostProcessBlock {
|
|
|
3899
4081
|
constructor(..._args: unknown[]);
|
|
3900
4082
|
}
|
|
3901
4083
|
|
|
4084
|
+
/** Babylon.js 9.29 node-render-graph min/max reduction block. */
|
|
4085
|
+
export declare class NodeRenderGraphMinMaxReducerBlock {
|
|
4086
|
+
constructor(..._args: unknown[]);
|
|
4087
|
+
}
|
|
4088
|
+
|
|
3902
4089
|
/**
|
|
3903
4090
|
* Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
|
|
3904
4091
|
* scene logic (animations, observables, physics stepping, frame timing) without
|
|
@@ -4583,8 +4770,11 @@ export declare class PickingInfo {
|
|
|
4583
4770
|
aimTransform: TransformNode | null;
|
|
4584
4771
|
gripTransform: TransformNode | null;
|
|
4585
4772
|
private _normal;
|
|
4586
|
-
private _worldNormal;
|
|
4587
4773
|
getNormal(useWorldCoordinates?: boolean, _useVerticesNormals?: boolean): Vector3 | null;
|
|
4588
|
-
|
|
4774
|
+
private _worldNormal;
|
|
4775
|
+
private _faceNormal;
|
|
4776
|
+
private _faceWorldNormal;
|
|
4777
|
+
private _uv;
|
|
4589
4778
|
getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3 | null;
|
|
4779
|
+
getTextureCoordinates(uvSet?: string): Vector2 | null;
|
|
4590
4780
|
}
|
|
4591
4781
|
|
|
4592
4782
|
declare type PickListItem = PickableMesh | {
|
|
@@ -4718,6 +4908,26 @@ export declare class Polar {
|
|
|
4718
4908
|
static FromArray(array: number[]): Polar;
|
|
4719
4909
|
}
|
|
4720
4910
|
|
|
4911
|
+
/** Babylon.js polygon-builder namespace object. */
|
|
4912
|
+
export declare const PolygonBuilder: {
|
|
4913
|
+
ExtrudePolygon: typeof ExtrudePolygon;
|
|
4914
|
+
CreatePolygon: typeof CreatePolygon;
|
|
4915
|
+
};
|
|
4916
|
+
|
|
4917
|
+
declare interface PolygonBuilderOptions {
|
|
4918
|
+
shape: Vector3[];
|
|
4919
|
+
holes?: Vector3[][];
|
|
4920
|
+
depth?: number;
|
|
4921
|
+
smoothingThreshold?: number;
|
|
4922
|
+
faceUV?: Vector4[];
|
|
4923
|
+
faceColors?: Color4[];
|
|
4924
|
+
updatable?: boolean;
|
|
4925
|
+
sideOrientation?: number;
|
|
4926
|
+
frontUVs?: Vector4;
|
|
4927
|
+
backUVs?: Vector4;
|
|
4928
|
+
wrap?: boolean;
|
|
4929
|
+
}
|
|
4930
|
+
|
|
4721
4931
|
export declare class PositionGizmo extends GizmoBase {
|
|
4722
4932
|
private _attached;
|
|
4723
4933
|
private _xGizmo;
|
|
4724
4934
|
private _yGizmo;
|
|
@@ -4921,7 +5131,7 @@ export declare class RawTexture3D extends BaseTexture {
|
|
|
4921
5131
|
readonly is3D = true;
|
|
4922
5132
|
constructor(data: ArrayBufferView | null, width: number, height: number, depth: number,
|
|
4923
5133
|
/** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
|
|
4924
|
-
format: number, scene: Scene,
|
|
5134
|
+
format: number, scene: Scene, generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number);
|
|
4925
5135
|
getClassName(): string;
|
|
4926
5136
|
/** Gets the width of the texture. */
|
|
4927
5137
|
get width(): number;
|
|
@@ -4993,8 +5203,17 @@ export declare function RegisterImageProcessingConfiguration(): void;
|
|
|
4993
5203
|
|
|
4994
5204
|
export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
4995
5205
|
|
|
5206
|
+
/** Babylon.js 9.29 node-render-graph registration function. */
|
|
5207
|
+
export declare function RegisterMinMaxReducerBlock(): never;
|
|
5208
|
+
|
|
4996
5209
|
export declare function RegisterOpenpbrMaterial(): void;
|
|
4997
5210
|
|
|
5211
|
+
/**
|
|
5212
|
+
* Babylon.js side-effect registration shim. Compat defines the corresponding
|
|
5213
|
+
* methods directly, so importing or calling this function requires no mutation.
|
|
5214
|
+
*/
|
|
5215
|
+
export declare function RegisterPolygonBuilder(): void;
|
|
5216
|
+
|
|
4998
5217
|
export declare function RegisterSPLATFileLoader(): void;
|
|
4999
5218
|
|
|
5000
5219
|
export declare function RegisterUSDFileLoader(): void;
|
|
@@ -5277,14 +5496,14 @@ export declare class Scene extends AbstractScene {
|
|
|
5277
5496
|
/** Babylon.js fog-mode c
|
|
5278
5497
|
/** Babylon.js synchronous readiness check — always ready in the compat layer. */
|
|
5279
5498
|
isReady(): boolean;
|
|
5280
5499
|
/** Babylon.js synchronous screen-coordinate picking over Lite's CPU ray picker. */
|
|
5281
|
-
pick(x: number, y: number, predicate?:
|
|
5500
|
+
pick(x: number, y: number, predicate?: MeshPredicate, fastCheck?: boolean, camera?: Camera | null, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
|
|
5282
5501
|
/**
|
|
5283
5502
|
* Babylon.js `Scene.createPickingRay` — translate CSS coordinates and camera
|
|
5284
5503
|
* transforms into Lite's reverse-Z unprojection helper.
|
|
5285
5504
|
*/
|
|
5286
5505
|
createPickingRay(x: number, y: number, world?: Matrix | null, camera?: Camera | null, cameraViewSpace?: boolean): Ray;
|
|
5287
5506
|
/** Synchronous CPU ray picking over Babylon Lite's scene-mesh picker. */
|
|
5288
|
-
pickWithRay(ray: Ray, predicate?: (mesh: AbstractMesh) => boolean, fastCheck?: boolean, trianglePredicate?: (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray) => boolean): PickingInfo;
|
|
5289
5507
|
/**
|
|
5508
|
+
pickWithRay(ray: Ray, predicate?: MeshPredicate, fastCheck?: boolean, trianglePredicate?: TrianglePickingPredicate): PickingInfo;
|
|
5290
5509
|
/**
|
|
5291
5510
|
* Babylon.js `scene.enablePhysics(gravity, plugin)`. Wires the given Havok V2
|
|
5292
5511
|
* {@link HavokPlugin} to this scene, creating the native Lite physics world and
|
|
5293
5512
|
* registering per-frame stepping. The plugin's `useDeltaForWorldStep` flag
|
|
@@ -6174,6 +6393,8 @@ export declare class TransformNode extends Node_2 {
|
|
|
6174
6393
|
physicsBody: PhysicsBody
|
|
6175
6394
|
|
|
6176
6395
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
6177
6396
|
|
|
6397
|
+
export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
|
|
6398
|
+
|
|
6178
6399
|
/** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
|
|
6179
6400
|
export declare class UniformBuffer {
|
|
6180
6401
|
private readonly _engine;
|
|
@@ -6525,6 +6746,8 @@ export declare class VertexData {
|
|
|
6525
6746
|
uvs: number[] | Float32Array | null;
|
|
6526
6747
|
colors: number[] | Float32Array | null;
|
|
6527
6748
|
indices: number[] | Uint32Array | Uint16Array | null;
|
|
6749
|
+
/** Deprecated Babylon.js polygon vertex-data entry point. */
|
|
6750
|
+
static CreatePolygon(polygon: Mesh, sideOrientation: number, faceUV?: Vector4[], faceColors?: Color4[], frontUVs?: Vector4, backUVs?: Vector4, wrap?: boolean): never;
|
|
6528
6751
|
/**
|
|
6529
6752
|
* Babylon.js `VertexData.applyToMesh(mesh)` — upload this CPU geometry onto a
|
|
6530
6753
|
* mesh (typically one created via `new Mesh(name, scene)`). Replaces the Lite
|
|
@@ -6559,6 +6782,15 @@ export declare class VirtualJoystick {
|
|
|
6559
6782
|
export declare class WebGPUEngine extends AbstractEngine {
|
|
6560
6783
|
}
|
|
6561
6784
|
|
|
6785
|
+
/** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
|
|
6786
|
+
export declare interface WebGPUEngineOptions extends EngineOptions {
|
|
6787
|
+
antialias?: boolean;
|
|
6788
|
+
adaptToDeviceRatio?: boolean;
|
|
6789
|
+
useLargeWorldRendering?: boolean;
|
|
6790
|
+
canvasToneMapping?: GPUCanvasToneMapping;
|
|
6791
|
+
canvasColorSpace?: PredefinedColorSpace;
|
|
6792
|
+
}
|
|
6793
|
+
|
|
6562
6794
|
/** Babylon.js `WebXRCamera` — WebXR is not part of Babylon Lite. */
|
|
6563
6795
|
export declare class WebXRCamera {
|
|
6564
6796
|
constructor();
|