@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/README.md +12 -12
- package/index.d.ts +172 -35
- package/index.js +513 -46
- package/index.js.map +1 -1
- package/{meshes-Fu955h5M.js → meshes-Ds66ewr9.js} +66 -7
- package/meshes-Ds66ewr9.js.map +1 -0
- package/navigation.d.ts +1 -2
- package/navigation.js +1 -1
- package/package.json +4 -4
- package/meshes-Fu955h5M.js.map +0 -1
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-
|
|
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
|
-
|
|
5426
|
-
|
|
5427
|
-
|
|
5428
|
-
|
|
5429
|
-
|
|
5430
|
-
|
|
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
|
|
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
|
-
/**
|
|
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.
|
|
6329
|
-
|
|
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)
|
|
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
|
-
|
|
7333
|
-
|
|
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
|
-
|
|
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: [
|
|
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
|