@babylonjs/lite-compat 1.33.0-preview → 1.35.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.js CHANGED
@@ -1,5 +1,5 @@
1
- import { $ as Vector4, A as PBRClearCoatConfiguration, B as Observable, C as RegisterPolygonBuilder, D as registerMeshAtStart, E as VertexData, F as PBRSpecularGlossinessMaterial, G as transformCoordinates, H as BoundingInfo, I as PushMaterial, J as Color3, K as transformNormal, L as StandardMaterial, M as PBRMaterial, N as PBRMetallicRoughnessMaterial, O as Material, P as PBRSheenConfiguration, Q as Vector3, R as attachMaterialToScene, S as PolygonBuilder, T as VertexBuffer, U as BoundingSphere, V as BoundingBox, W as Matrix, X as liteBackedColor3, Y as Color4, Z as Vector2, _ as GroundMesh, a as CreateDisc, b as Mesh, c as CreateLines, d as CreatePolygonVertexData, et as liteBackedVector3, f as CreateSphere, g as ExtrudePolygon, h as CreateTorus, i as CreateDashedLines, j as PBRIridescenceConfiguration, k as PBRAnisotropicConfiguration, l as CreatePlane, m as CreateTiledPlane, n as CreateBox, nt as unsupported, o as CreateGround, p as CreateTiledBox, q as Quaternion, r as CreateCylinder, s as CreateLineSystem, t as AbstractMesh, tt as LiteCompatError, u as CreatePolygon, v as InstancedMesh, w as TransformNode, x as MeshBuilder, y as LinesMesh, z as Node } from "./meshes-BLcUDvXV.js";
2
- import { CharacterSupportedState as CharacterSupportedState$1, MaxTintMagnitude, MinTemperatureKelvin, PhysicsConstraintAxis as PhysicsConstraintAxis$1, PhysicsConstraintType as PhysicsConstraintType$1, PhysicsMotionType as PhysicsMotionType$1, PhysicsPrestepType as PhysicsPrestepType$1, PhysicsShapeType as PhysicsShapeType$1, VERSION, addAnimationGroup, addBillboardSpriteIndex, addClusteredLightContainer, addComputeDispatch, addFacingBillboardSystem, addPolarToRef, addSphericalToRef, addSprite2DIndex, addToScene, animateParticleSystem, applyPhysicsBodyForce, applyPhysicsBodyImpulse, attachAxisDragGizmoToNode, attachAxisScaleGizmoToNode, attachBoundingBoxGizmoToNode, attachCameraGizmoToCamera, attachControl, attachFreeControl, attachGeospatialControls, attachLightGizmoToLight, attachPlaneDragGizmoToNode, attachPlaneRotationGizmoToNode, attachPositionGizmoToNode, attachRotationGizmoToNode, attachScaleGizmoToNode, backEase, bakeCurrentTransformIntoVertices, bezierCurveEase, billboardBlendAdditive, billboardBlendAlpha, bounceEase, calculatePhysicsCharacterMovementToRef, circleEase, clearAnimationManager, clearBoneOverride, clearStorageBuffer, computeStorageBufferBinding, computeUniformBufferBinding, createAnimationManager, createArcRotateCamera, createAudioBusAsync, createAudioEngineAsync, createAxisDragGizmo, createAxisScaleGizmo, createBankedFreeCamera, createBoundingBoxGizmo, createCameraGizmo, createClusteredLightContainer, createClusteredPointLight, createComputeBindingSet, createComputeDispatch, createComputeIndirectDispatch, createComputeShader, createComputeTask, createCsg2FromMesh, createCsgFromMesh, createCsmDirectionalShadowGenerator, createDefaultCamera, createDefaultMeshBlendRadiusDefinitions, createDirectionalLight, createDynamicTexture, createEngine, createEsmDirectionalShadowGenerator, createFacingBillboardSystem, createFreeCamera, createGeospatialCamera, createGpuPicker, createGridMaterial, createHavokWorld, createHemisphericLight, createHtmlTexture, createKhrInteractivityRuntimeValueSnapshot, createLightGizmo, createMeshFromCsg, createMeshesFromCsg2, createMicrophoneSoundSourceAsync, createMorphTargets, createNullEngine, createParticleBillboard, createPcfDirectionalShadowGenerator, createPcfSpotlightShadowGenerator, createPhysicsAggregate, createPhysicsBody, createPhysicsCharacterController, createPhysicsConstraint, createPhysicsShape, createPickingRay, createPlaneDragGizmo, createPlaneRotationGizmo, createPointLight, createPositionGizmo, createPropertyAnimationClip, createPropertyAnimationGroup, createRotationGizmo, createScaleGizmo, createSceneContext, createSoundAsync, createSoundBufferAsync, createSoundSourceAsync, createSpotLight, createSprite2DLayer, createSpriteRenderer, createStorageBuffer, createStreamingSoundAsync, createTexture2DArray, createTexture2DArrayFromKtx2, createTexture2DArrayFromPixels, createTexture2DArrayFromUrls, createTexture2DFromPixels, createTexture3DFromPixels, createTransformNode, createUniformBuffer, createUtilityLayer, csg2Add, csg2Intersect, csg2Subtract, csgIntersect, csgSubtract, csgUnion, cubicEase, disableOrthographicCamera, disposeAudioBus, disposeAudioEngine, disposeAxisDragGizmo, disposeAxisScaleGizmo, disposeBoundingBoxGizmo, disposeCameraGizmo, disposeComputeBindingSet, disposeComputeShader, disposeCsg2, disposeEngine, disposeHtmlTexture, disposeLightGizmo, disposePhysics, disposePicker, disposePlaneDragGizmo, disposePlaneRotationGizmo, disposePositionGizmo, disposeRotationGizmo, disposeScaleGizmo, disposeScene, disposeSound, disposeSoundSource, disposeStorageBuffer, disposeStreamingSound, disposeUniformBuffer, disposeUsd, disposeUtilityLayer, dividePolarToRef, divideSphericalToRef, elasticEase, enableAnalyzer, enableAnimationBlending, enableArcRotateKeyboardControls, enableBoneControlForSkinnedAssets, enableHavokThinInstancePhysicsSync, enableMirroredMeshes, enableOrthographicCamera, enableSpatial, enableStereo, exponentialEase, getBoneByName, getByteFrequencyData, getByteTimeDomainData, getCameraPosition, getFloatFrequencyData, getFloatTimeDomainData, getMasterVolume, getPhysicsBodyAngularVelocity, getPhysicsBodyLinearVelocity, getPickedUV, getProjectionMatrix, getVariantNames, getViewMatrix, getWhiteBalanceMatrix, goToFrame, hasDefaultInteractivityFlowInput, initializeCsg2Async, invertMat4, loadBabylon, loadBasisTexture2D, loadDdsEnvironment, loadEnvironment, loadGltf, loadHdrEnvironment, loadImageToArrayLayer, loadKtxTexture2D, loadSOG, loadSPZ, loadSplat, loadSpriteAtlas, loadTexture2D, loadUsd, markClusteredLightContainerDirty, multiplyMat4, multiplyPolarToRef, multiplySphericalToRef, normalizeInteractivityEventDataConfiguration, normalizeKhrInteractivityRuntimeValue, onBeforeRender, onPhysicsAfterStep, packMeshBlendingTag, parseNodeMaterialFromSnippet, parseNodeParticleSetFromSnippet, pauseAnimation, pauseSound, pauseStreamingSound, physicsRaycast, pickAsync, pickMeshesWithRayPrecise, playAnimation, playSound, playStreamingSound, polarFromVec2ToRef, polarToVec2ToRef, powerEase, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, quadraticEase, quarticEase, quinticEase, readStorageBufferAfterFrame, registerNodeParticleSet, registerScene, registerSceneWithShadowSupport, registerSpriteRenderer, registerUtilityLayer, releasePhysicsConstraint, releasePhysicsShape, removeAnimationGroup, removeFromScene, removePhysicsBody, requestHtmlTextureUpdate, resetVariant, resizeEngine, resolveCameraViewport, resumeSound, resumeStreamingSound, sampleCatmullRomSpline, sampleHermiteSpline, scalePolarToRef, scaleSphericalToRef, selectVariant, setAnimationAdditive, setBonePosition, setBoneRotationQuaternion, setBoneScaling, setBusVolume, setClipPlane, setEngineSize, setFog, setGeospatialOrientation, setMasterVolume, setMorphTargetWeights, setParent, setPhysicsBodyAngularVelocity, setPhysicsBodyLinearVelocity, setPhysicsBodyMassProperties, setPhysicsBodyMotionType, setPhysicsBodyPrestepType, setPhysicsBodyShape, setPhysicsGravity, setPhysicsShapeFilterCollideMask, setPhysicsShapeFilterMembershipMask, setPhysicsShapeIsTrigger, setPhysicsShapeMaterial, setPhysicsTimestep, setPositionGizmoLocalCoordinates, setRotationGizmoLocalCoordinates, setScaleGizmoLocalCoordinates, setShadowTaskCasterMeshes, setSoundSourceVolume, setSoundVolume, setSpatialListener, setSpatialListenerPosition, setSpatialOrientation, setSpatialPosition, setStereoPan, setStreamingSoundVolume, sineEase, sphericalFromVec3ToRef, sphericalToVec3ToRef, spriteBlendAdditive, spriteBlendAlpha, spriteBlendPremultiplied, startEngine, startParticleSystem, stepScene, stopAnimation, stopEngine, stopParticleSystem, stopSound, stopStreamingSound, submitComputeTasks, subtractPolarToRef, subtractSphericalToRef, syncParticleBillboard, temperatureTintToXyz, unlockAudioEngineAsync, unpackMeshBlendingTag, updateAnimationManager, updateBillboardSpriteIndex, updateDynamicTexture, updateHtmlTexture, updateSpatialAudio, updateSprite2DIndex, updateStorageBufferRange, updateTexture2DArrayFromPixels, updateTexture2DFromPixels, updateUniformBuffer, uploadImageToArrayLayer, whenHtmlTextureReady } from "@babylonjs/lite";
1
+ import { $ as Vector4, A as PBRClearCoatConfiguration, B as Observable, C as RegisterPolygonBuilder, D as registerMeshAtStart, E as VertexData, F as PBRSpecularGlossinessMaterial, G as transformCoordinates, H as BoundingInfo, I as PushMaterial, J as Color3, K as transformNormal, L as StandardMaterial, M as PBRMaterial, N as PBRMetallicRoughnessMaterial, O as Material, P as PBRSheenConfiguration, Q as Vector3, R as attachMaterialToScene, S as PolygonBuilder, T as VertexBuffer, U as BoundingSphere, V as BoundingBox, W as Matrix, X as liteBackedColor3, Y as Color4, Z as Vector2, _ as GroundMesh, a as CreateDisc, b as Mesh, c as CreateLines, d as CreatePolygonVertexData, et as liteBackedVector3, f as CreateSphere, g as ExtrudePolygon, h as CreateTorus, i as CreateDashedLines, j as PBRIridescenceConfiguration, k as PBRAnisotropicConfiguration, l as CreatePlane, m as CreateTiledPlane, n as CreateBox, nt as unsupported, o as CreateGround, p as CreateTiledBox, q as Quaternion, r as CreateCylinder, s as CreateLineSystem, t as AbstractMesh, tt as LiteCompatError, u as CreatePolygon, v as InstancedMesh, w as TransformNode, x as MeshBuilder, y as LinesMesh, z as Node } from "./meshes-zeNif9yt.js";
2
+ import { CharacterSupportedState as CharacterSupportedState$1, GAUSSIAN_SPLATTING_MAX_PART_COUNT, MaxTintMagnitude, MinTemperatureKelvin, PhysicsConstraintAxis as PhysicsConstraintAxis$1, PhysicsConstraintType as PhysicsConstraintType$1, PhysicsMotionType as PhysicsMotionType$1, PhysicsPrestepType as PhysicsPrestepType$1, PhysicsShapeType as PhysicsShapeType$1, VERSION, addAnimationGroup, addBillboardSpriteIndex, addClusteredLightContainer, addComputeDispatch, addFacingBillboardSystem, addPolarToRef, addSphericalToRef, addSprite2DIndex, addToScene, animateParticleSystem, applyPhysicsBodyForce, applyPhysicsBodyImpulse, attachAxisDragGizmoToNode, attachAxisScaleGizmoToNode, attachBoundingBoxGizmoToNode, attachCameraGizmoToCamera, attachControl, attachFreeControl, attachGeospatialControls, attachLightGizmoToLight, attachPlaneDragGizmoToNode, attachPlaneRotationGizmoToNode, attachPositionGizmoToNode, attachRotationGizmoToNode, attachScaleGizmoToNode, backEase, bakeCurrentTransformIntoVertices, bezierCurveEase, billboardBlendAdditive, billboardBlendAlpha, bounceEase, calculatePhysicsCharacterMovementToRef, circleEase, clearAnimationManager, clearBoneOverride, clearStorageBuffer, computeStorageBufferBinding, computeUniformBufferBinding, createAnimationManager, createArcRotateCamera, createAudioBusAsync, createAudioEngineAsync, createAxisDragGizmo, createAxisScaleGizmo, createBankedFreeCamera, createBoundingBoxGizmo, createCameraGizmo, createClusteredLightContainer, createClusteredPointLight, createComputeBindingSet, createComputeDispatch, createComputeIndirectDispatch, createComputeShader, createComputeTask, createCsg2FromMesh, createCsgFromMesh, createCsmDirectionalShadowGenerator, createDefaultCamera, createDefaultMeshBlendRadiusDefinitions, createDirectionalLight, createDynamicTexture, createEngine, createEsmDirectionalShadowGenerator, createExternalTexture, createFacingBillboardSystem, createFreeCamera, createGeospatialCamera, createGpuPicker, createGridMaterial, createHavokWorld, createHemisphericLight, createHtmlTexture, createKhrInteractivityRuntimeValueSnapshot, createLightGizmo, createMeshFromCsg, createMeshesFromCsg2, createMicrophoneSoundSourceAsync, createMorphTargets, createNullEngine, createParticleBillboard, createPcfDirectionalShadowGenerator, createPcfSpotlightShadowGenerator, createPhysicsAggregate, createPhysicsBody, createPhysicsCharacterController, createPhysicsConstraint, createPhysicsShape, createPickingRay, createPlaneDragGizmo, createPlaneRotationGizmo, createPointLight, createPositionGizmo, createPropertyAnimationClip, createPropertyAnimationGroup, createRotationGizmo, createScaleGizmo, createSceneContext, createSoundAsync, createSoundBufferAsync, createSoundSourceAsync, createSpotLight, createSprite2DLayer, createSpriteRenderer, createStorageBuffer, createStreamingSoundAsync, createTexture2DArray, createTexture2DArrayFromKtx2, createTexture2DArrayFromPixels, createTexture2DArrayFromUrls, createTexture2DFromPixels, createTexture3DFromPixels, createTransformNode, createUniformBuffer, createUtilityLayer, csg2Add, csg2Intersect, csg2Subtract, csgIntersect, csgSubtract, csgUnion, cubicEase, disableOrthographicCamera, disposeAudioBus, disposeAudioEngine, disposeAxisDragGizmo, disposeAxisScaleGizmo, disposeBoundingBoxGizmo, disposeCameraGizmo, disposeComputeBindingSet, disposeComputeShader, disposeCsg2, disposeEngine, disposeHtmlTexture, disposeLightGizmo, disposePhysics, disposePicker, disposePlaneDragGizmo, disposePlaneRotationGizmo, disposePositionGizmo, disposeRotationGizmo, disposeScaleGizmo, disposeScene, disposeSound, disposeSoundSource, disposeStorageBuffer, disposeStreamingSound, disposeUniformBuffer, disposeUsd, disposeUtilityLayer, dividePolarToRef, divideSphericalToRef, elasticEase, enableAnalyzer, enableAnimationBlending, enableArcRotateKeyboardControls, enableBoneControlForSkinnedAssets, enableHavokThinInstancePhysicsSync, enableMirroredMeshes, enableOrthographicCamera, enableSpatial, enableStereo, encodeIdToColor, exponentialEase, getBoneByName, getByteFrequencyData, getByteTimeDomainData, getCameraPosition, getFloatFrequencyData, getFloatTimeDomainData, getGaussianSplattingMaxPartCount, getGaussianSplattingPartIndexVaryingDeclaration, getMasterVolume, getPhysicsBodyAngularVelocity, getPhysicsBodyLinearVelocity, getPickedUV, getProjectionMatrix, getVariantNames, getViewMatrix, getWhiteBalanceMatrix, goToFrame, hasDefaultInteractivityFlowInput, initializeCsg2Async, invertMat4, isExternalTextureReady, loadBabylon, loadBasisTexture2D, loadDdsEnvironment, loadEnvironment, loadGltf, loadHdrEnvironment, loadImageToArrayLayer, loadKtxTexture2D, loadSOG, loadSPZ, loadSplat, loadSpriteAtlas, loadTexture2D, loadUsd, markClusteredLightContainerDirty, multiplyMat4, multiplyPolarToRef, multiplySphericalToRef, normalizeInteractivityEventDataConfiguration, normalizeKhrInteractivityRuntimeValue, onBeforeRender, onEngineDeviceLost, onPhysicsAfterStep, packMeshBlendingTag, parseNodeMaterialFromSnippet, parseNodeParticleSetFromSnippet, pauseAnimation, pauseSound, pauseStreamingSound, physicsRaycast, pickAsync, pickMeshesWithRayPrecise, playAnimation, playSound, playStreamingSound, polarFromVec2ToRef, polarToVec2ToRef, powerEase, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, quadraticEase, quarticEase, quinticEase, readStorageBufferAfterFrame, registerNodeParticleSet, registerScene, registerSceneWithShadowSupport, registerSpriteRenderer, registerUtilityLayer, releasePhysicsConstraint, releasePhysicsShape, removeAnimationGroup, removeFromScene, removePhysicsBody, requestHtmlTextureUpdate, resetVariant, resizeEngine, resolveCameraViewport, resumeSound, resumeStreamingSound, sampleCatmullRomSpline, sampleHermiteSpline, scalePolarToRef, scaleSphericalToRef, selectVariant, setAnimationAdditive, setBonePosition, setBoneRotationQuaternion, setBoneScaling, setBusVolume, setClipPlane, setEngineSize, setFog, setGeospatialOrientation, setMasterVolume, setMorphTargetWeights, setParent, setPhysicsBodyAngularVelocity, setPhysicsBodyLinearVelocity, setPhysicsBodyMassProperties, setPhysicsBodyMotionType, setPhysicsBodyPrestepType, setPhysicsBodyShape, setPhysicsGravity, setPhysicsShapeFilterCollideMask, setPhysicsShapeFilterMembershipMask, setPhysicsShapeIsTrigger, setPhysicsShapeMaterial, setPhysicsTimestep, setPositionGizmoLocalCoordinates, setRotationGizmoLocalCoordinates, setScaleGizmoLocalCoordinates, setShadowTaskCasterMeshes, setSoundSourceVolume, setSoundVolume, setSpatialListener, setSpatialListenerPosition, setSpatialOrientation, setSpatialPosition, setStereoPan, setStreamingSoundVolume, sineEase, sphericalFromVec3ToRef, sphericalToVec3ToRef, spriteBlendAdditive, spriteBlendAlpha, spriteBlendPremultiplied, startEngine, startParticleSystem, stepScene, stopAnimation, stopEngine, stopParticleSystem, stopSound, stopStreamingSound, submitComputeTasks, subtractPolarToRef, subtractSphericalToRef, syncParticleBillboard, temperatureTintToXyz, unlockAudioEngineAsync, unpackMeshBlendingTag, updateAnimationManager, updateBillboardSpriteIndex, updateDynamicTexture, updateHtmlTexture, updateSpatialAudio, updateSprite2DIndex, updateStorageBufferRange, updateTexture2DArrayFromPixels, updateTexture2DFromPixels, updateUniformBuffer, uploadImageToArrayLayer, whenHtmlTextureReady } from "@babylonjs/lite";
3
3
  //#region \0rolldown/runtime.js
