@baidumap/mapv-three 1.0.0

package/dist/types/threemap/engine/map/earth/EllipsoidalOccluder.d.ts

@@ -0,0 +1,187 @@
+/**
+ * Determine whether or not other objects are visible or hidden behind the visible horizon defined by
+ * an {@link Ellipsoid} and a camera position.  The ellipsoid is assumed to be located at the
+ * origin of the coordinate system.  This class uses the algorithm described in the
+ * {@link https://cesium.com/blog/2013/04/25/Horizon-culling/|Horizon Culling} blog post.
+ *
+ * @alias EllipsoidalOccluder
+ *
+ * @param {Ellipsoid} ellipsoid The ellipsoid to use as an occluder.
+ * @param {Cartesian3} [cameraPosition] The coordinate of the viewer/camera.  If this parameter is not
+ *        specified, {@link EllipsoidalOccluder#cameraPosition} must be called before
+ *        testing visibility.
+ *
+ * @constructor
+ *
+ * @example
+ * // Construct an ellipsoidal occluder with radii 1.0, 1.1, and 0.9.
+ * const cameraPosition = new Cesium.Cartesian3(5.0, 6.0, 7.0);
+ * const occluderEllipsoid = new Cesium.Ellipsoid(1.0, 1.1, 0.9);
+ * const occluder = new Cesium.EllipsoidalOccluder(occluderEllipsoid, cameraPosition);
+ *
+ * @private
+ */
+export function EllipsoidalOccluder(ellipsoid: Ellipsoid, cameraPosition?: Cartesian3): void;
+export class EllipsoidalOccluder {
+    /**
+     * Determine whether or not other objects are visible or hidden behind the visible horizon defined by
+     * an {@link Ellipsoid} and a camera position.  The ellipsoid is assumed to be located at the
+     * origin of the coordinate system.  This class uses the algorithm described in the
+     * {@link https://cesium.com/blog/2013/04/25/Horizon-culling/|Horizon Culling} blog post.
+     *
+     * @alias EllipsoidalOccluder
+     *
+     * @param {Ellipsoid} ellipsoid The ellipsoid to use as an occluder.
+     * @param {Cartesian3} [cameraPosition] The coordinate of the viewer/camera.  If this parameter is not
+     *        specified, {@link EllipsoidalOccluder#cameraPosition} must be called before
+     *        testing visibility.
+     *
+     * @constructor
+     *
+     * @example
+     * // Construct an ellipsoidal occluder with radii 1.0, 1.1, and 0.9.
+     * const cameraPosition = new Cesium.Cartesian3(5.0, 6.0, 7.0);
+     * const occluderEllipsoid = new Cesium.Ellipsoid(1.0, 1.1, 0.9);
+     * const occluder = new Cesium.EllipsoidalOccluder(occluderEllipsoid, cameraPosition);
+     *
+     * @private
+     */
+    private constructor();
+    _ellipsoid: Ellipsoid;
+    _cameraPosition: any;
+    _cameraPositionInScaledSpace: any;
+    _distanceToLimbInScaledSpaceSquared: number;
+    cameraPosition: Cartesian3 | undefined;
+    /**
+     * Determines whether or not a point, the <code>occludee</code>, is hidden from view by the occluder.
+     *
+     * @param {Cartesian3} occludee The point to test for visibility.
+     * @returns {Boolean} <code>true</code> if the occludee is visible; otherwise <code>false</code>.
+     *
+     * @example
+     * const cameraPosition = new Cesium.Cartesian3(0, 0, 2.5);
+     * const ellipsoid = new Cesium.Ellipsoid(1.0, 1.1, 0.9);
+     * const occluder = new Cesium.EllipsoidalOccluder(ellipsoid, cameraPosition);
+     * const point = new Cesium.Cartesian3(0, -3, -3);
+     * occluder.isPointVisible(point); //returns true
+     */
+    isPointVisible(occludee: Cartesian3): boolean;
+    /**
+     * Determines whether or not a point expressed in the ellipsoid scaled space, is hidden from view by the
+     * occluder.  To transform a Cartesian X, Y, Z position in the coordinate system aligned with the ellipsoid
+     * into the scaled space, call {@link Ellipsoid#transformPositionToScaledSpace}.
+     *
+     * @param {Cartesian3} occludeeScaledSpacePosition The point to test for visibility, represented in the scaled space.
+     * @returns {Boolean} <code>true</code> if the occludee is visible; otherwise <code>false</code>.
+     *
+     * @example
+     * const cameraPosition = new Cesium.Cartesian3(0, 0, 2.5);
+     * const ellipsoid = new Cesium.Ellipsoid(1.0, 1.1, 0.9);
+     * const occluder = new Cesium.EllipsoidalOccluder(ellipsoid, cameraPosition);
+     * const point = new Cesium.Cartesian3(0, -3, -3);
+     * const scaledSpacePoint = ellipsoid.transformPositionToScaledSpace(point);
+     * occluder.isScaledSpacePointVisible(scaledSpacePoint); //returns true
+     */
+    isScaledSpacePointVisible(occludeeScaledSpacePosition: Cartesian3): boolean;
+    /**
+     * Similar to {@link EllipsoidalOccluder#isScaledSpacePointVisible} except tests against an
+     * ellipsoid that has been shrunk by the minimum height when the minimum height is below
+     * the ellipsoid. This is intended to be used with points generated by
+     * {@link EllipsoidalOccluder#computeHorizonCullingPointPossiblyUnderEllipsoid} or
+     * {@link EllipsoidalOccluder#computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid}.
+     *
+     * @param {Cartesian3} occludeeScaledSpacePosition The point to test for visibility, represented in the scaled space of the possibly-shrunk ellipsoid.
+     * @returns {Boolean} <code>true</code> if the occludee is visible; otherwise <code>false</code>.
+     */
+    isScaledSpacePointVisiblePossiblyUnderEllipsoid(occludeeScaledSpacePosition: Cartesian3, minimumHeight: any): boolean;
+    /**
+     * Computes a point that can be used for horizon culling from a list of positions.  If the point is below
+     * the horizon, all of the positions are guaranteed to be below the horizon as well.  The returned point
+     * is expressed in the ellipsoid-scaled space and is suitable for use with
+     * {@link EllipsoidalOccluder#isScaledSpacePointVisible}.
+     *
+     * @param {Cartesian3} directionToPoint The direction that the computed point will lie along.
+     *                     A reasonable direction to use is the direction from the center of the ellipsoid to
+     *                     the center of the bounding sphere computed from the positions.  The direction need not
+     *                     be normalized.
+     * @param {Cartesian3[]} positions The positions from which to compute the horizon culling point.  The positions
+     *                       must be expressed in a reference frame centered at the ellipsoid and aligned with the
+     *                       ellipsoid's axes.
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
+     */
+    computeHorizonCullingPoint(directionToPoint: Cartesian3, positions: Cartesian3[], result?: Cartesian3): Cartesian3;
+    /**
+     * Similar to {@link EllipsoidalOccluder#computeHorizonCullingPoint} except computes the culling
+     * point relative to an ellipsoid that has been shrunk by the minimum height when the minimum height is below
+     * the ellipsoid. The returned point is expressed in the possibly-shrunk ellipsoid-scaled space and is suitable
+     * for use with {@link EllipsoidalOccluder#isScaledSpacePointVisiblePossiblyUnderEllipsoid}.
+     *
+     * @param {Cartesian3} directionToPoint The direction that the computed point will lie along.
+     *                     A reasonable direction to use is the direction from the center of the ellipsoid to
+     *                     the center of the bounding sphere computed from the positions.  The direction need not
+     *                     be normalized.
+     * @param {Cartesian3[]} positions The positions from which to compute the horizon culling point.  The positions
+     *                       must be expressed in a reference frame centered at the ellipsoid and aligned with the
+     *                       ellipsoid's axes.
+     * @param {Number} [minimumHeight] The minimum height of all positions. If this value is undefined, all positions are assumed to be above the ellipsoid.
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the possibly-shrunk ellipsoid-scaled space.
+     */
+    computeHorizonCullingPointPossiblyUnderEllipsoid(directionToPoint: Cartesian3, positions: Cartesian3[], minimumHeight?: number, result?: Cartesian3): Cartesian3;
+    /**
+     * Computes a point that can be used for horizon culling from a list of positions.  If the point is below
+     * the horizon, all of the positions are guaranteed to be below the horizon as well.  The returned point
+     * is expressed in the ellipsoid-scaled space and is suitable for use with
+     * {@link EllipsoidalOccluder#isScaledSpacePointVisible}.
+     *
+     * @param {Cartesian3} directionToPoint The direction that the computed point will lie along.
+     *                     A reasonable direction to use is the direction from the center of the ellipsoid to
+     *                     the center of the bounding sphere computed from the positions.  The direction need not
+     *                     be normalized.
+     * @param {Number[]} vertices  The vertices from which to compute the horizon culling point.  The positions
+     *                   must be expressed in a reference frame centered at the ellipsoid and aligned with the
+     *                   ellipsoid's axes.
+     * @param {Number} [stride=3]
+     * @param {Cartesian3} [center=Cartesian3.ZERO]
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
+     */
+    computeHorizonCullingPointFromVertices(directionToPoint: Cartesian3, vertices: number[], stride?: number, center?: Cartesian3, result?: Cartesian3): Cartesian3;
+    /**
+     * Similar to {@link EllipsoidalOccluder#computeHorizonCullingPointFromVertices} except computes the culling
+     * point relative to an ellipsoid that has been shrunk by the minimum height when the minimum height is below
+     * the ellipsoid. The returned point is expressed in the possibly-shrunk ellipsoid-scaled space and is suitable
+     * for use with {@link EllipsoidalOccluder#isScaledSpacePointVisiblePossiblyUnderEllipsoid}.
+     *
+     * @param {Cartesian3} directionToPoint The direction that the computed point will lie along.
+     *                     A reasonable direction to use is the direction from the center of the ellipsoid to
+     *                     the center of the bounding sphere computed from the positions.  The direction need not
+     *                     be normalized.
+     * @param {Number[]} vertices  The vertices from which to compute the horizon culling point.  The positions
+     *                   must be expressed in a reference frame centered at the ellipsoid and aligned with the
+     *                   ellipsoid's axes.
+     * @param {Number} [stride=3]
+     * @param {Cartesian3} [center=Cartesian3.ZERO]
+     * @param {Number} [minimumHeight] The minimum height of all vertices. If this value is undefined, all vertices are assumed to be above the ellipsoid.
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the possibly-shrunk ellipsoid-scaled space.
+     */
+    computeHorizonCullingPointFromVerticesPossiblyUnderEllipsoid(directionToPoint: Cartesian3, vertices: number[], stride?: number, center?: Cartesian3, minimumHeight?: number, result?: Cartesian3): Cartesian3;
+    /**
+     * Computes a point that can be used for horizon culling of a rectangle.  If the point is below
+     * the horizon, the ellipsoid-conforming rectangle is guaranteed to be below the horizon as well.
+     * The returned point is expressed in the ellipsoid-scaled space and is suitable for use with
+     * {@link EllipsoidalOccluder#isScaledSpacePointVisible}.
+     *
+     * @param {Rectangle} rectangle The rectangle for which to compute the horizon culling point.
+     * @param {Ellipsoid} ellipsoid The ellipsoid on which the rectangle is defined.  This may be different from
+     *                    the ellipsoid used by this instance for occlusion testing.
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
+     */
+    computeHorizonCullingPointFromRectangle(rectangle: Rectangle, ellipsoid: Ellipsoid, result?: Cartesian3): Cartesian3;
+}
+import { Ellipsoid } from './Ellipsoid';
+import { Cartesian3 } from './Cartesian3';
+import { Rectangle } from './Rectangle';

