@cesium/engine 0.1.0

package/Source/Core/Credit.js

@@ -0,0 +1,166 @@
+import DOMPurify from "dompurify";
+import Check from "./Check.js";
+import defaultValue from "./defaultValue.js";
+import defined from "./defined.js";
+
+let nextCreditId = 0;
+const creditToId = {};
+
+/**
+ * A credit contains data pertaining to how to display attributions/credits for certain content on the screen.
+ * @param {String} html An string representing an html code snippet
+ * @param {Boolean} [showOnScreen=false] If true, the credit will be visible in the main credit container.  Otherwise, it will appear in a popover
+ *
+ * @alias Credit
+ * @constructor
+ *
+ * @exception {DeveloperError} html is required.
+ *
+ * @example
+ * //Create a credit with a tooltip, image and link
+ * const credit = new Cesium.Credit('<a href="https://cesium.com/" target="_blank"><img src="/images/cesium_logo.png" title="Cesium"/></a>');
+ */
+function Credit(html, showOnScreen) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.string("html", html);
+  //>>includeEnd('debug');
+  let id;
+  const key = html;
+
+  if (defined(creditToId[key])) {
+    id = creditToId[key];
+  } else {
+    id = nextCreditId++;
+    creditToId[key] = id;
+  }
+
+  showOnScreen = defaultValue(showOnScreen, false);
+
+  // Credits are immutable so generate an id to use to optimize equal()
+  this._id = id;
+  this._html = html;
+  this._showOnScreen = showOnScreen;
+  this._element = undefined;
+}
+
+Object.defineProperties(Credit.prototype, {
+  /**
+   * The credit content
+   * @memberof Credit.prototype
+   * @type {String}
+   * @readonly
+   */
+  html: {
+    get: function () {
+      return this._html;
+    },
+  },
+
+  /**
+   * @memberof Credit.prototype
+   * @type {Number}
+   * @readonly
+   *
+   * @private
+   */
+  id: {
+    get: function () {
+      return this._id;
+    },
+  },
+
+  /**
+   * Whether the credit should be displayed on screen or in a lightbox
+   * @memberof Credit.prototype
+   * @type {Boolean}
+   */
+  showOnScreen: {
+    get: function () {
+      return this._showOnScreen;
+    },
+    set: function (value) {
+      this._showOnScreen = value;
+    },
+  },
+
+  /**
+   * Gets the credit element
+   * @memberof Credit.prototype
+   * @type {HTMLElement}
+   * @readonly
+   */
+  element: {
+    get: function () {
+      if (!defined(this._element)) {
+        const html = DOMPurify.sanitize(this._html);
+
+        const div = document.createElement("div");
+        div._creditId = this._id;
+        div.style.display = "inline";
+        div.innerHTML = html;
+
+        const links = div.querySelectorAll("a");
+        for (let i = 0; i < links.length; i++) {
+          links[i].setAttribute("target", "_blank");
+        }
+
+        this._element = div;
+      }
+      return this._element;
+    },
+  },
+});
+
+/**
+ * Returns true if the credits are equal
+ *
+ * @param {Credit} left The first credit
+ * @param {Credit} right The second credit
+ * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+ */
+Credit.equals = function (left, right) {
+  return (
+    left === right ||
+    (defined(left) &&
+      defined(right) &&
+      left._id === right._id &&
+      left._showOnScreen === right._showOnScreen)
+  );
+};
+
+/**
+ * Returns true if the credits are equal
+ *
+ * @param {Credit} credit The credit to compare to.
+ * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+ */
+Credit.prototype.equals = function (credit) {
+  return Credit.equals(this, credit);
+};
+
+/**
+ * @private
+ * @param attribution
+ * @return {Credit}
+ */
+Credit.getIonCredit = function (attribution) {
+  const showOnScreen =
+    defined(attribution.collapsible) && !attribution.collapsible;
+  const credit = new Credit(attribution.html, showOnScreen);
+
+  credit._isIon = credit.html.indexOf("ion-credit.png") !== -1;
+  return credit;
+};
+
+/**
+ * Duplicates a Credit instance.
+ *
+ * @param {Credit} [credit] The Credit to duplicate.
+ * @returns {Credit} A new Credit instance that is a duplicate of the one provided. (Returns undefined if the credit is undefined)
+ */
+Credit.clone = function (credit) {
+  if (defined(credit)) {
+    return new Credit(credit.html, credit.showOnScreen);
+  }
+};
+export default Credit;

