@pggis/pg-sdk 3.3.9 → 3.5.0

package/dist/resources/Workers/createWallGeometry.js

@@ -1,7 +1,7 @@
 /**
  * @license
  * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.115
+ * Version 1.132
  *
  * Copyright 2011-2022 Cesium Contributors
  *
@@ -23,468 +23,4 @@
  * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
  */
 
-import {
-  WallGeometryLibrary_default
-} from "./chunk-4DO5W5XZ.js";
-import "./chunk-KKCR2YOP.js";
-import "./chunk-F4HFJMGM.js";
-import {
-  VertexFormat_default
-} from "./chunk-2FWRMUTY.js";
-import "./chunk-FZRIVR7Y.js";
-import "./chunk-SH5USDPI.js";
-import "./chunk-2FRVPMCS.js";
-import "./chunk-Y5UQJLYE.js";
-import {
-  IndexDatatype_default
-} from "./chunk-LPR3YNP2.js";
-import {
-  GeometryAttributes_default
-} from "./chunk-4H7PY4U5.js";
-import {
-  GeometryAttribute_default,
-  Geometry_default,
-  PrimitiveType_default
-} from "./chunk-7TC63SJW.js";
-import {
-  BoundingSphere_default
-} from "./chunk-FJKNFAKQ.js";
-import "./chunk-TTUZP4BO.js";
-import "./chunk-BG4UCVXN.js";
-import "./chunk-YJEBABKH.js";
-import {
-  ComponentDatatype_default
-} from "./chunk-PPH7OFP3.js";
-import {
-  Cartesian3_default,
-  Ellipsoid_default
-} from "./chunk-OGXZVPPM.js";
-import {
-  Math_default
-} from "./chunk-5QULIR53.js";
-import "./chunk-SOWMRMWA.js";
-import "./chunk-STW2DGFI.js";
-import {
-  defaultValue_default
-} from "./chunk-BBWDMCVU.js";
-import {
-  DeveloperError_default
-} from "./chunk-XGI5BXZY.js";
-import {
-  defined_default
-} from "./chunk-YWTJ2B4B.js";
-
-// packages/engine/Source/Core/WallGeometry.js
-var scratchCartesian3Position1 = new Cartesian3_default();
-var scratchCartesian3Position2 = new Cartesian3_default();
-var scratchCartesian3Position4 = new Cartesian3_default();
-var scratchCartesian3Position5 = new Cartesian3_default();
-var scratchBitangent = new Cartesian3_default();
-var scratchTangent = new Cartesian3_default();
-var scratchNormal = new Cartesian3_default();
-function WallGeometry(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  const wallPositions = options.positions;
-  const maximumHeights = options.maximumHeights;
-  const minimumHeights = options.minimumHeights;
-  if (!defined_default(wallPositions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  if (defined_default(maximumHeights) && maximumHeights.length !== wallPositions.length) {
-    throw new DeveloperError_default(
-      "options.positions and options.maximumHeights must have the same length."
-    );
-  }
-  if (defined_default(minimumHeights) && minimumHeights.length !== wallPositions.length) {
-    throw new DeveloperError_default(
-      "options.positions and options.minimumHeights must have the same length."
-    );
-  }
-  const vertexFormat = defaultValue_default(options.vertexFormat, VertexFormat_default.DEFAULT);
-  const granularity = defaultValue_default(
-    options.granularity,
-    Math_default.RADIANS_PER_DEGREE
-  );
-  const ellipsoid = defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84);
-  this._positions = wallPositions;
-  this._minimumHeights = minimumHeights;
-  this._maximumHeights = maximumHeights;
-  this._vertexFormat = VertexFormat_default.clone(vertexFormat);
-  this._granularity = granularity;
-  this._ellipsoid = Ellipsoid_default.clone(ellipsoid);
-  this._workerName = "createWallGeometry";
-  let numComponents = 1 + wallPositions.length * Cartesian3_default.packedLength + 2;
-  if (defined_default(minimumHeights)) {
-    numComponents += minimumHeights.length;
-  }
-  if (defined_default(maximumHeights)) {
-    numComponents += maximumHeights.length;
-  }
-  this.packedLength = numComponents + Ellipsoid_default.packedLength + VertexFormat_default.packedLength + 1;
-}
-WallGeometry.pack = function(value, array, startingIndex) {
-  if (!defined_default(value)) {
-    throw new DeveloperError_default("value is required");
-  }
-  if (!defined_default(array)) {
-    throw new DeveloperError_default("array is required");
-  }
-  startingIndex = defaultValue_default(startingIndex, 0);
-  let i;
-  const positions = value._positions;
-  let length = positions.length;
-  array[startingIndex++] = length;
-  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
-    Cartesian3_default.pack(positions[i], array, startingIndex);
-  }
-  const minimumHeights = value._minimumHeights;
-  length = defined_default(minimumHeights) ? minimumHeights.length : 0;
-  array[startingIndex++] = length;
-  if (defined_default(minimumHeights)) {
-    for (i = 0; i < length; ++i) {
-      array[startingIndex++] = minimumHeights[i];
-    }
-  }
-  const maximumHeights = value._maximumHeights;
-  length = defined_default(maximumHeights) ? maximumHeights.length : 0;
-  array[startingIndex++] = length;
-  if (defined_default(maximumHeights)) {
-    for (i = 0; i < length; ++i) {
-      array[startingIndex++] = maximumHeights[i];
-    }
-  }
-  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
-  startingIndex += Ellipsoid_default.packedLength;
-  VertexFormat_default.pack(value._vertexFormat, array, startingIndex);
-  startingIndex += VertexFormat_default.packedLength;
-  array[startingIndex] = value._granularity;
-  return array;
-};
-var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
-var scratchVertexFormat = new VertexFormat_default();
-var scratchOptions = {
-  positions: void 0,
-  minimumHeights: void 0,
-  maximumHeights: void 0,
-  ellipsoid: scratchEllipsoid,
-  vertexFormat: scratchVertexFormat,
-  granularity: void 0
-};
-WallGeometry.unpack = function(array, startingIndex, result) {
-  if (!defined_default(array)) {
-    throw new DeveloperError_default("array is required");
-  }
-  startingIndex = defaultValue_default(startingIndex, 0);
-  let i;
-  let length = array[startingIndex++];
-  const positions = new Array(length);
-  for (i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
-    positions[i] = Cartesian3_default.unpack(array, startingIndex);
-  }
-  length = array[startingIndex++];
-  let minimumHeights;
-  if (length > 0) {
-    minimumHeights = new Array(length);
-    for (i = 0; i < length; ++i) {
-      minimumHeights[i] = array[startingIndex++];
-    }
-  }
-  length = array[startingIndex++];
-  let maximumHeights;
-  if (length > 0) {
-    maximumHeights = new Array(length);
-    for (i = 0; i < length; ++i) {
-      maximumHeights[i] = array[startingIndex++];
-    }
-  }
-  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
-  startingIndex += Ellipsoid_default.packedLength;
-  const vertexFormat = VertexFormat_default.unpack(
-    array,
-    startingIndex,
-    scratchVertexFormat
-  );
-  startingIndex += VertexFormat_default.packedLength;
-  const granularity = array[startingIndex];
-  if (!defined_default(result)) {
-    scratchOptions.positions = positions;
-    scratchOptions.minimumHeights = minimumHeights;
-    scratchOptions.maximumHeights = maximumHeights;
-    scratchOptions.granularity = granularity;
-    return new WallGeometry(scratchOptions);
-  }
-  result._positions = positions;
-  result._minimumHeights = minimumHeights;
-  result._maximumHeights = maximumHeights;
-  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
-  result._vertexFormat = VertexFormat_default.clone(vertexFormat, result._vertexFormat);
-  result._granularity = granularity;
-  return result;
-};
-WallGeometry.fromConstantHeights = function(options) {
-  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
-  const positions = options.positions;
-  if (!defined_default(positions)) {
-    throw new DeveloperError_default("options.positions is required.");
-  }
-  let minHeights;
-  let maxHeights;
-  const min = options.minimumHeight;
-  const max = options.maximumHeight;
-  const doMin = defined_default(min);
-  const doMax = defined_default(max);
-  if (doMin || doMax) {
-    const length = positions.length;
-    minHeights = doMin ? new Array(length) : void 0;
-    maxHeights = doMax ? new Array(length) : void 0;
-    for (let i = 0; i < length; ++i) {
-      if (doMin) {
-        minHeights[i] = min;
-      }
-      if (doMax) {
-        maxHeights[i] = max;
-      }
-    }
-  }
-  const newOptions = {
-    positions,
-    maximumHeights: maxHeights,
-    minimumHeights: minHeights,
-    ellipsoid: options.ellipsoid,
-    vertexFormat: options.vertexFormat
-  };
-  return new WallGeometry(newOptions);
-};
-WallGeometry.createGeometry = function(wallGeometry) {
-  const wallPositions = wallGeometry._positions;
-  const minimumHeights = wallGeometry._minimumHeights;
-  const maximumHeights = wallGeometry._maximumHeights;
-  const vertexFormat = wallGeometry._vertexFormat;
-  const granularity = wallGeometry._granularity;
-  const ellipsoid = wallGeometry._ellipsoid;
-  const pos = WallGeometryLibrary_default.computePositions(
-    ellipsoid,
-    wallPositions,
-    maximumHeights,
-    minimumHeights,
-    granularity,
-    true
-  );
-  if (!defined_default(pos)) {
-    return;
-  }
-  const bottomPositions = pos.bottomPositions;
-  const topPositions = pos.topPositions;
-  const numCorners = pos.numCorners;
-  let length = topPositions.length;
-  let size = length * 2;
-  const positions = vertexFormat.position ? new Float64Array(size) : void 0;
-  const normals = vertexFormat.normal ? new Float32Array(size) : void 0;
-  const tangents = vertexFormat.tangent ? new Float32Array(size) : void 0;
-  const bitangents = vertexFormat.bitangent ? new Float32Array(size) : void 0;
-  const textureCoordinates = vertexFormat.st ? new Float32Array(size / 3 * 2) : void 0;
-  let positionIndex = 0;
-  let normalIndex = 0;
-  let bitangentIndex = 0;
-  let tangentIndex = 0;
-  let stIndex = 0;
-  let normal = scratchNormal;
-  let tangent = scratchTangent;
-  let bitangent = scratchBitangent;
-  let recomputeNormal = true;
-  length /= 3;
-  let i;
-  let s = 0;
-  const ds = 1 / (length - numCorners - 1);
-  for (i = 0; i < length; ++i) {
-    const i3 = i * 3;
-    const topPosition = Cartesian3_default.fromArray(
-      topPositions,
-      i3,
-      scratchCartesian3Position1
-    );
-    const bottomPosition = Cartesian3_default.fromArray(
-      bottomPositions,
-      i3,
-      scratchCartesian3Position2
-    );
-    if (vertexFormat.position) {
-      positions[positionIndex++] = bottomPosition.x;
-      positions[positionIndex++] = bottomPosition.y;
-      positions[positionIndex++] = bottomPosition.z;
-      positions[positionIndex++] = topPosition.x;
-      positions[positionIndex++] = topPosition.y;
-      positions[positionIndex++] = topPosition.z;
-    }
-    if (vertexFormat.st) {
-      textureCoordinates[stIndex++] = s;
-      textureCoordinates[stIndex++] = 0;
-      textureCoordinates[stIndex++] = s;
-      textureCoordinates[stIndex++] = 1;
-    }
-    if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
-      let nextTop = Cartesian3_default.clone(
-        Cartesian3_default.ZERO,
-        scratchCartesian3Position5
-      );
-      const groundPosition = Cartesian3_default.subtract(
-        topPosition,
-        ellipsoid.geodeticSurfaceNormal(
-          topPosition,
-          scratchCartesian3Position2
-        ),
-        scratchCartesian3Position2
-      );
-      if (i + 1 < length) {
-        nextTop = Cartesian3_default.fromArray(
-          topPositions,
-          i3 + 3,
-          scratchCartesian3Position5
-        );
-      }
-      if (recomputeNormal) {
-        const scalednextPosition = Cartesian3_default.subtract(
-          nextTop,
-          topPosition,
-          scratchCartesian3Position4
-        );
-        const scaledGroundPosition = Cartesian3_default.subtract(
-          groundPosition,
-          topPosition,
-          scratchCartesian3Position1
-        );
-        normal = Cartesian3_default.normalize(
-          Cartesian3_default.cross(scaledGroundPosition, scalednextPosition, normal),
-          normal
-        );
-        recomputeNormal = false;
-      }
-      if (Cartesian3_default.equalsEpsilon(topPosition, nextTop, Math_default.EPSILON10)) {
-        recomputeNormal = true;
-      } else {
-        s += ds;
-        if (vertexFormat.tangent) {
-          tangent = Cartesian3_default.normalize(
-            Cartesian3_default.subtract(nextTop, topPosition, tangent),
-            tangent
-          );
-        }
-        if (vertexFormat.bitangent) {
-          bitangent = Cartesian3_default.normalize(
-            Cartesian3_default.cross(normal, tangent, bitangent),
-            bitangent
-          );
-        }
-      }
-      if (vertexFormat.normal) {
-        normals[normalIndex++] = normal.x;
-        normals[normalIndex++] = normal.y;
-        normals[normalIndex++] = normal.z;
-        normals[normalIndex++] = normal.x;
-        normals[normalIndex++] = normal.y;
-        normals[normalIndex++] = normal.z;
-      }
-      if (vertexFormat.tangent) {
-        tangents[tangentIndex++] = tangent.x;
-        tangents[tangentIndex++] = tangent.y;
-        tangents[tangentIndex++] = tangent.z;
-        tangents[tangentIndex++] = tangent.x;
-        tangents[tangentIndex++] = tangent.y;
-        tangents[tangentIndex++] = tangent.z;
-      }
-      if (vertexFormat.bitangent) {
-        bitangents[bitangentIndex++] = bitangent.x;
-        bitangents[bitangentIndex++] = bitangent.y;
-        bitangents[bitangentIndex++] = bitangent.z;
-        bitangents[bitangentIndex++] = bitangent.x;
-        bitangents[bitangentIndex++] = bitangent.y;
-        bitangents[bitangentIndex++] = bitangent.z;
-      }
-    }
-  }
-  const attributes = new GeometryAttributes_default();
-  if (vertexFormat.position) {
-    attributes.position = new GeometryAttribute_default({
-      componentDatatype: ComponentDatatype_default.DOUBLE,
-      componentsPerAttribute: 3,
-      values: positions
-    });
-  }
-  if (vertexFormat.normal) {
-    attributes.normal = new GeometryAttribute_default({
-      componentDatatype: ComponentDatatype_default.FLOAT,
-      componentsPerAttribute: 3,
-      values: normals
-    });
-  }
-  if (vertexFormat.tangent) {
-    attributes.tangent = new GeometryAttribute_default({
-      componentDatatype: ComponentDatatype_default.FLOAT,
-      componentsPerAttribute: 3,
-      values: tangents
-    });
-  }
-  if (vertexFormat.bitangent) {
-    attributes.bitangent = new GeometryAttribute_default({
-      componentDatatype: ComponentDatatype_default.FLOAT,
-      componentsPerAttribute: 3,
-      values: bitangents
-    });
-  }
-  if (vertexFormat.st) {
-    attributes.st = new GeometryAttribute_default({
-      componentDatatype: ComponentDatatype_default.FLOAT,
-      componentsPerAttribute: 2,
-      values: textureCoordinates
-    });
-  }
-  const numVertices = size / 3;
-  size -= 6 * (numCorners + 1);
-  const indices = IndexDatatype_default.createTypedArray(numVertices, size);
-  let edgeIndex = 0;
-  for (i = 0; i < numVertices - 2; i += 2) {
-    const LL = i;
-    const LR = i + 2;
-    const pl = Cartesian3_default.fromArray(
-      positions,
-      LL * 3,
-      scratchCartesian3Position1
-    );
-    const pr = Cartesian3_default.fromArray(
-      positions,
-      LR * 3,
-      scratchCartesian3Position2
-    );
-    if (Cartesian3_default.equalsEpsilon(pl, pr, Math_default.EPSILON10)) {
-      continue;
-    }
-    const UL = i + 1;
-    const UR = i + 3;
-    indices[edgeIndex++] = UL;
-    indices[edgeIndex++] = LL;
-    indices[edgeIndex++] = UR;
-    indices[edgeIndex++] = UR;
-    indices[edgeIndex++] = LL;
-    indices[edgeIndex++] = LR;
-  }
-  return new Geometry_default({
-    attributes,
-    indices,
-    primitiveType: PrimitiveType_default.TRIANGLES,
-    boundingSphere: new BoundingSphere_default.fromVertices(positions)
-  });
-};
-var WallGeometry_default = WallGeometry;
-
-// packages/engine/Source/Workers/createWallGeometry.js
-function createWallGeometry(wallGeometry, offset) {
-  if (defined_default(offset)) {
-    wallGeometry = WallGeometry_default.unpack(wallGeometry, offset);
-  }
-  wallGeometry._ellipsoid = Ellipsoid_default.clone(wallGeometry._ellipsoid);
-  return WallGeometry_default.createGeometry(wallGeometry);
-}
-var createWallGeometry_default = createWallGeometry;
-export {
-  createWallGeometry_default as default
-};
+import{a as nt}from"./chunk-NB3ML6JO.js";import"./chunk-XRL4AVS5.js";import"./chunk-U4IEOH5K.js";import{a as w}from"./chunk-CYCB63OH.js";import"./chunk-3W4GT7KQ.js";import"./chunk-G5AGHVVC.js";import"./chunk-DMEY62ID.js";import"./chunk-HTFSEEMT.js";import{a as ot}from"./chunk-OFUUQVMR.js";import{a as it}from"./chunk-A56XVLQR.js";import{b as tt,c as et,d as R}from"./chunk-RCV6KWXS.js";import{d as I}from"./chunk-4IW2T6GF.js";import"./chunk-PSPPBZWI.js";import{a as N}from"./chunk-AU7IKHOH.js";import{a as s,d as l,f as K}from"./chunk-64RSHJUE.js";import{a as V}from"./chunk-3SSKC3VN.js";import"./chunk-OSW76XDF.js";import"./chunk-ED5JPB3S.js";import{a as y}from"./chunk-LEYMRMBK.js";import{e as r}from"./chunk-VTAIKJXX.js";var Q=new s,J=new s,lt=new s,st=new s,pt=new s,ut=new s,ft=new s;function E(t){t=t??K.EMPTY_OBJECT;let e=t.positions,o=t.maximumHeights,n=t.minimumHeights;if(!r(e))throw new y("options.positions is required.");if(r(o)&&o.length!==e.length)throw new y("options.positions and options.maximumHeights must have the same length.");if(r(n)&&n.length!==e.length)throw new y("options.positions and options.minimumHeights must have the same length.");let i=t.vertexFormat??w.DEFAULT,c=t.granularity??V.RADIANS_PER_DEGREE,a=t.ellipsoid??l.default;this._positions=e,this._minimumHeights=n,this._maximumHeights=o,this._vertexFormat=w.clone(i),this._granularity=c,this._ellipsoid=l.clone(a),this._workerName="createWallGeometry";let m=1+e.length*s.packedLength+2;r(n)&&(m+=n.length),r(o)&&(m+=o.length),this.packedLength=m+l.packedLength+w.packedLength+1}E.pack=function(t,e,o){if(!r(t))throw new y("value is required");if(!r(e))throw new y("array is required");o=o??0;let n,i=t._positions,c=i.length;for(e[o++]=c,n=0;n<c;++n,o+=s.packedLength)s.pack(i[n],e,o);let a=t._minimumHeights;if(c=r(a)?a.length:0,e[o++]=c,r(a))for(n=0;n<c;++n)e[o++]=a[n];let m=t._maximumHeights;if(c=r(m)?m.length:0,e[o++]=c,r(m))for(n=0;n<c;++n)e[o++]=m[n];return l.pack(t._ellipsoid,e,o),o+=l.packedLength,w.pack(t._vertexFormat,e,o),o+=w.packedLength,e[o]=t._granularity,e};var mt=l.clone(l.UNIT_SPHERE),rt=new w,U={positions:void 0,minimumHeights:void 0,maximumHeights:void 0,ellipsoid:mt,vertexFormat:rt,granularity:void 0};E.unpack=function(t,e,o){if(!r(t))throw new y("array is required");e=e??0;let n,i=t[e++],c=new Array(i);for(n=0;n<i;++n,e+=s.packedLength)c[n]=s.unpack(t,e);i=t[e++];let a;if(i>0)for(a=new Array(i),n=0;n<i;++n)a[n]=t[e++];i=t[e++];let m;if(i>0)for(m=new Array(i),n=0;n<i;++n)m[n]=t[e++];let S=l.unpack(t,e,mt);e+=l.packedLength;let _=w.unpack(t,e,rt);e+=w.packedLength;let f=t[e];return r(o)?(o._positions=c,o._minimumHeights=a,o._maximumHeights=m,o._ellipsoid=l.clone(S,o._ellipsoid),o._vertexFormat=w.clone(_,o._vertexFormat),o._granularity=f,o):(U.positions=c,U.minimumHeights=a,U.maximumHeights=m,U.granularity=f,new E(U))};E.fromConstantHeights=function(t){t=t??K.EMPTY_OBJECT;let e=t.positions;if(!r(e))throw new y("options.positions is required.");let o,n,i=t.minimumHeight,c=t.maximumHeight,a=r(i),m=r(c);if(a||m){let _=e.length;o=a?new Array(_):void 0,n=m?new Array(_):void 0;for(let f=0;f<_;++f)a&&(o[f]=i),m&&(n[f]=c)}let S={positions:e,maximumHeights:n,minimumHeights:o,ellipsoid:t.ellipsoid,vertexFormat:t.vertexFormat};return new E(S)};E.createGeometry=function(t){let e=t._positions,o=t._minimumHeights,n=t._maximumHeights,i=t._vertexFormat,c=t._granularity,a=t._ellipsoid,m=nt.computePositions(a,e,n,o,c,!0);if(!r(m))return;let S=m.bottomPositions,_=m.topPositions,f=m.numCorners,q=_.length,A=q*2,h=i.position?new Float64Array(A):void 0,P=i.normal?new Float32Array(A):void 0,b=i.tangent?new Float32Array(A):void 0,x=i.bitangent?new Float32Array(A):void 0,B=i.st?new Float32Array(A/3*2):void 0,k=0,v=0,T=0,C=0,W=0,g=ft,d=ut,H=pt,Y=!0;q/=3;let p,Z=0,ct=1/(q-f-1);for(p=0;p<q;++p){let L=p*3,u=s.fromArray(_,L,Q),M=s.fromArray(S,L,J);if(i.position&&(h[k++]=M.x,h[k++]=M.y,h[k++]=M.z,h[k++]=u.x,h[k++]=u.y,h[k++]=u.z),i.st&&(B[W++]=Z,B[W++]=0,B[W++]=Z,B[W++]=1),i.normal||i.tangent||i.bitangent){let O=s.clone(s.ZERO,st),j=s.subtract(u,a.geodeticSurfaceNormal(u,J),J);if(p+1<q&&(O=s.fromArray(_,L+3,st)),Y){let G=s.subtract(O,u,lt),at=s.subtract(j,u,Q);g=s.normalize(s.cross(at,G,g),g),Y=!1}s.equalsEpsilon(u,O,V.EPSILON10)?Y=!0:(Z+=ct,i.tangent&&(d=s.normalize(s.subtract(O,u,d),d)),i.bitangent&&(H=s.normalize(s.cross(g,d,H),H))),i.normal&&(P[v++]=g.x,P[v++]=g.y,P[v++]=g.z,P[v++]=g.x,P[v++]=g.y,P[v++]=g.z),i.tangent&&(b[C++]=d.x,b[C++]=d.y,b[C++]=d.z,b[C++]=d.x,b[C++]=d.y,b[C++]=d.z),i.bitangent&&(x[T++]=H.x,x[T++]=H.y,x[T++]=H.z,x[T++]=H.x,x[T++]=H.y,x[T++]=H.z)}}let z=new it;i.position&&(z.position=new R({componentDatatype:N.DOUBLE,componentsPerAttribute:3,values:h})),i.normal&&(z.normal=new R({componentDatatype:N.FLOAT,componentsPerAttribute:3,values:P})),i.tangent&&(z.tangent=new R({componentDatatype:N.FLOAT,componentsPerAttribute:3,values:b})),i.bitangent&&(z.bitangent=new R({componentDatatype:N.FLOAT,componentsPerAttribute:3,values:x})),i.st&&(z.st=new R({componentDatatype:N.FLOAT,componentsPerAttribute:2,values:B}));let $=A/3;A-=6*(f+1);let F=ot.createTypedArray($,A),D=0;for(p=0;p<$-2;p+=2){let L=p,u=p+2,M=s.fromArray(h,L*3,Q),O=s.fromArray(h,u*3,J);if(s.equalsEpsilon(M,O,V.EPSILON10))continue;let j=p+1,G=p+3;F[D++]=j,F[D++]=L,F[D++]=G,F[D++]=G,F[D++]=L,F[D++]=u}return new et({attributes:z,indices:F,primitiveType:tt.TRIANGLES,boundingSphere:new I.fromVertices(h)})};var X=E;function ht(t,e){return r(e)&&(t=X.unpack(t,e)),t._ellipsoid=l.clone(t._ellipsoid),X.createGeometry(t)}var Ot=ht;export{Ot as default};