@baidumap/mapv-three 1.0.0

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

@@ -0,0 +1,85 @@
+/**
+ * Create an instance of an OrientedBoundingBox
+ * Creates an instance of an OrientedBoundingBox.
+ * An OrientedBoundingBox of some object is a closed and convex rectangular cuboid.
+ * It can provide a tighter bounding volume than {@link BoundingSphere} or {@link AxisAlignedBoundingBox} in many cases.
+ * @alias OrientedBoundingBox
+ * @constructor
+ *
+ * @param {Cartesian3} [center=Cartesian3.ZERO] The center of the box.
+ * @param {Matrix3} [halfAxes=Matrix3.ZERO] The three orthogonal half-axes of the bounding box.
+ *                                          Equivalently, the transformation matrix, to rotate and scale a 2x2x2
+ *                                          cube centered at the origin.
+ *
+ *
+ */
+export class OrientedBoundingBox {
+    constructor(center: any, halfAxes: any);
+    isOrientedBoundingBox: boolean;
+    /**
+     * The center of the box.
+     */
+    center: any;
+    /**
+     * The three orthogonal half-axes of the bounding box. Equivalently, the
+     * transformation matrix, to rotate and scale a 2x2x2 cube centered at the
+     * origin.
+     */
+    halfAxes: any;
+    intersectPlane(plane: any): number;
+    distanceSquaredTo(cartesian: any): Interval;
+    computeCorners(result: any): Cartesian3[];
+    getCenter(result: any): any;
+    /**
+     * 检测当前OBB是否与另一个OBB相交
+     * @param {OrientedBoundingBox} otherObb 另一个OBB
+     * @returns {boolean} 是否相交
+     */
+    intersectsObb(otherObb: OrientedBoundingBox): boolean;
+}
+export namespace OrientedBoundingBox {
+    /**
+     * Computes an OrientedBoundingBox that bounds a {@link Rectangle} on the surface of an {@link Ellipsoid}.
+     * There are no guarantees about the orientation of the bounding box.
+     *
+     * @param {Rectangle} rectangle The cartographic rectangle on the surface of the ellipsoid.
+     * @param {number} [minimumHeight=0.0] The minimum height (elevation) within the tile.
+     * @param {number} [maximumHeight=0.0] The maximum height (elevation) within the tile.
+     * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the rectangle is defined.
+     * @param {OrientedBoundingBox} [result] The object onto which to store the result.
+     * @returns {OrientedBoundingBox} The modified result parameter
+     * or a new OrientedBoundingBox instance if none was provided.
+     *
+     * @exception {DeveloperError} rectangle.width must be between 0 and 2 * pi.
+     * @exception {DeveloperError} rectangle.height must be between 0 and pi.
+     * @exception {DeveloperError} ellipsoid must be an ellipsoid of revolution (<code>radii.x == radii.y</code>)
+     */
+    function fromRectangle(rectangle: Rectangle, minimumHeight?: number, maximumHeight?: number, ellipsoid?: Ellipsoid, result?: OrientedBoundingBox): OrientedBoundingBox;
+    /**
+     * The distances calculated by the vector from the center of the bounding box to position projected onto direction.
+     * <br>
+     * If you imagine the infinite number of planes with normal direction, this computes the smallest distance to the
+     * closest and farthest planes from position that intersect the bounding box.
+     *
+     * @param {OrientedBoundingBox} box The bounding box to calculate the distance to.
+     * @param {Cartesian3} position The position to calculate the distance from.
+     * @param {Cartesian3} direction The direction from position.
+     * @param {Interval} [result] A Interval to store the nearest and farthest distances.
+     * @returns {Interval} The nearest and farthest distances on the bounding box from position in direction.
+     */
+    function distanceSquaredTo(box: OrientedBoundingBox, cartesian: any): Interval;
+    function intersectPlane(box: any, plane: any): number;
+    /**
+     * Computes the eight corners of an oriented bounding box. The corners are ordered by
+     * (-X, -Y, -Z), (-X, -Y, +Z), (-X, +Y, -Z), (-X, +Y, +Z), (+X, -Y, -Z), (+X, -Y, +Z), (+X, +Y, -Z), (+X, +Y, +Z).
+     *
+     * @param {OrientedBoundingBox} box The oriented bounding box.
+     * @param {Cartesian3[]} [result] An array of eight {@link Cartesian3} instances onto which to store the corners.
+     * @returns {Cartesian3[]} The modified result parameter or a new array if none was provided.
+     */
+    function computeCorners(box: OrientedBoundingBox, result?: Cartesian3[]): Cartesian3[];
+    function fromGeoBoundingBox(geoBoundingBox: any, result: any): OrientedBoundingBox;
+}
+import { Cartesian3 } from './Cartesian3';
+import { Rectangle } from './Rectangle';
+import { Ellipsoid } from './Ellipsoid';

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

