@babylonjs/lite-compat 1.18.0-preview → 1.20.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
@@ -123,7 +123,7 @@ overloads within a supported area may still be absent.
123
123
  | Cameras (`ArcRotateCamera`, `FreeCamera`/`Universal`/`Target`, `FollowCamera`, `GeospatialCamera`) | ✅ | XR / device-orientation / stereoscopic rigs unsupported |
124
124
  | Lights (`Hemispheric`, `Directional`, `Point`, `Spot`) | ✅ | `RectAreaLight` / clustered lights 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
  }
@@ -1240,6 +1246,10 @@ declare type CompatMaterial = StandardMaterial | PBRMaterial | NodeMaterial | Gr
1240
1246
 
1241
1247
  declare type CompatMaterial_2 = StandardMaterial | PBRMaterial | NodeMaterial;
1242
1248
 
1249
+ export declare function CompleteGreasedLineColorTable(..._args: unknown[]): never;
1250
+
1251
+ export declare function CompleteGreasedLineWidthTable(..._args: unknown[]): never;
1252
+
1243
1253
  /** Babylon.js `ComputeOverlayCssTransform` — HTML overlay interaction is unsupported by the compat layer. */
1244
1254
  export declare function ComputeOverlayCssTransform(): never;
1245
1255
 
@@ -1289,9 +1299,16 @@ export declare function CreateBox(name: string, options: BoxOptions, scene: Scen
1289
1299
  /** Babylon.js `CreateCylinder(name, options, scene)` (cylinderBuilder). */
1290
1300
  export declare function CreateCylinder(name: string, options: CylinderOptions, scene: Scene): Mesh;
1291
1301
 
1302
+ /** Babylon.js `CreateDashedLines(name, options, scene)` (linesBuilder). */
1303
+ export declare function CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
1304
+
1292
1305
  /** Babylon.js `CreateDisc(name, options, scene)` (discBuilder). */
1293
1306
  export declare function CreateDisc(name: string, options: object, scene: Scene): Mesh;
1294
1307
 
1308
+ export declare function CreateGreasedLine(..._args: unknown[]): never;
1309
+
1310
+ export declare function CreateGreasedLineMaterial(..._args: unknown[]): never;
1311
+
1295
1312
  /** Babylon.js `CreateGround(name, options, scene)` (groundBuilder). */
1296
1313
  export declare function CreateGround(name: string, options: GroundOptions, scene: Scene): Mesh;
1297
1314
 
@@ -1470,6 +1487,17 @@ declare interface CylinderOptions {
1470
1487
  tessellation?: number;
1471
1488
  }
1472
1489
 
1490
+ declare interface DashedLinesBuilderOptions {
1491
+ points: Vector3[];
1492
+ dashSize?: number;
1493
+ gapSize?: number;
1494
+ dashNb?: number;
1495
+ updatable?: boolean;
1496
+ instance?: LinesMesh | null;
1497
+ useVertexAlpha?: boolean;
1498
+ material?: unknown;
1499
+ }
1500
+
1473
1501
  declare interface DefaultEnvironmentOptions {
1474
1502
  createSkybox?: boolean;
1475
1503
  createGround?: boolean;
@@ -1725,6 +1753,13 @@ export declare class GaussianSplattingMesh extends TransformNode {
1725
1753
  /**
1726
1754
  /** Babylon.js `gs.bakeCurrentTransformIntoVertices()` — fold the node transform into the splat data. */
1727
1755
  bakeCurrentTransformIntoVertices(): void;
1728
1756
 
1757
+ export declare class GaussianSplattingStream {
1758
+ constructor(..._args: unknown[]);
1759
+ }
1760
+
1761
+ /** Babylon.js `GaussianSplattingStreamDebugLodSource` — LOD debug source selector (shape-only stub for type parity). */
1762
+ export declare type GaussianSplattingStreamDebugLodSource = "optimal" | "current";
1763
+
1729
1764
  export declare class GeometryBufferRenderer {
1730
1765
  constructor();
1731
1766
  }
@@ -1762,6 +1797,8 @@ export declare class GeospatialClippingBehavior {
1762
1797
  /** Babylon.js `GetElementPixelFromUv` — HTML overlay raycast interaction is unsupported by the compat layer. */
1763
1798
  export declare function GetElementPixelFromUv(): never;
1764
1799
 
1800
+ export declare function GetPointsCount(..._args: unknown[]): never;
1801
+
1765
1802
  /** Shared base for compat gizmos (Babylon.js `Gizmo`). */
1766
1803
  declare abstract class GizmoBase {
1767
1804
  protected constructor(layer: UtilityLayerRenderer);
1768
1805
  abstract get attachedMesh(): AbstractMesh | null;
@@ -1829,8 +1866,97 @@ export declare class GPUPicker {
1829
1866
  dispose(): void;
1830
1867
  }
1831
1868
 
1869
+ export declare class GreasedLineBaseMesh {
1870
+ constructor(..._args: unknown[]);
1871
+ }
1872
+
1873
+ export declare class GreasedLineMaterialDefaults {
1874
+ constructor(..._args: unknown[]);
1875
+ static get DEFAULT_COLOR(): never;
1876
+ static get DEFAULT_WIDTH_ATTENUATED(): never;
1877
+ static get DEFAULT_WIDTH(): never;
1878
+ static get EmptyColorsTexture(): never;
1879
+ }
1880
+
1832
1881
  export declare class GreasedLineMesh {
1833
- constructor();
1882
+ constructor(..._args: unknown[]);
1883
+ }
1884
+
1885
+ export declare enum GreasedLineMeshColorDistribution {
1886
+ COLOR_DISTRIBUTION_NONE = 0,
1887
+ COLOR_DISTRIBUTION_REPEAT = 1,
1888
+ COLOR_DISTRIBUTION_EVEN = 2,
1889
+ COLOR_DISTRIBUTION_START = 3,
1890
+ COLOR_DISTRIBUTION_END = 4,
1891
+ COLOR_DISTRIBUTION_START_END = 5
1892
+ }
1893
+
1894
+ export declare enum GreasedLineMeshWidthDistribution {
1895
+ WIDTH_DISTRIBUTION_NONE = 0,
1896
+ WIDTH_DISTRIBUTION_REPEAT = 1,
1897
+ WIDTH_DISTRIBUTION_EVEN = 2,
1898
+ WIDTH_DISTRIBUTION_START = 3,
1899
+ WIDTH_DISTRIBUTION_END = 4,
1900
+ WIDTH_DISTRIBUTION_START_END = 5
1901
+ }
1902
+
1903
+ export declare class GreasedLinePluginMaterial {
1904
+ constructor(..._args: unknown[]);
1905
+ }
1906
+
1907
+ export declare enum GreasedLineRibbonAutoDirectionMode {
1908
+ AUTO_DIRECTIONS_FROM_FIRST_SEGMENT = 0,
1909
+ AUTO_DIRECTIONS_FROM_ALL_SEGMENTS = 1,
1910
+ AUTO_DIRECTIONS_ENHANCED = 2,
1911
+ AUTO_DIRECTIONS_FACE_TO = 3,
1912
+ AUTO_DIRECTIONS_NONE = 99
1913
+ }
1914
+
1915
+ export declare enum GreasedLineRibbonFacesMode {
1916
+ FACES_MODE_SINGLE_SIDED = 0,
1917
+ FACES_MODE_SINGLE_SIDED_NO_BACKFACE_CULLING = 1,
1918
+ FACES_MODE_DOUBLE_SIDED = 2
1919
+ }
1920
+
1921
+ export declare class GreasedLineRibbonMesh {
1922
+ constructor(..._args: unknown[]);
1923
+ }
1924
+
1925
+ export declare enum GreasedLineRibbonPointsMode {
1926
+ POINTS_MODE_POINTS = 0,
1927
+ POINTS_MODE_PATHS = 1
1928
+ }
1929
+
1930
+ export declare class GreasedLineSimpleMaterial {
1931
+ constructor(..._args: unknown[]);
1932
+ }
1933
+
1934
+ export declare class GreasedLineTools {
1935
+ constructor(..._args: unknown[]);
1936
+ static ConvertPoints(..._args: unknown[]): never;
1937
+ static OmitZeroLengthPredicate(..._args: unknown[]): never;
1938
+ static OmitDuplicatesPredicate(..._args: unknown[]): never;
1939
+ static MeshesToLines(..._args: unknown[]): never;
1940
+ static ToVector3Array(..._args: unknown[]): never;
1941
+ static ToNumberArray(..._args: unknown[]): never;
1942
+ static GetPointsCountInfo(..._args: unknown[]): never;
1943
+ static GetLineLength(..._args: unknown[]): never;
1944
+ static GetLineLengthArray(..._args: unknown[]): never;
1945
+ static SegmentizeSegmentByCount(..._args: unknown[]): never;
1946
+ static SegmentizeLineBySegmentLength(..._args: unknown[]): never;
1947
+ static SegmentizeLineBySegmentCount(..._args: unknown[]): never;
1948
+ static GetLineSegments(..._args: unknown[]): never;
1949
+ static GetMinMaxSegmentLength(..._args: unknown[]): never;
1950
+ static GetPositionOnLineByVisibility(..._args: unknown[]): never;
1951
+ static GetCircleLinePoints(..._args: unknown[]): never;
1952
+ static GetBezierLinePoints(..._args: unknown[]): never;
1953
+ static GetArrowCap(..._args: unknown[]): never;
1954
+ static GetPointsFromText(..._args: unknown[]): never;
1955
+ static Color3toRGBAUint8(..._args: unknown[]): never;
1956
+ static CreateColorsTexture(..._args: unknown[]): never;
1957
+ static PrepareEmptyColorsTexture(..._args: unknown[]): never;
1958
+ static DisposeEmptyColorsTexture(..._args: unknown[]): never;
1959
+ static BooleanToNumber(..._args: unknown[]): never;
1834
1960
  }
1835
1961
 
1836
1962
  export declare class GridMaterial {
@@ -2073,6 +2199,16 @@ export declare interface ICreateTexture2DArrayFromKTX2Options {
2073
2199
  invertY?: boolean;
2074
2200
  }
2075
2201
 
2202
+ /** Babylon.js `IGaussianSplattingStreamingPart` — a streamed part of a GS compound mesh (shape-only stub for type parity). */
2203
+ export declare interface IGaussianSplattingStreamingPart {
2204
+ [key: string]: unknown;
2205
+ }
2206
+
2207
+ /** Babylon.js `IGaussianSplattingStreamOptions` — GS LOD stream options (shape-only stub for type parity). */
2208
+ export declare interface IGaussianSplattingStreamOptions {
2209
+ [key: string]: unknown;
2210
+ }
2211
+
2076
2212
  /** Result of a multi-point GPU pick. Mirrors Babylon.js `IGPUMultiPickingInfo`. */
2077
2213
  export declare interface IGPUMultiPickingInfo {
2078
2214
  meshes: Array<PickableMesh | null>;
@@ -2184,6 +2320,11 @@ export declare function IsHtmlInCanvasSupportedNatively(): never;
2184
2320
  /** Babylon.js `IsHtmlInCanvasUploadSupported` — HTML texture upload is unsupported by the compat layer. */
2185
2321
  export declare function IsHtmlInCanvasUploadSupported(): never;
2186
2322
 
2323
+ /** Babylon.js `ISOGLODMetadata` — SOG LOD octree metadata (shape-only stub for type parity). */
2324
+ export declare interface ISOGLODMetadata {
2325
+ [key: string]: unknown;
2326
+ }
2327
+
2187
2328
  /** Babylon.js `ISoundSourceOptions` (subset). */
2188
2329
  export declare interface ISoundSourceOptions extends Partial<IVolumeAudioOptions> {
2189
2330
  /** Name. */
@@ -2500,6 +2641,10 @@ export declare abstract class Material {
2500
2641
  protected _markDirty(): void;
2501
2642
  dispose(): void;
2502
2643
  }
2503
2644
 
2645
+ export declare class MaterialGreasedLineDefines {
2646
+ constructor(..._args: unknown[]);
2647
+ }
2648
+
2504
2649
  export declare class Matrix {
2505
2650
  readonly m: Float32Array;
2506
2651
  constructor();
@@ -2651,7 +2796,7 @@ export declare const MeshBuilder: {
2651
2796
  ExtrudeShape(name: string, options: object, scene: Scene): Mesh;
2652
2797
  CreateLines(name: string, options: LinesBuilderOptions, scene?: Scene | null): LinesMesh;
2653
2798
  CreateLineSystem(name: string, options: LineSystemBuilderOptions, scene?: Scene | null): LinesMesh;
2654
- CreateDashedLines(): never;
2799
+ CreateDashedLines(name: string, options: DashedLinesBuilderOptions, scene?: Scene | null): LinesMesh;
2655
2800
  CreateDecal(): never;
2656
2801
  CreateText(): never;
2657
2802
  CreateTiledBox(_name?: string, _options?: object, _scene?: Scene): never;
@@ -3589,6 +3734,8 @@ export declare class ReflectionProbe {
3589
3734
  constructor();
3590
3735
  }
3591
3736
 
3737
+ export declare function RegisterGreasedLinePluginMaterial(..._args: unknown[]): never;
3738
+
3592
3739
  /** Babylon.js `RenderTargetTexture` — offscreen render target. Use the native frame-graph RTT APIs. */
3593
3740
  export declare class RenderTargetTexture {
3594
3741
  constructor();
package/index.js CHANGED
@@ -1,8 +1,8 @@
1
1
  var __defProp = Object.defineProperty;
2
2
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
3
3
  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
4
- import { V as Vector3, u as unsupported, L as LiteCompatError, N as Node, M as Matrix, C as Color3, S as StandardMaterial, a as Color4, b as Mesh, T as TransformNode, l as liteBackedVector3, Q as Quaternion } from "./meshes-0TVZfbq3.js";
5
- import { A, B, c, d, e, f, g, h, i, j, k, m, n, o, p, G, I, q, r, s, P, t, v, w, x, y, z, D, E, F, H, J, K, O } from "./meshes-0TVZfbq3.js";
4
+ import { V as Vector3, u as unsupported, L as LiteCompatError, N as Node, M as Matrix, C as Color3, S as StandardMaterial, a as Color4, b as Mesh, T as TransformNode, l as liteBackedVector3, Q as Quaternion } from "./meshes-eNVvq5sm.js";
5
+ import { A, B, c, d, e, f, g, h, i, j, k, m, n, o, p, q, G, I, r, s, t, P, v, w, x, y, z, D, E, F, H, J, K, O, R } from "./meshes-eNVvq5sm.js";
6
6
  import { VERSION, createEngine, onBeforeRender, stopEngine, resizeEngine, setEngineSize, disposeEngine, uploadImageToArrayLayer, enableMirroredMeshes, registerSceneWithShadowSupport, registerScene, startEngine, createNullEngine, stepScene, setPhysicsTimestep, setPhysicsGravity, disposePhysics, createHavokWorld, createArcRotateCamera, attachControl, getCameraPosition, getViewMatrix, getProjectionMatrix, createGeospatialCamera, setGeospatialOrientation, attachGeospatialControls, createFreeCamera, attachFreeControl, setAnimationAdditive, playAnimation, pauseAnimation, goToFrame, stopAnimation, createSceneContext, updateAnimationManager, setFog, setClipPlane, loadHdrEnvironment, loadDdsEnvironment, loadEnvironment, createDefaultCamera, addToScene, createHemisphericLight, createAnimationManager, enableAnimationBlending, addAnimationGroup, disposeScene, createDirectionalLight, createPointLight, createSpotLight, createCsgFromMesh, csgSubtract, csgIntersect, csgUnion, createMeshFromCsg, createCsg2FromMesh, csg2Subtract, csg2Intersect, csg2Add, createMeshesFromCsg2, disposeCsg2, initializeCsg2Async, createMorphTargets, setMorphTargetWeights, createTransformNode, bakeCurrentTransformIntoVertices, loadSOG, loadSPZ, loadSplat, createDynamicTexture, updateDynamicTexture, createTexture2DFromPixels, updateTexture2DFromPixels, createTexture3DFromPixels, loadBasisTexture2D, loadKtxTexture2D, loadTexture2D, createTexture2DArrayFromUrls, createTexture2DArrayFromKtx2, loadImageToArrayLayer, createTexture2DArray, createTexture2DArrayFromPixels, updateTexture2DArrayFromPixels, loadBabylon, loadGltf, resetVariant, getVariantNames, selectVariant, disposePicker, createGpuPicker, pickAsync, createAxisDragGizmo, attachAxisDragGizmoToNode, disposeAxisDragGizmo, createAxisScaleGizmo, attachAxisScaleGizmoToNode, disposeAxisScaleGizmo, createBoundingBoxGizmo, attachBoundingBoxGizmoToNode, disposeBoundingBoxGizmo, createCameraGizmo, attachCameraGizmoToCamera, disposeCameraGizmo, createLightGizmo, attachLightGizmoToLight, disposeLightGizmo, createPlaneDragGizmo, attachPlaneDragGizmoToNode, disposePlaneDragGizmo, createPlaneRotationGizmo, attachPlaneRotationGizmoToNode, disposePlaneRotationGizmo, createPositionGizmo, setPositionGizmoLocalCoordinates, attachPositionGizmoToNode, disposePositionGizmo, createRotationGizmo, setRotationGizmoLocalCoordinates, attachRotationGizmoToNode, disposeRotationGizmo, createScaleGizmo, setScaleGizmoLocalCoordinates, attachScaleGizmoToNode, disposeScaleGizmo, createUtilityLayer, registerUtilityLayer, disposeUtilityLayer, addBillboardSpriteIndex, updateBillboardSpriteIndex, loadSpriteAtlas, createFacingBillboardSystem, addFacingBillboardSystem, billboardBlendAdditive, billboardBlendAlpha, spriteBlendPremultiplied, spriteBlendAdditive, spriteBlendAlpha, createSprite2DLayer, addSprite2DIndex, createSpriteRenderer, registerSpriteRenderer, updateSprite2DIndex, createPcfSpotlightShadowGenerator, createPcfDirectionalShadowGenerator, createEsmDirectionalShadowGenerator, setShadowTaskCasterMeshes, parseNodeMaterialFromSnippet, createGridMaterial, getByteFrequencyData, getFloatFrequencyData, getByteTimeDomainData, getFloatTimeDomainData, enableAnalyzer, setSpatialPosition, setSpatialOrientation, enableSpatial, setSpatialListenerPosition, setSpatialListener, updateSpatialAudio, enableStereo, setStereoPan, disposeAudioBus, setBusVolume, getMasterVolume, setMasterVolume, unlockAudioEngineAsync, createSoundAsync, createSoundBufferAsync, createStreamingSoundAsync, createAudioBusAsync, createSoundSourceAsync, createMicrophoneSoundSourceAsync, disposeAudioEngine, createAudioEngineAsync, disposeSoundSource, setSoundSourceVolume, playSound, pauseSound, resumeSound, stopSound, disposeSound, setSoundVolume, playStreamingSound, pauseStreamingSound, resumeStreamingSound, stopStreamingSound, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, disposeStreamingSound, setStreamingSoundVolume, startParticleSystem, animateParticleSystem, stopParticleSystem, createParticleBillboard, syncParticleBillboard, parseNodeParticleSetFromSnippet, registerNodeParticleSet } from "@babylonjs/lite";
7
7
  const Epsilon = 1e-3;
8
8
  const ToRadians = Math.PI / 180;
@@ -7057,11 +7057,186 @@ class GlowLayer {
7057
7057
  unsupported("GlowLayer", "Effect layers are not implemented in Babylon Lite. For a bloom-style glow, use the native bloom post-process task.");
7058
7058
  }
7059
7059
  }
7060
+ const GREASED_LINE_REASON = "Greased (thick) lines are a ribbon/tube geometry + dedicated plugin-material subsystem (per-point widths, color/width distribution tables, dashing, camera-facing ribbon modes). Babylon Lite renders only 1px hardware line-lists (MeshBuilder.CreateLines / CreateDashedLines) and has no thick-line ribbon pipeline or plugin material to back it.";
7061
+ class GreasedLineBaseMesh {
7062
+ constructor(..._args) {
7063
+ unsupported("GreasedLineBaseMesh", GREASED_LINE_REASON);
7064
+ }
7065
+ }
7060
7066
  class GreasedLineMesh {
7061
- constructor() {
7062
- unsupported("GreasedLineMesh", "Greased-line meshes are not implemented in Babylon Lite.");
7067
+ constructor(..._args) {
7068
+ unsupported("GreasedLineMesh", GREASED_LINE_REASON);
7069
+ }
7070
+ }
7071
+ class GreasedLineRibbonMesh {
7072
+ constructor(..._args) {
7073
+ unsupported("GreasedLineRibbonMesh", GREASED_LINE_REASON);
7074
+ }
7075
+ }
7076
+ class GreasedLinePluginMaterial {
7077
+ constructor(..._args) {
7078
+ unsupported("GreasedLinePluginMaterial", GREASED_LINE_REASON);
7079
+ }
7080
+ }
7081
+ class MaterialGreasedLineDefines {
7082
+ constructor(..._args) {
7083
+ unsupported("MaterialGreasedLineDefines", GREASED_LINE_REASON);
7084
+ }
7085
+ }
7086
+ class GreasedLineMaterialDefaults {
7087
+ constructor(..._args) {
7088
+ unsupported("GreasedLineMaterialDefaults", GREASED_LINE_REASON);
7089
+ }
7090
+ static get DEFAULT_COLOR() {
7091
+ return unsupported("GreasedLineMaterialDefaults.DEFAULT_COLOR", GREASED_LINE_REASON);
7092
+ }
7093
+ static get DEFAULT_WIDTH_ATTENUATED() {
7094
+ return unsupported("GreasedLineMaterialDefaults.DEFAULT_WIDTH_ATTENUATED", GREASED_LINE_REASON);
7095
+ }
7096
+ static get DEFAULT_WIDTH() {
7097
+ return unsupported("GreasedLineMaterialDefaults.DEFAULT_WIDTH", GREASED_LINE_REASON);
7098
+ }
7099
+ static get EmptyColorsTexture() {
7100
+ return unsupported("GreasedLineMaterialDefaults.EmptyColorsTexture", GREASED_LINE_REASON);
7101
+ }
7102
+ }
7103
+ function RegisterGreasedLinePluginMaterial(..._args) {
7104
+ return unsupported("RegisterGreasedLinePluginMaterial", GREASED_LINE_REASON);
7105
+ }
7106
+ class GreasedLineSimpleMaterial {
7107
+ constructor(..._args) {
7108
+ unsupported("GreasedLineSimpleMaterial", GREASED_LINE_REASON);
7063
7109
  }
7064
7110
  }
7111
+ class GreasedLineTools {
7112
+ constructor(..._args) {
7113
+ unsupported("GreasedLineTools", GREASED_LINE_REASON);
7114
+ }
7115
+ static ConvertPoints(..._args) {
7116
+ return unsupported("GreasedLineTools.ConvertPoints", GREASED_LINE_REASON);
7117
+ }
7118
+ static OmitZeroLengthPredicate(..._args) {
7119
+ return unsupported("GreasedLineTools.OmitZeroLengthPredicate", GREASED_LINE_REASON);
7120
+ }
7121
+ static OmitDuplicatesPredicate(..._args) {
7122
+ return unsupported("GreasedLineTools.OmitDuplicatesPredicate", GREASED_LINE_REASON);
7123
+ }
7124
+ static MeshesToLines(..._args) {
7125
+ return unsupported("GreasedLineTools.MeshesToLines", GREASED_LINE_REASON);
7126
+ }
7127
+ static ToVector3Array(..._args) {
7128
+ return unsupported("GreasedLineTools.ToVector3Array", GREASED_LINE_REASON);
7129
+ }
7130
+ static ToNumberArray(..._args) {
7131
+ return unsupported("GreasedLineTools.ToNumberArray", GREASED_LINE_REASON);
7132
+ }
7133
+ static GetPointsCountInfo(..._args) {
7134
+ return unsupported("GreasedLineTools.GetPointsCountInfo", GREASED_LINE_REASON);
7135
+ }
7136
+ static GetLineLength(..._args) {
7137
+ return unsupported("GreasedLineTools.GetLineLength", GREASED_LINE_REASON);
7138
+ }
7139
+ static GetLineLengthArray(..._args) {
7140
+ return unsupported("GreasedLineTools.GetLineLengthArray", GREASED_LINE_REASON);
7141
+ }
7142
+ static SegmentizeSegmentByCount(..._args) {
7143
+ return unsupported("GreasedLineTools.SegmentizeSegmentByCount", GREASED_LINE_REASON);
7144
+ }
7145
+ static SegmentizeLineBySegmentLength(..._args) {
7146
+ return unsupported("GreasedLineTools.SegmentizeLineBySegmentLength", GREASED_LINE_REASON);
7147
+ }
7148
+ static SegmentizeLineBySegmentCount(..._args) {
7149
+ return unsupported("GreasedLineTools.SegmentizeLineBySegmentCount", GREASED_LINE_REASON);
7150
+ }
7151
+ static GetLineSegments(..._args) {
7152
+ return unsupported("GreasedLineTools.GetLineSegments", GREASED_LINE_REASON);
7153
+ }
7154
+ static GetMinMaxSegmentLength(..._args) {
7155
+ return unsupported("GreasedLineTools.GetMinMaxSegmentLength", GREASED_LINE_REASON);
7156
+ }
7157
+ static GetPositionOnLineByVisibility(..._args) {
7158
+ return unsupported("GreasedLineTools.GetPositionOnLineByVisibility", GREASED_LINE_REASON);
7159
+ }
7160
+ static GetCircleLinePoints(..._args) {
7161
+ return unsupported("GreasedLineTools.GetCircleLinePoints", GREASED_LINE_REASON);
7162
+ }
7163
+ static GetBezierLinePoints(..._args) {
7164
+ return unsupported("GreasedLineTools.GetBezierLinePoints", GREASED_LINE_REASON);
7165
+ }
7166
+ static GetArrowCap(..._args) {
7167
+ return unsupported("GreasedLineTools.GetArrowCap", GREASED_LINE_REASON);
7168
+ }
7169
+ static GetPointsFromText(..._args) {
7170
+ return unsupported("GreasedLineTools.GetPointsFromText", GREASED_LINE_REASON);
7171
+ }
7172
+ static Color3toRGBAUint8(..._args) {
7173
+ return unsupported("GreasedLineTools.Color3toRGBAUint8", GREASED_LINE_REASON);
7174
+ }
7175
+ static CreateColorsTexture(..._args) {
7176
+ return unsupported("GreasedLineTools.CreateColorsTexture", GREASED_LINE_REASON);
7177
+ }
7178
+ static PrepareEmptyColorsTexture(..._args) {
7179
+ return unsupported("GreasedLineTools.PrepareEmptyColorsTexture", GREASED_LINE_REASON);
7180
+ }
7181
+ static DisposeEmptyColorsTexture(..._args) {
7182
+ return unsupported("GreasedLineTools.DisposeEmptyColorsTexture", GREASED_LINE_REASON);
7183
+ }
7184
+ static BooleanToNumber(..._args) {
7185
+ return unsupported("GreasedLineTools.BooleanToNumber", GREASED_LINE_REASON);
7186
+ }
7187
+ }
7188
+ function CreateGreasedLine(..._args) {
7189
+ return unsupported("CreateGreasedLine", GREASED_LINE_REASON);
7190
+ }
7191
+ function CreateGreasedLineMaterial(..._args) {
7192
+ return unsupported("CreateGreasedLineMaterial", GREASED_LINE_REASON);
7193
+ }
7194
+ function GetPointsCount(..._args) {
7195
+ return unsupported("GetPointsCount", GREASED_LINE_REASON);
7196
+ }
7197
+ function CompleteGreasedLineWidthTable(..._args) {
7198
+ return unsupported("CompleteGreasedLineWidthTable", GREASED_LINE_REASON);
7199
+ }
7200
+ function CompleteGreasedLineColorTable(..._args) {
7201
+ return unsupported("CompleteGreasedLineColorTable", GREASED_LINE_REASON);
7202
+ }
7203
+ var GreasedLineMeshColorDistribution = /* @__PURE__ */ ((GreasedLineMeshColorDistribution2) => {
7204
+ GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_NONE"] = 0] = "COLOR_DISTRIBUTION_NONE";
7205
+ GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_REPEAT"] = 1] = "COLOR_DISTRIBUTION_REPEAT";
7206
+ GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_EVEN"] = 2] = "COLOR_DISTRIBUTION_EVEN";
7207
+ GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_START"] = 3] = "COLOR_DISTRIBUTION_START";
7208
+ GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_END"] = 4] = "COLOR_DISTRIBUTION_END";
7209
+ GreasedLineMeshColorDistribution2[GreasedLineMeshColorDistribution2["COLOR_DISTRIBUTION_START_END"] = 5] = "COLOR_DISTRIBUTION_START_END";
7210
+ return GreasedLineMeshColorDistribution2;
7211
+ })(GreasedLineMeshColorDistribution || {});
7212
+ var GreasedLineMeshWidthDistribution = /* @__PURE__ */ ((GreasedLineMeshWidthDistribution2) => {
7213
+ GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_NONE"] = 0] = "WIDTH_DISTRIBUTION_NONE";
7214
+ GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_REPEAT"] = 1] = "WIDTH_DISTRIBUTION_REPEAT";
7215
+ GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_EVEN"] = 2] = "WIDTH_DISTRIBUTION_EVEN";
7216
+ GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_START"] = 3] = "WIDTH_DISTRIBUTION_START";
7217
+ GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_END"] = 4] = "WIDTH_DISTRIBUTION_END";
7218
+ GreasedLineMeshWidthDistribution2[GreasedLineMeshWidthDistribution2["WIDTH_DISTRIBUTION_START_END"] = 5] = "WIDTH_DISTRIBUTION_START_END";
7219
+ return GreasedLineMeshWidthDistribution2;
7220
+ })(GreasedLineMeshWidthDistribution || {});
7221
+ var GreasedLineRibbonPointsMode = /* @__PURE__ */ ((GreasedLineRibbonPointsMode2) => {
7222
+ GreasedLineRibbonPointsMode2[GreasedLineRibbonPointsMode2["POINTS_MODE_POINTS"] = 0] = "POINTS_MODE_POINTS";
7223
+ GreasedLineRibbonPointsMode2[GreasedLineRibbonPointsMode2["POINTS_MODE_PATHS"] = 1] = "POINTS_MODE_PATHS";
7224
+ return GreasedLineRibbonPointsMode2;
7225
+ })(GreasedLineRibbonPointsMode || {});
7226
+ var GreasedLineRibbonFacesMode = /* @__PURE__ */ ((GreasedLineRibbonFacesMode2) => {
7227
+ GreasedLineRibbonFacesMode2[GreasedLineRibbonFacesMode2["FACES_MODE_SINGLE_SIDED"] = 0] = "FACES_MODE_SINGLE_SIDED";
7228
+ GreasedLineRibbonFacesMode2[GreasedLineRibbonFacesMode2["FACES_MODE_SINGLE_SIDED_NO_BACKFACE_CULLING"] = 1] = "FACES_MODE_SINGLE_SIDED_NO_BACKFACE_CULLING";
7229
+ GreasedLineRibbonFacesMode2[GreasedLineRibbonFacesMode2["FACES_MODE_DOUBLE_SIDED"] = 2] = "FACES_MODE_DOUBLE_SIDED";
7230
+ return GreasedLineRibbonFacesMode2;
7231
+ })(GreasedLineRibbonFacesMode || {});
7232
+ var GreasedLineRibbonAutoDirectionMode = /* @__PURE__ */ ((GreasedLineRibbonAutoDirectionMode2) => {
7233
+ GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_FROM_FIRST_SEGMENT"] = 0] = "AUTO_DIRECTIONS_FROM_FIRST_SEGMENT";
7234
+ GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_FROM_ALL_SEGMENTS"] = 1] = "AUTO_DIRECTIONS_FROM_ALL_SEGMENTS";
7235
+ GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_ENHANCED"] = 2] = "AUTO_DIRECTIONS_ENHANCED";
7236
+ GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_FACE_TO"] = 3] = "AUTO_DIRECTIONS_FACE_TO";
7237
+ GreasedLineRibbonAutoDirectionMode2[GreasedLineRibbonAutoDirectionMode2["AUTO_DIRECTIONS_NONE"] = 99] = "AUTO_DIRECTIONS_NONE";
7238
+ return GreasedLineRibbonAutoDirectionMode2;
7239
+ })(GreasedLineRibbonAutoDirectionMode || {});
7065
7240
  class EdgesRenderer {
7066
7241
  constructor() {
7067
7242
  unsupported("EdgesRenderer", "Edge rendering is not implemented in Babylon Lite.");
@@ -7113,6 +7288,26 @@ function InstallHtmlInCanvasPolyfill() {
7113
7288
  function UninstallHtmlInCanvasPolyfill() {
7114
7289
  return unsupported("UninstallHtmlInCanvasPolyfill", "The HTML-in-canvas polyfill is not supported by Babylon Lite.");
7115
7290
  }
7291
+ class GaussianSplattingStream {
7292
+ constructor(..._args) {
7293
+ unsupported(
7294
+ "GaussianSplattingStream",
7295
+ "Gaussian-Splatting LOD streaming is a whole GPU subsystem (SOG-octree LOD residency + work-buffer decode into render-target atlases) with no Babylon Lite equivalent. Load the full cloud with `GaussianSplattingMesh` / `loadSplat` instead."
7296
+ );
7297
+ }
7298
+ }
7299
+ function AddGaussianSplattingStreamPart(..._args) {
7300
+ return unsupported(
7301
+ "AddGaussianSplattingStreamPart",
7302
+ "Gaussian-Splatting LOD streaming (compound mesh + streamed parts) is not backed by Babylon Lite, which loads a whole splat cloud eagerly via `GaussianSplattingMesh`."
7303
+ );
7304
+ }
7305
+ function AddGaussianSplattingStreamPartAsync(..._args) {
7306
+ return unsupported(
7307
+ "AddGaussianSplattingStreamPartAsync",
7308
+ "Gaussian-Splatting LOD streaming (compound mesh + streamed parts) is not backed by Babylon Lite, which loads a whole splat cloud eagerly via `GaussianSplattingMesh`."
7309
+ );
7310
+ }
7116
7311
  class Sound {
7117
7312
  constructor() {
7118
7313
  unsupported("Sound", "Audio is not part of Babylon Lite. Use the Web Audio API directly.");
@@ -7692,6 +7887,8 @@ export {
7692
7887
  Action,
7693
7888
  ActionManager,
7694
7889
  ActionManagerTriggers,
7890
+ AddGaussianSplattingStreamPart,
7891
+ AddGaussianSplattingStreamPartAsync,
7695
7892
  AmmoJSPlugin,
7696
7893
  AnaglyphArcRotateCamera,
7697
7894
  Angle,
@@ -7742,6 +7939,8 @@ export {
7742
7939
  Color3,
7743
7940
  Color4,
7744
7941
  ColorGradient,
7942
+ CompleteGreasedLineColorTable,
7943
+ CompleteGreasedLineWidthTable,
7745
7944
  ComputeOverlayCssTransform,
7746
7945
  Condition,
7747
7946
  Constants,
@@ -7749,23 +7948,26 @@ export {
7749
7948
  CreateAudioEngineAsync,
7750
7949
  e as CreateBox,
7751
7950
  f as CreateCylinder,
7752
- g as CreateDisc,
7753
- h as CreateGround,
7754
- i as CreateLineSystem,
7755
- j as CreateLines,
7951
+ g as CreateDashedLines,
7952
+ h as CreateDisc,
7953
+ CreateGreasedLine,
7954
+ CreateGreasedLineMaterial,
7955
+ i as CreateGround,
7956
+ j as CreateLineSystem,
7957
+ k as CreateLines,
7756
7958
  CreateMainAudioBusAsync,
7757
7959
  CreateMicrophoneSoundSourceAsync,
7758
- k as CreatePlane,
7960
+ m as CreatePlane,
7759
7961
  CreateSoundAsync,
7760
7962
  CreateSoundBufferAsync,
7761
7963
  CreateSoundSourceAsync,
7762
- m as CreateSphere,
7964
+ n as CreateSphere,
7763
7965
  CreateStreamingSoundAsync,
7764
7966
  CreateTexture2DArrayFromImageUrlsAsync,
7765
7967
  CreateTexture2DArrayFromKTX2Async,
7766
- n as CreateTiledBox,
7767
- o as CreateTiledPlane,
7768
- p as CreateTorus,
7968
+ o as CreateTiledBox,
7969
+ p as CreateTiledPlane,
7970
+ q as CreateTorus,
7769
7971
  CubeTexture,
7770
7972
  CubicEase,
7771
7973
  Curve3,
@@ -7801,13 +8003,26 @@ export {
7801
8003
  GPUPicker,
7802
8004
  GamepadCamera,
7803
8005
  GaussianSplattingMesh,
8006
+ GaussianSplattingStream,
7804
8007
  GeometryBufferRenderer,
7805
8008
  GeospatialCamera,
7806
8009
  GeospatialClippingBehavior,
7807
8010
  GetElementPixelFromUv,
8011
+ GetPointsCount,
7808
8012
  GizmoManager,
7809
8013
  GlowLayer,
8014
+ GreasedLineBaseMesh,
8015
+ GreasedLineMaterialDefaults,
7810
8016
  GreasedLineMesh,
8017
+ GreasedLineMeshColorDistribution,
8018
+ GreasedLineMeshWidthDistribution,
8019
+ GreasedLinePluginMaterial,
8020
+ GreasedLineRibbonAutoDirectionMode,
8021
+ GreasedLineRibbonFacesMode,
8022
+ GreasedLineRibbonMesh,
8023
+ GreasedLineRibbonPointsMode,
8024
+ GreasedLineSimpleMaterial,
8025
+ GreasedLineTools,
7811
8026
  GridMaterial,
7812
8027
  G as GroundMesh,
7813
8028
  HDRCubeTexture,
@@ -7832,16 +8047,17 @@ export {
7832
8047
  Layer,
7833
8048
  Light,
7834
8049
  LightGizmo,
7835
- q as LinesMesh,
8050
+ r as LinesMesh,
7836
8051
  LiteCompatError,
7837
8052
  LoadAssetContainerAsync,
7838
8053
  LoadImageToTexture2DArrayLayerAsync,
7839
8054
  Logger,
7840
8055
  MainAudioBus,
7841
- r as Material,
8056
+ s as Material,
8057
+ MaterialGreasedLineDefines,
7842
8058
  Matrix,
7843
8059
  Mesh,
7844
- s as MeshBuilder,
8060
+ t as MeshBuilder,
7845
8061
  MeshoptCompression,
7846
8062
  MirrorTexture,
7847
8063
  MorphTarget,
@@ -7857,12 +8073,12 @@ export {
7857
8073
  OnAudioEngineV2CreatedObservable,
7858
8074
  OutlineRenderer,
7859
8075
  P as PBRAnisotropicConfiguration,
7860
- t as PBRClearCoatConfiguration,
7861
- v as PBRIridescenceConfiguration,
7862
- w as PBRMaterial,
7863
- x as PBRMetallicRoughnessMaterial,
7864
- y as PBRSheenConfiguration,
7865
- z as PBRSpecularGlossinessMaterial,
8076
+ v as PBRClearCoatConfiguration,
8077
+ w as PBRIridescenceConfiguration,
8078
+ x as PBRMaterial,
8079
+ y as PBRMetallicRoughnessMaterial,
8080
+ z as PBRSheenConfiguration,
8081
+ D as PBRSpecularGlossinessMaterial,
7866
8082
  ParticleHelper,
7867
8083
  ParticleSystem,
7868
8084
  ParticleSystemSet,
@@ -7886,7 +8102,7 @@ export {
7886
8102
  PostProcess,
7887
8103
  PrecisionDate,
7888
8104
  PredicateCondition,
7889
- D as PushMaterial,
8105
+ E as PushMaterial,
7890
8106
  QuadraticEase,
7891
8107
  QuarticEase,
7892
8108
  Quaternion,
@@ -7898,6 +8114,7 @@ export {
7898
8114
  RecastJSPlugin,
7899
8115
  RectAreaLight,
7900
8116
  ReflectionProbe,
8117
+ RegisterGreasedLinePluginMaterial,
7901
8118
  RenderTargetTexture,
7902
8119
  RotationGizmo,
7903
8120
  SSAO2RenderingPipeline,
@@ -7953,18 +8170,18 @@ export {
7953
8170
  UtilityLayerRenderer,
7954
8171
  ValueCondition,
7955
8172
  ValueConditionOperators,
7956
- E as Vector2,
8173
+ F as Vector2,
7957
8174
  Vector3,
7958
- F as Vector4,
7959
- H as VertexBuffer,
7960
- J as VertexData,
8175
+ H as Vector4,
8176
+ J as VertexBuffer,
8177
+ K as VertexData,
7961
8178
  Viewport,
7962
8179
  VirtualJoystick,
7963
8180
  WebGPUEngine,
7964
8181
  WebXRCamera,
7965
8182
  WeightedSound,
7966
- K as transformCoordinates,
7967
- O as transformNormal,
8183
+ O as transformCoordinates,
8184
+ R as transformNormal,
7968
8185
  unsupported
7969
8186
  };
7970
8187
  //# sourceMappingURL=index.js.map