package/Source/Core/CubicRealPolynomial.js

@@ -0,0 +1,238 @@
+import DeveloperError from "./DeveloperError.js";
+import QuadraticRealPolynomial from "./QuadraticRealPolynomial.js";
+
+/**
+ * Defines functions for 3rd order polynomial functions of one variable with only real coefficients.
+ *
+ * @namespace CubicRealPolynomial
+ */
+const CubicRealPolynomial = {};
+
+/**
+ * Provides the discriminant of the cubic equation from the supplied coefficients.
+ *
+ * @param {Number} a The coefficient of the 3rd order monomial.
+ * @param {Number} b The coefficient of the 2nd order monomial.
+ * @param {Number} c The coefficient of the 1st order monomial.
+ * @param {Number} d The coefficient of the 0th order monomial.
+ * @returns {Number} The value of the discriminant.
+ */
+CubicRealPolynomial.computeDiscriminant = function (a, b, c, d) {
+  //>>includeStart('debug', pragmas.debug);
+  if (typeof a !== "number") {
+    throw new DeveloperError("a is a required number.");
+  }
+  if (typeof b !== "number") {
+    throw new DeveloperError("b is a required number.");
+  }
+  if (typeof c !== "number") {
+    throw new DeveloperError("c is a required number.");
+  }
+  if (typeof d !== "number") {
+    throw new DeveloperError("d is a required number.");
+  }
+  //>>includeEnd('debug');
+
+  const a2 = a * a;
+  const b2 = b * b;
+  const c2 = c * c;
+  const d2 = d * d;
+
+  const discriminant =
+    18.0 * a * b * c * d +
+    b2 * c2 -
+    27.0 * a2 * d2 -
+    4.0 * (a * c2 * c + b2 * b * d);
+  return discriminant;
+};
+
+function computeRealRoots(a, b, c, d) {
+  const A = a;
+  const B = b / 3.0;
+  const C = c / 3.0;
+  const D = d;
+
+  const AC = A * C;
+  const BD = B * D;
+  const B2 = B * B;
+  const C2 = C * C;
+  const delta1 = A * C - B2;
+  const delta2 = A * D - B * C;
+  const delta3 = B * D - C2;
+
+  const discriminant = 4.0 * delta1 * delta3 - delta2 * delta2;
+  let temp;
+  let temp1;
+
+  if (discriminant < 0.0) {
+    let ABar;
+    let CBar;
+    let DBar;
+
+    if (B2 * BD >= AC * C2) {
+      ABar = A;
+      CBar = delta1;
+      DBar = -2.0 * B * delta1 + A * delta2;
+    } else {
+      ABar = D;
+      CBar = delta3;
+      DBar = -D * delta2 + 2.0 * C * delta3;
+    }
+
+    const s = DBar < 0.0 ? -1.0 : 1.0; // This is not Math.Sign()!
+    const temp0 = -s * Math.abs(ABar) * Math.sqrt(-discriminant);
+    temp1 = -DBar + temp0;
+
+    const x = temp1 / 2.0;
+    const p = x < 0.0 ? -Math.pow(-x, 1.0 / 3.0) : Math.pow(x, 1.0 / 3.0);
+    const q = temp1 === temp0 ? -p : -CBar / p;
+
+    temp = CBar <= 0.0 ? p + q : -DBar / (p * p + q * q + CBar);
+
+    if (B2 * BD >= AC * C2) {
+      return [(temp - B) / A];
+    }
+
+    return [-D / (temp + C)];
+  }
+
+  const CBarA = delta1;
+  const DBarA = -2.0 * B * delta1 + A * delta2;
+
+  const CBarD = delta3;
+  const DBarD = -D * delta2 + 2.0 * C * delta3;
+
+  const squareRootOfDiscriminant = Math.sqrt(discriminant);
+  const halfSquareRootOf3 = Math.sqrt(3.0) / 2.0;
+
+  let theta = Math.abs(Math.atan2(A * squareRootOfDiscriminant, -DBarA) / 3.0);
+  temp = 2.0 * Math.sqrt(-CBarA);
+  let cosine = Math.cos(theta);
+  temp1 = temp * cosine;
+  let temp3 = temp * (-cosine / 2.0 - halfSquareRootOf3 * Math.sin(theta));
+
+  const numeratorLarge = temp1 + temp3 > 2.0 * B ? temp1 - B : temp3 - B;
+  const denominatorLarge = A;
+
+  const root1 = numeratorLarge / denominatorLarge;
+
+  theta = Math.abs(Math.atan2(D * squareRootOfDiscriminant, -DBarD) / 3.0);
+  temp = 2.0 * Math.sqrt(-CBarD);
+  cosine = Math.cos(theta);
+  temp1 = temp * cosine;
+  temp3 = temp * (-cosine / 2.0 - halfSquareRootOf3 * Math.sin(theta));
+
+  const numeratorSmall = -D;
+  const denominatorSmall = temp1 + temp3 < 2.0 * C ? temp1 + C : temp3 + C;
+
+  const root3 = numeratorSmall / denominatorSmall;
+
+  const E = denominatorLarge * denominatorSmall;
+  const F =
+    -numeratorLarge * denominatorSmall - denominatorLarge * numeratorSmall;
+  const G = numeratorLarge * numeratorSmall;
+
+  const root2 = (C * F - B * G) / (-B * F + C * E);
+
+  if (root1 <= root2) {
+    if (root1 <= root3) {
+      if (root2 <= root3) {
+        return [root1, root2, root3];
+      }
+      return [root1, root3, root2];
+    }
+    return [root3, root1, root2];
+  }
+  if (root1 <= root3) {
+    return [root2, root1, root3];
+  }
+  if (root2 <= root3) {
+    return [root2, root3, root1];
+  }
+  return [root3, root2, root1];
+}
+
+/**
+ * Provides the real valued roots of the cubic polynomial with the provided coefficients.
+ *
+ * @param {Number} a The coefficient of the 3rd order monomial.
+ * @param {Number} b The coefficient of the 2nd order monomial.
+ * @param {Number} c The coefficient of the 1st order monomial.
+ * @param {Number} d The coefficient of the 0th order monomial.
+ * @returns {Number[]} The real valued roots.
+ */
+CubicRealPolynomial.computeRealRoots = function (a, b, c, d) {
+  //>>includeStart('debug', pragmas.debug);
+  if (typeof a !== "number") {
+    throw new DeveloperError("a is a required number.");
+  }
+  if (typeof b !== "number") {
+    throw new DeveloperError("b is a required number.");
+  }
+  if (typeof c !== "number") {
+    throw new DeveloperError("c is a required number.");
+  }
+  if (typeof d !== "number") {
+    throw new DeveloperError("d is a required number.");
+  }
+  //>>includeEnd('debug');
+
+  let roots;
+  let ratio;
+  if (a === 0.0) {
+    // Quadratic function: b * x^2 + c * x + d = 0.
+    return QuadraticRealPolynomial.computeRealRoots(b, c, d);
+  } else if (b === 0.0) {
+    if (c === 0.0) {
+      if (d === 0.0) {
+        // 3rd order monomial: a * x^3 = 0.
+        return [0.0, 0.0, 0.0];
+      }
+
+      // a * x^3 + d = 0
+      ratio = -d / a;
+      const root =
+        ratio < 0.0 ? -Math.pow(-ratio, 1.0 / 3.0) : Math.pow(ratio, 1.0 / 3.0);
+      return [root, root, root];
+    } else if (d === 0.0) {
+      // x * (a * x^2 + c) = 0.
+      roots = QuadraticRealPolynomial.computeRealRoots(a, 0, c);
+
+      // Return the roots in ascending order.
+      if (roots.Length === 0) {
+        return [0.0];
+      }
+      return [roots[0], 0.0, roots[1]];
+    }
+
+    // Deflated cubic polynomial: a * x^3 + c * x + d= 0.
+    return computeRealRoots(a, 0, c, d);
+  } else if (c === 0.0) {
+    if (d === 0.0) {
+      // x^2 * (a * x + b) = 0.
+      ratio = -b / a;
+      if (ratio < 0.0) {
+        return [ratio, 0.0, 0.0];
+      }
+      return [0.0, 0.0, ratio];
+    }
+    // a * x^3 + b * x^2 + d = 0.
+    return computeRealRoots(a, b, 0, d);
+  } else if (d === 0.0) {
+    // x * (a * x^2 + b * x + c) = 0
+    roots = QuadraticRealPolynomial.computeRealRoots(a, b, c);
+
+    // Return the roots in ascending order.
+    if (roots.length === 0) {
+      return [0.0];
+    } else if (roots[1] <= 0.0) {
+      return [roots[0], roots[1], 0.0];
+    } else if (roots[0] >= 0.0) {
+      return [0.0, roots[0], roots[1]];
+    }
+    return [roots[0], 0.0, roots[1]];
+  }
+
+  return computeRealRoots(a, b, c, d);
+};
+export default CubicRealPolynomial;