@@ -0,0 +1,20 @@
+export namespace QuadraticRealPolynomial {
+    /**
+     * Provides the discriminant of the quadratic equation from the supplied coefficients.
+     *
+     * @param {Number} a The coefficient of the 2nd order monomial.
+     * @param {Number} b The coefficient of the 1st order monomial.
+     * @param {Number} c The coefficient of the 0th order monomial.
+     * @returns {Number} The value of the discriminant.
+     */
+    function computeDiscriminant(a: number, b: number, c: number): number;
+    /**
+     * Provides the real valued roots of the quadratic polynomial with the provided coefficients.
+     *
+     * @param {Number} a The coefficient of the 2nd order monomial.
+     * @param {Number} b The coefficient of the 1st order monomial.
+     * @param {Number} c The coefficient of the 0th order monomial.
+     * @returns {Number[]} The real valued roots.
+     */
+    function computeRealRoots(a: number, b: number, c: number): number[];
+}

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

@@ -0,0 +1,24 @@
+export namespace QuarticRealPolynomial {
+    /**
+     * Provides the discriminant of the quartic equation from the supplied coefficients.
+     *
+     * @param {Number} a The coefficient of the 4th order monomial.
+     * @param {Number} b The coefficient of the 3rd order monomial.
+     * @param {Number} c The coefficient of the 2nd order monomial.
+     * @param {Number} d The coefficient of the 1st order monomial.
+     * @param {Number} e The coefficient of the 0th order monomial.
+     * @returns {Number} The value of the discriminant.
+     */
+    function computeDiscriminant(a: number, b: number, c: number, d: number, e: number): number;
+    /**
+     * Provides the real valued roots of the quartic polynomial with the provided coefficients.
+     *
+     * @param {Number} a The coefficient of the 4th order monomial.
+     * @param {Number} b The coefficient of the 3rd order monomial.
+     * @param {Number} c The coefficient of the 2nd order monomial.
+     * @param {Number} d The coefficient of the 1st order monomial.
+     * @param {Number} e The coefficient of the 0th order monomial.
+     * @returns {Number[]} The real valued roots.
+     */
+    function computeRealRoots(a: number, b: number, c: number, d: number, e: number): number[];
+}

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

