@babylonjs/lite-compat 1.38.1-preview → 1.39.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/index.d.ts CHANGED
@@ -257,12 +257,19 @@ export declare interface AbstractEngineOptions extends EngineOptions_2 {
257
257
  * visibility, and shadow-receipt. Concrete meshes derive from this.
258
258
  */
259
259
  export declare class AbstractMesh extends TransformNode {
260
260
  private _material;
261
261
  private _meshBlendingTag;
262
+ protected _visibilityValue: number;
262
263
  protected _visible: boolean;
263
264
  constructor(name: string, lite: Mesh_2, scene?: Scene);
264
265
  getClassName(): string;
265
266
  get material(): CompatMaterial | null;
266
267
  set material(value: CompatMaterial | null);
267
268
  get isVisible(): boolean;
268
269
  set isVisible(value: boolean);
270
+ /** Raw finite Babylon visibility; rendering clamps it to [0, 1]. Independent of isVisible. */
271
+ get visibility(): number;
272
+ set visibility(value: number);
273
+ private _validateCompatOpacityMaterial;
274
+ /** A glTF node owns its immediate primitive meshes, never a child glTF node's primitives. */
275
+ private _opacityTargets;
269
276
  get isPickable(): boolean;
270
277
  set isPickable(value: boolean);
271
278
  get receiveShadows(): boolean;
@@ -1119,7 +1126,8 @@ export declare const BlurPostProcess: new () => never;
1119
1126
 
1120
1127
  export declare class Bone {
1121
1128
  private _enabled;
1122
- readonly name: string;
1123
1129
  constructor(_name?: string, _skeleton?: Skeleton);
1124
1130
  getName(): string;
1131
+ readonly name: string;
1132
+ readonly parent: Bone | null;
1125
1133
  constructor(_name?: string, _skeleton?: Skeleton);
1126
1134
  getName(): string;
1127
1135
  getSkeleton(): Skeleton;
1128
1136
  setPosition(position: Vector3, space?: number): this;
1129
1137
  setRotationQuaternion(rotation: Quaternion, space?: number): this;
@@ -1244,6 +1252,12 @@ export declare abstract class Camera extends Node_2 {
1244
1252
  private _orthoTop;
1245
1253
  protected constructor(name: string, scene?: Scene);
1246
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;
1247
1261
  get fov(): number;
1248
1262
  set fov(value: number);
1249
1263
  get minZ(): number;
@@ -1326,6 +1340,15 @@ declare interface CellSize {
1326
1340
  height: number;
1327
1341
  }
1328
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
+
1329
1352
  export declare interface CharacterShapeOptions {
1330
1353
  shape?: PhysicsShape;
1331
1354
  capsuleHeight?: number;
@@ -1353,6 +1376,8 @@ export declare class CircleEase extends EasingFunction {
1353
1376
  easeInCore(gradient: number): number;
1354
1377
  }
1355
1378
 
1379
+ export declare function _ClampGpuSortKeyBits(keyBits: number): number;
1380
+
1356
1381
  /**
1357
1382
  * Babylon.js `ClusteredLightContainer` — a `Light` that renders a large set of
1358
1383
  * point lights through a clustered / forward+ system.
@@ -1496,6 +1521,18 @@ export declare type ComputeBindingMapping = Record<string, ComputeBindingLocatio
1496
1521
 
1497
1522
  declare type ComputeEffect = ComputeShader_2;
1498
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
+
1499
1536
  /** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
1500
1537
  export declare function ComputeOverlayCssTransform(): never;
1501
1538
 
@@ -1579,6 +1616,7 @@ export declare const Constants: {
1579
1616
  readonly TEXTURE_TRILINEAR_SAMPLINGMODE: 3;
1580
1617
  readonly TEXTUREFORMAT_RGBA: 5;
1581
1618
  readonly TEXTURETYPE_UNSIGNED_BYTE: 0;
1619
+ readonly TEXTURE_CREATIONFLAG_SAMPLED_DATA_ONLY: 2;
1582
1620
  readonly BUFFER_CREATIONFLAG_READ: 1;
1583
1621
  readonly BUFFER_CREATIONFLAG_WRITE: 2;
1584
1622
  readonly BUFFER_CREATIONFLAG_READWRITE: 3;
@@ -1817,6 +1855,8 @@ declare interface DashedLinesBuilderOptions {
1817
1855
 
1818
1856
  export declare type DataArray = number[] | ArrayBufferLike | ArrayBufferView;
1819
1857
 
1858
+ export declare function _DecodeGpuSortSogMean(value: number): number;
1859
+
1820
1860
  declare interface DefaultEnvironmentOptions {
1821
1861
  createSkybox?: boolean;
1822
1862
  createGround?: boolean;
@@ -1924,6 +1964,8 @@ export declare type DitheredTileFadeMesh = Mesh | InstancedMesh;
1924
1964
 
1925
1965
  export declare type DitheredTileFadeSupportedMaterial = StandardMaterial | PBRMaterial;
1926
1966
 
1967
+ export declare function DivideTexturesAsync(_name: string, a: ITextureProcessOperand, b: ITextureProcessOperand, _scene: Scene, _outputColorSpace?: TextureColorSpace, outputChannelMask?: ChannelMask, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
1968
+
1927
1969
  /** Babylon.js drag move payload. */
1928
1970
  declare type DragEvent_2 = {
1929
1971
  delta: Vector3;
@@ -2462,6 +2504,34 @@ export declare class GaussianSplattingGpuPickingMaterialPlugin extends MaterialP
2462
2504
  static EncodeIdToColor(id: number): [number, number, number];
2463
2505
  constructor(material: GaussianSplattingMaterial, _maxPartCount?: number);
2464
2506
  }
2465
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
+
2466
2536
  export declare class GaussianSplattingMaterial extends PushMaterial {
2467
2537
  constructor(name: string, scene?: Scene);
2468
2538
  clone(_name: string): GaussianSplattingMaterial;
2469
2539
  }
@@ -2472,7 +2542,14 @@ export declare const GaussianSplattingMaxPartCount = 128;
2472
2542
  * Babylon.js `GaussianSplattingMesh`. Derives from `TransformNode` so the loaded
2473
2543
  * cloud's `position` / `rotation` / `scaling` proxy onto the Lite splat node.
2474
2544
  */
2475
- export declare class GaussianSplattingMesh extends TransformNode {
2476
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);
2477
2551
  private _useGpuSort;
2552
+ get useGpuSort(): boolean | null;
2553
+ set useGpuSort(value: boolean | null);
2554
+ /**
2478
2555
  * Babylon.js `gs.safeOrbitCameraLimits` — safe-orbit camera limits parsed from the source
2479
2556
  * file's metadata (Adobe safe-orbit extension), or `null` when the file carries none.
2480
2557
  *
@@ -2640,8 +2717,14 @@ export declare class GeospatialClippingBehavior {
2640
2717
  /** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
2641
2718
  export declare function GetElementPixelFromUv(): never;
2642
2719
 
2720
+ export declare function GetGaussianSplattingGpuSorterMaxSplatCount(engine: AbstractEngine): number;
2721
+
2643
2722
  export declare function GetGaussianSplattingMaxPartCount(engine: AbstractEngine): number;
2644
2723
 
2724
+ export declare function _GetGpuSortPaddedCount(activeCount: number): number;
2725
+
2726
+ export declare function _GetGpuSortPassCount(keyBits: number): number;
2727
+
2645
2728
  export declare function _GetPackedShBytesPerSplat(shDegree: number): number;
2646
2729
 
2647
2730
  export declare function GetPartIndexVaryingDeclaration(shaderLanguage: ShaderLanguage): string;
@@ -2711,6 +2794,8 @@ export declare namespace GLTF1 {
2711
2794
  export declare namespace GLTF2 {
2712
2795
  export {
2713
2796
  OpenPBRMaterialLoadingAdapter,
2797
+ KHR_materials_scatter,
2798
+ RegisterKHR_materials_scatter,
2714
2799
  ParseDebugLogTemplate,
2715
2800
  getMappingForFullOperationName,
2716
2801
  getMappingForDeclaration,
@@ -3312,6 +3397,29 @@ export declare interface IGaussianSplattingDebugOptions {
3312
3397
  shOrder4: boolean;
3313
3398
  }
3314
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
+
3315
3423
  export declare interface IGaussianSplattingStreamingPart {
3316
3424
  readonly proxy: GaussianSplattingPartProxyMesh;
3317
3425
  readonly partIndex: number;
@@ -3632,6 +3740,9 @@ export declare interface ISceneLoaderProgressEvent {
3632
3740
  total: number;
3633
3741
  }
3634
3742
 
3743
+ /** Babylon.js internal polyfill-state query. Compat never installs the unsupported polyfill. */
3744
+ export declare function _IsHtmlInCanvasPolyfillInstalled(): boolean;
3745
+
3635
3746
  /** Babylon.js `IsHtmlInCanvasSupportedNatively` — the HTML-in-canvas feature is unsupported by the compat layer. */
3636
3747
  export declare function IsHtmlInCanvasSupportedNatively(): never;
3637
3748
 
@@ -3777,6 +3888,20 @@ export declare interface IStreamingSoundPlayOptions {
3777
3888
  volume?: number;
3778
3889
  }
3779
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
+
3780
3905
  export declare interface IThinMeshBlendingPostProcessOptions extends IMeshBlendConfiguration {
3781
3906
  [key: string]: unknown;
3782
3907
  }
@@ -3827,6 +3952,19 @@ export declare interface IWheelEvent extends IMouseEvent {
3827
3952
  wheelDelta?: number;
3828
3953
  }
3829
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
+
3830
3968
  /**
3831
3969
  * Babylon.js `KHR_materials_variants` extension helpers. Mirrors the static
3832
3970
  * surface ported code calls (`SelectVariant` / `GetAvailableVariants` / `Reset`)
@@ -4176,6 +4314,8 @@ export { MaxTintMagnitude }
4176
4314
  export declare class Mesh extends AbstractMesh {
4177
4315
  constructor(name: string, sceneOrLite?: Scene | Mesh_2, scene?: Scene);
4178
4316
  getClassName(): string;
4179
4317
  private _morphTargetManager;
4318
+ private readonly _ownedMorphTargetManagers;
4319
+ private _retainMorphTargetManagerOwnership;
4180
4320
  /**
4181
4321
  * Babylon.js `mesh.morphTargetManager`. Babylon Lite builds morph GPU data via
4182
4322
  * `createMorphTargets` and stores it on the Lite mesh; the compat manager is
@@ -4183,8 +4323,7 @@ export declare class Mesh extends AbstractMesh {
4183
4323
  * CPU geometry exists) and assigns it onto the Lite mesh before registration.
4184
4324
  */
4185
4325
  get morphTargetManager(): MorphTargetManager | null;
4186
- set morphTargetManager(value: MorphTargetManager | null);
4187
- /** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
4326
+ set morphTargetManager(value: MorphTargetManager | null);
4188
4327
  /** Legacy `Mesh.CreateSphere(name, segments, diameter, scene)`. */
4189
4328
  static CreateSphere(name: string, segments: number, diameter: number, scene: Scene): Mesh;
4190
4329
  /** Legacy `Mesh.CreateBox(name, size, scene)`. */
4191
4330
  static CreateBox(name: string, size: number, scene: Scene): Mesh;
@@ -4375,16 +4514,16 @@ export declare class MorphTarget {
4375
4514
  /** Babylon.js `MorphTarget.setNormals(data)` — absolute target normals. */
4376
4515
  setNormals(data: Float32Array | number[] | null): void;
4377
4516
  /** Babylon.js `MorphTarget.getNormals()`. */
4378
- getNormals(): Float32Array | null;
4379
- }
4517
+ getNormals(): Float32Array | null;
4380
4518
 
4381
4519
  /** Babylon.js `MorphTargetManager` — owns a mesh's morph targets (Babylon Lite supports up to 4). */
4382
4520
  export declare class MorphTargetManager {
4383
4521
  private readonly _targets;
4384
- constructor(_scene?: Scene);
4385
- get numTargets(): number;
4522
+ constructor(_scene?: Scene);
4386
4523
  get numTargets(): number;
4387
4524
  getTarget(index: number): MorphTarget;
4388
4525
  /** Babylon.js `MorphTargetManager.addTarget(target)`. */
4389
- addTarget(target: MorphTarget): void;
4526
+ addTarget(target: MorphTarget): void;
4390
4527
  /** Babylon.js `MorphTargetManager.dispose()` — release this manager's morph-resource claim. */
4528
+ dispose(): void;
4529
+ }
4391
4530
 
4392
4531
  export declare class MultiMaterial {
4393
4532
  constructor();
@@ -4394,6 +4533,8 @@ export declare class MultiPointerScaleBehavior {
4394
4533
  constructor();
4395
4534
  }
4396
4535
 
4536
+ export declare function MultiScatterToSingleScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, scale?: ITextureProcessOperand): Promise<ITextureProcessOperand>;
4537
+
4397
4538
  declare abstract class Node_2 {
4398
4539
  name: string;
4399
4540
  /** String id. Defaults to the name (Babylon.js parity). */
@@ -4609,6 +4750,12 @@ export declare class OutlineRenderer {
4609
4750
  constructor();
4610
4751
  }
4611
4752
 
4753
+ export declare function _PackGpuSortIntervals(intervals: ArrayLike<number>, vertexCount: number): {
4754
+ data: Uint32Array;
4755
+ count: number;
4756
+ total: number;
4757
+ };
4758
+
4612
4759
  export declare function PackMeshBlendingTag(groupId: number, radiusClass: MeshBlendingRadiusClass): number;
4613
4760
 
4614
4761
  export declare class ParticleHelper {
@@ -4633,6 +4780,7 @@ export declare class ParticleSystem {
4633
4780
  private _texture;
4634
4781
  private _billboardScheduled;
4635
4782
  private _billboardOwnedBySet;
4783
+ private _started;
4636
4784
  /**
4637
4785
  * Babylon.js `new ParticleSystem(name, capacity, scene)`. The imperative
4638
4786
  * construction API (emitters, over-lifetime gradients, `minEmitBox`, a
@@ -4670,6 +4818,8 @@ export declare class ParticleSystem {
4670
4818
  animate(preWarmOnly?: boolean): void;
4671
4819
  /** Babylon.js `ParticleSystem.stop()` — stop emission; live particles drain. Forwards to Lite `stopParticleSystem`. */
4672
4820
  stop(): void;
4821
+ /** Babylon.js `ParticleSystem.isStarted()` — whether the system is currently emitting. */
4822
+ isStarted(): boolean;
4673
4823
  /** Babylon.js `ParticleSystem.dispose()` — stop the system. */
4674
4824
  dispose(): void;
4675
4825
  /**
4676
4826
  * Schedule the one-time billboard build. Deferred to engine start (via the
@@ -5711,6 +5861,8 @@ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]):
5711
5861
  /** Babylon.js pure-module registration hook. */
5712
5862
  export declare function RegisterImageProcessingConfiguration(): void;
5713
5863
 
5864
+ export declare function RegisterKHR_materials_scatter(): void;
5865
+
5714
5866
  export declare function RegisterMeshBlendingPostProcessBlock(): never;
5715
5867
 
5716
5868
  /** Babylon.js 9.29 node-render-graph registration function. */
@@ -5867,6 +6019,10 @@ export declare class Scene extends AbstractScene {
5867
6019
  /** Babylon.js fog-mode c
5868
6020
  /** Babylon.js `scene.getAnimationGroupByName(name)` — first loaded animation group with a matching name, else `null`. */
5869
6021
  getAnimationGroupByName(name: string): AnimationGroup | null;
5870
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[];
5871
6027
  private readonly _engine;
5872
6028
  private _activeCamera;
5873
6029
  cameraToUseForPointers: Camera | null;
@@ -5888,9 +6044,16 @@ export declare class Scene extends AbstractScene {
5888
6044
  /** Babylon.js fog-mode c
5889
6045
  private readonly _pendingTextures;
5890
6046
  private readonly _pendingGroundBakes;
5891
6047
  private readonly _pendingMorphBuilds;
6048
+ private readonly _ownedMorphTargetManagers;
5892
6049
  private _materialPluginsRequested;
5893
6050
  private readonly _pendingMaterialPluginReconciliations;
5894
- private readonly _runningAnimatables;
5895
6051
  private readonly _animationGroupCache;
5896
6052
  private _ambientColor;
6053
+ private readonly _runningAnimatables;
5897
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;
5898
6061
  private _ambientColor;
5899
6062
  private _environmentIntensity;
5900
6063
  private _imageProcessingConfiguration;
5901
6064
  /** Babylon.js `scene.uniqueId` — a process-unique numeric id. */
5902
6065
  readonly uniqueId: number;
@@ -6201,6 +6364,8 @@ export declare class SineEase extends EasingFunction {
6201
6364
  easeInCore(gradient: number): number;
6202
6365
  }
6203
6366
 
6367
+ export declare function SingleScatterToMultiScatterAlbedoAsync(_name: string, input: ITextureProcessOperand, _scene: Scene, aniso?: number, _outputOptions?: ITextureProcessorOutputOptions): Promise<ITextureProcessOperand>;
6368
+
6204
6369
  export declare class SixDofDragBehavior {
6205
6370
  constructor();
6206
6371
  }
@@ -6222,6 +6387,10 @@ export declare class Skeleton {
6222
6387
  readonly id: string;
6223
6388
  readonly bones: Bone[];
6224
6389
  constructor(_name?: string, _id?: string, _scene?: Scene);
6225
6390
  getBoneIndexByName(name: string): number;
6226
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;
6227
6396
  }
6228
6397
 
6229
6398
  export declare class SliderConstraint extends PhysicsConstraint {
@@ -6856,6 +7025,19 @@ export declare class Texture extends BaseTexture {
6856
7025
  static LoadAsync(url: string, scene: Scene): Promise<Texture>;
6857
7026
  }
6858
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
+
6859
7041
  declare interface TextureLike {
6860
7042
  _lite?: Texture2D;
6861
7043
  whenReadyAsync?(): Promise<void>;
@@ -6921,6 +7103,11 @@ declare interface ThinSpriteLike {
6921
7103
  isVisible: boolean;
6922
7104
  }
6923
7105
 
7106
+ export declare function ThinWalledScatterWeightsAsync(_name: string, transmission: ITextureProcessOperand, scatter: ITextureProcessOperand, _scene: Scene): Promise<{
7107
+ transmission: ITextureProcessOperand;
7108
+ subsurface: ITextureProcessOperand;
7109
+ }>;
7110
+
6924
7111
  export declare const ToDegrees: number;
6925
7112
 
6926
7113
  /** Babylon.js-compatible `Tools` helpers (the small, pure subset). */
@@ -6954,22 +7141,29 @@ export declare function transformCoordinates(vector: Vector3, transformation: Ma
6954
7141
  * Wraps a Lite scene node (`_node`): either a standalone Lite transform node, or
6955
7142
  * (for meshes) the Lite mesh itself, which also carries the transform.
6956
7143
  */
6957
- export declare class TransformNode extends Node_2 {
6958
7144
  physicsBody: PhysicsBody | null;
6959
7145
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
7146
+ export declare class TransformNode extends Node_2 {
6960
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?;
6961
7156
  constructor(name: string, scene?: Scene, liteNode?: SceneNode);
6962
7157
  getClassName(): string;
6963
7158
  get position(): Vector3;
6964
7159
  set position(value: Vector3);
6965
7160
  get rotation(): Vector3;
6966
7161
  set rotation(value: Vector3);
6967
7162
  get scaling(): Vector3;
6968
- set scaling(value: Vector3);
6969
7163
  /**
6970
- * Babylon.js `rotationQuaternion`. Babylon Lite always drives a node's world
6971
- * matrix from a quaternion (its euler `rotation` is a proxy over the same
6972
- * quaternion), so this reads/writes that quaternion. Returns `null` until
6973
- * explicitly assigned, matching Babylon.js's euler-by-default convention.
6974
- */
7164
+ set scaling(value: Vector3);
7165
+ /** Babylon.js `rotationQuaternion`, kept live while Lite receives translated component writes. */
6975
7166
  get rotationQuaternion(): Quaternion | null;
6976
7167
  set rotationQuaternion(value: Quaternion | null);
6977
- /**
7168
+ private _applyEulerRotation;
7169
+ private _applyQuaternionRotation;
7170
+ private _markNativeRotationSynced;
7171
+ private _syncRotationFromNative;
6978
7172
  /**
6979
7173
  * Babylon.js `getChildTransformNodes(directDescendantsOnly?, predicate?)` — the descendants that are transform nodes
6980
7174
  * (meshes included). As in Babylon.js, `predicate` is called on every evaluated descendant.
6981
7175
  */
@@ -6980,10 +7174,16 @@ export declare class TransformNode extends Node_2 {
6980
7174
  physicsBody: PhysicsBody
6981
7175
  * setter, which keeps the local transform and lets the world move.
6982
7176
  */
6983
7177
  setParent(parent: Node_2 | null): TransformNode;
6984
- protected _applyParent(parent: Node_2 | null): void;
7178
+ protected _applyParent(parent: Node_2 | null): void;
6985
7179
  private _bindRotationSceneDisposal;
7180
+ protected _retireFromScene(): void;
7181
+ }
6986
7182
 
6987
7183
  export declare function transformNormal(vector: Vector3, transformation: Matrix): Vector3;
6988
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
+
6989
7189
  export declare type TrianglePickingPredicate = (p0: Vector3, p1: Vector3, p2: Vector3, ray: Ray, i0: number, i1: number, i2: number) => boolean;
6990
7190
 
6991
7191
  /** Minimum Babylon.js UniformBuffer surface needed to author compute bindings. */