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

package/dist/node_modules/@babylonjs/core/Meshes/abstractMesh.esm.js

@@ -0,0 +1,1448 @@
+import { Observable as O } from "../Misc/observable.esm.js";
+import { ScenePerformancePriority as T } from "../scene.esm.js";
+import { Vector3 as h, Matrix as y, Quaternion as N, TmpVectors as p } from "../Maths/math.vector.esm.js";
+import { Engine as V } from "../Engines/engine.esm.js";
+import { VertexBuffer as m } from "../Buffers/buffer.esm.js";
+import { VertexData as L } from "./mesh.vertexData.esm.js";
+import { TransformNode as A } from "./transformNode.esm.js";
+import { PickingInfo as z } from "../Collisions/pickingInfo.esm.js";
+import { BoundingInfo as R } from "../Culling/boundingInfo.esm.js";
+import { UniformBuffer as U } from "../Materials/uniformBuffer.esm.js";
+import { _MeshCollisionData as W } from "../Collisions/meshCollisionData.esm.js";
+import { _WarnImport as k } from "../Misc/devTools.esm.js";
+import { extractMinAndMax as G } from "../Maths/math.functions.esm.js";
+import { Color3 as w, Color4 as Y } from "../Maths/math.color.esm.js";
+import { Epsilon as x } from "../Maths/math.constants.esm.js";
+import { Axis as Z } from "../Maths/math.axis.esm.js";
+import { RegisterClass as K } from "../Misc/typeStore.esm.js";
+class Q {
+  constructor() {
+    this.facetNb = 0, this.partitioningSubdivisions = 10, this.partitioningBBoxRatio = 1.01, this.facetDataEnabled = !1, this.facetParameters = {}, this.bbSize = h.Zero(), this.subDiv = {
+      // actual number of subdivisions per axis for ComputeNormals()
+      max: 1,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      X: 1,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Y: 1,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      Z: 1
+    }, this.facetDepthSort = !1, this.facetDepthSortEnabled = !1;
+  }
+}
+class X {
+  constructor() {
+    this._hasVertexAlpha = !1, this._useVertexColors = !0, this._numBoneInfluencers = 4, this._applyFog = !0, this._receiveShadows = !1, this._facetData = new Q(), this._visibility = 1, this._skeleton = null, this._layerMask = 268435455, this._computeBonesUsingShaders = !0, this._isActive = !1, this._onlyForInstances = !1, this._isActiveIntermediate = !1, this._onlyForInstancesIntermediate = !1, this._actAsRegularMesh = !1, this._currentLOD = null, this._currentLODIsUpToDate = !1, this._collisionRetryCount = 3, this._morphTargetManager = null, this._renderingGroupId = 0, this._bakedVertexAnimationManager = null, this._material = null, this._positions = null, this._pointerOverDisableMeshTesting = !1, this._meshCollisionData = new W(), this._enableDistantPicking = !1, this._rawBoundingInfo = null;
+  }
+}
+class I extends A {
+  /**
+   * No billboard
+   */
+  static get BILLBOARDMODE_NONE() {
+    return A.BILLBOARDMODE_NONE;
+  }
+  /** Billboard on X axis */
+  static get BILLBOARDMODE_X() {
+    return A.BILLBOARDMODE_X;
+  }
+  /** Billboard on Y axis */
+  static get BILLBOARDMODE_Y() {
+    return A.BILLBOARDMODE_Y;
+  }
+  /** Billboard on Z axis */
+  static get BILLBOARDMODE_Z() {
+    return A.BILLBOARDMODE_Z;
+  }
+  /** Billboard on all axes */
+  static get BILLBOARDMODE_ALL() {
+    return A.BILLBOARDMODE_ALL;
+  }
+  /** Billboard on using position instead of orientation */
+  static get BILLBOARDMODE_USE_POSITION() {
+    return A.BILLBOARDMODE_USE_POSITION;
+  }
+  /**
+   * Gets the number of facets in the mesh
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#what-is-a-mesh-facet
+   */
+  get facetNb() {
+    return this._internalAbstractMeshDataInfo._facetData.facetNb;
+  }
+  /**
+   * Gets or set the number (integer) of subdivisions per axis in the partitioning space
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#tweaking-the-partitioning
+   */
+  get partitioningSubdivisions() {
+    return this._internalAbstractMeshDataInfo._facetData.partitioningSubdivisions;
+  }
+  set partitioningSubdivisions(t) {
+    this._internalAbstractMeshDataInfo._facetData.partitioningSubdivisions = t;
+  }
+  /**
+   * The ratio (float) to apply to the bounding box size to set to the partitioning space.
+   * Ex : 1.01 (default) the partitioning space is 1% bigger than the bounding box
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#tweaking-the-partitioning
+   */
+  get partitioningBBoxRatio() {
+    return this._internalAbstractMeshDataInfo._facetData.partitioningBBoxRatio;
+  }
+  set partitioningBBoxRatio(t) {
+    this._internalAbstractMeshDataInfo._facetData.partitioningBBoxRatio = t;
+  }
+  /**
+   * Gets or sets a boolean indicating that the facets must be depth sorted on next call to `updateFacetData()`.
+   * Works only for updatable meshes.
+   * Doesn't work with multi-materials
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#facet-depth-sort
+   */
+  get mustDepthSortFacets() {
+    return this._internalAbstractMeshDataInfo._facetData.facetDepthSort;
+  }
+  set mustDepthSortFacets(t) {
+    this._internalAbstractMeshDataInfo._facetData.facetDepthSort = t;
+  }
+  /**
+   * The location (Vector3) where the facet depth sort must be computed from.
+   * By default, the active camera position.
+   * Used only when facet depth sort is enabled
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#facet-depth-sort
+   */
+  get facetDepthSortFrom() {
+    return this._internalAbstractMeshDataInfo._facetData.facetDepthSortFrom;
+  }
+  set facetDepthSortFrom(t) {
+    this._internalAbstractMeshDataInfo._facetData.facetDepthSortFrom = t;
+  }
+  /** number of collision detection tries. Change this value if not all collisions are detected and handled properly */
+  get collisionRetryCount() {
+    return this._internalAbstractMeshDataInfo._collisionRetryCount;
+  }
+  set collisionRetryCount(t) {
+    this._internalAbstractMeshDataInfo._collisionRetryCount = t;
+  }
+  /**
+   * gets a boolean indicating if facetData is enabled
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData#what-is-a-mesh-facet
+   */
+  get isFacetDataEnabled() {
+    return this._internalAbstractMeshDataInfo._facetData.facetDataEnabled;
+  }
+  /**
+   * Gets or sets the morph target manager
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/morphTargets
+   */
+  get morphTargetManager() {
+    return this._internalAbstractMeshDataInfo._morphTargetManager;
+  }
+  set morphTargetManager(t) {
+    this._internalAbstractMeshDataInfo._morphTargetManager !== t && (this._internalAbstractMeshDataInfo._morphTargetManager = t, this._syncGeometryWithMorphTargetManager());
+  }
+  /**
+   * Gets or sets the baked vertex animation manager
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/baked_texture_animations
+   */
+  get bakedVertexAnimationManager() {
+    return this._internalAbstractMeshDataInfo._bakedVertexAnimationManager;
+  }
+  set bakedVertexAnimationManager(t) {
+    this._internalAbstractMeshDataInfo._bakedVertexAnimationManager !== t && (this._internalAbstractMeshDataInfo._bakedVertexAnimationManager = t, this._markSubMeshesAsAttributesDirty());
+  }
+  /** @internal */
+  _syncGeometryWithMorphTargetManager() {
+  }
+  /**
+   * @internal
+   */
+  _updateNonUniformScalingState(t) {
+    return super._updateNonUniformScalingState(t) ? (this._markSubMeshesAsMiscDirty(), !0) : !1;
+  }
+  /** @internal */
+  get rawBoundingInfo() {
+    return this._internalAbstractMeshDataInfo._rawBoundingInfo;
+  }
+  set rawBoundingInfo(t) {
+    this._internalAbstractMeshDataInfo._rawBoundingInfo = t;
+  }
+  /** Set a function to call when this mesh collides with another one */
+  set onCollide(t) {
+    this._internalAbstractMeshDataInfo._meshCollisionData._onCollideObserver && this.onCollideObservable.remove(this._internalAbstractMeshDataInfo._meshCollisionData._onCollideObserver), this._internalAbstractMeshDataInfo._meshCollisionData._onCollideObserver = this.onCollideObservable.add(t);
+  }
+  /** Set a function to call when the collision's position changes */
+  set onCollisionPositionChange(t) {
+    this._internalAbstractMeshDataInfo._meshCollisionData._onCollisionPositionChangeObserver && this.onCollisionPositionChangeObservable.remove(this._internalAbstractMeshDataInfo._meshCollisionData._onCollisionPositionChangeObserver), this._internalAbstractMeshDataInfo._meshCollisionData._onCollisionPositionChangeObserver = this.onCollisionPositionChangeObservable.add(t);
+  }
+  /**
+   * Gets or sets mesh visibility between 0 and 1 (default is 1)
+   */
+  get visibility() {
+    return this._internalAbstractMeshDataInfo._visibility;
+  }
+  /**
+   * Gets or sets mesh visibility between 0 and 1 (default is 1)
+   */
+  set visibility(t) {
+    if (this._internalAbstractMeshDataInfo._visibility === t)
+      return;
+    const e = this._internalAbstractMeshDataInfo._visibility;
+    this._internalAbstractMeshDataInfo._visibility = t, (e === 1 && t !== 1 || e !== 1 && t === 1) && this._markSubMeshesAsDirty((i) => {
+      i.markAsMiscDirty(), i.markAsPrePassDirty();
+    });
+  }
+  /**
+   * Gets or sets the property which disables the test that is checking that the mesh under the pointer is the same than the previous time we tested for it (default: false).
+   * Set this property to true if you want thin instances picking to be reported accurately when moving over the mesh.
+   * Note that setting this property to true will incur some performance penalties when dealing with pointer events for this mesh so use it sparingly.
+   */
+  get pointerOverDisableMeshTesting() {
+    return this._internalAbstractMeshDataInfo._pointerOverDisableMeshTesting;
+  }
+  set pointerOverDisableMeshTesting(t) {
+    this._internalAbstractMeshDataInfo._pointerOverDisableMeshTesting = t;
+  }
+  /**
+   * Specifies the rendering group id for this mesh (0 by default)
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/materials/advanced/transparent_rendering#rendering-groups
+   */
+  get renderingGroupId() {
+    return this._internalAbstractMeshDataInfo._renderingGroupId;
+  }
+  set renderingGroupId(t) {
+    this._internalAbstractMeshDataInfo._renderingGroupId = t;
+  }
+  /** Gets or sets current material */
+  get material() {
+    return this._internalAbstractMeshDataInfo._material;
+  }
+  set material(t) {
+    this._internalAbstractMeshDataInfo._material !== t && (this._internalAbstractMeshDataInfo._material && this._internalAbstractMeshDataInfo._material.meshMap && (this._internalAbstractMeshDataInfo._material.meshMap[this.uniqueId] = void 0), this._internalAbstractMeshDataInfo._material = t, t && t.meshMap && (t.meshMap[this.uniqueId] = this), this.onMaterialChangedObservable.hasObservers() && this.onMaterialChangedObservable.notifyObservers(this), this.subMeshes && (this.resetDrawCache(), this._unBindEffect()));
+  }
+  /**
+   * Gets the material used to render the mesh in a specific render pass
+   * @param renderPassId render pass id
+   * @returns material used for the render pass. If no specific material is used for this render pass, undefined is returned (meaning mesh.material is used for this pass)
+   */
+  getMaterialForRenderPass(t) {
+    var e;
+    return (e = this._internalAbstractMeshDataInfo._materialForRenderPass) === null || e === void 0 ? void 0 : e[t];
+  }
+  /**
+   * Sets the material to be used to render the mesh in a specific render pass
+   * @param renderPassId render pass id
+   * @param material material to use for this render pass. If undefined is passed, no specific material will be used for this render pass but the regular material will be used instead (mesh.material)
+   */
+  setMaterialForRenderPass(t, e) {
+    this.resetDrawCache(t), this._internalAbstractMeshDataInfo._materialForRenderPass || (this._internalAbstractMeshDataInfo._materialForRenderPass = []), this._internalAbstractMeshDataInfo._materialForRenderPass[t] = e;
+  }
+  /**
+   * Gets or sets a boolean indicating that this mesh can receive realtime shadows
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/lights/shadows
+   */
+  get receiveShadows() {
+    return this._internalAbstractMeshDataInfo._receiveShadows;
+  }
+  set receiveShadows(t) {
+    this._internalAbstractMeshDataInfo._receiveShadows !== t && (this._internalAbstractMeshDataInfo._receiveShadows = t, this._markSubMeshesAsLightDirty());
+  }
+  /** Gets or sets a boolean indicating that this mesh contains vertex color data with alpha values */
+  get hasVertexAlpha() {
+    return this._internalAbstractMeshDataInfo._hasVertexAlpha;
+  }
+  set hasVertexAlpha(t) {
+    this._internalAbstractMeshDataInfo._hasVertexAlpha !== t && (this._internalAbstractMeshDataInfo._hasVertexAlpha = t, this._markSubMeshesAsAttributesDirty(), this._markSubMeshesAsMiscDirty());
+  }
+  /** Gets or sets a boolean indicating that this mesh needs to use vertex color data to render (if this kind of vertex data is available in the geometry) */
+  get useVertexColors() {
+    return this._internalAbstractMeshDataInfo._useVertexColors;
+  }
+  set useVertexColors(t) {
+    this._internalAbstractMeshDataInfo._useVertexColors !== t && (this._internalAbstractMeshDataInfo._useVertexColors = t, this._markSubMeshesAsAttributesDirty());
+  }
+  /**
+   * Gets or sets a boolean indicating that bone animations must be computed by the GPU (true by default)
+   */
+  get computeBonesUsingShaders() {
+    return this._internalAbstractMeshDataInfo._computeBonesUsingShaders;
+  }
+  set computeBonesUsingShaders(t) {
+    this._internalAbstractMeshDataInfo._computeBonesUsingShaders !== t && (this._internalAbstractMeshDataInfo._computeBonesUsingShaders = t, this._markSubMeshesAsAttributesDirty());
+  }
+  /** Gets or sets the number of allowed bone influences per vertex (4 by default) */
+  get numBoneInfluencers() {
+    return this._internalAbstractMeshDataInfo._numBoneInfluencers;
+  }
+  set numBoneInfluencers(t) {
+    this._internalAbstractMeshDataInfo._numBoneInfluencers !== t && (this._internalAbstractMeshDataInfo._numBoneInfluencers = t, this._markSubMeshesAsAttributesDirty());
+  }
+  /** Gets or sets a boolean indicating that this mesh will allow fog to be rendered on it (true by default) */
+  get applyFog() {
+    return this._internalAbstractMeshDataInfo._applyFog;
+  }
+  set applyFog(t) {
+    this._internalAbstractMeshDataInfo._applyFog !== t && (this._internalAbstractMeshDataInfo._applyFog = t, this._markSubMeshesAsMiscDirty());
+  }
+  /** When enabled, decompose picking matrices for better precision with large values for mesh position and scling */
+  get enableDistantPicking() {
+    return this._internalAbstractMeshDataInfo._enableDistantPicking;
+  }
+  set enableDistantPicking(t) {
+    this._internalAbstractMeshDataInfo._enableDistantPicking = t;
+  }
+  /**
+   * Gets or sets the current layer mask (default is 0x0FFFFFFF)
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/layerMasksAndMultiCam
+   */
+  get layerMask() {
+    return this._internalAbstractMeshDataInfo._layerMask;
+  }
+  set layerMask(t) {
+    t !== this._internalAbstractMeshDataInfo._layerMask && (this._internalAbstractMeshDataInfo._layerMask = t, this._resyncLightSources());
+  }
+  /**
+   * Gets or sets a collision mask used to mask collisions (default is -1).
+   * A collision between A and B will happen if A.collisionGroup & b.collisionMask !== 0
+   */
+  get collisionMask() {
+    return this._internalAbstractMeshDataInfo._meshCollisionData._collisionMask;
+  }
+  set collisionMask(t) {
+    this._internalAbstractMeshDataInfo._meshCollisionData._collisionMask = isNaN(t) ? -1 : t;
+  }
+  /**
+   * Gets or sets a collision response flag (default is true).
+   * when collisionResponse is false, events are still triggered but colliding entity has no response
+   * This helps creating trigger volume when user wants collision feedback events but not position/velocity
+   * to respond to the collision.
+   */
+  get collisionResponse() {
+    return this._internalAbstractMeshDataInfo._meshCollisionData._collisionResponse;
+  }
+  set collisionResponse(t) {
+    this._internalAbstractMeshDataInfo._meshCollisionData._collisionResponse = t;
+  }
+  /**
+   * Gets or sets the current collision group mask (-1 by default).
+   * A collision between A and B will happen if A.collisionGroup & b.collisionMask !== 0
+   */
+  get collisionGroup() {
+    return this._internalAbstractMeshDataInfo._meshCollisionData._collisionGroup;
+  }
+  set collisionGroup(t) {
+    this._internalAbstractMeshDataInfo._meshCollisionData._collisionGroup = isNaN(t) ? -1 : t;
+  }
+  /**
+   * Gets or sets current surrounding meshes (null by default).
+   *
+   * By default collision detection is tested against every mesh in the scene.
+   * It is possible to set surroundingMeshes to a defined list of meshes and then only these specified
+   * meshes will be tested for the collision.
+   *
+   * Note: if set to an empty array no collision will happen when this mesh is moved.
+   */
+  get surroundingMeshes() {
+    return this._internalAbstractMeshDataInfo._meshCollisionData._surroundingMeshes;
+  }
+  set surroundingMeshes(t) {
+    this._internalAbstractMeshDataInfo._meshCollisionData._surroundingMeshes = t;
+  }
+  /** Gets the list of lights affecting that mesh */
+  get lightSources() {
+    return this._lightSources;
+  }
+  /** @internal */
+  get _positions() {
+    return null;
+  }
+  /**
+   * Gets or sets a skeleton to apply skinning transformations
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/bonesSkeletons
+   */
+  set skeleton(t) {
+    const e = this._internalAbstractMeshDataInfo._skeleton;
+    e && e.needInitialSkinMatrix && e._unregisterMeshWithPoseMatrix(this), t && t.needInitialSkinMatrix && t._registerMeshWithPoseMatrix(this), this._internalAbstractMeshDataInfo._skeleton = t, this._internalAbstractMeshDataInfo._skeleton || (this._bonesTransformMatrices = null), this._markSubMeshesAsAttributesDirty();
+  }
+  get skeleton() {
+    return this._internalAbstractMeshDataInfo._skeleton;
+  }
+  // Constructor
+  /**
+   * Creates a new AbstractMesh
+   * @param name defines the name of the mesh
+   * @param scene defines the hosting scene
+   */
+  constructor(t, e = null) {
+    switch (super(t, e, !1), this._internalAbstractMeshDataInfo = new X(), this._waitingMaterialId = null, this.cullingStrategy = I.CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY, this.onCollideObservable = new O(), this.onCollisionPositionChangeObservable = new O(), this.onMaterialChangedObservable = new O(), this.definedFacingForward = !0, this._occlusionQuery = null, this._renderingGroup = null, this.alphaIndex = Number.MAX_VALUE, this.isVisible = !0, this.isPickable = !0, this.isNearPickable = !1, this.isNearGrabbable = !1, this.showSubMeshesBoundingBox = !1, this.isBlocker = !1, this.enablePointerMoveEvents = !1, this.outlineColor = w.Red(), this.outlineWidth = 0.02, this.overlayColor = w.Red(), this.overlayAlpha = 0.5, this.useOctreeForRenderingSelection = !0, this.useOctreeForPicking = !0, this.useOctreeForCollisions = !0, this.alwaysSelectAsActiveMesh = !1, this.doNotSyncBoundingInfo = !1, this.actionManager = null, this.ellipsoid = new h(0.5, 1, 0.5), this.ellipsoidOffset = new h(0, 0, 0), this.edgesWidth = 1, this.edgesColor = new Y(1, 0, 0, 1), this._edgesRenderer = null, this._masterMesh = null, this._boundingInfo = null, this._boundingInfoIsDirty = !0, this._renderId = 0, this._intersectionsInProgress = new Array(), this._unIndexed = !1, this._lightSources = new Array(), this._waitingData = {
+      lods: null,
+      actions: null,
+      freezeWorldMatrix: null
+    }, this._bonesTransformMatrices = null, this._transformMatrixTexture = null, this.onRebuildObservable = new O(), this._onCollisionPositionChange = (i, n, r = null) => {
+      n.subtractToRef(this._internalAbstractMeshDataInfo._meshCollisionData._oldPositionForCollisions, this._internalAbstractMeshDataInfo._meshCollisionData._diffPositionForCollisions), this._internalAbstractMeshDataInfo._meshCollisionData._diffPositionForCollisions.length() > V.CollisionsEpsilon && this.position.addInPlace(this._internalAbstractMeshDataInfo._meshCollisionData._diffPositionForCollisions), r && this.onCollideObservable.notifyObservers(r), this.onCollisionPositionChangeObservable.notifyObservers(this.position);
+    }, e = this.getScene(), e.addMesh(this), this._resyncLightSources(), this._uniformBuffer = new U(this.getScene().getEngine(), void 0, void 0, t, !this.getScene().getEngine().isWebGPU), this._buildUniformLayout(), e.performancePriority) {
+      case T.Aggressive:
+        this.doNotSyncBoundingInfo = !0;
+      case T.Intermediate:
+        this.alwaysSelectAsActiveMesh = !0, this.isPickable = !1;
+        break;
+    }
+  }
+  _buildUniformLayout() {
+    this._uniformBuffer.addUniform("world", 16), this._uniformBuffer.addUniform("visibility", 1), this._uniformBuffer.create();
+  }
+  /**
+   * Transfer the mesh values to its UBO.
+   * @param world The world matrix associated with the mesh
+   */
+  transferToEffect(t) {
+    const e = this._uniformBuffer;
+    e.updateMatrix("world", t), e.updateFloat("visibility", this._internalAbstractMeshDataInfo._visibility), e.update();
+  }
+  /**
+   * Gets the mesh uniform buffer.
+   * @returns the uniform buffer of the mesh.
+   */
+  getMeshUniformBuffer() {
+    return this._uniformBuffer;
+  }
+  /**
+   * Returns the string "AbstractMesh"
+   * @returns "AbstractMesh"
+   */
+  getClassName() {
+    return "AbstractMesh";
+  }
+  /**
+   * Gets a string representation of the current mesh
+   * @param fullDetails defines a boolean indicating if full details must be included
+   * @returns a string representation of the current mesh
+   */
+  toString(t) {
+    let e = "Name: " + this.name + ", isInstance: " + (this.getClassName() !== "InstancedMesh" ? "YES" : "NO");
+    e += ", # of submeshes: " + (this.subMeshes ? this.subMeshes.length : 0);
+    const i = this._internalAbstractMeshDataInfo._skeleton;
+    return i && (e += ", skeleton: " + i.name), t && (e += ", billboard mode: " + ["NONE", "X", "Y", null, "Z", null, null, "ALL"][this.billboardMode], e += ", freeze wrld mat: " + (this._isWorldMatrixFrozen || this._waitingData.freezeWorldMatrix ? "YES" : "NO")), e;
+  }
+  /**
+   * @internal
+   */
+  _getEffectiveParent() {
+    return this._masterMesh && this.billboardMode !== A.BILLBOARDMODE_NONE ? this._masterMesh : super._getEffectiveParent();
+  }
+  /**
+   * @internal
+   */
+  _getActionManagerForTrigger(t, e = !0) {
+    if (this.actionManager && (e || this.actionManager.isRecursive))
+      if (t) {
+        if (this.actionManager.hasSpecificTrigger(t))
+          return this.actionManager;
+      } else
+        return this.actionManager;
+    return this.parent ? this.parent._getActionManagerForTrigger(t, !1) : null;
+  }
+  /**
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _rebuild(t = !1) {
+    if (this.onRebuildObservable.notifyObservers(this), this._occlusionQuery !== null && (this._occlusionQuery = null), !!this.subMeshes)
+      for (const e of this.subMeshes)
+        e._rebuild();
+  }
+  /** @internal */
+  _resyncLightSources() {
+    this._lightSources.length = 0;
+    for (const t of this.getScene().lights)
+      t.isEnabled() && t.canAffectMesh(this) && this._lightSources.push(t);
+    this._markSubMeshesAsLightDirty();
+  }
+  /**
+   * @internal
+   */
+  _resyncLightSource(t) {
+    const e = t.isEnabled() && t.canAffectMesh(this), i = this._lightSources.indexOf(t);
+    let n = !1;
+    if (i === -1) {
+      if (!e)
+        return;
+      this._lightSources.push(t);
+    } else {
+      if (e)
+        return;
+      n = !0, this._lightSources.splice(i, 1);
+    }
+    this._markSubMeshesAsLightDirty(n);
+  }
+  /** @internal */
+  _unBindEffect() {
+    for (const t of this.subMeshes)
+      t.setEffect(null);
+  }
+  /**
+   * @internal
+   */
+  _removeLightSource(t, e) {
+    const i = this._lightSources.indexOf(t);
+    i !== -1 && (this._lightSources.splice(i, 1), this._markSubMeshesAsLightDirty(e));
+  }
+  _markSubMeshesAsDirty(t) {
+    if (this.subMeshes)
+      for (const e of this.subMeshes)
+        for (let i = 0; i < e._drawWrappers.length; ++i) {
+          const n = e._drawWrappers[i];
+          !n || !n.defines || !n.defines.markAllAsDirty || t(n.defines);
+        }
+  }
+  /**
+   * @internal
+   */
+  _markSubMeshesAsLightDirty(t = !1) {
+    this._markSubMeshesAsDirty((e) => e.markAsLightDirty(t));
+  }
+  /** @internal */
+  _markSubMeshesAsAttributesDirty() {
+    this._markSubMeshesAsDirty((t) => t.markAsAttributesDirty());
+  }
+  /** @internal */
+  _markSubMeshesAsMiscDirty() {
+    this._markSubMeshesAsDirty((t) => t.markAsMiscDirty());
+  }
+  /**
+   * Flag the AbstractMesh as dirty (Forcing it to update everything)
+   * @param property if set to "rotation" the objects rotationQuaternion will be set to null
+   * @returns this AbstractMesh
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  markAsDirty(t) {
+    return this._currentRenderId = Number.MAX_VALUE, this._isDirty = !0, this;
+  }
+  /**
+   * Resets the draw wrappers cache for all submeshes of this abstract mesh
+   * @param passId If provided, releases only the draw wrapper corresponding to this render pass id
+   */
+  resetDrawCache(t) {
+    if (this.subMeshes)
+      for (const e of this.subMeshes)
+        e.resetDrawCache(t);
+  }
+  // Methods
+  /**
+   * Returns true if the mesh is blocked. Implemented by child classes
+   */
+  get isBlocked() {
+    return !1;
+  }
+  /**
+   * Returns the mesh itself by default. Implemented by child classes
+   * @param camera defines the camera to use to pick the right LOD level
+   * @returns the currentAbstractMesh
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getLOD(t) {
+    return this;
+  }
+  /**
+   * Returns 0 by default. Implemented by child classes
+   * @returns an integer
+   */
+  getTotalVertices() {
+    return 0;
+  }
+  /**
+   * Returns a positive integer : the total number of indices in this mesh geometry.
+   * @returns the number of indices or zero if the mesh has no geometry.
+   */
+  getTotalIndices() {
+    return 0;
+  }
+  /**
+   * Returns null by default. Implemented by child classes
+   * @returns null
+   */
+  getIndices() {
+    return null;
+  }
+  /**
+   * Returns the array of the requested vertex data kind. Implemented by child classes
+   * @param kind defines the vertex data kind to use
+   * @returns null
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getVerticesData(t) {
+    return null;
+  }
+  /**
+   * Sets the vertex data of the mesh geometry for the requested `kind`.
+   * If the mesh has no geometry, a new Geometry object is set to the mesh and then passed this vertex data.
+   * Note that a new underlying VertexBuffer object is created each call.
+   * If the `kind` is the `PositionKind`, the mesh BoundingInfo is renewed, so the bounding box and sphere, and the mesh World Matrix is recomputed.
+   * @param kind defines vertex data kind:
+   * * VertexBuffer.PositionKind
+   * * VertexBuffer.UVKind
+   * * VertexBuffer.UV2Kind
+   * * VertexBuffer.UV3Kind
+   * * VertexBuffer.UV4Kind
+   * * VertexBuffer.UV5Kind
+   * * VertexBuffer.UV6Kind
+   * * VertexBuffer.ColorKind
+   * * VertexBuffer.MatricesIndicesKind
+   * * VertexBuffer.MatricesIndicesExtraKind
+   * * VertexBuffer.MatricesWeightsKind
+   * * VertexBuffer.MatricesWeightsExtraKind
+   * @param data defines the data source
+   * @param updatable defines if the data must be flagged as updatable (or static)
+   * @param stride defines the vertex stride (size of an entire vertex). Can be null and in this case will be deduced from vertex data kind
+   * @returns the current mesh
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setVerticesData(t, e, i, n) {
+    return this;
+  }
+  /**
+   * Updates the existing vertex data of the mesh geometry for the requested `kind`.
+   * If the mesh has no geometry, it is simply returned as it is.
+   * @param kind defines vertex data kind:
+   * * VertexBuffer.PositionKind
+   * * VertexBuffer.UVKind
+   * * VertexBuffer.UV2Kind
+   * * VertexBuffer.UV3Kind
+   * * VertexBuffer.UV4Kind
+   * * VertexBuffer.UV5Kind
+   * * VertexBuffer.UV6Kind
+   * * VertexBuffer.ColorKind
+   * * VertexBuffer.MatricesIndicesKind
+   * * VertexBuffer.MatricesIndicesExtraKind
+   * * VertexBuffer.MatricesWeightsKind
+   * * VertexBuffer.MatricesWeightsExtraKind
+   * @param data defines the data source
+   * @param updateExtends If `kind` is `PositionKind` and if `updateExtends` is true, the mesh BoundingInfo is renewed, so the bounding box and sphere, and the mesh World Matrix is recomputed
+   * @param makeItUnique If true, a new global geometry is created from this data and is set to the mesh
+   * @returns the current mesh
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  updateVerticesData(t, e, i, n) {
+    return this;
+  }
+  /**
+   * Sets the mesh indices,
+   * If the mesh has no geometry, a new Geometry object is created and set to the mesh.
+   * @param indices Expects an array populated with integers or a typed array (Int32Array, Uint32Array, Uint16Array)
+   * @param totalVertices Defines the total number of vertices
+   * @returns the current mesh
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  setIndices(t, e) {
+    return this;
+  }
+  /**
+   * Gets a boolean indicating if specific vertex data is present
+   * @param kind defines the vertex data kind to use
+   * @returns true is data kind is present
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isVerticesDataPresent(t) {
+    return !1;
+  }
+  /**
+   * Returns the mesh BoundingInfo object or creates a new one and returns if it was undefined.
+   * Note that it returns a shallow bounding of the mesh (i.e. it does not include children).
+   * However, if the mesh contains thin instances, it will be expanded to include them. If you want the "raw" bounding data instead, then use `getRawBoundingInfo()`.
+   * To get the full bounding of all children, call `getHierarchyBoundingVectors` instead.
+   * @returns a BoundingInfo
+   */
+  getBoundingInfo() {
+    return this._masterMesh ? this._masterMesh.getBoundingInfo() : (this._boundingInfoIsDirty && (this._boundingInfoIsDirty = !1, this._updateBoundingInfo()), this._boundingInfo);
+  }
+  /**
+   * Returns the bounding info unnafected by instance data.
+   * @returns the bounding info of the mesh unaffected by instance data.
+   */
+  getRawBoundingInfo() {
+    var t;
+    return (t = this.rawBoundingInfo) !== null && t !== void 0 ? t : this.getBoundingInfo();
+  }
+  /**
+   * Overwrite the current bounding info
+   * @param boundingInfo defines the new bounding info
+   * @returns the current mesh
+   */
+  setBoundingInfo(t) {
+    return this._boundingInfo = t, this;
+  }
+  /**
+   * Returns true if there is already a bounding info
+   */
+  get hasBoundingInfo() {
+    return this._boundingInfo !== null;
+  }
+  /**
+   * Creates a new bounding info for the mesh
+   * @param minimum min vector of the bounding box/sphere
+   * @param maximum max vector of the bounding box/sphere
+   * @param worldMatrix defines the new world matrix
+   * @returns the new bounding info
+   */
+  buildBoundingInfo(t, e, i) {
+    return this._boundingInfo = new R(t, e, i), this._boundingInfo;
+  }
+  /**
+   * Uniformly scales the mesh to fit inside of a unit cube (1 X 1 X 1 units)
+   * @param includeDescendants Use the hierarchy's bounding box instead of the mesh's bounding box. Default is false
+   * @param ignoreRotation ignore rotation when computing the scale (ie. object will be axis aligned). Default is false
+   * @param predicate predicate that is passed in to getHierarchyBoundingVectors when selecting which object should be included when scaling
+   * @returns the current mesh
+   */
+  normalizeToUnitCube(t = !0, e = !1, i) {
+    return super.normalizeToUnitCube(t, e, i);
+  }
+  /** Gets a boolean indicating if this mesh has skinning data and an attached skeleton */
+  get useBones() {
+    return this.skeleton && this.getScene().skeletonsEnabled && this.isVerticesDataPresent(m.MatricesIndicesKind) && this.isVerticesDataPresent(m.MatricesWeightsKind);
+  }
+  /** @internal */
+  _preActivate() {
+  }
+  /**
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _preActivateForIntermediateRendering(t) {
+  }
+  /**
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _activate(t, e) {
+    return this._renderId = t, !0;
+  }
+  /** @internal */
+  _postActivate() {
+  }
+  /** @internal */
+  _freeze() {
+  }
+  /** @internal */
+  _unFreeze() {
+  }
+  /**
+   * Gets the current world matrix
+   * @returns a Matrix
+   */
+  getWorldMatrix() {
+    return this._masterMesh && this.billboardMode === A.BILLBOARDMODE_NONE ? this._masterMesh.getWorldMatrix() : super.getWorldMatrix();
+  }
+  /** @internal */
+  _getWorldMatrixDeterminant() {
+    return this._masterMesh ? this._masterMesh._getWorldMatrixDeterminant() : super._getWorldMatrixDeterminant();
+  }
+  /**
+   * Gets a boolean indicating if this mesh is an instance or a regular mesh
+   */
+  get isAnInstance() {
+    return !1;
+  }
+  /**
+   * Gets a boolean indicating if this mesh has instances
+   */
+  get hasInstances() {
+    return !1;
+  }
+  /**
+   * Gets a boolean indicating if this mesh has thin instances
+   */
+  get hasThinInstances() {
+    return !1;
+  }
+  // ================================== Point of View Movement =================================
+  /**
+   * Perform relative position change from the point of view of behind the front of the mesh.
+   * This is performed taking into account the meshes current rotation, so you do not have to care.
+   * Supports definition of mesh facing forward or backward {@link definedFacingForwardSearch | See definedFacingForwardSearch }.
+   * @param amountRight defines the distance on the right axis
+   * @param amountUp defines the distance on the up axis
+   * @param amountForward defines the distance on the forward axis
+   * @returns the current mesh
+   */
+  movePOV(t, e, i) {
+    return this.position.addInPlace(this.calcMovePOV(t, e, i)), this;
+  }
+  /**
+   * Calculate relative position change from the point of view of behind the front of the mesh.
+   * This is performed taking into account the meshes current rotation, so you do not have to care.
+   * Supports definition of mesh facing forward or backward {@link definedFacingForwardSearch | See definedFacingForwardSearch }.
+   * @param amountRight defines the distance on the right axis
+   * @param amountUp defines the distance on the up axis
+   * @param amountForward defines the distance on the forward axis
+   * @returns the new displacement vector
+   */
+  calcMovePOV(t, e, i) {
+    const n = new y();
+    (this.rotationQuaternion ? this.rotationQuaternion : N.RotationYawPitchRoll(this.rotation.y, this.rotation.x, this.rotation.z)).toRotationMatrix(n);
+    const a = h.Zero(), s = this.definedFacingForward ? -1 : 1;
+    return h.TransformCoordinatesFromFloatsToRef(t * s, e, i * s, n, a), a;
+  }
+  // ================================== Point of View Rotation =================================
+  /**
+   * Perform relative rotation change from the point of view of behind the front of the mesh.
+   * Supports definition of mesh facing forward or backward {@link definedFacingForwardSearch | See definedFacingForwardSearch }.
+   * @param flipBack defines the flip
+   * @param twirlClockwise defines the twirl
+   * @param tiltRight defines the tilt
+   * @returns the current mesh
+   */
+  rotatePOV(t, e, i) {
+    return this.rotation.addInPlace(this.calcRotatePOV(t, e, i)), this;
+  }
+  /**
+   * Calculate relative rotation change from the point of view of behind the front of the mesh.
+   * Supports definition of mesh facing forward or backward {@link definedFacingForwardSearch | See definedFacingForwardSearch }.
+   * @param flipBack defines the flip
+   * @param twirlClockwise defines the twirl
+   * @param tiltRight defines the tilt
+   * @returns the new rotation vector
+   */
+  calcRotatePOV(t, e, i) {
+    const n = this.definedFacingForward ? 1 : -1;
+    return new h(t * n, e, i * n);
+  }
+  /**
+   * This method recomputes and sets a new BoundingInfo to the mesh unless it is locked.
+   * This means the mesh underlying bounding box and sphere are recomputed.
+   * @param applySkeleton defines whether to apply the skeleton before computing the bounding info
+   * @param applyMorph  defines whether to apply the morph target before computing the bounding info
+   * @returns the current mesh
+   */
+  refreshBoundingInfo(t = !1, e = !1) {
+    return this._boundingInfo && this._boundingInfo.isLocked ? this : (this._refreshBoundingInfo(this._getPositionData(t, e), null), this);
+  }
+  /**
+   * @internal
+   */
+  _refreshBoundingInfo(t, e) {
+    if (t) {
+      const i = G(t, 0, this.getTotalVertices(), e);
+      this._boundingInfo ? this._boundingInfo.reConstruct(i.minimum, i.maximum) : this._boundingInfo = new R(i.minimum, i.maximum);
+    }
+    if (this.subMeshes)
+      for (let i = 0; i < this.subMeshes.length; i++)
+        this.subMeshes[i].refreshBoundingInfo(t);
+    this._updateBoundingInfo();
+  }
+  /**
+   * Internal function to get buffer data and possibly apply morphs and normals
+   * @param applySkeleton
+   * @param applyMorph
+   * @param data
+   * @param kind the kind of data you want. Can be Normal or Position
+   */
+  _getData(t = !1, e = !1, i, n = m.PositionKind) {
+    if (i = i ?? this.getVerticesData(n).slice(), i && e && this.morphTargetManager) {
+      let r = 0, a = 0;
+      for (let s = 0; s < i.length; s++) {
+        for (let o = 0; o < this.morphTargetManager.numTargets; o++) {
+          const f = this.morphTargetManager.getTarget(o), d = f.influence;
+          if (d > 0) {
+            const l = f.getPositions();
+            l && (i[s] += (l[s] - i[s]) * d);
+          }
+        }
+        if (r++, n === m.PositionKind && this._positions && r === 3) {
+          r = 0;
+          const o = a * 3;
+          this._positions[a++].copyFromFloats(i[o], i[o + 1], i[o + 2]);
+        }
+      }
+    }
+    if (i && t && this.skeleton) {
+      const r = this.getVerticesData(m.MatricesIndicesKind), a = this.getVerticesData(m.MatricesWeightsKind);
+      if (a && r) {
+        const s = this.numBoneInfluencers > 4, o = s ? this.getVerticesData(m.MatricesIndicesExtraKind) : null, f = s ? this.getVerticesData(m.MatricesWeightsExtraKind) : null, d = this.skeleton.getTransformMatrices(this), l = p.Vector3[0], _ = p.Matrix[0], M = p.Matrix[1];
+        let D = 0;
+        for (let c = 0; c < i.length; c += 3, D += 4) {
+          _.reset();
+          let g, u;
+          for (g = 0; g < 4; g++)
+            u = a[D + g], u > 0 && (y.FromFloat32ArrayToRefScaled(d, Math.floor(r[D + g] * 16), u, M), _.addToSelf(M));
+          if (s)
+            for (g = 0; g < 4; g++)
+              u = f[D + g], u > 0 && (y.FromFloat32ArrayToRefScaled(d, Math.floor(o[D + g] * 16), u, M), _.addToSelf(M));
+          n === m.NormalKind ? h.TransformNormalFromFloatsToRef(i[c], i[c + 1], i[c + 2], _, l) : h.TransformCoordinatesFromFloatsToRef(i[c], i[c + 1], i[c + 2], _, l), l.toArray(i, c), n === m.PositionKind && this._positions && this._positions[c / 3].copyFrom(l);
+        }
+      }
+    }
+    return i;
+  }
+  /**
+   * Get the normals vertex data and optionally apply skeleton and morphing.
+   * @param applySkeleton defines whether to apply the skeleton
+   * @param applyMorph  defines whether to apply the morph target
+   * @returns the normals data
+   */
+  getNormalsData(t = !1, e = !1) {
+    return this._getData(t, e, null, m.NormalKind);
+  }
+  /**
+   * Get the position vertex data and optionally apply skeleton and morphing.
+   * @param applySkeleton defines whether to apply the skeleton
+   * @param applyMorph  defines whether to apply the morph target
+   * @param data defines the position data to apply the skeleton and morph to
+   * @returns the position data
+   */
+  getPositionData(t = !1, e = !1, i) {
+    return this._getData(t, e, i, m.PositionKind);
+  }
+  /**
+   * @internal
+   */
+  _getPositionData(t, e) {
+    var i;
+    let n = this.getVerticesData(m.PositionKind);
+    if (this._internalAbstractMeshDataInfo._positions && (this._internalAbstractMeshDataInfo._positions = null), n && (t && this.skeleton || e && this.morphTargetManager)) {
+      if (n = n.slice(), this._generatePointsArray(), this._positions) {
+        const r = this._positions;
+        this._internalAbstractMeshDataInfo._positions = new Array(r.length);
+        for (let a = 0; a < r.length; a++)
+          this._internalAbstractMeshDataInfo._positions[a] = ((i = r[a]) === null || i === void 0 ? void 0 : i.clone()) || new h();
+      }
+      return this.getPositionData(t, e, n);
+    }
+    return n;
+  }
+  /** @internal */
+  _updateBoundingInfo() {
+    return this._boundingInfo ? this._boundingInfo.update(this.worldMatrixFromCache) : this._boundingInfo = new R(h.Zero(), h.Zero(), this.worldMatrixFromCache), this._updateSubMeshesBoundingInfo(this.worldMatrixFromCache), this;
+  }
+  /**
+   * @internal
+   */
+  _updateSubMeshesBoundingInfo(t) {
+    if (!this.subMeshes)
+      return this;
+    const e = this.subMeshes.length;
+    for (let i = 0; i < e; i++) {
+      const n = this.subMeshes[i];
+      (e > 1 || !n.IsGlobal) && n.updateBoundingInfo(t);
+    }
+    return this;
+  }
+  /** @internal */
+  _afterComputeWorldMatrix() {
+    this.doNotSyncBoundingInfo || (this._boundingInfoIsDirty = !0);
+  }
+  /**
+   * Returns `true` if the mesh is within the frustum defined by the passed array of planes.
+   * A mesh is in the frustum if its bounding box intersects the frustum
+   * @param frustumPlanes defines the frustum to test
+   * @returns true if the mesh is in the frustum planes
+   */
+  isInFrustum(t) {
+    return this.getBoundingInfo().isInFrustum(t, this.cullingStrategy);
+  }
+  /**
+   * Returns `true` if the mesh is completely in the frustum defined be the passed array of planes.
+   * A mesh is completely in the frustum if its bounding box it completely inside the frustum.
+   * @param frustumPlanes defines the frustum to test
+   * @returns true if the mesh is completely in the frustum planes
+   */
+  isCompletelyInFrustum(t) {
+    return this.getBoundingInfo().isCompletelyInFrustum(t);
+  }
+  /**
+   * True if the mesh intersects another mesh or a SolidParticle object
+   * @param mesh defines a target mesh or SolidParticle to test
+   * @param precise Unless the parameter `precise` is set to `true` the intersection is computed according to Axis Aligned Bounding Boxes (AABB), else according to OBB (Oriented BBoxes)
+   * @param includeDescendants Can be set to true to test if the mesh defined in parameters intersects with the current mesh or any child meshes
+   * @returns true if there is an intersection
+   */
+  intersectsMesh(t, e = !1, i) {
+    const n = this.getBoundingInfo(), r = t.getBoundingInfo();
+    if (n.intersects(r, e))
+      return !0;
+    if (i) {
+      for (const a of this.getChildMeshes())
+        if (a.intersectsMesh(t, e, !0))
+          return !0;
+    }
+    return !1;
+  }
+  /**
+   * Returns true if the passed point (Vector3) is inside the mesh bounding box
+   * @param point defines the point to test
+   * @returns true if there is an intersection
+   */
+  intersectsPoint(t) {
+    return this.getBoundingInfo().intersectsPoint(t);
+  }
+  // Collisions
+  /**
+   * Gets or sets a boolean indicating that this mesh can be used in the collision engine
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions
+   */
+  get checkCollisions() {
+    return this._internalAbstractMeshDataInfo._meshCollisionData._checkCollisions;
+  }
+  set checkCollisions(t) {
+    this._internalAbstractMeshDataInfo._meshCollisionData._checkCollisions = t;
+  }
+  /**
+   * Gets Collider object used to compute collisions (not physics)
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions
+   */
+  get collider() {
+    return this._internalAbstractMeshDataInfo._meshCollisionData._collider;
+  }
+  /**
+   * Move the mesh using collision engine
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/cameras/camera_collisions
+   * @param displacement defines the requested displacement vector
+   * @returns the current mesh
+   */
+  moveWithCollisions(t) {
+    this.getAbsolutePosition().addToRef(this.ellipsoidOffset, this._internalAbstractMeshDataInfo._meshCollisionData._oldPositionForCollisions);
+    const i = this.getScene().collisionCoordinator;
+    return this._internalAbstractMeshDataInfo._meshCollisionData._collider || (this._internalAbstractMeshDataInfo._meshCollisionData._collider = i.createCollider()), this._internalAbstractMeshDataInfo._meshCollisionData._collider._radius = this.ellipsoid, i.getNewPosition(this._internalAbstractMeshDataInfo._meshCollisionData._oldPositionForCollisions, t, this._internalAbstractMeshDataInfo._meshCollisionData._collider, this.collisionRetryCount, this, this._onCollisionPositionChange, this.uniqueId), this;
+  }
+  // Collisions
+  /**
+   * @internal
+   */
+  _collideForSubMesh(t, e, i) {
+    var n;
+    if (this._generatePointsArray(), !this._positions)
+      return this;
+    if (!t._lastColliderWorldVertices || !t._lastColliderTransformMatrix.equals(e)) {
+      t._lastColliderTransformMatrix = e.clone(), t._lastColliderWorldVertices = [], t._trianglePlanes = [];
+      const r = t.verticesStart, a = t.verticesStart + t.verticesCount;
+      for (let s = r; s < a; s++)
+        t._lastColliderWorldVertices.push(h.TransformCoordinates(this._positions[s], e));
+    }
+    return i._collide(t._trianglePlanes, t._lastColliderWorldVertices, this.getIndices(), t.indexStart, t.indexStart + t.indexCount, t.verticesStart, !!t.getMaterial(), this, this._shouldConvertRHS(), ((n = t.getMaterial()) === null || n === void 0 ? void 0 : n.fillMode) === 7), this;
+  }
+  /**
+   * @internal
+   */
+  _processCollisionsForSubMeshes(t, e) {
+    const i = this._scene.getCollidingSubMeshCandidates(this, t), n = i.length;
+    for (let r = 0; r < n; r++) {
+      const a = i.data[r];
+      n > 1 && !a._checkCollision(t) || this._collideForSubMesh(a, e, t);
+    }
+    return this;
+  }
+  /** @internal */
+  _shouldConvertRHS() {
+    return !1;
+  }
+  /**
+   * @internal
+   */
+  _checkCollision(t) {
+    if (!this.getBoundingInfo()._checkCollision(t))
+      return this;
+    const e = p.Matrix[0], i = p.Matrix[1];
+    return y.ScalingToRef(1 / t._radius.x, 1 / t._radius.y, 1 / t._radius.z, e), this.worldMatrixFromCache.multiplyToRef(e, i), this._processCollisionsForSubMeshes(t, i), this;
+  }
+  // Picking
+  /** @internal */
+  _generatePointsArray() {
+    return !1;
+  }
+  /**
+   * Checks if the passed Ray intersects with the mesh. A mesh triangle can be picked both from its front and back sides,
+   * irrespective of orientation.
+   * @param ray defines the ray to use. It should be in the mesh's LOCAL coordinate space.
+   * @param fastCheck defines if fast mode (but less precise) must be used (false by default)
+   * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+   * @param onlyBoundingInfo defines a boolean indicating if picking should only happen using bounding info (false by default)
+   * @param worldToUse defines the world matrix to use to get the world coordinate of the intersection point
+   * @param skipBoundingInfo a boolean indicating if we should skip the bounding info check
+   * @returns the picking info
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/interactions/mesh_intersect
+   */
+  intersects(t, e, i, n = !1, r, a = !1) {
+    const s = new z(), o = this.getClassName(), f = o === "InstancedLinesMesh" || o === "LinesMesh" || o === "GreasedLineMesh" ? this.intersectionThreshold : 0, d = this.getBoundingInfo();
+    if (!this.subMeshes || !a && (!t.intersectsSphere(d.boundingSphere, f) || !t.intersectsBox(d.boundingBox, f)))
+      return s;
+    if (n)
+      return s.hit = !a, s.pickedMesh = a ? null : this, s.distance = a ? 0 : h.Distance(t.origin, d.boundingSphere.center), s.subMeshId = 0, s;
+    if (!this._generatePointsArray())
+      return s;
+    let l = null;
+    const _ = this._scene.getIntersectingSubMeshCandidates(this, t), M = _.length;
+    let D = !1;
+    for (let c = 0; c < M; c++) {
+      const u = _.data[c].getMaterial();
+      if (u && (u.fillMode == 7 || u.fillMode == 0 || u.fillMode == 1 || u.fillMode == 2 || u.fillMode == 4)) {
+        D = !0;
+        break;
+      }
+    }
+    if (!D)
+      return s.hit = !0, s.pickedMesh = this, s.distance = h.Distance(t.origin, d.boundingSphere.center), s.subMeshId = -1, s;
+    for (let c = 0; c < M; c++) {
+      const g = _.data[c];
+      if (M > 1 && !g.canIntersects(t))
+        continue;
+      const u = g.intersects(t, this._positions, this.getIndices(), e, i);
+      if (u && (e || !l || u.distance < l.distance) && (l = u, l.subMeshId = c, e))
+        break;
+    }
+    if (l) {
+      const c = r ?? this.getWorldMatrix(), g = p.Vector3[0], u = p.Vector3[1];
+      h.TransformCoordinatesToRef(t.origin, c, g), t.direction.scaleToRef(l.distance, u);
+      const C = h.TransformNormal(u, c).addInPlace(g);
+      return s.hit = !0, s.distance = h.Distance(g, C), s.pickedPoint = C, s.pickedMesh = this, s.bu = l.bu || 0, s.bv = l.bv || 0, s.subMeshFaceId = l.faceId, s.faceId = l.faceId + _.data[l.subMeshId].indexStart / (this.getClassName().indexOf("LinesMesh") !== -1 ? 2 : 3), s.subMeshId = l.subMeshId, s;
+    }
+    return s;
+  }
+  /**
+   * Clones the current mesh
+   * @param name defines the mesh name
+   * @param newParent defines the new mesh parent
+   * @param doNotCloneChildren defines a boolean indicating that children must not be cloned (false by default)
+   * @returns the new mesh
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  clone(t, e, i) {
+    return null;
+  }
+  /**
+   * Disposes all the submeshes of the current meshnp
+   * @returns the current mesh
+   */
+  releaseSubMeshes() {
+    if (this.subMeshes)
+      for (; this.subMeshes.length; )
+        this.subMeshes[0].dispose();
+    else
+      this.subMeshes = new Array();
+    return this;
+  }
+  /**
+   * Releases resources associated with this abstract mesh.
+   * @param doNotRecurse Set to true to not recurse into each children (recurse into each children by default)
+   * @param disposeMaterialAndTextures Set to true to also dispose referenced materials and textures (false by default)
+   */
+  dispose(t, e = !1) {
+    let i;
+    for (this._scene.useMaterialMeshMap && this._internalAbstractMeshDataInfo._material && this._internalAbstractMeshDataInfo._material.meshMap && (this._internalAbstractMeshDataInfo._material.meshMap[this.uniqueId] = void 0), this.getScene().freeActiveMeshes(), this.getScene().freeRenderingGroups(), this.actionManager !== void 0 && this.actionManager !== null && (this.actionManager.dispose(), this.actionManager = null), this._internalAbstractMeshDataInfo._skeleton = null, this._transformMatrixTexture && (this._transformMatrixTexture.dispose(), this._transformMatrixTexture = null), i = 0; i < this._intersectionsInProgress.length; i++) {
+      const a = this._intersectionsInProgress[i], s = a._intersectionsInProgress.indexOf(this);
+      a._intersectionsInProgress.splice(s, 1);
+    }
+    this._intersectionsInProgress.length = 0, this.getScene().lights.forEach((a) => {
+      let s = a.includedOnlyMeshes.indexOf(this);
+      s !== -1 && a.includedOnlyMeshes.splice(s, 1), s = a.excludedMeshes.indexOf(this), s !== -1 && a.excludedMeshes.splice(s, 1);
+      const o = a.getShadowGenerators();
+      if (o) {
+        const f = o.values();
+        for (let d = f.next(); d.done !== !0; d = f.next()) {
+          const _ = d.value.getShadowMap();
+          _ && _.renderList && (s = _.renderList.indexOf(this), s !== -1 && _.renderList.splice(s, 1));
+        }
+      }
+    }), (this.getClassName() !== "InstancedMesh" || this.getClassName() !== "InstancedLinesMesh") && this.releaseSubMeshes();
+    const r = this.getScene().getEngine();
+    if (this._occlusionQuery !== null && (this.isOcclusionQueryInProgress = !1, r.deleteQuery(this._occlusionQuery), this._occlusionQuery = null), r.wipeCaches(), this.getScene().removeMesh(this), this._parentContainer) {
+      const a = this._parentContainer.meshes.indexOf(this);
+      a > -1 && this._parentContainer.meshes.splice(a, 1), this._parentContainer = null;
+    }
+    if (e && this.material && (this.material.getClassName() === "MultiMaterial" ? this.material.dispose(!1, !0, !0) : this.material.dispose(!1, !0)), !t)
+      for (i = 0; i < this.getScene().particleSystems.length; i++)
+        this.getScene().particleSystems[i].emitter === this && (this.getScene().particleSystems[i].dispose(), i--);
+    this._internalAbstractMeshDataInfo._facetData.facetDataEnabled && this.disableFacetData(), this._uniformBuffer.dispose(), this.onAfterWorldMatrixUpdateObservable.clear(), this.onCollideObservable.clear(), this.onCollisionPositionChangeObservable.clear(), this.onRebuildObservable.clear(), super.dispose(t, e);
+  }
+  /**
+   * Adds the passed mesh as a child to the current mesh
+   * @param mesh defines the child mesh
+   * @param preserveScalingSign if true, keep scaling sign of child. Otherwise, scaling sign might change.
+   * @returns the current mesh
+   */
+  addChild(t, e = !1) {
+    return t.setParent(this, e), this;
+  }
+  /**
+   * Removes the passed mesh from the current mesh children list
+   * @param mesh defines the child mesh
+   * @param preserveScalingSign if true, keep scaling sign of child. Otherwise, scaling sign might change.
+   * @returns the current mesh
+   */
+  removeChild(t, e = !1) {
+    return t.setParent(null, e), this;
+  }
+  // Facet data
+  /** @internal */
+  _initFacetData() {
+    const t = this._internalAbstractMeshDataInfo._facetData;
+    t.facetNormals || (t.facetNormals = new Array()), t.facetPositions || (t.facetPositions = new Array()), t.facetPartitioning || (t.facetPartitioning = new Array()), t.facetNb = this.getIndices().length / 3 | 0, t.partitioningSubdivisions = t.partitioningSubdivisions ? t.partitioningSubdivisions : 10, t.partitioningBBoxRatio = t.partitioningBBoxRatio ? t.partitioningBBoxRatio : 1.01;
+    for (let e = 0; e < t.facetNb; e++)
+      t.facetNormals[e] = h.Zero(), t.facetPositions[e] = h.Zero();
+    return t.facetDataEnabled = !0, this;
+  }
+  /**
+   * Updates the mesh facetData arrays and the internal partitioning when the mesh is morphed or updated.
+   * This method can be called within the render loop.
+   * You don't need to call this method by yourself in the render loop when you update/morph a mesh with the methods CreateXXX() as they automatically manage this computation
+   * @returns the current mesh
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  updateFacetData() {
+    const t = this._internalAbstractMeshDataInfo._facetData;
+    t.facetDataEnabled || this._initFacetData();
+    const e = this.getVerticesData(m.PositionKind), i = this.getIndices(), n = this.getVerticesData(m.NormalKind), r = this.getBoundingInfo();
+    if (t.facetDepthSort && !t.facetDepthSortEnabled) {
+      if (t.facetDepthSortEnabled = !0, i instanceof Uint16Array)
+        t.depthSortedIndices = new Uint16Array(i);
+      else if (i instanceof Uint32Array)
+        t.depthSortedIndices = new Uint32Array(i);
+      else {
+        let s = !1;
+        for (let o = 0; o < i.length; o++)
+          if (i[o] > 65535) {
+            s = !0;
+            break;
+          }
+        s ? t.depthSortedIndices = new Uint32Array(i) : t.depthSortedIndices = new Uint16Array(i);
+      }
+      if (t.facetDepthSortFunction = function(s, o) {
+        return o.sqDistance - s.sqDistance;
+      }, !t.facetDepthSortFrom) {
+        const s = this.getScene().activeCamera;
+        t.facetDepthSortFrom = s ? s.position : h.Zero();
+      }
+      t.depthSortedFacets = [];
+      for (let s = 0; s < t.facetNb; s++) {
+        const o = { ind: s * 3, sqDistance: 0 };
+        t.depthSortedFacets.push(o);
+      }
+      t.invertedMatrix = y.Identity(), t.facetDepthSortOrigin = h.Zero();
+    }
+    t.bbSize.x = r.maximum.x - r.minimum.x > x ? r.maximum.x - r.minimum.x : x, t.bbSize.y = r.maximum.y - r.minimum.y > x ? r.maximum.y - r.minimum.y : x, t.bbSize.z = r.maximum.z - r.minimum.z > x ? r.maximum.z - r.minimum.z : x;
+    let a = t.bbSize.x > t.bbSize.y ? t.bbSize.x : t.bbSize.y;
+    if (a = a > t.bbSize.z ? a : t.bbSize.z, t.subDiv.max = t.partitioningSubdivisions, t.subDiv.X = Math.floor(t.subDiv.max * t.bbSize.x / a), t.subDiv.Y = Math.floor(t.subDiv.max * t.bbSize.y / a), t.subDiv.Z = Math.floor(t.subDiv.max * t.bbSize.z / a), t.subDiv.X = t.subDiv.X < 1 ? 1 : t.subDiv.X, t.subDiv.Y = t.subDiv.Y < 1 ? 1 : t.subDiv.Y, t.subDiv.Z = t.subDiv.Z < 1 ? 1 : t.subDiv.Z, t.facetParameters.facetNormals = this.getFacetLocalNormals(), t.facetParameters.facetPositions = this.getFacetLocalPositions(), t.facetParameters.facetPartitioning = this.getFacetLocalPartitioning(), t.facetParameters.bInfo = r, t.facetParameters.bbSize = t.bbSize, t.facetParameters.subDiv = t.subDiv, t.facetParameters.ratio = this.partitioningBBoxRatio, t.facetParameters.depthSort = t.facetDepthSort, t.facetDepthSort && t.facetDepthSortEnabled && (this.computeWorldMatrix(!0), this._worldMatrix.invertToRef(t.invertedMatrix), h.TransformCoordinatesToRef(t.facetDepthSortFrom, t.invertedMatrix, t.facetDepthSortOrigin), t.facetParameters.distanceTo = t.facetDepthSortOrigin), t.facetParameters.depthSortedFacets = t.depthSortedFacets, n && L.ComputeNormals(e, i, n, t.facetParameters), t.facetDepthSort && t.facetDepthSortEnabled) {
+      t.depthSortedFacets.sort(t.facetDepthSortFunction);
+      const s = t.depthSortedIndices.length / 3 | 0;
+      for (let o = 0; o < s; o++) {
+        const f = t.depthSortedFacets[o].ind;
+        t.depthSortedIndices[o * 3] = i[f], t.depthSortedIndices[o * 3 + 1] = i[f + 1], t.depthSortedIndices[o * 3 + 2] = i[f + 2];
+      }
+      this.updateIndices(t.depthSortedIndices, void 0, !0);
+    }
+    return this;
+  }
+  /**
+   * Returns the facetLocalNormals array.
+   * The normals are expressed in the mesh local spac
+   * @returns an array of Vector3
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetLocalNormals() {
+    const t = this._internalAbstractMeshDataInfo._facetData;
+    return t.facetNormals || this.updateFacetData(), t.facetNormals;
+  }
+  /**
+   * Returns the facetLocalPositions array.
+   * The facet positions are expressed in the mesh local space
+   * @returns an array of Vector3
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetLocalPositions() {
+    const t = this._internalAbstractMeshDataInfo._facetData;
+    return t.facetPositions || this.updateFacetData(), t.facetPositions;
+  }
+  /**
+   * Returns the facetLocalPartitioning array
+   * @returns an array of array of numbers
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetLocalPartitioning() {
+    const t = this._internalAbstractMeshDataInfo._facetData;
+    return t.facetPartitioning || this.updateFacetData(), t.facetPartitioning;
+  }
+  /**
+   * Returns the i-th facet position in the world system.
+   * This method allocates a new Vector3 per call
+   * @param i defines the facet index
+   * @returns a new Vector3
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetPosition(t) {
+    const e = h.Zero();
+    return this.getFacetPositionToRef(t, e), e;
+  }
+  /**
+   * Sets the reference Vector3 with the i-th facet position in the world system
+   * @param i defines the facet index
+   * @param ref defines the target vector
+   * @returns the current mesh
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetPositionToRef(t, e) {
+    const i = this.getFacetLocalPositions()[t], n = this.getWorldMatrix();
+    return h.TransformCoordinatesToRef(i, n, e), this;
+  }
+  /**
+   * Returns the i-th facet normal in the world system.
+   * This method allocates a new Vector3 per call
+   * @param i defines the facet index
+   * @returns a new Vector3
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetNormal(t) {
+    const e = h.Zero();
+    return this.getFacetNormalToRef(t, e), e;
+  }
+  /**
+   * Sets the reference Vector3 with the i-th facet normal in the world system
+   * @param i defines the facet index
+   * @param ref defines the target vector
+   * @returns the current mesh
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetNormalToRef(t, e) {
+    const i = this.getFacetLocalNormals()[t];
+    return h.TransformNormalToRef(i, this.getWorldMatrix(), e), this;
+  }
+  /**
+   * Returns the facets (in an array) in the same partitioning block than the one the passed coordinates are located (expressed in the mesh local system)
+   * @param x defines x coordinate
+   * @param y defines y coordinate
+   * @param z defines z coordinate
+   * @returns the array of facet indexes
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetsAtLocalCoordinates(t, e, i) {
+    const n = this.getBoundingInfo(), r = this._internalAbstractMeshDataInfo._facetData, a = Math.floor((t - n.minimum.x * r.partitioningBBoxRatio) * r.subDiv.X * r.partitioningBBoxRatio / r.bbSize.x), s = Math.floor((e - n.minimum.y * r.partitioningBBoxRatio) * r.subDiv.Y * r.partitioningBBoxRatio / r.bbSize.y), o = Math.floor((i - n.minimum.z * r.partitioningBBoxRatio) * r.subDiv.Z * r.partitioningBBoxRatio / r.bbSize.z);
+    return a < 0 || a > r.subDiv.max || s < 0 || s > r.subDiv.max || o < 0 || o > r.subDiv.max ? null : r.facetPartitioning[a + r.subDiv.max * s + r.subDiv.max * r.subDiv.max * o];
+  }
+  /**
+   * Returns the closest mesh facet index at (x,y,z) World coordinates, null if not found
+   * @param x defines x coordinate
+   * @param y defines y coordinate
+   * @param z defines z coordinate
+   * @param projected sets as the (x,y,z) world projection on the facet
+   * @param checkFace if true (default false), only the facet "facing" to (x,y,z) or only the ones "turning their backs", according to the parameter "facing" are returned
+   * @param facing if facing and checkFace are true, only the facet "facing" to (x, y, z) are returned : positive dot (x, y, z) * facet position. If facing si false and checkFace is true, only the facet "turning their backs" to (x, y, z) are returned : negative dot (x, y, z) * facet position
+   * @returns the face index if found (or null instead)
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getClosestFacetAtCoordinates(t, e, i, n, r = !1, a = !0) {
+    const s = this.getWorldMatrix(), o = p.Matrix[5];
+    s.invertToRef(o);
+    const f = p.Vector3[8];
+    h.TransformCoordinatesFromFloatsToRef(t, e, i, o, f);
+    const d = this.getClosestFacetAtLocalCoordinates(f.x, f.y, f.z, n, r, a);
+    return n && h.TransformCoordinatesFromFloatsToRef(n.x, n.y, n.z, s, n), d;
+  }
+  /**
+   * Returns the closest mesh facet index at (x,y,z) local coordinates, null if not found
+   * @param x defines x coordinate
+   * @param y defines y coordinate
+   * @param z defines z coordinate
+   * @param projected sets as the (x,y,z) local projection on the facet
+   * @param checkFace if true (default false), only the facet "facing" to (x,y,z) or only the ones "turning their backs", according to the parameter "facing" are returned
+   * @param facing if facing and checkFace are true, only the facet "facing" to (x, y, z) are returned : positive dot (x, y, z) * facet position. If facing si false and checkFace is true, only the facet "turning their backs" to (x, y, z) are returned : negative dot (x, y, z) * facet position
+   * @returns the face index if found (or null instead)
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getClosestFacetAtLocalCoordinates(t, e, i, n, r = !1, a = !0) {
+    let s = null, o = 0, f = 0, d = 0, l = 0, _ = 0, M = 0, D = 0, c = 0;
+    const g = this.getFacetLocalPositions(), u = this.getFacetLocalNormals(), P = this.getFacetsAtLocalCoordinates(t, e, i);
+    if (!P)
+      return null;
+    let C = Number.MAX_VALUE, v = C, B, b, S;
+    for (let F = 0; F < P.length; F++)
+      B = P[F], b = u[B], S = g[B], l = (t - S.x) * b.x + (e - S.y) * b.y + (i - S.z) * b.z, (!r || r && a && l >= 0 || r && !a && l <= 0) && (l = b.x * S.x + b.y * S.y + b.z * S.z, _ = -(b.x * t + b.y * e + b.z * i - l) / (b.x * b.x + b.y * b.y + b.z * b.z), M = t + b.x * _, D = e + b.y * _, c = i + b.z * _, o = M - t, f = D - e, d = c - i, v = o * o + f * f + d * d, v < C && (C = v, s = B, n && (n.x = M, n.y = D, n.z = c)));
+    return s;
+  }
+  /**
+   * Returns the object "parameter" set with all the expected parameters for facetData computation by ComputeNormals()
+   * @returns the parameters
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  getFacetDataParameters() {
+    return this._internalAbstractMeshDataInfo._facetData.facetParameters;
+  }
+  /**
+   * Disables the feature FacetData and frees the related memory
+   * @returns the current mesh
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/facetData
+   */
+  disableFacetData() {
+    const t = this._internalAbstractMeshDataInfo._facetData;
+    return t.facetDataEnabled && (t.facetDataEnabled = !1, t.facetPositions = new Array(), t.facetNormals = new Array(), t.facetPartitioning = new Array(), t.facetParameters = null, t.depthSortedIndices = new Uint32Array(0)), this;
+  }
+  /**
+   * Updates the AbstractMesh indices array
+   * @param indices defines the data source
+   * @param offset defines the offset in the index buffer where to store the new data (can be null)
+   * @param gpuMemoryOnly defines a boolean indicating that only the GPU memory must be updated leaving the CPU version of the indices unchanged (false by default)
+   * @returns the current mesh
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  updateIndices(t, e, i = !1) {
+    return this;
+  }
+  /**
+   * Creates new normals data for the mesh
+   * @param updatable defines if the normal vertex buffer must be flagged as updatable
+   * @returns the current mesh
+   */
+  createNormals(t) {
+    const e = this.getVerticesData(m.PositionKind), i = this.getIndices();
+    let n;
+    return this.isVerticesDataPresent(m.NormalKind) ? n = this.getVerticesData(m.NormalKind) : n = [], L.ComputeNormals(e, i, n, { useRightHandedSystem: this.getScene().useRightHandedSystem }), this.setVerticesData(m.NormalKind, n, t), this;
+  }
+  /**
+   * Align the mesh with a normal
+   * @param normal defines the normal to use
+   * @param upDirection can be used to redefined the up vector to use (will use the (0, 1, 0) by default)
+   * @returns the current mesh
+   */
+  alignWithNormal(t, e) {
+    e || (e = Z.Y);
+    const i = p.Vector3[0], n = p.Vector3[1];
+    return h.CrossToRef(e, t, n), h.CrossToRef(t, n, i), this.rotationQuaternion ? N.RotationQuaternionFromAxisToRef(i, t, n, this.rotationQuaternion) : h.RotationFromAxisToRef(i, t, n, this.rotation), this;
+  }
+  /** @internal */
+  _checkOcclusionQuery() {
+    return !1;
+  }
+  /**
+   * Disables the mesh edge rendering mode
+   * @returns the currentAbstractMesh
+   */
+  disableEdgesRendering() {
+    throw k("EdgesRenderer");
+  }
+  /**
+   * Enables the edge rendering mode on the mesh.
+   * This mode makes the mesh edges visible
+   * @param epsilon defines the maximal distance between two angles to detect a face
+   * @param checkVerticesInsteadOfIndices indicates that we should check vertex list directly instead of faces
+   * @param options options to the edge renderer
+   * @returns the currentAbstractMesh
+   * @see https://www.babylonjs-playground.com/#19O9TU#0
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  enableEdgesRendering(t, e, i) {
+    throw k("EdgesRenderer");
+  }
+  /**
+   * This function returns all of the particle systems in the scene that use the mesh as an emitter.
+   * @returns an array of particle systems in the scene that use the mesh as an emitter
+   */
+  getConnectedParticleSystems() {
+    return this._scene.particleSystems.filter((t) => t.emitter === this);
+  }
+}
+I.OCCLUSION_TYPE_NONE = 0;
+I.OCCLUSION_TYPE_OPTIMISTIC = 1;
+I.OCCLUSION_TYPE_STRICT = 2;
+I.OCCLUSION_ALGORITHM_TYPE_ACCURATE = 0;
+I.OCCLUSION_ALGORITHM_TYPE_CONSERVATIVE = 1;
+I.CULLINGSTRATEGY_STANDARD = 0;
+I.CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY = 1;
+I.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION = 2;
+I.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY = 3;
+K("BABYLON.AbstractMesh", I);
+export {
+  I as AbstractMesh
+};