package/dist/types/threemap/engine/map/earth/GeographicProjection.d.ts

@@ -0,0 +1,9 @@
+export function GeographicProjection(ellipsoid: any): void;
+export class GeographicProjection {
+    constructor(ellipsoid: any);
+    _ellipsoid: any;
+    _semimajorAxis: any;
+    _oneOverSemimajorAxis: number;
+    project(cartographic: any, result: any): any;
+    unproject(cartesian: any, result: any): any;
+}

package/dist/types/threemap/engine/map/earth/Globe.d.ts

@@ -0,0 +1,7 @@
+export class Globe {
+    constructor(ellipsoid: any, engine: any);
+    _ellipsoid: any;
+    _engine: any;
+    onBeforeScenePrepareRender(engine: any, scene: any, camera: any, renderState: any): void;
+    get ellipsoid(): any;
+}

package/dist/types/threemap/engine/map/earth/HeadingPitchRange.d.ts

@@ -0,0 +1,7 @@
+export class HeadingPitchRange {
+    constructor(heading: any, pitch: any, range: any);
+    heading: any;
+    pitch: any;
+    range: any;
+    clone(hpr: any, result: any): any;
+}

package/dist/types/threemap/engine/map/earth/HeadingPitchRoll.d.ts

@@ -0,0 +1,75 @@
+export function HeadingPitchRoll(heading: any, pitch: any, roll: any): void;
+export class HeadingPitchRoll {
+    constructor(heading: any, pitch: any, roll: any);
+    /**
+   * Gets or sets the heading.
+   * @type {number}
+   * @default 0.0
+   */
+    heading: number;
+    /**
+   * Gets or sets the pitch.
+   * @type {number}
+   * @default 0.0
+   */
+    pitch: number;
+    /**
+   * Gets or sets the roll.
+   * @type {number}
+   * @default 0.0
+   */
+    roll: number;
+    clone(result: any): HeadingPitchRoll;
+    equals(right: any): boolean;
+    equalsEpsilon(right: any, relativeEpsilon: any, absoluteEpsilon: any): boolean;
+    toString(): string;
+}
+export namespace HeadingPitchRoll {
+    /**
+     * Computes the heading, pitch and roll from a quaternion (see http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles )
+     *
+     * @param {Quaternion} quaternion The quaternion from which to retrieve heading, pitch, and roll, all expressed in radians.
+     * @param {HeadingPitchRoll} [result] The object in which to store the result. If not provided, a new instance is created and returned.
+     * @returns {HeadingPitchRoll} The modified result parameter or a new HeadingPitchRoll instance if one was not provided.
+     */
+    function fromQuaternion(quaternion: Quaternion, result?: HeadingPitchRoll): HeadingPitchRoll;
+    /**
+     * Returns a new HeadingPitchRoll instance from angles given in degrees.
+     *
+     * @param {number} heading the heading in degrees
+     * @param {number} pitch the pitch in degrees
+     * @param {number} roll the heading in degrees
+     * @param {HeadingPitchRoll} [result] The object in which to store the result. If not provided, a new instance is created and returned.
+     * @returns {HeadingPitchRoll} A new HeadingPitchRoll instance
+     */
+    function fromDegrees(heading: number, pitch: number, roll: number, result?: HeadingPitchRoll): HeadingPitchRoll;
+    /**
+     * Duplicates a HeadingPitchRoll instance.
+     *
+     * @param {HeadingPitchRoll} headingPitchRoll The HeadingPitchRoll to duplicate.
+     * @param {HeadingPitchRoll} [result] The object onto which to store the result.
+     * @returns {HeadingPitchRoll} The modified result parameter or a new HeadingPitchRoll instance if one was not provided. (Returns undefined if headingPitchRoll is undefined)
+     */
+    function clone(headingPitchRoll: HeadingPitchRoll, result?: HeadingPitchRoll): HeadingPitchRoll;
+    /**
+     * Compares the provided HeadingPitchRolls componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     *
+     * @param {HeadingPitchRoll} [left] The first HeadingPitchRoll.
+     * @param {HeadingPitchRoll} [right] The second HeadingPitchRoll.
+     * @returns {boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    function equals(left?: HeadingPitchRoll, right?: HeadingPitchRoll): boolean;
+    /**
+     * Compares the provided HeadingPitchRolls componentwise and returns
+     * <code>true</code> if they pass an absolute or relative tolerance test,
+     * <code>false</code> otherwise.
+     *
+     * @param {HeadingPitchRoll} [left] The first HeadingPitchRoll.
+     * @param {HeadingPitchRoll} [right] The second HeadingPitchRoll.
+     * @param {number} [relativeEpsilon=0] The relative epsilon tolerance to use for equality testing.
+     * @param {number} [absoluteEpsilon=relativeEpsilon] The absolute epsilon tolerance to use for equality testing.
+     * @returns {boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+     */
+    function equalsEpsilon(left?: HeadingPitchRoll, right?: HeadingPitchRoll, relativeEpsilon?: number, absoluteEpsilon?: number): boolean;
+}