@@ -0,0 +1,87 @@
+export class Rectangle {
+    constructor(west: any, south: any, east: any, north: any);
+    west: any;
+    south: any;
+    east: any;
+    north: any;
+    /**
+     * Gets the width of the rectangle in radians.
+     * @memberof Rectangle.prototype
+     * @type {number}
+     * @readonly
+     */
+    readonly get width(): number;
+    /**
+     * Gets the height of the rectangle in radians.
+     * @memberof Rectangle.prototype
+     * @type {number}
+     * @readonly
+     */
+    readonly get height(): number;
+}
+export namespace Rectangle {
+    function fromDegrees(west: any, south: any, east: any, north: any, result: any): any;
+    /**
+     * Computes the width of a rectangle in radians.
+     * @param {Rectangle} rectangle The rectangle to compute the width of.
+     * @returns {number} The width.
+     */
+    function computeWidth(rectangle: Rectangle): number;
+    /**
+       * Computes the height of a rectangle in radians.
+       * @param {Rectangle} rectangle The rectangle to compute the height of.
+       * @returns {number} The height.
+       */
+    function computeHeight(rectangle: Rectangle): number;
+    function clone(rectangle: any, result: any): any;
+    /**
+     * Computes the southwest corner of a rectangle.
+     *
+     * @param {Rectangle} rectangle The rectangle for which to find the corner
+     * @param {Vector3} [result] The object onto which to store the result.
+     * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
+     */
+    function southwest(rectangle: Rectangle, result?: Vector3): Vector3;
+    /**
+     * Computes the northeast corner of a rectangle.
+     *
+     * @param {Rectangle} rectangle The rectangle for which to find the corner
+     * @param {Vector3} [result] The object onto which to store the result.
+     * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
+     */
+    function northeast(rectangle: Rectangle, result?: Vector3): Vector3;
+    /**
+     * Computes the southeast corner of a rectangle.
+     *
+     * @param {Rectangle} rectangle The rectangle for which to find the corner
+     * @param {Vector3} [result] The object onto which to store the result.
+     * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
+     */
+    function southeast(rectangle: Rectangle, result?: Vector3): Vector3;
+    /**
+     * Computes the northwest corner of a rectangle.
+     *
+     * @param {Rectangle} rectangle The rectangle for which to find the corner
+     * @param {Vector3} [result] The object onto which to store the result.
+     * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
+     */
+    function northwest(rectangle: Rectangle, result?: Vector3): Vector3;
+    /**
+     * Computes the center of a rectangle.
+     *
+     * @param {Rectangle} rectangle The rectangle for which to find the center
+     * @param {Vector3} [result] The object onto which to store the result.
+     * @returns {Vector3} The modified result parameter or a new Cartographic instance if none was provided.
+     */
+    function center(rectangle: Rectangle, result?: Vector3): Vector3;
+    /**
+     * Returns true if the cartographic is on or inside the rectangle, false otherwise.
+     *
+     * @param {Rectangle} rectangle The rectangle
+     * @param {Vector3} cartographic The cartographic to test.
+     * @returns {boolean} true if the provided cartographic is inside the rectangle, false otherwise.
+     */
+    function contains(rectangle: Rectangle, cartographic: Vector3): boolean;
+    function fromBox(box: any, result: any, restrict?: boolean): any;
+    let MAX_VALUE: Readonly<Rectangle>;
+}

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

@@ -0,0 +1,45 @@
+declare const _default: Readonly<{
+    /**
+     * Morphing between mode, e.g., 3D to 2D.
+     *
+     * @type {number}
+     * @constant
+     */
+    MORPHING: number;
+    /**
+     * Columbus View mode.  A 2.5D perspective view where the map is laid out
+     * flat and objects with non-zero height are drawn above it.
+     *
+     * @type {number}
+     * @constant
+     */
+    COLUMBUS_VIEW: number;
+    /**
+     * 2D mode.  The map is viewed top-down with an orthographic projection.
+     *
+     * @type {number}
+     * @constant
+     */
+    SCENE2D: number;
+    /**
+     * 3D mode.  A traditional 3D perspective view of the globe.
+     *
+     * @type {number}
+     * @constant
+     */
+    SCENE3D: number;
+}>;
+export default _default;
+/**
+ * *
+ */
+export type SceneMode = number;
+export namespace SceneMode {
+    /**
+       * Returns the morph time for the given scene mode.
+       *
+       * @param {SceneMode} value The scene mode
+       * @returns {number} The morph time
+       */
+    function getMorphTime(value: SceneMode): number;
+}

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

@@ -0,0 +1,6 @@
+export namespace SceneTransforms {
+    function computeActualEllipsoidPosition(scene: any, position: any, result: any): any;
+    function worldToWindowCoordinates(scene: any, position: any, result: any): any;
+    function worldWithEyeOffsetToWindowCoordinates(scene: any, position: any, eyeOffset: any, result: any): any;
+    function clipToGLWindowCoordinates(viewport: any, position: any, result: any): any;
+}

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

