@babylonjs/lite-compat 1.30.0-preview → 1.31.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 { A as PushMaterial, B as Quaternion, C as PBRAnisotropicConfiguration, D as PBRMetallicRoughnessMaterial, E as PBRMaterial, F as BoundingInfo, G as Vector4, H as Color4, I as BoundingSphere, J as unsupported, K as liteBackedVector3, L as Matrix, M as Node, N as Observable, O as PBRSheenConfiguration, P as BoundingBox, R as transformCoordinates, S as Material, T as PBRIridescenceConfiguration, U as Vector2, V as Color3, W as Vector3, _ as Mesh, a as CreateDisc, b as VertexBuffer, c as CreateLines, d as CreateTiledBox, f as CreateTiledPlane, g as LinesMesh, h as InstancedMesh, i as CreateDashedLines, j as StandardMaterial, k as PBRSpecularGlossinessMaterial, l as CreatePlane, m as GroundMesh, n as CreateBox, o as CreateGround, p as CreateTorus, q as LiteCompatError, r as CreateCylinder, s as CreateLineSystem, t as AbstractMesh, u as CreateSphere, v as MeshBuilder, w as PBRClearCoatConfiguration, x as VertexData, y as TransformNode, z as transformNormal } from "./meshes-DJ46g22_.js";
2
- import { CharacterSupportedState as CharacterSupportedState$1, PhysicsConstraintAxis as PhysicsConstraintAxis$1, PhysicsConstraintType as PhysicsConstraintType$1, PhysicsMotionType as PhysicsMotionType$1, PhysicsPrestepType as PhysicsPrestepType$1, PhysicsShapeType as PhysicsShapeType$1, VERSION, addAnimationGroup, addBillboardSpriteIndex, addClusteredLightContainer, addFacingBillboardSystem, addPolarToRef, addSphericalToRef, addSprite2DIndex, addToScene, animateParticleSystem, applyPhysicsBodyForce, applyPhysicsBodyImpulse, attachAxisDragGizmoToNode, attachAxisScaleGizmoToNode, attachBoundingBoxGizmoToNode, attachCameraGizmoToCamera, attachControl, attachFreeControl, attachGeospatialControls, attachLightGizmoToLight, attachPlaneDragGizmoToNode, attachPlaneRotationGizmoToNode, attachPositionGizmoToNode, attachRotationGizmoToNode, attachScaleGizmoToNode, bakeCurrentTransformIntoVertices, billboardBlendAdditive, billboardBlendAlpha, calculatePhysicsCharacterMovementToRef, clearBoneOverride, createAnimationManager, createArcRotateCamera, createAudioBusAsync, createAudioEngineAsync, createAxisDragGizmo, createAxisScaleGizmo, createBankedFreeCamera, createBoundingBoxGizmo, createCameraGizmo, createClusteredLightContainer, createClusteredPointLight, createCsg2FromMesh, createCsgFromMesh, createCsmDirectionalShadowGenerator, createDefaultCamera, createDirectionalLight, createDynamicTexture, createEngine, createEsmDirectionalShadowGenerator, createFacingBillboardSystem, createFreeCamera, createGeospatialCamera, createGpuPicker, createGridMaterial, createHavokWorld, createHemisphericLight, createHtmlTexture, createLightGizmo, createMeshFromCsg, createMeshesFromCsg2, createMicrophoneSoundSourceAsync, createMorphTargets, createNullEngine, createParticleBillboard, createPcfDirectionalShadowGenerator, createPcfSpotlightShadowGenerator, createPhysicsAggregate, createPhysicsBody, createPhysicsCharacterController, createPhysicsConstraint, createPhysicsShape, createPickingRay, createPlaneDragGizmo, createPlaneRotationGizmo, createPointLight, createPositionGizmo, createRotationGizmo, createScaleGizmo, createSceneContext, createSoundAsync, createSoundBufferAsync, createSoundSourceAsync, createSpotLight, createSprite2DLayer, createSpriteRenderer, createStreamingSoundAsync, createTexture2DArray, createTexture2DArrayFromKtx2, createTexture2DArrayFromPixels, createTexture2DArrayFromUrls, createTexture2DFromPixels, createTexture3DFromPixels, createTransformNode, createUtilityLayer, csg2Add, csg2Intersect, csg2Subtract, csgIntersect, csgSubtract, csgUnion, disableOrthographicCamera, disposeAudioBus, disposeAudioEngine, disposeAxisDragGizmo, disposeAxisScaleGizmo, disposeBoundingBoxGizmo, disposeCameraGizmo, disposeCsg2, disposeEngine, disposeHtmlTexture, disposeLightGizmo, disposePhysics, disposePicker, disposePlaneDragGizmo, disposePlaneRotationGizmo, disposePositionGizmo, disposeRotationGizmo, disposeScaleGizmo, disposeScene, disposeSound, disposeSoundSource, disposeStreamingSound, disposeUtilityLayer, dividePolarToRef, divideSphericalToRef, enableAnalyzer, enableAnimationBlending, enableArcRotateKeyboardControls, enableBoneControlForSkinnedAssets, enableHavokThinInstancePhysicsSync, enableMirroredMeshes, enableOrthographicCamera, enableSpatial, enableStereo, getBoneByName, getByteFrequencyData, getByteTimeDomainData, getCameraPosition, getFloatFrequencyData, getFloatTimeDomainData, getMasterVolume, getPhysicsBodyAngularVelocity, getPhysicsBodyLinearVelocity, getProjectionMatrix, getVariantNames, getViewMatrix, goToFrame, initializeCsg2Async, invertMat4, loadBabylon, loadBasisTexture2D, loadDdsEnvironment, loadEnvironment, loadGltf, loadHdrEnvironment, loadImageToArrayLayer, loadKtxTexture2D, loadSOG, loadSPZ, loadSplat, loadSpriteAtlas, loadTexture2D, markClusteredLightContainerDirty, multiplyMat4, multiplyPolarToRef, multiplySphericalToRef, onBeforeRender, onPhysicsAfterStep, parseNodeMaterialFromSnippet, parseNodeParticleSetFromSnippet, pauseAnimation, pauseSound, pauseStreamingSound, physicsRaycast, pickAsync, pickMeshesWithRay, playAnimation, playSound, playStreamingSound, polarFromVec2ToRef, polarToVec2ToRef, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, registerNodeParticleSet, registerScene, registerSceneWithShadowSupport, registerSpriteRenderer, registerUtilityLayer, releasePhysicsConstraint, releasePhysicsShape, removeFromScene, removePhysicsBody, requestHtmlTextureUpdate, resetVariant, resizeEngine, resolveCameraViewport, resumeSound, resumeStreamingSound, sampleCatmullRomSpline, sampleHermiteSpline, scalePolarToRef, scaleSphericalToRef, selectVariant, setAnimationAdditive, setBonePosition, setBoneRotationQuaternion, setBoneScaling, setBusVolume, setClipPlane, setEngineSize, setFog, setGeospatialOrientation, setMasterVolume, setMorphTargetWeights, setPhysicsBodyAngularVelocity, setPhysicsBodyLinearVelocity, setPhysicsBodyMassProperties, setPhysicsBodyMotionType, setPhysicsBodyPrestepType, setPhysicsBodyShape, setPhysicsGravity, setPhysicsShapeFilterCollideMask, setPhysicsShapeFilterMembershipMask, setPhysicsShapeIsTrigger, setPhysicsShapeMaterial, setPhysicsTimestep, setPositionGizmoLocalCoordinates, setRotationGizmoLocalCoordinates, setScaleGizmoLocalCoordinates, setShadowTaskCasterMeshes, setSoundSourceVolume, setSoundVolume, setSpatialListener, setSpatialListenerPosition, setSpatialOrientation, setSpatialPosition, setStereoPan, setStreamingSoundVolume, sphericalFromVec3ToRef, sphericalToVec3ToRef, spriteBlendAdditive, spriteBlendAlpha, spriteBlendPremultiplied, startEngine, startParticleSystem, stepScene, stopAnimation, stopEngine, stopParticleSystem, stopSound, stopStreamingSound, subtractPolarToRef, subtractSphericalToRef, syncParticleBillboard, unlockAudioEngineAsync, updateAnimationManager, updateBillboardSpriteIndex, updateDynamicTexture, updateHtmlTexture, updateSpatialAudio, updateSprite2DIndex, updateTexture2DArrayFromPixels, updateTexture2DFromPixels, uploadImageToArrayLayer, whenHtmlTextureReady } from "@babylonjs/lite";
1
+ import { A as PBRSpecularGlossinessMaterial, B as transformCoordinates, C as Material, D as PBRMaterial, E as PBRIridescenceConfiguration, F as Observable, G as liteBackedColor3, H as Quaternion, I as BoundingBox, J as Vector4, K as Vector2, L as BoundingInfo, M as StandardMaterial, N as attachMaterialToScene, O as PBRMetallicRoughnessMaterial, P as Node, R as BoundingSphere, S as registerMeshAtStart, T as PBRClearCoatConfiguration, U as Color3, V as transformNormal, W as Color4, X as LiteCompatError, Y as liteBackedVector3, Z as unsupported, _ as Mesh, a as CreateDisc, b as VertexBuffer, c as CreateLines, d as CreateTiledBox, f as CreateTiledPlane, g as LinesMesh, h as InstancedMesh, i as CreateDashedLines, j as PushMaterial, k as PBRSheenConfiguration, l as CreatePlane, m as GroundMesh, n as CreateBox, o as CreateGround, p as CreateTorus, q as Vector3, r as CreateCylinder, s as CreateLineSystem, t as AbstractMesh, u as CreateSphere, v as MeshBuilder, w as PBRAnisotropicConfiguration, x as VertexData, y as TransformNode, z as Matrix } from "./meshes-Fu955h5M.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, addFacingBillboardSystem, addPolarToRef, addSphericalToRef, addSprite2DIndex, addToScene, animateParticleSystem, applyPhysicsBodyForce, applyPhysicsBodyImpulse, attachAxisDragGizmoToNode, attachAxisScaleGizmoToNode, attachBoundingBoxGizmoToNode, attachCameraGizmoToCamera, attachControl, attachFreeControl, attachGeospatialControls, attachLightGizmoToLight, attachPlaneDragGizmoToNode, attachPlaneRotationGizmoToNode, attachPositionGizmoToNode, attachRotationGizmoToNode, attachScaleGizmoToNode, bakeCurrentTransformIntoVertices, billboardBlendAdditive, billboardBlendAlpha, calculatePhysicsCharacterMovementToRef, clearBoneOverride, createAnimationManager, createArcRotateCamera, createAudioBusAsync, createAudioEngineAsync, createAxisDragGizmo, createAxisScaleGizmo, createBankedFreeCamera, createBoundingBoxGizmo, createCameraGizmo, createClusteredLightContainer, createClusteredPointLight, 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, createRotationGizmo, createScaleGizmo, createSceneContext, createSoundAsync, createSoundBufferAsync, createSoundSourceAsync, createSpotLight, createSprite2DLayer, createSpriteRenderer, createStreamingSoundAsync, createTexture2DArray, createTexture2DArrayFromKtx2, createTexture2DArrayFromPixels, createTexture2DArrayFromUrls, createTexture2DFromPixels, createTexture3DFromPixels, createTransformNode, createUtilityLayer, csg2Add, csg2Intersect, csg2Subtract, csgIntersect, csgSubtract, csgUnion, disableOrthographicCamera, disposeAudioBus, disposeAudioEngine, disposeAxisDragGizmo, disposeAxisScaleGizmo, disposeBoundingBoxGizmo, disposeCameraGizmo, disposeCsg2, disposeEngine, disposeHtmlTexture, disposeLightGizmo, disposePhysics, disposePicker, disposePlaneDragGizmo, disposePlaneRotationGizmo, disposePositionGizmo, disposeRotationGizmo, disposeScaleGizmo, disposeScene, disposeSound, disposeSoundSource, disposeStreamingSound, disposeUtilityLayer, dividePolarToRef, divideSphericalToRef, enableAnalyzer, enableAnimationBlending, enableArcRotateKeyboardControls, enableBoneControlForSkinnedAssets, enableHavokThinInstancePhysicsSync, enableMirroredMeshes, enableOrthographicCamera, enableSpatial, enableStereo, getBoneByName, getByteFrequencyData, getByteTimeDomainData, getCameraPosition, getFloatFrequencyData, getFloatTimeDomainData, getMasterVolume, getPhysicsBodyAngularVelocity, getPhysicsBodyLinearVelocity, getProjectionMatrix, getVariantNames, getViewMatrix, getWhiteBalanceMatrix, goToFrame, hasDefaultInteractivityFlowInput, initializeCsg2Async, invertMat4, loadBabylon, loadBasisTexture2D, loadDdsEnvironment, loadEnvironment, loadGltf, loadHdrEnvironment, loadImageToArrayLayer, loadKtxTexture2D, loadSOG, loadSPZ, loadSplat, loadSpriteAtlas, loadTexture2D, markClusteredLightContainerDirty, multiplyMat4, multiplyPolarToRef, multiplySphericalToRef, normalizeInteractivityEventDataConfiguration, normalizeKhrInteractivityRuntimeValue, onBeforeRender, onPhysicsAfterStep, packMeshBlendingTag, parseNodeMaterialFromSnippet, parseNodeParticleSetFromSnippet, pauseAnimation, pauseSound, pauseStreamingSound, physicsRaycast, pickAsync, pickMeshesWithRay, playAnimation, playSound, playStreamingSound, polarFromVec2ToRef, polarToVec2ToRef, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, registerNodeParticleSet, registerScene, registerSceneWithShadowSupport, registerSpriteRenderer, registerUtilityLayer, releasePhysicsConstraint, releasePhysicsShape, removeFromScene, removePhysicsBody, requestHtmlTextureUpdate, resetVariant, resizeEngine, resolveCameraViewport, resumeSound, resumeStreamingSound, sampleCatmullRomSpline, sampleHermiteSpline, scalePolarToRef, scaleSphericalToRef, selectVariant, setAnimationAdditive, setBonePosition, setBoneRotationQuaternion, setBoneScaling, setBusVolume, setClipPlane, setEngineSize, setFog, setGeospatialOrientation, setMasterVolume, setMorphTargetWeights, setPhysicsBodyAngularVelocity, setPhysicsBodyLinearVelocity, setPhysicsBodyMassProperties, setPhysicsBodyMotionType, setPhysicsBodyPrestepType, setPhysicsBodyShape, setPhysicsGravity, setPhysicsShapeFilterCollideMask, setPhysicsShapeFilterMembershipMask, setPhysicsShapeIsTrigger, setPhysicsShapeMaterial, setPhysicsTimestep, setPositionGizmoLocalCoordinates, setRotationGizmoLocalCoordinates, setScaleGizmoLocalCoordinates, setShadowTaskCasterMeshes, setSoundSourceVolume, setSoundVolume, setSpatialListener, setSpatialListenerPosition, setSpatialOrientation, setSpatialPosition, setStereoPan, setStreamingSoundVolume, sphericalFromVec3ToRef, sphericalToVec3ToRef, spriteBlendAdditive, spriteBlendAlpha, spriteBlendPremultiplied, startEngine, startParticleSystem, stepScene, stopAnimation, stopEngine, stopParticleSystem, stopSound, stopStreamingSound, subtractPolarToRef, subtractSphericalToRef, syncParticleBillboard, temperatureTintToXyz, unlockAudioEngineAsync, unpackMeshBlendingTag, updateAnimationManager, updateBillboardSpriteIndex, updateDynamicTexture, updateHtmlTexture, updateSpatialAudio, updateSprite2DIndex, updateTexture2DArrayFromPixels, updateTexture2DFromPixels, uploadImageToArrayLayer, whenHtmlTextureReady } from "@babylonjs/lite";
3
3
  //#region \0rolldown/runtime.js