package/dist/types/threemap/engine/map/earth/IndexDatatype.d.ts

@@ -0,0 +1,27 @@
+declare const _default: Readonly<{
+    /**
+   * 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
+   * of an element in <code>Uint8Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+    UNSIGNED_BYTE: number;
+    /**
+   * 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
+   * of an element in <code>Uint16Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+    UNSIGNED_SHORT: number;
+    /**
+   * 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
+   * of an element in <code>Uint32Array</code>.
+   *
+   * @type {number}
+   * @constant
+   */
+    UNSIGNED_INT: number;
+}>;
+export default _default;

package/dist/types/threemap/engine/map/earth/IntersectionTests.d.ts

@@ -0,0 +1,135 @@
+export namespace IntersectionTests {
+    function rayPlane(ray: any, plane: any, result: any): any;
+    /**
+     * Computes the intersection of a ray and a triangle as a parametric distance along the input ray. The result is negative when the triangle is behind the ray.
+     *
+     * Implements {@link https://cadxfem.org/inf/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf|
+     * Fast Minimum Storage Ray/Triangle Intersection} by Tomas Moller and Ben Trumbore.
+     *
+     * @memberof IntersectionTests
+     *
+     * @param {Ray} ray The ray.
+     * @param {Cartesian3} p0 The first vertex of the triangle.
+     * @param {Cartesian3} p1 The second vertex of the triangle.
+     * @param {Cartesian3} p2 The third vertex of the triangle.
+     * @param {Boolean} [cullBackFaces=false] If <code>true</code>, will only compute an intersection with the front face of the triangle
+     *                  and return undefined for intersections with the back face.
+     * @returns {Number} The intersection as a parametric distance along the ray, or undefined if there is no intersection.
+     */
+    function rayTriangleParametric(ray: Ray, p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, cullBackFaces?: boolean): number;
+    /**
+     * Computes the intersection of a ray and a triangle as a Cartesian3 coordinate.
+     *
+     * Implements {@link https://cadxfem.org/inf/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf|
+     * Fast Minimum Storage Ray/Triangle Intersection} by Tomas Moller and Ben Trumbore.
+     *
+     * @memberof IntersectionTests
+     *
+     * @param {Ray} ray The ray.
+     * @param {Cartesian3} p0 The first vertex of the triangle.
+     * @param {Cartesian3} p1 The second vertex of the triangle.
+     * @param {Cartesian3} p2 The third vertex of the triangle.
+     * @param {Boolean} [cullBackFaces=false] If <code>true</code>, will only compute an intersection with the front face of the triangle
+     *                  and return undefined for intersections with the back face.
+     * @param {Cartesian3} [result] The <code>Cartesian3</code> onto which to store the result.
+     * @returns {Cartesian3} The intersection point or undefined if there is no intersections.
+     */
+    function rayTriangle(ray: Ray, p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, cullBackFaces?: boolean, result?: Cartesian3): Cartesian3;
+    /**
+     * Computes the intersection of a line segment and a triangle.
+     * @memberof IntersectionTests
+     *
+     * @param {Cartesian3} v0 The an end point of the line segment.
+     * @param {Cartesian3} v1 The other end point of the line segment.
+     * @param {Cartesian3} p0 The first vertex of the triangle.
+     * @param {Cartesian3} p1 The second vertex of the triangle.
+     * @param {Cartesian3} p2 The third vertex of the triangle.
+     * @param {Boolean} [cullBackFaces=false] If <code>true</code>, will only compute an intersection with the front face of the triangle
+     *                  and return undefined for intersections with the back face.
+     * @param {Cartesian3} [result] The <code>Cartesian3</code> onto which to store the result.
+     * @returns {Cartesian3} The intersection point or undefined if there is no intersections.
+     */
+    function lineSegmentTriangle(v0: Cartesian3, v1: Cartesian3, p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, cullBackFaces?: boolean, result?: Cartesian3): Cartesian3;
+    /**
+     * Computes the intersection points of a ray with a sphere.
+     * @memberof IntersectionTests
+     *
+     * @param {Ray} ray The ray.
+     * @param {BoundingSphere} sphere The sphere.
+     * @param {Interval} [result] The result onto which to store the result.
+     * @returns {Interval} The interval containing scalar points along the ray or undefined if there are no intersections.
+     */
+    function raySphere(ray: Ray, sphere: BoundingSphere, result?: Interval): Interval;
+    /**
+     * Computes the intersection points of a line segment with a sphere.
+     * @memberof IntersectionTests
+     *
+     * @param {Cartesian3} p0 An end point of the line segment.
+     * @param {Cartesian3} p1 The other end point of the line segment.
+     * @param {BoundingSphere} sphere The sphere.
+     * @param {Interval} [result] The result onto which to store the result.
+     * @returns {Interval} The interval containing scalar points along the ray or undefined if there are no intersections.
+     */
+    function lineSegmentSphere(p0: Cartesian3, p1: Cartesian3, sphere: BoundingSphere, result?: Interval): Interval;
+    /**
+     * Computes the intersection points of a ray with an ellipsoid.
+     *
+     * @param {Ray} ray The ray.
+     * @param {Ellipsoid} ellipsoid The ellipsoid.
+     * @returns {Interval} The interval containing scalar points along the ray or undefined if there are no intersections.
+     */
+    function rayEllipsoid(ray: Ray, ellipsoid: Ellipsoid): Interval;
+    /**
+     * Provides the point along the ray which is nearest to the ellipsoid.
+     *
+     * @param {Ray} ray The ray.
+     * @param {Ellipsoid} ellipsoid The ellipsoid.
+     * @returns {Cartesian3} The nearest planetodetic point on the ray.
+     */
+    function grazingAltitudeLocation(ray: Ray, ellipsoid: Ellipsoid): Cartesian3;
+    /**
+     * Computes the intersection of a line segment and a plane.
+     *
+     * @param {Cartesian3} endPoint0 An end point of the line segment.
+     * @param {Cartesian3} endPoint1 The other end point of the line segment.
+     * @param {Plane} plane The plane.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @returns {Cartesian3} The intersection point or undefined if there is no intersection.
+     *
+     * @example
+     * var origin = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
+     * var normal = ellipsoid.geodeticSurfaceNormal(origin);
+     * var plane = Cesium.Plane.fromPointNormal(origin, normal);
+     *
+     * var p0 = new Cesium.Cartesian3(...);
+     * var p1 = new Cesium.Cartesian3(...);
+     *
+     * // find the intersection of the line segment from p0 to p1 and the tangent plane at origin.
+     * var intersection = Cesium.IntersectionTests.lineSegmentPlane(p0, p1, plane);
+     */
+    function lineSegmentPlane(endPoint0: Cartesian3, endPoint1: Cartesian3, plane: Plane, result?: Cartesian3): Cartesian3;
+    /**
+     * Computes the intersection of a triangle and a plane
+     *
+     * @param {Cartesian3} p0 First point of the triangle
+     * @param {Cartesian3} p1 Second point of the triangle
+     * @param {Cartesian3} p2 Third point of the triangle
+     * @param {Plane} plane Intersection plane
+     * @returns {Object} An object with properties <code>positions</code> and <code>indices</code>, which are arrays that represent three triangles that do not cross the plane. (Undefined if no intersection exists)
+     *
+     * @example
+     * var origin = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
+     * var normal = ellipsoid.geodeticSurfaceNormal(origin);
+     * var plane = Cesium.Plane.fromPointNormal(origin, normal);
+     *
+     * var p0 = new Cesium.Cartesian3(...);
+     * var p1 = new Cesium.Cartesian3(...);
+     * var p2 = new Cesium.Cartesian3(...);
+     *
+     * // convert the triangle composed of points (p0, p1, p2) to three triangles that don't cross the plane
+     * var triangles = Cesium.IntersectionTests.trianglePlaneIntersection(p0, p1, p2, plane);
+     */
+    function trianglePlaneIntersection(p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, plane: Plane): Object;
+}
+import { Cartesian3 } from './Cartesian3';
+import { Interval } from './Interval';