@@ -0,0 +1,95 @@
+export default ScreenSpaceCameraController;
+export function ScreenSpaceCameraController(scene: any): void;
+export class ScreenSpaceCameraController {
+    constructor(scene: any);
+    enableInputs: boolean;
+    enableTranslate: boolean;
+    enableZoom: boolean;
+    enableRotate: boolean;
+    enableTilt: boolean;
+    enableLook: boolean;
+    enableFixCenter: boolean;
+    enableTerrainCollision: boolean;
+    /**
+     * 惯性0-1
+     * @type {Number}
+     * @default 0.9
+     */
+    inertiaSpin: number;
+    inertiaTranslate: number;
+    inertiaZoom: number;
+    maximumMovementRatio: number;
+    bounceAnimationTime: number;
+    minimumZoomDistance: number;
+    maximumZoomDistance: number;
+    translateEventTypes: number;
+    zoomEventTypes: number[];
+    rotateEventTypes: number;
+    tiltEventTypes: (number | {
+        eventType: number;
+        modifier: number;
+    })[];
+    lookEventTypes: {
+        eventType: number;
+        modifier: number;
+    };
+    minimumPickingTerrainHeight: number;
+    _minimumPickingTerrainHeight: number;
+    minimumPickingTerrainDistanceWithInertia: number;
+    minimumCollisionTerrainHeight: number;
+    _minimumCollisionTerrainHeight: number;
+    minimumTrackBallHeight: number;
+    _minimumTrackBallHeight: number;
+    enableCollisionDetection: boolean;
+    _scene: any;
+    _globe: any;
+    _ellipsoid: any;
+    _lastGlobeHeight: number;
+    _aggregator: CameraEventAggregator;
+    _lastInertiaSpinMovement: any;
+    _lastInertiaZoomMovement: any;
+    _lastInertiaTranslateMovement: any;
+    _lastInertiaTiltMovement: any;
+    _inertiaDisablers: {
+        _lastInertiaZoomMovement: string[];
+        _lastInertiaTiltMovement: string[];
+    };
+    _horizontalRotationAxis: any;
+    _tiltCenterMousePosition: any;
+    _tiltCenter: any;
+    _translateMousePosition: any;
+    _rotateMousePosition: any;
+    _rotateStartPosition: any;
+    _strafeStartPosition: any;
+    _strafeMousePosition: any;
+    _strafeEndMousePosition: any;
+    _zoomMouseStart: any;
+    _zoomWorldPosition: any;
+    _useZoomWorldPosition: boolean;
+    _panLastMousePosition: any;
+    _panLastWorldPosition: any;
+    _tiltCVOffMap: boolean;
+    _looking: boolean;
+    _rotating: boolean;
+    _strafing: boolean;
+    _zoomingOnVector: boolean;
+    _zoomingUnderground: boolean;
+    _rotatingZoom: boolean;
+    _adjustedHeightForTerrain: boolean;
+    _cameraUnderground: boolean;
+    _maxCoord: any;
+    _zoomFactor: number;
+    _rotateFactor: number | undefined;
+    _rotateRateRangeAdjustment: any;
+    _maximumRotateRate: number;
+    _minimumRotateRate: number;
+    _minimumZoomRate: number;
+    _maximumZoomRate: number;
+    _minimumUndergroundPickDistance: number;
+    _maximumUndergroundPickDistance: number;
+    private onMap;
+    private update;
+    isDestroyed(): boolean;
+    destroy(): undefined;
+}
+import { CameraEventAggregator } from './CameraEventAggregator';

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

