@babylonjs/lite-compat 1.37.0-preview → 1.37.1-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 +112 -3
- package/index.d.ts +142 -15
- package/index.js +144 -23
- package/index.js.map +1 -1
- package/{meshes-zeNif9yt.js → meshes-BqMDWl4h.js} +33 -13
- package/meshes-BqMDWl4h.js.map +1 -0
- package/navigation.d.ts +38 -8
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-zeNif9yt.js.map +0 -1
package/README.md
CHANGED
|
@@ -118,7 +118,7 @@ overloads within a supported area may still be absent.
|
|
|
118
118
|
| Feature area | Status | Notes |
|
|
119
119
|
| ----------------------------------------------------------------------------------------------------------------------------------------- | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
120
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
|
-
| 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
|
|
121
|
+
| Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; reverse-depth constructor options/state are exposed over Lite's fixed reverse-Z pipeline; `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
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 |
|
|
@@ -144,14 +144,18 @@ overloads within a supported area may still be absent.
|
|
|
144
144
|
| Feature area | Status | Notes |
|
|
145
145
|
| ---------------------------------------------------------------------------------------------- | :----: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
146
146
|
| glTF 2.0 (+ extensions), `.babylon` | ✅ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime |
|
|
147
|
-
| `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/export planning throws with named structural blockers
|
|
147
|
+
| `GLTF2.KHR_interactivity` public helpers | ⚡ | pure operation/data normalization and exporter data types are implemented; BJS FlowGraph registry/parser/block/export planning throws with named structural blockers |
|
|
148
148
|
| glTF 1.0 loader and extensions | ❌ | named `GLTF1` stubs throw; Lite has no legacy parser, extension registry, or material-conversion subsystem |
|
|
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`) | ⚡ | `GaussianSplattingMesh` wraps eager Lite loaders; BJS streaming and the separate stochastic WebGPU point-splatting compute path resolve to named stubs because their budget, pass-lifecycle, and rendering models do not map to Lite's sorted-splat renderer |
|
|
152
|
+
| Gaussian Splatting (`.ply` / `.splat` / `.sog` / `.spz`) | ⚡ | `GaussianSplattingMesh` wraps eager Lite loaders; BJS streaming (including range residency) and the separate stochastic WebGPU point-splatting compute path resolve to named stubs because their budget, pass-lifecycle, and rendering models do not map to Lite's sorted-splat renderer |
|
|
153
153
|
| `OBJ` / `STL` / `FBX` / `BVH` | ❌ | parser/materializer subsystems are not in Lite — convert to glTF |
|
|
154
154
|
|
|
155
|
+
> **glTF hierarchy:** `result.meshes` is a flattened view of the glTF node hierarchy (transform nodes plus the
|
|
156
|
+
> primitive meshes beneath them), not one mesh per node as in Babylon.js. Reparent with `setParent()`, not `.parent =`,
|
|
157
|
+
> when you flatten it — see [glTF import hierarchy and reparenting](#gltf-import-hierarchy-and-reparenting).
|
|
158
|
+
|
|
155
159
|
### `@babylonjs/addons` · `@recast-navigation/*`
|
|
156
160
|
|
|
157
161
|
| Feature area | Status | Notes |
|
|
@@ -174,6 +178,111 @@ The intended migration path is:
|
|
|
174
178
|
@babylonjs/core → @babylonjs/lite-compat → babylon-lite (native)
|
|
175
179
|
```
|
|
176
180
|
|
|
181
|
+
## glTF import hierarchy and reparenting
|
|
182
|
+
|
|
183
|
+
Babylon Lite keeps the glTF node hierarchy: every glTF node becomes a transform node, and every primitive of its mesh
|
|
184
|
+
becomes a mesh **under** that node. For a node with a single primitive, Babylon.js instead returns one `Mesh` that
|
|
185
|
+
carries both the node transform and the geometry. The compat layer rebuilds Lite's hierarchy as canonical wrappers and
|
|
186
|
+
returns it flattened, in hierarchy order, from `SceneLoader.ImportMeshAsync(...).meshes` and `AssetContainer.meshes`:
|
|
187
|
+
|
|
188
|
+
- The list is a flattened view of a retained hierarchy, not a list of independent renderable meshes. A parent always
|
|
189
|
+
comes before its children.
|
|
190
|
+
- It contains the synthetic `__root__` at index 0, the source glTF transform nodes, and the primitive meshes beneath
|
|
191
|
+
them.
|
|
192
|
+
- Transform-only entries are wrapped as `Mesh` too, but carry no geometry: `getTotalVertices() === 0`. Do not treat an
|
|
193
|
+
entry as geometry just because it is a `Mesh`.
|
|
194
|
+
|
|
195
|
+
### Why per-entry `.parent` breaks
|
|
196
|
+
|
|
197
|
+
`mesh.parent = node` keeps the mesh's **local** transform and lets its world transform change under the new parent.
|
|
198
|
+
`mesh.setParent(node)` keeps its **world** transform. Both behave as in Babylon.js, but a loop written for Babylon.js
|
|
199
|
+
often assigns `.parent` to every returned entry:
|
|
200
|
+
|
|
201
|
+
```ts
|
|
202
|
+
// Fine in Babylon.js. Under compat it detaches each primitive from the glTF node that carries its transform.
|
|
203
|
+
for (const mesh of result.meshes) {
|
|
204
|
+
mesh.parent = applicationRoot;
|
|
205
|
+
}
|
|
206
|
+
```
|
|
207
|
+
|
|
208
|
+
Under compat every primitive mesh is then moved off the glTF node above it and keeps only its own local transform, so
|
|
209
|
+
any scale, rotation or translation that came from an ancestor node is lost. A typical case is a hardware asset modelled
|
|
210
|
+
in millimetres whose glTF node scales it by `0.001`: after the loop its primitives render 1000 times too large, so a
|
|
211
|
+
40 mm connector becomes 40 m, often far outside the camera range.
|
|
212
|
+
|
|
213
|
+
Baking in list order fails the same way. `bakeCurrentTransformIntoVertices()` bakes only the mesh's **local**
|
|
214
|
+
transform: on a primitive that still sits under its glTF node it leaves the node's scale out, and resetting a node's
|
|
215
|
+
transform first (it comes earlier in the list) changes what its children inherit before they are processed.
|
|
216
|
+
|
|
217
|
+
### Safe patterns
|
|
218
|
+
|
|
219
|
+
Keep the hierarchy and move the whole import:
|
|
220
|
+
|
|
221
|
+
```ts
|
|
222
|
+
import { Mesh, SceneLoader } from "@babylonjs/lite-compat";
|
|
223
|
+
|
|
224
|
+
const result = await SceneLoader.ImportMeshAsync("", rootUrl, "model.glb", scene);
|
|
225
|
+
result.meshes[0]!.setParent(applicationRoot);
|
|
226
|
+
```
|
|
227
|
+
|
|
228
|
+
Flatten only the renderable meshes, keeping their current world transforms. `result.meshes` is typed as
|
|
229
|
+
`TransformNode[]`, so narrow the entries to `Mesh` before calling mesh-only methods:
|
|
230
|
+
|
|
231
|
+
```ts
|
|
232
|
+
const renderableMeshes = result.meshes.filter((mesh): mesh is Mesh => mesh instanceof Mesh && mesh.getTotalVertices() > 0);
|
|
233
|
+
for (const mesh of renderableMeshes) {
|
|
234
|
+
mesh.setParent(applicationRoot);
|
|
235
|
+
}
|
|
236
|
+
```
|
|
237
|
+
|
|
238
|
+
Baking the composed transform into the geometry works only for a narrow set of imported meshes. For those, call
|
|
239
|
+
`setParent()` first, so the full hierarchy-composed world transform becomes the mesh's new local transform, then bake:
|
|
240
|
+
|
|
241
|
+
```ts
|
|
242
|
+
// bakeableMeshes: the entries of renderableMeshes that meet every condition listed below.
|
|
243
|
+
for (const mesh of bakeableMeshes) {
|
|
244
|
+
mesh.setParent(applicationRoot);
|
|
245
|
+
mesh.bakeCurrentTransformIntoVertices();
|
|
246
|
+
}
|
|
247
|
+
```
|
|
248
|
+
|
|
249
|
+
Bake a mesh only if all of the following hold. Otherwise flatten it with `setParent()` alone, or keep the hierarchy and
|
|
250
|
+
move the whole import:
|
|
251
|
+
|
|
252
|
+
- **Shear-free composed transform.** `setParent()` keeps the exact affine local matrix, but
|
|
253
|
+
`bakeCurrentTransformIntoVertices()` rebuilds the transform from position, rotation and scaling, and that cannot
|
|
254
|
+
express shear. Shear appears when an ancestor has a non-uniform scale and a descendant below it is rotated: for
|
|
255
|
+
example, a node scaled `(2, 1, 1)` above a primitive rotated 45 degrees around Z. Baking such a primitive drops the
|
|
256
|
+
shear and changes the geometry.
|
|
257
|
+
- **Tightly packed vertex data.** Baking replaces the vertex buffers through `resizeMeshGeometry()`, which throws for
|
|
258
|
+
interleaved geometry. A glTF primitive loads as interleaved only when at least one of its vertex attributes comes
|
|
259
|
+
from a bufferView whose `byteStride` is larger than that attribute's element size, for example positions and normals
|
|
260
|
+
sharing one bufferView with `byteStride: 24`, and no loader extension such as Draco has already decoded it. A
|
|
261
|
+
`byteStride` equal to the element size, which many exporters write on tightly packed bufferViews, keeps the primitive
|
|
262
|
+
on the tightly packed path.
|
|
263
|
+
- **Undeformed geometry.** The baker transforms the base positions, normals and tangents only. It does not transform
|
|
264
|
+
morph target deltas, so after baking a delta contributes in the baked space: under an inherited uniform scale of
|
|
265
|
+
`0.001`, a delta of 1 contributes `0.001` before baking and `1` after. Skinned meshes are not covered either, and
|
|
266
|
+
flattening already detaches a primitive from any animated glTF node above it. Keep the hierarchy for assets whose
|
|
267
|
+
morph targets, skinning or node animation must keep working.
|
|
268
|
+
- **Only positions, normals and the first UV set.** Baking can only re-upload the vertex attributes whose CPU arrays are
|
|
269
|
+
retained. The glTF loader uploads `COLOR_0` and `TEXCOORD_1` without keeping CPU copies, so baking drops vertex colors
|
|
270
|
+
and the second UV set, and it retains tangents only after `enableGltfCpuTangents()` from `@babylonjs/lite` is called before loading.
|
|
271
|
+
- **No thin instances.** This includes every primitive on a glTF node with `EXT_mesh_gpu_instancing`, which the loader
|
|
272
|
+
draws as thin instances: their matrices stay in the node's local frame, and the shader composes
|
|
273
|
+
`mesh.world * instanceWorld`. Baking transforms only the prototype geometry and resets the mesh transform, but not the
|
|
274
|
+
instance matrices, so the instance offsets end up in the baked space: under an inherited uniform scale of `0.001`, an
|
|
275
|
+
instance translation of `(0, 1, 0)` contributes `0.001` before baking and `1` after, and the copies scatter. Flatten
|
|
276
|
+
such meshes with `setParent()` alone, or keep the hierarchy.
|
|
277
|
+
- **Triangle lists only.** The glTF loader keeps the topology of line, line-strip and triangle-strip primitives, but the
|
|
278
|
+
baker treats every index buffer as a triangle list. When the baked transform mirrors the geometry, it swaps the second
|
|
279
|
+
and third index of each group of three to keep the winding. Flattening a glTF import under an identity
|
|
280
|
+
`applicationRoot` includes the mirroring of its synthetic handedness root, so a line list `[0, 1, 2, 3, 4, 5]` becomes
|
|
281
|
+
`[0, 2, 1, 3, 5, 4]` and connects other vertices; strips lose their connectivity the same way. Flatten line and strip
|
|
282
|
+
primitives with `setParent()` alone.
|
|
283
|
+
|
|
284
|
+
`setParent()` also preserves mirrored transforms, including the synthetic handedness root of glTF imports (#456).
|
|
285
|
+
|
|
177
286
|
## Missing an API you need?
|
|
178
287
|
|
|
179
288
|
The compat surface grows in response to real-world migration needs. If you hit a
|
package/index.d.ts
CHANGED
|
@@ -5,7 +5,7 @@ import { AudioGraphHost } from '@babylonjs/lite';
|
|
|
5
5
|
import { ClearCoatProps } from '@babylonjs/lite';
|
|
6
6
|
import { ComputeShader as ComputeShader_2 } from '@babylonjs/lite';
|
|
7
7
|
import { EngineContext } from '@babylonjs/lite';
|
|
8
|
-
import { EngineOptions } from '@babylonjs/lite';
|
|
8
|
+
import { EngineOptions as EngineOptions_2 } from '@babylonjs/lite';
|
|
9
9
|
import { IridescenceProps } from '@babylonjs/lite';
|
|
10
10
|
import { LineMaterial } from '@babylonjs/lite';
|
|
11
11
|
import { MaxTintMagnitude } from '@babylonjs/lite';
|
|
@@ -243,12 +243,19 @@ export declare abstract class AbstractEngine {
|
|
|
243
243
|
private _ensureInitialized;
|
|
244
244
|
}
|
|
245
245
|
|
|
246
|
+
/** Babylon.js `AbstractEngineOptions` subset accepted by the compat engine. */
|
|
247
|
+
export declare interface AbstractEngineOptions extends EngineOptions_2 {
|
|
248
|
+
antialias?: boolean;
|
|
249
|
+
adaptToDeviceRatio?: boolean;
|
|
250
|
+
useLargeWorldRendering?: boolean;
|
|
251
|
+
useReverseDepthBuffer?: boolean;
|
|
252
|
+
}
|
|
253
|
+
|
|
246
254
|
/**
|
|
247
255
|
* Babylon.js `AbstractMesh` — a renderable transform node with a material,
|
|
248
256
|
* visibility, and shadow-receipt. Concrete meshes derive from this.
|
|
249
257
|
*/
|
|
250
|
-
export declare class AbstractMesh extends TransformNode {
|
|
251
258
|
private _material;
|
|
252
|
-
|
|
259
|
+
export declare class AbstractMesh extends TransformNode {
|
|
253
260
|
private _material;
|
|
254
261
|
private _meshBlendingTag;
|
|
255
262
|
protected _visible: boolean;
|
|
256
263
|
constructor(name: string, lite: Mesh_2, scene?: Scene);
|
|
257
264
|
getClassName(): string;
|
|
258
265
|
get material(): CompatMaterial | null;
|
|
@@ -811,6 +818,7 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
811
818
|
constructor(name: stri
|
|
812
819
|
set beta(value: number);
|
|
813
820
|
get radius(): number;
|
|
814
821
|
set radius(value: number);
|
|
822
|
+
/** Live, as in Babylon.js: `camera.target.x = …` and in-place vector math move the target. */
|
|
815
823
|
get target(): Vector3;
|
|
816
824
|
set target(value: Vector3);
|
|
817
825
|
/** Babylon.js `setTarget` — point the arc-rotate camera at a world-space target. */
|
|
@@ -1708,6 +1716,11 @@ export declare class CubeTexture extends BaseTexture {
|
|
|
1708
1716
|
gammaSpace: boolean;
|
|
1709
1717
|
level: number;
|
|
1710
1718
|
/** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
|
|
1711
1719
|
readonly onLoadObservable: Observable<CubeTexture>;
|
|
1720
|
+
/**
|
|
1721
|
+
* Babylon.js `CubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
|
|
1722
|
+
* texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
|
|
1723
|
+
*/
|
|
1724
|
+
rotationY: number;
|
|
1712
1725
|
private _ready;
|
|
1713
1726
|
private readonly _readyPromise;
|
|
1714
1727
|
constructor(url: string, _scene?: unknown, _extensions?: unknown, _noMipmap?: boolean, _files?: unknown, onLoad?: (() => void) | null, _onError?: unknown, _format?: unknown, _prefiltered?: boolean);
|
|
@@ -1785,6 +1798,8 @@ export declare class DefaultRenderingPipeline {
|
|
|
1785
1798
|
constructor();
|
|
1786
1799
|
}
|
|
1787
1800
|
|
|
1801
|
+
export declare function defaultValueParseFunction(_key: string, _serializationObject: any, _assetsContainer: AssetContainer, _scene: Scene): any;
|
|
1802
|
+
|
|
1788
1803
|
export declare const DepthOfFieldEffect: new () => never;
|
|
1789
1804
|
|
|
1790
1805
|
export declare class DepthRenderer {
|
|
@@ -1976,6 +1991,11 @@ export declare class ElasticEase extends EasingFunction {
|
|
|
1976
1991
|
* Lite WebGPU context; this class exists to mirror Babylon.js's name + hierarchy.
|
|
1977
1992
|
*/
|
|
1978
1993
|
export declare class Engine extends ThinEngine {
|
|
1994
|
+
constructor(canvas: RenderCanvas, antialiasOrOptions?: boolean | EngineOptions, options?: EngineOptions, adaptToDeviceRatio?: boolean);
|
|
1995
|
+
}
|
|
1996
|
+
|
|
1997
|
+
/** Babylon.js `EngineOptions` subset accepted by the compat engine. */
|
|
1998
|
+
export declare interface EngineOptions extends AbstractEngineOptions {
|
|
1979
1999
|
}
|
|
1980
2000
|
|
|
1981
2001
|
/** Babylon.js-compatible scalar helpers and a small set of math constants. */
|
|
@@ -2143,6 +2163,15 @@ export declare type FBXNormalMapCoordinateSystem = "y-up" | "y-down";
|
|
|
2143
2163
|
|
|
2144
2164
|
declare type FloatArray = number[] | Float32Array;
|
|
2145
2165
|
|
|
2166
|
+
export declare interface FlowGraphContext {
|
|
2167
|
+
_getGlobalContextVariable<T>(name: string, defaultValue: T): T;
|
|
2168
|
+
_setGlobalContextVariable<T>(name: string, value: T): void;
|
|
2169
|
+
}
|
|
2170
|
+
|
|
2171
|
+
export declare interface FlowGraphPlayAnimationBlock {
|
|
2172
|
+
getClassName(): string;
|
|
2173
|
+
}
|
|
2174
|
+
|
|
2146
2175
|
export declare enum FlowGraphValidationSeverity {
|
|
2147
2176
|
Error = 0,
|
|
2148
2177
|
Warning = 1
|
|
@@ -2425,6 +2454,10 @@ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
|
|
|
2425
2454
|
get debugLodSource(): never;
|
|
2426
2455
|
set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
|
|
2427
2456
|
evaluateOptimalLods(_camera?: unknown): never;
|
|
2457
|
+
getSourceRange(_fileId: number): Readonly<IGaussianSplattingStreamSourceRange> | null;
|
|
2458
|
+
isSplitPage(_fileId: number): boolean;
|
|
2459
|
+
cancelRangeLoads(_files: readonly number[], _keepSources?: readonly number[]): void;
|
|
2460
|
+
get rangeResidencyStats(): Readonly<IGaussianSplattingStreamRangeResidencyStats>;
|
|
2428
2461
|
}
|
|
2429
2462
|
|
|
2430
2463
|
export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
|
|
@@ -2592,6 +2625,8 @@ export declare namespace GLTF2 {
|
|
|
2592
2625
|
IKHRInteractivityTypeMapping,
|
|
2593
2626
|
gltfTypeToBabylonType,
|
|
2594
2627
|
IFlowGraphEventReferenceBlockConfiguration,
|
|
2628
|
+
IFlowGraphDelayReferenceBlockConfiguration,
|
|
2629
|
+
FlowGraphDelayReferenceBlock,
|
|
2595
2630
|
FlowGraphEventReferenceBlock,
|
|
2596
2631
|
IFlowGraphGLTFDataProviderBlockConfiguration,
|
|
2597
2632
|
FlowGraphGLTFDataProvider,
|
|
@@ -2880,6 +2915,11 @@ export declare class HDRCubeTexture extends BaseTexture {
|
|
|
2880
2915
|
gammaSpace: boolean;
|
|
2881
2916
|
level: number;
|
|
2882
2917
|
/** Fires when the HDR environment is "ready" (resolved on a microtask). */
|
|
2883
2918
|
readonly onLoadObservable: Observable<HDRCubeTexture>;
|
|
2919
|
+
/**
|
|
2920
|
+
* Babylon.js `HDRCubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
|
|
2921
|
+
* texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
|
|
2922
|
+
*/
|
|
2923
|
+
rotationY: number;
|
|
2884
2924
|
private _ready;
|
|
2885
2925
|
private readonly _readyPromise;
|
|
2886
2926
|
constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
|
|
@@ -3091,6 +3131,14 @@ export declare interface IEasingFunction {
|
|
|
3091
3131
|
ease(gradient: number): number;
|
|
3092
3132
|
}
|
|
3093
3133
|
|
|
3134
|
+
export declare interface IFlowGraphAnimationObserverSet {
|
|
3135
|
+
block: FlowGraphPlayAnimationBlock;
|
|
3136
|
+
groupEnd: Observer<AnimationGroup>;
|
|
3137
|
+
animationEnd: Observer<any>;
|
|
3138
|
+
animationLoop: Observer<any>;
|
|
3139
|
+
groupLoop: Observer<AnimationGroup>;
|
|
3140
|
+
}
|
|
3141
|
+
|
|
3094
3142
|
export declare interface IFlowGraphValidationIssue {
|
|
3095
3143
|
severity: FlowGraphValidationSeverity;
|
|
3096
3144
|
message: string;
|
|
@@ -3186,6 +3234,28 @@ export declare interface IGaussianSplattingStreamOptions {
|
|
|
3186
3234
|
hostCompound?: GaussianSplattingMesh;
|
|
3187
3235
|
decodeSh?: boolean;
|
|
3188
3236
|
needsRotationScale?: boolean;
|
|
3237
|
+
rangeResidency?: boolean;
|
|
3238
|
+
rangePack?: (source: Readonly<IGaussianSplattingStreamSourceRange>, sourceData: SOGRootData) => IGaussianSplattingStreamRangePack | null;
|
|
3239
|
+
}
|
|
3240
|
+
|
|
3241
|
+
export declare interface IGaussianSplattingStreamRangePack {
|
|
3242
|
+
sogData: SOGRootData;
|
|
3243
|
+
subRootUrl: string;
|
|
3244
|
+
}
|
|
3245
|
+
|
|
3246
|
+
export declare interface IGaussianSplattingStreamRangeResidencyStats {
|
|
3247
|
+
enabled: boolean;
|
|
3248
|
+
pages: number;
|
|
3249
|
+
sourcePackLoads: number;
|
|
3250
|
+
sourcePackReuses: number;
|
|
3251
|
+
splitPackLoads: number;
|
|
3252
|
+
cachedSourceSplats: number;
|
|
3253
|
+
}
|
|
3254
|
+
|
|
3255
|
+
export declare interface IGaussianSplattingStreamSourceRange {
|
|
3256
|
+
file: number;
|
|
3257
|
+
offset: number;
|
|
3258
|
+
count: number;
|
|
3189
3259
|
}
|
|
3190
3260
|
|
|
3191
3261
|
/** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
|
|
@@ -3836,6 +3906,7 @@ export declare class Matrix {
|
|
|
3836
3906
|
multiplyToRef(other: Matrix, result: Matrix): Matrix;
|
|
3837
3907
|
transpose(): Matrix;
|
|
3838
3908
|
determinant(): number;
|
|
3909
|
+
/** Babylon.js `invert`: inverts this matrix in place and returns it. */
|
|
3839
3910
|
invert(): Matrix;
|
|
3840
3911
|
invertToRef(result: Matrix): Matrix;
|
|
3841
3912
|
getTranslation(): Vector3;
|
|
@@ -4289,6 +4360,14 @@ export declare class Observable<T> {
|
|
|
4289
4360
|
cleanLastNotifiedState(): void;
|
|
4290
4361
|
}
|
|
4291
4362
|
|
|
4363
|
+
export declare interface Observer<T> {
|
|
4364
|
+
callback: (eventData: T, eventState: unknown) => void;
|
|
4365
|
+
mask: number;
|
|
4366
|
+
scope: any;
|
|
4367
|
+
unregisterOnNextCall: boolean;
|
|
4368
|
+
remove(defer?: boolean): void;
|
|
4369
|
+
}
|
|
4370
|
+
|
|
4292
4371
|
/**
|
|
4293
4372
|
* Minimal Babylon.js-compatible `Observable`.
|
|
4294
4373
|
*
|
|
@@ -5004,8 +5083,10 @@ export declare class PointerEventTypes {
|
|
|
5004
5083
|
export declare class PointerInfo {
|
|
5005
5084
|
type: number;
|
|
5006
5085
|
event: PointerEvent | WheelEvent;
|
|
5007
|
-
private
|
|
5008
|
-
|
|
5086
|
+
private _pickInfo;
|
|
5087
|
+
private _pick;
|
|
5088
|
+
constructor(type: number, event: PointerEvent | WheelEvent, _pickInfo: PickingInfo | null, _pick?: (() => PickingInfo) | null);
|
|
5089
|
+
/** Like Babylon.js lazy picking: without a precomputed pick, `_pick` runs on the first read only. */
|
|
5009
5090
|
get pickInfo(): PickingInfo | null;
|
|
5010
5091
|
}
|
|
5011
5092
|
|
|
@@ -5102,8 +5183,12 @@ export declare class PositionGizmo extends GizmoBase {
|
|
|
5102
5183
|
private _attached;
|
|
5103
5184
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5104
5185
|
get attachedMesh(): AbstractMesh | null;
|
|
5105
5186
|
set attachedMesh(value: AbstractMesh | null);
|
|
5106
|
-
|
|
5107
|
-
|
|
5187
|
+
/**
|
|
5188
|
+
* Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
|
|
5189
|
+
* Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
|
|
5190
|
+
*/
|
|
5191
|
+
get attachedNode(): Node_2 | null;
|
|
5192
|
+
set attachedNode(value: Node_2 | null);
|
|
5108
5193
|
dispose(): void;
|
|
5109
5194
|
}
|
|
5110
5195
|
|
|
@@ -5160,6 +5245,7 @@ export declare class Quaternion {
|
|
|
5160
5245
|
constructor(x?: number, y?: number, z?: number, w?: number);
|
|
5161
5246
|
set(x: number, y: number, z: number, w: number): this;
|
|
5162
5247
|
copyFrom(source: Quaternion): this;
|
|
5248
|
+
/** Babylon.js `multiply`: the product `this · other` as a new quaternion. */
|
|
5163
5249
|
multiply(other: Quaternion): Quaternion;
|
|
5164
5250
|
length(): number;
|
|
5165
5251
|
normalize(): this;
|
|
@@ -5394,6 +5480,8 @@ export declare function RegisterSPLATFileLoader(): void;
|
|
|
5394
5480
|
|
|
5395
5481
|
export declare function RegisterUSDFileLoader(): void;
|
|
5396
5482
|
|
|
5483
|
+
export declare function RemoveFlowGraphAnimationGroupObservers(_context: FlowGraphContext, _animationGroup: AnimationGroup): FlowGraphPlayAnimationBlock | undefined;
|
|
5484
|
+
|
|
5397
5485
|
/** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
|
|
5398
5486
|
export declare class RenderTargetTexture {
|
|
5399
5487
|
constructor();
|
|
@@ -5461,8 +5549,12 @@ export declare class RotationGizmo extends GizmoBase {
|
|
|
5461
5549
|
private _attached;
|
|
5462
5550
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5463
5551
|
get attachedMesh(): AbstractMesh | null;
|
|
5464
5552
|
set attachedMesh(value: AbstractMesh | null);
|
|
5465
|
-
|
|
5466
|
-
|
|
5553
|
+
/**
|
|
5554
|
+
* Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
|
|
5555
|
+
* Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
|
|
5556
|
+
*/
|
|
5557
|
+
get attachedNode(): Node_2 | null;
|
|
5558
|
+
set attachedNode(value: Node_2 | null);
|
|
5467
5559
|
dispose(): void;
|
|
5468
5560
|
}
|
|
5469
5561
|
|
|
@@ -5491,8 +5583,12 @@ export declare class ScaleGizmo extends GizmoBase {
|
|
|
5491
5583
|
private _attached;
|
|
5492
5584
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5493
5585
|
get attachedMesh(): AbstractMesh | null;
|
|
5494
5586
|
set attachedMesh(value: AbstractMesh | null);
|
|
5495
|
-
|
|
5496
|
-
|
|
5587
|
+
/**
|
|
5588
|
+
* Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
|
|
5589
|
+
* Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
|
|
5590
|
+
*/
|
|
5591
|
+
get attachedNode(): Node_2 | null;
|
|
5592
|
+
set attachedNode(value: Node_2 | null);
|
|
5497
5593
|
dispose(): void;
|
|
5498
5594
|
}
|
|
5499
5595
|
|
|
@@ -5526,6 +5622,9 @@ export declare class Scene extends AbstractScene {
|
|
|
5526
5622
|
/** Babylon.js fog-mode c
|
|
5527
5623
|
private readonly _engine;
|
|
5528
5624
|
private _activeCamera;
|
|
5529
5625
|
cameraToUseForPointers: Camera | null;
|
|
5626
|
+
/** Babylon.js `scene.pointerX` / `pointerY`: the last pointer position in CSS pixels relative to the canvas. */
|
|
5627
|
+
pointerX: number;
|
|
5628
|
+
pointerY: number;
|
|
5530
5629
|
private _defaultMaterial;
|
|
5531
5630
|
private _fogMode;
|
|
5532
5631
|
private _fogStart;
|
|
@@ -5533,6 +5632,8 @@ export declare class Scene extends AbstractScene {
|
|
|
5533
5632
|
/** Babylon.js fog-mode c
|
|
5534
5633
|
private _fogDensity;
|
|
5535
5634
|
private _fogColor;
|
|
5536
5635
|
private _started;
|
|
5537
5636
|
private _envTexture;
|
|
5637
|
+
/** Environment lighting rotation last forwarded to Lite. */
|
|
5638
|
+
private _envRotation;
|
|
5538
5639
|
private _brdfTexture;
|
|
5539
5640
|
private _defaultEnvOptions;
|
|
5540
5641
|
private readonly _shadowGenerators;
|
|
@@ -5622,6 +5723,13 @@ export declare class Scene extends AbstractScene {
|
|
|
5622
5723
|
/** Babylon.js fog-mode c
|
|
5623
5724
|
set clipPlane(value: Plane | null);
|
|
5624
5725
|
get environmentTexture(): CubeTexture | HDRCubeTexture | null;
|
|
5625
5726
|
set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
|
|
5727
|
+
/**
|
|
5728
|
+
* Forward the environment texture's `rotationY` to the image-based lighting only. As in Babylon.js, a skybox keeps the
|
|
5729
|
+
* orientation it was created with (see {@link createDefaultSkybox}) and the `createDefaultEnvironment` background never
|
|
5730
|
+
* turns. Also runs every frame, so the texture needs no link back to the scenes that use it. A scene whose
|
|
5731
|
+
* environment is never rotated never calls Lite.
|
|
5732
|
+
*/
|
|
5733
|
+
private _syncEnvironmentRotation;
|
|
5626
5734
|
/**
|
|
5627
5735
|
* Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
|
|
5628
5736
|
* Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
|
|
@@ -5885,6 +5993,28 @@ export declare class SmartArray<T> {
|
|
|
5885
5993
|
dispose(): void;
|
|
5886
5994
|
}
|
|
5887
5995
|
|
|
5996
|
+
declare interface SOGDataFile {
|
|
5997
|
+
shape: number[];
|
|
5998
|
+
dtype: string;
|
|
5999
|
+
mins?: number | number[];
|
|
6000
|
+
maxs?: number | number[];
|
|
6001
|
+
codebook?: number[];
|
|
6002
|
+
encoding?: string;
|
|
6003
|
+
quantization?: number;
|
|
6004
|
+
files: string[];
|
|
6005
|
+
bands?: number;
|
|
6006
|
+
}
|
|
6007
|
+
|
|
6008
|
+
declare interface SOGRootData {
|
|
6009
|
+
version?: number;
|
|
6010
|
+
means: SOGDataFile;
|
|
6011
|
+
scales: SOGDataFile;
|
|
6012
|
+
quats: SOGDataFile;
|
|
6013
|
+
sh0: SOGDataFile;
|
|
6014
|
+
shN?: SOGDataFile;
|
|
6015
|
+
count?: number;
|
|
6016
|
+
}
|
|
6017
|
+
|
|
5888
6018
|
export declare class SolidParticleSystem {
|
|
5889
6019
|
constructor();
|
|
5890
6020
|
}
|
|
@@ -6958,10 +7088,7 @@ export declare class WebGPUEngine extends AbstractEngine {
|
|
|
6958
7088
|
}
|
|
6959
7089
|
|
|
6960
7090
|
/** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
|
|
6961
|
-
export declare interface WebGPUEngineOptions extends
|
|
6962
|
-
antialias?: boolean;
|
|
6963
|
-
adaptToDeviceRatio?: boolean;
|
|
6964
|
-
useLargeWorldRendering?: boolean;
|
|
7091
|
+
export declare interface WebGPUEngineOptions extends AbstractEngineOptions {
|
|
6965
7092
|
canvasToneMapping?: GPUCanvasToneMapping;
|
|
6966
7093
|
canvasColorSpace?: PredefinedColorSpace;
|
|
6967
7094
|
}
|