4
4
  var __defProp = Object.defineProperty;
5
5
  var __exportAll = (all, no_symbols) => {
@@ -578,6 +578,15 @@ var Path3D = class {
578
578
  }
579
579
  };
580
580
  //#endregion
581
+ //#region src/math/color-temperature.ts
582
+ function TemperatureTintToXyz(temperatureKelvin, tint) {
583
+ const [x, y, z] = temperatureTintToXyz(temperatureKelvin, tint);
584
+ return new Vector3(x, y, z);
585
+ }
586
+ function GetWhiteBalanceMatrix(temperatureKelvin, tint) {
587
+ return getWhiteBalanceMatrix(temperatureKelvin, tint);
588
+ }
589
+ //#endregion
581
590
  //#region src/culling/picking-info.ts
582
591
  /** Babylon.js-compatible result of a scene pick. */
583
592
  var PickingInfo = class PickingInfo {
@@ -874,6 +883,10 @@ var AbstractEngine = class {
874
883
  _initialized = false;
875
884
  _startupComplete = false;
876
885
  _startPromise = null;
886
+ /** @internal Whether scene registration and the first engine start have completed. */
887
+ get _hasStarted() {
888
+ return this._startupComplete;
889
+ }
877
890
  /** @internal Active `requestAnimationFrame` id for the scene-less loop, if any. */
878
891
  _rafId = null;
879
892
  /**
@@ -1146,12 +1159,16 @@ var AbstractEngine = class {
1146
1159
  scene._flushPendingAdds();
1147
1160
  scene._buildMorphTargets();
1148
1161
  scene._buildClusteredContainers();
1162
+ await scene._enableMaterialPlugins();
1149
1163
  await scene._loadPendingEnvironment();
1150
1164
  await enableMirroredMeshes(scene._lite);
1151
1165
  if (scene._hasShadows()) await registerSceneWithShadowSupport(scene._lite);
1152
1166
  else await registerScene(scene._lite);
1153
1167
  }
1154
1168
  await startEngine(this._lite);
1169
+ do
1170
+ await Promise.all(this._scenes.map((scene) => scene._reconcilePendingMaterialPlugins()));
1171
+ while (this._scenes.some((scene) => scene._hasPendingMaterialPluginReconciliations));
1155
1172
  this._startupComplete = true;
1156
1173
  if (this._lateWork.length > 0) {
1157
1174
  await Promise.all(this._lateWork.map(runLateWork));
@@ -3457,22 +3474,22 @@ var ImageProcessingConfiguration = class {
3457
3474
  return false;
3458
3475
  }
3459
3476
  set whiteBalanceEnabled(value) {
3460
- if (value) unsupported("ImageProcessingConfiguration.whiteBalanceEnabled", WHITE_BALANCE_UNSUPPORTED$1);
3477
+ if (value) unsupported("ImageProcessingConfiguration.whiteBalanceEnabled", WHITE_BALANCE_UNSUPPORTED);
3461
3478
  }
3462
3479
  get temperature() {
3463
3480
  return 6500;
3464
3481
  }
3465
3482
  set temperature(value) {
3466
- if (value !== 6500) unsupported("ImageProcessingConfiguration.temperature", WHITE_BALANCE_UNSUPPORTED$1);
3483
+ if (value !== 6500) unsupported("ImageProcessingConfiguration.temperature", WHITE_BALANCE_UNSUPPORTED);
3467
3484
  }
3468
3485
  get tint() {
3469
3486
  return 0;
3470
3487
  }
3471
3488
  set tint(value) {
3472
- if (value !== 0) unsupported("ImageProcessingConfiguration.tint", WHITE_BALANCE_UNSUPPORTED$1);
3489
+ if (value !== 0) unsupported("ImageProcessingConfiguration.tint", WHITE_BALANCE_UNSUPPORTED);
3473
3490
  }
3474
3491
  };
3475
- var WHITE_BALANCE_UNSUPPORTED$1 = "White balance requires color-temperature math, a shader uniform, material/post-process defines, and pipeline invalidation that Babylon Lite does not expose; adding it needs a cross-cutting Lite subsystem design.";
3492
+ var WHITE_BALANCE_UNSUPPORTED = "White balance requires color-temperature math, a shader uniform, material/post-process defines, and pipeline invalidation that Babylon Lite does not expose; adding it needs a cross-cutting Lite subsystem design.";
3476
3493
  /** Babylon.js pure-module registration hook. */
3477
3494
  function RegisterImageProcessingConfiguration() {
3478
3495
  return unsupported("RegisterImageProcessingConfiguration", "Babylon Lite has no Babylon.js SerializationHelper parser registry to install ImageProcessingConfiguration into.");
@@ -3482,6 +3499,10 @@ function RegisterImageProcessingConfiguration() {
3482
3499
  * supported texture formats directly, so no registration is required.
3483
3500
  */
3484
3501
  function RegisterAbstractEngineTextureLoaders() {}
3502
+ /** Pure-build registration shim; compat wires the Lite array upload directly. */
3503
+ function RegisterEnginesExtensionsEngineTexture2DArrayImageSource() {}
3504
+ /** WebGPU pure-build registration shim; Babylon Lite is WebGPU-only. */
3505
+ function RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource() {}
3485
3506
  /**
3486
3507
  * Babylon.js `Constants` — the small subset of numeric constants referenced by
3487
3508
  * the ported scenes. Extend as needed.
@@ -3641,6 +3662,8 @@ var Scene = class Scene extends AbstractScene {
3641
3662
  _pendingTextures = [];
3642
3663
  _pendingGroundBakes = [];
3643
3664
  _pendingMorphBuilds = [];
3665
+ _materialPluginsRequested = false;
3666
+ _pendingMaterialPluginReconciliations = /* @__PURE__ */ new Set();
3644
3667
  _runningAnimatables = [];
3645
3668
  _animationGroupCache = /* @__PURE__ */ new WeakMap();
3646
3669
  /** @internal Structural `AnimationGroup`s stepped + weight-blended each frame. */
@@ -3832,6 +3855,42 @@ var Scene = class Scene extends AbstractScene {
3832
3855
  for (const { mesh, manager } of this._pendingMorphBuilds) manager._build(mesh, engine);
3833
3856
  this._pendingMorphBuilds.length = 0;
3834
3857
  }
3858
+ /**
3859
+ * @internal Request Lite's opt-in material-plugin bridges for this scene.
3860
+ * Once the engine is live, reconcile the changed material through Lite's
3861
+ * runtime rebuild path rather than leaving the startup-only request stranded.
3862
+ */
3863
+ _requestMaterialPlugins(material) {
3864
+ this._materialPluginsRequested = true;
3865
+ if (material && this._engine._hasStarted) this._engine._registerLateWork(async () => {
3866
+ const { reconcileMaterialPlugins } = await import("@babylonjs/lite");
3867
+ await reconcileMaterialPlugins(this._lite, material);
3868
+ });
3869
+ else if (material && this._started) this._pendingMaterialPluginReconciliations.add(material);
3870
+ }
3871
+ /** @internal Enable requested material plugins after meshes are added and before scene registration. */
3872
+ async _enableMaterialPlugins() {
3873
+ if (this._materialPluginsRequested) {
3874
+ const { enableMaterialPlugins } = await import("@babylonjs/lite");
3875
+ enableMaterialPlugins(this._lite);
3876
+ this._materialPluginsRequested = false;
3877
+ this._pendingMaterialPluginReconciliations.clear();
3878
+ }
3879
+ }
3880
+ /** @internal Reconcile plugin requests raised by first-frame callbacks before engine startup completes. */
3881
+ async _reconcilePendingMaterialPlugins() {
3882
+ while (this._pendingMaterialPluginReconciliations.size > 0) {
3883
+ const materials = [...this._pendingMaterialPluginReconciliations];
3884
+ this._pendingMaterialPluginReconciliations.clear();
3885
+ const { reconcileMaterialPlugins } = await import("@babylonjs/lite");
3886
+ await Promise.all(materials.map((material) => reconcileMaterialPlugins(this._lite, material)));
3887
+ }
3888
+ this._materialPluginsRequested = false;
3889
+ }
3890
+ /** @internal Whether this scene queued plugin changes during the engine startup transition. */
3891
+ get _hasPendingMaterialPluginReconciliations() {
3892
+ return this._pendingMaterialPluginReconciliations.size > 0;
3893
+ }
3835
3894
  /** @internal Clustered light containers to register on the Lite scene at engine start. */
3836
3895
  _pendingClusteredContainers = [];
3837
3896
  /** @internal Register a compat `ClusteredLightContainer` to be wired into the scene at engine start. */
@@ -3900,6 +3959,7 @@ var Scene = class Scene extends AbstractScene {
3900
3959
  }
3901
3960
  set defaultMaterial(value) {
3902
3961
  this._defaultMaterial = value;
3962
+ value?._adoptScene(this);
3903
3963
  }
3904
3964
  get clearColor() {
3905
3965
  const c = this._lite.clearColor;
@@ -4383,11 +4443,11 @@ var Scene = class Scene extends AbstractScene {
4383
4443
  * wrappers do the same by calling `addToScene` when a scene is supplied. The
4384
4444
  * underlying Lite light is exposed as `_lite` for advanced interop.
4385
4445
  *
4386
- * Colour properties (`diffuse`, `specular`, `groundColor`) are write-through on
4387
- * assignment: `light.diffuse = new Color3(...)` propagates immediately. In-place
4388
- * mutation of a returned colour (`light.diffuse.r = x`) does not propagate; assign
4389
- * a new colour instead. Direction/position are backed by Lite's observable vectors
4390
- * and propagate on `.x/.y/.z` writes.
4446
+ * As in Babylon.js, the getters hand out the light's own live objects, so both assignment
4447
+ * (`light.diffuse = new Color3(...)`) and in-place edits (`light.diffuse.copyFrom(c)`,
4448
+ * `light.direction.set(x, y, z)`, `light.position.y = 2`) reach the Lite light. Direction and
4449
+ * position are proxies over Lite's observable vectors; colours are proxies over the Lite colour
4450
+ * tuples, and every colour write bumps the light version so it reaches the lights UBO.
4391
4451
  */
4392
4452
  /** Babylon.js `Light` — base class for all lights (derives from `Node`). */
4393
4453
  var Light = class extends Node {
@@ -4438,6 +4498,21 @@ var Light = class extends Node {
4438
4498
  this._liteVersionBump();
4439
4499
  }
4440
4500
  /**
4501
+ * @internal Babylon.js hands out the light's own `Color3`, so `light.diffuse.copyFrom(c)` or
4502
+ * `light.specular.set(0, 0, 0)` edits the light. Return a live proxy over the Lite tuple rather than a
4503
+ * copy (whose edits were silently dropped); a colour write cannot notify Lite, so it bumps the version.
4504
+ */
4505
+ _liveColor(tuple) {
4506
+ return liteBackedColor3(tuple, () => this._bumpLiteVersion());
4507
+ }
4508
+ /** @internal Assign a colour and publish it (a tuple write cannot notify Lite by itself). */
4509
+ _writeColor(tuple, value) {
4510
+ tuple[0] = value.r;
4511
+ tuple[1] = value.g;
4512
+ tuple[2] = value.b;
4513
+ this._bumpLiteVersion();
4514
+ }
4515
+ /**
4441
4516
  * Babylon.js `light.intensity`. While the light is disabled the Lite light
4442
4517
  * carries `0`, but the getter still returns the logical value the caller set.
4443
4518
  */
@@ -4500,17 +4575,6 @@ function ensureLightVersionBump(lite) {
4500
4575
  });
4501
4576
  return bump;
4502
4577
  }
4503
- function readColor(tuple) {
4504
- return new Color3(tuple[0], tuple[1], tuple[2]);
4505
- }
4506
- function writeColor(tuple, value) {
4507
- tuple[0] = value.r;
4508
- tuple[1] = value.g;
4509
- tuple[2] = value.b;
4510
- }
4511
- function readVector(vec) {
4512
- return new Vector3(vec.x, vec.y, vec.z);
4513
- }
4514
4578
  var HemisphericLight = class extends Light {
4515
4579
  /** @internal Underlying Babylon Lite hemispheric light. */
4516
4580
  _lite;
@@ -4523,28 +4587,28 @@ var HemisphericLight = class extends Light {
4523
4587
  return "HemisphericLight";
4524
4588
  }
4525
4589
  get direction() {
4526
- return readVector(this._lite.direction);
4590
+ return liteBackedVector3(this._lite.direction);
4527
4591
  }
4528
4592
  set direction(value) {
4529
4593
  this._lite.direction.set(value.x, value.y, value.z);
4530
4594
  }
4531
4595
  get diffuse() {
4532
- return readColor(this._lite.diffuseColor);
4596
+ return this._liveColor(this._lite.diffuseColor);
4533
4597
  }
4534
4598
  set diffuse(value) {
4535
- writeColor(this._lite.diffuseColor, value);
4599
+ this._writeColor(this._lite.diffuseColor, value);
4536
4600
  }
4537
4601
  get specular() {
4538
- return readColor(this._lite.specularColor);
4602
+ return this._liveColor(this._lite.specularColor);
4539
4603
  }
4540
4604
  set specular(value) {
4541
- writeColor(this._lite.specularColor, value);
4605
+ this._writeColor(this._lite.specularColor, value);
4542
4606
  }
4543
4607
  get groundColor() {
4544
- return readColor(this._lite.groundColor);
4608
+ return this._liveColor(this._lite.groundColor);
4545
4609
  }
4546
4610
  set groundColor(value) {
4547
- writeColor(this._lite.groundColor, value);
4611
+ this._writeColor(this._lite.groundColor, value);
4548
4612
  }
4549
4613
  };
4550
4614
  var DirectionalLight = class extends Light {
@@ -4559,28 +4623,28 @@ var DirectionalLight = class extends Light {
4559
4623
  return "DirectionalLight";
4560
4624
  }
4561
4625
  get direction() {
4562
- return readVector(this._lite.direction);
4626
+ return liteBackedVector3(this._lite.direction);
4563
4627
  }
4564
4628
  set direction(value) {
4565
4629
  this._lite.direction.set(value.x, value.y, value.z);
4566
4630
  }
4567
4631
  get position() {
4568
- return readVector(this._lite.position);
4632
+ return liteBackedVector3(this._lite.position);
4569
4633
  }
4570
4634
  set position(value) {
4571
4635
  this._lite.position.set(value.x, value.y, value.z);
4572
4636
  }
4573
4637
  get diffuse() {
4574
- return readColor(this._lite.diffuse);
4638
+ return this._liveColor(this._lite.diffuse);
4575
4639
  }
4576
4640
  set diffuse(value) {
4577
- writeColor(this._lite.diffuse, value);
4641
+ this._writeColor(this._lite.diffuse, value);
4578
4642
  }
4579
4643
  get specular() {
4580
- return readColor(this._lite.specular);
4644
+ return this._liveColor(this._lite.specular);
4581
4645
  }
4582
4646
  set specular(value) {
4583
- writeColor(this._lite.specular, value);
4647
+ this._writeColor(this._lite.specular, value);
4584
4648
  }
4585
4649
  };
4586
4650
  var PointLight = class extends Light {
@@ -4601,22 +4665,22 @@ var PointLight = class extends Light {
4601
4665
  this._lite.range = value;
4602
4666
  }
4603
4667
  get position() {
4604
- return readVector(this._lite.position);
4668
+ return liteBackedVector3(this._lite.position);
4605
4669
  }
4606
4670
  set position(value) {
4607
4671
  this._lite.position.set(value.x, value.y, value.z);
4608
4672
  }
4609
4673
  get diffuse() {
4610
- return readColor(this._lite.diffuse);
4674
+ return this._liveColor(this._lite.diffuse);
4611
4675
  }
4612
4676
  set diffuse(value) {
4613
- writeColor(this._lite.diffuse, value);
4677
+ this._writeColor(this._lite.diffuse, value);
4614
4678
  }
4615
4679
  get specular() {
4616
- return readColor(this._lite.specular);
4680
+ return this._liveColor(this._lite.specular);
4617
4681
  }
4618
4682
  set specular(value) {
4619
- writeColor(this._lite.specular, value);
4683
+ this._writeColor(this._lite.specular, value);
4620
4684
  }
4621
4685
  };
4622
4686
  var SpotLight = class extends Light {
@@ -4649,28 +4713,28 @@ var SpotLight = class extends Light {
4649
4713
  this._lite.range = value;
4650
4714
  }
4651
4715
  get position() {
4652
- return readVector(this._lite.position);
4716
+ return liteBackedVector3(this._lite.position);
4653
4717
  }
4654
4718
  set position(value) {
4655
4719
  this._lite.position.set(value.x, value.y, value.z);
4656
4720
  }
4657
4721
  get direction() {
4658
- return readVector(this._lite.direction);
4722
+ return liteBackedVector3(this._lite.direction);
4659
4723
  }
4660
4724
  set direction(value) {
4661
4725
  this._lite.direction.set(value.x, value.y, value.z);
4662
4726
  }
4663
4727
  get diffuse() {
4664
- return readColor(this._lite.diffuse);
4728
+ return this._liveColor(this._lite.diffuse);
4665
4729
  }
4666
4730
  set diffuse(value) {
4667
- writeColor(this._lite.diffuse, value);
4731
+ this._writeColor(this._lite.diffuse, value);
4668
4732
  }
4669
4733
  get specular() {
4670
- return readColor(this._lite.specular);
4734
+ return this._liveColor(this._lite.specular);
4671
4735
  }
4672
4736
  set specular(value) {
4673
- writeColor(this._lite.specular, value);
4737
+ this._writeColor(this._lite.specular, value);
4674
4738
  }
4675
4739
  };
4676
4740
  //#endregion
@@ -4902,17 +4966,6 @@ var ClusteredLightContainer = class ClusteredLightContainer extends Light {
4902
4966
  * so positioning the result moves them together — matching Babylon.js's single
4903
4967
  * multi-material `toMesh` return.
4904
4968
  */
4905
- /** @internal Add a freshly-built CSG result mesh to its scene at engine start. */
4906
- function deferAddCsgMesh(mesh, scene, material) {
4907
- scene._deferAdd(() => {
4908
- const engine = scene.getEngine()._lite;
4909
- if (material) {
4910
- material._ensureRenderable(engine);
4911
- mesh._lite.material = material._lite;
4912
- }
4913
- addToScene(scene._lite, mesh._lite);
4914
- });
4915
- }
4916
4969
  /**
4917
4970
  * Babylon.js `CSG` — legacy constructive solid geometry. Build from a mesh with
4918
4971
  * {@link FromMesh}, combine with {@link subtract} / {@link intersect} /
@@ -4944,8 +4997,8 @@ var CSG = class CSG {
4944
4997
  const engine = scene.getEngine()._lite;
4945
4998
  const lite = createMeshFromCsg(engine, this._lite, name);
4946
4999
  const mesh = new Mesh(name, lite, scene);
4947
- deferAddCsgMesh(mesh, scene, material ?? void 0);
4948
- return mesh;
5000
+ if (material) mesh.material = material;
5001
+ return registerMeshAtStart(mesh, scene);
4949
5002
  }
4950
5003
  };
4951
5004
  /** Module-wide unique material-slot counter for CSG2 (`MATERIAL_ID_RESERVE_COUNT` = 65536). */
@@ -4993,14 +5046,22 @@ var CSG2 = class CSG2 {
4993
5046
  const engine = scene.getEngine()._lite;
4994
5047
  const materials = [];
4995
5048
  for (const [slot, material] of this._materials) {
4996
- material._ensureRenderable(engine);
5049
+ attachMaterialToScene(material, scene);
4997
5050
  materials[slot] = material._lite;
4998
5051
  }
4999
5052
  const liteMeshes = createMeshesFromCsg2(engine, this._lite, materials, name);
5000
5053
  const savedMaterials = liteMeshes.map((m) => m.material);
5001
5054
  const root = new Mesh(name, liteMeshes[0], scene);
5055
+ const wrapped = root.material;
5002
5056
  root._lite.material = savedMaterials[0];
5003
- scene._deferAdd(() => addToScene(scene._lite, root._lite));
5057
+ scene._deferAdd(() => {
5058
+ const assigned = root.material;
5059
+ if (assigned && assigned !== wrapped) {
5060
+ attachMaterialToScene(assigned, scene);
5061
+ root._lite.material = assigned._lite;
5062
+ }
5063
+ addToScene(scene._lite, root._lite);
5064
+ });
5004
5065
  for (let i = 1; i < liteMeshes.length; i++) {
5005
5066
  const sub = liteMeshes[i];
5006
5067
  sub.material = savedMaterials[i];
@@ -5313,6 +5374,80 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
5313
5374
  }
5314
5375
  };
5315
5376
  //#endregion
5377
+ //#region src/meshes/mesh-blending.ts
5378
+ var MeshBlendingRadiusClass = /* @__PURE__ */ function(MeshBlendingRadiusClass) {
5379
+ MeshBlendingRadiusClass[MeshBlendingRadiusClass["Small"] = 0] = "Small";
5380
+ MeshBlendingRadiusClass[MeshBlendingRadiusClass["Medium"] = 1] = "Medium";
5381
+ MeshBlendingRadiusClass[MeshBlendingRadiusClass["Large"] = 2] = "Large";
5382
+ MeshBlendingRadiusClass[MeshBlendingRadiusClass["ExtraLarge"] = 3] = "ExtraLarge";
5383
+ return MeshBlendingRadiusClass;
5384
+ }({});
5385
+ function PackMeshBlendingTag(groupId, radiusClass) {
5386
+ return packMeshBlendingTag(groupId, radiusClass);
5387
+ }
5388
+ function UnpackMeshBlendingTag(tag) {
5389
+ const unpacked = unpackMeshBlendingTag(tag);
5390
+ return {
5391
+ groupId: unpacked.groupId,
5392
+ radiusClass: unpacked.radiusClass
5393
+ };
5394
+ }
5395
+ var MeshBlendQuality = /* @__PURE__ */ function(MeshBlendQuality) {
5396
+ MeshBlendQuality[MeshBlendQuality["Low"] = 0] = "Low";
5397
+ MeshBlendQuality[MeshBlendQuality["Medium"] = 1] = "Medium";
5398
+ MeshBlendQuality[MeshBlendQuality["High"] = 2] = "High";
5399
+ MeshBlendQuality[MeshBlendQuality["Cinematic"] = 3] = "Cinematic";
5400
+ return MeshBlendQuality;
5401
+ }({});
5402
+ var MeshBlendDebugMode = /* @__PURE__ */ function(MeshBlendDebugMode) {
5403
+ MeshBlendDebugMode[MeshBlendDebugMode["Off"] = 0] = "Off";
5404
+ MeshBlendDebugMode[MeshBlendDebugMode["PackedTag"] = 1] = "PackedTag";
5405
+ MeshBlendDebugMode[MeshBlendDebugMode["CandidateDirectionDistance"] = 2] = "CandidateDirectionDistance";
5406
+ MeshBlendDebugMode[MeshBlendDebugMode["SeamFade"] = 3] = "SeamFade";
5407
+ MeshBlendDebugMode[MeshBlendDebugMode["RejectionReason"] = 4] = "RejectionReason";
5408
+ MeshBlendDebugMode[MeshBlendDebugMode["StageWork"] = 5] = "StageWork";
5409
+ MeshBlendDebugMode[MeshBlendDebugMode["Continuation"] = 6] = "Continuation";
5410
+ MeshBlendDebugMode[MeshBlendDebugMode["TinyObject"] = 7] = "TinyObject";
5411
+ MeshBlendDebugMode[MeshBlendDebugMode["MultiTarget"] = 8] = "MultiTarget";
5412
+ MeshBlendDebugMode[MeshBlendDebugMode["TargetColor"] = 9] = "TargetColor";
5413
+ MeshBlendDebugMode[MeshBlendDebugMode["ShadowAttenuation"] = 10] = "ShadowAttenuation";
5414
+ MeshBlendDebugMode[MeshBlendDebugMode["ColorInterpolation"] = 11] = "ColorInterpolation";
5415
+ MeshBlendDebugMode[MeshBlendDebugMode["WorldPosition"] = 12] = "WorldPosition";
5416
+ return MeshBlendDebugMode;
5417
+ }({});
5418
+ var MeshBlendDepthType = /* @__PURE__ */ function(MeshBlendDepthType) {
5419
+ MeshBlendDepthType[MeshBlendDepthType["View"] = 0] = "View";
5420
+ MeshBlendDepthType[MeshBlendDepthType["Screen"] = 1] = "Screen";
5421
+ return MeshBlendDepthType;
5422
+ }({});
5423
+ function CreateDefaultMeshBlendRadiusDefinitions() {
5424
+ return createDefaultMeshBlendRadiusDefinitions();
5425
+ }
5426
+ var MESH_BLENDING_BLOCKER = "Babylon Lite supports mesh blending through its native createMeshBlendingPostProcessTask API; the Babylon.js post-process, frame-graph, and node-render-graph wrapper classes are not implemented by the compat layer.";
5427
+ var ThinMeshBlendingPostProcess = class {
5428
+ constructor(..._args) {
5429
+ unsupported("ThinMeshBlendingPostProcess", MESH_BLENDING_BLOCKER);
5430
+ }
5431
+ };
5432
+ var MeshBlendingPostProcess = class {
5433
+ constructor(..._args) {
5434
+ unsupported("MeshBlendingPostProcess", MESH_BLENDING_BLOCKER);
5435
+ }
5436
+ };
5437
+ var FrameGraphMeshBlendingTask = class {
5438
+ constructor(..._args) {
5439
+ unsupported("FrameGraphMeshBlendingTask", MESH_BLENDING_BLOCKER);
5440
+ }
5441
+ };
5442
+ var NodeRenderGraphMeshBlendingPostProcessBlock = class {
5443
+ constructor(..._args) {
5444
+ unsupported("NodeRenderGraphMeshBlendingPostProcessBlock", MESH_BLENDING_BLOCKER);
5445
+ }
5446
+ };
5447
+ function RegisterMeshBlendingPostProcessBlock() {
5448
+ return unsupported("RegisterMeshBlendingPostProcessBlock", MESH_BLENDING_BLOCKER);
5449
+ }
5450
+ //#endregion
5316
5451
  //#region src/textures/textures.ts
5317
5452
  /**
5318
5453
  * Babylon.js-compatible texture wrappers over Babylon Lite's `loadTexture2D`.
@@ -7741,7 +7876,23 @@ var ShadowGenerator = class {
7741
7876
  _flushCasterSync() {
7742
7877
  if (!this._casterSyncDirty || !this._liteGen) return;
7743
7878
  this._casterSyncDirty = false;
7744
- setShadowTaskCasterMeshes(this._liteGen, this._casters.map((caster) => caster._lite));
7879
+ setShadowTaskCasterMeshes(this._liteGen, this._liteCasterMeshes());
7880
+ }
7881
+ /**
7882
+ * The Lite meshes handed to the native shadow task: every requested caster that carries GPU geometry.
7883
+ * The compat loader wraps a model's complete hierarchy as `Mesh`es, so `addShadowCaster(root, true)`
7884
+ * legitimately collects transform-only roots and intermediate nodes into `renderList`, exactly as
7885
+ * Babylon.js does. Those nodes must not reach the native state: the render task cannot build a
7886
+ * renderable for a mesh without `_gpu` (it would throw inside the frame, every frame), and directional
7887
+ * fitting would substitute default bounds for it, distorting the shadow volume.
7888
+ */
7889
+ _liteCasterMeshes() {
7890
+ const meshes = [];
7891
+ for (const caster of this._casters) {
7892
+ const lite = caster._lite;
7893
+ if (lite._gpu) meshes.push(lite);
7894
+ }
7895
+ return meshes;
7745
7896
  }
7746
7897
  /** Babylon.js `getShadowMap()` — returns a minimal render-list holder for parity. */
7747
7898
  getShadowMap() {
@@ -7814,8 +7965,7 @@ var ShadowGenerator = class {
7814
7965
  liteLight.shadowGenerator = liteGen;
7815
7966
  this._liteGen = liteGen;
7816
7967
  this._casterSyncDirty = false;
7817
- const casterMeshes = this._casters.map((m) => m._lite);
7818
- setShadowTaskCasterMeshes(liteGen, casterMeshes);
7968
+ setShadowTaskCasterMeshes(liteGen, this._liteCasterMeshes());
7819
7969
  }
7820
7970
  };
7821
7971
  /** Babylon.js `CascadedShadowGenerator` backed by Lite's native CSM generator. */
@@ -9581,6 +9731,237 @@ function CreateMicrophoneSoundSourceAsync(name, options, engine) {
9581
9731
  return resolveEngine(engine).createMicrophoneSoundSourceAsync(name, options);
9582
9732
  }
9583
9733
  //#endregion
9734
+ //#region src/materials/material-plugin.ts
9735
+ var MATERIAL_PLUGIN_INCLUDES_UNSUPPORTED = "Babylon.js shader includes depend on its ShaderStore include registry and expansion pipeline. Lite has no compatible include registry, and introducing one is a loader/shader-subsystem design rather than adapter translation.";
9736
+ var MATERIAL_PLUGIN_REGEX_UNSUPPORTED = "Regular-expression shader replacement requires access to the composed host shader source. Lite's plugin bridge exposes fixed injection slots only, so adding regex rewriting requires a new Lite shader-composition contract.";
9737
+ var MATERIAL_PLUGIN_HOOKS_UNSUPPORTED = "This Babylon.js plugin overrides hooks outside fixed-slot custom shader code. Executing those hooks requires Babylon.js-compatible define, uniform-buffer, sampler, texture, mesh-attribute, or render-target bridge contracts that Lite does not expose.";
9738
+ function toLiteCustomCode(code) {
9739
+ if (!code) return null;
9740
+ const translated = {};
9741
+ for (const [point, value] of Object.entries(code)) {
9742
+ if (point.startsWith("!")) return unsupported("MaterialPluginBase.getCustomCode(regex)", MATERIAL_PLUGIN_REGEX_UNSUPPORTED);
9743
+ switch (point) {
9744
+ case "CUSTOM_FRAGMENT_DEFINITIONS":
9745
+ case "CUSTOM_FRAGMENT_MAIN_BEGIN":
9746
+ case "CUSTOM_FRAGMENT_UPDATE_ALPHA":
9747
+ case "CUSTOM_FRAGMENT_UPDATE_DIFFUSE":
9748
+ case "CUSTOM_FRAGMENT_BEFORE_LIGHTS":
9749
+ case "CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION":
9750
+ case "CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR":
9751
+ case "CUSTOM_VERTEX_MAIN_BEGIN":
9752
+ case "CUSTOM_VERTEX_UPDATE_WORLDPOS":
9753
+ case "CUSTOM_VERTEX_MAIN_END":
9754
+ translated[point] = value;
9755
+ break;
9756
+ default: return unsupported(`MaterialPluginBase.getCustomCode(${point})`, "Lite's material-plugin bridge does not expose this Babylon.js shader injection point.");
9757
+ }
9758
+ }
9759
+ return translated;
9760
+ }
9761
+ function toLiteDefines(defines) {
9762
+ const translated = {};
9763
+ for (const [name, value] of Object.entries(defines)) if (typeof value === "boolean" || typeof value === "number") translated[name] = value;
9764
+ return translated;
9765
+ }
9766
+ /** Babylon.js-shaped manager for the adapter-visible material plugin list. */
9767
+ var MaterialPluginManager = class {
9768
+ _plugins = [];
9769
+ constructor(material) {}
9770
+ /** @internal Attach a plugin through Lite's descriptor list. */
9771
+ _addPlugin(plugin) {
9772
+ if (this._plugins.some((candidate) => candidate.name === plugin.name)) return false;
9773
+ this._plugins.push(plugin);
9774
+ this._plugins.sort((a, b) => a.priority - b.priority);
9775
+ plugin._attachToLiteMaterial();
9776
+ return true;
9777
+ }
9778
+ /** @internal Activate a plugin through Lite's descriptor state. */
9779
+ _activatePlugin(plugin) {
9780
+ plugin._setLiteEnabled(true);
9781
+ }
9782
+ /** @internal Remove a disposed plugin from the adapter-visible list. */
9783
+ _removePlugin(plugin) {
9784
+ const index = this._plugins.indexOf(plugin);
9785
+ if (index >= 0) this._plugins.splice(index, 1);
9786
+ }
9787
+ getPlugin(name) {
9788
+ return this._plugins.find((plugin) => plugin.name === name) ?? null;
9789
+ }
9790
+ };
9791
+ /**
9792
+ * Babylon.js `MaterialPluginBase` adapter over Lite's opt-in material-plugin
9793
+ * bridge. Subclasses keep the Babylon.js override shape while Lite receives a
9794
+ * plain plugin descriptor.
9795
+ */
9796
+ var MaterialPluginBase = class MaterialPluginBase {
9797
+ _name;
9798
+ _priority;
9799
+ _resolveIncludes = false;
9800
+ markAllDefinesAsDirty;
9801
+ registerForExtraEvents = false;
9802
+ doNotSerialize = false;
9803
+ _material;
9804
+ _pluginManager;
9805
+ _pluginDefineNames;
9806
+ /** @internal Plain plugin descriptor attached to the backing Lite material. */
9807
+ _lite;
9808
+ constructor(material, name, priority, defines = {}, addToPluginList = true, enable = false, resolveIncludes = false) {
9809
+ this._material = material;
9810
+ this._name = name;
9811
+ this._priority = priority;
9812
+ this.resolveIncludes = resolveIncludes;
9813
+ this._pluginDefineNames = defines;
9814
+ this._pluginManager = material.pluginManager ??= new MaterialPluginManager(material);
9815
+ this.markAllDefinesAsDirty = () => material._markPluginDefinesDirty();
9816
+ this._lite = {
9817
+ get name() {
9818
+ return name;
9819
+ },
9820
+ get priority() {
9821
+ return priority;
9822
+ },
9823
+ defines: toLiteDefines(defines),
9824
+ isEnabled: enable,
9825
+ getCustomCode: (shaderType) => {
9826
+ this._assertSupportedExecution();
9827
+ return this.isCompatible(ShaderLanguage.WGSL) ? toLiteCustomCode(this.getCustomCode(shaderType, ShaderLanguage.WGSL)) : null;
9828
+ }
9829
+ };
9830
+ if (addToPluginList) this._pluginManager._addPlugin(this);
9831
+ }
9832
+ get name() {
9833
+ return this._name;
9834
+ }
9835
+ set name(value) {
9836
+ this._name = value;
9837
+ Object.defineProperty(this._lite, "name", {
9838
+ configurable: true,
9839
+ enumerable: true,
9840
+ get: () => this._name
9841
+ });
9842
+ }
9843
+ get priority() {
9844
+ return this._priority;
9845
+ }
9846
+ set priority(value) {
9847
+ this._priority = value;
9848
+ Object.defineProperty(this._lite, "priority", {
9849
+ configurable: true,
9850
+ enumerable: true,
9851
+ get: () => this._priority
9852
+ });
9853
+ }
9854
+ get resolveIncludes() {
9855
+ return this._resolveIncludes;
9856
+ }
9857
+ set resolveIncludes(value) {
9858
+ if (value) unsupported("MaterialPluginBase.resolveIncludes", MATERIAL_PLUGIN_INCLUDES_UNSUPPORTED);
9859
+ this._resolveIncludes = false;
9860
+ }
9861
+ /** @internal Unsupported derived stubs override this to avoid mutating Lite state before throwing. */
9862
+ get _attachToLite() {
9863
+ return true;
9864
+ }
9865
+ _enable(enable) {
9866
+ if (enable) this._pluginManager._activatePlugin(this);
9867
+ else this._setLiteEnabled(false);
9868
+ }
9869
+ /** @internal Attach this adapter's descriptor to the backing Lite material. */
9870
+ _attachToLiteMaterial() {
9871
+ if (!this._attachToLite) return;
9872
+ const liteMaterial = this._material._lite;
9873
+ liteMaterial.plugins = [...liteMaterial.plugins ?? [], this._lite];
9874
+ this._material._usesMaterialPlugins = true;
9875
+ this._material.getScene()?._requestMaterialPlugins(this._material._lite);
9876
+ }
9877
+ /** @internal Update this adapter's Lite activation state. */
9878
+ _setLiteEnabled(enable) {
9879
+ this._lite.isEnabled = enable;
9880
+ this.markAllDefinesAsDirty();
9881
+ }
9882
+ _assertSupportedExecution() {
9883
+ if (this.resolveIncludes) unsupported("MaterialPluginBase.resolveIncludes", MATERIAL_PLUGIN_INCLUDES_UNSUPPORTED);
9884
+ const base = MaterialPluginBase.prototype;
9885
+ if (this.registerForExtraEvents || this.collectDefines !== base.collectDefines || this.prepareDefinesBeforeAttributes !== base.prepareDefinesBeforeAttributes || this.prepareDefines !== base.prepareDefines || this.isReadyForSubMesh !== base.isReadyForSubMesh || this.hardBindForSubMesh !== base.hardBindForSubMesh || this.bindForSubMesh !== base.bindForSubMesh || this.hasTexture !== base.hasTexture || this.hasRenderTargetTextures !== base.hasRenderTargetTextures || this.fillRenderTargetTextures !== base.fillRenderTargetTextures || this.getActiveTextures !== base.getActiveTextures || this.getAnimatables !== base.getAnimatables || this.addFallbacks !== base.addFallbacks || this.getSamplers !== base.getSamplers || this.getAttributes !== base.getAttributes || this.getUniformBuffersNames !== base.getUniformBuffersNames || this.getUniforms !== base.getUniforms) unsupported("MaterialPluginBase hooks", MATERIAL_PLUGIN_HOOKS_UNSUPPORTED);
9886
+ }
9887
+ isCompatible(_shaderLanguage) {
9888
+ return _shaderLanguage === ShaderLanguage.GLSL;
9889
+ }
9890
+ getCustomCode(_shaderType, _shaderLanguage = ShaderLanguage.GLSL) {
9891
+ return null;
9892
+ }
9893
+ isReadyForSubMesh(_defines, _scene, _engine, _subMesh) {
9894
+ return true;
9895
+ }
9896
+ hardBindForSubMesh(_uniformBuffer, _scene, _engine, _subMesh) {}
9897
+ bindForSubMesh(_uniformBuffer, _scene, _engine, _subMesh) {}
9898
+ collectDefines(defines) {
9899
+ if (!this._pluginDefineNames) return;
9900
+ for (const [name, value] of Object.entries(this._pluginDefineNames)) if (!name.startsWith("_")) {
9901
+ const valueType = typeof value;
9902
+ defines[name] = {
9903
+ type: valueType === "number" || valueType === "string" || valueType === "boolean" ? valueType : "object",
9904
+ default: value
9905
+ };
9906
+ }
9907
+ }
9908
+ prepareDefinesBeforeAttributes(_defines, _scene, _mesh) {}
9909
+ prepareDefines(_defines, _scene, _mesh) {}
9910
+ hasTexture(_texture) {
9911
+ return false;
9912
+ }
9913
+ hasRenderTargetTextures() {
9914
+ return false;
9915
+ }
9916
+ fillRenderTargetTextures(_renderTargets) {}
9917
+ getActiveTextures(_activeTextures) {}
9918
+ getAnimatables(_animatables) {}
9919
+ addFallbacks(_defines, _fallbacks, currentRank) {
9920
+ return currentRank;
9921
+ }
9922
+ getSamplers(_samplers) {}
9923
+ getAttributes(_attributes, _scene, _mesh) {}
9924
+ getUniformBuffersNames(_ubos) {}
9925
+ getUniforms(_shaderLanguage = ShaderLanguage.GLSL) {
9926
+ return {};
9927
+ }
9928
+ getClassName() {
9929
+ return "MaterialPluginBase";
9930
+ }
9931
+ copyTo(plugin) {
9932
+ plugin.name = this.name;
9933
+ plugin.priority = this.priority;
9934
+ plugin.resolveIncludes = this.resolveIncludes;
9935
+ plugin.registerForExtraEvents = this.registerForExtraEvents;
9936
+ plugin.doNotSerialize = this.doNotSerialize;
9937
+ }
9938
+ serialize() {
9939
+ return {
9940
+ name: this.name,
9941
+ priority: this.priority,
9942
+ resolveIncludes: this.resolveIncludes,
9943
+ registerForExtraEvents: this.registerForExtraEvents,
9944
+ doNotSerialize: this.doNotSerialize
9945
+ };
9946
+ }
9947
+ parse(source, _scene, _rootUrl) {
9948
+ if (typeof source.resolveIncludes === "boolean") this.resolveIncludes = source.resolveIncludes;
9949
+ if (typeof source.name === "string") this.name = source.name;
9950
+ if (typeof source.priority === "number") this.priority = source.priority;
9951
+ if (typeof source.registerForExtraEvents === "boolean") this.registerForExtraEvents = source.registerForExtraEvents;
9952
+ if (typeof source.doNotSerialize === "boolean") this.doNotSerialize = source.doNotSerialize;
9953
+ }
9954
+ dispose(_forceDisposeTextures) {
9955
+ const liteMaterial = this._material._lite;
9956
+ if (liteMaterial.plugins) {
9957
+ liteMaterial.plugins = liteMaterial.plugins.filter((plugin) => plugin !== this._lite);
9958
+ this._material._usesMaterialPlugins = liteMaterial.plugins.length > 0;
9959
+ this._material._markPluginDefinesDirty();
9960
+ }
9961
+ this._pluginManager._removePlugin(this);
9962
+ }
9963
+ };
9964
+ //#endregion
9584
9965
  //#region src/unsupported/unsupported-apis.ts
9585
9966
  /**
9586
9967
  * Stubs for Babylon.js core/loader APIs that are **known but not supported** by
@@ -9595,9 +9976,9 @@ function CreateMicrophoneSoundSourceAsync(name, options, engine) {
9595
9976
  * As Babylon Lite gains a capability, the corresponding stub here should be
9596
9977
  * replaced by a real wrapper (and its `COMPAT-STATUS.md` row upgraded).
9597
9978
  */
9598
- var WHITE_BALANCE_UNSUPPORTED = "White balance requires color-temperature math, a shader uniform, material/post-process defines, and pipeline invalidation that Babylon Lite does not expose; adding it needs a cross-cutting Lite subsystem design.";
9599
9979
  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.";
9600
9980
  var USD_LOADER_UNSUPPORTED = "OpenUSD loading requires an OpenUSD WebAssembly worker, virtual-file staging, command-buffer extraction, and a USD-to-Lite scene/material materializer; those form a new loader subsystem with unresolved ownership and material-mapping design.";
9981
+ 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.";
9601
9982
  var USDFileLoader = class {
9602
9983
  constructor(_options = {}) {
9603
9984
  unsupported("USDFileLoader", USD_LOADER_UNSUPPORTED);
@@ -9606,13 +9987,17 @@ var USDFileLoader = class {
9606
9987
  function RegisterUSDFileLoader() {
9607
9988
  return unsupported("RegisterUSDFileLoader", USD_LOADER_UNSUPPORTED);
9608
9989
  }
9609
- var MinTemperatureKelvin = 1e6 / 600;
9610
- var MaxTintMagnitude = 150;
9611
- function TemperatureTintToXyz(_temperatureKelvin, _tint) {
9612
- return unsupported("TemperatureTintToXyz", WHITE_BALANCE_UNSUPPORTED);
9990
+ 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.";
9991
+ var FlowGraphValidationSeverity = /* @__PURE__ */ function(FlowGraphValidationSeverity) {
9992
+ FlowGraphValidationSeverity[FlowGraphValidationSeverity["Error"] = 0] = "Error";
9993
+ FlowGraphValidationSeverity[FlowGraphValidationSeverity["Warning"] = 1] = "Warning";
9994
+ return FlowGraphValidationSeverity;
9995
+ }({});
9996
+ function ValidateFlowGraph(_flowGraph) {
9997
+ return unsupported("ValidateFlowGraph", FLOW_GRAPH_UNSUPPORTED);
9613
9998
  }
9614
- function GetWhiteBalanceMatrix(_temperatureKelvin, _tint) {
9615
- return unsupported("GetWhiteBalanceMatrix", WHITE_BALANCE_UNSUPPORTED);
9999
+ function ValidateFlowGraphWithBlockList(_flowGraph, _allKnownBlocks) {
10000
+ return unsupported("ValidateFlowGraphWithBlockList", FLOW_GRAPH_UNSUPPORTED);
9616
10001
  }
9617
10002
  var FluidRenderingObject = class {
9618
10003
  static UsePerParticleSizeAttribute = false;
@@ -9653,6 +10038,62 @@ var MultiMaterial = class {
9653
10038
  unsupported("MultiMaterial", "Babylon Lite uses one material per renderable. Split the mesh geometry by material into separate meshes instead.");
9654
10039
  }
9655
10040
  };
10041
+ var DitheredTileFadeMaterialPlugin = class DitheredTileFadeMaterialPlugin extends MaterialPluginBase {
10042
+ static Name = "DitheredTileFade";
10043
+ /** @internal The unsupported constructor must not alter the material or scene. */
10044
+ get _attachToLite() {
10045
+ return false;
10046
+ }
10047
+ constructor(material) {
10048
+ super(material, DitheredTileFadeMaterialPlugin.Name, 190);
10049
+ unsupported("DitheredTileFadeMaterialPlugin", DITHERED_TILE_FADE_UNSUPPORTED);
10050
+ }
10051
+ static GetOrCreate(_material) {
10052
+ return unsupported("DitheredTileFadeMaterialPlugin.GetOrCreate", DITHERED_TILE_FADE_UNSUPPORTED);
10053
+ }
10054
+ get isEnabled() {
10055
+ return unsupported("DitheredTileFadeMaterialPlugin.isEnabled", DITHERED_TILE_FADE_UNSUPPORTED);
10056
+ }
10057
+ set isEnabled(_value) {
10058
+ unsupported("DitheredTileFadeMaterialPlugin.isEnabled", DITHERED_TILE_FADE_UNSUPPORTED);
10059
+ }
10060
+ setFadeBounds(_mesh, _lowerBound, _upperBound) {
10061
+ unsupported("DitheredTileFadeMaterialPlugin.setFadeBounds", DITHERED_TILE_FADE_UNSUPPORTED);
10062
+ }
10063
+ setFadeLowerBound(_mesh, _lowerBound) {
10064
+ unsupported("DitheredTileFadeMaterialPlugin.setFadeLowerBound", DITHERED_TILE_FADE_UNSUPPORTED);
10065
+ }
10066
+ setFadeUpperBound(_mesh, _upperBound) {
10067
+ unsupported("DitheredTileFadeMaterialPlugin.setFadeUpperBound", DITHERED_TILE_FADE_UNSUPPORTED);
10068
+ }
10069
+ getFadeBoundsToRef(_mesh, _result) {
10070
+ return unsupported("DitheredTileFadeMaterialPlugin.getFadeBoundsToRef", DITHERED_TILE_FADE_UNSUPPORTED);
10071
+ }
10072
+ resetFade(_mesh) {
10073
+ unsupported("DitheredTileFadeMaterialPlugin.resetFade", DITHERED_TILE_FADE_UNSUPPORTED);
10074
+ }
10075
+ setThinInstanceFadeBounds(_mesh, _index, _lowerBound, _upperBound, _refresh = true) {
10076
+ unsupported("DitheredTileFadeMaterialPlugin.setThinInstanceFadeBounds", DITHERED_TILE_FADE_UNSUPPORTED);
10077
+ }
10078
+ setThinInstanceFadeBoundsBuffer(_mesh, _bounds) {
10079
+ unsupported("DitheredTileFadeMaterialPlugin.setThinInstanceFadeBoundsBuffer", DITHERED_TILE_FADE_UNSUPPORTED);
10080
+ }
10081
+ commitThinInstanceFadeBounds(_mesh) {
10082
+ unsupported("DitheredTileFadeMaterialPlugin.commitThinInstanceFadeBounds", DITHERED_TILE_FADE_UNSUPPORTED);
10083
+ }
10084
+ resetThinInstanceFade(_mesh, _index, _refresh = true) {
10085
+ unsupported("DitheredTileFadeMaterialPlugin.resetThinInstanceFade", DITHERED_TILE_FADE_UNSUPPORTED);
10086
+ }
10087
+ reset() {
10088
+ unsupported("DitheredTileFadeMaterialPlugin.reset", DITHERED_TILE_FADE_UNSUPPORTED);
10089
+ }
10090
+ copyToMaterial(_material) {
10091
+ return unsupported("DitheredTileFadeMaterialPlugin.copyToMaterial", DITHERED_TILE_FADE_UNSUPPORTED);
10092
+ }
10093
+ getClassName() {
10094
+ return "DitheredTileFadeMaterialPlugin";
10095
+ }
10096
+ };
9656
10097
  var ShaderMaterial = class {
9657
10098
  constructor() {
9658
10099
  unsupported("ShaderMaterial", "Babylon Lite is WGSL-only. Use the native `createShaderMaterial` (WGSL) API; there is no automatic GLSL translation.");
@@ -9951,6 +10392,9 @@ var GaussianSplattingStream = class {
9951
10392
  constructor(..._args) {
9952
10393
  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.");
9953
10394
  }
10395
+ get minimumResidentSplats() {
10396
+ 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.");
10397
+ }
9954
10398
  };
9955
10399
  /** Babylon.js `AddGaussianSplattingStreamPart` — appends a streamed LOD part to a GS compound mesh. */
9956
10400
  function AddGaussianSplattingStreamPart(..._args) {
@@ -10030,8 +10474,228 @@ var SceneSerializer = {
10030
10474
  }
10031
10475
  };
10032
10476
  //#endregion
10477
+ //#region src/loading/unsupported-khr-interactivity.ts
10478
+ var KHR_INTERACTIVITY_UNSUPPORTED = "KHR_interactivity depends on Babylon.js FlowGraph block, connection, context, serialization, and glTF-reference models. Lite's flow-graph runtime uses a different graph model, so a stable cross-model adapter requires a broader loader/runtime design.";
10479
+ var KHR_INTERACTIVITY_EXPORT_UNSUPPORTED = "KHR_interactivity export planning depends on Babylon.js FlowGraph block provenance and the Babylon.js glTF serializer's final entity-index remapping context. Lite exposes a different runtime graph model and no glTF serializer.";
10480
+ function ParseDebugLogTemplate(_message) {
10481
+ return unsupported("GLTF2.ParseDebugLogTemplate", KHR_INTERACTIVITY_UNSUPPORTED);
10482
+ }
10483
+ function getMappingForFullOperationName(_operation) {
10484
+ return unsupported("GLTF2.getMappingForFullOperationName", KHR_INTERACTIVITY_UNSUPPORTED);
10485
+ }
10486
+ function getMappingForDeclaration(_declaration, _returnNoOpIfNotAvailable = true) {
10487
+ return unsupported("GLTF2.getMappingForDeclaration", KHR_INTERACTIVITY_UNSUPPORTED);
10488
+ }
10489
+ function getNoOpMappingForDeclaration(_declaration) {
10490
+ return unsupported("GLTF2.getNoOpMappingForDeclaration", KHR_INTERACTIVITY_UNSUPPORTED);
10491
+ }
10492
+ function addNewInteractivityFlowGraphMapping(_key, _extension, _mapping) {
10493
+ unsupported("GLTF2.addNewInteractivityFlowGraphMapping", KHR_INTERACTIVITY_UNSUPPORTED);
10494
+ }
10495
+ function getAllSupportedNativeNodeTypes() {
10496
+ return unsupported("GLTF2.getAllSupportedNativeNodeTypes", KHR_INTERACTIVITY_UNSUPPORTED);
10497
+ }
10498
+ function HasDefaultInteractivityFlowInput(operation) {
10499
+ return hasDefaultInteractivityFlowInput(operation);
10500
+ }
10501
+ function NormalizeInteractivityEventDataConfiguration(value) {
10502
+ return normalizeInteractivityEventDataConfiguration(value);
10503
+ }
10504
+ function GetInteractivityOperationRegistry() {
10505
+ return unsupported("GLTF2.GetInteractivityOperationRegistry", KHR_INTERACTIVITY_UNSUPPORTED);
10506
+ }
10507
+ var gltfTypeToBabylonType = {
10508
+ float: {
10509
+ length: 1,
10510
+ flowGraphType: "number",
10511
+ elementType: "number"
10512
+ },
10513
+ bool: {
10514
+ length: 1,
10515
+ flowGraphType: "boolean",
10516
+ elementType: "boolean"
10517
+ },
10518
+ float2: {
10519
+ length: 2,
10520
+ flowGraphType: "Vector2",
10521
+ elementType: "number"
10522
+ },
10523
+ float3: {
10524
+ length: 3,
10525
+ flowGraphType: "Vector3",
10526
+ elementType: "number"
10527
+ },
10528
+ float4: {
10529
+ length: 4,
10530
+ flowGraphType: "Vector4",
10531
+ elementType: "number"
10532
+ },
10533
+ float4x4: {
10534
+ length: 16,
10535
+ flowGraphType: "Matrix",
10536
+ elementType: "number"
10537
+ },
10538
+ float2x2: {
10539
+ length: 4,
10540
+ flowGraphType: "Matrix2D",
10541
+ elementType: "number"
10542
+ },
10543
+ float3x3: {
10544
+ length: 9,
10545
+ flowGraphType: "Matrix3D",
10546
+ elementType: "number"
10547
+ },
10548
+ int: {
10549
+ length: 1,
10550
+ flowGraphType: "FlowGraphInteger",
10551
+ elementType: "number"
10552
+ },
10553
+ ref: {
10554
+ length: 1,
10555
+ flowGraphType: "string",
10556
+ elementType: "string"
10557
+ },
10558
+ custom: {
10559
+ length: 0,
10560
+ flowGraphType: "any",
10561
+ elementType: "any"
10562
+ }
10563
+ };
10564
+ var FlowGraphEventReferenceBlock = class {
10565
+ config;
10566
+ constructor(config) {
10567
+ this.config = config;
10568
+ unsupported("GLTF2.FlowGraphEventReferenceBlock", KHR_INTERACTIVITY_UNSUPPORTED);
10569
+ }
10570
+ };
10571
+ var FlowGraphGLTFDataProvider = class {
10572
+ constructor(_config = {}) {
10573
+ unsupported("GLTF2.FlowGraphGLTFDataProvider", KHR_INTERACTIVITY_UNSUPPORTED);
10574
+ }
10575
+ };
10576
+ function GetInteractivityObjectReference(_context, _value) {
10577
+ return unsupported("GLTF2.GetInteractivityObjectReference", KHR_INTERACTIVITY_UNSUPPORTED);
10578
+ }
10579
+ var FlowGraphObjectReferenceBlock = class {
10580
+ constructor(_config = {}) {
10581
+ unsupported("GLTF2.FlowGraphObjectReferenceBlock", KHR_INTERACTIVITY_UNSUPPORTED);
10582
+ }
10583
+ };
10584
+ var FlowGraphUnsupportedInteractivityBlock = class {
10585
+ config;
10586
+ constructor(config) {
10587
+ this.config = config;
10588
+ unsupported("GLTF2.FlowGraphUnsupportedInteractivityBlock", KHR_INTERACTIVITY_UNSUPPORTED);
10589
+ }
10590
+ };
10591
+ var KHR_INTERACTIVITY_SPECIFICATION_COMMIT = "f798712c5685bc9223a628140fba707db8889300";
10592
+ function _NormalizeKHRInteractivityRuntimeValue(value) {
10593
+ return normalizeKhrInteractivityRuntimeValue(value);
10594
+ }
10595
+ function _CreateKHRInteractivityRuntimeValueSnapshot(value) {
10596
+ return createKhrInteractivityRuntimeValueSnapshot(value);
10597
+ }
10598
+ function CloneKHRInteractivityGraph(_graph) {
10599
+ return unsupported("GLTF2.CloneKHRInteractivityGraph", KHR_INTERACTIVITY_UNSUPPORTED);
10600
+ }
10601
+ function CreateEffectiveKHRInteractivityGraph(_graph, _declarations, _assetNodeCount) {
10602
+ return unsupported("GLTF2.CreateEffectiveKHRInteractivityGraph", KHR_INTERACTIVITY_UNSUPPORTED);
10603
+ }
10604
+ function CreateKHRInteractivityGraphModel(_graph, _index = 0, _supportedExtensions, _assetNodeCount) {
10605
+ return unsupported("GLTF2.CreateKHRInteractivityGraphModel", KHR_INTERACTIVITY_UNSUPPORTED);
10606
+ }
10607
+ function CreateKHRInteractivityDocument(_extension, _supportedExtensions, _assetNodeCount) {
10608
+ return unsupported("GLTF2.CreateKHRInteractivityDocument", KHR_INTERACTIVITY_UNSUPPORTED);
10609
+ }
10610
+ function _CaptureKHRInteractivityRuntimeInputDefaults(_flowGraph) {
10611
+ unsupported("GLTF2._CaptureKHRInteractivityRuntimeInputDefaults", KHR_INTERACTIVITY_UNSUPPORTED);
10612
+ }
10613
+ var KHRInteractivityExportError = class extends Error {
10614
+ diagnostics;
10615
+ constructor(diagnostics) {
10616
+ super(diagnostics.map((diagnostic) => `${diagnostic.path}: ${diagnostic.message}`).join("\n"));
10617
+ this.diagnostics = diagnostics;
10618
+ this.name = "KHRInteractivityExportError";
10619
+ }
10620
+ };
10621
+ var KHRInteractivityExportPlan = class {
10622
+ required = true;
10623
+ additionalExtensionsUsed = [];
10624
+ additionalExtensionsRequired = [];
10625
+ constructor(_flowGraphs, _options = {}) {
10626
+ unsupported("GLTF2.KHRInteractivityExportPlan", KHR_INTERACTIVITY_EXPORT_UNSUPPORTED);
10627
+ }
10628
+ analyze() {
10629
+ return unsupported("GLTF2.KHRInteractivityExportPlan.analyze", KHR_INTERACTIVITY_EXPORT_UNSUPPORTED);
10630
+ }
10631
+ build(_context) {
10632
+ return unsupported("GLTF2.KHRInteractivityExportPlan.build", KHR_INTERACTIVITY_EXPORT_UNSUPPORTED);
10633
+ }
10634
+ };
10635
+ function CreateKHRInteractivityExportPlan(flowGraphs, options = {}) {
10636
+ return new KHRInteractivityExportPlan(flowGraphs, options);
10637
+ }
10638
+ var InteractivityGraphToFlowGraphParser = class {
10639
+ /** @internal Upstream parser timing state; the parser itself is unsupported. */
10640
+ _animationTargetFps;
10641
+ constructor(_interactivityGraph, _gltf, animationTargetFps = 60, _graphIndex = 0, _supportedExtensions, _declarationModels) {
10642
+ this._animationTargetFps = animationTargetFps;
10643
+ unsupported("GLTF2.InteractivityGraphToFlowGraphParser", KHR_INTERACTIVITY_UNSUPPORTED);
10644
+ }
10645
+ getVariableName(_index) {
10646
+ return unsupported("GLTF2.InteractivityGraphToFlowGraphParser.getVariableName", KHR_INTERACTIVITY_UNSUPPORTED);
10647
+ }
10648
+ get arrays() {
10649
+ return unsupported("GLTF2.InteractivityGraphToFlowGraphParser.arrays", KHR_INTERACTIVITY_UNSUPPORTED);
10650
+ }
10651
+ serializeToFlowGraph() {
10652
+ return unsupported("GLTF2.InteractivityGraphToFlowGraphParser.serializeToFlowGraph", KHR_INTERACTIVITY_UNSUPPORTED);
10653
+ }
10654
+ };
10655
+ function InitializeInteractivityNodeState(_nodes, _state, _getAuthoredState) {
10656
+ unsupported("GLTF2.InitializeInteractivityNodeState", KHR_INTERACTIVITY_UNSUPPORTED);
10657
+ }
10658
+ function GetInteractivityNodeState(_node, _state) {
10659
+ return unsupported("GLTF2.GetInteractivityNodeState", KHR_INTERACTIVITY_UNSUPPORTED);
10660
+ }
10661
+ function SetInteractivityNodeState(_node, _state, _value) {
10662
+ unsupported("GLTF2.SetInteractivityNodeState", KHR_INTERACTIVITY_UNSUPPORTED);
10663
+ }
10664
+ //#endregion
10033
10665
  //#region src/loading/gltf2.ts
10034
- var gltf2_exports = /* @__PURE__ */ __exportAll({ OpenPBRMaterialLoadingAdapter: () => OpenPBRMaterialLoadingAdapter });
10666
+ var gltf2_exports = /* @__PURE__ */ __exportAll({
10667
+ CloneKHRInteractivityGraph: () => CloneKHRInteractivityGraph,
10668
+ CreateEffectiveKHRInteractivityGraph: () => CreateEffectiveKHRInteractivityGraph,
10669
+ CreateKHRInteractivityDocument: () => CreateKHRInteractivityDocument,
10670
+ CreateKHRInteractivityExportPlan: () => CreateKHRInteractivityExportPlan,
10671
+ CreateKHRInteractivityGraphModel: () => CreateKHRInteractivityGraphModel,
10672
+ FlowGraphEventReferenceBlock: () => FlowGraphEventReferenceBlock,
10673
+ FlowGraphGLTFDataProvider: () => FlowGraphGLTFDataProvider,
10674
+ FlowGraphObjectReferenceBlock: () => FlowGraphObjectReferenceBlock,
10675
+ FlowGraphUnsupportedInteractivityBlock: () => FlowGraphUnsupportedInteractivityBlock,
10676
+ GetInteractivityNodeState: () => GetInteractivityNodeState,
10677
+ GetInteractivityObjectReference: () => GetInteractivityObjectReference,
10678
+ GetInteractivityOperationRegistry: () => GetInteractivityOperationRegistry,
10679
+ HasDefaultInteractivityFlowInput: () => HasDefaultInteractivityFlowInput,
10680
+ InitializeInteractivityNodeState: () => InitializeInteractivityNodeState,
10681
+ InteractivityGraphToFlowGraphParser: () => InteractivityGraphToFlowGraphParser,
10682
+ KHRInteractivityExportError: () => KHRInteractivityExportError,
10683
+ KHRInteractivityExportPlan: () => KHRInteractivityExportPlan,
10684
+ KHR_INTERACTIVITY_SPECIFICATION_COMMIT: () => KHR_INTERACTIVITY_SPECIFICATION_COMMIT,
10685
+ NormalizeInteractivityEventDataConfiguration: () => NormalizeInteractivityEventDataConfiguration,
10686
+ OpenPBRMaterialLoadingAdapter: () => OpenPBRMaterialLoadingAdapter,
10687
+ ParseDebugLogTemplate: () => ParseDebugLogTemplate,
10688
+ SetInteractivityNodeState: () => SetInteractivityNodeState,
10689
+ _CaptureKHRInteractivityRuntimeInputDefaults: () => _CaptureKHRInteractivityRuntimeInputDefaults,
10690
+ _CreateKHRInteractivityRuntimeValueSnapshot: () => _CreateKHRInteractivityRuntimeValueSnapshot,
10691
+ _NormalizeKHRInteractivityRuntimeValue: () => _NormalizeKHRInteractivityRuntimeValue,
10692
+ addNewInteractivityFlowGraphMapping: () => addNewInteractivityFlowGraphMapping,
10693
+ getAllSupportedNativeNodeTypes: () => getAllSupportedNativeNodeTypes,
10694
+ getMappingForDeclaration: () => getMappingForDeclaration,
10695
+ getMappingForFullOperationName: () => getMappingForFullOperationName,
10696
+ getNoOpMappingForDeclaration: () => getNoOpMappingForDeclaration,
10697
+ gltfTypeToBabylonType: () => gltfTypeToBabylonType
10698
+ });
10035
10699
  //#endregion
10036
10700
  //#region src/loading/gltf1.ts
10037
10701
  var gltf1_exports = /* @__PURE__ */ __exportAll({
@@ -10197,6 +10861,7 @@ var WeightedSound = class {
10197
10861
  unsupported("WeightedSound", "Audio is not part of Babylon Lite.");
10198
10862
  }
10199
10863
  };
10864
+ var FBX_LOADER_UNSUPPORTED = "FBX support requires a parser, DCC transform/material/animation mapping, geometry and skin materialization, and a scene-scheduled constraint solver. Those form a new loader subsystem with unresolved ownership and mapping policies.";
10200
10865
  var OBJFileLoader = class {
10201
10866
  constructor() {
10202
10867
  unsupported("OBJFileLoader", "The OBJ format is not supported by Babylon Lite. Convert to glTF.");
@@ -10207,9 +10872,77 @@ var STLFileLoader = class {
10207
10872
  unsupported("STLFileLoader", "The STL format is not supported by Babylon Lite. Convert to glTF.");
10208
10873
  }
10209
10874
  };
10875
+ var FBXFileLoaderMetadata = {
10876
+ name: "fbx",
10877
+ extensions: { ".fbx": { isBinary: true } }
10878
+ };
10210
10879
  var FBXFileLoader = class {
10880
+ constructor(_options = {}) {
10881
+ unsupported("FBXFileLoader", FBX_LOADER_UNSUPPORTED);
10882
+ }
10883
+ };
10884
+ var FBXConstraintSolver = class {
10211
10885
  constructor() {
10212
- unsupported("FBXFileLoader", "The FBX format is not supported by Babylon Lite. Convert to glTF.");
10886
+ unsupported("FBXConstraintSolver", FBX_LOADER_UNSUPPORTED);
10887
+ }
10888
+ static Get(_scene) {
10889
+ return unsupported("FBXConstraintSolver.Get", FBX_LOADER_UNSUPPORTED);
10890
+ }
10891
+ static GetOrCreate(_scene) {
10892
+ return unsupported("FBXConstraintSolver.GetOrCreate", FBX_LOADER_UNSUPPORTED);
10893
+ }
10894
+ get constraints() {
10895
+ return unsupported("FBXConstraintSolver.constraints", FBX_LOADER_UNSUPPORTED);
10896
+ }
10897
+ get cyclicConstraints() {
10898
+ return unsupported("FBXConstraintSolver.cyclicConstraints", FBX_LOADER_UNSUPPORTED);
10899
+ }
10900
+ register(_behavior) {
10901
+ unsupported("FBXConstraintSolver.register", FBX_LOADER_UNSUPPORTED);
10902
+ }
10903
+ unregister(_behavior) {
10904
+ unsupported("FBXConstraintSolver.unregister", FBX_LOADER_UNSUPPORTED);
10905
+ }
10906
+ invalidateOrder() {
10907
+ unsupported("FBXConstraintSolver.invalidateOrder", FBX_LOADER_UNSUPPORTED);
10908
+ }
10909
+ beginFrame() {
10910
+ unsupported("FBXConstraintSolver.beginFrame", FBX_LOADER_UNSUPPORTED);
10911
+ }
10912
+ solve() {
10913
+ unsupported("FBXConstraintSolver.solve", FBX_LOADER_UNSUPPORTED);
10914
+ }
10915
+ };
10916
+ var FBXConstraintBehavior = class {
10917
+ constraint;
10918
+ name;
10919
+ attachedNode = null;
10920
+ enabled = true;
10921
+ constructor(constraint, _options) {
10922
+ this.constraint = constraint;
10923
+ this.name = `fbxConstraint:${constraint.name}`;
10924
+ unsupported("FBXConstraintBehavior", FBX_LOADER_UNSUPPORTED);
10925
+ }
10926
+ init() {
10927
+ unsupported("FBXConstraintBehavior.init", FBX_LOADER_UNSUPPORTED);
10928
+ }
10929
+ attach(_target) {
10930
+ unsupported("FBXConstraintBehavior.attach", FBX_LOADER_UNSUPPORTED);
10931
+ }
10932
+ detach() {
10933
+ unsupported("FBXConstraintBehavior.detach", FBX_LOADER_UNSUPPORTED);
10934
+ }
10935
+ captureBase() {
10936
+ unsupported("FBXConstraintBehavior.captureBase", FBX_LOADER_UNSUPPORTED);
10937
+ }
10938
+ restoreBase() {
10939
+ unsupported("FBXConstraintBehavior.restoreBase", FBX_LOADER_UNSUPPORTED);
10940
+ }
10941
+ dependencyNodes() {
10942
+ return unsupported("FBXConstraintBehavior.dependencyNodes", FBX_LOADER_UNSUPPORTED);
10943
+ }
10944
+ evaluate() {
10945
+ unsupported("FBXConstraintBehavior.evaluate", FBX_LOADER_UNSUPPORTED);
10213
10946
  }
10214
10947
  };
10215
10948
  var BVHFileLoader = class {
@@ -10581,6 +11314,6 @@ var NodeParticleSystemSet = class NodeParticleSystemSet {
10581
11314
  }
10582
11315
  };
10583
11316
  //#endregion
10584
- 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, 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, Condition, Constants, CreateAudioBusAsync, CreateAudioEngineAsync, CreateBox, CreateCylinder, CreateDashedLines, CreateDisc, CreateGreasedLine, CreateGreasedLineMaterial, CreateGround, CreateLineSystem, CreateLines, CreateMainAudioBusAsync, CreateMicrophoneSoundSourceAsync, CreatePlane, CreateSoundAsync, CreateSoundBufferAsync, CreateSoundSourceAsync, CreateSphere, CreateStreamingSoundAsync, CreateTexture2DArrayFromImageUrlsAsync, CreateTexture2DArrayFromKTX2Async, CreateTiledBox, CreateTiledPlane, CreateTorus, CubeTexture, CubicEase, Curve3, CustomAssetTask, DefaultRenderingPipeline, DepthOfFieldEffect, DepthRenderer, DeviceOrientationCamera, DirectionalLight, DistanceConstraint, DynamicTexture, EASINGMODE_EASEIN, EASINGMODE_EASEINOUT, EASINGMODE_EASEOUT, EasingFunction, EdgesRenderer, EffectLayer, ElasticEase, Engine, Epsilon, ExecuteCodeAction, ExponentialEase, FBXFileLoader, FSR1RenderingPipeline, FactorGradient, FadeInOutBehavior, FluidRenderer, FluidRendererSceneComponent, FluidRenderingObject, FluidRenderingObjectCustomParticles, FluidRenderingObjectParticleSystem, FluidRenderingTargetRenderer, FlyCamera, FollowBehavior, FollowCamera, 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, Matrix, MaxTintMagnitude, Mesh, MeshBuilder, MeshoptCompression, MinTemperatureKelvin, MirrorTexture, MorphTarget, MorphTargetManager, MultiMaterial, MultiPointerScaleBehavior, Node, NodeMaterial, NodeParticleSystemSet, NullEngine, OBJFileLoader, Observable, OnAudioEngineV2CreatedObservable, OpenPBRMaterial, OpenPBRMaterialDefines, OpenPBRMaterialLoadingAdapter, OutlineRenderer, PBRAnisotropicConfiguration, PBRClearCoatConfiguration, PBRIridescenceConfiguration, PBRMaterial, PBRMetallicRoughnessMaterial, PBRSheenConfiguration, PBRSpecularGlossinessMaterial, 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, PositionGizmo, PostProcess, PrecisionDate, PredicateCondition, PrismaticConstraint, PushMaterial, QuadraticEase, QuarticEase, Quaternion, QuinticEase, RandomGUID, RawTexture, RawTexture2DArray, RawTexture3D, Ray, RecastJSPlugin, RectAreaLight, ReflectionProbe, RegisterAbstractEngineTextureLoaders, RegisterFluidRenderer, RegisterGreasedLinePluginMaterial, RegisterImageProcessingConfiguration, RegisterOpenpbrMaterial, RegisterUSDFileLoader, RenderTargetTexture, RotationGizmo, 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, StreamingSound, StringDictionary, SurfaceMagnetismBehavior, Tags, TargetCamera, TemperatureTintToXyz, Texture, ThinEngine, ThinFSR1SharpenPostProcess, ThinFSR1UpscalePostProcess, ThinSprite, ToDegrees, ToRadians, Tools, TouchCamera, TransformNode, USDFileLoader, UninstallHtmlInCanvasPolyfill, UniversalCamera, UploadHtmlElementToTexture, UploadImageToTexture2DArrayLayer, UtilityLayerRenderer, ValueCondition, ValueConditionOperators, Vector2, Vector3, Vector4, VertexBuffer, VertexData, Viewport, VirtualJoystick, WebGPUEngine, WebXRCamera, WeightedSound, registerBuiltInLoaders, transformCoordinates, transformNormal, unsupported };
11317
+ 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, 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, Condition, Constants, CreateAudioBusAsync, CreateAudioEngineAsync, CreateBox, CreateCylinder, CreateDashedLines, CreateDefaultMeshBlendRadiusDefinitions, CreateDisc, CreateGreasedLine, CreateGreasedLineMaterial, CreateGround, CreateLineSystem, CreateLines, CreateMainAudioBusAsync, CreateMicrophoneSoundSourceAsync, CreatePlane, 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, 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, PositionGizmo, PostProcess, PrecisionDate, PredicateCondition, PrismaticConstraint, PushMaterial, QuadraticEase, QuarticEase, Quaternion, QuinticEase, RandomGUID, RawTexture, RawTexture2DArray, RawTexture3D, Ray, RecastJSPlugin, RectAreaLight, ReflectionProbe, RegisterAbstractEngineTextureLoaders, RegisterEnginesExtensionsEngineTexture2DArrayImageSource, RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource, RegisterFluidRenderer, RegisterGreasedLinePluginMaterial, RegisterImageProcessingConfiguration, RegisterMeshBlendingPostProcessBlock, RegisterOpenpbrMaterial, RegisterUSDFileLoader, RenderTargetTexture, RotationGizmo, 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, StreamingSound, StringDictionary, SurfaceMagnetismBehavior, Tags, TargetCamera, TemperatureTintToXyz, Texture, ThinEngine, ThinFSR1SharpenPostProcess, ThinFSR1UpscalePostProcess, ThinMeshBlendingPostProcess, ThinSprite, ToDegrees, ToRadians, Tools, TouchCamera, TransformNode, USDFileLoader, UninstallHtmlInCanvasPolyfill, UniversalCamera, UnpackMeshBlendingTag, UploadHtmlElementToTexture, UploadImageToTexture2DArrayLayer, UtilityLayerRenderer, ValidateFlowGraph, ValidateFlowGraphWithBlockList, ValueCondition, ValueConditionOperators, Vector2, Vector3, Vector4, VertexBuffer, VertexData, Viewport, VirtualJoystick, WebGPUEngine, WebXRCamera, WeightedSound, registerBuiltInLoaders, transformCoordinates, transformNormal, unsupported };
10585
11318
 
10586
11319
  //# sourceMappingURL=index.js.map