Skip to content

Instantly share code, notes, and snippets.

@thw0rted

thw0rted/cesium.d.ts

Last active May 27, 2020 08:10
Show Gist options
  • Save thw0rted/c0c73335c9968d5e7b6dd18a43ef6c42 to your computer and use it in GitHub Desktop.
Save thw0rted/c0c73335c9968d5e7b6dd18a43ef6c42 to your computer and use it in GitHub Desktop.
Download ZIP
Updated typings file for Cesium v1.69 (I think?)
Raw
cesium.d.ts
/**
* Cesium type definitions
* For use with Cesium v1.66
* Created by Aigars Zeiza <https://github.com/Zuzon>
* Modified by Harry Nicholls <harry@northstar-robotics.com>
* Updated for v1.66.0 by James Bromwell <https://github.com/Thw0rted>
*/
declare module "cesium"{
type RenderState = any;
interface Type<T> extends Function { new (...args: any[]): T; }
interface Proxy {
getURL(resource: string): string;
}
enum ArcType {
GEODESIC, NONE, RHUMB
}
class AssociativeArray {
length: number;
values: any[];
contains(key: string | number): boolean;
set(key: string | number, value: any): void;
get(key: string | number): any;
remove(key: string | number): boolean;
removeAll(): void;
}
class AxisAlignedBoundingBox {
minimum: Cartesian3;
maximum: Cartesian3;
center: Cartesian3;
constructor(minimum?: Cartesian3, maximum?: Cartesian3, center?: Cartesian3);
clone(result?: AxisAlignedBoundingBox): AxisAlignedBoundingBox;
intersect(plane: Cartesian4): Intersect;
equals(right?: AxisAlignedBoundingBox): boolean;
static fromPoints(positions: Cartesian3[], result?: AxisAlignedBoundingBox): AxisAlignedBoundingBox;
static clone(box: AxisAlignedBoundingBox, result?: AxisAlignedBoundingBox): AxisAlignedBoundingBox;
static equals(left?: AxisAlignedBoundingBox, right?: AxisAlignedBoundingBox): boolean;
static intersect(box: AxisAlignedBoundingBox, plane: Cartesian4): Intersect;
}
class BoundingRectangle {
x: number;
y: number;
width: number;
height: number;
constructor(x?: number, y?: number, width?: number, height?: number);
clone(result?: BoundingRectangle): BoundingRectangle;
intersect(right: BoundingRectangle): Intersect;
equals(right?: BoundingRectangle): boolean;
static fromPoints(positions: Cartesian2[], result?: BoundingRectangle): BoundingRectangle;
static fromRectangle(rectangle: Rectangle, projection?: any, result?: BoundingRectangle): BoundingRectangle;
static clone(rectangle: BoundingRectangle, result?: BoundingRectangle): BoundingRectangle;
static union(left: BoundingRectangle, right: BoundingRectangle, result?: BoundingRectangle): BoundingRectangle;
static expand(rectangle: BoundingRectangle, point: Cartesian2, result?: BoundingRectangle): BoundingRectangle;
static intersect(left: BoundingRectangle, right: BoundingRectangle): Intersect;
static equals(left?: BoundingRectangle, right?: BoundingRectangle): boolean;
}
class BoundingSphere implements BoundingVolume {
center: Cartesian3;
radius: number;
static packedLength: number;
constructor(center?: Cartesian3, radius?: number);
clone(result?: BoundingSphere): BoundingSphere;
computePlaneDistances(position: Cartesian3, direction: Cartesian3, result?: Interval): Interval;
distanceSquaredTo(cartesian: Cartesian3): number;
equals(right?: BoundingSphere): boolean;
intersectPlane(plane: Plane): Intersect;
isOccluded(occluder: Occluder): boolean;
volume(): number;
static clone(sphere: BoundingSphere, result?: BoundingSphere): BoundingSphere;
static computePlaneDistances(sphere: BoundingSphere, position: Cartesian3, direction: Cartesian3, result?: Interval): Interval;
static distanceSquaredTo(sphere: BoundingSphere, cartesian: Cartesian3): number;
static equals(left?: BoundingSphere, right?: BoundingSphere): boolean;
static expand(sphere: BoundingSphere, point: Cartesian3, result?: BoundingSphere): BoundingSphere;
static fromBoundingSpheres(boundingSpheres: BoundingSphere[], result?: BoundingSphere): BoundingSphere;
static fromCornerPoints(corner?: Cartesian3, oppositeCorner?: Cartesian3, result?: BoundingSphere): BoundingSphere;
static fromEllipsoid(ellipsoid: Ellipsoid, result?: BoundingSphere): BoundingSphere;
static fromEncodedCartesianVertices(positionsHigh?: number[], positionsLow?: number[], result?: BoundingSphere): BoundingSphere;
static fromPoints(positions: Cartesian3[], result?: BoundingSphere): BoundingSphere;
static fromRectangle2D(rectangle?: Rectangle, projection?: any, result?: BoundingSphere): BoundingSphere;
static fromRectangle3D(rectangle?: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: BoundingSphere): BoundingSphere;
static fromRectangleWithHeights2D(rectangle: Rectangle, projection?: any, minimumHeight?: number, maximumHeight?: number, result?: BoundingSphere): BoundingSphere;
static fromVertices(positions: Cartesian3[], center?: Cartesian3, stride?: number, result?: BoundingSphere): BoundingSphere;
static intersectPlane(sphere: BoundingSphere, plane: Plane): Intersect;
static isOccluded(sphere: BoundingSphere, occluder: Occluder): boolean;
static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
static projectTo2D(sphere: BoundingSphere, projection?: any, result?: BoundingSphere): BoundingSphere;
static transform(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
static transformWithoutScale(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
static union(left: BoundingSphere, right: BoundingSphere, result?: BoundingSphere): BoundingSphere;
static unpack(array: number[], startingIndex?: number, result?: BoundingSphere): BoundingSphere;
}
class BoxGeometry {
static packedLength: number;
constructor(options: { minimumCorner: Cartesian3; maximumCorner: Cartesian3; vertexFormat?: VertexFormat });
static fromDimensions(): BoxGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: BoxGeometry): BoxGeometry;
static createGeometry(boxGeometry: BoxGeometry): Geometry;
}
class BoxOutlineGeometry {
static packedLength: number;
constructor();
static fromDimensions(): BoxOutlineGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: BoxOutlineGeometry): BoxOutlineGeometry;
static createGeometry(boxGeometry: BoxOutlineGeometry): Geometry;
}
class Cartesian2 {
x: number;
y: number;
static packedLength: number;
static ZERO: Cartesian2;
static UNIT_X: Cartesian2;
static UNIT_Y: Cartesian2;
constructor(x?: number, y?: number);
clone(result?: Cartesian2): Cartesian2;
equals(right?: Cartesian2): boolean;
equalsEpsilon(right: Cartesian2, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
toString(): string;
static abs(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static add(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static angleBetween(left: Cartesian2, right: Cartesian2): number;
static clone(cartesian: Cartesian2, result?: Cartesian2): Cartesian2;
static distance(left: Cartesian2, right: Cartesian2): number;
static distanceSquared(left: Cartesian2, right: Cartesian2): number;
static divideByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
static divideComponents(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static dot(left: Cartesian2, right: Cartesian2): number;
static equals(left?: Cartesian2, right?: Cartesian2): boolean;
static equalsEpsilon(left: Cartesian2, right: Cartesian2, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
static fromArray(array: number[], startingIndex?: number, result?: Cartesian2): Cartesian2;
static fromCartesian3(cartesian: Cartesian3, result?: Cartesian2): Cartesian2;
static fromCartesian4(cartesian: Cartesian4, result?: Cartesian2): Cartesian2;
static fromElements(x: number, y: number, result?: Cartesian2): Cartesian2;
static lerp(start: Cartesian2, end: Cartesian2, t: number, result: Cartesian2): Cartesian2;
static magnitude(cartesian: Cartesian2): number;
static magnitudeSquared(cartesian: Cartesian2): number;
static maximumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
static maximumComponent(cartesian: Cartesian2): number;
static minimumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
static minimumComponent(cartesian: Cartesian2): number;
static mostOrthogonalAxis(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static multiplyByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
static multiplyComponents(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static negate(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static normalize(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static pack(value: Cartesian2, array: number[], startingIndex?: number): number[];
static packArray(values: Cartesian2[], array: number[]): number[];
static subtract(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static unpack(array: number[], startingIndex?: number, result?: Cartesian2): Cartesian2;
static unpackArray(array: number[], result: Cartesian2): Cartesian2;
}
class Cartesian3 {
x: number;
y: number;
z: number;
static UNIT_X: Cartesian3;
static UNIT_Y: Cartesian3;
static UNIT_Z: Cartesian3;
static ZERO: Cartesian3;
static packedLength: number;
constructor(x?: number, y?: number, z?: number);
clone(result?: Cartesian3): Cartesian3;
equals(right?: Cartesian3): boolean;
equalsEpsilon(right: Cartesian3, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
toString(): string;
static abs(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static add(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static angleBetween(left: Cartesian3, right: Cartesian3): number;
static clone(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
static cross(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static distance(left: Cartesian3, right: Cartesian3): number;
static distanceSquared(left: Cartesian3, right: Cartesian3): number;
static divideByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
static dot(left: Cartesian3, right: Cartesian3): number;
static equals(left?: Cartesian3, right?: Cartesian3): boolean;
static equalsEpsilon(left: Cartesian3, right: Cartesian3, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
static fromArray(array: number[], startingIndex?: number, result?: Cartesian3): Cartesian3;
static fromCartesian4(cartesian: Cartesian4, result?: Cartesian3): Cartesian3;
static fromDegrees(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
static fromDegreesArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromDegreesArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromElements(x: number, y: number, z: number, result?: Cartesian3): Cartesian3;
static fromRadians(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
static fromRadiansArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromRadiansArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromSpherical(spherical: Spherical, result?: Cartesian3): Cartesian3;
static lerp(start: Cartesian3, end: Cartesian3, t: number, result: Cartesian3): Cartesian3;
static magnitude(cartesian: Cartesian3): number;
static magnitudeSquared(cartesian: Cartesian3): number;
static maximumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
static maximumComponent(cartesian: Cartesian3): number;
static midpoint(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static minimumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
static minimumComponent(cartesian: Cartesian3): number;
static mostOrthogonalAxis(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
static multiplyComponents(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static negate(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static normalize(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static pack(value: Cartesian3, array: number[], startingIndex?: number): number[];
static packArray(array: Cartesian3[], result: number[]): number[];
static subtract(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static unpack(array: number[], startingIndex?: number, result?: Cartesian3): Cartesian3;
static unpackArray(array: number[], result?: Cartesian3[]): Cartesian3[];
}
class Cartesian4 {
x: number;
y: number;
z: number;
w: number;
static packedLength: number;
static ZERO: Cartesian4;
static UNIT_X: Cartesian4;
static UNIT_Y: Cartesian4;
static UNIT_Z: Cartesian4;
static UNIT_W: Cartesian4;
constructor(x?: number, y?: number, z?: number, w?: number);
clone(result?: Cartesian4): Cartesian4;
equals(right?: Cartesian4): boolean;
equalsEpsilon(right: Cartesian4, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
toString(): string;
static fromElements(x: number, y: number, z: number, w: number, result?: Cartesian4): Cartesian4;
static fromColor(color: Color, result?: Cartesian4): Cartesian4;
static clone(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
static pack(value: Cartesian4, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Cartesian4): Cartesian4;
static fromArray(array: number[], startingIndex?: number, result?: Cartesian4): Cartesian4;
static maximumComponent(cartesian: Cartesian4): number;
static minimumComponent(cartesian: Cartesian4): number;
static minimumByComponent(first: Cartesian4, second: Cartesian4, result: Cartesian4): Cartesian4;
static maximumByComponent(first: Cartesian4, second: Cartesian4, result: Cartesian4): Cartesian4;
static magnitudeSquared(cartesian: Cartesian4): number;
static magnitude(cartesian: Cartesian4): number;
static distance(left: Cartesian4, right: Cartesian4): number;
static distanceSquared(left: Cartesian4, right: Cartesian4): number;
static normalize(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static dot(left: Cartesian4, right: Cartesian4): number;
static multiplyComponents(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
static add(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
static subtract(left: Cartesian4, right: Cartesian4, result: Cartesian4): Cartesian4;
static multiplyByScalar(cartesian: Cartesian4, scalar: number, result: Cartesian4): Cartesian4;
static divideByScalar(cartesian: Cartesian4, scalar: number, result: Cartesian4): Cartesian4;
static negate(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static abs(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static lerp(start: Cartesian4, end: Cartesian4, t: number, result: Cartesian4): Cartesian4;
static mostOrthogonalAxis(cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static equals(left?: Cartesian4, right?: Cartesian4): boolean;
static equalsEpsilon(left: Cartesian4, right: Cartesian4, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
}
class Cartographic {
longitude: number;
latitude: number;
height: number;
static ZERO: Cartographic;
constructor(longitude?: number, latitude?: number, height?: number);
static clone(cartographic: Cartographic, result?: Cartographic): Cartographic;
static equals(left?: Cartographic, right?: Cartographic): boolean;
static equalsEpsilon(left: Cartographic, right: Cartographic, epsilon: number): boolean;
static fromCartesian(cartesian: Cartesian3, ellipsoid?: Ellipsoid, result?: Cartographic): Cartographic;
static fromDegrees(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
static fromRadians(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
static toCartesian(cartographic: Cartographic, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
clone(result?: Cartographic): Cartographic;
equals(right?: Cartographic): boolean;
equalsEpsilon(right: Cartographic, epsilon: number): boolean;
toString(): string;
}
class CartographicGeocoderService implements GeocoderService {
geocode(query: string): Promise<Array<GeocoderResult>>
}
class CatmullRomSpline {
times: number[];
points: Cartesian3[];
firstTangent: Cartesian3;
lastTangent: Cartesian3;
constructor(options: { times: number[]; points: Cartesian3[]; firstTangent?: Cartesian3; lastTangent?: Cartesian3 });
findTimeInterval(time: number): number;
evaluate(time: number, result?: Cartesian3): Cartesian3;
}
class Cesium3DTileset {
// TODO
}
class CesiumTerrainProvider extends TerrainProvider {
requestVertexNormals: boolean;
requestWaterMask: boolean;
constructor(options: {
url: Resource | string;
requestVertexNormals?: boolean;
requestWaterMask?: boolean;
ellipsoid?: Ellipsoid;
credit?: Credit | string;
});
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
}
class CircleGeometry {
static packedLength: number;
constructor(options: CircleGeometry.ConstructorOptions);
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CircleGeometry): CircleGeometry;
static createGeometry(circleGeometry: CircleGeometry): Geometry;
}
namespace CircleGeometry {
interface ConstructorOptions {
center: Cartesian3;
radius: number;
ellipsoid?: Ellipsoid;
height?: number;
granularity?: number;
vertexFormat?: VertexFormat;
extrudedHeight?: number;
stRotation?: number;
}
}
class CircleOutlineGeometry {
static packedLength: number;
constructor(options: { center: Cartesian3; radius: number; ellipsoid?: Ellipsoid; height?: number; granularity?: number; extrudedHeight?: number; numberOfVerticalLines?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CircleOutlineGeometry): CircleOutlineGeometry;
static createGeometry(circleGeometry: CircleOutlineGeometry): Geometry;
}
enum ClassificationType { CESIUM_3D_TILE, TERRAIN, BOTH }
class ClippingPlaneCollection {
// TODO
}
class Clock {
canAnimate: boolean;
clockRange: ClockRange;
clockStep: ClockStep;
currentTime: JulianDate;
multiplier: number;
onStop: Event<(c: this) => void>;
onTick: Event<(c: this) => void>;
shouldAnimate: boolean;
startTime: JulianDate;
stopTime: JulianDate;
constructor(options: {
startTime?: JulianDate;
stopTime?: JulianDate;
currentTime?: JulianDate;
multiplier?: number;
clockStep?: ClockStep;
clockRange?: ClockRange;
canAnimate?: boolean;
shouldAnimate?: boolean;
});
tick(): JulianDate;
}
class Color {
red: number;
green: number;
blue: number;
alpha: number;
static packedLength: number;
static ALICEBLUE: Color;
static ANTIQUEWHITE: Color;
static AQUA: Color;
static AQUAMARINE: Color;
static AZURE: Color;
static BEIGE: Color;
static BISQUE: Color;
static BLACK: Color;
static BLANCHEDALMOND: Color;
static BLUE: Color;
static BLUEVIOLET: Color;
static BROWN: Color;
static BURLYWOOD: Color;
static CADETBLUE: Color;
static CHARTREUSE: Color;
static CHOCOLATE: Color;
static CORAL: Color;
static CORNFLOWERBLUE: Color;
static CORNSILK: Color;
static CRIMSON: Color;
static CYAN: Color;
static DARKBLUE: Color;
static DARKCYAN: Color;
static DARKGOLDENROD: Color;
static DARKGRAY: Color;
static DARKGREEN: Color;
static DARKGREY: Color;
static DARKKHAKI: Color;
static DARKMAGENTA: Color;
static DARKOLIVEGREEN: Color;
static DARKORANGE: Color;
static DARKORCHID: Color;
static DARKRED: Color;
static DARKSALMON: Color;
static DARKSEAGREEN: Color;
static DARKSLATEBLUE: Color;
static DARKSLATEGRAY: Color;
static DARKSLATEGREY: Color;
static DARKTURQUOISE: Color;
static DARKVIOLET: Color;
static DEEPPINK: Color;
static DEEPSKYBLUE: Color;
static DIMGRAY: Color;
static DIMGREY: Color;
static DODGERBLUE: Color;
static FIREBRICK: Color;
static FLORALWHITE: Color;
static FORESTGREEN: Color;
static FUSCHIA: Color;
static GAINSBORO: Color;
static GHOSTWHITE: Color;
static GOLD: Color;
static GOLDENROD: Color;
static GRAY: Color;
static GREEN: Color;
static GREENYELLOW: Color;
static GREY: Color;
static HONEYDEW: Color;
static HOTPINK: Color;
static INDIANRED: Color;
static INDIGO: Color;
static IVORY: Color;
static KHAKI: Color;
static LAVENDER: Color;
static LAVENDAR_BLUSH: Color;
static LAWNGREEN: Color;
static LEMONCHIFFON: Color;
static LIGHTBLUE: Color;
static LIGHTCORAL: Color;
static LIGHTCYAN: Color;
static LIGHTGOLDENRODYELLOW: Color;
static LIGHTGRAY: Color;
static LIGHTGREEN: Color;
static LIGHTGREY: Color;
static LIGHTPINK: Color;
static LIGHTSEAGREEN: Color;
static LIGHTSKYBLUE: Color;
static LIGHTSLATEGRAY: Color;
static LIGHTSLATEGREY: Color;
static LIGHTSTEELBLUE: Color;
static LIGHTYELLOW: Color;
static LIME: Color;
static LIMEGREEN: Color;
static LINEN: Color;
static MAGENTA: Color;
static MAROON: Color;
static MEDIUMAQUAMARINE: Color;
static MEDIUMBLUE: Color;
static MEDIUMORCHID: Color;
static MEDIUMPURPLE: Color;
static MEDIUMSEAGREEN: Color;
static MEDIUMSLATEBLUE: Color;
static MEDIUMSPRINGGREEN: Color;
static MEDIUMTURQUOISE: Color;
static MEDIUMVIOLETRED: Color;
static MIDNIGHTBLUE: Color;
static MINTCREAM: Color;
static MISTYROSE: Color;
static MOCCASIN: Color;
static NAVAJOWHITE: Color;
static NAVY: Color;
static OLDLACE: Color;
static OLIVE: Color;
static OLIVEDRAB: Color;
static ORANGE: Color;
static ORANGERED: Color;
static ORCHID: Color;
static PALEGOLDENROD: Color;
static PALEGREEN: Color;
static PALETURQUOISE: Color;
static PALEVIOLETRED: Color;
static PAPAYAWHIP: Color;
static PEACHPUFF: Color;
static PERU: Color;
static PINK: Color;
static PLUM: Color;
static POWDERBLUE: Color;
static PURPLE: Color;
static RED: Color;
static ROSYBROWN: Color;
static ROYALBLUE: Color;
static SADDLEBROWN: Color;
static SALMON: Color;
static SANDYBROWN: Color;
static SEAGREEN: Color;
static SEASHELL: Color;
static SIENNA: Color;
static SILVER: Color;
static SKYBLUE: Color;
static SLATEBLUE: Color;
static SLATEGRAY: Color;
static SLATEGREY: Color;
static SNOW: Color;
static SPRINGGREEN: Color;
static STEELBLUE: Color;
static TAN: Color;
static TEAL: Color;
static THISTLE: Color;
static TOMATO: Color;
static TURQUOISE: Color;
static VIOLET: Color;
static WHEAT: Color;
static WHITE: Color;
static WHITESMOKE: Color;
static YELLOW: Color;
static YELLOWGREEN: Color;
static TRANSPARENT: Color;
constructor(red?: number, green?: number, blue?: number, alpha?: number);
clone(result?: Color): Color;
equals(other: Color): boolean;
equalsEpsilon(other: Color, epsilon?: number): boolean;
toString(): string;
toCssColorString(): string;
toBytes(result?: number[]): number[];
toRgba(): number;
brighten(magnitude: number, result: Color): Color;
darken(magnitude: number, result: Color): Color;
withAlpha(alpha: number, result?: Color): Color;
static fromCartesian4(cartesian: Cartesian4, result?: Color): Color;
static fromBytes(red?: number, green?: number, blue?: number, alpha?: number, result?: Color): Color;
static fromAlpha(color: Color, alpha: number, result?: Color): Color;
static fromRgba(rgba: number): Color;
static fromHsl(hue?: number, saturation?: number, lightness?: number, alpha?: number): Color;
static fromRandom(options?: { red?: number; minimumRed?: number; maximumRed?: number; green?: number; minimumGreen?: number; maximumGreen?: number; blue?: number; minimumBlue?: number; maximumBlue?: number; alpha?: number; minimumAlpha?: number; maximumAlpha?: number }, result?: Color): Color;
static fromCssColorString(color: string): Color;
static pack(value: Color, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Color): Color;
static byteToFloat(number: number): number;
static floatToByte(number: number): number;
static clone(color: Color, result?: Color): Color;
static equals(left: Color, right: Color): boolean;
}
class ColorGeometryInstanceAttribute {
value: Uint8Array;
componentDatatype: ComponentDatatype;
componentsPerAttribute: number;
normalize: boolean;
constructor(red?: number, green?: number, blue?: number, alpha?: number);
static fromColor(color: Color): ColorGeometryInstanceAttribute;
static toValue(color: Color, result?: Uint8Array): Uint8Array;
}
class CoplanarPolygonGeometry {
packedLength: number;
constructor(options: {polygonHierarchy: PolygonHierarchy, stRotation?: number, vertexFormat?: VertexFormat});
static createGeometry(polygonGeometry: CoplanarPolygonGeometry): Geometry;
static fromPositions(options: {positions: Cartesian3[], vertexFormat?: VertexFormat, stRotation?: number}): CoplanarPolygonGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CoplanarPolygonGeometry): CoplanarPolygonGeometry;
}
class CoplanarPolygonOutlineGeometry {
packedLength: number;
constructor(options: {polygonHierarchy: PolygonHierarchy});
static createGeometry(polygonGeometry: CoplanarPolygonOutlineGeometry): Geometry;
static fromPositions(options: {positions: Cartesian3[]}): CoplanarPolygonOutlineGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CoplanarPolygonOutlineGeometry): CoplanarPolygonOutlineGeometry;
}
class CorridorGeometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; width: number; ellipsoid?: Ellipsoid; granularity?: number; height?: number; extrudedHeight?: number; vertexFormat?: VertexFormat; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CorridorGeometry): CorridorGeometry;
static createGeometry(corridorGeometry: CorridorGeometry): Geometry;
}
class CorridorOutlineGeometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; width: number; ellipsoid?: Ellipsoid; granularity?: number; height?: number; extrudedHeight?: number; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CorridorOutlineGeometry): CorridorOutlineGeometry;
static createGeometry(corridorOutlineGeometry: CorridorOutlineGeometry): Geometry;
}
class Credit {
readonly element: HTMLElement;
readonly html: string;
readonly showOnScreen: boolean;
constructor(html: string, showOnScreen?: boolean);
static equals(left: Credit, right: Credit): boolean;
equals(credits: Credit): boolean;
}
class CylinderGeometry {
static packedLength: number;
constructor(options: { length: number; topRadius: number; bottomRadius: number; slices?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CylinderGeometry): CylinderGeometry;
static createGeometry(cylinderGeometry: CylinderGeometry): Geometry;
}
class CylinderOutlineGeometry {
static packedLength: number;
constructor(options: { length: number; topRadius: number; bottomRadius: number; slices?: number; numberOfVerticalLines?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: CylinderOutlineGeometry): CylinderOutlineGeometry;
static createGeometry(cylinderGeometry: CylinderOutlineGeometry): Geometry;
}
class DefaultProxy {
constructor(proxy: string);
getURL(resource: string): string;
}
class DeveloperError {
name: string;
message: string;
stack: string;
constructor(message?: string);
}
class DistanceDisplayCondition {
far: number;
near: number;
constructor(near?: number, far?: number);
clone(result?: DistanceDisplayCondition): DistanceDisplayCondition;
equals(other: DistanceDisplayCondition): boolean;
static clone(value?: DistanceDisplayCondition, result?: DistanceDisplayCondition): DistanceDisplayCondition;
static equals(left: DistanceDisplayCondition, right: DistanceDisplayCondition): boolean;
static pack(value: DistanceDisplayCondition, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: DistanceDisplayCondition): DistanceDisplayCondition;
}
class EllipseGeometry {
static packedLength: number;
constructor(options: { center: Cartesian3; semiMajorAxis: number; semiMinorAxis: number; ellipsoid?: Ellipsoid; height?: number; extrudedHeight?: number; rotation?: number; stRotation?: number; granularity?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipseGeometry): EllipseGeometry;
static createGeometry(ellipseGeometry: EllipseGeometry): Geometry;
}
class EllipseOutlineGeometry {
static packedLength: number;
constructor(options: { center: Cartesian3; semiMajorAxis: number; semiMinorAxis: number; ellipsoid?: Ellipsoid; height?: number; extrudedHeight?: number; rotation?: number; granularity?: number; numberOfVerticalLines?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipseOutlineGeometry): EllipseOutlineGeometry;
static createGeometry(ellipseGeometry: EllipseOutlineGeometry): Geometry;
}
class Ellipsoid {
radii: Cartesian3;
radiiSquared: Cartesian3;
radiiToTheFourth: Cartesian3;
oneOverRadii: Cartesian3;
oneOverRadiiSquared: Cartesian3;
minimumRadius: number;
maximumRadius: number;
static WGS84: Ellipsoid;
static UNIT_SPHERE: Ellipsoid;
static MOON: Ellipsoid;
static packedLength: number;
constructor(x?: number, y?: number, z?: number);
clone(result?: Ellipsoid): Ellipsoid;
geocentricSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
geodeticSurfaceNormalCartographic(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
geodeticSurfaceNormal(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
cartographicToCartesian(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
cartographicArrayToCartesianArray(cartographics: Cartographic[], result?: Cartesian3[]): Cartesian3[];
cartesianToCartographic(cartesian: Cartesian3, result?: Cartographic): Cartographic;
cartesianArrayToCartographicArray(cartesians: Cartesian3[], result?: Cartographic[]): Cartographic[];
scaleToGeodeticSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
scaleToGeocentricSurface(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
transformPositionToScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3;
transformPositionFromScaledSpace(position: Cartesian3, result?: Cartesian3): Cartesian3;
equals(right?: Ellipsoid): boolean;
toString(): string;
static clone(ellipsoid: Ellipsoid, result?: Ellipsoid): Ellipsoid;
static fromCartesian3(radii?: Cartesian3): Ellipsoid;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Ellipsoid): Ellipsoid;
}
class EllipsoidGeodesic {
surfaceDistance: number;
start: Cartographic;
end: Cartographic;
startHeading: number;
endHeading: number;
constructor(start?: Cartographic, end?: Cartographic, ellipsoid?: Ellipsoid);
setEndPoints(start: Cartographic, end: Cartographic): void;
interpolateUsingFraction(fraction: number): Cartographic;
interpolateUsingSurfaceDistance(distance: number): Cartographic;
}
class EllipsoidGeometry {
static packedLength: number;
constructor(options?: { radii?: Cartesian3; stackPartitions?: number; slicePartitions?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipsoidGeometry): EllipsoidGeometry;
static createGeometry(ellipsoidGeometry: EllipsoidGeometry): Geometry;
}
class EllipsoidOutlineGeometry {
static packedLength: number;
constructor(options?: { radii?: Cartesian3; stackPartitions?: number; slicePartitions?: number; subdivisions?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: EllipsoidOutlineGeometry): EllipsoidOutlineGeometry;
static createGeometry(ellipsoidGeometry: EllipsoidOutlineGeometry): Geometry;
}
class EllipsoidTangentPlane {
ellipsoid: Ellipsoid;
origin: Cartesian3;
constructor(ellipsoid: Ellipsoid, origin: Cartesian3);
projectPointOntoPlane(cartesian: Cartesian3, result?: Cartesian2): Cartesian2;
projectPointsOntoPlane(cartesians: Cartesian3[], result?: Cartesian2[]): Cartesian2[];
projectPointsOntoEllipsoid(cartesians: Cartesian2[], result?: Cartesian3[]): Cartesian3[];
static fromPoints(ellipsoid: Ellipsoid, cartesians: Cartesian3): EllipsoidTangentPlane;
}
class EllipsoidTerrainProvider extends TerrainProvider {
constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid });
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
}
class Event<CB extends (...args: any[]) => void = (...args: any[]) => void> {
numberOfListeners: number;
addEventListener(listener: CB, scope?: any): Event.RemoveCallback;
removeEventListener(listener: CB, scope?: any): boolean;
raiseEvent(...args: any[]): void;
}
namespace Event {
type RemoveCallback = () => void;
}
class EventHelper {
add(event: Event, listener: Function, scope?: any): EventHelper.RemoveCallback;
removeAll(): void;
}
namespace EventHelper {
type RemoveCallback = () => void;
}
class GeographicProjection {
ellipsoid: Ellipsoid;
constructor(ellipsoid?: Ellipsoid);
project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
}
class GeographicTilingScheme {
ellipsoid: Ellipsoid;
rectangle: Rectangle;
projection: MapProjection;
constructor(options?: { ellipsoid?: Ellipsoid; rectangle?: Rectangle; numberOfLevelZeroTilesX?: number; numberOfLevelZeroTilesY?: number });
getNumberOfXTilesAtLevel(level: number): number;
getNumberOfYTilesAtLevel(level: number): number;
rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): Rectangle;
tileXYToRectangle(x: number, y: number, level: number, result?: any): Rectangle;
positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
}
class Geometry {
attributes: GeometryAttributes;
boundingSphere: BoundingSphere;
indices: any[];
primitiveType: PrimitiveType;
constructor(options: { attributes: GeometryAttributes; primitiveType?: PrimitiveType; indices?: Uint16Array | Uint32Array; boundingSphere?: BoundingSphere });
static computeNumberOfVertices(geometry: Cartesian3): number;
}
class GeometryAttribute {
componentDatatype: ComponentDatatype;
componentsPerAttribute: number;
normalize: boolean;
values: any[];
constructor(options?: { componentDatatype?: ComponentDatatype; componentsPerAttribute?: number; normalize?: boolean; values?: number[] });
}
class GeometryAttributes {
position: GeometryAttribute;
normal: GeometryAttribute;
st: GeometryAttribute;
binormal: GeometryAttribute;
tangent: GeometryAttribute;
color: GeometryAttribute;
}
class GeometryInstance {
geometry: Geometry;
modelMatrix: Matrix4;
id: any;
attributes: any;
constructor(options: {
geometry: Geometry;
modelMatrix?: Matrix4;
id?: any;
attributes?: any;
});
}
class GeometryInstanceAttribute {
componentDatatype: ComponentDatatype;
componentsPerAttribute: number;
normalize: boolean;
value: number[];
constructor(options: { componentDatatype?: ComponentDatatype; componentsPerAttribute?: number; normalize?: boolean; value?: number[] });
}
class GregorianDate {
year: number;
month: number;
day: number;
hour: number;
minute: number;
second: number;
millisecond: number;
isLeapSecond: boolean;
constructor(
year?: number,
month?: number,
day?: number,
hour?: number,
minute?: number,
second?: number,
millisecond?: number,
isLeapSecond?: boolean,
);
}
class HeightmapTerrainData {
waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
constructor(options: { buffer: Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array; width: number; height: number; childTileMask?: number; structure?: any; structureheightScale?: number; structureheightOffset?: number; structureelementsPerHeight?: number; structurestride?: number; structureelementMultiplier?: number; structureisBigEndian?: boolean; createdByUpsampling?: boolean });
createMesh(tilingScheme: TilingScheme, x: number, y: number, level: number): Promise<TerrainMesh>;
interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<HeightmapTerrainData>;
isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
wasCreatedByUpsampling(): boolean;
}
class HermiteSpline {
times: number[];
points: Cartesian3[];
inTangents: Cartesian3[];
outTangents: Cartesian3[];
constructor(options: { times: number[]; points: Cartesian3[]; inTangents: Cartesian3[]; outTangents: Cartesian3[] });
findTimeInterval(time: number): number;
evaluate(time: number, result?: Cartesian3): Cartesian3;
static createC1(): HermiteSpline;
static createNaturalCubic(): HermiteSpline | LinearSpline;
static createClampedCubic(): HermiteSpline | LinearSpline;
}
class Interval {
start: number;
stop: number;
constructor(start?: number, stop?: number);
}
class JulianDate {
dayNumber: number;
secondsOfDay: number;
static leapSeconds: LeapSecond[];
constructor(julianDayNumber: number, secondsOfDay: number, timeStandard?: TimeStandard);
clone(result?: JulianDate): JulianDate;
equals(right?: JulianDate): boolean;
equalsEpsilon(right: JulianDate, epsilon: number): boolean;
toString(): string;
static fromDate(date: Date, result?: JulianDate): JulianDate;
static fromGregorianDate(date: GregorianDate, result?: JulianDate): JulianDate;
static fromIso8601(iso8601String: string, result?: JulianDate): JulianDate;
static now(result?: JulianDate): JulianDate;
static toGregorianDate(julianDate: JulianDate, result?: GregorianDate): GregorianDate;
static toDate(julianDate: JulianDate): Date;
static toIso8601(julianDate: JulianDate, precision?: number): string;
static clone(julianDate: JulianDate, result?: JulianDate): JulianDate;
static compare(left: JulianDate, right: JulianDate): number;
static equals(left?: JulianDate, right?: JulianDate): boolean;
static equalsEpsilon(left: JulianDate, right: JulianDate, epsilon: number): boolean;
static totalDays(julianDate: JulianDate): number;
static secondsDifference(left: JulianDate, right: JulianDate): number;
static daysDifference(left: JulianDate, right: JulianDate): number;
static computeTaiMinusUtc(julianDate: JulianDate): number;
static addSeconds(julianDate: JulianDate, seconds: number, result: JulianDate): JulianDate;
static addMinutes(julianDate: JulianDate, minutes: number, result: JulianDate): JulianDate;
static addHours(julianDate: JulianDate, hours: number, result: JulianDate): JulianDate;
static addDays(julianDate: JulianDate, days: number, result: JulianDate): JulianDate;
static lessThan(left: JulianDate, right: JulianDate): boolean;
static lessThanOrEquals(left: JulianDate, right: JulianDate): boolean;
static greaterThan(left: JulianDate, right: JulianDate): boolean;
static greaterThanOrEquals(left: JulianDate, right: JulianDate): boolean;
}
class LeapSecond {
julianDate: JulianDate;
offset: number;
constructor(date?: JulianDate, offset?: number);
}
class LinearSpline {
times: number[];
points: Cartesian3[];
constructor();
findTimeInterval(time: number): number;
evaluate(time: number, result?: Cartesian3): Cartesian3;
}
class MapProjection {
ellipsoid: Ellipsoid;
project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
}
class Matrix2 {
static packedLength: number;
static IDENTITY: Matrix2;
static COLUMN0ROW0: number;
static COLUMN0ROW1: number;
static COLUMN1ROW0: number;
static COLUMN1ROW1: number;
constructor(column0Row0?: number, column1Row0?: number, column0Row1?: number, column1Row1?: number);
clone(result?: Matrix2): Matrix2;
equals(right?: Matrix2): boolean;
equalsEpsilon(right: Matrix2, epsilon: number): boolean;
toString(): string;
static pack(value: Matrix2, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Matrix2): Matrix2;
static clone(matrix: Matrix2, result?: Matrix2): Matrix2;
static fromArray(array: number[], startingIndex?: number, result?: Matrix2): Matrix2;
static fromColumnMajorArray(values: number[], result?: Matrix2): Matrix2;
static fromRowMajorArray(values: number[], result?: Matrix2): Matrix2;
static fromScale(scale: Cartesian2, result?: Matrix2): Matrix2;
static fromUniformScale(scale: number, result?: Matrix2): Matrix2;
static fromRotation(angle: number, result?: Matrix2): Matrix2;
static toArray(matrix: Matrix2, result?: number[]): number[];
static getElementIndex(row: number, column: number): number;
static getColumn(matrix: Matrix2, index: number, result: Cartesian2): Cartesian2;
static setColumn(matrix: Matrix2, index: number, cartesian: Cartesian2, result: Cartesian2): Matrix2;
static getRow(matrix: Matrix2, index: number, result: Cartesian2): Cartesian2;
static setRow(matrix: Matrix2, index: number, cartesian: Cartesian2, result: Matrix2): Matrix2;
static getScale(matrix: Matrix2, result: Cartesian2): Cartesian2;
static getMaximumScale(matrix: Matrix2): number;
static multiply(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
static add(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
static subtract(left: Matrix2, right: Matrix2, result: Matrix2): Matrix2;
static multiplyByVector(matrix: Matrix2, cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static multiplyByScalar(matrix: Matrix2, scalar: number, result: Matrix2): Matrix2;
static negate(matrix: Matrix2, result: Matrix2): Matrix2;
static transpose(matrix: Matrix2, result: Matrix2): Matrix2;
static abs(matrix: Matrix2, result: Matrix2): Matrix2;
static equals(left?: Matrix2, right?: Matrix2): boolean;
static equalsEpsilon(left: Matrix2, right: Matrix2, epsilon: number): boolean;
}
class Matrix3 {
static packedLength: number;
static IDENTITY: Matrix3;
static COLUMN0ROW0: number;
static COLUMN0ROW1: number;
static COLUMN0ROW2: number;
static COLUMN1ROW0: number;
static COLUMN1ROW1: number;
static COLUMN1ROW2: number;
static COLUMN2ROW0: number;
static COLUMN2ROW1: number;
static COLUMN2ROW2: number;
constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number);
clone(result?: Matrix3): Matrix3;
equals(right?: Matrix3): boolean;
equalsEpsilon(right: Matrix3, epsilon: number): boolean;
toString(): string;
static pack(value: Matrix3, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Matrix3): Matrix3;
static clone(matrix: Matrix3, result?: Matrix3): Matrix3;
static fromArray(array: number[], startingIndex?: number, result?: Matrix3): Matrix3;
static fromColumnMajorArray(values: number[], result?: Matrix3): Matrix3;
static fromRowMajorArray(values: number[], result?: Matrix3): Matrix3;
static fromQuaternion(quaternion: Quaternion): Matrix3;
static fromScale(scale: Cartesian3, result?: Matrix3): Matrix3;
static fromUniformScale(scale: number, result?: Matrix3): Matrix3;
static fromCrossProduct(the: Cartesian3, result?: Matrix3): Matrix3;
static fromRotationX(angle: number, result?: Matrix3): Matrix3;
static fromRotationY(angle: number, result?: Matrix3): Matrix3;
static fromRotationZ(angle: number, result?: Matrix3): Matrix3;
static toArray(matrix: Matrix3, result?: number[]): number[];
static getElementIndex(row: number, column: number): number;
static getColumn(matrix: Matrix3, index: number, result: Cartesian3): Cartesian3;
static setColumn(matrix: Matrix3, index: number, cartesian: Cartesian3, result: Cartesian3): Matrix3;
static getRow(matrix: Matrix3, index: number, result: Cartesian3): Cartesian3;
static setRow(matrix: Matrix3, index: number, cartesian: Cartesian3, result: Cartesian3): Matrix3;
static getScale(matrix: Matrix3, result: Cartesian3): Cartesian3;
static getMaximumScale(matrix: Matrix3): number;
static multiply(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
static add(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
static subtract(left: Matrix3, right: Matrix3, result: Matrix3): Matrix3;
static multiplyByVector(matrix: Matrix3, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByScalar(matrix: Matrix3, scalar: number, result: Matrix3): Matrix3;
static negate(matrix: Matrix3, result: Matrix3): Matrix3;
static transpose(matrix: Matrix3, result: Matrix3): Matrix3;
static computeEigenDecomposition(matrix: Matrix3, result?: any): any;
static abs(matrix: Matrix3, result: Matrix3): Matrix3;
static determinant(matrix: Matrix3): number;
static inverse(matrix: Matrix3, result: Matrix3): Matrix3;
static equals(left?: Matrix3, right?: Matrix3): boolean;
static equalsEpsilon(left: Matrix3, right: Matrix3, epsilon: number): boolean;
}
class Matrix4 {
static packedLength: number;
static IDENTITY: Matrix4;
static COLUMN0ROW0: number;
static COLUMN0ROW1: number;
static COLUMN0ROW2: number;
static COLUMN0ROW3: number;
static COLUMN1ROW0: number;
static COLUMN1ROW1: number;
static COLUMN1ROW2: number;
static COLUMN1ROW3: number;
static COLUMN2ROW0: number;
static COLUMN2ROW1: number;
static COLUMN2ROW2: number;
static COLUMN2ROW3: number;
static COLUMN3ROW0: number;
static COLUMN3ROW1: number;
static COLUMN3ROW2: number;
static COLUMN3ROW3: number;
constructor(column0Row0?: number, column1Row0?: number, column2Row0?: number, column3Row0?: number, column0Row1?: number, column1Row1?: number, column2Row1?: number, column3Row1?: number, column0Row2?: number, column1Row2?: number, column2Row2?: number, column3Row2?: number, column0Row3?: number, column1Row3?: number, column2Row3?: number, column3Row3?: number);
clone(result?: Matrix4): Matrix4;
equals(right?: Matrix4): boolean;
equalsEpsilon(right: Matrix4, epsilon: number): boolean;
toString(): string;
static pack(value: Matrix4, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Matrix4): Matrix4;
static clone(matrix: Matrix4, result?: Matrix4): Matrix4;
static fromArray(array: number[], startingIndex?: number, result?: Matrix4): Matrix4;
static fromColumnMajorArray(values: number[], result?: Matrix4): Matrix4;
static fromRowMajorArray(values: number[], result?: Matrix4): Matrix4;
static fromRotationTranslation(rotation: Matrix3, translation?: Cartesian3, result?: Matrix4): Matrix4;
static fromTranslationQuaternionRotationScale(translation: Cartesian3, rotation: Quaternion, scale: Cartesian3, result?: Matrix4): Matrix4;
static fromTranslation(translation: Cartesian3, result?: Matrix4): Matrix4;
static fromScale(scale: Cartesian3, result?: Matrix4): Matrix4;
static fromUniformScale(scale: number, result?: Matrix4): Matrix4;
static fromCamera(camera: Camera, result?: Matrix4): Matrix4;
static computePerspectiveFieldOfView(fovY: number, aspectRatio: number, near: number, far: number, result: Matrix4): Matrix4;
static computeOrthographicOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
static computePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
static computeInfinitePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4): Matrix4;
static computeViewportTransformation(viewport: any, nearDepthRange: number, farDepthRange: number, result: Matrix4): Matrix4;
static toArray(matrix: Matrix4, result?: number[]): number[];
static getElementIndex(row: number, column: number): number;
static getColumn(matrix: Matrix4, index: number, result: Cartesian4): Cartesian4;
static setColumn(matrix: Matrix4, index: number, cartesian: Cartesian4, result: Cartesian4): Matrix4;
static getRow(matrix: Matrix4, index: number, result: Cartesian4): Cartesian4;
static setRow(matrix: Matrix4, index: number, cartesian: Cartesian4, result: Cartesian4): Matrix4;
static getScale(matrix: Matrix4, result: Cartesian3): Cartesian3;
static getMaximumScale(matrix: Matrix4): number;
static multiply(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static add(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static subtract(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static multiplyTransformation(left: Matrix4, right: Matrix4, result: Matrix4): Matrix4;
static multiplyByMatrix3(matrix: Matrix4, rotation: Matrix3, result: Matrix4): Matrix4;
static multiplyByTranslation(matrix: Matrix4, translation: Cartesian3, result: Matrix4): Matrix4;
static multiplyByUniformScale(matrix: Matrix4, scale: number, result: Matrix4): Matrix4;
static multiplyByScale(matrix: Matrix4, scale: Cartesian3, result: Matrix4): Matrix4;
static multiplyByVector(matrix: Matrix4, cartesian: Cartesian4, result: Cartesian4): Cartesian4;
static multiplyByPointAsVector(matrix: Matrix4, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByPoint(matrix: Matrix4, cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByScalar(matrix: Matrix4, scalar: number, result: Matrix4): Matrix4;
static negate(matrix: Matrix4, result: Matrix4): Matrix4;
static transpose(matrix: Matrix4, result: Matrix4): Matrix4;
static abs(matrix: Matrix4, result: Matrix4): Matrix4;
static equals(left?: Matrix4, right?: Matrix4): boolean;
static equalsEpsilon(left: Matrix4, right: Matrix4, epsilon: number): boolean;
static getTranslation(matrix: Matrix4, result: Cartesian3): Cartesian3;
static getRotation(matrix: Matrix4, result: Matrix3): Matrix3;
static inverse(matrix: Matrix4, result: Matrix4): Matrix4;
static inverseTransformation(matrix: Matrix4, result: Matrix4): Matrix4;
}
class NearFarScalar {
near: number;
nearValue: number;
far: number;
farValue: number;
static packedLength: number;
constructor(near?: number, nearValue?: number, far?: number, farValue?: number);
clone(result?: NearFarScalar): NearFarScalar;
equals(right?: NearFarScalar): boolean;
static clone(nearFarScalar: NearFarScalar, result?: NearFarScalar): NearFarScalar;
static pack(value: NearFarScalar, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: NearFarScalar): NearFarScalar;
static equals(left?: NearFarScalar, right?: NearFarScalar): boolean;
}
class OrientedBoundingBox implements BoundingVolume {
static packedLength: number;
center: Cartesian3;
halfAxes: Matrix3;
constructor(center?: Cartesian3, halfAxes?: Matrix3);
clone(result?: OrientedBoundingBox): OrientedBoundingBox;
computePlaneDistances(position: Cartesian3, direction: Cartesian3, result?: Interval): Interval;
distanceSquaredTo(cartesian: Cartesian3): number;
equals(right?: OrientedBoundingBox): boolean;
intersectPlane(plane: Plane): Intersect;
isOccluded(occluder: Occluder): boolean;
static clone(box: OrientedBoundingBox, result?: OrientedBoundingBox): OrientedBoundingBox;
static computePlaneDistances(box: OrientedBoundingBox, position: Cartesian3, direction: Cartesian3, result?: Interval): Interval;
static distanceSquaredTo(box: OrientedBoundingBox, cartesian: Cartesian3): number;
static equals(left: OrientedBoundingBox, right: OrientedBoundingBox): boolean;
static fromPoints(positions: Cartesian3[], result?: OrientedBoundingBox): OrientedBoundingBox;
static fromRectangle(rectangle: Rectangle, minimumHeight?: number, maximumHeight?: number, ellipsoid?: Ellipsoid, result?: OrientedBoundingBox): OrientedBoundingBox;
static intersectPlane(box: OrientedBoundingBox, plane: Plane): Intersect;
static isOccluded(box: OrientedBoundingBox, occluder: Occluder): boolean;
static pack(value: OrientedBoundingBox, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: OrientedBoundingBox): OrientedBoundingBox;
}
class Occluder {
position: Cartesian3;
radius: number;
cameraPosition: Cartesian3;
constructor(occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3);
isPointVisible(occludee: Cartesian3): boolean;
isBoundingSphereVisible(occludee: BoundingSphere): boolean;
computeVisibility(occludeeBS: BoundingSphere): number;
static fromBoundingSphere(occluderBoundingSphere: BoundingSphere, cameraPosition: Cartesian3, result?: Occluder): Occluder;
static computeOccludeePoint(occluderBoundingSphere: BoundingSphere, occludeePosition: Cartesian3, positions: Cartesian3[]): any;
static computeOccludeePointFromRectangle(rectangle: Rectangle, ellipsoid?: Ellipsoid): any;
}
class PinBuilder {
fromColor(color: Color, size: number): HTMLCanvasElement;
fromUrl(url: string, color: Color, size: number): HTMLCanvasElement | Promise<HTMLCanvasElement>;
fromMakiIconId(id: string, color: Color, size: number): HTMLCanvasElement | Promise<HTMLCanvasElement>;
fromText(text: string, color: Color, size: number): HTMLCanvasElement;
}
class Plane {
normal: Cartesian3;
distance: number;
constructor(normal: Cartesian3, distance: number);
static clone(plane: Plane, result?: Plane): Plane;
static equals(left: Plane, right: Plane): boolean;
static fromCartesian4(coefficients: Cartesian4, result?: Plane): Plane;
static fromPointNormal(point: Cartesian3, normal: Cartesian3, result?: Plane): Plane;
static getPointDistance(plane: Plane, point: Cartesian3): number;
static projectPointOntoPlane(plane: Plane, point: Cartesian3, result?: Cartesian3): Cartesian3;
static transform(plane: Plane, transform: Matrix4, result?: Plane): Plane;
}
class PolygonGeometry {
constructor(options: PolygonGeometry.ConstructorOptions);
packedLength: number;
static createGeometry(polygonGeometry: PolygonGeometry): Geometry;
static fromPositions(options: PolygonGeometry.PositionOptions): PolygonGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolygonGeometry): PolygonGeometry;
}
namespace PolygonGeometry {
type BaseOptions = {
stRotation?: number;
closeBottom?: boolean;
closeTop?: boolean;
};
type ConstructorOptions = PolygonOutlineGeometry.ConstructorOptions & BaseOptions;
type PositionOptions = PolygonOutlineGeometry.PositionOptions & BaseOptions;
}
class PolygonHierarchy {
holes: PolygonHierarchy[];
positions: Cartesian3[];
constructor(positions?: Cartesian3[], holes?: PolygonHierarchy[]);
}
class PolygonOutlineGeometry {
constructor(options: PolygonOutlineGeometry.ConstructorOptions);
packedLength: number;
static createGeometry(polygonGeometry: PolygonOutlineGeometry): Geometry;
static fromPositions(options: PolygonOutlineGeometry.PositionOptions): PolygonOutlineGeometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolygonOutlineGeometry): PolygonOutlineGeometry;
}
namespace PolygonOutlineGeometry {
type BaseOptions = {
ellipsoid?: Ellipsoid;
extrudedHeight?: number;
granularity?: number;
height?: number;
perPositionHeight?: boolean;
};
type ConstructorOptions = BaseOptions & {
polygonHierarchy: PolygonHierarchy;
vertexFormat?: VertexFormat;
};
type PositionOptions = BaseOptions & {
positions: Cartesian3[];
};
}
class PolylineGeometry {
packedLength: number;
constructor(options: PolylineGeometry.ConstructorOptions);
static createGeometry(polylineGeometry: PolylineGeometry): Geometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolylineGeometry): PolylineGeometry;
}
namespace PolylineGeometry {
interface ConstructorOptions {
positions: Cartesian3[];
width?: number;
colors?: Color[];
colorsPerVertex?: boolean;
arcType?: ArcType;
granularity?: number;
vertexFormat?: VertexFormat;
ellipsoid?: Ellipsoid;
}
}
class PolylineVolumeGeometry {
packedLength: number;
constructor(options: { polylinePositions: Cartesian3[]; shapePositions: Cartesian2[]; ellipsoid?: Ellipsoid; granularity?: number; vertexFormat?: VertexFormat; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolylineVolumeGeometry): PolylineVolumeGeometry;
static createGeometry(polylineVolumeGeometry: PolylineVolumeGeometry): Geometry;
}
class PolylineVolumeOutlineGeometry {
packedLength: number;
constructor(options: { polylinePositions: Cartesian3[]; shapePositions: number; ellipsoid?: Ellipsoid; granularity?: number; cornerType?: CornerType });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: PolylineVolumeOutlineGeometry): PolylineVolumeOutlineGeometry;
static createGeometry(polylineVolumeOutlineGeometry: PolylineVolumeOutlineGeometry): Geometry;
}
class QuantizedMeshTerrainData {
waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
constructor(options: { quantizedVertices: Uint16Array; indices: Uint16Array | Uint32Array; minimumHeight: number; maximumHeight: number; boundingSphere: BoundingSphere; horizonOcclusionPoint: Cartesian3; westIndices: number[]; southIndices: number[]; eastIndices: number[]; northIndices: number[]; westSkirtHeight: number; southSkirtHeight: number; eastSkirtHeight: number; northSkirtHeight: number; childTileMask?: number; createdByUpsampling?: boolean; encodedNormals?: Uint8Array; waterMask?: Uint8Array });
createMesh(tilingScheme: TilingScheme, x: number, y: number, level: number): Promise<TerrainMesh>;
upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<QuantizedMeshTerrainData>;
interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
wasCreatedByUpsampling(): boolean;
}
class Quaternion {
x: number;
y: number;
z: number;
w: number;
static packedLength: number;
static packedInterpolationLength: number;
static ZERO: Quaternion;
static IDENTITY: Quaternion;
constructor(x?: number, y?: number, z?: number, w?: number);
clone(result?: Quaternion): Quaternion;
equals(right?: Quaternion): boolean;
equalsEpsilon(right: Quaternion, epsilon: number): boolean;
toString(): string;
static fromAxisAngle(axis: Cartesian3, angle: number, result?: Quaternion): Quaternion;
static fromRotationMatrix(matrix: Matrix3, result?: Quaternion): Quaternion;
static fromHeadingPitchRoll(hpr: HeadingPitchRoll, result?: Quaternion): Quaternion;
static pack(value: Quaternion, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: Quaternion): Quaternion;
static convertPackedArrayForInterpolation(packedArray: number[], startingIndex?: number, lastIndex?: number, result?: number[]): void;
static unpackInterpolationResult(array: number[], sourceArray: number[], startingIndex?: number, lastIndex?: number, result?: Quaternion): Quaternion;
static clone(quaternion: Quaternion, result?: Quaternion): Quaternion;
static conjugate(quaternion: Quaternion, result: Quaternion): Quaternion;
static magnitudeSquared(quaternion: Quaternion): number;
static magnitude(quaternion: Quaternion): number;
static normalize(quaternion: Quaternion, result: Quaternion): Quaternion;
static inverse(quaternion: Quaternion, result: Quaternion): Quaternion;
static add(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
static subtract(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
static negate(quaternion: Quaternion, result: Quaternion): Quaternion;
static dot(left: Quaternion, right: Quaternion): number;
static multiply(left: Quaternion, right: Quaternion, result: Quaternion): Quaternion;
static multiplyByScalar(quaternion: Quaternion, scalar: number, result: Quaternion): Quaternion;
static divideByScalar(quaternion: Quaternion, scalar: number, result: Quaternion): Quaternion;
static computeAxis(quaternion: Quaternion, result: Cartesian3): Cartesian3;
static computeAngle(quaternion: Quaternion): number;
static lerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
static slerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
static log(quaternion: Quaternion, result: Cartesian3): Cartesian3;
static exp(cartesian: Cartesian3, result: Quaternion): Quaternion;
static computeInnerQuadrangle(q0: Quaternion, q1: Quaternion, q2: Quaternion, result: Quaternion): Quaternion;
static squad(q0: Quaternion, q1: Quaternion, s0: Quaternion, s1: Quaternion, t: number, result: Quaternion): Quaternion;
static fastSlerp(start: Quaternion, end: Quaternion, t: number, result: Quaternion): Quaternion;
static fastSquad(q0: Quaternion, q1: Quaternion, s0: Quaternion, s1: Quaternion, t: number, result?: Quaternion): Quaternion;
static equals(left?: Quaternion, right?: Quaternion): boolean;
static equalsEpsilon(left: Quaternion, right: Quaternion, epsilon: number): boolean;
}
class QuaternionSpline {
times: number[];
points: Quaternion[];
innerQuadrangles: Quaternion[];
constructor(options: { times: number[]; points: Quaternion[]; firstInnerQuadrangle?: Quaternion; lastInnerQuadrangle?: Quaternion });
findTimeInterval(time: number): number;
evaluate(time: number, result?: Quaternion): Quaternion;
}
class Queue<T> {
readonly length: number;
clear(): void;
contains(item: T): boolean;
dequeue(): T | undefined;
enqueue(item: T): void;
peek(): T | undefined;
sort(compareFunction: Queue.Comparator<T>): void;
}
namespace Queue {
type Comparator<T> = (a: T, b: T) => number;
}
class Ray {
origin: Cartesian3;
direction: Cartesian3;
constructor(origin?: Cartesian3, direction?: Cartesian3);
static getPoint(ray: Ray, t: number, result?: Cartesian3): Cartesian3;
}
class Rectangle {
east: number;
height: number;
north: number;
south: number;
west: number;
width: number;
static MAX_VALUE: Rectangle;
static packedLength: number;
constructor(west?: number, south?: number, east?: number, north?: number);
clone(result?: Rectangle): Rectangle;
equals(other?: Rectangle): boolean;
equalsEpsilon(other: Rectangle, epsilon: number): boolean;
static center(rectangle: Rectangle, result?: Cartographic): Cartographic;
static clone(rectangle: Rectangle, result?: Rectangle): Rectangle;
static computeHeight(rectangle: Rectangle): number;
static computeWidth(rectangle: Rectangle): number;
static contains(rectangle: Rectangle, cartographic: Cartographic): boolean;
static equals(left: Rectangle, right: Rectangle): boolean;
static equalsEpsilon(left: Rectangle, right: Rectangle, absoluteEpsilon: number): boolean;
static expand(rectangle: Rectangle, cartographic: Cartographic, result?: Rectangle): Rectangle;
static fromCartesianArray(cartesians: Cartesian3[], ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
static fromCartographicArray(cartographics: Cartographic[], result?: Rectangle): Rectangle;
static fromDegrees(west?: number, south?: number, east?: number, north?: number, result?: Rectangle): Rectangle;
static fromRadians(west?: number, south?: number, east?: number, north?: number, result?: Rectangle): Rectangle;
static intersection(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle | undefined;
static northeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
static northwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
static pack(value: Rectangle, array: number[], startingIndex?: number): number[];
static simpleIntersection(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle | undefined;
static southeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
static southwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
static subsample(rectangle: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: Cartesian3[]): Cartesian3[];
static union(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle;
static unpack(array: number[], startingIndex?: number, result?: Rectangle): Rectangle;
static validate(rectangle: Rectangle): void;
}
class RectangleGeometry {
static packedLength: number;
constructor(options: { });
static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: RectangleGeometry): RectangleGeometry;
static createGeometry(rectangleGeometry: RectangleGeometry): Geometry;
}
namespace RectangleGeometry {
interface ConstructorOptions {
rectangle: Rectangle;
vertexFormat?: VertexFormat;
ellipsoid?: Ellipsoid;
granularity?: number;
height?: number;
rotation?: number;
stRotation?: number;
extrudedHeight?: number;
zIndex?: number;
}
}
class RectangleOutlineGeometry {
static packedLength: number;
constructor(options: { rectangle: Rectangle; ellipsoid?: Ellipsoid; granularity?: number; height?: number; rotation?: number; extrudedHeight?: number });
static pack(value: BoundingSphere, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: RectangleGeometry): RectangleGeometry;
static createGeometry(rectangleGeometry: RectangleOutlineGeometry): Geometry;
}
// This is a bad idea because it conflicts with window.Request!
class Request {
cancelFunction: Request.CancelCallback;
priority: number;
priorityFunction: Request.PriorityCallback;
requestFunction: Request.RequestCallback;
readonly state: RequestState;
readonly throttle: boolean;
readonly throttleByServer: boolean;
readonly type: RequestType;
url: string;
clone(result: Request): Request;
}
namespace Request {
type CancelCallback = () => void;
type PriorityCallback = () => number;
type RequestCallback = () => void;
}
class RequestErrorEvent {
statusCode: number;
response: any;
responseHeaders: any;
constructor(statusCode?: number, response?: any, responseHeaders?: string | any);
toString(): string;
}
enum RequestState {
ACTIVE, CANCELLED, FAILED, ISSUED, RECEIVED, UNISSUED,
}
enum RequestType {
IMAGERY, OTHER, TERRAIN, TILES3D,
}
/**
* The various fetch/post methods are declared as always returning a
* Promise, even though technically they may return undefined, because
* it would force a null-check or assert for the 99% case in order to
* cover the 1% case. These functions return undefined only when the
* `request` option is specified (which is described as "internal use
* only"), and this Request has its `throttle` option set, *and* the
* request is actually denied due to throttling. Users who specify a
* throttled request (against the guidance of the documentation!),
* consider yourselves advised to check for undefined responses when
* calling these methods.
*/
class Resource {
constructor(options: Resource.ConstructorOptions);
static readonly DEFAULT: Resource;
static readonly isBlobSupported: boolean;
readonly extension: string;
hasHeaders: boolean;
headers: {[headerName: string]: string};
isBlobUri: boolean;
isCrossOriginUrl: boolean;
isDataUri: boolean;
proxy: DefaultProxy;
readonly queryParameters: Resource.QueryParameters;
request: Request;
retryAttempts: number;
retryCallback: Resource.RetryCallback;
readonly templateValues: {[templateKey: string]: string};
url: string;
static delete(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static fetch(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static fetchArrayBuffer(options: string | Resource.ConstructorOptions): Promise<ArrayBuffer>;
static fetchBlob(options: string | Resource.ConstructorOptions): Promise<Blob>;
static fetchImage(options: string | (Resource.ConstructorOptions & {
preferBlob?: boolean;
preferImageBitmap?: boolean;
flipY?: boolean;
})): Promise<HTMLImageElement>;
static fetchJson(options: string | Resource.ConstructorOptions): Promise<any>;
static fetchJsonp(options: string | (Resource.ConstructorOptions & {
callbackParameterName: string;
})): Promise<any>;
static fetchText(options: string | Resource.ConstructorOptions): Promise<string>;
static fetchXML(options: string | Resource.ConstructorOptions): Promise<XMLDocument>;
static head(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static options(options: string | (Resource.ConstructorOptions & {
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static patch(options: string | (Resource.ConstructorOptions & {
data: {};
responseType?: string;
overrideMimeType?: string;
})): Promise<any>;
static post(options: Resource.ConstructorOptions & {
data: {};
responseType?: string;
overrideMimeType?: string;
}): Promise<any>;
static put(options: Resource.ConstructorOptions & {
data: {};
responseType?: string;
overrideMimeType?: string;
}): Promise<any>;
appendForwardSlash(): void;
clone(result?: Resource): Resource;
delete(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
fetch(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
fetchArrayBuffer(): Promise<ArrayBuffer>;
fetchBlob(): Promise<Blob>;
fetchImage(options?: {
preferBlob?: boolean;
preferImageBitmap?: boolean;
flipY?: boolean;
}): Promise<HTMLImageElement> | Promise<ImageBitmap>;
fetchJson(): Promise<any>;
fetchJsonp(callbackParameterName: string): Promise<any>;
fetchText(): Promise<string>;
fetchXML(): Promise<XMLDocument>;
getBaseUri(includeQuery?: boolean): string;
getDerivedResource(options: Resource.DerivedOptions): Resource;
getUrlComponent(query?: boolean, proxy?: boolean): string;
head(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
options(options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
patch(data: any, options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
post(data: any, options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
put(data: any, options?: {
headers?: {[headerName: string]: string};
overrideMimeType?: string;
responseType?: string;
}): Promise<any>;
setQueryParameters(params: Resource.QueryParameters, useAsDefault?: boolean): void;
setTemplateValues(params: {[templateKey: string]: string}, useAsDefault?: boolean): void;
}
namespace Resource {
type QueryValue = string | number | boolean;
interface QueryParameters {
[queryKey: string]: QueryValue | QueryValue[] | undefined;
}
type BaseOptions = {
headers?: {[headerName: string]: string};
proxy?: DefaultProxy;
queryParameters?: QueryParameters;
request?: Request;
retryAttempts?: number;
retryCallback?: Resource.RetryCallback;
templateValues?: {[templateKey: string]: string};
}
type ConstructorOptions = Resource.BaseOptions & {
url: string;
};
type DerivedOptions = Resource.BaseOptions & {
url?: string;
preserveQueryParameters?: boolean;
};
type RetryCallback = (resource: Resource, error: Error) => boolean | Promise<boolean>;
}
class RuntimeError {
name: string;
message: string;
stack: string;
constructor(message?: string);
}
class ScreenSpaceEventHandler {
constructor(element?: HTMLCanvasElement);
setInputAction(action: ScreenSpaceEventAction, type: number, modifier?: number): void;
getInputAction(type: number, modifier?: number): ScreenSpaceEventAction;
removeInputAction(type: number, modifier?: number): void;
isDestroyed(): boolean;
destroy(): void;
}
type ScreenSpaceEventAction = (evt: PositionedEvent | MoveEvent | Touch2Event) => void;
class ShowGeometryInstanceAttribute {
value: Uint8Array;
componentDatatype: ComponentDatatype;
componentsPerAttribute: number;
normalize: boolean;
constructor(show?: boolean);
static toValue(show: boolean, result?: Uint8Array): Uint8Array;
}
class SimplePolylineGeometry {
packedLength: number;
constructor(options: SimplePolylineGeometry.ConstructorOptions);
static createGeometry(simplePolylineGeometry: SimplePolylineGeometry): Geometry;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: SimplePolylineGeometry): SimplePolylineGeometry;
}
namespace SimplePolylineGeometry {
interface ConstructorOptions {
positions: Cartesian3[];
colors?: Color[];
colorsPerVertex?: boolean;
arcType?: ArcType;
granularity?: number;
ellipsoid?: Ellipsoid;
}
}
class SphereGeometry {
static packedLength: number;
constructor(options?: { radius?: number; stackPartitions?: number; slicePartitions?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: SphereGeometry): SphereGeometry;
static createGeometry(sphereGeometry: SphereGeometry): Geometry;
}
class SphereOutlineGeometry {
static packedLength: number;
constructor(options?: { radius?: number; stackPartitions?: number; slicePartitions?: number; subdivisions?: number });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: SphereOutlineGeometry): SphereOutlineGeometry;
static createGeometry(sphereGeometry: SphereOutlineGeometry): Geometry;
}
class Spherical {
constructor(clock?: number, cone?: number, magnitude?: number);
equals(other: Spherical): boolean;
clone(result?: Spherical): Spherical;
equalsEpsilon(other: Spherical, epsilon: number): boolean;
toString(): string;
static fromCartesian3(cartesian3: Cartesian3, spherical?: Spherical): Spherical;
static clone(spherical: Spherical, result?: Spherical): Spherical;
static normalize(spherical: Spherical, result?: Spherical): Spherical;
static equals(left: Spherical, right: Spherical): boolean;
static equalsEpsilon(left: Spherical, right: Spherical, epsilon?: number): boolean;
}
abstract class Spline {
points: Cartesian3[] | Quaternion[];
times: number[];
private constructor();
clampTime(time: number): number;
abstract evaluate(time: number, result?: Cartesian3 | Quaternion): Cartesian3 | Quaternion | number[];
findTimeInterval(time: number, startIndex: number): number;
wrapTime(time: number): number;
}
class TaskProcessor {
constructor(workerName: string, maximumActiveTasks?: number);
destroy(): void;
initWebAssemblyModule(options: {
modulePath?: string,
wasmBinaryFile?: string,
fallbackModulePath?: string,
}): Promise<any>;
isDestroyed(): boolean;
scheduleTask(parameters: any, transferableObjects?: any[]): Promise<any>;
}
class TerrainData {
waterMask: Uint8Array | HTMLImageElement | HTMLCanvasElement;
interpolateHeight(rectangle: Rectangle, longitude: number, latitude: number): number;
isChildAvailable(thisX: number, thisY: number, childX: number, childY: number): boolean;
createMesh(tilingScheme: TilingScheme, x: number, y: number, level: number): Promise<TerrainMesh>;
upsample(tilingScheme: TilingScheme, thisX: number, thisY: number, thisLevel: number, descendantX: number, descendantY: number, descendantLevel: number): Promise<TerrainData>;
wasCreatedByUpsampling(): boolean;
}
class TerrainMesh {
center: Cartesian3;
vertices: Float32Array;
stride: number;
indices: Uint16Array | Uint32Array;
minimumHeight: number;
maximumHeight: number;
boundingSphere3D: BoundingSphere;
occludeePointInScaledSpace: Cartesian3;
constructor(center: Cartesian3, vertices: Float32Array, indices: Uint16Array | Uint32Array, minimumHeight: number, maximumHeight: number, boundingSphere3D: BoundingSphere, occludeePointInScaledSpace: Cartesian3, vertexStride?: number);
}
abstract class TerrainProvider {
readonly availability: TileAvailability;
readonly credit: Credit;
readonly errorEvent: Event<(prov: this, err: TileProviderError) => void>;
readonly hasVertexNormals: boolean;
readonly hasWaterMask: boolean;
readonly ready: boolean;
readonly readyPromise: Promise<boolean>;
readonly tilingScheme: TilingScheme;
static heightmapTerrainQuality: number;
abstract getLevelMaximumGeometricError(level: number): number;
abstract getTileDataAvailable(x: number, y: number, level: number): boolean;
abstract loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
abstract requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
static getEstimatedLevelZeroGeometricErrorForAHeightmap(ellipsoid: Ellipsoid, tileImageWidth: number, numberOfTilesAtLevelZero: number): number;
static getRegularGridIndices(width: number, height: number): Uint16Array;
}
class TileAvailability {
// TODO
}
class TileProviderError {
provider: ImageryProvider | TerrainProvider;
message: string;
x: number;
y: number;
level: number;
timesRetried: number;
retry: boolean;
error: Error;
constructor(provider: ImageryProvider | TerrainProvider, message: string, x?: number, y?: number, level?: number, timesRetried?: number, error?: Error);
static handleError(previousError: TileProviderError, provider: ImageryProvider | TerrainProvider, event: Event, message: string, x: number, y: number, level: number, retryFunction: TileProviderError.RetryFunction, errorDetails?: Error): TileProviderError;
static handleSuccess(previousError: TileProviderError): void;
}
namespace TileProviderError {
type RetryFunction = () => void;
}
class TilingScheme {
ellipsoid: Ellipsoid;
rectangle: Rectangle;
projection: MapProjection;
getNumberOfXTilesAtLevel(level: number): number;
getNumberOfYTilesAtLevel(level: number): number;
rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): Rectangle;
tileXYToRectangle(x: number, y: number, level: number, result?: any): Rectangle;
positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
}
class TimeInterval {
start: JulianDate;
stop: JulianDate;
data: TimeInterval.DataType;
isStartIncluded: boolean;
isStopIncluded: boolean;
isEmpty: boolean;
static EMPTY: TimeInterval;
constructor(options?: TimeInterval.ConstructorOptions);
clone(result?: TimeInterval): TimeInterval;
equals(right?: TimeInterval, dataComparer?: TimeInterval.DataComparer): boolean;
equalsEpsilon(right: TimeInterval, epsilon: number, dataComparer?: TimeInterval.DataComparer): boolean;
toString(): string;
static fromIso8601(options: { iso8601: string; isStartIncluded?: boolean; isStopIncluded?: boolean; data?: TimeInterval.DataType }, result?: TimeInterval): TimeInterval;
static toIso8601(timeInterval: TimeInterval, precision?: number): string;
static clone(timeInterval?: TimeInterval, result?: TimeInterval): TimeInterval;
static equals(left?: TimeInterval, right?: TimeInterval, dataComparer?: TimeInterval.DataComparer): boolean;
static equalsEpsilon(left: TimeInterval, right: TimeInterval, epsilon: number, dataComparer?: TimeInterval.DataComparer): boolean;
static intersect(left: TimeInterval, right: TimeInterval, result: TimeInterval, mergeCallback?: TimeInterval.MergeCallback): TimeInterval;
static contains(timeInterval: TimeInterval, julianDate: JulianDate): boolean;
}
namespace TimeInterval {
type DataType = {}; // TODO: are there other constraints on this?
type MergeCallback = (leftData: DataType, rightData: DataType) => DataType;
type DataComparer = (leftData: DataType, rightData: DataType) => boolean;
interface ConstructorOptions {
start?: JulianDate;
stop?: JulianDate;
isStartIncluded?: boolean;
isStopIncluded?: boolean;
data?: DataType;
}
}
class TimeIntervalCollection {
readonly changedEvent: Event<(coll: this) => void>;
readonly isEmpty: boolean;
readonly isStartIncluded: boolean;
readonly isStopIncluded: boolean;
readonly length: number;
readonly start: JulianDate;
readonly stop: JulianDate;
constructor(intervals?: TimeInterval[]);
addInterval(interval: TimeInterval, dataComparer?: TimeInterval.DataComparer): void;
contains(julianDate: JulianDate): boolean;
equals(right?: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer): boolean;
findDataForIntervalContainingDate(date: JulianDate): TimeInterval.DataType | undefined;
findInterval(options?: TimeIntervalCollection.FindOptions): TimeInterval | undefined;
findIntervalContainingDate(date: JulianDate): TimeInterval | undefined;
get(index: number): TimeInterval | undefined;
indexOf(date: JulianDate): number;
intersect(other: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer, mergeCallback?: TimeInterval.MergeCallback): TimeIntervalCollection;
removeAll(): void;
removeInterval(interval: TimeInterval): void;
static fromIso8601(options: {iso8601: string} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
static fromIso8601DateArray(options: {iso8601Dates: string[]} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
static fromIso8601DurationArray(options: {epoch: JulianDate, iso8601Durations: string[]} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
static fromJulianDateArray(options: {julianDates: JulianDate[]} & TimeIntervalCollection.HelperOptions, result?: TimeIntervalCollection): TimeIntervalCollection;
}
namespace TimeIntervalCollection {
interface HelperOptions {
isStartIncluded?: boolean;
isStopIncluded?: boolean;
leadingInterval?: boolean;
trailingInterval?: boolean;
dataCallback?: DataCallback;
}
type DataCallback = (interval: TimeInterval, index: number) => TimeInterval.DataType;
interface FindOptions {
start?: JulianDate;
stop?: JulianDate;
isStartIncluded?: boolean;
isStopIncluded?: boolean;
}
}
class TranslationRotationScale {
rotation: Quaternion;
scale: Cartesian3;
translation: Cartesian3;
constructor(translation?: Cartesian3, rotation?: Quaternion, scale?: Cartesian3);
equals(right?: TranslationRotationScale): boolean;
}
namespace TrustedServers {
function add(host: string, port: number): void;
function clear(): void;
function contains(url: string): boolean;
function remove(host: string, port: number): void;
}
class VRTheWorldTerrainProvider extends TerrainProvider {
constructor(options: {
url: Resource | string;
ellipsoid?: Ellipsoid;
credit?: Credit | string;
});
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
}
class VertexFormat {
position: boolean;
normal: boolean;
st: boolean;
binormal: boolean;
tangent: boolean;
color: boolean;
static POSITION_ONLY: VertexFormat;
static POSITION_AND_NORMAL: VertexFormat;
static POSITION_NORMAL_AND_ST: VertexFormat;
static POSITION_AND_ST: VertexFormat;
static POSITION_AND_COLOR: VertexFormat;
static ALL: VertexFormat;
static DEFAULT: VertexFormat;
static packedLength: number;
constructor(options?: any);
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: VertexFormat): VertexFormat;
static clone(cartesian: VertexFormat, result?: VertexFormat): VertexFormat;
}
class WallGeometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; granularity?: number; maximumHeights?: number[]; minimumHeights?: number[]; ellipsoid?: Ellipsoid; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: WallGeometry): WallGeometry;
static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid): WallGeometry;
static createGeometry(wallGeometry: WallGeometry): Geometry;
}
class WallOutlineGeometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; granularity?: number; maximumHeights?: number[]; minimumHeights?: number[]; ellipsoid?: Ellipsoid });
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: WallOutlineGeometry): WallOutlineGeometry;
static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid): WallOutlineGeometry;
static createGeometry(wallGeometry: WallOutlineGeometry): Geometry;
}
class WebMercatorProjection {
ellipsoid: Ellipsoid;
static MaximumLatitude: number;
constructor(ellipsoid?: Ellipsoid);
project(cartographic: Cartographic, result?: Cartesian3): Cartesian3;
unproject(cartesian: Cartesian3, result?: Cartographic): Cartographic;
static mercatorAngleToGeodeticLatitude(mercatorAngle: number): number;
static geodeticLatitudeToMercatorAngle(latitude: number): number;
}
class WebMercatorTilingScheme {
ellipsoid: Ellipsoid;
rectangle: Rectangle;
projection: MapProjection;
constructor(options?: { ellipsoid?: Ellipsoid; numberOfLevelZeroTilesX?: number; numberOfLevelZeroTilesY?: number; rectangleSouthwestInMeters?: Cartesian2; rectangleNortheastInMeters?: Cartesian2 });
getNumberOfXTilesAtLevel(level: number): number;
getNumberOfYTilesAtLevel(level: number): number;
rectangleToNativeRectangle(rectangle: Rectangle, result?: Rectangle): Rectangle;
tileXYToNativeRectangle(x: number, y: number, level: number, result?: any): Rectangle;
tileXYToRectangle(x: number, y: number, level: number, result?: any): Rectangle;
positionToTileXY(position: Cartographic, level: number, result?: Cartesian2): Cartesian2;
}
class BillboardGraphics {
alignedAxis: Property;
color: Property;
readonly definitionChanged: Event;
disableDepthTestDistance: Property;
distanceDisplayCondition: Property;
eyeOffset: Property;
height: Property;
heightReference: Property;
horizontalOrigin: Property;
image: Property;
imageSubRegion: Property;
pixelOffset: Property;
pixelOffsetScaleByDistance: Property;
rotation: Property;
scale: Property;
scaleByDistance: Property;
show: boolean;
sizeInMeters: boolean;
translucencyByDistance: Property;
verticalOrigin: Property;
width: Property;
constructor(options?: BillboardGraphics.ConstructorOptions);
clone(result?: BillboardGraphics): BillboardGraphics;
merge(source: BillboardGraphics): void;
}
namespace BillboardGraphics {
type ConstructorOptions = {
image?: Property | string | HTMLCanvasElement;
show?: Property | boolean;
scale?: Property | number;
horizontalOrigin?: Property | HorizontalOrigin;
verticalOrigin?: Property | VerticalOrigin;
eyeOffset?: Property;
pixelOffset?: Property | Cartesian2;
rotation?: Property;
alignedAxis?: Property;
width?: Property | number;
height?: Property | number;
color?: Property;
scaleByDistance?: Property | NearFarScalar;
translucencyByDistance?: Property | NearFarScalar;
pixelOffsetScaleByDistance?: Property | NearFarScalar;
imageSubRegion?: Property;
disableDepthTestDistance?: Property | number;
heightReference?: Property | HeightReference;
}
}
class BillboardVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class BoxGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class BoxGraphics {
readonly definitionChanged: Event;
show: Property;
dimensions: Property;
material: MaterialProperty;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
constructor(options?: BoxGraphics.ConstructorOptions);
clone(result?: BoxGraphics): BoxGraphics;
merge(source: BoxGraphics): void;
}
namespace BoxGraphics {
type ConstructorOptions = {
dimensions?: Property;
show?: Property;
fill?: Property;
material?: MaterialProperty;
outline?: Property;
outlineColor?: Property;
outlineWidth?: Property;
};
}
class CallbackProperty extends Property {
constructor(callback: CallbackProperty.Callback, isConstant: boolean);
equals(other?: Property): boolean;
getValue(time?: JulianDate, result?: any): any;
setCallback(callback: CallbackProperty.Callback, isConstant: boolean): void;
}
namespace CallbackProperty {
type Callback = (time?: JulianDate, result?: any) => any;
}
class CheckerboardMaterialProperty extends MaterialProperty {
evenColor: Property;
oddColor: Property;
repeat: Property;
constructor(options?: { evenColor?: Property; oddColor?: Property; repeat?: Property });
equals(other?: Property): boolean;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
}
class ColorMaterialProperty extends MaterialProperty {
color: Property;
constructor(color?: Property);
equals(other?: Property): boolean;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
}
class CompositeEntityCollection {
readonly definitionChanged: Event<EntityCollection.collectionChangedEventCallback>;
id: string;
values: Entity[];
constructor(collections?: EntityCollection[]);
addCollection(collection: EntityCollection, index?: number): void;
removeCollection(collection: EntityCollection): boolean;
removeAllCollections(): void;
containsCollection(collection: EntityCollection): boolean;
contains(entity: Entity): boolean;
indexOfCollection(collection: EntityCollection): number;
getCollection(index: number): EntityCollection;
getCollectionsLength(): number;
raiseCollection(collection: EntityCollection): void;
lowerCollection(collection: EntityCollection): void;
raiseCollectionToTop(collection: EntityCollection): void;
lowerCollectionToBottom(collection: EntityCollection): void;
suspendEvents(): void;
resumeEvents(): void;
computeAvailability(): TimeInterval;
getById(id: any): Entity;
}
class CompositeMaterialProperty extends MaterialProperty implements CompositeProperty {
readonly intervals: TimeIntervalCollection;
constructor();
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class CompositePositionProperty extends PositionProperty implements CompositeProperty {
readonly intervals: TimeIntervalCollection;
}
class CompositeProperty extends Property {
readonly intervals: TimeIntervalCollection;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class TimeIntervalCollectionProperty extends CompositeProperty {} // Exact same shape
class ConstantPositionProperty extends Property {
referenceFrame: ReferenceFrame;
constructor(value?: Cartesian3, referenceFrame?: ReferenceFrame);
equals(other?: Property): boolean;
// TODO: Remove `true` when GH #8676 is resolved
getValue(time: JulianDate | true, result?: any): Cartesian3;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
setValue(value: Cartesian3, referenceFrame?: ReferenceFrame): void;
}
class ConstantProperty extends Property {
constructor(value?: any);
equals(other?: Property): boolean;
getValue(time?: JulianDate, result?: any): any;
setValue(value: any): void;
}
class CorridorGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class CorridorGraphics {
classificationType: Property;
cornerType: Property;
readonly definitionChanged: Event;
distanceDisplayCondition: Property;
extrudedHeight: Property;
extrudedHeightReference: Property;
fill: Property;
granularity: Property;
height: Property;
heightReference: Property;
material: MaterialProperty;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
positions: Property;
shadows: Property;
show: Property;
width: Property;
zIndex: Property;
constructor(options?: CorridorGraphics.ConstructorOptions);
clone(result?: CorridorGraphics): CorridorGraphics;
merge(source: CorridorGraphics): void;
}
namespace CorridorGraphics {
type ConstructorOptions = {
positions?: Property | Cartesian3[];
width?: Property | number;
cornerType?: Property | CornerType;
height?: Property | number;
heightReference?: Property | HeightReference;
extrudedHeight?: Property | number;
extrudedHeightReference?: Property | HeightReference;
show?: Property | boolean;
fill?: Property | boolean;
material?: MaterialProperty | Color;
outline?: Property | boolean;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
granularity?: Property | number;
shadows?: Property | ShadowMode;
distanceDisplayCondition?: Property | DistanceDisplayCondition;
zIndex?: Property | number;
}
}
class CustomDataSource extends DataSource {
constructor(name?: string);
}
class CylinderGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class CylinderGraphics {
readonly definitionChanged: Event;
length: Property;
topRadius: Property;
bottomRadius: Property;
numberOfVerticalLines: Property;
slices: Property;
show: Property;
material: MaterialProperty;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
constructor(options?: CylinderGraphics.ConstructorOptions);
clone(result?: CylinderGraphics): CylinderGraphics;
merge(source: CylinderGraphics): void;
}
namespace CylinderGraphics {
type ConstructorOptions = {
length?: Property;
topRadius?: Property;
bottomRadius?: Property;
show?: Property;
fill?: Property;
material?: MaterialProperty;
outline?: Property;
outlineColor?: Property;
outlineWidth?: Property;
numberOfVerticalLines?: Property;
slices?: Property;
};
}
class CzmlDataSource extends DataSource {
static updaters: any[];
constructor(name?: string);
process(data: string | CZMLObject, options?: CzmlDataSource.LoadOptions): Promise<CzmlDataSource>;
load(data: Resource | string | CZMLObject, options?: { sourceUri?: string }): Promise<CzmlDataSource>;
static load(data: string | any, options?: { sourceUri?: string }): Promise<CzmlDataSource>;
static processPacketData(type: Function, object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection): void;
static processPositionPacketData(object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection): void;
static processMaterialPacketData(object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection): void;
}
namespace CzmlDataSource {
interface LoadOptions {
sourceUri?: string;
}
}
type CZMLPacket = any;
type CZMLObject = CZMLPacket | CZMLPacket[];
abstract class DataSource {
readonly changedEvent: Event<(src: this) => void>;
clock: DataSourceClock;
clustering: EntityCluster;
entities: EntityCollection;
readonly errorEvent: Event<(src: this, err: RequestErrorEvent) => void>;
isLoading: boolean;
readonly loadingEvent: Event<(src: this, loading: boolean) => void>;
name: string;
show: boolean;
update(time: JulianDate): boolean;
}
class DataSourceClock {
readonly definitionChanged: Event; // Can't find call signature
startTime: JulianDate;
stopTime: JulianDate;
currentTime: JulianDate;
clockRange: ClockRange;
clockStep: ClockStep;
multiplier: number;
clone(result?: DataSourceClock): DataSourceClock;
equals(other: DataSourceClock): boolean;
merge(source: DataSourceClock): void;
getValue(): Clock;
}
class DataSourceCollection {
readonly dataSourceAdded: Event<(newSrc: DataSource) => void>;
readonly dataSourceMoved: Event<(src: DataSource, newIdx: number, oldIdx: number) => void>;
readonly dataSourceRemoved: Event<(src: DataSource) => void>;
readonly length: number;
add(dataSource: DataSource | Promise<DataSource>): Promise<DataSource>;
contains(dataSource: DataSource): boolean;
destroy(): void;
get(index: number): DataSource;
getByName(name: string): DataSource[];
indexOf(dataSource: DataSource): number;
isDestroyed(): boolean;
lower(dataSource: DataSource): void;
lowerToBottom(dataSource: DataSource): void;
raise(dataSource: DataSource): void;
raiseToTop(dataSource: DataSource): void;
remove(dataSource: DataSource, destroy?: boolean): boolean;
removeAll(destroy?: boolean): void;
}
class DataSourceDisplay {
scene: Scene;
dataSources: DataSourceCollection;
defaultDataSource: CustomDataSource;
static defaultVisualizersCallback: DataSourceDisplay.VisualizersCallback;
constructor(options: { scene: Scene; dataSourceCollection: DataSourceCollection; visualizersCallback?: DataSourceDisplay.VisualizersCallback });
isDestroyed(): boolean;
destroy(): void;
update(time: JulianDate): boolean;
}
namespace DataSourceDisplay {
type VisualizersCallback = (scene: Scene, dataSource: DataSource) => Visualizer[];
}
class DynamicGeometryUpdater {
update(time: JulianDate): void;
isDestroyed(): boolean;
destroy(): void;
}
class EllipseGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class EllipseGraphics {
classificationType: Property;
readonly definitionChanged: Event;
distanceDisplayCondition: Property;
extrudedHeight: Property;
extrudedHeightReference: Property;
fill: Property;
granularity: Property;
height: Property;
heightReference: Property;
material: MaterialProperty;
numberOfVerticalLines: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
rotation: Property;
semiMajorAxis: Property;
semiMinorAxis: Property;
shadows: Property;
show: Property;
stRotation: Property;
zIndex: Property;
constructor(options?: EllipseGraphics.ConstructorOptions);
clone(result?: EllipseGraphics): EllipseGraphics;
merge(source: EllipseGraphics): void;
}
namespace EllipseGraphics {
type ConstructorOptions = {
semiMajorAxis?: Property | number;
semiMinorAxis?: Property | number;
height?: Property | number;
heightReference?: Property | HeightReference;
extrudedHeight?: Property | number;
extrudedHeightReference?: Property | HeightReference;
show?: Property | boolean;
fill?: Property | boolean;
material?: MaterialProperty | Color;
outline?: Property | boolean;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
numberOfVerticalLines?: Property | number;
rotation?: Property | number;
stRotation?: Property | number;
granularity?: Property | number;
shadows?: Property | ShadowMode;
distanceDisplayCondition?: Property | DistanceDisplayCondition;
zIndex?: Property | number;
};
}
class EllipsoidGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class EllipsoidGraphics {
readonly definitionChanged: Event;
distanceDisplayCondition: Property;
fill: Property;
material: MaterialProperty;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
radii: Property;
shadows: Property;
show: Property;
slicePartitions: Property;
stackPartitions: Property;
subdivisions: Property;
constructor(options?: EllipsoidGraphics.ConstructorOptions);
clone(result?: EllipsoidGraphics): EllipsoidGraphics;
merge(source: EllipsoidGraphics): void;
}
namespace EllipsoidGraphics {
type ConstructorOptions = {
radii?: Property | Cartesian3;
show?: Property | boolean;
fill?: Property | boolean;
material?: MaterialProperty | Color;
outline?: Property | boolean;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
subdivisions?: Property | number;
stackPartitions?: Property | number;
slicePartitions?: Property | number;
distanceDisplayCondition?: Property | DistanceDisplayCondition;
}
}
class Entity {
availability?: TimeIntervalCollection;
billboard?: BillboardGraphics;
box?: BoxGraphics;
corridor?: CorridorGraphics;
cylinder?: CylinderGraphics;
readonly definitionChanged: Event<(ent: this, propName: string, newValue: any, oldValue: any) => void>;
description?: Property;
ellipse?: EllipseGraphics;
ellipsoid?: EllipsoidGraphics;
entityCollection?: EntityCollection;
id: string;
isShowing: boolean;
label?: LabelGraphics;
model?: ModelGraphics;
name?: string;
orientation?: Property;
parent?: Entity;
path?: PathGraphics;
point?: PointGraphics;
polygon?: PolygonGraphics;
polyline?: PolylineGraphics;
polylineVolume?: PolylineVolumeGraphics;
position?: PositionProperty;
properties?: PropertyBag;
propertyNames: string[];
rectangle?: RectangleGraphics;
show: boolean;
viewFrom?: Property;
wall?: WallGraphics;
constructor(options?: Entity.ConstructorOptions);
isAvailable(time: JulianDate): boolean;
addProperty(propertyName: string): void;
removeProperty(propertyName: string): void;
merge(source: Entity): void;
}
namespace Entity {
type ConstructorOptions = {
id?: string;
name?: string;
show?: boolean;
description?: Property | string;
position?: PositionProperty | CallbackProperty | Cartesian3;
orientation?: Property | any;
viewFrom?: Property | any;
parent?: Entity;
billboard?: BillboardGraphics.ConstructorOptions;
box?: BoxGraphics.ConstructorOptions;
corridor?: CorridorGraphics.ConstructorOptions;
cylinder?: CylinderGraphics.ConstructorOptions;
ellipse?: EllipseGraphics.ConstructorOptions;
ellipsoid?: EllipsoidGraphics.ConstructorOptions;
label?: LabelGraphics.ConstructorOptions;
model?: ModelGraphics.ConstructorOptions;
path?: PathGraphics.ConstructorOptions;
point?: PointGraphics.ConstructorOptions;
polygon?: PolygonGraphics.ConstructorOptions;
polyline?: PolylineGraphics.ConstructorOptions;
polylineVolume?: PolylineVolumeGraphics.ConstructorOptions;
properties?: {[key:string]: string|number|boolean|undefined};
rectangle?: RectangleGraphics.ConstructorOptions;
wall?: WallGraphics
}
}
class EntityCluster {
constructor(options: EntityCluster.ConstructorOptions);
clusterBillboards: boolean;
clusterEvent: Event<EntityCluster.newClusterCallback>;
clusterLabels: boolean;
clusterPoints: boolean;
enabled: boolean;
minimumClusterSize: number;
pixelRange: number;
}
namespace EntityCluster {
type ConstructorOptions = {
clusterBillboards?: boolean;
clusterLabels?: boolean;
clusterPoints?: boolean;
enabled?: boolean;
minimumClusterSize?: number;
pixelRange?: number;
};
type newClusterCallback = (clusteredEntities: Entity[], cluster: {
billboard: Billboard,
label: Label,
point: PointPrimitive,
}) => void;
}
class EntityCollection {
readonly collectionChanged: Event<EntityCollection.collectionChangedEventCallback>;
id: string;
owner: DataSource | CompositeEntityCollection;
show: boolean;
values: Entity[];
suspendEvents(): void;
resumeEvents(): void;
computeAvailability(): TimeInterval;
add(entity: Entity | Entity.ConstructorOptions): Entity;
remove(entity: Entity): boolean;
contains(entity: Entity): boolean;
removeById(id: any): boolean;
removeAll(): void;
getById(id: any): Entity;
getOrCreateEntity(id: any): Entity;
}
namespace EntityCollection {
type collectionChangedEventCallback = (collection: EntityCollection, added: Entity[], removed: Entity[], changed: Entity[]) => void;
}
class EntityView {
entity: Entity;
scene: Scene;
ellipsoid: Ellipsoid;
boundingSphere: Entity;
static defaultOffset3D: Cartesian3;
constructor(entity: Entity, scene: Scene, ellipsoid?: Ellipsoid, boundingSphere?: BoundingSphere);
update(time: JulianDate): void;
}
class GeoJsonDataSource extends DataSource {
static markerSize: number;
static markerSymbol: string;
static markerColor: Color;
static stroke: Color;
static strokeWidth: number;
static fill: Color;
static crsNames: any;
static crsLinkHrefs: any;
static crsLinkTypes: any;
constructor(name?: string);
load(data: Resource | string | any, options?: GeoJsonDataSource.LoadOptions): Promise<GeoJsonDataSource>;
static load(data: Resource | string | any, options?: GeoJsonDataSource.LoadOptions): Promise<GeoJsonDataSource>;
}
namespace GeoJsonDataSource {
type LoadOptions = {
sourceUri?: string;
markerSize?: number;
markerSymbol?: string;
markerColor?: Color;
stroke?: Color;
strokeWidth?: number;
fill?: Color;
}
}
class GeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class GeometryVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection, primitives: PrimitiveCollection, groundPrimitives: PrimitiveCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class GridMaterialProperty extends MaterialProperty {
cellAlpha: Property;
color: Color;
lineCount: Property;
lineOffset: Property;
lineThickness: Property;
constructor(options?: { color?: Property; cellAlpha?: Property; lineCount?: Property; lineThickness?: Property; lineOffset?: Property });
equals(other?: Property): boolean;
getType(time: JulianDate): string;
getValue(time?: JulianDate, result?: any): any;
}
class GroundPolylineGraphics {
arcType: ArcType;
granularity: boolean;
loop: boolean;
width: number;
constructor(options: GroundPolylineGraphics.ConstructorOptions);
static pack(value: GroundPolylineGraphics, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: GroundPolylineGraphics): GroundPolylineGraphics;
}
namespace GroundPolylineGraphics {
interface ConstructorOptions {
positions: Cartesian3[];
width?: number;
granularity?: number;
loop?: boolean;
arcType?: ArcType;
}
}
abstract class GroundPrimitiveBase {
readonly allowPicking: boolean;
appearance: Appearance;
readonly asynchronous: boolean;
classificationType: ClassificationType;
debugShowBoundingVolume: boolean;
readonly debugShowShadowVolume: boolean;
readonly geometryInstances: GeometryInstance[];
readonly interleave: boolean;
readonly ready: boolean;
readonly readyPromise: Promise<GroundPrimitive>;
readonly releaseGeometryInstances: boolean;
show: boolean;
static initializeTerrainHeights(): Promise<void>;
static isSupported(scene: Scene): boolean;
destroy(): void;
getGeometryInstanceAttributes(id: string): any;
isDestroyed(): boolean;
/** @internal */ update(): void;
}
namespace GroundPrimitiveBase {
interface OptionBase {
geometryInstances?: GeometryInstance[];
appearance?: Appearance;
show?: boolean;
interleave?: boolean;
releaseGeometryInstances?: boolean;
allowPicking?: boolean;
asynchronous?: boolean;
classificationType?: ClassificationType;
debugShowBoundingVolume?: boolean;
debugShowShadowVolume?: boolean;
}
}
class GroundPrimitive {
readonly compressVertices: boolean;
readonly vertexCacheOptimize: boolean;
constructor(options?: GroundPrimitive.ConstructorOptions);
static supportsMaterials(scene: Scene): boolean;
}
namespace GroundPrimitive {
interface ConstructorOptions extends GroundPrimitiveBase.OptionBase {
vertexCacheOptimize?: boolean;
compressVertices?: boolean;
}
}
class GroundPolylinePrimitive extends GroundPrimitiveBase {
constructor(options: GroundPolylinePrimitive.ConstructorOptions);
}
namespace GroundPolylinePrimitive {
interface ConstructorOptions extends GroundPrimitiveBase.OptionBase {
// Adds nothing
}
}
class ImageMaterialProperty extends MaterialProperty {
color: Property;
image: Property;
repeat: Property;
transparent: Property;
constructor(options?: { image?: Property; repeat?: Property });
equals(other?: Property | undefined): boolean;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
}
class KmlDataSource extends DataSource {
readonly refreshEvent: Event<(src: this, url: string) => void>;
readonly unsupportedNodeEvent: Event<KmlDataSource.unsupportedNodeCallback>;
constructor(options: KmlDataSource.ConstructorOptions);
load(data: KmlDataSource.Loadable, options?: KmlDataSource.LoadOptions): Promise<KmlDataSource>;
update(time: JulianDate): boolean;
static load(data: KmlDataSource.Loadable,
options?: KmlDataSource.ConstructorOptions & KmlDataSource.LoadOptions): Promise<KmlDataSource>;
}
namespace KmlDataSource {
type ConstructorOptions = {
camera: Camera;
canvas: HTMLCanvasElement;
ellipsoid?: Ellipsoid;
}
type Loadable = Resource | string | Document | Blob;
type LoadOptions = {
sourceUri?: string | Resource;
clampToGround?: boolean;
}
type unsupportedNodeCallback = (
dataSource: KmlDataSource,
parent: any,
node: any,
entityCollection: EntityCollection,
styleCollection: EntityCollection,
sourceResource: Resource,
uriResolver: any,
) => void;
}
class KmlFeatureData {
author: { name: string; uri: string; email: string };
link: { href: string; hreflang: string; rel: string; type: string; title: string; length: string };
address: string;
phoneNumber: string;
snippet: string;
extendedData: string;
}
class LabelGraphics {
backgroundColor: Property;
backgroundPadding: Property;
readonly definitionChanged: Event;
disableDepthTestDistance: Property;
distanceDisplayCondition: Property;
eyeOffset: Property;
fillColor: Property;
font: Property;
heightReference: Property;
horizontalOrigin: Property;
outlineColor: Property;
outlineWidth: Property;
pixelOffset: Property;
pixelOffsetScaleByDistance: Property;
scale: Property;
scaleByDistance: Property;
show: Property;
showBackground: Property;
style: Property;
text: Property;
translucencyByDistance: Property;
verticalOrigin: Property;
constructor(options?: LabelGraphics.ConstructorOptions);
clone(result?: LabelGraphics): LabelGraphics;
merge(source: LabelGraphics): void;
}
namespace LabelGraphics {
type ConstructorOptions = {
text?: Property | string;
font?: Property | string;
style?: Property | LabelStyle;
fillColor?: Property | Color;
backgroundColor?: Property | Color;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
show?: Property | boolean;
showBackground?: Property | boolean;
scale?: Property | NearFarScalar;
scaleByDistance?: Property | NearFarScalar;
horizontalOrigin?: Property | HorizontalOrigin;
verticalOrigin?: Property | VerticalOrigin;
eyeOffset?: Property | Cartesian2;
pixelOffset?: Property | Cartesian2;
translucencyByDistance?: Property | NearFarScalar;
pixelOffsetScaleByDistance?: Property | NearFarScalar;
disableDepthTestDistance?: Property | number;
}
}
class LabelVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
abstract class MaterialProperty extends Property {
abstract getType(time: JulianDate): string;
}
class ModelGraphics {
clampAnimations: Property;
clippingPlanes: Property;
color: Property;
colorBlendAmount: Property;
colorBlendMode: Property;
readonly definitionChanged: Event;
distanceDisplayCondition: Property;
heightReference: Property;
incrementallyLoadTextures: Property;
maximumScale: Property;
minimumPixelSize: Property;
nodeTransformations: PropertyBag;
runAnimations: Property;
scale: Property;
shadows: Property;
show: Property;
silhouetteColor: Property;
silhouetteSize: Property;
uri: Property;
constructor(options?: ModelGraphics.ConstructorOptions);
clone(result?: ModelGraphics): ModelGraphics;
merge(source: ModelGraphics): void;
}
namespace ModelGraphics {
type ConstructorOptions = {
uri?: string | Resource;
show?: boolean | Property ;
scale?: number;
minimumPixelSize?: number;
maximumScale?: number;
incrementallyLoadTextures?: boolean;
runAnimations?: boolean;
clampAnimations?: boolean;
nodeTransformations?: {[nodeName: string]: TranslationRotationScale};
shadows?: ShadowMode;
heightReference?: HeightReference;
distanceDisplayCondition?: DistanceDisplayCondition;
silhouetteColor?: Color;
silhouetteSize?: number;
color?: Color;
colorBlendMode?: Model.ColorBlendMode;
colorBlendAmount?: number;
clippingPlanes?: ClippingPlaneCollection;
};
}
class ModelVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class PathGraphics {
readonly definitionChanged: Event;
leadTime: Property;
material: MaterialProperty;
resolution: Property;
show: Property;
trailTime: Property;
width: Property;
constructor(options?: PathGraphics.ConstructorOptions);
clone(result?: PathGraphics): PathGraphics;
merge(source: PathGraphics): void;
}
namespace PathGraphics {
type ConstructorOptions = {
leadTime?: Property;
trailTime?: Property;
show?: Property;
width?: Property;
material?: MaterialProperty;
resolution?: Property;
};
}
class PathVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class PointGraphics {
color: Property;
readonly definitionChanged: Event;
disableDepthTestDistance: Property;
distanceDisplayCondition: Property;
heightReference: Property;
outlineColor: Property;
outlineWidth: Property;
pixelSize: Property;
scaleByDistance: Property;
show: Property;
translucencyByDistance: Property;
constructor(options?: PointGraphics.ConstructorOptions);
clone(result?: PointGraphics): PointGraphics;
merge(source: PointGraphics): void;
}
namespace PointGraphics {
type ConstructorOptions = {
color?: Color;
pixelSize?: number;
outlineColor?: Color;
outlineWidth?: number;
show?: Property | boolean;
scaleByDistance?: Property | NearFarScalar;
translucencyByDistance?: Property | NearFarScalar;
heightReference?: HeightReference;
distanceDisplayCondition?: Property | number;
};
}
class PointVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class PolygonGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class PolygonGraphics {
closeBottom: Property;
closeTop: Property;
readonly definitionChanged: Event;
distanceDisplayCondition: Property;
extrudedHeight: Property;
fill: Property;
granularity: Property;
height: Property;
hierarchy: Property;
material: MaterialProperty;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
perPositionHeight: Property;
shadows: Property;
show: Property | boolean;
stRotation: Property;
constructor(options?: PolygonGraphics.ConstructorOptions);
clone(result?: PolygonGraphics): PolygonGraphics;
merge(source: PolygonGraphics): void;
}
namespace PolygonGraphics {
type ConstructorOptions = {
hierarchy?: Property | PolygonHierarchy;
height?: Property | number;
heightReference?: Property | HeightReference;
extrudedHeight?: Property | number;
extrudedHeightReference?: Property | HeightReference;
show?: Property | boolean;
fill?: Property | boolean;
material?: MaterialProperty | Color;
outline?: Property | boolean;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
stRotation?: Property | number;
granularity?: Property | number;
perPositionHeight?: Property | boolean;
closeTop?: Property | boolean;
closeBottom?: Property | boolean;
shadows?: Property | ShadowMode;
distanceDisplayCondition?: Property | DistanceDisplayCondition;
zIndex?: Property | number;
};
}
class PolylineArrowMaterialProperty {
isConstant: boolean;
readonly definitionChanged: Event<(prop: this) => void>;
color: Property;
constructor(color?: Property);
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class PolylineGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class PolylineGlowMaterialProperty {
isConstant: boolean;
readonly definitionChanged: Event<(prop: this) => void>;
color: Property;
glowPower: Property;
constructor(options?: { color?: Property; glowPower?: Property });
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class PolylineGraphics {
arcType: ArcType;
clampToGround: Property;
classificationType: ClassificationType;
readonly definitionChanged: Event;
depthFailMaterial: MaterialProperty;
distanceDisplayCondition: Property;
granularity: Property;
material: MaterialProperty;
positions: Property;
shadows: Property;
show: Property;
width: Property;
zIndex: Property;
constructor(options?: PolylineGraphics.ConstructorOptions);
clone(result?: PolylineGraphics): PolylineGraphics;
merge(source: PolylineGraphics): void;
}
namespace PolylineGraphics {
type ConstructorOptions = {
positions?: Property | Cartesian3[];
arcType?: ArcType;
clampToGround?: Property | boolean;
width?: Property | number;
show?: Property | boolean;
material?: MaterialProperty | Color;
depthFailMaterial?: MaterialProperty | Color;
granularity?: Property | number;
shadows?: Property | ShadowMode;
distanceDisplayCondition?: Property | DistanceDisplayCondition;
classificationType?: Property | ClassificationType;
zIndex?: Property | number;
};
}
class PolylineOutlineMaterialProperty {
isConstant: boolean;
readonly definitionChanged: Event<(prop: this) => void>;
color: Property;
outlineColor: Property;
outlineWidth: Property;
constructor(options?: { color?: Property; outlineColor?: Property; outlineWidth?: Property });
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class PolylineVolumeGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class PolylineVolumeGraphics {
cornerType: Property;
readonly definitionChanged: Event;
fill: Property;
granularity: Property;
material: MaterialProperty;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
positions: Property;
shape: Property;
show: Property;
constructor(options?: PolylineVolumeGraphics.ConstructorOptions);
clone(result?: PolylineVolumeGraphics): PolylineVolumeGraphics;
merge(source: PolylineVolumeGraphics): void;
}
namespace PolylineVolumeGraphics {
type ConstructorOptions = {
positions?: Property | Cartesian3[];
shape?: Property | Cartesian2[];
cornerType?: Property | CornerType;
show?: Property | boolean;
fill?: Property | boolean;
material?: MaterialProperty | Material | Color;
outline?: Property | boolean;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
granularity?: Property | number;
shadows?: Property | ShadowMode;
distanceDisplayCondition?: Property | number;
};
}
class PositionProperty extends Property{
readonly referenceFrame: ReferenceFrame;
equals(other: any): boolean;
getValue(time: JulianDate, result?: Cartesian3): Cartesian3;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
}
class PositionPropertyArray {
isConstant: boolean;
readonly definitionChanged: Event<(prop: this) => void>;
referenceFrame: ReferenceFrame;
constructor(value?: Property[]);
getValue(time?: JulianDate, result?: Cartesian3[]): Cartesian3[];
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
setValue(value: Property[]): void;
equals(other?: Property): boolean;
}
abstract class Property {
readonly definitionChanged: Event<(prop: this) => void>;
readonly isConstant: boolean;
abstract equals(other?: Property): boolean;
abstract getValue(time: JulianDate, result?: any): any;
}
class PropertyArray extends Property {
constructor(value?: Property[]);
getValue(time?: JulianDate, result?: any[]): any[];
setValue(value: Property[]): void;
equals(other?: Property): boolean;
}
interface ObjectLike {
[key: string]: Property | undefined;
}
class PropertyBagBase {
readonly propertyNames: string[];
constructor(value?: object, createPropertyCallback?: Function);
addProperty(propertyName: string, value?: any, createPropertyCallback?: Function): void;
hasProperty(propertyName: string): boolean;
merge(source: Object, createPropertyCallback?: Function): void;
removeProperty(propertyName: string): void;
}
type PropertyBag = ObjectLike & Property & PropertyBagBase;
class RectangleGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class RectangleGraphics {
classificationType: Property;
coordinates: Property;
readonly definitionChanged: Event;
distanceDisplayCondition: Property;
extrudedHeight: Property;
extrudedHeightReference: Property;
fill: Property;
granularity: Property;
height: Property;
heightReference: Property;
material: MaterialProperty;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
rotation: Property;
shadows: Property;
show: Property;
stRotation: Property;
zIndex: Property;
constructor(options?: RectangleGraphics.ConstructorOptions);
clone(result?: RectangleGraphics): RectangleGraphics;
merge(source: RectangleGraphics): void;
}
namespace RectangleGraphics {
interface ConstructorOptions {
coordinates?: Property | Rectangle;
height?: Property | number;
heightReference?: Property | HeightReference;
extrudedHeight?: Property | number;
extrudedHeightReference?: Property | HeightReference;
show?: Property | boolean;
fill?: Property | boolean;
material?: MaterialProperty | Color;
outline?: Property | boolean;
outlineColor?: Property | Color;
outlineWidth?: Property | number;
rotation?: Property | number;
stRotation?: Property | number;
granularity?: Property | number;
shadows?: Property | ShadowMode;
distanceDisplayCondition?: Property | DistanceDisplayCondition;
zIndex?: Property | number;
}
}
class ReferenceProperty extends Property {
readonly referenceFrame: ReferenceFrame;
readonly resolvedProperty: Property;
readonly targetCollection: EntityCollection;
readonly targetId: string;
readonly targetPropertyNames: string[];
constructor(targetCollection: EntityCollection, targetId: string, targetPropertyNames: string[]);
equals(other?: Property): boolean;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
static fromString(targetCollection: Entity, referenceString: string): ReferenceProperty;
}
class SampledPositionProperty extends SampledProperty<Cartesian3> implements PositionProperty {
readonly numberOfDerivatives: number;
readonly referenceFrame: ReferenceFrame;
constructor(referenceFrame?: ReferenceFrame, numberOfDerivatives?: number);
addSample(time: JulianDate, position: Cartesian3, derivatives?: Cartesian3[]): void;
addSamples(times: JulianDate[], positions: Cartesian3[], derivatives?: any[][]): void;
addSamplesPackedArray(packedSamples: number[], epoch?: JulianDate): void;
getValue(time: JulianDate, result?: Cartesian3): Cartesian3;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm; interpolationDegree?: number }): void;
}
class SampledProperty<T extends Packable | number> extends Property {
backwardExtrapolationDuration: number;
backwardExtrapolationType: ExtrapolationType;
readonly derivativeTypes: Type<Packable>[];
forwardExtrapolationDuration: number;
forwardExtrapolationType: ExtrapolationType;
readonly interpolationAlgorithm: InterpolationAlgorithm;
readonly interpolationDegree: number;
readonly type: Type<T>;
constructor(type: T, derivativeTypes?: Type<Packable>[]);
addSample(time: JulianDate, value: T, derivatives?: T[]): void;
addSamples(times: JulianDate[], values: T[], derivativeValues?: any[][]): void;
addSamplesPackedArray(packedSamples: number[], epoch?: JulianDate): void;
equals(other?: Property): boolean;
getValue(time: JulianDate, result?: any): any;
removeSample(time: JulianDate): boolean;
removeSamples(time: TimeInterval): void;
setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm; interpolationDegree?: number }): void;
}
class StripeMaterialProperty extends MaterialProperty {
evenColor: Color;
oddColor: Color;
offset: Property;
orientation: Property;
repeat: number;
constructor(options?: { evenColor?: Property; oddColor?: Property; repeat?: Property; offset?: Property; orientation?: Property });
equals(other?: Property): boolean;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
}
class TimeIntervalCollectionPositionProperty extends TimeIntervalCollectionProperty implements PositionProperty {
readonly referenceFrame: ReferenceFrame;
constructor(referenceFrame?: ReferenceFrame);
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
}
class VelocityOrientationProperty extends Property {
ellipsoid: Property;
position: Property;
constructor(position?: Property, ellipsoid?: Ellipsoid);
getValue(time?: JulianDate, result?: Quaternion): Quaternion;
equals(other?: Property): boolean;
}
class Visualizer {
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class WallGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy(): void;
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class WallGraphics {
readonly definitionChanged: Event;
show: Property;
material: MaterialProperty;
positions: Property;
minimumHeights: Property;
maximumHeights: Property;
granularity: Property;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
constructor(options?: { positions?: Property; maximumHeights?: Property; minimumHeights?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; granularity?: Property });
clone(result?: WallGraphics): WallGraphics;
merge(source: WallGraphics): void;
}
class Appearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
constructor(options?: Appearance.ConstructorOptions);
getFragmentShaderSource(): string;
isTranslucent(): boolean;
getRenderState(): any;
}
namespace Appearance {
interface ConstructorOptions {
translucent?: boolean;
closed?: boolean;
material?: Material;
vertexShaderSource?: string;
fragmentShaderSource?: string;
renderState?: RenderState;
}
}
class ArcGisMapServerImageryProvider extends ImageryProvider {
readonly token: string;
readonly url: string;
readonly usingPrecachedTiles: boolean;
constructor(options: ArcGisMapServerImageryProvider.ConstructorOptions);
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
namespace ArcGisMapServerImageryProvider {
interface ConstructorOptions {
url: Resource | string;
token?: string;
tileDiscardPolicy?: TileDiscardPolicy;
usePreCachedTilesIfAvailable?: boolean;
layers?: string;
enablePickFeatures?: boolean;
rectangle?: Rectangle;
tilingScheme?: TilingScheme;
ellipsoid?: Ellipsoid;
tileWidth?: number;
tileHeight?: number;
maximumLevel?: number;
}
}
class ArcGISTiledElevationTerrainProvider extends TerrainProvider {
constructor(options: {
url: Resource | string;
token?: string;
ellipsoid?: Ellipsoid;
});
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
}
class Billboard {
alignedAxis: Cartesian3;
color: Color;
disableDepthTestDistance: number;
distanceDisplayCondition: DistanceDisplayCondition;
eyeOffset: Cartesian3;
height: number;
heightReference: HeightReference;
horizontalOrigin: HorizontalOrigin;
id: any;
image: string;
pixelOffset: Cartesian2;
pixelOffsetScaleByDistance: NearFarScalar;
position: Cartesian3;
ready: boolean;
rotation: number;
scale: number;
scaleByDistance: NearFarScalar;
show: boolean;
sizeInMeters: boolean;
translucencyByDistance: NearFarScalar;
verticalOrigin: VerticalOrigin;
width: number;
computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
equals(other: Billboard): boolean;
setImage(id: string, image: HTMLImageElement | HTMLCanvasElement | string | Resource | Billboard.CreateImageCallback): void;
setImageSubRegion(id: string, subRegion: BoundingRectangle): void;
}
namespace Billboard {
type CreateImageCallback = (id: string) => HTMLImageElement | HTMLCanvasElement | Promise<HTMLImageElement | HTMLCanvasElement>;
}
class BillboardCollection {
modelMatrix: Matrix4;
debugShowBoundingVolume: boolean;
length: number;
constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean });
add(billboard?: any): Billboard;
remove(billboard: Billboard): boolean;
removeAll(): void;
contains(billboard?: Billboard): boolean;
get(index: number): Billboard;
update(): void;
isDestroyed(): boolean;
destroy(): void;
}
class BingMapsImageryProvider extends ImageryProvider {
readonly url: string;
readonly key: string;
readonly mapStyle: BingMapsStyle;
readonly culture: string;
constructor(options: BingMapsImageryProvider.ConstructorOptions);
static quadKeyToTileXY(quadkey: string): {x: number, y: number, level: number};
static tileXYToQuadKey(x: number, y: number, level: number): string;
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
namespace BingMapsImageryProvider {
type ConstructorOptions = {
url: Resource | string;
key?: string;
tileProtocol?: string;
mapStyle?: BingMapsStyle;
culture?: string;
ellipsoid?: Ellipsoid;
tileDiscardPolicy?: TileDiscardPolicy;
};
}
class Camera {
static DEFAULT_OFFSET: HeadingPitchRange;
static DEFAULT_VIEW_FACTOR: number;
static DEFAULT_VIEW_RECTANGLE: Rectangle;
readonly changed: Event<(areaPercentage: number) => void>;
constrainedAxis: Cartesian3;
defaultLookAmount: number;
defaultMoveAmount: number;
defaultRotateAmount: number;
defaultZoomAmount: number;
direction: Cartesian3;
readonly directionWC: Cartesian3;
frustum: OrthographicFrustum;
readonly heading: number;
readonly inverseTransform: Matrix4;
readonly inverseViewMatrix: Matrix4;
maximumZoomFactor: number;
readonly moveEnd: Event; // Not sure what the signature is for either of these
readonly moveStart: Event;
percentageChanged: number;
readonly pitch: number;
position: Cartesian3;
readonly positionCartographic: Cartographic;
readonly positionWC: Cartesian3;
right: Cartesian3;
readonly rightWC: Cartesian3;
readonly roll: number;
readonly transform: Matrix4;
up: Cartesian3;
readonly upWC: Cartesian3;
readonly viewMatrix: Matrix4;
constructor(scene: Scene);
cameraToWorldCoordinates(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
cameraToWorldCoordinatesPoint(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
cameraToWorldCoordinatesVector(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
clone(): Camera;
computeViewRectangle(ellipsoid?: Ellipsoid, result?: Rectangle): Rectangle;
flyTo(options: { destination: Cartesian3 | Rectangle; orientation?: any; duration?: number; complete?: () => void; cancel?: () => void; endTransform?: Matrix4; convert?: boolean }): void;
flyToBoundingSphere(boundingSphere: BoundingSphere, options?: { duration?: number; offset?: HeadingPitchRange; complete?: () => void; cancel?: () => void; endTransform?: Matrix4 }): void;
getMagnitude(): number;
getPickRay(windowPosition: Cartesian2, result?: Ray): Ray;
getRectangleCameraCoordinates(rectangle: Rectangle, result?: Cartesian3): Cartesian3;
look(axis: Cartesian3, angle?: number): void;
lookAt(target: Cartesian3, offset: Cartesian3 | HeadingPitchRange): void;
lookAtTransform(transform: Matrix4, offset: Cartesian3 | HeadingPitchRange): void;
lookDown(amount?: number): void;
lookLeft(amount?: number): void;
lookRight(amount?: number): void;
lookUp(amount?: number): void;
move(direction: Cartesian3, amount?: number): void;
moveBackward(amount?: number): void;
moveDown(amount?: number): void;
moveForward(amount?: number): void;
moveLeft(amount?: number): void;
moveRight(amount?: number): void;
moveUp(amount?: number): void;
pickEllipsoid(windowPosition: Cartesian2, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3 | undefined;
rotate(axis: Cartesian3, angle?: number): void;
rotateDown(angle?: number): void;
rotateLeft(angle?: number): void;
rotateRight(angle?: number): void;
rotateUp(angle?: number): void;
setView(): void;
twistLeft(amount?: number): void;
twistRight(amount?: number): void;
viewBoundingSphere(boundingSphere: BoundingSphere, offset?: HeadingPitchRange): void;
worldToCameraCoordinates(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
worldToCameraCoordinatesPoint(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
worldToCameraCoordinatesVector(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
zoomIn(amount?: number): void;
zoomOut(amount?: number): void;
}
class CameraEventAggregator {
currentMousePosition: Cartesian2;
anyButtonDown: boolean;
constructor(element?: HTMLCanvasElement);
isMoving(type: CameraEventType, modifier?: KeyboardEventModifier): boolean;
getMovement(type: CameraEventType, modifier?: KeyboardEventModifier): any;
getLastMovement(type: CameraEventType, modifier?: KeyboardEventModifier): any;
isButtonDown(type: CameraEventType, modifier?: KeyboardEventModifier): boolean;
getStartMousePosition(type: CameraEventType, modifier?: KeyboardEventModifier): Cartesian2;
getButtonPressTime(type: CameraEventType, modifier?: KeyboardEventModifier): Date;
getButtonReleaseTime(type: CameraEventType, modifier?: KeyboardEventModifier): Date;
reset(): void;
isDestroyed(): boolean;
destroy(): void;
}
class CreditDisplay {
constructor(container: HTMLElement, delimiter?: string);
addCredit(credit: Credit): void;
addDefaultCredit(credit: Credit): void;
beginFrame(credit: Credit): void;
destroy(): void;
endFrame(credit: Credit): void;
isDestroyed(): boolean;
removeDefaultCredit(credit: Credit): void;
update(): void;
}
interface BoundingVolume { intersectPlane(plane: Plane): Intersect; }
class CullingVolume {
planes: Cartesian4[];
constructor(planes: Cartesian4[]);
computeVisibility(boundingVolume: BoundingVolume): Intersect;
}
class DebugAppearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
attributeName: string;
glslDatatype: string;
constructor(options: { attributeName: string; glslDatatype?: string; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
getFragmentShaderSource(): string;
isTranslucent(): boolean;
getRenderState(): any;
}
class DebugModelMatrixPrimitive {
length: number;
width: number;
show: boolean;
modelMatrix: Matrix4;
id: any;
constructor(options?: { length?: number; width?: number; modelMatrix?: Matrix4; show?: boolean; id?: any });
isDestroyed(): boolean;
destroy(): void;
}
class DiscardMissingTileImagePolicy {
constructor(options: { missingImageUrl: string; pixelsToCheck: Cartesian2[]; disableCheckIfAllPixelsAreTransparent?: boolean });
isReady(): boolean;
shouldDiscardImage(image: HTMLImageElement): boolean;
}
class EllipsoidPrimitive {
center: Cartesian3;
radii: Cartesian3;
modelMatrix: Matrix4;
show: boolean;
material: Material;
id: any;
debugShowBoundingVolume: boolean;
constructor(options?: { center?: Cartesian3; radii?: Cartesian3; modelMatrix?: Matrix4; show?: boolean; material?: Material; id?: any; debugShowBoundingVolume?: boolean });
update(): void;
isDestroyed(): boolean;
destroy(): void;
}
class EllipsoidSurfaceAppearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
vertexFormat: VertexFormat;
flat: boolean;
faceForward: boolean;
aboveGround: boolean;
static VERTEX_FORMAT: VertexFormat;
constructor(options?: { flat?: boolean; faceForward?: boolean; translucent?: boolean; aboveGround?: boolean; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
getFragmentShaderSource(): void;
isTranslucent(): boolean;
getRenderState(): any;
}
class FrameRateMonitor {
static defaultSettings: Object;
lastFramesPerSecond: number;
readonly lowFrameRate: Event<(scene: Scene, fps: number) => void>;
minimumFrameRateAfterWarmup: number;
minimumFrameRateDuringWarmup: number;
readonly nominalFrameRate: Event<(scene: Scene, fps: number) => void>;
quietPeriod: number;
samplingWindow: number;
scene: Scene;
warmupPeriod: number;
constructor(options?: { scene: Scene; samplingWindow?: number; quietPeriod?: number; warmupPeriod?: number; minimumFrameRateDuringWarmup?: number; minimumFrameRateAfterWarmup?: number });
static fromScene(scene: Scene): FrameRateMonitor;
destroy(): void;
isDestroyed(): boolean;
pause(): void;
unpause(): void;
}
class GetFeatureInfoFormat {
constructor(type: string, format?: string);
}
class Globe {
atmosphereBrightnessShift : number;
atmosphereHueShift: number;
atmosphereSaturationShift : number;
baseColor: Color;
cartographicLimitRectangle?: Rectangle;
clippingPlanes: ClippingPlaneCollection;
depthTestAgainstTerrain: boolean;
ellipsoid: Ellipsoid;
enableLighting: boolean;
imageryLayers: ImageryLayerCollection;
readonly imageryLayersUpdatedEvent: Event;
lightingFadeInDistance: number;
lightingFadeOutDistance: number;
material: Material;
maximumScreenSpaceError: number;
nightFadeInDistance: number;
nightFadeOutDistance: number;
oceanNormalMapUrl: string;
shadows: ShadowMode;
show: boolean;
showGroundAtmosphere: boolean;
showWaterEffect: boolean;
terrainProvider: TerrainProvider;
readonly terrainProviderChanged: Event<(provider: TerrainProvider) => void>;
tileCacheSize: number;
readonly tileLoadedEvent: Event;
readonly tileLoadProgressEvent: Event<(length: number) => void>;
readonly tilesLoaded: boolean;
constructor(ellipsoid?: Ellipsoid);
destroy(): void;
getHeight(cartographic: Cartographic): number;
isDestroyed(): boolean;
pick(ray: Ray, scene: Scene, result?: Cartesian3): Cartesian3 | undefined;
}
class GoogleEarthEnterpriseMetadata {
constructor(resourceOrUrl: Resource | string);
imageryPresent: boolean;
key: ArrayBuffer;
negativeAltitudeExponentBias: number;
negativeAltitudeThreshold: number;
protoImagery: boolean;
providers: {[id: string]: string};
readonly proxy: Proxy;
readonly readyPromise: Promise<boolean>;
readonly resource: Resource;
terrainPresent: boolean;
readonly url: string;
static quadKeyToTileXY(quadkey: string): {x: number, y: number, level: number};
static tileXYToQuadKey(x: number, y: number, level: number): string;
}
/* Not an ImageryProvider (!!!) */
class GoogleEarthEnterpriseImageryProvider {
readonly credit: Credit;
readonly errorEvent: Event<(err: TileProviderError) => void>;
readonly hasAlphaChannel: boolean;
readonly maximumLevel: number;
readonly minimumLevel: number;
readonly proxy: Proxy;
readonly ready: boolean;
readonly readyPromise: Promise<boolean>;
readonly rectangle: Rectangle;
readonly tileDiscardPolicy: TileDiscardPolicy;
readonly tileHeight: number;
readonly tileWidth: number;
readonly tilingScheme: TilingScheme;
readonly url: string;
constructor(options: GoogleEarthEnterpriseImageryProvider.ConstructorOptions);
getTileCredits(x: number, y: number, level: number): Credit[];
requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}
namespace GoogleEarthEnterpriseImageryProvider {
type ConstructorOptions = {
url?: string;
metadata?: GoogleEarthEnterpriseMetadata;
ellipsoid?: Ellipsoid;
tileDiscardPolicy?: TileDiscardPolicy;
credit?: Credit | string;
};
}
/* Not an ImageryProvider (!!!) */
class GoogleEarthEnterpriseMapsProvider {
constructor(options: GoogleEarthEnterpriseMapsProvider.ConstructorOptions);
readonly channel: number;
readonly credit: Credit;
defaultGamma: number;
readonly errorEvent: Event<(err: TileProviderError) => void>;
readonly hasAlphaChannel: boolean;
readonly maximumLevel: number;
readonly minimumLevel: number;
readonly path: string;
readonly proxy: Proxy;
readonly ready: boolean;
readonly readyPromise: Promise<boolean>;
readonly rectangle: Rectangle;
readonly requestType: string;
readonly tileDiscardPolicy: TileDiscardPolicy;
readonly tileHeight: number;
readonly tileWidth: number;
readonly tilingScheme: TilingScheme;
readonly url: string;
readonly version: number;
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
}
namespace GoogleEarthEnterpriseMapsProvider {
type ConstructorOptions = {
url: Resource | string;
channel: number;
path?: string;
maximumLevel?: number;
tileDiscardPolicy?: TileDiscardPolicy;
ellipsoid?: Ellipsoid;
};
}
class GoogleEarthEnterpriseTerrainProvider extends TerrainProvider {
constructor(options: {
url: Resource | string;
ellipsoid?: Ellipsoid;
credit?: Credit | string;
});
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<TerrainData>;
}
class GridImageryProvider extends ImageryProvider{
constructor(options?: {
tilingScheme?: TilingScheme;
ellipsoid?: Ellipsoid;
cells?: number;
color?: Color;
glowColor?: Color;
glowWidth?: number;
tileWidth?: number;
tileHeight?: number;
canvasSize?: number;
backgroundColor?: Color;
});
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
class HeadingPitchRange {
heading: number;
pitch: number;
range: number;
constructor(heading?: number, pitch?: number, range?: number);
static clone(hpr: HeadingPitchRange, result?: HeadingPitchRange): HeadingPitchRange;
}
class HeadingPitchRoll {
heading: number;
pitch: number;
roll: number;
constructor(heading?: number, pitch?: number, roll?: number);
static clone(hpr: HeadingPitchRoll, result?: HeadingPitchRoll): HeadingPitchRoll;
static equals(left: HeadingPitchRoll, right: HeadingPitchRoll): boolean;
static fromDegrees(heading: number, pitch: number, roll: number, result?: HeadingPitchRoll): HeadingPitchRoll;
static fromQuaternion(quaternion: Quaternion, result?: HeadingPitchRoll): HeadingPitchRoll;
clone(result?: HeadingPitchRoll): HeadingPitchRoll;
equals(right: HeadingPitchRoll): boolean;
}
class ImageryLayer {
alpha: number;
brightness: number;
contrast: number;
hue: number;
saturation: number;
gamma: number;
show: boolean;
imageryProvider: ImageryProvider;
rectangle: Rectangle;
static DEFAULT_BRIGHTNESS: number;
static DEFAULT_CONTRAST: number;
static DEFAULT_HUE: number;
static DEFAULT_SATURATION: number;
static DEFAULT_GAMMA: number;
constructor(imageryProvider: ImageryProvider, options?: { rectangle?: Rectangle; alpha?: number | Function; brightness?: number | Function; contrast?: number | Function; hue?: number | Function; saturation?: number | Function; gamma?: number | Function; show?: boolean; maximumAnisotropy?: number; minimumTerrainLevel?: number; maximumTerrainLevel?: number });
isBaseLayer(): boolean;
isDestroyed(): boolean;
destroy(): void;
}
class ImageryLayerCollection {
readonly layerAdded: Event<(layer: ImageryLayer, idx: number) => void>;
readonly layerRemoved: Event<(layer: ImageryLayer, newIndex: number, oldIndex: number) => void>;
readonly layerMoved: Event<(layer: ImageryLayer, idx: number) => void>;
readonly layerShownOrHidden: Event<(layer: ImageryLayer, idx: number, showing: boolean) => void>;
length: number;
add(layer: ImageryLayer, index?: number): void;
addImageryProvider(imageryProvider: ImageryProvider, index?: number): ImageryLayer;
contains(layer: ImageryLayer): boolean;
destroy(): void;
get(index: number): ImageryLayer;
indexOf(layer: ImageryLayer): number;
isDestroyed(): boolean;
lower(layer: ImageryLayer): void;
lowerToBottom(layer: ImageryLayer): void;
pickImageryLayerFeatures(ray: Ray, scene: Scene): Promise<ImageryLayerFeatureInfo[]>;
raise(layer: ImageryLayer): void;
raiseToTop(layer: ImageryLayer): void;
remove(layer: ImageryLayer, destroy?: boolean): boolean;
removeAll(destroy?: boolean): void;
}
class ImageryLayerFeatureInfo {
name: string;
description: string;
position: Cartographic;
data: any;
configureNameFromProperties(properties: any): void;
configureDescriptionFromProperties(properties: any): void;
}
abstract class ImageryProvider {
readonly credit: Credit;
// These exist in the "interface" class but aren't implemented in any subclasses, since Cesium doesn't actually use inheritance.
// defaultAlpha: number;
// defaultBrightness: number;
// defaultContrast: number;
// defaultGamma: number;
// defaultHue: number;
// defaultMagnificationFilter: TextureMagnificationFilter;
// defaultMinificationFilter: TextureMinificationFilter;
// defaultSaturation: number;
readonly errorEvent: Event<(err: TileProviderError) => void>;
readonly hasAlphaChannel: boolean;
readonly maximumLevel: number;
readonly minimumLevel: number;
readonly proxy: Proxy;
readonly ready: boolean;
readonly readyPromise: Promise<boolean>;
readonly rectangle: Rectangle;
readonly tileDiscardPolicy: TileDiscardPolicy;
readonly tileHeight: number;
readonly tileWidth: number;
readonly tilingScheme: TilingScheme;
static loadImage(imageryProvider: ImageryProvider, url: string): Promise<HTMLImageElement | HTMLCanvasElement>;
abstract getTileCredits(x: number, y: number, level: number): Credit[];
abstract pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
abstract requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
class TextureMagnificationFilter {
// TODO
}
class TextureMinificationFilter {
// TODO
}
class Label {
backgroundColor: Color;
backgroundPadding: Cartesian2;
disableDepthTestDistance: number;
distanceDisplayCondition: DistanceDisplayCondition;
eyeOffset: Cartesian3;
fillColor: Color;
font: string;
heightReference: HeightReference;
horizontalOrigin: HorizontalOrigin;
id: any;
outlineColor: Color;
outlineWidth: number;
pixelOffset: Cartesian2;
pixelOffsetScaleByDistance: NearFarScalar;
position: Cartesian3;
scale: number;
scaleByDistance: NearFarScalar;
show: boolean;
showBackground: boolean;
style: LabelStyle;
text: string;
translucencyByDistance: NearFarScalar;
verticalOrigin: VerticalOrigin;
static enableRightToLeftDetection: boolean;
computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
equals(other: Label): boolean;
isDestroyed(): boolean;
}
class LabelCollection {
modelMatrix: Matrix4;
debugShowBoundingVolume: boolean;
length: number;
constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean });
add(options?: any): Label;
remove(label: Label): boolean;
removeAll(): void;
contains(label: Label): boolean;
get(index: number): Label;
isDestroyed(): boolean;
destroy(): void;
}
class Material {
type: string;
shaderSource: string;
materials: any;
uniforms: any;
translucent: boolean | Function;
static DefaultImageId: string;
static DefaultCubeMapId: string;
static ColorType: string;
static ImageType: string;
static DiffuseMapType: string;
static AlphaMapType: string;
static SpecularMapType: string;
static EmissionMapType: string;
static BumpMapType: string;
static NormalMapType: string;
static GridType: string;
static StripeType: string;
static CheckerboardType: string;
static DotType: string;
static WaterType: string;
static RimLightingType: string;
static FadeType: string;
static PolylineArrowType: string;
static PolylineGlowType: string;
static PolylineOutlineType: string;
constructor(options?: { strict?: boolean; translucent?: boolean | Function; fabric: any });
isTranslucent(): boolean;
isDestroyed(): boolean;
destroy(): void;
static fromType(type: string, uniforms?: any): Material;
}
class MaterialAppearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
materialSupport: MaterialAppearance.MaterialSupport;
vertexFormat: VertexFormat;
flat: boolean;
faceForward: boolean;
constructor(options?: MaterialAppearance.ConstructorOptions);
getFragmentShaderSource(): string;
isTranslucent(): boolean;
getRenderState(): any;
}
namespace MaterialAppearance {
type ConstructorOptions = {
flat?: boolean;
faceForward?: boolean;
translucent?: boolean;
closed?: boolean;
materialSupport?: MaterialAppearance.MaterialSupport;
material?: Material;
vertexShaderSource?: string;
fragmentShaderSource?: string;
renderState?: RenderState
};
enum MaterialSupport {
BASIC,
TEXTURED,
ALL
}
}
class Model {
show: boolean;
modelMatrix: Matrix4;
scale: number;
minimumPixelSize: number;
id: any;
activeAnimations: ModelAnimationCollection;
debugShowBoundingVolume: boolean;
debugWireframe: boolean;
gltf: any;
basePath: string;
boundingSphere: BoundingSphere;
ready: boolean;
readyPromise: Promise<Model>;
asynchronous: boolean;
allowPicking: boolean;
constructor(options?: Model.OptionBase & {gltf?: Object | ArrayBuffer | Uint8Array;});
getNode(name: string): ModelNode;
getMesh(name: string): ModelMesh;
getMaterial(name: string): ModelMaterial;
update(): void;
isDestroyed(): boolean;
destroy(): void;
static fromGltf(options: Model.OptionBase & {url: Resource | string;}): Model;
}
namespace Model {
type OptionBase = {
basePath?: Resource | string;
show?: boolean;
modelMatrix?: Matrix4;
scale?: number;
minimumPixelSize?: number;
maximumScale?: number;
id?: any;
allowPicking?: boolean;
incrementallyLoadTextures?: boolean;
asynchronous?: boolean;
clampAnimations?: boolean;
shadows?: ShadowMode;
debugShowBoundingVolume?: boolean;
debugWireframe?: boolean;
heightReference?: HeightReference;
scene?: Scene;
distanceDisplayCondition?: DistanceDisplayCondition;
color?: Color;
colorBlendMode?: ColorBlendMode;
colorBlendAmount?: number;
silhouetteColor?: Color;
silhouetteSize?: number;
clippingPlanes?: ClippingPlaneCollection;
};
enum ColorBlendMode {
HIGHLIGHT,
REPLACE,
MIX,
}
}
class ModelAnimation {
readonly delay: number;
readonly loop: ModelAnimationLoop;
readonly multiplier: number;
readonly name: string;
removeOnStop: boolean;
readonly reverse: boolean;
readonly start: Event<(model: Model, animation: this) => void>;
readonly startTime: JulianDate;
readonly stop: Event<(model: Model, animation: this) => void>;
readonly stopTime: JulianDate;
readonly update: Event<(model: Model, animation: this, time: number) => void>;
/** @private */ constructor();
}
class ModelAnimationCollection {
readonly animationAdded: Event<(model: Model, animation: this) => void>;
readonly animationRemoved: Event<(model: Model, animation: this) => void>;
readonly length: number;
add(options: ModelAnimationCollection.ConstructorOptions): ModelAnimation;
addAll(options: ModelAnimationCollection.ConstructorOptions): ModelAnimation[];
contains(animation: ModelAnimation): boolean;
get(index: number): ModelAnimation | undefined;
remove(animation: ModelAnimation): boolean;
removeAll(): void;
/** @private */ constructor();
}
namespace ModelAnimationCollection {
interface ConstructorOptions {
name?: string;
index?: number;
startTime?: JulianDate;
delay?: number;
stopTime?: JulianDate;
removeOnStop?: boolean;
multiplier?: number;
reverse?: boolean;
loop?: ModelAnimationLoop;
}
}
class ModelMaterial {
name: string;
id: string;
setValue(name: string, value?: any): void;
getValue(name: string): any;
}
class ModelMesh {
name: string;
id: string;
materials: ModelMaterial[];
}
class ModelNode {
name: string;
id: string;
show: boolean;
matrix: Matrix4;
}
class Moon {
show: boolean;
textureUrl: string;
onlySunLighting: boolean;
ellipsoid: Ellipsoid;
constructor(options?: { show?: boolean; textureUrl?: string; ellipsoid?: Ellipsoid; onlySunLighting?: boolean });
isDestroyed(): boolean;
destroy(): void;
}
class NeverTileDiscardPolicy {
isReady(): boolean;
shouldDiscardImage(image: HTMLImageElement | Promise<HTMLImageElement>): Promise<boolean>;
}
class OpenStreetMapImageryProvider extends UrlTemplateImageryProvider {
constructor(options?: OpenStreetMapImageryProvider.ConstructorOptions);
}
namespace OpenStreetMapImageryProvider {
interface ConstructorOptions {
url?: string;
fileExtension?: string;
rectangle?: Rectangle;
minimumLevel?: number;
maximumLevel?: number;
ellipsoid?: Ellipsoid;
credit?: Credit | string;
}
}
class OrthographicFrustum {
aspectRatio: number;
far: number;
near: number;
readonly projectionMatrix: Matrix4;
width: number;
static packedLength: number;
constructor(options?: {width?: number, aspectRatio?: number, near?: number, far?: number});
clone(result?: OrthographicFrustum): OrthographicFrustum;
computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
equals(other?: OrthographicFrustum): boolean;
equalsEpsilon(other: OrthographicFrustum, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
getPixelDimensions(drawingBufferWidth: number, drawingBufferHeight: number, distance: number, result: Cartesian2): Cartesian2;
static pack(value: OrthographicFrustum, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: OrthographicFrustum): OrthographicFrustum;
}
class OrthographicOffCenterFrustum {
bottom: number;
far: number;
left: number;
near: number;
readonly projectionMatrix: Matrix4;
right: number;
top: number;
constructor(options?: {left?: number, right?: number, top?: number, bottom?: number, near?: number, far?: number});
clone(result?: OrthographicOffCenterFrustum): OrthographicOffCenterFrustum;
computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
equals(other?: OrthographicOffCenterFrustum): boolean;
equalsEpsilon(other: OrthographicOffCenterFrustum, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
getPixelDimensions(drawingBufferWidth: number, drawingBufferHeight: number, distance: number, result: Cartesian2): Cartesian2;
}
class PerInstanceColorAppearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
vertexFormat: VertexFormat;
flat: boolean;
faceForward: boolean;
static VERTEX_FORMAT: VertexFormat;
static FLAT_VERTEX_FORMAT: VertexFormat;
constructor(options?: { flat?: boolean; faceForward?: boolean; translucent?: boolean; closed?: boolean; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
getFragmentShaderSource(): void;
isTranslucent(): boolean;
getRenderState(): any;
}
class PerspectiveFrustum {
fov: number;
aspectRatio: number;
near: number;
far: number;
projectionMatrix: Matrix4;
infiniteProjectionMatrix: Matrix4;
fovy: number;
computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
getPixelSize(drawingBufferDimensions: Cartesian2, distance?: number, result?: Cartesian2): Cartesian2;
clone(result?: PerspectiveFrustum): PerspectiveFrustum;
equals(other?: PerspectiveFrustum): boolean;
equalsEpsilon(other: PerspectiveFrustum, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
}
class PerspectiveOffCenterFrustum {
bottom: number;
far: number;
readonly infiniteProjectionMatrix: Matrix4;
left: number;
near: number;
readonly projectionMatrix: Matrix4;
right: number;
top: number;
constructor(options?: {left?: number, right?: number, top?: number, bottom?: number, near?: number, far?: number});
clone(result?: PerspectiveOffCenterFrustum): PerspectiveOffCenterFrustum;
computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
equals(other?: PerspectiveOffCenterFrustum): boolean;
equalsEpsilon(other: PerspectiveOffCenterFrustum, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
getPixelDimensions(drawingBufferWidth: number, drawingBufferHeight: number, distance: number, result: Cartesian2): Cartesian2;
}
class PointPrimitive {
show: boolean;
position: Cartesian3;
scaleByDistance: NearFarScalar;
translucencyByDistance: NearFarScalar;
pixelSize: number;
color: Color;
outlineColor: Color;
outlineWidth: number;
id: any;
computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
equals(other: PointPrimitive): boolean;
}
class PointPrimitiveCollection {
modelMatrix: Matrix4;
debugShowBoundingVolume: boolean;
length: number;
constructor(options?: {
modelMatrix?: Matrix4;
debugShowBoundingVolume?: boolean;
blendOption?: BlendOption;
});
add(pointPrimitive?: PointPrimitiveCollection.PointOptions): PointPrimitive;
remove(pointPrimitive: PointPrimitive): boolean;
removeAll(): void;
contains(pointPrimitive?: PointPrimitive): boolean;
get(index: number): PointPrimitive;
isDestroyed(): boolean;
destroy(): void;
}
namespace PointPrimitiveCollection {
interface PointOptions {
show?: boolean,
position?: Cartesian3,
pixelSize?: number,
color?: Color,
outlineColor?: Color,
outlineWidth?: number,
id?: string;
}
}
enum BlendOption {
OPAQUE, OPAQUE_AND_TRANSLUCENT, TRANSLUCENT
}
class Polygon {
ellipsoid: Ellipsoid;
granularity: number;
height: number;
textureRotationAngle: number;
show: boolean;
material: Material;
id: any;
asynchronous: boolean;
debugShowBoundingVolume: boolean;
positions: Cartesian3[];
constructor(options?: { ellipsoid?: Ellipsoid; positions?: Cartesian3[]; polygonHierarchy?: any; granularity?: number; height?: number; textureRotationAngle?: number; show?: boolean; material?: Material; id?: any; asynchronous?: boolean; debugShowBoundingVolume?: boolean });
configureFromPolygonHierarchy(hierarchy: any): void;
update(): void;
isDestroyed(): boolean;
destroy(): void;
}
class Polyline {
show: boolean;
positions: Cartesian3[];
material: Material;
width: number;
loop: boolean;
id: any;
constructor(options?: { show?: boolean; width?: number; loop?: boolean; material?: Material; positions?: Cartesian3[]; id?: any });
}
class PolylineCollection {
modelMatrix: Matrix4;
debugShowBoundingVolume: boolean;
length: number;
constructor(options?: { modelMatrix?: Matrix4; debugShowBoundingVolume?: boolean });
add(polyline?: any): Polyline;
remove(polyline: Polyline): boolean;
removeAll(): void;
contains(polyline: Polyline): boolean;
get(index: number): Polyline;
isDestroyed(): boolean;
destroy(): void;
}
class PolylineColorAppearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
vertexFormat: VertexFormat;
static VERTEX_FORMAT: VertexFormat;
constructor(options?: { translucent?: boolean; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
getFragmentShaderSource(): void;
isTranslucent(): boolean;
getRenderState(): any;
}
class PolylineMaterialAppearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
vertexFormat: VertexFormat;
static VERTEX_FORMAT: VertexFormat;
constructor(options?: { translucent?: boolean; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
getFragmentShaderSource(): void;
isTranslucent(): boolean;
getRenderState(): any;
}
class PostProcessStage {
readonly clearColor: Color;
enabled: boolean;
readonly forcePowerOfTwo: number;
readonly fragmentShader: string;
readonly name: string;
readonly pixelDatatype: PixelDatatype;
readonly pixelFormat: PixelFormat;
readonly ready: boolean;
readonly sampleMode: PostProcessStageSampleMode;
readonly scissorRectangle: BoundingRectangle;
selected: any[];
readonly textureScale: number;
readonly uniforms: {[key: string]: string | HTMLCanvasElement | HTMLImageElement};
destroy(): void;
isDestroyed(): boolean;
constructor(options: PostProcessStage.ConstructorOptions);
}
namespace PostProcessStage {
interface ConstructorOptions {
fragmentShader: string;
uniforms?: {[key: string]: string | HTMLCanvasElement | HTMLImageElement};
textureScale?: number;
forcePowerOfTwo?: number;
sampleMode?: PostProcessStageSampleMode;
pixelFormat?: PixelFormat;
pixelDatatype?: PixelDatatype;
clearColor?: Color;
scissorRectangle?: BoundingRectangle;
name?: string;
}
}
// TODO
type PixelDatatype = any;
class PostProcessStageCollection {
readonly ambientOcclusion: PostProcessStageComposite;
readonly bloom: PostProcessStageComposite;
readonly fxaa: PostProcessStage;
readonly length: number;
readonly ready: boolean;
add(stage: PostProcessStage | PostProcessStageComposite): PostProcessStage | PostProcessStageComposite;
contains(stage: PostProcessStage | PostProcessStageComposite): boolean;
destroy(): void;
get(index: number): PostProcessStage | PostProcessStageComposite;
isDestroyed(): boolean;
remove(stage: PostProcessStage | PostProcessStageComposite): boolean;
removeAll(): void;
}
class PostProcessStageComposite {
enabled: boolean;
readonly inputPreviousStageTexture: boolean;
readonly length: number;
readonly name: string;
readonly ready: boolean;
selected: any[];
readonly uniforms: {[key: string]: string | HTMLCanvasElement | HTMLImageElement};
destroy(): void;
get(index: number): PostProcessStage | PostProcessStageComposite;
isDestroyed(): boolean;
}
namespace PostProcessStageComposite {
interface ConstructorOptions {
stages: PostProcessStage[];
inputPreviousStageTexture?: boolean;
name?: string;
uniforms?: {[key: string]: string | HTMLCanvasElement | HTMLImageElement};
}
}
namespace PostProcessStageLibrary {
function createBlackAndWhiteStage(): PostProcessStage;
function createBlurStage(): PostProcessStage;
function createBrightnessStage(): PostProcessStage;
function createDepthOfFieldStage(): PostProcessStage;
function createEdgeDetectionStage(): PostProcessStage;
function createLensFlareStage(): PostProcessStage;
function createNightVisionStage(): PostProcessStage;
function createSilhouetteStage(): PostProcessStage;
function isAmbientOcclusionSupported(scene: Scene): boolean;
function isDepthOfFieldSupported(scene: Scene): boolean;
function isEdgeDetectionSupported(scene: Scene): boolean;
function isSilhouetteSupported(scene: Scene): boolean;
}
enum PostProcessStageSampleMode { LINEAR, NEAREST }
class Primitive {
geometryInstances: any[];
appearance: Appearance;
modelMatrix: Matrix4;
show: boolean;
cull: boolean;
debugShowBoundingVolume: boolean;
vertexCacheOptimize: boolean;
interleave: boolean;
releaseGeometryInstances: boolean;
allowPicking: boolean;
asynchronous: boolean;
compressVertices: boolean;
ready: boolean;
readyPromise: Promise<Primitive>;
constructor(options?: { geometryInstances?: any[] | GeometryInstance; appearance?: Appearance; show?: boolean; modelMatrix?: Matrix4; vertexCacheOptimize?: boolean; interleave?: boolean; compressVertices?: boolean; releaseGeometryInstances?: boolean; allowPicking?: boolean; cull?: boolean; asynchronous?: boolean; debugShowBoundingVolume?: boolean });
update(): void;
getGeometryInstanceAttributes(id: any): any;
isDestroyed(): boolean;
destroy(): void;
}
class PrimitiveCollection {
show: boolean;
destroyPrimitives: boolean;
length: number;
constructor(options?: { show?: boolean; destroyPrimitives?: boolean });
add(primitive: any, index?: number): any;
remove(primitive?: any): boolean;
removeAll(): void;
contains(primitive?: any): boolean;
raise(primitive?: any): void;
raiseToTop(primitive?: any): void;
lower(primitive?: any): void;
lowerToBottom(primitive?: any): void;
get(index: number): any;
isDestroyed(): boolean;
destroy(): void;
}
class RectanglePrimitive {
ellipsoid: Ellipsoid;
rectangle: Rectangle;
granularity: number;
height: number;
rotation: number;
textureRotationAngle: number;
show: boolean;
material: Material;
id: any;
asynchronous: boolean;
debugShowBoundingVolume: boolean;
constructor(options?: { ellipsoid?: Ellipsoid; rectangle?: Rectangle; granularity?: number; height?: number; rotation?: number; textureRotationAngle?: number; show?: boolean; material?: Material; id?: any; asynchronous?: boolean; debugShowBoundingVolume?: boolean });
update(): void;
isDestroyed(): boolean;
destroy(): void;
}
class Fog {
density: number;
enabled: boolean;
screenSpaceErrorFactor: number;
}
class Scene {
backgroundColor: Color;
readonly camera: Camera;
readonly canvas: HTMLCanvasElement;
readonly clampToHeightSupported: boolean;
completeMorphOnUserInput: boolean;
debugCommandFilter: Function;
readonly debugFrustumStatistics: any;
debugShowCommands: boolean;
debugShowDepthFrustum: boolean;
debugShowFramesPerSecond: boolean;
debugShowFrustumPlanes: boolean;
debugShowFrustums: boolean;
debugShowGlobeDepth: boolean;
readonly drawingBufferHeight: number;
readonly drawingBufferWidth: number;
eyeSeparation: number;
farToNearRatio: number;
focalLength: number;
fog: Fog;
globe: Globe;
readonly groundPrimitives: PrimitiveCollection;
highDynamicRange: boolean;
readonly highDynamicRangeSupported: boolean;
readonly id: string;
readonly imageryLayers: ImageryLayerCollection;
imagerySplitPosition: number;
invertClassification: boolean;
invertClassificationColor: Color;
readonly invertClassificationSupported: boolean;
readonly lastRenderTime: JulianDate;
logarithmicDepthBuffer: boolean;
logarithmicDepthFarToNearRatio: number;
mapMode2D: boolean;
readonly mapProjection: MapProjection;
readonly maximumAliasedLineWidth: number;
readonly maximumCubeMapSize: number;
maximumRenderTimeChange: number;
minimumDisableDepthTestDistance: number;
mode: SceneMode;
moon: Moon;
readonly morphComplete: Event;
readonly morphStart: Event;
morphTime: number;
nearToFarDistance2D: number;
readonly orderIndependentTranslucency: boolean;
readonly pickPositionSupported: boolean;
pickTranslucentDepth: boolean;
postProcessStages: PostProcessStageCollection;
readonly postRender: Event<(scene: this, time: JulianDate) => void>;
readonly postUpdate: Event<(scene: this, time: JulianDate) => void>;
readonly preRender: Event<(scene: this, time: JulianDate) => void>;
readonly preUpdate: Event<(scene: this, time: JulianDate) => void>;
readonly primitives: PrimitiveCollection;
readonly renderError: Event<(scene: this, err: any) => void>;
requestRenderMode: boolean;
rethrowRenderErrors: boolean;
readonly sampleHeightSupported: boolean;
readonly scene3DOnly: boolean;
readonly screenSpaceCameraController: ScreenSpaceCameraController;
shadowMap: ShadowMap;
skyAtmosphere: SkyAtmosphere;
skyBox: SkyBox;
sun: Sun;
sunBloom: boolean;
terrainExaggeration: number;
terrainProvider: TerrainProvider;
readonly terrainProviderChanged: Event;
useDepthPicking: boolean;
useWebVR: boolean;
constructor(options?: Scene.ConstructorOptions);
cartesianToCanvasCoordinates(position: Cartesian3, result?: Cartesian2): Cartesian2;
clampToHeight(cartesian: Cartesian3, objectsToExclude?: any[], width?: number, result?: Cartesian3): Cartesian3;
clampToHeightMostDetailed(cartesians: Cartesian3[], objectsToExclude?: any[], width?: number): Promise<Cartesian3[]>;
completeMorph(): void;
destroy(): void;
drillPick(windowPosition: Cartesian2, limit?: number, width?: number, height?: number): Scene.PickResult[];
getCompressedTextureFormatSupported(format: string): boolean;
isDestroyed(): boolean;
morphTo2D(duration?: number): void;
morphTo3D(duration?: number): void;
morphToColumbusView(duration?: number): void;
pick(windowPosition: Cartesian2, width?: number, height?: number): Scene.PickResult;
pickPosition(windowPosition: Cartesian2, result?: Cartesian3): Cartesian3;
requestRender(): void;
sampleHeight(position: Cartographic, objectsToExclude?: any[], width?: number): number;
sampleHeightMostDetailed(positions: Cartographic[], objectsToExclude?: any[], width?: number): Promise<number[]>;
}
namespace Scene {
type ConstructorOptions = {
canvas: HTMLCanvasElement;
contextOptions?: any;
creditContainer?: Element;
creditViewport?: Element;
mapProjection?: MapProjection;
orderIndependentTranslucency?: boolean;
scene3DOnly?: boolean;
terrainExaggeration?: number;
shadows?: boolean;
mapMode2D: MapMode2D;
requestRenderMode?: boolean;
maximumRenderTimeChange?: number;
};
enum MapMode2D {
INFINITE_SCROLL,
ROTATE,
}
interface PickResult {
// If the pick is a cluster, `id` can be an array
id: Entity | Entity[];
// I think this will be one of the "main" Entity fields:
// WhateverGraphics, Billboard, Label, etc
primitive: any;
}
}
class ScreenSpaceCameraController {
enableInputs: boolean;
enableTranslate: boolean;
enableZoom: boolean;
enableRotate: boolean;
enableTilt: boolean;
enableLook: boolean;
inertiaSpin: number;
inertiaTranslate: number;
inertiaZoom: number;
maximumMovementRatio: number;
bounceAnimationTime: number;
minimumZoomDistance: number;
maximumZoomDistance: number;
translateEventTypes: CameraEventType | any[];
zoomEventTypes: CameraEventType | any[];
rotateEventTypes: CameraEventType | any[];
tiltEventTypes: CameraEventType | any[];
lookEventTypes: CameraEventType | any[];
minimumPickingTerrainHeight: number;
minimumCollisionTerrainHeight: number;
minimumTrackBallHeight: number;
enableCollisionDetection: boolean;
constructor(scene: Scene);
isDestroyed(): boolean;
destroy(): void;
}
class ShadowMap {
darkness: number;
enabled: boolean;
maximumDistance: number;
normalOffset: boolean;
size: number;
softShadows: boolean;
constructor(options: ShadowMapOptions);
}
type ShadowMapOptions = {
lightCamera: Camera;
cascadesEnabled?: boolean;
darkness?: number;
enabled?: boolean;
isPointLight?: boolean;
maximumDistance?: number;
normalOffset?: boolean;
numberOfCascades?: number;
pointLightRadius?: number;
size?: number;
softShadows?: boolean;
}
enum ShadowMode {
CAST_ONLY,
DISABLED,
ENABLED,
RECEIVE_ONLY,
}
/* Not an ImageryProvider (!!!) */
class SingleTileImageryProvider {
readonly credit: Credit;
readonly errorEvent: Event<(err: TileProviderError) => void>;
readonly hasAlphaChannel: boolean;
readonly maximumLevel: number;
readonly minimumLevel: number;
readonly proxy: Proxy;
readonly ready: boolean;
readonly readyPromise: Promise<boolean>;
readonly rectangle: Rectangle;
readonly tileDiscardPolicy: TileDiscardPolicy;
readonly tileHeight: number;
readonly tileWidth: number;
readonly tilingScheme: TilingScheme;
readonly url: string;
constructor(options: {
url: Resource | string;
rectangle?: Rectangle;
credit?: Credit | string;
ellipsoid?: Ellipsoid;
});
getTileCredits(x: number, y: number, level: number): Credit[];
requestImage(x: number, y: number, level: number): Promise<HTMLImageElement | HTMLCanvasElement>;
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}
class SkyAtmosphere {
show: boolean;
ellipsoid: Ellipsoid;
constructor(ellipsoid?: Ellipsoid);
isDestroyed(): boolean;
destroy(): void;
}
class SkyBox {
sources: any;
show: boolean;
constructor(options: { sources?: any; show?: boolean });
update(): void;
isDestroyed(): boolean;
destroy(): void;
}
class Sun {
show: boolean;
glowFactor: number;
isDestroyed(): boolean;
destroy(): void;
}
class TileCoordinatesImageryProvider extends ImageryProvider {
constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; color?: Color; tileWidth?: number; tileHeight?: number });
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
class TileDiscardPolicy {
isReady(): boolean;
shouldDiscardImage(image: HTMLImageElement | Promise<HTMLImageElement>): Promise<boolean>;
}
class TileMapServiceImageryProvider extends UrlTemplateImageryProvider {
constructor(options?: TileMapServiceImageryProvider.ConstructorOptions);
}
namespace TileMapServiceImageryProvider {
interface ConstructorOptions {
url?: string;
fileExtension?: string;
credit?: Credit | string;
minimumLevel?: number;
maximumLevel?: number;
rectangle?: Rectangle;
tilingScheme?: TilingScheme;
ellipsoid?: Ellipsoid;
tileWidth?: number;
tileHeight?: number;
flipXY?: boolean;
}
}
class ViewportQuad {
show: boolean;
rectangle: BoundingRectangle;
material: Material;
constructor(rectangle?: BoundingRectangle, material?: Material);
update(): void;
isDestroyed(): boolean;
destroy(): void;
}
class WebMapServiceImageryProvider extends ImageryProvider {
static DefaultParameters: {[paramName: string]: string};
static GetFeatureInfoDefaultParameters: {[paramName: string]: string};
clock: Clock;
enablePickFeatures: boolean;
readonly layers: string;
times: TimeIntervalCollection;
url: string;
constructor(options: WebMapServiceImageryProvider.ConstructorOptions);
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
namespace WebMapServiceImageryProvider {
type ConstructorOptions = {
url: Resource | string;
layers: string;
parameters?: {[paramName: string]: string};
getFeatureInfoParameters?: {[paramName: string]: string};
enablePickFeatures?: boolean;
getFeatureInfoFormats?: GetFeatureInfoFormat[];
rectangle?: Rectangle;
tilingScheme?: TilingScheme;
ellipsoid?: Ellipsoid;
tileWidth?: number;
tileHeight?: number;
minimumLevel?: number;
maximumLevel?: number;
crs?: string;
srs?: string;
credit?: Credit | string;
subdomains?: string | string[];
clock?: Clock;
times?: TimeIntervalCollection;
};
}
class WebMapTileServiceImageryProvider extends ImageryProvider {
clock: Clock | undefined;
dimensions: {[paramName: string]: string};
readonly format: string;
times: TimeIntervalCollection | undefined;
readonly url: string;
constructor(options: WebMapTileServiceImageryProvider.ConstructorOptions);
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
namespace WebMapTileServiceImageryProvider {
type ConstructorOptions = {
url: string | Resource;
format?: string;
layer: string;
style: string;
tileMatrixSetID: string;
tileMatrixLabels?: string[];
clock?: Clock;
times?: TimeIntervalCollection;
dimensions?: {[paramName: string]: string};
tileWidth?: number;
tileHeight?: number;
tilingScheme?: TilingScheme;
rectangle?: Rectangle;
minimumLevel?: number;
maximumLevel?: number;
ellipsoid?: Ellipsoid;
credit?: Credit | string;
subdomains?: string | string[];
}
}
class Animation {
container: Element;
viewModel: AnimationViewModel;
constructor(container: Element | string, viewModel: AnimationViewModel);
isDestroyed(): boolean;
destroy(): void;
resize(): void;
applyThemeChanges(): void;
}
class AnimationViewModel {
shuttleRingDragging: boolean;
snapToTicks: boolean;
timeLabel: string;
dateLabel: string;
multiplierLabel: string;
shuttleRingAngle: number;
slower: Command;
faster: Command;
clockViewModel: ClockViewModel;
pauseViewModel: ToggleButtonViewModel;
playReverseViewModel: ToggleButtonViewModel;
playForwardViewModel: ToggleButtonViewModel;
playRealtimeViewModel: ToggleButtonViewModel;
dateFormatter: AnimationViewModel.DateFormatter;
timeFormatter: AnimationViewModel.TimeFormatter;
static defaultDateFormatter: AnimationViewModel.DateFormatter;
static defaultTicks: number[];
static defaultTimeFormatter: AnimationViewModel.TimeFormatter;
constructor(clockViewModel: ClockViewModel);
getShuttleRingTicks(): number[];
setShuttleRingTicks(positiveTicks: number[]): void;
}
namespace AnimationViewModel {
type DateFormatter = (date: JulianDate, viewModel: AnimationViewModel) => string;
type TimeFormatter = (date: JulianDate, viewModel: AnimationViewModel) => string;
}
class BaseLayerPicker {
container: Element;
viewModel: BaseLayerPickerViewModel;
constructor(container: Element, options: { globe: Globe; imageryProviderViewModels?: ProviderViewModel[]; selectedImageryProviderViewModel?: ProviderViewModel; terrainProviderViewModels?: ProviderViewModel[]; selectedTerrainProviderViewModel?: ProviderViewModel });
isDestroyed(): boolean;
destroy(): void;
}
class BaseLayerPickerViewModel {
imageryProviderViewModels: ProviderViewModel[];
terrainProviderViewModels: ProviderViewModel[];
dropDownVisible: boolean;
buttonTooltip: string;
buttonImageUrl: string;
selectedImagery: ProviderViewModel;
selectedTerrain: ProviderViewModel;
toggleDropDown: Command;
globe: Globe;
constructor(options: { globe: Globe; imageryProviderViewModels?: ProviderViewModel[]; selectedImageryProviderViewModel?: ProviderViewModel; terrainProviderViewModels?: ProviderViewModel[]; selectedTerrainProviderViewModel?: ProviderViewModel });
}
class ProviderViewModel {
name: string;
tooltip: string;
iconUrl: string;
creationCommand: Command;
constructor(options: {
name: string;
tooltip: string;
iconUrl: string;
creationFunction: ProviderViewModel.CreationFunction | Command
});
}
namespace ProviderViewModel {
type CreationFunction = () => ImageryProvider | TerrainProvider | ImageryProvider[] | TerrainProvider[];
}
class CesiumInspector {
container: Element;
viewModel: CesiumInspectorViewModel;
constructor(container: Element | string, scene: Scene);
isDestroyed(): boolean;
destroy(): void;
}
class CesiumInspectorViewModel {
frustums: boolean;
performance: boolean;
shaderCacheText: string;
primitiveBoundingSphere: boolean;
primitiveReferenceFrame: boolean;
filterPrimitive: boolean;
tileBoundingSphere: boolean;
filterTile: boolean;
wireframe: boolean;
suspendUpdates: boolean;
tileCoordinates: boolean;
frustumStatisticText: string;
tileText: string;
hasPickedPrimitive: boolean;
hasPickedTile: boolean;
pickPimitiveActive: boolean;
pickTileActive: boolean;
dropDownVisible: boolean;
generalVisible: boolean;
primitivesVisible: boolean;
terrainVisible: boolean;
generalSwitchText: string;
primitivesSwitchText: string;
terrainSwitchText: string;
scene: Scene;
performanceContainer: Element;
toggleDropDown: Command;
showFrustums: Command;
showPerformance: Command;
showPrimitiveBoundingSphere: Command;
showPrimitiveReferenceFrame: Command;
doFilterPrimitive: Command;
showWireframe: Command;
doSuspendUpdates: Command;
showTileCoordinates: Command;
showTileBoundingSphere: Command;
doFilterTile: Command;
toggleGeneral: Command;
togglePrimitives: Command;
toggleTerrain: Command;
pickPrimitive: Command;
pickTile: Command;
selectParent: Command;
selectNW: Command;
selectNE: Command;
selectSW: Command;
selectSE: Command;
primitive: Command;
tile: Command;
constructor(scene: Scene);
isDestroyed(): boolean;
destroy(): void;
}
class CesiumWidget {
container: Element;
canvas: HTMLCanvasElement;
creditContainer: Element;
scene: Scene;
imageryLayers: ImageryLayerCollection;
terrainProvider: TerrainProvider;
camera: Camera;
clock: Clock;
screenSpaceEventHandler: ScreenSpaceEventHandler;
targetFrameRate: number;
useDefaultRenderLoop: boolean;
resolutionScale: number;
constructor(container: Element | string, options?: CesiumWidgetOptions);
showErrorPanel(title: string, message: string, error?: string): void;
isDestroyed(): boolean;
destroy(): void;
resize(): void;
render(): void;
}
class CesiumWidgetOptions {
clock?: Clock;
imageryProvider?: ImageryProvider;
terrainProvider?: TerrainProvider;
skyBox?: SkyBox | boolean;
skyAtmosphere?: SkyAtmosphere | boolean;
sceneMode?: SceneMode;
scene3DOnly?: boolean;
orderIndependentTranslucency?: boolean;
mapProjection?: MapProjection;
globe?: Globe;
useDefaultRenderLoop?: boolean;
targetFrameRate?: number;
showRenderLoopErrors?: boolean;
contextOptions?: any;
creditContainer?: Element | string;
}
class ClockViewModel {
systemTime: JulianDate;
startTime: JulianDate;
stopTime: JulianDate;
currentTime: JulianDate;
multiplier: number;
clockStep: ClockStep;
clockRange: ClockRange;
canAnimate: boolean;
shouldAnimate: boolean;
clock: Clock;
constructor(clock?: Clock);
synchronize(): void;
isDestroyed(): boolean;
destroy(): void;
}
abstract class Command {
canExecute: boolean;
readonly beforeExecute: Event<(opts: {cancel: boolean, args: any[]}) => void>;
readonly afterExecute: Event<(returnValue: any) => void>;
}
class FullscreenButton {
container: Element;
viewModel: FullscreenButtonViewModel;
constructor(container: Element | string, fullscreenElement?: Element | string);
isDestroyed(): boolean;
destroy(): void;
}
class FullscreenButtonViewModel {
isFullscreen: boolean;
isFullscreenEnabled: boolean;
tooltip: string;
fullscreenElement: Element;
command: Command;
constructor(fullscreenElement?: Element | string);
isDestroyed(): boolean;
destroy(): void;
}
class Geocoder {
readonly container: Element;
readonly searchSuggestionsContainer: Element;
readonly viewModel: GeocoderViewModel;
constructor(options: Geocoder.ConstructorOptions);
destroy(): void;
isDestroyed(): boolean;
}
namespace Geocoder {
type DestinationFoundFunction = (viewModel: GeocoderViewModel, destination: Cartesian3 | Rectangle) => void;
interface ConstructorOptions {
container?: Element | string
scene?: Scene
url?: string
key?: string
flightDuration?: number;
}
}
class GeocoderViewModel {
autoComplete: boolean;
readonly complete: Event<() => void>;
flightDuration?: number;
readonly isSearchInProgress: boolean;
keepExpanded: boolean;
readonly scene: Scene;
search: Command;
searchText: string;
readonly selectedSuggestion: any;
readonly suggestions: any[];
constructor(options: GeocoderViewModel.ConstructorOptions);
static flyToDestination: Geocoder.DestinationFoundFunction;
destroy(): void;
}
namespace GeocoderViewModel {
interface ConstructorOptions {
scene: Scene;
geocoderServices?: GeocoderService[];
flightDuration?: number;
destinationFound?: Geocoder.DestinationFoundFunction;
}
}
class GeocoderResult {
displayName: string;
destination: Rectangle | Cartesian3;
}
interface GeocoderService {
geocode(query: string): Promise<Array<GeocoderResult>>
}
class HomeButton {
container: Element;
viewModel: HomeButtonViewModel;
constructor(container: Element | string, scene: Scene, duration?: number);
isDestroyed(): boolean;
destroy(): void;
}
class HomeButtonViewModel {
tooltip: string;
scene: Scene;
command: Command;
duration: number;
constructor(scene: Scene, duration?: number);
}
class InfoBox {
container: Element;
viewModel: InfoBoxViewModel;
frame: HTMLIFrameElement;
constructor(container: Element | string);
isDestroyed(): boolean;
destroy(): void;
}
class InfoBoxViewModel {
readonly cameraClicked: Event<() => void>;
cameraIconPath: string;
readonly closeClicked: Event<() => void>;
description: string;
enableCamera: boolean;
isCameraTracking: boolean;
maxHeight: number;
maxHeightOffset(offset: number): string;
showInfo: boolean;
titleText: string;
}
class NavigationHelpButton {
container: Element;
viewModel: NavigationHelpButtonViewModel;
constructor(options: { container: Element | string; instructionsInitiallyVisible?: boolean });
isDestroyed(): boolean;
destroy(): void;
}
class NavigationHelpButtonViewModel {
showInstructions: boolean;
tooltip: string;
command: Command;
showClick: Command;
showTouch: Command;
}
class PerformanceWatchdog {
container: Element;
viewModel: PerformanceWatchdogViewModel;
constructor(options?: { container: Element | string; scene: Scene; lowFrameRateMessage?: string });
isDestroyed(): boolean;
destroy(): void;
}
class PerformanceWatchdogViewModel {
lowFrameRateMessage: string;
lowFrameRateMessageDismissed: boolean;
showingLowFrameRateMessage: boolean;
scene: Scene;
dismissMessage: Command;
constructor(options?: { scene: Scene; lowFrameRateMessage?: string });
}
class SceneModePicker {
container: Element;
viewModel: SceneModePickerViewModel;
constructor(container: Element | string, scene: Scene, duration?: number);
isDestroyed(): boolean;
destroy(): void;
}
class SceneModePickerViewModel {
sceneMode: SceneMode;
dropDownVisible: boolean;
tooltip2D: string;
tooltip3D: string;
tooltipColumbusView: string;
selectedTooltip: string;
scene: Scene;
duration: number;
toggleDropDown: Command;
morphTo2D: Command;
morphTo3D: Command;
morphToColumbusView: Command;
constructor(scene: Scene, duration?: number);
isDestroyed(): boolean;
destroy(): void;
}
class SelectionIndicator {
container: Element;
viewModel: SelectionIndicatorViewModel;
constructor(container: Element | string, scene: Scene);
isDestroyed(): boolean;
destroy(): void;
}
class SelectionIndicatorViewModel {
position: Cartesian3;
showSelection: boolean;
isVisible: boolean;
computeScreenSpacePosition: SelectionIndicatorViewModel.ComputeScreenSpacePosition;
container: Element;
selectionIndicatorElement: Element;
scene: Scene;
constructor(scene: Scene, selectionIndicatorElement: Element, container: Element);
update(): void;
animateAppear(): void;
animateDepart(): void;
}
namespace SelectionIndicatorViewModel {
type ComputeScreenSpacePosition = (position: Cartesian3, result: Cartesian2) => Cartesian2;
}
class Timeline {
container: Element;
constructor(container: Element, clock: Clock);
isDestroyed(): boolean;
destroy(): void;
zoomTo(startTime: JulianDate, stopTime: JulianDate): void;
resize(): void;
}
class ToggleButtonViewModel {
toggled: boolean;
tooltip: string;
command: Command;
constructor(command: Command, options?: { toggled?: boolean; tooltip?: string });
}
class Viewer {
constructor(container: Element | string, options?: Viewer.ConstructorOptions);
allowDataSourcesToSuspendAnimation: boolean;
readonly animation: Animation;
readonly baseLayerPicker: BaseLayerPicker;
readonly bottomContainer: Element;
readonly camera: Camera;
readonly canvas: HTMLCanvasElement;
readonly cesiumLogo: Element;
readonly cesiumWidget: CesiumWidget;
readonly clock: Clock;
clockTrackedDataSource: DataSource;
readonly clockViewModel: ClockViewModel;
readonly container: Element;
readonly dataSourceDisplay: DataSourceDisplay;
readonly dataSources: DataSourceCollection;
readonly entities: EntityCollection;
readonly fullscreenButton: FullscreenButton;
readonly geocoder: Geocoder;
readonly homeButton: HomeButton;
readonly imageryLayers: ImageryLayerCollection;
readonly infoBox: InfoBox;
readonly navigationHelpButton: NavigationHelpButton;
resolutionScale: number;
readonly scene: Scene;
readonly sceneModePicker: SceneModePicker;
readonly screenSpaceEventHandler: ScreenSpaceEventHandler;
selectedEntity?: Entity;
readonly selectedEntityChanged: Event<(value: Entity) => void>;
readonly selectionIndicator: SelectionIndicator;
readonly shadowMap: ShadowMap;
shadows: boolean;
targetFrameRate: number;
terrainProvider: TerrainProvider;
terrainShadows: boolean;
readonly timeline: Timeline;
trackedEntity?: Entity;
readonly trackedEntityChanged: Event<(value: Entity) => void>;
useDefaultRenderLoop: boolean;
readonly vrButton: VRButton;
destroy(): void;
extend(mixin: Viewer.ViewerMixin, options: any): void;
flyTo(target: Viewer.TargetTypes | Promise<Viewer.TargetTypes>,
options?: { duration?: number; offset?: HeadingPitchRange }): Promise<boolean>;
forceResize(): void;
isDestroyed(): boolean;
render(): void;
resize(): void;
zoomTo(target: Viewer.TargetTypes | Promise<Viewer.TargetTypes>,
offset?: HeadingPitchRange): Promise<boolean>;
}
namespace Viewer {
class ConstructorOptions {
animation?: boolean;
automaticallyTrackDataSourceClocks?: boolean;
baseLayerPicker?: boolean;
clockViewModel?: ClockViewModel;
contextOptions?: any;
creditContainer?: Element | string;
creditViewport?: Element | string;
dataSources?: DataSourceCollection;
fullscreenButton?: boolean;
fullscreenElement?: Element | string;
geocoder?: boolean;
globe?: Globe;
homeButton?: boolean;
imageryProvider?: ImageryProvider;
imageryProviderViewModels?: ProviderViewModel[];
infoBox?: boolean;
mapMode2D?: Scene.MapMode2D;
mapProjection?: MapProjection;
maximumRenderTimeChange?: number;
navigationHelpButton?: boolean;
navigationInstructionsInitiallyVisible?: boolean;
orderIndependentTranslucency?: boolean;
projectionPicker?: boolean;
requestRenderMode?: boolean;
scene3DOnly?: boolean;
sceneMode?: SceneMode;
sceneModePicker?: boolean;
selectedImageryProviderViewModel?: ProviderViewModel;
selectedTerrainProviderViewModel?: ProviderViewModel;
selectionIndicator?: boolean;
shadows?: false;
shouldAnimate?: boolean;
showRenderLoopErrors?: boolean;
skyAtmosphere?: SkyAtmosphere;
skyBox?: SkyBox;
targetFrameRate?: number;
terrainExaggeration?: number;
terrainProvider?: TerrainProvider;
terrainProviderViewModels?: ProviderViewModel[];
terrainShadows?: ShadowMode;
timeline?: boolean;
useDefaultRenderLoop?: boolean;
vrButton?: boolean;
}
type ViewerMixin = (viewer: Viewer, options: any) => void;
type TargetTypes =
Entity |
Entity[] |
EntityCollection |
DataSource |
ImageryLayer |
Cesium3DTileset
}
class VRButton {
constructor(container: Element|string, scene: Scene, vrElement: Element|string);
readonly container: Element;
readonly viewModel: VRButtonViewModel;
destroy(): void;
isDestroyed(): boolean;
}
class VRButtonViewModel {
constructor(scene: Scene, vrElement: Element | string);
readonly command: Command;
isVREnabled: boolean;
readonly isVRMode: boolean;
readonly tooltip: string;
vrElement: Element;
destroy(): void;
isDestroyed(): boolean;
}
function barycentricCoordinates(point: Cartesian2 | Cartesian3, p0: Cartesian2 | Cartesian3, p1: Cartesian2 | Cartesian3, p2: Cartesian2 | Cartesian3, result?: Cartesian3): Cartesian3;
function binarySearch(array: any[], itemToFind: any, comparator: binarySearch.Comparator): number;
namespace binarySearch {
type Comparator = (a: any, b: any) => number;
}
function cancelAnimationFrame(requestID: number): void;
function clone(object: Object, deep?: boolean): Object;
function combine(object1?: Object, object2?: Object, deep?: boolean): Object;
function destroyObject(object: any, message?: string): void;
namespace exportKml {
interface CommonOptions {
entities: EntityCollection;
ellipsoid?: Ellipsoid;
modelCallback?: ModelCallback;
time?: JulianDate;
defaultAvailability?: TimeInterval;
sampleDuration?: number;
}
interface FileDict {
kml: string;
externalFiles: {
[fileName: string]: Blob;
};
}
type ModelCallback = (model: ModelGraphics, time: JulianDate, externalFiles: {[fileName: string]: Blob}) => string;
}
function exportKml(options: exportKml.CommonOptions & {kmz: true}): Promise<{kmz:Blob}>;
function exportKml(options: exportKml.CommonOptions & {kmz: false}): Promise<exportKml.FileDict>;
function formatError(object: any): string;
function getFilenameFromUri(uri: string): string;
function getImagePixels(image: HTMLImageElement): number[];
function isArray(value: any): boolean;
function isLeapYear(year: number): boolean;
function jsonp(url: string, options?: { parameters?: any; callbackParameterName?: string; proxy?: any }): Promise<any>;
function mergeSort(array: any[], comparator: mergeSort.Comparator, userDefinedObject?: any): void;
namespace mergeSort {
type Comparator = (a: any, b: any, userDefinedObject?: any) => number;
}
function objectToQuery(obj: any): string;
function pointInsideTriangle(point: Cartesian2 | Cartesian3, p0: Cartesian2 | Cartesian3, p1: Cartesian2 | Cartesian3, p2: Cartesian2 | Cartesian3): boolean;
function queryToObject(queryString: string): any;
function requestAnimationFrame(callback: requestAnimationFrame.Callback): number;
namespace requestAnimationFrame {
type Callback = (timestamp: number) => void;
}
function sampleTerrain(terrainProvider: TerrainProvider, level: number, positions: Cartographic[]): Promise<Cartographic[]>;
function sampleTerrainMostDetailed(terrainProvider: TerrainProvider, positions: Cartographic[]): Promise<Cartographic[]>;
function subdivideArray<T>(array: T[], numberOfArrays: number): T[][];
function throttleRequestByServer(url: string, requestFunction: throttleRequestByServer.RequestFunction): Promise<any>;
namespace throttleRequestByServer {
type RequestFunction = (url: string) => Promise<any>;
}
function createTangentSpaceDebugPrimitive(options: { geometry: Geometry; length?: number; modelMatrix?: Matrix4 }): Primitive;
function viewerCesiumInspectorMixin(viewer: Viewer): void;
function viewerDragDropMixin(viewer: Viewer, options?: { dropTarget?: Element | string; clearOnDrop?: boolean; proxy?: DefaultProxy }): void;
function viewerPerformanceWatchdogMixin(viewer: Viewer): void;
function createCommand(func: Function, canExecute?: boolean): Function;
function createTaskProcessorWorker(workerFunction: createTaskProcessorWorker.WorkerFunction): createTaskProcessorWorker.TaskProcessorWorkerFunction;
namespace createTaskProcessorWorker {
type WorkerFunction = (parameters: any, transferableObjects: any[]) => any;
type TaskProcessorWorkerFunction = (event: any) => void;
}
enum ClockRange {
UNBOUNDED,
CLAMPED,
LOOP_STOP,
}
enum ClockStep {
TICK_DEPENDENT,
SYSTEM_CLOCK_MULTIPLIER,
SYSTEM_CLOCK,
}
enum ComponentDatatype {
BYTE,
UNSIGNED_BYTE,
SHORT,
UNSIGNED_SHORT,
FLOAT,
DOUBLE,
}
namespace ComponentDatatype {
function getSizeInBytes(componentDatatype: ComponentDatatype): number;
function fromTypedArray(array: Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array): ComponentDatatype;
function validate(componentDatatype: ComponentDatatype): boolean;
function createTypedArray(componentDatatype: ComponentDatatype, valuesOrLength: number | any[]): Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array;
function createArrayBufferView(componentDatatype: ComponentDatatype, buffer: ArrayBuffer, byteOffset?: number, length?: number): Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array;
}
enum CornerType {
ROUNDED,
MITERED,
BEVELED,
}
namespace CubicRealPolynomial {
function computeDiscriminant(a: number, b: number, c: number, d: number): number;
function computeRealRoots(a: number, b: number, c: number, d: number): number[];
}
enum ExtrapolationType {
NONE,
HOLD,
EXTRAPOLATE,
}
namespace FeatureDetection {
function supportsFullscreen(): boolean;
function supportsTypedArrays(): boolean;
function supportsWebAssembly(): boolean;
function supportsWebWorkers(): boolean;
}
enum Fullscreen {
element,
changeEventName,
errorEventName,
enabled,
fullscreen,
}
namespace Fullscreen {
function supportsFullscreen(): boolean;
function requestFullscreen(element: any): boolean;
function exitFullscreen(): boolean;
}
namespace GeometryPipeline {
function toWireframe(geometry: Geometry): Geometry;
function createLineSegmentsForVectors(geometry: Geometry, attributeName?: string, length?: number): Geometry;
function createAttributeLocations(geometry: Geometry): any;
function reorderForPreVertexCache(geometry: Geometry): Geometry;
function reorderForPostVertexCache(geometry: Geometry, cacheCapacity?: number): Geometry;
function fitToUnsignedShortIndices(geometry: Geometry): Geometry[];
function projectTo2D(geometry: Geometry, attributeName: string, attributeName3D: string, attributeName2D: string, projection?: any): Geometry;
function encodeAttribute(geometry: Geometry, attributeName: string, attributeHighName: string, attributeLowName: string): Geometry;
function transformToWorldCoordinates(instance: GeometryInstance): GeometryInstance;
function computeNormal(geometry: Geometry): Geometry;
function computeBinormalAndTangent(geometry: Geometry): Geometry;
function compressVertices(geometry: Geometry): Geometry;
}
// enum HeightmapTessellator {
// DEFAULT_STRUCTURE,
// }
// namespace HeightmapTessellator {
// function computeVertices(options: { vertices: any[] | Float32Array; heightmap: Int8Array | Uint8Array | Int16Array | Uint16Array | Float32Array | Float64Array; width: number; height: number; skirtHeight: number; nativeRectangle: Rectangle; rectangle?: Rectangle; isGeographic?: boolean; relativetoCenter?: Cartesian3; ellipsoid?: Ellipsoid; structure?: any; structureheightScale?: number; structureheightOffset?: number; structureelementsPerHeight?: number; structurestride?: number; structureelementMultiplier?: number; structureisBigEndian?: boolean });
// }
enum HeightReference {
CLAMP_TO_GROUND,
NONE,
RELATIVE_TO_GROUND
}
namespace HermitePolynomialApproximation {
function getRequiredDataPoints(degree: number, inputOrder?: number): number;
function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
function interpolate(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
}
enum IndexDatatype {
UNSIGNED_BYTE,
UNSIGNED_SHORT,
UNSIGNED_INT,
}
namespace IndexDatatype {
function getSizeInBytes(indexDatatype: IndexDatatype): number;
function validate(indexDatatype: IndexDatatype): boolean;
function createTypedArray(numberOfVertices: number, indicesLengthOrArray: any): Uint16Array | Uint32Array;
function createTypedArrayFromArrayBuffer(numberOfVertices: number, sourceArray: ArrayBuffer, byteOffset: number, length: number): Uint16Array | Uint32Array;
}
enum InterpolationAlgorithm {
type,
}
namespace InterpolationAlgorithm {
function getRequiredDataPoints(degree: number): number;
function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
function interpolate(x: number, xTable: number[], yTable: number[], yStride: number, inputOrder: number, outputOrder: number, result?: number[]): number[];
}
enum Intersect {
OUTSIDE,
INTERSECTING,
INSIDE,
}
namespace IntersectionTests {
function rayPlane(ray: Ray, plane: Plane, result?: Cartesian3): Cartesian3;
function rayTriangle(ray: Ray, p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, cullBackFaces?: boolean, result?: Cartesian3): Cartesian3;
function lineSegmentTriangle(v0: Cartesian3, v1: Cartesian3, p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, cullBackFaces?: boolean, result?: Cartesian3): Cartesian3;
function raySphere(ray: Ray, sphere: BoundingSphere, result?: any): any;
function lineSegmentSphere(p0: Cartesian3, p1: Cartesian3, sphere: BoundingSphere, result?: any): any;
function rayEllipsoid(ray: Ray, ellipsoid: Ellipsoid): any;
function grazingAltitudeLocation(ray: Ray, ellipsoid: Ellipsoid): Cartesian3;
function lineSegmentPlane(endPoint0: Cartesian3, endPoint1: Cartesian3, plane: Plane, result?: Cartesian3): Cartesian3;
function trianglePlaneIntersection(p0: Cartesian3, p1: Cartesian3, p2: Cartesian3, plane: Plane): any;
}
namespace Intersections2D {
function clipTriangleAtAxisAlignedThreshold(threshold: number, keepAbove: boolean, u0: number, u1: number, u2: number, result?: number[]): number[];
function computeBarycentricCoordinates(x: number, y: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, result?: Cartesian3): Cartesian3;
}
enum Iso8601 {
MINIMUM_VALUE,
MAXIMUM_VALUE,
MAXIMUM_INTERVAL,
}
enum KeyboardEventModifier {
SHIFT,
CTRL,
ALT,
}
namespace LagrangePolynomialApproximation {
function getRequiredDataPoints(degree: number): number;
function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
}
namespace LinearApproximation {
function getRequiredDataPoints(degree: number): number;
function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
}
enum Math {
EPSILON1,
EPSILON2,
EPSILON3,
EPSILON4,
EPSILON5,
EPSILON6,
EPSILON7,
EPSILON8,
EPSILON9,
EPSILON10,
EPSILON11,
EPSILON12,
EPSILON13,
EPSILON14,
EPSILON15,
EPSILON16,
EPSILON17,
EPSILON18,
EPSILON19,
EPSILON20,
GRAVITATIONALPARAMETER,
SOLAR_RADIUS,
LUNAR_RADIUS,
SIXTY_FOUR_KILOBYTES,
PI,
ONE_OVER_PI,
PI_OVER_TWO,
PI_OVER_THREE,
PI_OVER_FOUR,
PI_OVER_SIX,
THREE_PI_OVER_TWO,
TWO_PI,
ONE_OVER_TWO_PI,
RADIANS_PER_DEGREE,
DEGREES_PER_RADIAN,
RADIANS_PER_ARCSECOND,
}
namespace Math {
function acosClamped(value: number): number;
function asinClamped(value: number): number;
function cbrt(value: number): number;
function chordLength(angle: number, radius: number): number;
function clamp(value: number, min: number, max: number): number;
function clampToLatitudeRange(angle: number): number;
function convertLongitudeRange(angle: number): number;
function cosh(value: number): number;
function equalsEpsilon(left: number, right: number, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
function factorial(n: number): number;
function fastApproximateAtan(x: number): number;
function fastApproximateAtan2(x: number, y: number): number;
function fromSNorm(value: number): number;
function incrementWrap(n?: number, maximumValue?: number, minimumValue?: number): number;
function isPowerOfTwo(n: number): boolean;
function lerp(p: number, q: number, time: number): number;
function log2(x: number): number;
function logBase(x: number, base: number): number;
function mod(m: number, n: number): number;
function negativePiToPi(angle: number): number;
function nextPowerOfTwo(n: number): number;
function nextRandomNumber(): number;
function randomBetween(min: number, max:number): number;
function setRandomNumberSeed(seed: number): void;
function sign(value: number): number;
function signNotZero(value: number): number;
function sinh(value: number): number;
function toDegrees(radians: number): number;
function toRadians(degrees: number): number;
function toSNorm(value: number): number;
function zeroToTwoPi(angle: number): number;
}
abstract class Packable {
static packedLength: number;
static pack(value: any, array: number[], startingIndex?: number): number[];
static unpack(array: number[], startingIndex?: number, result?: any): any;
}
enum PackableForInterpolation {
packedInterpolationLength,
}
namespace PackableForInterpolation {
function convertPackedArrayForInterpolation(packedArray: number[], startingIndex?: number, lastIndex?: number, result?: number[]): void;
function unpackInterpolationResult(array: number[], sourceArray: number[], startingIndex?: number, lastIndex?: number, result?: any): any;
}
enum PixelFormat {
DEPTH_COMPONENT,
DEPTH_STENCIL,
ALPHA,
RGB,
RGBA,
LUMINANCE,
LUMINANCE_ALPHA,
}
enum PrimitiveType {
POINTS,
LINES,
LINE_LOOP,
LINE_STRIP,
TRIANGLES,
TRIANGLE_STRIP,
TRIANGLE_FAN,
}
namespace QuadraticRealPolynomial {
function computeDiscriminant(a: number, b: number, c: number): number;
function computeRealRoots(a: number, b: number, c: number): number[];
}
namespace QuarticRealPolynomial {
function computeDiscriminant(a: number, b: number, c: number, d: number, e: number): number;
function computeRealRoots(a: number, b: number, c: number, d: number, e: number): number[];
}
enum ReferenceFrame {
FIXED,
INERTIAL,
}
enum ScreenSpaceEventType {
LEFT_DOWN,
LEFT_UP,
LEFT_CLICK,
LEFT_DOUBLE_CLICK,
RIGHT_DOWN,
RIGHT_UP,
RIGHT_CLICK,
RIGHT_DOUBLE_CLICK,
MIDDLE_DOWN,
MIDDLE_UP,
MIDDLE_CLICK,
MIDDLE_DOUBLE_CLICK,
MOUSE_MOVE,
WHEEL,
PINCH_START,
PINCH_END,
PINCH_MOVE,
}
interface PositionedEvent {
position: Cartesian2;
}
interface MoveEvent {
startPosition: Cartesian2;
endPosition: Cartesian2;
}
interface Touch2Event {
position1: Cartesian2;
position2: Cartesian2;
}
namespace Simon1994PlanetaryPositions {
function computeSunPositionInEarthInertialFrame(julianDate?: JulianDate, result?: Cartesian3): Cartesian3;
function computeMoonPositionInEarthInertialFrame(julianDate?: JulianDate, result?: Cartesian3): Cartesian3;
}
enum TimeStandard {
UTC,
TAI,
}
namespace Transforms {
function computeFixedToIcrfMatrix(date: JulianDate, result?: Matrix3): Matrix3;
function computeIcrfToFixedMatrix(date: JulianDate, result?: Matrix3): Matrix3;
function computeTemeToPseudoFixedMatrix(date: JulianDate, result?: Matrix3): Matrix3;
function eastNorthUpToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function headingPitchRollQuaternion(origin: Cartesian3, hpr: HeadingPitchRoll,
ellipsoid?: Ellipsoid, fixedFrameTransform?: LocalFrameToFixedFrame, result?: Quaternion): Quaternion;
function headingPitchRollToFixedFrame(origin: Cartesian3, hpr: HeadingPitchRoll,
ellipsoid?: Ellipsoid, fixedFrameTransform?: LocalFrameToFixedFrame, result?: Matrix4): Matrix4;
function localFrameToFixedFrameGenerator(firstAxis: AxisName, secondAxis: AxisName): LocalFrameToFixedFrame;
function northEastDownToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function northUpEastToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function northWestUpToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function pointToWindowCoordinates(modelViewProjectionMatrix: Matrix4,
viewportTransformation: Matrix4, point: Cartesian3, result?: Cartesian2): Cartesian2;
function preloadIcrfFixed(timeInterval: TimeInterval): Promise<void>;
type LocalFrameToFixedFrame = (origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4) => Matrix4;
type AxisName = "east" | "north" | "up" | "west" | "south" | "down";
}
namespace TridiagonalSystemSolver {
function solve(diagonal: number[], lower: number[], upper: number[], right: Cartesian3[]): Cartesian3[];
}
enum Visibility {
NONE,
PARTIAL,
FULL,
}
enum WindingOrder {
CLOCKWISE,
COUNTER_CLOCKWISE,
}
enum StripeOrientation {
HORIZONTAL,
VERTICAL,
}
enum BingMapsStyle {
AERIAL,
AERIAL_WITH_LABELS,
ROAD,
ORDNANCE_SURVEY,
COLLINS_BART,
}
enum BlendEquation {
ADD,
SUBTRACT,
REVERSE_SUBTRACT,
}
enum BlendFunction {
ZERO,
ONE,
SOURCE_COLOR,
ONE_MINUS_SOURCE_COLOR,
DESTINATION_COLOR,
ONE_MINUS_DESTINATION_COLOR,
SOURCE_ALPHA,
ONE_MINUS_SOURCE_ALPHA,
DESTINATION_ALPHA,
ONE_MINUS_DESTINATION_ALPHA,
CONSTANT_COLOR,
ONE_MINUS_CONSTANT_COLOR,
CONSTANT_ALPHA,
ONE_MINUS_CONSTANT_ALPHA,
SOURCE_ALPHA_SATURATE,
}
enum BlendingState {
DISABLED,
ALPHA_BLEND,
PRE_MULTIPLIED_ALPHA_BLEND,
ADDITIVE_BLEND,
}
enum CameraEventType {
LEFT_DRAG,
RIGHT_DRAG,
MIDDLE_DRAG,
WHEEL,
PINCH,
}
enum CullFace {
FRONT,
BACK,
FRONT_AND_BACK,
}
enum DepthFunction {
NEVER,
LESS,
EQUAL,
LESS_OR_EQUAL,
GREATER,
NOT_EQUAL,
GREATER_OR_EQUAL,
ALWAYS,
}
enum HorizontalOrigin {
CENTER,
LEFT,
RIGHT,
}
enum LabelStyle {
FILL,
OUTLINE,
FILL_AND_OUTLINE,
}
enum ModelAnimationLoop {
NONE,
REPEAT,
MIRRORED_REPEAT,
}
enum SceneMode {
MORPHING,
COLUMBUS_VIEW,
SCENE2D,
SCENE3D,
}
namespace SceneMode {
function getMorphTime(value: SceneMode): number;
}
namespace SceneTransforms {
function wgs84ToWindowCoordinates(scene: Scene, position: Cartesian3, result?: Cartesian2): Cartesian2;
function wgs84ToDrawingBufferCoordinates(scene: Scene, position: Cartesian3, result?: Cartesian2): Cartesian2;
}
enum StencilFunction {
NEVER,
LESS,
EQUAL,
LESS_OR_EQUAL,
GREATER,
NOT_EQUAL,
GREATER_OR_EQUAL,
ALWAYS,
}
enum StencilOperation {
ZERO,
KEEP,
REPLACE,
INCREMENT,
DECREMENT,
INVERT,
INCREMENT_WRAP,
DECREMENT_WRAP,
}
enum VerticalOrigin {
CENTER,
BOTTOM,
TOP,
}
function createWorldTerrain(options: {
requestVertexNormals?: boolean;
requestWaterMask?: boolean;
}): CesiumTerrainProvider;
class UrlTemplateImageryProvider extends ImageryProvider {
enablePickFeatures: boolean;
readonly pickFeaturesUrl: string;
readonly url: string;
readonly urlSchemeZeroPadding: {[templateVar: string]: string};
constructor(options: UrlTemplateImageryProvider.ConstructorOptions);
getTileCredits(x: number, y: number, level: number): Credit[];
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]> | undefined;
reinitialize(opts: UrlTemplateImageryProvider.ConstructorOptions | Promise<UrlTemplateImageryProvider.ConstructorOptions>): void;
requestImage(x: number, y: number, level: number, request?: Request): Promise<HTMLImageElement | HTMLCanvasElement> | undefined;
}
namespace UrlTemplateImageryProvider {
interface ConstructorOptions {
url: Resource | string,
pickFeaturesUrl?: Resource | string,
urlSchemeZeroPadding?: {[templateVar: string]: string},
subdomains?: string | Array<string>
credit?: Credit | string,
minimumLevel?: number,
maximumLevel?: number,
rectangle?: Rectangle,
tilingScheme?: TilingScheme,
ellipsoid?: Ellipsoid,
tileWidth?: number,
tileHeight?: number,
hasAlphaChannel?: boolean,
getFeatureInfoFormats?: Array<GetFeatureInfoFormat>,
enablePickFeatures?: boolean;
customTags?: {[templateVar: string]: string};
}
}
function defined(value: Object): boolean;
function buildModuleUrl(url: string): string;
namespace when {
function all<T>(promises: Promise<T>[]): Promise<T[]>;
function resolve<T>(val: T): Promise<T>;
}
function when(arg:any) : Promise<any>;
// TODO
var knockout: any;
}
@thw0rted
Copy link
Author

thw0rted commented Apr 2, 2018 •
edited
Loading

I forgot to update this gist as I've been keeping my local typings (more or less) up to date with new releases. The most recent version I've been using was from February, so I just included the 1.42.1 changes. I figure I'll probably skip 1.43 and wait for the April release. @beginor, you're welcome to update your repo with these.

Unfortunately, I haven't come up with a better way of managing these than hand-jamming updates based on the changelog when a new release drops. It doesn't take that long, and I don't mind, but it would be nice if they could be generated from JSDoc or something...

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment