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

package/dist/node_modules/@babylonjs/core/Meshes/mesh.vertexData.esm.js

@@ -1,865 +0,0 @@
-import { __decorate as X } from "../tslib.es6.esm.js";
-import { TmpVectors as F, Vector3 as _, Vector4 as j } from "../Maths/math.vector.esm.js";
-import { VertexBuffer as n } from "../Buffers/buffer.esm.js";
-import { _WarnImport as E } from "../Misc/devTools.esm.js";
-import { Color4 as ci } from "../Maths/math.color.esm.js";
-import { Logger as li } from "../Misc/logger.esm.js";
-import { nativeOverride as Y } from "../Misc/decorators.esm.js";
-import { makeSyncFunction as fi, runCoroutineSync as hi } from "../Misc/coroutine.esm.js";
-import { RuntimeError as oi, ErrorCodes as di } from "../Misc/error.esm.js";
-class h {
-  constructor() {
-    this._applyTo = fi(this._applyToCoroutine.bind(this));
-  }
-  /**
-   * Uses the passed data array to set the set the values for the specified kind of data
-   * @param data a linear array of floating numbers
-   * @param kind the type of data that is being set, eg positions, colors etc
-   */
-  set(i, e) {
-    switch (i.length || li.Warn(`Setting vertex data kind '${e}' with an empty array`), e) {
-      case n.PositionKind:
-        this.positions = i;
-        break;
-      case n.NormalKind:
-        this.normals = i;
-        break;
-      case n.TangentKind:
-        this.tangents = i;
-        break;
-      case n.UVKind:
-        this.uvs = i;
-        break;
-      case n.UV2Kind:
-        this.uvs2 = i;
-        break;
-      case n.UV3Kind:
-        this.uvs3 = i;
-        break;
-      case n.UV4Kind:
-        this.uvs4 = i;
-        break;
-      case n.UV5Kind:
-        this.uvs5 = i;
-        break;
-      case n.UV6Kind:
-        this.uvs6 = i;
-        break;
-      case n.ColorKind:
-        this.colors = i;
-        break;
-      case n.MatricesIndicesKind:
-        this.matricesIndices = i;
-        break;
-      case n.MatricesWeightsKind:
-        this.matricesWeights = i;
-        break;
-      case n.MatricesIndicesExtraKind:
-        this.matricesIndicesExtra = i;
-        break;
-      case n.MatricesWeightsExtraKind:
-        this.matricesWeightsExtra = i;
-        break;
-    }
-  }
-  /**
-   * Associates the vertexData to the passed Mesh.
-   * Sets it as updatable or not (default `false`)
-   * @param mesh the mesh the vertexData is applied to
-   * @param updatable when used and having the value true allows new data to update the vertexData
-   * @returns the VertexData
-   */
-  applyToMesh(i, e) {
-    return this._applyTo(i, e, !1), this;
-  }
-  /**
-   * Associates the vertexData to the passed Geometry.
-   * Sets it as updatable or not (default `false`)
-   * @param geometry the geometry the vertexData is applied to
-   * @param updatable when used and having the value true allows new data to update the vertexData
-   * @returns VertexData
-   */
-  applyToGeometry(i, e) {
-    return this._applyTo(i, e, !1), this;
-  }
-  /**
-   * Updates the associated mesh
-   * @param mesh the mesh to be updated
-   * @returns VertexData
-   */
-  updateMesh(i) {
-    return this._update(i), this;
-  }
-  /**
-   * Updates the associated geometry
-   * @param geometry the geometry to be updated
-   * @returns VertexData.
-   */
-  updateGeometry(i) {
-    return this._update(i), this;
-  }
-  /**
-   * @internal
-   */
-  *_applyToCoroutine(i, e = !1, s) {
-    return this.positions && (i.setVerticesData(n.PositionKind, this.positions, e), s && (yield)), this.normals && (i.setVerticesData(n.NormalKind, this.normals, e), s && (yield)), this.tangents && (i.setVerticesData(n.TangentKind, this.tangents, e), s && (yield)), this.uvs && (i.setVerticesData(n.UVKind, this.uvs, e), s && (yield)), this.uvs2 && (i.setVerticesData(n.UV2Kind, this.uvs2, e), s && (yield)), this.uvs3 && (i.setVerticesData(n.UV3Kind, this.uvs3, e), s && (yield)), this.uvs4 && (i.setVerticesData(n.UV4Kind, this.uvs4, e), s && (yield)), this.uvs5 && (i.setVerticesData(n.UV5Kind, this.uvs5, e), s && (yield)), this.uvs6 && (i.setVerticesData(n.UV6Kind, this.uvs6, e), s && (yield)), this.colors && (i.setVerticesData(n.ColorKind, this.colors, e), s && (yield)), this.matricesIndices && (i.setVerticesData(n.MatricesIndicesKind, this.matricesIndices, e), s && (yield)), this.matricesWeights && (i.setVerticesData(n.MatricesWeightsKind, this.matricesWeights, e), s && (yield)), this.matricesIndicesExtra && (i.setVerticesData(n.MatricesIndicesExtraKind, this.matricesIndicesExtra, e), s && (yield)), this.matricesWeightsExtra && (i.setVerticesData(n.MatricesWeightsExtraKind, this.matricesWeightsExtra, e), s && (yield)), this.indices ? (i.setIndices(this.indices, null, e), s && (yield)) : i.setIndices([], null), this;
-  }
-  _update(i, e, s) {
-    return this.positions && i.updateVerticesData(n.PositionKind, this.positions, e, s), this.normals && i.updateVerticesData(n.NormalKind, this.normals, e, s), this.tangents && i.updateVerticesData(n.TangentKind, this.tangents, e, s), this.uvs && i.updateVerticesData(n.UVKind, this.uvs, e, s), this.uvs2 && i.updateVerticesData(n.UV2Kind, this.uvs2, e, s), this.uvs3 && i.updateVerticesData(n.UV3Kind, this.uvs3, e, s), this.uvs4 && i.updateVerticesData(n.UV4Kind, this.uvs4, e, s), this.uvs5 && i.updateVerticesData(n.UV5Kind, this.uvs5, e, s), this.uvs6 && i.updateVerticesData(n.UV6Kind, this.uvs6, e, s), this.colors && i.updateVerticesData(n.ColorKind, this.colors, e, s), this.matricesIndices && i.updateVerticesData(n.MatricesIndicesKind, this.matricesIndices, e, s), this.matricesWeights && i.updateVerticesData(n.MatricesWeightsKind, this.matricesWeights, e, s), this.matricesIndicesExtra && i.updateVerticesData(n.MatricesIndicesExtraKind, this.matricesIndicesExtra, e, s), this.matricesWeightsExtra && i.updateVerticesData(n.MatricesWeightsExtraKind, this.matricesWeightsExtra, e, s), this.indices && i.setIndices(this.indices, null), this;
-  }
-  static _TransformVector3Coordinates(i, e, s = 0, t = i.length) {
-    const a = F.Vector3[0], l = F.Vector3[1];
-    for (let c = s; c < s + t; c += 3)
-      _.FromArrayToRef(i, c, a), _.TransformCoordinatesToRef(a, e, l), i[c] = l.x, i[c + 1] = l.y, i[c + 2] = l.z;
-  }
-  static _TransformVector3Normals(i, e, s = 0, t = i.length) {
-    const a = F.Vector3[0], l = F.Vector3[1];
-    for (let c = s; c < s + t; c += 3)
-      _.FromArrayToRef(i, c, a), _.TransformNormalToRef(a, e, l), i[c] = l.x, i[c + 1] = l.y, i[c + 2] = l.z;
-  }
-  static _TransformVector4Normals(i, e, s = 0, t = i.length) {
-    const a = F.Vector4[0], l = F.Vector4[1];
-    for (let c = s; c < s + t; c += 4)
-      j.FromArrayToRef(i, c, a), j.TransformNormalToRef(a, e, l), i[c] = l.x, i[c + 1] = l.y, i[c + 2] = l.z, i[c + 3] = l.w;
-  }
-  static _FlipFaces(i, e = 0, s = i.length) {
-    for (let t = e; t < e + s; t += 3) {
-      const a = i[t + 1];
-      i[t + 1] = i[t + 2], i[t + 2] = a;
-    }
-  }
-  /**
-   * Transforms each position and each normal of the vertexData according to the passed Matrix
-   * @param matrix the transforming matrix
-   * @returns the VertexData
-   */
-  transform(i) {
-    const e = i.determinant() < 0;
-    return this.positions && h._TransformVector3Coordinates(this.positions, i), this.normals && h._TransformVector3Normals(this.normals, i), this.tangents && h._TransformVector4Normals(this.tangents, i), e && this.indices && h._FlipFaces(this.indices), this;
-  }
-  /**
-   * Merges the passed VertexData into the current one
-   * @param others the VertexData to be merged into the current one
-   * @param use32BitsIndices defines a boolean indicating if indices must be store in a 32 bits array
-   * @param forceCloneIndices defines a boolean indicating if indices are forced to be cloned
-   * @returns the modified VertexData
-   */
-  merge(i, e = !1, s = !1) {
-    const t = Array.isArray(i) ? i.map((a) => ({ vertexData: a })) : [{ vertexData: i }];
-    return hi(this._mergeCoroutine(void 0, t, e, !1, s));
-  }
-  /**
-   * @internal
-   */
-  *_mergeCoroutine(i, e, s = !1, t, a) {
-    var l, c, u, K;
-    this._validate();
-    const f = e.map((r) => r.vertexData);
-    for (const r of f)
-      if (r._validate(), !this.normals != !r.normals || !this.tangents != !r.tangents || !this.uvs != !r.uvs || !this.uvs2 != !r.uvs2 || !this.uvs3 != !r.uvs3 || !this.uvs4 != !r.uvs4 || !this.uvs5 != !r.uvs5 || !this.uvs6 != !r.uvs6 || !this.colors != !r.colors || !this.matricesIndices != !r.matricesIndices || !this.matricesWeights != !r.matricesWeights || !this.matricesIndicesExtra != !r.matricesIndicesExtra || !this.matricesWeightsExtra != !r.matricesWeightsExtra)
-        throw new Error("Cannot merge vertex data that do not have the same set of attributes");
-    const g = f.reduce((r, o) => {
-      var v, I;
-      return r + ((I = (v = o.indices) === null || v === void 0 ? void 0 : v.length) !== null && I !== void 0 ? I : 0);
-    }, (c = (l = this.indices) === null || l === void 0 ? void 0 : l.length) !== null && c !== void 0 ? c : 0);
-    let d = a || f.some((r) => r.indices === this.indices) ? (u = this.indices) === null || u === void 0 ? void 0 : u.slice() : this.indices;
-    if (g > 0) {
-      let r = (K = d == null ? void 0 : d.length) !== null && K !== void 0 ? K : 0;
-      if (d || (d = new Array(g)), d.length !== g) {
-        if (Array.isArray(d))
-          d.length = g;
-        else {
-          const v = s || d instanceof Uint32Array ? new Uint32Array(g) : new Uint16Array(g);
-          v.set(d), d = v;
-        }
-        i && i.determinant() < 0 && h._FlipFaces(d, 0, r);
-      }
-      let o = this.positions ? this.positions.length / 3 : 0;
-      for (const { vertexData: v, transform: I } of e)
-        if (v.indices) {
-          for (let M = 0; M < v.indices.length; M++)
-            d[r + M] = v.indices[M] + o;
-          I && I.determinant() < 0 && h._FlipFaces(d, r, v.indices.length), o += v.positions.length / 3, r += v.indices.length, t && (yield);
-        }
-    }
-    return this.indices = d, this.positions = h._MergeElement(n.PositionKind, this.positions, i, e.map((r) => [r.vertexData.positions, r.transform])), t && (yield), this.normals = h._MergeElement(n.NormalKind, this.normals, i, e.map((r) => [r.vertexData.normals, r.transform])), t && (yield), this.tangents = h._MergeElement(n.TangentKind, this.tangents, i, e.map((r) => [r.vertexData.tangents, r.transform])), t && (yield), this.uvs = h._MergeElement(n.UVKind, this.uvs, i, e.map((r) => [r.vertexData.uvs, r.transform])), t && (yield), this.uvs2 = h._MergeElement(n.UV2Kind, this.uvs2, i, e.map((r) => [r.vertexData.uvs2, r.transform])), t && (yield), this.uvs3 = h._MergeElement(n.UV3Kind, this.uvs3, i, e.map((r) => [r.vertexData.uvs3, r.transform])), t && (yield), this.uvs4 = h._MergeElement(n.UV4Kind, this.uvs4, i, e.map((r) => [r.vertexData.uvs4, r.transform])), t && (yield), this.uvs5 = h._MergeElement(n.UV5Kind, this.uvs5, i, e.map((r) => [r.vertexData.uvs5, r.transform])), t && (yield), this.uvs6 = h._MergeElement(n.UV6Kind, this.uvs6, i, e.map((r) => [r.vertexData.uvs6, r.transform])), t && (yield), this.colors = h._MergeElement(n.ColorKind, this.colors, i, e.map((r) => [r.vertexData.colors, r.transform])), t && (yield), this.matricesIndices = h._MergeElement(n.MatricesIndicesKind, this.matricesIndices, i, e.map((r) => [r.vertexData.matricesIndices, r.transform])), t && (yield), this.matricesWeights = h._MergeElement(n.MatricesWeightsKind, this.matricesWeights, i, e.map((r) => [r.vertexData.matricesWeights, r.transform])), t && (yield), this.matricesIndicesExtra = h._MergeElement(n.MatricesIndicesExtraKind, this.matricesIndicesExtra, i, e.map((r) => [r.vertexData.matricesIndicesExtra, r.transform])), t && (yield), this.matricesWeightsExtra = h._MergeElement(n.MatricesWeightsExtraKind, this.matricesWeightsExtra, i, e.map((r) => [r.vertexData.matricesWeightsExtra, r.transform])), this;
-  }
-  static _MergeElement(i, e, s, t) {
-    const a = t.filter((u) => u[0] !== null && u[0] !== void 0);
-    if (!e && a.length == 0)
-      return e;
-    if (!e)
-      return this._MergeElement(i, a[0][0], a[0][1], a.slice(1));
-    const l = a.reduce((u, K) => u + K[0].length, e.length), c = i === n.PositionKind ? h._TransformVector3Coordinates : i === n.NormalKind ? h._TransformVector3Normals : i === n.TangentKind ? h._TransformVector4Normals : () => {
-    };
-    if (e instanceof Float32Array) {
-      const u = new Float32Array(l);
-      u.set(e), s && c(u, s, 0, e.length);
-      let K = e.length;
-      for (const [f, g] of a)
-        u.set(f, K), g && c(u, g, K, f.length), K += f.length;
-      return u;
-    } else {
-      const u = new Array(l);
-      for (let f = 0; f < e.length; f++)
-        u[f] = e[f];
-      s && c(u, s, 0, e.length);
-      let K = e.length;
-      for (const [f, g] of a) {
-        for (let m = 0; m < f.length; m++)
-          u[K + m] = f[m];
-        g && c(u, g, K, f.length), K += f.length;
-      }
-      return u;
-    }
-  }
-  _validate() {
-    if (!this.positions)
-      throw new oi("Positions are required", di.MeshInvalidPositionsError);
-    const i = (t, a) => {
-      const l = n.DeduceStride(t);
-      if (a.length % l !== 0)
-        throw new Error("The " + t + "s array count must be a multiple of " + l);
-      return a.length / l;
-    }, e = i(n.PositionKind, this.positions), s = (t, a) => {
-      const l = i(t, a);
-      if (l !== e)
-        throw new Error("The " + t + "s element count (" + l + ") does not match the positions count (" + e + ")");
-    };
-    this.normals && s(n.NormalKind, this.normals), this.tangents && s(n.TangentKind, this.tangents), this.uvs && s(n.UVKind, this.uvs), this.uvs2 && s(n.UV2Kind, this.uvs2), this.uvs3 && s(n.UV3Kind, this.uvs3), this.uvs4 && s(n.UV4Kind, this.uvs4), this.uvs5 && s(n.UV5Kind, this.uvs5), this.uvs6 && s(n.UV6Kind, this.uvs6), this.colors && s(n.ColorKind, this.colors), this.matricesIndices && s(n.MatricesIndicesKind, this.matricesIndices), this.matricesWeights && s(n.MatricesWeightsKind, this.matricesWeights), this.matricesIndicesExtra && s(n.MatricesIndicesExtraKind, this.matricesIndicesExtra), this.matricesWeightsExtra && s(n.MatricesWeightsExtraKind, this.matricesWeightsExtra);
-  }
-  /**
-   * Serializes the VertexData
-   * @returns a serialized object
-   */
-  serialize() {
-    const i = {};
-    return this.positions && (i.positions = this.positions), this.normals && (i.normals = this.normals), this.tangents && (i.tangents = this.tangents), this.uvs && (i.uvs = this.uvs), this.uvs2 && (i.uvs2 = this.uvs2), this.uvs3 && (i.uvs3 = this.uvs3), this.uvs4 && (i.uvs4 = this.uvs4), this.uvs5 && (i.uvs5 = this.uvs5), this.uvs6 && (i.uvs6 = this.uvs6), this.colors && (i.colors = this.colors), this.matricesIndices && (i.matricesIndices = this.matricesIndices, i.matricesIndices._isExpanded = !0), this.matricesWeights && (i.matricesWeights = this.matricesWeights), this.matricesIndicesExtra && (i.matricesIndicesExtra = this.matricesIndicesExtra, i.matricesIndicesExtra._isExpanded = !0), this.matricesWeightsExtra && (i.matricesWeightsExtra = this.matricesWeightsExtra), i.indices = this.indices, i;
-  }
-  // Statics
-  /**
-   * Extracts the vertexData from a mesh
-   * @param mesh the mesh from which to extract the VertexData
-   * @param copyWhenShared defines if the VertexData must be cloned when shared between multiple meshes, optional, default false
-   * @param forceCopy indicating that the VertexData must be cloned, optional, default false
-   * @returns the object VertexData associated to the passed mesh
-   */
-  static ExtractFromMesh(i, e, s) {
-    return h._ExtractFrom(i, e, s);
-  }
-  /**
-   * Extracts the vertexData from the geometry
-   * @param geometry the geometry from which to extract the VertexData
-   * @param copyWhenShared defines if the VertexData must be cloned when the geometry is shared between multiple meshes, optional, default false
-   * @param forceCopy indicating that the VertexData must be cloned, optional, default false
-   * @returns the object VertexData associated to the passed mesh
-   */
-  static ExtractFromGeometry(i, e, s) {
-    return h._ExtractFrom(i, e, s);
-  }
-  static _ExtractFrom(i, e, s) {
-    const t = new h();
-    return i.isVerticesDataPresent(n.PositionKind) && (t.positions = i.getVerticesData(n.PositionKind, e, s)), i.isVerticesDataPresent(n.NormalKind) && (t.normals = i.getVerticesData(n.NormalKind, e, s)), i.isVerticesDataPresent(n.TangentKind) && (t.tangents = i.getVerticesData(n.TangentKind, e, s)), i.isVerticesDataPresent(n.UVKind) && (t.uvs = i.getVerticesData(n.UVKind, e, s)), i.isVerticesDataPresent(n.UV2Kind) && (t.uvs2 = i.getVerticesData(n.UV2Kind, e, s)), i.isVerticesDataPresent(n.UV3Kind) && (t.uvs3 = i.getVerticesData(n.UV3Kind, e, s)), i.isVerticesDataPresent(n.UV4Kind) && (t.uvs4 = i.getVerticesData(n.UV4Kind, e, s)), i.isVerticesDataPresent(n.UV5Kind) && (t.uvs5 = i.getVerticesData(n.UV5Kind, e, s)), i.isVerticesDataPresent(n.UV6Kind) && (t.uvs6 = i.getVerticesData(n.UV6Kind, e, s)), i.isVerticesDataPresent(n.ColorKind) && (t.colors = i.getVerticesData(n.ColorKind, e, s)), i.isVerticesDataPresent(n.MatricesIndicesKind) && (t.matricesIndices = i.getVerticesData(n.MatricesIndicesKind, e, s)), i.isVerticesDataPresent(n.MatricesWeightsKind) && (t.matricesWeights = i.getVerticesData(n.MatricesWeightsKind, e, s)), i.isVerticesDataPresent(n.MatricesIndicesExtraKind) && (t.matricesIndicesExtra = i.getVerticesData(n.MatricesIndicesExtraKind, e, s)), i.isVerticesDataPresent(n.MatricesWeightsExtraKind) && (t.matricesWeightsExtra = i.getVerticesData(n.MatricesWeightsExtraKind, e, s)), t.indices = i.getIndices(e, s), t;
-  }
-  /**
-   * Creates the VertexData for a Ribbon
-   * @param options an object used to set the following optional parameters for the ribbon, required but can be empty
-   * * pathArray array of paths, each of which an array of successive Vector3
-   * * closeArray creates a seam between the first and the last paths of the pathArray, optional, default false
-   * * closePath creates a seam between the first and the last points of each path of the path array, optional, default false
-   * * offset a positive integer, only used when pathArray contains a single path (offset = 10 means the point 1 is joined to the point 11), default rounded half size of the pathArray length
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * * invertUV swaps in the U and V coordinates when applying a texture, optional, default false
-   * * uvs a linear array, of length 2 * number of vertices, of custom UV values, optional
-   * * colors a linear array, of length 4 * number of vertices, of custom color values, optional
-   * @param options.pathArray
-   * @param options.closeArray
-   * @param options.closePath
-   * @param options.offset
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @param options.invertUV
-   * @param options.uvs
-   * @param options.colors
-   * @returns the VertexData of the ribbon
-   * @deprecated use CreateRibbonVertexData instead
-   */
-  static CreateRibbon(i) {
-    throw E("ribbonBuilder");
-  }
-  /**
-   * Creates the VertexData for a box
-   * @param options an object used to set the following optional parameters for the box, required but can be empty
-   * * size sets the width, height and depth of the box to the value of size, optional default 1
-   * * width sets the width (x direction) of the box, overwrites the width set by size, optional, default size
-   * * height sets the height (y direction) of the box, overwrites the height set by size, optional, default size
-   * * depth sets the depth (z direction) of the box, overwrites the depth set by size, optional, default size
-   * * faceUV an array of 6 Vector4 elements used to set different images to each box side
-   * * faceColors an array of 6 Color3 elements used to set different colors to each box side
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.size
-   * @param options.width
-   * @param options.height
-   * @param options.depth
-   * @param options.faceUV
-   * @param options.faceColors
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the box
-   * @deprecated Please use CreateBoxVertexData from the BoxBuilder file instead
-   */
-  static CreateBox(i) {
-    throw E("boxBuilder");
-  }
-  /**
-   * Creates the VertexData for a tiled box
-   * @param options an object used to set the following optional parameters for the box, required but can be empty
-   * * faceTiles sets the pattern, tile size and number of tiles for a face
-   * * faceUV an array of 6 Vector4 elements used to set different images to each box side
-   * * faceColors an array of 6 Color3 elements used to set different colors to each box side
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * @param options.pattern
-   * @param options.width
-   * @param options.height
-   * @param options.depth
-   * @param options.tileSize
-   * @param options.tileWidth
-   * @param options.tileHeight
-   * @param options.alignHorizontal
-   * @param options.alignVertical
-   * @param options.faceUV
-   * @param options.faceColors
-   * @param options.sideOrientation
-   * @returns the VertexData of the box
-   * @deprecated Please use CreateTiledBoxVertexData instead
-   */
-  static CreateTiledBox(i) {
-    throw E("tiledBoxBuilder");
-  }
-  /**
-   * Creates the VertexData for a tiled plane
-   * @param options an object used to set the following optional parameters for the box, required but can be empty
-   * * pattern a limited pattern arrangement depending on the number
-   * * tileSize sets the width, height and depth of the tile to the value of size, optional default 1
-   * * tileWidth sets the width (x direction) of the tile, overwrites the width set by size, optional, default size
-   * * tileHeight sets the height (y direction) of the tile, overwrites the height set by size, optional, default size
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.pattern
-   * @param options.tileSize
-   * @param options.tileWidth
-   * @param options.tileHeight
-   * @param options.size
-   * @param options.width
-   * @param options.height
-   * @param options.alignHorizontal
-   * @param options.alignVertical
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the tiled plane
-   * @deprecated use CreateTiledPlaneVertexData instead
-   */
-  static CreateTiledPlane(i) {
-    throw E("tiledPlaneBuilder");
-  }
-  /**
-   * Creates the VertexData for an ellipsoid, defaults to a sphere
-   * @param options an object used to set the following optional parameters for the box, required but can be empty
-   * * segments sets the number of horizontal strips optional, default 32
-   * * diameter sets the axes dimensions, diameterX, diameterY and diameterZ to the value of diameter, optional default 1
-   * * diameterX sets the diameterX (x direction) of the ellipsoid, overwrites the diameterX set by diameter, optional, default diameter
-   * * diameterY sets the diameterY (y direction) of the ellipsoid, overwrites the diameterY set by diameter, optional, default diameter
-   * * diameterZ sets the diameterZ (z direction) of the ellipsoid, overwrites the diameterZ set by diameter, optional, default diameter
-   * * arc a number from 0 to 1, to create an unclosed ellipsoid based on the fraction of the circumference (latitude) given by the arc value, optional, default 1
-   * * slice a number from 0 to 1, to create an unclosed ellipsoid based on the fraction of the height (latitude) given by the arc value, optional, default 1
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.segments
-   * @param options.diameter
-   * @param options.diameterX
-   * @param options.diameterY
-   * @param options.diameterZ
-   * @param options.arc
-   * @param options.slice
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the ellipsoid
-   * @deprecated use CreateSphereVertexData instead
-   */
-  static CreateSphere(i) {
-    throw E("sphereBuilder");
-  }
-  /**
-   * Creates the VertexData for a cylinder, cone or prism
-   * @param options an object used to set the following optional parameters for the box, required but can be empty
-   * * height sets the height (y direction) of the cylinder, optional, default 2
-   * * diameterTop sets the diameter of the top of the cone, overwrites diameter,  optional, default diameter
-   * * diameterBottom sets the diameter of the bottom of the cone, overwrites diameter,  optional, default diameter
-   * * diameter sets the diameter of the top and bottom of the cone, optional default 1
-   * * tessellation the number of prism sides, 3 for a triangular prism, optional, default 24
-   * * subdivisions` the number of rings along the cylinder height, optional, default 1
-   * * arc a number from 0 to 1, to create an unclosed cylinder based on the fraction of the circumference given by the arc value, optional, default 1
-   * * faceColors an array of Color3 elements used to set different colors to the top, rings and bottom respectively
-   * * faceUV an array of Vector4 elements used to set different images to the top, rings and bottom respectively
-   * * hasRings when true makes each subdivision independently treated as a face for faceUV and faceColors, optional, default false
-   * * enclose when true closes an open cylinder by adding extra flat faces between the height axis and vertical edges, think cut cake
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.height
-   * @param options.diameterTop
-   * @param options.diameterBottom
-   * @param options.diameter
-   * @param options.tessellation
-   * @param options.subdivisions
-   * @param options.arc
-   * @param options.faceColors
-   * @param options.faceUV
-   * @param options.hasRings
-   * @param options.enclose
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the cylinder, cone or prism
-   * @deprecated please use CreateCylinderVertexData instead
-   */
-  static CreateCylinder(i) {
-    throw E("cylinderBuilder");
-  }
-  /**
-   * Creates the VertexData for a torus
-   * @param options an object used to set the following optional parameters for the box, required but can be empty
-   * * diameter the diameter of the torus, optional default 1
-   * * thickness the diameter of the tube forming the torus, optional default 0.5
-   * * tessellation the number of prism sides, 3 for a triangular prism, optional, default 24
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.diameter
-   * @param options.thickness
-   * @param options.tessellation
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the torus
-   * @deprecated use CreateTorusVertexData instead
-   */
-  static CreateTorus(i) {
-    throw E("torusBuilder");
-  }
-  /**
-   * Creates the VertexData of the LineSystem
-   * @param options an object used to set the following optional parameters for the LineSystem, required but can be empty
-   *  - lines an array of lines, each line being an array of successive Vector3
-   *  - colors an array of line colors, each of the line colors being an array of successive Color4, one per line point
-   * @param options.lines
-   * @param options.colors
-   * @returns the VertexData of the LineSystem
-   * @deprecated use CreateLineSystemVertexData instead
-   */
-  static CreateLineSystem(i) {
-    throw E("linesBuilder");
-  }
-  /**
-   * Create the VertexData for a DashedLines
-   * @param options an object used to set the following optional parameters for the DashedLines, required but can be empty
-   *  - points an array successive Vector3
-   *  - dashSize the size of the dashes relative to the dash number, optional, default 3
-   *  - gapSize the size of the gap between two successive dashes relative to the dash number, optional, default 1
-   *  - dashNb the intended total number of dashes, optional, default 200
-   * @param options.points
-   * @param options.dashSize
-   * @param options.gapSize
-   * @param options.dashNb
-   * @returns the VertexData for the DashedLines
-   * @deprecated use CreateDashedLinesVertexData instead
-   */
-  static CreateDashedLines(i) {
-    throw E("linesBuilder");
-  }
-  /**
-   * Creates the VertexData for a Ground
-   * @param options an object used to set the following optional parameters for the Ground, required but can be empty
-   *  - width the width (x direction) of the ground, optional, default 1
-   *  - height the height (z direction) of the ground, optional, default 1
-   *  - subdivisions the number of subdivisions per side, optional, default 1
-   * @param options.width
-   * @param options.height
-   * @param options.subdivisions
-   * @param options.subdivisionsX
-   * @param options.subdivisionsY
-   * @returns the VertexData of the Ground
-   * @deprecated Please use CreateGroundVertexData instead
-   */
-  static CreateGround(i) {
-    throw E("groundBuilder");
-  }
-  /**
-   * Creates the VertexData for a TiledGround by subdividing the ground into tiles
-   * @param options an object used to set the following optional parameters for the Ground, required but can be empty
-   * * xmin the ground minimum X coordinate, optional, default -1
-   * * zmin the ground minimum Z coordinate, optional, default -1
-   * * xmax the ground maximum X coordinate, optional, default 1
-   * * zmax the ground maximum Z coordinate, optional, default 1
-   * * subdivisions a javascript object {w: positive integer, h: positive integer}, `w` and `h` are the numbers of subdivisions on the ground width and height creating 'tiles', default {w: 6, h: 6}
-   * * precision a javascript object {w: positive integer, h: positive integer}, `w` and `h` are the numbers of subdivisions on the tile width and height, default {w: 2, h: 2}
-   * @param options.xmin
-   * @param options.zmin
-   * @param options.xmax
-   * @param options.zmax
-   * @param options.subdivisions
-   * @param options.subdivisions.w
-   * @param options.subdivisions.h
-   * @param options.precision
-   * @param options.precision.w
-   * @param options.precision.h
-   * @returns the VertexData of the TiledGround
-   * @deprecated use CreateTiledGroundVertexData instead
-   */
-  static CreateTiledGround(i) {
-    throw E("groundBuilder");
-  }
-  /**
-   * Creates the VertexData of the Ground designed from a heightmap
-   * @param options an object used to set the following parameters for the Ground, required and provided by CreateGroundFromHeightMap
-   * * width the width (x direction) of the ground
-   * * height the height (z direction) of the ground
-   * * subdivisions the number of subdivisions per side
-   * * minHeight the minimum altitude on the ground, optional, default 0
-   * * maxHeight the maximum altitude on the ground, optional default 1
-   * * colorFilter the filter to apply to the image pixel colors to compute the height, optional Color3, default (0.3, 0.59, 0.11)
-   * * buffer the array holding the image color data
-   * * bufferWidth the width of image
-   * * bufferHeight the height of image
-   * * alphaFilter Remove any data where the alpha channel is below this value, defaults 0 (all data visible)
-   * @param options.width
-   * @param options.height
-   * @param options.subdivisions
-   * @param options.minHeight
-   * @param options.maxHeight
-   * @param options.colorFilter
-   * @param options.buffer
-   * @param options.bufferWidth
-   * @param options.bufferHeight
-   * @param options.alphaFilter
-   * @returns the VertexData of the Ground designed from a heightmap
-   * @deprecated use CreateGroundFromHeightMapVertexData instead
-   */
-  static CreateGroundFromHeightMap(i) {
-    throw E("groundBuilder");
-  }
-  /**
-   * Creates the VertexData for a Plane
-   * @param options an object used to set the following optional parameters for the plane, required but can be empty
-   * * size sets the width and height of the plane to the value of size, optional default 1
-   * * width sets the width (x direction) of the plane, overwrites the width set by size, optional, default size
-   * * height sets the height (y direction) of the plane, overwrites the height set by size, optional, default size
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.size
-   * @param options.width
-   * @param options.height
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the box
-   * @deprecated use CreatePlaneVertexData instead
-   */
-  static CreatePlane(i) {
-    throw E("planeBuilder");
-  }
-  /**
-   * Creates the VertexData of the Disc or regular Polygon
-   * @param options an object used to set the following optional parameters for the disc, required but can be empty
-   * * radius the radius of the disc, optional default 0.5
-   * * tessellation the number of polygon sides, optional, default 64
-   * * arc a number from 0 to 1, to create an unclosed polygon based on the fraction of the circumference given by the arc value, optional, default 1
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.radius
-   * @param options.tessellation
-   * @param options.arc
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the box
-   * @deprecated use CreateDiscVertexData instead
-   */
-  static CreateDisc(i) {
-    throw E("discBuilder");
-  }
-  /**
-   * Creates the VertexData for an irregular Polygon in the XoZ plane using a mesh built by polygonTriangulation.build()
-   * All parameters are provided by CreatePolygon as needed
-   * @param polygon a mesh built from polygonTriangulation.build()
-   * @param sideOrientation takes the values Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * @param fUV an array of Vector4 elements used to set different images to the top, rings and bottom respectively
-   * @param fColors an array of Color3 elements used to set different colors to the top, rings and bottom respectively
-   * @param frontUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * @param backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param wrap a boolean, default false, when true and fUVs used texture is wrapped around all sides, when false texture is applied side
-   * @returns the VertexData of the Polygon
-   * @deprecated use CreatePolygonVertexData instead
-   */
-  static CreatePolygon(i, e, s, t, a, l, c) {
-    throw E("polygonBuilder");
-  }
-  /**
-   * Creates the VertexData of the IcoSphere
-   * @param options an object used to set the following optional parameters for the IcoSphere, required but can be empty
-   * * radius the radius of the IcoSphere, optional default 1
-   * * radiusX allows stretching in the x direction, optional, default radius
-   * * radiusY allows stretching in the y direction, optional, default radius
-   * * radiusZ allows stretching in the z direction, optional, default radius
-   * * flat when true creates a flat shaded mesh, optional, default true
-   * * subdivisions increasing the subdivisions increases the number of faces, optional, default 4
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.radius
-   * @param options.radiusX
-   * @param options.radiusY
-   * @param options.radiusZ
-   * @param options.flat
-   * @param options.subdivisions
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the IcoSphere
-   * @deprecated use CreateIcoSphereVertexData instead
-   */
-  static CreateIcoSphere(i) {
-    throw E("icoSphereBuilder");
-  }
-  // inspired from // http://stemkoski.github.io/Three.js/Polyhedra.html
-  /**
-   * Creates the VertexData for a Polyhedron
-   * @param options an object used to set the following optional parameters for the polyhedron, required but can be empty
-   * * type provided types are:
-   *  * 0 : Tetrahedron, 1 : Octahedron, 2 : Dodecahedron, 3 : Icosahedron, 4 : Rhombicuboctahedron, 5 : Triangular Prism, 6 : Pentagonal Prism, 7 : Hexagonal Prism, 8 : Square Pyramid (J1)
-   *  * 9 : Pentagonal Pyramid (J2), 10 : Triangular Dipyramid (J12), 11 : Pentagonal Dipyramid (J13), 12 : Elongated Square Dipyramid (J15), 13 : Elongated Pentagonal Dipyramid (J16), 14 : Elongated Pentagonal Cupola (J20)
-   * * size the size of the IcoSphere, optional default 1
-   * * sizeX allows stretching in the x direction, optional, default size
-   * * sizeY allows stretching in the y direction, optional, default size
-   * * sizeZ allows stretching in the z direction, optional, default size
-   * * custom a number that overwrites the type to create from an extended set of polyhedron from https://www.babylonjs-playground.com/#21QRSK#15 with minimised editor
-   * * faceUV an array of Vector4 elements used to set different images to the top, rings and bottom respectively
-   * * faceColors an array of Color3 elements used to set different colors to the top, rings and bottom respectively
-   * * flat when true creates a flat shaded mesh, optional, default true
-   * * subdivisions increasing the subdivisions increases the number of faces, optional, default 4
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.type
-   * @param options.size
-   * @param options.sizeX
-   * @param options.sizeY
-   * @param options.sizeZ
-   * @param options.custom
-   * @param options.faceUV
-   * @param options.faceColors
-   * @param options.flat
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the Polyhedron
-   * @deprecated use CreatePolyhedronVertexData instead
-   */
-  static CreatePolyhedron(i) {
-    throw E("polyhedronBuilder");
-  }
-  /**
-   * Creates the VertexData for a Capsule, inspired from https://github.com/maximeq/three-js-capsule-geometry/blob/master/src/CapsuleBufferGeometry.js
-   * @param options an object used to set the following optional parameters for the capsule, required but can be empty
-   * @returns the VertexData of the Capsule
-   * @deprecated Please use CreateCapsuleVertexData from the capsuleBuilder file instead
-   */
-  static CreateCapsule(i = {
-    orientation: _.Up(),
-    subdivisions: 2,
-    tessellation: 16,
-    height: 1,
-    radius: 0.25,
-    capSubdivisions: 6
-  }) {
-    throw E("capsuleBuilder");
-  }
-  // based on http://code.google.com/p/away3d/source/browse/trunk/fp10/Away3D/src/away3d/primitives/TorusKnot.as?spec=svn2473&r=2473
-  /**
-   * Creates the VertexData for a TorusKnot
-   * @param options an object used to set the following optional parameters for the TorusKnot, required but can be empty
-   * * radius the radius of the torus knot, optional, default 2
-   * * tube the thickness of the tube, optional, default 0.5
-   * * radialSegments the number of sides on each tube segments, optional, default 32
-   * * tubularSegments the number of tubes to decompose the knot into, optional, default 32
-   * * p the number of windings around the z axis, optional,  default 2
-   * * q the number of windings around the x axis, optional,  default 3
-   * * sideOrientation optional and takes the values : Mesh.FRONTSIDE (default), Mesh.BACKSIDE or Mesh.DOUBLESIDE
-   * * frontUvs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the front side, optional, default vector4 (0, 0, 1, 1)
-   * * backUVs only usable when you create a double-sided mesh, used to choose what parts of the texture image to crop and apply on the back side, optional, default vector4 (0, 0, 1, 1)
-   * @param options.radius
-   * @param options.tube
-   * @param options.radialSegments
-   * @param options.tubularSegments
-   * @param options.p
-   * @param options.q
-   * @param options.sideOrientation
-   * @param options.frontUVs
-   * @param options.backUVs
-   * @returns the VertexData of the Torus Knot
-   * @deprecated use CreateTorusKnotVertexData instead
-   */
-  static CreateTorusKnot(i) {
-    throw E("torusKnotBuilder");
-  }
-  // Tools
-  /**
-   * Compute normals for given positions and indices
-   * @param positions an array of vertex positions, [...., x, y, z, ......]
-   * @param indices an array of indices in groups of three for each triangular facet, [...., i, j, k, ......]
-   * @param normals an array of vertex normals, [...., x, y, z, ......]
-   * @param options an object used to set the following optional parameters for the TorusKnot, optional
-   * * facetNormals : optional array of facet normals (vector3)
-   * * facetPositions : optional array of facet positions (vector3)
-   * * facetPartitioning : optional partitioning array. facetPositions is required for facetPartitioning computation
-   * * ratio : optional partitioning ratio / bounding box, required for facetPartitioning computation
-   * * bInfo : optional bounding info, required for facetPartitioning computation
-   * * bbSize : optional bounding box size data, required for facetPartitioning computation
-   * * subDiv : optional partitioning data about subdivisions on  each axis (int), required for facetPartitioning computation
-   * * useRightHandedSystem: optional boolean to for right handed system computation
-   * * depthSort : optional boolean to enable the facet depth sort computation
-   * * distanceTo : optional Vector3 to compute the facet depth from this location
-   * * depthSortedFacets : optional array of depthSortedFacets to store the facet distances from the reference location
-   * @param options.facetNormals
-   * @param options.facetPositions
-   * @param options.facetPartitioning
-   * @param options.ratio
-   * @param options.bInfo
-   * @param options.bbSize
-   * @param options.subDiv
-   * @param options.useRightHandedSystem
-   * @param options.depthSort
-   * @param options.distanceTo
-   * @param options.depthSortedFacets
-   */
-  static ComputeNormals(i, e, s, t) {
-    let a = 0, l = 0, c = 0, u = 0, K = 0, f = 0, g = 0, m = 0, d = 0, r = 0, o = 0, v = 0, I = 0, M = 0, P = 0, W = 0, N = 0, x = 0, z = 0, U = 0, Q = !1, k = !1, $ = !1, J = !1, A = 1, V = 0, H = null;
-    t && (Q = !!t.facetNormals, k = !!t.facetPositions, $ = !!t.facetPartitioning, A = t.useRightHandedSystem === !0 ? -1 : 1, V = t.ratio || 0, J = !!t.depthSort, H = t.distanceTo, J && H === void 0 && (H = _.Zero()));
-    let B = 0, S = 0, R = 0, L = 0;
-    for ($ && t && t.bbSize && (B = t.subDiv.X * V / t.bbSize.x, S = t.subDiv.Y * V / t.bbSize.y, R = t.subDiv.Z * V / t.bbSize.z, L = t.subDiv.max * t.subDiv.max, t.facetPartitioning.length = 0), a = 0; a < i.length; a++)
-      s[a] = 0;
-    const p = e.length / 3 | 0;
-    for (a = 0; a < p; a++) {
-      if (v = e[a * 3] * 3, I = v + 1, M = v + 2, P = e[a * 3 + 1] * 3, W = P + 1, N = P + 2, x = e[a * 3 + 2] * 3, z = x + 1, U = x + 2, l = i[v] - i[P], c = i[I] - i[W], u = i[M] - i[N], K = i[x] - i[P], f = i[z] - i[W], g = i[U] - i[N], m = A * (c * g - u * f), d = A * (u * K - l * g), r = A * (l * f - c * K), o = Math.sqrt(m * m + d * d + r * r), o = o === 0 ? 1 : o, m /= o, d /= o, r /= o, Q && t && (t.facetNormals[a].x = m, t.facetNormals[a].y = d, t.facetNormals[a].z = r), k && t && (t.facetPositions[a].x = (i[v] + i[P] + i[x]) / 3, t.facetPositions[a].y = (i[I] + i[W] + i[z]) / 3, t.facetPositions[a].z = (i[M] + i[N] + i[U]) / 3), $ && t) {
-        const Z = Math.floor((t.facetPositions[a].x - t.bInfo.minimum.x * V) * B), q = Math.floor((t.facetPositions[a].y - t.bInfo.minimum.y * V) * S), y = Math.floor((t.facetPositions[a].z - t.bInfo.minimum.z * V) * R), O = Math.floor((i[v] - t.bInfo.minimum.x * V) * B), G = Math.floor((i[I] - t.bInfo.minimum.y * V) * S), ii = Math.floor((i[M] - t.bInfo.minimum.z * V) * R), ti = Math.floor((i[P] - t.bInfo.minimum.x * V) * B), si = Math.floor((i[W] - t.bInfo.minimum.y * V) * S), ei = Math.floor((i[N] - t.bInfo.minimum.z * V) * R), ni = Math.floor((i[x] - t.bInfo.minimum.x * V) * B), ri = Math.floor((i[z] - t.bInfo.minimum.y * V) * S), ai = Math.floor((i[U] - t.bInfo.minimum.z * V) * R), T = O + t.subDiv.max * G + L * ii, D = ti + t.subDiv.max * si + L * ei, w = ni + t.subDiv.max * ri + L * ai, C = Z + t.subDiv.max * q + L * y;
-        t.facetPartitioning[C] = t.facetPartitioning[C] ? t.facetPartitioning[C] : new Array(), t.facetPartitioning[T] = t.facetPartitioning[T] ? t.facetPartitioning[T] : new Array(), t.facetPartitioning[D] = t.facetPartitioning[D] ? t.facetPartitioning[D] : new Array(), t.facetPartitioning[w] = t.facetPartitioning[w] ? t.facetPartitioning[w] : new Array(), t.facetPartitioning[T].push(a), D != T && t.facetPartitioning[D].push(a), w == D || w == T || t.facetPartitioning[w].push(a), C == T || C == D || C == w || t.facetPartitioning[C].push(a);
-      }
-      if (J && t && t.facetPositions) {
-        const Z = t.depthSortedFacets[a];
-        Z.ind = a * 3, Z.sqDistance = _.DistanceSquared(t.facetPositions[a], H);
-      }
-      s[v] += m, s[I] += d, s[M] += r, s[P] += m, s[W] += d, s[N] += r, s[x] += m, s[z] += d, s[U] += r;
-    }
-    for (a = 0; a < s.length / 3; a++)
-      m = s[a * 3], d = s[a * 3 + 1], r = s[a * 3 + 2], o = Math.sqrt(m * m + d * d + r * r), o = o === 0 ? 1 : o, m /= o, d /= o, r /= o, s[a * 3] = m, s[a * 3 + 1] = d, s[a * 3 + 2] = r;
-  }
-  /**
-   * @internal
-   */
-  static _ComputeSides(i, e, s, t, a, l, c) {
-    const u = s.length, K = t.length;
-    let f, g;
-    switch (i = i || h.DEFAULTSIDE, i) {
-      case h.FRONTSIDE:
-        break;
-      case h.BACKSIDE:
-        for (f = 0; f < u; f += 3) {
-          const m = s[f];
-          s[f] = s[f + 2], s[f + 2] = m;
-        }
-        for (g = 0; g < K; g++)
-          t[g] = -t[g];
-        break;
-      case h.DOUBLESIDE: {
-        const m = e.length, d = m / 3;
-        for (let v = 0; v < m; v++)
-          e[m + v] = e[v];
-        for (f = 0; f < u; f += 3)
-          s[f + u] = s[f + 2] + d, s[f + 1 + u] = s[f + 1] + d, s[f + 2 + u] = s[f] + d;
-        for (g = 0; g < K; g++)
-          t[K + g] = -t[g];
-        const r = a.length;
-        let o = 0;
-        for (o = 0; o < r; o++)
-          a[o + r] = a[o];
-        for (l = l || new j(0, 0, 1, 1), c = c || new j(0, 0, 1, 1), o = 0, f = 0; f < r / 2; f++)
-          a[o] = l.x + (l.z - l.x) * a[o], a[o + 1] = l.y + (l.w - l.y) * a[o + 1], a[o + r] = c.x + (c.z - c.x) * a[o + r], a[o + r + 1] = c.y + (c.w - c.y) * a[o + r + 1], o += 2;
-        break;
-      }
-    }
-  }
-  /**
-   * Applies VertexData created from the imported parameters to the geometry
-   * @param parsedVertexData the parsed data from an imported file
-   * @param geometry the geometry to apply the VertexData to
-   */
-  static ImportVertexData(i, e) {
-    const s = new h(), t = i.positions;
-    t && s.set(t, n.PositionKind);
-    const a = i.normals;
-    a && s.set(a, n.NormalKind);
-    const l = i.tangents;
-    l && s.set(l, n.TangentKind);
-    const c = i.uvs;
-    c && s.set(c, n.UVKind);
-    const u = i.uv2s;
-    u && s.set(u, n.UV2Kind);
-    const K = i.uv3s;
-    K && s.set(K, n.UV3Kind);
-    const f = i.uv4s;
-    f && s.set(f, n.UV4Kind);
-    const g = i.uv5s;
-    g && s.set(g, n.UV5Kind);
-    const m = i.uv6s;
-    m && s.set(m, n.UV6Kind);
-    const d = i.colors;
-    d && s.set(ci.CheckColors4(d, t.length / 3), n.ColorKind);
-    const r = i.matricesIndices;
-    r && s.set(r, n.MatricesIndicesKind);
-    const o = i.matricesWeights;
-    o && s.set(o, n.MatricesWeightsKind);
-    const v = i.indices;
-    v && (s.indices = v), e.setAllVerticesData(s, i.updatable);
-  }
-}
-h.FRONTSIDE = 0;
-h.BACKSIDE = 1;
-h.DOUBLESIDE = 2;
-h.DEFAULTSIDE = 0;
-X([
-  Y.filter((...[b]) => !Array.isArray(b))
-], h, "_TransformVector3Coordinates", null);
-X([
-  Y.filter((...[b]) => !Array.isArray(b))
-], h, "_TransformVector3Normals", null);
-X([
-  Y.filter((...[b]) => !Array.isArray(b))
-], h, "_TransformVector4Normals", null);
-X([
-  Y.filter((...[b]) => !Array.isArray(b))
-], h, "_FlipFaces", null);
-export {
-  h as VertexData
-};