@babylonjs/lite-compat 1.36.0-preview → 1.37.1-preview

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/index.js CHANGED
@@ -1,5 +1,5 @@
1
- import { $ as Vector4, A as PBRClearCoatConfiguration, B as Observable, C as RegisterPolygonBuilder, D as registerMeshAtStart, E as VertexData, F as PBRSpecularGlossinessMaterial, G as transformCoordinates, H as BoundingInfo, I as PushMaterial, J as Color3, K as transformNormal, L as StandardMaterial, M as PBRMaterial, N as PBRMetallicRoughnessMaterial, O as Material, P as PBRSheenConfiguration, Q as Vector3, R as attachMaterialToScene, S as PolygonBuilder, T as VertexBuffer, U as BoundingSphere, V as BoundingBox, W as Matrix, X as liteBackedColor3, Y as Color4, Z as Vector2, _ as GroundMesh, a as CreateDisc, b as Mesh, c as CreateLines, d as CreatePolygonVertexData, et as liteBackedVector3, f as CreateSphere, g as ExtrudePolygon, h as CreateTorus, i as CreateDashedLines, j as PBRIridescenceConfiguration, k as PBRAnisotropicConfiguration, l as CreatePlane, m as CreateTiledPlane, n as CreateBox, nt as unsupported, o as CreateGround, p as CreateTiledBox, q as Quaternion, r as CreateCylinder, s as CreateLineSystem, t as AbstractMesh, tt as LiteCompatError, u as CreatePolygon, v as InstancedMesh, w as TransformNode, x as MeshBuilder, y as LinesMesh, z as Node } from "./meshes-zeNif9yt.js";
2
- import { CharacterSupportedState as CharacterSupportedState$1, GAUSSIAN_SPLATTING_MAX_PART_COUNT, MaxTintMagnitude, MinTemperatureKelvin, PhysicsConstraintAxis as PhysicsConstraintAxis$1, PhysicsConstraintType as PhysicsConstraintType$1, PhysicsMotionType as PhysicsMotionType$1, PhysicsPrestepType as PhysicsPrestepType$1, PhysicsShapeType as PhysicsShapeType$1, VERSION, addAnimationGroup, addBillboardSpriteIndex, addClusteredLightContainer, addComputeDispatch, addFacingBillboardSystem, addPolarToRef, addSphericalToRef, addSprite2DIndex, addToScene, animateParticleSystem, applyPhysicsBodyForce, applyPhysicsBodyImpulse, attachAxisDragGizmoToNode, attachAxisScaleGizmoToNode, attachBoundingBoxGizmoToNode, attachCameraGizmoToCamera, attachControl, attachFreeControl, attachGeospatialControls, attachLightGizmoToLight, attachPlaneDragGizmoToNode, attachPlaneRotationGizmoToNode, attachPositionGizmoToNode, attachRotationGizmoToNode, attachScaleGizmoToNode, backEase, bakeCurrentTransformIntoVertices, bezierCurveEase, billboardBlendAdditive, billboardBlendAlpha, bounceEase, calculatePhysicsCharacterMovementToRef, circleEase, clearAnimationManager, clearBoneOverride, clearStorageBuffer, computeStorageBufferBinding, computeUniformBufferBinding, createAnimationManager, createArcRotateCamera, createAudioBusAsync, createAudioEngineAsync, createAxisDragGizmo, createAxisScaleGizmo, createBankedFreeCamera, createBoundingBoxGizmo, createCameraGizmo, createClusteredLightContainer, createClusteredPointLight, createComputeBindingSet, createComputeDispatch, createComputeIndirectDispatch, createComputeShader, createComputeTask, createCsg2FromMesh, createCsgFromMesh, createCsmDirectionalShadowGenerator, createDefaultCamera, createDefaultMeshBlendRadiusDefinitions, createDirectionalLight, createDynamicTexture, createEngine, createEsmDirectionalShadowGenerator, createExternalTexture, createFacingBillboardSystem, createFreeCamera, createGeospatialCamera, createGpuPicker, createGridMaterial, createHavokWorld, createHemisphericLight, createHtmlTexture, createKhrInteractivityRuntimeValueSnapshot, createLightGizmo, createMeshFromCsg, createMeshesFromCsg2, createMicrophoneSoundSourceAsync, createMorphTargets, createNullEngine, createParticleBillboard, createPcfDirectionalShadowGenerator, createPcfSpotlightShadowGenerator, createPhysicsAggregate, createPhysicsBody, createPhysicsCharacterController, createPhysicsConstraint, createPhysicsShape, createPickingRay, createPlaneDragGizmo, createPlaneRotationGizmo, createPointLight, createPositionGizmo, createPropertyAnimationClip, createPropertyAnimationGroup, createRotationGizmo, createScaleGizmo, createSceneContext, createSoundAsync, createSoundBufferAsync, createSoundSourceAsync, createSpotLight, createSprite2DLayer, createSpriteRenderer, createStorageBuffer, createStreamingSoundAsync, createTexture2DArray, createTexture2DArrayFromKtx2, createTexture2DArrayFromPixels, createTexture2DArrayFromUrls, createTexture2DFromPixels, createTexture3DFromPixels, createTransformNode, createUniformBuffer, createUtilityLayer, csg2Add, csg2Intersect, csg2Subtract, csgIntersect, csgSubtract, csgUnion, cubicEase, disableOrthographicCamera, disposeAudioBus, disposeAudioEngine, disposeAxisDragGizmo, disposeAxisScaleGizmo, disposeBoundingBoxGizmo, disposeCameraGizmo, disposeComputeBindingSet, disposeComputeShader, disposeCsg2, disposeEngine, disposeHtmlTexture, disposeLightGizmo, disposePhysics, disposePicker, disposePlaneDragGizmo, disposePlaneRotationGizmo, disposePositionGizmo, disposeRotationGizmo, disposeScaleGizmo, disposeScene, disposeSound, disposeSoundSource, disposeStorageBuffer, disposeStreamingSound, disposeUniformBuffer, disposeUsd, disposeUtilityLayer, dividePolarToRef, divideSphericalToRef, elasticEase, enableAnalyzer, enableAnimationBlending, enableArcRotateKeyboardControls, enableBoneControlForSkinnedAssets, enableHavokThinInstancePhysicsSync, enableMirroredMeshes, enableOrthographicCamera, enableSpatial, enableStereo, encodeIdToColor, exponentialEase, getBoneByName, getByteFrequencyData, getByteTimeDomainData, getCameraPosition, getFloatFrequencyData, getFloatTimeDomainData, getGaussianSplattingMaxPartCount, getGaussianSplattingPartIndexVaryingDeclaration, getMasterVolume, getPhysicsBodyAngularVelocity, getPhysicsBodyLinearVelocity, getPickedUV, getProjectionMatrix, getVariantNames, getViewMatrix, getWhiteBalanceMatrix, goToFrame, hasDefaultInteractivityFlowInput, initializeCsg2Async, invertMat4, isExternalTextureReady, loadBabylon, loadBasisTexture2D, loadDdsEnvironment, loadEnvironment, loadGltf, loadHdrEnvironment, loadImageToArrayLayer, loadKtxTexture2D, loadSOG, loadSPZ, loadSplat, loadSpriteAtlas, loadTexture2D, loadUsd, markClusteredLightContainerDirty, multiplyMat4, multiplyPolarToRef, multiplySphericalToRef, normalizeInteractivityEventDataConfiguration, normalizeKhrInteractivityRuntimeValue, onBeforeRender, onEngineDeviceLost, onPhysicsAfterStep, packMeshBlendingTag, parseNodeMaterialFromSnippet, parseNodeParticleSetFromSnippet, pauseAnimation, pauseSound, pauseStreamingSound, physicsRaycast, pickAsync, pickMeshesWithRayPrecise, playAnimation, playSound, playStreamingSound, polarFromVec2ToRef, polarToVec2ToRef, powerEase, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, quadraticEase, quarticEase, quinticEase, readStorageBufferAfterFrame, registerNodeParticleSet, registerScene, registerSceneWithShadowSupport, registerSpriteRenderer, registerUtilityLayer, releasePhysicsConstraint, releasePhysicsShape, removeAnimationGroup, removeFromScene, removePhysicsBody, requestHtmlTextureUpdate, resetVariant, resizeEngine, resolveCameraViewport, resumeSound, resumeStreamingSound, sampleCatmullRomSpline, sampleHermiteSpline, scalePolarToRef, scaleSphericalToRef, selectVariant, setAnimationAdditive, setBonePosition, setBoneRotationQuaternion, setBoneScaling, setBusVolume, setClipPlane, setEngineSize, setFog, setGeospatialOrientation, setMasterVolume, setMorphTargetWeights, setParent, setPhysicsBodyAngularVelocity, setPhysicsBodyLinearVelocity, setPhysicsBodyMassProperties, setPhysicsBodyMotionType, setPhysicsBodyPrestepType, setPhysicsBodyShape, setPhysicsGravity, setPhysicsShapeFilterCollideMask, setPhysicsShapeFilterMembershipMask, setPhysicsShapeIsTrigger, setPhysicsShapeMaterial, setPhysicsTimestep, setPositionGizmoLocalCoordinates, setRotationGizmoLocalCoordinates, setScaleGizmoLocalCoordinates, setShadowTaskCasterMeshes, setSoundSourceVolume, setSoundVolume, setSpatialListener, setSpatialListenerPosition, setSpatialOrientation, setSpatialPosition, setStereoPan, setStreamingSoundVolume, sineEase, sphericalFromVec3ToRef, sphericalToVec3ToRef, spriteBlendAdditive, spriteBlendAlpha, spriteBlendPremultiplied, startEngine, startParticleSystem, stepScene, stopAnimation, stopEngine, stopParticleSystem, stopSound, stopStreamingSound, submitComputeTasks, subtractPolarToRef, subtractSphericalToRef, syncParticleBillboard, temperatureTintToXyz, unlockAudioEngineAsync, unpackMeshBlendingTag, updateAnimationManager, updateBillboardSpriteIndex, updateDynamicTexture, updateHtmlTexture, updateSpatialAudio, updateSprite2DIndex, updateStorageBufferRange, updateTexture2DArrayFromPixels, updateTexture2DFromPixels, updateUniformBuffer, uploadImageToArrayLayer, whenHtmlTextureReady } from "@babylonjs/lite";
1
+ import { $ as Vector4, A as PBRClearCoatConfiguration, B as Observable, C as RegisterPolygonBuilder, D as registerMeshAtStart, E as VertexData, F as PBRSpecularGlossinessMaterial, G as transformCoordinates, H as BoundingInfo, I as PushMaterial, J as Color3, K as transformNormal, L as StandardMaterial, M as PBRMaterial, N as PBRMetallicRoughnessMaterial, O as Material, P as PBRSheenConfiguration, Q as Vector3, R as attachMaterialToScene, S as PolygonBuilder, T as VertexBuffer, U as BoundingSphere, V as BoundingBox, W as Matrix, X as liteBackedColor3, Y as Color4, Z as Vector2, _ as GroundMesh, a as CreateDisc, b as Mesh, c as CreateLines, d as CreatePolygonVertexData, et as liteBackedVector3, f as CreateSphere, g as ExtrudePolygon, h as CreateTorus, i as CreateDashedLines, j as PBRIridescenceConfiguration, k as PBRAnisotropicConfiguration, l as CreatePlane, m as CreateTiledPlane, n as CreateBox, nt as unsupported, o as CreateGround, p as CreateTiledBox, q as Quaternion, r as CreateCylinder, s as CreateLineSystem, t as AbstractMesh, tt as LiteCompatError, u as CreatePolygon, v as InstancedMesh, w as TransformNode, x as MeshBuilder, y as LinesMesh, z as Node } from "./meshes-BqMDWl4h.js";
2
+ import { CharacterSupportedState as CharacterSupportedState$1, GAUSSIAN_SPLATTING_MAX_PART_COUNT, MaxTintMagnitude, MinTemperatureKelvin, PhysicsConstraintAxis as PhysicsConstraintAxis$1, PhysicsConstraintType as PhysicsConstraintType$1, PhysicsMotionType as PhysicsMotionType$1, PhysicsPrestepType as PhysicsPrestepType$1, PhysicsShapeType as PhysicsShapeType$1, VERSION, _getGaussianPointSplattingPackedShBytesPerSplat, _hasGaussianPointSplattingProjectedDepth, addAnimationGroup, addBillboardSpriteIndex, addClusteredLightContainer, addComputeDispatch, addFacingBillboardSystem, addPolarToRef, addSphericalToRef, addSprite2DIndex, addToScene, animateParticleSystem, applyPhysicsBodyForce, applyPhysicsBodyImpulse, attachAxisDragGizmoToNode, attachAxisScaleGizmoToNode, attachBoundingBoxGizmoToNode, attachCameraGizmoToCamera, attachControl, attachFreeControl, attachGeospatialControls, attachLightGizmoToLight, attachPlaneDragGizmoToNode, attachPlaneRotationGizmoToNode, attachPositionGizmoToNode, attachRotationGizmoToNode, attachScaleGizmoToNode, backEase, bakeCurrentTransformIntoVertices, bezierCurveEase, billboardBlendAdditive, billboardBlendAlpha, bounceEase, calculatePhysicsCharacterMovementToRef, circleEase, clearAnimationManager, clearBoneOverride, clearStorageBuffer, computeStorageBufferBinding, computeUniformBufferBinding, createAnimationManager, createArcRotateCamera, createAudioBusAsync, createAudioEngineAsync, createAxisDragGizmo, createAxisScaleGizmo, createBankedFreeCamera, createBoundingBoxGizmo, createCameraGizmo, createClusteredLightContainer, createClusteredPointLight, createComputeBindingSet, createComputeDispatch, createComputeIndirectDispatch, createComputeShader, createComputeTask, createCsg2FromMesh, createCsgFromMesh, createCsmDirectionalShadowGenerator, createDefaultCamera, createDefaultMeshBlendRadiusDefinitions, createDirectionalLight, createDynamicTexture, createEngine, createEsmDirectionalShadowGenerator, createExternalTexture, createFacingBillboardSystem, createFreeCamera, createGeospatialCamera, createGpuPicker, createGridMaterial, createHavokWorld, createHemisphericLight, createHtmlTexture, createKhrInteractivityRuntimeValueSnapshot, createLightGizmo, createMeshFromCsg, createMeshesFromCsg2, createMicrophoneSoundSourceAsync, createMorphTargets, createNullEngine, createParticleBillboard, createPcfDirectionalShadowGenerator, createPcfSpotlightShadowGenerator, createPhysicsAggregate, createPhysicsBody, createPhysicsCharacterController, createPhysicsConstraint, createPhysicsShape, createPickingRay, createPlaneDragGizmo, createPlaneRotationGizmo, createPointLight, createPositionGizmo, createPropertyAnimationClip, createPropertyAnimationGroup, createRotationGizmo, createScaleGizmo, createSceneContext, createSoundAsync, createSoundBufferAsync, createSoundSourceAsync, createSpotLight, createSprite2DLayer, createSpriteRenderer, createStorageBuffer, createStreamingSoundAsync, createTexture2DArray, createTexture2DArrayFromKtx2, createTexture2DArrayFromPixels, createTexture2DArrayFromUrls, createTexture2DFromPixels, createTexture3DFromPixels, createTransformNode, createUniformBuffer, createUtilityLayer, csg2Add, csg2Intersect, csg2Subtract, csgIntersect, csgSubtract, csgUnion, cubicEase, disableOrthographicCamera, disposeAudioBus, disposeAudioEngine, disposeAxisDragGizmo, disposeAxisScaleGizmo, disposeBoundingBoxGizmo, disposeCameraGizmo, disposeComputeBindingSet, disposeComputeShader, disposeCsg2, disposeEngine, disposeHtmlTexture, disposeLightGizmo, disposePhysics, disposePicker, disposePlaneDragGizmo, disposePlaneRotationGizmo, disposePositionGizmo, disposeRotationGizmo, disposeScaleGizmo, disposeScene, disposeSound, disposeSoundSource, disposeStorageBuffer, disposeStreamingSound, disposeUniformBuffer, disposeUsd, disposeUtilityLayer, dividePolarToRef, divideSphericalToRef, elasticEase, enableAnalyzer, enableAnimationBlending, enableArcRotateKeyboardControls, enableBoneControlForSkinnedAssets, enableHavokThinInstancePhysicsSync, enableMirroredMeshes, enableOrthographicCamera, enableSpatial, enableStereo, encodeIdToColor, exponentialEase, getBoneByName, getByteFrequencyData, getByteTimeDomainData, getCameraPosition, getFloatFrequencyData, getFloatTimeDomainData, getGaussianSplattingMaxPartCount, getGaussianSplattingPartIndexVaryingDeclaration, getMasterVolume, getPhysicsBodyAngularVelocity, getPhysicsBodyLinearVelocity, getPickedUV, getProjectionMatrix, getVariantNames, getViewMatrix, getWhiteBalanceMatrix, goToFrame, hasDefaultInteractivityFlowInput, initializeCsg2Async, inverseLerp, invertMat4, isExternalTextureReady, loadBabylon, loadBasisTexture2D, loadDdsEnvironment, loadEnvironment, loadGltf, loadHdrEnvironment, loadImageToArrayLayer, loadKtxTexture2D, loadSOG, loadSPZ, loadSplat, loadSpriteAtlas, loadTexture2D, loadUsd, markClusteredLightContainerDirty, multiplyMat4, multiplyPolarToRef, multiplySphericalToRef, normalizeInteractivityEventDataConfiguration, normalizeKhrInteractivityRuntimeValue, onBeforeRender, onEngineDeviceLost, onPhysicsAfterStep, packMeshBlendingTag, parseNodeMaterialFromSnippet, parseNodeParticleSetFromSnippet, pauseAnimation, pauseSound, pauseStreamingSound, physicsRaycast, pickAsync, pickMeshesWithRayPrecise, playAnimation, playSound, playStreamingSound, polarFromVec2ToRef, polarToVec2ToRef, powerEase, preloadStreamingInstanceAsync, preloadStreamingInstancesAsync, quadraticEase, quarticEase, quinticEase, readStorageBufferAfterFrame, registerNodeParticleSet, registerScene, registerSceneWithShadowSupport, registerSpriteRenderer, registerUtilityLayer, releasePhysicsConstraint, releasePhysicsShape, removeAnimationGroup, removeFromScene, removePhysicsBody, requestHtmlTextureUpdate, resetVariant, resizeEngine, resolveCameraViewport, resumeSound, resumeStreamingSound, sampleCatmullRomSpline, sampleHermiteSpline, scalePolarToRef, scaleSphericalToRef, selectVariant, setAnimationAdditive, setBonePosition, setBoneRotationQuaternion, setBoneScaling, setBusVolume, setClipPlane, setEngineSize, setEnvironmentLightingRotation, setEnvironmentSkyboxRotation, 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) => {
@@ -26,7 +26,7 @@ var Scalar = {
26
26
  return start + (end - start) * amount;
27
27
  },
28
28
  InverseLerp(a, b, value) {
29
- return a === b ? 0 : (value - a) / (b - a);
29
+ return inverseLerp(a, b, value);
30
30
  },
31
31
  DegreesToRadians(degrees) {
32
32
  return degrees * ToRadians;
@@ -933,12 +933,14 @@ var AbstractEngine = class {
933
933
  constructor(canvas, options) {
934
934
  this._canvas = canvas;
935
935
  const opts = typeof options === "object" ? { ...options } : options === false ? { msaaSamples: 1 } : void 0;
936
+ this.useReverseDepthBuffer = opts?.useReverseDepthBuffer ?? false;
936
937
  if (opts) {
937
938
  if (opts.canvasToneMapping !== void 0 || opts.canvasColorSpace !== void 0) unsupported("WebGPUEngineOptions.canvasToneMapping/canvasColorSpace", "Supporting WebGPU canvas presentation options requires changing Lite's existing surface configuration hot path; it cannot be added as an independently tree-shakeable compat capability.");
938
939
  const antialias = opts.antialias;
939
940
  delete opts.antialias;
940
941
  delete opts.canvasToneMapping;
941
942
  delete opts.canvasColorSpace;
943
+ delete opts.useReverseDepthBuffer;
942
944
  if (antialias === false) opts.msaaSamples = 1;
943
945
  }
944
946
  if (opts?.useLargeWorldRendering) {
@@ -1219,7 +1221,23 @@ var ThinEngine = class extends AbstractEngine {};
1219
1221
  * Babylon Lite is WebGPU-only, so a compat `Engine` is still backed by the same
1220
1222
  * Lite WebGPU context; this class exists to mirror Babylon.js's name + hierarchy.
1221
1223
  */
1222
- var Engine = class extends ThinEngine {};
1224
+ var Engine = class extends ThinEngine {
1225
+ constructor(canvas, antialiasOrOptions, options, adaptToDeviceRatio) {
1226
+ if (typeof antialiasOrOptions === "object") {
1227
+ super(canvas, antialiasOrOptions);
1228
+ return;
1229
+ }
1230
+ if (!options && adaptToDeviceRatio === void 0) {
1231
+ super(canvas, antialiasOrOptions);
1232
+ return;
1233
+ }
1234
+ super(canvas, {
1235
+ ...options,
1236
+ antialias: antialiasOrOptions ?? options?.antialias,
1237
+ ...adaptToDeviceRatio === void 0 ? {} : { adaptToDeviceRatio }
1238
+ });
1239
+ }
1240
+ };
1223
1241
  /**
1224
1242
  * Babylon.js's WebGPU engine. In Babylon.js `WebGPUEngine extends AbstractEngine`
1225
1243
  * (sibling to {@link Engine}). This is the natural engine for the compat layer
@@ -3286,16 +3304,15 @@ var ArcRotateCamera = class ArcRotateCamera extends Camera {
3286
3304
  set radius(value) {
3287
3305
  this._lite.radius = value;
3288
3306
  }
3307
+ /** Live, as in Babylon.js: `camera.target.x = …` and in-place vector math move the target. */
3289
3308
  get target() {
3290
- const t = this._lite.target;
3291
- return new Vector3(t.x, t.y, t.z);
3309
+ return liteBackedVector3(this._lite.target);
3292
3310
  }
3293
3311
  set target(value) {
3294
- this._lite.target = {
3295
- x: value.x,
3296
- y: value.y,
3297
- z: value.z
3298
- };
3312
+ const target = this._lite.target;
3313
+ target.x = value.x;
3314
+ target.y = value.y;
3315
+ target.z = value.z;
3299
3316
  }
3300
3317
  /** Babylon.js `setTarget` — point the arc-rotate camera at a world-space target. */
3301
3318
  setTarget(target) {
@@ -3618,15 +3635,15 @@ var Animation = class Animation {
3618
3635
  return this._keys.length > 0 ? this._keys[this._keys.length - 1].frame : 0;
3619
3636
  }
3620
3637
  /**
3621
- * Assigns the easing function used to transform each non-STEP segment's normalized progress.
3622
- * @param easingFunction - A Babylon.js-shaped easing object, or `null` to restore linear progress.
3638
+ * Assigns default easing for non-STEP segments without a key-specific easing function.
3639
+ * @param easingFunction - A Babylon.js-shaped easing object, or `null` to use linear progress on keys without an override.
3623
3640
  */
3624
3641
  setEasingFunction(easingFunction) {
3625
3642
  this._easingFunction = easingFunction;
3626
3643
  }
3627
3644
  /**
3628
3645
  * Gets the easing function currently assigned to this animation.
3629
- * @returns The assigned easing object, or `null` when interpolation uses linear progress.
3646
+ * @returns The assigned default easing object, or `null` when keys without an override use linear progress.
3630
3647
  */
3631
3648
  getEasingFunction() {
3632
3649
  return this._easingFunction;
@@ -3643,7 +3660,8 @@ var Animation = class Animation {
3643
3660
  if (frame >= a.frame && frame < b.frame) {
3644
3661
  if (a.interpolation === AnimationKeyInterpolation.STEP) return a.value;
3645
3662
  const gradient = (frame - a.frame) / (b.frame - a.frame);
3646
- return interpolateValue(a.value, b.value, this._easingFunction?.ease(gradient) ?? gradient, this.dataType);
3663
+ const easing = a.easingFunction ?? this._easingFunction;
3664
+ return interpolateValue(a.value, b.value, easing?.ease(gradient) ?? gradient, this.dataType);
3647
3665
  }
3648
3666
  }
3649
3667
  return keys[keys.length - 1].value;
@@ -4031,6 +4049,7 @@ function getTrackNativeFallbackReason(target, animation, from, to) {
4031
4049
  }
4032
4050
  if (from < keys[0].frame || to > keys[keys.length - 1].frame) return `native property animation track "${animation.targetProperty}" does not cover the requested play range`;
4033
4051
  if (!uniformInterpolation(keys)) return `native property animation track "${animation.targetProperty}" mixes STEP and LINEAR segments`;
4052
+ if (keys.some((key, index) => index < keys.length - 1 && key.interpolation !== AnimationKeyInterpolation.STEP && key.easingFunction)) return `native property animation track "${animation.targetProperty}" uses per-key easing`;
4034
4053
  if (!supportsNativeBinding(target, animation.targetProperty, stride)) return `native property animation path "${animation.targetProperty}" is not writable by the native binding`;
4035
4054
  }
4036
4055
  function createNativeAnimationGroup(manager, target, animations, from, to, loop, speedRatio) {
@@ -4553,12 +4572,19 @@ var PointerInfo = class {
4553
4572
  type;
4554
4573
  event;
4555
4574
  _pickInfo;
4556
- constructor(type, event, _pickInfo) {
4575
+ _pick;
4576
+ constructor(type, event, _pickInfo, _pick = null) {
4557
4577
  this.type = type;
4558
4578
  this.event = event;
4559
4579
  this._pickInfo = _pickInfo;
4580
+ this._pick = _pick;
4560
4581
  }
4582
+ /** Like Babylon.js lazy picking: without a precomputed pick, `_pick` runs on the first read only. */
4561
4583
  get pickInfo() {
4584
+ if (!this._pickInfo && this._pick) {
4585
+ this._pickInfo = this._pick();
4586
+ this._pick = null;
4587
+ }
4562
4588
  return this._pickInfo;
4563
4589
  }
4564
4590
  };
@@ -4645,6 +4671,9 @@ var Scene = class Scene extends AbstractScene {
4645
4671
  _engine;
4646
4672
  _activeCamera = null;
4647
4673
  cameraToUseForPointers = null;
4674
+ /** Babylon.js `scene.pointerX` / `pointerY`: the last pointer position in CSS pixels relative to the canvas. */
4675
+ pointerX = 0;
4676
+ pointerY = 0;
4648
4677
  _defaultMaterial = null;
4649
4678
  _fogMode = 0;
4650
4679
  _fogStart = 0;
@@ -4661,6 +4690,8 @@ var Scene = class Scene extends AbstractScene {
4661
4690
  _pendingAdds = [];
4662
4691
  _started = false;
4663
4692
  _envTexture = null;
4693
+ /** Environment lighting rotation last forwarded to Lite. */
4694
+ _envRotation = 0;
4664
4695
  _brdfTexture = null;
4665
4696
  _defaultEnvOptions = null;
4666
4697
  _shadowGenerators = [];
@@ -4723,7 +4754,16 @@ var Scene = class Scene extends AbstractScene {
4723
4754
  break;
4724
4755
  default: return;
4725
4756
  }
4726
- this.onPointerObservable.notifyObservers(new PointerInfo(type, event, null), type);
4757
+ const pointerEvent = event;
4758
+ const rect = this._engine.getRenderingCanvasClientRect();
4759
+ if (rect && typeof pointerEvent.clientX === "number") {
4760
+ this.pointerX = pointerEvent.clientX - rect.x;
4761
+ this.pointerY = pointerEvent.clientY - rect.y;
4762
+ }
4763
+ const x = this.pointerX;
4764
+ const y = this.pointerY;
4765
+ const camera = this.cameraToUseForPointers;
4766
+ this.onPointerObservable.notifyObservers(new PointerInfo(type, pointerEvent, null, () => this.pick(x, y, void 0, false, camera)), type);
4727
4767
  };
4728
4768
  for (const type of [
4729
4769
  "pointerdown",
@@ -4762,6 +4802,7 @@ var Scene = class Scene extends AbstractScene {
4762
4802
  this._renderedAFrame = true;
4763
4803
  this.onBeforeRenderObservable.notifyObservers(this);
4764
4804
  for (const callback of this._beforeRenderFlushCallbacks) callback();
4805
+ this._syncEnvironmentRotation();
4765
4806
  }
4766
4807
  /** @internal Register work that must observe all compat before-render mutations before Lite renders. */
4767
4808
  _registerBeforeRenderFlush(callback) {
@@ -5149,6 +5190,20 @@ var Scene = class Scene extends AbstractScene {
5149
5190
  }
5150
5191
  set environmentTexture(value) {
5151
5192
  this._envTexture = value;
5193
+ this._syncEnvironmentRotation();
5194
+ }
5195
+ /**
5196
+ * Forward the environment texture's `rotationY` to the image-based lighting only. As in Babylon.js, a skybox keeps the
5197
+ * orientation it was created with (see {@link createDefaultSkybox}) and the `createDefaultEnvironment` background never
5198
+ * turns. Also runs every frame, so the texture needs no link back to the scenes that use it. A scene whose
5199
+ * environment is never rotated never calls Lite.
5200
+ */
5201
+ _syncEnvironmentRotation() {
5202
+ const rotation = this._envTexture?.rotationY ?? 0;
5203
+ if (rotation !== this._envRotation) {
5204
+ this._envRotation = rotation;
5205
+ setEnvironmentLightingRotation(this._lite, rotation);
5206
+ }
5152
5207
  }
5153
5208
  /**
5154
5209
  * Babylon.js `scene.environmentBRDFTexture` — the BRDF lookup used by PBR materials.
@@ -5207,7 +5262,9 @@ var Scene = class Scene extends AbstractScene {
5207
5262
  * not already set) and flags a skybox-from-environment load at engine start.
5208
5263
  */
5209
5264
  createDefaultSkybox(texture, _pbr, scale, _blur, _setGlobalEnv) {
5210
- if (texture) this._envTexture = texture;
5265
+ if (texture) this.environmentTexture = texture;
5266
+ const skyboxRotation = (texture ?? this._envTexture)?.rotationY ?? 0;
5267
+ if (skyboxRotation) setEnvironmentSkyboxRotation(this._lite, skyboxRotation);
5211
5268
  this._defaultEnvOptions = {
5212
5269
  ...this._defaultEnvOptions ?? {},
5213
5270
  createSkybox: true,
@@ -6278,6 +6335,13 @@ var MorphTargetManager = class {
6278
6335
  * lightweight placeholder transform node until the splat loads, buffering any
6279
6336
  * transforms set in the meantime, then adopting the loaded Lite node.
6280
6337
  */
6338
+ var GAUSSIAN_POINT_SPLATTING_UNSUPPORTED$1 = "Babylon.js Gaussian Point Splatting is a separate stochastic WebGPU compute-renderer subsystem with accumulation, Hi-Z culling, depth-pass integration, and fullscreen compositing lifecycles. Lite's sorted-splat renderer has no equivalent compute or pass-ownership model, and adding one requires broad engine design rather than a small mechanical export.";
6339
+ function _HasGaussianPointSplattingProjectedDepth(projection) {
6340
+ return _hasGaussianPointSplattingProjectedDepth(projection.m);
6341
+ }
6342
+ function _GetPackedShBytesPerSplat(shDegree) {
6343
+ return _getGaussianPointSplattingPackedShBytesPerSplat(shDegree);
6344
+ }
6281
6345
  /** Lite loader chosen by file extension (mirrors the BJS splat plugin dispatch). */
6282
6346
  function liteLoaderFor(url) {
6283
6347
  const lower = url.split("?")[0].toLowerCase();
@@ -6313,6 +6377,12 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
6313
6377
  _ctorUrl;
6314
6378
  /** @internal Optional Lite shader-fragment plugins applied at load (scene 126). */
6315
6379
  _fragments;
6380
+ /** @internal Point-splatting configuration retained for BJS state parity while the unsupported mode is disabled. */
6381
+ _pointSplattingRenderScale = "auto";
6382
+ /** @internal Point-splatting configuration retained for BJS state parity while the unsupported mode is disabled. */
6383
+ _pointSplattingOcclusionCulling = false;
6384
+ /** @internal Point-splatting configuration retained for BJS state parity while the unsupported mode is disabled. */
6385
+ _pointSplattingScale = 1;
6316
6386
  /**
6317
6387
  * Babylon.js `gs.safeOrbitCameraLimits` — safe-orbit camera limits parsed from the source
6318
6388
  * file's metadata (Adobe safe-orbit extension), or `null` when the file carries none.
@@ -6323,6 +6393,39 @@ var GaussianSplattingMesh = class GaussianSplattingMesh extends TransformNode {
6323
6393
  * to Lite's splat loaders; the field is exposed here for shape parity so ported reads resolve.
6324
6394
  */
6325
6395
  safeOrbitCameraLimits = null;
6396
+ get pointSplattingRenderScale() {
6397
+ return this._pointSplattingRenderScale;
6398
+ }
6399
+ set pointSplattingRenderScale(value) {
6400
+ this._pointSplattingRenderScale = value;
6401
+ }
6402
+ get pointSplattingOcclusionCulling() {
6403
+ return this._pointSplattingOcclusionCulling;
6404
+ }
6405
+ set pointSplattingOcclusionCulling(value) {
6406
+ this._pointSplattingOcclusionCulling = value;
6407
+ }
6408
+ get pointSplattingRenderMode() {
6409
+ return false;
6410
+ }
6411
+ set pointSplattingRenderMode(value) {
6412
+ if (value) unsupported("GaussianSplattingMesh.pointSplattingRenderMode", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED$1);
6413
+ }
6414
+ get pointSplattingDepthRenderMode() {
6415
+ return false;
6416
+ }
6417
+ set pointSplattingDepthRenderMode(value) {
6418
+ if (value) unsupported("GaussianSplattingMesh.pointSplattingDepthRenderMode", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED$1);
6419
+ }
6420
+ get pointSplattingProgress() {
6421
+ return null;
6422
+ }
6423
+ get pointSplattingScale() {
6424
+ return this._pointSplattingScale;
6425
+ }
6426
+ set pointSplattingScale(value) {
6427
+ this._pointSplattingScale = value;
6428
+ }
6326
6429
  constructor(name, url, scene, _keepInRam) {
6327
6430
  super(name, scene, createTransformNode(name));
6328
6431
  this._ctorUrl = url ?? null;
@@ -6975,6 +7078,11 @@ var CubeTexture = class CubeTexture extends BaseTexture {
6975
7078
  _envLoaderKind = "cube";
6976
7079
  /** Fires when the cube map is "ready" (resolved on a microtask in this compat layer). */
6977
7080
  onLoadObservable = new Observable();
7081
+ /**
7082
+ * Babylon.js `CubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
7083
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
7084
+ */
7085
+ rotationY = 0;
6978
7086
  _ready = false;
6979
7087
  _readyPromise;
6980
7088
  constructor(url, _scene, _extensions, _noMipmap, _files, onLoad, _onError, _format, _prefiltered) {
@@ -7027,6 +7135,11 @@ var HDRCubeTexture = class extends BaseTexture {
7027
7135
  _envLoaderKind = "hdr";
7028
7136
  /** Fires when the HDR environment is "ready" (resolved on a microtask). */
7029
7137
  onLoadObservable = new Observable();
7138
+ /**
7139
+ * Babylon.js `HDRCubeTexture.rotationY` — rotation of the environment around the Y axis, in radians. A scene that uses the
7140
+ * texture as its `environmentTexture` turns its image-based lighting with it (see `Scene.environmentTexture`).
7141
+ */
7142
+ rotationY = 0;
7030
7143
  _ready = false;
7031
7144
  _readyPromise;
7032
7145
  constructor(url, _sceneOrEngine, size = 256, _noMipmap, _generateHarmonics, _gammaSpace, _prefilterOnLoad, onLoad) {
@@ -8302,14 +8415,19 @@ var PositionGizmo = class extends GizmoBase {
8302
8415
  return this._attached;
8303
8416
  }
8304
8417
  set attachedMesh(value) {
8305
- this._attached = value;
8306
- attachPositionGizmoToNode(this._lite, value?._lite ?? null);
8418
+ this.attachedNode = value;
8307
8419
  }
8420
+ /**
8421
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
8422
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
8423
+ */
8308
8424
  get attachedNode() {
8309
8425
  return this._attached;
8310
8426
  }
8311
8427
  set attachedNode(value) {
8312
- this.attachedMesh = value;
8428
+ const target = transformTargetLite(value, "PositionGizmo.attachedNode");
8429
+ this._attached = value;
8430
+ attachPositionGizmoToNode(this._lite, target);
8313
8431
  }
8314
8432
  dispose() {
8315
8433
  disposePositionGizmo(this._lite, this._layer._lite);
@@ -8359,14 +8477,19 @@ var RotationGizmo = class extends GizmoBase {
8359
8477
  return this._attached;
8360
8478
  }
8361
8479
  set attachedMesh(value) {
8362
- this._attached = value;
8363
- attachRotationGizmoToNode(this._lite, value?._lite ?? null);
8480
+ this.attachedNode = value;
8364
8481
  }
8482
+ /**
8483
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
8484
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
8485
+ */
8365
8486
  get attachedNode() {
8366
8487
  return this._attached;
8367
8488
  }
8368
8489
  set attachedNode(value) {
8369
- this.attachedMesh = value;
8490
+ const target = transformTargetLite(value, "RotationGizmo.attachedNode");
8491
+ this._attached = value;
8492
+ attachRotationGizmoToNode(this._lite, target);
8370
8493
  }
8371
8494
  dispose() {
8372
8495
  disposeRotationGizmo(this._lite, this._layer._lite);
@@ -8407,14 +8530,19 @@ var ScaleGizmo = class extends GizmoBase {
8407
8530
  return this._attached;
8408
8531
  }
8409
8532
  set attachedMesh(value) {
8410
- this._attached = value;
8411
- attachScaleGizmoToNode(this._lite, value?._lite ?? null);
8533
+ this.attachedNode = value;
8412
8534
  }
8535
+ /**
8536
+ * Babylon.js `attachedNode` — a mesh, a `TransformNode` (whose Lite node is `_node` rather than `_lite`) or a light.
8537
+ * Cameras throw a `LiteCompatError`: see {@link transformTargetLite}.
8538
+ */
8413
8539
  get attachedNode() {
8414
8540
  return this._attached;
8415
8541
  }
8416
8542
  set attachedNode(value) {
8417
- this.attachedMesh = value;
8543
+ const target = transformTargetLite(value, "ScaleGizmo.attachedNode");
8544
+ this._attached = value;
8545
+ attachScaleGizmoToNode(this._lite, target);
8418
8546
  }
8419
8547
  dispose() {
8420
8548
  disposeScaleGizmo(this._lite, this._layer._lite);
@@ -8530,6 +8658,16 @@ function nodeLite(value) {
8530
8658
  return n._lite ?? n._node ?? null;
8531
8659
  }
8532
8660
  /**
8661
+ * Lite node for a composite gizmo target. The native gizmos edit the target's `position`, `rotationQuaternion` and
8662
+ * `scaling`. Meshes, transform nodes and lights have them; Lite cameras do not (an orbit camera has none, a free camera
8663
+ * only `position`), so a camera is rejected before attachment instead of failing on the first drag.
8664
+ */
8665
+ function transformTargetLite(value, api) {
8666
+ const lite = nodeLite(value);
8667
+ if (lite && !(lite.position && lite.rotationQuaternion && lite.scaling)) unsupported(api, `A ${value.getClassName()} has no editable transform in Babylon Lite. Attach the gizmo to a mesh, transform node or light.`);
8668
+ return lite;
8669
+ }
8670
+ /**
8533
8671
  * @internal Build a single-axis/plane gizmo wrapper around a Lite sub-gizmo that
8534
8672
  * a composite already created, without re-running the public constructor (which
8535
8673
  * would build a second Lite gizmo). Used by the composite `xGizmo`/`yGizmo`/`zGizmo`
@@ -9827,9 +9965,9 @@ RandomId: RandomGUID };
9827
9965
  //#region src/misc/tools.ts
9828
9966
  /** Babylon.js-compatible `Tools` helpers (the small, pure subset). */
9829
9967
  var Tools = {
9830
- /** High-resolution timestamp in milliseconds. */
9831
- Now() {
9832
- return typeof performance !== "undefined" ? performance.now() : Date.now();
9968
+ /** Current high-resolution timestamp in milliseconds, matching Babylon.js's numeric property. */
9969
+ get Now() {
9970
+ return PrecisionDate.Now;
9833
9971
  },
9834
9972
  ToRadians(degrees) {
9835
9973
  return degrees * Math.PI / 180;
@@ -11440,6 +11578,8 @@ var MaterialPluginBase = class MaterialPluginBase {
11440
11578
  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.";
11441
11579
  var DITHERED_TILE_FADE_UNSUPPORTED = "Lite's material-plugin bridge supports shared shader injection, but not Babylon.js per-draw mesh uniforms, hardware-instance bounds, or custom thin-instance attributes/varyings. Adding those requires an opt-in per-renderable plugin-data design.";
11442
11580
  var GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED = "Lite's Gaussian-splat renderable fixes shader fragments and render state at load time and exposes no post-load material replacement or pipeline-rebuild lifecycle. Supporting Babylon.js GaussianSplattingMaterial plugins requires an opt-in Lite splat-material lifecycle design.";
11581
+ var GAUSSIAN_POINT_SPLATTING_UNSUPPORTED = "Babylon.js Gaussian Point Splatting is a separate stochastic WebGPU compute-renderer subsystem with accumulation, Hi-Z culling, depth-pass integration, and fullscreen compositing lifecycles. Lite's sorted-splat renderer has no equivalent compute or pass-ownership model, and adding one requires broad engine design rather than a small mechanical export.";
11582
+ var SHADER_MATERIAL_UNSUPPORTED = "Lite accepts standalone WGSL, but Babylon.js ShaderMaterial sources rely on the Effect shader-store/preprocessor dialect (attribute/varying declarations and injected VertexInputs/FragmentInputs); adapting it requires a shader preprocessing subsystem.";
11443
11583
  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.";
11444
11584
  var FlowGraphValidationSeverity = /* @__PURE__ */ function(FlowGraphValidationSeverity) {
11445
11585
  FlowGraphValidationSeverity[FlowGraphValidationSeverity["Error"] = 0] = "Error";
@@ -11452,6 +11592,12 @@ function ValidateFlowGraph(_flowGraph) {
11452
11592
  function ValidateFlowGraphWithBlockList(_flowGraph, _allKnownBlocks) {
11453
11593
  return unsupported("ValidateFlowGraphWithBlockList", FLOW_GRAPH_UNSUPPORTED);
11454
11594
  }
11595
+ function RemoveFlowGraphAnimationGroupObservers(_context, _animationGroup) {
11596
+ return unsupported("RemoveFlowGraphAnimationGroupObservers", FLOW_GRAPH_UNSUPPORTED);
11597
+ }
11598
+ function defaultValueParseFunction(_key, _serializationObject, _assetsContainer, _scene) {
11599
+ return unsupported("defaultValueParseFunction", FLOW_GRAPH_UNSUPPORTED);
11600
+ }
11455
11601
  var FluidRenderingObject = class {
11456
11602
  static UsePerParticleSizeAttribute = false;
11457
11603
  constructor(_scene, _shaderLanguage) {
@@ -11712,6 +11858,87 @@ function RegisterGaussianSplattingOverdrawMaterialPlugin() {
11712
11858
  function RegisterGaussianSplattingMaterial() {
11713
11859
  unsupported("RegisterGaussianSplattingMaterial", GAUSSIAN_SPLATTING_MATERIAL_UNSUPPORTED);
11714
11860
  }
11861
+ var GaussianPointSplattingRenderer = class {
11862
+ pointScale = 1;
11863
+ kernelSize = .3;
11864
+ minPixelSize = 0;
11865
+ rightHandedSystem = false;
11866
+ debugActive = 0;
11867
+ isOrthographic = false;
11868
+ compensation = false;
11869
+ occlusionCulling = false;
11870
+ maxAccumFrames = 255;
11871
+ constructor(_engine) {
11872
+ unsupported("GaussianPointSplattingRenderer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11873
+ }
11874
+ supportsWorkload(_gaussianCount, _shDegree, _outWidth, _outHeight) {
11875
+ return unsupported("GaussianPointSplattingRenderer.supportsWorkload", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11876
+ }
11877
+ get accumBuffer() {
11878
+ return unsupported("GaussianPointSplattingRenderer.accumBuffer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11879
+ }
11880
+ get accumDepthBuffer() {
11881
+ return unsupported("GaussianPointSplattingRenderer.accumDepthBuffer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11882
+ }
11883
+ get renderedFrameCount() {
11884
+ return unsupported("GaussianPointSplattingRenderer.renderedFrameCount", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11885
+ }
11886
+ get accumulationVersion() {
11887
+ return unsupported("GaussianPointSplattingRenderer.accumulationVersion", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11888
+ }
11889
+ get pixelCycleLength() {
11890
+ return unsupported("GaussianPointSplattingRenderer.pixelCycleLength", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11891
+ }
11892
+ async readPointCountAsync() {
11893
+ return unsupported("GaussianPointSplattingRenderer.readPointCountAsync", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11894
+ }
11895
+ get width() {
11896
+ return unsupported("GaussianPointSplattingRenderer.width", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11897
+ }
11898
+ get height() {
11899
+ return unsupported("GaussianPointSplattingRenderer.height", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11900
+ }
11901
+ get outputWidth() {
11902
+ return unsupported("GaussianPointSplattingRenderer.outputWidth", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11903
+ }
11904
+ get outputHeight() {
11905
+ return unsupported("GaussianPointSplattingRenderer.outputHeight", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11906
+ }
11907
+ get gaussianCount() {
11908
+ return unsupported("GaussianPointSplattingRenderer.gaussianCount", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11909
+ }
11910
+ isReady() {
11911
+ return unsupported("GaussianPointSplattingRenderer.isReady", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11912
+ }
11913
+ updateSplats(_means, _cov3d, _colorOpacity, _sh, _shDegree, _count) {
11914
+ unsupported("GaussianPointSplattingRenderer.updateSplats", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11915
+ }
11916
+ resetAccumulation() {
11917
+ unsupported("GaussianPointSplattingRenderer.resetAccumulation", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11918
+ }
11919
+ setCamera(_view, _viewProjection, _near, _far, _focalX, _focalY, _camX, _camY, _camZ, _viewZMin, _viewZMax) {
11920
+ unsupported("GaussianPointSplattingRenderer.setCamera", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11921
+ }
11922
+ setProjectionZ(_m10, _m11, _m14, _m15) {
11923
+ unsupported("GaussianPointSplattingRenderer.setProjectionZ", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11924
+ }
11925
+ setProjectionMatrix(_projection, _inverseProjection, _reverseDepth = false) {
11926
+ unsupported("GaussianPointSplattingRenderer.setProjectionMatrix", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11927
+ }
11928
+ setPartData(_packed, _count) {
11929
+ unsupported("GaussianPointSplattingRenderer.setPartData", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11930
+ }
11931
+ /** @internal */
11932
+ _matchesPartData(_packed, _count) {
11933
+ return unsupported("GaussianPointSplattingRenderer._matchesPartData", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11934
+ }
11935
+ renderToBuffer(_width, _height, _outWidth = _width, _outHeight = _height, _upsampleN = 1, _jitterX = 0, _jitterY = 0) {
11936
+ return unsupported("GaussianPointSplattingRenderer.renderToBuffer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11937
+ }
11938
+ dispose() {
11939
+ unsupported("GaussianPointSplattingRenderer.dispose", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11940
+ }
11941
+ };
11715
11942
  var DitheredTileFadeMaterialPlugin = class DitheredTileFadeMaterialPlugin extends MaterialPluginBase {
11716
11943
  static Name = "DitheredTileFade";
11717
11944
  /** @internal The unsupported constructor must not alter the material or scene. */
@@ -11769,8 +11996,69 @@ var DitheredTileFadeMaterialPlugin = class DitheredTileFadeMaterialPlugin extend
11769
11996
  }
11770
11997
  };
11771
11998
  var ShaderMaterial = class {
11999
+ /** @internal Stable diagnostic API inherited by unsupported subclasses. */
12000
+ static _UnsupportedApi = "ShaderMaterial";
12001
+ /** @internal Stable structural blocker inherited by unsupported subclasses. */
12002
+ static _UnsupportedReason = SHADER_MATERIAL_UNSUPPORTED;
11772
12003
  constructor() {
11773
- unsupported("ShaderMaterial", "Lite accepts standalone WGSL, but Babylon.js ShaderMaterial sources rely on the Effect shader-store/preprocessor dialect (attribute/varying declarations and injected VertexInputs/FragmentInputs); adapting it requires a shader preprocessing subsystem.");
12004
+ unsupported(new.target._UnsupportedApi, new.target._UnsupportedReason);
12005
+ }
12006
+ };
12007
+ var GaussianPointSplattingBlitMaterial = class extends ShaderMaterial {
12008
+ /** @internal Stable diagnostic API inherited by consumer subclasses. */
12009
+ static _UnsupportedApi = "GaussianPointSplattingBlitMaterial";
12010
+ /** @internal Stable structural blocker inherited by consumer subclasses. */
12011
+ static _UnsupportedReason = GAUSSIAN_POINT_SPLATTING_UNSUPPORTED;
12012
+ constructor(_name, _scene) {
12013
+ super();
12014
+ }
12015
+ setAccumBuffer(_buffer) {
12016
+ unsupported("GaussianPointSplattingBlitMaterial.setAccumBuffer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12017
+ }
12018
+ setAccumDepthBuffer(_buffer) {
12019
+ unsupported("GaussianPointSplattingBlitMaterial.setAccumDepthBuffer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12020
+ }
12021
+ setResolution(_width, _height) {
12022
+ unsupported("GaussianPointSplattingBlitMaterial.setResolution", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12023
+ }
12024
+ setProjectionZ(_m10, _m11, _m14, _m15) {
12025
+ unsupported("GaussianPointSplattingBlitMaterial.setProjectionZ", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12026
+ }
12027
+ setInverseProjection(_inverseProjection) {
12028
+ unsupported("GaussianPointSplattingBlitMaterial.setInverseProjection", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12029
+ }
12030
+ setLogarithmicDepthConstant(_constant) {
12031
+ unsupported("GaussianPointSplattingBlitMaterial.setLogarithmicDepthConstant", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12032
+ }
12033
+ };
12034
+ var GaussianPointSplattingDepthBlitMaterial = class extends ShaderMaterial {
12035
+ /** @internal Stable diagnostic API inherited by consumer subclasses. */
12036
+ static _UnsupportedApi = "GaussianPointSplattingDepthBlitMaterial";
12037
+ /** @internal Stable structural blocker inherited by consumer subclasses. */
12038
+ static _UnsupportedReason = GAUSSIAN_POINT_SPLATTING_UNSUPPORTED;
12039
+ constructor(_name, _scene) {
12040
+ super();
12041
+ }
12042
+ setAccumBuffer(_buffer) {
12043
+ unsupported("GaussianPointSplattingDepthBlitMaterial.setAccumBuffer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12044
+ }
12045
+ setAccumDepthBuffer(_buffer) {
12046
+ unsupported("GaussianPointSplattingDepthBlitMaterial.setAccumDepthBuffer", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12047
+ }
12048
+ setResolution(_width, _height) {
12049
+ unsupported("GaussianPointSplattingDepthBlitMaterial.setResolution", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12050
+ }
12051
+ setProjectionZ(_m10, _m11, _m14, _m15) {
12052
+ unsupported("GaussianPointSplattingDepthBlitMaterial.setProjectionZ", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12053
+ }
12054
+ setInverseProjection(_inverseProjection) {
12055
+ unsupported("GaussianPointSplattingDepthBlitMaterial.setInverseProjection", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12056
+ }
12057
+ setDepthValues(_minZ, _minZPlusMaxZ) {
12058
+ unsupported("GaussianPointSplattingDepthBlitMaterial.setDepthValues", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
12059
+ }
12060
+ setReverseDepth(_reverse) {
12061
+ unsupported("GaussianPointSplattingDepthBlitMaterial.setReverseDepth", GAUSSIAN_POINT_SPLATTING_UNSUPPORTED);
11774
12062
  }
11775
12063
  };
11776
12064
  var BackgroundMaterial = class {
@@ -12219,6 +12507,18 @@ var gltfTypeToBabylonType = {
12219
12507
  elementType: "any"
12220
12508
  }
12221
12509
  };
12510
+ var FlowGraphDelayReferenceBlock = class {
12511
+ config;
12512
+ input;
12513
+ value;
12514
+ constructor(config) {
12515
+ this.config = config;
12516
+ unsupported("GLTF2.FlowGraphDelayReferenceBlock", KHR_INTERACTIVITY_UNSUPPORTED);
12517
+ }
12518
+ getClassName() {
12519
+ return "FlowGraphDelayReferenceBlock";
12520
+ }
12521
+ };
12222
12522
  var FlowGraphEventReferenceBlock = class {
12223
12523
  config;
12224
12524
  constructor(config) {
@@ -12327,6 +12627,7 @@ var gltf2_exports = /* @__PURE__ */ __exportAll({
12327
12627
  CreateKHRInteractivityDocument: () => CreateKHRInteractivityDocument,
12328
12628
  CreateKHRInteractivityExportPlan: () => CreateKHRInteractivityExportPlan,
12329
12629
  CreateKHRInteractivityGraphModel: () => CreateKHRInteractivityGraphModel,
12630
+ FlowGraphDelayReferenceBlock: () => FlowGraphDelayReferenceBlock,
12330
12631
  FlowGraphEventReferenceBlock: () => FlowGraphEventReferenceBlock,
12331
12632
  FlowGraphGLTFDataProvider: () => FlowGraphGLTFDataProvider,
12332
12633
  FlowGraphObjectReferenceBlock: () => FlowGraphObjectReferenceBlock,
@@ -12534,6 +12835,18 @@ var GaussianSplattingStream = class extends GaussianSplattingMesh {
12534
12835
  evaluateOptimalLods(_camera = null) {
12535
12836
  return unsupported("GaussianSplattingStream.evaluateOptimalLods", STREAM_BLOCKER);
12536
12837
  }
12838
+ getSourceRange(_fileId) {
12839
+ return unsupported("GaussianSplattingStream.getSourceRange", STREAM_BLOCKER);
12840
+ }
12841
+ isSplitPage(_fileId) {
12842
+ return unsupported("GaussianSplattingStream.isSplitPage", STREAM_BLOCKER);
12843
+ }
12844
+ cancelRangeLoads(_files, _keepSources = []) {
12845
+ unsupported("GaussianSplattingStream.cancelRangeLoads", STREAM_BLOCKER);
12846
+ }
12847
+ get rangeResidencyStats() {
12848
+ return unsupported("GaussianSplattingStream.rangeResidencyStats", STREAM_BLOCKER);
12849
+ }
12537
12850
  };
12538
12851
  function AddGaussianSplattingStreamPart(_compound, _name, _metadata, _rootUrl, _options = {}) {
12539
12852
  return unsupported("AddGaussianSplattingStreamPart", COMPOUND_BLOCKER);
@@ -13164,6 +13477,6 @@ var NodeParticleSystemSet = class NodeParticleSystemSet {
13164
13477
  }
13165
13478
  };
13166
13479
  //#endregion
13167
- export { AbstractAssetTask, AbstractAudioAnalyzer, AbstractAudioBus, AbstractAudioNode, AbstractAudioOutNode, AbstractEngine, AbstractMesh, AbstractNamedAudioNode, AbstractScene, AbstractSound, AbstractSoundSource, AbstractSpatialAudio, AbstractSpatialAudioListener, AbstractStereoAudio, Action, ActionManager, ActionManagerTriggers, AddGaussianSplattingStreamPart, AddGaussianSplattingStreamPartAsync, AmmoJSPlugin, AnaglyphArcRotateCamera, Angle, Animatable, Animation, AnimationGroup, AnimationKeyInterpolation, AnimationLoopModes, AnimationTypes, AppendSceneAsync, ArcRotateCamera, AssetContainer, AssetsManager, AttachToBoxBehavior, AudioBus, AudioEngine, AudioEngineV2, AudioParameterRampShape, AutoRotationBehavior, Axis, AxisDragGizmo, AxisScaleGizmo, BVHFileLoader, BackEase, BackgroundMaterial, BallAndSocketConstraint, BaseSixDofDragBehavior, BaseTexture, BezierCurveEase, BlackAndWhitePostProcess, BloomEffect, BlurPostProcess, Bone, BounceEase, BouncingBehavior, BoundingBox, BoundingBoxGizmo, BoundingBoxRenderer, BoundingInfo, BoundingSphere, CSG, CSG2, Camera, CameraGizmo, CannonJSPlugin, CascadedShadowGenerator, CastingResult, CharacterSupportedState, ChromaticAberrationPostProcess, CircleEase, ClusteredLightContainer, Color3, Color4, ColorGradient, CompleteGreasedLineColorTable, CompleteGreasedLineWidthTable, ComputeOverlayCssTransform, ComputeShader, ComputeShaderParse, Condition, Constants, CreateAudioBusAsync, CreateAudioEngineAsync, CreateBox, CreateCylinder, CreateDashedLines, CreateDefaultMeshBlendRadiusDefinitions, CreateDisc, CreateGreasedLine, CreateGreasedLineMaterial, CreateGround, CreateLineSystem, CreateLines, CreateMainAudioBusAsync, CreateMicrophoneSoundSourceAsync, CreatePlane, CreatePolygon, CreatePolygonVertexData, CreateSoundAsync, CreateSoundBufferAsync, CreateSoundSourceAsync, CreateSphere, CreateStreamingSoundAsync, CreateTexture2DArrayFromImageUrlsAsync, CreateTexture2DArrayFromKTX2Async, CreateTiledBox, CreateTiledPlane, CreateTorus, CubeTexture, CubicEase, Curve3, CustomAssetTask, DefaultRenderingPipeline, DepthOfFieldEffect, DepthRenderer, DeviceOrientationCamera, DirectionalLight, DistanceConstraint, DitheredTileFadeMaterialPlugin, DynamicTexture, EASINGMODE_EASEIN, EASINGMODE_EASEINOUT, EASINGMODE_EASEOUT, EasingFunction, EdgesRenderer, Effect, EffectLayer, EffectWrapper, ElasticEase, Engine, Epsilon, ExecuteCodeAction, ExponentialEase, ExternalTexture, ExtrudePolygon, FBXConstraintBehavior, FBXConstraintSolver, FBXFileLoader, FBXFileLoaderMetadata, FSR1RenderingPipeline, FactorGradient, FadeInOutBehavior, FlowGraphValidationSeverity, FluidRenderer, FluidRendererSceneComponent, FluidRenderingObject, FluidRenderingObjectCustomParticles, FluidRenderingObjectParticleSystem, FluidRenderingTargetRenderer, FlyCamera, FollowBehavior, FollowCamera, FrameGraphMeshBlendingTask, FrameGraphMinMaxReducerTask, FramingBehavior, FreeCamera, Frustum, FxaaPostProcess, gltf1_exports as GLTF1, gltf2_exports as GLTF2, GPUParticleSystem, GPUPicker, GUID, GamepadCamera, GaussianSplattingDebugMaterialPlugin, GaussianSplattingGpuPickingMaterialPlugin, GaussianSplattingMaterial, GaussianSplattingMaxPartCount, GaussianSplattingMesh, GaussianSplattingOverdrawMaterialPlugin, GaussianSplattingPartProxyMesh, GaussianSplattingSizeMaterialPlugin, GaussianSplattingSolidColorMaterialPlugin, GaussianSplattingStream, GeometryBufferRenderer, GeospatialCamera, GeospatialClippingBehavior, GetElementPixelFromUv, GetGaussianSplattingMaxPartCount, GetPartIndexVaryingDeclaration, GetPointsCount, GetSupportedSimultaneousLights, GetWhiteBalanceMatrix, GizmoManager, GlowLayer, GreasedLineBaseMesh, GreasedLineMaterialDefaults, GreasedLineMesh, GreasedLineMeshColorDistribution, GreasedLineMeshWidthDistribution, GreasedLinePluginMaterial, GreasedLineRibbonAutoDirectionMode, GreasedLineRibbonFacesMode, GreasedLineRibbonMesh, GreasedLineRibbonPointsMode, GreasedLineSimpleMaterial, GreasedLineTools, GridMaterial, GroundMesh, HDRCubeTexture, HandConstraintBehavior, HavokPlugin, HemisphericLight, HighlightLayer, HingeConstraint, HtmlInteractionManager, HtmlRaycastInteractionManager, HtmlTexture, ImageProcessingConfiguration, ImportMeshAsync, IncrementValueAction, InitializeCSG2Async, InstallHtmlInCanvasPolyfill, InstancedMesh, InterpolatingBehavior, IsHtmlInCanvasSupportedNatively, IsHtmlInCanvasUploadSupported, KHR_materials_variants, LastCreatedAudioEngine, Layer, Light, LightGizmo, LinesMesh, LiteCompatError, LoadAssetContainerAsync, LoadImageToTexture2DArrayLayerAsync, LockConstraint, Logger, MainAudioBus, Material, MaterialGreasedLineDefines, MaterialPluginBase, MaterialPluginManager, Matrix, MaxTintMagnitude, Mesh, MeshBlendDebugMode, MeshBlendDepthType, MeshBlendQuality, MeshBlendingPostProcess, MeshBlendingRadiusClass, MeshBuilder, MeshoptCompression, MinTemperatureKelvin, MirrorTexture, MorphTarget, MorphTargetManager, MultiMaterial, MultiPointerScaleBehavior, Node, NodeMaterial, NodeParticleSystemSet, NodeRenderGraphMeshBlendingPostProcessBlock, NodeRenderGraphMinMaxReducerBlock, NullEngine, OBJFileLoader, Observable, OnAudioEngineV2CreatedObservable, OpenPBRMaterial, OpenPBRMaterialDefines, OpenPBRMaterialLoadingAdapter, OutlineRenderer, PBRAnisotropicConfiguration, PBRClearCoatConfiguration, PBRIridescenceConfiguration, PBRMaterial, PBRMetallicRoughnessMaterial, PBRSheenConfiguration, PBRSpecularGlossinessMaterial, PackMeshBlendingTag, ParticleHelper, ParticleSystem, ParticleSystemSet, Path3D, PerformanceMonitor, Physics6DoFConstraint, Physics6DoFLimit, PhysicsAggregate, PhysicsBody, PhysicsCharacterController, PhysicsConstraint, PhysicsConstraintAxis, PhysicsConstraintType, PhysicsEngine, PhysicsMotionType, PhysicsPrestepType, PhysicsRaycastResult, PhysicsShape, PhysicsShapeType, PickingInfo, Plane, PlaneDragGizmo, PlaneRotationGizmo, PointLight, PointerDragBehavior, PointerEventTypes, PointerInfo, PointsCloudSystem, Polar, PolygonBuilder, PositionGizmo, PostProcess, PowerEase, PrecisionDate, PredicateCondition, PrismaticConstraint, PushMaterial, QuadraticEase, QuarticEase, Quaternion, QuinticEase, RandomGUID, RawTexture, RawTexture2DArray, RawTexture3D, Ray, RecastJSPlugin, RectAreaLight, ReflectionProbe, RegisterAbstractEngineTextureLoaders, RegisterComputeShader, RegisterEnginesExtensionsEngineTexture2DArrayImageSource, RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource, RegisterFluidRenderer, RegisterGaussianSplattingDebugMaterialPlugin, RegisterGaussianSplattingGpuPickingMaterialPlugin, RegisterGaussianSplattingMaterial, RegisterGaussianSplattingOverdrawMaterialPlugin, RegisterGaussianSplattingSizeMaterialPlugin, RegisterGaussianSplattingSolidColorMaterialPlugin, RegisterGreasedLinePluginMaterial, RegisterImageProcessingConfiguration, RegisterMeshBlendingPostProcessBlock, RegisterMinMaxReducerBlock, RegisterOpenpbrMaterial, RegisterPolygonBuilder, RegisterSPLATFileLoader, RegisterUSDFileLoader, RenderTargetTexture, RootMotionClip, RootMotionController, RootMotionSource, RotationGizmo, SPLATFileLoader, SSAO2RenderingPipeline, STLFileLoader, Scalar, ScaleGizmo, Scene, SceneLoader, SceneOptimizer, ScenePerformancePriority, SceneSerializer, SetValueAction, ShaderLanguage, ShaderMaterial, ShadowGenerator, SineEase, SixDofDragBehavior, Size, Skeleton, SliderConstraint, SmartArray, SolidParticleSystem, Sound, SoundSource, SoundState, Space, SpatialAudioAttachmentType, Spherical, SpotLight, SpringConstraint, Sprite, SpriteManager, SpriteMap, SpritePackedManager, SpriteRenderer, StandardMaterial, StaticSound, StaticSoundBuffer, StorageBuffer, StreamingSound, StringDictionary, SurfaceMagnetismBehavior, Tags, TargetCamera, TemperatureTintToXyz, Texture, ThinEngine, ThinFSR1SharpenPostProcess, ThinFSR1UpscalePostProcess, ThinMeshBlendingPostProcess, ThinSprite, ToDegrees, ToRadians, Tools, TouchCamera, TransformNode, USDFileLoader, UniformBuffer, UninstallHtmlInCanvasPolyfill, UniversalCamera, UnpackMeshBlendingTag, UploadHtmlElementToTexture, UploadImageToTexture2DArrayLayer, UtilityLayerRenderer, ValidateFlowGraph, ValidateFlowGraphWithBlockList, ValueCondition, ValueConditionOperators, Vector2, Vector3, Vector4, VertexBuffer, VertexData, Viewport, VirtualJoystick, WebGPUEngine, WebXRCamera, WeightedSound, _RegisterUSDLoaderDependencies, registerBuiltInLoaders, transformCoordinates, transformNormal, unsupported };
13480
+ export { AbstractAssetTask, AbstractAudioAnalyzer, AbstractAudioBus, AbstractAudioNode, AbstractAudioOutNode, AbstractEngine, AbstractMesh, AbstractNamedAudioNode, AbstractScene, AbstractSound, AbstractSoundSource, AbstractSpatialAudio, AbstractSpatialAudioListener, AbstractStereoAudio, Action, ActionManager, ActionManagerTriggers, AddGaussianSplattingStreamPart, AddGaussianSplattingStreamPartAsync, AmmoJSPlugin, AnaglyphArcRotateCamera, Angle, Animatable, Animation, AnimationGroup, AnimationKeyInterpolation, AnimationLoopModes, AnimationTypes, AppendSceneAsync, ArcRotateCamera, AssetContainer, AssetsManager, AttachToBoxBehavior, AudioBus, AudioEngine, AudioEngineV2, AudioParameterRampShape, AutoRotationBehavior, Axis, AxisDragGizmo, AxisScaleGizmo, BVHFileLoader, BackEase, BackgroundMaterial, BallAndSocketConstraint, BaseSixDofDragBehavior, BaseTexture, BezierCurveEase, BlackAndWhitePostProcess, BloomEffect, BlurPostProcess, Bone, BounceEase, BouncingBehavior, BoundingBox, BoundingBoxGizmo, BoundingBoxRenderer, BoundingInfo, BoundingSphere, CSG, CSG2, Camera, CameraGizmo, CannonJSPlugin, CascadedShadowGenerator, CastingResult, CharacterSupportedState, ChromaticAberrationPostProcess, CircleEase, ClusteredLightContainer, Color3, Color4, ColorGradient, CompleteGreasedLineColorTable, CompleteGreasedLineWidthTable, ComputeOverlayCssTransform, ComputeShader, ComputeShaderParse, Condition, Constants, CreateAudioBusAsync, CreateAudioEngineAsync, CreateBox, CreateCylinder, CreateDashedLines, CreateDefaultMeshBlendRadiusDefinitions, CreateDisc, CreateGreasedLine, CreateGreasedLineMaterial, CreateGround, CreateLineSystem, CreateLines, CreateMainAudioBusAsync, CreateMicrophoneSoundSourceAsync, CreatePlane, CreatePolygon, CreatePolygonVertexData, CreateSoundAsync, CreateSoundBufferAsync, CreateSoundSourceAsync, CreateSphere, CreateStreamingSoundAsync, CreateTexture2DArrayFromImageUrlsAsync, CreateTexture2DArrayFromKTX2Async, CreateTiledBox, CreateTiledPlane, CreateTorus, CubeTexture, CubicEase, Curve3, CustomAssetTask, DefaultRenderingPipeline, DepthOfFieldEffect, DepthRenderer, DeviceOrientationCamera, DirectionalLight, DistanceConstraint, DitheredTileFadeMaterialPlugin, DynamicTexture, EASINGMODE_EASEIN, EASINGMODE_EASEINOUT, EASINGMODE_EASEOUT, EasingFunction, EdgesRenderer, Effect, EffectLayer, EffectWrapper, ElasticEase, Engine, Epsilon, ExecuteCodeAction, ExponentialEase, ExternalTexture, ExtrudePolygon, FBXConstraintBehavior, FBXConstraintSolver, FBXFileLoader, FBXFileLoaderMetadata, FSR1RenderingPipeline, FactorGradient, FadeInOutBehavior, FlowGraphValidationSeverity, FluidRenderer, FluidRendererSceneComponent, FluidRenderingObject, FluidRenderingObjectCustomParticles, FluidRenderingObjectParticleSystem, FluidRenderingTargetRenderer, FlyCamera, FollowBehavior, FollowCamera, FrameGraphMeshBlendingTask, FrameGraphMinMaxReducerTask, FramingBehavior, FreeCamera, Frustum, FxaaPostProcess, gltf1_exports as GLTF1, gltf2_exports as GLTF2, GPUParticleSystem, GPUPicker, GUID, GamepadCamera, GaussianPointSplattingBlitMaterial, GaussianPointSplattingDepthBlitMaterial, GaussianPointSplattingRenderer, GaussianSplattingDebugMaterialPlugin, GaussianSplattingGpuPickingMaterialPlugin, GaussianSplattingMaterial, GaussianSplattingMaxPartCount, GaussianSplattingMesh, GaussianSplattingOverdrawMaterialPlugin, GaussianSplattingPartProxyMesh, GaussianSplattingSizeMaterialPlugin, GaussianSplattingSolidColorMaterialPlugin, GaussianSplattingStream, GeometryBufferRenderer, GeospatialCamera, GeospatialClippingBehavior, GetElementPixelFromUv, GetGaussianSplattingMaxPartCount, GetPartIndexVaryingDeclaration, GetPointsCount, GetSupportedSimultaneousLights, GetWhiteBalanceMatrix, GizmoManager, GlowLayer, GreasedLineBaseMesh, GreasedLineMaterialDefaults, GreasedLineMesh, GreasedLineMeshColorDistribution, GreasedLineMeshWidthDistribution, GreasedLinePluginMaterial, GreasedLineRibbonAutoDirectionMode, GreasedLineRibbonFacesMode, GreasedLineRibbonMesh, GreasedLineRibbonPointsMode, GreasedLineSimpleMaterial, GreasedLineTools, GridMaterial, GroundMesh, HDRCubeTexture, HandConstraintBehavior, HavokPlugin, HemisphericLight, HighlightLayer, HingeConstraint, HtmlInteractionManager, HtmlRaycastInteractionManager, HtmlTexture, ImageProcessingConfiguration, ImportMeshAsync, IncrementValueAction, InitializeCSG2Async, InstallHtmlInCanvasPolyfill, InstancedMesh, InterpolatingBehavior, IsHtmlInCanvasSupportedNatively, IsHtmlInCanvasUploadSupported, KHR_materials_variants, LastCreatedAudioEngine, Layer, Light, LightGizmo, LinesMesh, LiteCompatError, LoadAssetContainerAsync, LoadImageToTexture2DArrayLayerAsync, LockConstraint, Logger, MainAudioBus, Material, MaterialGreasedLineDefines, MaterialPluginBase, MaterialPluginManager, Matrix, MaxTintMagnitude, Mesh, MeshBlendDebugMode, MeshBlendDepthType, MeshBlendQuality, MeshBlendingPostProcess, MeshBlendingRadiusClass, MeshBuilder, MeshoptCompression, MinTemperatureKelvin, MirrorTexture, MorphTarget, MorphTargetManager, MultiMaterial, MultiPointerScaleBehavior, Node, NodeMaterial, NodeParticleSystemSet, NodeRenderGraphMeshBlendingPostProcessBlock, NodeRenderGraphMinMaxReducerBlock, NullEngine, OBJFileLoader, Observable, OnAudioEngineV2CreatedObservable, OpenPBRMaterial, OpenPBRMaterialDefines, OpenPBRMaterialLoadingAdapter, OutlineRenderer, PBRAnisotropicConfiguration, PBRClearCoatConfiguration, PBRIridescenceConfiguration, PBRMaterial, PBRMetallicRoughnessMaterial, PBRSheenConfiguration, PBRSpecularGlossinessMaterial, PackMeshBlendingTag, ParticleHelper, ParticleSystem, ParticleSystemSet, Path3D, PerformanceMonitor, Physics6DoFConstraint, Physics6DoFLimit, PhysicsAggregate, PhysicsBody, PhysicsCharacterController, PhysicsConstraint, PhysicsConstraintAxis, PhysicsConstraintType, PhysicsEngine, PhysicsMotionType, PhysicsPrestepType, PhysicsRaycastResult, PhysicsShape, PhysicsShapeType, PickingInfo, Plane, PlaneDragGizmo, PlaneRotationGizmo, PointLight, PointerDragBehavior, PointerEventTypes, PointerInfo, PointsCloudSystem, Polar, PolygonBuilder, PositionGizmo, PostProcess, PowerEase, PrecisionDate, PredicateCondition, PrismaticConstraint, PushMaterial, QuadraticEase, QuarticEase, Quaternion, QuinticEase, RandomGUID, RawTexture, RawTexture2DArray, RawTexture3D, Ray, RecastJSPlugin, RectAreaLight, ReflectionProbe, RegisterAbstractEngineTextureLoaders, RegisterComputeShader, RegisterEnginesExtensionsEngineTexture2DArrayImageSource, RegisterEnginesWebGPUExtensionsEngineTexture2DArrayImageSource, RegisterFluidRenderer, RegisterGaussianSplattingDebugMaterialPlugin, RegisterGaussianSplattingGpuPickingMaterialPlugin, RegisterGaussianSplattingMaterial, RegisterGaussianSplattingOverdrawMaterialPlugin, RegisterGaussianSplattingSizeMaterialPlugin, RegisterGaussianSplattingSolidColorMaterialPlugin, RegisterGreasedLinePluginMaterial, RegisterImageProcessingConfiguration, RegisterMeshBlendingPostProcessBlock, RegisterMinMaxReducerBlock, RegisterOpenpbrMaterial, RegisterPolygonBuilder, RegisterSPLATFileLoader, RegisterUSDFileLoader, RemoveFlowGraphAnimationGroupObservers, 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, _GetPackedShBytesPerSplat, _HasGaussianPointSplattingProjectedDepth, _RegisterUSDLoaderDependencies, defaultValueParseFunction, registerBuiltInLoaders, transformCoordinates, transformNormal, unsupported };
13168
13481
 
13169
13482
  //# sourceMappingURL=index.js.map