@babylonjs/lite-compat 1.31.1-preview → 1.32.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 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, 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, disposeUtilityLayer, dividePolarToRef, divideSphericalToRef, elasticEase, enableAnalyzer, enableAnimationBlending, enableArcRotateKeyboardControls, enableBoneControlForSkinnedAssets, enableHavokThinInstancePhysicsSync, enableMirroredMeshes, enableOrthographicCamera, enableSpatial, enableStereo, exponentialEase, 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, 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, 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 { 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-Ds66ewr9.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, 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, pickMeshesWithRay, 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) => {
@@ -5422,14 +5422,32 @@ var Scene = class Scene extends AbstractScene {
5422
5422
  return this.beginDirectAnimation(target, target.animations ?? [], from, to, loop, speedRatio);
5423
5423
  }
5424
5424
  dispose() {
5425
- this._detachPointerEvents();
5426
- this.onDisposeObservable.notifyObservers(this);
5427
- this.onPointerObservable.clear();
5428
- this._beforeRenderFlushCallbacks.clear();
5429
- if (this._propertyAnimationManager) clearAnimationManager(this._propertyAnimationManager);
5430
- if (this._blendManager) clearAnimationManager(this._blendManager);
5425
+ let hasError = false;
5426
+ let firstError;
5427
+ const runCleanup = (cleanup) => {
5428
+ try {
5429
+ cleanup();
5430
+ } catch (error) {
5431
+ if (!hasError) {
5432
+ hasError = true;
5433
+ firstError = error;
5434
+ }
5435
+ }
5436
+ };
5437
+ runCleanup(() => this._detachPointerEvents());
5438
+ const observerResult = this.onDisposeObservable._notifyObserversSafely(this);
5439
+ if (observerResult.hasError && !hasError) {
5440
+ hasError = true;
5441
+ firstError = observerResult.error;
5442
+ }
5443
+ runCleanup(() => this.onDisposeObservable.clear());
5444
+ runCleanup(() => this.onPointerObservable.clear());
5445
+ runCleanup(() => this._beforeRenderFlushCallbacks.clear());
5446
+ if (this._propertyAnimationManager) runCleanup(() => clearAnimationManager(this._propertyAnimationManager));
5447
+ if (this._blendManager) runCleanup(() => clearAnimationManager(this._blendManager));
5431
5448
  this._runningAnimatables.length = 0;
5432
- disposeScene(this._lite);
5449
+ runCleanup(() => disposeScene(this._lite));
5450
+ if (hasError) throw firstError;
5433
5451
  }
5434
5452
  };
5435
5453
  //#endregion
@@ -6283,9 +6301,9 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
6283
6301
  getClassName() {
6284
6302
  return "GaussianSplattingMesh";
6285
6303
  }
6286
- /** @internal The transform-carrying Lite node: the loaded splat node once present, else the placeholder. */
6304
+ /** @internal The wrapper's transform node; the loaded cloud is parented beneath it during deferred adoption. */
6287
6305
  get _xform() {
6288
- return this._gs ?? this._node;
6306
+ return this._gs?.parent === this._node ? this._node : this._gs ?? this._node;
6289
6307
  }
6290
6308
  get position() {
6291
6309
  return liteBackedVector3(this._xform.position);
@@ -6322,12 +6340,15 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
6322
6340
  this._adopt(lite);
6323
6341
  return this;
6324
6342
  }
6325
- /** @internal Adopt a loaded Lite splat node: carry over placeholder transforms + name, and register on the scene. */
6343
+ /**
6344
+ * @internal Adopt a loaded Lite splat node from either the mesh or loader-plugin API.
6345
+ * Parenting preserves the loader's format-specific local transform while composing it
6346
+ * with transforms applied to the wrapper before loading.
6347
+ */
6326
6348
  _adopt(lite) {
6327
6349
  const placeholder = this._node;
6328
- lite.position.set(placeholder.position.x, placeholder.position.y, placeholder.position.z);
6329
- lite.scaling.set(placeholder.scaling.x, placeholder.scaling.y, placeholder.scaling.z);
6330
- lite.rotation.set(placeholder.rotation.x, placeholder.rotation.y, placeholder.rotation.z);
6350
+ lite.parent = placeholder;
6351
+ placeholder.children.push(lite);
6331
6352
  lite.name = this.name;
6332
6353
  this._gs = lite;
6333
6354
  this._scene?._registerMesh(this);
@@ -6361,7 +6382,18 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
6361
6382
  }
6362
6383
  /** Babylon.js `gs.bakeCurrentTransformIntoVertices()` — fold the node transform into the splat data. */
6363
6384
  bakeCurrentTransformIntoVertices() {
6364
- if (this._gs) bakeCurrentTransformIntoVertices(this._gs);
6385
+ if (this._gs) {
6386
+ bakeCurrentTransformIntoVertices(this._gs);
6387
+ if (this._gs.parent === this._node) {
6388
+ const userChildren = this._node.children.filter((child) => child !== this._gs && child.parent === this._node);
6389
+ for (const child of this.getChildren(void 0, true)) if (child instanceof TransformNode && child._node !== this._gs && !userChildren.includes(child._node)) userChildren.push(child._node);
6390
+ for (const child of userChildren) setParent(child, null);
6391
+ this._node.position.set(0, 0, 0);
6392
+ this._node.rotation.set(0, 0, 0);
6393
+ this._node.scaling.set(1, 1, 1);
6394
+ for (const child of userChildren) setParent(child, this._node);
6395
+ }
6396
+ }
6365
6397
  }