package/Source/Core/CullingVolume.js

@@ -0,0 +1,217 @@
+import Cartesian3 from "./Cartesian3.js";
+import Cartesian4 from "./Cartesian4.js";
+import defaultValue from "./defaultValue.js";
+import defined from "./defined.js";
+import DeveloperError from "./DeveloperError.js";
+import Intersect from "./Intersect.js";
+import Plane from "./Plane.js";
+
+/**
+ * The culling volume defined by planes.
+ *
+ * @alias CullingVolume
+ * @constructor
+ *
+ * @param {Cartesian4[]} [planes] An array of clipping planes.
+ */
+function CullingVolume(planes) {
+  /**
+   * Each plane is represented by a Cartesian4 object, where the x, y, and z components
+   * define the unit vector normal to the plane, and the w component is the distance of the
+   * plane from the origin.
+   * @type {Cartesian4[]}
+   * @default []
+   */
+  this.planes = defaultValue(planes, []);
+}
+
+const faces = [new Cartesian3(), new Cartesian3(), new Cartesian3()];
+Cartesian3.clone(Cartesian3.UNIT_X, faces[0]);
+Cartesian3.clone(Cartesian3.UNIT_Y, faces[1]);
+Cartesian3.clone(Cartesian3.UNIT_Z, faces[2]);
+
+const scratchPlaneCenter = new Cartesian3();
+const scratchPlaneNormal = new Cartesian3();
+const scratchPlane = new Plane(new Cartesian3(1.0, 0.0, 0.0), 0.0);
+
+/**
+ * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.
+ * The planes are aligned to the x, y, and z axes in world coordinates.
+ *
+ * @param {BoundingSphere} boundingSphere The bounding sphere used to create the culling volume.
+ * @param {CullingVolume} [result] The object onto which to store the result.
+ * @returns {CullingVolume} The culling volume created from the bounding sphere.
+ */
+CullingVolume.fromBoundingSphere = function (boundingSphere, result) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(boundingSphere)) {
+    throw new DeveloperError("boundingSphere is required.");
+  }
+  //>>includeEnd('debug');
+
+  if (!defined(result)) {
+    result = new CullingVolume();
+  }
+
+  const length = faces.length;
+  const planes = result.planes;
+  planes.length = 2 * length;
+
+  const center = boundingSphere.center;
+  const radius = boundingSphere.radius;
+
+  let planeIndex = 0;
+
+  for (let i = 0; i < length; ++i) {
+    const faceNormal = faces[i];
+
+    let plane0 = planes[planeIndex];
+    let plane1 = planes[planeIndex + 1];
+
+    if (!defined(plane0)) {
+      plane0 = planes[planeIndex] = new Cartesian4();
+    }
+    if (!defined(plane1)) {
+      plane1 = planes[planeIndex + 1] = new Cartesian4();
+    }
+
+    Cartesian3.multiplyByScalar(faceNormal, -radius, scratchPlaneCenter);
+    Cartesian3.add(center, scratchPlaneCenter, scratchPlaneCenter);
+
+    plane0.x = faceNormal.x;
+    plane0.y = faceNormal.y;
+    plane0.z = faceNormal.z;
+    plane0.w = -Cartesian3.dot(faceNormal, scratchPlaneCenter);
+
+    Cartesian3.multiplyByScalar(faceNormal, radius, scratchPlaneCenter);
+    Cartesian3.add(center, scratchPlaneCenter, scratchPlaneCenter);
+
+    plane1.x = -faceNormal.x;
+    plane1.y = -faceNormal.y;
+    plane1.z = -faceNormal.z;
+    plane1.w = -Cartesian3.dot(
+      Cartesian3.negate(faceNormal, scratchPlaneNormal),
+      scratchPlaneCenter
+    );
+
+    planeIndex += 2;
+  }
+
+  return result;
+};
+
+/**
+ * Determines whether a bounding volume intersects the culling volume.
+ *
+ * @param {Object} boundingVolume The bounding volume whose intersection with the culling volume is to be tested.
+ * @returns {Intersect}  Intersect.OUTSIDE, Intersect.INTERSECTING, or Intersect.INSIDE.
+ */
+CullingVolume.prototype.computeVisibility = function (boundingVolume) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(boundingVolume)) {
+    throw new DeveloperError("boundingVolume is required.");
+  }
+  //>>includeEnd('debug');
+
+  const planes = this.planes;
+  let intersecting = false;
+  for (let k = 0, len = planes.length; k < len; ++k) {
+    const result = boundingVolume.intersectPlane(
+      Plane.fromCartesian4(planes[k], scratchPlane)
+    );
+    if (result === Intersect.OUTSIDE) {
+      return Intersect.OUTSIDE;
+    } else if (result === Intersect.INTERSECTING) {
+      intersecting = true;
+    }
+  }
+
+  return intersecting ? Intersect.INTERSECTING : Intersect.INSIDE;
+};
+
+/**
+ * Determines whether a bounding volume intersects the culling volume.
+ *
+ * @param {Object} boundingVolume The bounding volume whose intersection with the culling volume is to be tested.
+ * @param {Number} parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling
+ *                                 volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then
+ *                                 the parent (and therefore this) volume is completely inside plane[planeIndex]
+ *                                 and that plane check can be skipped.
+ * @returns {Number} A plane mask as described above (which can be applied to this boundingVolume's children).
+ *
+ * @private
+ */
+CullingVolume.prototype.computeVisibilityWithPlaneMask = function (
+  boundingVolume,
+  parentPlaneMask
+) {
+  //>>includeStart('debug', pragmas.debug);
+  if (!defined(boundingVolume)) {
+    throw new DeveloperError("boundingVolume is required.");
+  }
+  if (!defined(parentPlaneMask)) {
+    throw new DeveloperError("parentPlaneMask is required.");
+  }
+  //>>includeEnd('debug');
+
+  if (
+    parentPlaneMask === CullingVolume.MASK_OUTSIDE ||
+    parentPlaneMask === CullingVolume.MASK_INSIDE
+  ) {
+    // parent is completely outside or completely inside, so this child is as well.
+    return parentPlaneMask;
+  }
+
+  // Start with MASK_INSIDE (all zeros) so that after the loop, the return value can be compared with MASK_INSIDE.
+  // (Because if there are fewer than 31 planes, the upper bits wont be changed.)
+  let mask = CullingVolume.MASK_INSIDE;
+
+  const planes = this.planes;
+  for (let k = 0, len = planes.length; k < len; ++k) {
+    // For k greater than 31 (since 31 is the maximum number of INSIDE/INTERSECTING bits we can store), skip the optimization.
+    const flag = k < 31 ? 1 << k : 0;
+    if (k < 31 && (parentPlaneMask & flag) === 0) {
+      // boundingVolume is known to be INSIDE this plane.
+      continue;
+    }
+
+    const result = boundingVolume.intersectPlane(
+      Plane.fromCartesian4(planes[k], scratchPlane)
+    );
+    if (result === Intersect.OUTSIDE) {
+      return CullingVolume.MASK_OUTSIDE;
+    } else if (result === Intersect.INTERSECTING) {
+      mask |= flag;
+    }
+  }
+
+  return mask;
+};
+
+/**
+ * For plane masks (as used in {@link CullingVolume#computeVisibilityWithPlaneMask}), this special value
+ * represents the case where the object bounding volume is entirely outside the culling volume.
+ *
+ * @type {Number}
+ * @private
+ */
+CullingVolume.MASK_OUTSIDE = 0xffffffff;
+
+/**
+ * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
+ * represents the case where the object bounding volume is entirely inside the culling volume.
+ *
+ * @type {Number}
+ * @private
+ */
+CullingVolume.MASK_INSIDE = 0x00000000;
+
+/**
+ * For plane masks (as used in {@link CullingVolume.prototype.computeVisibilityWithPlaneMask}), this value
+ * represents the case where the object bounding volume (may) intersect all planes of the culling volume.
+ *
+ * @type {Number}
+ * @private
+ */
+CullingVolume.MASK_INDETERMINATE = 0x7fffffff;
+export default CullingVolume;