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

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

@@ -0,0 +1,729 @@
+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
+};