@babylonjs/lite-compat 1.36.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 +223 -22
- package/index.js +345 -32
- 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 +43 -11
- 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
|
|
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;
|
|
@@ -677,13 +684,13 @@ declare class Animation_2 {
|
|
|
677
684
|
getKeys(): IAnimationKey[];
|
|
678
685
|
getHighestFrame(): number;
|
|
679
686
|
/**
|
|
680
|
-
* Assigns
|
|
681
|
-
* @param easingFunction - A Babylon.js-shaped easing object, or `null` to
|
|
687
|
+
* Assigns default easing for non-STEP segments without a key-specific easing function.
|
|
688
|
+
* @param easingFunction - A Babylon.js-shaped easing object, or `null` to use linear progress on keys without an override.
|
|
682
689
|
*/
|
|
683
690
|
setEasingFunction(easingFunction: IEasingFunction | null): void;
|
|
684
691
|
/**
|
|
685
692
|
* Gets the easing function currently assigned to this animation.
|
|
686
|
-
* @returns The assigned easing object, or `null` when
|
|
693
|
+
* @returns The assigned default easing object, or `null` when keys without an override use linear progress.
|
|
687
694
|
*/
|
|
688
695
|
getEasingFunction(): IEasingFunction | null;
|
|
689
696
|
/** Evaluate the animated value at `frame`, clamped to the key range. */
|
|
@@ -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
|
|
@@ -2244,6 +2273,58 @@ export declare class GamepadCamera extends UniversalCamera {
|
|
|
2244
2273
|
getClassName(): string;
|
|
2245
2274
|
}
|
|
2246
2275
|
|
|
2276
|
+
export declare class GaussianPointSplattingBlitMaterial extends ShaderMaterial {
|
|
2247
2277
|
constructor(_name: string, _scene: Scene);
|
|
2278
|
+
setAccumBuffer(_buffer: StorageBuffer): void;
|
|
2279
|
+
setAccumDepthBuffer(_buffer: StorageBuffer): void;
|
|
2280
|
+
setResolution(_width: number, _height: number): void;
|
|
2281
|
+
setProjectionZ(_m10: number, _m11: number, _m14: number, _m15: number): void;
|
|
2282
|
+
setInverseProjection(_inverseProjection: Matrix): void;
|
|
2283
|
+
setLogarithmicDepthConstant(_constant: number): void;
|
|
2284
|
+
}
|
|
2285
|
+
|
|
2286
|
+
export declare class GaussianPointSplattingDepthBlitMaterial extends ShaderMaterial {
|
|
2248
2287
|
constructor(_name: string, _scene: Scene);
|
|
2288
|
+
setAccumBuffer(_buffer: StorageBuffer): void;
|
|
2289
|
+
setAccumDepthBuffer(_buffer: StorageBuffer): void;
|
|
2290
|
+
setResolution(_width: number, _height: number): void;
|
|
2291
|
+
setProjectionZ(_m10: number, _m11: number, _m14: number, _m15: number): void;
|
|
2292
|
+
setInverseProjection(_inverseProjection: Matrix): void;
|
|
2293
|
+
setDepthValues(_minZ: number, _minZPlusMaxZ: number): void;
|
|
2294
|
+
setReverseDepth(_reverse: boolean): void;
|
|
2295
|
+
}
|
|
2296
|
+
|
|
2297
|
+
export declare class GaussianPointSplattingRenderer {
|
|
2298
|
+
pointScale: number;
|
|
2299
|
+
kernelSize: number;
|
|
2300
|
+
minPixelSize: number;
|
|
2301
|
+
rightHandedSystem: boolean;
|
|
2302
|
+
debugActive: number;
|
|
2303
|
+
isOrthographic: boolean;
|
|
2304
|
+
compensation: boolean;
|
|
2305
|
+
occlusionCulling: boolean;
|
|
2306
|
+
maxAccumFrames: number;
|
|
2307
|
+
constructor(_engine: AbstractEngine);
|
|
2308
|
+
supportsWorkload(_gaussianCount: number, _shDegree: number, _outWidth: number, _outHeight: number): boolean;
|
|
2309
|
+
get accumBuffer(): StorageBuffer | null;
|
|
2310
|
+
get accumDepthBuffer(): StorageBuffer | null;
|
|
2311
|
+
get renderedFrameCount(): number;
|
|
2312
|
+
get accumulationVersion(): number;
|
|
2313
|
+
get pixelCycleLength(): number;
|
|
2314
|
+
readPointCountAsync(): Promise<number>;
|
|
2315
|
+
get width(): number;
|
|
2316
|
+
get height(): number;
|
|
2317
|
+
get outputWidth(): number;
|
|
2318
|
+
get outputHeight(): number;
|
|
2319
|
+
get gaussianCount(): number;
|
|
2320
|
+
isReady(): boolean;
|
|
2321
|
+
updateSplats(_means: Float32Array, _cov3d: Uint32Array, _colorOpacity: Uint32Array, _sh: Uint32Array | null, _shDegree: number, _count: number): void;
|
|
2322
|
+
resetAccumulation(): void;
|
|
2323
|
+
setCamera(_view: Matrix, _viewProjection: Matrix, _near: number, _far: number, _focalX: number, _focalY: number, _camX: number, _camY: number, _camZ: number, _viewZMin: number, _viewZMax: number): void;
|
|
2324
|
+
setProjectionZ(_m10: number, _m11: number, _m14: number, _m15: number): void;
|
|
2325
|
+
setProjectionMatrix(_projection: Matrix, _inverseProjection: Matrix, _reverseDepth?: boolean): void;
|
|
2326
|
+
setPartData(_packed: Float32Array, _count: number): void;
|
|
2249
2327
|
renderToBuffer(_width: number, _height: number, _outWidth?: number, _outHeight?: number, _upsampleN?: number, _jitterX?: number, _jitterY?: number): boolean;
|
|
2328
|
+
dispose(): void;
|
|
2329
|
+
}
|
|
2330
|
+
|
|
2250
2331
|
export declare class GaussianSplattingDebugMaterialPlugin extends MaterialPluginBase {
|
|
2251
2332
|
constructor(material: GaussianSplattingMaterial);
|
|
2252
2333
|
}
|
|
2253
2334
|
|
|
@@ -2271,6 +2352,17 @@ export declare class GaussianSplattingMesh extends TransformNode {
|
|
|
2271
2352
|
/**
|
|
2272
2353
|
* to Lite's splat loaders; the field is exposed here for shape parity so ported reads resolve.
|
|
2273
2354
|
*/
|
|
2274
2355
|
safeOrbitCameraLimits: ISafeOrbitCameraLimits | null;
|
|
2356
|
+
get pointSplattingRenderScale(): number | "auto";
|
|
2357
|
+
set pointSplattingRenderScale(value: number | "auto");
|
|
2358
|
+
get pointSplattingOcclusionCulling(): boolean;
|
|
2359
|
+
set pointSplattingOcclusionCulling(value: boolean);
|
|
2360
|
+
get pointSplattingRenderMode(): boolean;
|
|
2361
|
+
set pointSplattingRenderMode(value: boolean);
|
|
2362
|
+
get pointSplattingDepthRenderMode(): boolean;
|
|
2363
|
+
set pointSplattingDepthRenderMode(value: boolean);
|
|
2364
|
+
get pointSplattingProgress(): IGaussianPointSplattingProgress | null;
|
|
2365
|
+
get pointSplattingScale(): number;
|
|
2366
|
+
set pointSplattingScale(value: number);
|
|
2275
2367
|
constructor(name: string, url?: string | null, scene?: Scene, _keepInRam?: boolean);
|
|
2276
2368
|
getClassName(): string;
|
|
2277
2369
|
get position(): Vector3;
|
|
2278
2370
|
set position(value: Vector3);
|
|
@@ -2362,6 +2454,10 @@ export declare class GaussianSplattingStream extends GaussianSplattingMesh {
|
|
|
2362
2454
|
get debugLodSource(): never;
|
|
2363
2455
|
set debugLodSource(_value: GaussianSplattingStreamDebugLodSource);
|
|
2364
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>;
|
|
2365
2461
|
}
|
|
2366
2462
|
|
|
2367
2463
|
export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
|
|
@@ -2416,6 +2512,8 @@ export declare function GetElementPixelFromUv(): never;
|
|
|
2416
2512
|
|
|
2417
2513
|
export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
|
|
2418
2514
|
|
|
2515
|
+
export declare function _GetPackedShBytesPerSplat(shDegree: number): number;
|
|
2516
|
+
|
|
2419
2517
|
export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
|
|
2420
2518
|
|
|
2421
2519
|
export declare function GetPointsCount(..._args: unknown[]): never;
|
|
@@ -2527,6 +2625,8 @@ export declare namespace GLTF2 {
|
|
|
2527
2625
|
IKHRInteractivityTypeMapping,
|
|
2528
2626
|
gltfTypeToBabylonType,
|
|
2529
2627
|
IFlowGraphEventReferenceBlockConfiguration,
|
|
2628
|
+
IFlowGraphDelayReferenceBlockConfiguration,
|
|
2629
|
+
FlowGraphDelayReferenceBlock,
|
|
2530
2630
|
FlowGraphEventReferenceBlock,
|
|
2531
2631
|
IFlowGraphGLTFDataProviderBlockConfiguration,
|
|
2532
2632
|
FlowGraphGLTFDataProvider,
|
|
@@ -2752,6 +2852,8 @@ export declare class HandConstraintBehavior {
|
|
|
2752
2852
|
constructor();
|
|
2753
2853
|
}
|
|
2754
2854
|
|
|
2855
|
+
export declare function _HasGaussianPointSplattingProjectedDepth(projection: Matrix): boolean;
|
|
2856
|
+
|
|
2755
2857
|
/**
|
|
2756
2858
|
* Babylon.js-shaped Havok V2 physics plugin, backed by Babylon Lite's native
|
|
2757
2859
|
* `createHavokWorld` API.
|
|
@@ -2813,6 +2915,11 @@ export declare class HDRCubeTexture extends BaseTexture {
|
|
|
2813
2915
|
gammaSpace: boolean;
|
|
2814
2916
|
level: number;
|
|
2815
2917
|
/** Fires when the HDR environment is "ready" (resolved on a microtask). */
|
|
2816
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;
|
|
2817
2924
|
private _ready;
|
|
2818
2925
|
private readonly _readyPromise;
|
|
2819
2926
|
constructor(url: string, _sceneOrEngine?: unknown, size?: number, _noMipmap?: boolean, _generateHarmonics?: boolean, _gammaSpace?: boolean, _prefilterOnLoad?: boolean, onLoad?: (() => void) | null);
|
|
@@ -2902,6 +3009,8 @@ export declare interface IAnimationKey {
|
|
|
2902
3009
|
value: AnimationValue;
|
|
2903
3010
|
/** Babylon.js per-key interpolation hint (`AnimationKeyInterpolation`). */
|
|
2904
3011
|
interpolation?: number;
|
|
3012
|
+
/** Easing for the segment starting at this key; overrides animation-level easing. */
|
|
3013
|
+
easingFunction?: IEasingFunction;
|
|
2905
3014
|
}
|
|
2906
3015
|
|
|
2907
3016
|
/** Structural vector/quaternion value accepted by Babylon.js animation keys. */
|
|
@@ -3022,6 +3131,14 @@ export declare interface IEasingFunction {
|
|
|
3022
3131
|
ease(gradient: number): number;
|
|
3023
3132
|
}
|
|
3024
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
|
+
|
|
3025
3142
|
export declare interface IFlowGraphValidationIssue {
|
|
3026
3143
|
severity: FlowGraphValidationSeverity;
|
|
3027
3144
|
message: string;
|
|
@@ -3037,6 +3154,12 @@ export declare interface IFlowGraphValidationResult {
|
|
|
3037
3154
|
issuesByBlock: Map<string, IFlowGraphValidationIssue[]>;
|
|
3038
3155
|
}
|
|
3039
3156
|
|
|
3157
|
+
export declare interface IGaussianPointSplattingProgress {
|
|
3158
|
+
renderedFrameCount: number;
|
|
3159
|
+
accumulationVersion: number;
|
|
3160
|
+
pixelCycleLength: number;
|
|
3161
|
+
}
|
|
3162
|
+
|
|
3040
3163
|
export declare interface IGaussianSplattingDebugOptions {
|
|
3041
3164
|
clippingBox: {
|
|
3042
3165
|
min: Vector3;
|
|
@@ -3111,6 +3234,28 @@ export declare interface IGaussianSplattingStreamOptions {
|
|
|
3111
3234
|
hostCompound?: GaussianSplattingMesh;
|
|
3112
3235
|
decodeSh?: boolean;
|
|
3113
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;
|
|
3114
3259
|
}
|
|
3115
3260
|
|
|
3116
3261
|
/** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
|
|
@@ -3761,6 +3906,7 @@ export declare class Matrix {
|
|
|
3761
3906
|
multiplyToRef(other: Matrix, result: Matrix): Matrix;
|
|
3762
3907
|
transpose(): Matrix;
|
|
3763
3908
|
determinant(): number;
|
|
3909
|
+
/** Babylon.js `invert`: inverts this matrix in place and returns it. */
|
|
3764
3910
|
invert(): Matrix;
|
|
3765
3911
|
invertToRef(result: Matrix): Matrix;
|
|
3766
3912
|
getTranslation(): Vector3;
|
|
@@ -4214,6 +4360,14 @@ export declare class Observable<T> {
|
|
|
4214
4360
|
cleanLastNotifiedState(): void;
|
|
4215
4361
|
}
|
|
4216
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
|
+
|
|
4217
4371
|
/**
|
|
4218
4372
|
* Minimal Babylon.js-compatible `Observable`.
|
|
4219
4373
|
*
|
|
@@ -4929,8 +5083,10 @@ export declare class PointerEventTypes {
|
|
|
4929
5083
|
export declare class PointerInfo {
|
|
4930
5084
|
type: number;
|
|
4931
5085
|
event: PointerEvent | WheelEvent;
|
|
4932
|
-
private
|
|
4933
|
-
|
|
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. */
|
|
4934
5090
|
get pickInfo(): PickingInfo | null;
|
|
4935
5091
|
}
|
|
4936
5092
|
|
|
@@ -5027,8 +5183,12 @@ export declare class PositionGizmo extends GizmoBase {
|
|
|
5027
5183
|
private _attached;
|
|
5028
5184
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5029
5185
|
get attachedMesh(): AbstractMesh | null;
|
|
5030
5186
|
set attachedMesh(value: AbstractMesh | null);
|
|
5031
|
-
|
|
5032
|
-
|
|
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);
|
|
5033
5193
|
dispose(): void;
|
|
5034
5194
|
}
|
|
5035
5195
|
|
|
@@ -5085,6 +5245,7 @@ export declare class Quaternion {
|
|
|
5085
5245
|
constructor(x?: number, y?: number, z?: number, w?: number);
|
|
5086
5246
|
set(x: number, y: number, z: number, w: number): this;
|
|
5087
5247
|
copyFrom(source: Quaternion): this;
|
|
5248
|
+
/** Babylon.js `multiply`: the product `this · other` as a new quaternion. */
|
|
5088
5249
|
multiply(other: Quaternion): Quaternion;
|
|
5089
5250
|
length(): number;
|
|
5090
5251
|
normalize(): this;
|
|
@@ -5319,6 +5480,8 @@ export declare function RegisterSPLATFileLoader(): void;
|
|
|
5319
5480
|
|
|
5320
5481
|
export declare function RegisterUSDFileLoader(): void;
|
|
5321
5482
|
|
|
5483
|
+
export declare function RemoveFlowGraphAnimationGroupObservers(_context: FlowGraphContext, _animationGroup: AnimationGroup): FlowGraphPlayAnimationBlock | undefined;
|
|
5484
|
+
|
|
5322
5485
|
/** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
|
|
5323
5486
|
export declare class RenderTargetTexture {
|
|
5324
5487
|
constructor();
|
|
@@ -5386,8 +5549,12 @@ export declare class RotationGizmo extends GizmoBase {
|
|
|
5386
5549
|
private _attached;
|
|
5387
5550
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5388
5551
|
get attachedMesh(): AbstractMesh | null;
|
|
5389
5552
|
set attachedMesh(value: AbstractMesh | null);
|
|
5390
|
-
|
|
5391
|
-
|
|
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);
|
|
5392
5559
|
dispose(): void;
|
|
5393
5560
|
}
|
|
5394
5561
|
|
|
@@ -5416,8 +5583,12 @@ export declare class ScaleGizmo extends GizmoBase {
|
|
|
5416
5583
|
private _attached;
|
|
5417
5584
|
set updateGizmoRotationToMatchAttachedMesh(value: boolean);
|
|
5418
5585
|
get attachedMesh(): AbstractMesh | null;
|
|
5419
5586
|
set attachedMesh(value: AbstractMesh | null);
|
|
5420
|
-
|
|
5421
|
-
|
|
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);
|
|
5422
5593
|
dispose(): void;
|
|
5423
5594
|
}
|
|
5424
5595
|
|
|
@@ -5451,6 +5622,9 @@ export declare class Scene extends AbstractScene {
|
|
|
5451
5622
|
/** Babylon.js fog-mode c
|
|
5452
5623
|
private readonly _engine;
|
|
5453
5624
|
private _activeCamera;
|
|
5454
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;
|
|
5455
5629
|
private _defaultMaterial;
|
|
5456
5630
|
private _fogMode;
|
|
5457
5631
|
private _fogStart;
|
|
@@ -5458,6 +5632,8 @@ export declare class Scene extends AbstractScene {
|
|
|
5458
5632
|
/** Babylon.js fog-mode c
|
|
5459
5633
|
private _fogDensity;
|
|
5460
5634
|
private _fogColor;
|
|
5461
5635
|
private _started;
|
|
5462
5636
|
private _envTexture;
|
|
5637
|
+
/** Environment lighting rotation last forwarded to Lite. */
|
|
5638
|
+
private _envRotation;
|
|
5463
5639
|
private _brdfTexture;
|
|
5464
5640
|
private _defaultEnvOptions;
|
|
5465
5641
|
private readonly _shadowGenerators;
|
|
@@ -5547,6 +5723,13 @@ export declare class Scene extends AbstractScene {
|
|
|
5547
5723
|
/** Babylon.js fog-mode c
|
|
5548
5724
|
set clipPlane(value: Plane | null);
|
|
5549
5725
|
get environmentTexture(): CubeTexture | HDRCubeTexture | null;
|
|
5550
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;
|
|
5551
5734
|
/**
|
|
5552
5735
|
* Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
|
|
5553
5736
|
* Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
|
|
@@ -5699,8 +5882,7 @@ export declare enum ShaderLanguage {
|
|
|
5699
5882
|
WGSL = 1
|
|
5700
5883
|
}
|
|
5701
5884
|
|
|
5702
|
-
export declare class ShaderMaterial {
|
|
5703
|
-
constructor();
|
|
5885
|
+
export declare class ShaderMaterial {
|
|
5704
5886
|
constructor();
|
|
5705
5887
|
}
|
|
5706
5888
|
|
|
5707
5889
|
export declare class ShadowGenerator {
|
|
@@ -5811,6 +5993,28 @@ export declare class SmartArray<T> {
|
|
|
5811
5993
|
dispose(): void;
|
|
5812
5994
|
}
|
|
5813
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
|
+
|
|
5814
6018
|
export declare class SolidParticleSystem {
|
|
5815
6019
|
constructor();
|
|
5816
6020
|
}
|
|
@@ -6440,8 +6644,8 @@ export declare const ToDegrees: number;
|
|
|
6440
6644
|
|
|
6441
6645
|
/** Babylon.js-compatible `Tools` helpers (the small, pure subset). */
|
|
6442
6646
|
export declare const Tools: {
|
|
6443
|
-
/**
|
|
6444
|
-
Now
|
|
6647
|
+
/** Current high-resolution timestamp in milliseconds, matching Babylon.js's numeric property. */
|
|
6648
|
+
readonly Now: number;
|
|
6445
6649
|
ToRadians(degrees: number): number;
|
|
6446
6650
|
ToDegrees(radians: number): number;
|
|
6447
6651
|
/** Clamp `value` into the inclusive `[min, max]` range. */
|
|
@@ -6884,10 +7088,7 @@ export declare class WebGPUEngine extends AbstractEngine {
|
|
|
6884
7088
|
}
|
|
6885
7089
|
|
|
6886
7090
|
/** Babylon.js `WebGPUEngineOptions` subset accepted by the compat engine. */
|
|
6887
|
-
export declare interface WebGPUEngineOptions extends
|
|
6888
|
-
antialias?: boolean;
|
|
6889
|
-
adaptToDeviceRatio?: boolean;
|
|
6890
|
-
useLargeWorldRendering?: boolean;
|
|
7091
|
+
export declare interface WebGPUEngineOptions extends AbstractEngineOptions {
|
|
6891
7092
|
canvasToneMapping?: GPUCanvasToneMapping;
|
|
6892
7093
|
canvasColorSpace?: PredefinedColorSpace;
|
|
6893
7094
|
}
|