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

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

@@ -1,25 +1,126 @@
-/**
- * @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","./EllipsoidOutlineGeometry-e6e16e49","./ComponentDatatype-0200bf8c","./WebGLConstants-5b50ced1","./RuntimeError-5baf5c66","./Transforms-d2e5867e","./_commonjsHelpers-bc29abbc","./combine-7533016d","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./GeometryOffsetAttribute-08ae0c50","./IndexDatatype-e713bfd2"],(function(e,i,t,n,o,r,s,a,d,l,c,u,m){"use strict";function p(n){const o=e.defaultValue(n.radius,1),r={radii:new i.Cartesian3(o,o,o),stackPartitions:n.stackPartitions,slicePartitions:n.slicePartitions,subdivisions:n.subdivisions};this._ellipsoidGeometry=new t.EllipsoidOutlineGeometry(r),this._workerName="createSphereOutlineGeometry"}p.packedLength=t.EllipsoidOutlineGeometry.packedLength,p.pack=function(e,i,n){return t.EllipsoidOutlineGeometry.pack(e._ellipsoidGeometry,i,n)};const f=new t.EllipsoidOutlineGeometry,y={radius:void 0,radii:new i.Cartesian3,stackPartitions:void 0,slicePartitions:void 0,subdivisions:void 0};return p.unpack=function(n,o,r){const s=t.EllipsoidOutlineGeometry.unpack(n,o,f);return y.stackPartitions=s._stackPartitions,y.slicePartitions=s._slicePartitions,y.subdivisions=s._subdivisions,e.defined(r)?(i.Cartesian3.clone(s._radii,y.radii),r._ellipsoidGeometry=new t.EllipsoidOutlineGeometry(y),r):(y.radius=s._radii.x,new p(y))},p.createGeometry=function(e){return t.EllipsoidOutlineGeometry.createGeometry(e._ellipsoidGeometry)},function(i,t){return e.defined(t)&&(i=p.unpack(i,t)),p.createGeometry(i)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './Check-666ab1a0', './EllipsoidOutlineGeometry-eff247c8', './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, EllipsoidOutlineGeometry, Math, Transforms, Matrix2, RuntimeError, combine, ComponentDatatype, WebGLConstants, GeometryAttribute, GeometryAttributes, GeometryOffsetAttribute, IndexDatatype) { 'use strict';
+
+  /**
+   * A description of the outline of a sphere.
+   *
+   * @alias SphereOutlineGeometry
+   * @constructor
+   *
+   * @param {Object} [options] Object with the following properties:
+   * @param {Number} [options.radius=1.0] The radius of the sphere.
+   * @param {Number} [options.stackPartitions=10] The count of stacks for the sphere (1 greater than the number of parallel lines).
+   * @param {Number} [options.slicePartitions=8] The count of slices for the sphere (Equal to the number of radial lines).
+   * @param {Number} [options.subdivisions=200] The number of points per line, determining the granularity of the curvature .
+   *
+   * @exception {DeveloperError} options.stackPartitions must be greater than or equal to one.
+   * @exception {DeveloperError} options.slicePartitions must be greater than or equal to zero.
+   * @exception {DeveloperError} options.subdivisions must be greater than or equal to zero.
+   *
+   * @example
+   * const sphere = new Cesium.SphereOutlineGeometry({
+   *   radius : 100.0,
+   *   stackPartitions : 6,
+   *   slicePartitions: 5
+   * });
+   * const geometry = Cesium.SphereOutlineGeometry.createGeometry(sphere);
+   */
+  function SphereOutlineGeometry(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,
+      subdivisions: options.subdivisions,
+    };
+
+    this._ellipsoidGeometry = new EllipsoidOutlineGeometry.EllipsoidOutlineGeometry(ellipsoidOptions);
+    this._workerName = "createSphereOutlineGeometry";
+  }
+
+  /**
+   * The number of elements used to pack the object into an array.
+   * @type {Number}
+   */
+  SphereOutlineGeometry.packedLength = EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.packedLength;
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {SphereOutlineGeometry} 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
+   */
+  SphereOutlineGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.Check.typeOf.object("value", value);
+    //>>includeEnd('debug');
+
+    return EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.pack(
+      value._ellipsoidGeometry,
+      array,
+      startingIndex
+    );
+  };
+
+  const scratchEllipsoidGeometry = new EllipsoidOutlineGeometry.EllipsoidOutlineGeometry();
+  const scratchOptions = {
+    radius: undefined,
+    radii: new Matrix3.Cartesian3(),
+    stackPartitions: undefined,
+    slicePartitions: undefined,
+    subdivisions: 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 {SphereOutlineGeometry} [result] The object into which to store the result.
+   * @returns {SphereOutlineGeometry} The modified result parameter or a new SphereOutlineGeometry instance if one was not provided.
+   */
+  SphereOutlineGeometry.unpack = function (array, startingIndex, result) {
+    const ellipsoidGeometry = EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.unpack(
+      array,
+      startingIndex,
+      scratchEllipsoidGeometry
+    );
+    scratchOptions.stackPartitions = ellipsoidGeometry._stackPartitions;
+    scratchOptions.slicePartitions = ellipsoidGeometry._slicePartitions;
+    scratchOptions.subdivisions = ellipsoidGeometry._subdivisions;
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.radius = ellipsoidGeometry._radii.x;
+      return new SphereOutlineGeometry(scratchOptions);
+    }
+
+    Matrix3.Cartesian3.clone(ellipsoidGeometry._radii, scratchOptions.radii);
+    result._ellipsoidGeometry = new EllipsoidOutlineGeometry.EllipsoidOutlineGeometry(scratchOptions);
+    return result;
+  };
+
+  /**
+   * Computes the geometric representation of an outline of a sphere, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {SphereOutlineGeometry} sphereGeometry A description of the sphere outline.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  SphereOutlineGeometry.createGeometry = function (sphereGeometry) {
+    return EllipsoidOutlineGeometry.EllipsoidOutlineGeometry.createGeometry(
+      sphereGeometry._ellipsoidGeometry
+    );
+  };
+
+  function createSphereOutlineGeometry(sphereGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      sphereGeometry = SphereOutlineGeometry.unpack(sphereGeometry, offset);
+    }
+    return SphereOutlineGeometry.createGeometry(sphereGeometry);
+  }
+
+  return createSphereOutlineGeometry;
+
+}));

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

@@ -1,25 +1,127 @@
-/**
- * @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"],(function(e){"use strict";return function(r){let t;return function(n){const s=n.data,a=[],i={id:s.id,result:void 0,error:void 0};return Promise.resolve(function(e,r,t){let n;try{return n=e(r,t),n}catch(e){return Promise.reject(e)}}(r,s.parameters,a)).then((function(e){i.result=e})).catch((function(e){e instanceof Error?i.error={name:e.name,message:e.message,stack:e.stack}:i.error=e})).finally((function(){e.defined(t)||(t=e.defaultValue(self.webkitPostMessage,self.postMessage)),s.canTransferArrayBuffer||(a.length=0);try{t(i,a)}catch(r){i.result=void 0,i.error=`postMessage failed with error: ${function(r){let t;const n=r.name,s=r.message;t=e.defined(n)&&e.defined(s)?`${n}: ${s}`:r.toString();const a=r.stack;return e.defined(a)&&(t+=`\n${a}`),t}(r)}\n  with responseMessage: ${JSON.stringify(i)}`,t(i)}}))}}}));
+define(['./defaultValue-0a909f67'], (function (defaultValue) { 'use strict';
+
+  /**
+   * Formats an error object into a String.  If available, uses name, message, and stack
+   * properties, otherwise, falls back on toString().
+   *
+   * @function
+   *
+   * @param {*} object The item to find in the array.
+   * @returns {String} A string containing the formatted error.
+   */
+  function formatError(object) {
+    let result;
+
+    const name = object.name;
+    const message = object.message;
+    if (defaultValue.defined(name) && defaultValue.defined(message)) {
+      result = `${name}: ${message}`;
+    } else {
+      result = object.toString();
+    }
+
+    const stack = object.stack;
+    if (defaultValue.defined(stack)) {
+      result += `\n${stack}`;
+    }
+
+    return result;
+  }
+
+  // createXXXGeometry functions may return Geometry or a Promise that resolves to Geometry
+  // if the function requires access to ApproximateTerrainHeights.
+  // For fully synchronous functions, just wrapping the function call in a Promise doesn't
+  // handle errors correctly, hence try-catch
+  function callAndWrap(workerFunction, parameters, transferableObjects) {
+    let resultOrPromise;
+    try {
+      resultOrPromise = workerFunction(parameters, transferableObjects);
+      return resultOrPromise; // errors handled by Promise
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
+  /**
+   * Creates an adapter function to allow a calculation function to operate as a Web Worker,
+   * paired with TaskProcessor, to receive tasks and return results.
+   *
+   * @function createTaskProcessorWorker
+   *
+   * @param {createTaskProcessorWorker.WorkerFunction} workerFunction The calculation function,
+   *        which takes parameters and returns a result.
+   * @returns {createTaskProcessorWorker.TaskProcessorWorkerFunction} A function that adapts the
+   *          calculation function to work as a Web Worker onmessage listener with TaskProcessor.
+   *
+   *
+   * @example
+   * function doCalculation(parameters, transferableObjects) {
+   *   // calculate some result using the inputs in parameters
+   *   return result;
+   * }
+   *
+   * return Cesium.createTaskProcessorWorker(doCalculation);
+   * // the resulting function is compatible with TaskProcessor
+   *
+   * @see TaskProcessor
+   * @see {@link http://www.w3.org/TR/workers/|Web Workers}
+   * @see {@link http://www.w3.org/TR/html5/common-dom-interfaces.html#transferable-objects|Transferable objects}
+   */
+  function createTaskProcessorWorker(workerFunction) {
+    let postMessage;
+
+    return function (event) {
+      const data = event.data;
+
+      const transferableObjects = [];
+      const responseMessage = {
+        id: data.id,
+        result: undefined,
+        error: undefined,
+      };
+
+      return Promise.resolve(
+        callAndWrap(workerFunction, data.parameters, transferableObjects)
+      )
+        .then(function (result) {
+          responseMessage.result = result;
+        })
+        .catch(function (e) {
+          if (e instanceof Error) {
+            // Errors can't be posted in a message, copy the properties
+            responseMessage.error = {
+              name: e.name,
+              message: e.message,
+              stack: e.stack,
+            };
+          } else {
+            responseMessage.error = e;
+          }
+        })
+        .finally(function () {
+          if (!defaultValue.defined(postMessage)) {
+            postMessage = defaultValue.defaultValue(self.webkitPostMessage, self.postMessage);
+          }
+
+          if (!data.canTransferArrayBuffer) {
+            transferableObjects.length = 0;
+          }
+
+          try {
+            postMessage(responseMessage, transferableObjects);
+          } catch (e) {
+            // something went wrong trying to post the message, post a simpler
+            // error that we can be sure will be cloneable
+            responseMessage.result = undefined;
+            responseMessage.error = `postMessage failed with error: ${formatError(
+            e
+          )}\n  with responseMessage: ${JSON.stringify(responseMessage)}`;
+            postMessage(responseMessage);
+          }
+        });
+    };
+  }
+
+  return createTaskProcessorWorker;
+
+}));