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

package/dist/assets/cesium/Workers/VertexFormat-6b480673.js

@@ -0,0 +1,312 @@
+define(['exports', './defaultValue-0a909f67', './Check-666ab1a0'], (function (exports, defaultValue, Check) { 'use strict';
+
+  /**
+   * A vertex format defines what attributes make up a vertex.  A VertexFormat can be provided
+   * to a {@link Geometry} to request that certain properties be computed, e.g., just position,
+   * position and normal, etc.
+   *
+   * @param {Object} [options] An object with boolean properties corresponding to VertexFormat properties as shown in the code example.
+   *
+   * @alias VertexFormat
+   * @constructor
+   *
+   * @example
+   * // Create a vertex format with position and 2D texture coordinate attributes.
+   * const format = new Cesium.VertexFormat({
+   *   position : true,
+   *   st : true
+   * });
+   *
+   * @see Geometry#attributes
+   * @see Packable
+   */
+  function VertexFormat(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+
+    /**
+     * When <code>true</code>, the vertex has a 3D position attribute.
+     * <p>
+     * 64-bit floating-point (for precision).  3 components per attribute.
+     * </p>
+     *
+     * @type Boolean
+     *
+     * @default false
+     */
+    this.position = defaultValue.defaultValue(options.position, false);
+
+    /**
+     * When <code>true</code>, the vertex has a normal attribute (normalized), which is commonly used for lighting.
+     * <p>
+     * 32-bit floating-point.  3 components per attribute.
+     * </p>
+     *
+     * @type Boolean
+     *
+     * @default false
+     */
+    this.normal = defaultValue.defaultValue(options.normal, false);
+
+    /**
+     * When <code>true</code>, the vertex has a 2D texture coordinate attribute.
+     * <p>
+     * 32-bit floating-point.  2 components per attribute
+     * </p>
+     *
+     * @type Boolean
+     *
+     * @default false
+     */
+    this.st = defaultValue.defaultValue(options.st, false);
+
+    /**
+     * When <code>true</code>, the vertex has a bitangent attribute (normalized), which is used for tangent-space effects like bump mapping.
+     * <p>
+     * 32-bit floating-point.  3 components per attribute.
+     * </p>
+     *
+     * @type Boolean
+     *
+     * @default false
+     */
+    this.bitangent = defaultValue.defaultValue(options.bitangent, false);
+
+    /**
+     * When <code>true</code>, the vertex has a tangent attribute (normalized), which is used for tangent-space effects like bump mapping.
+     * <p>
+     * 32-bit floating-point.  3 components per attribute.
+     * </p>
+     *
+     * @type Boolean
+     *
+     * @default false
+     */
+    this.tangent = defaultValue.defaultValue(options.tangent, false);
+
+    /**
+     * When <code>true</code>, the vertex has an RGB color attribute.
+     * <p>
+     * 8-bit unsigned byte.  3 components per attribute.
+     * </p>
+     *
+     * @type Boolean
+     *
+     * @default false
+     */
+    this.color = defaultValue.defaultValue(options.color, false);
+  }
+
+  /**
+   * An immutable vertex format with only a position attribute.
+   *
+   * @type {VertexFormat}
+   * @constant
+   *
+   * @see VertexFormat#position
+   */
+  VertexFormat.POSITION_ONLY = Object.freeze(
+    new VertexFormat({
+      position: true,
+    })
+  );
+
+  /**
+   * An immutable vertex format with position and normal attributes.
+   * This is compatible with per-instance color appearances like {@link PerInstanceColorAppearance}.
+   *
+   * @type {VertexFormat}
+   * @constant
+   *
+   * @see VertexFormat#position
+   * @see VertexFormat#normal
+   */
+  VertexFormat.POSITION_AND_NORMAL = Object.freeze(
+    new VertexFormat({
+      position: true,
+      normal: true,
+    })
+  );
+
+  /**
+   * An immutable vertex format with position, normal, and st attributes.
+   * This is compatible with {@link MaterialAppearance} when {@link MaterialAppearance#materialSupport}
+   * is <code>TEXTURED/code>.
+   *
+   * @type {VertexFormat}
+   * @constant
+   *
+   * @see VertexFormat#position
+   * @see VertexFormat#normal
+   * @see VertexFormat#st
+   */
+  VertexFormat.POSITION_NORMAL_AND_ST = Object.freeze(
+    new VertexFormat({
+      position: true,
+      normal: true,
+      st: true,
+    })
+  );
+
+  /**
+   * An immutable vertex format with position and st attributes.
+   * This is compatible with {@link EllipsoidSurfaceAppearance}.
+   *
+   * @type {VertexFormat}
+   * @constant
+   *
+   * @see VertexFormat#position
+   * @see VertexFormat#st
+   */
+  VertexFormat.POSITION_AND_ST = Object.freeze(
+    new VertexFormat({
+      position: true,
+      st: true,
+    })
+  );
+
+  /**
+   * An immutable vertex format with position and color attributes.
+   *
+   * @type {VertexFormat}
+   * @constant
+   *
+   * @see VertexFormat#position
+   * @see VertexFormat#color
+   */
+  VertexFormat.POSITION_AND_COLOR = Object.freeze(
+    new VertexFormat({
+      position: true,
+      color: true,
+    })
+  );
+
+  /**
+   * An immutable vertex format with well-known attributes: position, normal, st, tangent, and bitangent.
+   *
+   * @type {VertexFormat}
+   * @constant
+   *
+   * @see VertexFormat#position
+   * @see VertexFormat#normal
+   * @see VertexFormat#st
+   * @see VertexFormat#tangent
+   * @see VertexFormat#bitangent
+   */
+  VertexFormat.ALL = Object.freeze(
+    new VertexFormat({
+      position: true,
+      normal: true,
+      st: true,
+      tangent: true,
+      bitangent: true,
+    })
+  );
+
+  /**
+   * An immutable vertex format with position, normal, and st attributes.
+   * This is compatible with most appearances and materials; however
+   * normal and st attributes are not always required.  When this is
+   * known in advance, another <code>VertexFormat</code> should be used.
+   *
+   * @type {VertexFormat}
+   * @constant
+   *
+   * @see VertexFormat#position
+   * @see VertexFormat#normal
+   */
+  VertexFormat.DEFAULT = VertexFormat.POSITION_NORMAL_AND_ST;
+
+  /**
+   * The number of elements used to pack the object into an array.
+   * @type {Number}
+   */
+  VertexFormat.packedLength = 6;
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {VertexFormat} 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
+   */
+  VertexFormat.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);
+
+    array[startingIndex++] = value.position ? 1.0 : 0.0;
+    array[startingIndex++] = value.normal ? 1.0 : 0.0;
+    array[startingIndex++] = value.st ? 1.0 : 0.0;
+    array[startingIndex++] = value.tangent ? 1.0 : 0.0;
+    array[startingIndex++] = value.bitangent ? 1.0 : 0.0;
+    array[startingIndex] = value.color ? 1.0 : 0.0;
+
+    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 {VertexFormat} [result] The object into which to store the result.
+   * @returns {VertexFormat} The modified result parameter or a new VertexFormat instance if one was not provided.
+   */
+  VertexFormat.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);
+
+    if (!defaultValue.defined(result)) {
+      result = new VertexFormat();
+    }
+
+    result.position = array[startingIndex++] === 1.0;
+    result.normal = array[startingIndex++] === 1.0;
+    result.st = array[startingIndex++] === 1.0;
+    result.tangent = array[startingIndex++] === 1.0;
+    result.bitangent = array[startingIndex++] === 1.0;
+    result.color = array[startingIndex] === 1.0;
+    return result;
+  };
+
+  /**
+   * Duplicates a VertexFormat instance.
+   *
+   * @param {VertexFormat} vertexFormat The vertex format to duplicate.
+   * @param {VertexFormat} [result] The object onto which to store the result.
+   * @returns {VertexFormat} The modified result parameter or a new VertexFormat instance if one was not provided. (Returns undefined if vertexFormat is undefined)
+   */
+  VertexFormat.clone = function (vertexFormat, result) {
+    if (!defaultValue.defined(vertexFormat)) {
+      return undefined;
+    }
+    if (!defaultValue.defined(result)) {
+      result = new VertexFormat();
+    }
+
+    result.position = vertexFormat.position;
+    result.normal = vertexFormat.normal;
+    result.st = vertexFormat.st;
+    result.tangent = vertexFormat.tangent;
+    result.bitangent = vertexFormat.bitangent;
+    result.color = vertexFormat.color;
+    return result;
+  };
+
+  exports.VertexFormat = VertexFormat;
+
+}));

