@babylonjs/lite-compat 1.19.0-preview → 1.21.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 CHANGED
@@ -121,9 +121,9 @@ overloads within a supported area may still be absent.
121
121
  | Engine (`WebGPUEngine`, `Engine`, `ThinEngine`, `NullEngine`) | ⚡ | async startup + render loop; `beginFrame`/`endFrame`, MSAA/alpha-to-coverage (`currentSampleCount`/`get`/`setAlphaToCoverage`), and manual `scene.render()` unsupported |
122
122
  | Scene (clear color, cameras/lights, fog, environment, observables, ready state) | ⚡ | sync `scene.pick` unsupported (use async `GPUPicker`); `scene.meshes` + `getMeshBy*`/`getNodeBy*` now enumerate every mesh via a canonical wrapper registry |
123
123
  | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | XR / device-orientation / stereoscopic rigs unsupported |
124
- | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `RectAreaLight` / clustered lights unsupported |
124
+ | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `ClusteredLightContainer` clusters point lights (⚡ partial); `RectAreaLight` unsupported |
125
125
  | Shadows (`ShadowGenerator` directional ESM/PCF, spot PCF) | ⚡ | `CascadedShadowGenerator` falls back to single cascade |
126
- | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; `CreateDashedLines`/`CreateDecal`/`CreateText`/`CreateTiledBox`/`CreateTiledPlane`, `InstancedMesh`, LOD/edges/outline, hardware instances unsupported |
126
+ | Meshes & geometry (class chain, `MeshBuilder` primitives, transforms, thin instances, `clone`, `VertexData`, `Mesh.MergeMeshes`) | ⚡ | `CreateLines`/`CreateLineSystem` support fixed-topology line lists and RGBA point colors; `CreateDashedLines` supports uniform-color dashed line lists; `MergeMeshes` bakes positions/normals/UVs and rejects unsupported attributes/animation; `CreateDecal`/`CreateText`/`CreateTiledBox`/`CreateTiledPlane`, `GreasedLine*` (thick lines), `InstancedMesh`, LOD/edges/outline, hardware instances unsupported |
127
127
  | CSG / CSG2 | ✅ | over Lite boolean ops |
128
128
  | Gizmos (position/rotation/scale/bounding-box/light/camera + `GizmoManager`) | ⚡ | over Lite gizmo suite; `isEnabled` toggles per-axis interactivity (display-only when disabled) |
129
129
  | Materials (`StandardMaterial`, `PBRMaterial`, metallic-rough / spec-gloss, `NodeMaterial`) | ⚡ | `clone(name)` shares textures with its own renderable; `ShaderMaterial` (GLSL), `MultiMaterial`, `BackgroundMaterial` unsupported |
package/index.d.ts CHANGED
@@ -580,6 +580,12 @@ export declare const ActionManagerTriggers: {
580
580
  readonly OnEveryFrameTrigger: 14;
581
581
  };
582
582
 
583
+ /** Babylon.js `AddGaussianSplattingStreamPart` — appends a streamed LOD part to a GS compound mesh. */
584
+ export declare function AddGaussianSplattingStreamPart(..._args: unknown[]): never;
585
+
586
+ /** Babylon.js `AddGaussianSplattingStreamPartAsync` — async variant of {@link AddGaussianSplattingStreamPart}. */
587
+ export declare function AddGaussianSplattingStreamPartAsync(..._args: unknown[]): never;
588
+
583
589
  export declare class AmmoJSPlugin {
584
590
  constructor();
585
591
  }
@@ -1173,8 +1179,62 @@ export declare class CircleEase extends EasingFunction {
1173
1179
  easeInCore(gradient: number): number;
1174
1180
  }
1175
1181
 