4
4
  var __defProp = Object.defineProperty;
5
5
  var __exportAll = (all, no_symbols) => {
@@ -903,6 +903,12 @@ var AbstractEngine = class {
903
903
  useReverseDepthBuffer = false;
904
904
  /** Babylon.js `engine.onResizeObservable` — fires after `resize()` / `setSize()`. */
905
905
  onResizeObservable = new Observable();
906
+ /** Babylon.js context-loss signal, forwarded from Lite's device-loss subscription. */
907
+ onContextLostObservable = new Observable();
908
+ /** Babylon.js context-restored signal. Lite does not expose a completed-recovery event, so this remains shape-only. */
909
+ onContextRestoredObservable = new Observable();
910
+ /** @internal Device-loss unsubscriber installed by `initAsync`. */
911
+ _unsubscribeDeviceLost = null;
906
912
  /** @internal Babylon.js hardware-scaling level. Babylon Lite manages device-pixel-ratio itself; stored for parity. */
907
913
  _hardwareScalingLevel = 1;
908
914
  /** @internal Latest per-frame delta in ms, updated by each scene's before-render hook. */
@@ -928,8 +934,11 @@ var AbstractEngine = class {
928
934
  this._canvas = canvas;
929
935
  const opts = typeof options === "object" ? { ...options } : options === false ? { msaaSamples: 1 } : void 0;
930
936
  if (opts) {
937
+ if (opts.canvasToneMapping !== void 0 || opts.canvasColorSpace !== void 0) unsupported("WebGPUEngineOptions.canvasToneMapping/canvasColorSpace", "Supporting WebGPU canvas presentation options requires changing Lite's existing surface configuration hot path; it cannot be added as an independently tree-shakeable compat capability.");
931
938
  const antialias = opts.antialias;
932
939
  delete opts.antialias;
940
+ delete opts.canvasToneMapping;
941
+ delete opts.canvasColorSpace;
933
942
  if (antialias === false) opts.msaaSamples = 1;
934
943
  }
935
944
  if (opts?.useLargeWorldRendering) {
@@ -943,6 +952,7 @@ var AbstractEngine = class {
943
952
  async initAsync() {
944
953
  if (this._initialized) return;
945
954
  this._lite = await createEngine(this._canvas, this._options);
955
+ this._unsubscribeDeviceLost = onEngineDeviceLost(this._lite, () => this.onContextLostObservable.notifyObservers(this));
946
956
  this._initialized = true;
947
957
  }
948
958
  getRenderingCanvas() {
@@ -1105,6 +1115,8 @@ var AbstractEngine = class {
1105
1115
  cancelAnimationFrame(this._rafId);
1106
1116
  this._rafId = null;
1107
1117
  }
1118
+ this._unsubscribeDeviceLost?.();
1119
+ this._unsubscribeDeviceLost = null;
1108
1120
  if (this._initialized) disposeEngine(this._lite);
1109
1121
  }
1110
1122
  /** Babylon.js manual frame-pump entry point — unsupported (Lite's frame graph owns the frame). */
@@ -4808,6 +4820,11 @@ var Scene = class Scene extends AbstractScene {
4808
4820
  _registerShadowGenerator(gen) {
4809
4821
  this._shadowGenerators.push(gen);
4810
4822
  }
4823
+ /** @internal Drop a disposed compat `ShadowGenerator` from the pending/build list. */
4824
+ _unregisterShadowGenerator(gen) {
4825
+ const index = this._shadowGenerators.indexOf(gen);
4826
+ if (index !== -1) this._shadowGenerators.splice(index, 1);
4827
+ }
4811
4828
  /** @internal Track an async texture load so the engine can await it before building the scene. */
4812
4829
  _trackTextureLoad(promise) {
4813
4830
  this._pendingTextures.push(promise);
@@ -5482,6 +5499,11 @@ var Light = class extends Node {
5482
5499
  * with the container module.
5483
5500
  */
5484
5501
  _clusteredContainer = null;
5502
+ /**
5503
+ * @internal The compat shadow generator logically owned by this light,
5504
+ * including before its deferred Lite generator is built.
5505
+ */
5506
+ _shadowGenerator = null;
5485
5507
  constructor(name, scene) {
5486
5508
  super(name, scene);
5487
5509
  scene?._registerLight(this);
@@ -5773,21 +5795,25 @@ var SpotLight = class extends Light {
5773
5795
  * per-mesh light path; this wrapper mirrors that shape and forwards the feature
5774
5796
  * work to Lite — the clustering math lives entirely in Lite.
5775
5797
  *
5776
- * Scope (⚡ partial): Babylon Lite clusters **point lights only**, so
5777
- * {@link ClusteredLightContainer.IsLightSupported} accepts a compat `PointLight`
5778
- * and rejects everything else (Babylon.js additionally clusters spot lights).
5779
- * Each added light is snapshotted into a Lite `ClusteredPointLight` at add time;
5798
+ * Scope (⚡ partial): Babylon Lite's clustered spot payload cannot represent
5799
+ * Babylon.js exponent / inner-cone falloff, so only point lights are accepted.
5800
+ * Each added point light is snapshotted into a Lite clustered light at add time;
5780
5801
  * later in-place mutation of the source light does not propagate. `maxRange` is a
5781
5802
  * clustering optimisation Babylon Lite manages internally, so the property is
5782
5803
  * stored for shape parity but does not re-bin lights.
5783
5804
  */
5784
5805
  /** The numeric light type id Babylon.js reports for a clustered container (`LIGHTTYPEID_CLUSTERED_CONTAINER`). */
5785
5806
  var LIGHTTYPEID_CLUSTERED_CONTAINER = 5;
5807
+ function isSupportedPointLight(light) {
5808
+ if (!(light instanceof PointLight)) return false;
5809
+ if (light.getScene()?.getEngine()._headless) return false;
5810
+ return light._shadowGenerator === null && light._lite.shadowGenerator === void 0;
5811
+ }
5786
5812
  /**
5787
5813
  * Babylon.js `ClusteredLightContainer` — a `Light` that renders a large set of
5788
5814
  * point lights through a clustered / forward+ system.
5789
5815
  */
5790
- var ClusteredLightContainer = class ClusteredLightContainer extends Light {
5816
+ var ClusteredLightContainer = class extends Light {
5791
5817
  /**
5792
5818
  * @internal The underlying Babylon Lite clustered light container. The base
5793
5819
  * `Light._lite` is typed as `LightBase`, but a clustered container is a distinct
@@ -5809,17 +5835,16 @@ var ClusteredLightContainer = class ClusteredLightContainer extends Light {
5809
5835
  _maxRange = 16383;
5810
5836
  _selfIntensity = 1;
5811
5837
  /**
5812
- * True if a point/spot light can be clustered by this container. Babylon Lite
5813
- * clusters point lights only.
5838
+ * True if this point light can be represented by Lite's clustered payload.
5814
5839
  */
5815
5840
  static IsLightSupported(light) {
5816
- return light instanceof PointLight;
5841
+ return isSupportedPointLight(light);
5817
5842
  }
5818
5843
  /**
5819
5844
  * Creates a new clustered light container.
5820
5845
  *
5821
5846
  * @param name - The container's node name.
5822
- * @param lights - Initial lights to cluster (point lights).
5847
+ * @param lights - Initial point lights to cluster.
5823
5848
  * @param scene - Owning scene; when supplied the container is registered and
5824
5849
  * built into the Lite scene at engine start.
5825
5850
  */
@@ -5838,7 +5863,7 @@ var ClusteredLightContainer = class ClusteredLightContainer extends Light {
5838
5863
  }
5839
5864
  /** True when clustered lighting is available (Babylon Lite backs it on WebGPU). */
5840
5865
  get isSupported() {
5841
- return true;
5866
+ return !this._scene?.getEngine()._headless;
5842
5867
  }
5843
5868
  /** The lights added to this clustering system. */
5844
5869
  get lights() {
@@ -5879,33 +5904,33 @@ var ClusteredLightContainer = class ClusteredLightContainer extends Light {
5879
5904
  set maxRange(value) {
5880
5905
  this._maxRange = value;
5881
5906
  }
5882
- /** Babylon.js `container.addLight(light)`. Only point lights are clustered. */
5907
+ /** Babylon.js `container.addLight(light)`. */
5883
5908
  addLight(light) {
5884
- if (!ClusteredLightContainer.IsLightSupported(light) || light._clusteredContainer) return;
5885
- const point = light;
5909
+ if (!isSupportedPointLight(light) || light._clusteredContainer) return;
5910
+ if (this._built) unsupported("ClusteredLightContainer.addLight after engine start", "Lite bakes clustered-light capacity and layout into GPU state; dynamic growth needs a Lite-owned rebuild lifecycle.");
5886
5911
  light._clusteredContainer = this;
5887
- const pos = point.position;
5888
- const diffuse = point.diffuse;
5912
+ const position = light.position;
5913
+ const diffuse = light.diffuse;
5889
5914
  const liteLight = createClusteredPointLight(this._container, {
5890
5915
  position: [
5891
- pos.x,
5892
- pos.y,
5893
- pos.z
5916
+ position.x,
5917
+ position.y,
5918
+ position.z
5894
5919
  ],
5895
5920
  diffuse: [
5896
5921
  diffuse.r,
5897
5922
  diffuse.g,
5898
5923
  diffuse.b
5899
5924
  ],
5900
- range: point.range,
5901
- intensity: point.intensity
5925
+ range: light.range,
5926
+ intensity: light.intensity
5902
5927
  });
5903
- this._childLights.push(point);
5928
+ this._childLights.push(light);
5904
5929
  this._liteLights.push(liteLight);
5905
- const lightScene = point.getScene();
5930
+ const lightScene = light.getScene();
5906
5931
  if (lightScene) {
5907
- lightScene._unregisterNode(point);
5908
- removeFromScene(lightScene._lite, point._lite);
5932
+ lightScene._unregisterNode(light);
5933
+ removeFromScene(lightScene._lite, light._lite);
5909
5934
  }
5910
5935
  this._markDirty();
5911
5936
  }
@@ -5914,19 +5939,17 @@ var ClusteredLightContainer = class ClusteredLightContainer extends Light {
5914
5939
  * in the container's light list, or `-1` if it was not present.
5915
5940
  */
5916
5941
  removeLight(light) {
5917
- const index = this._childLights.indexOf(light);
5942
+ const index = this._childLights.findIndex((child) => child === light);
5918
5943
  if (index === -1) return -1;
5919
5944
  this._childLights.splice(index, 1);
5920
5945
  const liteLight = this._liteLights.splice(index, 1)[0];
5921
- const pool = this._container.pointLights;
5922
- const j = liteLight ? pool.indexOf(liteLight) : -1;
5923
- if (j !== -1) pool.splice(j, 1);
5946
+ const j = liteLight ? this._container.pointLights.indexOf(liteLight) : -1;
5947
+ if (j !== -1) this._container.pointLights.splice(j, 1);
5924
5948
  light._clusteredContainer = null;
5925
- const point = light;
5926
- const lightScene = point.getScene();
5949
+ const lightScene = light.getScene();
5927
5950
  if (lightScene) {
5928
- lightScene._registerLight(point);
5929
- addToScene(lightScene._lite, point._lite);
5951
+ lightScene._registerLight(light);
5952
+ addToScene(lightScene._lite, light._lite);
5930
5953
  }
5931
5954
  this._markDirty();
5932
5955
  return index;
@@ -6311,6 +6334,10 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
6311
6334
  get _xform() {
6312
6335
  return this._gs?.parent === this._node ? this._node : this._gs ?? this._node;
6313
6336
  }
6337
+ /** @internal Accessibility metadata belongs to the loaded cloud, or its placeholder before loading. */
6338
+ _accessibilitySource() {
6339
+ return this._gs ?? this._node;
6340
+ }
6314
6341
  get position() {
6315
6342
  return liteBackedVector3(this._xform.position);
6316
6343
  }
@@ -6353,10 +6380,12 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
6353
6380
  */
6354
6381
  _adopt(lite) {
6355
6382
  const placeholder = this._node;
6383
+ const previousAccessibilitySource = this._accessibilitySource();
6356
6384
  lite.parent = placeholder;
6357
6385
  placeholder.children.push(lite);
6358
6386
  lite.name = this.name;
6359
6387
  this._gs = lite;
6388
+ this._syncAccessibilityTag(previousAccessibilitySource);
6360
6389
  this._scene?._registerMesh(this);
6361
6390
  }
6362
6391
  /** @internal Wrap an already-loaded Lite splat node (used by the loader's `ImportMeshAsync` path). */
@@ -7033,6 +7062,36 @@ var RenderTargetTexture = class {
7033
7062
  }
7034
7063
  };
7035
7064
  //#endregion
7065
+ //#region src/textures/external-texture.ts
7066
+ var nextUniqueId = 0;
7067
+ /** Babylon.js `ExternalTexture` over Lite's caller-owned video wrapper. */
7068
+ var ExternalTexture = class {
7069
+ _video;
7070
+ /** @internal Underlying Lite external texture. */
7071
+ _lite;
7072
+ useMipMaps = false;
7073
+ type = 16;
7074
+ format = 4294967295;
7075
+ uniqueId = nextUniqueId++;
7076
+ static IsExternalTexture(texture) {
7077
+ return !!texture && typeof texture === "object" && texture.underlyingResource !== void 0;
7078
+ }
7079
+ constructor(_video) {
7080
+ this._video = _video;
7081
+ this._lite = createExternalTexture(_video);
7082
+ }
7083
+ getClassName() {
7084
+ return "ExternalTexture";
7085
+ }
7086
+ get underlyingResource() {
7087
+ return this._video;
7088
+ }
7089
+ isReady() {
7090
+ return isExternalTextureReady(this._lite);
7091
+ }
7092
+ dispose() {}
7093
+ };
7094
+ //#endregion
7036
7095
  //#region src/textures/raw-texture-2d-array.ts
7037
7096
  /**
7038
7097
  * Babylon.js-compatible 2D **texture array** wrappers over Babylon Lite's
@@ -9197,6 +9256,7 @@ var ShadowGenerator = class {
9197
9256
  constructor(mapSize, light) {
9198
9257
  this._mapSize = mapSize;
9199
9258
  this._light = light;
9259
+ light._shadowGenerator = this;
9200
9260
  const scene = light.getScene();
9201
9261
  if (scene) {
9202
9262
  scene._registerShadowGenerator(this);
@@ -9294,12 +9354,14 @@ var ShadowGenerator = class {
9294
9354
  }
9295
9355
  dispose() {
9296
9356
  this._disposeBeforeRenderFlush?.();
9357
+ this._light.getScene()?._unregisterShadowGenerator(this);
9297
9358
  for (const { caster, observer } of this._casterDisposeObservers.values()) caster.onDisposeObservable.remove(observer);
9298
9359
  this._casterDisposeObservers.clear();
9299
9360
  this._casterSyncScheduled = false;
9300
9361
  this._casterSyncDirty = false;
9301
9362
  this._liteGen = void 0;
9302
9363
  this._light._lite.shadowGenerator = void 0;
9364
+ if (this._light._shadowGenerator === this) this._light._shadowGenerator = null;
9303
9365
  }
9304
9366
  /**
9305
9367
  * @internal Build the underlying Lite shadow generator and wire casters. Called
@@ -11208,7 +11270,9 @@ var MaterialPluginBase = class MaterialPluginBase {
11208
11270
  this._priority = priority;
11209
11271
  this.resolveIncludes = resolveIncludes;
11210
11272
  this._pluginDefineNames = defines;
11211
- this._pluginManager = material.pluginManager ??= new MaterialPluginManager(material);
11273
+ const pluginManager = material.pluginManager ?? new MaterialPluginManager(material);
11274
+ if (addToPluginList || this._attachToLite) material.pluginManager ??= pluginManager;
11275
+ this._pluginManager = pluginManager;
11212
11276
  this.markAllDefinesAsDirty = () => material._markPluginDefinesDirty();
11213
11277
  this._lite = {
11214
11278
  get name() {
@@ -11375,6 +11439,7 @@ var MaterialPluginBase = class MaterialPluginBase {
11375
11439
  */
11376
11440
  var FLUID_RENDERER_UNSUPPORTED = "Fluid rendering requires dedicated depth, thickness, and diffuse passes plus render-target lifecycle and composition policies that Babylon Lite does not define.";
11377
11441
  var DITHERED_TILE_FADE_UNSUPPORTED = "Lite's material-plugin bridge supports shared shader injection, but not Babylon.js per-draw mesh uniforms, hardware-instance bounds, or custom thin-instance attributes/varyings. Adding those requires an opt-in per-renderable plugin-data design.";
11442
+ var GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED = "Lite's Gaussian-splat renderable fixes shader fragments and render state at load time and exposes no post-load material replacement or pipeline-rebuild lifecycle. Supporting Babylon.js GaussianSplattingMaterial plugins requires an opt-in Lite splat-material lifecycle design.";
11378
11443
  var FLOW_GRAPH_UNSUPPORTED = "Babylon Lite's flow-graph runtime does not expose Babylon.js FlowGraph blocks, connections, or contexts. Validation requires a stable cross-model graph adapter and block registry design.";
11379
11444
  var FlowGraphValidationSeverity = /* @__PURE__ */ function(FlowGraphValidationSeverity) {
11380
11445
  FlowGraphValidationSeverity[FlowGraphValidationSeverity["Error"] = 0] = "Error";
@@ -11532,6 +11597,121 @@ var MultiMaterial = class {
11532
11597
  unsupported("MultiMaterial", "Babylon Lite uses one material per renderable. Split the mesh geometry by material into separate meshes instead.");
11533
11598
  }
11534
11599
  };
11600
+ var GaussianSplattingMaxPartCount = GAUSSIAN_SPLATTING_MAX_PART_COUNT;
11601
+ function GetGaussianSplattingMaxPartCount(engine) {
11602
+ return getGaussianSplattingMaxPartCount(engine._lite);
11603
+ }
11604
+ function GetPartIndexVaryingDeclaration(shaderLanguage) {
11605
+ return getGaussianSplattingPartIndexVaryingDeclaration(shaderLanguage === ShaderLanguage.WGSL);
11606
+ }
11607
+ var GaussianSplattingMaterial = class extends PushMaterial {
11608
+ /** @internal The unsupported material has no Lite backing. */
11609
+ get _lite() {
11610
+ return unsupported("GaussianSplattingMaterial._lite", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11611
+ }
11612
+ constructor(name, scene) {
11613
+ super(name);
11614
+ unsupported("GaussianSplattingMaterial", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11615
+ }
11616
+ clone(_name) {
11617
+ return unsupported("GaussianSplattingMaterial.clone", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11618
+ }
11619
+ };
11620
+ var GaussianSplattingDebugMaterialPlugin = class extends MaterialPluginBase {
11621
+ /** @internal An unsupported plugin must not attach to a Lite material. */
11622
+ get _attachToLite() {
11623
+ return false;
11624
+ }
11625
+ constructor(material) {
11626
+ super(material, "GaussianSplattingDebug", 200, {}, false);
11627
+ unsupported("GaussianSplattingDebugMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11628
+ }
11629
+ };
11630
+ var GaussianSplattingGpuPickingMaterialPlugin = class extends MaterialPluginBase {
11631
+ static EncodeIdToColor(id) {
11632
+ return encodeIdToColor(id);
11633
+ }
11634
+ /** @internal An unsupported plugin must not attach to a Lite material. */
11635
+ get _attachToLite() {
11636
+ return false;
11637
+ }
11638
+ constructor(material, _maxPartCount) {
11639
+ super(material, "GaussianSplatGpuPicking", 230, {}, false);
11640
+ unsupported("GaussianSplattingGpuPickingMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11641
+ }
11642
+ };
11643
+ var GaussianSplattingSolidColorMaterialPlugin = class extends MaterialPluginBase {
11644
+ /** @internal An unsupported plugin must not attach to a Lite material. */
11645
+ get _attachToLite() {
11646
+ return false;
11647
+ }
11648
+ constructor(material, _partColors, _maxPartCount) {
11649
+ super(material, "GaussianSplatSolidColor", 200, {}, false);
11650
+ unsupported("GaussianSplattingSolidColorMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11651
+ }
11652
+ };
11653
+ var GaussianSplattingSizeMaterialPlugin = class extends MaterialPluginBase {
11654
+ /** @internal An unsupported plugin must not attach to a Lite material. */
11655
+ get _attachToLite() {
11656
+ return false;
11657
+ }
11658
+ constructor(material) {
11659
+ super(material, "GaussianSplattingSize", 210, {}, false);
11660
+ unsupported("GaussianSplattingSizeMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11661
+ }
11662
+ get isEnabled() {
11663
+ return unsupported("GaussianSplattingSizeMaterialPlugin.isEnabled", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11664
+ }
11665
+ set isEnabled(_value) {
11666
+ unsupported("GaussianSplattingSizeMaterialPlugin.isEnabled", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11667
+ }
11668
+ get sizeScale() {
11669
+ return unsupported("GaussianSplattingSizeMaterialPlugin.sizeScale", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11670
+ }
11671
+ set sizeScale(_value) {
11672
+ unsupported("GaussianSplattingSizeMaterialPlugin.sizeScale", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11673
+ }
11674
+ };
11675
+ var GaussianSplattingOverdrawMaterialPlugin = class extends MaterialPluginBase {
11676
+ /** @internal An unsupported plugin must not attach to a Lite material. */
11677
+ get _attachToLite() {
11678
+ return false;
11679
+ }
11680
+ constructor(material) {
11681
+ super(material, "GaussianSplattingOverdraw", 220, {}, false);
11682
+ unsupported("GaussianSplattingOverdrawMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11683
+ }
11684
+ get isEnabled() {
11685
+ return unsupported("GaussianSplattingOverdrawMaterialPlugin.isEnabled", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11686
+ }
11687
+ set isEnabled(_value) {
11688
+ unsupported("GaussianSplattingOverdrawMaterialPlugin.isEnabled", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11689
+ }
11690
+ get intensity() {
11691
+ return unsupported("GaussianSplattingOverdrawMaterialPlugin.intensity", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11692
+ }
11693
+ set intensity(_value) {
11694
+ unsupported("GaussianSplattingOverdrawMaterialPlugin.intensity", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11695
+ }
11696
+ };
11697
+ function RegisterGaussianSplattingDebugMaterialPlugin() {
11698
+ unsupported("RegisterGaussianSplattingDebugMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11699
+ }
11700
+ function RegisterGaussianSplattingGpuPickingMaterialPlugin() {
11701
+ unsupported("RegisterGaussianSplattingGpuPickingMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11702
+ }
11703
+ function RegisterGaussianSplattingSolidColorMaterialPlugin() {
11704
+ unsupported("RegisterGaussianSplattingSolidColorMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11705
+ }
11706
+ function RegisterGaussianSplattingSizeMaterialPlugin() {
11707
+ unsupported("RegisterGaussianSplattingSizeMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11708
+ }
11709
+ function RegisterGaussianSplattingOverdrawMaterialPlugin() {
11710
+ unsupported("RegisterGaussianSplattingOverdrawMaterialPlugin", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11711
+ }
11712
+ function RegisterGaussianSplattingMaterial() {
11713
+ unsupported("RegisterGaussianSplattingMaterial", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11714
+ }
11535
11715
  var DitheredTileFadeMaterialPlugin = class DitheredTileFadeMaterialPlugin extends MaterialPluginBase {
11536
11716
  static Name = "DitheredTileFade";
11537
11717
  /** @internal The unsupported constructor must not alter the material or scene. */
@@ -11539,7 +11719,7 @@ var DitheredTileFadeMaterialPlugin = class DitheredTileFadeMaterialPlugin extend
11539
11719
  return false;
11540
11720
  }
11541
11721
  constructor(material) {
11542
- super(material, DitheredTileFadeMaterialPlugin.Name, 190);
11722
+ super(material, DitheredTileFadeMaterialPlugin.Name, 190, {}, false);
11543
11723
  unsupported("DitheredTileFadeMaterialPlugin", DITHERED_TILE_FADE_UNSUPPORTED);
11544
11724
  }
11545
11725
  static GetOrCreate(_material) {
@@ -11590,7 +11770,7 @@ var DitheredTileFadeMaterialPlugin = class DitheredTileFadeMaterialPlugin extend
11590
11770
  };
11591
11771
  var ShaderMaterial = class {
11592
11772
  constructor() {
11593
- unsupported("ShaderMaterial", "Babylon Lite is WGSL-only. Use the native `createShaderMaterial` (WGSL) API; there is no automatic GLSL translation.");
11773
+ unsupported("ShaderMaterial", "Lite accepts standalone WGSL, but Babylon.js ShaderMaterial sources rely on the Effect shader-store/preprocessor dialect (attribute/varying declarations and injected VertexInputs/FragmentInputs); adapting it requires a shader preprocessing subsystem.");
11594
11774
  }
11595
11775
  };
11596
11776
  var BackgroundMaterial = class {
@@ -11882,22 +12062,6 @@ function InstallHtmlInCanvasPolyfill() {
11882
12062
  function UninstallHtmlInCanvasPolyfill() {
11883
12063
  return unsupported("UninstallHtmlInCanvasPolyfill", "The HTML-in-canvas polyfill is not supported by Babylon Lite.");
11884
12064
  }
11885
- var GaussianSplattingStream = class {
11886
- constructor(..._args) {
11887
- unsupported("GaussianSplattingStream", "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.");
11888
- }
11889
- get minimumResidentSplats() {
11890
- return unsupported("GaussianSplattingStream.minimumResidentSplats", "The value is owned by Babylon.js's SOG streaming residency controller; Babylon Lite has no LOD residency subsystem from which to derive it.");
11891
- }
11892
- };
11893
- /** Babylon.js `AddGaussianSplattingStreamPart` — appends a streamed LOD part to a GS compound mesh. */
11894
- function AddGaussianSplattingStreamPart(..._args) {
11895
- return unsupported("AddGaussianSplattingStreamPart", "Gaussian-Splatting LOD streaming (compound mesh + streamed parts) is not backed by Babylon Lite, which loads a whole splat cloud eagerly via `GaussianSplattingMesh`.");
11896
- }
11897
- /** Babylon.js `AddGaussianSplattingStreamPartAsync` — async variant of {@link AddGaussianSplattingStreamPart}. */
11898
- function AddGaussianSplattingStreamPartAsync(..._args) {
11899
- return unsupported("AddGaussianSplattingStreamPartAsync", "Gaussian-Splatting LOD streaming (compound mesh + streamed parts) is not backed by Babylon Lite, which loads a whole splat cloud eagerly via `GaussianSplattingMesh`.");
11900
- }
11901
12065
  var Sound = class {
11902
12066
  constructor() {
11903
12067
  unsupported("Sound", "Audio is not part of Babylon Lite. Use the Web Audio API directly.");
@@ -12232,6 +12396,152 @@ function RegisterGLTFMaterialsCommonExtension() {
12232
12396
  unsupported("GLTF1.RegisterGLTFMaterialsCommonExtension", GLTF1_UNSUPPORTED);
12233
12397
  }
12234
12398
  //#endregion
12399
+ //#region src/meshes/gaussian-splatting-stream.ts
12400
+ var STREAM_BLOCKER = "Lite's native streamer accepts only an HTTP(S) manifest URL and combines selection capacity with a mandatory render cap. Babylon.js constructs synchronously from parsed metadata, applies a distinct SOG coordinate transform, and independently controls render budget, residency, compound hosting, and cancellation. Bridging those lifecycle/policy differences requires a new Lite stream-construction contract.";
12401
+ var COMPOUND_BLOCKER = "Lite streams one independently rendered scene node and has no compound-mesh atlas reservation/proxy lifecycle to adapt.";
12402
+ function unsupportedProxyConstruction(_name) {
12403
+ return unsupported("GaussianSplattingPartProxyMesh", COMPOUND_BLOCKER);
12404
+ }
12405
+ var GaussianSplattingPartProxyMesh = class extends Mesh {
12406
+ compoundSplatMesh;
12407
+ /** @internal */
12408
+ _vertexCount;
12409
+ /** @internal */
12410
+ _splatsDataOffset;
12411
+ /** @internal */
12412
+ _shDataOffset;
12413
+ _partIndex;
12414
+ _visibility = 1;
12415
+ constructor(name, _scene, compoundSplatMesh, partIndex, _boundingInfo, vertexCount, splatsDataOffset, shDataOffset = splatsDataOffset) {
12416
+ super(unsupportedProxyConstruction(name));
12417
+ this.compoundSplatMesh = compoundSplatMesh;
12418
+ this._partIndex = partIndex;
12419
+ this._vertexCount = vertexCount;
12420
+ this._splatsDataOffset = splatsDataOffset;
12421
+ this._shDataOffset = shDataOffset;
12422
+ }
12423
+ get partIndex() {
12424
+ return this._partIndex;
12425
+ }
12426
+ get proxiedMesh() {
12427
+ return this.compoundSplatMesh;
12428
+ }
12429
+ getClassName() {
12430
+ return "GaussianSplattingPartProxyMesh";
12431
+ }
12432
+ get isVisible() {
12433
+ return this._visibility > 0;
12434
+ }
12435
+ set isVisible(value) {
12436
+ this._visibility = value ? 1 : 0;
12437
+ }
12438
+ get visibility() {
12439
+ return this._visibility;
12440
+ }
12441
+ set visibility(value) {
12442
+ this._visibility = Math.max(0, Math.min(1, value));
12443
+ }
12444
+ updateBoundingInfoFromPartData() {
12445
+ return unsupported("GaussianSplattingPartProxyMesh.updateBoundingInfoFromPartData", COMPOUND_BLOCKER);
12446
+ }
12447
+ updateBoundingInfoFromProxiedMesh() {
12448
+ return unsupported("GaussianSplattingPartProxyMesh.updateBoundingInfoFromProxiedMesh", COMPOUND_BLOCKER);
12449
+ }
12450
+ updatePartIndex(_newPartIndex) {
12451
+ return unsupported("GaussianSplattingPartProxyMesh.updatePartIndex", COMPOUND_BLOCKER);
12452
+ }
12453
+ updatePartMetadata(_vertexCount, _splatsDataOffset, _shDataOffset = _splatsDataOffset) {
12454
+ return unsupported("GaussianSplattingPartProxyMesh.updatePartMetadata", COMPOUND_BLOCKER);
12455
+ }
12456
+ };
12457
+ /** Babylon.js `GaussianSplattingStream` exact-shape stub pending a compatible Lite construction contract. */
12458
+ var GaussianSplattingStream = class extends GaussianSplattingMesh {
12459
+ static IsLODMetadata(data) {
12460
+ if (!data || typeof data !== "object") return false;
12461
+ const metadata = data;
12462
+ return typeof metadata.lodLevels === "number" && Array.isArray(metadata.filenames) && !!metadata.tree && typeof metadata.tree === "object";
12463
+ }
12464
+ constructor(name, _metadata, _rootUrl, scene, _options = {}) {
12465
+ super(name, null, scene, false);
12466
+ unsupported("GaussianSplattingStream", STREAM_BLOCKER);
12467
+ }
12468
+ getClassName() {
12469
+ return "GaussianSplattingStream";
12470
+ }
12471
+ isReady(_completeCheck = false) {
12472
+ return unsupported("GaussianSplattingStream.isReady", STREAM_BLOCKER);
12473
+ }
12474
+ get streamingPartProxy() {
12475
+ return unsupported("GaussianSplattingStream.streamingPartProxy", COMPOUND_BLOCKER);
12476
+ }
12477
+ whenPartReadyAsync() {
12478
+ return unsupported("GaussianSplattingStream.whenPartReadyAsync", COMPOUND_BLOCKER);
12479
+ }
12480
+ whenSettledAsync(_stableFrames = 3) {
12481
+ return unsupported("GaussianSplattingStream.whenSettledAsync", STREAM_BLOCKER);
12482
+ }
12483
+ get maxDetailLod() {
12484
+ return unsupported("GaussianSplattingStream.maxDetailLod", STREAM_BLOCKER);
12485
+ }
12486
+ set maxDetailLod(_value) {
12487
+ unsupported("GaussianSplattingStream.maxDetailLod", STREAM_BLOCKER);
12488
+ }
12489
+ get splatBudget() {
12490
+ return unsupported("GaussianSplattingStream.splatBudget", STREAM_BLOCKER);
12491
+ }
12492
+ set splatBudget(_value) {
12493
+ unsupported("GaussianSplattingStream.splatBudget", STREAM_BLOCKER);
12494
+ }
12495
+ get effectiveSplatBudget() {
12496
+ return unsupported("GaussianSplattingStream.effectiveSplatBudget", STREAM_BLOCKER);
12497
+ }
12498
+ get residentSplatBudget() {
12499
+ return unsupported("GaussianSplattingStream.residentSplatBudget", STREAM_BLOCKER);
12500
+ }
12501
+ get minimumResidentSplats() {
12502
+ return unsupported("GaussianSplattingStream.minimumResidentSplats", STREAM_BLOCKER);
12503
+ }
12504
+ get lod0SplatCount() {
12505
+ return unsupported("GaussianSplattingStream.lod0SplatCount", STREAM_BLOCKER);
12506
+ }
12507
+ getBudgetDemand() {
12508
+ return unsupported("GaussianSplattingStream.getBudgetDemand", COMPOUND_BLOCKER);
12509
+ }
12510
+ setBudgetAllocation(_splats) {
12511
+ return unsupported("GaussianSplattingStream.setBudgetAllocation", COMPOUND_BLOCKER);
12512
+ }
12513
+ get maxLodLevel() {
12514
+ return unsupported("GaussianSplattingStream.maxLodLevel", STREAM_BLOCKER);
12515
+ }
12516
+ get frustumCulling() {
12517
+ return unsupported("GaussianSplattingStream.frustumCulling", STREAM_BLOCKER);
12518
+ }
12519
+ set frustumCulling(_value) {
12520
+ unsupported("GaussianSplattingStream.frustumCulling", STREAM_BLOCKER);
12521
+ }
12522
+ get debugDisplay() {
12523
+ return unsupported("GaussianSplattingStream.debugDisplay", STREAM_BLOCKER);
12524
+ }
12525
+ set debugDisplay(_value) {
12526
+ unsupported("GaussianSplattingStream.debugDisplay", STREAM_BLOCKER);
12527
+ }
12528
+ get debugLodSource() {
12529
+ return unsupported("GaussianSplattingStream.debugLodSource", STREAM_BLOCKER);
12530
+ }
12531
+ set debugLodSource(_value) {
12532
+ unsupported("GaussianSplattingStream.debugLodSource", STREAM_BLOCKER);
12533
+ }
12534
+ evaluateOptimalLods(_camera = null) {
12535
+ return unsupported("GaussianSplattingStream.evaluateOptimalLods", STREAM_BLOCKER);
12536
+ }
12537
+ };
12538
+ function AddGaussianSplattingStreamPart(_compound, _name, _metadata, _rootUrl, _options = {}) {
12539
+ return unsupported("AddGaussianSplattingStreamPart", COMPOUND_BLOCKER);
12540
+ }
12541
+ async function AddGaussianSplattingStreamPartAsync(_compound, _name, _metadata, _rootUrl, _options = {}) {
12542
+ unsupported("AddGaussianSplattingStreamPartAsync", COMPOUND_BLOCKER);
12543
+ }
12544
+ //#endregion
12235
12545
  //#region src/unsupported/unsupported-extended.ts
12236
12546
  /**
12237
12547
  * Throwing stubs for additional Babylon.js core/loaders symbols that Babylon
@@ -12278,6 +12588,52 @@ var PostProcess = class {
12278
12588
  unsupported("PostProcess", "Babylon Lite uses frame-graph post-process tasks rather than camera-attached PostProcess objects. Use the native `create*PostProcessTask` APIs.");
12279
12589
  }
12280
12590
  };
12591
+ var Effect = class {
12592
+ constructor() {
12593
+ unsupported("Effect", "Babylon.js Effect owns shader-store lookup, preprocessing, compilation, reflection, and binding; Lite exposes explicit typed WGSL material/render-shader APIs instead.");
12594
+ }
12595
+ isReady() {
12596
+ return unsupported("Effect.isReady", "Lite has no Babylon.js Effect compilation lifecycle.");
12597
+ }
12598
+ getEngine() {
12599
+ return unsupported("Effect.getEngine", "Lite has no Babylon.js Effect object associated with a compat engine.");
12600
+ }
12601
+ getCompilationError() {
12602
+ return unsupported("Effect.getCompilationError", "Lite has no Babylon.js Effect compilation lifecycle or error store.");
12603
+ }
12604
+ setTexture(_channel, _texture) {
12605
+ return unsupported("Effect.setTexture", "Lite binds textures through typed material/render-shader APIs, not an Effect binding table.");
12606
+ }
12607
+ setFloat(_uniformName, _value) {
12608
+ return unsupported("Effect.setFloat", "Lite binds uniforms through typed material/render-shader APIs, not an Effect binding table.");
12609
+ }
12610
+ };
12611
+ var EffectWrapper = class {
12612
+ static ForceGLSL = false;
12613
+ static RegisterShaderCodeProcessing(_effectWrapperName, _customShaderCodeProcessing) {
12614
+ return unsupported("EffectWrapper.RegisterShaderCodeProcessing", "Lite has no Babylon.js Effect shader-store/preprocessor registry to receive custom code-processing hooks.");
12615
+ }
12616
+ constructor(_options) {
12617
+ unsupported("EffectWrapper", "Babylon.js EffectWrapper compiles GLSL/WGSL through the Effect shader-store and preprocessor lifecycle; Lite exposes only explicit WGSL render shaders and has no Effect object to adapt.");
12618
+ }
12619
+ };
12620
+ var FRAME_GRAPH_MODEL_BLOCKER = "Lite exposes standalone frame-graph task factories, but not Babylon.js's FrameGraph handles, task base classes, texture manager, or node-render-graph object model required by this API.";
12621
+ /** Babylon.js 9.29 frame-graph min/max reduction task. */
12622
+ var FrameGraphMinMaxReducerTask = class {
12623
+ constructor(..._args) {
12624
+ unsupported("FrameGraphMinMaxReducerTask", FRAME_GRAPH_MODEL_BLOCKER);
12625
+ }
12626
+ };
12627
+ /** Babylon.js 9.29 node-render-graph min/max reduction block. */
12628
+ var NodeRenderGraphMinMaxReducerBlock = class {
12629
+ constructor(..._args) {
12630
+ unsupported("NodeRenderGraphMinMaxReducerBlock", FRAME_GRAPH_MODEL_BLOCKER);
12631
+ }
12632
+ };
12633
+ /** Babylon.js 9.29 node-render-graph registration function. */
12634
+ function RegisterMinMaxReducerBlock() {
12635
+ return unsupported("RegisterMinMaxReducerBlock", FRAME_GRAPH_MODEL_BLOCKER);
12636
+ }
12281
12637
  function postProcessStub(name, nativeTask) {
12282
12638
  return class {
12283
12639
  constructor() {
@@ -12808,6 +13164,6 @@ var NodeParticleSystemSet = class NodeParticleSystemSet {
12808
13164
  }
12809
13165
  };
12810
13166
  //#endregion
12811
- export { AbstractAssetTask, AbstractAudioAnalyzer, AbstractAudioBus, AbstractAudioNode, AbstractAudioOutNode, AbstractEngine, AbstractMesh, AbstractNamedAudioNode, AbstractScene, AbstractSound, AbstractSoundSource, AbstractSpatialAudio, AbstractSpatialAudioListener, AbstractStereoAudio, Action, ActionManager, ActionManagerTriggers, AddGaussianSplattingStreamPart, AddGaussianSplattingStreamPartAsync, AmmoJSPlugin, AnaglyphArcRotateCamera, Angle, Animatable, Animation, AnimationGroup, AnimationKeyInterpolation, AnimationLoopModes, AnimationTypes, AppendSceneAsync, ArcRotateCamera, AssetContainer, AssetsManager, AttachToBoxBehavior, AudioBus, AudioEngine, AudioEngineV2, AudioParameterRampShape, AutoRotationBehavior, Axis, AxisDragGizmo, AxisScaleGizmo, BVHFileLoader, BackEase, BackgroundMaterial, BallAndSocketConstraint, BaseSixDofDragBehavior, BaseTexture, BezierCurveEase, BlackAndWhitePostProcess, BloomEffect, BlurPostProcess, Bone, BounceEase, BouncingBehavior, BoundingBox, BoundingBoxGizmo, BoundingBoxRenderer, BoundingInfo, BoundingSphere, CSG, CSG2, Camera, CameraGizmo, CannonJSPlugin, CascadedShadowGenerator, CastingResult, CharacterSupportedState, ChromaticAberrationPostProcess, CircleEase, ClusteredLightContainer, Color3, Color4, ColorGradient, CompleteGreasedLineColorTable, CompleteGreasedLineWidthTable, ComputeOverlayCssTransform, ComputeShader, ComputeShaderParse, Condition, Constants, CreateAudioBusAsync, CreateAudioEngineAsync, CreateBox, CreateCylinder, CreateDashedLines, CreateDefaultMeshBlendRadiusDefinitions, CreateDisc, CreateGreasedLine, CreateGreasedLineMaterial, CreateGround, CreateLineSystem, CreateLines, CreateMainAudioBusAsync, CreateMicrophoneSoundSourceAsync, CreatePlane, CreatePolygon, CreatePolygonVertexData, CreateSoundAsync, CreateSoundBufferAsync, CreateSoundSourceAsync, CreateSphere, CreateStreamingSoundAsync, CreateTexture2DArrayFromImageUrlsAsync, CreateTexture2DArrayFromKTX2Async, CreateTiledBox, CreateTiledPlane, CreateTorus, CubeTexture, CubicEase, Curve3, CustomAssetTask, DefaultRenderingPipeline, DepthOfFieldEffect, DepthRenderer, DeviceOrientationCamera, DirectionalLight, DistanceConstraint, DitheredTileFadeMaterialPlugin, DynamicTexture, EASINGMODE_EASEIN, EASINGMODE_EASEINOUT, EASINGMODE_EASEOUT, EasingFunction, EdgesRenderer, EffectLayer, ElasticEase, Engine, Epsilon, ExecuteCodeAction, ExponentialEase, ExtrudePolygon, FBXConstraintBehavior, FBXConstraintSolver, FBXFileLoader, FBXFileLoaderMetadata, FSR1RenderingPipeline, FactorGradient, FadeInOutBehavior, FlowGraphValidationSeverity, FluidRenderer, FluidRendererSceneComponent, FluidRenderingObject, FluidRenderingObjectCustomParticles, FluidRenderingObjectParticleSystem, FluidRenderingTargetRenderer, FlyCamera, FollowBehavior, FollowCamera, FrameGraphMeshBlendingTask, FramingBehavior, FreeCamera, Frustum, FxaaPostProcess, gltf1_exports as GLTF1, gltf2_exports as GLTF2, GPUParticleSystem, GPUPicker, GUID, GamepadCamera, GaussianSplattingMesh, GaussianSplattingStream, GeometryBufferRenderer, GeospatialCamera, GeospatialClippingBehavior, GetElementPixelFromUv, GetPointsCount, GetSupportedSimultaneousLights, GetWhiteBalanceMatrix, GizmoManager, GlowLayer, GreasedLineBaseMesh, GreasedLineMaterialDefaults, GreasedLineMesh, GreasedLineMeshColorDistribution, GreasedLineMeshWidthDistribution, GreasedLinePluginMaterial, GreasedLineRibbonAutoDirectionMode, GreasedLineRibbonFacesMode, GreasedLineRibbonMesh, GreasedLineRibbonPointsMode, GreasedLineSimpleMaterial, GreasedLineTools, GridMaterial, GroundMesh, HDRCubeTexture, HandConstraintBehavior, HavokPlugin, HemisphericLight, HighlightLayer, HingeConstraint, HtmlInteractionManager, HtmlRaycastInteractionManager, HtmlTexture, ImageProcessingConfiguration, ImportMeshAsync, IncrementValueAction, InitializeCSG2Async, InstallHtmlInCanvasPolyfill, InstancedMesh, InterpolatingBehavior, IsHtmlInCanvasSupportedNatively, IsHtmlInCanvasUploadSupported, KHR_materials_variants, LastCreatedAudioEngine, Layer, Light, LightGizmo, LinesMesh, LiteCompatError, LoadAssetContainerAsync, LoadImageToTexture2DArrayLayerAsync, LockConstraint, Logger, MainAudioBus, Material, MaterialGreasedLineDefines, MaterialPluginBase, MaterialPluginManager, Matrix, MaxTintMagnitude, Mesh, MeshBlendDebugMode, MeshBlendDepthType, MeshBlendQuality, MeshBlendingPostProcess, MeshBlendingRadiusClass, MeshBuilder, MeshoptCompression, MinTemperatureKelvin, MirrorTexture, MorphTarget, MorphTargetManager, MultiMaterial, MultiPointerScaleBehavior, Node, NodeMaterial, NodeParticleSystemSet, NodeRenderGraphMeshBlendingPostProcessBlock, NullEngine, OBJFileLoader, Observable, OnAudioEngineV2CreatedObservable, OpenPBRMaterial, OpenPBRMaterialDefines, OpenPBRMaterialLoadingAdapter, OutlineRenderer, PBRAnisotropicConfiguration, PBRClearCoatConfiguration, PBRIridescenceConfiguration, PBRMaterial, PBRMetallicRoughnessMaterial, PBRSheenConfiguration, PBRSpecularGlossinessMaterial, PackMeshBlendingTag, ParticleHelper, ParticleSystem, ParticleSystemSet, Path3D, PerformanceMonitor, Physics6DoFConstraint, Physics6DoFLimit, PhysicsAggregate, PhysicsBody, PhysicsCharacterController, PhysicsConstraint, PhysicsConstraintAxis, PhysicsConstraintType, PhysicsEngine, PhysicsMotionType, PhysicsPrestepType, PhysicsRaycastResult, PhysicsShape, PhysicsShapeType, PickingInfo, Plane, PlaneDragGizmo, PlaneRotationGizmo, PointLight, PointerDragBehavior, PointerEventTypes, PointerInfo, PointsCloudSystem, Polar, PolygonBuilder, PositionGizmo, PostProcess, PowerEase, PrecisionDate, PredicateCondition, PrismaticConstraint, PushMaterial, QuadraticEase, QuarticEase, Quaternion, QuinticEase, RandomGUID, RawTexture, RawTexture2DArray, RawTexture3D, Ray, RecastJSPlugin, RectAreaLight, ReflectionProbe, RegisterAbstractEngineTextureLoaders, RegisterComputeShader, RegisterEnginesExtensionsEngineTexture2DArrayImageSource, RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource, RegisterFluidRenderer, RegisterGreasedLinePluginMaterial, RegisterImageProcessingConfiguration, RegisterMeshBlendingPostProcessBlock, RegisterOpenpbrMaterial, RegisterPolygonBuilder, RegisterSPLATFileLoader, RegisterUSDFileLoader, RenderTargetTexture, RootMotionClip, RootMotionController, RootMotionSource, RotationGizmo, SPLATFileLoader, SSAO2RenderingPipeline, STLFileLoader, Scalar, ScaleGizmo, Scene, SceneLoader, SceneOptimizer, ScenePerformancePriority, SceneSerializer, SetValueAction, ShaderLanguage, ShaderMaterial, ShadowGenerator, SineEase, SixDofDragBehavior, Size, Skeleton, SliderConstraint, SmartArray, SolidParticleSystem, Sound, SoundSource, SoundState, Space, SpatialAudioAttachmentType, Spherical, SpotLight, SpringConstraint, Sprite, SpriteManager, SpriteMap, SpritePackedManager, SpriteRenderer, StandardMaterial, StaticSound, StaticSoundBuffer, StorageBuffer, StreamingSound, StringDictionary, SurfaceMagnetismBehavior, Tags, TargetCamera, TemperatureTintToXyz, Texture, ThinEngine, ThinFSR1SharpenPostProcess, ThinFSR1UpscalePostProcess, ThinMeshBlendingPostProcess, ThinSprite, ToDegrees, ToRadians, Tools, TouchCamera, TransformNode, USDFileLoader, UniformBuffer, UninstallHtmlInCanvasPolyfill, UniversalCamera, UnpackMeshBlendingTag, UploadHtmlElementToTexture, UploadImageToTexture2DArrayLayer, UtilityLayerRenderer, ValidateFlowGraph, ValidateFlowGraphWithBlockList, ValueCondition, ValueConditionOperators, Vector2, Vector3, Vector4, VertexBuffer, VertexData, Viewport, VirtualJoystick, WebGPUEngine, WebXRCamera, WeightedSound, _RegisterUSDLoaderDependencies, registerBuiltInLoaders, transformCoordinates, transformNormal, unsupported };
13167
+ export { AbstractAssetTask, AbstractAudioAnalyzer, AbstractAudioBus, AbstractAudioNode, AbstractAudioOutNode, AbstractEngine, AbstractMesh, AbstractNamedAudioNode, AbstractScene, AbstractSound, AbstractSoundSource, AbstractSpatialAudio, AbstractSpatialAudioListener, AbstractStereoAudio, Action, ActionManager, ActionManagerTriggers, AddGaussianSplattingStreamPart, AddGaussianSplattingStreamPartAsync, AmmoJSPlugin, AnaglyphArcRotateCamera, Angle, Animatable, Animation, AnimationGroup, AnimationKeyInterpolation, AnimationLoopModes, AnimationTypes, AppendSceneAsync, ArcRotateCamera, AssetContainer, AssetsManager, AttachToBoxBehavior, AudioBus, AudioEngine, AudioEngineV2, AudioParameterRampShape, AutoRotationBehavior, Axis, AxisDragGizmo, AxisScaleGizmo, BVHFileLoader, BackEase, BackgroundMaterial, BallAndSocketConstraint, BaseSixDofDragBehavior, BaseTexture, BezierCurveEase, BlackAndWhitePostProcess, BloomEffect, BlurPostProcess, Bone, BounceEase, BouncingBehavior, BoundingBox, BoundingBoxGizmo, BoundingBoxRenderer, BoundingInfo, BoundingSphere, CSG, CSG2, Camera, CameraGizmo, CannonJSPlugin, CascadedShadowGenerator, CastingResult, CharacterSupportedState, ChromaticAberrationPostProcess, CircleEase, ClusteredLightContainer, Color3, Color4, ColorGradient, CompleteGreasedLineColorTable, CompleteGreasedLineWidthTable, ComputeOverlayCssTransform, ComputeShader, ComputeShaderParse, Condition, Constants, CreateAudioBusAsync, CreateAudioEngineAsync, CreateBox, CreateCylinder, CreateDashedLines, CreateDefaultMeshBlendRadiusDefinitions, CreateDisc, CreateGreasedLine, CreateGreasedLineMaterial, CreateGround, CreateLineSystem, CreateLines, CreateMainAudioBusAsync, CreateMicrophoneSoundSourceAsync, CreatePlane, CreatePolygon, CreatePolygonVertexData, CreateSoundAsync, CreateSoundBufferAsync, CreateSoundSourceAsync, CreateSphere, CreateStreamingSoundAsync, CreateTexture2DArrayFromImageUrlsAsync, CreateTexture2DArrayFromKTX2Async, CreateTiledBox, CreateTiledPlane, CreateTorus, CubeTexture, CubicEase, Curve3, CustomAssetTask, DefaultRenderingPipeline, DepthOfFieldEffect, DepthRenderer, DeviceOrientationCamera, DirectionalLight, DistanceConstraint, DitheredTileFadeMaterialPlugin, DynamicTexture, EASINGMODE_EASEIN, EASINGMODE_EASEINOUT, EASINGMODE_EASEOUT, EasingFunction, EdgesRenderer, Effect, EffectLayer, EffectWrapper, ElasticEase, Engine, Epsilon, ExecuteCodeAction, ExponentialEase, ExternalTexture, ExtrudePolygon, FBXConstraintBehavior, FBXConstraintSolver, FBXFileLoader, FBXFileLoaderMetadata, FSR1RenderingPipeline, FactorGradient, FadeInOutBehavior, FlowGraphValidationSeverity, FluidRenderer, FluidRendererSceneComponent, FluidRenderingObject, FluidRenderingObjectCustomParticles, FluidRenderingObjectParticleSystem, FluidRenderingTargetRenderer, FlyCamera, FollowBehavior, FollowCamera, FrameGraphMeshBlendingTask, FrameGraphMinMaxReducerTask, FramingBehavior, FreeCamera, Frustum, FxaaPostProcess, gltf1_exports as GLTF1, gltf2_exports as GLTF2, GPUParticleSystem, GPUPicker, GUID, GamepadCamera, GaussianSplattingDebugMaterialPlugin, GaussianSplattingGpuPickingMaterialPlugin, GaussianSplattingMaterial, GaussianSplattingMaxPartCount, GaussianSplattingMesh, GaussianSplattingOverdrawMaterialPlugin, GaussianSplattingPartProxyMesh, GaussianSplattingSizeMaterialPlugin, GaussianSplattingSolidColorMaterialPlugin, GaussianSplattingStream, GeometryBufferRenderer, GeospatialCamera, GeospatialClippingBehavior, GetElementPixelFromUv, GetGaussianSplattingMaxPartCount, GetPartIndexVaryingDeclaration, GetPointsCount, GetSupportedSimultaneousLights, GetWhiteBalanceMatrix, GizmoManager, GlowLayer, GreasedLineBaseMesh, GreasedLineMaterialDefaults, GreasedLineMesh, GreasedLineMeshColorDistribution, GreasedLineMeshWidthDistribution, GreasedLinePluginMaterial, GreasedLineRibbonAutoDirectionMode, GreasedLineRibbonFacesMode, GreasedLineRibbonMesh, GreasedLineRibbonPointsMode, GreasedLineSimpleMaterial, GreasedLineTools, GridMaterial, GroundMesh, HDRCubeTexture, HandConstraintBehavior, HavokPlugin, HemisphericLight, HighlightLayer, HingeConstraint, HtmlInteractionManager, HtmlRaycastInteractionManager, HtmlTexture, ImageProcessingConfiguration, ImportMeshAsync, IncrementValueAction, InitializeCSG2Async, InstallHtmlInCanvasPolyfill, InstancedMesh, InterpolatingBehavior, IsHtmlInCanvasSupportedNatively, IsHtmlInCanvasUploadSupported, KHR_materials_variants, LastCreatedAudioEngine, Layer, Light, LightGizmo, LinesMesh, LiteCompatError, LoadAssetContainerAsync, LoadImageToTexture2DArrayLayerAsync, LockConstraint, Logger, MainAudioBus, Material, MaterialGreasedLineDefines, MaterialPluginBase, MaterialPluginManager, Matrix, MaxTintMagnitude, Mesh, MeshBlendDebugMode, MeshBlendDepthType, MeshBlendQuality, MeshBlendingPostProcess, MeshBlendingRadiusClass, MeshBuilder, MeshoptCompression, MinTemperatureKelvin, MirrorTexture, MorphTarget, MorphTargetManager, MultiMaterial, MultiPointerScaleBehavior, Node, NodeMaterial, NodeParticleSystemSet, NodeRenderGraphMeshBlendingPostProcessBlock, NodeRenderGraphMinMaxReducerBlock, NullEngine, OBJFileLoader, Observable, OnAudioEngineV2CreatedObservable, OpenPBRMaterial, OpenPBRMaterialDefines, OpenPBRMaterialLoadingAdapter, OutlineRenderer, PBRAnisotropicConfiguration, PBRClearCoatConfiguration, PBRIridescenceConfiguration, PBRMaterial, PBRMetallicRoughnessMaterial, PBRSheenConfiguration, PBRSpecularGlossinessMaterial, PackMeshBlendingTag, ParticleHelper, ParticleSystem, ParticleSystemSet, Path3D, PerformanceMonitor, Physics6DoFConstraint, Physics6DoFLimit, PhysicsAggregate, PhysicsBody, PhysicsCharacterController, PhysicsConstraint, PhysicsConstraintAxis, PhysicsConstraintType, PhysicsEngine, PhysicsMotionType, PhysicsPrestepType, PhysicsRaycastResult, PhysicsShape, PhysicsShapeType, PickingInfo, Plane, PlaneDragGizmo, PlaneRotationGizmo, PointLight, PointerDragBehavior, PointerEventTypes, PointerInfo, PointsCloudSystem, Polar, PolygonBuilder, PositionGizmo, PostProcess, PowerEase, PrecisionDate, PredicateCondition, PrismaticConstraint, PushMaterial, QuadraticEase, QuarticEase, Quaternion, QuinticEase, RandomGUID, RawTexture, RawTexture2DArray, RawTexture3D, Ray, RecastJSPlugin, RectAreaLight, ReflectionProbe, RegisterAbstractEngineTextureLoaders, RegisterComputeShader, RegisterEnginesExtensionsEngineTexture2DArrayImageSource, RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource, RegisterFluidRenderer, RegisterGaussianSplattingDebugMaterialPlugin, RegisterGaussianSplattingGpuPickingMaterialPlugin, RegisterGaussianSplattingMaterial, RegisterGaussianSplattingOverdrawMaterialPlugin, RegisterGaussianSplattingSizeMaterialPlugin, RegisterGaussianSplattingSolidColorMaterialPlugin, RegisterGreasedLinePluginMaterial, RegisterImageProcessingConfiguration, RegisterMeshBlendingPostProcessBlock, RegisterMinMaxReducerBlock, RegisterOpenpbrMaterial, RegisterPolygonBuilder, RegisterSPLATFileLoader, RegisterUSDFileLoader, RenderTargetTexture, RootMotionClip, RootMotionController, RootMotionSource, RotationGizmo, SPLATFileLoader, SSAO2RenderingPipeline, STLFileLoader, Scalar, ScaleGizmo, Scene, SceneLoader, SceneOptimizer, ScenePerformancePriority, SceneSerializer, SetValueAction, ShaderLanguage, ShaderMaterial, ShadowGenerator, SineEase, SixDofDragBehavior, Size, Skeleton, SliderConstraint, SmartArray, SolidParticleSystem, Sound, SoundSource, SoundState, Space, SpatialAudioAttachmentType, Spherical, SpotLight, SpringConstraint, Sprite, SpriteManager, SpriteMap, SpritePackedManager, SpriteRenderer, StandardMaterial, StaticSound, StaticSoundBuffer, StorageBuffer, StreamingSound, StringDictionary, SurfaceMagnetismBehavior, Tags, TargetCamera, TemperatureTintToXyz, Texture, ThinEngine, ThinFSR1SharpenPostProcess, ThinFSR1UpscalePostProcess, ThinMeshBlendingPostProcess, ThinSprite, ToDegrees, ToRadians, Tools, TouchCamera, TransformNode, USDFileLoader, UniformBuffer, UninstallHtmlInCanvasPolyfill, UniversalCamera, UnpackMeshBlendingTag, UploadHtmlElementToTexture, UploadImageToTexture2DArrayLayer, UtilityLayerRenderer, ValidateFlowGraph, ValidateFlowGraphWithBlockList, ValueCondition, ValueConditionOperators, Vector2, Vector3, Vector4, VertexBuffer, VertexData, Viewport, VirtualJoystick, WebGPUEngine, WebXRCamera, WeightedSound, _RegisterUSDLoaderDependencies, registerBuiltInLoaders, transformCoordinates, transformNormal, unsupported };
12812
13168
 
12813
13169
  //# sourceMappingURL=index.js.map