package/dist/types/threemap/engine/map/earth/Intersections2D.d.ts

@@ -0,0 +1,70 @@
+export default Intersections2D;
+declare namespace Intersections2D {
+    /**
+     * Splits a 2D triangle at given axis-aligned threshold value and returns the resulting
+     * polygon on a given side of the threshold.  The resulting polygon may have 0, 1, 2,
+     * 3, or 4 vertices.
+     *
+     * @param {number} threshold The threshold coordinate value at which to clip the triangle.
+     * @param {boolean} keepAbove true to keep the portion of the triangle above the threshold, or false
+     *                            to keep the portion below.
+     * @param {number} u0 The coordinate of the first vertex in the triangle, in counter-clockwise order.
+     * @param {number} u1 The coordinate of the second vertex in the triangle, in counter-clockwise order.
+     * @param {number} u2 The coordinate of the third vertex in the triangle, in counter-clockwise order.
+     * @param {number[]} [result] The array into which to copy the result.  If this parameter is not supplied,
+     *                            a new array is constructed and returned.
+     * @returns {number[]} The polygon that results after the clip, specified as a list of
+     *                     vertices.  The vertices are specified in counter-clockwise order.
+     *                     Each vertex is either an index from the existing list (identified as
+     *                     a 0, 1, or 2) or -1 indicating a new vertex not in the original triangle.
+     *                     For new vertices, the -1 is followed by three additional numbers: the
+     *                     index of each of the two original vertices forming the line segment that
+     *                     the new vertex lies on, and the fraction of the distance from the first
+     *                     vertex to the second one.
+     *
+     * @example
+     * const result = Cesium.Intersections2D.clipTriangleAtAxisAlignedThreshold(0.5, false, 0.2, 0.6, 0.4);
+     * // result === [2, 0, -1, 1, 0, 0.25, -1, 1, 2, 0.5]
+     */
+    function clipTriangleAtAxisAlignedThreshold(threshold: number, keepAbove: boolean, u0: number, u1: number, u2: number, result?: number[]): number[];
+    /**
+     * Compute the barycentric coordinates of a 2D position within a 2D triangle.
+     *
+     * @param {number} x The x coordinate of the position for which to find the barycentric coordinates.
+     * @param {number} y The y coordinate of the position for which to find the barycentric coordinates.
+     * @param {number} x1 The x coordinate of the triangle's first vertex.
+     * @param {number} y1 The y coordinate of the triangle's first vertex.
+     * @param {number} x2 The x coordinate of the triangle's second vertex.
+     * @param {number} y2 The y coordinate of the triangle's second vertex.
+     * @param {number} x3 The x coordinate of the triangle's third vertex.
+     * @param {number} y3 The y coordinate of the triangle's third vertex.
+     * @param {Vector3} [result] The instance into to which to copy the result.  If this parameter
+     *                     is undefined, a new instance is created and returned.
+     * @returns {Vector3} The barycentric coordinates of the position within the triangle.
+     *
+     * @example
+     * const result = Cesium.Intersections2D.computeBarycentricCoordinates(0.0, 0.0, 0.0, 1.0, -1, -0.5, 1, -0.5);
+     * // result === new Cesium.Vector3(1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0);
+     */
+    function computeBarycentricCoordinates(x: number, y: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, result?: Vector3): Vector3;
+    /**
+     * Compute the intersection between 2 line segments
+     *
+     * @param {number} x00 The x coordinate of the first line's first vertex.
+     * @param {number} y00 The y coordinate of the first line's first vertex.
+     * @param {number} x01 The x coordinate of the first line's second vertex.
+     * @param {number} y01 The y coordinate of the first line's second vertex.
+     * @param {number} x10 The x coordinate of the second line's first vertex.
+     * @param {number} y10 The y coordinate of the second line's first vertex.
+     * @param {number} x11 The x coordinate of the second line's second vertex.
+     * @param {number} y11 The y coordinate of the second line's second vertex.
+     * @param {Vector2} [result] The instance into to which to copy the result. If this parameter
+     *                     is undefined, a new instance is created and returned.
+     * @returns {Vector2} The intersection point, undefined if there is no intersection point or lines are coincident.
+     *
+     * @example
+     * const result = Cesium.Intersections2D.computeLineSegmentLineSegmentIntersection(0.0, 0.0, 0.0, 2.0, -1, 1, 1, 1);
+     * // result === new Cesium.Vector2(0.0, 1.0);
+     */
+    function computeLineSegmentLineSegmentIntersection(x00: number, y00: number, x01: number, y01: number, x10: number, y10: number, x11: number, y11: number, result?: Vector2): Vector2;
+}