package/dist/assets/cesium/Workers/WallGeometryLibrary-919eed92.js

@@ -0,0 +1,211 @@
+define(['exports', './arrayRemoveDuplicates-c2038105', './Matrix3-315394f6', './defaultValue-0a909f67', './Math-2dbd6b93', './PolylinePipeline-32f36d2a'], (function (exports, arrayRemoveDuplicates, Matrix3, defaultValue, Math, PolylinePipeline) { 'use strict';
+
+  /**
+   * @private
+   */
+  const WallGeometryLibrary = {};
+
+  function latLonEquals(c0, c1) {
+    return (
+      Math.CesiumMath.equalsEpsilon(c0.latitude, c1.latitude, Math.CesiumMath.EPSILON10) &&
+      Math.CesiumMath.equalsEpsilon(c0.longitude, c1.longitude, Math.CesiumMath.EPSILON10)
+    );
+  }
+
+  const scratchCartographic1 = new Matrix3.Cartographic();
+  const scratchCartographic2 = new Matrix3.Cartographic();
+  function removeDuplicates(ellipsoid, positions, topHeights, bottomHeights) {
+    positions = arrayRemoveDuplicates.arrayRemoveDuplicates(positions, Matrix3.Cartesian3.equalsEpsilon);
+
+    const length = positions.length;
+    if (length < 2) {
+      return;
+    }
+
+    const hasBottomHeights = defaultValue.defined(bottomHeights);
+    const hasTopHeights = defaultValue.defined(topHeights);
+
+    const cleanedPositions = new Array(length);
+    const cleanedTopHeights = new Array(length);
+    const cleanedBottomHeights = new Array(length);
+
+    const v0 = positions[0];
+    cleanedPositions[0] = v0;
+
+    const c0 = ellipsoid.cartesianToCartographic(v0, scratchCartographic1);
+    if (hasTopHeights) {
+      c0.height = topHeights[0];
+    }
+
+    cleanedTopHeights[0] = c0.height;
+
+    if (hasBottomHeights) {
+      cleanedBottomHeights[0] = bottomHeights[0];
+    } else {
+      cleanedBottomHeights[0] = 0.0;
+    }
+
+    const startTopHeight = cleanedTopHeights[0];
+    const startBottomHeight = cleanedBottomHeights[0];
+    let hasAllSameHeights = startTopHeight === startBottomHeight;
+
+    let index = 1;
+    for (let i = 1; i < length; ++i) {
+      const v1 = positions[i];
+      const c1 = ellipsoid.cartesianToCartographic(v1, scratchCartographic2);
+      if (hasTopHeights) {
+        c1.height = topHeights[i];
+      }
+      hasAllSameHeights = hasAllSameHeights && c1.height === 0;
+
+      if (!latLonEquals(c0, c1)) {
+        cleanedPositions[index] = v1; // Shallow copy!
+        cleanedTopHeights[index] = c1.height;
+
+        if (hasBottomHeights) {
+          cleanedBottomHeights[index] = bottomHeights[i];
+        } else {
+          cleanedBottomHeights[index] = 0.0;
+        }
+        hasAllSameHeights =
+          hasAllSameHeights &&
+          cleanedTopHeights[index] === cleanedBottomHeights[index];
+
+        Matrix3.Cartographic.clone(c1, c0);
+        ++index;
+      } else if (c0.height < c1.height) {
+        // two adjacent positions are the same, so use whichever has the greater height
+        cleanedTopHeights[index - 1] = c1.height;
+      }
+    }
+
+    if (hasAllSameHeights || index < 2) {
+      return;
+    }
+
+    cleanedPositions.length = index;
+    cleanedTopHeights.length = index;
+    cleanedBottomHeights.length = index;
+
+    return {
+      positions: cleanedPositions,
+      topHeights: cleanedTopHeights,
+      bottomHeights: cleanedBottomHeights,
+    };
+  }
+
+  const positionsArrayScratch = new Array(2);
+  const heightsArrayScratch = new Array(2);
+  const generateArcOptionsScratch = {
+    positions: undefined,
+    height: undefined,
+    granularity: undefined,
+    ellipsoid: undefined,
+  };
+
+  /**
+   * @private
+   */
+  WallGeometryLibrary.computePositions = function (
+    ellipsoid,
+    wallPositions,
+    maximumHeights,
+    minimumHeights,
+    granularity,
+    duplicateCorners
+  ) {
+    const o = removeDuplicates(
+      ellipsoid,
+      wallPositions,
+      maximumHeights,
+      minimumHeights
+    );
+
+    if (!defaultValue.defined(o)) {
+      return;
+    }
+
+    wallPositions = o.positions;
+    maximumHeights = o.topHeights;
+    minimumHeights = o.bottomHeights;
+
+    const length = wallPositions.length;
+    const numCorners = length - 2;
+    let topPositions;
+    let bottomPositions;
+
+    const minDistance = Math.CesiumMath.chordLength(
+      granularity,
+      ellipsoid.maximumRadius
+    );
+
+    const generateArcOptions = generateArcOptionsScratch;
+    generateArcOptions.minDistance = minDistance;
+    generateArcOptions.ellipsoid = ellipsoid;
+
+    if (duplicateCorners) {
+      let count = 0;
+      let i;
+
+      for (i = 0; i < length - 1; i++) {
+        count +=
+          PolylinePipeline.PolylinePipeline.numberOfPoints(
+            wallPositions[i],
+            wallPositions[i + 1],
+            minDistance
+          ) + 1;
+      }
+
+      topPositions = new Float64Array(count * 3);
+      bottomPositions = new Float64Array(count * 3);
+
+      const generateArcPositions = positionsArrayScratch;
+      const generateArcHeights = heightsArrayScratch;
+      generateArcOptions.positions = generateArcPositions;
+      generateArcOptions.height = generateArcHeights;
+
+      let offset = 0;
+      for (i = 0; i < length - 1; i++) {
+        generateArcPositions[0] = wallPositions[i];
+        generateArcPositions[1] = wallPositions[i + 1];
+
+        generateArcHeights[0] = maximumHeights[i];
+        generateArcHeights[1] = maximumHeights[i + 1];
+
+        const pos = PolylinePipeline.PolylinePipeline.generateArc(generateArcOptions);
+        topPositions.set(pos, offset);
+
+        generateArcHeights[0] = minimumHeights[i];
+        generateArcHeights[1] = minimumHeights[i + 1];
+
+        bottomPositions.set(
+          PolylinePipeline.PolylinePipeline.generateArc(generateArcOptions),
+          offset
+        );
+
+        offset += pos.length;
+      }
+    } else {
+      generateArcOptions.positions = wallPositions;
+      generateArcOptions.height = maximumHeights;
+      topPositions = new Float64Array(
+        PolylinePipeline.PolylinePipeline.generateArc(generateArcOptions)
+      );
+
+      generateArcOptions.height = minimumHeights;
+      bottomPositions = new Float64Array(
+        PolylinePipeline.PolylinePipeline.generateArc(generateArcOptions)
+      );
+    }
+
+    return {
+      bottomPositions: bottomPositions,
+      topPositions: topPositions,
+      numCorners: numCorners,
+    };
+  };
+  var WallGeometryLibrary$1 = WallGeometryLibrary;
+
+  exports.WallGeometryLibrary = WallGeometryLibrary$1;
+
+}));