Skip to content

Instantly share code, notes, and snippets.

@mgiraldo

mgiraldo/cesium.d.ts

Forked from icholy/cesium.d.ts
Last active May 16, 2023 11:27
Show Gist options
  • Save mgiraldo/f07432df1ccc50a0ea6e to your computer and use it in GitHub Desktop.
Save mgiraldo/f07432df1ccc50a0ea6e to your computer and use it in GitHub Desktop.
Download ZIP
Raw
cesium.d.ts
declare module Cesium {
export function defined(any): boolean;
export function defaultValue(a:any, b:any): any;
class RenderState {
static fromCache(any);
}
interface Promise<T> {
(arg: any): any;
}
interface Proxy {
getURL(resource: string): string;
}
class BingMapsApi {
static defaultKey: string;
}
class ArcGisImageServerTerrainProvider {
errorEvent: Event;
credit: Credit;
tilingScheme: GeographicTilingScheme;
ready: boolean;
hasWaterMask: boolean;
hasVertexNormals: boolean;
constructor(options: { url: string; token?: string; proxy?: any; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; credit?: Credit|string });
requestTileGeometry(x: number, y: number, level: number): Promise<TerrainData>;
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
}
class AssociativeArray {
length: number;
values: any[];
contains(key: string|number): boolean;
set(key: string|number, value: any);
get(key: string|number): any;
remove(key: string|number): boolean;
removeAll();
}
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 {
center: Cartesian3;
radius: number;
static packedLength: number;
constructor(center?: Cartesian3, radius?: number);
intersect(plane: Cartesian4): Intersect;
equals(right?: BoundingSphere): boolean;
clone(result?: BoundingSphere): BoundingSphere;
static fromPoints(positions: Cartesian3[], result?: BoundingSphere): BoundingSphere;
static fromRectangle2D(rectangle: Rectangle, projection?: any, result?: BoundingSphere): BoundingSphere;
static fromRectangleWithHeights2D(rectangle: Rectangle, projection?: any, minimumHeight?: number, maximumHeight?: number, result?: BoundingSphere): BoundingSphere;
static fromRectangle3D(rectangle: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: BoundingSphere): BoundingSphere;
static fromVertices(positions: Cartesian3[], center?: Cartesian3, stride?: number, result?: BoundingSphere): BoundingSphere;
static fromCornerPoints(corner?: number, oppositeCorner?: number, result?: BoundingSphere): BoundingSphere;
static fromEllipsoid(ellipsoid: Ellipsoid, result?: BoundingSphere): BoundingSphere;
static fromBoundingSpheres(boundingSpheres: BoundingSphere[], result?: BoundingSphere): BoundingSphere;
static clone(sphere: BoundingSphere, result?: BoundingSphere): BoundingSphere;
static pack(value: BoundingSphere, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: BoundingSphere);
static union(left: BoundingSphere, right: BoundingSphere, result?: BoundingSphere): BoundingSphere;
static expand(sphere: BoundingSphere, point: Cartesian3, result?: BoundingSphere): BoundingSphere;
static intersect(sphere: BoundingSphere, plane: Cartesian4): Intersect;
static transform(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
static distanceSquaredTo(sphere: BoundingSphere, cartesian: Cartesian3): number;
static transformWithoutScale(sphere: BoundingSphere, transform: Matrix4, result?: BoundingSphere): BoundingSphere;
static computePlaneDistances(sphere: BoundingSphere, position: Cartesian3, direction: Cartesian3, result?: Cartesian2): Interval;
static projectTo2D(sphere: BoundingSphere, projection?: any, result?: BoundingSphere): BoundingSphere;
static equals(left?: BoundingSphere, right?: BoundingSphere): boolean;
}
class BoxGeometry {
static packedLength: number;
constructor(options: { minimumCorner: Cartesian3; maximumCorner: Cartesian3; vertexFormat?: VertexFormat });
static fromDimensions();
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: BoxGeometry);
static createGeometry(boxGeometry: BoxGeometry): Geometry;
}
class BoxOutlineGeometry {
static packedLength: number;
constructor();
static fromDimensions();
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: 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 fromElements(x: number, y: number, result?: Cartesian2): Cartesian2;
static clone(cartesian: Cartesian2, result?: Cartesian2): Cartesian2;
static fromCartesian3(cartesian: Cartesian3, result?: Cartesian2): Cartesian2;
static fromCartesian4(cartesian: Cartesian4, result?: Cartesian2): Cartesian2;
static pack(value: Cartesian2, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: Cartesian2);
static fromArray(array: number[], startingIndex?: number, result?: Cartesian2): Cartesian2;
static maximumComponent(cartesian: Cartesian2): number;
static minimumComponent(cartesian: Cartesian2): number;
static minimumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
static maximumByComponent(first: Cartesian2, second: Cartesian2, result: Cartesian2): Cartesian2;
static magnitudeSquared(cartesian: Cartesian2): number;
static magnitude(cartesian: Cartesian2): number;
static distance(left: Cartesian2, right: Cartesian2): number;
static distanceSquared(left: Cartesian2, right: Cartesian2): number;
static normalize(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static dot(left: Cartesian2, right: Cartesian2): number;
static multiplyComponents(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static add(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static subtract(left: Cartesian2, right: Cartesian2, result: Cartesian2): Cartesian2;
static multiplyByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
static divideByScalar(cartesian: Cartesian2, scalar: number, result: Cartesian2): Cartesian2;
static negate(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static abs(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static lerp(start: Cartesian2, end: Cartesian2, t: number, result: Cartesian2): Cartesian2;
static angleBetween(left: Cartesian2, right: Cartesian2): number;
static mostOrthogonalAxis(cartesian: Cartesian2, result: Cartesian2): Cartesian2;
static equals(left?: Cartesian2, right?: Cartesian2): boolean;
static equalsEpsilon(left: Cartesian2, right: Cartesian2, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
}
class Cartesian3 {
x: number;
y: number;
z: number;
static packedLength: number;
static ZERO: Cartesian3;
static UNIT_X: Cartesian3;
static UNIT_Y: Cartesian3;
static UNIT_Z: Cartesian3;
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 fromSpherical(spherical: Spherical, result?: Cartesian3): Cartesian3;
static fromElements(x: number, y: number, z: number, result?: Cartesian3): Cartesian3;
static clone(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
static fromCartesian4(cartesian: Cartesian4, result?: Cartesian3): Cartesian3;
static pack(value: Cartesian3, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: Cartesian3);
static fromArray(array: number[], startingIndex?: number, result?: Cartesian3): Cartesian3;
static maximumComponent(cartesian: Cartesian3): number;
static minimumComponent(cartesian: Cartesian3): number;
static minimumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
static maximumByComponent(first: Cartesian3, second: Cartesian3, result: Cartesian3): Cartesian3;
static magnitudeSquared(cartesian: Cartesian3): number;
static magnitude(cartesian: Cartesian3): number;
static distance(left: Cartesian3, right: Cartesian3): number;
static distanceSquared(left: Cartesian3, right: Cartesian3): number;
static normalize(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static dot(left: Cartesian3, right: Cartesian3): number;
static multiplyComponents(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static add(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static subtract(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static multiplyByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
static divideByScalar(cartesian: Cartesian3, scalar: number, result: Cartesian3): Cartesian3;
static negate(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static abs(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static lerp(start: Cartesian3, end: Cartesian3, t: number, result: Cartesian3): Cartesian3;
static angleBetween(left: Cartesian3, right: Cartesian3): number;
static mostOrthogonalAxis(cartesian: Cartesian3, result: Cartesian3): Cartesian3;
static equals(left?: Cartesian3, right?: Cartesian3): boolean;
static equalsEpsilon(left: Cartesian3, right: Cartesian3, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
static cross(left: Cartesian3, right: Cartesian3, result: Cartesian3): Cartesian3;
static fromDegrees(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
static fromRadians(longitude: number, latitude: number, height?: number, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
static fromDegreesArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromRadiansArray(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromDegreesArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, result?: Cartesian3[]): Cartesian3[];
static fromRadiansArrayHeights(coordinates: number[], ellipsoid?: Ellipsoid, 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);
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);
clone(result?: Cartographic): Cartographic;
equals(right?: Cartographic): boolean;
equalsEpsilon(right: Cartographic, epsilon: number): boolean;
toString(): string;
static fromRadians(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
static fromDegrees(longitude: number, latitude: number, height?: number, result?: Cartographic): Cartographic;
static clone(cartographic: Cartographic, result?: Cartographic): Cartographic;
static equals(left?: Cartographic, right?: Cartographic): boolean;
static equalsEpsilon(left: Cartographic, right: Cartographic, epsilon: number): boolean;
}
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 CesiumTerrainProvider {
errorEvent: Event;
credit: Credit;
tilingScheme: GeographicTilingScheme;
ready: boolean;
hasWaterMask: boolean;
hasVertexNormals: boolean;
requestVertexNormals: boolean;
requestWaterMask: boolean;
constructor(options: { url: string; proxy?: Proxy; requestVertexNormals?: boolean; requestWaterMask?: boolean; ellipsoid?: Ellipsoid; credit?: Credit|string });
requestTileGeometry(x: number, y: number, level: number, throttleRequests?: boolean): Promise<TerrainData>;
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
}
class CircleGeometry {
static packedLength: number;
constructor(options: { center: Cartesian3; radius: number; ellipsoid?: Ellipsoid; height?: number; granularity?: number; vertexFormat?: VertexFormat; extrudedHeight?: number; stRotation?: number });
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: CircleGeometry);
static createGeometry(circleGeometry: CircleGeometry): Geometry;
}
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);
static unpack(array: number[], startingIndex?: number, result?: CircleOutlineGeometry);
static createGeometry(circleGeometry: CircleOutlineGeometry): Geometry;
}
class Clock {
startTime: JulianDate;
stopTime: JulianDate;
currentTime: JulianDate;
multiplier: number;
clockStep: ClockStep;
clockRange: ClockRange;
canAnimate: boolean;
shouldAnimate: boolean;
onTick;
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);
static unpack(array: number[], startingIndex?: number, result?: 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 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);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: CorridorOutlineGeometry);
static createGeometry(corridorOutlineGeometry: CorridorOutlineGeometry): Geometry;
}
class Credit {
text: string;
imageUrl: string;
link: string;
constructor(text?: string, imageUrl?: string, link?: string);
hasImage(): boolean;
hasLink(): boolean;
equals(credits: Credit): boolean;
static equals(left: Credit, right: 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);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: 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 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);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: 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);
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);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: 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);
}
class EllipsoidTerrainProvider {
errorEvent: Event;
credit: Credit;
tilingScheme: GeographicTilingScheme;
ready: boolean;
hasWaterMask: boolean;
hasVertexNormals: boolean;
constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid });
requestTileGeometry(x: number, y: number, level: number, throttleRequests?: boolean): Promise<TerrainData>;
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
}
class Event {
numberOfListeners: number;
addEventListener(listener: Function, scope?: any): Event.RemoveCallback;
removeEventListener(listener: Function, scope?: any): boolean;
raiseEvent(...args: any[]);
}
module Event{
type RemoveCallback = () => void;
}
class EventHelper {
add(event: Event, listener: Function, scope?: any): EventHelper.RemoveCallback;
removeAll();
}
module 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;
indices: any[];
primitiveType: PrimitiveType;
boundingSphere: BoundingSphere;
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;
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;
}
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 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);
static unpack(array: number[], startingIndex?: number, result?: Matrix2);
static clone(matrix: Matrix2, result?: Matrix2): Matrix2;
static fromArray(array: number[], startingIndex?: number, result?: Matrix2): Matrix2;
static fromColumnMajorArray(values: number[], result?: Matrix2);
static fromRowMajorArray(values: number[], result?: Matrix2);
static fromScale(scale: Cartesian2, result?: Matrix2);
static fromUniformScale(scale: number, result?: Matrix2);
static fromRotation(angle: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: Matrix3);
static clone(matrix: Matrix3, result?: Matrix3): Matrix3;
static fromArray(array: number[], startingIndex?: number, result?: Matrix3): Matrix3;
static fromColumnMajorArray(values: number[], result?: Matrix3);
static fromRowMajorArray(values: number[], result?: Matrix3);
static fromQuaternion(quaternion: Quaternion): Matrix3;
static fromScale(scale: Cartesian3, result?: Matrix3);
static fromUniformScale(scale: number, result?: Matrix3);
static fromCrossProduct(the: Cartesian3, result?: Matrix3);
static fromRotationX(angle: number, result?: Matrix3);
static fromRotationY(angle: number, result?: Matrix3);
static fromRotationZ(angle: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: Matrix4);
static clone(matrix: Matrix4, result?: Matrix4): Matrix4;
static fromArray(array: number[], startingIndex?: number, result?: Matrix4): Matrix4;
static fromColumnMajorArray(values: number[], result?: Matrix4);
static fromRowMajorArray(values: number[], result?: Matrix4);
static fromRotationTranslation(rotation: Matrix3, translation?: Cartesian3, result?: Matrix4);
static fromTranslationQuaternionRotationScale(translation: Cartesian3, rotation: Quaternion, scale: Cartesian3, result?: Matrix4);
static fromTranslation(translation: Cartesian3, result?: Matrix4);
static fromScale(scale: Cartesian3, result?: Matrix4);
static fromUniformScale(scale: number, result?: Matrix4);
static fromCamera(camera: Camera, result?: Matrix4);
static computePerspectiveFieldOfView(fovY: number, aspectRatio: number, near: number, far: number, result: Matrix4);
static computeOrthographicOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4);
static computePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4);
static computeInfinitePerspectiveOffCenter(left: number, right: number, bottom: number, top: number, near: number, far: number, result: Matrix4);
static computeViewportTransformation(viewport: any, nearDepthRange: number, farDepthRange: number, result: 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);
static unpack(array: number[], startingIndex?: number, result?: NearFarScalar);
static equals(left?: NearFarScalar, right?: NearFarScalar): boolean;
}
class ObjectOrientedBoundingBox {
rotation: Matrix3;
translation: Cartesian3;
scale: Cartesian3;
constructor(rotation?: Matrix3, translation?: Cartesian3, scale?: Cartesian3);
clone(result?: ObjectOrientedBoundingBox): ObjectOrientedBoundingBox;
equals(right?: ObjectOrientedBoundingBox): boolean;
static fromPoints(positions: Cartesian3[], result?: ObjectOrientedBoundingBox): ObjectOrientedBoundingBox;
static fromBoundingRectangle(boundingRectangle: BoundingRectangle, rotation?: number): ObjectOrientedBoundingBox;
static clone(box: ObjectOrientedBoundingBox, result?: ObjectOrientedBoundingBox): ObjectOrientedBoundingBox;
static intersect(left: ObjectOrientedBoundingBox, right: ObjectOrientedBoundingBox): boolean;
static equals(left: ObjectOrientedBoundingBox, right: ObjectOrientedBoundingBox): boolean;
}
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 fromPointNormal(point: Cartesian3, normal: Cartesian3, result?: Plane): Plane;
static getPointDistance(plane: Plane, point: Cartesian3): number;
}
class PolygonGeometry {
packedLength: number;
constructor(options: { polygonHierarchy: PolygonHierarchy; height?: number; extrudedHeight?: number; vertexFormat?: VertexFormat; stRotation?: number; ellipsoid?: Ellipsoid; granularity?: number; perPositionHeight?: boolean });
static fromPositions();
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: PolygonGeometry);
static createGeometry(polygonGeometry: PolygonGeometry): Geometry;
}
class PolygonHierarchy {
positions: Cartesian3[];
holes: PolygonHierarchy[];
constructor(positions?: Cartesian3[], holes?: PolygonHierarchy[]);
}
class PolygonOutlineGeometry {
packedLength: number;
constructor(options: { polygonHierarchy: any; height?: number; extrudedHeight?: number; vertexFormat?: VertexFormat; ellipsoid?: Ellipsoid; granularity?: number; perPositionHeight?: boolean });
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: PolygonOutlineGeometry);
static fromPositions();
static createGeometry(polygonGeometry: PolygonOutlineGeometry): Geometry;
}
class PolylineGeometry extends Geometry {
packedLength: number;
constructor(options: { positions: Cartesian3[]; width?: number; vertexFormat?: VertexFormat; colors?: Color[]; colorsPerVertex?: boolean; followSurface?: boolean; granularity?: number; ellipsoid?: Ellipsoid });
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: PolylineGeometry);
static createGeometry(polylineGeometry: PolylineGeometry): Geometry;
}
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);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: 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(heading: number, pitch: number, roll: number, result: Quaternion): Quaternion;
static pack(value: Quaternion, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: Quaternion);
static convertPackedArrayForInterpolation(packedArray: number[], startingIndex?: number, lastIndex?: number, result?: number[]);
static unpackInterpolationResult(array: number[], sourceArray: number[], startingIndex?: number, lastIndex?: number, result?: 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 {
length;
enqueue(item: any);
dequeue();
contains(item: any);
clear();
sort(compareFunction: Queue.Comparator);
}
module Queue{
type Comparator = (a: any, b: any) => number;
}
class Ray {
origin: Cartesian3;
direction: Cartesian3;
constructor(origin?: Cartesian3, direction?: Cartesian3);
static getPoint(t: number, result?: Cartesian3);
}
class Rectangle {
west: number;
south: number;
east: number;
north: number;
width: number;
height: number;
static packedLength: number;
static MAX_VALUE: Rectangle;
constructor(west?: number, south?: number, east?: number, north?: number);
clone(result?: Rectangle): Rectangle;
equals(other?: Rectangle): boolean;
equalsEpsilon(other: Rectangle, epsilon: number): boolean;
static pack(value: Rectangle, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: Rectangle);
static computeWidth(rectangle: Rectangle): number;
static computeHeight(rectangle: Rectangle): number;
static fromDegrees(west?: number, south?: number, east?: number, north?: number, result?: Rectangle): Rectangle;
static fromCartographicArray(cartographics: Cartographic[], result?: Rectangle): Rectangle;
static clone(rectangle: Rectangle, result?: Rectangle): Rectangle;
static equals(left?: Rectangle, right?: Rectangle): boolean;
static validate(rectangle: Rectangle);
static southwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
static northwest(rectangle: Rectangle, result?: Cartographic): Cartographic;
static northeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
static southeast(rectangle: Rectangle, result?: Cartographic): Cartographic;
static center(rectangle: Rectangle, result?: Cartographic): Cartographic;
static intersection(rectangle: Rectangle, otherRectangle: Rectangle, result?: Rectangle): Rectangle;
static contains(rectangle: Rectangle, cartographic: Cartographic): boolean;
static subsample(rectangle: Rectangle, ellipsoid?: Ellipsoid, surfaceHeight?: number, result?: Cartesian3[]): Cartesian3[];
}
class RectangleGeometry {
static packedLength: number;
constructor(options: { rectangle: Rectangle; vertexFormat?: VertexFormat; ellipsoid?: Ellipsoid; granularity?: number; height?: number; rotation?: number; stRotation?: number; extrudedHeight?: number });
static pack(value: BoundingSphere, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: RectangleGeometry);
static createGeometry(rectangleGeometry: RectangleGeometry): Geometry;
}
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);
static unpack(array: number[], startingIndex?: number, result?: RectangleGeometry);
static createGeometry(rectangleGeometry: RectangleOutlineGeometry): Geometry;
}
class RequestErrorEvent {
statusCode: number;
response: any;
responseHeaders: any;
constructor(statusCode?: number, response?: any, responseHeaders?: string|any);
toString(): string;
}
class RuntimeError {
name: string;
message: string;
stack: string;
constructor(message?: string);
}
class ScreenSpaceEventHandler {
constructor(element?: HTMLCanvasElement);
setInputAction(action: Function, type: number, modifier?: number);
getInputAction(type: number, modifier?: number);
removeInputAction(type: number, modifier?: number);
isDestroyed(): boolean;
destroy();
}
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: { positions: Cartesian3[]; colors?: Color[]; colorsPerVertex?: boolean; followSurface?: boolean; granularity?: number; ellipsoid?: Ellipsoid });
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: SimplePolylineGeometry);
static createGeometry(simplePolylineGeometry: SimplePolylineGeometry): Geometry;
}
class SphereGeometry {
static packedLength: number;
constructor(options?: { radius?: number; stackPartitions?: number; slicePartitions?: number; vertexFormat?: VertexFormat });
static pack(value: any, array: number[], startingIndex?: number);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: SphereOutlineGeometry);
static createGeometry(sphereGeometry: SphereOutlineGeometry): Geometry;
}
class Spherical {
constructor(clock?: number, cone?: number, magnitude?: number);
equals(other: Spherical);
clone(result?: Spherical);
equalsEpsilon(other: Spherical, epsilon: number);
toString();
static fromCartesian3(cartesian3: Cartesian3, spherical?: Spherical);
static clone(spherical: Spherical, result?: Spherical);
static normalize(spherical: Spherical, result?: Spherical);
static equals(left: Spherical, right: Spherical);
static equalsEpsilon(left: Spherical, right: Spherical, epsilon?: number);
}
class Spline {
times: number[];
points: Cartesian3[]|Quaternion[];
evaluate(time: number, result?: Cartesian3|Quaternion): Cartesian3|Quaternion;
findTimeInterval(time: number, startIndex: number): number;
}
class TaskProcessor {
constructor(workerName: string, maximumActiveTasks?: number);
scheduleTask(parameters: any, transferableObjects?: any[]): Promise<any>;
isDestroyed(): boolean;
destroy();
}
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);
}
class TerrainProvider {
errorEvent: Event;
credit: Credit;
tilingScheme: TilingScheme;
ready: boolean;
hasWaterMask: boolean;
hasVertexNormals: boolean;
static heightmapTerrainQuality;
requestTileGeometry(x: number, y: number, level: number, throttleRequests?: boolean): Promise<TerrainData>;
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
static getRegularGridIndices(width: number, height: number): Uint16Array;
static getEstimatedLevelZeroGeometricErrorForAHeightmap(ellipsoid: Ellipsoid, tileImageWidth: number, numberOfTilesAtLevelZero: number): number;
}
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);
}
module 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: any;
isStartIncluded: boolean;
isStopIncluded: boolean;
isEmpty: boolean;
static EMPTY: TimeInterval;
constructor(options?: { start?: JulianDate; stop?: JulianDate; isStartIncluded?: boolean; isStopIncluded?: boolean; data?: any });
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?: any }, 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;
}
module TimeInterval{
type MergeCallback = (leftData: any, rightData: any) => any;
type DataComparer = (leftData: any, rightData: any) => boolean;
}
class TimeIntervalCollection {
changedEvent: Event;
start: JulianDate;
isStartIncluded: boolean;
stop: JulianDate;
isStopIncluded: boolean;
length: number;
isEmpty: boolean;
constructor(intervals?: TimeInterval[]);
equals(right?: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer): boolean;
get(index: number): TimeInterval;
removeAll();
findIntervalContainingDate(date: JulianDate);
findDataForIntervalContainingDate(date: JulianDate);
contains(julianDate: JulianDate): boolean;
indexOf(date: JulianDate);
findInterval(options?: { start?: JulianDate; stop?: JulianDate; isStartIncluded?: boolean; isStopIncluded?: boolean });
addInterval(interval: TimeInterval, dataComparer?: TimeInterval.DataComparer);
removeInterval(interval: TimeInterval);
intersect(other: TimeIntervalCollection, dataComparer?: TimeInterval.DataComparer, mergeCallback?: TimeInterval.MergeCallback);
}
class VRTheWorldTerrainProvider {
errorEvent: Event;
credit: Credit;
tilingScheme: GeographicTilingScheme;
ready: boolean;
hasWaterMask: boolean;
hasVertexNormals: boolean;
constructor(options: { url: string; proxy?: any; ellipsoid?: Ellipsoid; credit?: Credit|string });
requestTileGeometry(x: number, y: number, level: number, throttleRequests?: boolean): Promise<TerrainData>;
getLevelMaximumGeometricError(level: number): number;
getTileDataAvailable(x: number, y: number, level: number): boolean;
}
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);
static unpack(array: number[], startingIndex?: number, result?: 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);
static unpack(array: number[], startingIndex?: number, result?: WallGeometry);
static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid);
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);
static unpack(array: number[], startingIndex?: number, result?: WallOutlineGeometry);
static fromConstantHeights(positions: Cartesian3[], maximumHeight?: number, minimumHeight?: number, ellipsoid?: Ellipsoid);
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 {
definitionChanged: Event;
image: Property;
imageSubRegion: Property;
scale: Property;
rotation: Property;
alignedAxis: Property;
horizontalOrigin: Property;
verticalOrigin: Property;
color: Property;
eyeOffset: Property;
pixelOffset: Property;
show: Property;
width: Property;
height: Property;
scaleByDistance: Property;
translucencyByDistance: Property;
pixelOffsetScaleByDistance: Property;
constructor(options?: { image?: Property; show?: Property; scale?: Property; horizontalOrigin?: Property; verticalOrigin?: Property; eyeOffset?: Property; pixelOffset?: Property; rotation?: Property; alignedAxis?: Property; width?: Property; height?: Property; color?: Property; scaleByDistance?: Property; translucencyByDistance?: Property; pixelOffsetScaleByDistance?: Property; imageSubRegion?: Property });
clone(result?: BillboardGraphics): BillboardGraphics;
merge(source: BillboardGraphics);
}
class BillboardVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy();
}
class BoxGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class BoxGraphics {
definitionChanged: Event;
show: Property;
dimensions: Property;
material: MaterialProperty;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
constructor(options?: { dimensions?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property });
clone(result?: BoxGraphics): BoxGraphics;
merge(source: BoxGraphics);
}
class CallbackProperty {
isConstant: boolean;
definitionChanged: Event;
constructor(callback: CallbackProperty.Callback, isConstant: boolean);
getValue(time?: JulianDate, result?: any): any;
setCallback(callback: CallbackProperty.Callback, isConstant: boolean);
equals(other?: Property): boolean;
}
module CallbackProperty{
type Callback = (time?: JulianDate, result?: any) => any;
}
class CheckerboardMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
evenColor: Property;
oddColor: Property;
repeat: Property;
constructor(options?: { evenColor?: Property; oddColor?: Property; repeat?: Property });
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class ColorMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
color: Property;
constructor(color?: Property);
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class CompositeEntityCollection {
collectionChanged: Event;
id: string;
values: Entity[];
constructor(collections?: EntityCollection[]);
addCollection(collection: EntityCollection, index?: number);
removeCollection(collection: EntityCollection): boolean;
removeAllCollections();
containsCollection(collection: EntityCollection): boolean;
contains(entity): boolean;
indexOfCollection(collection: EntityCollection): number;
getCollection(index: number);
getCollectionsLength();
raiseCollection(collection: EntityCollection);
lowerCollection(collection: EntityCollection);
raiseCollectionToTop(collection: EntityCollection);
lowerCollectionToBottom(collection: EntityCollection);
suspendEvents();
resumeEvents();
computeAvailability(): TimeInterval;
getById(id: any): Entity;
}
class CompositeMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
intervals: TimeIntervalCollection;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class CompositePositionProperty {
isConstant: boolean;
definitionChanged: Event;
intervals: TimeIntervalCollection;
referenceFrame: ReferenceFrame;
getValue(time: JulianDate, result?: any): any;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
equals(other?: Property): boolean;
}
class CompositeProperty {
isConstant: boolean;
definitionChanged: Event;
intervals: TimeIntervalCollection;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class ConstantPositionProperty {
isConstant: boolean;
definitionChanged: Event;
referenceFrame: ReferenceFrame;
constructor(value?: Cartesian3, referenceFrame?: ReferenceFrame);
getValue(time: JulianDate, result?: any): any;
setValue(value: Cartesian3, referenceFrame?: ReferenceFrame);
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
equals(other?: Property): boolean;
}
class ConstantProperty {
isConstant: boolean;
definitionChanged: Event;
constructor(value?: any);
getValue(time?: JulianDate, result?: any): any;
setValue(value: any);
equals(other?: Property): boolean;
}
class CorridorGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class CorridorGraphics {
definitionChanged: Event;
show: Property;
material: MaterialProperty;
positions: Property;
height: Property;
extrudedHeight: Property;
granularity: Property;
width: Property;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
cornerType: Property;
constructor(options?: { positions?: Property; width?: Property; cornerType?: Property; height?: Property; extrudedHeight?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; granularity?: Property });
clone(result?: CorridorGraphics): CorridorGraphics;
merge(source: CorridorGraphics);
}
class CustomDataSource {
name: string;
clock: DataSourceClock;
entities: EntityCollection;
isLoading: boolean;
changedEvent: Event;
errorEvent: Event;
loadingEvent: Event;
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;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class CylinderGraphics {
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?: { length?: Property; topRadius?: Property; bottomRadius?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; numberOfVerticalLines?: Property; slices?: Property });
clone(result?: CylinderGraphics): CylinderGraphics;
merge(source: CylinderGraphics);
}
class CzmlDataSource {
name: string;
clock: DataSourceClock;
entities: EntityCollection;
isLoading: boolean;
changedEvent: Event;
errorEvent: Event;
loadingEvent: Event;
static updaters: any[];
constructor(name?: string);
process(data: string|any, options?: { sourceUri?: string }): Promise<CzmlDataSource>;
load(data: string|any, 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);
static processPositionPacketData(object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection);
static processMaterialPacketData(object: any, propertyName: string, packetData: any, interval: TimeInterval, sourceUri: string, entityCollection: EntityCollection);
}
class DataSource {
name: string;
clock: DataSourceClock;
entities: EntityCollection;
isLoading: boolean;
changedEvent: Event;
errorEvent: Event;
loadingEvent: Event;
update(time: JulianDate): boolean;
}
class DataSourceClock {
definitionChanged: Event;
startTime: JulianDate;
stopTime: JulianDate;
currentTime: JulianDate;
clockRange: ClockRange;
clockStep: ClockStep;
multiplier: number;
clone(result?: DataSourceClock): DataSourceClock;
equals(other: DataSourceClock): boolean;
merge(source: DataSourceClock);
getValue(): Clock;
}
class DataSourceCollection {
length: number;
dataSourceAdded: Event;
dataSourceRemoved: Event;
add(dataSource: DataSource|Promise<DataSource>): Promise<DataSource>;
remove(dataSource: DataSource, destroy?: boolean): boolean;
removeAll(destroy?: boolean);
contains(dataSource: DataSource): boolean;
indexOf(dataSource: DataSource): number;
get(index: number);
isDestroyed(): boolean;
destroy();
}
class DataSourceDisplay {
scene: Scene;
dataSources: DataSourceCollection;
defaultDataSource: CustomDataSource;
static defaultVisualizersCallback: DataSourceDisplay.VisualizersCallback;
constructor(options: { scene: Scene; dataSourceCollection: DataSourceCollection; visualizersCallback?: DataSourceDisplay.VisualizersCallback });
isDestroyed(): boolean;
destroy();
update(time: JulianDate): boolean;
}
module DataSourceDisplay{
type VisualizersCallback = (scene: Scene, dataSource: DataSource) => Visualizer[];
}
class DynamicGeometryUpdater {
update;
isDestroyed;
destroy;
}
class EllipseGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class EllipseGraphics {
definitionChanged: Event;
semiMajorAxis: Property;
semiMinorAxis: Property;
rotation: Property;
show: Property;
material: MaterialProperty;
height: Property;
extrudedHeight: Property;
granularity: Property;
stRotation: Property;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
numberOfVerticalLines: Property;
constructor(options?: { semiMajorAxis?: Property; semiMinorAxis?: Property; height?: Property; extrudedHeight?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; numberOfVerticalLines?: Property; rotation?: Property; stRotation?: Property; granularity?: Property });
clone(result?: EllipseGraphics): EllipseGraphics;
merge(source: EllipseGraphics);
}
class EllipsoidGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class EllipsoidGraphics {
definitionChanged: Event;
show: Property;
radii: Property;
material: MaterialProperty;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
stackPartitions: Property;
slicePartitions: Property;
subdivisions: Property;
constructor(options?: { radii?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; subdivisions?: Property; stackPartitions?: Property; slicePartitions?: Property });
clone(result?: EllipsoidGraphics): EllipsoidGraphics;
merge(source: EllipsoidGraphics);
}
class Entity {
availability: TimeIntervalCollection;
id: string;
definitionChanged: Event;
name: string;
show: boolean;
isShowing: boolean;
parent: Entity;
propertyNames: Event;
billboard: BillboardGraphics;
box: BoxGraphics;
corridor: CorridorGraphics;
cylinder: CylinderGraphics;
description: Property;
ellipse: EllipseGraphics;
ellipsoid: EllipsoidGraphics;
label: LabelGraphics;
model: ModelGraphics;
orientation: Property;
path: PathGraphics;
point: PointGraphics;
polygon: PolygonGraphics;
polyline: PolylineGraphics;
polylineVolume: PolylineVolumeGraphics;
position: PositionProperty;
rectangle: RectangleGraphics;
viewFrom: Property;
wall: WallGraphics;
constructor(options?: { id?: string; name?: string; show?: boolean; description?: Property; position?: PositionProperty; orientation?: Property; viewFrom?: Property; parent?: Entity; billboard?: BillboardGraphics; box?: BoxGraphics; corridor?: CorridorGraphics; cylinder?: CylinderGraphics; ellipse?: EllipseGraphics; ellipsoid?: EllipsoidGraphics; label?: LabelGraphics; model?: ModelGraphics; path?: PathGraphics; point?: PointGraphics; polygon?: PolygonGraphics; polyline?: PolylineGraphics; polylineVolume?: PolylineVolumeGraphics; rectangle?: RectangleGraphics; wall?: WallGraphics });
isAvailable(time: JulianDate);
addProperty(propertyName: string);
removeProperty(propertyName: string);
merge(source: Entity);
}
class EntityCollection {
collectionChanged: Event;
id: string;
values: Entity[];
suspendEvents();
resumeEvents();
computeAvailability(): TimeInterval;
add(entity: Entity);
remove(entity: Entity): boolean;
contains(entity): boolean;
removeById(id: any): boolean;
removeAll();
getById(id: any): Entity;
getOrCreateEntity(id: any): Entity;
static collectionChangedEventCallback(collection: EntityCollection, added: Entity[], removed: Entity[], changed: Entity[]);
}
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);
}
class GeoJsonDataSource {
name: string;
clock: DataSourceClock;
entities: EntityCollection;
isLoading: boolean;
changedEvent: Event;
errorEvent: Event;
loadingEvent: Event;
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: string|any, options?: { sourceUri?: string; markerSize?: number; markerSymbol?: string; markerColor?: Color; stroke?: Color; strokeWidth?: number; fill?: Color }): Promise<GeoJsonDataSource>;
static load(data: string|any, options?: { sourceUri?: string; markerSize?: number; markerSymbol?: string; markerColor?: Color; stroke?: Color; strokeWidth?: number; fill?: Color }): Promise<GeoJsonDataSource>;
}
class GeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class GeometryVisualizer {
constructor(type: GeometryUpdater, scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy();
}
class GridMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
color: Property;
cellAlpha: Property;
lineCount: Property;
lineThickness: Property;
lineOffset: Property;
constructor(options?: { color?: Property; cellAlpha?: Property; lineCount?: Property; lineThickness?: Property; lineOffset?: Property });
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class ImageMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
image: Property;
repeat: Property;
constructor(options?: { image?: Property; repeat?: Property });
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class KmlDataSource {
name: string;
clock: DataSourceClock;
entities: EntityCollection;
isLoading: boolean;
changedEvent: Event;
errorEvent: Event;
loadingEvent: Event;
constructor(proxy?: DefaultProxy);
load(data: string|Document|Blob, options?: { sourceUri?: number }): Promise<KmlDataSource>;
static load(data: string|Document|Blob, options?: { proxy?: DefaultProxy; sourceUri?: string }): Promise<KmlDataSource>;
}
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 {
definitionChanged: Event;
text: Property;
font: Property;
style: Property;
fillColor: Property;
outlineColor: Property;
outlineWidth: Property;
horizontalOrigin: Property;
verticalOrigin: Property;
eyeOffset: Property;
pixelOffset: Property;
scale: Property;
show: Property;
translucencyByDistance: Property;
pixelOffsetScaleByDistance: Property;
constructor(options?: { text?: Property; font?: Property; style?: Property; fillColor?: Property; outlineColor?: Property; outlineWidth?: Property; show?: Property; scale?: Property; horizontalOrigin?: Property; verticalOrigin?: Property; eyeOffset?: Property; pixelOffset?: Property; translucencyByDistance?: Property; pixelOffsetScaleByDistance?: Property });
clone(result?: LabelGraphics): LabelGraphics;
merge(source: LabelGraphics);
}
class LabelVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy();
}
class MaterialProperty {
isConstant: boolean;
definitionChanged: Event;
equals;
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
}
class ModelGraphics {
definitionChanged: Event;
show: Property;
scale: Property;
minimumPixelSize: Property;
uri: Property;
constructor(options?: { uri?: Property; show?: Property; scale?: Property; minimumPixelSize?: Property });
clone(result?: ModelGraphics): ModelGraphics;
merge(source: ModelGraphics);
}
class ModelVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy();
}
class PathGraphics {
definitionChanged: Event;
show: Property;
material: MaterialProperty;
width: Property;
resolution: Property;
leadTime: Property;
trailTime: Property;
constructor(options?: { leadTime?: Property; trailTime?: Property; show?: Property; width?: Property; material?: MaterialProperty; resolution?: Property });
clone(result?: PathGraphics): PathGraphics;
merge(source: PathGraphics);
}
class PathVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy();
}
class PointGraphics {
definitionChanged: Event;
color: Property;
pixelSize: Property;
outlineColor: Property;
outlineWidth: Property;
show: Property;
scaleByDistance: Property;
translucencyByDistance: Property;
constructor(options?: { color?: Property; pixelSize?: Property; outlineColor?: Property; outlineWidth?: Property; show?: Property; scaleByDistance?: Property; translucencyByDistance?: Property });
clone(result?: PointGraphics): PointGraphics;
merge(source: PointGraphics);
}
class PointVisualizer {
constructor(scene: Scene, entityCollection: EntityCollection);
update(time: JulianDate): boolean;
isDestroyed(): boolean;
destroy();
}
class PolygonGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class PolygonGraphics {
definitionChanged: Event;
show: Property;
material: MaterialProperty;
positions: Property;
hierarchy: Property;
height: Property;
extrudedHeight: Property;
granularity: Property;
stRotation: Property;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
perPositionHeight: Property;
constructor(options?: { hierarchy?: Property; height?: Property; extrudedHeight?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; stRotation?: Property; granularity?: Property; perPositionHeight?: Property });
clone(result?: PolygonGraphics): PolygonGraphics;
merge(source: PolygonGraphics);
}
class PolylineArrowMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
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;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class PolylineGlowMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
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 {
definitionChanged: Event;
show: Property;
material: MaterialProperty;
positions: Property;
width: Property;
followSurface: Property;
granularity: Property;
constructor(options?: { positions?: Property; followSurface?: Property; width?: Property; show?: Property; material?: MaterialProperty; granularity?: Property });
clone(result?: PolylineGraphics): PolylineGraphics;
merge(source: PolylineGraphics);
}
class PolylineOutlineMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
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;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class PolylineVolumeGraphics {
definitionChanged: Event;
show: Property;
material: MaterialProperty;
positions: Property;
shape: Property;
granularity: Property;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
cornerType: Property;
constructor(options?: { positions?: Property; shape?: Property; cornerType?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; granularity?: Property });
clone(result?: PolylineVolumeGraphics): PolylineVolumeGraphics;
merge(source: PolylineVolumeGraphics);
}
class PositionProperty {
isConstant: boolean;
definitionChanged: Event;
referenceFrame: ReferenceFrame;
equals;
getValue(time: JulianDate, result?: Cartesian3): Cartesian3;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
}
class PositionPropertyArray {
isConstant: boolean;
definitionChanged: Event;
referenceFrame: ReferenceFrame;
constructor(value?: Property[]);
getValue(time?: JulianDate, result?: Cartesian3[]): Cartesian3[];
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
setValue(value: Property[]);
equals(other?: Property): boolean;
}
class Property {
isConstant: boolean;
definitionChanged: Event;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class PropertyArray {
isConstant: boolean;
definitionChanged: Event;
constructor(value?: Property[]);
getValue(time?: JulianDate, result?: any[]): any[];
setValue(value: Property[]);
equals(other?: Property): boolean;
}
class RectangleGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class RectangleGraphics {
definitionChanged: Event;
show: Property;
coordinates: Property;
material: MaterialProperty;
height: Property;
extrudedHeight: Property;
granularity: Property;
stRotation: Property;
rotation: Property;
fill: Property;
outline: Property;
outlineColor: Property;
outlineWidth: Property;
closeTop: Property;
closeBottom: Property;
constructor(options?: { coordinates?: Property; height?: Property; extrudedHeight?: Property; closeTop?: Property; closeBottom?: Property; show?: Property; fill?: Property; material?: MaterialProperty; outline?: Property; outlineColor?: Property; outlineWidth?: Property; rotation?: Property; stRotation?: Property; granularity?: Property });
clone(result?: RectangleGraphics): RectangleGraphics;
merge(source: RectangleGraphics);
}
class ReferenceProperty {
isConstant: boolean;
definitionChanged: Event;
referenceFrame: ReferenceFrame;
targetId: string;
targetCollection: EntityCollection;
targetPropertyNames: string[];
resolvedProperty: Property;
constructor(targetCollection: EntityCollection, targetId: string, targetPropertyNames: string);
getValue(time: JulianDate, result?: any): any;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
getType(time: JulianDate): string;
equals(other?: Property): boolean;
static fromString(targetCollection: Entity, referenceString: string);
}
class SampledPositionProperty {
isConstant: boolean;
definitionChanged: Event;
referenceFrame: ReferenceFrame;
interpolationDegree: number;
interpolationAlgorithm: InterpolationAlgorithm;
numberOfDerivatives: boolean;
forwardExtrapolationType: ExtrapolationType;
forwardExtrapolationDuration: number;
backwardExtrapolationType: ExtrapolationType;
backwardExtrapolationDuration: number;
constructor(referenceFrame?: ReferenceFrame, numberOfDerivatives?: number);
getValue(time: JulianDate, result?: Cartesian3): Cartesian3;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm; interpolationDegree?: number });
addSample(time: JulianDate, position: Cartesian3, derivatives?: Cartesian3[]);
addSamples(times: JulianDate[], positions: Cartesian3[], derivatives?: any[][]);
addSamplesPackedArray(packedSamples: number[], epoch?: JulianDate);
equals(other?: Property): boolean;
}
class SampledProperty {
isConstant: boolean;
definitionChanged: Event;
type: any;
derivativeTypes: Packable[];
interpolationDegree: number;
interpolationAlgorithm: InterpolationAlgorithm;
forwardExtrapolationType: ExtrapolationType;
forwardExtrapolationDuration: number;
backwardExtrapolationType: ExtrapolationType;
backwardExtrapolationDuration: number;
constructor(type: number|Packable, derivativeTypes?: Packable[]);
getValue(time: JulianDate, result?: any): any;
setInterpolationOptions(options?: { interpolationAlgorithm?: InterpolationAlgorithm; interpolationDegree?: number });
addSample(time: JulianDate, value: Packable, derivatives?: Packable[]);
addSamples(times: JulianDate[], values: Packable[], derivativeValues?: any[][]);
addSamplesPackedArray(packedSamples: number[], epoch?: JulianDate);
equals(other?: Property): boolean;
}
class StripeMaterialProperty {
isConstant: boolean;
definitionChanged: Event;
orientation: Property;
evenColor: Property;
oddColor: Property;
offset: Property;
repeat: Property;
constructor(options?: { evenColor?: Property; oddColor?: Property; repeat?: Property; offset?: Property; orientation?: Property });
getType(time: JulianDate): string;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class TimeIntervalCollectionPositionProperty {
isConstant: boolean;
definitionChanged: Event;
intervals: TimeIntervalCollection;
referenceFrame: ReferenceFrame;
constructor(referenceFrame?: ReferenceFrame);
getValue(time: JulianDate, result?: any): any;
getValueInReferenceFrame(time: JulianDate, referenceFrame: ReferenceFrame, result?: Cartesian3): Cartesian3;
equals(other?: Property): boolean;
}
class TimeIntervalCollectionProperty {
isConstant: boolean;
definitionChanged: Event;
intervals: TimeIntervalCollection;
getValue(time: JulianDate, result?: any): any;
equals(other?: Property): boolean;
}
class VelocityOrientationProperty {
isConstant: boolean;
definitionChanged: Event;
position: Property;
ellipsoid: 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();
}
class WallGeometryUpdater {
entity: Entity;
fillEnabled: boolean;
hasConstantFill: boolean;
fillMaterialProperty: MaterialProperty;
outlineEnabled: boolean;
hasConstantOutline: boolean;
outlineColorProperty: Property;
outlineWidth: number;
isDynamic: boolean;
isClosed: boolean;
geometryChanged: boolean;
static perInstanceColorAppearanceType: Appearance;
static materialAppearanceType: Appearance;
constructor(entity: Entity, scene: Scene);
isOutlineVisible(time: JulianDate): boolean;
isFilled(time: JulianDate): boolean;
createFillGeometryInstance(time: JulianDate): GeometryInstance;
createOutlineGeometryInstance(time: JulianDate): GeometryInstance;
isDestroyed(): boolean;
destroy();
createDynamicUpdater(primitives: PrimitiveCollection): DynamicGeometryUpdater;
}
class WallGraphics {
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);
}
class Appearance {
material: Material;
translucent: boolean;
vertexShaderSource: string;
fragmentShaderSource: string;
renderState: any;
closed: boolean;
constructor(options?: { translucent?: boolean; closed?: boolean; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
getFragmentShaderSource(): string;
isTranslucent(): boolean;
getRenderState(): any;
}
class ArcGisMapServerImageryProvider {
url: string;
proxy: Proxy;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
usingPrecachedTiles: boolean;
hasAlphaChannel: boolean;
constructor(options: { url: string; tileDiscardPolicy?: TileDiscardPolicy; proxy?: Proxy; usePreCachedTilesIfAvailable?: boolean; enablePickFeatures?: boolean; rectangle?: Rectangle; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; tileWidth?: number; tileHeight?: number; maximumLevel?: number }, layers?: string);
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 Billboard {
show: boolean;
position: Cartesian3;
pixelOffset: Cartesian2;
scaleByDistance: NearFarScalar;
translucencyByDistance: NearFarScalar;
pixelOffsetScaleByDistance: NearFarScalar;
eyeOffset: Cartesian3;
horizontalOrigin: HorizontalOrigin;
verticalOrigin: VerticalOrigin;
scale: number;
color;
rotation: number;
alignedAxis: Cartesian3;
width: number;
height: number;
id: any;
image: string;
ready: boolean;
setImage(id: string, image: HTMLImageElement|HTMLCanvasElement|string|Billboard.CreateImageCallback);
setImageSubRegion(id: string, subRegion: BoundingRectangle);
computeScreenSpacePosition(scene: Scene, result?: Cartesian2): Cartesian2;
equals(other: Billboard): boolean;
}
module 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();
contains(billboard?: Billboard): boolean;
get(index: number): Billboard;
update();
isDestroyed(): boolean;
destroy();
}
class BingMapsImageryProvider {
defaultGamma: number;
url: string;
proxy: Proxy;
key: string;
mapStyle: BingMapsStyle;
culture: string;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
constructor(options: { url: string; key?: string; tileProtocol?: string; mapStyle?: string; culture?: string; ellipsoid?: Ellipsoid; tileDiscardPolicy?: TileDiscardPolicy; proxy?: Proxy });
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[]>;
static tileXYToQuadKey(x: number, y: number, level: number);
static quadKeyToTileXY(quadkey: string);
}
class Camera {
position: Cartesian3;
direction: Cartesian3;
up: Cartesian3;
right: Cartesian3;
frustum: OrthographicFrustum;
defaultMoveAmount: number;
defaultLookAmount: number;
defaultRotateAmount: number;
defaultZoomAmount: number;
constrainedAxis: Cartesian3;
maximumTranslateFactor: number;
maximumZoomFactor: number;
transform: Matrix4;
inverseTransform: Matrix4;
viewMatrix: Matrix4;
inverseViewMatrix: Matrix4;
positionCartographic: Cartographic;
positionWC: Cartesian3;
directionWC: Cartesian3;
upWC: Cartesian3;
rightWC: Cartesian3;
heading: number;
pitch: number;
roll: number;
moveStart: Event;
moveEnd: Event;
static DEFAULT_VIEW_RECTANGLE: Rectangle;
static DEFAULT_VIEW_FACTOR: number;
setView();
worldToCameraCoordinates(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
worldToCameraCoordinatesPoint(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
worldToCameraCoordinatesVector(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
cameraToWorldCoordinates(cartesian: Cartesian4, result?: Cartesian4): Cartesian4;
cameraToWorldCoordinatesPoint(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
cameraToWorldCoordinatesVector(cartesian: Cartesian3, result?: Cartesian3): Cartesian3;
move(direction: Cartesian3, amount?: number);
moveForward(amount?: number);
moveBackward(amount?: number);
moveUp(amount?: number);
moveDown(amount?: number);
moveRight(amount?: number);
moveLeft(amount?: number);
lookLeft(amount?: number);
lookRight(amount?: number);
lookUp(amount?: number);
lookDown(amount?: number);
look(axis: Cartesian3, angle?: number);
twistLeft(amount?: number);
twistRight(amount?: number);
rotate(axis: Cartesian3, angle?: number);
rotateDown(angle?: number);
rotateUp(angle?: number);
rotateRight(angle?: number);
rotateLeft(angle?: number);
zoomIn(amount?: number);
zoomOut(amount?: number);
getMagnitude(): number;
lookAt(target: Cartesian3, offset: Cartesian3|HeadingPitchRange);
lookAtTransform(transform: Matrix4, offset: Cartesian3|HeadingPitchRange);
getRectangleCameraCoordinates(rectangle: Rectangle, result?: Cartesian3): Cartesian3;
viewRectangle(rectangle: Rectangle, ellipsoid?: Ellipsoid);
pickEllipsoid(windowPosition: Cartesian2, ellipsoid?: Ellipsoid, result?: Cartesian3): Cartesian3;
getPickRay(windowPosition: Cartesian2, result?: Ray): any;
flyTo(options: { destination: Cartesian3|Rectangle; orientation?: any; duration?: number; complete?: Camera.FlightCompleteCallback; cancel?: Camera.FlightCancelledCallback; endTransform?: Matrix4; convert?: boolean });
viewBoundingSphere(boundingSphere: BoundingSphere, offset?: HeadingPitchRange);
flyToBoundingSphere(boundingSphere: BoundingSphere, options?: { duration?: number; offset?: HeadingPitchRange; complete?: Camera.FlightCompleteCallback; cancel?: Camera.FlightCancelledCallback; endTransform?: Matrix4 });
clone(): Camera;
}
module Camera{
type FlightCompleteCallback = () => void;
type FlightCancelledCallback = () => 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();
isDestroyed(): boolean;
destroy();
}
class CreditDisplay {
constructor(container: HTMLElement, delimiter?: string);
addCredit(credit: Credit);
addDefaultCredit(credit: Credit);
removeDefaultCredit(credit: Credit);
beginFrame(credit: Credit);
endFrame(credit: Credit);
destroy();
isDestroyed(): boolean;
}
class CullingVolume {
planes: Cartesian4[];
constructor(planes: Cartesian4[]);
computeVisibility(boundingVolume: any): 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();
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();
}
class DiscardMissingTileImagePolicy {
constructor(options: { missingImageUrl: string; pixelsToCheck: Cartesian2[]; disableCheckIfAllPixelsAreTransparent?: boolean });
isReady();
shouldDiscardImage(image: HTMLImageElement);
}
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();
isDestroyed(): boolean;
destroy();
}
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();
isTranslucent(): boolean;
getRenderState(): any;
}
class FrameRateMonitor {
samplingWindow: number;
quietPeriod: number;
warmupPeriod: number;
minimumFrameRateDuringWarmup: number;
minimumFrameRateAfterWarmup: number;
scene: Scene;
lowFrameRate: Event;
nominalFrameRate: Event;
lastFramesPerSecond: number;
static defaultSettings;
constructor(options?: { scene: Scene; samplingWindow?: number; quietPeriod?: number; warmupPeriod?: number; minimumFrameRateDuringWarmup?: number; minimumFrameRateAfterWarmup?: number });
pause();
unpause();
isDestroyed(): boolean;
destroy();
static fromScene(scene: Scene): FrameRateMonitor;
}
class GetFeatureInfoFormat {
constructor(type: string, format?: string);
}
class Globe {
terrainProvider: TerrainProvider;
northPoleColor: Cartesian3;
southPoleColor: Cartesian3;
show: boolean;
oceanNormalMapUrl: string;
depthTestAgainstTerrain: boolean;
maximumScreenSpaceError: number;
tileCacheSize: number;
enableLighting: boolean;
lightingFadeOutDistance: number;
lightingFadeInDistance: number;
showWaterEffect: boolean;
ellipsoid: Ellipsoid;
imageryLayers: ImageryLayerCollection;
baseColor: Color;
constructor(ellipsoid?: Ellipsoid);
pick(ray: Ray, scene: Scene, result?: Cartesian3): Cartesian3;
getHeight(cartographic: Cartographic): number;
isDestroyed(): boolean;
destroy();
}
class GoogleEarthImageryProvider {
defaultGamma: number;
url: string;
path: string;
proxy: Proxy;
channel: number;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
version: number;
requestType: string;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
constructor(options: { url: string; channel: number; path?: string; maximumLevel?: number; tileDiscardPolicy?: TileDiscardPolicy; ellipsoid?: Ellipsoid; proxy?: Proxy });
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 GridImageryProvider {
proxy: Proxy;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
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[];
requestImage(x: number, y: number, level: number): Promise<HTMLImageElement|HTMLCanvasElement>;
pickFeatures(x: number, y: number, level: number, longitude: number, latitude: number): Promise<ImageryLayerFeatureInfo[]>;
}
class HeadingPitchRange {
heading: number;
pitch: number;
range: number;
constructor(heading?: number, pitch?: number, range?: number);
static clone(hpr: HeadingPitchRange, result?: HeadingPitchRange): HeadingPitchRange;
}
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();
}
class ImageryLayerCollection {
layerAdded: Event;
layerRemoved: Event;
layerMoved: Event;
layerShownOrHidden: Event;
length: number;
add(layer: ImageryLayer, index?: number);
addImageryProvider(imageryProvider: ImageryProvider, index?: number): ImageryLayer;
remove(layer: ImageryLayer, destroy?: boolean): boolean;
removeAll(destroy?: boolean);
contains(layer: ImageryLayer): boolean;
indexOf(layer: ImageryLayer): number;
get(index: number);
raise(layer: ImageryLayer);
lower(layer: ImageryLayer);
raiseToTop(layer: ImageryLayer);
lowerToBottom(layer: ImageryLayer);
pickImageryLayerFeatures(ray: Ray, scene: Scene): Promise<ImageryLayerFeatureInfo[]>;
isDestroyed(): boolean;
destroy();
}
class ImageryLayerFeatureInfo {
name: string;
description: string;
position: Cartographic;
data: any;
configureNameFromProperties(properties: any);
configureDescriptionFromProperties(properties: any);
}
class ImageryProvider {
defaultAlpha: number;
defaultBrightness: number;
defaultContrast: number;
defaultHue: number;
defaultSaturation: number;
defaultGamma: number;
ready: boolean;
rectangle: Rectangle;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
credit: Credit;
proxy: Proxy;
hasAlphaChannel: boolean;
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[]>;
static loadImage(url: string): Promise<HTMLImageElement|HTMLCanvasElement>;
}
class Label {
show: boolean;
position: Cartesian3;
text: string;
font: string;
fillColor: Color;
outlineColor: Color;
outlineWidth: number;
style: LabelStyle;
pixelOffset: Cartesian2;
translucencyByDistance: NearFarScalar;
pixelOffsetScaleByDistance: NearFarScalar;
eyeOffset: Cartesian3;
horizontalOrigin: HorizontalOrigin;
verticalOrigin: VerticalOrigin;
scale: number;
id: any;
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();
contains(label: Label): boolean;
get(index: number): Label;
isDestroyed(): boolean;
destroy();
}
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();
isDestroyed(): boolean;
destroy();
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?: { flat?: boolean; faceForward?: boolean; translucent?: boolean; closed?: boolean; materialSupport?: MaterialAppearance.MaterialSupport; material?: Material; vertexShaderSource?: string; fragmentShaderSource?: string; renderState?: RenderState });
getFragmentShaderSource();
isTranslucent(): boolean;
getRenderState(): any;
}
module MaterialAppearance {
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?: { gltf?: any; basePath?: string; show?: boolean; modelMatrix?: Matrix4; scale?: number; minimumPixelSize?: number; id?: any; allowPicking?: boolean; asynchronous?: boolean; debugShowBoundingVolume?: boolean; debugWireframe?: boolean });
getNode(name: string): ModelNode;
getMesh(name: string): ModelMesh;
getMaterial(name: string): ModelMaterial;
update();
isDestroyed(): boolean;
destroy();
static fromGltf(options: { url: string; headers?: any; show?: boolean; modelMatrix?: Matrix4; scale?: number; minimumPixelSize?: number; allowPicking?: boolean; asynchronous?: boolean; debugShowBoundingVolume?: boolean; debugWireframe?: boolean }): Model;
}
class ModelAnimation {
removeOnStop: boolean;
start: Event;
update: Event;
stop: Event;
name: string;
startTime: JulianDate;
delay: number;
stopTime: JulianDate;
speedup: number;
reverse: boolean;
loop: ModelAnimationLoop;
}
class ModelAnimationCollection {
animationAdded: Event;
animationRemoved: Event;
length: number;
add(options: { name: string; startTime?: JulianDate; delay?: number; stopTime?: JulianDate; removeOnStop?: boolean; speedup?: number; reverse?: boolean; loop?: ModelAnimationLoop }): ModelAnimation;
addAll(options?: { startTime?: JulianDate; delay?: number; stopTime?: JulianDate; removeOnStop?: boolean; speedup?: number; reverse?: boolean; loop?: ModelAnimationLoop }): ModelAnimation[];
remove(animation: ModelAnimation): boolean;
removeAll();
contains(animation: ModelAnimation): boolean;
get(index: number): ModelAnimation;
}
class ModelMaterial {
name: string;
id: string;
setValue(name: string, value?: any);
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();
}
class NeverTileDiscardPolicy {
isReady();
shouldDiscardImage(image: HTMLImageElement|Promise<HTMLImageElement>): Promise<boolean>;
}
class OpenStreetMapImageryProvider {
url: string;
proxy: Proxy;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
constructor(options?: { url?: string; fileExtension?: string; proxy?: any; rectangle?: Rectangle; minimumLevel?: number; maximumLevel?: number; ellipsoid?: Ellipsoid; credit?: Credit|string });
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 OrthographicFrustum {
left: number;
right: number;
top: number;
bottom: number;
near: number;
far: number;
projectionMatrix: Matrix4;
computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
getPixelSize(drawingBufferDimensions: Cartesian2, distance?: number, result?: Cartesian2): Cartesian2;
clone(result?: OrthographicFrustum): OrthographicFrustum;
equals(other?: OrthographicFrustum): boolean;
}
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();
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;
}
class PerspectiveOffCenterFrustum {
left: number;
right: number;
top: number;
bottom: number;
near: number;
far: number;
projectionMatrix: Matrix4;
infiniteProjectionMatrix: Matrix4;
computeCullingVolume(position: Cartesian3, direction: Cartesian3, up: Cartesian3): CullingVolume;
getPixelSize(drawingBufferDimensions: Cartesian2, distance?: number, result?: Cartesian2): Cartesian2;
clone(result?: PerspectiveOffCenterFrustum): PerspectiveOffCenterFrustum;
equals(other?: PerspectiveOffCenterFrustum): boolean;
}
class PointPrimitive {
show: boolean;
position: Cartesian3;
scaleByDistance: NearFarScalar;
translucencyByDistance: NearFarScalar;
pixelSize: number;
color;
outlineColor;
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 });
add(pointPrimitive?: any): PointPrimitive;
remove(pointPrimitive: PointPrimitive): boolean;
removeAll();
contains(pointPrimitive?: PointPrimitive): boolean;
get(index: number): PointPrimitive;
isDestroyed(): boolean;
destroy();
}
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);
update();
isDestroyed(): boolean;
destroy();
}
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();
contains(polyline: Polyline): boolean;
get(index: number): Polyline;
isDestroyed(): boolean;
destroy();
}
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();
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();
isTranslucent(): boolean;
getRenderState(): any;
}
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();
getGeometryInstanceAttributes(id: any): any;
isDestroyed(): boolean;
destroy();
}
class PrimitiveCollection {
show: boolean;
destroyPrimitives: boolean;
length: number;
constructor(options?: { show?: boolean; destroyPrimitives?: boolean });
add(primitive: any): any;
remove(primitive?: any): boolean;
removeAll();
contains(primitive?: any): boolean;
raise(primitive?: any);
raiseToTop(primitive?: any);
lower(primitive?: any);
lowerToBottom(primitive?: any);
get(index: number): any;
isDestroyed(): boolean;
destroy();
}
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();
isDestroyed(): boolean;
destroy();
}
class Scene {
rethrowRenderErrors: boolean;
completeMorphOnUserInput: boolean;
morphStart: Event;
morphComplete: Event;
skyBox: SkyBox;
skyAtmosphere: SkyAtmosphere;
sun: Sun;
sunBloom: boolean;
moon: Moon;
backgroundColor: Color;
morphTime: number;
farToNearRatio: number;
debugCommandFilter: Function;
debugShowCommands: boolean;
debugShowFrustums: boolean;
debugShowFramesPerSecond: boolean;
fxaaOrderIndependentTranslucency: boolean;
fxaa: boolean;
canvas: Element;
drawingBufferHeight: number;
drawingBufferWidth: number;
maximumAliasedLineWidth: number;
maximumCubeMapSize: number;
globe: Globe;
primitives: PrimitiveCollection;
camera: Camera;
screenSpaceCameraController: ScreenSpaceCameraController;
mapProjection: MapProjection;
imageryLayers: ImageryLayerCollection;
terrainProvider: TerrainProvider;
renderError: Event;
preRender: Event;
postRender: Event;
debugFrustumStatistics: any;
scene3DOnly: boolean;
orderIndependentTranslucency: boolean;
id: string;
mode: SceneMode;
constructor(options?: { canvas: HTMLCanvasElement; contextOptions?: any; creditContainer?: Element; mapProjection?: MapProjection; orderIndependentTranslucency?: boolean; scene3DOnly?: boolean });
pick(windowPosition: Cartesian2): any;
drillPick(windowPosition: Cartesian2, limit?: number): any[];
completeMorph();
morphTo2D(duration?: number);
morphToColumbusView(duration?: number);
morphTo3D(duration?: number);
isDestroyed(): boolean;
destroy();
}
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();
}
class SingleTileImageryProvider {
url: string;
proxy: Proxy;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
constructor(options: { url: string; rectangle?: Rectangle; credit?: Credit|string; ellipsoid?: Ellipsoid; proxy?: any });
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();
}
class SkyBox {
sources: any;
show: boolean;
constructor(options: { sources?: any; show?: boolean });
update();
isDestroyed(): boolean;
destroy();
}
class Sun {
show: boolean;
glowFactor: number;
isDestroyed(): boolean;
destroy();
}
class TileCoordinatesImageryProvider {
proxy: Proxy;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
constructor(options?: { tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; color?: Color; tileWidth?: number; tileHeight?: number });
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 TileDiscardPolicy {
isReady(): boolean;
shouldDiscardImage(image: HTMLImageElement|Promise<HTMLImageElement>): Promise<boolean>;
}
class TileMapServiceImageryProvider {
url: string;
proxy: Proxy;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
constructor(options?: { url?: string; fileExtension?: string; proxy?: any; credit?: Credit|string; minimumLevel?: number; maximumLevel?: number; rectangle?: Rectangle; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; tileWidth?: number; tileHeight?: number });
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 ViewportQuad {
show: boolean;
rectangle: BoundingRectangle;
material: Material;
constructor(rectangle?: BoundingRectangle, material?: Material);
update();
isDestroyed(): boolean;
destroy();
}
class WebMapServiceImageryProvider {
url: string;
proxy: Proxy;
layers: string;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
static DefaultParameters;
static GetFeatureInfoDefaultParameters;
constructor(options: { url: string; layers: string; parameters?: any; getFeatureInfoParameters?: any; enablePickFeatures?: boolean; getFeatureInfoFormats?: GetFeatureInfoFormat[]; rectangle?: Rectangle; tilingScheme?: TilingScheme; ellipsoid?: Ellipsoid; tileWidth?: number; tileHeight?: number; minimumLevel?: number; maximumLevel?: number; credit?: Credit|string; proxy?: any });
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 WebMapTileServiceImageryProvider {
url: string;
proxy: Proxy;
tileWidth: number;
tileHeight: number;
maximumLevel: number;
minimumLevel: number;
tilingScheme: TilingScheme;
rectangle: Rectangle;
tileDiscardPolicy: TileDiscardPolicy;
errorEvent: Event;
format: string;
ready: boolean;
credit: Credit;
hasAlphaChannel: boolean;
constructor(options: { url: string; format?: string; layer: string; style: string; tileMatrixSetID: string; tileMatrixLabels?: any[]; tileWidth?: number; tileHeight?: number; tilingScheme?: TilingScheme; proxy?: any; rectangle?: Rectangle; minimumLevel?: number; maximumLevel?: number; ellipsoid?: Ellipsoid; credit?: Credit|string });
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 Animation {
container: Element;
viewModel: AnimationViewModel;
constructor(container: Element|string, viewModel: AnimationViewModel);
isDestroyed(): boolean;
destroy();
resize();
applyThemeChanges();
}
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;
static defaultTimeFormatter: AnimationViewModel.TimeFormatter;
constructor(clockViewModel: ClockViewModel);
getShuttleRingTicks();
setShuttleRingTicks(positiveTicks: number[]);
}
module 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();
}
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 });
}
module ProviderViewModel{
type CreationFunction = () => ImageryProvider|TerrainProvider|ImageryProvider[]|TerrainProvider[];
}
class CesiumInspector {
container: Element;
viewModel: CesiumInspectorViewModel;
constructor(container: Element|string, scene: Scene);
isDestroyed(): boolean;
destroy();
}
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();
}
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?: { clock?: Clock; imageryProvider?: ImageryProvider; terrainProvider?: TerrainProvider; skyBox?: SkyBox; skyAtmosphere?: SkyAtmosphere; sceneMode?: SceneMode; scene3DOnly?: boolean; orderIndependentTranslucency?: boolean; mapProjection?: MapProjection; globe?: Globe; useDefaultRenderLoop?: boolean; targetFrameRate?: number; showRenderLoopErrors?: boolean; contextOptions?: any; creditContainer?: Element|string });
showErrorPanel(title: string, message: string, error?: string);
isDestroyed(): boolean;
destroy();
resize();
render();
}
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();
isDestroyed(): boolean;
destroy();
}
class Command {
canExecute: boolean;
beforeExecute: Event;
afterExecute: Event;
}
class FullscreenButton {
container: Element;
viewModel: FullscreenButtonViewModel;
constructor(container: Element|string, fullscreenElement?: Element|string);
isDestroyed(): boolean;
destroy();
}
class FullscreenButtonViewModel {
isFullscreen: boolean;
isFullscreenEnabled: boolean;
tooltip: string;
fullscreenElement: Element;
command: Command;
constructor(fullscreenElement?: Element|string);
isDestroyed(): boolean;
destroy();
}
class Geocoder {
container: Element;
viewModel: GeocoderViewModel;
constructor(options: { container: Element|string; scene: Scene; url?: string; key?: string; flightDuration?: number });
isDestroyed(): boolean;
destroy();
}
class GeocoderViewModel {
isSearchInProgress: boolean;
searchText: string;
flightDuration: number;
url: string;
key: string;
complete: Event;
scene: Scene;
search: Command;
constructor(options: { scene: Scene; url?: string; key?: string; flightDuration?: number });
}
class HomeButton {
container: Element;
viewModel: HomeButtonViewModel;
constructor(container: Element|string, scene: Scene, duration?: number);
isDestroyed(): boolean;
destroy();
}
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();
}
class InfoBoxViewModel {
maxHeight: number;
enableCamera: boolean;
isCameraTracking: boolean;
showInfo: boolean;
titleText: string;
description: string;
cameraIconPath: string;
cameraClicked: Event;
closeClicked: Event;
maxHeightOffset(offset: number): string;
}
class NavigationHelpButton {
container: Element;
viewModel: NavigationHelpButtonViewModel;
constructor(options: { container: Element|string; instructionsInitiallyVisible?: boolean });
isDestroyed(): boolean;
destroy();
}
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();
}
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();
}
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();
}
class SelectionIndicator {
container: Element;
viewModel: SelectionIndicatorViewModel;
constructor(container: Element|string, scene: Scene);
isDestroyed(): boolean;
destroy();
}
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();
animateAppear();
animateDepart();
}
module SelectionIndicatorViewModel{
type ComputeScreenSpacePosition = (position: Cartesian3, result: Cartesian2) => Cartesian2;
}
class Timeline {
container: Element;
constructor(container: Element, clock: Clock);
isDestroyed(): boolean;
destroy();
zoomTo(startTime: JulianDate, stopTime: JulianDate);
resize();
}
class ToggleButtonViewModel {
toggled: boolean;
tooltip: string;
command: Command;
constructor(command: Command, options?: { toggled?: boolean; tooltip?: string });
}
class Viewer {
container: Element;
bottomContainer: Element;
cesiumWidget: CesiumWidget;
selectionIndicator: SelectionIndicator;
infoBox: InfoBox;
geocoder: Geocoder;
homeButton: HomeButton;
sceneModePicker: SceneModePicker;
baseLayerPicker: BaseLayerPicker;
animation: Animation;
timeline: Timeline;
fullscreenButton: FullscreenButton;
dataSourceDisplay: DataSourceDisplay;
entities: EntityCollection;
dataSources: DataSourceCollection;
canvas: HTMLCanvasElement;
cesiumLogo: Element;
scene: Scene;
imageryLayers: ImageryLayerCollection;
terrainProvider: TerrainProvider;
camera: Camera;
clock: Clock;
screenSpaceEventHandler: ScreenSpaceEventHandler;
targetFrameRate: number;
useDefaultRenderLoop: boolean;
resolutionScale: number;
allowDataSourcesToSuspendAnimation: boolean;
trackedEntity: Entity;
selectedEntity: Entity;
constructor(container: Element|string, options?: { animation?: boolean; baseLayerPicker?: boolean; fullscreenButton?: boolean; geocoder?: boolean; homeButton?: boolean; infoBox?: boolean; sceneModePicker?: boolean; selectionIndicator?: boolean; timeline?: boolean; navigationHelpButton?: boolean; navigationInstructionsInitiallyVisible?: boolean; scene3DOnly?: boolean; clock?: Clock; selectedImageryProviderViewModel?: ProviderViewModel; imageryProviderViewModels?: ProviderViewModel[]; selectedTerrainProviderViewModel?: ProviderViewModel; terrainProviderViewModels?: ProviderViewModel[]; imageryProvider?: ImageryProvider | OpenStreetMapImageryProvider; terrainProvider?: TerrainProvider; skyBox?: SkyBox | boolean; skyAtmosphere?: SkyAtmosphere; fullscreenElement?: Element|string; useDefaultRenderLoop?: boolean; targetFrameRate?: number; showRenderLoopErrors?: boolean; automaticallyTrackDataSourceClocks?: boolean; contextOptions?: any; sceneMode?: SceneMode; mapProjection?: MapProjection; globe?: Globe; orderIndependentTranslucency?: boolean; creditContainer?: Element|string; dataSources?: DataSourceCollection });
extend(mixin: Viewer.ViewerMixin, options: any);
resize();
forceResize();
render();
isDestroyed(): boolean;
destroy();
zoomTo(target: Entity|Entity[]|EntityCollection|DataSource|Promise<Entity|Entity[]|EntityCollection|DataSource>, offset?: HeadingPitchRange): Promise<boolean>;
flyTo(target: Entity|Entity[]|EntityCollection|DataSource|Promise<Entity|Entity[]|EntityCollection|DataSource>, options?: { duration?: number; offset?: HeadingPitchRange }): Promise<boolean>;
}
module Viewer{
type ViewerMixin = (viewer: Viewer, options: any) => void;
}
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;
module binarySearch {
type Comparator = (a: any, b: any) => number;
}
function cancelAnimationFrame(requestID);
function clone(object: any, deep?: boolean);
function combine(object1?: any, object2?: any, deep?: boolean): any;
function destroyObject(object: any, message?: string);
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 loadArrayBuffer(url: string|Promise<string>, headers?: any): Promise<ArrayBuffer>;
function loadBlob(url: string|Promise<string>, headers?: any): Promise<Blob>;
function loadImage(url: string|Promise<string>, allowCrossOrigin?: boolean): Promise<HTMLImageElement>;
function loadImageViaBlob(url: string|Promise<string>): Promise<HTMLImageElement>;
function loadJson(url: string|Promise<string>, headers?: any): Promise<any>;
function loadText(url: string|Promise<string>, headers?: any): Promise<string>;
function loadWithXhr(options: { url: string|Promise<string>; responseType?: string; method?: string; data?: string; headers?: any; overrideMimeType?: string }): Promise<any>;
function loadXML(url: string|Promise<string>, headers?: any): Promise<XMLDocument>;
function mergeSort(array: any[], comparator: mergeSort.Comparator, userDefinedObject?: any);
module 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);
module requestAnimationFrame {
type Callback = (timestamp: number) => void;
}
function sampleTerrain(terrainProvider: TerrainProvider, level: number, positions: Cartographic[]): Promise<Cartographic[]>;
function subdivideArray(array: any[], numberOfArrays: number);
function throttleRequestByServer(url: string, requestFunction: throttleRequestByServer.RequestFunction): Promise<any>;
module throttleRequestByServer {
type RequestFunction = (url: string) => Promise<any>;
}
function createTangentSpaceDebugPrimitive(options: { geometry: Geometry; length?: number; modelMatrix?: Matrix4 }): Primitive;
function viewerCesiumInspectorMixin(viewer: Viewer);
function viewerDragDropMixin(viewer: Viewer, options?: { dropTarget?: Element|string; clearOnDrop?: boolean; proxy?: DefaultProxy });
function viewerPerformanceWatchdogMixin(viewer: Viewer);
function createCommand(func: Function, canExecute?: boolean);
function createTaskProcessorWorker(workerFunction: createTaskProcessorWorker.WorkerFunction): createTaskProcessorWorker.TaskProcessorWorkerFunction;
module 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,
}
module 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,
}
module 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,
}
module FeatureDetection {
function supportsFullscreen();
function supportsTypedArrays();
function supportsWebWorkers();
}
enum Fullscreen {
element,
changeEventName,
errorEventName,
enabled,
fullscreen,
}
module Fullscreen {
function supportsFullscreen();
function requestFullscreen(element: any);
function exitFullscreen();
}
module 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,
}
module 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 });
}
module HermitePolynomialApproximation {
function getRequiredDataPoints(degree: number, inputOrder?: 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,
}
module 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,
}
module InterpolationAlgorithm {
function getRequiredDataPoints(degree: 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,
}
module 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;
}
module 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,
}
module LagrangePolynomialApproximation {
function getRequiredDataPoints(degree: number);
function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
}
module LinearApproximation {
function getRequiredDataPoints(degree: number): number;
function interpolateOrderZero(x: number, xTable: number[], yTable: number[], yStride: number, result?: number[]): number[];
}
enum CesiumMath {
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,
}
module CesiumMath {
function sign(value: number): number;
function signNotZero(value: number): number;
function toSNorm(value: number): number;
function fromSNorm(value: number): number;
function sinh(value: number);
function cosh(value: number);
function lerp(p: number, q: number, time: number): number;
function toRadians(degrees: number): number;
function toDegrees(radians: number): number;
function convertLongitudeRange(angle: number): number;
function negativePiToPi(angle: number): number;
function zeroToTwoPi(angle: number): number;
function mod(m: number, n: number): number;
function equalsEpsilon(left: number, right: number, relativeEpsilon: number, absoluteEpsilon?: number): boolean;
function factorial(n: number): number;
function incrementWrap(n?: number, maximumValue?: number, minimumValue?: number): number;
function isPowerOfTwo(n: number): boolean;
function nextPowerOfTwo(n: number): number;
function clamp(value: number, min: number, max: number): number;
function setRandomNumberSeed(seed: number);
function nextRandomNumber(): number;
function acosClamped(value: number): number;
function asinClamped(value: number): number;
function chordLength(angle: number, radius: number): number;
}
enum Packable {
packedLength,
}
module Packable {
function pack(value: any, array: number[], startingIndex?: number);
function unpack(array: number[], startingIndex?: number, result?: any);
}
enum PackableForInterpolation {
packedInterpolationLength,
}
module PackableForInterpolation {
function convertPackedArrayForInterpolation(packedArray: number[], startingIndex?: number, lastIndex?: number, result?: number[]);
function unpackInterpolationResult(array: number[], sourceArray: number[], startingIndex?: number, lastIndex?: number, result?: 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,
}
module QuadraticRealPolynomial {
function computeDiscriminant(a: number, b: number, c: number): number;
function computeRealRoots(a: number, b: number, c: number): number[];
}
module 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,
}
module Simon1994PlanetaryPositions {
function computeSunPositionInEarthInertialFrame(julianDate?: JulianDate, result?: Cartesian3): Cartesian3;
function computeMoonPositionInEarthInertialFrame(julianDate?: JulianDate, result?: Cartesian3): Cartesian3;
}
enum TimeStandard {
UTC,
TAI,
}
module Transforms {
function eastNorthUpToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function northEastDownToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function northUpEastToFixedFrame(origin: Cartesian3, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function headingPitchRollToFixedFrame(origin: Cartesian3, heading: number, pitch: number, roll: number, ellipsoid?: Ellipsoid, result?: Matrix4): Matrix4;
function headingPitchRollQuaternion(origin: Cartesian3, heading: number, pitch: number, roll: number, ellipsoid?: Ellipsoid, result?: Quaternion): Quaternion;
function computeTemeToPseudoFixedMatrix(date: JulianDate, result?: Matrix3): Matrix3;
function preloadIcrfFixed(timeInterval: TimeInterval): Promise<void>;
function computeIcrfToFixedMatrix(date: JulianDate, result?: Matrix3): Matrix3;
function computeFixedToIcrfMatrix(date: JulianDate, result?: Matrix3): Matrix3;
function pointToWindowCoordinates(modelViewProjectionMatrix: Matrix4, viewportTransformation: Matrix4, point: Cartesian3, result?: Cartesian2): Cartesian2;
}
module 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,
}
module SceneMode {
function getMorphTime(value: SceneMode): number;
}
module 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,
}
}
Copy link

ghost commented Jun 6, 2017

nicely done! Help me a lot!

@lzttiff
Copy link

lzttiff commented Aug 14, 2017

great file, just noticed a small error: I believe in the Matrix3 class the functions setRow() and setColumn() have a parameter called "result" that are both of type Matrix3, not Cartesian3.

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