@spiffcommerce/preview 3.6.2-rc.3 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/scene.esm.js

@@ -0,0 +1,2809 @@
+import { Tools as C } from "./Misc/tools.esm.js";
+import { PrecisionDate as N } from "./Misc/precisionDate.esm.js";
+import { Observable as h } from "./Misc/observable.esm.js";
+import { SmartArrayNoDuplicate as v, SmartArray as x } from "./Misc/smartArray.esm.js";
+import { StringDictionary as P } from "./Misc/stringDictionary.esm.js";
+import { Tags as T } from "./Misc/tags.esm.js";
+import { TmpVectors as b, Vector3 as y, Matrix as F } from "./Maths/math.vector.esm.js";
+import { AbstractScene as E } from "./abstractScene.esm.js";
+import { ImageProcessingConfiguration as S } from "./Materials/imageProcessingConfiguration.esm.js";
+import { UniformBuffer as U } from "./Materials/uniformBuffer.esm.js";
+import { PickingInfo as I } from "./Collisions/pickingInfo.esm.js";
+import { ActionEvent as w } from "./Actions/actionEvent.esm.js";
+import { PostProcessManager as B } from "./PostProcesses/postProcessManager.esm.js";
+import { RenderingManager as L } from "./Rendering/renderingManager.esm.js";
+import { Stage as d } from "./sceneComponent.esm.js";
+import { IsWindowObjectExist as q } from "./Misc/domManagement.esm.js";
+import { EngineStore as R } from "./Engines/engineStore.esm.js";
+import { _WarnImport as f } from "./Misc/devTools.esm.js";
+import { InputManager as m } from "./Inputs/scene.inputManager.esm.js";
+import { PerfCounter as O } from "./Misc/perfCounter.esm.js";
+import { Color4 as G, Color3 as D } from "./Maths/math.color.esm.js";
+import { Frustum as k } from "./Maths/math.frustum.esm.js";
+import { UniqueIdGenerator as V } from "./Misc/uniqueIdGenerator.esm.js";
+import { LoadFile as W, RequestFile as z, ReadFile as j } from "./Misc/fileTools.esm.js";
+import { LightConstants as X } from "./Lights/lightConstants.esm.js";
+import { _ObserveArray as H } from "./Misc/arrayTools.esm.js";
+import { PointerPickingConfiguration as K } from "./Inputs/pointerPickingConfiguration.esm.js";
+var M;
+(function(_) {
+  _[_.BackwardCompatible = 0] = "BackwardCompatible", _[_.Intermediate = 1] = "Intermediate", _[_.Aggressive = 2] = "Aggressive";
+})(M || (M = {}));
+class c extends E {
+  /**
+   * Factory used to create the default material.
+   * @param scene The scene to create the material for
+   * @returns The default material
+   */
+  static DefaultMaterialFactory(e) {
+    throw f("StandardMaterial");
+  }
+  /**
+   * Factory used to create the a collision coordinator.
+   * @returns The collision coordinator
+   */
+  static CollisionCoordinatorFactory() {
+    throw f("DefaultCollisionCoordinator");
+  }
+  /**
+   * Texture used in all pbr material as the reflection texture.
+   * As in the majority of the scene they are the same (exception for multi room and so on),
+   * this is easier to reference from here than from all the materials.
+   */
+  get environmentTexture() {
+    return this._environmentTexture;
+  }
+  /**
+   * Texture used in all pbr material as the reflection texture.
+   * As in the majority of the scene they are the same (exception for multi room and so on),
+   * this is easier to set here than in all the materials.
+   */
+  set environmentTexture(e) {
+    this._environmentTexture !== e && (this._environmentTexture = e, this.markAllMaterialsAsDirty(1));
+  }
+  /**
+   * Default image processing configuration used either in the rendering
+   * Forward main pass or through the imageProcessingPostProcess if present.
+   * As in the majority of the scene they are the same (exception for multi camera),
+   * this is easier to reference from here than from all the materials and post process.
+   *
+   * No setter as we it is a shared configuration, you can set the values instead.
+   */
+  get imageProcessingConfiguration() {
+    return this._imageProcessingConfiguration;
+  }
+  /**
+   * Gets or sets a value indicating how to treat performance relatively to ease of use and backward compatibility
+   */
+  get performancePriority() {
+    return this._performancePriority;
+  }
+  set performancePriority(e) {
+    if (e !== this._performancePriority) {
+      switch (this._performancePriority = e, e) {
+        case M.BackwardCompatible:
+          this.skipFrustumClipping = !1, this._renderingManager.maintainStateBetweenFrames = !1, this.skipPointerMovePicking = !1, this.autoClear = !0;
+          break;
+        case M.Intermediate:
+          this.skipFrustumClipping = !1, this._renderingManager.maintainStateBetweenFrames = !1, this.skipPointerMovePicking = !0, this.autoClear = !1;
+          break;
+        case M.Aggressive:
+          this.skipFrustumClipping = !0, this._renderingManager.maintainStateBetweenFrames = !0, this.skipPointerMovePicking = !0, this.autoClear = !1;
+          break;
+      }
+      this.onScenePerformancePriorityChangedObservable.notifyObservers(e);
+    }
+  }
+  /**
+   * Gets or sets a boolean indicating if all rendering must be done in wireframe
+   */
+  set forceWireframe(e) {
+    this._forceWireframe !== e && (this._forceWireframe = e, this.markAllMaterialsAsDirty(16));
+  }
+  get forceWireframe() {
+    return this._forceWireframe;
+  }
+  /**
+   * Gets or sets a boolean indicating if we should skip the frustum clipping part of the active meshes selection
+   */
+  set skipFrustumClipping(e) {
+    this._skipFrustumClipping !== e && (this._skipFrustumClipping = e);
+  }
+  get skipFrustumClipping() {
+    return this._skipFrustumClipping;
+  }
+  /**
+   * Gets or sets a boolean indicating if all rendering must be done in point cloud
+   */
+  set forcePointsCloud(e) {
+    this._forcePointsCloud !== e && (this._forcePointsCloud = e, this.markAllMaterialsAsDirty(16));
+  }
+  get forcePointsCloud() {
+    return this._forcePointsCloud;
+  }
+  /**
+   * Gets or sets the animation properties override
+   */
+  get animationPropertiesOverride() {
+    return this._animationPropertiesOverride;
+  }
+  set animationPropertiesOverride(e) {
+    this._animationPropertiesOverride = e;
+  }
+  /** Sets a function to be executed when this scene is disposed. */
+  set onDispose(e) {
+    this._onDisposeObserver && this.onDisposeObservable.remove(this._onDisposeObserver), this._onDisposeObserver = this.onDisposeObservable.add(e);
+  }
+  /** Sets a function to be executed before rendering this scene */
+  set beforeRender(e) {
+    this._onBeforeRenderObserver && this.onBeforeRenderObservable.remove(this._onBeforeRenderObserver), e && (this._onBeforeRenderObserver = this.onBeforeRenderObservable.add(e));
+  }
+  /** Sets a function to be executed after rendering this scene */
+  set afterRender(e) {
+    this._onAfterRenderObserver && this.onAfterRenderObservable.remove(this._onAfterRenderObserver), e && (this._onAfterRenderObserver = this.onAfterRenderObservable.add(e));
+  }
+  /** Sets a function to be executed before rendering a camera*/
+  set beforeCameraRender(e) {
+    this._onBeforeCameraRenderObserver && this.onBeforeCameraRenderObservable.remove(this._onBeforeCameraRenderObserver), this._onBeforeCameraRenderObserver = this.onBeforeCameraRenderObservable.add(e);
+  }
+  /** Sets a function to be executed after rendering a camera*/
+  set afterCameraRender(e) {
+    this._onAfterCameraRenderObserver && this.onAfterCameraRenderObservable.remove(this._onAfterCameraRenderObserver), this._onAfterCameraRenderObserver = this.onAfterCameraRenderObservable.add(e);
+  }
+  /**
+   * Gets or sets a predicate used to select candidate meshes for a pointer down event
+   */
+  get pointerDownPredicate() {
+    return this._pointerPickingConfiguration.pointerDownPredicate;
+  }
+  set pointerDownPredicate(e) {
+    this._pointerPickingConfiguration.pointerDownPredicate = e;
+  }
+  /**
+   * Gets or sets a predicate used to select candidate meshes for a pointer up event
+   */
+  get pointerUpPredicate() {
+    return this._pointerPickingConfiguration.pointerUpPredicate;
+  }
+  set pointerUpPredicate(e) {
+    this._pointerPickingConfiguration.pointerUpPredicate = e;
+  }
+  /**
+   * Gets or sets a predicate used to select candidate meshes for a pointer move event
+   */
+  get pointerMovePredicate() {
+    return this._pointerPickingConfiguration.pointerMovePredicate;
+  }
+  set pointerMovePredicate(e) {
+    this._pointerPickingConfiguration.pointerMovePredicate = e;
+  }
+  /**
+   * Gets or sets a predicate used to select candidate meshes for a pointer down event
+   */
+  get pointerDownFastCheck() {
+    return this._pointerPickingConfiguration.pointerDownFastCheck;
+  }
+  set pointerDownFastCheck(e) {
+    this._pointerPickingConfiguration.pointerDownFastCheck = e;
+  }
+  /**
+   * Gets or sets a predicate used to select candidate meshes for a pointer up event
+   */
+  get pointerUpFastCheck() {
+    return this._pointerPickingConfiguration.pointerUpFastCheck;
+  }
+  set pointerUpFastCheck(e) {
+    this._pointerPickingConfiguration.pointerUpFastCheck = e;
+  }
+  /**
+   * Gets or sets a predicate used to select candidate meshes for a pointer move event
+   */
+  get pointerMoveFastCheck() {
+    return this._pointerPickingConfiguration.pointerMoveFastCheck;
+  }
+  set pointerMoveFastCheck(e) {
+    this._pointerPickingConfiguration.pointerMoveFastCheck = e;
+  }
+  /**
+   * Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer move event occurs.
+   */
+  get skipPointerMovePicking() {
+    return this._pointerPickingConfiguration.skipPointerMovePicking;
+  }
+  set skipPointerMovePicking(e) {
+    this._pointerPickingConfiguration.skipPointerMovePicking = e;
+  }
+  /**
+   * Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer down event occurs.
+   */
+  get skipPointerDownPicking() {
+    return this._pointerPickingConfiguration.skipPointerDownPicking;
+  }
+  set skipPointerDownPicking(e) {
+    this._pointerPickingConfiguration.skipPointerDownPicking = e;
+  }
+  /**
+   * Gets or sets a boolean indicating if the user want to entirely skip the picking phase when a pointer up event occurs.  Off by default.
+   */
+  get skipPointerUpPicking() {
+    return this._pointerPickingConfiguration.skipPointerUpPicking;
+  }
+  set skipPointerUpPicking(e) {
+    this._pointerPickingConfiguration.skipPointerUpPicking = e;
+  }
+  /**
+   * Gets the pointer coordinates without any translation (ie. straight out of the pointer event)
+   */
+  get unTranslatedPointer() {
+    return this._inputManager.unTranslatedPointer;
+  }
+  /**
+   * Gets or sets the distance in pixel that you have to move to prevent some events. Default is 10 pixels
+   */
+  static get DragMovementThreshold() {
+    return m.DragMovementThreshold;
+  }
+  static set DragMovementThreshold(e) {
+    m.DragMovementThreshold = e;
+  }
+  /**
+   * Time in milliseconds to wait to raise long press events if button is still pressed. Default is 500 ms
+   */
+  static get LongPressDelay() {
+    return m.LongPressDelay;
+  }
+  static set LongPressDelay(e) {
+    m.LongPressDelay = e;
+  }
+  /**
+   * Time in milliseconds to wait to raise long press events if button is still pressed. Default is 300 ms
+   */
+  static get DoubleClickDelay() {
+    return m.DoubleClickDelay;
+  }
+  static set DoubleClickDelay(e) {
+    m.DoubleClickDelay = e;
+  }
+  /** If you need to check double click without raising a single click at first click, enable this flag */
+  static get ExclusiveDoubleClickMode() {
+    return m.ExclusiveDoubleClickMode;
+  }
+  static set ExclusiveDoubleClickMode(e) {
+    m.ExclusiveDoubleClickMode = e;
+  }
+  /**
+   * Bind the current view position to an effect.
+   * @param effect The effect to be bound
+   * @param variableName name of the shader variable that will hold the eye position
+   * @param isVector3 true to indicates that variableName is a Vector3 and not a Vector4
+   * @returns the computed eye position
+   */
+  bindEyePosition(e, t = "vEyePosition", i = !1) {
+    var r;
+    const s = this._forcedViewPosition ? this._forcedViewPosition : this._mirroredCameraPosition ? this._mirroredCameraPosition : (r = this.activeCamera.globalPosition) !== null && r !== void 0 ? r : this.activeCamera.devicePosition, n = this.useRightHandedSystem === (this._mirroredCameraPosition != null);
+    return b.Vector4[0].set(s.x, s.y, s.z, n ? -1 : 1), e && (i ? e.setFloat3(t, b.Vector4[0].x, b.Vector4[0].y, b.Vector4[0].z) : e.setVector4(t, b.Vector4[0])), b.Vector4[0];
+  }
+  /**
+   * Update the scene ubo before it can be used in rendering processing
+   * @returns the scene UniformBuffer
+   */
+  finalizeSceneUbo() {
+    const e = this.getSceneUniformBuffer(), t = this.bindEyePosition(null);
+    return e.updateFloat4("vEyePosition", t.x, t.y, t.z, t.w), e.update(), e;
+  }
+  /**
+   * Gets or sets a boolean indicating if the scene must use right-handed coordinates system
+   */
+  set useRightHandedSystem(e) {
+    this._useRightHandedSystem !== e && (this._useRightHandedSystem = e, this.markAllMaterialsAsDirty(16));
+  }
+  get useRightHandedSystem() {
+    return this._useRightHandedSystem;
+  }
+  /**
+   * Sets the step Id used by deterministic lock step
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
+   * @param newStepId defines the step Id
+   */
+  setStepId(e) {
+    this._currentStepId = e;
+  }
+  /**
+   * Gets the step Id used by deterministic lock step
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
+   * @returns the step Id
+   */
+  getStepId() {
+    return this._currentStepId;
+  }
+  /**
+   * Gets the internal step used by deterministic lock step
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#deterministic-lockstep
+   * @returns the internal step
+   */
+  getInternalStep() {
+    return this._currentInternalStep;
+  }
+  /**
+   * Gets or sets a boolean indicating if fog is enabled on this scene
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/environment/environment_introduction#fog
+   * (Default is true)
+   */
+  set fogEnabled(e) {
+    this._fogEnabled !== e && (this._fogEnabled = e, this.markAllMaterialsAsDirty(16));
+  }
+  get fogEnabled() {
+    return this._fogEnabled;
+  }
+  /**
+   * Gets or sets the fog mode to use
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/environment/environment_introduction#fog
+   * | mode | value |
+   * | --- | --- |
+   * | FOGMODE_NONE | 0 |
+   * | FOGMODE_EXP | 1 |
+   * | FOGMODE_EXP2 | 2 |
+   * | FOGMODE_LINEAR | 3 |
+   */
+  set fogMode(e) {
+    this._fogMode !== e && (this._fogMode = e, this.markAllMaterialsAsDirty(16));
+  }
+  get fogMode() {
+    return this._fogMode;
+  }
+  /**
+   * Flag indicating that the frame buffer binding is handled by another component
+   */
+  get prePass() {
+    return !!this.prePassRenderer && this.prePassRenderer.defaultRT.enabled;
+  }
+  /**
+   * Gets or sets a boolean indicating if shadows are enabled on this scene
+   */
+  set shadowsEnabled(e) {
+    this._shadowsEnabled !== e && (this._shadowsEnabled = e, this.markAllMaterialsAsDirty(2));
+  }
+  get shadowsEnabled() {
+    return this._shadowsEnabled;
+  }
+  /**
+   * Gets or sets a boolean indicating if lights are enabled on this scene
+   */
+  set lightsEnabled(e) {
+    this._lightsEnabled !== e && (this._lightsEnabled = e, this.markAllMaterialsAsDirty(2));
+  }
+  get lightsEnabled() {
+    return this._lightsEnabled;
+  }
+  /** All of the active cameras added to this scene. */
+  get activeCameras() {
+    return this._activeCameras;
+  }
+  set activeCameras(e) {
+    this._unObserveActiveCameras && (this._unObserveActiveCameras(), this._unObserveActiveCameras = null), e && (this._unObserveActiveCameras = H(e, () => {
+      this.onActiveCamerasChanged.notifyObservers(this);
+    })), this._activeCameras = e;
+  }
+  /** Gets or sets the current active camera */
+  get activeCamera() {
+    return this._activeCamera;
+  }
+  set activeCamera(e) {
+    e !== this._activeCamera && (this._activeCamera = e, this.onActiveCameraChanged.notifyObservers(this));
+  }
+  /** The default material used on meshes when no material is affected */
+  get defaultMaterial() {
+    return this._defaultMaterial || (this._defaultMaterial = c.DefaultMaterialFactory(this)), this._defaultMaterial;
+  }
+  /** The default material used on meshes when no material is affected */
+  set defaultMaterial(e) {
+    this._defaultMaterial = e;
+  }
+  /**
+   * Gets or sets a boolean indicating if textures are enabled on this scene
+   */
+  set texturesEnabled(e) {
+    this._texturesEnabled !== e && (this._texturesEnabled = e, this.markAllMaterialsAsDirty(1));
+  }
+  get texturesEnabled() {
+    return this._texturesEnabled;
+  }
+  /**
+   * Gets or sets a boolean indicating if skeletons are enabled on this scene
+   */
+  set skeletonsEnabled(e) {
+    this._skeletonsEnabled !== e && (this._skeletonsEnabled = e, this.markAllMaterialsAsDirty(8));
+  }
+  get skeletonsEnabled() {
+    return this._skeletonsEnabled;
+  }
+  /** @internal */
+  get collisionCoordinator() {
+    return this._collisionCoordinator || (this._collisionCoordinator = c.CollisionCoordinatorFactory(), this._collisionCoordinator.init(this)), this._collisionCoordinator;
+  }
+  /**
+   * Gets the scene's rendering manager
+   */
+  get renderingManager() {
+    return this._renderingManager;
+  }
+  /**
+   * Gets the list of frustum planes (built from the active camera)
+   */
+  get frustumPlanes() {
+    return this._frustumPlanes;
+  }
+  /**
+   * Registers the transient components if needed.
+   */
+  _registerTransientComponents() {
+    if (this._transientComponents.length > 0) {
+      for (const e of this._transientComponents)
+        e.register();
+      this._transientComponents.length = 0;
+    }
+  }
+  /**
+   * @internal
+   * Add a component to the scene.
+   * Note that the ccomponent could be registered on th next frame if this is called after
+   * the register component stage.
+   * @param component Defines the component to add to the scene
+   */
+  _addComponent(e) {
+    this._components.push(e), this._transientComponents.push(e);
+    const t = e;
+    t.addFromContainer && t.serialize && this._serializableComponents.push(t);
+  }
+  /**
+   * @internal
+   * Gets a component from the scene.
+   * @param name defines the name of the component to retrieve
+   * @returns the component or null if not present
+   */
+  _getComponent(e) {
+    for (const t of this._components)
+      if (t.name === e)
+        return t;
+    return null;
+  }
+  /**
+   * Creates a new Scene
+   * @param engine defines the engine to use to render this scene
+   * @param options defines the scene options
+   */
+  constructor(e, t) {
+    super(), this._inputManager = new m(this), this.cameraToUseForPointers = null, this._isScene = !0, this._blockEntityCollection = !1, this.autoClear = !0, this.autoClearDepthAndStencil = !0, this.clearColor = new G(0.2, 0.2, 0.3, 1), this.ambientColor = new D(0, 0, 0), this.environmentIntensity = 1, this._performancePriority = M.BackwardCompatible, this.onScenePerformancePriorityChangedObservable = new h(), this._forceWireframe = !1, this._skipFrustumClipping = !1, this._forcePointsCloud = !1, this.animationsEnabled = !0, this._animationPropertiesOverride = null, this.useConstantAnimationDeltaTime = !1, this.constantlyUpdateMeshUnderPointer = !1, this.hoverCursor = "pointer", this.defaultCursor = "", this.doNotHandleCursors = !1, this.preventDefaultOnPointerDown = !0, this.preventDefaultOnPointerUp = !0, this.metadata = null, this.reservedDataStore = null, this.disableOfflineSupportExceptionRules = new Array(), this.onDisposeObservable = new h(), this._onDisposeObserver = null, this.onBeforeRenderObservable = new h(), this._onBeforeRenderObserver = null, this.onAfterRenderObservable = new h(), this.onAfterRenderCameraObservable = new h(), this._onAfterRenderObserver = null, this.onBeforeAnimationsObservable = new h(), this.onAfterAnimationsObservable = new h(), this.onBeforeDrawPhaseObservable = new h(), this.onAfterDrawPhaseObservable = new h(), this.onReadyObservable = new h(), this.onBeforeCameraRenderObservable = new h(), this._onBeforeCameraRenderObserver = null, this.onAfterCameraRenderObservable = new h(), this._onAfterCameraRenderObserver = null, this.onBeforeActiveMeshesEvaluationObservable = new h(), this.onAfterActiveMeshesEvaluationObservable = new h(), this.onBeforeParticlesRenderingObservable = new h(), this.onAfterParticlesRenderingObservable = new h(), this.onDataLoadedObservable = new h(), this.onNewCameraAddedObservable = new h(), this.onCameraRemovedObservable = new h(), this.onNewLightAddedObservable = new h(), this.onLightRemovedObservable = new h(), this.onNewGeometryAddedObservable = new h(), this.onGeometryRemovedObservable = new h(), this.onNewTransformNodeAddedObservable = new h(), this.onTransformNodeRemovedObservable = new h(), this.onNewMeshAddedObservable = new h(), this.onMeshRemovedObservable = new h(), this.onNewSkeletonAddedObservable = new h(), this.onSkeletonRemovedObservable = new h(), this.onNewMaterialAddedObservable = new h(), this.onNewMultiMaterialAddedObservable = new h(), this.onMaterialRemovedObservable = new h(), this.onMultiMaterialRemovedObservable = new h(), this.onNewTextureAddedObservable = new h(), this.onTextureRemovedObservable = new h(), this.onBeforeRenderTargetsRenderObservable = new h(), this.onAfterRenderTargetsRenderObservable = new h(), this.onBeforeStepObservable = new h(), this.onAfterStepObservable = new h(), this.onActiveCameraChanged = new h(), this.onActiveCamerasChanged = new h(), this.onBeforeRenderingGroupObservable = new h(), this.onAfterRenderingGroupObservable = new h(), this.onMeshImportedObservable = new h(), this.onAnimationFileImportedObservable = new h(), this._registeredForLateAnimationBindings = new v(256), this._pointerPickingConfiguration = new K(), this.onPrePointerObservable = new h(), this.onPointerObservable = new h(), this.onPreKeyboardObservable = new h(), this.onKeyboardObservable = new h(), this._useRightHandedSystem = !1, this._timeAccumulator = 0, this._currentStepId = 0, this._currentInternalStep = 0, this._fogEnabled = !0, this._fogMode = c.FOGMODE_NONE, this.fogColor = new D(0.2, 0.2, 0.3), this.fogDensity = 0.1, this.fogStart = 0, this.fogEnd = 1e3, this.needsPreviousWorldMatrices = !1, this._shadowsEnabled = !0, this._lightsEnabled = !0, this._unObserveActiveCameras = null, this._texturesEnabled = !0, this.physicsEnabled = !0, this.particlesEnabled = !0, this.spritesEnabled = !0, this._skeletonsEnabled = !0, this.lensFlaresEnabled = !0, this.collisionsEnabled = !0, this.gravity = new y(0, -9.807, 0), this.postProcessesEnabled = !0, this.renderTargetsEnabled = !0, this.dumpNextRenderTargets = !1, this.customRenderTargets = new Array(), this.importedMeshesFiles = new Array(), this.probesEnabled = !0, this._meshesForIntersections = new v(256), this.proceduralTexturesEnabled = !0, this._totalVertices = new O(), this._activeIndices = new O(), this._activeParticles = new O(), this._activeBones = new O(), this._animationTime = 0, this.animationTimeScale = 1, this._renderId = 0, this._frameId = 0, this._executeWhenReadyTimeoutId = null, this._intermediateRendering = !1, this._defaultFrameBufferCleared = !1, this._viewUpdateFlag = -1, this._projectionUpdateFlag = -1, this._toBeDisposed = new Array(256), this._activeRequests = new Array(), this._pendingData = new Array(), this._isDisposed = !1, this.dispatchAllSubMeshesOfActiveMeshes = !1, this._activeMeshes = new x(256), this._processedMaterials = new x(256), this._renderTargets = new v(256), this._materialsRenderTargets = new v(256), this._activeParticleSystems = new x(256), this._activeSkeletons = new v(32), this._softwareSkinnedMeshes = new v(32), this._activeAnimatables = new Array(), this._transformMatrix = F.Zero(), this.requireLightSorting = !1, this._components = [], this._serializableComponents = [], this._transientComponents = [], this._beforeCameraUpdateStage = d.Create(), this._beforeClearStage = d.Create(), this._beforeRenderTargetClearStage = d.Create(), this._gatherRenderTargetsStage = d.Create(), this._gatherActiveCameraRenderTargetsStage = d.Create(), this._isReadyForMeshStage = d.Create(), this._beforeEvaluateActiveMeshStage = d.Create(), this._evaluateSubMeshStage = d.Create(), this._preActiveMeshStage = d.Create(), this._cameraDrawRenderTargetStage = d.Create(), this._beforeCameraDrawStage = d.Create(), this._beforeRenderTargetDrawStage = d.Create(), this._beforeRenderingGroupDrawStage = d.Create(), this._beforeRenderingMeshStage = d.Create(), this._afterRenderingMeshStage = d.Create(), this._afterRenderingGroupDrawStage = d.Create(), this._afterCameraDrawStage = d.Create(), this._afterCameraPostProcessStage = d.Create(), this._afterRenderTargetDrawStage = d.Create(), this._afterRenderTargetPostProcessStage = d.Create(), this._afterRenderStage = d.Create(), this._pointerMoveStage = d.Create(), this._pointerDownStage = d.Create(), this._pointerUpStage = d.Create(), this._geometriesByUniqueId = null, this._defaultMeshCandidates = {
+      data: [],
+      length: 0
+    }, this._defaultSubMeshCandidates = {
+      data: [],
+      length: 0
+    }, this._preventFreeActiveMeshesAndRenderingGroups = !1, this._activeMeshesFrozen = !1, this._activeMeshesFrozenButKeepClipping = !1, this._skipEvaluateActiveMeshesCompletely = !1, this._allowPostProcessClearColor = !0, this.getDeterministicFrameTime = () => this._engine.getTimeStep(), this._registeredActions = 0, this._blockMaterialDirtyMechanism = !1, this._perfCollector = null, this.activeCameras = new Array();
+    const i = Object.assign({ useGeometryUniqueIdsMap: !0, useMaterialMeshMap: !0, useClonedMeshMap: !0, virtual: !1 }, t);
+    this._engine = e || R.LastCreatedEngine, i.virtual ? this._engine._virtualScenes.push(this) : (R._LastCreatedScene = this, this._engine.scenes.push(this)), this._uid = null, this._renderingManager = new L(this), B && (this.postProcessManager = new B(this)), q() && this.attachControl(), this._createUbo(), S && (this._imageProcessingConfiguration = new S()), this.setDefaultCandidateProviders(), i.useGeometryUniqueIdsMap && (this._geometriesByUniqueId = {}), this.useMaterialMeshMap = i.useMaterialMeshMap, this.useClonedMeshMap = i.useClonedMeshMap, (!t || !t.virtual) && this._engine.onNewSceneAddedObservable.notifyObservers(this);
+  }
+  /**
+   * Gets a string identifying the name of the class
+   * @returns "Scene" string
+   */
+  getClassName() {
+    return "Scene";
+  }
+  /**
+   * @internal
+   */
+  _getDefaultMeshCandidates() {
+    return this._defaultMeshCandidates.data = this.meshes, this._defaultMeshCandidates.length = this.meshes.length, this._defaultMeshCandidates;
+  }
+  /**
+   * @internal
+   */
+  _getDefaultSubMeshCandidates(e) {
+    return this._defaultSubMeshCandidates.data = e.subMeshes, this._defaultSubMeshCandidates.length = e.subMeshes.length, this._defaultSubMeshCandidates;
+  }
+  /**
+   * Sets the default candidate providers for the scene.
+   * This sets the getActiveMeshCandidates, getActiveSubMeshCandidates, getIntersectingSubMeshCandidates
+   * and getCollidingSubMeshCandidates to their default function
+   */
+  setDefaultCandidateProviders() {
+    this.getActiveMeshCandidates = this._getDefaultMeshCandidates.bind(this), this.getActiveSubMeshCandidates = this._getDefaultSubMeshCandidates.bind(this), this.getIntersectingSubMeshCandidates = this._getDefaultSubMeshCandidates.bind(this), this.getCollidingSubMeshCandidates = this._getDefaultSubMeshCandidates.bind(this);
+  }
+  /**
+   * Gets the mesh that is currently under the pointer
+   */
+  get meshUnderPointer() {
+    return this._inputManager.meshUnderPointer;
+  }
+  /**
+   * Gets or sets the current on-screen X position of the pointer
+   */
+  get pointerX() {
+    return this._inputManager.pointerX;
+  }
+  set pointerX(e) {
+    this._inputManager.pointerX = e;
+  }
+  /**
+   * Gets or sets the current on-screen Y position of the pointer
+   */
+  get pointerY() {
+    return this._inputManager.pointerY;
+  }
+  set pointerY(e) {
+    this._inputManager.pointerY = e;
+  }
+  /**
+   * Gets the cached material (ie. the latest rendered one)
+   * @returns the cached material
+   */
+  getCachedMaterial() {
+    return this._cachedMaterial;
+  }
+  /**
+   * Gets the cached effect (ie. the latest rendered one)
+   * @returns the cached effect
+   */
+  getCachedEffect() {
+    return this._cachedEffect;
+  }
+  /**
+   * Gets the cached visibility state (ie. the latest rendered one)
+   * @returns the cached visibility state
+   */
+  getCachedVisibility() {
+    return this._cachedVisibility;
+  }
+  /**
+   * Gets a boolean indicating if the current material / effect / visibility must be bind again
+   * @param material defines the current material
+   * @param effect defines the current effect
+   * @param visibility defines the current visibility state
+   * @returns true if one parameter is not cached
+   */
+  isCachedMaterialInvalid(e, t, i = 1) {
+    return this._cachedEffect !== t || this._cachedMaterial !== e || this._cachedVisibility !== i;
+  }
+  /**
+   * Gets the engine associated with the scene
+   * @returns an Engine
+   */
+  getEngine() {
+    return this._engine;
+  }
+  /**
+   * Gets the total number of vertices rendered per frame
+   * @returns the total number of vertices rendered per frame
+   */
+  getTotalVertices() {
+    return this._totalVertices.current;
+  }
+  /**
+   * Gets the performance counter for total vertices
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#instrumentation
+   */
+  get totalVerticesPerfCounter() {
+    return this._totalVertices;
+  }
+  /**
+   * Gets the total number of active indices rendered per frame (You can deduce the number of rendered triangles by dividing this number by 3)
+   * @returns the total number of active indices rendered per frame
+   */
+  getActiveIndices() {
+    return this._activeIndices.current;
+  }
+  /**
+   * Gets the performance counter for active indices
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#instrumentation
+   */
+  get totalActiveIndicesPerfCounter() {
+    return this._activeIndices;
+  }
+  /**
+   * Gets the total number of active particles rendered per frame
+   * @returns the total number of active particles rendered per frame
+   */
+  getActiveParticles() {
+    return this._activeParticles.current;
+  }
+  /**
+   * Gets the performance counter for active particles
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#instrumentation
+   */
+  get activeParticlesPerfCounter() {
+    return this._activeParticles;
+  }
+  /**
+   * Gets the total number of active bones rendered per frame
+   * @returns the total number of active bones rendered per frame
+   */
+  getActiveBones() {
+    return this._activeBones.current;
+  }
+  /**
+   * Gets the performance counter for active bones
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#instrumentation
+   */
+  get activeBonesPerfCounter() {
+    return this._activeBones;
+  }
+  /**
+   * Gets the array of active meshes
+   * @returns an array of AbstractMesh
+   */
+  getActiveMeshes() {
+    return this._activeMeshes;
+  }
+  /**
+   * Gets the animation ratio (which is 1.0 is the scene renders at 60fps and 2 if the scene renders at 30fps, etc.)
+   * @returns a number
+   */
+  getAnimationRatio() {
+    return this._animationRatio !== void 0 ? this._animationRatio : 1;
+  }
+  /**
+   * Gets an unique Id for the current render phase
+   * @returns a number
+   */
+  getRenderId() {
+    return this._renderId;
+  }
+  /**
+   * Gets an unique Id for the current frame
+   * @returns a number
+   */
+  getFrameId() {
+    return this._frameId;
+  }
+  /** Call this function if you want to manually increment the render Id*/
+  incrementRenderId() {
+    this._renderId++;
+  }
+  _createUbo() {
+    this.setSceneUniformBuffer(this.createSceneUniformBuffer());
+  }
+  /**
+   * Use this method to simulate a pointer move on a mesh
+   * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+   * @param pickResult pickingInfo of the object wished to simulate pointer event on
+   * @param pointerEventInit pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+   * @returns the current scene
+   */
+  simulatePointerMove(e, t) {
+    return this._inputManager.simulatePointerMove(e, t), this;
+  }
+  /**
+   * Use this method to simulate a pointer down on a mesh
+   * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+   * @param pickResult pickingInfo of the object wished to simulate pointer event on
+   * @param pointerEventInit pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+   * @returns the current scene
+   */
+  simulatePointerDown(e, t) {
+    return this._inputManager.simulatePointerDown(e, t), this;
+  }
+  /**
+   * Use this method to simulate a pointer up on a mesh
+   * The pickResult parameter can be obtained from a scene.pick or scene.pickWithRay
+   * @param pickResult pickingInfo of the object wished to simulate pointer event on
+   * @param pointerEventInit pointer event state to be used when simulating the pointer event (eg. pointer id for multitouch)
+   * @param doubleTap indicates that the pointer up event should be considered as part of a double click (false by default)
+   * @returns the current scene
+   */
+  simulatePointerUp(e, t, i) {
+    return this._inputManager.simulatePointerUp(e, t, i), this;
+  }
+  /**
+   * Gets a boolean indicating if the current pointer event is captured (meaning that the scene has already handled the pointer down)
+   * @param pointerId defines the pointer id to use in a multi-touch scenario (0 by default)
+   * @returns true if the pointer was captured
+   */
+  isPointerCaptured(e = 0) {
+    return this._inputManager.isPointerCaptured(e);
+  }
+  /**
+   * Attach events to the canvas (To handle actionManagers triggers and raise onPointerMove, onPointerDown and onPointerUp
+   * @param attachUp defines if you want to attach events to pointerup
+   * @param attachDown defines if you want to attach events to pointerdown
+   * @param attachMove defines if you want to attach events to pointermove
+   */
+  attachControl(e = !0, t = !0, i = !0) {
+    this._inputManager.attachControl(e, t, i);
+  }
+  /** Detaches all event handlers*/
+  detachControl() {
+    this._inputManager.detachControl();
+  }
+  /**
+   * This function will check if the scene can be rendered (textures are loaded, shaders are compiled)
+   * Delay loaded resources are not taking in account
+   * @param checkRenderTargets true to also check that the meshes rendered as part of a render target are ready (default: true)
+   * @returns true if all required resources are ready
+   */
+  isReady(e = !0) {
+    var t, i, r;
+    if (this._isDisposed)
+      return !1;
+    let s;
+    const n = this.getEngine(), l = n.currentRenderPassId;
+    n.currentRenderPassId = (i = (t = this.activeCamera) === null || t === void 0 ? void 0 : t.renderPassId) !== null && i !== void 0 ? i : l;
+    let a = !0;
+    for (this._pendingData.length > 0 && (a = !1), (r = this.prePassRenderer) === null || r === void 0 || r.update(), e && (this._processedMaterials.reset(), this._materialsRenderTargets.reset()), s = 0; s < this.meshes.length; s++) {
+      const o = this.meshes[s];
+      if (!o.subMeshes || o.subMeshes.length === 0)
+        continue;
+      if (!o.isReady(!0)) {
+        a = !1;
+        continue;
+      }
+      const u = o.hasThinInstances || o.getClassName() === "InstancedMesh" || o.getClassName() === "InstancedLinesMesh" || n.getCaps().instancedArrays && o.instances.length > 0;
+      for (const A of this._isReadyForMeshStage)
+        A.action(o, u) || (a = !1);
+      if (!e)
+        continue;
+      const g = o.material || this.defaultMaterial;
+      if (g)
+        if (g._storeEffectOnSubMeshes)
+          for (const A of o.subMeshes) {
+            const p = A.getMaterial();
+            p && p.hasRenderTargetTextures && p.getRenderTargetTextures != null && this._processedMaterials.indexOf(p) === -1 && (this._processedMaterials.push(p), this._materialsRenderTargets.concatWithNoDuplicate(p.getRenderTargetTextures()));
+          }
+        else
+          g.hasRenderTargetTextures && g.getRenderTargetTextures != null && this._processedMaterials.indexOf(g) === -1 && (this._processedMaterials.push(g), this._materialsRenderTargets.concatWithNoDuplicate(g.getRenderTargetTextures()));
+    }
+    if (e)
+      for (s = 0; s < this._materialsRenderTargets.length; ++s)
+        this._materialsRenderTargets.data[s].isReadyForRendering() || (a = !1);
+    for (s = 0; s < this.geometries.length; s++)
+      this.geometries[s].delayLoadState === 2 && (a = !1);
+    if (this.activeCameras && this.activeCameras.length > 0)
+      for (const o of this.activeCameras)
+        o.isReady(!0) || (a = !1);
+    else
+      this.activeCamera && (this.activeCamera.isReady(!0) || (a = !1));
+    for (const o of this.particleSystems)
+      o.isReady() || (a = !1);
+    if (this.layers)
+      for (const o of this.layers)
+        o.isReady() || (a = !1);
+    return n.areAllEffectsReady() || (a = !1), n.currentRenderPassId = l, a;
+  }
+  /** Resets all cached information relative to material (including effect and visibility) */
+  resetCachedMaterial() {
+    this._cachedMaterial = null, this._cachedEffect = null, this._cachedVisibility = null;
+  }
+  /**
+   * Registers a function to be called before every frame render
+   * @param func defines the function to register
+   */
+  registerBeforeRender(e) {
+    this.onBeforeRenderObservable.add(e);
+  }
+  /**
+   * Unregisters a function called before every frame render
+   * @param func defines the function to unregister
+   */
+  unregisterBeforeRender(e) {
+    this.onBeforeRenderObservable.removeCallback(e);
+  }
+  /**
+   * Registers a function to be called after every frame render
+   * @param func defines the function to register
+   */
+  registerAfterRender(e) {
+    this.onAfterRenderObservable.add(e);
+  }
+  /**
+   * Unregisters a function called after every frame render
+   * @param func defines the function to unregister
+   */
+  unregisterAfterRender(e) {
+    this.onAfterRenderObservable.removeCallback(e);
+  }
+  _executeOnceBeforeRender(e) {
+    const t = () => {
+      e(), setTimeout(() => {
+        this.unregisterBeforeRender(t);
+      });
+    };
+    this.registerBeforeRender(t);
+  }
+  /**
+   * The provided function will run before render once and will be disposed afterwards.
+   * A timeout delay can be provided so that the function will be executed in N ms.
+   * The timeout is using the browser's native setTimeout so time percision cannot be guaranteed.
+   * @param func The function to be executed.
+   * @param timeout optional delay in ms
+   */
+  executeOnceBeforeRender(e, t) {
+    t !== void 0 ? setTimeout(() => {
+      this._executeOnceBeforeRender(e);
+    }, t) : this._executeOnceBeforeRender(e);
+  }
+  /**
+   * This function can help adding any object to the list of data awaited to be ready in order to check for a complete scene loading.
+   * @param data defines the object to wait for
+   */
+  addPendingData(e) {
+    this._pendingData.push(e);
+  }
+  /**
+   * Remove a pending data from the loading list which has previously been added with addPendingData.
+   * @param data defines the object to remove from the pending list
+   */
+  removePendingData(e) {
+    const t = this.isLoading, i = this._pendingData.indexOf(e);
+    i !== -1 && this._pendingData.splice(i, 1), t && !this.isLoading && this.onDataLoadedObservable.notifyObservers(this);
+  }
+  /**
+   * Returns the number of items waiting to be loaded
+   * @returns the number of items waiting to be loaded
+   */
+  getWaitingItemsCount() {
+    return this._pendingData.length;
+  }
+  /**
+   * Returns a boolean indicating if the scene is still loading data
+   */
+  get isLoading() {
+    return this._pendingData.length > 0;
+  }
+  /**
+   * Registers a function to be executed when the scene is ready
+   * @param func - the function to be executed
+   * @param checkRenderTargets true to also check that the meshes rendered as part of a render target are ready (default: false)
+   */
+  executeWhenReady(e, t = !1) {
+    this.onReadyObservable.addOnce(e), this._executeWhenReadyTimeoutId === null && this._checkIsReady(t);
+  }
+  /**
+   * Returns a promise that resolves when the scene is ready
+   * @param checkRenderTargets true to also check that the meshes rendered as part of a render target are ready (default: false)
+   * @returns A promise that resolves when the scene is ready
+   */
+  whenReadyAsync(e = !1) {
+    return new Promise((t) => {
+      this.executeWhenReady(() => {
+        t();
+      }, e);
+    });
+  }
+  /**
+   * @internal
+   */
+  _checkIsReady(e = !1) {
+    if (this._registerTransientComponents(), this.isReady(e)) {
+      this.onReadyObservable.notifyObservers(this), this.onReadyObservable.clear(), this._executeWhenReadyTimeoutId = null;
+      return;
+    }
+    if (this._isDisposed) {
+      this.onReadyObservable.clear(), this._executeWhenReadyTimeoutId = null;
+      return;
+    }
+    this._executeWhenReadyTimeoutId = setTimeout(() => {
+      this.incrementRenderId(), this._checkIsReady(e);
+    }, 100);
+  }
+  /**
+   * Gets all animatable attached to the scene
+   */
+  get animatables() {
+    return this._activeAnimatables;
+  }
+  /**
+   * Resets the last animation time frame.
+   * Useful to override when animations start running when loading a scene for the first time.
+   */
+  resetLastAnimationTimeFrame() {
+    this._animationTimeLast = N.Now;
+  }
+  // Matrix
+  /**
+   * Gets the current view matrix
+   * @returns a Matrix
+   */
+  getViewMatrix() {
+    return this._viewMatrix;
+  }
+  /**
+   * Gets the current projection matrix
+   * @returns a Matrix
+   */
+  getProjectionMatrix() {
+    return this._projectionMatrix;
+  }
+  /**
+   * Gets the current transform matrix
+   * @returns a Matrix made of View * Projection
+   */
+  getTransformMatrix() {
+    return this._transformMatrix;
+  }
+  /**
+   * Sets the current transform matrix
+   * @param viewL defines the View matrix to use
+   * @param projectionL defines the Projection matrix to use
+   * @param viewR defines the right View matrix to use (if provided)
+   * @param projectionR defines the right Projection matrix to use (if provided)
+   */
+  setTransformMatrix(e, t, i, r) {
+    !i && !r && this._multiviewSceneUbo && (this._multiviewSceneUbo.dispose(), this._multiviewSceneUbo = null), !(this._viewUpdateFlag === e.updateFlag && this._projectionUpdateFlag === t.updateFlag) && (this._viewUpdateFlag = e.updateFlag, this._projectionUpdateFlag = t.updateFlag, this._viewMatrix = e, this._projectionMatrix = t, this._viewMatrix.multiplyToRef(this._projectionMatrix, this._transformMatrix), this._frustumPlanes ? k.GetPlanesToRef(this._transformMatrix, this._frustumPlanes) : this._frustumPlanes = k.GetPlanes(this._transformMatrix), this._multiviewSceneUbo && this._multiviewSceneUbo.useUbo ? this._updateMultiviewUbo(i, r) : this._sceneUbo.useUbo && (this._sceneUbo.updateMatrix("viewProjection", this._transformMatrix), this._sceneUbo.updateMatrix("view", this._viewMatrix), this._sceneUbo.updateMatrix("projection", this._projectionMatrix)));
+  }
+  /**
+   * Gets the uniform buffer used to store scene data
+   * @returns a UniformBuffer
+   */
+  getSceneUniformBuffer() {
+    return this._multiviewSceneUbo ? this._multiviewSceneUbo : this._sceneUbo;
+  }
+  /**
+   * Creates a scene UBO
+   * @param name name of the uniform buffer (optional, for debugging purpose only)
+   * @returns a new ubo
+   */
+  createSceneUniformBuffer(e) {
+    const t = new U(this._engine, void 0, !1, e ?? "scene");
+    return t.addUniform("viewProjection", 16), t.addUniform("view", 16), t.addUniform("projection", 16), t.addUniform("vEyePosition", 4), t;
+  }
+  /**
+   * Sets the scene ubo
+   * @param ubo the ubo to set for the scene
+   */
+  setSceneUniformBuffer(e) {
+    this._sceneUbo = e, this._viewUpdateFlag = -1, this._projectionUpdateFlag = -1;
+  }
+  /**
+   * Gets an unique (relatively to the current scene) Id
+   * @returns an unique number for the scene
+   */
+  getUniqueId() {
+    return V.UniqueId;
+  }
+  /**
+   * Add a mesh to the list of scene's meshes
+   * @param newMesh defines the mesh to add
+   * @param recursive if all child meshes should also be added to the scene
+   */
+  addMesh(e, t = !1) {
+    this._blockEntityCollection || (this.meshes.push(e), e._resyncLightSources(), e.parent || e._addToSceneRootNodes(), this.onNewMeshAddedObservable.notifyObservers(e), t && e.getChildMeshes().forEach((i) => {
+      this.addMesh(i);
+    }));
+  }
+  /**
+   * Remove a mesh for the list of scene's meshes
+   * @param toRemove defines the mesh to remove
+   * @param recursive if all child meshes should also be removed from the scene
+   * @returns the index where the mesh was in the mesh list
+   */
+  removeMesh(e, t = !1) {
+    const i = this.meshes.indexOf(e);
+    return i !== -1 && (this.meshes[i] = this.meshes[this.meshes.length - 1], this.meshes.pop(), e.parent || e._removeFromSceneRootNodes()), this._inputManager._invalidateMesh(e), this.onMeshRemovedObservable.notifyObservers(e), t && e.getChildMeshes().forEach((r) => {
+      this.removeMesh(r);
+    }), i;
+  }
+  /**
+   * Add a transform node to the list of scene's transform nodes
+   * @param newTransformNode defines the transform node to add
+   */
+  addTransformNode(e) {
+    this._blockEntityCollection || e.getScene() === this && e._indexInSceneTransformNodesArray !== -1 || (e._indexInSceneTransformNodesArray = this.transformNodes.length, this.transformNodes.push(e), e.parent || e._addToSceneRootNodes(), this.onNewTransformNodeAddedObservable.notifyObservers(e));
+  }
+  /**
+   * Remove a transform node for the list of scene's transform nodes
+   * @param toRemove defines the transform node to remove
+   * @returns the index where the transform node was in the transform node list
+   */
+  removeTransformNode(e) {
+    const t = e._indexInSceneTransformNodesArray;
+    if (t !== -1) {
+      if (t !== this.transformNodes.length - 1) {
+        const i = this.transformNodes[this.transformNodes.length - 1];
+        this.transformNodes[t] = i, i._indexInSceneTransformNodesArray = t;
+      }
+      e._indexInSceneTransformNodesArray = -1, this.transformNodes.pop(), e.parent || e._removeFromSceneRootNodes();
+    }
+    return this.onTransformNodeRemovedObservable.notifyObservers(e), t;
+  }
+  /**
+   * Remove a skeleton for the list of scene's skeletons
+   * @param toRemove defines the skeleton to remove
+   * @returns the index where the skeleton was in the skeleton list
+   */
+  removeSkeleton(e) {
+    const t = this.skeletons.indexOf(e);
+    return t !== -1 && (this.skeletons.splice(t, 1), this.onSkeletonRemovedObservable.notifyObservers(e), this._executeActiveContainerCleanup(this._activeSkeletons)), t;
+  }
+  /**
+   * Remove a morph target for the list of scene's morph targets
+   * @param toRemove defines the morph target to remove
+   * @returns the index where the morph target was in the morph target list
+   */
+  removeMorphTargetManager(e) {
+    const t = this.morphTargetManagers.indexOf(e);
+    return t !== -1 && this.morphTargetManagers.splice(t, 1), t;
+  }
+  /**
+   * Remove a light for the list of scene's lights
+   * @param toRemove defines the light to remove
+   * @returns the index where the light was in the light list
+   */
+  removeLight(e) {
+    const t = this.lights.indexOf(e);
+    if (t !== -1) {
+      for (const i of this.meshes)
+        i._removeLightSource(e, !1);
+      this.lights.splice(t, 1), this.sortLightsByPriority(), e.parent || e._removeFromSceneRootNodes();
+    }
+    return this.onLightRemovedObservable.notifyObservers(e), t;
+  }
+  /**
+   * Remove a camera for the list of scene's cameras
+   * @param toRemove defines the camera to remove
+   * @returns the index where the camera was in the camera list
+   */
+  removeCamera(e) {
+    const t = this.cameras.indexOf(e);
+    if (t !== -1 && (this.cameras.splice(t, 1), e.parent || e._removeFromSceneRootNodes()), this.activeCameras) {
+      const i = this.activeCameras.indexOf(e);
+      i !== -1 && this.activeCameras.splice(i, 1);
+    }
+    return this.activeCamera === e && (this.cameras.length > 0 ? this.activeCamera = this.cameras[0] : this.activeCamera = null), this.onCameraRemovedObservable.notifyObservers(e), t;
+  }
+  /**
+   * Remove a particle system for the list of scene's particle systems
+   * @param toRemove defines the particle system to remove
+   * @returns the index where the particle system was in the particle system list
+   */
+  removeParticleSystem(e) {
+    const t = this.particleSystems.indexOf(e);
+    return t !== -1 && (this.particleSystems.splice(t, 1), this._executeActiveContainerCleanup(this._activeParticleSystems)), t;
+  }
+  /**
+   * Remove a animation for the list of scene's animations
+   * @param toRemove defines the animation to remove
+   * @returns the index where the animation was in the animation list
+   */
+  removeAnimation(e) {
+    const t = this.animations.indexOf(e);
+    return t !== -1 && this.animations.splice(t, 1), t;
+  }
+  /**
+   * Will stop the animation of the given target
+   * @param target - the target
+   * @param animationName - the name of the animation to stop (all animations will be stopped if both this and targetMask are empty)
+   * @param targetMask - a function that determines if the animation should be stopped based on its target (all animations will be stopped if both this and animationName are empty)
+   */
+  stopAnimation(e, t, i) {
+  }
+  /**
+   * Removes the given animation group from this scene.
+   * @param toRemove The animation group to remove
+   * @returns The index of the removed animation group
+   */
+  removeAnimationGroup(e) {
+    const t = this.animationGroups.indexOf(e);
+    return t !== -1 && this.animationGroups.splice(t, 1), t;
+  }
+  /**
+   * Removes the given multi-material from this scene.
+   * @param toRemove The multi-material to remove
+   * @returns The index of the removed multi-material
+   */
+  removeMultiMaterial(e) {
+    const t = this.multiMaterials.indexOf(e);
+    return t !== -1 && this.multiMaterials.splice(t, 1), this.onMultiMaterialRemovedObservable.notifyObservers(e), t;
+  }
+  /**
+   * Removes the given material from this scene.
+   * @param toRemove The material to remove
+   * @returns The index of the removed material
+   */
+  removeMaterial(e) {
+    const t = e._indexInSceneMaterialArray;
+    if (t !== -1 && t < this.materials.length) {
+      if (t !== this.materials.length - 1) {
+        const i = this.materials[this.materials.length - 1];
+        this.materials[t] = i, i._indexInSceneMaterialArray = t;
+      }
+      e._indexInSceneMaterialArray = -1, this.materials.pop();
+    }
+    return this.onMaterialRemovedObservable.notifyObservers(e), t;
+  }
+  /**
+   * Removes the given action manager from this scene.
+   * @deprecated
+   * @param toRemove The action manager to remove
+   * @returns The index of the removed action manager
+   */
+  removeActionManager(e) {
+    const t = this.actionManagers.indexOf(e);
+    return t !== -1 && this.actionManagers.splice(t, 1), t;
+  }
+  /**
+   * Removes the given texture from this scene.
+   * @param toRemove The texture to remove
+   * @returns The index of the removed texture
+   */
+  removeTexture(e) {
+    const t = this.textures.indexOf(e);
+    return t !== -1 && this.textures.splice(t, 1), this.onTextureRemovedObservable.notifyObservers(e), t;
+  }
+  /**
+   * Adds the given light to this scene
+   * @param newLight The light to add
+   */
+  addLight(e) {
+    if (!this._blockEntityCollection) {
+      this.lights.push(e), this.sortLightsByPriority(), e.parent || e._addToSceneRootNodes();
+      for (const t of this.meshes)
+        t.lightSources.indexOf(e) === -1 && (t.lightSources.push(e), t._resyncLightSources());
+      this.onNewLightAddedObservable.notifyObservers(e);
+    }
+  }
+  /**
+   * Sorts the list list based on light priorities
+   */
+  sortLightsByPriority() {
+    this.requireLightSorting && this.lights.sort(X.CompareLightsPriority);
+  }
+  /**
+   * Adds the given camera to this scene
+   * @param newCamera The camera to add
+   */
+  addCamera(e) {
+    this._blockEntityCollection || (this.cameras.push(e), this.onNewCameraAddedObservable.notifyObservers(e), e.parent || e._addToSceneRootNodes());
+  }
+  /**
+   * Adds the given skeleton to this scene
+   * @param newSkeleton The skeleton to add
+   */
+  addSkeleton(e) {
+    this._blockEntityCollection || (this.skeletons.push(e), this.onNewSkeletonAddedObservable.notifyObservers(e));
+  }
+  /**
+   * Adds the given particle system to this scene
+   * @param newParticleSystem The particle system to add
+   */
+  addParticleSystem(e) {
+    this._blockEntityCollection || this.particleSystems.push(e);
+  }
+  /**
+   * Adds the given animation to this scene
+   * @param newAnimation The animation to add
+   */
+  addAnimation(e) {
+    this._blockEntityCollection || this.animations.push(e);
+  }
+  /**
+   * Adds the given animation group to this scene.
+   * @param newAnimationGroup The animation group to add
+   */
+  addAnimationGroup(e) {
+    this._blockEntityCollection || this.animationGroups.push(e);
+  }
+  /**
+   * Adds the given multi-material to this scene
+   * @param newMultiMaterial The multi-material to add
+   */
+  addMultiMaterial(e) {
+    this._blockEntityCollection || (this.multiMaterials.push(e), this.onNewMultiMaterialAddedObservable.notifyObservers(e));
+  }
+  /**
+   * Adds the given material to this scene
+   * @param newMaterial The material to add
+   */
+  addMaterial(e) {
+    this._blockEntityCollection || e.getScene() === this && e._indexInSceneMaterialArray !== -1 || (e._indexInSceneMaterialArray = this.materials.length, this.materials.push(e), this.onNewMaterialAddedObservable.notifyObservers(e));
+  }
+  /**
+   * Adds the given morph target to this scene
+   * @param newMorphTargetManager The morph target to add
+   */
+  addMorphTargetManager(e) {
+    this._blockEntityCollection || this.morphTargetManagers.push(e);
+  }
+  /**
+   * Adds the given geometry to this scene
+   * @param newGeometry The geometry to add
+   */
+  addGeometry(e) {
+    this._blockEntityCollection || (this._geometriesByUniqueId && (this._geometriesByUniqueId[e.uniqueId] = this.geometries.length), this.geometries.push(e));
+  }
+  /**
+   * Adds the given action manager to this scene
+   * @deprecated
+   * @param newActionManager The action manager to add
+   */
+  addActionManager(e) {
+    this.actionManagers.push(e);
+  }
+  /**
+   * Adds the given texture to this scene.
+   * @param newTexture The texture to add
+   */
+  addTexture(e) {
+    this._blockEntityCollection || (this.textures.push(e), this.onNewTextureAddedObservable.notifyObservers(e));
+  }
+  /**
+   * Switch active camera
+   * @param newCamera defines the new active camera
+   * @param attachControl defines if attachControl must be called for the new active camera (default: true)
+   */
+  switchActiveCamera(e, t = !0) {
+    this._engine.getInputElement() && (this.activeCamera && this.activeCamera.detachControl(), this.activeCamera = e, t && e.attachControl());
+  }
+  /**
+   * sets the active camera of the scene using its Id
+   * @param id defines the camera's Id
+   * @returns the new active camera or null if none found.
+   */
+  setActiveCameraById(e) {
+    const t = this.getCameraById(e);
+    return t ? (this.activeCamera = t, t) : null;
+  }
+  /**
+   * sets the active camera of the scene using its name
+   * @param name defines the camera's name
+   * @returns the new active camera or null if none found.
+   */
+  setActiveCameraByName(e) {
+    const t = this.getCameraByName(e);
+    return t ? (this.activeCamera = t, t) : null;
+  }
+  /**
+   * get an animation group using its name
+   * @param name defines the material's name
+   * @returns the animation group or null if none found.
+   */
+  getAnimationGroupByName(e) {
+    for (let t = 0; t < this.animationGroups.length; t++)
+      if (this.animationGroups[t].name === e)
+        return this.animationGroups[t];
+    return null;
+  }
+  _getMaterial(e, t) {
+    for (let i = 0; i < this.materials.length; i++) {
+      const r = this.materials[i];
+      if (t(r))
+        return r;
+    }
+    if (e)
+      for (let i = 0; i < this.multiMaterials.length; i++) {
+        const r = this.multiMaterials[i];
+        if (t(r))
+          return r;
+      }
+    return null;
+  }
+  /**
+   * Get a material using its unique id
+   * @param uniqueId defines the material's unique id
+   * @param allowMultiMaterials determines whether multimaterials should be considered
+   * @returns the material or null if none found.
+   */
+  getMaterialByUniqueID(e, t = !1) {
+    return this._getMaterial(t, (i) => i.uniqueId === e);
+  }
+  /**
+   * get a material using its id
+   * @param id defines the material's Id
+   * @param allowMultiMaterials determines whether multimaterials should be considered
+   * @returns the material or null if none found.
+   */
+  getMaterialById(e, t = !1) {
+    return this._getMaterial(t, (i) => i.id === e);
+  }
+  /**
+   * Gets a material using its name
+   * @param name defines the material's name
+   * @param allowMultiMaterials determines whether multimaterials should be considered
+   * @returns the material or null if none found.
+   */
+  getMaterialByName(e, t = !1) {
+    return this._getMaterial(t, (i) => i.name === e);
+  }
+  /**
+   * Gets a last added material using a given id
+   * @param id defines the material's id
+   * @param allowMultiMaterials determines whether multimaterials should be considered
+   * @returns the last material with the given id or null if none found.
+   */
+  getLastMaterialById(e, t = !1) {
+    for (let i = this.materials.length - 1; i >= 0; i--)
+      if (this.materials[i].id === e)
+        return this.materials[i];
+    if (t) {
+      for (let i = this.multiMaterials.length - 1; i >= 0; i--)
+        if (this.multiMaterials[i].id === e)
+          return this.multiMaterials[i];
+    }
+    return null;
+  }
+  /**
+   * Get a texture using its unique id
+   * @param uniqueId defines the texture's unique id
+   * @returns the texture or null if none found.
+   */
+  getTextureByUniqueId(e) {
+    for (let t = 0; t < this.textures.length; t++)
+      if (this.textures[t].uniqueId === e)
+        return this.textures[t];
+    return null;
+  }
+  /**
+   * Gets a texture using its name
+   * @param name defines the texture's name
+   * @returns the texture or null if none found.
+   */
+  getTextureByName(e) {
+    for (let t = 0; t < this.textures.length; t++)
+      if (this.textures[t].name === e)
+        return this.textures[t];
+    return null;
+  }
+  /**
+   * Gets a camera using its Id
+   * @param id defines the Id to look for
+   * @returns the camera or null if not found
+   */
+  getCameraById(e) {
+    for (let t = 0; t < this.cameras.length; t++)
+      if (this.cameras[t].id === e)
+        return this.cameras[t];
+    return null;
+  }
+  /**
+   * Gets a camera using its unique Id
+   * @param uniqueId defines the unique Id to look for
+   * @returns the camera or null if not found
+   */
+  getCameraByUniqueId(e) {
+    for (let t = 0; t < this.cameras.length; t++)
+      if (this.cameras[t].uniqueId === e)
+        return this.cameras[t];
+    return null;
+  }
+  /**
+   * Gets a camera using its name
+   * @param name defines the camera's name
+   * @returns the camera or null if none found.
+   */
+  getCameraByName(e) {
+    for (let t = 0; t < this.cameras.length; t++)
+      if (this.cameras[t].name === e)
+        return this.cameras[t];
+    return null;
+  }
+  /**
+   * Gets a bone using its Id
+   * @param id defines the bone's Id
+   * @returns the bone or null if not found
+   */
+  getBoneById(e) {
+    for (let t = 0; t < this.skeletons.length; t++) {
+      const i = this.skeletons[t];
+      for (let r = 0; r < i.bones.length; r++)
+        if (i.bones[r].id === e)
+          return i.bones[r];
+    }
+    return null;
+  }
+  /**
+   * Gets a bone using its id
+   * @param name defines the bone's name
+   * @returns the bone or null if not found
+   */
+  getBoneByName(e) {
+    for (let t = 0; t < this.skeletons.length; t++) {
+      const i = this.skeletons[t];
+      for (let r = 0; r < i.bones.length; r++)
+        if (i.bones[r].name === e)
+          return i.bones[r];
+    }
+    return null;
+  }
+  /**
+   * Gets a light node using its name
+   * @param name defines the the light's name
+   * @returns the light or null if none found.
+   */
+  getLightByName(e) {
+    for (let t = 0; t < this.lights.length; t++)
+      if (this.lights[t].name === e)
+        return this.lights[t];
+    return null;
+  }
+  /**
+   * Gets a light node using its Id
+   * @param id defines the light's Id
+   * @returns the light or null if none found.
+   */
+  getLightById(e) {
+    for (let t = 0; t < this.lights.length; t++)
+      if (this.lights[t].id === e)
+        return this.lights[t];
+    return null;
+  }
+  /**
+   * Gets a light node using its scene-generated unique Id
+   * @param uniqueId defines the light's unique Id
+   * @returns the light or null if none found.
+   */
+  getLightByUniqueId(e) {
+    for (let t = 0; t < this.lights.length; t++)
+      if (this.lights[t].uniqueId === e)
+        return this.lights[t];
+    return null;
+  }
+  /**
+   * Gets a particle system by Id
+   * @param id defines the particle system Id
+   * @returns the corresponding system or null if none found
+   */
+  getParticleSystemById(e) {
+    for (let t = 0; t < this.particleSystems.length; t++)
+      if (this.particleSystems[t].id === e)
+        return this.particleSystems[t];
+    return null;
+  }
+  /**
+   * Gets a geometry using its Id
+   * @param id defines the geometry's Id
+   * @returns the geometry or null if none found.
+   */
+  getGeometryById(e) {
+    for (let t = 0; t < this.geometries.length; t++)
+      if (this.geometries[t].id === e)
+        return this.geometries[t];
+    return null;
+  }
+  _getGeometryByUniqueId(e) {
+    if (this._geometriesByUniqueId) {
+      const t = this._geometriesByUniqueId[e];
+      if (t !== void 0)
+        return this.geometries[t];
+    } else
+      for (let t = 0; t < this.geometries.length; t++)
+        if (this.geometries[t].uniqueId === e)
+          return this.geometries[t];
+    return null;
+  }
+  /**
+   * Add a new geometry to this scene
+   * @param geometry defines the geometry to be added to the scene.
+   * @param force defines if the geometry must be pushed even if a geometry with this id already exists
+   * @returns a boolean defining if the geometry was added or not
+   */
+  pushGeometry(e, t) {
+    return !t && this._getGeometryByUniqueId(e.uniqueId) ? !1 : (this.addGeometry(e), this.onNewGeometryAddedObservable.notifyObservers(e), !0);
+  }
+  /**
+   * Removes an existing geometry
+   * @param geometry defines the geometry to be removed from the scene
+   * @returns a boolean defining if the geometry was removed or not
+   */
+  removeGeometry(e) {
+    let t;
+    if (this._geometriesByUniqueId) {
+      if (t = this._geometriesByUniqueId[e.uniqueId], t === void 0)
+        return !1;
+    } else if (t = this.geometries.indexOf(e), t < 0)
+      return !1;
+    if (t !== this.geometries.length - 1) {
+      const i = this.geometries[this.geometries.length - 1];
+      i && (this.geometries[t] = i, this._geometriesByUniqueId && (this._geometriesByUniqueId[i.uniqueId] = t));
+    }
+    return this._geometriesByUniqueId && (this._geometriesByUniqueId[e.uniqueId] = void 0), this.geometries.pop(), this.onGeometryRemovedObservable.notifyObservers(e), !0;
+  }
+  /**
+   * Gets the list of geometries attached to the scene
+   * @returns an array of Geometry
+   */
+  getGeometries() {
+    return this.geometries;
+  }
+  /**
+   * Gets the first added mesh found of a given Id
+   * @param id defines the Id to search for
+   * @returns the mesh found or null if not found at all
+   */
+  getMeshById(e) {
+    for (let t = 0; t < this.meshes.length; t++)
+      if (this.meshes[t].id === e)
+        return this.meshes[t];
+    return null;
+  }
+  /**
+   * Gets a list of meshes using their Id
+   * @param id defines the Id to search for
+   * @returns a list of meshes
+   */
+  getMeshesById(e) {
+    return this.meshes.filter(function(t) {
+      return t.id === e;
+    });
+  }
+  /**
+   * Gets the first added transform node found of a given Id
+   * @param id defines the Id to search for
+   * @returns the found transform node or null if not found at all.
+   */
+  getTransformNodeById(e) {
+    for (let t = 0; t < this.transformNodes.length; t++)
+      if (this.transformNodes[t].id === e)
+        return this.transformNodes[t];
+    return null;
+  }
+  /**
+   * Gets a transform node with its auto-generated unique Id
+   * @param uniqueId defines the unique Id to search for
+   * @returns the found transform node or null if not found at all.
+   */
+  getTransformNodeByUniqueId(e) {
+    for (let t = 0; t < this.transformNodes.length; t++)
+      if (this.transformNodes[t].uniqueId === e)
+        return this.transformNodes[t];
+    return null;
+  }
+  /**
+   * Gets a list of transform nodes using their Id
+   * @param id defines the Id to search for
+   * @returns a list of transform nodes
+   */
+  getTransformNodesById(e) {
+    return this.transformNodes.filter(function(t) {
+      return t.id === e;
+    });
+  }
+  /**
+   * Gets a mesh with its auto-generated unique Id
+   * @param uniqueId defines the unique Id to search for
+   * @returns the found mesh or null if not found at all.
+   */
+  getMeshByUniqueId(e) {
+    for (let t = 0; t < this.meshes.length; t++)
+      if (this.meshes[t].uniqueId === e)
+        return this.meshes[t];
+    return null;
+  }
+  /**
+   * Gets a the last added mesh using a given Id
+   * @param id defines the Id to search for
+   * @returns the found mesh or null if not found at all.
+   */
+  getLastMeshById(e) {
+    for (let t = this.meshes.length - 1; t >= 0; t--)
+      if (this.meshes[t].id === e)
+        return this.meshes[t];
+    return null;
+  }
+  /**
+   * Gets a the last transform node using a given Id
+   * @param id defines the Id to search for
+   * @returns the found mesh or null if not found at all.
+   */
+  getLastTransformNodeById(e) {
+    for (let t = this.transformNodes.length - 1; t >= 0; t--)
+      if (this.transformNodes[t].id === e)
+        return this.transformNodes[t];
+    return null;
+  }
+  /**
+   * Gets a the last added node (Mesh, Camera, Light) using a given Id
+   * @param id defines the Id to search for
+   * @returns the found node or null if not found at all
+   */
+  getLastEntryById(e) {
+    let t;
+    for (t = this.meshes.length - 1; t >= 0; t--)
+      if (this.meshes[t].id === e)
+        return this.meshes[t];
+    for (t = this.transformNodes.length - 1; t >= 0; t--)
+      if (this.transformNodes[t].id === e)
+        return this.transformNodes[t];
+    for (t = this.cameras.length - 1; t >= 0; t--)
+      if (this.cameras[t].id === e)
+        return this.cameras[t];
+    for (t = this.lights.length - 1; t >= 0; t--)
+      if (this.lights[t].id === e)
+        return this.lights[t];
+    return null;
+  }
+  /**
+   * Gets a node (Mesh, Camera, Light) using a given Id
+   * @param id defines the Id to search for
+   * @returns the found node or null if not found at all
+   */
+  getNodeById(e) {
+    const t = this.getMeshById(e);
+    if (t)
+      return t;
+    const i = this.getTransformNodeById(e);
+    if (i)
+      return i;
+    const r = this.getLightById(e);
+    if (r)
+      return r;
+    const s = this.getCameraById(e);
+    if (s)
+      return s;
+    const n = this.getBoneById(e);
+    return n || null;
+  }
+  /**
+   * Gets a node (Mesh, Camera, Light) using a given name
+   * @param name defines the name to search for
+   * @returns the found node or null if not found at all.
+   */
+  getNodeByName(e) {
+    const t = this.getMeshByName(e);
+    if (t)
+      return t;
+    const i = this.getTransformNodeByName(e);
+    if (i)
+      return i;
+    const r = this.getLightByName(e);
+    if (r)
+      return r;
+    const s = this.getCameraByName(e);
+    if (s)
+      return s;
+    const n = this.getBoneByName(e);
+    return n || null;
+  }
+  /**
+   * Gets a mesh using a given name
+   * @param name defines the name to search for
+   * @returns the found mesh or null if not found at all.
+   */
+  getMeshByName(e) {
+    for (let t = 0; t < this.meshes.length; t++)
+      if (this.meshes[t].name === e)
+        return this.meshes[t];
+    return null;
+  }
+  /**
+   * Gets a transform node using a given name
+   * @param name defines the name to search for
+   * @returns the found transform node or null if not found at all.
+   */
+  getTransformNodeByName(e) {
+    for (let t = 0; t < this.transformNodes.length; t++)
+      if (this.transformNodes[t].name === e)
+        return this.transformNodes[t];
+    return null;
+  }
+  /**
+   * Gets a skeleton using a given Id (if many are found, this function will pick the last one)
+   * @param id defines the Id to search for
+   * @returns the found skeleton or null if not found at all.
+   */
+  getLastSkeletonById(e) {
+    for (let t = this.skeletons.length - 1; t >= 0; t--)
+      if (this.skeletons[t].id === e)
+        return this.skeletons[t];
+    return null;
+  }
+  /**
+   * Gets a skeleton using a given auto generated unique id
+   * @param  uniqueId defines the unique id to search for
+   * @returns the found skeleton or null if not found at all.
+   */
+  getSkeletonByUniqueId(e) {
+    for (let t = 0; t < this.skeletons.length; t++)
+      if (this.skeletons[t].uniqueId === e)
+        return this.skeletons[t];
+    return null;
+  }
+  /**
+   * Gets a skeleton using a given id (if many are found, this function will pick the first one)
+   * @param id defines the id to search for
+   * @returns the found skeleton or null if not found at all.
+   */
+  getSkeletonById(e) {
+    for (let t = 0; t < this.skeletons.length; t++)
+      if (this.skeletons[t].id === e)
+        return this.skeletons[t];
+    return null;
+  }
+  /**
+   * Gets a skeleton using a given name
+   * @param name defines the name to search for
+   * @returns the found skeleton or null if not found at all.
+   */
+  getSkeletonByName(e) {
+    for (let t = 0; t < this.skeletons.length; t++)
+      if (this.skeletons[t].name === e)
+        return this.skeletons[t];
+    return null;
+  }
+  /**
+   * Gets a morph target manager  using a given id (if many are found, this function will pick the last one)
+   * @param id defines the id to search for
+   * @returns the found morph target manager or null if not found at all.
+   */
+  getMorphTargetManagerById(e) {
+    for (let t = 0; t < this.morphTargetManagers.length; t++)
+      if (this.morphTargetManagers[t].uniqueId === e)
+        return this.morphTargetManagers[t];
+    return null;
+  }
+  /**
+   * Gets a morph target using a given id (if many are found, this function will pick the first one)
+   * @param id defines the id to search for
+   * @returns the found morph target or null if not found at all.
+   */
+  getMorphTargetById(e) {
+    for (let t = 0; t < this.morphTargetManagers.length; ++t) {
+      const i = this.morphTargetManagers[t];
+      for (let r = 0; r < i.numTargets; ++r) {
+        const s = i.getTarget(r);
+        if (s.id === e)
+          return s;
+      }
+    }
+    return null;
+  }
+  /**
+   * Gets a morph target using a given name (if many are found, this function will pick the first one)
+   * @param name defines the name to search for
+   * @returns the found morph target or null if not found at all.
+   */
+  getMorphTargetByName(e) {
+    for (let t = 0; t < this.morphTargetManagers.length; ++t) {
+      const i = this.morphTargetManagers[t];
+      for (let r = 0; r < i.numTargets; ++r) {
+        const s = i.getTarget(r);
+        if (s.name === e)
+          return s;
+      }
+    }
+    return null;
+  }
+  /**
+   * Gets a post process using a given name (if many are found, this function will pick the first one)
+   * @param name defines the name to search for
+   * @returns the found post process or null if not found at all.
+   */
+  getPostProcessByName(e) {
+    for (let t = 0; t < this.postProcesses.length; ++t) {
+      const i = this.postProcesses[t];
+      if (i.name === e)
+        return i;
+    }
+    return null;
+  }
+  /**
+   * Gets a boolean indicating if the given mesh is active
+   * @param mesh defines the mesh to look for
+   * @returns true if the mesh is in the active list
+   */
+  isActiveMesh(e) {
+    return this._activeMeshes.indexOf(e) !== -1;
+  }
+  /**
+   * Return a unique id as a string which can serve as an identifier for the scene
+   */
+  get uid() {
+    return this._uid || (this._uid = C.RandomId()), this._uid;
+  }
+  /**
+   * Add an externally attached data from its key.
+   * This method call will fail and return false, if such key already exists.
+   * If you don't care and just want to get the data no matter what, use the more convenient getOrAddExternalDataWithFactory() method.
+   * @param key the unique key that identifies the data
+   * @param data the data object to associate to the key for this Engine instance
+   * @returns true if no such key were already present and the data was added successfully, false otherwise
+   */
+  addExternalData(e, t) {
+    return this._externalData || (this._externalData = new P()), this._externalData.add(e, t);
+  }
+  /**
+   * Get an externally attached data from its key
+   * @param key the unique key that identifies the data
+   * @returns the associated data, if present (can be null), or undefined if not present
+   */
+  getExternalData(e) {
+    return this._externalData ? this._externalData.get(e) : null;
+  }
+  /**
+   * Get an externally attached data from its key, create it using a factory if it's not already present
+   * @param key the unique key that identifies the data
+   * @param factory the factory that will be called to create the instance if and only if it doesn't exists
+   * @returns the associated data, can be null if the factory returned null.
+   */
+  getOrAddExternalDataWithFactory(e, t) {
+    return this._externalData || (this._externalData = new P()), this._externalData.getOrAddWithFactory(e, t);
+  }
+  /**
+   * Remove an externally attached data from the Engine instance
+   * @param key the unique key that identifies the data
+   * @returns true if the data was successfully removed, false if it doesn't exist
+   */
+  removeExternalData(e) {
+    return this._externalData.remove(e);
+  }
+  _evaluateSubMesh(e, t, i, r) {
+    if (r || e.isInFrustum(this._frustumPlanes)) {
+      for (const n of this._evaluateSubMeshStage)
+        n.action(t, e);
+      const s = e.getMaterial();
+      s != null && (s.hasRenderTargetTextures && s.getRenderTargetTextures != null && this._processedMaterials.indexOf(s) === -1 && (this._processedMaterials.push(s), this._materialsRenderTargets.concatWithNoDuplicate(s.getRenderTargetTextures())), this._renderingManager.dispatch(e, t, s));
+    }
+  }
+  /**
+   * Clear the processed materials smart array preventing retention point in material dispose.
+   */
+  freeProcessedMaterials() {
+    this._processedMaterials.dispose();
+  }
+  /** Gets or sets a boolean blocking all the calls to freeActiveMeshes and freeRenderingGroups
+   * It can be used in order to prevent going through methods freeRenderingGroups and freeActiveMeshes several times to improve performance
+   * when disposing several meshes in a row or a hierarchy of meshes.
+   * When used, it is the responsibility of the user to blockfreeActiveMeshesAndRenderingGroups back to false.
+   */
+  get blockfreeActiveMeshesAndRenderingGroups() {
+    return this._preventFreeActiveMeshesAndRenderingGroups;
+  }
+  set blockfreeActiveMeshesAndRenderingGroups(e) {
+    this._preventFreeActiveMeshesAndRenderingGroups !== e && (e && (this.freeActiveMeshes(), this.freeRenderingGroups()), this._preventFreeActiveMeshesAndRenderingGroups = e);
+  }
+  /**
+   * Clear the active meshes smart array preventing retention point in mesh dispose.
+   */
+  freeActiveMeshes() {
+    if (!this.blockfreeActiveMeshesAndRenderingGroups && (this._activeMeshes.dispose(), this.activeCamera && this.activeCamera._activeMeshes && this.activeCamera._activeMeshes.dispose(), this.activeCameras))
+      for (let e = 0; e < this.activeCameras.length; e++) {
+        const t = this.activeCameras[e];
+        t && t._activeMeshes && t._activeMeshes.dispose();
+      }
+  }
+  /**
+   * Clear the info related to rendering groups preventing retention points during dispose.
+   */
+  freeRenderingGroups() {
+    if (!this.blockfreeActiveMeshesAndRenderingGroups && (this._renderingManager && this._renderingManager.freeRenderingGroups(), this.textures))
+      for (let e = 0; e < this.textures.length; e++) {
+        const t = this.textures[e];
+        t && t.renderList && t.freeRenderingGroups();
+      }
+  }
+  /** @internal */
+  _isInIntermediateRendering() {
+    return this._intermediateRendering;
+  }
+  /**
+   * Use this function to stop evaluating active meshes. The current list will be keep alive between frames
+   * @param skipEvaluateActiveMeshes defines an optional boolean indicating that the evaluate active meshes step must be completely skipped
+   * @param onSuccess optional success callback
+   * @param onError optional error callback
+   * @param freezeMeshes defines if meshes should be frozen (true by default)
+   * @param keepFrustumCulling defines if you want to keep running the frustum clipping (false by default)
+   * @returns the current scene
+   */
+  freezeActiveMeshes(e = !1, t, i, r = !0, s = !1) {
+    return this.executeWhenReady(() => {
+      if (!this.activeCamera) {
+        i && i("No active camera found");
+        return;
+      }
+      if (this._frustumPlanes || this.updateTransformMatrix(), this._evaluateActiveMeshes(), this._activeMeshesFrozen = !0, this._activeMeshesFrozenButKeepClipping = s, this._skipEvaluateActiveMeshesCompletely = e, r)
+        for (let n = 0; n < this._activeMeshes.length; n++)
+          this._activeMeshes.data[n]._freeze();
+      t && t();
+    }), this;
+  }
+  /**
+   * Use this function to restart evaluating active meshes on every frame
+   * @returns the current scene
+   */
+  unfreezeActiveMeshes() {
+    for (let e = 0; e < this.meshes.length; e++) {
+      const t = this.meshes[e];
+      t._internalAbstractMeshDataInfo && (t._internalAbstractMeshDataInfo._isActive = !1);
+    }
+    for (let e = 0; e < this._activeMeshes.length; e++)
+      this._activeMeshes.data[e]._unFreeze();
+    return this._activeMeshesFrozen = !1, this;
+  }
+  _executeActiveContainerCleanup(e) {
+    !(this._engine.snapshotRendering && this._engine.snapshotRenderingMode === 1) && this._activeMeshesFrozen && this._activeMeshes.length || this.onBeforeRenderObservable.addOnce(() => e.dispose());
+  }
+  _evaluateActiveMeshes() {
+    var e;
+    if (this._engine.snapshotRendering && this._engine.snapshotRenderingMode === 1) {
+      this._activeMeshes.length > 0 && ((e = this.activeCamera) === null || e === void 0 || e._activeMeshes.reset(), this._activeMeshes.reset(), this._renderingManager.reset(), this._processedMaterials.reset(), this._activeParticleSystems.reset(), this._activeSkeletons.reset(), this._softwareSkinnedMeshes.reset());
+      return;
+    }
+    if (this._activeMeshesFrozen && this._activeMeshes.length) {
+      if (!this._skipEvaluateActiveMeshesCompletely) {
+        const r = this._activeMeshes.length;
+        for (let s = 0; s < r; s++)
+          this._activeMeshes.data[s].computeWorldMatrix();
+      }
+      if (this._activeParticleSystems) {
+        const r = this._activeParticleSystems.length;
+        for (let s = 0; s < r; s++)
+          this._activeParticleSystems.data[s].animate();
+      }
+      this._renderingManager.resetSprites();
+      return;
+    }
+    if (!this.activeCamera)
+      return;
+    this.onBeforeActiveMeshesEvaluationObservable.notifyObservers(this), this.activeCamera._activeMeshes.reset(), this._activeMeshes.reset(), this._renderingManager.reset(), this._processedMaterials.reset(), this._activeParticleSystems.reset(), this._activeSkeletons.reset(), this._softwareSkinnedMeshes.reset(), this._materialsRenderTargets.reset();
+    for (const r of this._beforeEvaluateActiveMeshStage)
+      r.action();
+    const t = this.getActiveMeshCandidates(), i = t.length;
+    for (let r = 0; r < i; r++) {
+      const s = t.data[r];
+      if (s._internalAbstractMeshDataInfo._currentLODIsUpToDate = !1, s.isBlocked || (this._totalVertices.addCount(s.getTotalVertices(), !1), !s.isReady() || !s.isEnabled() || s.scaling.hasAZeroComponent))
+        continue;
+      s.computeWorldMatrix(), s.actionManager && s.actionManager.hasSpecificTriggers2(12, 13) && this._meshesForIntersections.pushNoDuplicate(s);
+      let n = this.customLODSelector ? this.customLODSelector(s, this.activeCamera) : s.getLOD(this.activeCamera);
+      if (s._internalAbstractMeshDataInfo._currentLOD = n, s._internalAbstractMeshDataInfo._currentLODIsUpToDate = !0, n != null && (n !== s && n.billboardMode !== 0 && n.computeWorldMatrix(), s._preActivate(), s.isVisible && s.visibility > 0 && s.layerMask & this.activeCamera.layerMask && (this._skipFrustumClipping || s.alwaysSelectAsActiveMesh || s.isInFrustum(this._frustumPlanes)))) {
+        this._activeMeshes.push(s), this.activeCamera._activeMeshes.push(s), n !== s && n._activate(this._renderId, !1);
+        for (const l of this._preActiveMeshStage)
+          l.action(s);
+        s._activate(this._renderId, !1) && (s.isAnInstance ? s._internalAbstractMeshDataInfo._actAsRegularMesh && (n = s) : n._internalAbstractMeshDataInfo._onlyForInstances = !1, n._internalAbstractMeshDataInfo._isActive = !0, this._activeMesh(s, n)), s._postActivate();
+      }
+    }
+    if (this.onAfterActiveMeshesEvaluationObservable.notifyObservers(this), this.particlesEnabled) {
+      this.onBeforeParticlesRenderingObservable.notifyObservers(this);
+      for (let r = 0; r < this.particleSystems.length; r++) {
+        const s = this.particleSystems[r];
+        if (!s.isStarted() || !s.emitter)
+          continue;
+        const n = s.emitter;
+        (!n.position || n.isEnabled()) && (this._activeParticleSystems.push(s), s.animate(), this._renderingManager.dispatchParticles(s));
+      }
+      this.onAfterParticlesRenderingObservable.notifyObservers(this);
+    }
+  }
+  _activeMesh(e, t) {
+    this._skeletonsEnabled && t.skeleton !== null && t.skeleton !== void 0 && (this._activeSkeletons.pushNoDuplicate(t.skeleton) && (t.skeleton.prepare(), this._activeBones.addCount(t.skeleton.bones.length, !1)), t.computeBonesUsingShaders || this._softwareSkinnedMeshes.pushNoDuplicate(t));
+    let i = e.hasInstances || e.isAnInstance || this.dispatchAllSubMeshesOfActiveMeshes || this._skipFrustumClipping || t.alwaysSelectAsActiveMesh;
+    if (t && t.subMeshes && t.subMeshes.length > 0) {
+      const r = this.getActiveSubMeshCandidates(t), s = r.length;
+      i = i || s === 1;
+      for (let n = 0; n < s; n++) {
+        const l = r.data[n];
+        this._evaluateSubMesh(l, t, e, i);
+      }
+    }
+  }
+  /**
+   * Update the transform matrix to update from the current active camera
+   * @param force defines a boolean used to force the update even if cache is up to date
+   */
+  updateTransformMatrix(e) {
+    if (this.activeCamera)
+      if (this.activeCamera._renderingMultiview) {
+        const t = this.activeCamera._rigCameras[0], i = this.activeCamera._rigCameras[1];
+        this.setTransformMatrix(t.getViewMatrix(), t.getProjectionMatrix(e), i.getViewMatrix(), i.getProjectionMatrix(e));
+      } else
+        this.setTransformMatrix(this.activeCamera.getViewMatrix(), this.activeCamera.getProjectionMatrix(e));
+  }
+  _bindFrameBuffer(e, t = !0) {
+    e && e._multiviewTexture ? e._multiviewTexture._bindFrameBuffer() : e && e.outputRenderTarget ? e.outputRenderTarget._bindFrameBuffer() : this._engine._currentFrameBufferIsDefaultFrameBuffer() || this._engine.restoreDefaultFramebuffer(), t && this._clearFrameBuffer(e);
+  }
+  _clearFrameBuffer(e) {
+    if (!(e && e._multiviewTexture))
+      if (e && e.outputRenderTarget && !e._renderingMultiview) {
+        const t = e.outputRenderTarget;
+        t.onClearObservable.hasObservers() ? t.onClearObservable.notifyObservers(this._engine) : t.skipInitialClear || (this.autoClear && this._engine.clear(t.clearColor || this.clearColor, !t._cleared, !0, !0), t._cleared = !0);
+      } else
+        this._defaultFrameBufferCleared ? this._engine.clear(null, !1, !0, !0) : (this._defaultFrameBufferCleared = !0, this._clear());
+  }
+  /**
+   * @internal
+   */
+  _renderForCamera(e, t, i = !0) {
+    var r, s, n;
+    if (e && e._skipRendering)
+      return;
+    const l = this._engine;
+    if (this._activeCamera = e, !this.activeCamera)
+      throw new Error("Active camera not set");
+    if (l.setViewport(this.activeCamera.viewport), this.resetCachedMaterial(), this._renderId++, !this.prePass && i) {
+      let o = !0;
+      e._renderingMultiview && e.outputRenderTarget && (o = e.outputRenderTarget.skipInitialClear, this.autoClear && (this._defaultFrameBufferCleared = !1, e.outputRenderTarget.skipInitialClear = !1)), this._bindFrameBuffer(this._activeCamera), e._renderingMultiview && e.outputRenderTarget && (e.outputRenderTarget.skipInitialClear = o);
+    }
+    this.updateTransformMatrix(), this.onBeforeCameraRenderObservable.notifyObservers(this.activeCamera), this._evaluateActiveMeshes();
+    for (let o = 0; o < this._softwareSkinnedMeshes.length; o++) {
+      const u = this._softwareSkinnedMeshes.data[o];
+      u.applySkeleton(u.skeleton);
+    }
+    this.onBeforeRenderTargetsRenderObservable.notifyObservers(this), this._renderTargets.concatWithNoDuplicate(this._materialsRenderTargets), e.customRenderTargets && e.customRenderTargets.length > 0 && this._renderTargets.concatWithNoDuplicate(e.customRenderTargets), t && t.customRenderTargets && t.customRenderTargets.length > 0 && this._renderTargets.concatWithNoDuplicate(t.customRenderTargets), this.environmentTexture && this.environmentTexture.isRenderTarget && this._renderTargets.pushNoDuplicate(this.environmentTexture);
+    for (const o of this._gatherActiveCameraRenderTargetsStage)
+      o.action(this._renderTargets);
+    let a = !1;
+    if (this.renderTargetsEnabled) {
+      if (this._intermediateRendering = !0, this._renderTargets.length > 0) {
+        C.StartPerformanceCounter("Render targets", this._renderTargets.length > 0);
+        for (let o = 0; o < this._renderTargets.length; o++) {
+          const u = this._renderTargets.data[o];
+          if (u._shouldRender()) {
+            this._renderId++;
+            const g = u.activeCamera && u.activeCamera !== this.activeCamera;
+            u.render(g, this.dumpNextRenderTargets), a = !0;
+          }
+        }
+        C.EndPerformanceCounter("Render targets", this._renderTargets.length > 0), this._renderId++;
+      }
+      for (const o of this._cameraDrawRenderTargetStage)
+        a = o.action(this.activeCamera) || a;
+      this._intermediateRendering = !1;
+    }
+    this._engine.currentRenderPassId = (n = (s = (r = e.outputRenderTarget) === null || r === void 0 ? void 0 : r.renderPassId) !== null && s !== void 0 ? s : e.renderPassId) !== null && n !== void 0 ? n : 0, a && !this.prePass && this._bindFrameBuffer(this._activeCamera, !1), this.onAfterRenderTargetsRenderObservable.notifyObservers(this), this.postProcessManager && !e._multiviewTexture && !this.prePass && this.postProcessManager._prepareFrame();
+    for (const o of this._beforeCameraDrawStage)
+      o.action(this.activeCamera);
+    this.onBeforeDrawPhaseObservable.notifyObservers(this), l.snapshotRendering && l.snapshotRenderingMode === 1 && this.finalizeSceneUbo(), this._renderingManager.render(null, null, !0, !0), this.onAfterDrawPhaseObservable.notifyObservers(this);
+    for (const o of this._afterCameraDrawStage)
+      o.action(this.activeCamera);
+    if (this.postProcessManager && !e._multiviewTexture) {
+      const o = e.outputRenderTarget ? e.outputRenderTarget.renderTarget : void 0;
+      this.postProcessManager._finalizeFrame(e.isIntermediate, o);
+    }
+    for (const o of this._afterCameraPostProcessStage)
+      o.action(this.activeCamera);
+    this._renderTargets.reset(), this.onAfterCameraRenderObservable.notifyObservers(this.activeCamera);
+  }
+  _processSubCameras(e, t = !0) {
+    if (e.cameraRigMode === 0 || e._renderingMultiview) {
+      e._renderingMultiview && !this._multiviewSceneUbo && this._createMultiviewUbo(), this._renderForCamera(e, void 0, t), this.onAfterRenderCameraObservable.notifyObservers(e);
+      return;
+    }
+    if (e._useMultiviewToSingleView)
+      this._renderMultiviewToSingleView(e);
+    else {
+      this.onBeforeCameraRenderObservable.notifyObservers(e);
+      for (let i = 0; i < e._rigCameras.length; i++)
+        this._renderForCamera(e._rigCameras[i], e);
+    }
+    this._activeCamera = e, this.updateTransformMatrix(), this.onAfterRenderCameraObservable.notifyObservers(e);
+  }
+  _checkIntersections() {
+    for (let e = 0; e < this._meshesForIntersections.length; e++) {
+      const t = this._meshesForIntersections.data[e];
+      if (t.actionManager)
+        for (let i = 0; t.actionManager && i < t.actionManager.actions.length; i++) {
+          const r = t.actionManager.actions[i];
+          if (r.trigger === 12 || r.trigger === 13) {
+            const s = r.getTriggerParameter(), n = s.mesh ? s.mesh : s, l = n.intersectsMesh(t, s.usePreciseIntersection), a = t._intersectionsInProgress.indexOf(n);
+            l && a === -1 ? r.trigger === 12 ? (r._executeCurrent(w.CreateNew(t, void 0, n)), t._intersectionsInProgress.push(n)) : r.trigger === 13 && t._intersectionsInProgress.push(n) : !l && a > -1 && (r.trigger === 13 && r._executeCurrent(w.CreateNew(t, void 0, n)), (!t.actionManager.hasSpecificTrigger(13, (o) => {
+              const u = o.mesh ? o.mesh : o;
+              return n === u;
+            }) || r.trigger === 13) && t._intersectionsInProgress.splice(a, 1));
+          }
+        }
+    }
+  }
+  /**
+   * @internal
+   */
+  _advancePhysicsEngineStep(e) {
+  }
+  /** @internal */
+  _animate() {
+  }
+  /** Execute all animations (for a frame) */
+  animate() {
+    if (this._engine.isDeterministicLockStep()) {
+      let e = Math.max(c.MinDeltaTime, Math.min(this._engine.getDeltaTime(), c.MaxDeltaTime)) + this._timeAccumulator;
+      const t = this._engine.getTimeStep(), i = 1e3 / t / 1e3;
+      let r = 0;
+      const s = this._engine.getLockstepMaxSteps();
+      let n = Math.floor(e / t);
+      for (n = Math.min(n, s); e > 0 && r < n; )
+        this.onBeforeStepObservable.notifyObservers(this), this._animationRatio = t * i, this._animate(), this.onAfterAnimationsObservable.notifyObservers(this), this.physicsEnabled && this._advancePhysicsEngineStep(t), this.onAfterStepObservable.notifyObservers(this), this._currentStepId++, r++, e -= t;
+      this._timeAccumulator = e < 0 ? 0 : e;
+    } else {
+      const e = this.useConstantAnimationDeltaTime ? 16 : Math.max(c.MinDeltaTime, Math.min(this._engine.getDeltaTime(), c.MaxDeltaTime));
+      this._animationRatio = e * (60 / 1e3), this._animate(), this.onAfterAnimationsObservable.notifyObservers(this), this.physicsEnabled && this._advancePhysicsEngineStep(e);
+    }
+  }
+  _clear() {
+    (this.autoClearDepthAndStencil || this.autoClear) && this._engine.clear(this.clearColor, this.autoClear || this.forceWireframe || this.forcePointsCloud, this.autoClearDepthAndStencil, this.autoClearDepthAndStencil);
+  }
+  _checkCameraRenderTarget(e) {
+    var t;
+    if (e != null && e.outputRenderTarget && !(e != null && e.isRigCamera) && (e.outputRenderTarget._cleared = !1), !((t = e == null ? void 0 : e.rigCameras) === null || t === void 0) && t.length)
+      for (let i = 0; i < e.rigCameras.length; ++i) {
+        const r = e.rigCameras[i].outputRenderTarget;
+        r && (r._cleared = !1);
+      }
+  }
+  /**
+   * Resets the draw wrappers cache of all meshes
+   * @param passId If provided, releases only the draw wrapper corresponding to this render pass id
+   */
+  resetDrawCache(e) {
+    if (this.meshes)
+      for (const t of this.meshes)
+        t.resetDrawCache(e);
+  }
+  /**
+   * Render the scene
+   * @param updateCameras defines a boolean indicating if cameras must update according to their inputs (true by default)
+   * @param ignoreAnimations defines a boolean indicating if animations should not be executed (false by default)
+   */
+  render(e = !0, t = !1) {
+    var i, r, s;
+    if (this.isDisposed)
+      return;
+    this.onReadyObservable.hasObservers() && this._executeWhenReadyTimeoutId === null && this._checkIsReady(), this._frameId++, this._defaultFrameBufferCleared = !1, this._checkCameraRenderTarget(this.activeCamera), !((i = this.activeCameras) === null || i === void 0) && i.length && this.activeCameras.forEach(this._checkCameraRenderTarget), this._registerTransientComponents(), this._activeParticles.fetchNewFrame(), this._totalVertices.fetchNewFrame(), this._activeIndices.fetchNewFrame(), this._activeBones.fetchNewFrame(), this._meshesForIntersections.reset(), this.resetCachedMaterial(), this.onBeforeAnimationsObservable.notifyObservers(this), this.actionManager && this.actionManager.processTrigger(11), t || this.animate();
+    for (const a of this._beforeCameraUpdateStage)
+      a.action();
+    if (e) {
+      if (this.activeCameras && this.activeCameras.length > 0)
+        for (let a = 0; a < this.activeCameras.length; a++) {
+          const o = this.activeCameras[a];
+          if (o.update(), o.cameraRigMode !== 0)
+            for (let u = 0; u < o._rigCameras.length; u++)
+              o._rigCameras[u].update();
+        }
+      else if (this.activeCamera && (this.activeCamera.update(), this.activeCamera.cameraRigMode !== 0))
+        for (let a = 0; a < this.activeCamera._rigCameras.length; a++)
+          this.activeCamera._rigCameras[a].update();
+    }
+    this.onBeforeRenderObservable.notifyObservers(this);
+    const n = this.getEngine();
+    this.onBeforeRenderTargetsRenderObservable.notifyObservers(this);
+    const l = !((r = this.activeCameras) === null || r === void 0) && r.length ? this.activeCameras[0] : this.activeCamera;
+    if (this.renderTargetsEnabled) {
+      C.StartPerformanceCounter("Custom render targets", this.customRenderTargets.length > 0), this._intermediateRendering = !0;
+      for (let a = 0; a < this.customRenderTargets.length; a++) {
+        const o = this.customRenderTargets[a];
+        if (o._shouldRender()) {
+          if (this._renderId++, this.activeCamera = o.activeCamera || this.activeCamera, !this.activeCamera)
+            throw new Error("Active camera not set");
+          n.setViewport(this.activeCamera.viewport), this.updateTransformMatrix(), o.render(l !== this.activeCamera, this.dumpNextRenderTargets);
+        }
+      }
+      C.EndPerformanceCounter("Custom render targets", this.customRenderTargets.length > 0), this._intermediateRendering = !1, this._renderId++;
+    }
+    this._engine.currentRenderPassId = (s = l == null ? void 0 : l.renderPassId) !== null && s !== void 0 ? s : 0, this.activeCamera = l, this._activeCamera && this._activeCamera.cameraRigMode !== 22 && !this.prePass && this._bindFrameBuffer(this._activeCamera, !1), this.onAfterRenderTargetsRenderObservable.notifyObservers(this);
+    for (const a of this._beforeClearStage)
+      a.action();
+    this._clearFrameBuffer(this.activeCamera);
+    for (const a of this._gatherRenderTargetsStage)
+      a.action(this._renderTargets);
+    if (this.activeCameras && this.activeCameras.length > 0)
+      for (let a = 0; a < this.activeCameras.length; a++)
+        this._processSubCameras(this.activeCameras[a], a > 0);
+    else {
+      if (!this.activeCamera)
+        throw new Error("No camera defined");
+      this._processSubCameras(this.activeCamera, !!this.activeCamera.outputRenderTarget);
+    }
+    this._checkIntersections();
+    for (const a of this._afterRenderStage)
+      a.action();
+    if (this.afterRender && this.afterRender(), this.onAfterRenderObservable.notifyObservers(this), this._toBeDisposed.length) {
+      for (let a = 0; a < this._toBeDisposed.length; a++) {
+        const o = this._toBeDisposed[a];
+        o && o.dispose();
+      }
+      this._toBeDisposed.length = 0;
+    }
+    this.dumpNextRenderTargets && (this.dumpNextRenderTargets = !1), this._activeBones.addCount(0, !0), this._activeIndices.addCount(0, !0), this._activeParticles.addCount(0, !0), this._engine.restoreDefaultFramebuffer();
+  }
+  /**
+   * Freeze all materials
+   * A frozen material will not be updatable but should be faster to render
+   * Note: multimaterials will not be frozen, but their submaterials will
+   */
+  freezeMaterials() {
+    for (let e = 0; e < this.materials.length; e++)
+      this.materials[e].freeze();
+  }
+  /**
+   * Unfreeze all materials
+   * A frozen material will not be updatable but should be faster to render
+   */
+  unfreezeMaterials() {
+    for (let e = 0; e < this.materials.length; e++)
+      this.materials[e].unfreeze();
+  }
+  /**
+   * Releases all held resources
+   */
+  dispose() {
+    if (this.isDisposed)
+      return;
+    this.beforeRender = null, this.afterRender = null, this.metadata = null, this.skeletons.length = 0, this.morphTargetManagers.length = 0, this._transientComponents.length = 0, this._isReadyForMeshStage.clear(), this._beforeEvaluateActiveMeshStage.clear(), this._evaluateSubMeshStage.clear(), this._preActiveMeshStage.clear(), this._cameraDrawRenderTargetStage.clear(), this._beforeCameraDrawStage.clear(), this._beforeRenderTargetDrawStage.clear(), this._beforeRenderingGroupDrawStage.clear(), this._beforeRenderingMeshStage.clear(), this._afterRenderingMeshStage.clear(), this._afterRenderingGroupDrawStage.clear(), this._afterCameraDrawStage.clear(), this._afterRenderTargetDrawStage.clear(), this._afterRenderStage.clear(), this._beforeCameraUpdateStage.clear(), this._beforeClearStage.clear(), this._gatherRenderTargetsStage.clear(), this._gatherActiveCameraRenderTargetsStage.clear(), this._pointerMoveStage.clear(), this._pointerDownStage.clear(), this._pointerUpStage.clear(), this.importedMeshesFiles = new Array(), this.stopAllAnimations && this.stopAllAnimations(), this.resetCachedMaterial(), this.activeCamera && (this.activeCamera._activeMeshes.dispose(), this.activeCamera = null), this.activeCameras = null, this._activeMeshes.dispose(), this._renderingManager.dispose(), this._processedMaterials.dispose(), this._activeParticleSystems.dispose(), this._activeSkeletons.dispose(), this._softwareSkinnedMeshes.dispose(), this._renderTargets.dispose(), this._materialsRenderTargets.dispose(), this._registeredForLateAnimationBindings.dispose(), this._meshesForIntersections.dispose(), this._toBeDisposed.length = 0;
+    const e = this._activeRequests.slice();
+    for (const s of e)
+      s.abort();
+    this._activeRequests.length = 0;
+    try {
+      this.onDisposeObservable.notifyObservers(this);
+    } catch (s) {
+      console.error("An error occurred while calling onDisposeObservable!", s);
+    }
+    if (this.detachControl(), this._engine.getInputElement())
+      for (let s = 0; s < this.cameras.length; s++)
+        this.cameras[s].detachControl();
+    this._disposeList(this.animationGroups), this._disposeList(this.lights), this._disposeList(this.meshes, (s) => s.dispose(!0)), this._disposeList(this.transformNodes, (s) => s.dispose(!0));
+    const i = this.cameras;
+    this._disposeList(i), this._defaultMaterial && this._defaultMaterial.dispose(), this._disposeList(this.multiMaterials), this._disposeList(this.materials), this._disposeList(this.particleSystems), this._disposeList(this.postProcesses), this._disposeList(this.textures), this._disposeList(this.morphTargetManagers), this._sceneUbo.dispose(), this._multiviewSceneUbo && this._multiviewSceneUbo.dispose(), this.postProcessManager.dispose(), this._disposeList(this._components);
+    let r = this._engine.scenes.indexOf(this);
+    r > -1 && this._engine.scenes.splice(r, 1), R._LastCreatedScene === this && (this._engine.scenes.length > 0 ? R._LastCreatedScene = this._engine.scenes[this._engine.scenes.length - 1] : R._LastCreatedScene = null), r = this._engine._virtualScenes.indexOf(this), r > -1 && this._engine._virtualScenes.splice(r, 1), this._engine.wipeCaches(!0), this.onDisposeObservable.clear(), this.onBeforeRenderObservable.clear(), this.onAfterRenderObservable.clear(), this.onBeforeRenderTargetsRenderObservable.clear(), this.onAfterRenderTargetsRenderObservable.clear(), this.onAfterStepObservable.clear(), this.onBeforeStepObservable.clear(), this.onBeforeActiveMeshesEvaluationObservable.clear(), this.onAfterActiveMeshesEvaluationObservable.clear(), this.onBeforeParticlesRenderingObservable.clear(), this.onAfterParticlesRenderingObservable.clear(), this.onBeforeDrawPhaseObservable.clear(), this.onAfterDrawPhaseObservable.clear(), this.onBeforeAnimationsObservable.clear(), this.onAfterAnimationsObservable.clear(), this.onDataLoadedObservable.clear(), this.onBeforeRenderingGroupObservable.clear(), this.onAfterRenderingGroupObservable.clear(), this.onMeshImportedObservable.clear(), this.onBeforeCameraRenderObservable.clear(), this.onAfterCameraRenderObservable.clear(), this.onAfterRenderCameraObservable.clear(), this.onReadyObservable.clear(), this.onNewCameraAddedObservable.clear(), this.onCameraRemovedObservable.clear(), this.onNewLightAddedObservable.clear(), this.onLightRemovedObservable.clear(), this.onNewGeometryAddedObservable.clear(), this.onGeometryRemovedObservable.clear(), this.onNewTransformNodeAddedObservable.clear(), this.onTransformNodeRemovedObservable.clear(), this.onNewMeshAddedObservable.clear(), this.onMeshRemovedObservable.clear(), this.onNewSkeletonAddedObservable.clear(), this.onSkeletonRemovedObservable.clear(), this.onNewMaterialAddedObservable.clear(), this.onNewMultiMaterialAddedObservable.clear(), this.onMaterialRemovedObservable.clear(), this.onMultiMaterialRemovedObservable.clear(), this.onNewTextureAddedObservable.clear(), this.onTextureRemovedObservable.clear(), this.onPrePointerObservable.clear(), this.onPointerObservable.clear(), this.onPreKeyboardObservable.clear(), this.onKeyboardObservable.clear(), this.onActiveCameraChanged.clear(), this.onScenePerformancePriorityChangedObservable.clear(), this._isDisposed = !0;
+  }
+  _disposeList(e, t) {
+    const i = e.slice(0);
+    t = t ?? ((r) => r.dispose());
+    for (const r of i)
+      t(r);
+    e.length = 0;
+  }
+  /**
+   * Gets if the scene is already disposed
+   */
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  /**
+   * Call this function to reduce memory footprint of the scene.
+   * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
+   */
+  clearCachedVertexData() {
+    for (let e = 0; e < this.meshes.length; e++) {
+      const i = this.meshes[e].geometry;
+      i && i.clearCachedData();
+    }
+  }
+  /**
+   * This function will remove the local cached buffer data from texture.
+   * It will save memory but will prevent the texture from being rebuilt
+   */
+  cleanCachedTextureBuffer() {
+    for (const e of this.textures)
+      e._buffer && (e._buffer = null);
+  }
+  /**
+   * Get the world extend vectors with an optional filter
+   *
+   * @param filterPredicate the predicate - which meshes should be included when calculating the world size
+   * @returns {{ min: Vector3; max: Vector3 }} min and max vectors
+   */
+  getWorldExtends(e) {
+    const t = new y(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), i = new y(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+    return e = e || (() => !0), this.meshes.filter(e).forEach((r) => {
+      if (r.computeWorldMatrix(!0), !r.subMeshes || r.subMeshes.length === 0 || r.infiniteDistance)
+        return;
+      const s = r.getBoundingInfo(), n = s.boundingBox.minimumWorld, l = s.boundingBox.maximumWorld;
+      y.CheckExtends(n, t, i), y.CheckExtends(l, t, i);
+    }), {
+      min: t,
+      max: i
+    };
+  }
+  // Picking
+  /**
+   * Creates a ray that can be used to pick in the scene
+   * @param x defines the x coordinate of the origin (on-screen)
+   * @param y defines the y coordinate of the origin (on-screen)
+   * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
+   * @param camera defines the camera to use for the picking
+   * @param cameraViewSpace defines if picking will be done in view space (false by default)
+   * @returns a Ray
+   */
+  createPickingRay(e, t, i, r, s = !1) {
+    throw f("Ray");
+  }
+  /**
+   * Creates a ray that can be used to pick in the scene
+   * @param x defines the x coordinate of the origin (on-screen)
+   * @param y defines the y coordinate of the origin (on-screen)
+   * @param world defines the world matrix to use if you want to pick in object space (instead of world space)
+   * @param result defines the ray where to store the picking ray
+   * @param camera defines the camera to use for the picking
+   * @param cameraViewSpace defines if picking will be done in view space (false by default)
+   * @param enableDistantPicking defines if picking should handle large values for mesh position/scaling (false by default)
+   * @returns the current scene
+   */
+  createPickingRayToRef(e, t, i, r, s, n = !1, l = !1) {
+    throw f("Ray");
+  }
+  /**
+   * Creates a ray that can be used to pick in the scene
+   * @param x defines the x coordinate of the origin (on-screen)
+   * @param y defines the y coordinate of the origin (on-screen)
+   * @param camera defines the camera to use for the picking
+   * @returns a Ray
+   */
+  createPickingRayInCameraSpace(e, t, i) {
+    throw f("Ray");
+  }
+  /**
+   * Creates a ray that can be used to pick in the scene
+   * @param x defines the x coordinate of the origin (on-screen)
+   * @param y defines the y coordinate of the origin (on-screen)
+   * @param result defines the ray where to store the picking ray
+   * @param camera defines the camera to use for the picking
+   * @returns the current scene
+   */
+  createPickingRayInCameraSpaceToRef(e, t, i, r) {
+    throw f("Ray");
+  }
+  /** @internal */
+  get _pickingAvailable() {
+    return !1;
+  }
+  /** Launch a ray to try to pick a mesh in the scene
+   * @param x position on screen
+   * @param y position on screen
+   * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+   * @param fastCheck defines if the first intersection will be used (and not the closest)
+   * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+   * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+   * @returns a PickingInfo
+   */
+  pick(e, t, i, r, s, n) {
+    return new I();
+  }
+  /** Launch a ray to try to pick a mesh in the scene using only bounding information of the main mesh (not using submeshes)
+   * @param x position on screen
+   * @param y position on screen
+   * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+   * @param fastCheck defines if the first intersection will be used (and not the closest)
+   * @param camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+   * @returns a PickingInfo (Please note that some info will not be set like distance, bv, bu and everything that cannot be capture by only using bounding infos)
+   */
+  pickWithBoundingInfo(e, t, i, r, s) {
+    return new I();
+  }
+  /**
+   * Use the given ray to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,
+   * irrespective of orientation.
+   * @param ray The ray to use to pick meshes
+   * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must have isPickable set to true
+   * @param fastCheck defines if the first intersection will be used (and not the closest)
+   * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+   * @returns a PickingInfo
+   */
+  pickWithRay(e, t, i, r) {
+    throw f("Ray");
+  }
+  /**
+   * Launch a ray to try to pick a mesh in the scene. A mesh triangle can be picked both from its front and back sides,
+   * irrespective of orientation.
+   * @param x X position on screen
+   * @param y Y position on screen
+   * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+   * @param camera camera to use for computing the picking ray. Can be set to null. In this case, the scene.activeCamera will be used
+   * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+   * @returns an array of PickingInfo
+   */
+  multiPick(e, t, i, r, s) {
+    throw f("Ray");
+  }
+  /**
+   * Launch a ray to try to pick a mesh in the scene
+   * @param ray Ray to use
+   * @param predicate Predicate function used to determine eligible meshes. Can be set to null. In this case, a mesh must be enabled, visible and with isPickable set to true
+   * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+   * @returns an array of PickingInfo
+   */
+  multiPickWithRay(e, t, i) {
+    throw f("Ray");
+  }
+  /**
+   * Force the value of meshUnderPointer
+   * @param mesh defines the mesh to use
+   * @param pointerId optional pointer id when using more than one pointer
+   * @param pickResult optional pickingInfo data used to find mesh
+   */
+  setPointerOverMesh(e, t, i) {
+    this._inputManager.setPointerOverMesh(e, t, i);
+  }
+  /**
+   * Gets the mesh under the pointer
+   * @returns a Mesh or null if no mesh is under the pointer
+   */
+  getPointerOverMesh() {
+    return this._inputManager.getPointerOverMesh();
+  }
+  // Misc.
+  /** @internal */
+  _rebuildGeometries() {
+    for (const e of this.geometries)
+      e._rebuild();
+    for (const e of this.meshes)
+      e._rebuild();
+    this.postProcessManager && this.postProcessManager._rebuild();
+    for (const e of this._components)
+      e.rebuild();
+    for (const e of this.particleSystems)
+      e.rebuild();
+    if (this.spriteManagers)
+      for (const e of this.spriteManagers)
+        e.rebuild();
+  }
+  /** @internal */
+  _rebuildTextures() {
+    for (const e of this.textures)
+      e._rebuild();
+    this.markAllMaterialsAsDirty(1);
+  }
+  // Tags
+  _getByTags(e, t, i) {
+    if (t === void 0)
+      return e;
+    const r = [];
+    i = i || ((s) => {
+    });
+    for (const s in e) {
+      const n = e[s];
+      T && T.MatchesQuery(n, t) && (r.push(n), i(n));
+    }
+    return r;
+  }
+  /**
+   * Get a list of meshes by tags
+   * @param tagsQuery defines the tags query to use
+   * @param forEach defines a predicate used to filter results
+   * @returns an array of Mesh
+   */
+  getMeshesByTags(e, t) {
+    return this._getByTags(this.meshes, e, t);
+  }
+  /**
+   * Get a list of cameras by tags
+   * @param tagsQuery defines the tags query to use
+   * @param forEach defines a predicate used to filter results
+   * @returns an array of Camera
+   */
+  getCamerasByTags(e, t) {
+    return this._getByTags(this.cameras, e, t);
+  }
+  /**
+   * Get a list of lights by tags
+   * @param tagsQuery defines the tags query to use
+   * @param forEach defines a predicate used to filter results
+   * @returns an array of Light
+   */
+  getLightsByTags(e, t) {
+    return this._getByTags(this.lights, e, t);
+  }
+  /**
+   * Get a list of materials by tags
+   * @param tagsQuery defines the tags query to use
+   * @param forEach defines a predicate used to filter results
+   * @returns an array of Material
+   */
+  getMaterialByTags(e, t) {
+    return this._getByTags(this.materials, e, t).concat(this._getByTags(this.multiMaterials, e, t));
+  }
+  /**
+   * Get a list of transform nodes by tags
+   * @param tagsQuery defines the tags query to use
+   * @param forEach defines a predicate used to filter results
+   * @returns an array of TransformNode
+   */
+  getTransformNodesByTags(e, t) {
+    return this._getByTags(this.transformNodes, e, t);
+  }
+  /**
+   * Overrides the default sort function applied in the rendering group to prepare the meshes.
+   * This allowed control for front to back rendering or reversly depending of the special needs.
+   *
+   * @param renderingGroupId The rendering group id corresponding to its index
+   * @param opaqueSortCompareFn The opaque queue comparison function use to sort.
+   * @param alphaTestSortCompareFn The alpha test queue comparison function use to sort.
+   * @param transparentSortCompareFn The transparent queue comparison function use to sort.
+   */
+  setRenderingOrder(e, t = null, i = null, r = null) {
+    this._renderingManager.setRenderingOrder(e, t, i, r);
+  }
+  /**
+   * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
+   *
+   * @param renderingGroupId The rendering group id corresponding to its index
+   * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
+   * @param depth Automatically clears depth between groups if true and autoClear is true.
+   * @param stencil Automatically clears stencil between groups if true and autoClear is true.
+   */
+  setRenderingAutoClearDepthStencil(e, t, i = !0, r = !0) {
+    this._renderingManager.setRenderingAutoClearDepthStencil(e, t, i, r);
+  }
+  /**
+   * Gets the current auto clear configuration for one rendering group of the rendering
+   * manager.
+   * @param index the rendering group index to get the information for
+   * @returns The auto clear setup for the requested rendering group
+   */
+  getAutoClearDepthStencilSetup(e) {
+    return this._renderingManager.getAutoClearDepthStencilSetup(e);
+  }
+  /** Gets or sets a boolean blocking all the calls to markAllMaterialsAsDirty (ie. the materials won't be updated if they are out of sync) */
+  get blockMaterialDirtyMechanism() {
+    return this._blockMaterialDirtyMechanism;
+  }
+  set blockMaterialDirtyMechanism(e) {
+    this._blockMaterialDirtyMechanism !== e && (this._blockMaterialDirtyMechanism = e, e || this.markAllMaterialsAsDirty(63));
+  }
+  /**
+   * Will flag all materials as dirty to trigger new shader compilation
+   * @param flag defines the flag used to specify which material part must be marked as dirty
+   * @param predicate If not null, it will be used to specify if a material has to be marked as dirty
+   */
+  markAllMaterialsAsDirty(e, t) {
+    if (!this._blockMaterialDirtyMechanism)
+      for (const i of this.materials)
+        t && !t(i) || i.markAsDirty(e);
+  }
+  /**
+   * @internal
+   */
+  _loadFile(e, t, i, r, s, n, l) {
+    const a = W(e, t, i, r ? this.offlineProvider : void 0, s, n, l);
+    return this._activeRequests.push(a), a.onCompleteObservable.add((o) => {
+      this._activeRequests.splice(this._activeRequests.indexOf(o), 1);
+    }), a;
+  }
+  /**
+   * @internal
+   */
+  _loadFileAsync(e, t, i, r, s) {
+    return new Promise((n, l) => {
+      this._loadFile(e, (a) => {
+        n(a);
+      }, t, i, r, (a, o) => {
+        l(o);
+      }, s);
+    });
+  }
+  /**
+   * @internal
+   */
+  _requestFile(e, t, i, r, s, n, l) {
+    const a = z(e, t, i, r ? this.offlineProvider : void 0, s, n, l);
+    return this._activeRequests.push(a), a.onCompleteObservable.add((o) => {
+      this._activeRequests.splice(this._activeRequests.indexOf(o), 1);
+    }), a;
+  }
+  /**
+   * @internal
+   */
+  _requestFileAsync(e, t, i, r, s) {
+    return new Promise((n, l) => {
+      this._requestFile(e, (a) => {
+        n(a);
+      }, t, i, r, (a) => {
+        l(a);
+      }, s);
+    });
+  }
+  /**
+   * @internal
+   */
+  _readFile(e, t, i, r, s) {
+    const n = j(e, t, i, r, s);
+    return this._activeRequests.push(n), n.onCompleteObservable.add((l) => {
+      this._activeRequests.splice(this._activeRequests.indexOf(l), 1);
+    }), n;
+  }
+  /**
+   * @internal
+   */
+  _readFileAsync(e, t, i) {
+    return new Promise((r, s) => {
+      this._readFile(e, (n) => {
+        r(n);
+      }, t, i, (n) => {
+        s(n);
+      });
+    });
+  }
+  /**
+   * This method gets the performance collector belonging to the scene, which is generally shared with the inspector.
+   * @returns the perf collector belonging to the scene.
+   */
+  getPerfCollector() {
+    throw f("performanceViewerSceneExtension");
+  }
+  // deprecated
+  /**
+   * Sets the active camera of the scene using its Id
+   * @param id defines the camera's Id
+   * @returns the new active camera or null if none found.
+   * @deprecated Please use setActiveCameraById instead
+   */
+  setActiveCameraByID(e) {
+    return this.setActiveCameraById(e);
+  }
+  /**
+   * Get a material using its id
+   * @param id defines the material's Id
+   * @returns the material or null if none found.
+   * @deprecated Please use getMaterialById instead
+   */
+  getMaterialByID(e) {
+    return this.getMaterialById(e);
+  }
+  /**
+   * Gets a the last added material using a given id
+   * @param id defines the material's Id
+   * @returns the last material with the given id or null if none found.
+   * @deprecated Please use getLastMaterialById instead
+   */
+  getLastMaterialByID(e) {
+    return this.getLastMaterialById(e);
+  }
+  /**
+   * Get a texture using its unique id
+   * @param uniqueId defines the texture's unique id
+   * @returns the texture or null if none found.
+   * @deprecated Please use getTextureByUniqueId instead
+   */
+  getTextureByUniqueID(e) {
+    return this.getTextureByUniqueId(e);
+  }
+  /**
+   * Gets a camera using its Id
+   * @param id defines the Id to look for
+   * @returns the camera or null if not found
+   * @deprecated Please use getCameraById instead
+   */
+  getCameraByID(e) {
+    return this.getCameraById(e);
+  }
+  /**
+   * Gets a camera using its unique Id
+   * @param uniqueId defines the unique Id to look for
+   * @returns the camera or null if not found
+   * @deprecated Please use getCameraByUniqueId instead
+   */
+  getCameraByUniqueID(e) {
+    return this.getCameraByUniqueId(e);
+  }
+  /**
+   * Gets a bone using its Id
+   * @param id defines the bone's Id
+   * @returns the bone or null if not found
+   * @deprecated Please use getBoneById instead
+   */
+  getBoneByID(e) {
+    return this.getBoneById(e);
+  }
+  /**
+   * Gets a light node using its Id
+   * @param id defines the light's Id
+   * @returns the light or null if none found.
+   * @deprecated Please use getLightById instead
+   */
+  getLightByID(e) {
+    return this.getLightById(e);
+  }
+  /**
+   * Gets a light node using its scene-generated unique Id
+   * @param uniqueId defines the light's unique Id
+   * @returns the light or null if none found.
+   * @deprecated Please use getLightByUniqueId instead
+   */
+  getLightByUniqueID(e) {
+    return this.getLightByUniqueId(e);
+  }
+  /**
+   * Gets a particle system by Id
+   * @param id defines the particle system Id
+   * @returns the corresponding system or null if none found
+   * @deprecated Please use getParticleSystemById instead
+   */
+  getParticleSystemByID(e) {
+    return this.getParticleSystemById(e);
+  }
+  /**
+   * Gets a geometry using its Id
+   * @param id defines the geometry's Id
+   * @returns the geometry or null if none found.
+   * @deprecated Please use getGeometryById instead
+   */
+  getGeometryByID(e) {
+    return this.getGeometryById(e);
+  }
+  /**
+   * Gets the first added mesh found of a given Id
+   * @param id defines the Id to search for
+   * @returns the mesh found or null if not found at all
+   * @deprecated Please use getMeshById instead
+   */
+  getMeshByID(e) {
+    return this.getMeshById(e);
+  }
+  /**
+   * Gets a mesh with its auto-generated unique Id
+   * @param uniqueId defines the unique Id to search for
+   * @returns the found mesh or null if not found at all.
+   * @deprecated Please use getMeshByUniqueId instead
+   */
+  getMeshByUniqueID(e) {
+    return this.getMeshByUniqueId(e);
+  }
+  /**
+   * Gets a the last added mesh using a given Id
+   * @param id defines the Id to search for
+   * @returns the found mesh or null if not found at all.
+   * @deprecated Please use getLastMeshById instead
+   */
+  getLastMeshByID(e) {
+    return this.getLastMeshById(e);
+  }
+  /**
+   * Gets a list of meshes using their Id
+   * @param id defines the Id to search for
+   * @returns a list of meshes
+   * @deprecated Please use getMeshesById instead
+   */
+  getMeshesByID(e) {
+    return this.getMeshesById(e);
+  }
+  /**
+   * Gets the first added transform node found of a given Id
+   * @param id defines the Id to search for
+   * @returns the found transform node or null if not found at all.
+   * @deprecated Please use getTransformNodeById instead
+   */
+  getTransformNodeByID(e) {
+    return this.getTransformNodeById(e);
+  }
+  /**
+   * Gets a transform node with its auto-generated unique Id
+   * @param uniqueId defines the unique Id to search for
+   * @returns the found transform node or null if not found at all.
+   * @deprecated Please use getTransformNodeByUniqueId instead
+   */
+  getTransformNodeByUniqueID(e) {
+    return this.getTransformNodeByUniqueId(e);
+  }
+  /**
+   * Gets a list of transform nodes using their Id
+   * @param id defines the Id to search for
+   * @returns a list of transform nodes
+   * @deprecated Please use getTransformNodesById instead
+   */
+  getTransformNodesByID(e) {
+    return this.getTransformNodesById(e);
+  }
+  /**
+   * Gets a node (Mesh, Camera, Light) using a given Id
+   * @param id defines the Id to search for
+   * @returns the found node or null if not found at all
+   * @deprecated Please use getNodeById instead
+   */
+  getNodeByID(e) {
+    return this.getNodeById(e);
+  }
+  /**
+   * Gets a the last added node (Mesh, Camera, Light) using a given Id
+   * @param id defines the Id to search for
+   * @returns the found node or null if not found at all
+   * @deprecated Please use getLastEntryById instead
+   */
+  getLastEntryByID(e) {
+    return this.getLastEntryById(e);
+  }
+  /**
+   * Gets a skeleton using a given Id (if many are found, this function will pick the last one)
+   * @param id defines the Id to search for
+   * @returns the found skeleton or null if not found at all.
+   * @deprecated Please use getLastSkeletonById instead
+   */
+  getLastSkeletonByID(e) {
+    return this.getLastSkeletonById(e);
+  }
+}
+c.FOGMODE_NONE = 0;
+c.FOGMODE_EXP = 1;
+c.FOGMODE_EXP2 = 2;
+c.FOGMODE_LINEAR = 3;
+c.MinDeltaTime = 1;
+c.MaxDeltaTime = 1e3;
+export {
+  c as Scene,
+  M as ScenePerformancePriority
+};