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

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

@@ -1,729 +0,0 @@
-import { Vector3 as D } from "../Maths/math.vector.esm.js";
-import { Color4 as y } from "../Maths/math.color.esm.js";
-import { VertexData as V } from "./mesh.vertexData.esm.js";
-import { VertexBuffer as n } from "../Buffers/buffer.esm.js";
-import { SubMesh as A } from "./subMesh.esm.js";
-import { SceneLoaderFlags as p } from "../Loading/sceneLoaderFlags.esm.js";
-import { BoundingInfo as v } from "../Culling/boundingInfo.esm.js";
-import { Tools as m } from "../Misc/tools.esm.js";
-import { Tags as b } from "../Misc/tags.esm.js";
-import { extractMinAndMax as B } from "../Maths/math.functions.esm.js";
-import { EngineStore as U } from "../Engines/engineStore.esm.js";
-import { CompatibilityOptions as x } from "../Compat/compatibilityOptions.esm.js";
-class I {
-  /**
-   *  Gets or sets the Bias Vector to apply on the bounding elements (box/sphere), the max extend is computed as v += v * bias.x + bias.y, the min is computed as v -= v * bias.x + bias.y
-   */
-  get boundingBias() {
-    return this._boundingBias;
-  }
-  /**
-   *  Gets or sets the Bias Vector to apply on the bounding elements (box/sphere), the max extend is computed as v += v * bias.x + bias.y, the min is computed as v -= v * bias.x + bias.y
-   */
-  set boundingBias(t) {
-    this._boundingBias ? this._boundingBias.copyFrom(t) : this._boundingBias = t.clone(), this._updateBoundingInfo(!0, null);
-  }
-  /**
-   * Static function used to attach a new empty geometry to a mesh
-   * @param mesh defines the mesh to attach the geometry to
-   * @returns the new Geometry
-   */
-  static CreateGeometryForMesh(t) {
-    const e = new I(I.RandomId(), t.getScene());
-    return e.applyToMesh(t), e;
-  }
-  /** Get the list of meshes using this geometry */
-  get meshes() {
-    return this._meshes;
-  }
-  /**
-   * Creates a new geometry
-   * @param id defines the unique ID
-   * @param scene defines the hosting scene
-   * @param vertexData defines the VertexData used to get geometry data
-   * @param updatable defines if geometry must be updatable (false by default)
-   * @param mesh defines the mesh that will be associated with the geometry
-   */
-  constructor(t, e, a, s = !1, c = null) {
-    this.delayLoadState = 0, this._totalVertices = 0, this._isDisposed = !1, this._indexBufferIsUpdatable = !1, this._positionsCache = [], this._parentContainer = null, this.useBoundingInfoFromGeometry = !1, this._scene = e || U.LastCreatedScene, this._scene && (this.id = t, this.uniqueId = this._scene.getUniqueId(), this._engine = this._scene.getEngine(), this._meshes = [], this._vertexBuffers = {}, this._indices = [], this._updatable = s, a ? this.setAllVerticesData(a, s) : this._totalVertices = 0, this._engine.getCaps().vertexArrayObject && (this._vertexArrayObjects = {}), c && (this.applyToMesh(c), c.computeWorldMatrix(!0)));
-  }
-  /**
-   * Gets the current extend of the geometry
-   */
-  get extend() {
-    return this._extend;
-  }
-  /**
-   * Gets the hosting scene
-   * @returns the hosting Scene
-   */
-  getScene() {
-    return this._scene;
-  }
-  /**
-   * Gets the hosting engine
-   * @returns the hosting Engine
-   */
-  getEngine() {
-    return this._engine;
-  }
-  /**
-   * Defines if the geometry is ready to use
-   * @returns true if the geometry is ready to be used
-   */
-  isReady() {
-    return this.delayLoadState === 1 || this.delayLoadState === 0;
-  }
-  /**
-   * Gets a value indicating that the geometry should not be serialized
-   */
-  get doNotSerialize() {
-    for (let t = 0; t < this._meshes.length; t++)
-      if (!this._meshes[t].doNotSerialize)
-        return !1;
-    return !0;
-  }
-  /** @internal */
-  _rebuild() {
-    this._vertexArrayObjects && (this._vertexArrayObjects = {}), this._meshes.length !== 0 && this._indices && (this._indexBuffer = this._engine.createIndexBuffer(this._indices, this._updatable));
-    for (const t in this._vertexBuffers)
-      this._vertexBuffers[t]._rebuild();
-  }
-  /**
-   * Affects all geometry data in one call
-   * @param vertexData defines the geometry data
-   * @param updatable defines if the geometry must be flagged as updatable (false as default)
-   */
-  setAllVerticesData(t, e) {
-    t.applyToGeometry(this, e), this._notifyUpdate();
-  }
-  /**
-   * Set specific vertex data
-   * @param kind defines the data kind (Position, normal, etc...)
-   * @param data defines the vertex data to use
-   * @param updatable defines if the vertex must be flagged as updatable (false as default)
-   * @param stride defines the stride to use (0 by default). This value is deduced from the kind value if not specified
-   */
-  setVerticesData(t, e, a = !1, s) {
-    a && Array.isArray(e) && (e = new Float32Array(e));
-    const c = new n(this._engine, e, t, a, this._meshes.length === 0, s);
-    this.setVerticesBuffer(c);
-  }
-  /**
-   * Removes a specific vertex data
-   * @param kind defines the data kind (Position, normal, etc...)
-   */
-  removeVerticesData(t) {
-    this._vertexBuffers[t] && (this._vertexBuffers[t].dispose(), delete this._vertexBuffers[t]), this._vertexArrayObjects && this._disposeVertexArrayObjects();
-  }
-  /**
-   * Affect a vertex buffer to the geometry. the vertexBuffer.getKind() function is used to determine where to store the data
-   * @param buffer defines the vertex buffer to use
-   * @param totalVertices defines the total number of vertices for position kind (could be null)
-   * @param disposeExistingBuffer disposes the existing buffer, if any (default: true)
-   */
-  setVerticesBuffer(t, e = null, a = !0) {
-    const s = t.getKind();
-    this._vertexBuffers[s] && a && this._vertexBuffers[s].dispose(), t._buffer && t._buffer._increaseReferences(), this._vertexBuffers[s] = t;
-    const c = this._meshes, i = c.length;
-    if (s === n.PositionKind) {
-      const r = t.getData();
-      e != null ? this._totalVertices = e : r != null && (this._totalVertices = r.length / (t.type === n.BYTE ? t.byteStride : t.byteStride / 4)), this._updateExtend(r), this._resetPointsArrayCache();
-      for (let o = 0; o < i; o++) {
-        const f = c[o];
-        f.buildBoundingInfo(this._extend.minimum, this._extend.maximum), f._createGlobalSubMesh(f.isUnIndexed), f.computeWorldMatrix(!0), f.synchronizeInstances();
-      }
-    }
-    this._notifyUpdate(s);
-  }
-  /**
-   * Update a specific vertex buffer
-   * This function will directly update the underlying DataBuffer according to the passed numeric array or Float32Array
-   * It will do nothing if the buffer is not updatable
-   * @param kind defines the data kind (Position, normal, etc...)
-   * @param data defines the data to use
-   * @param offset defines the offset in the target buffer where to store the data
-   * @param useBytes set to true if the offset is in bytes
-   */
-  updateVerticesDataDirectly(t, e, a, s = !1) {
-    const c = this.getVertexBuffer(t);
-    c && (c.updateDirectly(e, a, s), this._notifyUpdate(t));
-  }
-  /**
-   * Update a specific vertex buffer
-   * This function will create a new buffer if the current one is not updatable
-   * @param kind defines the data kind (Position, normal, etc...)
-   * @param data defines the data to use
-   * @param updateExtends defines if the geometry extends must be recomputed (false by default)
-   */
-  updateVerticesData(t, e, a = !1) {
-    const s = this.getVertexBuffer(t);
-    s && (s.update(e), t === n.PositionKind && this._updateBoundingInfo(a, e), this._notifyUpdate(t));
-  }
-  _updateBoundingInfo(t, e) {
-    if (t && this._updateExtend(e), this._resetPointsArrayCache(), t) {
-      const a = this._meshes;
-      for (const s of a) {
-        s.hasBoundingInfo ? s.getBoundingInfo().reConstruct(this._extend.minimum, this._extend.maximum) : s.buildBoundingInfo(this._extend.minimum, this._extend.maximum);
-        const c = s.subMeshes;
-        for (const i of c)
-          i.refreshBoundingInfo();
-      }
-    }
-  }
-  /**
-   * @internal
-   */
-  _bind(t, e, a, s) {
-    if (!t)
-      return;
-    e === void 0 && (e = this._indexBuffer);
-    const c = this.getVertexBuffers();
-    if (!c)
-      return;
-    if (e != this._indexBuffer || !this._vertexArrayObjects && !s) {
-      this._engine.bindBuffers(c, e, t, a);
-      return;
-    }
-    const i = s || this._vertexArrayObjects;
-    i[t.key] || (i[t.key] = this._engine.recordVertexArrayObject(c, e, t, a)), this._engine.bindVertexArrayObject(i[t.key], e);
-  }
-  /**
-   * Gets total number of vertices
-   * @returns the total number of vertices
-   */
-  getTotalVertices() {
-    return this.isReady() ? this._totalVertices : 0;
-  }
-  /**
-   * Gets a specific vertex data attached to this geometry. Float data is constructed if the vertex buffer data cannot be returned directly.
-   * @param kind defines the data kind (Position, normal, etc...)
-   * @param copyWhenShared defines if the returned array must be cloned upon returning it if the current geometry is shared between multiple meshes
-   * @param forceCopy defines a boolean indicating that the returned array must be cloned upon returning it
-   * @returns a float array containing vertex data
-   */
-  getVerticesData(t, e, a) {
-    const s = this.getVertexBuffer(t);
-    return s ? s.getFloatData(this._totalVertices, a || e && this._meshes.length !== 1) : null;
-  }
-  /**
-   * Returns a boolean defining if the vertex data for the requested `kind` is updatable
-   * @param kind defines the data kind (Position, normal, etc...)
-   * @returns true if the vertex buffer with the specified kind is updatable
-   */
-  isVertexBufferUpdatable(t) {
-    const e = this._vertexBuffers[t];
-    return e ? e.isUpdatable() : !1;
-  }
-  /**
-   * Gets a specific vertex buffer
-   * @param kind defines the data kind (Position, normal, etc...)
-   * @returns a VertexBuffer
-   */
-  getVertexBuffer(t) {
-    return this.isReady() ? this._vertexBuffers[t] : null;
-  }
-  /**
-   * Returns all vertex buffers
-   * @returns an object holding all vertex buffers indexed by kind
-   */
-  getVertexBuffers() {
-    return this.isReady() ? this._vertexBuffers : null;
-  }
-  /**
-   * Gets a boolean indicating if specific vertex buffer is present
-   * @param kind defines the data kind (Position, normal, etc...)
-   * @returns true if data is present
-   */
-  isVerticesDataPresent(t) {
-    return this._vertexBuffers ? this._vertexBuffers[t] !== void 0 : this._delayInfo ? this._delayInfo.indexOf(t) !== -1 : !1;
-  }
-  /**
-   * Gets a list of all attached data kinds (Position, normal, etc...)
-   * @returns a list of string containing all kinds
-   */
-  getVerticesDataKinds() {
-    const t = [];
-    let e;
-    if (!this._vertexBuffers && this._delayInfo)
-      for (e in this._delayInfo)
-        t.push(e);
-    else
-      for (e in this._vertexBuffers)
-        t.push(e);
-    return t;
-  }
-  /**
-   * Update index buffer
-   * @param indices defines the indices to store in the index buffer
-   * @param offset defines the offset in the target buffer where to store the data
-   * @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)
-   */
-  updateIndices(t, e, a = !1) {
-    if (this._indexBuffer)
-      if (!this._indexBufferIsUpdatable)
-        this.setIndices(t, null, !0);
-      else {
-        const s = t.length !== this._indices.length;
-        if (a || (this._indices = t.slice()), this._engine.updateDynamicIndexBuffer(this._indexBuffer, t, e), s)
-          for (const c of this._meshes)
-            c._createGlobalSubMesh(!0);
-      }
-  }
-  /**
-   * Creates a new index buffer
-   * @param indices defines the indices to store in the index buffer
-   * @param totalVertices defines the total number of vertices (could be null)
-   * @param updatable defines if the index buffer must be flagged as updatable (false by default)
-   */
-  setIndices(t, e = null, a = !1) {
-    this._indexBuffer && this._engine._releaseBuffer(this._indexBuffer), this._indices = t, this._indexBufferIsUpdatable = a, this._meshes.length !== 0 && this._indices && (this._indexBuffer = this._engine.createIndexBuffer(this._indices, a)), e != null && (this._totalVertices = e);
-    for (const s of this._meshes)
-      s._createGlobalSubMesh(!0), s.synchronizeInstances();
-    this._notifyUpdate();
-  }
-  /**
-   * Return the total number of indices
-   * @returns the total number of indices
-   */
-  getTotalIndices() {
-    return this.isReady() ? this._indices.length : 0;
-  }
-  /**
-   * Gets the index buffer array
-   * @param copyWhenShared defines if the returned array must be cloned upon returning it if the current geometry is shared between multiple meshes
-   * @param forceCopy defines a boolean indicating that the returned array must be cloned upon returning it
-   * @returns the index buffer array
-   */
-  getIndices(t, e) {
-    if (!this.isReady())
-      return null;
-    const a = this._indices;
-    return !e && (!t || this._meshes.length === 1) ? a : a.slice();
-  }
-  /**
-   * Gets the index buffer
-   * @returns the index buffer
-   */
-  getIndexBuffer() {
-    return this.isReady() ? this._indexBuffer : null;
-  }
-  /**
-   * @internal
-   */
-  _releaseVertexArrayObject(t = null) {
-    !t || !this._vertexArrayObjects || this._vertexArrayObjects[t.key] && (this._engine.releaseVertexArrayObject(this._vertexArrayObjects[t.key]), delete this._vertexArrayObjects[t.key]);
-  }
-  /**
-   * Release the associated resources for a specific mesh
-   * @param mesh defines the source mesh
-   * @param shouldDispose defines if the geometry must be disposed if there is no more mesh pointing to it
-   */
-  releaseForMesh(t, e) {
-    const a = this._meshes, s = a.indexOf(t);
-    s !== -1 && (a.splice(s, 1), this._vertexArrayObjects && t._invalidateInstanceVertexArrayObject(), t._geometry = null, a.length === 0 && e && this.dispose());
-  }
-  /**
-   * Apply current geometry to a given mesh
-   * @param mesh defines the mesh to apply geometry to
-   */
-  applyToMesh(t) {
-    if (t._geometry === this)
-      return;
-    const e = t._geometry;
-    e && e.releaseForMesh(t), this._vertexArrayObjects && t._invalidateInstanceVertexArrayObject();
-    const a = this._meshes;
-    t._geometry = this, t._internalAbstractMeshDataInfo._positions = null, this._scene.pushGeometry(this), a.push(t), this.isReady() ? this._applyToMesh(t) : this._boundingInfo && t.setBoundingInfo(this._boundingInfo);
-  }
-  _updateExtend(t = null) {
-    if (this.useBoundingInfoFromGeometry && this._boundingInfo)
-      this._extend = {
-        minimum: this._boundingInfo.minimum.clone(),
-        maximum: this._boundingInfo.maximum.clone()
-      };
-    else {
-      if (!t && (t = this.getVerticesData(n.PositionKind), !t))
-        return;
-      this._extend = B(t, 0, this._totalVertices, this.boundingBias, 3);
-    }
-  }
-  _applyToMesh(t) {
-    const e = this._meshes.length;
-    for (const a in this._vertexBuffers)
-      e === 1 && this._vertexBuffers[a].create(), a === n.PositionKind && (this._extend || this._updateExtend(), t.buildBoundingInfo(this._extend.minimum, this._extend.maximum), t._createGlobalSubMesh(t.isUnIndexed), t._updateBoundingInfo());
-    e === 1 && this._indices && this._indices.length > 0 && (this._indexBuffer = this._engine.createIndexBuffer(this._indices, this._updatable)), t._syncGeometryWithMorphTargetManager(), t.synchronizeInstances();
-  }
-  _notifyUpdate(t) {
-    this.onGeometryUpdated && this.onGeometryUpdated(this, t), this._vertexArrayObjects && this._disposeVertexArrayObjects();
-    for (const e of this._meshes)
-      e._markSubMeshesAsAttributesDirty();
-  }
-  /**
-   * Load the geometry if it was flagged as delay loaded
-   * @param scene defines the hosting scene
-   * @param onLoaded defines a callback called when the geometry is loaded
-   */
-  load(t, e) {
-    if (this.delayLoadState !== 2) {
-      if (this.isReady()) {
-        e && e();
-        return;
-      }
-      this.delayLoadState = 2, this._queueLoad(t, e);
-    }
-  }
-  _queueLoad(t, e) {
-    this.delayLoadingFile && (t.addPendingData(this), t._loadFile(this.delayLoadingFile, (a) => {
-      if (!this._delayLoadingFunction)
-        return;
-      this._delayLoadingFunction(JSON.parse(a), this), this.delayLoadState = 1, this._delayInfo = [], t.removePendingData(this);
-      const s = this._meshes, c = s.length;
-      for (let i = 0; i < c; i++)
-        this._applyToMesh(s[i]);
-      e && e();
-    }, void 0, !0));
-  }
-  /**
-   * Invert the geometry to move from a right handed system to a left handed one.
-   */
-  toLeftHanded() {
-    const t = this.getIndices(!1);
-    if (t != null && t.length > 0) {
-      for (let s = 0; s < t.length; s += 3) {
-        const c = t[s + 0];
-        t[s + 0] = t[s + 2], t[s + 2] = c;
-      }
-      this.setIndices(t);
-    }
-    const e = this.getVerticesData(n.PositionKind, !1);
-    if (e != null && e.length > 0) {
-      for (let s = 0; s < e.length; s += 3)
-        e[s + 2] = -e[s + 2];
-      this.setVerticesData(n.PositionKind, e, !1);
-    }
-    const a = this.getVerticesData(n.NormalKind, !1);
-    if (a != null && a.length > 0) {
-      for (let s = 0; s < a.length; s += 3)
-        a[s + 2] = -a[s + 2];
-      this.setVerticesData(n.NormalKind, a, !1);
-    }
-  }
-  // Cache
-  /** @internal */
-  _resetPointsArrayCache() {
-    this._positions = null;
-  }
-  /** @internal */
-  _generatePointsArray() {
-    if (this._positions)
-      return !0;
-    const t = this.getVerticesData(n.PositionKind);
-    if (!t || t.length === 0)
-      return !1;
-    for (let e = this._positionsCache.length * 3, a = this._positionsCache.length; e < t.length; e += 3, ++a)
-      this._positionsCache[a] = D.FromArray(t, e);
-    for (let e = 0, a = 0; e < t.length; e += 3, ++a)
-      this._positionsCache[a].set(t[0 + e], t[1 + e], t[2 + e]);
-    return this._positionsCache.length = t.length / 3, this._positions = this._positionsCache, !0;
-  }
-  /**
-   * Gets a value indicating if the geometry is disposed
-   * @returns true if the geometry was disposed
-   */
-  isDisposed() {
-    return this._isDisposed;
-  }
-  _disposeVertexArrayObjects() {
-    if (this._vertexArrayObjects) {
-      for (const a in this._vertexArrayObjects)
-        this._engine.releaseVertexArrayObject(this._vertexArrayObjects[a]);
-      this._vertexArrayObjects = {};
-      const t = this._meshes, e = t.length;
-      for (let a = 0; a < e; a++)
-        t[a]._invalidateInstanceVertexArrayObject();
-    }
-  }
-  /**
-   * Free all associated resources
-   */
-  dispose() {
-    const t = this._meshes, e = t.length;
-    let a;
-    for (a = 0; a < e; a++)
-      this.releaseForMesh(t[a]);
-    this._meshes.length = 0, this._disposeVertexArrayObjects();
-    for (const s in this._vertexBuffers)
-      this._vertexBuffers[s].dispose();
-    if (this._vertexBuffers = {}, this._totalVertices = 0, this._indexBuffer && this._engine._releaseBuffer(this._indexBuffer), this._indexBuffer = null, this._indices = [], this.delayLoadState = 0, this.delayLoadingFile = null, this._delayLoadingFunction = null, this._delayInfo = [], this._boundingInfo = null, this._scene.removeGeometry(this), this._parentContainer) {
-      const s = this._parentContainer.geometries.indexOf(this);
-      s > -1 && this._parentContainer.geometries.splice(s, 1), this._parentContainer = null;
-    }
-    this._isDisposed = !0;
-  }
-  /**
-   * Clone the current geometry into a new geometry
-   * @param id defines the unique ID of the new geometry
-   * @returns a new geometry object
-   */
-  copy(t) {
-    const e = new V();
-    e.indices = [];
-    const a = this.getIndices();
-    if (a)
-      for (let o = 0; o < a.length; o++)
-        e.indices.push(a[o]);
-    let s = !1, c = !1, i;
-    for (i in this._vertexBuffers) {
-      const o = this.getVerticesData(i);
-      if (o && (o instanceof Float32Array ? e.set(new Float32Array(o), i) : e.set(o.slice(0), i), !c)) {
-        const f = this.getVertexBuffer(i);
-        f && (s = f.isUpdatable(), c = !s);
-      }
-    }
-    const r = new I(t, this._scene, e, s);
-    r.delayLoadState = this.delayLoadState, r.delayLoadingFile = this.delayLoadingFile, r._delayLoadingFunction = this._delayLoadingFunction;
-    for (i in this._delayInfo)
-      r._delayInfo = r._delayInfo || [], r._delayInfo.push(i);
-    return r._boundingInfo = new v(this._extend.minimum, this._extend.maximum), r;
-  }
-  /**
-   * Serialize the current geometry info (and not the vertices data) into a JSON object
-   * @returns a JSON representation of the current geometry data (without the vertices data)
-   */
-  serialize() {
-    const t = {};
-    return t.id = this.id, t.uniqueId = this.uniqueId, t.updatable = this._updatable, b && b.HasTags(this) && (t.tags = b.GetTags(this)), t;
-  }
-  _toNumberArray(t) {
-    return Array.isArray(t) ? t : Array.prototype.slice.call(t);
-  }
-  /**
-   * Release any memory retained by the cached data on the Geometry.
-   *
-   * Call this function to reduce memory footprint of the mesh.
-   * Vertex buffers will not store CPU data anymore (this will prevent picking, collisions or physics to work correctly)
-   */
-  clearCachedData() {
-    this._indices = [], this._resetPointsArrayCache();
-    for (const t in this._vertexBuffers)
-      Object.prototype.hasOwnProperty.call(this._vertexBuffers, t) && (this._vertexBuffers[t]._buffer._data = null);
-  }
-  /**
-   * Serialize all vertices data into a JSON object
-   * @returns a JSON representation of the current geometry data
-   */
-  serializeVerticeData() {
-    const t = this.serialize();
-    return this.isVerticesDataPresent(n.PositionKind) && (t.positions = this._toNumberArray(this.getVerticesData(n.PositionKind)), this.isVertexBufferUpdatable(n.PositionKind) && (t.positions._updatable = !0)), this.isVerticesDataPresent(n.NormalKind) && (t.normals = this._toNumberArray(this.getVerticesData(n.NormalKind)), this.isVertexBufferUpdatable(n.NormalKind) && (t.normals._updatable = !0)), this.isVerticesDataPresent(n.TangentKind) && (t.tangents = this._toNumberArray(this.getVerticesData(n.TangentKind)), this.isVertexBufferUpdatable(n.TangentKind) && (t.tangents._updatable = !0)), this.isVerticesDataPresent(n.UVKind) && (t.uvs = this._toNumberArray(this.getVerticesData(n.UVKind)), this.isVertexBufferUpdatable(n.UVKind) && (t.uvs._updatable = !0)), this.isVerticesDataPresent(n.UV2Kind) && (t.uv2s = this._toNumberArray(this.getVerticesData(n.UV2Kind)), this.isVertexBufferUpdatable(n.UV2Kind) && (t.uv2s._updatable = !0)), this.isVerticesDataPresent(n.UV3Kind) && (t.uv3s = this._toNumberArray(this.getVerticesData(n.UV3Kind)), this.isVertexBufferUpdatable(n.UV3Kind) && (t.uv3s._updatable = !0)), this.isVerticesDataPresent(n.UV4Kind) && (t.uv4s = this._toNumberArray(this.getVerticesData(n.UV4Kind)), this.isVertexBufferUpdatable(n.UV4Kind) && (t.uv4s._updatable = !0)), this.isVerticesDataPresent(n.UV5Kind) && (t.uv5s = this._toNumberArray(this.getVerticesData(n.UV5Kind)), this.isVertexBufferUpdatable(n.UV5Kind) && (t.uv5s._updatable = !0)), this.isVerticesDataPresent(n.UV6Kind) && (t.uv6s = this._toNumberArray(this.getVerticesData(n.UV6Kind)), this.isVertexBufferUpdatable(n.UV6Kind) && (t.uv6s._updatable = !0)), this.isVerticesDataPresent(n.ColorKind) && (t.colors = this._toNumberArray(this.getVerticesData(n.ColorKind)), this.isVertexBufferUpdatable(n.ColorKind) && (t.colors._updatable = !0)), this.isVerticesDataPresent(n.MatricesIndicesKind) && (t.matricesIndices = this._toNumberArray(this.getVerticesData(n.MatricesIndicesKind)), t.matricesIndices._isExpanded = !0, this.isVertexBufferUpdatable(n.MatricesIndicesKind) && (t.matricesIndices._updatable = !0)), this.isVerticesDataPresent(n.MatricesWeightsKind) && (t.matricesWeights = this._toNumberArray(this.getVerticesData(n.MatricesWeightsKind)), this.isVertexBufferUpdatable(n.MatricesWeightsKind) && (t.matricesWeights._updatable = !0)), t.indices = this._toNumberArray(this.getIndices()), t;
-  }
-  // Statics
-  /**
-   * Extracts a clone of a mesh geometry
-   * @param mesh defines the source mesh
-   * @param id defines the unique ID of the new geometry object
-   * @returns the new geometry object
-   */
-  static ExtractFromMesh(t, e) {
-    const a = t._geometry;
-    return a ? a.copy(e) : null;
-  }
-  /**
-   * You should now use Tools.RandomId(), this method is still here for legacy reasons.
-   * Implementation from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#answer-2117523
-   * Be aware Math.random() could cause collisions, but:
-   * "All but 6 of the 128 bits of the ID are randomly generated, which means that for any two ids, there's a 1 in 2^^122 (or 5.3x10^^36) chance they'll collide"
-   * @returns a string containing a new GUID
-   */
-  static RandomId() {
-    return m.RandomId();
-  }
-  static _GetGeometryByLoadedUniqueId(t, e) {
-    for (let a = 0; a < e.geometries.length; a++)
-      if (e.geometries[a]._loadedUniqueId === t)
-        return e.geometries[a];
-    return null;
-  }
-  /**
-   * @internal
-   */
-  static _ImportGeometry(t, e) {
-    const a = e.getScene(), s = t.geometryUniqueId, c = t.geometryId;
-    if (s || c) {
-      const i = s ? this._GetGeometryByLoadedUniqueId(s, a) : a.getGeometryById(c);
-      i && i.applyToMesh(e);
-    } else if (t instanceof ArrayBuffer) {
-      const i = e._binaryInfo;
-      if (i.positionsAttrDesc && i.positionsAttrDesc.count > 0) {
-        const r = new Float32Array(t, i.positionsAttrDesc.offset, i.positionsAttrDesc.count);
-        e.setVerticesData(n.PositionKind, r, !1);
-      }
-      if (i.normalsAttrDesc && i.normalsAttrDesc.count > 0) {
-        const r = new Float32Array(t, i.normalsAttrDesc.offset, i.normalsAttrDesc.count);
-        e.setVerticesData(n.NormalKind, r, !1);
-      }
-      if (i.tangetsAttrDesc && i.tangetsAttrDesc.count > 0) {
-        const r = new Float32Array(t, i.tangetsAttrDesc.offset, i.tangetsAttrDesc.count);
-        e.setVerticesData(n.TangentKind, r, !1);
-      }
-      if (i.uvsAttrDesc && i.uvsAttrDesc.count > 0) {
-        const r = new Float32Array(t, i.uvsAttrDesc.offset, i.uvsAttrDesc.count);
-        if (x.UseOpenGLOrientationForUV)
-          for (let o = 1; o < r.length; o += 2)
-            r[o] = 1 - r[o];
-        e.setVerticesData(n.UVKind, r, !1);
-      }
-      if (i.uvs2AttrDesc && i.uvs2AttrDesc.count > 0) {
-        const r = new Float32Array(t, i.uvs2AttrDesc.offset, i.uvs2AttrDesc.count);
-        if (x.UseOpenGLOrientationForUV)
-          for (let o = 1; o < r.length; o += 2)
-            r[o] = 1 - r[o];
-        e.setVerticesData(n.UV2Kind, r, !1);
-      }
-      if (i.uvs3AttrDesc && i.uvs3AttrDesc.count > 0) {
-        const r = new Float32Array(t, i.uvs3AttrDesc.offset, i.uvs3AttrDesc.count);
-        if (x.UseOpenGLOrientationForUV)
-          for (let o = 1; o < r.length; o += 2)
-            r[o] = 1 - r[o];
-        e.setVerticesData(n.UV3Kind, r, !1);
-      }
-      if (i.uvs4AttrDesc && i.uvs4AttrDesc.count > 0) {
-        const r = new Float32Array(t, i.uvs4AttrDesc.offset, i.uvs4AttrDesc.count);
-        if (x.UseOpenGLOrientationForUV)
-          for (let o = 1; o < r.length; o += 2)
-            r[o] = 1 - r[o];
-        e.setVerticesData(n.UV4Kind, r, !1);
-      }
-      if (i.uvs5AttrDesc && i.uvs5AttrDesc.count > 0) {
-        const r = new Float32Array(t, i.uvs5AttrDesc.offset, i.uvs5AttrDesc.count);
-        if (x.UseOpenGLOrientationForUV)
-          for (let o = 1; o < r.length; o += 2)
-            r[o] = 1 - r[o];
-        e.setVerticesData(n.UV5Kind, r, !1);
-      }
-      if (i.uvs6AttrDesc && i.uvs6AttrDesc.count > 0) {
-        const r = new Float32Array(t, i.uvs6AttrDesc.offset, i.uvs6AttrDesc.count);
-        if (x.UseOpenGLOrientationForUV)
-          for (let o = 1; o < r.length; o += 2)
-            r[o] = 1 - r[o];
-        e.setVerticesData(n.UV6Kind, r, !1);
-      }
-      if (i.colorsAttrDesc && i.colorsAttrDesc.count > 0) {
-        const r = new Float32Array(t, i.colorsAttrDesc.offset, i.colorsAttrDesc.count);
-        e.setVerticesData(n.ColorKind, r, !1, i.colorsAttrDesc.stride);
-      }
-      if (i.matricesIndicesAttrDesc && i.matricesIndicesAttrDesc.count > 0) {
-        const r = new Int32Array(t, i.matricesIndicesAttrDesc.offset, i.matricesIndicesAttrDesc.count), o = [];
-        for (let f = 0; f < r.length; f++) {
-          const l = r[f];
-          o.push(l & 255), o.push((l & 65280) >> 8), o.push((l & 16711680) >> 16), o.push(l >> 24 & 255);
-        }
-        e.setVerticesData(n.MatricesIndicesKind, o, !1);
-      }
-      if (i.matricesIndicesExtraAttrDesc && i.matricesIndicesExtraAttrDesc.count > 0) {
-        const r = new Int32Array(t, i.matricesIndicesExtraAttrDesc.offset, i.matricesIndicesExtraAttrDesc.count), o = [];
-        for (let f = 0; f < r.length; f++) {
-          const l = r[f];
-          o.push(l & 255), o.push((l & 65280) >> 8), o.push((l & 16711680) >> 16), o.push(l >> 24 & 255);
-        }
-        e.setVerticesData(n.MatricesIndicesExtraKind, o, !1);
-      }
-      if (i.matricesWeightsAttrDesc && i.matricesWeightsAttrDesc.count > 0) {
-        const r = new Float32Array(t, i.matricesWeightsAttrDesc.offset, i.matricesWeightsAttrDesc.count);
-        e.setVerticesData(n.MatricesWeightsKind, r, !1);
-      }
-      if (i.indicesAttrDesc && i.indicesAttrDesc.count > 0) {
-        const r = new Int32Array(t, i.indicesAttrDesc.offset, i.indicesAttrDesc.count);
-        e.setIndices(r, null);
-      }
-      if (i.subMeshesAttrDesc && i.subMeshesAttrDesc.count > 0) {
-        const r = new Int32Array(t, i.subMeshesAttrDesc.offset, i.subMeshesAttrDesc.count * 5);
-        e.subMeshes = [];
-        for (let o = 0; o < i.subMeshesAttrDesc.count; o++) {
-          const f = r[o * 5 + 0], l = r[o * 5 + 1], u = r[o * 5 + 2], g = r[o * 5 + 3], h = r[o * 5 + 4];
-          A.AddToMesh(f, l, u, g, h, e);
-        }
-      }
-    } else if (t.positions && t.normals && t.indices) {
-      if (e.setVerticesData(n.PositionKind, t.positions, t.positions._updatable), e.setVerticesData(n.NormalKind, t.normals, t.normals._updatable), t.tangents && e.setVerticesData(n.TangentKind, t.tangents, t.tangents._updatable), t.uvs && e.setVerticesData(n.UVKind, t.uvs, t.uvs._updatable), t.uvs2 && e.setVerticesData(n.UV2Kind, t.uvs2, t.uvs2._updatable), t.uvs3 && e.setVerticesData(n.UV3Kind, t.uvs3, t.uvs3._updatable), t.uvs4 && e.setVerticesData(n.UV4Kind, t.uvs4, t.uvs4._updatable), t.uvs5 && e.setVerticesData(n.UV5Kind, t.uvs5, t.uvs5._updatable), t.uvs6 && e.setVerticesData(n.UV6Kind, t.uvs6, t.uvs6._updatable), t.colors && e.setVerticesData(n.ColorKind, y.CheckColors4(t.colors, t.positions.length / 3), t.colors._updatable), t.matricesIndices)
-        if (t.matricesIndices._isExpanded)
-          delete t.matricesIndices._isExpanded, e.setVerticesData(n.MatricesIndicesKind, t.matricesIndices, t.matricesIndices._updatable);
-        else {
-          const i = [];
-          for (let r = 0; r < t.matricesIndices.length; r++) {
-            const o = t.matricesIndices[r];
-            i.push(o & 255), i.push((o & 65280) >> 8), i.push((o & 16711680) >> 16), i.push(o >> 24 & 255);
-          }
-          e.setVerticesData(n.MatricesIndicesKind, i, t.matricesIndices._updatable);
-        }
-      if (t.matricesIndicesExtra)
-        if (t.matricesIndicesExtra._isExpanded)
-          delete t.matricesIndices._isExpanded, e.setVerticesData(n.MatricesIndicesExtraKind, t.matricesIndicesExtra, t.matricesIndicesExtra._updatable);
-        else {
-          const i = [];
-          for (let r = 0; r < t.matricesIndicesExtra.length; r++) {
-            const o = t.matricesIndicesExtra[r];
-            i.push(o & 255), i.push((o & 65280) >> 8), i.push((o & 16711680) >> 16), i.push(o >> 24 & 255);
-          }
-          e.setVerticesData(n.MatricesIndicesExtraKind, i, t.matricesIndicesExtra._updatable);
-        }
-      t.matricesWeights && (I._CleanMatricesWeights(t, e), e.setVerticesData(n.MatricesWeightsKind, t.matricesWeights, t.matricesWeights._updatable)), t.matricesWeightsExtra && e.setVerticesData(n.MatricesWeightsExtraKind, t.matricesWeightsExtra, t.matricesWeights._updatable), e.setIndices(t.indices, null);
-    }
-    if (t.subMeshes) {
-      e.subMeshes = [];
-      for (let i = 0; i < t.subMeshes.length; i++) {
-        const r = t.subMeshes[i];
-        A.AddToMesh(r.materialIndex, r.verticesStart, r.verticesCount, r.indexStart, r.indexCount, e);
-      }
-    }
-    e._shouldGenerateFlatShading && (e.convertToFlatShadedMesh(), e._shouldGenerateFlatShading = !1), e.computeWorldMatrix(!0), a.onMeshImportedObservable.notifyObservers(e);
-  }
-  static _CleanMatricesWeights(t, e) {
-    if (!p.CleanBoneMatrixWeights)
-      return;
-    let s = 0;
-    if (t.skeletonId > -1) {
-      const u = e.getScene().getLastSkeletonById(t.skeletonId);
-      if (!u)
-        return;
-      s = u.bones.length;
-    } else
-      return;
-    const c = e.getVerticesData(n.MatricesIndicesKind), i = e.getVerticesData(n.MatricesIndicesExtraKind), r = t.matricesWeights, o = t.matricesWeightsExtra, f = t.numBoneInfluencer, l = r.length;
-    for (let u = 0; u < l; u += 4) {
-      let g = 0, h = -1;
-      for (let _ = 0; _ < 4; _++) {
-        const d = r[u + _];
-        g += d, d < 1e-3 && h < 0 && (h = _);
-      }
-      if (o)
-        for (let _ = 0; _ < 4; _++) {
-          const d = o[u + _];
-          g += d, d < 1e-3 && h < 0 && (h = _ + 4);
-        }
-      if ((h < 0 || h > f - 1) && (h = f - 1), g > 1e-3) {
-        const _ = 1 / g;
-        for (let d = 0; d < 4; d++)
-          r[u + d] *= _;
-        if (o)
-          for (let d = 0; d < 4; d++)
-            o[u + d] *= _;
-      } else
-        h >= 4 ? (o[u + h - 4] = 1 - g, i[u + h - 4] = s) : (r[u + h] = 1 - g, c[u + h] = s);
-    }
-    e.setVerticesData(n.MatricesIndicesKind, c), t.matricesWeightsExtra && e.setVerticesData(n.MatricesIndicesExtraKind, i);
-  }
-  /**
-   * Create a new geometry from persisted data (Using .babylon file format)
-   * @param parsedVertexData defines the persisted data
-   * @param scene defines the hosting scene
-   * @param rootUrl defines the root url to use to load assets (like delayed data)
-   * @returns the new geometry object
-   */
-  static Parse(t, e, a) {
-    const s = new I(t.id, e, void 0, t.updatable);
-    return s._loadedUniqueId = t.uniqueId, b && b.AddTagsTo(s, t.tags), t.delayLoadingFile ? (s.delayLoadState = 4, s.delayLoadingFile = a + t.delayLoadingFile, s._boundingInfo = new v(D.FromArray(t.boundingBoxMinimum), D.FromArray(t.boundingBoxMaximum)), s._delayInfo = [], t.hasUVs && s._delayInfo.push(n.UVKind), t.hasUVs2 && s._delayInfo.push(n.UV2Kind), t.hasUVs3 && s._delayInfo.push(n.UV3Kind), t.hasUVs4 && s._delayInfo.push(n.UV4Kind), t.hasUVs5 && s._delayInfo.push(n.UV5Kind), t.hasUVs6 && s._delayInfo.push(n.UV6Kind), t.hasColors && s._delayInfo.push(n.ColorKind), t.hasMatricesIndices && s._delayInfo.push(n.MatricesIndicesKind), t.hasMatricesWeights && s._delayInfo.push(n.MatricesWeightsKind), s._delayLoadingFunction = V.ImportVertexData) : V.ImportVertexData(t, s), e.pushGeometry(s, !0), s;
-  }
-}
-export {
-  I as Geometry
-};