package/dist/types/threemap/engine/map/earth/Interval.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Represents the closed interval [start, stop].
+ * @alias Interval
+ * @constructor
+ *
+ * @param {Number} [start=0.0] The beginning of the interval.
+ * @param {Number} [stop=0.0] The end of the interval.
+ */
+export function Interval(start?: number, stop?: number): void;
+export class Interval {
+    /**
+     * Represents the closed interval [start, stop].
+     * @alias Interval
+     * @constructor
+     *
+     * @param {Number} [start=0.0] The beginning of the interval.
+     * @param {Number} [stop=0.0] The end of the interval.
+     */
+    constructor(start?: number, stop?: number);
+    /**
+     * The beginning of the interval.
+     * @type {Number}
+     * @default 0.0
+     */
+    start: number;
+    /**
+     * The end of the interval.
+     * @type {Number}
+     * @default 0.0
+     */
+    stop: number;
+}

package/dist/types/threemap/engine/map/earth/KeyboardEventModifier.d.ts

@@ -0,0 +1,34 @@
+declare const _default: Readonly<{
+    /**
+     * Represents the shift key being held down.
+     *
+     * @type {number}
+     * @constant
+     */
+    SHIFT: number;
+    /**
+     * Represents the control key being held down.
+     *
+     * @type {number}
+     * @constant
+     */
+    CTRL: number;
+    /**
+     * Represents the alt key being held down.
+     *
+     * @type {number}
+     * @constant
+     */
+    ALT: number;
+}>;
+export default _default;
+/**
+ * This enumerated type is for representing keyboard modifiers. These are keys
+ * that are held down in addition to other event types.
+ */
+export type KeyboardEventModifier = number;
+export namespace KeyboardEventModifier {
+    let SHIFT: number;
+    let CTRL: number;
+    let ALT: number;
+}

package/dist/types/threemap/engine/map/earth/MapMode2D.d.ts

@@ -0,0 +1,25 @@
+declare const _default: Readonly<{
+    /**
+   * The 2D map can be rotated about the z axis.
+   *
+   * @type {number}
+   * @constant
+   */
+    ROTATE: number;
+    /**
+   * The 2D map can be scrolled infinitely in the horizontal direction.
+   *
+   * @type {number}
+   * @constant
+   */
+    INFINITE_SCROLL: number;
+}>;
+export default _default;
+/**
+ * Describes how the map will operate in 2D.
+ */
+export type MapMode2D = number;
+export namespace MapMode2D {
+    let ROTATE: number;
+    let INFINITE_SCROLL: number;
+}