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