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

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

@@ -1,25 +1,251 @@
-/**
- * @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","./Transforms-d2e5867e","./Matrix2-eefef8eb","./ComponentDatatype-0200bf8c","./FrustumGeometry-a8b5d817","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./_commonjsHelpers-bc29abbc","./combine-7533016d","./RuntimeError-5baf5c66","./WebGLConstants-5b50ced1","./Plane-b0299683","./VertexFormat-5ec0d9ff"],(function(e,t,r,n,a,u,i,o,c,s,p,m,f){"use strict";function d(n){const u=n.frustum,i=n.orientation,o=n.origin,c=e.defaultValue(n._drawNearPlane,!0);let s,p;u instanceof a.PerspectiveFrustum?(s=0,p=a.PerspectiveFrustum.packedLength):u instanceof a.OrthographicFrustum&&(s=1,p=a.OrthographicFrustum.packedLength),this._frustumType=s,this._frustum=u.clone(),this._origin=r.Cartesian3.clone(o),this._orientation=t.Quaternion.clone(i),this._drawNearPlane=c,this._workerName="createFrustumOutlineGeometry",this.packedLength=2+p+r.Cartesian3.packedLength+t.Quaternion.packedLength}d.pack=function(n,u,i){i=e.defaultValue(i,0);const o=n._frustumType,c=n._frustum;return u[i++]=o,0===o?(a.PerspectiveFrustum.pack(c,u,i),i+=a.PerspectiveFrustum.packedLength):(a.OrthographicFrustum.pack(c,u,i),i+=a.OrthographicFrustum.packedLength),r.Cartesian3.pack(n._origin,u,i),i+=r.Cartesian3.packedLength,t.Quaternion.pack(n._orientation,u,i),u[i+=t.Quaternion.packedLength]=n._drawNearPlane?1:0,u};const h=new a.PerspectiveFrustum,l=new a.OrthographicFrustum,g=new t.Quaternion,_=new r.Cartesian3;return d.unpack=function(n,u,i){u=e.defaultValue(u,0);const o=n[u++];let c;0===o?(c=a.PerspectiveFrustum.unpack(n,u,h),u+=a.PerspectiveFrustum.packedLength):(c=a.OrthographicFrustum.unpack(n,u,l),u+=a.OrthographicFrustum.packedLength);const s=r.Cartesian3.unpack(n,u,_);u+=r.Cartesian3.packedLength;const p=t.Quaternion.unpack(n,u,g),m=1===n[u+=t.Quaternion.packedLength];if(!e.defined(i))return new d({frustum:c,origin:s,orientation:p,_drawNearPlane:m});const f=o===i._frustumType?i._frustum:void 0;return i._frustum=c.clone(f),i._frustumType=o,i._origin=r.Cartesian3.clone(s,i._origin),i._orientation=t.Quaternion.clone(p,i._orientation),i._drawNearPlane=m,i},d.createGeometry=function(e){const r=e._frustumType,o=e._frustum,c=e._origin,s=e._orientation,p=e._drawNearPlane,m=new Float64Array(24);a.FrustumGeometry._computeNearFarPlanes(c,s,r,o,m);const f=new i.GeometryAttributes({position:new u.GeometryAttribute({componentDatatype:n.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:m})});let d,h;const l=p?2:1,g=new Uint16Array(8*(l+1));let _=p?0:1;for(;_<2;++_)d=p?8*_:0,h=4*_,g[d]=h,g[d+1]=h+1,g[d+2]=h+1,g[d+3]=h+2,g[d+4]=h+2,g[d+5]=h+3,g[d+6]=h+3,g[d+7]=h;for(_=0;_<2;++_)d=8*(l+_),h=4*_,g[d]=h,g[d+1]=h+4,g[d+2]=h+1,g[d+3]=h+5,g[d+4]=h+2,g[d+5]=h+6,g[d+6]=h+3,g[d+7]=h+7;return new u.Geometry({attributes:f,indices:g,primitiveType:u.PrimitiveType.LINES,boundingSphere:t.BoundingSphere.fromVertices(m)})},function(t,r){return e.defined(r)&&(t=d.unpack(t,r)),d.createGeometry(t)}}));
+define(['./defaultValue-0a909f67', './Transforms-40229881', './Matrix3-315394f6', './Check-666ab1a0', './ComponentDatatype-f7b11d02', './FrustumGeometry-ac42a6d9', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './Math-2dbd6b93', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c', './Plane-900aa728', './VertexFormat-6b480673'], (function (defaultValue, Transforms, Matrix3, Check, ComponentDatatype, FrustumGeometry, GeometryAttribute, GeometryAttributes, Math, Matrix2, RuntimeError, combine, WebGLConstants, Plane, VertexFormat) { 'use strict';
+
+  const PERSPECTIVE = 0;
+  const ORTHOGRAPHIC = 1;
+
+  /**
+   * A description of the outline of a frustum with the given the origin and orientation.
+   *
+   * @alias FrustumOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {PerspectiveFrustum|OrthographicFrustum} options.frustum The frustum.
+   * @param {Cartesian3} options.origin The origin of the frustum.
+   * @param {Quaternion} options.orientation The orientation of the frustum.
+   */
+  function FrustumOutlineGeometry(options) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("options", options);
+    Check.Check.typeOf.object("options.frustum", options.frustum);
+    Check.Check.typeOf.object("options.origin", options.origin);
+    Check.Check.typeOf.object("options.orientation", options.orientation);
+    //>>includeEnd('debug');
+
+    const frustum = options.frustum;
+    const orientation = options.orientation;
+    const origin = options.origin;
+
+    // This is private because it is used by DebugCameraPrimitive to draw a multi-frustum by
+    // creating multiple FrustumOutlineGeometrys. This way the near plane of one frustum doesn't overlap
+    // the far plane of another.
+    const drawNearPlane = defaultValue.defaultValue(options._drawNearPlane, true);
+
+    let frustumType;
+    let frustumPackedLength;
+    if (frustum instanceof FrustumGeometry.PerspectiveFrustum) {
+      frustumType = PERSPECTIVE;
+      frustumPackedLength = FrustumGeometry.PerspectiveFrustum.packedLength;
+    } else if (frustum instanceof FrustumGeometry.OrthographicFrustum) {
+      frustumType = ORTHOGRAPHIC;
+      frustumPackedLength = FrustumGeometry.OrthographicFrustum.packedLength;
+    }
+
+    this._frustumType = frustumType;
+    this._frustum = frustum.clone();
+    this._origin = Matrix3.Cartesian3.clone(origin);
+    this._orientation = Transforms.Quaternion.clone(orientation);
+    this._drawNearPlane = drawNearPlane;
+    this._workerName = "createFrustumOutlineGeometry";
+
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    this.packedLength =
+      2 + frustumPackedLength + Matrix3.Cartesian3.packedLength + Transforms.Quaternion.packedLength;
+  }
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {FrustumOutlineGeometry} 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
+   */
+  FrustumOutlineGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("value", value);
+    Check.Check.defined("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    const frustumType = value._frustumType;
+    const frustum = value._frustum;
+
+    array[startingIndex++] = frustumType;
+
+    if (frustumType === PERSPECTIVE) {
+      FrustumGeometry.PerspectiveFrustum.pack(frustum, array, startingIndex);
+      startingIndex += FrustumGeometry.PerspectiveFrustum.packedLength;
+    } else {
+      FrustumGeometry.OrthographicFrustum.pack(frustum, array, startingIndex);
+      startingIndex += FrustumGeometry.OrthographicFrustum.packedLength;
+    }
+
+    Matrix3.Cartesian3.pack(value._origin, array, startingIndex);
+    startingIndex += Matrix3.Cartesian3.packedLength;
+    Transforms.Quaternion.pack(value._orientation, array, startingIndex);
+    startingIndex += Transforms.Quaternion.packedLength;
+    array[startingIndex] = value._drawNearPlane ? 1.0 : 0.0;
+
+    return array;
+  };
+
+  const scratchPackPerspective = new FrustumGeometry.PerspectiveFrustum();
+  const scratchPackOrthographic = new FrustumGeometry.OrthographicFrustum();
+  const scratchPackQuaternion = new Transforms.Quaternion();
+  const scratchPackorigin = new Matrix3.Cartesian3();
+
+  /**
+   * 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 {FrustumOutlineGeometry} [result] The object into which to store the result.
+   */
+  FrustumOutlineGeometry.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.defined("array", array);
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    const frustumType = array[startingIndex++];
+
+    let frustum;
+    if (frustumType === PERSPECTIVE) {
+      frustum = FrustumGeometry.PerspectiveFrustum.unpack(
+        array,
+        startingIndex,
+        scratchPackPerspective
+      );
+      startingIndex += FrustumGeometry.PerspectiveFrustum.packedLength;
+    } else {
+      frustum = FrustumGeometry.OrthographicFrustum.unpack(
+        array,
+        startingIndex,
+        scratchPackOrthographic
+      );
+      startingIndex += FrustumGeometry.OrthographicFrustum.packedLength;
+    }
+
+    const origin = Matrix3.Cartesian3.unpack(array, startingIndex, scratchPackorigin);
+    startingIndex += Matrix3.Cartesian3.packedLength;
+    const orientation = Transforms.Quaternion.unpack(
+      array,
+      startingIndex,
+      scratchPackQuaternion
+    );
+    startingIndex += Transforms.Quaternion.packedLength;
+    const drawNearPlane = array[startingIndex] === 1.0;
+
+    if (!defaultValue.defined(result)) {
+      return new FrustumOutlineGeometry({
+        frustum: frustum,
+        origin: origin,
+        orientation: orientation,
+        _drawNearPlane: drawNearPlane,
+      });
+    }
+
+    const frustumResult =
+      frustumType === result._frustumType ? result._frustum : undefined;
+    result._frustum = frustum.clone(frustumResult);
+
+    result._frustumType = frustumType;
+    result._origin = Matrix3.Cartesian3.clone(origin, result._origin);
+    result._orientation = Transforms.Quaternion.clone(orientation, result._orientation);
+    result._drawNearPlane = drawNearPlane;
+
+    return result;
+  };
+
+  /**
+   * Computes the geometric representation of a frustum outline, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {FrustumOutlineGeometry} frustumGeometry A description of the frustum.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  FrustumOutlineGeometry.createGeometry = function (frustumGeometry) {
+    const frustumType = frustumGeometry._frustumType;
+    const frustum = frustumGeometry._frustum;
+    const origin = frustumGeometry._origin;
+    const orientation = frustumGeometry._orientation;
+    const drawNearPlane = frustumGeometry._drawNearPlane;
+
+    const positions = new Float64Array(3 * 4 * 2);
+    FrustumGeometry.FrustumGeometry._computeNearFarPlanes(
+      origin,
+      orientation,
+      frustumType,
+      frustum,
+      positions
+    );
+
+    const attributes = new GeometryAttributes.GeometryAttributes({
+      position: new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+        componentsPerAttribute: 3,
+        values: positions,
+      }),
+    });
+
+    let offset;
+    let index;
+
+    const numberOfPlanes = drawNearPlane ? 2 : 1;
+    const indices = new Uint16Array(8 * (numberOfPlanes + 1));
+
+    // Build the near/far planes
+    let i = drawNearPlane ? 0 : 1;
+    for (; i < 2; ++i) {
+      offset = drawNearPlane ? i * 8 : 0;
+      index = i * 4;
+
+      indices[offset] = index;
+      indices[offset + 1] = index + 1;
+      indices[offset + 2] = index + 1;
+      indices[offset + 3] = index + 2;
+      indices[offset + 4] = index + 2;
+      indices[offset + 5] = index + 3;
+      indices[offset + 6] = index + 3;
+      indices[offset + 7] = index;
+    }
+
+    // Build the sides of the frustums
+    for (i = 0; i < 2; ++i) {
+      offset = (numberOfPlanes + i) * 8;
+      index = i * 4;
+
+      indices[offset] = index;
+      indices[offset + 1] = index + 4;
+      indices[offset + 2] = index + 1;
+      indices[offset + 3] = index + 5;
+      indices[offset + 4] = index + 2;
+      indices[offset + 5] = index + 6;
+      indices[offset + 6] = index + 3;
+      indices[offset + 7] = index + 7;
+    }
+
+    return new GeometryAttribute.Geometry({
+      attributes: attributes,
+      indices: indices,
+      primitiveType: GeometryAttribute.PrimitiveType.LINES,
+      boundingSphere: Transforms.BoundingSphere.fromVertices(positions),
+    });
+  };
+
+  function createFrustumOutlineGeometry(frustumGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      frustumGeometry = FrustumOutlineGeometry.unpack(frustumGeometry, offset);
+    }
+    return FrustumOutlineGeometry.createGeometry(frustumGeometry);
+  }
+
+  return createFrustumOutlineGeometry;
+
+}));

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

@@ -1,25 +1,55 @@
-/**
- * @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","./PrimitivePipeline-e2640413","./createTaskProcessorWorker","./Transforms-d2e5867e","./Matrix2-eefef8eb","./ComponentDatatype-0200bf8c","./WebGLConstants-5b50ced1","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryPipeline-33ca229c","./AttributeCompression-7b0f288d","./EncodedCartesian3-ea0e408f","./IndexDatatype-e713bfd2","./IntersectionTests-eb4db8e0","./Plane-b0299683","./WebMercatorProjection-cd2f30c2"],(function(e,t,r,n,o,i,s,c,a,f,b,u,d,m,l,p,y,P,k){"use strict";const C={};function G(t){let r=C[t];return e.defined(r)||("object"==typeof exports?C[r]=r=require(`Workers/${t}`):require([`Workers/${t}`],(function(e){r=e,C[r]=e}))),r}return r((function(r,n){const o=r.subTasks,i=o.length,s=new Array(i);for(let t=0;t<i;t++){const r=o[t],n=r.geometry,i=r.moduleName;if(e.defined(i)){const e=G(i);s[t]=e(n,r.offset)}else s[t]=n}return Promise.all(s).then((function(e){return t.PrimitivePipeline.packCreateGeometryResults(e,n)}))}))}));
+define(['./defaultValue-0a909f67', './PrimitivePipeline-ba38434a', './createTaskProcessorWorker', './Transforms-40229881', './Matrix3-315394f6', './Check-666ab1a0', './Math-2dbd6b93', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './ComponentDatatype-f7b11d02', './WebGLConstants-a8cc3e8c', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './GeometryPipeline-ce4339ed', './AttributeCompression-b646d393', './EncodedCartesian3-81f70735', './IndexDatatype-a55ceaa1', './IntersectionTests-f6e6bd8a', './Plane-900aa728', './WebMercatorProjection-13a90d41'], (function (defaultValue, PrimitivePipeline, createTaskProcessorWorker, Transforms, Matrix3, Check, Math, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryPipeline, AttributeCompression, EncodedCartesian3, IndexDatatype, IntersectionTests, Plane, WebMercatorProjection) { 'use strict';
+
+  /* global require */
+
+  const moduleCache = {};
+
+  function getModule(moduleName) {
+    let module = moduleCache[moduleName];
+    if (!defaultValue.defined(module)) {
+      if (typeof exports === "object") {
+        // Use CommonJS-style require.
+        moduleCache[module] = module = require(`Workers/${moduleName}`);
+      } else {
+        // Use AMD-style require.
+        // in web workers, require is synchronous
+        require([`Workers/${moduleName}`], function (f) {
+          module = f;
+          moduleCache[module] = f;
+        });
+      }
+    }
+    return module;
+  }
+
+  function createGeometry(parameters, transferableObjects) {
+    const subTasks = parameters.subTasks;
+    const length = subTasks.length;
+    const resultsOrPromises = new Array(length);
+
+    for (let i = 0; i < length; i++) {
+      const task = subTasks[i];
+      const geometry = task.geometry;
+      const moduleName = task.moduleName;
+
+      if (defaultValue.defined(moduleName)) {
+        const createFunction = getModule(moduleName);
+        resultsOrPromises[i] = createFunction(geometry, task.offset);
+      } else {
+        //Already created geometry
+        resultsOrPromises[i] = geometry;
+      }
+    }
+
+    return Promise.all(resultsOrPromises).then(function (results) {
+      return PrimitivePipeline.PrimitivePipeline.packCreateGeometryResults(
+        results,
+        transferableObjects
+      );
+    });
+  }
+  var createGeometry$1 = createTaskProcessorWorker(createGeometry);
+
+  return createGeometry$1;
+
+}));