@@ -0,0 +1,111 @@
+/**
+ * Handles user input events. Custom functions can be added to be executed on
+ * when the user enters input.
+ *
+ * @alias ScreenSpaceEventHandler
+ *
+ * @param {HTMLCanvasElement} [element=document] The element to add events to.
+ *
+ * @constructor
+ */
+export function ScreenSpaceEventHandler(element?: HTMLCanvasElement): void;
+export class ScreenSpaceEventHandler {
+    /**
+     * Handles user input events. Custom functions can be added to be executed on
+     * when the user enters input.
+     *
+     * @alias ScreenSpaceEventHandler
+     *
+     * @param {HTMLCanvasElement} [element=document] The element to add events to.
+     *
+     * @constructor
+     */
+    constructor(element?: HTMLCanvasElement);
+    _inputEvents: {};
+    _buttonDown: {
+        LEFT: boolean;
+        MIDDLE: boolean;
+        RIGHT: boolean;
+    };
+    _isPinching: boolean;
+    _isTouchHolding: boolean;
+    _lastSeenTouchEvent: number;
+    _primaryStartPosition: any;
+    _primaryPosition: any;
+    _primaryPreviousPosition: any;
+    _positions: AssociativeArray;
+    _previousPositions: AssociativeArray;
+    _removalFunctions: any[];
+    _touchHoldTimer: any;
+    _clickPixelTolerance: number;
+    _holdPixelTolerance: number;
+    _element: any;
+    /**
+     * Set a function to be executed on an input event.
+     *
+     * @param {Function} action Function to be executed when the input event occurs.
+     * @param {Number} type The ScreenSpaceEventType of input event.
+     * @param {Number} [modifier] A KeyboardEventModifier key that is held when a <code>type</code>
+     * event occurs.
+     *
+     * @see ScreenSpaceEventHandler#getInputAction
+     * @see ScreenSpaceEventHandler#removeInputAction
+     */
+    setInputAction(action: Function, type: number, modifier?: number): void;
+    /**
+     * Returns the function to be executed on an input event.
+     *
+     * @param {Number} type The ScreenSpaceEventType of input event.
+     * @param {Number} [modifier] A KeyboardEventModifier key that is held when a <code>type</code>
+     * event occurs.
+     *
+     * @returns {Function} The function to be executed on an input event.
+     *
+     * @see ScreenSpaceEventHandler#setInputAction
+     * @see ScreenSpaceEventHandler#removeInputAction
+     */
+    getInputAction(type: number, modifier?: number): Function;
+    /**
+     * Removes the function to be executed on an input event.
+     *
+     * @param {Number} type The ScreenSpaceEventType of input event.
+     * @param {Number} [modifier] A KeyboardEventModifier key that is held when a <code>type</code>
+     * event occurs.
+     *
+     * @see ScreenSpaceEventHandler#getInputAction
+     * @see ScreenSpaceEventHandler#setInputAction
+     */
+    removeInputAction(type: number, modifier?: number): void;
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     *
+     * @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     *
+     * @see ScreenSpaceEventHandler#destroy
+     */
+    isDestroyed(): boolean;
+    /**
+     * Removes listeners held by this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     *
+     * @example
+     * handler = handler && handler.destroy();
+     *
+     * @see ScreenSpaceEventHandler#isDestroyed
+     */
+    destroy(): undefined;
+}
+export namespace ScreenSpaceEventHandler {
+    let mouseEmulationIgnoreMilliseconds: number;
+    let touchHoldDelayMilliseconds: number;
+}
+import { AssociativeArray } from './AssociativeArray';

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

@@ -0,0 +1,130 @@
+declare const _default: Readonly<{
+    /**
+     * Represents a mouse left button down event.
+     *
+     * @type {number}
+     * @constant
+     */
+    LEFT_DOWN: number;
+    /**
+     * Represents a mouse left button up event.
+     *
+     * @type {number}
+     * @constant
+     */
+    LEFT_UP: number;
+    /**
+     * Represents a mouse left click event.
+     *
+     * @type {number}
+     * @constant
+     */
+    LEFT_CLICK: number;
+    /**
+     * Represents a mouse left double click event.
+     *
+     * @type {number}
+     * @constant
+     */
+    LEFT_DOUBLE_CLICK: number;
+    /**
+     * Represents a mouse left button down event.
+     *
+     * @type {number}
+     * @constant
+     */
+    RIGHT_DOWN: number;
+    /**
+     * Represents a mouse right button up event.
+     *
+     * @type {number}
+     * @constant
+     */
+    RIGHT_UP: number;
+    /**
+     * Represents a mouse right click event.
+     *
+     * @type {number}
+     * @constant
+     */
+    RIGHT_CLICK: number;
+    /**
+     * Represents a mouse middle button down event.
+     *
+     * @type {number}
+     * @constant
+     */
+    MIDDLE_DOWN: number;
+    /**
+     * Represents a mouse middle button up event.
+     *
+     * @type {number}
+     * @constant
+     */
+    MIDDLE_UP: number;
+    /**
+     * Represents a mouse middle click event.
+     *
+     * @type {number}
+     * @constant
+     */
+    MIDDLE_CLICK: number;
+    /**
+     * Represents a mouse move event.
+     *
+     * @type {number}
+     * @constant
+     */
+    MOUSE_MOVE: number;
+    /**
+     * Represents a mouse wheel event.
+     *
+     * @type {number}
+     * @constant
+     */
+    WHEEL: number;
+    /**
+     * Represents the start of a two-finger event on a touch surface.
+     *
+     * @type {number}
+     * @constant
+     */
+    PINCH_START: number;
+    /**
+     * Represents the end of a two-finger event on a touch surface.
+     *
+     * @type {number}
+     * @constant
+     */
+    PINCH_END: number;
+    /**
+     * Represents a change of a two-finger event on a touch surface.
+     *
+     * @type {number}
+     * @constant
+     */
+    PINCH_MOVE: number;
+}>;
+export default _default;
+/**
+ * This enumerated type is for classifying mouse events:
+ * down, up, click, double click, move and move while a button is held down.
+ */
+export type ScreenSpaceEventType = number;
+export namespace ScreenSpaceEventType {
+    let LEFT_DOWN: number;
+    let LEFT_UP: number;
+    let LEFT_CLICK: number;
+    let LEFT_DOUBLE_CLICK: number;
+    let RIGHT_DOWN: number;
+    let RIGHT_UP: number;
+    let RIGHT_CLICK: number;
+    let MIDDLE_DOWN: number;
+    let MIDDLE_UP: number;
+    let MIDDLE_CLICK: number;
+    let MOUSE_MOVE: number;
+    let WHEEL: number;
+    let PINCH_START: number;
+    let PINCH_END: number;
+    let PINCH_MOVE: number;
+}

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

