@babylonjs/lite-compat 1.38.2-preview → 1.39.1
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/CHANGELOG.md +1725 -0
- package/README.md +24 -24
- package/index.d.ts +212 -19
- package/index.js +790 -545
- package/index.js.map +1 -1
- package/{meshes-Bt_UAqXU.js → meshes-C-PkzbPM.js} +420 -20
- package/meshes-C-PkzbPM.js.map +1 -0
- package/navigation.d.ts +178 -17
- package/navigation.js +1 -1
- package/package.json +8 -5
- package/meshes-Bt_UAqXU.js.map +0 -1
package/README.md
CHANGED
|
@@ -115,35 +115,35 @@ overloads within a supported area may still be absent.
|
|
|
115
115
|
|
|
116
116
|
### `@babylonjs/core`
|
|
117
117
|
|
|
118
|
-
| Feature area | Status | Notes
|
|
119
|
-
| ------------------------------------------------------------------------------------------------------------------------------------------ | :----: |
|
|
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; 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
|
-
| Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported
|
|
123
|
-
| Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | `
|
|
124
|
-
| Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | arc controls include pointer, wheel, touch, and BJS-default Arrow-key input; orthographic bounds and projection-mode switching forward to Lite; fully unconfigured orthographic extents use Lite's `halfHeight` + aspect-ratio derivation rather than Babylon.js render dimensions; XR / device-orientation / stereoscopic rigs unsupported
|
|
125
|
-
| Lights (`Hemispheric`, `Directional`, `Point`, `Spot`, `RectAreaLight`) | ⚡ | rectangular area lights use Lite's native LTC path, including `AreaLightTextureTools` emission preprocessing; Lite is stricter for invalid negative/non-finite emitter dimensions. `ClusteredLightContainer` clusters unshadowed point lights before engine start (⚡ partial), while clustered spot lights remain unsupported
|
|
126
|
-
| Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM
|
|
127
|
-
| Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ |
|
|
128
|
-
| CSG / CSG2 | ✅ | over Lite boolean ops
|
|
129
|
-
| Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled)
|
|
130
|
-
| Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while Gaussian-splat visualization plugins, `DitheredTileFadeMaterialPlugin`, BJS-preprocessed `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported
|
|
131
|
-
| Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `ExternalTexture`, cube textures) | ⚡ |
|
|
132
|
-
| Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported; root-motion analysis/controller APIs throw
|
|
133
|
-
| Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets
|
|
134
|
-
| Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported
|
|
135
|
-
| Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw
|
|
136
|
-
| Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ |
|
|
137
|
-
| Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported
|
|
138
|
-
| Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations, thin-instance bodies, and filtered raycasts with instance indices; unrecognized enum values throw at the compat boundary
|
|
139
|
-
| Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`,
|
|
140
|
-
| Post-processes, layers (glow/highlight), probes, WebXR | ❌ | Babylon.js wrapper classes are not implemented — use native Lite `create*Task` functions, including `createMeshBlendingPostProcessTask` with geometry-renderer tag/depth/albedo outputs
|
|
118
|
+
| Feature area | Status | Notes |
|
|
119
|
+
| ------------------------------------------------------------------------------------------------------------------------------------------ | :----: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
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; 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
|
+
| Compute + GPU buffers (`ComputeShader`, `StorageBuffer`, `UniformBuffer`) | ⚡ | WGSL compute, direct/indirect dispatch, storage buffers, and compute-oriented std140 uniform buffers forward to Lite; shader registries/preprocessing, texture bindings, in-frame immediate dispatch, and Effect-oriented UBO methods remain unsupported |
|
|
123
|
+
| Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | `scene.meshes`, loader-produced `scene.skeletons`, and registered NPE `scene.particleSystems` expose stable compat wrappers; sync `scene.pick` forwards to Lite's CPU triangle picker; exposure/contrast/tone mapping are forwarded, while camera-wide temporal-history reset, white balance, and fluid rendering throw because Lite lacks the required cross-cutting ownership/render-pass contracts |
|
|
124
|
+
| Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | arc controls include pointer, wheel, touch, and BJS-default Arrow-key input; orthographic bounds and projection-mode switching forward to Lite; fully unconfigured orthographic extents use Lite's `halfHeight` + aspect-ratio derivation rather than Babylon.js render dimensions; XR / device-orientation / stereoscopic rigs unsupported |
|
|
125
|
+
| Lights (`Hemispheric`, `Directional`, `Point`, `Spot`, `RectAreaLight`) | ⚡ | rectangular area lights use Lite's native LTC path, including `AreaLightTextureTools` emission preprocessing; Lite is stricter for invalid negative/non-finite emitter dimensions. `ClusteredLightContainer` clusters unshadowed point lights before engine start (⚡ partial), while clustered spot lights remain unsupported |
|
|
126
|
+
| Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` uses Lite's native 2–4 cascade CSM |
|
|
127
|
+
| Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | Gaussian GPU-sort helper math is available and GPU-sort preferences preserve Lite's CPU-worker fallback; explicit GPU sorter/output resource classes still throw. `CreateLines`/`CreateLineSystem`, dashed lines, mesh metadata/blending tags, and common merges work; polygon/decal/text/tiled builders, thick lines, instances, LOD/edges/outline remain unsupported |
|
|
128
|
+
| CSG / CSG2 | ✅ | over Lite boolean ops |
|
|
129
|
+
| Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
|
|
130
|
+
| Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; fixed-slot custom WGSL `MaterialPluginBase` injection is supported (`#include`, regex replacement, and custom UBO/sampler hooks are not), while Gaussian-splat visualization plugins, `DitheredTileFadeMaterialPlugin`, BJS-preprocessed `ShaderMaterial`, `MultiMaterial`, `BackgroundMaterial`, and `OpenPBRMaterial` remain unsupported |
|
|
131
|
+
| Textures (`Texture`, `RawTexture`, `RawTexture2DArray`, `RawTexture3D`, `DynamicTexture`, `HtmlTexture`, `ExternalTexture`, cube textures) | ⚡ | New texture/scatter processors support exact constant-only paths; textured operands need BJS's missing procedural render-target pipeline and throw. Arrays, base-level 3D volumes, dynamic/HTML/external textures, and cube environments work; `RenderTargetTexture` / `MirrorTexture` remain unsupported |
|
|
132
|
+
| Animation (keyframe `Animation`, easing, `Animatable`, `AnimationGroup` incl. weighted/additive blend) | ⚡ | All standard easing classes, including `PowerEase` / `BezierCurveEase`, reuse Lite's native functional curves; `beginAnimation` / `beginDirectAnimation` delegate supported float/vector/quaternion tracks to Lite property animation; unsupported tracks use an explicit compat evaluator; structural groups remain compat-owned; loaded glTF skeletal blending supported; root-motion analysis/controller APIs throw |
|
|
133
|
+
| Morph targets (`MorphTarget` / `MorphTargetManager`) | ✅ | over Lite morph targets, including named loader-produced targets and live influence writes |
|
|
134
|
+
| Sprites (`SpriteManager` / `Sprite`) | ⚡ | camera-facing billboards; `SpriteMap` / packed atlas unsupported |
|
|
135
|
+
| Behaviors / Actions (`AutoRotation`, `Framing`, `ActionManager`, conditions) | ⚡ | `ActionManager` is manual-dispatch; drag / six-DoF / XR-oriented mesh behaviors throw |
|
|
136
|
+
| Misc (`Observable`, `Tools`, `SmartArray`, `Tags`, gradients, `PerformanceMonitor`) | ✅ | |
|
|
137
|
+
| Audio V2 (`AudioEngineV2`, `StaticSound`, `StreamingSound`, `AudioBus`, buses/sources/analyzer) | ⚡ | over Lite's AudioV2 port; `MainAudioBus` spatial/analyzer and a second main bus unsupported |
|
|
138
|
+
| Physics (`HavokPlugin`, `scene.enablePhysics`/`getPhysicsEngine`, `PhysicsAggregate`/`PhysicsBody`/`PhysicsShape`) | ⚡ | Native Havok V2 forwarding for common body/shape operations, thin-instance bodies, and filtered raycasts with instance indices; unrecognized enum values throw at the compat boundary |
|
|
139
|
+
| Particles (`NodeParticleSystemSet` / `ParticleSystemSet` — Node Particle Editor) | ⚡ | NPE snippet/JSON graphs: `Parse`/`ParseFromSnippetAsync` → `buildAsync` → `start`, with stable named systems through both `set.systems` and `scene.particleSystems`, plus `isStarted`; imperative classic/GPU/solid construction and programmatic block authoring remain unsupported |
|
|
140
|
+
| Post-processes, layers (glow/highlight), probes, WebXR | ❌ | Babylon.js wrapper classes are not implemented — use native Lite `create*Task` functions, including `createMeshBlendingPostProcessTask` with geometry-renderer tag/depth/albedo outputs |
|
|
141
141
|
|
|
142
142
|
### `@babylonjs/loaders`
|
|
143
143
|
|
|
144
144
|
| Feature area | Status | Notes |
|
|
145
145
|
| ---------------------------------------------------------------------------------------------- | :----: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
146
|
-
| glTF 2.0 (+ extensions), `.babylon` |
|
|
146
|
+
| glTF 2.0 (+ extensions), `.babylon` | ⚡ | via Lite `loadGltf` / `loadBabylon`; KHR_interactivity assets run through Lite's native flow-graph runtime. `KHR_materials_scatter` resolves but throws because Lite has no scattering prepass/texture-processing subsystem |
|
|
147
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 |
|
package/index.d.ts
CHANGED
|
@@ -1126,7 +1126,8 @@ export declare const BlurPostProcess: new () => never;
|
|
|
1126
1126
|
|
|
1127
1127
|
export declare class Bone {
|
|
1128
1128
|
private _enabled;
|
|
1129
|
-
readonly name: string;
|
|
1130
1129
|
constructor(_name?: string, _skeleton?: Skeleton);
|
|
1131
1130
|
getName(): string;
|
|
1131
|
+
readonly name: string;
|
|
1132
|
+
readonly parent: Bone | null;
|
|
1132
1133
|
constructor(_name?: string, _skeleton?: Skeleton);
|
|
1133
1134
|
getName(): string;
|
|
1134
1135
|
getSkeleton(): Skeleton;
|
|
1135
1136
|
setPosition(position: Vector3, space?: number): this;
|
|
1136
1137
|
setRotationQuaternion(rotation: Quaternion, space?: number): this;
|
|
@@ -1251,6 +1252,12 @@ export declare abstract class Camera extends Node_2 {
|
|
|
1251
1252
|
private _orthoTop;
|
|
1252
1253
|
protected constructor(name: string, scene?: Scene);
|
|
1253
1254
|
getClassName(): string;
|
|
1255
|
+
/**
|
|
1256
|
+
* Babylon.js `Camera.resetViewHistory()` invalidates temporal history owned by
|
|
1257
|
+
* every render pass using this camera. Lite's TAA/history state is owned by
|
|
1258
|
+
* independently-created frame-graph tasks, with no camera-to-task registry.
|
|
1259
|
+
*/
|
|
1260
|
+
resetViewHistory(): never;
|
|
1254
1261
|
get fov(): number;
|
|
1255
1262
|
set fov(value: number);
|
|
1256
1263
|
get minZ(): number;
|
|
@@ -1333,6 +1340,15 @@ declare interface CellSize {
|
|
|
1333
1340
|
height: number;
|
|
1334
1341
|
}
|
|
1335
1342
|
|
|
1343
|
+
export declare enum ChannelMask {
|
|
1344
|
+
R = 1,
|
|
1345
|
+
G = 2,
|
|
1346
|
+
B = 4,
|
|
1347
|
+
A = 8,
|
|
1348
|
+
RGB = 7,
|
|
1349
|
+
RGBA = 15
|
|
1350
|
+
}
|
|
1351
|
+
|
|
1336
1352
|
export declare interface CharacterShapeOptions {
|
|
1337
1353
|
shape?: PhysicsShape;
|
|
1338
1354
|
capsuleHeight?: number;
|
|
@@ -1360,6 +1376,8 @@ export declare class CircleEase extends EasingFunction {
|
|
|
1360
1376
|
easeInCore(gradient: number): number;
|
|
1361
1377
|
}
|
|
1362
1378
|
|
|
1379
|
+
export declare function _ClampGpuSortKeyBits(keyBits: number): number;
|
|
1380
|
+
|
|
1363
1381
|
/**
|
|
1364
1382
|
* Babylon.js `ClusteredLightContainer` — a `Light` that renders a large set of
|
|
1365
1383
|
* point lights through a clustered / forward+ system.
|
|
@@ -1503,6 +1521,18 @@ export declare type ComputeBindingMapping = Record<string, ComputeBindingLocatio
|
|
|
1503
1521
|
|
|
1504
1522
|
declare type ComputeEffect = ComputeShader_2;
|
|
1505
1523
|
|
|
1524
|
+
export declare function _ComputeGpuSortDepthCoefficients(_world: ArrayLike<number>, _view: ArrayLike<number>, _depthSign: number, _cameraPosition: ArrayLike<number> | null, _out: Float32Array, _offset: number, _worldOffset?: number): void;
|
|
1525
|
+
|
|
1526
|
+
export declare function _ComputeGpuSortDepthRange(_coefficients: ArrayLike<number>, _setCount: number, _boundsMin: ArrayLike<number>, _boundsMax: ArrayLike<number>, _result?: {
|
|
1527
|
+
min: number;
|
|
1528
|
+
max: number;
|
|
1529
|
+
}): {
|
|
1530
|
+
min: number;
|
|
1531
|
+
max: number;
|
|
1532
|
+
};
|
|
1533
|
+
|
|
1534
|
+
export declare function _ComputeGpuSortKeyScale(depthMin: number, depthMax: number, keyBits: number): number;
|
|
1535
|
+
|
|
1506
1536
|
/** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
|
|
1507
1537
|
export declare function ComputeOverlayCssTransform(): never;
|
|
1508
1538
|
|
|
@@ -1586,6 +1616,7 @@ export declare const Constants: {
|
|
|
1586
1616
|
readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
|
|
1587
1617
|
readonly TEXTUREFORMAT_RGBA: 5;
|
|
1588
1618
|
readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
|
|
1619
|
+
readonly TEXTURE_CREATIONFLAG_SAMPLED_DATA_ONLY: 2;
|
|
1589
1620
|
readonly BUFFER_CREATIONFLAG_READ: 1;
|
|
1590
1621
|
readonly BUFFER_CREATIONFLAG_WRITE: 2;
|
|
1591
1622
|
readonly BUFFER_CREATIONFLAG_READWRITE: 3;
|
|
@@ -1824,6 +1855,8 @@ declare interface DashedLinesBuilderOptions {
|
|
|
1824
1855
|
|
|
1825
1856
|
export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
|
|
1826
1857
|
|
|
1858
|
+
export declare function _DecodeGpuSortSogMean(value: number): number;
|
|
1859
|
+
|
|
1827
1860
|
declare interface DefaultEnvironmentOptions {
|
|
1828
1861
|
createSkybox?: boolean;
|
|
1829
1862
|
createGround?: boolean;
|
|
@@ -1931,6 +1964,8 @@ export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
|
|
|
1931
1964
|
|
|
1932
1965
|
export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
|
|
1933
1966
|
|
|
1967
|
+
export declare function DivideTexturesAsync(_name: string, a: ITextureProcessOperand, b: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
1968
|
+
|
|
1934
1969
|
/** Babylon.js drag move payload. */
|
|
1935
1970
|
declare type DragEvent_2 = {
|
|
1936
1971
|
delta: Vector3;
|
|
@@ -2469,6 +2504,34 @@ export declare class GaussianSplattingGpuPickingMaterialPlugin extends MaterialP
|
|
|
2469
2504
|
static EncodeIdToColor(id: number): [number, number, number];
|
|
2470
2505
|
constructor(material: GaussianSplattingMaterial, _maxPartCount?: number);
|
|
2471
2506
|
}
|
|
2472
2507
|
|
|
2508
|
+
export declare class GaussianSplattingGpuSorter {
|
|
2509
|
+
static IsSupported(_engine: AbstractEngine): boolean;
|
|
2510
|
+
static GetMaxSupportedSplatCount(_engine: AbstractEngine): number;
|
|
2511
|
+
static LoadDependenciesAsync(): Promise<void>;
|
|
2512
|
+
constructor(_engine: AbstractEngine, _name?: string, _keyBits?: number);
|
|
2513
|
+
get activeCount(): number;
|
|
2514
|
+
get paddedCount(): number;
|
|
2515
|
+
get keyBits(): number;
|
|
2516
|
+
setSource(_source: IGaussianSplattingGpuSortSource): never;
|
|
2517
|
+
setPartMatrices(_matrices: ReadonlyArray<GaussianSplattingGpuSortMatrix> | ArrayLike<number> | null): never;
|
|
2518
|
+
setIntervals(_intervals: ArrayLike<number> | null): never;
|
|
2519
|
+
createOutput(): never;
|
|
2520
|
+
sort(_output: GaussianSplattingGpuSortOutput, _worldMatrix: GaussianSplattingGpuSortMatrix, _viewMatrix: GaussianSplattingGpuSortMatrix, _options?: IGaussianSplattingGpuSortOptions): never;
|
|
2521
|
+
dispose(): void;
|
|
2522
|
+
}
|
|
2523
|
+
|
|
2524
|
+
export declare type GaussianSplattingGpuSortMatrix = Pick<Matrix, "m">;
|
|
2525
|
+
|
|
2526
|
+
export declare class GaussianSplattingGpuSortOutput {
|
|
2527
|
+
constructor(_engine?: AbstractEngine, _label?: string);
|
|
2528
|
+
get buffer(): null;
|
|
2529
|
+
get vertexBuffers(): readonly never[];
|
|
2530
|
+
get paddedCount(): number;
|
|
2531
|
+
get instanceCount(): number;
|
|
2532
|
+
get buffersVersion(): number;
|
|
2533
|
+
dispose(): void;
|
|
2534
|
+
}
|
|
2535
|
+
|
|
2473
2536
|
export declare class GaussianSplattingMaterial extends PushMaterial {
|
|
2474
2537
|
constructor(name: string, scene?: Scene);
|
|
2475
2538
|
clone(_name: string): GaussianSplattingMaterial;
|
|
2476
2539
|
}
|
|
@@ -2479,7 +2542,14 @@ export declare const GaussianSplattingMaxPartCount = 128;
|
|
|
2479
2542
|
* Babylon.js `GaussianSplattingMesh`. Derives from `TransformNode` so the loaded
|
|
2480
2543
|
* cloud's `position` / `rotation` / `scaling` proxy onto the Lite splat node.
|
|
2481
2544
|
*/
|
|
2482
|
-
export declare class GaussianSplattingMesh extends TransformNode {
|
|
2483
2545
|
/**
|
|
2546
|
+
export declare class GaussianSplattingMesh extends TransformNode {
|
|
2547
|
+
private static _useGpuSort;
|
|
2548
|
+
static GpuSortMinFrameInterval: number;
|
|
2549
|
+
static get UseGpuSort(): boolean;
|
|
2550
|
+
static set UseGpuSort(value: boolean);
|
|
2484
2551
|
private _useGpuSort;
|
|
2552
|
+
get useGpuSort(): boolean | null;
|
|
2553
|
+
set useGpuSort(value: boolean | null);
|
|
2554
|
+
/**
|
|
2485
2555
|
* Babylon.js `gs.safeOrbitCameraLimits` — safe-orbit camera limits parsed from the source
|
|
2486
2556
|
* file's metadata (Adobe safe-orbit extension), or `null` when the file carries none.
|
|
2487
2557
|
*
|
|
@@ -2647,8 +2717,14 @@ export declare class GeospatialClippingBehavior {
|
|
|
2647
2717
|
/** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
|
|
2648
2718
|
export declare function GetElementPixelFromUv(): never;
|
|
2649
2719
|
|
|
2720
|
+
export declare function GetGaussianSplattingGpuSorterMaxSplatCount(engine: AbstractEngine): number;
|
|
2721
|
+
|
|
2650
2722
|
export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
|
|
2651
2723
|
|
|
2724
|
+
export declare function _GetGpuSortPaddedCount(activeCount: number): number;
|
|
2725
|
+
|
|
2726
|
+
export declare function _GetGpuSortPassCount(keyBits: number): number;
|
|
2727
|
+
|
|
2652
2728
|
export declare function _GetPackedShBytesPerSplat(shDegree: number): number;
|
|
2653
2729
|
|
|
2654
2730
|
export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
|
|
@@ -2718,6 +2794,8 @@ export declare namespace GLTF1 {
|
|
|
2718
2794
|
export declare namespace GLTF2 {
|
|
2719
2795
|
export {
|
|
2720
2796
|
OpenPBRMaterialLoadingAdapter,
|
|
2797
|
+
KHR_materials_scatter,
|
|
2798
|
+
RegisterKHR_materials_scatter,
|
|
2721
2799
|
ParseDebugLogTemplate,
|
|
2722
2800
|
getMappingForFullOperationName,
|
|
2723
2801
|
getMappingForDeclaration,
|
|
@@ -3319,6 +3397,29 @@ export declare interface IGaussianSplattingDebugOptions {
|
|
|
3319
3397
|
shOrder4: boolean;
|
|
3320
3398
|
}
|
|
3321
3399
|
|
|
3400
|
+
export declare interface IGaussianSplattingGpuSortOptions {
|
|
3401
|
+
rightHanded?: boolean;
|
|
3402
|
+
cameraPosition?: ArrayLike<number>;
|
|
3403
|
+
depthRange?: {
|
|
3404
|
+
min: number;
|
|
3405
|
+
max: number;
|
|
3406
|
+
};
|
|
3407
|
+
}
|
|
3408
|
+
|
|
3409
|
+
export declare interface IGaussianSplattingGpuSortSource {
|
|
3410
|
+
vertexCount: number;
|
|
3411
|
+
textureWidth: number;
|
|
3412
|
+
centersTexture: BaseTexture;
|
|
3413
|
+
sog?: {
|
|
3414
|
+
meansHighTexture: BaseTexture;
|
|
3415
|
+
meansMin: ArrayLike<number>;
|
|
3416
|
+
meansMax: ArrayLike<number>;
|
|
3417
|
+
};
|
|
3418
|
+
partIndicesTexture?: BaseTexture;
|
|
3419
|
+
boundsMin?: ArrayLike<number>;
|
|
3420
|
+
boundsMax?: ArrayLike<number>;
|
|
3421
|
+
}
|
|
3422
|
+
|
|
3322
3423
|
export declare interface IGaussianSplattingStreamingPart {
|
|
3323
3424
|
readonly proxy: GaussianSplattingPartProxyMesh;
|
|
3324
3425
|
readonly partIndex: number;
|
|
@@ -3639,6 +3740,9 @@ export declare interface ISceneLoaderProgressEvent {
|
|
|
3639
3740
|
total: number;
|
|
3640
3741
|
}
|
|
3641
3742
|
|
|
3743
|
+
/** Babylon.js internal polyfill-state query. Compat never installs the unsupported polyfill. */
|
|
3744
|
+
export declare function _IsHtmlInCanvasPolyfillInstalled(): boolean;
|
|
3745
|
+
|
|
3642
3746
|
/** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
|
|
3643
3747
|
export declare function IsHtmlInCanvasSupportedNatively(): never;
|
|
3644
3748
|
|
|
@@ -3784,6 +3888,20 @@ export declare interface IStreamingSoundPlayOptions {
|
|
|
3784
3888
|
volume?: number;
|
|
3785
3889
|
}
|
|
3786
3890
|
|
|
3891
|
+
export declare interface ITextureProcessOperand {
|
|
3892
|
+
texture: BaseTexture | null;
|
|
3893
|
+
factor?: Color4;
|
|
3894
|
+
channel?: TextureChannel;
|
|
3895
|
+
colorSpace?: TextureColorSpace;
|
|
3896
|
+
dispose?: () => void;
|
|
3897
|
+
}
|
|
3898
|
+
|
|
3899
|
+
export declare interface ITextureProcessorOutputOptions {
|
|
3900
|
+
textureType?: number;
|
|
3901
|
+
samplingMode?: number;
|
|
3902
|
+
generateMipMaps?: boolean;
|
|
3903
|
+
}
|
|
3904
|
+
|
|
3787
3905
|
export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
|
|
3788
3906
|
[key: string]: unknown;
|
|
3789
3907
|
}
|
|
@@ -3834,6 +3952,19 @@ export declare interface IWheelEvent extends IMouseEvent {
|
|
|
3834
3952
|
wheelDelta?: number;
|
|
3835
3953
|
}
|
|
3836
3954
|
|
|
3955
|
+
export declare class KHR_materials_scatter {
|
|
3956
|
+
readonly name = "KHR_materials_scatter";
|
|
3957
|
+
enabled: boolean;
|
|
3958
|
+
order: number;
|
|
3959
|
+
constructor(loader?: {
|
|
3960
|
+
isExtensionUsed?(name: string): boolean;
|
|
3961
|
+
});
|
|
3962
|
+
dispose(): void;
|
|
3963
|
+
loadMaterialPropertiesAsync(_context: string, material: {
|
|
3964
|
+
extensions?: Record<string, unknown>;
|
|
3965
|
+
}, _babylonMaterial: unknown): Promise<void> | null;
|
|
3966
|
+
}
|
|
3967
|
+
|
|
3837
3968
|
/**
|
|
3838
3969
|
* Babylon.js `KHR_materials_variants` extension helpers. Mirrors the static
|
|
3839
3970
|
* surface ported code calls (`SelectVariant` / `GetAvailableVariants` / `Reset`)
|
|
@@ -4183,6 +4314,8 @@ export { MaxTintMagnitude }
|
|
|
4183
4314
|
export declare class Mesh extends AbstractMesh {
|
|
4184
4315
|
constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
|
|
4185
4316
|
getClassName(): string;
|
|
4186
4317
|
private _morphTargetManager;
|
|
4318
|
+
private readonly _ownedMorphTargetManagers;
|
|
4319
|
+
private _retainMorphTargetManagerOwnership;
|
|
4187
4320
|
/**
|
|
4188
4321
|
* Babylon.js `mesh.morphTargetManager`. Babylon Lite builds morph GPU data via
|
|
4189
4322
|
* `createMorphTargets` and stores it on the Lite mesh; the compat manager is
|
|
@@ -4190,8 +4323,7 @@ export declare class Mesh extends AbstractMesh {
|
|
|
4190
4323
|
* CPU geometry exists) and assigns it onto the Lite mesh before registration.
|
|
4191
4324
|
*/
|
|
4192
4325
|
get morphTargetManager(): MorphTargetManager | null;
|
|
4193
|
-
set morphTargetManager(value: MorphTargetManager | null);
|
|
4194
|
-
/** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
|
|
4326
|
+
set morphTargetManager(value: MorphTargetManager | null);
|
|
4195
4327
|
/** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
|
|
4196
4328
|
static CreateSphere(name: string, segments: number, diameter: number, scene: Scene): Mesh;
|
|
4197
4329
|
/** Legacy `Mesh.CreateBox(name, size, scene)`. */
|
|
4198
4330
|
static CreateBox(name: string, size: number, scene: Scene): Mesh;
|
|
@@ -4382,16 +4514,16 @@ export declare class MorphTarget {
|
|
|
4382
4514
|
/** Babylon.js `MorphTarget.setNormals(data)` — absolute target normals. */
|
|
4383
4515
|
setNormals(data: Float32Array | number[] | null): void;
|
|
4384
4516
|
/** Babylon.js `MorphTarget.getNormals()`. */
|
|
4385
|
-
getNormals(): Float32Array | null;
|
|
4386
|
-
}
|
|
4517
|
+
getNormals(): Float32Array | null;
|
|
4387
4518
|
|
|
4388
4519
|
/** Babylon.js `MorphTargetManager` — owns a mesh's morph targets (Babylon Lite supports up to 4). */
|
|
4389
4520
|
export declare class MorphTargetManager {
|
|
4390
4521
|
private readonly _targets;
|
|
4391
|
-
constructor(_scene?: Scene);
|
|
4392
|
-
get numTargets(): number;
|
|
4522
|
+
constructor(_scene?: Scene);
|
|
4393
4523
|
get numTargets(): number;
|
|
4394
4524
|
getTarget(index: number): MorphTarget;
|
|
4395
4525
|
/** Babylon.js `MorphTargetManager.addTarget(target)`. */
|
|
4396
|
-
addTarget(target: MorphTarget): void;
|
|
4526
|
+
addTarget(target: MorphTarget): void;
|
|
4397
4527
|
/** Babylon.js `MorphTargetManager.dispose()` — release this manager's morph-resource claim. */
|
|
4528
|
+
dispose(): void;
|
|
4529
|
+
}
|
|
4398
4530
|
|
|
4399
4531
|
export declare class MultiMaterial {
|
|
4400
4532
|
constructor();
|
|
@@ -4401,6 +4533,8 @@ export declare class MultiPointerScaleBehavior {
|
|
|
4401
4533
|
constructor();
|
|
4402
4534
|
}
|
|
4403
4535
|
|
|
4536
|
+
export declare function MultiScatterToSingleScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, scale?: ITextureProcessOperand): Promise<ITextureProcessOperand>;
|
|
4537
|
+
|
|
4404
4538
|
declare abstract class Node_2 {
|
|
4405
4539
|
name: string;
|
|
4406
4540
|
/** String id. Defaults to the name (Babylon.js parity). */
|
|
@@ -4616,6 +4750,12 @@ export declare class OutlineRenderer {
|
|
|
4616
4750
|
constructor();
|
|
4617
4751
|
}
|
|
4618
4752
|
|
|
4753
|
+
export declare function _PackGpuSortIntervals(intervals: ArrayLike<number>, vertexCount: number): {
|
|
4754
|
+
data: Uint32Array;
|
|
4755
|
+
count: number;
|
|
4756
|
+
total: number;
|
|
4757
|
+
};
|
|
4758
|
+
|
|
4619
4759
|
export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
|
|
4620
4760
|
|
|
4621
4761
|
export declare class ParticleHelper {
|
|
@@ -4640,6 +4780,7 @@ export declare class ParticleSystem {
|
|
|
4640
4780
|
private _texture;
|
|
4641
4781
|
private _billboardScheduled;
|
|
4642
4782
|
private _billboardOwnedBySet;
|
|
4783
|
+
private _started;
|
|
4643
4784
|
/**
|
|
4644
4785
|
* Babylon.js `new ParticleSystem(name, capacity, scene)`. The imperative
|
|
4645
4786
|
* construction API (emitters, over-lifetime gradients, `minEmitBox`, a
|
|
@@ -4677,6 +4818,8 @@ export declare class ParticleSystem {
|
|
|
4677
4818
|
animate(preWarmOnly?: boolean): void;
|
|
4678
4819
|
/** Babylon.js `ParticleSystem.stop()` — stop emission; live particles drain. Forwards to Lite `stopParticleSystem`. */
|
|
4679
4820
|
stop(): void;
|
|
4821
|
+
/** Babylon.js `ParticleSystem.isStarted()` — whether the system is currently emitting. */
|
|
4822
|
+
isStarted(): boolean;
|
|
4680
4823
|
/** Babylon.js `ParticleSystem.dispose()` — stop the system. */
|
|
4681
4824
|
dispose(): void;
|
|
4682
4825
|
/**
|
|
4683
4826
|
* Schedule the one-time billboard build. Deferred to engine start (via the
|
|
@@ -5718,6 +5861,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
|
|
|
5718
5861
|
/** Babylon.js pure-module registration hook. */
|
|
5719
5862
|
export declare function RegisterImageProcessingConfiguration(): void;
|
|
5720
5863
|
|
|
5864
|
+
export declare function RegisterKHR_materials_scatter(): void;
|
|
5865
|
+
|
|
5721
5866
|
export declare function RegisterMeshBlendingPostProcessBlock(): never;
|
|
5722
5867
|
|
|
5723
5868
|
/** Babylon.js 9.29 node-render-graph registration function. */
|
|
@@ -5874,6 +6019,10 @@ export declare class Scene extends AbstractScene {
|
|
|
5874
6019
|
/** Babylon.js fog-mode c
|
|
5875
6020
|
/** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
|
|
5876
6021
|
getAnimationGroupByName(name: string): AnimationGroup | null;
|
|
5877
6022
|
get animatables(): Animatable_2[];
|
|
6023
|
+
/** Babylon.js `scene.skeletons` — loader-produced skeletons currently used by scene meshes. */
|
|
6024
|
+
get skeletons(): Skeleton[];
|
|
6025
|
+
/** Babylon.js `scene.particleSystems` — registered Lite node-particle systems in scene order. */
|
|
6026
|
+
get particleSystems(): ParticleSystem[];
|
|
5878
6027
|
private readonly _engine;
|
|
5879
6028
|
private _activeCamera;
|
|
5880
6029
|
cameraToUseForPointers: Camera | null;
|
|
@@ -5895,9 +6044,16 @@ export declare class Scene extends AbstractScene {
|
|
|
5895
6044
|
/** Babylon.js fog-mode c
|
|
5896
6045
|
private readonly _pendingTextures;
|
|
5897
6046
|
private readonly _pendingGroundBakes;
|
|
5898
6047
|
private readonly _pendingMorphBuilds;
|
|
6048
|
+
private readonly _ownedMorphTargetManagers;
|
|
5899
6049
|
private _materialPluginsRequested;
|
|
5900
6050
|
private readonly _pendingMaterialPluginReconciliations;
|
|
5901
|
-
private readonly _runningAnimatables;
|
|
5902
6051
|
private readonly _animationGroupCache;
|
|
5903
6052
|
private _ambientColor;
|
|
6053
|
+
private readonly _runningAnimatables;
|
|
5904
6054
|
private readonly _animationGroupCache;
|
|
6055
|
+
private readonly _skeletonCache;
|
|
6056
|
+
private readonly _skeletons;
|
|
6057
|
+
private readonly _particleSystemCache;
|
|
6058
|
+
private readonly _particleSystems;
|
|
6059
|
+
private readonly _retiredParticleSystems;
|
|
6060
|
+
private _disposed;
|
|
5905
6061
|
private _ambientColor;
|
|
5906
6062
|
private _environmentIntensity;
|
|
5907
6063
|
private _imageProcessingConfiguration;
|
|
5908
6064
|
/** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
|
|
5909
6065
|
readonly uniqueId: number;
|
|
@@ -6208,6 +6364,8 @@ export declare class SineEase extends EasingFunction {
|
|
|
6208
6364
|
easeInCore(gradient: number): number;
|
|
6209
6365
|
}
|
|
6210
6366
|
|
|
6367
|
+
export declare function SingleScatterToMultiScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
6368
|
+
|
|
6211
6369
|
export declare class SixDofDragBehavior {
|
|
6212
6370
|
constructor();
|
|
6213
6371
|
}
|
|
@@ -6229,6 +6387,10 @@ export declare class Skeleton {
|
|
|
6229
6387
|
readonly id: string;
|
|
6230
6388
|
readonly bones: Bone[];
|
|
6231
6389
|
constructor(_name?: string, _id?: string, _scene?: Scene);
|
|
6232
6390
|
getBoneIndexByName(name: string): number;
|
|
6233
6391
|
getBoneByName(name: string): Bone | null;
|
|
6392
|
+
/** Babylon.js `Skeleton.returnToRest()` — clear every compat bone override. */
|
|
6393
|
+
returnToRest(): void;
|
|
6394
|
+
/** Babylon.js `Skeleton.prepare()` — Lite keeps loaded/evaluated bone matrices ready, so no additional bake is needed. */
|
|
6395
|
+
prepare(_dontCheckFrameId?: boolean): void;
|
|
6234
6396
|
}
|
|
6235
6397
|
|
|
6236
6398
|
export declare class SliderConstraint extends PhysicsConstraint {
|
|
@@ -6863,6 +7025,19 @@ export declare class Texture extends BaseTexture {
|
|
|
6863
7025
|
static LoadAsync(url: string, scene: Scene): Promise<Texture>;
|
|
6864
7026
|
}
|
|
6865
7027
|
|
|
7028
|
+
export declare enum TextureChannel {
|
|
7029
|
+
RGBA = 0,
|
|
7030
|
+
R = 1,
|
|
7031
|
+
G = 2,
|
|
7032
|
+
B = 3,
|
|
7033
|
+
A = 4
|
|
7034
|
+
}
|
|
7035
|
+
|
|
7036
|
+
export declare enum TextureColorSpace {
|
|
7037
|
+
Linear = 0,
|
|
7038
|
+
SRGB = 1
|
|
7039
|
+
}
|
|
7040
|
+
|
|
6866
7041
|
declare interface TextureLike {
|
|
6867
7042
|
_lite?: Texture2D;
|
|
6868
7043
|
whenReadyAsync?(): Promise<void>;
|
|
@@ -6928,6 +7103,11 @@ declare interface ThinSpriteLike {
|
|
|
6928
7103
|
isVisible: boolean;
|
|
6929
7104
|
}
|
|
6930
7105
|
|
|
7106
|
+
export declare function ThinWalledScatterWeightsAsync(_name: string, transmission: ITextureProcessOperand, scatter: ITextureProcessOperand, _scene: Scene): Promise<{
|
|
7107
|
+
transmission: ITextureProcessOperand;
|
|
7108
|
+
subsurface: ITextureProcessOperand;
|
|
7109
|
+
}>;
|
|
7110
|
+
|
|
6931
7111
|
export declare const ToDegrees: number;
|
|
6932
7112
|
|
|
6933
7113
|
/** Babylon.js-compatible `Tools` helpers (the small, pure subset). */
|
|
@@ -6961,22 +7141,29 @@ export declare function transformCoordinates(vector: Vector3, transformation: Ma
|
|
|
6961
7141
|
* Wraps a Lite scene node (`_node`): either a standalone Lite transform node, or
|
|
6962
7142
|
* (for meshes) the Lite mesh itself, which also carries the transform.
|
|
6963
7143
|
*/
|
|
6964
|
-
export declare class TransformNode extends Node_2 {
|
|
6965
7144
|
physicsBody: PhysicsBody | null;
|
|
6966
7145
|
constructor(name: string, scene?: Scene, liteNode?: SceneNode);
|
|
7146
|
+
export declare class TransformNode extends Node_2 {
|
|
6967
7147
|
physicsBody: PhysicsBody | null;
|
|
7148
|
+
private _rotation;
|
|
7149
|
+
private _rotationBinding;
|
|
7150
|
+
private _rotationQuaternion;
|
|
7151
|
+
private _rotationQuaternionBinding?;
|
|
7152
|
+
private _nativeRotationVersion;
|
|
7153
|
+
private readonly _nativeRotationValues;
|
|
7154
|
+
private _isSyncingRotationFromNative;
|
|
7155
|
+
private _sceneDisposeObserver?;
|
|
6968
7156
|
constructor(name: string, scene?: Scene, liteNode?: SceneNode);
|
|
6969
7157
|
getClassName(): string;
|
|
6970
7158
|
get position(): Vector3;
|
|
6971
7159
|
set position(value: Vector3);
|
|
6972
7160
|
get rotation(): Vector3;
|
|
6973
7161
|
set rotation(value: Vector3);
|
|
6974
7162
|
get scaling(): Vector3;
|
|
6975
|
-
set scaling(value: Vector3);
|
|
6976
7163
|
/**
|
|
6977
|
-
|
|
6978
|
-
|
|
6979
|
-
* quaternion), so this reads/writes that quaternion. Returns `null` until
|
|
6980
|
-
* explicitly assigned, matching Babylon.js's euler-by-default convention.
|
|
6981
|
-
*/
|
|
7164
|
+
set scaling(value: Vector3);
|
|
7165
|
+
/** Babylon.js `rotationQuaternion`, kept live while Lite receives translated component writes. */
|
|
6982
7166
|
get rotationQuaternion(): Quaternion | null;
|
|
6983
7167
|
set rotationQuaternion(value: Quaternion | null);
|
|
6984
|
-
|
|
7168
|
+
private _applyEulerRotation;
|
|
7169
|
+
private _applyQuaternionRotation;
|
|
7170
|
+
private _markNativeRotationSynced;
|
|
7171
|
+
private _syncRotationFromNative;
|
|
6985
7172
|
/**
|
|
6986
7173
|
* Babylon.js `getChildTransformNodes(directDescendantsOnly?, predicate?)` — the descendants that are transform nodes
|
|
6987
7174
|
* (meshes included). As in Babylon.js, `predicate` is called on every evaluated descendant.
|
|
6988
7175
|
*/
|
|
@@ -6987,10 +7174,16 @@ export declare class TransformNode extends Node_2 {
|
|
|
6987
7174
|
physicsBody: PhysicsBody
|
|
6988
7175
|
* setter, which keeps the local transform and lets the world move.
|
|
6989
7176
|
*/
|
|
6990
7177
|
setParent(parent: Node_2 | null): TransformNode;
|
|
6991
|
-
protected _applyParent(parent: Node_2 | null): void;
|
|
7178
|
+
protected _applyParent(parent: Node_2 | null): void;
|
|
6992
7179
|
private _bindRotationSceneDisposal;
|
|
7180
|
+
protected _retireFromScene(): void;
|
|
7181
|
+
}
|
|
6993
7182
|
|
|
6994
7183
|
export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
|
|
6995
7184
|
|
|
7185
|
+
export declare function TransmissionFractionAsync(_name: string, a: ITextureProcessOperand, b: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
7186
|
+
|
|
7187
|
+
export declare function TransmissionScatterToSingleScatterAlbedoAsync(_name: string, transmissionColor: ITextureProcessOperand, transmissionScatter: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
|
|
7188
|
+
|
|
6996
7189
|
export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
|
|
6997
7190
|
|
|
6998
7191
|
/** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */
|