@babylonjs/lite-compat 1.14.0-preview → 1.16.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 +10 -8
- package/brdf-lut-data-BFfYlW71.js +5 -0
- package/brdf-lut-data-BFfYlW71.js.map +1 -0
- package/index.d.ts +503 -97
- package/index.js +1277 -497
- package/index.js.map +1 -1
- package/{meshes-CPZtn6G5.js → meshes-DduMsRJk.js} +691 -104
- package/meshes-DduMsRJk.js.map +1 -0
- package/navigation.d.ts +264 -78
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-CPZtn6G5.js.map +0 -1
package/index.d.ts
CHANGED
|
@@ -12,6 +12,7 @@ import { RenderCanvas } from '@babylonjs/lite';
|
|
|
12
12
|
import { SceneNode } from '@babylonjs/lite';
|
|
13
13
|
import { SheenProps } from '@babylonjs/lite';
|
|
14
14
|
import { Texture2D } from '@babylonjs/lite';
|
|
15
|
+
import { Texture2DArray } from '@babylonjs/lite';
|
|
15
16
|
|
|
16
17
|
/** Base class for an asset-loading task. Subclasses implement {@link runAsync}. */
|
|
17
18
|
export declare abstract class AbstractAssetTask {
|
|
@@ -113,7 +114,8 @@ export declare abstract class AbstractEngine {
|
|
|
113
114
|
protected readonly _scenes: Scene[];
|
|
114
115
|
protected readonly _loopCallbacks: Array<() => void>;
|
|
115
116
|
protected _initialized: boolean;
|
|
116
|
-
private _started;
|
|
117
117
|
/**
|
|
118
|
+
private _startupComplete;
|
|
119
|
+
private _startPromise;
|
|
118
120
|
/**
|
|
119
121
|
* Babylon.js `engine.useReverseDepthBuffer`. Babylon Lite owns its depth
|
|
120
122
|
* configuration internally, so this is a settable no-op kept for API shape.
|
|
121
123
|
*/
|
|
@@ -197,7 +199,35 @@ export declare abstract class AbstractEngine {
|
|
|
197
199
|
beginFrame(): never;
|
|
198
200
|
/** Babylon.js manual frame-pump exit point — unsupported (Lite's frame graph owns the frame). */
|
|
199
201
|
endFrame(): never;
|
|
202
|
+
/**
|
|
203
|
+
* Babylon.js `engine.currentSampleCount` — the MSAA sample count of the current render target.
|
|
204
|
+
* Babylon Lite manages MSAA internally and exposes no public sample-count accessor, so this
|
|
205
|
+
* needs a tree-shakeable Lite core addition before it can report a real value.
|
|
206
|
+
*/
|
|
207
|
+
get currentSampleCount(): never;
|
|
208
|
+
/**
|
|
209
|
+
* Babylon.js `engine.getAlphaToCoverage()` — alpha-to-coverage state. Babylon Lite does not
|
|
210
|
+
* expose an engine-level alpha-to-coverage toggle, so this is unsupported.
|
|
211
|
+
*/
|
|
212
|
+
getAlphaToCoverage(): never;
|
|
213
|
+
/**
|
|
214
|
+
* Babylon.js `engine.setAlphaToCoverage(enable)` — toggle alpha-to-coverage. Babylon Lite does
|
|
215
|
+
* not expose an engine-level alpha-to-coverage toggle, so this is unsupported.
|
|
216
|
+
*/
|
|
217
|
+
setAlphaToCoverage(_enable: boolean): never;
|
|
218
|
+
/**
|
|
219
|
+
* Babylon.js `engine.updateTextureArrayLayerFromImageSource(texture, source, layer, invertY, premultiplyAlpha)`
|
|
220
|
+
* — the engine extension that uploads a decoded image source into one layer of a 2D array
|
|
221
|
+
* texture. Forwards to Babylon Lite's `uploadImageToArrayLayer`.
|
|
222
|
+
*
|
|
223
|
+
* Babylon.js passes an `InternalTexture`; the compat layer's equivalent handle is the Lite
|
|
224
|
+
* `Texture2DArray` returned by `RawTexture2DArray.getInternalTexture()`, so ported code that
|
|
225
|
+
* goes through `UploadImageToTexture2DArrayLayer` (which is exactly what Babylon.js's helper
|
|
226
|
+
* does) works unchanged.
|
|
227
|
+
*/
|
|
228
|
+
updateTextureArrayLayerFromImageSource(texture: Texture2DArray, source: GPUCopyExternalImageSource, layer: number, invertY?: boolean, premultiplyAlpha?: boolean): void;
|
|
200
229
|
private _start;
|
|
230
|
+
private _startCore;
|
|
201
231
|
private _ensureInitialized;
|
|
202
232
|
}
|
|
203
233
|
|
|
@@ -206,7 +236,7 @@ export declare abstract class AbstractEngine {
|
|
|
206
236
|
* visibility, and shadow-receipt. Concrete meshes derive from this.
|
|
207
237
|
*/
|
|
208
238
|
export declare class AbstractMesh extends TransformNode {
|
|
209
239
|
private _material;
|
|
210
|
-
|
|
240
|
+
protected _visible: boolean;
|
|
211
241
|
constructor(name: string, lite: Mesh_2, scene?: Scene);
|
|
212
242
|
getClassName(): string;
|
|
213
243
|
get material(): CompatMaterial | null;
|
|
214
244
|
set material(value: CompatMaterial | null);
|
|
@@ -214,19 +244,28 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
214
244
|
private _material;
|
|
215
245
|
set isVisible(value: boolean);
|
|
216
246
|
get receiveShadows(): boolean;
|
|
217
247
|
set receiveShadows(value: boolean);
|
|
218
|
-
|
|
219
|
-
/**
|
|
220
|
-
* Babylon.js `mesh.getBoundingInfo()` — local-space AABB of this mesh. Babylon
|
|
221
|
-
* Lite stores `boundMin`/`boundMax` (local space) on factory- and loader-built
|
|
222
|
-
* meshes; when absent (e.g. a placeholder mesh whose bounds were never computed)
|
|
223
|
-
* we fold the retained CPU positions through Lite's `computeAabb`. A mesh with
|
|
224
|
-
* no geometry returns a degenerate zero-size box.
|
|
248
|
+
protected _onEffectiveEnabledStateChanged(enabled: boolean): void;
|
|
225
249
|
/**
|
|
250
|
+
* Babylon.js `mesh.getBoundingInfo()` — the mesh's AABB. `minimum`/`maximum`
|
|
251
|
+
* are the local-space bounds; the returned `BoundingInfo`'s world members
|
|
252
|
+
* (`minimumWorld`/`maximumWorld`/`centerWorld`/…) are derived by transforming
|
|
253
|
+
* the eight local corners by the mesh's world matrix, so a mesh at (1,2,3)
|
|
254
|
+
* reports correctly-offset world bounds. Babylon Lite stores `boundMin`/
|
|
255
|
+
* `boundMax` (local space) on factory- and loader-built meshes; when absent
|
|
256
|
+
* (e.g. a placeholder mesh whose bounds were never computed) we fold the
|
|
257
|
+
* retained CPU positions through Lite's `computeAabb`. A mesh with no geometry
|
|
258
|
+
* returns a degenerate zero-size box.
|
|
226
259
|
*/
|
|
227
260
|
getBoundingInfo(): BoundingInfo;
|
|
261
|
+
/** Compat handle over Babylon Lite's world matrix for bounds derivation. Returns
|
|
262
|
+
* `undefined` when the Lite node hasn't computed one (world bounds fall back to
|
|
263
|
+
* local). */
|
|
264
|
+
private _worldMatrixForBounds;
|
|
228
265
|
/**
|
|
229
|
-
* Babylon.js `mesh.getVerticesData(kind)` — read back the CPU geometry buffer
|
|
230
|
-
*
|
|
231
|
-
* (for picking + device-loss recovery)
|
|
266
|
+
* Babylon.js `mesh.getVerticesData(kind)` — read back the CPU geometry buffer.
|
|
267
|
+
* `position` / `normal` / `uv` come from the buffers Babylon Lite retains on the
|
|
268
|
+
* mesh (for picking + device-loss recovery). Prefer the last compat-side value
|
|
269
|
+
* for `uv2` / `tangent` / `color`, falling back to attributes retained by Lite
|
|
270
|
+
* for loader- and factory-created meshes.
|
|
232
271
|
*/
|
|
233
272
|
getVerticesData(kind: string): Float32Array | null;
|
|
234
273
|
/**
|
|
@@ -237,8 +276,22 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
237
276
|
private _material;
|
|
238
277
|
* (`matricesIndices`, etc.) are accepted but not applied (Babylon Lite drives
|
|
239
278
|
* skinning through its own loaded-skeleton path).
|
|
240
279
|
*/
|
|
241
|
-
setVerticesData(kind: string, data: number[] | Float32Array, _updatable?: boolean): void;
|
|
242
280
|
private _lastColors;
|
|
243
|
-
|
|
281
|
+
setVerticesData(kind: string, data: number[] | Float32Array, _updatable?: boolean): void;
|
|
282
|
+
/**
|
|
283
|
+
* Babylon.js `mesh.getIndices()` — read back the mesh's index (topology) buffer.
|
|
284
|
+
* Babylon Lite retains the indices on the mesh as a `Uint32Array` (for picking +
|
|
285
|
+
* device-loss recovery), so we return that directly; a mesh with no geometry
|
|
286
|
+
* returns `null`.
|
|
287
|
+
*/
|
|
288
|
+
getIndices(_copyWhenShared?: boolean, forceCopy?: boolean): Uint32Array | null;
|
|
289
|
+
/**
|
|
290
|
+
* Babylon.js `mesh.setIndices(indices)` — replace the mesh's index (topology)
|
|
291
|
+
* buffer. Babylon Lite re-uploads the geometry in place via `resizeMeshGeometry`,
|
|
292
|
+
* keeping the existing position/normal/uv/tangent/color attributes and swapping
|
|
293
|
+
* only the indices. Returns the mesh for chaining.
|
|
294
|
+
*/
|
|
295
|
+
setIndices(indices: number[] | Uint16Array | Uint32Array | Int32Array, _totalVertices?: number | null, _updatable?: boolean): this;
|
|
244
296
|
private _lastTangents;
|
|
297
|
+
private _lastColors;
|
|
245
298
|
/** Babylon.js `mesh.getTotalVertices()` — vertex count from the position buffer. */
|
|
246
299
|
getTotalVertices(): number;
|
|
247
300
|
/**
|
|
248
301
|
* Babylon.js `mesh.refreshBoundingInfo()` — Babylon Lite recomputes a mesh's
|
|
@@ -246,15 +299,20 @@ export declare class AbstractMesh extends TransformNode {
|
|
|
246
299
|
private _material;
|
|
247
300
|
* no-op that returns the mesh for chaining. The deformed-pick options
|
|
248
301
|
* (`applySkeleton` / `applyMorph`) are accepted for parity but not used.
|
|
249
302
|
*/
|
|
250
|
-
refreshBoundingInfo(_options?: unknown): this;
|
|
251
|
-
/**
|
|
303
|
+
refreshBoundingInfo(_options?: unknown): this;
|
|
252
304
|
/**
|
|
253
305
|
* Babylon.js `mesh.bakeCurrentTransformIntoVertices()` — fold the node's local
|
|
254
|
-
* transform (position / rotation / scaling) into the CPU geometry
|
|
255
|
-
*
|
|
256
|
-
*
|
|
257
|
-
* renormalized), re-upload via `resizeMeshGeometry`, then clear the transform.
|
|
306
|
+
* transform (position / rotation / scaling) into the CPU geometry via the shared
|
|
307
|
+
* {@link _bakeMatrix} helper, then reset the node transform to identity (the
|
|
308
|
+
* geometry now carries it).
|
|
258
309
|
*/
|
|
259
310
|
bakeCurrentTransformIntoVertices(): this;
|
|
311
|
+
/**
|
|
312
|
+
* Babylon.js `mesh.bakeTransformIntoVertices(transform)` — fold an **arbitrary**
|
|
313
|
+
* matrix into the CPU geometry via the shared {@link _bakeMatrix} helper. Unlike
|
|
314
|
+
* {@link bakeCurrentTransformIntoVertices}, the node's own transform is **not**
|
|
315
|
+
* reset: the supplied matrix is independent of the node transform.
|
|
316
|
+
*/
|
|
317
|
+
bakeTransformIntoVertices(transform: Matrix): this;
|
|
260
318
|
dispose(): void;
|
|
261
319
|
}
|
|
262
320
|
|
|
@@ -271,10 +329,14 @@ export declare abstract class AbstractNamedAudioNode extends AbstractAudioNode {
|
|
|
271
329
|
}
|
|
272
330
|
|
|
273
331
|
export declare abstract class AbstractScene {
|
|
274
332
|
/**
|
|
275
|
-
* Babylon.js `scene.meshes
|
|
276
|
-
*
|
|
277
|
-
*
|
|
278
|
-
*
|
|
333
|
+
* Babylon.js `scene.meshes` — the compat mesh wrappers in the scene. Backed by the
|
|
334
|
+
* canonical {@link _meshWrappers} registry and kept in sync with the Lite-core-owned
|
|
335
|
+
* list: the core list ({@link _coreMeshList}) supplies authoritative membership and
|
|
336
|
+
* ordering, mapped back to each mesh's canonical wrapper so the returned handles are
|
|
337
|
+
* the right type and keep wrapper identity. Wrappers not yet mirrored into the core
|
|
338
|
+
* list (transform-only loader roots, primitives whose scene-add is deferred to engine
|
|
339
|
+
* start, and Gaussian-Splatting meshes that register their renderables outside
|
|
340
|
+
* `scene.meshes`) retain their registration positions.
|
|
279
341
|
*/
|
|
280
342
|
get meshes(): TransformNode[];
|
|
281
343
|
/** Babylon.js `scene.cameras` — every camera constructed against this scene. */
|
|
@@ -295,19 +357,18 @@ export declare abstract class AbstractScene {
|
|
|
295
357
|
/**
|
|
296
358
|
/** Babylon.js `scene.getMaterialById(id)` — first material whose `id` matches, else `null`. */
|
|
297
359
|
getMaterialById(id: string): Material | null;
|
|
298
360
|
/**
|
|
299
|
-
* Babylon.js `scene.getMeshByName(name)
|
|
300
|
-
*
|
|
301
|
-
* (
|
|
302
|
-
* when not found, matching Babylon.js.
|
|
361
|
+
* Babylon.js `scene.getMeshByName(name)` — first mesh in {@link meshes} with a
|
|
362
|
+
* matching name, else `null`. Enumerates the full canonical mesh registry
|
|
363
|
+
* (primitives + loader-surfaced meshes), not just the loader-surfaced subset.
|
|
303
364
|
*/
|
|
304
365
|
getMeshByName(name: string): TransformNode | null;
|
|
305
|
-
/** Babylon.js `scene.getMeshById(id)` — first
|
|
366
|
+
/** Babylon.js `scene.getMeshById(id)` — first mesh whose `id` matches, else `null`. */
|
|
306
367
|
getMeshById(id: string): TransformNode | null;
|
|
307
368
|
/** Babylon.js legacy `scene.getMeshByID(id)` — alias of {@link getMeshById}. */
|
|
308
369
|
getMeshByID(id: string): TransformNode | null;
|
|
309
|
-
/** Babylon.js `scene.getNodeByName(name)` — searches
|
|
370
|
+
/** Babylon.js `scene.getNodeByName(name)` — searches meshes, cameras, and lights. */
|
|
310
371
|
getNodeByName(name: string): Node_2 | null;
|
|
311
|
-
/** Babylon.js `scene.getNodeById(id)` — searches
|
|
372
|
+
/** Babylon.js `scene.getNodeById(id)` — searches meshes, cameras, and lights by `id`. */
|
|
312
373
|
getNodeById(id: string): Node_2 | null;
|
|
313
374
|
}
|
|
314
375
|
|
|
@@ -707,12 +768,26 @@ export declare class ArcRotateCamera extends Camera {
|
|
|
707
768
|
constructor(name: stri
|
|
708
769
|
set lowerRadiusLimit(value: number | undefined);
|
|
709
770
|
get upperRadiusLimit(): number | undefined;
|
|
710
771
|
set upperRadiusLimit(value: number | undefined);
|
|
772
|
+
/** Wheel-zoom sensitivity (HIGHER = slower zoom). Babylon default 3. */
|
|
773
|
+
get wheelPrecision(): number;
|
|
774
|
+
set wheelPrecision(value: number);
|
|
775
|
+
/** Mouse-drag orbit sensitivity (HIGHER = slower rotation). Babylon default 1000. */
|
|
776
|
+
get angularSensibility(): number;
|
|
777
|
+
set angularSensibility(value: number);
|
|
778
|
+
/** Right-drag panning sensitivity in pixels-per-unit (LOWER = faster pan). Babylon default 50. */
|
|
779
|
+
get panningSensibility(): number;
|
|
780
|
+
set panningSensibility(value: number);
|
|
711
781
|
attachControl(canvas: HTMLCanvasElement, _noPreventDefault?: boolean): void;
|
|
712
782
|
|
|
713
783
|
export declare class AssetContainer {
|
|
714
784
|
constructor(lite: AssetContainer_2);
|
|
715
785
|
get animationGroups(): AnimationGroup_2[];
|
|
716
|
-
/**
|
|
717
|
-
|
|
786
|
+
/**
|
|
787
|
+
* Flat list of the loaded meshes as canonical, stable-identity compat `Mesh`
|
|
788
|
+
* handles (`__root__` at index 0, matching Babylon.js). Repeated reads return
|
|
789
|
+
* the same wrapper objects, and — once the container is added to a scene — the
|
|
790
|
+
* same handles `scene.meshes` exposes.
|
|
791
|
+
*/
|
|
792
|
+
get meshes(): Mesh[];
|
|
718
793
|
/** Add every entity, animation group, camera, and clear colour to the scene. */
|
|
719
794
|
addAllToScene(scene: Scene): void;
|
|
720
795
|
dispose(): void;
|
|
@@ -907,7 +982,12 @@ export declare class BaseSixDofDragBehavior {
|
|
|
907
982
|
}
|
|
908
983
|
|
|
909
984
|
export declare abstract class BaseTexture {
|
|
910
|
-
name: string;
|
|
911
985
|
getClassName(): string;
|
|
986
|
+
name: string;
|
|
912
987
|
getClassName(): string;
|
|
913
988
|
/**
|
|
989
|
+
* Babylon.js `BaseTexture.getInternalTexture()` — the backend texture handle. Babylon.js
|
|
990
|
+
* returns an `InternalTexture`; the compat layer's equivalent is the Lite texture handle,
|
|
991
|
+
* which is what the compat engine's texture methods accept.
|
|
992
|
+
*/
|
|
993
|
+
getInternalTexture(): Texture2D | null;
|
|
914
994
|
abstract whenReadyAsync(): Promise<void>;
|
|
915
995
|
dispose(): void;
|
|
916
996
|
}
|
|
@@ -950,18 +1030,28 @@ export declare class BouncingBehavior implements Behavior<ArcRotateCamera> {
|
|
|
950
1030
|
}
|
|
951
1031
|
|
|
952
1032
|
export declare class BoundingBox {
|
|
953
|
-
minimum: Vector3;
|
|
954
|
-
maximum: Vector3;
|
|
955
|
-
center: Vector3;
|
|
956
|
-
extendSize: Vector3;
|
|
957
|
-
/**
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
/**
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
1033
|
+
readonly minimum: Vector3;
|
|
1034
|
+
readonly maximum: Vector3;
|
|
1035
|
+
readonly center: Vector3;
|
|
1036
|
+
readonly extendSize: Vector3;
|
|
1037
|
+
/** Center of the AABB in world space. */
|
|
1038
|
+
readonly centerWorld: Vector3;
|
|
1039
|
+
/** Half-size of the AABB in world space (multiply by 2 for the full size). */
|
|
1040
|
+
readonly extendSizeWorld: Vector3;
|
|
1041
|
+
/** Minimum corner of the world-space AABB. */
|
|
1042
|
+
readonly minimumWorld: Vector3;
|
|
1043
|
+
/** Maximum corner of the world-space AABB. */
|
|
1044
|
+
readonly maximumWorld: Vector3;
|
|
1045
|
+
/** The 8 corner points in local space (min/max combinations). */
|
|
1046
|
+
readonly vectors: Vector3[];
|
|
1047
|
+
/** The 8 corner points transformed into world space. */
|
|
1048
|
+
readonly vectorsWorld: Vector3[];
|
|
1049
|
+
/** The three world-space axis directions of the box (rows of the world matrix). */
|
|
1050
|
+
readonly directions: Vector3[];
|
|
1051
|
+
private _worldMatrix;
|
|
1052
|
+
constructor(min: Vector3, max: Vector3, worldMatrix?: Matrix);
|
|
1053
|
+
reConstruct(min: Vector3, max: Vector3, worldMatrix?: Matrix): void;
|
|
1054
|
+
getWorldMatrix(): Matrix;
|
|
965
1055
|
intersectsPoint(point: Vector3): boolean;
|
|
966
1056
|
static Intersects(a: BoundingBox, b: BoundingBox): boolean;
|
|
967
1057
|
}
|
|
968
1058
|
|
|
@@ -987,27 +1077,37 @@ export declare class BoundingBoxRenderer {
|
|
|
987
1077
|
export declare class BoundingInfo {
|
|
988
1078
|
boundingBox: BoundingBox;
|
|
989
1079
|
boundingSphere: BoundingSphere;
|
|
990
|
-
constructor(min: Vector3, max: Vector3);
|
|
1080
|
+
constructor(min: Vector3, max: Vector3, worldMatrix?: Matrix);
|
|
991
1081
|
get minimum(): Vector3;
|
|
992
1082
|
get maximum(): Vector3;
|
|
993
1083
|
intersectsPoint(point: Vector3): boolean;
|
|
994
|
-
/**
|
|
995
|
-
|
|
1084
|
+
/** Babylon.js `BoundingInfo.update` — re-derive the world-space bounds from the
|
|
1085
|
+
* local geometry and a new world matrix. */
|
|
1086
|
+
update(worldMatrix: Matrix): void;
|
|
1087
|
+
/** Rebuild the local bounds and (optionally) re-derive world-space bounds from
|
|
1088
|
+
* the supplied world matrix, transforming all eight corners. */
|
|
1089
|
+
reConstruct(min: Vector3, max: Vector3, worldMatrix?: Matrix): void;
|
|
996
1090
|
}
|
|
997
1091
|
|
|
998
1092
|
export declare class BoundingSphere {
|
|
999
|
-
center: Vector3;
|
|
1093
|
+
readonly center: Vector3;
|
|
1000
1094
|
radius: number;
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1095
|
+
readonly centerWorld: Vector3;
|
|
1096
|
+
radiusWorld: number;
|
|
1097
|
+
readonly minimum: Vector3;
|
|
1098
|
+
readonly maximum: Vector3;
|
|
1099
|
+
private _worldMatrix;
|
|
1100
|
+
constructor(min: Vector3, max: Vector3, worldMatrix?: Matrix);
|
|
1101
|
+
reConstruct(min: Vector3, max: Vector3, worldMatrix?: Matrix): void;
|
|
1102
|
+
getWorldMatrix(): Matrix;
|
|
1005
1103
|
intersectsPoint(point: Vector3): boolean;
|
|
1006
1104
|
static Intersects(a: BoundingSphere, b: BoundingSphere): boolean;
|
|
1007
1105
|
}
|
|
1008
1106
|
|
|
1009
1107
|
declare interface BoxOptions {
|
|
1010
1108
|
size?: number;
|
|
1011
1109
|
width?: number;
|
|
1110
|
+
height?: number;
|
|
1111
|
+
depth?: number;
|
|
1012
1112
|
}
|
|
1013
1113
|
|
|
1014
1114
|
export declare class BVHFileLoader {
|
|
@@ -1162,12 +1262,18 @@ export declare const Constants: {
|
|
|
1162
1262
|
readonly ALPHA_COMBINE: 2;
|
|
1163
1263
|
readonly ALPHA_ONEONE: 6;
|
|
1164
1264
|
readonly ALPHA_PREMULTIPLIED: 7;
|
|
1265
|
+
readonly ALPHA_REPLACE_COLOR: 21;
|
|
1165
1266
|
readonly MATERIAL_OPAQUE: 0;
|
|
1166
1267
|
readonly MATERIAL_ALPHATEST: 1;
|
|
1167
1268
|
readonly MATERIAL_ALPHABLEND: 2;
|
|
1168
1269
|
readonly TEXTURE_CLAMP_ADDRESSMODE: 0;
|
|
1169
1270
|
readonly TEXTURE_WRAP_ADDRESSMODE: 1;
|
|
1170
1271
|
readonly TEXTURE_MIRROR_ADDRESSMODE: 2;
|
|
1272
|
+
readonly TEXTURE_NEAREST_SAMPLINGMODE: 1;
|
|
1273
|
+
readonly TEXTURE_BILINEAR_SAMPLINGMODE: 2;
|
|
1274
|
+
readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
|
|
1275
|
+
readonly TEXTUREFORMAT_RGBA: 5;
|
|
1276
|
+
readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
|
|
1171
1277
|
};
|
|
1172
1278
|
|
|
1173
1279
|
/** Babylon.js `CreateAudioBusAsync`. */
|
|
@@ -1212,6 +1318,35 @@ export declare function CreateSphere(name: string, options: SphereOptions, scene
|
|
|
1212
1318
|
/** Babylon.js `CreateStreamingSoundAsync`. */
|
|
1213
1319
|
export declare function CreateStreamingSoundAsync(name: string, source: HTMLMediaElement | string | string[], options?: Partial<IStreamingSoundOptions>, engine?: AudioEngineV2 | null): Promise<StreamingSound>;
|
|
1214
1320
|
|
|
1321
|
+
/**
|
|
1322
|
+
* Babylon.js `CreateTexture2DArrayFromImageUrlsAsync` — create a texture array and
|
|
1323
|
+
* fill each layer from a list of image URLs. Forwards to Lite's
|
|
1324
|
+
* `createTexture2DArrayFromUrls`, then wraps the result in a `RawTexture2DArray`.
|
|
1325
|
+
*
|
|
1326
|
+
* Lite's per-layer upload defaults to `invertY = true` (the Babylon.js *material*
|
|
1327
|
+
* convention); the Babylon.js helper defaults to `false`, so the flag is always
|
|
1328
|
+
* passed explicitly rather than left to the Lite default.
|
|
1329
|
+
*/
|
|
1330
|
+
export declare function CreateTexture2DArrayFromImageUrlsAsync(scene: Scene, urls: readonly [string, ...string[]], options?: ICreateTexture2DArrayFromImageUrlsOptions): Promise<RawTexture2DArray>;
|
|
1331
|
+
|
|
1332
|
+
/**
|
|
1333
|
+
* Babylon.js `CreateTexture2DArrayFromKTX2Async` — decode a single multi-layer KTX2
|
|
1334
|
+
* container into a texture array. Forwards to Lite's `createTexture2DArrayFromKtx2`
|
|
1335
|
+
* (transcodes to RGBA8, uploads the base level, regenerates mips), then wraps the
|
|
1336
|
+
* result in a `RawTexture2DArray`.
|
|
1337
|
+
*
|
|
1338
|
+
* Babylon.js defaults `generateMipMaps` to `true`; that value is always passed
|
|
1339
|
+
* explicitly rather than left to any Lite default. Sampling and Y inversion are
|
|
1340
|
+
* forwarded to the Lite array handle.
|
|
1341
|
+
*/
|
|
1342
|
+
export declare function CreateTexture2DArrayFromKTX2Async(scene: Scene, data: string | ArrayBufferView, options?: ICreateTexture2DArrayFromKTX2Options): Promise<RawTexture2DArray>;
|
|
1343
|
+
|
|
1344
|
+
/** Babylon.js `CreateTiledBox(name, options, scene)` (tiledBoxBuilder) — throwing stub (see `MeshBuilder.CreateTiledBox`). */
|
|
1345
|
+
export declare function CreateTiledBox(name?: string, options?: object, scene?: Scene): never;
|
|
1346
|
+
|
|
1347
|
+
/** Babylon.js `CreateTiledPlane(name, options, scene)` (tiledPlaneBuilder) — throwing stub (see `MeshBuilder.CreateTiledPlane`). */
|
|
1348
|
+
export declare function CreateTiledPlane(name?: string, options?: object, scene?: Scene): never;
|
|
1349
|
+
|
|
1215
1350
|
/** Babylon.js `CreateTorus(name, options, scene)` (torusBuilder). */
|
|
1216
1351
|
export declare function CreateTorus(name: string, options: object, scene: Scene): Mesh;
|
|
1217
1352
|
|
|
@@ -1538,7 +1673,17 @@ export declare class GamepadCamera extends UniversalCamera {
|
|
|
1538
1673
|
* Babylon.js `GaussianSplattingMesh`. Derives from `TransformNode` so the loaded
|
|
1539
1674
|
* cloud's `position` / `rotation` / `scaling` proxy onto the Lite splat node.
|
|
1540
1675
|
*/
|
|
1541
|
-
export declare class GaussianSplattingMesh extends TransformNode {
|
|
1542
1676
|
constructor(name: string, url?: string | null, scene?: Scene, _keepInRam?: boolean);
|
|
1677
|
+
export declare class GaussianSplattingMesh extends TransformNode {
|
|
1543
1678
|
/**
|
|
1679
|
+
* Babylon.js `gs.safeOrbitCameraLimits` — safe-orbit camera limits parsed from the source
|
|
1680
|
+
* file's metadata (Adobe safe-orbit extension), or `null` when the file carries none.
|
|
1681
|
+
*
|
|
1682
|
+
* Babylon Lite's splat loaders (`loadSplat` / `loadSOG` / `loadSPZ`) do not parse the Adobe
|
|
1683
|
+
* safe-orbit metadata block, so this stays `null` — matching BJS's own default for a file
|
|
1684
|
+
* without the extension. Populating it from real metadata needs a (non-tree-shakeable) change
|
|
1685
|
+
* to Lite's splat loaders; the field is exposed here for shape parity so ported reads resolve.
|
|
1686
|
+
*/
|
|
1687
|
+
safeOrbitCameraLimits: ISafeOrbitCameraLimits | null;
|
|
1688
|
+
constructor(name: string, url?: string | null, scene?: Scene, _keepInRam?: boolean);
|
|
1544
1689
|
getClassName(): string;
|
|
1545
1690
|
get position(): Vector3;
|
|
1546
1691
|
set position(value: Vector3);
|
|
1547
1692
|
get rotation(): Vector3;
|
|
@@ -1892,6 +2037,28 @@ export declare interface IAudioParameterRampOptions {
|
|
|
1892
2037
|
shape: AudioParameterRampShape;
|
|
1893
2038
|
}
|
|
1894
2039
|
|
|
2040
|
+
/** Babylon.js `ICreateTexture2DArrayFromImageUrlsOptions`. */
|
|
2041
|
+
export declare interface ICreateTexture2DArrayFromImageUrlsOptions extends IUploadImageToTexture2DArrayLayerOptions {
|
|
2042
|
+
/** Generate a full mip chain (true by default). */
|
|
2043
|
+
generateMipMaps?: boolean;
|
|
2044
|
+
/** Sampling mode (recorded for parity; Lite uses trilinear). */
|
|
2045
|
+
samplingMode?: number;
|
|
2046
|
+
/** Texture type (recorded for parity; Lite uploads RGBA8). */
|
|
2047
|
+
textureType?: number;
|
|
2048
|
+
/** Options forwarded to `createImageBitmap` (recorded for parity). */
|
|
2049
|
+
imageBitmapOptions?: ImageBitmapOptions;
|
|
2050
|
+
}
|
|
2051
|
+
|
|
2052
|
+
/** Babylon.js `ICreateTexture2DArrayFromKTX2Options`. */
|
|
2053
|
+
export declare interface ICreateTexture2DArrayFromKTX2Options {
|
|
2054
|
+
/** Generate a full mip chain (true by default). */
|
|
2055
|
+
generateMipMaps?: boolean;
|
|
2056
|
+
/** Sampling mode (trilinear by default). */
|
|
2057
|
+
samplingMode?: number;
|
|
2058
|
+
/** Store the texture with the Y axis inverted (false by default). */
|
|
2059
|
+
invertY?: boolean;
|
|
2060
|
+
}
|
|
2061
|
+
|
|
1895
2062
|
/** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
|
|
1896
2063
|
export declare interface IGPUMultiPickingInfo {
|
|
1897
2064
|
meshes: Array<PickableMesh | null>;
|
|
@@ -1940,6 +2107,9 @@ export declare class ImageProcessingConfiguration {
|
|
|
1940
2107
|
static readonly TONEMAPPING_KHR_PBR_NEUTRAL = 2;
|
|
1941
2108
|
}
|
|
1942
2109
|
|
|
2110
|
+
/** The decoded image sources WebGPU (and therefore Lite) can upload into a layer. */
|
|
2111
|
+
declare type ImageSource = ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | HTMLVideoElement | ImageData | VideoFrame;
|
|
2112
|
+
|
|
1943
2113
|
/** Babylon.js `IMainAudioBusOptions`. */
|
|
1944
2114
|
export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOptions> {
|
|
1945
2115
|
}
|
|
@@ -1948,7 +2118,7 @@ export declare interface IMainAudioBusOptions extends Partial<IVolumeAudioOption
|
|
|
1948
2118
|
export declare function ImportMeshAsync(source: string, scene: Scene, _options?: unknown): Promise<ImportResult>;
|
|
1949
2119
|
|
|
1950
2120
|
declare interface ImportResult {
|
|
1951
|
-
meshes:
|
|
2121
|
+
meshes: TransformNode[];
|
|
1952
2122
|
particleSystems: unknown[];
|
|
1953
2123
|
skeletons: unknown[];
|
|
1954
2124
|
animationGroups: AnimationGroup_2[];
|
|
@@ -1982,6 +2152,18 @@ export declare class InterpolatingBehavior {
|
|
|
1982
2152
|
constructor();
|
|
1983
2153
|
}
|
|
1984
2154
|
|
|
2155
|
+
/**
|
|
2156
|
+
* Babylon.js `ISafeOrbitCameraLimits` — safe-orbit camera limits embedded in a Gaussian
|
|
2157
|
+
* Splatting file's metadata (Adobe safe-orbit extension). Exposed on the loaded mesh via
|
|
2158
|
+
* {@link GaussianSplattingMesh.safeOrbitCameraLimits} for shape parity with `@babylonjs/core`.
|
|
2159
|
+
*/
|
|
2160
|
+
export declare interface ISafeOrbitCameraLimits {
|
|
2161
|
+
/** Minimum safe orbit radius (distance from the camera to its target), if the file specifies one. */
|
|
2162
|
+
radiusMin?: number;
|
|
2163
|
+
/** Safe elevation range as `[minElevation, maxElevation]` in radians, if the file specifies one. */
|
|
2164
|
+
elevationMinMax?: [number, number];
|
|
2165
|
+
}
|
|
2166
|
+
|
|
1985
2167
|
/** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
|
|
1986
2168
|
export declare function IsHtmlInCanvasSupportedNatively(): never;
|
|
1987
2169
|
|
|
@@ -2104,6 +2286,14 @@ export declare interface IStreamingSoundPlayOptions {
|
|
|
2104
2286
|
volume?: number;
|
|
2105
2287
|
}
|
|
2106
2288
|
|
|
2289
|
+
/** Babylon.js `IUploadImageToTexture2DArrayLayerOptions`. */
|
|
2290
|
+
export declare interface IUploadImageToTexture2DArrayLayerOptions {
|
|
2291
|
+
/** Store the source with the Y axis inverted (false by default). */
|
|
2292
|
+
invertY?: boolean;
|
|
2293
|
+
/** Premultiply the source alpha (false by default). */
|
|
2294
|
+
premultiplyAlpha?: boolean;
|
|
2295
|
+
}
|
|
2296
|
+
|
|
2107
2297
|
/** Babylon.js `IVolumeAudioOptions`. */
|
|
2108
2298
|
export declare interface IVolumeAudioOptions {
|
|
2109
2299
|
/** Volume / gain. Defaults to `1`. */
|
|
@@ -2150,15 +2340,7 @@ export declare abstract class Light extends Node_2 {
|
|
|
2150
2340
|
protected constructor(n
|
|
2151
2341
|
* carries `0`, but the getter still returns the logical value the caller set.
|
|
2152
2342
|
*/
|
|
2153
2343
|
get intensity(): number;
|
|
2154
|
-
set intensity(value: number);
|
|
2155
|
-
/**
|
|
2156
|
-
* Babylon.js `light.setEnabled(false)` — toggle the light's contribution.
|
|
2157
|
-
* Babylon Lite has no per-light enable flag, so a disabled light is expressed
|
|
2158
|
-
* by zeroing its intensity in the shared lights UBO (and restoring it on
|
|
2159
|
-
* re-enable). The logical intensity value is preserved across the toggle.
|
|
2160
|
-
*/
|
|
2161
|
-
setEnabled(value: boolean): void;
|
|
2162
|
-
/** Detach this light's shadow generator (compat for `light.shadowEnabled = false`). */
|
|
2344
|
+
set intensity(value: number);
|
|
2163
2345
|
/** Detach this light's shadow generator (compat for `light.shadowEnabled = false`). */
|
|
2164
2346
|
set shadowEnabled(enabled: boolean);
|
|
2165
2347
|
dispose(): void;
|
|
2166
2348
|
}
|
|
@@ -2200,20 +2382,10 @@ export declare class LiteCompatError extends Error {
|
|
|
2200
2382
|
export declare function LoadAssetContainerAsync(source: string, scene: Scene, _options?: unknown): Promise<AssetContainer>;
|
|
2201
2383
|
|
|
2202
2384
|
/**
|
|
2203
|
-
*
|
|
2204
|
-
*
|
|
2385
|
+
* Babylon.js `LoadImageToTexture2DArrayLayerAsync` — fetch/decode an image URL and
|
|
2386
|
+
* upload it into one layer. Forwards to Lite's `loadImageToArrayLayer`.
|
|
2205
2387
|
*/
|
|
2206
|
-
declare class LoadedMesh {
|
|
2207
|
-
readonly name: string;
|
|
2208
|
-
private readonly _mesh;
|
|
2209
2388
|
constructor(mesh: Mesh_2, container?: AssetContainer_2);
|
|
2210
2389
|
/** Babylon.js `refreshBoundingInfo()` — bounds are read on demand, so this is a no-op. */
|
|
2211
|
-
|
|
2212
|
-
/** Babylon.js `getBoundingInfo()` — local-space AABB of this mesh (see module note). */
|
|
2213
|
-
getBoundingInfo(): BoundingInfo;
|
|
2214
|
-
/** Babylon.js `getVerticesData(kind)` — CPU position buffer (positions only). */
|
|
2215
|
-
getVerticesData(kind: string): Float32Array | null;
|
|
2216
|
-
/** Babylon.js `getTotalVertices()`. */
|
|
2217
|
-
getTotalVertices(): number;
|
|
2218
|
-
}
|
|
2390
|
+
export declare function LoadImageToTexture2DArrayLayerAsync(texture: RawTexture2DArray, url: string, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): Promise<void>;
|
|
2219
2391
|
|
|
2220
2392
|
declare interface LockedTarget {
|
|
2221
2393
|
position: {
|
|
@@ -2254,6 +2426,22 @@ export declare abstract class Material {
|
|
|
2254
2426
|
set backFaceCulling(value: boolean);
|
|
2255
2427
|
/** Wireframe rendering toggle (not honoured by all Lite materials). */
|
|
2256
2428
|
wireframe: boolean;
|
|
2257
2429
|
protected constructor(name: string, scene?: Scene);
|
|
2258
2430
|
getClassName(): string;
|
|
2431
|
+
/**
|
|
2432
|
+
* Babylon.js `Material.clone(name)` — return a deep copy of this material under
|
|
2433
|
+
* a new name. Textures are **shared** by reference (matching Babylon.js), but the
|
|
2434
|
+
* clone gets its **own** Babylon Lite renderable (a fresh `_buildGroup` / UBO from
|
|
2435
|
+
* its factory) rather than aliasing the source's, so the two materials render and
|
|
2436
|
+
* dirty-track independently. Each concrete subclass copies its own property set.
|
|
2437
|
+
*/
|
|
2438
|
+
abstract clone(name: string): Material;
|
|
2259
2439
|
/** The scene this material was constructed against (Babylon.js `Material.getScene`). */
|
|
2440
|
+
getScene(): Scene | undefined;
|
|
2441
|
+
/**
|
|
2442
|
+
* The textures currently bound to this material (Babylon.js
|
|
2443
|
+
* `Material.getActiveTextures`). The base material owns no texture slots, so
|
|
2444
|
+
* this returns an empty array; each subclass overrides it to enumerate its own
|
|
2445
|
+
* slots and those of its extensions.
|
|
2446
|
+
*/
|
|
2447
|
+
getActiveTextures(): BaseTexture[];
|
|
2260
2448
|
protected _markDirty(): void;
|
|
2261
2449
|
dispose(): void;
|
|
2262
2450
|
}
|
|
2263
2451
|
|
|
@@ -2315,8 +2503,7 @@ export declare class Matrix {
|
|
|
2315
2503
|
/** Babylon.js `Mesh` — a concrete renderable mesh with geometry. */
|
|
2316
2504
|
export declare class Mesh extends AbstractMesh {
|
|
2317
2505
|
constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
|
|
2318
|
-
getClassName(): string;
|
|
2319
|
-
private _morphTargetManager;
|
|
2506
|
+
getClassName(): string;
|
|
2320
2507
|
private _morphTargetManager;
|
|
2321
2508
|
/**
|
|
2322
2509
|
* Babylon.js `mesh.morphTargetManager`. Babylon Lite builds morph GPU data via
|
|
2323
2510
|
* `createMorphTargets` and stores it on the Lite mesh; the compat manager is
|
|
@@ -2345,10 +2532,43 @@ export declare class Mesh extends AbstractMesh {
|
|
|
2345
2532
|
* API. Applied immediately to the Lite mesh (before the scene builds).
|
|
2346
2533
|
*/
|
|
2347
2534
|
thinInstanceSetBuffer(kind: string, buffer: Float32Array | null, _stride?: number): void;
|
|
2348
|
-
/**
|
|
2349
|
-
|
|
2535
|
+
/**
|
|
2536
|
+
* Babylon.js `mesh.clone(name, newParent?, doNotCloneChildren?)` — a new mesh
|
|
2537
|
+
* that shares this mesh's geometry. Forwards to Lite's `cloneTransformNode`,
|
|
2538
|
+
* which shares the `_gpu`/skeleton/morph/thin-instance resources with the clone
|
|
2539
|
+
* under ref-counting (so both meshes own the buffers and they survive until the
|
|
2540
|
+
* last is disposed). Babylon.js uses the requested name verbatim, derives clone
|
|
2541
|
+
* IDs from that name plus the source ID, and prefixes descendant names with the
|
|
2542
|
+
* root clone name. The source material is kept (BJS shares it by reference), and
|
|
2543
|
+
* the clone is registered with the same compat scene through its own wrapper.
|
|
2544
|
+
* An omitted or `null` `newParent` keeps the source parent.
|
|
2545
|
+
* `doNotCloneChildren` drops the descendants Lite always clones.
|
|
2546
|
+
*/
|
|
2547
|
+
clone(name?: string, newParent?: Node_2 | null, doNotCloneChildren?: boolean): Mesh;
|
|
2548
|
+
private static _wrapCloneHierarchy;
|
|
2350
2549
|
/** Level-of-detail — unsupported (no LOD system in Babylon Lite). */
|
|
2351
2550
|
addLODLevel(): never;
|
|
2551
|
+
/**
|
|
2552
|
+
* Babylon.js `Mesh.MergeMeshes` — bake several meshes into one, transforming
|
|
2553
|
+
* each source's geometry by its world matrix. Signature:
|
|
2554
|
+
* `MergeMeshes(meshes, disposeSource?, allow32BitsIndices?, meshSubclass?, subdivideWithSubMeshes?, multiMultiMaterials?)`.
|
|
2555
|
+
* Uses the compat-local `mergeMeshGeometry`; the merged mesh lives at
|
|
2556
|
+
* identity (world transforms are baked in) and takes the first mesh's material.
|
|
2557
|
+
*
|
|
2558
|
+
* **Supported semantics** (everything else is rejected, never silently dropped):
|
|
2559
|
+
* - `disposeSource` (default `true`) — source meshes are disposed after merge.
|
|
2560
|
+
* - `allow32BitsIndices` — Lite indices are always uint32, so 32-bit is always
|
|
2561
|
+
* available. When `allow32BitsIndices` is falsy and the merged vertex count
|
|
2562
|
+
* reaches 65536, this returns `null`, exactly like Babylon.js.
|
|
2563
|
+
* - Positions, normals (world-transformed) and one UV set are carried.
|
|
2564
|
+
*
|
|
2565
|
+
* **Rejected** (throws `LiteCompatError`): `multiMultiMaterials` /
|
|
2566
|
+
* `subdivideWithSubMeshes` (Lite has no submesh / multi-material partitioning),
|
|
2567
|
+
* a supplied `meshSubclass` target, and sources carrying vertex colours,
|
|
2568
|
+
* tangents or a second UV set, or sources carrying skeleton, morph-target, or
|
|
2569
|
+
* vertex-animation data (Lite would have to drop them).
|
|
2570
|
+
*/
|
|
2571
|
+
static MergeMeshes(meshes: (Mesh | null | undefined)[], disposeSource?: boolean, allow32BitsIndices?: boolean, meshSubclass?: Mesh, subdivideWithSubMeshes?: boolean, multiMultiMaterials?: boolean): Mesh | null;
|
|
2352
2572
|
}
|
|
2353
2573
|
|
|
2354
2574
|
/** Babylon.js `MeshBuilder` — factory namespace for primitive meshes. */
|
|
@@ -2379,6 +2599,8 @@ export declare const MeshBuilder: {
|
|
|
2379
2599
|
CreateDashedLines(): never;
|
|
2380
2600
|
CreateDecal(): never;
|
|
2381
2601
|
CreateText(): never;
|
|
2602
|
+
CreateTiledBox(_name?: string, _options?: object, _scene?: Scene): never;
|
|
2603
|
+
CreateTiledPlane(_name?: string, _options?: object, _scene?: Scene): never;
|
|
2382
2604
|
};
|
|
2383
2605
|
|
|
2384
2606
|
/** A compat mesh exposes its backing Lite mesh as `_lite`. */
|
|
@@ -2492,18 +2714,27 @@ declare abstract class Node_2 {
|
|
|
2492
2714
|
* descendant nodes that are meshes (all descendants by default).
|
|
2493
2715
|
*/
|
|
2494
2716
|
getChildMeshes(directDescendantsOnly?: boolean, predicate?: (node: Node_2) => boolean): Node_2[];
|
|
2495
|
-
isEnabled(): boolean;
|
|
2496
|
-
setEnabled(value: boolean): void;
|
|
2497
|
-
isDisposed(): boolean;
|
|
2498
|
-
dispose(): void;
|
|
2717
|
+
isEnabled(checkAncestors?: boolean): boolean;
|
|
2718
|
+
setEnabled(value: boolean): void;
|
|
2499
2719
|
isDisposed(): boolean;
|
|
2720
|
+
dispose(doNotRecurse?: boolean): void;
|
|
2500
2721
|
export { Node_2 as Node }
|
|
2501
2722
|
|
|
2502
2723
|
export declare class NodeMaterial {
|
|
2503
2724
|
name: string;
|
|
2504
2725
|
backFaceCulling: boolean;
|
|
2505
2726
|
private readonly _json;
|
|
2506
2727
|
private readonly _textureOverrides;
|
|
2507
|
-
|
|
2728
|
+
private readonly _scene;
|
|
2729
|
+
private readonly _pendingBindings;
|
|
2730
|
+
private _parsed;
|
|
2731
|
+
constructor(name: string, scene: Scene, json?: object | string);
|
|
2508
2732
|
getClassName(): string;
|
|
2733
|
+
/**
|
|
2734
|
+
* Babylon.js `NodeMaterial.clone(name)`. Reuses the same NME source graph and the
|
|
2735
|
+
* captured per-block texture overrides (textures shared by reference, as
|
|
2736
|
+
* Babylon.js does), registering the clone with the scene so it parses/compiles its
|
|
2737
|
+
* own Lite node material (own renderable) at engine start.
|
|
2738
|
+
*/
|
|
2739
|
+
clone(name: string): NodeMaterial;
|
|
2509
2740
|
/** Babylon.js `getBlockByName(name)` — returns a proxy that captures texture overrides. */
|
|
2510
2741
|
getBlockByName(name: string): NodeMaterialBlockProxy;
|
|
2511
2742
|
/** Babylon.js `NodeMaterial.build()` — Lite builds during parse, so this is a no-op. */
|
|
2512
2743
|
build(_verbose?: boolean): void;
|
|
2513
2744
|
dispose(): void;
|
|
2514
2745
|
/**
|
|
@@ -2524,6 +2755,43 @@ declare class NodeMaterialBlockProxy {
|
|
|
2524
2755
|
get texture(): TextureLike | null;
|
|
2525
2756
|
}
|
|
2526
2757
|
|
|
2758
|
+
/**
|
|
2759
|
+
* Babylon.js `NodeParticleSystemSet` — a Node Particle Editor graph. The compat
|
|
2760
|
+
* wrapper supports the load→build→start path used by ported scenes; the
|
|
2761
|
+
* programmatic graph-authoring surface throws.
|
|
2762
|
+
*/
|
|
2763
|
+
export declare class NodeParticleSystemSet {
|
|
2764
|
+
name: string;
|
|
2527
2765
|
constructor(name?: string);
|
|
2766
|
+
getClassName(): string;
|
|
2767
|
+
/**
|
|
2768
|
+
* Babylon.js `NodeParticleSystemSet.buildAsync(scene)` — compile the graph into
|
|
2769
|
+
* a live {@link ParticleSystemSet}. Forwards to Lite
|
|
2770
|
+
* `parseNodeParticleSetFromSnippet`, which parses and builds in one shot (from
|
|
2771
|
+
* the recorded snippet id or inline JSON).
|
|
2772
|
+
*/
|
|
2773
|
+
buildAsync(scene: Scene, _verbose?: boolean): Promise<ParticleSystemSet>;
|
|
2774
|
+
/** Babylon.js `NodeParticleSystemSet.Parse(source)` — deserialize an inline graph. */
|
|
2775
|
+
static Parse(source: unknown): NodeParticleSystemSet;
|
|
2776
|
+
/**
|
|
2777
|
+
* Babylon.js `NodeParticleSystemSet.ParseFromSnippetAsync(snippetId)` — load a
|
|
2778
|
+
* graph from the snippet server. The network fetch is deferred to `buildAsync`
|
|
2779
|
+
* (Lite fuses fetch+parse+build), so this resolves immediately with the id.
|
|
2780
|
+
*/
|
|
2781
|
+
static ParseFromSnippetAsync(snippetId: string, nodeParticleSet?: NodeParticleSystemSet): Promise<NodeParticleSystemSet>;
|
|
2782
|
+
/**
|
|
2783
|
+
* Babylon.js `NodeParticleSystemSet.ParseFromFileAsync(name, url)` — load a
|
|
2784
|
+
* serialized graph from a URL, then behave like {@link Parse}.
|
|
2785
|
+
*/
|
|
2786
|
+
static ParseFromFileAsync(name: string, url: string, nodeParticleSet?: NodeParticleSystemSet): Promise<NodeParticleSystemSet>;
|
|
2787
|
+
/** Babylon.js `NodeParticleSystemSet.CreateDefault(name)`. Requires programmatic block authoring — not backed. */
|
|
2788
|
+
static CreateDefault(_name: string): NodeParticleSystemSet;
|
|
2789
|
+
get attachedBlocks(): never;
|
|
2790
|
+
getBlockByName(_name: string): never;
|
|
2791
|
+
serialize(): never;
|
|
2792
|
+
editAsync(): never;
|
|
2793
|
+
dispose(): void;
|
|
2794
|
+
}
|
|
2795
|
+
|
|
2528
2796
|
/**
|
|
2529
2797
|
* Babylon.js's `NullEngine` — a headless engine with no GPU device, used to run
|
|
2530
2798
|
* scene logic (animations, observables, physics stepping, frame timing) without
|
|
@@ -2556,7 +2824,12 @@ export declare class OBJFileLoader {
|
|
|
2556
2824
|
}
|
|
2557
2825
|
|
|
2558
2826
|
export declare class Observable<T> {
|
|
2827
|
+
private _onObserverAdded?;
|
|
2828
|
+
notifyIfTriggered: boolean;
|
|
2559
2829
|
private _observers;
|
|
2830
|
+
private _hasNotified;
|
|
2831
|
+
private _lastNotifiedValue;
|
|
2832
|
+
constructor(_onObserverAdded?: ((observer: ObserverCallback<T>) => void) | undefined, notifyIfTriggered?: boolean);
|
|
2560
2833
|
add(callback: ObserverCallback<T>): ObserverCallback<T>;
|
|
2561
2834
|
addOnce(callback: ObserverCallback<T>): ObserverCallback<T>;
|
|
2562
2835
|
remove(callback: ObserverCallback<T> | null | undefined): boolean;
|
|
@@ -2564,6 +2837,7 @@ export declare class Observable<T> {
|
|
|
2564
2837
|
notifyObservers(eventData?: T): void;
|
|
2565
2838
|
hasObservers(): boolean;
|
|
2566
2839
|
clear(): void;
|
|
2840
|
+
cleanLastNotifiedState(): void;
|
|
2567
2841
|
}
|
|
2568
2842
|
|
|
2569
2843
|
/**
|
|
@@ -2590,8 +2864,34 @@ export declare class ParticleSystem {
|
|
|
2590
2864
|
constructor();
|
|
2591
2865
|
}
|
|
2592
2866
|
|
|
2593
|
-
|
|
2594
|
-
|
|
2867
|
+
/**
|
|
2868
|
+
* Babylon.js `ParticleSystemSet` — the built output of an NPE graph. Backed by a
|
|
2869
|
+
* Lite `NodeParticleSet`; `start()` registers it as a live billboard system in the
|
|
2870
|
+
* scene. Directly constructing an empty set (`new ParticleSystemSet()`) is allowed
|
|
2871
|
+
* for parity but has no systems until produced by {@link NodeParticleSystemSet.buildAsync}.
|
|
2872
|
+
*/
|
|
2873
|
+
export declare class ParticleSystemSet {
|
|
2595
2874
|
private _started;
|
|
2875
|
+
getClassName(): string;
|
|
2876
|
+
/**
|
|
2877
|
+
* Babylon.js `ParticleSystemSet.systems` — the array of per-system
|
|
2878
|
+
* `ParticleSystem` handles. Not backed: Lite's node-particle runtime is a fused
|
|
2879
|
+
* struct-of-arrays simulation with no per-system BJS `ParticleSystem` object to
|
|
2880
|
+
* expose. Drive the set as a whole via {@link start} instead.
|
|
2881
|
+
*/
|
|
2882
|
+
get systems(): never;
|
|
2883
|
+
/**
|
|
2884
|
+
* Babylon.js `ParticleSystemSet.start()` — begin all systems. Forwards to Lite
|
|
2885
|
+
* `registerNodeParticleSet`, which renders each system as a camera-facing
|
|
2886
|
+
* billboard and advances it once per frame. Idempotent.
|
|
2887
|
+
*/
|
|
2888
|
+
start(): void;
|
|
2889
|
+
/**
|
|
2890
|
+
* Babylon.js `ParticleSystemSet.dispose()` — stop the systems. Lite exposes no
|
|
2891
|
+
* unregister for an already-registered billboard system, so this stops emission
|
|
2892
|
+
* on every built system (via `stopParticleSystem`); the last-emitted particles
|
|
2893
|
+
* finish their lifetime.
|
|
2894
|
+
*/
|
|
2895
|
+
dispose(): void;
|
|
2596
2896
|
}
|
|
2597
2897
|
|
|
2598
2898
|
/** A 3D path with cumulative-distance queries over its points. */
|
|
@@ -2661,7 +2961,8 @@ export declare class PBRIridescenceConfiguration {
|
|
|
2661
2961
|
set maximumThickness(value: number);
|
|
2662
2962
|
}
|
|
2663
2963
|
|
|
2664
|
-
export declare class PBRMaterial extends PushMaterial {
|
|
2665
2964
|
constructor(name: string, scene?: Scene);
|
|
2965
|
+
export declare class PBRMaterial extends PushMaterial {
|
|
2666
2966
|
private _albedoFactor;
|
|
2967
|
+
constructor(name: string, scene?: Scene);
|
|
2667
2968
|
getClassName(): string;
|
|
2668
2969
|
get albedoColor(): Color3;
|
|
2669
2970
|
set albedoColor(value: Color3);
|
|
@@ -2673,6 +2974,11 @@ export declare class PBRMaterial extends PushMaterial {
|
|
|
2673
2974
|
constructor(name: st
|
|
2674
2975
|
get albedoTexture(): BaseTexture | null;
|
|
2675
2976
|
set albedoTexture(texture: BaseTexture | null);
|
|
2676
2977
|
private _albedoTexture;
|
|
2978
|
+
/**
|
|
2979
|
+
* Enumerate every bound PBR texture slot, including extension sub-configurations
|
|
2980
|
+
* (Babylon.js `PBRMaterial.getActiveTextures`).
|
|
2981
|
+
*/
|
|
2982
|
+
getActiveTextures(): BaseTexture[];
|
|
2677
2983
|
get metallic(): number;
|
|
2678
2984
|
set metallic(value: number);
|
|
2679
2985
|
get roughness(): number;
|
|
@@ -2718,8 +3024,15 @@ export declare class PBRMaterial extends PushMaterial {
|
|
|
2718
3024
|
constructor(name: st
|
|
2719
3025
|
*/
|
|
2720
3026
|
get environmentTexture(): CubeTexture | HDRCubeTexture | null;
|
|
2721
3027
|
set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
|
|
3028
|
+
private _environmentTexture;
|
|
2722
3029
|
get reflectionTexture(): CubeTexture | HDRCubeTexture | null;
|
|
2723
|
-
set reflectionTexture(value: CubeTexture | HDRCubeTexture | null);
|
|
3030
|
+
set reflectionTexture(value: CubeTexture | HDRCubeTexture | null);
|
|
2724
3031
|
/**
|
|
3032
|
+
* Babylon.js `PBRMaterial.clone(name)`. Copies the albedo/metallic/roughness/
|
|
3033
|
+
* emissive state, shares the albedo texture reference, gives the clone independent
|
|
3034
|
+
* clearcoat/sheen/anisotropy/iridescence sub-configurations (sharing any nested
|
|
3035
|
+
* texture), and a fresh Lite PBR renderable.
|
|
3036
|
+
*/
|
|
3037
|
+
clone(name: string): PBRMaterial;
|
|
2725
3038
|
|
|
2726
3039
|
/**
|
|
2727
3040
|
* Babylon.js `PBRMetallicRoughnessMaterial` — a simplified façade over
|
|
@@ -2730,6 +3043,7 @@ export declare class PBRMetallicRoughnessMaterial extends PBRMaterial {
|
|
|
2730
3043
|
/** Alias of `albedoColor` (glTF "base color"). */
|
|
2731
3044
|
get baseColor(): Color3;
|
|
2732
3045
|
set baseColor(value: Color3);
|
|
3046
|
+
clone(name: string): PBRMetallicRoughnessMaterial;
|
|
2733
3047
|
}
|
|
2734
3048
|
|
|
2735
3049
|
/** Babylon.js `PBRSheenConfiguration` — the `pbr.sheen` sub-object over Lite `SheenProps`. */
|
|
@@ -2745,10 +3059,12 @@ export declare class PBRSheenConfiguration {
|
|
|
2745
3059
|
set roughness(value: number);
|
|
2746
3060
|
get color(): Color3;
|
|
2747
3061
|
set color(value: Color3);
|
|
2748
|
-
/** Babylon.js `sheen.texture`.
|
|
2749
|
-
|
|
2750
|
-
|
|
2751
|
-
|
|
3062
|
+
/** Babylon.js `sheen.texture`. Retains the wrapper and binds the Lite handle if the texture has resolved. */
|
|
3063
|
+
get texture(): BaseTexture | null;
|
|
3064
|
+
set texture(value: BaseTexture | null);
|
|
3065
|
+
private _texture;
|
|
3066
|
+
/** Enumerate the sheen texture slot for `Material.getActiveTextures`. */
|
|
3067
|
+
getActiveTextures(): BaseTexture[];
|
|
2752
3068
|
}
|
|
2753
3069
|
|
|
2754
3070
|
/**
|
|
@@ -2765,6 +3081,7 @@ export declare class PBRSpecularGlossinessMaterial extends PBRMaterial {
|
|
|
2765
3081
|
/** Maps glossiness → (1 - roughness). */
|
|
2766
3082
|
get glossiness(): number;
|
|
2767
3083
|
set glossiness(value: number);
|
|
3084
|
+
clone(name: string): PBRSpecularGlossinessMaterial;
|
|
2768
3085
|
}
|
|
2769
3086
|
|
|
2770
3087
|
/** Rolling FPS/frame-time monitor (Babylon.js `PerformanceMonitor`). */
|
|
@@ -2999,6 +3316,11 @@ export declare class Quaternion {
|
|
|
2999
3316
|
* from the rotation part of `matrix`. Backed by Lite's `quatFromRotationMatrix`.
|
|
3000
3317
|
*/
|
|
3001
3318
|
fromRotationMatrix(matrix: Matrix): this;
|
|
3319
|
+
/**
|
|
3320
|
+
* Babylon.js `Quaternion.toRotationMatrix` — write this quaternion's rotation
|
|
3321
|
+
* into `result`.
|
|
3322
|
+
*/
|
|
3323
|
+
toRotationMatrix<T extends Matrix>(result: T): T;
|
|
3002
3324
|
clone(): Quaternion;
|
|
3003
3325
|
equals(other: Quaternion): boolean;
|
|
3004
3326
|
asArray(): [number, number, number, number];
|
|
@@ -3039,6 +3361,51 @@ export declare class RawTexture extends BaseTexture {
|
|
|
3039
3361
|
static CreateRGBATexture(data: Uint8Array, width: number, height: number, scene: Scene): RawTexture;
|
|
3040
3362
|
}
|
|
3041
3363
|
|
|
3364
|
+
/**
|
|
3365
|
+
* Babylon.js `RawTexture2DArray` — a 2D array texture. Backed by Babylon Lite's
|
|
3366
|
+
* `Texture2DArray`.
|
|
3367
|
+
*
|
|
3368
|
+
* Both Babylon.js construction paths work: pass raw multi-layer RGBA8 bytes
|
|
3369
|
+
* (`data !== null`) for a CPU-generated array, or construct empty (`data = null`)
|
|
3370
|
+
* and fill layers from decoded image sources via
|
|
3371
|
+
* {@link UploadImageToTexture2DArrayLayer} /
|
|
3372
|
+
* {@link LoadImageToTexture2DArrayLayerAsync}, or build the whole array in one call
|
|
3373
|
+
* with {@link CreateTexture2DArrayFromImageUrlsAsync}.
|
|
3374
|
+
*
|
|
3375
|
+
* Babylon Lite's array path is RGBA8-only, so `format` / `textureType` /
|
|
3376
|
+
* `samplingMode` are recorded for API parity but the upload always treats `data` as
|
|
3377
|
+
* tightly-packed `width * height * depth * 4` RGBA bytes (layer-major). Raw-byte
|
|
3378
|
+
* uploads are not Y-flipped (matching the compat `RawTexture` / `RawTexture3D`
|
|
3379
|
+
* pixel paths), so `invertY` is recorded but not applied to `data`.
|
|
3380
|
+
*/
|
|
3381
|
+
export declare class RawTexture2DArray extends BaseTexture {
|
|
3382
|
+
/** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
|
|
3383
|
+
format: number;
|
|
3042
3384
|
/** Babylon.js `RawTexture2DArray.is2DArray` — always true. */
|
|
3385
|
+
readonly is2DArray = true;
|
|
3043
3386
|
constructor(data: ArrayBufferView | null, width: number, height: number, depth: number,
|
|
3387
|
+
/** Babylon.js texture format (recorded for parity; Lite uploads RGBA8). */
|
|
3388
|
+
format: number, scene: Scene, generateMipMaps?: boolean, _invertY?: boolean, _samplingMode?: number, _textureType?: number, _creationFlags?: number, _mipLevelCount?: number);
|
|
3389
|
+
getClassName(): string;
|
|
3390
|
+
/** Babylon.js `RawTexture2DArray.depth` — the number of array layers. */
|
|
3391
|
+
get depth(): number;
|
|
3392
|
+
/** The scene this texture belongs to (Babylon.js `ThinTexture.getScene`). */
|
|
3393
|
+
getScene(): Scene;
|
|
3394
|
+
/**
|
|
3395
|
+
* Babylon.js `RawTexture2DArray.getInternalTexture()` — the backend handle the compat
|
|
3396
|
+
* engine's texture methods accept (Lite's `Texture2DArray`).
|
|
3397
|
+
*/
|
|
3398
|
+
getInternalTexture(): Texture2DArray | null;
|
|
3399
|
+
/** Babylon.js `RawTexture2DArray.update(data)` — replace the base mip of every layer. */
|
|
3400
|
+
update(data: ArrayBufferView): void;
|
|
3401
|
+
/**
|
|
3402
|
+
* Babylon.js `RawTexture2DArray.updateMipLevel(data, mipLevel)` — replace one mip level of
|
|
3403
|
+
* every layer. Level dimensions are `max(1, size >> mipLevel)`; writing level 0 of a
|
|
3404
|
+
* mipmapped array regenerates the rest of the chain, exactly as Babylon.js does.
|
|
3405
|
+
*/
|
|
3406
|
+
updateMipLevel(data: ArrayBufferView, mipLevel: number): void;
|
|
3407
|
+
whenReadyAsync(): Promise<void>;
|
|
3044
3408
|
/** Babylon.js `RawTexture2DArray.CreateRGBATexture` — RGBA raw-bytes factory. */
|
|
3409
|
+
static CreateRGBATexture(data: ArrayBufferView, width: number, height: number, depth: number, scene: Scene, generateMipMaps?: boolean, invertY?: boolean, samplingMode?: 3, type?: 0): RawTexture2DArray;
|
|
3410
|
+
}
|
|
3411
|
+
|
|
3045
3412
|
/**
|
|
3046
3413
|
* Babylon.js `RawTexture3D` — a volumetric texture created from raw RGBA8 pixel
|
|
3047
3414
|
* bytes (the common case being a colour-grading LUT / colour cube). Backed by
|
|
@@ -3185,6 +3552,7 @@ export declare class Scene extends AbstractScene {
|
|
|
3185
3552
|
/** Babylon.js fog-mode c
|
|
3186
3553
|
private _fogDensity;
|
|
3187
3554
|
private _fogColor;
|
|
3188
3555
|
private _started;
|
|
3189
3556
|
private _envTexture;
|
|
3557
|
+
private _brdfTexture;
|
|
3190
3558
|
private _defaultEnvOptions;
|
|
3191
3559
|
private readonly _shadowGenerators;
|
|
3192
3560
|
private readonly _pendingTextures;
|
|
@@ -3198,7 +3566,7 @@ export declare class Scene extends AbstractScene {
|
|
|
3198
3566
|
/** Babylon.js fog-mode c
|
|
3199
3567
|
/** Babylon.js `scene.getClassName()`. */
|
|
3200
3568
|
getClassName(): string;
|
|
3201
3569
|
/** Babylon.js `scene.getUniqueId()` — the process-unique scene id. */
|
|
3202
|
-
getUniqueId(): number;
|
|
3203
3570
|
/**
|
|
3571
|
+
getUniqueId(): number;
|
|
3204
3572
|
private _liteShadowGenerators;
|
|
3205
3573
|
/**
|
|
3206
3574
|
* Babylon.js `scene.defaultMaterial` — a shared `StandardMaterial` applied to
|
|
3207
3575
|
* meshes that have no material assigned. Babylon Lite requires every mesh to
|
|
3208
3576
|
* carry a material to render, so the mesh wrappers assign this lazily-created
|
|
@@ -3269,6 +3637,24 @@ export declare class Scene extends AbstractScene {
|
|
|
3269
3637
|
/** Babylon.js fog-mode c
|
|
3270
3638
|
set clipPlane(value: Plane | null);
|
|
3271
3639
|
get environmentTexture(): CubeTexture | HDRCubeTexture | null;
|
|
3272
3640
|
set environmentTexture(value: CubeTexture | HDRCubeTexture | null);
|
|
3641
|
+
/**
|
|
3642
|
+
* Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
|
|
3643
|
+
* Babylon.js defaults this to an embedded Base64 LUT and lets apps swap in one of the
|
|
3644
|
+
* published variants (e.g. `https://assets.babylonjs.com/environments/correlatedMSBRDF_RGBD.png`).
|
|
3645
|
+
*
|
|
3646
|
+
* Two deliberate divergences: the getter returns `null` while unset (Babylon.js
|
|
3647
|
+
* populates it with the decoded default once a PBR material is created, whereas Lite
|
|
3648
|
+
* keeps the default as an embedded data URL and never materialises a texture object),
|
|
3649
|
+
* and the assigned texture's own GPU upload goes unused because Babylon Lite decodes
|
|
3650
|
+
* the LUT itself, from the URL, as part of building the environment.
|
|
3651
|
+
*/
|
|
3652
|
+
get environmentBRDFTexture(): BaseTexture | null;
|
|
3653
|
+
set environmentBRDFTexture(value: BaseTexture | null);
|
|
3654
|
+
/**
|
|
3655
|
+
* Resolve the BRDF LUT URL for the environment loaders: an app-supplied
|
|
3656
|
+
* `environmentBRDFTexture`, else the embedded Babylon.js-style default.
|
|
3657
|
+
*/
|
|
3658
|
+
private _resolveBrdfUrl;
|
|
3273
3659
|
/**
|
|
3274
3660
|
* Babylon.js `scene.createDefaultEnvironment` — adds an IBL skybox and ground.
|
|
3275
3661
|
* Babylon Lite performs this through `loadEnvironment` (deferred to engine start),
|
|
@@ -3734,7 +4120,15 @@ export declare class StandardMaterial extends PushMaterial {
|
|
|
3734
4120
|
constructor(nam
|
|
3735
4121
|
set emissiveTexture(texture: BaseTexture | null);
|
|
3736
4122
|
private _diffuseTexture;
|
|
3737
4123
|
private _bumpTexture;
|
|
3738
|
-
private _emissiveTexture;
|
|
4124
|
+
private _emissiveTexture;
|
|
4125
|
+
/** Enumerate the standard-material texture slots that are bound (Babylon.js `getActiveTextures`). */
|
|
4126
|
+
getActiveTextures(): BaseTexture[];
|
|
3739
4127
|
/**
|
|
4128
|
+
* Babylon.js `StandardMaterial.clone(name)`. Copies the diffuse/specular/emissive/
|
|
4129
|
+
* ambient colours and scalars, shares the diffuse/bump/emissive texture references,
|
|
4130
|
+
* and gives the clone its own Lite standard-material renderable.
|
|
4131
|
+
*/
|
|
4132
|
+
clone(name: string): StandardMaterial;
|
|
4133
|
+
}
|
|
3740
4134
|
|
|
3741
4135
|
/** Babylon.js `StaticSound` — a buffer-backed sound wrapping a Lite `StaticSound`. */
|
|
3742
4136
|
export declare class StaticSound extends AbstractSound {
|
|
3743
4137
|
private readonly _autoplay;
|
|
@@ -3882,6 +4276,7 @@ declare type TaskState = "init" | "running" | "done" | "error";
|
|
|
3882
4276
|
|
|
3883
4277
|
export declare class Texture extends BaseTexture {
|
|
3884
4278
|
private readonly _ready;
|
|
4279
|
+
private _onLoadObservable;
|
|
3885
4280
|
/** Babylon.js sampling-mode constants (numeric parity). */
|
|
3886
4281
|
static readonly NEAREST_SAMPLINGMODE = 1;
|
|
3887
4282
|
static readonly BILINEAR_SAMPLINGMODE = 2;
|
|
@@ -3911,6 +4306,9 @@ export declare class Texture extends BaseTexture {
|
|
|
3911
4306
|
*/
|
|
3912
4307
|
clone(): Texture;
|
|
3913
4308
|
whenReadyAsync(): Promise<void>;
|
|
4309
|
+
/** Babylon.js `Texture.onLoadObservable`, allocated only when code subscribes. */
|
|
4310
|
+
get onLoadObservable(): Observable<Texture>;
|
|
4311
|
+
private _notifyLoadObservable;
|
|
3914
4312
|
/** Babylon.js `BaseTexture.isReady()` — true once the GPU handle has resolved. */
|
|
3915
4313
|
isReady(): boolean;
|
|
3916
4314
|
/** Load a texture and resolve once its GPU handle is available. */
|
|
@@ -4043,6 +4441,14 @@ export declare function unsupported(api: string, detail?: string): never;
|
|
|
4043
4441
|
/** Babylon.js `UploadHtmlElementToTexture` — HTML texture upload is unsupported by the compat layer. */
|
|
4044
4442
|
export declare function UploadHtmlElementToTexture(): never;
|
|
4045
4443
|
|
|
4444
|
+
/**
|
|
4445
|
+
* Babylon.js `UploadImageToTexture2DArrayLayer` — upload a decoded image source
|
|
4446
|
+
* into one layer of a texture array. Routes through the engine's
|
|
4447
|
+
* `updateTextureArrayLayerFromImageSource` (as Babylon.js does), which forwards to
|
|
4448
|
+
* Lite's `uploadImageToArrayLayer`.
|
|
4449
|
+
*/
|
|
4450
|
+
export declare function UploadImageToTexture2DArrayLayer(texture: RawTexture2DArray, source: ImageSource, layer: number, options?: IUploadImageToTexture2DArrayLayerOptions): void;
|
|
4451
|
+
|
|
4046
4452
|
/** Babylon.js `UtilityLayerRenderer` — the overlay scene gizmos render into. */
|
|
4047
4453
|
export declare class UtilityLayerRenderer {
|
|
4048
4454
|
private _registered;
|
|
4049
4455
|
constructor(scene: Scene);
|
|
4050
4456
|
dispose(): void;
|