1176
- export declare class ClusteredLightContainer {
1177
- constructor();
1182
+ /**
1183
+ * Babylon.js `ClusteredLightContainer` — a `Light` that renders a large set of
1184
+ * point lights through a clustered / forward+ system.
1185
+ */
1186
+ export declare class ClusteredLightContainer extends Light {
1178
1187
  private _maxRange;
1188
+ private _selfIntensity;
1189
+ /**
1190
+ * True if a point/spot light can be clustered by this container. Babylon Lite
1191
+ * clusters point lights only.
1192
+ */
1193
+ static IsLightSupported(light: Light): boolean;
1194
+ /**
1195
+ * Creates a new clustered light container.
1196
+ *
1197
+ * @param name - The container's node name.
1198
+ * @param lights - Initial lights to cluster (point lights).
1199
+ * @param scene - Owning scene; when supplied the container is registered and
1200
+ * built into the Lite scene at engine start.
1201
+ */
1202
+ constructor(name: string, lights?: Light[], scene?: Scene);
1203
+ getClassName(): string;
1204
+ /** Babylon.js `light.getTypeID()` — `LIGHTTYPEID_CLUSTERED_CONTAINER`. */
1205
+ getTypeID(): number;
1206
+ /** True when clustered lighting is available (Babylon Lite backs it on WebGPU). */
1207
+ get isSupported(): boolean;
1208
+ /** The lights added to this clustering system. */
1209
+ get lights(): readonly Light[];
1210
+ /** Number of cluster tiles across the screen horizontally (default `64`). */
1211
+ get horizontalTiles(): number;
1212
+ set horizontalTiles(value: number);
1213
+ /** Number of cluster tiles across the screen vertically (default `64`). */
1214
+ get verticalTiles(): number;
1215
+ set verticalTiles(value: number);
1216
+ /** Number of depth slices used to bin lights along view-space Z (default `16`). */
1217
+ get depthSlices(): number;
1218
+ set depthSlices(value: number);
1219
+ /**
1220
+ * Upper bound applied to clustered light ranges. Babylon Lite manages range
1221
+ * binning internally, so this is stored for API-shape parity and does not
1222
+ * re-cluster the lights.
1223
+ */
1224
+ get maxRange(): number;
1225
+ set maxRange(value: number);
1226
+ /** Babylon.js `container.addLight(light)`. Only point lights are clustered. */
1227
+ addLight(light: Light): void;
1228
+ /**
1229
+ * Babylon.js `container.removeLight(light)`. Returns the index the light held
1230
+ * in the container's light list, or `-1` if it was not present.
1231
+ */
1232
+ removeLight(light: Light): number;
1179
1233
  /** Container-level intensity (Babylon.js inherits it from `Light`; each child light carries its own). */
1234
+ get intensity(): number;
1235
+ set intensity(value: number);
1236
+ /** Clustered lights do not cast shadows in Babylon.js; the toggle is a no-op. */
1237
+ set shadowEnabled(_enabled: boolean);
1238
+ protected _onEffectiveEnabledStateChanged(_enabled: boolean): void;
1239
+ dispose(): void;
1180
1240
  }
1181
1241
 
1182
1242
  /**
@@ -1240,6 +1300,10 @@ declare type CompatMaterial = StandardMaterial | PBRMaterial | NodeMaterial | Gr
1240
1300
 
1241
1301
  declare type CompatMaterial_2 = StandardMaterial | PBRMaterial | NodeMaterial;
1242
1302
 
1303
+ export declare function CompleteGreasedLineColorTable(..._args: unknown[]): never;
1304
+
1305
+ export declare function CompleteGreasedLineWidthTable(..._args: unknown[]): never;
1306
+
1243
1307
  /** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
1244
1308
  export declare function ComputeOverlayCssTransform(): never;
1245
1309
 
@@ -1289,9 +1353,16 @@ export declare function CreateBox(name: string, options: BoxOptions, scene: Scen
1289
1353
  /** Babylon.js `CreateCylinder(name, options, scene)` (cylinderBuilder). */
1290
1354
  export declare function CreateCylinder(name: string, options: CylinderOptions, scene: Scene): Mesh;
1291
1355
 
1356
+ /** Babylon.js `CreateDashedLines(name, options, scene)` (linesBuilder). */
1357
+ export declare function CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
1358
+
1292
1359
  /** Babylon.js `CreateDisc(name, options, scene)` (discBuilder). */
1293
1360
  export declare function CreateDisc(name: string, options: object, scene: Scene): Mesh;
1294
1361
 
1362
+ export declare function CreateGreasedLine(..._args: unknown[]): never;
1363
+
1364
+ export declare function CreateGreasedLineMaterial(..._args: unknown[]): never;
1365
+
1295
1366
  /** Babylon.js `CreateGround(name, options, scene)` (groundBuilder). */
1296
1367
  export declare function CreateGround(name: string, options: GroundOptions, scene: Scene): Mesh;
1297
1368
 
@@ -1470,6 +1541,17 @@ declare interface CylinderOptions {
1470
1541
  tessellation?: number;
1471
1542
  }
1472
1543
 
1544
+ declare interface DashedLinesBuilderOptions {
1545
+ points: Vector3[];
1546
+ dashSize?: number;
1547
+ gapSize?: number;
1548
+ dashNb?: number;
1549
+ updatable?: boolean;
1550
+ instance?: LinesMesh | null;
1551
+ useVertexAlpha?: boolean;
1552
+ material?: unknown;
1553
+ }
1554
+
1473
1555
  declare interface DefaultEnvironmentOptions {
1474
1556
  createSkybox?: boolean;
1475
1557
  createGround?: boolean;
@@ -1725,6 +1807,13 @@ export declare class GaussianSplattingMesh extends TransformNode {
1725
1807
  /**
1726
1808
  /** Babylon.js `gs.bakeCurrentTransformIntoVertices()` — fold the node transform into the splat data. */
1727
1809
  bakeCurrentTransformIntoVertices(): void;
1728
1810
 
1811
+ export declare class GaussianSplattingStream {
1812
+ constructor(..._args: unknown[]);
1813
+ }
1814
+
1815
+ /** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
1816
+ export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
1817
+
1729
1818
  export declare class GeometryBufferRenderer {
1730
1819
  constructor();
1731
1820
  }
@@ -1762,6 +1851,8 @@ export declare class GeospatialClippingBehavior {
1762
1851
  /** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
1763
1852
  export declare function GetElementPixelFromUv(): never;
1764
1853
 
1854
+ export declare function GetPointsCount(..._args: unknown[]): never;
1855
+
1765
1856
  /** Shared base for compat gizmos (Babylon.js `Gizmo`). */
1766
1857
  declare abstract class GizmoBase {
1767
1858
  protected constructor(layer: UtilityLayerRenderer);
1768
1859
  abstract get attachedMesh(): AbstractMesh | null;
@@ -1829,8 +1920,97 @@ export declare class GPUPicker {
1829
1920
  dispose(): void;
1830
1921
  }
1831
1922
 
1923
+ export declare class GreasedLineBaseMesh {
1924
+ constructor(..._args: unknown[]);
1925
+ }
1926
+
1927
+ export declare class GreasedLineMaterialDefaults {
1928
+ constructor(..._args: unknown[]);
1929
+ static get DEFAULT_COLOR(): never;
1930
+ static get DEFAULT_WIDTH_ATTENUATED(): never;
1931
+ static get DEFAULT_WIDTH(): never;
1932
+ static get EmptyColorsTexture(): never;
1933
+ }
1934
+
1832
1935
  export declare class GreasedLineMesh {
1833
- constructor();
1936
+ constructor(..._args: unknown[]);
1937
+ }
1938
+
1939
+ export declare enum GreasedLineMeshColorDistribution {
1940
+ COLOR_DISTRIBUTION_NONE = 0,
1941
+ COLOR_DISTRIBUTION_REPEAT = 1,
1942
+ COLOR_DISTRIBUTION_EVEN = 2,
1943
+ COLOR_DISTRIBUTION_START = 3,
1944
+ COLOR_DISTRIBUTION_END = 4,
1945
+ COLOR_DISTRIBUTION_START_END = 5
1946
+ }
1947
+
1948
+ export declare enum GreasedLineMeshWidthDistribution {
1949
+ WIDTH_DISTRIBUTION_NONE = 0,
1950
+ WIDTH_DISTRIBUTION_REPEAT = 1,
1951
+ WIDTH_DISTRIBUTION_EVEN = 2,
1952
+ WIDTH_DISTRIBUTION_START = 3,
1953
+ WIDTH_DISTRIBUTION_END = 4,
1954
+ WIDTH_DISTRIBUTION_START_END = 5
1955
+ }
1956
+
1957
+ export declare class GreasedLinePluginMaterial {
1958
+ constructor(..._args: unknown[]);
1959
+ }
1960
+
1961
+ export declare enum GreasedLineRibbonAutoDirectionMode {
1962
+ AUTO_DIRECTIONS_FROM_FIRST_SEGMENT = 0,
1963
+ AUTO_DIRECTIONS_FROM_ALL_SEGMENTS = 1,
1964
+ AUTO_DIRECTIONS_ENHANCED = 2,
1965
+ AUTO_DIRECTIONS_FACE_TO = 3,
1966
+ AUTO_DIRECTIONS_NONE = 99
1967
+ }
1968
+
1969
+ export declare enum GreasedLineRibbonFacesMode {
1970
+ FACES_MODE_SINGLE_SIDED = 0,
1971
+ FACES_MODE_SINGLE_SIDED_NO_BACKFACE_CULLING = 1,
1972
+ FACES_MODE_DOUBLE_SIDED = 2
1973
+ }
1974
+
1975
+ export declare class GreasedLineRibbonMesh {
1976
+ constructor(..._args: unknown[]);
1977
+ }
1978
+
1979
+ export declare enum GreasedLineRibbonPointsMode {
1980
+ POINTS_MODE_POINTS = 0,
1981
+ POINTS_MODE_PATHS = 1
1982
+ }
1983
+
1984
+ export declare class GreasedLineSimpleMaterial {
1985
+ constructor(..._args: unknown[]);
1986
+ }
1987
+
1988
+ export declare class GreasedLineTools {
1989
+ constructor(..._args: unknown[]);
1990
+ static ConvertPoints(..._args: unknown[]): never;
1991
+ static OmitZeroLengthPredicate(..._args: unknown[]): never;
1992
+ static OmitDuplicatesPredicate(..._args: unknown[]): never;
1993
+ static MeshesToLines(..._args: unknown[]): never;
1994
+ static ToVector3Array(..._args: unknown[]): never;
1995
+ static ToNumberArray(..._args: unknown[]): never;
1996
+ static GetPointsCountInfo(..._args: unknown[]): never;
1997
+ static GetLineLength(..._args: unknown[]): never;
1998
+ static GetLineLengthArray(..._args: unknown[]): never;
1999
+ static SegmentizeSegmentByCount(..._args: unknown[]): never;
2000
+ static SegmentizeLineBySegmentLength(..._args: unknown[]): never;
2001
+ static SegmentizeLineBySegmentCount(..._args: unknown[]): never;
2002
+ static GetLineSegments(..._args: unknown[]): never;
2003
+ static GetMinMaxSegmentLength(..._args: unknown[]): never;
2004
+ static GetPositionOnLineByVisibility(..._args: unknown[]): never;
2005
+ static GetCircleLinePoints(..._args: unknown[]): never;
2006
+ static GetBezierLinePoints(..._args: unknown[]): never;
2007
+ static GetArrowCap(..._args: unknown[]): never;
2008
+ static GetPointsFromText(..._args: unknown[]): never;
2009
+ static Color3toRGBAUint8(..._args: unknown[]): never;
2010
+ static CreateColorsTexture(..._args: unknown[]): never;
2011
+ static PrepareEmptyColorsTexture(..._args: unknown[]): never;
2012
+ static DisposeEmptyColorsTexture(..._args: unknown[]): never;
2013
+ static BooleanToNumber(..._args: unknown[]): never;
1834
2014
  }
1835
2015
 
1836
2016
  export declare class GridMaterial {
@@ -2073,6 +2253,16 @@ export declare interface ICreateTexture2DArrayFromKTX2Options {
2073
2253
  invertY?: boolean;
2074
2254
  }
2075
2255
 
2256
+ /** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
2257
+ export declare interface IGaussianSplattingStreamingPart {
2258
+ [key: string]: unknown;
2259
+ }
2260
+
2261
+ /** Babylon.js `IGaussianSplattingStreamOptions` — GS LOD stream options (shape-only stub for type parity). */
2262
+ export declare interface IGaussianSplattingStreamOptions {
2263
+ [key: string]: unknown;
2264
+ }
2265
+
2076
2266
  /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
2077
2267
  export declare interface IGPUMultiPickingInfo {
2078
2268
  meshes: Array<PickableMesh | null>;
@@ -2184,6 +2374,11 @@ export declare function IsHtmlInCanvasSupportedNatively(): never;
2184
2374
  /** Babylon.js `IsHtmlInCanvasUploadSupported` — HTML texture upload is unsupported by the compat layer. */
2185
2375
  export declare function IsHtmlInCanvasUploadSupported(): never;
2186
2376
 
2377
+ /** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
2378
+ export declare interface ISOGLODMetadata {
2379
+ [key: string]: unknown;
2380
+ }
2381
+
2187
2382
  /** Babylon.js `ISoundSourceOptions` (subset). */
2188
2383
  export declare interface ISoundSourceOptions extends Partial<IVolumeAudioOptions> {
2189
2384
  /** Name. */
@@ -2500,6 +2695,10 @@ export declare abstract class Material {
2500
2695
  protected _markDirty(): void;
2501
2696
  dispose(): void;
2502
2697
  }
2503
2698
 
2699
+ export declare class MaterialGreasedLineDefines {
2700
+ constructor(..._args: unknown[]);
2701
+ }
2702
+
2504
2703
  export declare class Matrix {
2505
2704
  readonly m: Float32Array;
2506
2705
  constructor();
@@ -2651,7 +2850,7 @@ export declare const MeshBuilder: {
2651
2850
  ExtrudeShape(name: string, options: object, scene: Scene): Mesh;
2652
2851
  CreateLines(name: string, options: LinesBuilderOptions, scene?: Scene | null): LinesMesh;
2653
2852
  CreateLineSystem(name: string, options: LineSystemBuilderOptions, scene?: Scene | null): LinesMesh;
2654
- CreateDashedLines(): never;
2853
+ CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
2655
2854
  CreateDecal(): never;
2656
2855
  CreateText(): never;
2657
2856
  CreateTiledBox(_name?: string, _options?: object, _scene?: Scene): never;
@@ -3589,6 +3788,8 @@ export declare class ReflectionProbe {
3589
3788
  constructor();
3590
3789
  }
3591
3790
 
3791
+ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
3792
+
3592
3793
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
3593
3794
  export declare class RenderTargetTexture {
3594
3795
  constructor();