@vcmap/ui 5.0.0-rc.18 → 5.0.0-rc.21

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

@@ -1,25 +1,458 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./defaultValue-0c475b81","./Matrix2-eefef8eb","./ArcType-c9b2b290","./Transforms-d2e5867e","./Color-cc8c18b3","./ComponentDatatype-0200bf8c","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./IndexDatatype-e713bfd2","./PolylinePipeline-0f23dd84","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./WebGLConstants-5b50ced1","./EllipsoidGeodesic-8bfefbff","./EllipsoidRhumbLine-03528f73","./IntersectionTests-eb4db8e0","./Plane-b0299683"],(function(e,o,t,l,r,n,i,a,s,c,p,d,f,y,u,h,C,m){"use strict";function T(e,o,t,l,n,i,a){const s=c.PolylinePipeline.numberOfPoints(e,o,n);let p;const d=t.red,f=t.green,y=t.blue,u=t.alpha,h=l.red,C=l.green,m=l.blue,T=l.alpha;if(r.Color.equals(t,l)){for(p=0;p<s;p++)i[a++]=r.Color.floatToByte(d),i[a++]=r.Color.floatToByte(f),i[a++]=r.Color.floatToByte(y),i[a++]=r.Color.floatToByte(u);return a}const g=(h-d)/s,b=(C-f)/s,_=(m-y)/s,P=(T-u)/s;let B=a;for(p=0;p<s;p++)i[B++]=r.Color.floatToByte(d+p*g),i[B++]=r.Color.floatToByte(f+p*b),i[B++]=r.Color.floatToByte(y+p*_),i[B++]=r.Color.floatToByte(u+p*P);return B}function g(l){const i=(l=e.defaultValue(l,e.defaultValue.EMPTY_OBJECT)).positions,a=l.colors,s=e.defaultValue(l.colorsPerVertex,!1);this._positions=i,this._colors=a,this._colorsPerVertex=s,this._arcType=e.defaultValue(l.arcType,t.ArcType.GEODESIC),this._granularity=e.defaultValue(l.granularity,n.CesiumMath.RADIANS_PER_DEGREE),this._ellipsoid=e.defaultValue(l.ellipsoid,o.Ellipsoid.WGS84),this._workerName="createSimplePolylineGeometry";let c=1+i.length*o.Cartesian3.packedLength;c+=e.defined(a)?1+a.length*r.Color.packedLength:1,this.packedLength=c+o.Ellipsoid.packedLength+3}g.pack=function(t,l,n){let i;n=e.defaultValue(n,0);const a=t._positions;let s=a.length;for(l[n++]=s,i=0;i<s;++i,n+=o.Cartesian3.packedLength)o.Cartesian3.pack(a[i],l,n);const c=t._colors;for(s=e.defined(c)?c.length:0,l[n++]=s,i=0;i<s;++i,n+=r.Color.packedLength)r.Color.pack(c[i],l,n);return o.Ellipsoid.pack(t._ellipsoid,l,n),n+=o.Ellipsoid.packedLength,l[n++]=t._colorsPerVertex?1:0,l[n++]=t._arcType,l[n]=t._granularity,l},g.unpack=function(t,l,n){let i;l=e.defaultValue(l,0);let a=t[l++];const s=new Array(a);for(i=0;i<a;++i,l+=o.Cartesian3.packedLength)s[i]=o.Cartesian3.unpack(t,l);a=t[l++];const c=a>0?new Array(a):void 0;for(i=0;i<a;++i,l+=r.Color.packedLength)c[i]=r.Color.unpack(t,l);const p=o.Ellipsoid.unpack(t,l);l+=o.Ellipsoid.packedLength;const d=1===t[l++],f=t[l++],y=t[l];return e.defined(n)?(n._positions=s,n._colors=c,n._ellipsoid=p,n._colorsPerVertex=d,n._arcType=f,n._granularity=y,n):new g({positions:s,colors:c,ellipsoid:p,colorsPerVertex:d,arcType:f,granularity:y})};const b=new Array(2),_=new Array(2),P={positions:b,height:_,ellipsoid:void 0,minDistance:void 0,granularity:void 0};return g.createGeometry=function(p){const d=p._positions,f=p._colors,y=p._colorsPerVertex,u=p._arcType,h=p._granularity,C=p._ellipsoid,m=n.CesiumMath.chordLength(h,C.maximumRadius),g=e.defined(f)&&!y;let B;const A=d.length;let E,k,G,D,L=0;if(u===t.ArcType.GEODESIC||u===t.ArcType.RHUMB){let o,l,i;u===t.ArcType.GEODESIC?(o=n.CesiumMath.chordLength(h,C.maximumRadius),l=c.PolylinePipeline.numberOfPoints,i=c.PolylinePipeline.generateArc):(o=h,l=c.PolylinePipeline.numberOfPointsRhumbLine,i=c.PolylinePipeline.generateRhumbArc);const a=c.PolylinePipeline.extractHeights(d,C),s=P;if(u===t.ArcType.GEODESIC?s.minDistance=m:s.granularity=h,s.ellipsoid=C,g){let t=0;for(B=0;B<A-1;B++)t+=l(d[B],d[B+1],o)+1;E=new Float64Array(3*t),G=new Uint8Array(4*t),s.positions=b,s.height=_;let n=0;for(B=0;B<A-1;++B){b[0]=d[B],b[1]=d[B+1],_[0]=a[B],_[1]=a[B+1];const o=i(s);if(e.defined(f)){const e=o.length/3;D=f[B];for(let o=0;o<e;++o)G[n++]=r.Color.floatToByte(D.red),G[n++]=r.Color.floatToByte(D.green),G[n++]=r.Color.floatToByte(D.blue),G[n++]=r.Color.floatToByte(D.alpha)}E.set(o,L),L+=o.length}}else if(s.positions=d,s.height=a,E=new Float64Array(i(s)),e.defined(f)){for(G=new Uint8Array(E.length/3*4),B=0;B<A-1;++B){L=T(d[B],d[B+1],f[B],f[B+1],m,G,L)}const e=f[A-1];G[L++]=r.Color.floatToByte(e.red),G[L++]=r.Color.floatToByte(e.green),G[L++]=r.Color.floatToByte(e.blue),G[L++]=r.Color.floatToByte(e.alpha)}}else{k=g?2*A-2:A,E=new Float64Array(3*k),G=e.defined(f)?new Uint8Array(4*k):void 0;let t=0,l=0;for(B=0;B<A;++B){const n=d[B];if(g&&B>0&&(o.Cartesian3.pack(n,E,t),t+=3,D=f[B-1],G[l++]=r.Color.floatToByte(D.red),G[l++]=r.Color.floatToByte(D.green),G[l++]=r.Color.floatToByte(D.blue),G[l++]=r.Color.floatToByte(D.alpha)),g&&B===A-1)break;o.Cartesian3.pack(n,E,t),t+=3,e.defined(f)&&(D=f[B],G[l++]=r.Color.floatToByte(D.red),G[l++]=r.Color.floatToByte(D.green),G[l++]=r.Color.floatToByte(D.blue),G[l++]=r.Color.floatToByte(D.alpha))}}const w=new a.GeometryAttributes;w.position=new i.GeometryAttribute({componentDatatype:n.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:E}),e.defined(f)&&(w.color=new i.GeometryAttribute({componentDatatype:n.ComponentDatatype.UNSIGNED_BYTE,componentsPerAttribute:4,values:G,normalize:!0})),k=E.length/3;const V=2*(k-1),x=s.IndexDatatype.createTypedArray(k,V);let S=0;for(B=0;B<k-1;++B)x[S++]=B,x[S++]=B+1;return new i.Geometry({attributes:w,indices:x,primitiveType:i.PrimitiveType.LINES,boundingSphere:l.BoundingSphere.fromPoints(d)})},function(t,l){return e.defined(l)&&(t=g.unpack(t,l)),t._ellipsoid=o.Ellipsoid.clone(t._ellipsoid),g.createGeometry(t)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './ArcType-ce2e50ab', './Transforms-40229881', './Color-a84038cb', './ComponentDatatype-f7b11d02', './Check-666ab1a0', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './PolylinePipeline-32f36d2a', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c', './EllipsoidGeodesic-98c62a56', './EllipsoidRhumbLine-19756602', './IntersectionTests-f6e6bd8a', './Plane-900aa728'], (function (defaultValue, Matrix3, ArcType, Transforms, Color, ComponentDatatype, Check, GeometryAttribute, GeometryAttributes, IndexDatatype, Math, PolylinePipeline, Matrix2, RuntimeError, combine, WebGLConstants, EllipsoidGeodesic, EllipsoidRhumbLine, IntersectionTests, Plane) { 'use strict';
+
+  function interpolateColors(p0, p1, color0, color1, minDistance, array, offset) {
+    const numPoints = PolylinePipeline.PolylinePipeline.numberOfPoints(p0, p1, minDistance);
+    let i;
+
+    const r0 = color0.red;
+    const g0 = color0.green;
+    const b0 = color0.blue;
+    const a0 = color0.alpha;
+
+    const r1 = color1.red;
+    const g1 = color1.green;
+    const b1 = color1.blue;
+    const a1 = color1.alpha;
+
+    if (Color.Color.equals(color0, color1)) {
+      for (i = 0; i < numPoints; i++) {
+        array[offset++] = Color.Color.floatToByte(r0);
+        array[offset++] = Color.Color.floatToByte(g0);
+        array[offset++] = Color.Color.floatToByte(b0);
+        array[offset++] = Color.Color.floatToByte(a0);
+      }
+      return offset;
+    }
+
+    const redPerVertex = (r1 - r0) / numPoints;
+    const greenPerVertex = (g1 - g0) / numPoints;
+    const bluePerVertex = (b1 - b0) / numPoints;
+    const alphaPerVertex = (a1 - a0) / numPoints;
+
+    let index = offset;
+    for (i = 0; i < numPoints; i++) {
+      array[index++] = Color.Color.floatToByte(r0 + i * redPerVertex);
+      array[index++] = Color.Color.floatToByte(g0 + i * greenPerVertex);
+      array[index++] = Color.Color.floatToByte(b0 + i * bluePerVertex);
+      array[index++] = Color.Color.floatToByte(a0 + i * alphaPerVertex);
+    }
+
+    return index;
+  }
+
+  /**
+   * A description of a polyline modeled as a line strip; the first two positions define a line segment,
+   * and each additional position defines a line segment from the previous position.
+   *
+   * @alias SimplePolylineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.positions An array of {@link Cartesian3} defining the positions in the polyline as a line strip.
+   * @param {Color[]} [options.colors] An Array of {@link Color} defining the per vertex or per segment colors.
+   * @param {Boolean} [options.colorsPerVertex=false] A boolean that determines whether the colors will be flat across each segment of the line or interpolated across the vertices.
+   * @param {ArcType} [options.arcType=ArcType.GEODESIC] The type of line the polyline segments must follow.
+   * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude if options.arcType is not ArcType.NONE. Determines the number of positions in the buffer.
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
+   *
+   * @exception {DeveloperError} At least two positions are required.
+   * @exception {DeveloperError} colors has an invalid length.
+   *
+   * @see SimplePolylineGeometry#createGeometry
+   *
+   * @example
+   * // A polyline with two connected line segments
+   * const polyline = new Cesium.SimplePolylineGeometry({
+   *   positions : Cesium.Cartesian3.fromDegreesArray([
+   *     0.0, 0.0,
+   *     5.0, 0.0,
+   *     5.0, 5.0
+   *   ])
+   * });
+   * const geometry = Cesium.SimplePolylineGeometry.createGeometry(polyline);
+   */
+  function SimplePolylineGeometry(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+    const positions = options.positions;
+    const colors = options.colors;
+    const colorsPerVertex = defaultValue.defaultValue(options.colorsPerVertex, false);
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(positions) || positions.length < 2) {
+      throw new Check.DeveloperError("At least two positions are required.");
+    }
+    if (
+      defaultValue.defined(colors) &&
+      ((colorsPerVertex && colors.length < positions.length) ||
+        (!colorsPerVertex && colors.length < positions.length - 1))
+    ) {
+      throw new Check.DeveloperError("colors has an invalid length.");
+    }
+    //>>includeEnd('debug');
+
+    this._positions = positions;
+    this._colors = colors;
+    this._colorsPerVertex = colorsPerVertex;
+
+    this._arcType = defaultValue.defaultValue(options.arcType, ArcType.ArcType.GEODESIC);
+    this._granularity = defaultValue.defaultValue(
+      options.granularity,
+      Math.CesiumMath.RADIANS_PER_DEGREE
+    );
+    this._ellipsoid = defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84);
+    this._workerName = "createSimplePolylineGeometry";
+
+    let numComponents = 1 + positions.length * Matrix3.Cartesian3.packedLength;
+    numComponents += defaultValue.defined(colors) ? 1 + colors.length * Color.Color.packedLength : 1;
+
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    this.packedLength = numComponents + Matrix3.Ellipsoid.packedLength + 3;
+  }
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {SimplePolylineGeometry} 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
+   */
+  SimplePolylineGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(value)) {
+      throw new Check.DeveloperError("value is required");
+    }
+    if (!defaultValue.defined(array)) {
+      throw new Check.DeveloperError("array is required");
+    }
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    let i;
+
+    const positions = value._positions;
+    let length = positions.length;
+    array[startingIndex++] = length;
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      Matrix3.Cartesian3.pack(positions[i], array, startingIndex);
+    }
+
+    const colors = value._colors;
+    length = defaultValue.defined(colors) ? colors.length : 0.0;
+    array[startingIndex++] = length;
+
+    for (i = 0; i < length; ++i, startingIndex += Color.Color.packedLength) {
+      Color.Color.pack(colors[i], array, startingIndex);
+    }
+
+    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    array[startingIndex++] = value._colorsPerVertex ? 1.0 : 0.0;
+    array[startingIndex++] = value._arcType;
+    array[startingIndex] = value._granularity;
+
+    return array;
+  };
+
+  /**
+   * 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 {SimplePolylineGeometry} [result] The object into which to store the result.
+   * @returns {SimplePolylineGeometry} The modified result parameter or a new SimplePolylineGeometry instance if one was not provided.
+   */
+  SimplePolylineGeometry.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(array)) {
+      throw new Check.DeveloperError("array is required");
+    }
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    let i;
+
+    let length = array[startingIndex++];
+    const positions = new Array(length);
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      positions[i] = Matrix3.Cartesian3.unpack(array, startingIndex);
+    }
+
+    length = array[startingIndex++];
+    const colors = length > 0 ? new Array(length) : undefined;
+
+    for (i = 0; i < length; ++i, startingIndex += Color.Color.packedLength) {
+      colors[i] = Color.Color.unpack(array, startingIndex);
+    }
+
+    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    const colorsPerVertex = array[startingIndex++] === 1.0;
+    const arcType = array[startingIndex++];
+    const granularity = array[startingIndex];
+
+    if (!defaultValue.defined(result)) {
+      return new SimplePolylineGeometry({
+        positions: positions,
+        colors: colors,
+        ellipsoid: ellipsoid,
+        colorsPerVertex: colorsPerVertex,
+        arcType: arcType,
+        granularity: granularity,
+      });
+    }
+
+    result._positions = positions;
+    result._colors = colors;
+    result._ellipsoid = ellipsoid;
+    result._colorsPerVertex = colorsPerVertex;
+    result._arcType = arcType;
+    result._granularity = granularity;
+
+    return result;
+  };
+
+  const scratchArray1 = new Array(2);
+  const scratchArray2 = new Array(2);
+  const generateArcOptionsScratch = {
+    positions: scratchArray1,
+    height: scratchArray2,
+    ellipsoid: undefined,
+    minDistance: undefined,
+    granularity: undefined,
+  };
+
+  /**
+   * Computes the geometric representation of a simple polyline, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {SimplePolylineGeometry} simplePolylineGeometry A description of the polyline.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  SimplePolylineGeometry.createGeometry = function (simplePolylineGeometry) {
+    const positions = simplePolylineGeometry._positions;
+    const colors = simplePolylineGeometry._colors;
+    const colorsPerVertex = simplePolylineGeometry._colorsPerVertex;
+    const arcType = simplePolylineGeometry._arcType;
+    const granularity = simplePolylineGeometry._granularity;
+    const ellipsoid = simplePolylineGeometry._ellipsoid;
+
+    const minDistance = Math.CesiumMath.chordLength(
+      granularity,
+      ellipsoid.maximumRadius
+    );
+    const perSegmentColors = defaultValue.defined(colors) && !colorsPerVertex;
+
+    let i;
+    const length = positions.length;
+
+    let positionValues;
+    let numberOfPositions;
+    let colorValues;
+    let color;
+    let offset = 0;
+
+    if (arcType === ArcType.ArcType.GEODESIC || arcType === ArcType.ArcType.RHUMB) {
+      let subdivisionSize;
+      let numberOfPointsFunction;
+      let generateArcFunction;
+      if (arcType === ArcType.ArcType.GEODESIC) {
+        subdivisionSize = Math.CesiumMath.chordLength(
+          granularity,
+          ellipsoid.maximumRadius
+        );
+        numberOfPointsFunction = PolylinePipeline.PolylinePipeline.numberOfPoints;
+        generateArcFunction = PolylinePipeline.PolylinePipeline.generateArc;
+      } else {
+        subdivisionSize = granularity;
+        numberOfPointsFunction = PolylinePipeline.PolylinePipeline.numberOfPointsRhumbLine;
+        generateArcFunction = PolylinePipeline.PolylinePipeline.generateRhumbArc;
+      }
+
+      const heights = PolylinePipeline.PolylinePipeline.extractHeights(positions, ellipsoid);
+
+      const generateArcOptions = generateArcOptionsScratch;
+      if (arcType === ArcType.ArcType.GEODESIC) {
+        generateArcOptions.minDistance = minDistance;
+      } else {
+        generateArcOptions.granularity = granularity;
+      }
+      generateArcOptions.ellipsoid = ellipsoid;
+
+      if (perSegmentColors) {
+        let positionCount = 0;
+        for (i = 0; i < length - 1; i++) {
+          positionCount +=
+            numberOfPointsFunction(
+              positions[i],
+              positions[i + 1],
+              subdivisionSize
+            ) + 1;
+        }
+
+        positionValues = new Float64Array(positionCount * 3);
+        colorValues = new Uint8Array(positionCount * 4);
+
+        generateArcOptions.positions = scratchArray1;
+        generateArcOptions.height = scratchArray2;
+
+        let ci = 0;
+        for (i = 0; i < length - 1; ++i) {
+          scratchArray1[0] = positions[i];
+          scratchArray1[1] = positions[i + 1];
+
+          scratchArray2[0] = heights[i];
+          scratchArray2[1] = heights[i + 1];
+
+          const pos = generateArcFunction(generateArcOptions);
+
+          if (defaultValue.defined(colors)) {
+            const segLen = pos.length / 3;
+            color = colors[i];
+            for (let k = 0; k < segLen; ++k) {
+              colorValues[ci++] = Color.Color.floatToByte(color.red);
+              colorValues[ci++] = Color.Color.floatToByte(color.green);
+              colorValues[ci++] = Color.Color.floatToByte(color.blue);
+              colorValues[ci++] = Color.Color.floatToByte(color.alpha);
+            }
+          }
+
+          positionValues.set(pos, offset);
+          offset += pos.length;
+        }
+      } else {
+        generateArcOptions.positions = positions;
+        generateArcOptions.height = heights;
+        positionValues = new Float64Array(
+          generateArcFunction(generateArcOptions)
+        );
+
+        if (defaultValue.defined(colors)) {
+          colorValues = new Uint8Array((positionValues.length / 3) * 4);
+
+          for (i = 0; i < length - 1; ++i) {
+            const p0 = positions[i];
+            const p1 = positions[i + 1];
+            const c0 = colors[i];
+            const c1 = colors[i + 1];
+            offset = interpolateColors(
+              p0,
+              p1,
+              c0,
+              c1,
+              minDistance,
+              colorValues,
+              offset
+            );
+          }
+
+          const lastColor = colors[length - 1];
+          colorValues[offset++] = Color.Color.floatToByte(lastColor.red);
+          colorValues[offset++] = Color.Color.floatToByte(lastColor.green);
+          colorValues[offset++] = Color.Color.floatToByte(lastColor.blue);
+          colorValues[offset++] = Color.Color.floatToByte(lastColor.alpha);
+        }
+      }
+    } else {
+      numberOfPositions = perSegmentColors ? length * 2 - 2 : length;
+      positionValues = new Float64Array(numberOfPositions * 3);
+      colorValues = defaultValue.defined(colors)
+        ? new Uint8Array(numberOfPositions * 4)
+        : undefined;
+
+      let positionIndex = 0;
+      let colorIndex = 0;
+
+      for (i = 0; i < length; ++i) {
+        const p = positions[i];
+
+        if (perSegmentColors && i > 0) {
+          Matrix3.Cartesian3.pack(p, positionValues, positionIndex);
+          positionIndex += 3;
+
+          color = colors[i - 1];
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.red);
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.green);
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.blue);
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.alpha);
+        }
+
+        if (perSegmentColors && i === length - 1) {
+          break;
+        }
+
+        Matrix3.Cartesian3.pack(p, positionValues, positionIndex);
+        positionIndex += 3;
+
+        if (defaultValue.defined(colors)) {
+          color = colors[i];
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.red);
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.green);
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.blue);
+          colorValues[colorIndex++] = Color.Color.floatToByte(color.alpha);
+        }
+      }
+    }
+
+    const attributes = new GeometryAttributes.GeometryAttributes();
+    attributes.position = new GeometryAttribute.GeometryAttribute({
+      componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+      componentsPerAttribute: 3,
+      values: positionValues,
+    });
+
+    if (defaultValue.defined(colors)) {
+      attributes.color = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.UNSIGNED_BYTE,
+        componentsPerAttribute: 4,
+        values: colorValues,
+        normalize: true,
+      });
+    }
+
+    numberOfPositions = positionValues.length / 3;
+    const numberOfIndices = (numberOfPositions - 1) * 2;
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(
+      numberOfPositions,
+      numberOfIndices
+    );
+
+    let index = 0;
+    for (i = 0; i < numberOfPositions - 1; ++i) {
+      indices[index++] = i;
+      indices[index++] = i + 1;
+    }
+
+    return new GeometryAttribute.Geometry({
+      attributes: attributes,
+      indices: indices,
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      boundingSphere: Transforms.BoundingSphere.fromPoints(positions),
+    });
+  };
+
+  function createSimplePolylineGeometry(simplePolylineGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      simplePolylineGeometry = SimplePolylineGeometry.unpack(
+        simplePolylineGeometry,
+        offset
+      );
+    }
+    simplePolylineGeometry._ellipsoid = Matrix3.Ellipsoid.clone(
+      simplePolylineGeometry._ellipsoid
+    );
+    return SimplePolylineGeometry.createGeometry(simplePolylineGeometry);
+  }
+
+  return createSimplePolylineGeometry;
+
+}));

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

@@ -1,25 +1,123 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * 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.
- */
-define(["./defaultValue-0c475b81","./Matrix2-eefef8eb","./EllipsoidGeometry-377329b9","./VertexFormat-5ec0d9ff","./ComponentDatatype-0200bf8c","./WebGLConstants-5b50ced1","./RuntimeError-5baf5c66","./Transforms-d2e5867e","./_commonjsHelpers-bc29abbc","./combine-7533016d","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryOffsetAttribute-08ae0c50","./IndexDatatype-e713bfd2"],(function(e,t,i,r,o,a,n,s,c,d,l,m,u,p){"use strict";function f(r){const o=e.defaultValue(r.radius,1),a={radii:new t.Cartesian3(o,o,o),stackPartitions:r.stackPartitions,slicePartitions:r.slicePartitions,vertexFormat:r.vertexFormat};this._ellipsoidGeometry=new i.EllipsoidGeometry(a),this._workerName="createSphereGeometry"}f.packedLength=i.EllipsoidGeometry.packedLength,f.pack=function(e,t,r){return i.EllipsoidGeometry.pack(e._ellipsoidGeometry,t,r)};const y=new i.EllipsoidGeometry,G={radius:void 0,radii:new t.Cartesian3,vertexFormat:new r.VertexFormat,stackPartitions:void 0,slicePartitions:void 0};return f.unpack=function(o,a,n){const s=i.EllipsoidGeometry.unpack(o,a,y);return G.vertexFormat=r.VertexFormat.clone(s._vertexFormat,G.vertexFormat),G.stackPartitions=s._stackPartitions,G.slicePartitions=s._slicePartitions,e.defined(n)?(t.Cartesian3.clone(s._radii,G.radii),n._ellipsoidGeometry=new i.EllipsoidGeometry(G),n):(G.radius=s._radii.x,new f(G))},f.createGeometry=function(e){return i.EllipsoidGeometry.createGeometry(e._ellipsoidGeometry)},function(t,i){return e.defined(i)&&(t=f.unpack(t,i)),f.createGeometry(t)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './Check-666ab1a0', './EllipsoidGeometry-21c0e3a5', './VertexFormat-6b480673', './Math-2dbd6b93', './Transforms-40229881', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryOffsetAttribute-04332ce7', './IndexDatatype-a55ceaa1'], (function (defaultValue, Matrix3, Check, EllipsoidGeometry, VertexFormat, Math, Transforms, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype) { 'use strict';
+
+  /**
+   * A description of a sphere centered at the origin.
+   *
+   * @alias SphereGeometry
+   * @constructor
+   *
+   * @param {Object} [options] Object with the following properties:
+   * @param {Number} [options.radius=1.0] The radius of the sphere.
+   * @param {Number} [options.stackPartitions=64] The number of times to partition the ellipsoid into stacks.
+   * @param {Number} [options.slicePartitions=64] The number of times to partition the ellipsoid into radial slices.
+   * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
+   *
+   * @exception {DeveloperError} options.slicePartitions cannot be less than three.
+   * @exception {DeveloperError} options.stackPartitions cannot be less than three.
+   *
+   * @see SphereGeometry#createGeometry
+   *
+   * @example
+   * const sphere = new Cesium.SphereGeometry({
+   *   radius : 100.0,
+   *   vertexFormat : Cesium.VertexFormat.POSITION_ONLY
+   * });
+   * const geometry = Cesium.SphereGeometry.createGeometry(sphere);
+   */
+  function SphereGeometry(options) {
+    const radius = defaultValue.defaultValue(options.radius, 1.0);
+    const radii = new Matrix3.Cartesian3(radius, radius, radius);
+    const ellipsoidOptions = {
+      radii: radii,
+      stackPartitions: options.stackPartitions,
+      slicePartitions: options.slicePartitions,
+      vertexFormat: options.vertexFormat,
+    };
+
+    this._ellipsoidGeometry = new EllipsoidGeometry.EllipsoidGeometry(ellipsoidOptions);
+    this._workerName = "createSphereGeometry";
+  }
+
+  /**
+   * The number of elements used to pack the object into an array.
+   * @type {Number}
+   */
+  SphereGeometry.packedLength = EllipsoidGeometry.EllipsoidGeometry.packedLength;
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {SphereGeometry} 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
+   */
+  SphereGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("value", value);
+    //>>includeEnd('debug');
+
+    return EllipsoidGeometry.EllipsoidGeometry.pack(value._ellipsoidGeometry, array, startingIndex);
+  };
+
+  const scratchEllipsoidGeometry = new EllipsoidGeometry.EllipsoidGeometry();
+  const scratchOptions = {
+    radius: undefined,
+    radii: new Matrix3.Cartesian3(),
+    vertexFormat: new VertexFormat.VertexFormat(),
+    stackPartitions: undefined,
+    slicePartitions: 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 {SphereGeometry} [result] The object into which to store the result.
+   * @returns {SphereGeometry} The modified result parameter or a new SphereGeometry instance if one was not provided.
+   */
+  SphereGeometry.unpack = function (array, startingIndex, result) {
+    const ellipsoidGeometry = EllipsoidGeometry.EllipsoidGeometry.unpack(
+      array,
+      startingIndex,
+      scratchEllipsoidGeometry
+    );
+    scratchOptions.vertexFormat = VertexFormat.VertexFormat.clone(
+      ellipsoidGeometry._vertexFormat,
+      scratchOptions.vertexFormat
+    );
+    scratchOptions.stackPartitions = ellipsoidGeometry._stackPartitions;
+    scratchOptions.slicePartitions = ellipsoidGeometry._slicePartitions;
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.radius = ellipsoidGeometry._radii.x;
+      return new SphereGeometry(scratchOptions);
+    }
+
+    Matrix3.Cartesian3.clone(ellipsoidGeometry._radii, scratchOptions.radii);
+    result._ellipsoidGeometry = new EllipsoidGeometry.EllipsoidGeometry(scratchOptions);
+    return result;
+  };
+
+  /**
+   * Computes the geometric representation of a sphere, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {SphereGeometry} sphereGeometry A description of the sphere.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  SphereGeometry.createGeometry = function (sphereGeometry) {
+    return EllipsoidGeometry.EllipsoidGeometry.createGeometry(sphereGeometry._ellipsoidGeometry);
+  };
+
+  function createSphereGeometry(sphereGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      sphereGeometry = SphereGeometry.unpack(sphereGeometry, offset);
+    }
+    return SphereGeometry.createGeometry(sphereGeometry);
+  }
+
+  return createSphereGeometry;
+
+}));