@@ -0,0 +1,35 @@
+export class StaticMatrix3 {
+    static fromQuaternion(quaternion: any, result: any): any;
+    static getColumn(matrix: any, index: any, result: any): any;
+    static multiplyByVector(matrix: any, v: any, result: any): any;
+    static multiplyByScale(matrix: any, scale: any, result: any): any;
+    static transpose(m: any, result: any): any;
+    static fromScale(scale: any, result: any): any;
+    static multiply(a: any, b: any, result: any): any;
+    static clone(matrix: any, result: any): any;
+    /**
+     * Computes a new matrix that replaces the specified column in the provided matrix
+     * with the provided Cartesian3 instance.
+     *
+     * @param {Matrix3} matrix The matrix to use.
+     * @param {number} index The zero-based index of the column to set.
+     * @param {Cartesian3} cartesian The Cartesian whose values will be assigned to the specified column.
+     * @param {Matrix3} result The object onto which to store the result.
+     * @returns {Matrix3} The modified result parameter.
+     *
+     * @exception {DeveloperError} index must be 0, 1, or 2.
+     */
+    static setColumn(matrix: Matrix3, index: number, cartesian: Cartesian3, result: Matrix3): Matrix3;
+}
+export namespace StaticMatrix3 {
+    let ZERO: any;
+    let COLUMN0ROW0: number;
+    let COLUMN0ROW1: number;
+    let COLUMN0ROW2: number;
+    let COLUMN1ROW0: number;
+    let COLUMN1ROW1: number;
+    let COLUMN1ROW2: number;
+    let COLUMN2ROW0: number;
+    let COLUMN2ROW1: number;
+    let COLUMN2ROW2: number;
+}

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

@@ -0,0 +1,37 @@
+export class StaticMatrix4 {
+    static IDENTITY: any;
+    static clone(m1: any, m2: any): any;
+    static inverseTransformation(m1: any, m2: any): any;
+    static multiplyByPoint(m: any, v: any, result: any): any;
+    static multiplyByPointAsVector(m: any, v: any, result: any): any;
+    static computeViewportTransformation(viewport: any, nearDepthRange: any, farDepthRange: any, result: any): any;
+    static equals(a: any, b: any): any;
+    static multiplyByVector(matrix: any, v: any, result: any): any;
+    /**
+     * Retrieves a copy of the matrix column at the provided index as a Cartesian4 instance.
+     *
+     * @param {Matrix4} matrix The matrix to use.
+     * @param {number} index The zero-based index of the column to retrieve.
+     * @param {Cartesian4} result The object onto which to store the result.
+     * @returns {Cartesian4} The modified result parameter.
+     *
+     * @exception {DeveloperError} index must be 0, 1, 2, or 3.
+     *
+     * @example
+     * // m = [10.0, 11.0, 12.0, 13.0]
+     * //     [14.0, 15.0, 16.0, 17.0]
+     * //     [18.0, 19.0, 20.0, 21.0]
+     * //     [22.0, 23.0, 24.0, 25.0]
+     *
+     * // Sets values for Cartesian instance
+     * const a = new Cesium.Cartesian4();
+     * Cesium.Matrix4.getColumn(m, 2, a);
+     *
+     * // a.x = 12.0; a.y = 16.0; a.z = 20.0; a.w = 24.0;
+     */
+    static getColumn(matrix: Matrix4, index: number, result: Cartesian4): Cartesian4;
+    static fromTranslationQuaternionRotationScale(translation: any, rotation: any, scale: any, result: any): any;
+}
+export namespace StaticMatrix4 {
+    let ZERO: any;
+}