@vcmap/ui 5.0.0-rc.30 → 5.0.0-rc.31

package/dist/assets/cesium/Workers/createCorridorOutlineGeometry.js

@@ -1,120 +1,174 @@
-define(['./arrayRemoveDuplicates-d2061e85', './Transforms-a2a85221', './Matrix3-41c58dde', './Check-6ede7e26', './ComponentDatatype-cf1fa08e', './PolylineVolumeGeometryLibrary-b73549fb', './CorridorGeometryLibrary-7b94502b', './defaultValue-fe22d8c0', './GeometryAttribute-ff5b4fb1', './GeometryAttributes-ad136444', './GeometryOffsetAttribute-9ad0019c', './IndexDatatype-2643aa47', './Math-0a2ac845', './PolygonPipeline-b9f2810a', './Matrix2-e1298525', './RuntimeError-ef395448', './combine-d9581036', './WebGLConstants-0b1ce7ba', './EllipsoidTangentPlane-6dd1b7af', './AxisAlignedBoundingBox-4140c51f', './IntersectionTests-70d39ba9', './Plane-4c3d403b', './PolylinePipeline-639192e0', './EllipsoidGeodesic-5b3623dc', './EllipsoidRhumbLine-ef872433'], (function (arrayRemoveDuplicates, Transforms, Matrix3, Check, ComponentDatatype, PolylineVolumeGeometryLibrary, CorridorGeometryLibrary, defaultValue, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype, Math$1, PolygonPipeline, Matrix2, RuntimeError, combine$1, WebGLConstants, EllipsoidTangentPlane, AxisAlignedBoundingBox, IntersectionTests, Plane, PolylinePipeline, EllipsoidGeodesic, EllipsoidRhumbLine) { 'use strict';
-
-  const cartesian1 = new Matrix3.Cartesian3();
-  const cartesian2 = new Matrix3.Cartesian3();
-  const cartesian3 = new Matrix3.Cartesian3();
-
-  function scaleToSurface(positions, ellipsoid) {
-    for (let i = 0; i < positions.length; i++) {
-      positions[i] = ellipsoid.scaleToGeodeticSurface(positions[i], positions[i]);
-    }
-    return positions;
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.109.3
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import {
+  CorridorGeometryLibrary_default
+} from "./chunk-C3SXRKRW.js";
+import {
+  CornerType_default
+} from "./chunk-V3NGATMV.js";
+import "./chunk-GLZBE3ML.js";
+import "./chunk-AFFLIKOH.js";
+import {
+  GeometryOffsetAttribute_default
+} from "./chunk-MPAZH4BF.js";
+import "./chunk-RP2A7BR5.js";
+import "./chunk-2R5O53JW.js";
+import {
+  PolygonPipeline_default
+} from "./chunk-J3JY6I2C.js";
+import {
+  arrayRemoveDuplicates_default
+} from "./chunk-3W63OHNJ.js";
+import "./chunk-K36FEYS7.js";
+import "./chunk-MYZB7C4T.js";
+import "./chunk-OYFCF4PL.js";
+import {
+  IndexDatatype_default
+} from "./chunk-RW6LU2CJ.js";
+import {
+  GeometryAttributes_default
+} from "./chunk-EW2GWJYB.js";
+import {
+  GeometryAttribute_default,
+  Geometry_default,
+  PrimitiveType_default
+} from "./chunk-X4SU25DT.js";
+import {
+  BoundingSphere_default
+} from "./chunk-PFQBCKBM.js";
+import "./chunk-QJ3DFBH3.js";
+import "./chunk-DUHWWBQQ.js";
+import {
+  ComponentDatatype_default
+} from "./chunk-LLUNNUJV.js";
+import {
+  Cartesian3_default,
+  Ellipsoid_default
+} from "./chunk-PCJWUS4M.js";
+import {
+  Math_default
+} from "./chunk-N3JIFFX2.js";
+import "./chunk-AHKEZ2OE.js";
+import "./chunk-ABADGKYE.js";
+import {
+  defaultValue_default
+} from "./chunk-WXTV4ATB.js";
+import {
+  Check_default
+} from "./chunk-4MFFIWUA.js";
+import {
+  defined_default
+} from "./chunk-6BTKZDRG.js";
+
+// packages/engine/Source/Core/CorridorOutlineGeometry.js
+var cartesian1 = new Cartesian3_default();
+var cartesian2 = new Cartesian3_default();
+var cartesian3 = new Cartesian3_default();
+function scaleToSurface(positions, ellipsoid) {
+  for (let i = 0; i < positions.length; i++) {
+    positions[i] = ellipsoid.scaleToGeodeticSurface(positions[i], positions[i]);
   }
-
-  function combine(computedPositions, cornerType) {
-    const wallIndices = [];
-    const positions = computedPositions.positions;
-    const corners = computedPositions.corners;
-    const endPositions = computedPositions.endPositions;
-    const attributes = new GeometryAttributes.GeometryAttributes();
-    let corner;
-    let leftCount = 0;
-    let rightCount = 0;
-    let i;
-    let indicesLength = 0;
-    let length;
-    for (i = 0; i < positions.length; i += 2) {
-      length = positions[i].length - 3;
-      leftCount += length; //subtracting 3 to account for duplicate points at corners
-      indicesLength += (length / 3) * 4;
-      rightCount += positions[i + 1].length - 3;
-    }
-    leftCount += 3; //add back count for end positions
-    rightCount += 3;
-    for (i = 0; i < corners.length; i++) {
-      corner = corners[i];
-      const leftSide = corners[i].leftPositions;
-      if (defaultValue.defined(leftSide)) {
-        length = leftSide.length;
-        leftCount += length;
-        indicesLength += (length / 3) * 2;
-      } else {
-        length = corners[i].rightPositions.length;
-        rightCount += length;
-        indicesLength += (length / 3) * 2;
-      }
-    }
-
-    const addEndPositions = defaultValue.defined(endPositions);
-    let endPositionLength;
-    if (addEndPositions) {
-      endPositionLength = endPositions[0].length - 3;
-      leftCount += endPositionLength;
-      rightCount += endPositionLength;
-      endPositionLength /= 3;
-      indicesLength += endPositionLength * 4;
-    }
-    const size = leftCount + rightCount;
-    const finalPositions = new Float64Array(size);
-    let front = 0;
-    let back = size - 1;
-    let UL, LL, UR, LR;
-    let rightPos, leftPos;
-    const halfLength = endPositionLength / 2;
-
-    const indices = IndexDatatype.IndexDatatype.createTypedArray(size / 3, indicesLength + 4);
-    let index = 0;
-
-    indices[index++] = front / 3;
-    indices[index++] = (back - 2) / 3;
-    if (addEndPositions) {
-      // add rounded end
-      wallIndices.push(front / 3);
-      leftPos = cartesian1;
-      rightPos = cartesian2;
-      const firstEndPositions = endPositions[0];
-      for (i = 0; i < halfLength; i++) {
-        leftPos = Matrix3.Cartesian3.fromArray(
-          firstEndPositions,
-          (halfLength - 1 - i) * 3,
-          leftPos
-        );
-        rightPos = Matrix3.Cartesian3.fromArray(
-          firstEndPositions,
-          (halfLength + i) * 3,
-          rightPos
-        );
-        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(finalPositions, rightPos, front);
-        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
-          finalPositions,
-          leftPos,
-          undefined,
-          back
-        );
-
-        LL = front / 3;
-        LR = LL + 1;
-        UL = (back - 2) / 3;
-        UR = UL - 1;
-        indices[index++] = UL;
-        indices[index++] = UR;
-        indices[index++] = LL;
-        indices[index++] = LR;
-
-        front += 3;
-        back -= 3;
-      }
+  return positions;
+}
+function combine(computedPositions, cornerType) {
+  const wallIndices = [];
+  const positions = computedPositions.positions;
+  const corners = computedPositions.corners;
+  const endPositions = computedPositions.endPositions;
+  const attributes = new GeometryAttributes_default();
+  let corner;
+  let leftCount = 0;
+  let rightCount = 0;
+  let i;
+  let indicesLength = 0;
+  let length;
+  for (i = 0; i < positions.length; i += 2) {
+    length = positions[i].length - 3;
+    leftCount += length;
+    indicesLength += length / 3 * 4;
+    rightCount += positions[i + 1].length - 3;
+  }
+  leftCount += 3;
+  rightCount += 3;
+  for (i = 0; i < corners.length; i++) {
+    corner = corners[i];
+    const leftSide = corners[i].leftPositions;
+    if (defined_default(leftSide)) {
+      length = leftSide.length;
+      leftCount += length;
+      indicesLength += length / 3 * 2;
+    } else {
+      length = corners[i].rightPositions.length;
+      rightCount += length;
+      indicesLength += length / 3 * 2;
     }
-
-    let posIndex = 0;
-    let rightEdge = positions[posIndex++]; //add first two edges
-    let leftEdge = positions[posIndex++];
-    finalPositions.set(rightEdge, front);
-    finalPositions.set(leftEdge, back - leftEdge.length + 1);
-
-    length = leftEdge.length - 3;
-    wallIndices.push(front / 3, (back - 2) / 3);
-    for (i = 0; i < length; i += 3) {
+  }
+  const addEndPositions = defined_default(endPositions);
+  let endPositionLength;
+  if (addEndPositions) {
+    endPositionLength = endPositions[0].length - 3;
+    leftCount += endPositionLength;
+    rightCount += endPositionLength;
+    endPositionLength /= 3;
+    indicesLength += endPositionLength * 4;
+  }
+  const size = leftCount + rightCount;
+  const finalPositions = new Float64Array(size);
+  let front = 0;
+  let back = size - 1;
+  let UL, LL, UR, LR;
+  let rightPos, leftPos;
+  const halfLength = endPositionLength / 2;
+  const indices = IndexDatatype_default.createTypedArray(size / 3, indicesLength + 4);
+  let index = 0;
+  indices[index++] = front / 3;
+  indices[index++] = (back - 2) / 3;
+  if (addEndPositions) {
+    wallIndices.push(front / 3);
+    leftPos = cartesian1;
+    rightPos = cartesian2;
+    const firstEndPositions = endPositions[0];
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength - 1 - i) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(
+        firstEndPositions,
+        (halfLength + i) * 3,
+        rightPos
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
       LL = front / 3;
       LR = LL + 1;
       UL = (back - 2) / 3;
@@ -123,481 +177,391 @@ define(['./arrayRemoveDuplicates-d2061e85', './Transforms-a2a85221', './Matrix3-
       indices[index++] = UR;
       indices[index++] = LL;
       indices[index++] = LR;
-
       front += 3;
       back -= 3;
     }
-
-    for (i = 0; i < corners.length; i++) {
-      let j;
-      corner = corners[i];
-      const l = corner.leftPositions;
-      const r = corner.rightPositions;
-      let start;
-      let outsidePoint = cartesian3;
-      if (defaultValue.defined(l)) {
-        back -= 3;
-        start = UR;
-        wallIndices.push(LR);
-        for (j = 0; j < l.length / 3; j++) {
-          outsidePoint = Matrix3.Cartesian3.fromArray(l, j * 3, outsidePoint);
-          indices[index++] = start - j - 1;
-          indices[index++] = start - j;
-          CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
-            finalPositions,
-            outsidePoint,
-            undefined,
-            back
-          );
-          back -= 3;
-        }
-        wallIndices.push(start - Math.floor(l.length / 6));
-        if (cornerType === PolylineVolumeGeometryLibrary.CornerType.BEVELED) {
-          wallIndices.push((back - 2) / 3 + 1);
-        }
-        front += 3;
-      } else {
-        front += 3;
-        start = LR;
-        wallIndices.push(UR);
-        for (j = 0; j < r.length / 3; j++) {
-          outsidePoint = Matrix3.Cartesian3.fromArray(r, j * 3, outsidePoint);
-          indices[index++] = start + j;
-          indices[index++] = start + j + 1;
-          CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
-            finalPositions,
-            outsidePoint,
-            front
-          );
-          front += 3;
-        }
-        wallIndices.push(start + Math.floor(r.length / 6));
-        if (cornerType === PolylineVolumeGeometryLibrary.CornerType.BEVELED) {
-          wallIndices.push(front / 3 - 1);
-        }
+  }
+  let posIndex = 0;
+  let rightEdge = positions[posIndex++];
+  let leftEdge = positions[posIndex++];
+  finalPositions.set(rightEdge, front);
+  finalPositions.set(leftEdge, back - leftEdge.length + 1);
+  length = leftEdge.length - 3;
+  wallIndices.push(front / 3, (back - 2) / 3);
+  for (i = 0; i < length; i += 3) {
+    LL = front / 3;
+    LR = LL + 1;
+    UL = (back - 2) / 3;
+    UR = UL - 1;
+    indices[index++] = UL;
+    indices[index++] = UR;
+    indices[index++] = LL;
+    indices[index++] = LR;
+    front += 3;
+    back -= 3;
+  }
+  for (i = 0; i < corners.length; i++) {
+    let j;
+    corner = corners[i];
+    const l = corner.leftPositions;
+    const r = corner.rightPositions;
+    let start;
+    let outsidePoint = cartesian3;
+    if (defined_default(l)) {
+      back -= 3;
+      start = UR;
+      wallIndices.push(LR);
+      for (j = 0; j < l.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(l, j * 3, outsidePoint);
+        indices[index++] = start - j - 1;
+        indices[index++] = start - j;
+        CorridorGeometryLibrary_default.addAttribute(
+          finalPositions,
+          outsidePoint,
+          void 0,
+          back
+        );
         back -= 3;
       }
-      rightEdge = positions[posIndex++];
-      leftEdge = positions[posIndex++];
-      rightEdge.splice(0, 3); //remove duplicate points added by corner
-      leftEdge.splice(leftEdge.length - 3, 3);
-      finalPositions.set(rightEdge, front);
-      finalPositions.set(leftEdge, back - leftEdge.length + 1);
-      length = leftEdge.length - 3;
-
-      for (j = 0; j < leftEdge.length; j += 3) {
-        LR = front / 3;
-        LL = LR - 1;
-        UR = (back - 2) / 3;
-        UL = UR + 1;
-        indices[index++] = UL;
-        indices[index++] = UR;
-        indices[index++] = LL;
-        indices[index++] = LR;
-        front += 3;
-        back -= 3;
+      wallIndices.push(start - Math.floor(l.length / 6));
+      if (cornerType === CornerType_default.BEVELED) {
+        wallIndices.push((back - 2) / 3 + 1);
       }
-      front -= 3;
-      back += 3;
-      wallIndices.push(front / 3, (back - 2) / 3);
-    }
-
-    if (addEndPositions) {
-      // add rounded end
       front += 3;
-      back -= 3;
-      leftPos = cartesian1;
-      rightPos = cartesian2;
-      const lastEndPositions = endPositions[1];
-      for (i = 0; i < halfLength; i++) {
-        leftPos = Matrix3.Cartesian3.fromArray(
-          lastEndPositions,
-          (endPositionLength - i - 1) * 3,
-          leftPos
-        );
-        rightPos = Matrix3.Cartesian3.fromArray(lastEndPositions, i * 3, rightPos);
-        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(
+    } else {
+      front += 3;
+      start = LR;
+      wallIndices.push(UR);
+      for (j = 0; j < r.length / 3; j++) {
+        outsidePoint = Cartesian3_default.fromArray(r, j * 3, outsidePoint);
+        indices[index++] = start + j;
+        indices[index++] = start + j + 1;
+        CorridorGeometryLibrary_default.addAttribute(
           finalPositions,
-          leftPos,
-          undefined,
-          back
+          outsidePoint,
+          front
         );
-        CorridorGeometryLibrary.CorridorGeometryLibrary.addAttribute(finalPositions, rightPos, front);
-
-        LR = front / 3;
-        LL = LR - 1;
-        UR = (back - 2) / 3;
-        UL = UR + 1;
-        indices[index++] = UL;
-        indices[index++] = UR;
-        indices[index++] = LL;
-        indices[index++] = LR;
-
         front += 3;
-        back -= 3;
       }
-
-      wallIndices.push(front / 3);
-    } else {
-      wallIndices.push(front / 3, (back - 2) / 3);
-    }
-    indices[index++] = front / 3;
-    indices[index++] = (back - 2) / 3;
-
-    attributes.position = new GeometryAttribute.GeometryAttribute({
-      componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
-      componentsPerAttribute: 3,
-      values: finalPositions,
-    });
-
-    return {
-      attributes: attributes,
-      indices: indices,
-      wallIndices: wallIndices,
-    };
-  }
-
-  function computePositionsExtruded(params) {
-    const ellipsoid = params.ellipsoid;
-    const computedPositions = CorridorGeometryLibrary.CorridorGeometryLibrary.computePositions(params);
-    const attr = combine(computedPositions, params.cornerType);
-    const wallIndices = attr.wallIndices;
-    const height = params.height;
-    const extrudedHeight = params.extrudedHeight;
-    const attributes = attr.attributes;
-    const indices = attr.indices;
-    let positions = attributes.position.values;
-    let length = positions.length;
-    let extrudedPositions = new Float64Array(length);
-    extrudedPositions.set(positions);
-    const newPositions = new Float64Array(length * 2);
-
-    positions = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
-      positions,
-      height,
-      ellipsoid
-    );
-    extrudedPositions = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
-      extrudedPositions,
-      extrudedHeight,
-      ellipsoid
-    );
-    newPositions.set(positions);
-    newPositions.set(extrudedPositions, length);
-    attributes.position.values = newPositions;
-
-    length /= 3;
-    if (defaultValue.defined(params.offsetAttribute)) {
-      let applyOffset = new Uint8Array(length * 2);
-      if (params.offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.TOP) {
-        applyOffset = applyOffset.fill(1, 0, length);
-      } else {
-        const applyOffsetValue =
-          params.offsetAttribute === GeometryOffsetAttribute.GeometryOffsetAttribute.NONE ? 0 : 1;
-        applyOffset = applyOffset.fill(applyOffsetValue);
+      wallIndices.push(start + Math.floor(r.length / 6));
+      if (cornerType === CornerType_default.BEVELED) {
+        wallIndices.push(front / 3 - 1);
       }
-
-      attributes.applyOffset = new GeometryAttribute.GeometryAttribute({
-        componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
-        componentsPerAttribute: 1,
-        values: applyOffset,
-      });
-    }
-
-    let i;
-    const iLength = indices.length;
-    const newIndices = IndexDatatype.IndexDatatype.createTypedArray(
-      newPositions.length / 3,
-      (iLength + wallIndices.length) * 2
-    );
-    newIndices.set(indices);
-    let index = iLength;
-    for (i = 0; i < iLength; i += 2) {
-      // bottom indices
-      const v0 = indices[i];
-      const v1 = indices[i + 1];
-      newIndices[index++] = v0 + length;
-      newIndices[index++] = v1 + length;
+      back -= 3;
     }
-
-    let UL, LL;
-    for (i = 0; i < wallIndices.length; i++) {
-      //wall indices
-      UL = wallIndices[i];
-      LL = UL + length;
-      newIndices[index++] = UL;
-      newIndices[index++] = LL;
+    rightEdge = positions[posIndex++];
+    leftEdge = positions[posIndex++];
+    rightEdge.splice(0, 3);
+    leftEdge.splice(leftEdge.length - 3, 3);
+    finalPositions.set(rightEdge, front);
+    finalPositions.set(leftEdge, back - leftEdge.length + 1);
+    length = leftEdge.length - 3;
+    for (j = 0; j < leftEdge.length; j += 3) {
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
     }
-
-    return {
-      attributes: attributes,
-      indices: newIndices,
-    };
-  }
-
-  /**
-   * A description of a corridor outline.
-   *
-   * @alias CorridorOutlineGeometry
-   * @constructor
-   *
-   * @param {object} options Object with the following properties:
-   * @param {Cartesian3[]} options.positions An array of positions that define the center of the corridor outline.
-   * @param {number} options.width The distance between the edges of the corridor outline.
-   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
-   * @param {number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
-   * @param {number} [options.height=0] The distance in meters between the positions and the ellipsoid surface.
-   * @param {number} [options.extrudedHeight] The distance in meters between the extruded face and the ellipsoid surface.
-   * @param {CornerType} [options.cornerType=CornerType.ROUNDED] Determines the style of the corners.
-   *
-   * @see CorridorOutlineGeometry.createGeometry
-   *
-   * @example
-   * const corridor = new Cesium.CorridorOutlineGeometry({
-   *   positions : Cesium.Cartesian3.fromDegreesArray([-72.0, 40.0, -70.0, 35.0]),
-   *   width : 100000
-   * });
-   */
-  function CorridorOutlineGeometry(options) {
-    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
-    const positions = options.positions;
-    const width = options.width;
-
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("options.positions", positions);
-    Check.Check.typeOf.number("options.width", width);
-    //>>includeEnd('debug');
-
-    const height = defaultValue.defaultValue(options.height, 0.0);
-    const extrudedHeight = defaultValue.defaultValue(options.extrudedHeight, height);
-
-    this._positions = positions;
-    this._ellipsoid = Matrix3.Ellipsoid.clone(
-      defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84)
-    );
-    this._width = width;
-    this._height = Math.max(height, extrudedHeight);
-    this._extrudedHeight = Math.min(height, extrudedHeight);
-    this._cornerType = defaultValue.defaultValue(options.cornerType, PolylineVolumeGeometryLibrary.CornerType.ROUNDED);
-    this._granularity = defaultValue.defaultValue(
-      options.granularity,
-      Math$1.CesiumMath.RADIANS_PER_DEGREE
-    );
-    this._offsetAttribute = options.offsetAttribute;
-    this._workerName = "createCorridorOutlineGeometry";
-
-    /**
-     * The number of elements used to pack the object into an array.
-     * @type {number}
-     */
-    this.packedLength =
-      1 + positions.length * Matrix3.Cartesian3.packedLength + Matrix3.Ellipsoid.packedLength + 6;
+    front -= 3;
+    back += 3;
+    wallIndices.push(front / 3, (back - 2) / 3);
   }
-
-  /**
-   * Stores the provided instance into the provided array.
-   *
-   * @param {CorridorOutlineGeometry} value The value to pack.
-   * @param {number[]} array The array to pack into.
-   * @param {number} [startingIndex=0] The index into the array at which to start packing the elements.
-   *
-   * @returns {number[]} The array that was packed into
-   */
-  CorridorOutlineGeometry.pack = function (value, array, startingIndex) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("value", value);
-    Check.Check.typeOf.object("array", array);
-    //>>includeEnd('debug');
-
-    startingIndex = defaultValue.defaultValue(startingIndex, 0);
-
-    const positions = value._positions;
-    const length = positions.length;
-    array[startingIndex++] = length;
-
-    for (let i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
-      Matrix3.Cartesian3.pack(positions[i], array, startingIndex);
-    }
-
-    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
-    startingIndex += Matrix3.Ellipsoid.packedLength;
-
-    array[startingIndex++] = value._width;
-    array[startingIndex++] = value._height;
-    array[startingIndex++] = value._extrudedHeight;
-    array[startingIndex++] = value._cornerType;
-    array[startingIndex++] = value._granularity;
-    array[startingIndex] = defaultValue.defaultValue(value._offsetAttribute, -1);
-
-    return array;
-  };
-
-  const scratchEllipsoid = Matrix3.Ellipsoid.clone(Matrix3.Ellipsoid.UNIT_SPHERE);
-  const scratchOptions = {
-    positions: undefined,
-    ellipsoid: scratchEllipsoid,
-    width: undefined,
-    height: undefined,
-    extrudedHeight: undefined,
-    cornerType: undefined,
-    granularity: undefined,
-    offsetAttribute: undefined,
-  };
-
-  /**
-   * Retrieves an instance from a packed array.
-   *
-   * @param {number[]} array The packed array.
-   * @param {number} [startingIndex=0] The starting index of the element to be unpacked.
-   * @param {CorridorOutlineGeometry} [result] The object into which to store the result.
-   * @returns {CorridorOutlineGeometry} The modified result parameter or a new CorridorOutlineGeometry instance if one was not provided.
-   */
-  CorridorOutlineGeometry.unpack = function (array, startingIndex, result) {
-    //>>includeStart('debug', pragmas.debug);
-    Check.Check.typeOf.object("array", array);
-    //>>includeEnd('debug');
-
-    startingIndex = defaultValue.defaultValue(startingIndex, 0);
-
-    const length = array[startingIndex++];
-    const positions = new Array(length);
-
-    for (let i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
-      positions[i] = Matrix3.Cartesian3.unpack(array, startingIndex);
-    }
-
-    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
-    startingIndex += Matrix3.Ellipsoid.packedLength;
-
-    const width = array[startingIndex++];
-    const height = array[startingIndex++];
-    const extrudedHeight = array[startingIndex++];
-    const cornerType = array[startingIndex++];
-    const granularity = array[startingIndex++];
-    const offsetAttribute = array[startingIndex];
-
-    if (!defaultValue.defined(result)) {
-      scratchOptions.positions = positions;
-      scratchOptions.width = width;
-      scratchOptions.height = height;
-      scratchOptions.extrudedHeight = extrudedHeight;
-      scratchOptions.cornerType = cornerType;
-      scratchOptions.granularity = granularity;
-      scratchOptions.offsetAttribute =
-        offsetAttribute === -1 ? undefined : offsetAttribute;
-      return new CorridorOutlineGeometry(scratchOptions);
+  if (addEndPositions) {
+    front += 3;
+    back -= 3;
+    leftPos = cartesian1;
+    rightPos = cartesian2;
+    const lastEndPositions = endPositions[1];
+    for (i = 0; i < halfLength; i++) {
+      leftPos = Cartesian3_default.fromArray(
+        lastEndPositions,
+        (endPositionLength - i - 1) * 3,
+        leftPos
+      );
+      rightPos = Cartesian3_default.fromArray(lastEndPositions, i * 3, rightPos);
+      CorridorGeometryLibrary_default.addAttribute(
+        finalPositions,
+        leftPos,
+        void 0,
+        back
+      );
+      CorridorGeometryLibrary_default.addAttribute(finalPositions, rightPos, front);
+      LR = front / 3;
+      LL = LR - 1;
+      UR = (back - 2) / 3;
+      UL = UR + 1;
+      indices[index++] = UL;
+      indices[index++] = UR;
+      indices[index++] = LL;
+      indices[index++] = LR;
+      front += 3;
+      back -= 3;
     }
-
-    result._positions = positions;
-    result._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid, result._ellipsoid);
-    result._width = width;
-    result._height = height;
-    result._extrudedHeight = extrudedHeight;
-    result._cornerType = cornerType;
-    result._granularity = granularity;
-    result._offsetAttribute =
-      offsetAttribute === -1 ? undefined : offsetAttribute;
-
-    return result;
+    wallIndices.push(front / 3);
+  } else {
+    wallIndices.push(front / 3, (back - 2) / 3);
+  }
+  indices[index++] = front / 3;
+  indices[index++] = (back - 2) / 3;
+  attributes.position = new GeometryAttribute_default({
+    componentDatatype: ComponentDatatype_default.DOUBLE,
+    componentsPerAttribute: 3,
+    values: finalPositions
+  });
+  return {
+    attributes,
+    indices,
+    wallIndices
   };
-
-  /**
-   * Computes the geometric representation of a corridor, including its vertices, indices, and a bounding sphere.
-   *
-   * @param {CorridorOutlineGeometry} corridorOutlineGeometry A description of the corridor.
-   * @returns {Geometry|undefined} The computed vertices and indices.
-   */
-  CorridorOutlineGeometry.createGeometry = function (corridorOutlineGeometry) {
-    let positions = corridorOutlineGeometry._positions;
-    const width = corridorOutlineGeometry._width;
-    const ellipsoid = corridorOutlineGeometry._ellipsoid;
-
-    positions = scaleToSurface(positions, ellipsoid);
-    const cleanPositions = arrayRemoveDuplicates.arrayRemoveDuplicates(
-      positions,
-      Matrix3.Cartesian3.equalsEpsilon
-    );
-
-    if (cleanPositions.length < 2 || width <= 0) {
-      return;
-    }
-
-    const height = corridorOutlineGeometry._height;
-    const extrudedHeight = corridorOutlineGeometry._extrudedHeight;
-    const extrude = !Math$1.CesiumMath.equalsEpsilon(
-      height,
-      extrudedHeight,
-      0,
-      Math$1.CesiumMath.EPSILON2
-    );
-
-    const params = {
-      ellipsoid: ellipsoid,
-      positions: cleanPositions,
-      width: width,
-      cornerType: corridorOutlineGeometry._cornerType,
-      granularity: corridorOutlineGeometry._granularity,
-      saveAttributes: false,
-    };
-    let attr;
-    if (extrude) {
-      params.height = height;
-      params.extrudedHeight = extrudedHeight;
-      params.offsetAttribute = corridorOutlineGeometry._offsetAttribute;
-      attr = computePositionsExtruded(params);
+}
+function computePositionsExtruded(params) {
+  const ellipsoid = params.ellipsoid;
+  const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+  const attr = combine(computedPositions, params.cornerType);
+  const wallIndices = attr.wallIndices;
+  const height = params.height;
+  const extrudedHeight = params.extrudedHeight;
+  const attributes = attr.attributes;
+  const indices = attr.indices;
+  let positions = attributes.position.values;
+  let length = positions.length;
+  let extrudedPositions = new Float64Array(length);
+  extrudedPositions.set(positions);
+  const newPositions = new Float64Array(length * 2);
+  positions = PolygonPipeline_default.scaleToGeodeticHeight(
+    positions,
+    height,
+    ellipsoid
+  );
+  extrudedPositions = PolygonPipeline_default.scaleToGeodeticHeight(
+    extrudedPositions,
+    extrudedHeight,
+    ellipsoid
+  );
+  newPositions.set(positions);
+  newPositions.set(extrudedPositions, length);
+  attributes.position.values = newPositions;
+  length /= 3;
+  if (defined_default(params.offsetAttribute)) {
+    let applyOffset = new Uint8Array(length * 2);
+    if (params.offsetAttribute === GeometryOffsetAttribute_default.TOP) {
+      applyOffset = applyOffset.fill(1, 0, length);
     } else {
-      const computedPositions = CorridorGeometryLibrary.CorridorGeometryLibrary.computePositions(params);
-      attr = combine(computedPositions, params.cornerType);
-      attr.attributes.position.values = PolygonPipeline.PolygonPipeline.scaleToGeodeticHeight(
-        attr.attributes.position.values,
-        height,
-        ellipsoid
-      );
-
-      if (defaultValue.defined(corridorOutlineGeometry._offsetAttribute)) {
-        const length = attr.attributes.position.values.length;
-        const offsetValue =
-          corridorOutlineGeometry._offsetAttribute ===
-          GeometryOffsetAttribute.GeometryOffsetAttribute.NONE
-            ? 0
-            : 1;
-        const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
-        attr.attributes.applyOffset = new GeometryAttribute.GeometryAttribute({
-          componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
-          componentsPerAttribute: 1,
-          values: applyOffset,
-        });
-      }
+      const applyOffsetValue = params.offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      applyOffset = applyOffset.fill(applyOffsetValue);
     }
-    const attributes = attr.attributes;
-    const boundingSphere = Transforms.BoundingSphere.fromVertices(
-      attributes.position.values,
-      undefined,
-      3
-    );
-
-    return new GeometryAttribute.Geometry({
-      attributes: attributes,
-      indices: attr.indices,
-      primitiveType: GeometryAttribute.PrimitiveType.LINES,
-      boundingSphere: boundingSphere,
-      offsetAttribute: corridorOutlineGeometry._offsetAttribute,
+    attributes.applyOffset = new GeometryAttribute_default({
+      componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+      componentsPerAttribute: 1,
+      values: applyOffset
     });
+  }
+  let i;
+  const iLength = indices.length;
+  const newIndices = IndexDatatype_default.createTypedArray(
+    newPositions.length / 3,
+    (iLength + wallIndices.length) * 2
+  );
+  newIndices.set(indices);
+  let index = iLength;
+  for (i = 0; i < iLength; i += 2) {
+    const v0 = indices[i];
+    const v1 = indices[i + 1];
+    newIndices[index++] = v0 + length;
+    newIndices[index++] = v1 + length;
+  }
+  let UL, LL;
+  for (i = 0; i < wallIndices.length; i++) {
+    UL = wallIndices[i];
+    LL = UL + length;
+    newIndices[index++] = UL;
+    newIndices[index++] = LL;
+  }
+  return {
+    attributes,
+    indices: newIndices
   };
-
-  function createCorridorOutlineGeometry(corridorOutlineGeometry, offset) {
-    if (defaultValue.defined(offset)) {
-      corridorOutlineGeometry = CorridorOutlineGeometry.unpack(
-        corridorOutlineGeometry,
-        offset
-      );
+}
+function CorridorOutlineGeometry(options) {
+  options = defaultValue_default(options, defaultValue_default.EMPTY_OBJECT);
+  const positions = options.positions;
+  const width = options.width;
+  Check_default.typeOf.object("options.positions", positions);
+  Check_default.typeOf.number("options.width", width);
+  const height = defaultValue_default(options.height, 0);
+  const extrudedHeight = defaultValue_default(options.extrudedHeight, height);
+  this._positions = positions;
+  this._ellipsoid = Ellipsoid_default.clone(
+    defaultValue_default(options.ellipsoid, Ellipsoid_default.WGS84)
+  );
+  this._width = width;
+  this._height = Math.max(height, extrudedHeight);
+  this._extrudedHeight = Math.min(height, extrudedHeight);
+  this._cornerType = defaultValue_default(options.cornerType, CornerType_default.ROUNDED);
+  this._granularity = defaultValue_default(
+    options.granularity,
+    Math_default.RADIANS_PER_DEGREE
+  );
+  this._offsetAttribute = options.offsetAttribute;
+  this._workerName = "createCorridorOutlineGeometry";
+  this.packedLength = 1 + positions.length * Cartesian3_default.packedLength + Ellipsoid_default.packedLength + 6;
+}
+CorridorOutlineGeometry.pack = function(value, array, startingIndex) {
+  Check_default.typeOf.object("value", value);
+  Check_default.typeOf.object("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const positions = value._positions;
+  const length = positions.length;
+  array[startingIndex++] = length;
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    Cartesian3_default.pack(positions[i], array, startingIndex);
+  }
+  Ellipsoid_default.pack(value._ellipsoid, array, startingIndex);
+  startingIndex += Ellipsoid_default.packedLength;
+  array[startingIndex++] = value._width;
+  array[startingIndex++] = value._height;
+  array[startingIndex++] = value._extrudedHeight;
+  array[startingIndex++] = value._cornerType;
+  array[startingIndex++] = value._granularity;
+  array[startingIndex] = defaultValue_default(value._offsetAttribute, -1);
+  return array;
+};
+var scratchEllipsoid = Ellipsoid_default.clone(Ellipsoid_default.UNIT_SPHERE);
+var scratchOptions = {
+  positions: void 0,
+  ellipsoid: scratchEllipsoid,
+  width: void 0,
+  height: void 0,
+  extrudedHeight: void 0,
+  cornerType: void 0,
+  granularity: void 0,
+  offsetAttribute: void 0
+};
+CorridorOutlineGeometry.unpack = function(array, startingIndex, result) {
+  Check_default.typeOf.object("array", array);
+  startingIndex = defaultValue_default(startingIndex, 0);
+  const length = array[startingIndex++];
+  const positions = new Array(length);
+  for (let i = 0; i < length; ++i, startingIndex += Cartesian3_default.packedLength) {
+    positions[i] = Cartesian3_default.unpack(array, startingIndex);
+  }
+  const ellipsoid = Ellipsoid_default.unpack(array, startingIndex, scratchEllipsoid);
+  startingIndex += Ellipsoid_default.packedLength;
+  const width = array[startingIndex++];
+  const height = array[startingIndex++];
+  const extrudedHeight = array[startingIndex++];
+  const cornerType = array[startingIndex++];
+  const granularity = array[startingIndex++];
+  const offsetAttribute = array[startingIndex];
+  if (!defined_default(result)) {
+    scratchOptions.positions = positions;
+    scratchOptions.width = width;
+    scratchOptions.height = height;
+    scratchOptions.extrudedHeight = extrudedHeight;
+    scratchOptions.cornerType = cornerType;
+    scratchOptions.granularity = granularity;
+    scratchOptions.offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+    return new CorridorOutlineGeometry(scratchOptions);
+  }
+  result._positions = positions;
+  result._ellipsoid = Ellipsoid_default.clone(ellipsoid, result._ellipsoid);
+  result._width = width;
+  result._height = height;
+  result._extrudedHeight = extrudedHeight;
+  result._cornerType = cornerType;
+  result._granularity = granularity;
+  result._offsetAttribute = offsetAttribute === -1 ? void 0 : offsetAttribute;
+  return result;
+};
+CorridorOutlineGeometry.createGeometry = function(corridorOutlineGeometry) {
+  let positions = corridorOutlineGeometry._positions;
+  const width = corridorOutlineGeometry._width;
+  const ellipsoid = corridorOutlineGeometry._ellipsoid;
+  positions = scaleToSurface(positions, ellipsoid);
+  const cleanPositions = arrayRemoveDuplicates_default(
+    positions,
+    Cartesian3_default.equalsEpsilon
+  );
+  if (cleanPositions.length < 2 || width <= 0) {
+    return;
+  }
+  const height = corridorOutlineGeometry._height;
+  const extrudedHeight = corridorOutlineGeometry._extrudedHeight;
+  const extrude = !Math_default.equalsEpsilon(
+    height,
+    extrudedHeight,
+    0,
+    Math_default.EPSILON2
+  );
+  const params = {
+    ellipsoid,
+    positions: cleanPositions,
+    width,
+    cornerType: corridorOutlineGeometry._cornerType,
+    granularity: corridorOutlineGeometry._granularity,
+    saveAttributes: false
+  };
+  let attr;
+  if (extrude) {
+    params.height = height;
+    params.extrudedHeight = extrudedHeight;
+    params.offsetAttribute = corridorOutlineGeometry._offsetAttribute;
+    attr = computePositionsExtruded(params);
+  } else {
+    const computedPositions = CorridorGeometryLibrary_default.computePositions(params);
+    attr = combine(computedPositions, params.cornerType);
+    attr.attributes.position.values = PolygonPipeline_default.scaleToGeodeticHeight(
+      attr.attributes.position.values,
+      height,
+      ellipsoid
+    );
+    if (defined_default(corridorOutlineGeometry._offsetAttribute)) {
+      const length = attr.attributes.position.values.length;
+      const offsetValue = corridorOutlineGeometry._offsetAttribute === GeometryOffsetAttribute_default.NONE ? 0 : 1;
+      const applyOffset = new Uint8Array(length / 3).fill(offsetValue);
+      attr.attributes.applyOffset = new GeometryAttribute_default({
+        componentDatatype: ComponentDatatype_default.UNSIGNED_BYTE,
+        componentsPerAttribute: 1,
+        values: applyOffset
+      });
     }
-    corridorOutlineGeometry._ellipsoid = Matrix3.Ellipsoid.clone(
-      corridorOutlineGeometry._ellipsoid
+  }
+  const attributes = attr.attributes;
+  const boundingSphere = BoundingSphere_default.fromVertices(
+    attributes.position.values,
+    void 0,
+    3
+  );
+  return new Geometry_default({
+    attributes,
+    indices: attr.indices,
+    primitiveType: PrimitiveType_default.LINES,
+    boundingSphere,
+    offsetAttribute: corridorOutlineGeometry._offsetAttribute
+  });
+};
+var CorridorOutlineGeometry_default = CorridorOutlineGeometry;
+
+// packages/engine/Source/Workers/createCorridorOutlineGeometry.js
+function createCorridorOutlineGeometry(corridorOutlineGeometry, offset) {
+  if (defined_default(offset)) {
+    corridorOutlineGeometry = CorridorOutlineGeometry_default.unpack(
+      corridorOutlineGeometry,
+      offset
     );
-    return CorridorOutlineGeometry.createGeometry(corridorOutlineGeometry);
   }
-
-  return createCorridorOutlineGeometry;
-
-}));
+  corridorOutlineGeometry._ellipsoid = Ellipsoid_default.clone(
+    corridorOutlineGeometry._ellipsoid
+  );
+  return CorridorOutlineGeometry_default.createGeometry(corridorOutlineGeometry);
+}
+var createCorridorOutlineGeometry_default = createCorridorOutlineGeometry;
+export {
+  createCorridorOutlineGeometry_default as default
+};