6366
6398
  /** @internal Babylon.js's worker-throttle flag; ported scenes poll it to detect the first sort. */
6367
6399
  get _canPostToWorker() {
@@ -7299,6 +7331,184 @@ var Bone = class Bone {
7299
7331
  }
7300
7332
  };
7301
7333
  //#endregion
7334
+ //#region src/loading/splat-file-loader.ts
7335
+ var SPLAT_ASSET_CONTAINER_UNSUPPORTED = "Lite's splat loaders attach the GPU-backed cloud directly to a scene. They do not expose a detached Gaussian-Splatting asset-container lifecycle that can preserve the BJS mesh type.";
7336
+ var SPLAT_STREAMING_UNSUPPORTED = "PlayCanvas lod-meta.json requires Babylon.js's Gaussian-Splatting streaming residency, download scheduling, and GPU work-buffer subsystem, which Babylon Lite does not define.";
7337
+ var SPLAT_DIRECTORY_UNSUPPORTED = "Directory SOG JSON requires a loader contract for resolving and decoding external texture resources relative to rootUrl; Lite's SOG loader accepts only self-contained archives.";
7338
+ var SPLAT_RELOAD_UNSUPPORTED = "Lite does not expose an atomic Gaussian-Splatting replacement lifecycle that detaches the old renderable and picker while retiring its worker and GPU resources.";
7339
+ var SPLAT_CONCURRENT_TARGET_UNSUPPORTED = "An unloaded GaussianSplattingMesh target can only be populated by one in-flight load.";
7340
+ var loadingTargets;
7341
+ function bytesOf(data) {
7342
+ if (data instanceof ArrayBuffer) return new Uint8Array(data);
7343
+ if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
7344
+ return unsupported("SPLATFileLoader", "Binary .splat, .ply, .sog, and .spz inputs must be supplied as an ArrayBuffer or ArrayBufferView.");
7345
+ }
7346
+ function loaderFor(data) {
7347
+ if (typeof data === "string") return unsupported("SPLATFileLoader", data.includes("\"lods\"") ? SPLAT_STREAMING_UNSUPPORTED : SPLAT_DIRECTORY_UNSUPPORTED);
7348
+ const bytes = bytesOf(data);
7349
+ if (bytes[0] === 80 && bytes[1] === 75) return loadSOG;
7350
+ if (bytes[0] === 31 && bytes[1] === 139 || bytes[0] === 78 && bytes[1] === 71 && bytes[2] === 83 && bytes[3] === 80) return loadSPZ;
7351
+ return loadSplat;
7352
+ }
7353
+ function loaderForUrl(url) {
7354
+ const path = url.split(/[?#]/)[0].toLowerCase();
7355
+ if (path.endsWith(".json")) return unsupported("SPLATFileLoader", SPLAT_STREAMING_UNSUPPORTED);
7356
+ if (path.endsWith(".sog")) return loadSOG;
7357
+ if (path.endsWith(".spz")) return loadSPZ;
7358
+ return loadSplat;
7359
+ }
7360
+ function binaryData(data) {
7361
+ return new Uint8Array(bytesOf(data)).buffer;
7362
+ }
7363
+ function validateOptions(options) {
7364
+ if (options.flipY === true) unsupported("SPLATLoadingOptions.flipY", "Lite's native splat parsers own their format-specific orientation conversion and do not expose a parser-level flipY override.");
7365
+ if (options.deflateURL !== void 0 || options.fflate !== void 0) unsupported("SPLATLoadingOptions.fflate", "Lite owns its SOG decompressor and does not expose Babylon.js's replaceable fflate loading policy.");
7366
+ if (options.needsRotationScaleTextures) unsupported("SPLATLoadingOptions.needsRotationScaleTextures", "Voxel IBL-shadow rotation/scale textures require Babylon.js's Gaussian-Splatting IBL shadow subsystem, which Babylon Lite does not define.");
7367
+ if (options.useSogTextures) unsupported("SPLATLoadingOptions.useSogTextures", "Lite's SOG loader uses its native CPU decode path and does not expose Babylon.js's raw-texture dequantization pipeline.");
7368
+ if (options.spzLibraryUrl !== void 0) unsupported("SPLATLoadingOptions.spzLibraryUrl", "Lite owns its SPZ decoder and does not expose a replaceable WASM-library URL policy.");
7369
+ }
7370
+ var SPLATFileLoader = class SPLATFileLoader {
7371
+ name = "splat";
7372
+ extensions = {
7373
+ ".splat": { isBinary: true },
7374
+ ".ply": { isBinary: true },
7375
+ ".spz": { isBinary: true },
7376
+ ".json": { isBinary: false },
7377
+ ".sog": { isBinary: true }
7378
+ };
7379
+ _loadingOptions;
7380
+ constructor(loadingOptions = {}) {
7381
+ this._loadingOptions = { ...loadingOptions };
7382
+ validateOptions(this._loadingOptions);
7383
+ }
7384
+ createPlugin(options) {
7385
+ return new SPLATFileLoader(options.splat);
7386
+ }
7387
+ async importMeshAsync(_meshesNames, scene, data, _rootUrl, _onProgress, _fileName) {
7388
+ return {
7389
+ meshes: [await this._load(scene, data)],
7390
+ particleSystems: [],
7391
+ skeletons: [],
7392
+ animationGroups: [],
7393
+ transformNodes: [],
7394
+ geometries: [],
7395
+ lights: [],
7396
+ spriteManagers: []
7397
+ };
7398
+ }
7399
+ async loadAsync(scene, data, rootUrl, onProgress, fileName) {
7400
+ await this.importMeshAsync(null, scene, data, rootUrl, onProgress, fileName);
7401
+ }
7402
+ loadAssetContainerAsync(_scene, _data, _rootUrl) {
7403
+ return unsupported("SPLATFileLoader.loadAssetContainerAsync", SPLAT_ASSET_CONTAINER_UNSUPPORTED);
7404
+ }
7405
+ /** @internal Load a URL through Lite while preserving this plugin's Babylon.js options. */
7406
+ async _loadUrlAsync(scene, url) {
7407
+ return this._loadReserved(scene, () => loaderForUrl(url)(scene._lite, url));
7408
+ }
7409
+ async _load(scene, data) {
7410
+ return this._loadReserved(scene, async () => {
7411
+ const loader = loaderFor(data);
7412
+ const url = URL.createObjectURL(new Blob([binaryData(data)]));
7413
+ try {
7414
+ return await loader(scene._lite, url);
7415
+ } finally {
7416
+ URL.revokeObjectURL(url);
7417
+ }
7418
+ });
7419
+ }
7420
+ async _loadReserved(scene, load) {
7421
+ const target = this._loadingOptions.gaussianSplattingMesh;
7422
+ if (target?._pickLiteNode) unsupported("SPLATLoadingOptions.gaussianSplattingMesh", SPLAT_RELOAD_UNSUPPORTED);
7423
+ if (target) {
7424
+ loadingTargets ??= /* @__PURE__ */ new WeakSet();
7425
+ if (loadingTargets.has(target)) unsupported("SPLATLoadingOptions.gaussianSplattingMesh", SPLAT_CONCURRENT_TARGET_UNSUPPORTED);
7426
+ loadingTargets.add(target);
7427
+ }
7428
+ try {
7429
+ return this._adoptLoaded(scene, await load());
7430
+ } finally {
7431
+ if (target) loadingTargets?.delete(target);
7432
+ }
7433
+ }
7434
+ _adoptLoaded(scene, lite) {
7435
+ const target = this._loadingOptions.gaussianSplattingMesh;
7436
+ if (target) {
7437
+ target._adopt(lite);
7438
+ return target;
7439
+ }
7440
+ lite.name = "GaussianSplatting";
7441
+ return GaussianSplattingMesh._fromLite(lite, scene);
7442
+ }
7443
+ };
7444
+ function RegisterSPLATFileLoader() {}
7445
+ //#endregion
7446
+ //#region src/loading/usd-options.ts
7447
+ var USD_RUNTIME_BASE_URL = "https://cdn.babylonjs.com/babylonUsdImporter/5/";
7448
+ var USD_RUNTIME_NAMES = {
7449
+ workerUrl: "babylon-usd-importer.worker.js",
7450
+ glueUrl: "babylon-usd-importer.js",
7451
+ wasmUrl: "babylon-usd-importer.wasm",
7452
+ dataUrl: "babylon-usd-importer.data"
7453
+ };
7454
+ var defaultConfiguration;
7455
+ function getUsdDefaultConfiguration() {
7456
+ return defaultConfiguration ??= {
7457
+ glueUrl: `${USD_RUNTIME_BASE_URL}${USD_RUNTIME_NAMES.glueUrl}`,
7458
+ wasmUrl: `${USD_RUNTIME_BASE_URL}${USD_RUNTIME_NAMES.wasmUrl}`,
7459
+ dataUrl: `${USD_RUNTIME_BASE_URL}${USD_RUNTIME_NAMES.dataUrl}`,
7460
+ workerUrl: `${USD_RUNTIME_BASE_URL}${USD_RUNTIME_NAMES.workerUrl}`
7461
+ };
7462
+ }
7463
+ function setUsdDefaultConfiguration(configuration) {
7464
+ defaultConfiguration = configuration;
7465
+ }
7466
+ function resolveUsdOptions(options) {
7467
+ const configured = Object.keys(USD_RUNTIME_NAMES).filter((key) => options[key] !== void 0);
7468
+ if (configured.length !== 0 && configured.length !== 4) unsupported("USDFileLoaderOptions runtime URLs", "Babylon Lite loads the OpenUSD worker, glue, WASM, and data files from one runtime directory. Babylon.js runtime URL overrides can be adapted only when all four standard files are configured together.");
7469
+ const defaults = getUsdDefaultConfiguration();
7470
+ return {
7471
+ ...defaults,
7472
+ ...options,
7473
+ workerUrl: options.workerUrl ?? defaults.workerUrl,
7474
+ glueUrl: options.glueUrl ?? defaults.glueUrl,
7475
+ wasmUrl: options.wasmUrl ?? defaults.wasmUrl,
7476
+ dataUrl: options.dataUrl ?? defaults.dataUrl
7477
+ };
7478
+ }
7479
+ function toLiteUsdOptions(options, signal, onProgress) {
7480
+ const configured = Object.keys(USD_RUNTIME_NAMES).filter((key) => options[key] !== void 0);
7481
+ let runtimeBaseUrl;
7482
+ for (const key of configured) {
7483
+ const url = new URL(String(options[key]), globalThis.location?.href ?? "http://localhost/");
7484
+ if (url.search || url.hash) unsupported(`USDFileLoaderOptions.${key}`, "Babylon Lite reconstructs OpenUSD runtime file URLs from one directory and cannot preserve per-file query strings or hash fragments.");
7485
+ if (!url.pathname.endsWith(`/${USD_RUNTIME_NAMES[key]}`)) unsupported(`USDFileLoaderOptions.${key}`, `Babylon Lite loads the four OpenUSD runtime files from one directory using their standard names; '${USD_RUNTIME_NAMES[key]}' is required.`);
7486
+ const candidate = new URL(".", url).href;
7487
+ if (runtimeBaseUrl !== void 0 && candidate !== runtimeBaseUrl) unsupported("USDFileLoaderOptions runtime URLs", "Babylon Lite loads the OpenUSD worker, glue, WASM, and data files from one runtime directory; independently located runtime files cannot be adapted.");
7488
+ runtimeBaseUrl = candidate;
7489
+ }
7490
+ return {
7491
+ rootFileName: options.rootFileName,
7492
+ files: options.files,
7493
+ resolveByFileName: options.resolveByFileName ?? true,
7494
+ runtimeBaseUrl,
7495
+ signal,
7496
+ onProgress: (progress) => {
7497
+ if (progress.phase !== "fetching") options.onProgress?.({
7498
+ phase: progress.phase,
7499
+ message: progress.message
7500
+ });
7501
+ const loaded = progress.phase === "fetching" ? 0 : progress.phase === "initializing" ? 1 : progress.phase === "staging" ? 2 : progress.phase === "extracting" ? 3 : 4;
7502
+ onProgress?.({
7503
+ lengthComputable: false,
7504
+ loaded,
7505
+ total: 4
7506
+ });
7507
+ },
7508
+ onLog: options.onLog
7509
+ };
7510
+ }
7511
+ //#endregion
7302
7512
  //#region src/loading/scene-loader.ts
7303
7513
  /**
7304
7514
  * Babylon.js-compatible `SceneLoader` and `AssetContainer` over Babylon Lite's
@@ -7323,16 +7533,14 @@ function urlPath(url) {
7323
7533
  /** Splat asset extensions Babylon Lite can parse (`loadSplat` / `loadSOG` / `loadSPZ`). */
7324
7534
  function isSplatUrl(url) {
7325
7535
  const u = urlPath(url).toLowerCase();
7326
- return u.endsWith(".ply") || u.endsWith(".splat") || u.endsWith(".sog") || u.endsWith(".spz");
7536
+ return u.endsWith(".ply") || u.endsWith(".splat") || u.endsWith(".sog") || u.endsWith(".spz") || u.endsWith(".json");
7327
7537
  }
7328
7538
  /** True when a URL points at a `.babylon` file, ignoring any query string or hash. */
7329
7539
  function isBabylonUrl(url) {
7330
7540
  return urlPath(url).toLowerCase().endsWith(".babylon");
7331
7541
  }
7332
- /** Last path segment of a URL, used to name a loaded Gaussian-Splatting mesh. */
7333
- function baseName(url) {
7334
- const path = urlPath(url);
7335
- return path.slice(path.lastIndexOf("/") + 1) || "splat";
7542
+ function isUsdUrl(url) {
7543
+ return /\.(?:usd|usda|usdc|usdz)$/i.test(urlPath(url));
7336
7544
  }
7337
7545
  var AssetContainer = class {
7338
7546
  /** @internal Underlying Babylon Lite asset container. */
@@ -7343,8 +7551,15 @@ var AssetContainer = class {
7343
7551
  _scene;
7344
7552
  /** @internal Canonical loaded-skeleton wrappers. */
7345
7553
  _skeletons;
7346
- constructor(lite) {
7554
+ _dispose;
7555
+ /** @internal Original USD mesh ownership, independent of later hierarchy changes. */
7556
+ _ownedMeshes;
7557
+ _sceneDisposeObserver;
7558
+ _disposed = false;
7559
+ constructor(lite, dispose, ownedMeshes) {
7347
7560
  this._lite = lite;
7561
+ this._dispose = dispose;
7562
+ this._ownedMeshes = ownedMeshes ? [...ownedMeshes] : void 0;
7348
7563
  }
7349
7564
  get animationGroups() {
7350
7565
  return this._lite.animationGroups ?? [];
@@ -7356,6 +7571,7 @@ var AssetContainer = class {
7356
7571
  * same handles `scene.meshes` exposes.
7357
7572
  */
7358
7573
  get meshes() {
7574
+ if (this._disposed) return [...this._meshRegistry.values()];
7359
7575
  return collectLoadedMeshes(this._lite, this._meshRegistry, this._scene);
7360
7576
  }
7361
7577
  get skeletons() {
@@ -7364,21 +7580,77 @@ var AssetContainer = class {
7364
7580
  /** Add every entity, animation group, camera, and clear colour to the scene. */
7365
7581
  addAllToScene(scene) {
7366
7582
  addToScene(scene._lite, this._lite);
7583
+ this._adoptScene(scene);
7584
+ }
7585
+ /** @internal Associate an already-added Lite container with its compat scene. */
7586
+ _adoptScene(scene) {
7587
+ if (this._sceneDisposeObserver && this._scene && this._scene !== scene) {
7588
+ this._scene.onDisposeObservable.remove(this._sceneDisposeObserver);
7589
+ this._sceneDisposeObserver = void 0;
7590
+ }
7367
7591
  this._scene = scene;
7592
+ if (this._dispose && !this._sceneDisposeObserver) this._sceneDisposeObserver = scene.onDisposeObservable.addOnce(() => {
7593
+ this._scene = void 0;
7594
+ this._sceneDisposeObserver = void 0;
7595
+ this._detachFromScene(scene);
7596
+ });
7368
7597
  collectLoadedMeshes(this._lite, this._meshRegistry, scene);
7369
7598
  scene._surfaceLoadedCamera();
7370
7599
  }
7371
- dispose() {}
7600
+ dispose() {
7601
+ const scene = this._scene;
7602
+ if (scene && this._sceneDisposeObserver) {
7603
+ scene.onDisposeObservable.remove(this._sceneDisposeObserver);
7604
+ this._sceneDisposeObserver = void 0;
7605
+ }
7606
+ this._scene = void 0;
7607
+ if (scene) this._detachFromScene(scene);
7608
+ else try {
7609
+ this._retireMeshWrappers();
7610
+ } finally {
7611
+ this._disposeOnce();
7612
+ }
7613
+ }
7614
+ _detachFromScene(scene) {
7615
+ try {
7616
+ if (this._ownedMeshes) for (const mesh of this._ownedMeshes) setParent(mesh, null);
7617
+ removeFromScene(scene._lite, this._lite);
7618
+ if (this._ownedMeshes) for (const mesh of this._ownedMeshes) removeFromScene(scene._lite, mesh);
7619
+ } finally {
7620
+ try {
7621
+ this._retireMeshWrappers();
7622
+ } finally {
7623
+ this._disposeOnce();
7624
+ }
7625
+ }
7626
+ }
7627
+ _retireMeshWrappers() {
7628
+ let hasError = false;
7629
+ let firstError;
7630
+ for (const wrapper of this._meshRegistry.values()) try {
7631
+ wrapper._disposeWrapperOnly();
7632
+ } catch (error) {
7633
+ if (!hasError) {
7634
+ hasError = true;
7635
+ firstError = error;
7636
+ }
7637
+ }
7638
+ if (hasError) throw firstError;
7639
+ }
7640
+ _disposeOnce() {
7641
+ if (!this._disposed) {
7642
+ this._disposed = true;
7643
+ this._dispose?.();
7644
+ }
7645
+ }
7372
7646
  };
7373
7647
  function validateGltfOptions(source, options) {
7374
7648
  if (!isBabylonUrl(source) && !isSplatUrl(source) && options?.pluginOptions?.gltf?.preprocessUrlAsync) unsupported("ISceneLoaderOptions.pluginOptions.gltf.preprocessUrlAsync", "Supporting per-resource URL preprocessing requires a loader-wide callback/context contract across Lite's core glTF loader and lazy extension modules, which cannot be added as an independent tree-shakeable export.");
7375
7649
  }
7376
7650
  /** @internal Load a splat URL into a `GaussianSplattingMesh` (shared by every loader entry point). */
7377
- async function loadSplatResult(url, scene) {
7378
- const gs = new GaussianSplattingMesh(baseName(url), null, scene);
7379
- await gs.loadFileAsync(url);
7651
+ async function loadSplatResult(url, scene, options) {
7380
7652
  return {
7381
- meshes: [gs],
7653
+ meshes: [await new SPLATFileLoader(options)._loadUrlAsync(scene, url)],
7382
7654
  particleSystems: [],
7383
7655
  skeletons: [],
7384
7656
  animationGroups: [],
@@ -7391,10 +7663,11 @@ function joinUrl(rootUrl, fileName) {
7391
7663
  if (/^(https?:)?\/\//.test(fileName) || fileName.startsWith("/")) return fileName;
7392
7664
  return rootUrl.endsWith("/") || rootUrl === "" ? rootUrl + fileName : rootUrl + "/" + fileName;
7393
7665
  }
7394
- async function load(rootUrl, fileName, scene) {
7666
+ async function load(rootUrl, fileName, scene, usdOptions) {
7395
7667
  const url = joinUrl(rootUrl, fileName);
7396
7668
  const engine = scene.getEngine()._lite;
7397
- if (!isBabylonUrl(url)) enableBoneControlForSkinnedAssets();
7669
+ if (!isBabylonUrl(url) && !isUsdUrl(url)) enableBoneControlForSkinnedAssets();
7670
+ if (isUsdUrl(url)) return loadUsdContainer(engine, url, usdOptions);
7398
7671
  return new AssetContainer(isBabylonUrl(url) ? await loadBabylon(engine, url) : await loadGltf(engine, url));
7399
7672
  }
7400
7673
  /** Babylon.js `SceneLoader` — async glTF/.babylon loading into a compat scene. */
@@ -7427,6 +7700,7 @@ var SceneLoader = {
7427
7700
  },
7428
7701
  /** Load an asset into a container without adding it to the scene. */
7429
7702
  async LoadAssetContainerAsync(rootUrl, sceneFilename, scene) {
7703
+ if (isSplatUrl(joinUrl(rootUrl, sceneFilename))) return new SPLATFileLoader().loadAssetContainerAsync(scene, "", rootUrl);
7430
7704
  return load(rootUrl, sceneFilename, scene);
7431
7705
  },
7432
7706
  /** Plugin registration — out of scope (side-effectful global registry). */
@@ -7437,9 +7711,9 @@ var SceneLoader = {
7437
7711
  /** Babylon.js `ImportMeshAsync(source, scene, options?)` — imports an asset into the scene. */
7438
7712
  async function ImportMeshAsync(source, scene, options) {
7439
7713
  const url = joinUrl(options?.rootUrl ?? "", source);
7440
- if (isSplatUrl(url)) return loadSplatResult(url, scene);
7714
+ if (isSplatUrl(url)) return loadSplatResult(url, scene, options?.pluginOptions?.splat);
7441
7715
  validateGltfOptions(url, options);
7442
- const container = await loadFromSource(url, scene);
7716
+ const container = await loadFromSource(url, scene, options?.pluginOptions?.usd, options?.onProgress);
7443
7717
  container.addAllToScene(scene);
7444
7718
  return {
7445
7719
  meshes: container.meshes,
@@ -7455,25 +7729,38 @@ async function ImportMeshAsync(source, scene, options) {
7455
7729
  async function AppendSceneAsync(source, scene, options) {
7456
7730
  const url = joinUrl(options?.rootUrl ?? "", source);
7457
7731
  if (isSplatUrl(url)) {
7458
- await loadSplatResult(url, scene);
7732
+ await loadSplatResult(url, scene, options?.pluginOptions?.splat);
7459
7733
  return scene;
7460
7734
  }
7461
7735
  validateGltfOptions(url, options);
7462
- (await loadFromSource(url, scene)).addAllToScene(scene);
7736
+ (await loadFromSource(url, scene, options?.pluginOptions?.usd, options?.onProgress)).addAllToScene(scene);
7463
7737
  return scene;
7464
7738
  }
7465
7739
  /** Babylon.js `LoadAssetContainerAsync(source, scene, options?)` — loads into a container without adding. */
7466
7740
  async function LoadAssetContainerAsync(source, scene, options) {
7467
7741
  const url = joinUrl(options?.rootUrl ?? "", source);
7742
+ if (isSplatUrl(url)) return new SPLATFileLoader(options?.pluginOptions?.splat).loadAssetContainerAsync(scene, "", options?.rootUrl ?? "");
7468
7743
  validateGltfOptions(url, options);
7469
- return loadFromSource(url, scene);
7744
+ return loadFromSource(url, scene, options?.pluginOptions?.usd, options?.onProgress);
7470
7745
  }
7471
7746
  /** @internal Load a glTF/.babylon asset from a single source URL (function-loader form). */
7472
- async function loadFromSource(source, scene) {
7747
+ async function loadFromSource(source, scene, usdOptions, onProgress) {
7473
7748
  const engine = scene.getEngine()._lite;
7474
- if (!isBabylonUrl(source)) enableBoneControlForSkinnedAssets();
7749
+ if (!isBabylonUrl(source) && !isUsdUrl(source)) enableBoneControlForSkinnedAssets();
7750
+ if (isUsdUrl(source)) return loadUsdContainer(engine, source, usdOptions, onProgress);
7475
7751
  return new AssetContainer(isBabylonUrl(source) ? await loadBabylon(engine, source) : await loadGltf(engine, source));
7476
7752
  }
7753
+ async function loadUsdContainer(engine, source, options = {}, onProgress) {
7754
+ const lite = await loadUsd(engine, source, toLiteUsdOptions(resolveUsdOptions(options), void 0, onProgress));
7755
+ const container = new AssetContainer(lite, () => disposeUsd(lite), lite._usdMeshes);
7756
+ try {
7757
+ options.onComplete?.(lite.diagnostics);
7758
+ return container;
7759
+ } catch (error) {
7760
+ container.dispose();
7761
+ throw error;
7762
+ }
7763
+ }
7477
7764
  //#endregion
7478
7765
  //#region src/loading/assets-manager.ts
7479
7766
  /**
@@ -7618,6 +7905,89 @@ var KHR_materials_variants = {
7618
7905
  }
7619
7906
  };
7620
7907
  //#endregion
7908
+ //#region src/loading/usd-file-loader.ts
7909
+ function requireBinary(data) {
7910
+ if (!(data instanceof ArrayBuffer) && !ArrayBuffer.isView(data)) throw new Error("USDFileLoader expects binary USD data.");
7911
+ return data;
7912
+ }
7913
+ var USDFileLoader = class USDFileLoader {
7914
+ static get DefaultConfiguration() {
7915
+ return getUsdDefaultConfiguration();
7916
+ }
7917
+ static set DefaultConfiguration(configuration) {
7918
+ setUsdDefaultConfiguration(configuration);
7919
+ }
7920
+ name = "usd";
7921
+ extensions = {
7922
+ ".usd": { isBinary: true },
7923
+ ".usda": { isBinary: true },
7924
+ ".usdc": { isBinary: true },
7925
+ ".usdz": { isBinary: true }
7926
+ };
7927
+ _options;
7928
+ _activeLoads = /* @__PURE__ */ new Set();
7929
+ constructor(options = {}) {
7930
+ this._options = {
7931
+ ...getUsdDefaultConfiguration(),
7932
+ ...options
7933
+ };
7934
+ }
7935
+ createPlugin(options) {
7936
+ return new USDFileLoader(options.usd);
7937
+ }
7938
+ async importMeshAsync(_meshNames, scene, data, _rootUrl, onProgress, fileName) {
7939
+ const container = await this._load(scene, data, onProgress, fileName, true);
7940
+ return {
7941
+ meshes: container.meshes,
7942
+ particleSystems: [],
7943
+ skeletons: container.skeletons,
7944
+ animationGroups: container.animationGroups,
7945
+ transformNodes: [],
7946
+ lights: []
7947
+ };
7948
+ }
7949
+ async loadAsync(scene, data, _rootUrl, onProgress, fileName) {
7950
+ await this._load(scene, data, onProgress, fileName, true);
7951
+ }
7952
+ async loadAssetContainerAsync(scene, data, _rootUrl, onProgress, fileName) {
7953
+ return this._load(scene, data, onProgress, fileName, false);
7954
+ }
7955
+ dispose() {
7956
+ const error = /* @__PURE__ */ new Error("USDFileLoader was disposed.");
7957
+ for (const controller of this._activeLoads) controller.abort(error);
7958
+ this._activeLoads.clear();
7959
+ }
7960
+ async _load(scene, data, onProgress, fileName, add) {
7961
+ const controller = new AbortController();
7962
+ this._activeLoads.add(controller);
7963
+ try {
7964
+ const lite = await loadUsd(scene.getEngine()._lite, requireBinary(data), toLiteUsdOptions(resolveUsdOptions({
7965
+ ...this._options,
7966
+ rootFileName: this._options.rootFileName ?? fileName
7967
+ }), controller.signal, onProgress));
7968
+ const container = new AssetContainer(lite, () => disposeUsd(lite), lite._usdMeshes);
7969
+ try {
7970
+ controller.signal.throwIfAborted();
7971
+ if (add) {
7972
+ addToScene(scene._lite, lite);
7973
+ container._adoptScene(scene);
7974
+ }
7975
+ this._options.onComplete?.(lite.diagnostics);
7976
+ controller.signal.throwIfAborted();
7977
+ return container;
7978
+ } catch (error) {
7979
+ container.dispose();
7980
+ throw error;
7981
+ }
7982
+ } finally {
7983
+ this._activeLoads.delete(controller);
7984
+ }
7985
+ }
7986
+ };
7987
+ function RegisterUSDFileLoader() {}
7988
+ /** @internal Babylon.js pure-registration hook; Lite has no global loader dependency registry. */
7989
+ function _RegisterUSDLoaderDependencies() {}
7990
+ //#endregion
7621
7991
  //#region src/picking/gpu-picker.ts
7622
7992
  /**
7623
7993
  * Babylon.js-compatible `GPUPicker` over Babylon Lite's GPU picker
@@ -10997,16 +11367,7 @@ var MaterialPluginBase = class MaterialPluginBase {
10997
11367
  * replaced by a real wrapper (and its `COMPAT-STATUS.md` row upgraded).
10998
11368
  */
10999
11369
  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.";
11000
- 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.";
11001
11370
  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.";
11002
- var USDFileLoader = class {
11003
- constructor(_options = {}) {
11004
- unsupported("USDFileLoader", USD_LOADER_UNSUPPORTED);
11005
- }
11006
- };
11007
- function RegisterUSDFileLoader() {
11008
- return unsupported("RegisterUSDFileLoader", USD_LOADER_UNSUPPORTED);
11009
- }
11010
11371
  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.";
11011
11372
  var FlowGraphValidationSeverity = /* @__PURE__ */ function(FlowGraphValidationSeverity) {
11012
11373
  FlowGraphValidationSeverity[FlowGraphValidationSeverity["Error"] = 0] = "Error";
@@ -11053,6 +11414,112 @@ var FluidRendererSceneComponent = class {
11053
11414
  function RegisterFluidRenderer() {
11054
11415
  unsupported("RegisterFluidRenderer", FLUID_RENDERER_UNSUPPORTED);
11055
11416
  }
11417
+ var ROOT_MOTION_UNSUPPORTED = "Babylon.js root motion analyzes animation hierarchies, rewrites in-place clips, journals mixer writes, and applies blended per-frame travel. Lite exposes animation playback but not that analysis and mixer-journal subsystem; its lifecycle and ownership require a Lite-level design.";
11418
+ var RootMotionSource = /* @__PURE__ */ function(RootMotionSource) {
11419
+ RootMotionSource[RootMotionSource["None"] = 0] = "None";
11420
+ RootMotionSource[RootMotionSource["Root"] = 1] = "Root";
11421
+ RootMotionSource[RootMotionSource["FootContact"] = 2] = "FootContact";
11422
+ return RootMotionSource;
11423
+ }({});
11424
+ var RootMotionClip = class {
11425
+ constructor(_animationGroup, _options = {}) {
11426
+ unsupported("RootMotionClip", ROOT_MOTION_UNSUPPORTED);
11427
+ }
11428
+ get sourceAnimationGroup() {
11429
+ return unsupported("RootMotionClip.sourceAnimationGroup", ROOT_MOTION_UNSUPPORTED);
11430
+ }
11431
+ get animationGroup() {
11432
+ return unsupported("RootMotionClip.animationGroup", ROOT_MOTION_UNSUPPORTED);
11433
+ }
11434
+ get controller() {
11435
+ return unsupported("RootMotionClip.controller", ROOT_MOTION_UNSUPPORTED);
11436
+ }
11437
+ get source() {
11438
+ return unsupported("RootMotionClip.source", ROOT_MOTION_UNSUPPORTED);
11439
+ }
11440
+ get rootNode() {
11441
+ return unsupported("RootMotionClip.rootNode", ROOT_MOTION_UNSUPPORTED);
11442
+ }
11443
+ get characterNode() {
11444
+ return unsupported("RootMotionClip.characterNode", ROOT_MOTION_UNSUPPORTED);
11445
+ }
11446
+ get contactNodes() {
11447
+ return unsupported("RootMotionClip.contactNodes", ROOT_MOTION_UNSUPPORTED);
11448
+ }
11449
+ get upAxis() {
11450
+ return unsupported("RootMotionClip.upAxis", ROOT_MOTION_UNSUPPORTED);
11451
+ }
11452
+ get fromFrame() {
11453
+ return unsupported("RootMotionClip.fromFrame", ROOT_MOTION_UNSUPPORTED);
11454
+ }
11455
+ get toFrame() {
11456
+ return unsupported("RootMotionClip.toFrame", ROOT_MOTION_UNSUPPORTED);
11457
+ }
11458
+ get travelDirection() {
11459
+ return unsupported("RootMotionClip.travelDirection", ROOT_MOTION_UNSUPPORTED);
11460
+ }
11461
+ get cycleOffset() {
11462
+ return unsupported("RootMotionClip.cycleOffset", ROOT_MOTION_UNSUPPORTED);
11463
+ }
11464
+ get cycleDistance() {
11465
+ return unsupported("RootMotionClip.cycleDistance", ROOT_MOTION_UNSUPPORTED);
11466
+ }
11467
+ get cycleRotation() {
11468
+ return unsupported("RootMotionClip.cycleRotation", ROOT_MOTION_UNSUPPORTED);
11469
+ }
11470
+ get extractsRotation() {
11471
+ return unsupported("RootMotionClip.extractsRotation", ROOT_MOTION_UNSUPPORTED);
11472
+ }
11473
+ get duration() {
11474
+ return unsupported("RootMotionClip.duration", ROOT_MOTION_UNSUPPORTED);
11475
+ }
11476
+ get averageSpeed() {
11477
+ return unsupported("RootMotionClip.averageSpeed", ROOT_MOTION_UNSUPPORTED);
11478
+ }
11479
+ get characterHeight() {
11480
+ return unsupported("RootMotionClip.characterHeight", ROOT_MOTION_UNSUPPORTED);
11481
+ }
11482
+ getOffsetAtFrame(_frame, _result) {
11483
+ return unsupported("RootMotionClip.getOffsetAtFrame", ROOT_MOTION_UNSUPPORTED);
11484
+ }
11485
+ getRotationAtFrame(_frame) {
11486
+ return unsupported("RootMotionClip.getRotationAtFrame", ROOT_MOTION_UNSUPPORTED);
11487
+ }
11488
+ dispose() {
11489
+ unsupported("RootMotionClip.dispose", ROOT_MOTION_UNSUPPORTED);
11490
+ }
11491
+ };
11492
+ var RootMotionController = class {
11493
+ applyToCharacter = true;
11494
+ onRootMotionObservable;
11495
+ constructor(_characterNode, _clips = []) {
11496
+ unsupported("RootMotionController", ROOT_MOTION_UNSUPPORTED);
11497
+ }
11498
+ get characterNode() {
11499
+ return unsupported("RootMotionController.characterNode", ROOT_MOTION_UNSUPPORTED);
11500
+ }
11501
+ get clips() {
11502
+ return unsupported("RootMotionController.clips", ROOT_MOTION_UNSUPPORTED);
11503
+ }
11504
+ get deltaPosition() {
11505
+ return unsupported("RootMotionController.deltaPosition", ROOT_MOTION_UNSUPPORTED);
11506
+ }
11507
+ get deltaRotation() {
11508
+ return unsupported("RootMotionController.deltaRotation", ROOT_MOTION_UNSUPPORTED);
11509
+ }
11510
+ addClip(_clip) {
11511
+ unsupported("RootMotionController.addClip", ROOT_MOTION_UNSUPPORTED);
11512
+ }
11513
+ removeClip(_clip) {
11514
+ unsupported("RootMotionController.removeClip", ROOT_MOTION_UNSUPPORTED);
11515
+ }
11516
+ reset() {
11517
+ unsupported("RootMotionController.reset", ROOT_MOTION_UNSUPPORTED);
11518
+ }
11519
+ dispose() {
11520
+ unsupported("RootMotionController.dispose", ROOT_MOTION_UNSUPPORTED);
11521
+ }
11522
+ };
11056
11523
  var MultiMaterial = class {
11057
11524
  constructor() {
11058
11525
  unsupported("MultiMaterial", "Babylon Lite uses one material per renderable. Split the mesh geometry by material into separate meshes instead.");
@@ -12334,6 +12801,6 @@ var NodeParticleSystemSet = class NodeParticleSystemSet {
12334
12801
  }
12335
12802
  };
12336
12803
  //#endregion
12337
- 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, 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, 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, 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, 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, registerBuiltInLoaders, transformCoordinates, transformNormal, unsupported };
12804
+ 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, 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, 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, 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 };
12338
12805
 
12339
12806
  //# sourceMappingURL=index.js.map