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

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

@@ -0,0 +1,13 @@
+class t {
+  /**
+   * Creates a new LOD level
+   * @param distanceOrScreenCoverage defines either the distance or the screen coverage where this level should start being displayed
+   * @param mesh defines the mesh to use to render this level
+   */
+  constructor(e, s) {
+    this.distanceOrScreenCoverage = e, this.mesh = s;
+  }
+}
+export {
+  t as MeshLODLevel
+};

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

@@ -0,0 +1,422 @@
+import { VertexBuffer as M } from "../Buffers/buffer.esm.js";
+import { IntersectionInfo as p } from "../Collisions/intersectionInfo.esm.js";
+import { BoundingInfo as x } from "../Culling/boundingInfo.esm.js";
+import { extractMinAndMaxIndexed as w } from "../Maths/math.functions.esm.js";
+import { DrawWrapper as v } from "../Materials/drawWrapper.esm.js";
+class c {
+  /**
+   * Gets material defines used by the effect associated to the sub mesh
+   */
+  get materialDefines() {
+    var e;
+    return this._mainDrawWrapperOverride ? this._mainDrawWrapperOverride.defines : (e = this._getDrawWrapper()) === null || e === void 0 ? void 0 : e.defines;
+  }
+  /**
+   * Sets material defines used by the effect associated to the sub mesh
+   */
+  set materialDefines(e) {
+    var t;
+    const n = (t = this._mainDrawWrapperOverride) !== null && t !== void 0 ? t : this._getDrawWrapper(void 0, !0);
+    n.defines = e;
+  }
+  /**
+   * @internal
+   */
+  _getDrawWrapper(e, t = !1) {
+    e = e ?? this._engine.currentRenderPassId;
+    let n = this._drawWrappers[e];
+    return !n && t && (this._drawWrappers[e] = n = new v(this._mesh.getScene().getEngine())), n;
+  }
+  /**
+   * @internal
+   */
+  _removeDrawWrapper(e, t = !0) {
+    var n;
+    t && ((n = this._drawWrappers[e]) === null || n === void 0 || n.dispose()), this._drawWrappers[e] = void 0;
+  }
+  /**
+   * Gets associated (main) effect (possibly the effect override if defined)
+   */
+  get effect() {
+    var e, t;
+    return this._mainDrawWrapperOverride ? this._mainDrawWrapperOverride.effect : (t = (e = this._getDrawWrapper()) === null || e === void 0 ? void 0 : e.effect) !== null && t !== void 0 ? t : null;
+  }
+  /** @internal */
+  get _drawWrapper() {
+    var e;
+    return (e = this._mainDrawWrapperOverride) !== null && e !== void 0 ? e : this._getDrawWrapper(void 0, !0);
+  }
+  /** @internal */
+  get _drawWrapperOverride() {
+    return this._mainDrawWrapperOverride;
+  }
+  /**
+   * @internal
+   */
+  _setMainDrawWrapperOverride(e) {
+    this._mainDrawWrapperOverride = e;
+  }
+  /**
+   * Sets associated effect (effect used to render this submesh)
+   * @param effect defines the effect to associate with
+   * @param defines defines the set of defines used to compile this effect
+   * @param materialContext material context associated to the effect
+   * @param resetContext true to reset the draw context
+   */
+  setEffect(e, t = null, n, i = !0) {
+    const a = this._drawWrapper;
+    a.setEffect(e, t, i), n !== void 0 && (a.materialContext = n), e || (a.defines = null, a.materialContext = void 0);
+  }
+  /**
+   * Resets the draw wrappers cache
+   * @param passId If provided, releases only the draw wrapper corresponding to this render pass id
+   */
+  resetDrawCache(e) {
+    if (this._drawWrappers)
+      if (e !== void 0) {
+        this._removeDrawWrapper(e);
+        return;
+      } else
+        for (const t of this._drawWrappers)
+          t == null || t.dispose();
+    this._drawWrappers = [];
+  }
+  /**
+   * Add a new submesh to a mesh
+   * @param materialIndex defines the material index to use
+   * @param verticesStart defines vertex index start
+   * @param verticesCount defines vertices count
+   * @param indexStart defines index start
+   * @param indexCount defines indices count
+   * @param mesh defines the parent mesh
+   * @param renderingMesh defines an optional rendering mesh
+   * @param createBoundingBox defines if bounding box should be created for this submesh
+   * @returns the new submesh
+   */
+  static AddToMesh(e, t, n, i, a, r, s, u = !0) {
+    return new c(e, t, n, i, a, r, s, u);
+  }
+  /**
+   * Creates a new submesh
+   * @param materialIndex defines the material index to use
+   * @param verticesStart defines vertex index start
+   * @param verticesCount defines vertices count
+   * @param indexStart defines index start
+   * @param indexCount defines indices count
+   * @param mesh defines the parent mesh
+   * @param renderingMesh defines an optional rendering mesh
+   * @param createBoundingBox defines if bounding box should be created for this submesh
+   * @param addToMesh defines a boolean indicating that the submesh must be added to the mesh.subMeshes array (true by default)
+   */
+  constructor(e, t, n, i, a, r, s, u = !0, l = !0) {
+    this.materialIndex = e, this.verticesStart = t, this.verticesCount = n, this.indexStart = i, this.indexCount = a, this._mainDrawWrapperOverride = null, this._linesIndexCount = 0, this._linesIndexBuffer = null, this._lastColliderWorldVertices = null, this._lastColliderTransformMatrix = null, this._wasDispatched = !1, this._renderId = 0, this._alphaIndex = 0, this._distanceToCamera = 0, this._currentMaterial = null, this._mesh = r, this._renderingMesh = s || r, l && r.subMeshes.push(this), this._engine = this._mesh.getScene().getEngine(), this.resetDrawCache(), this._trianglePlanes = [], this._id = r.subMeshes.length - 1, u && (this.refreshBoundingInfo(), r.computeWorldMatrix(!0));
+  }
+  /**
+   * Returns true if this submesh covers the entire parent mesh
+   * @ignorenaming
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  get IsGlobal() {
+    return this.verticesStart === 0 && this.verticesCount === this._mesh.getTotalVertices() && this.indexStart === 0 && this.indexCount === this._mesh.getTotalIndices();
+  }
+  /**
+   * Returns the submesh BoundingInfo object
+   * @returns current bounding info (or mesh's one if the submesh is global)
+   */
+  getBoundingInfo() {
+    return this.IsGlobal ? this._mesh.getBoundingInfo() : this._boundingInfo;
+  }
+  /**
+   * Sets the submesh BoundingInfo
+   * @param boundingInfo defines the new bounding info to use
+   * @returns the SubMesh
+   */
+  setBoundingInfo(e) {
+    return this._boundingInfo = e, this;
+  }
+  /**
+   * Returns the mesh of the current submesh
+   * @returns the parent mesh
+   */
+  getMesh() {
+    return this._mesh;
+  }
+  /**
+   * Returns the rendering mesh of the submesh
+   * @returns the rendering mesh (could be different from parent mesh)
+   */
+  getRenderingMesh() {
+    return this._renderingMesh;
+  }
+  /**
+   * Returns the replacement mesh of the submesh
+   * @returns the replacement mesh (could be different from parent mesh)
+   */
+  getReplacementMesh() {
+    return this._mesh._internalAbstractMeshDataInfo._actAsRegularMesh ? this._mesh : null;
+  }
+  /**
+   * Returns the effective mesh of the submesh
+   * @returns the effective mesh (could be different from parent mesh)
+   */
+  getEffectiveMesh() {
+    const e = this._mesh._internalAbstractMeshDataInfo._actAsRegularMesh ? this._mesh : null;
+    return e || this._renderingMesh;
+  }
+  /**
+   * Returns the submesh material
+   * @param getDefaultMaterial Defines whether or not to get the default material if nothing has been defined.
+   * @returns null or the current material
+   */
+  getMaterial(e = !0) {
+    var t;
+    const n = (t = this._renderingMesh.getMaterialForRenderPass(this._engine.currentRenderPassId)) !== null && t !== void 0 ? t : this._renderingMesh.material;
+    if (n) {
+      if (this._isMultiMaterial(n)) {
+        const i = n.getSubMaterial(this.materialIndex);
+        return this._currentMaterial !== i && (this._currentMaterial = i, this.resetDrawCache()), i;
+      }
+    } else
+      return e ? this._mesh.getScene().defaultMaterial : null;
+    return n;
+  }
+  _isMultiMaterial(e) {
+    return e.getSubMaterial !== void 0;
+  }
+  // Methods
+  /**
+   * Sets a new updated BoundingInfo object to the submesh
+   * @param data defines an optional position array to use to determine the bounding info
+   * @returns the SubMesh
+   */
+  refreshBoundingInfo(e = null) {
+    if (this._lastColliderWorldVertices = null, this.IsGlobal || !this._renderingMesh || !this._renderingMesh.geometry)
+      return this;
+    if (e || (e = this._renderingMesh.getVerticesData(M.PositionKind)), !e)
+      return this._boundingInfo = this._mesh.getBoundingInfo(), this;
+    const t = this._renderingMesh.getIndices();
+    let n;
+    if (this.indexStart === 0 && this.indexCount === t.length) {
+      const i = this._renderingMesh.getBoundingInfo();
+      n = { minimum: i.minimum.clone(), maximum: i.maximum.clone() };
+    } else
+      n = w(e, t, this.indexStart, this.indexCount, this._renderingMesh.geometry.boundingBias);
+    return this._boundingInfo ? this._boundingInfo.reConstruct(n.minimum, n.maximum) : this._boundingInfo = new x(n.minimum, n.maximum), this;
+  }
+  /**
+   * @internal
+   */
+  _checkCollision(e) {
+    return this.getBoundingInfo()._checkCollision(e);
+  }
+  /**
+   * Updates the submesh BoundingInfo
+   * @param world defines the world matrix to use to update the bounding info
+   * @returns the submesh
+   */
+  updateBoundingInfo(e) {
+    let t = this.getBoundingInfo();
+    return t || (this.refreshBoundingInfo(), t = this.getBoundingInfo()), t && t.update(e), this;
+  }
+  /**
+   * True is the submesh bounding box intersects the frustum defined by the passed array of planes.
+   * @param frustumPlanes defines the frustum planes
+   * @returns true if the submesh is intersecting with the frustum
+   */
+  isInFrustum(e) {
+    const t = this.getBoundingInfo();
+    return t ? t.isInFrustum(e, this._mesh.cullingStrategy) : !1;
+  }
+  /**
+   * True is the submesh bounding box is completely inside the frustum defined by the passed array of planes
+   * @param frustumPlanes defines the frustum planes
+   * @returns true if the submesh is inside the frustum
+   */
+  isCompletelyInFrustum(e) {
+    const t = this.getBoundingInfo();
+    return t ? t.isCompletelyInFrustum(e) : !1;
+  }
+  /**
+   * Renders the submesh
+   * @param enableAlphaMode defines if alpha needs to be used
+   * @returns the submesh
+   */
+  render(e) {
+    return this._renderingMesh.render(this, e, this._mesh._internalAbstractMeshDataInfo._actAsRegularMesh ? this._mesh : void 0), this;
+  }
+  /**
+   * @internal
+   */
+  _getLinesIndexBuffer(e, t) {
+    if (!this._linesIndexBuffer) {
+      const n = [];
+      for (let i = this.indexStart; i < this.indexStart + this.indexCount; i += 3)
+        n.push(e[i], e[i + 1], e[i + 1], e[i + 2], e[i + 2], e[i]);
+      this._linesIndexBuffer = t.createIndexBuffer(n), this._linesIndexCount = n.length;
+    }
+    return this._linesIndexBuffer;
+  }
+  /**
+   * Checks if the submesh intersects with a ray
+   * @param ray defines the ray to test
+   * @returns true is the passed ray intersects the submesh bounding box
+   */
+  canIntersects(e) {
+    const t = this.getBoundingInfo();
+    return t ? e.intersectsBox(t.boundingBox) : !1;
+  }
+  /**
+   * Intersects current submesh with a ray
+   * @param ray defines the ray to test
+   * @param positions defines mesh's positions array
+   * @param indices defines mesh's indices array
+   * @param fastCheck defines if the first intersection will be used (and not the closest)
+   * @param trianglePredicate defines an optional predicate used to select faces when a mesh intersection is detected
+   * @returns intersection info or null if no intersection
+   */
+  intersects(e, t, n, i, a) {
+    const r = this.getMaterial();
+    if (!r)
+      return null;
+    let s = 3, u = !1;
+    switch (r.fillMode) {
+      case 3:
+      case 5:
+      case 6:
+      case 8:
+        return null;
+      case 7:
+        s = 1, u = !0;
+        break;
+    }
+    return r.fillMode === 4 ? n.length ? this._intersectLines(e, t, n, this._mesh.intersectionThreshold, i) : this._intersectUnIndexedLines(e, t, n, this._mesh.intersectionThreshold, i) : !n.length && this._mesh._unIndexed ? this._intersectUnIndexedTriangles(e, t, n, i, a) : this._intersectTriangles(e, t, n, s, u, i, a);
+  }
+  /**
+   * @internal
+   */
+  _intersectLines(e, t, n, i, a) {
+    let r = null;
+    for (let s = this.indexStart; s < this.indexStart + this.indexCount; s += 2) {
+      const u = t[n[s]], l = t[n[s + 1]], h = e.intersectionSegment(u, l, i);
+      if (!(h < 0) && (a || !r || h < r.distance) && (r = new p(null, null, h), r.faceId = s / 2, a))
+        break;
+    }
+    return r;
+  }
+  /**
+   * @internal
+   */
+  _intersectUnIndexedLines(e, t, n, i, a) {
+    let r = null;
+    for (let s = this.verticesStart; s < this.verticesStart + this.verticesCount; s += 2) {
+      const u = t[s], l = t[s + 1], h = e.intersectionSegment(u, l, i);
+      if (!(h < 0) && (a || !r || h < r.distance) && (r = new p(null, null, h), r.faceId = s / 2, a))
+        break;
+    }
+    return r;
+  }
+  /**
+   * @internal
+   */
+  _intersectTriangles(e, t, n, i, a, r, s) {
+    let u = null, l = -1;
+    for (let h = this.indexStart; h < this.indexStart + this.indexCount - (3 - i); h += i) {
+      l++;
+      const o = n[h], d = n[h + 1], _ = n[h + 2];
+      if (a && _ === 4294967295) {
+        h += 2;
+        continue;
+      }
+      const g = t[o], m = t[d], I = t[_];
+      if (!g || !m || !I || s && !s(g, m, I, e, o, d, _))
+        continue;
+      const f = e.intersectsTriangle(g, m, I);
+      if (f) {
+        if (f.distance < 0)
+          continue;
+        if ((r || !u || f.distance < u.distance) && (u = f, u.faceId = l, r))
+          break;
+      }
+    }
+    return u;
+  }
+  /**
+   * @internal
+   */
+  _intersectUnIndexedTriangles(e, t, n, i, a) {
+    let r = null;
+    for (let s = this.verticesStart; s < this.verticesStart + this.verticesCount; s += 3) {
+      const u = t[s], l = t[s + 1], h = t[s + 2];
+      if (a && !a(u, l, h, e, -1, -1, -1))
+        continue;
+      const o = e.intersectsTriangle(u, l, h);
+      if (o) {
+        if (o.distance < 0)
+          continue;
+        if ((i || !r || o.distance < r.distance) && (r = o, r.faceId = s / 3, i))
+          break;
+      }
+    }
+    return r;
+  }
+  /** @internal */
+  _rebuild() {
+    this._linesIndexBuffer && (this._linesIndexBuffer = null);
+  }
+  // Clone
+  /**
+   * Creates a new submesh from the passed mesh
+   * @param newMesh defines the new hosting mesh
+   * @param newRenderingMesh defines an optional rendering mesh
+   * @returns the new submesh
+   */
+  clone(e, t) {
+    const n = new c(this.materialIndex, this.verticesStart, this.verticesCount, this.indexStart, this.indexCount, e, t, !1);
+    if (!this.IsGlobal) {
+      const i = this.getBoundingInfo();
+      if (!i)
+        return n;
+      n._boundingInfo = new x(i.minimum, i.maximum);
+    }
+    return n;
+  }
+  // Dispose
+  /**
+   * Release associated resources
+   */
+  dispose() {
+    this._linesIndexBuffer && (this._mesh.getScene().getEngine()._releaseBuffer(this._linesIndexBuffer), this._linesIndexBuffer = null);
+    const e = this._mesh.subMeshes.indexOf(this);
+    this._mesh.subMeshes.splice(e, 1), this.resetDrawCache();
+  }
+  /**
+   * Gets the class name
+   * @returns the string "SubMesh".
+   */
+  getClassName() {
+    return "SubMesh";
+  }
+  // Statics
+  /**
+   * Creates a new submesh from indices data
+   * @param materialIndex the index of the main mesh material
+   * @param startIndex the index where to start the copy in the mesh indices array
+   * @param indexCount the number of indices to copy then from the startIndex
+   * @param mesh the main mesh to create the submesh from
+   * @param renderingMesh the optional rendering mesh
+   * @param createBoundingBox defines if bounding box should be created for this submesh
+   * @returns a new submesh
+   */
+  static CreateFromIndices(e, t, n, i, a, r = !0) {
+    let s = Number.MAX_VALUE, u = -Number.MAX_VALUE;
+    const h = (a || i).getIndices();
+    for (let o = t; o < t + n; o++) {
+      const d = h[o];
+      d < s && (s = d), d > u && (u = d);
+    }
+    return new c(e, s, u - s + 1, t, n, i, a, r);
+  }
+}
+export {
+  c as SubMesh
+};

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

@@ -0,0 +1,129 @@
+import { Mesh as o } from "./mesh.esm.js";
+import { VertexBuffer as i, Buffer as S } from "../Buffers/buffer.esm.js";
+import { Matrix as g, TmpVectors as f, Vector3 as B } from "../Maths/math.vector.esm.js";
+import { Logger as D } from "../Misc/logger.esm.js";
+import { BoundingInfo as p } from "../Culling/boundingInfo.esm.js";
+o.prototype.thinInstanceAdd = function(t, e = !0) {
+  if (!this.getScene().getEngine().getCaps().instancedArrays)
+    return D.Error("Thin Instances are not supported on this device as Instanced Array extension not supported"), -1;
+  this._thinInstanceUpdateBufferSize("matrix", Array.isArray(t) ? t.length : 1);
+  const a = this._thinInstanceDataStorage.instancesCount;
+  if (Array.isArray(t))
+    for (let n = 0; n < t.length; ++n)
+      this.thinInstanceSetMatrixAt(this._thinInstanceDataStorage.instancesCount++, t[n], n === t.length - 1 && e);
+  else
+    this.thinInstanceSetMatrixAt(this._thinInstanceDataStorage.instancesCount++, t, e);
+  return a;
+};
+o.prototype.thinInstanceAddSelf = function(t = !0) {
+  return this.thinInstanceAdd(g.IdentityReadOnly, t);
+};
+o.prototype.thinInstanceRegisterAttribute = function(t, e) {
+  t === i.ColorKind && (t = i.ColorInstanceKind), this.removeVerticesData(t), this._thinInstanceInitializeUserStorage(), this._userThinInstanceBuffersStorage.strides[t] = e, this._userThinInstanceBuffersStorage.sizes[t] = e * Math.max(32, this._thinInstanceDataStorage.instancesCount), this._userThinInstanceBuffersStorage.data[t] = new Float32Array(this._userThinInstanceBuffersStorage.sizes[t]), this._userThinInstanceBuffersStorage.vertexBuffers[t] = new i(this.getEngine(), this._userThinInstanceBuffersStorage.data[t], t, !0, !1, e, !0), this.setVerticesBuffer(this._userThinInstanceBuffersStorage.vertexBuffers[t]);
+};
+o.prototype.thinInstanceSetMatrixAt = function(t, e, a = !0) {
+  if (!this._thinInstanceDataStorage.matrixData || t >= this._thinInstanceDataStorage.instancesCount)
+    return !1;
+  const n = this._thinInstanceDataStorage.matrixData;
+  return e.copyToArray(n, t * 16), this._thinInstanceDataStorage.worldMatrices && (this._thinInstanceDataStorage.worldMatrices[t] = e), a && (this.thinInstanceBufferUpdated("matrix"), this.doNotSyncBoundingInfo || this.thinInstanceRefreshBoundingInfo(!1)), !0;
+};
+o.prototype.thinInstanceSetAttributeAt = function(t, e, a, n = !0) {
+  return t === i.ColorKind && (t = i.ColorInstanceKind), !this._userThinInstanceBuffersStorage || !this._userThinInstanceBuffersStorage.data[t] || e >= this._thinInstanceDataStorage.instancesCount ? !1 : (this._thinInstanceUpdateBufferSize(t, 0), this._userThinInstanceBuffersStorage.data[t].set(a, e * this._userThinInstanceBuffersStorage.strides[t]), n && this.thinInstanceBufferUpdated(t), !0);
+};
+Object.defineProperty(o.prototype, "thinInstanceCount", {
+  get: function() {
+    return this._thinInstanceDataStorage.instancesCount;
+  },
+  set: function(t) {
+    var e, a;
+    const n = (e = this._thinInstanceDataStorage.matrixData) !== null && e !== void 0 ? e : (a = this.source) === null || a === void 0 ? void 0 : a._thinInstanceDataStorage.matrixData, s = n ? n.length / 16 : 0;
+    t <= s && (this._thinInstanceDataStorage.instancesCount = t);
+  },
+  enumerable: !0,
+  configurable: !0
+});
+o.prototype._thinInstanceCreateMatrixBuffer = function(t, e, a = !1) {
+  t === i.ColorKind && (t = i.ColorInstanceKind);
+  const n = new S(this.getEngine(), e, !a, 16, !1, !0);
+  for (let s = 0; s < 4; s++)
+    this.setVerticesBuffer(n.createVertexBuffer(t + s, s * 4, 4));
+  return n;
+};
+o.prototype.thinInstanceSetBuffer = function(t, e, a = 0, n = !1) {
+  var s, h, r;
+  a = a || 16, t === "matrix" ? ((s = this._thinInstanceDataStorage.matrixBuffer) === null || s === void 0 || s.dispose(), this._thinInstanceDataStorage.matrixBuffer = null, this._thinInstanceDataStorage.matrixBufferSize = e ? e.length : 32 * a, this._thinInstanceDataStorage.matrixData = e, this._thinInstanceDataStorage.worldMatrices = null, e !== null ? (this._thinInstanceDataStorage.instancesCount = e.length / a, this._thinInstanceDataStorage.matrixBuffer = this._thinInstanceCreateMatrixBuffer("world", e, n), this.doNotSyncBoundingInfo || this.thinInstanceRefreshBoundingInfo(!1)) : (this._thinInstanceDataStorage.instancesCount = 0, this.doNotSyncBoundingInfo || this.refreshBoundingInfo())) : t === "previousMatrix" ? ((h = this._thinInstanceDataStorage.previousMatrixBuffer) === null || h === void 0 || h.dispose(), this._thinInstanceDataStorage.previousMatrixBuffer = null, this._thinInstanceDataStorage.previousMatrixData = e, e !== null && (this._thinInstanceDataStorage.previousMatrixBuffer = this._thinInstanceCreateMatrixBuffer("previousWorld", e, n))) : (t === i.ColorKind && (t = i.ColorInstanceKind), e === null ? !((r = this._userThinInstanceBuffersStorage) === null || r === void 0) && r.data[t] && (this.removeVerticesData(t), delete this._userThinInstanceBuffersStorage.data[t], delete this._userThinInstanceBuffersStorage.strides[t], delete this._userThinInstanceBuffersStorage.sizes[t], delete this._userThinInstanceBuffersStorage.vertexBuffers[t]) : (this._thinInstanceInitializeUserStorage(), this._userThinInstanceBuffersStorage.data[t] = e, this._userThinInstanceBuffersStorage.strides[t] = a, this._userThinInstanceBuffersStorage.sizes[t] = e.length, this._userThinInstanceBuffersStorage.vertexBuffers[t] = new i(this.getEngine(), e, t, !n, !1, a, !0), this.setVerticesBuffer(this._userThinInstanceBuffersStorage.vertexBuffers[t])));
+};
+o.prototype.thinInstanceBufferUpdated = function(t) {
+  var e, a, n;
+  t === "matrix" ? (e = this._thinInstanceDataStorage.matrixBuffer) === null || e === void 0 || e.updateDirectly(this._thinInstanceDataStorage.matrixData, 0, this._thinInstanceDataStorage.instancesCount) : t === "previousMatrix" ? (a = this._thinInstanceDataStorage.previousMatrixBuffer) === null || a === void 0 || a.updateDirectly(this._thinInstanceDataStorage.previousMatrixData, 0, this._thinInstanceDataStorage.instancesCount) : (t === i.ColorKind && (t = i.ColorInstanceKind), !((n = this._userThinInstanceBuffersStorage) === null || n === void 0) && n.vertexBuffers[t] && this._userThinInstanceBuffersStorage.vertexBuffers[t].updateDirectly(this._userThinInstanceBuffersStorage.data[t], 0));
+};
+o.prototype.thinInstancePartialBufferUpdate = function(t, e, a) {
+  var n;
+  t === "matrix" ? this._thinInstanceDataStorage.matrixBuffer && this._thinInstanceDataStorage.matrixBuffer.updateDirectly(e, a) : (t === i.ColorKind && (t = i.ColorInstanceKind), !((n = this._userThinInstanceBuffersStorage) === null || n === void 0) && n.vertexBuffers[t] && this._userThinInstanceBuffersStorage.vertexBuffers[t].updateDirectly(e, a));
+};
+o.prototype.thinInstanceGetWorldMatrices = function() {
+  if (!this._thinInstanceDataStorage.matrixData || !this._thinInstanceDataStorage.matrixBuffer)
+    return [];
+  const t = this._thinInstanceDataStorage.matrixData;
+  if (!this._thinInstanceDataStorage.worldMatrices) {
+    this._thinInstanceDataStorage.worldMatrices = new Array();
+    for (let e = 0; e < this._thinInstanceDataStorage.instancesCount; ++e)
+      this._thinInstanceDataStorage.worldMatrices[e] = g.FromArray(t, e * 16);
+  }
+  return this._thinInstanceDataStorage.worldMatrices;
+};
+o.prototype.thinInstanceRefreshBoundingInfo = function(t = !1, e = !1, a = !1) {
+  if (!this._thinInstanceDataStorage.matrixData || !this._thinInstanceDataStorage.matrixBuffer)
+    return;
+  const n = this._thinInstanceDataStorage.boundingVectors;
+  if (t || !this.rawBoundingInfo) {
+    n.length = 0, this.refreshBoundingInfo(e, a);
+    const r = this.getBoundingInfo();
+    this.rawBoundingInfo = new p(r.minimum, r.maximum);
+  }
+  const s = this.getBoundingInfo(), h = this._thinInstanceDataStorage.matrixData;
+  if (n.length === 0)
+    for (let r = 0; r < s.boundingBox.vectors.length; ++r)
+      n.push(s.boundingBox.vectors[r].clone());
+  f.Vector3[0].setAll(Number.POSITIVE_INFINITY), f.Vector3[1].setAll(Number.NEGATIVE_INFINITY);
+  for (let r = 0; r < this._thinInstanceDataStorage.instancesCount; ++r) {
+    g.FromArrayToRef(h, r * 16, f.Matrix[0]);
+    for (let I = 0; I < n.length; ++I)
+      B.TransformCoordinatesToRef(n[I], f.Matrix[0], f.Vector3[2]), f.Vector3[0].minimizeInPlace(f.Vector3[2]), f.Vector3[1].maximizeInPlace(f.Vector3[2]);
+  }
+  s.reConstruct(f.Vector3[0], f.Vector3[1]), this._updateBoundingInfo();
+};
+o.prototype._thinInstanceUpdateBufferSize = function(t, e = 1) {
+  var a, n, s;
+  t === i.ColorKind && (t = i.ColorInstanceKind);
+  const h = t === "matrix";
+  if (!h && (!this._userThinInstanceBuffersStorage || !this._userThinInstanceBuffersStorage.strides[t]))
+    return;
+  const r = h ? 16 : this._userThinInstanceBuffersStorage.strides[t], I = h ? this._thinInstanceDataStorage.matrixBufferSize : this._userThinInstanceBuffersStorage.sizes[t];
+  let u = h ? this._thinInstanceDataStorage.matrixData : this._userThinInstanceBuffersStorage.data[t];
+  const _ = (this._thinInstanceDataStorage.instancesCount + e) * r;
+  let c = I;
+  for (; c < _; )
+    c *= 2;
+  if (!u || I != c) {
+    if (!u)
+      u = new Float32Array(c);
+    else {
+      const l = new Float32Array(c);
+      l.set(u, 0), u = l;
+    }
+    h ? ((a = this._thinInstanceDataStorage.matrixBuffer) === null || a === void 0 || a.dispose(), this._thinInstanceDataStorage.matrixBuffer = this._thinInstanceCreateMatrixBuffer("world", u, !1), this._thinInstanceDataStorage.matrixData = u, this._thinInstanceDataStorage.matrixBufferSize = c, this._scene.needsPreviousWorldMatrices && !this._thinInstanceDataStorage.previousMatrixData && ((n = this._thinInstanceDataStorage.previousMatrixBuffer) === null || n === void 0 || n.dispose(), this._thinInstanceDataStorage.previousMatrixBuffer = this._thinInstanceCreateMatrixBuffer("previousWorld", u, !1))) : ((s = this._userThinInstanceBuffersStorage.vertexBuffers[t]) === null || s === void 0 || s.dispose(), this._userThinInstanceBuffersStorage.data[t] = u, this._userThinInstanceBuffersStorage.sizes[t] = c, this._userThinInstanceBuffersStorage.vertexBuffers[t] = new i(this.getEngine(), u, t, !0, !1, r, !0), this.setVerticesBuffer(this._userThinInstanceBuffersStorage.vertexBuffers[t]));
+  }
+};
+o.prototype._thinInstanceInitializeUserStorage = function() {
+  this._userThinInstanceBuffersStorage || (this._userThinInstanceBuffersStorage = {
+    data: {},
+    sizes: {},
+    vertexBuffers: {},
+    strides: {}
+  });
+};
+o.prototype._disposeThinInstanceSpecificData = function() {
+  var t;
+  !((t = this._thinInstanceDataStorage) === null || t === void 0) && t.matrixBuffer && (this._thinInstanceDataStorage.matrixBuffer.dispose(), this._thinInstanceDataStorage.matrixBuffer = null);
+};