tilingScheme.rectangle.east) {
rectangle.east = tilingScheme.rectangle.east;
}
if (rectangle.south < tilingScheme.rectangle.south) {
rectangle.south = tilingScheme.rectangle.south;
}
if (rectangle.north > tilingScheme.rectangle.north) {
rectangle.north = tilingScheme.rectangle.north;
}
// Check the number of tiles at the minimum level. If it's more than four,
// try requesting the lower levels anyway, because starting at the higher minimum
// level will cause too many tiles to be downloaded and rendered.
var swTile = tilingScheme.positionToTileXY(Rectangle.southwest(rectangle), minimumLevel);
var neTile = tilingScheme.positionToTileXY(Rectangle.northeast(rectangle), minimumLevel);
var tileCount = (Math.abs(neTile.x - swTile.x) + 1) * (Math.abs(neTile.y - swTile.y) + 1);
if (tileCount > 4) {
minimumLevel = 0;
}
var templateUrl = joinUrls(url, '{z}/{x}/{reverseY}.' + fileExtension);
deferred.resolve({
url : templateUrl,
tilingScheme : tilingScheme,
rectangle : rectangle,
tileWidth : tileWidth,
tileHeight : tileHeight,
minimumLevel : minimumLevel,
maximumLevel : maximumLevel,
proxy : options.proxy,
tileDiscardPolicy : options.tileDiscardPolicy,
credit: options.credit
});
}
function metadataFailure(error) {
// Can't load XML, still allow options and defaults
var fileExtension = defaultValue(options.fileExtension, 'png');
var tileWidth = defaultValue(options.tileWidth, 256);
var tileHeight = defaultValue(options.tileHeight, 256);
var minimumLevel = defaultValue(options.minimumLevel, 0);
var maximumLevel = options.maximumLevel;
var tilingScheme = defined(options.tilingScheme) ? options.tilingScheme : new WebMercatorTilingScheme({ ellipsoid : options.ellipsoid });
var rectangle = defaultValue(options.rectangle, tilingScheme.rectangle);
var templateUrl = joinUrls(url, '{z}/{x}/{reverseY}.' + fileExtension);
deferred.resolve({
url : templateUrl,
tilingScheme : tilingScheme,
rectangle : rectangle,
tileWidth : tileWidth,
tileHeight : tileHeight,
minimumLevel : minimumLevel,
maximumLevel : maximumLevel,
proxy : options.proxy,
tileDiscardPolicy : options.tileDiscardPolicy,
credit: options.credit
});
}
function requestMetadata() {
var resourceUrl = joinUrls(url, 'tilemapresource.xml');
var proxy = options.proxy;
if (defined(proxy)) {
resourceUrl = proxy.getURL(resourceUrl);
}
// Try to load remaining parameters from XML
loadXML(resourceUrl).then(metadataSuccess).otherwise(metadataFailure);
}
requestMetadata();
return imageryProvider;
}
return createTileMapServiceImageryProvider;
});
/*global define*/
define('Scene/CreditDisplay',[
'../Core/Credit',
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError'
], function(
Credit,
defaultValue,
defined,
destroyObject,
DeveloperError) {
'use strict';
function displayTextCredit(credit, container, delimiter) {
if (!defined(credit.element)) {
var text = credit.text;
var link = credit.link;
var span = document.createElement('span');
if (credit.hasLink()) {
var a = document.createElement('a');
a.textContent = text;
a.href = link;
a.target = '_blank';
span.appendChild(a);
} else {
span.textContent = text;
}
span.className = 'cesium-credit-text';
credit.element = span;
}
if (container.hasChildNodes()) {
var del = document.createElement('span');
del.textContent = delimiter;
del.className = 'cesium-credit-delimiter';
container.appendChild(del);
}
container.appendChild(credit.element);
}
function displayImageCredit(credit, container) {
if (!defined(credit.element)) {
var text = credit.text;
var link = credit.link;
var span = document.createElement('span');
var content = document.createElement('img');
content.src = credit.imageUrl;
content.style['vertical-align'] = 'bottom';
if (defined(text)) {
content.alt = text;
content.title = text;
}
if (credit.hasLink()) {
var a = document.createElement('a');
a.appendChild(content);
a.href = link;
a.target = '_blank';
span.appendChild(a);
} else {
span.appendChild(content);
}
span.className = 'cesium-credit-image';
credit.element = span;
}
container.appendChild(credit.element);
}
function contains(credits, credit) {
var len = credits.length;
for ( var i = 0; i < len; i++) {
var existingCredit = credits[i];
if (Credit.equals(existingCredit, credit)) {
return true;
}
}
return false;
}
function removeCreditDomElement(credit) {
var element = credit.element;
if (defined(element)) {
var container = element.parentNode;
if (!credit.hasImage()) {
var delimiter = element.previousSibling;
if (delimiter === null) {
delimiter = element.nextSibling;
}
if (delimiter !== null) {
container.removeChild(delimiter);
}
}
container.removeChild(element);
}
}
function displayTextCredits(creditDisplay, textCredits) {
var i;
var index;
var credit;
var displayedTextCredits = creditDisplay._displayedCredits.textCredits;
for (i = 0; i < textCredits.length; i++) {
credit = textCredits[i];
if (defined(credit)) {
index = displayedTextCredits.indexOf(credit);
if (index === -1) {
displayTextCredit(credit, creditDisplay._textContainer, creditDisplay._delimiter);
} else {
displayedTextCredits.splice(index, 1);
}
}
}
for (i = 0; i < displayedTextCredits.length; i++) {
credit = displayedTextCredits[i];
if (defined(credit)) {
removeCreditDomElement(credit);
}
}
}
function displayImageCredits(creditDisplay, imageCredits) {
var i;
var index;
var credit;
var displayedImageCredits = creditDisplay._displayedCredits.imageCredits;
for (i = 0; i < imageCredits.length; i++) {
credit = imageCredits[i];
if (defined(credit)) {
index = displayedImageCredits.indexOf(credit);
if (index === -1) {
displayImageCredit(credit, creditDisplay._imageContainer);
} else {
displayedImageCredits.splice(index, 1);
}
}
}
for (i = 0; i < displayedImageCredits.length; i++) {
credit = displayedImageCredits[i];
if (defined(credit)) {
removeCreditDomElement(credit);
}
}
}
/**
* The credit display is responsible for displaying credits on screen.
*
* @param {HTMLElement} container The HTML element where credits will be displayed
* @param {String} [delimiter= ' • '] The string to separate text credits
*
* @alias CreditDisplay
* @constructor
*
* @example
* var creditDisplay = new Cesium.CreditDisplay(creditContainer);
*/
function CreditDisplay(container, delimiter) {
if (!defined(container)) {
throw new DeveloperError('credit container is required');
}
var imageContainer = document.createElement('span');
imageContainer.className = 'cesium-credit-imageContainer';
var textContainer = document.createElement('span');
textContainer.className = 'cesium-credit-textContainer';
container.appendChild(imageContainer);
container.appendChild(textContainer);
this._delimiter = defaultValue(delimiter, ' • ');
this._textContainer = textContainer;
this._imageContainer = imageContainer;
this._defaultImageCredits = [];
this._defaultTextCredits = [];
this._displayedCredits = {
imageCredits : [],
textCredits : []
};
this._currentFrameCredits = {
imageCredits : [],
textCredits : []
};
/**
* The HTML element where credits will be displayed.
* @type {HTMLElement}
*/
this.container = container;
}
/**
* Adds a credit to the list of current credits to be displayed in the credit container
*
* @param {Credit} credit The credit to display
*/
CreditDisplay.prototype.addCredit = function(credit) {
if (!defined(credit)) {
throw new DeveloperError('credit must be defined');
}
if (credit.hasImage()) {
var imageCredits = this._currentFrameCredits.imageCredits;
if (!contains(this._defaultImageCredits, credit)) {
imageCredits[credit.id] = credit;
}
} else {
var textCredits = this._currentFrameCredits.textCredits;
if (!contains(this._defaultTextCredits, credit)) {
textCredits[credit.id] = credit;
}
}
};
/**
* Adds credits that will persist until they are removed
*
* @param {Credit} credit The credit to added to defaults
*/
CreditDisplay.prototype.addDefaultCredit = function(credit) {
if (!defined(credit)) {
throw new DeveloperError('credit must be defined');
}
if (credit.hasImage()) {
var imageCredits = this._defaultImageCredits;
if (!contains(imageCredits, credit)) {
imageCredits.push(credit);
}
} else {
var textCredits = this._defaultTextCredits;
if (!contains(textCredits, credit)) {
textCredits.push(credit);
}
}
};
/**
* Removes a default credit
*
* @param {Credit} credit The credit to be removed from defaults
*/
CreditDisplay.prototype.removeDefaultCredit = function(credit) {
if (!defined(credit)) {
throw new DeveloperError('credit must be defined');
}
var index;
if (credit.hasImage()) {
index = this._defaultImageCredits.indexOf(credit);
if (index !== -1) {
this._defaultImageCredits.splice(index, 1);
}
} else {
index = this._defaultTextCredits.indexOf(credit);
if (index !== -1) {
this._defaultTextCredits.splice(index, 1);
}
}
};
/**
* Resets the credit display to a beginning of frame state, clearing out current credits.
*
* @param {Credit} credit The credit to display
*/
CreditDisplay.prototype.beginFrame = function() {
this._currentFrameCredits.imageCredits.length = 0;
this._currentFrameCredits.textCredits.length = 0;
};
/**
* Sets the credit display to the end of frame state, displaying current credits in the credit container
*
* @param {Credit} credit The credit to display
*/
CreditDisplay.prototype.endFrame = function() {
var textCredits = this._defaultTextCredits.concat(this._currentFrameCredits.textCredits);
var imageCredits = this._defaultImageCredits.concat(this._currentFrameCredits.imageCredits);
displayTextCredits(this, textCredits);
displayImageCredits(this, imageCredits);
this._displayedCredits.textCredits = textCredits;
this._displayedCredits.imageCredits = imageCredits;
};
/**
* Destroys the resources held by this object. Destroying an object allows for deterministic
* release of resources, instead of relying on the garbage collector to destroy this object.
*
* Once an object is destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (undefined) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*/
CreditDisplay.prototype.destroy = function() {
this.container.removeChild(this._textContainer);
this.container.removeChild(this._imageContainer);
return destroyObject(this);
};
/**
* Returns true if this object was destroyed; otherwise, false.
*
*
* @returns {Boolean} true if this object was destroyed; otherwise, false.
*/
CreditDisplay.prototype.isDestroyed = function() {
return false;
};
return CreditDisplay;
});
/*global define*/
define('Scene/DebugAppearance',[
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'./Appearance'
], function(
defaultValue,
defined,
defineProperties,
DeveloperError,
Appearance) {
'use strict';
/**
* Visualizes a vertex attribute by displaying it as a color for debugging.
*
* Components for well-known unit-length vectors, i.e., normal,
* binormal, and tangent, are scaled and biased
* from [-1.0, 1.0] to (-1.0, 1.0).
*
*
* @alias DebugAppearance
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {String} options.attributeName The name of the attribute to visualize.
* @param {Boolean} options.perInstanceAttribute Boolean that determines whether this attribute is a per-instance geometry attribute.
* @param {String} [options.glslDatatype='vec3'] The GLSL datatype of the attribute. Supported datatypes are float, vec2, vec3, and vec4.
* @param {String} [options.vertexShaderSource] Optional GLSL vertex shader source to override the default vertex shader.
* @param {String} [options.fragmentShaderSource] Optional GLSL fragment shader source to override the default fragment shader.
* @param {RenderState} [options.renderState] Optional render state to override the default render state.
*
* @exception {DeveloperError} options.glslDatatype must be float, vec2, vec3, or vec4.
*
* @example
* var primitive = new Cesium.Primitive({
* geometryInstances : // ...
* appearance : new Cesium.DebugAppearance({
* attributeName : 'normal'
* })
* });
*/
function DebugAppearance(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var attributeName = options.attributeName;
var perInstanceAttribute = options.perInstanceAttribute;
if (!defined(attributeName)) {
throw new DeveloperError('options.attributeName is required.');
}
if (!defined(perInstanceAttribute)) {
throw new DeveloperError('options.perInstanceAttribute is required.');
}
var glslDatatype = defaultValue(options.glslDatatype, 'vec3');
var varyingName = 'v_' + attributeName;
var getColor;
// Well-known normalized vector attributes in VertexFormat
if ((attributeName === 'normal') || (attributeName === 'binormal') || (attributeName === 'tangent')) {
getColor = 'vec4 getColor() { return vec4((' + varyingName + ' + vec3(1.0)) * 0.5, 1.0); }\n';
} else {
// All other attributes, both well-known and custom
if (attributeName === 'st') {
glslDatatype = 'vec2';
}
switch(glslDatatype) {
case 'float':
getColor = 'vec4 getColor() { return vec4(vec3(' + varyingName + '), 1.0); }\n';
break;
case 'vec2':
getColor = 'vec4 getColor() { return vec4(' + varyingName + ', 0.0, 1.0); }\n';
break;
case 'vec3':
getColor = 'vec4 getColor() { return vec4(' + varyingName + ', 1.0); }\n';
break;
case 'vec4':
getColor = 'vec4 getColor() { return ' + varyingName + '; }\n';
break;
default:
throw new DeveloperError('options.glslDatatype must be float, vec2, vec3, or vec4.');
}
}
var vs =
'attribute vec3 position3DHigh;\n' +
'attribute vec3 position3DLow;\n' +
'attribute float batchId;\n' +
(perInstanceAttribute ? '' : 'attribute ' + glslDatatype + ' ' + attributeName + ';\n') +
'varying ' + glslDatatype + ' ' + varyingName + ';\n' +
'void main()\n' +
'{\n' +
'vec4 p = czm_translateRelativeToEye(position3DHigh, position3DLow);\n' +
(perInstanceAttribute ?
varyingName + ' = czm_batchTable_' + attributeName + '(batchId);\n' :
varyingName + ' = ' + attributeName + ';\n') +
'gl_Position = czm_modelViewProjectionRelativeToEye * p;\n' +
'}';
var fs =
'varying ' + glslDatatype + ' ' + varyingName + ';\n' +
getColor + '\n' +
'void main()\n' +
'{\n' +
'gl_FragColor = getColor();\n' +
'}';
/**
* This property is part of the {@link Appearance} interface, but is not
* used by {@link DebugAppearance} since a fully custom fragment shader is used.
*
* @type Material
*
* @default undefined
*/
this.material = undefined;
/**
* When true, the geometry is expected to appear translucent.
*
* @type {Boolean}
*
* @default false
*/
this.translucent = defaultValue(options.translucent, false);
this._vertexShaderSource = defaultValue(options.vertexShaderSource, vs);
this._fragmentShaderSource = defaultValue(options.fragmentShaderSource, fs);
this._renderState = Appearance.getDefaultRenderState(false, false, options.renderState);
this._closed = defaultValue(options.closed, false);
// Non-derived members
this._attributeName = attributeName;
this._glslDatatype = glslDatatype;
}
defineProperties(DebugAppearance.prototype, {
/**
* The GLSL source code for the vertex shader.
*
* @memberof DebugAppearance.prototype
*
* @type {String}
* @readonly
*/
vertexShaderSource : {
get : function() {
return this._vertexShaderSource;
}
},
/**
* The GLSL source code for the fragment shader. The full fragment shader
* source is built procedurally taking into account the {@link DebugAppearance#material}.
* Use {@link DebugAppearance#getFragmentShaderSource} to get the full source.
*
* @memberof DebugAppearance.prototype
*
* @type {String}
* @readonly
*/
fragmentShaderSource : {
get : function() {
return this._fragmentShaderSource;
}
},
/**
* The WebGL fixed-function state to use when rendering the geometry.
*
* @memberof DebugAppearance.prototype
*
* @type {Object}
* @readonly
*/
renderState : {
get : function() {
return this._renderState;
}
},
/**
* When true, the geometry is expected to be closed.
*
* @memberof DebugAppearance.prototype
*
* @type {Boolean}
* @readonly
*
* @default false
*/
closed : {
get : function() {
return this._closed;
}
},
/**
* The name of the attribute being visualized.
*
* @memberof DebugAppearance.prototype
*
* @type {String}
* @readonly
*/
attributeName : {
get : function() {
return this._attributeName;
}
},
/**
* The GLSL datatype of the attribute being visualized.
*
* @memberof DebugAppearance.prototype
*
* @type {String}
* @readonly
*/
glslDatatype : {
get : function() {
return this._glslDatatype;
}
}
});
/**
* Returns the full GLSL fragment shader source, which for {@link DebugAppearance} is just
* {@link DebugAppearance#fragmentShaderSource}.
*
* @function
*
* @returns {String} The full GLSL fragment shader source.
*/
DebugAppearance.prototype.getFragmentShaderSource = Appearance.prototype.getFragmentShaderSource;
/**
* Determines if the geometry is translucent based on {@link DebugAppearance#translucent}.
*
* @function
*
* @returns {Boolean} true if the appearance is translucent.
*/
DebugAppearance.prototype.isTranslucent = Appearance.prototype.isTranslucent;
/**
* Creates a render state. This is not the final render state instance; instead,
* it can contain a subset of render state properties identical to the render state
* created in the context.
*
* @function
*
* @returns {Object} The render state.
*/
DebugAppearance.prototype.getRenderState = Appearance.prototype.getRenderState;
return DebugAppearance;
});
/*global define*/
define('Scene/DebugCameraPrimitive',[
'../Core/BoundingSphere',
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/Color',
'../Core/ColorGeometryInstanceAttribute',
'../Core/ComponentDatatype',
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/GeometryAttribute',
'../Core/GeometryAttributes',
'../Core/GeometryInstance',
'../Core/Matrix4',
'../Core/PrimitiveType',
'./PerInstanceColorAppearance',
'./Primitive'
], function(
BoundingSphere,
Cartesian3,
Cartesian4,
Color,
ColorGeometryInstanceAttribute,
ComponentDatatype,
defaultValue,
defined,
destroyObject,
DeveloperError,
GeometryAttribute,
GeometryAttributes,
GeometryInstance,
Matrix4,
PrimitiveType,
PerInstanceColorAppearance,
Primitive) {
'use strict';
/**
* Draws the outline of the camera's view frustum.
*
* @alias DebugCameraPrimitive
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Camera} options.camera The camera.
* @param {Color} [options.color=Color.CYAN] The color of the debug outline.
* @param {Boolean} [options.updateOnChange=true] Whether the primitive updates when the underlying camera changes.
* @param {Boolean} [options.show=true] Determines if this primitive will be shown.
* @param {Object} [options.id] A user-defined object to return when the instance is picked with {@link Scene#pick}.
*
* @example
* primitives.add(new Cesium.DebugCameraPrimitive({
* camera : camera,
* color : Cesium.Color.YELLOW
* }));
*/
function DebugCameraPrimitive(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(options.camera)) {
throw new DeveloperError('options.camera is required.');
}
this._camera = options.camera;
this._color = defaultValue(options.color, Color.CYAN);
this._updateOnChange = defaultValue(options.updateOnChange, true);
/**
* Determines if this primitive will be shown.
*
* @type Boolean
* @default true
*/
this.show = defaultValue(options.show, true);
/**
* User-defined object returned when the primitive is picked.
*
* @type {Object}
* @default undefined
*
* @see Scene#pick
*/
this.id = options.id;
this._id = undefined;
this._outlinePrimitive = undefined;
this._planesPrimitive = undefined;
}
var frustumCornersNDC = new Array(8);
frustumCornersNDC[0] = new Cartesian4(-1.0, -1.0, -1.0, 1.0);
frustumCornersNDC[1] = new Cartesian4(1.0, -1.0, -1.0, 1.0);
frustumCornersNDC[2] = new Cartesian4(1.0, 1.0, -1.0, 1.0);
frustumCornersNDC[3] = new Cartesian4(-1.0, 1.0, -1.0, 1.0);
frustumCornersNDC[4] = new Cartesian4(-1.0, -1.0, 1.0, 1.0);
frustumCornersNDC[5] = new Cartesian4(1.0, -1.0, 1.0, 1.0);
frustumCornersNDC[6] = new Cartesian4(1.0, 1.0, 1.0, 1.0);
frustumCornersNDC[7] = new Cartesian4(-1.0, 1.0, 1.0, 1.0);
var scratchMatrix = new Matrix4();
var scratchFrustumCorners = new Array(8);
for (var i = 0; i < 8; ++i) {
scratchFrustumCorners[i] = new Cartesian4();
}
var scratchColor = new Color();
/**
* @private
*/
DebugCameraPrimitive.prototype.update = function(frameState) {
if (!this.show) {
return;
}
if (this._updateOnChange) {
// Recreate the primitive every frame
this._outlinePrimitive = this._outlinePrimitive && this._outlinePrimitive.destroy();
this._planesPrimitive = this._planesPrimitive && this._planesPrimitive.destroy();
}
if (!defined(this._outlinePrimitive)) {
var view = this._camera.viewMatrix;
var projection = this._camera.frustum.projectionMatrix;
var viewProjection = Matrix4.multiply(projection, view, scratchMatrix);
var inverseViewProjection = Matrix4.inverse(viewProjection, scratchMatrix);
var positions = new Float64Array(8 * 3);
for (var i = 0; i < 8; ++i) {
var corner = Cartesian4.clone(frustumCornersNDC[i], scratchFrustumCorners[i]);
Matrix4.multiplyByVector(inverseViewProjection, corner, corner);
Cartesian3.divideByScalar(corner, corner.w, corner); // Handle the perspective divide
positions[i * 3] = corner.x;
positions[i * 3 + 1] = corner.y;
positions[i * 3 + 2] = corner.z;
}
var boundingSphere = new BoundingSphere.fromVertices(positions);
var attributes = new GeometryAttributes();
attributes.position = new GeometryAttribute({
componentDatatype : ComponentDatatype.DOUBLE,
componentsPerAttribute : 3,
values : positions
});
// Create the outline primitive
var outlineIndices = new Uint16Array([0,1,1,2,2,3,3,0,0,4,4,7,7,3,7,6,6,2,2,1,1,5,5,4,5,6]);
this._outlinePrimitive = new Primitive({
geometryInstances : new GeometryInstance({
geometry : {
attributes : attributes,
indices : outlineIndices,
primitiveType : PrimitiveType.LINES,
boundingSphere : boundingSphere
},
attributes : {
color : ColorGeometryInstanceAttribute.fromColor(this._color)
},
id : this.id,
pickPrimitive : this
}),
appearance : new PerInstanceColorAppearance({
translucent : false,
flat : true
}),
asynchronous : false
});
// Create the planes primitive
var planesIndices = new Uint16Array([4,5,6,4,6,7,5,1,2,5,2,6,7,6,2,7,2,3,0,1,5,0,5,4,0,4,7,0,7,3,1,0,3,1,3,2]);
this._planesPrimitive = new Primitive({
geometryInstances : new GeometryInstance({
geometry : {
attributes : attributes,
indices : planesIndices,
primitiveType : PrimitiveType.TRIANGLES,
boundingSphere : boundingSphere
},
attributes : {
color : ColorGeometryInstanceAttribute.fromColor(Color.fromAlpha(this._color, 0.1, scratchColor))
},
id : this.id,
pickPrimitive : this
}),
appearance : new PerInstanceColorAppearance({
translucent : true,
flat : true
}),
asynchronous : false
});
}
this._outlinePrimitive.update(frameState);
this._planesPrimitive.update(frameState);
};
/**
* Returns true if this object was destroyed; otherwise, false.
*
* If this object was destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception.
*
*
* @returns {Boolean} true if this object was destroyed; otherwise, false.
*
* @see DebugCameraPrimitive#destroy
*/
DebugCameraPrimitive.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
*
* Once an object is destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (undefined) to the object as done in the example.
*
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @example
* p = p && p.destroy();
*
* @see DebugCameraPrimitive#isDestroyed
*/
DebugCameraPrimitive.prototype.destroy = function() {
this._outlinePrimitive = this._outlinePrimitive && this._outlinePrimitive.destroy();
this._planesPrimitive = this._planesPrimitive && this._planesPrimitive.destroy();
return destroyObject(this);
};
return DebugCameraPrimitive;
});
/*global define*/
define('Scene/DebugModelMatrixPrimitive',[
'../Core/Cartesian3',
'../Core/Color',
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/GeometryInstance',
'../Core/Matrix4',
'../Core/PolylineGeometry',
'./PolylineColorAppearance',
'./Primitive'
], function(
Cartesian3,
Color,
defaultValue,
defined,
destroyObject,
GeometryInstance,
Matrix4,
PolylineGeometry,
PolylineColorAppearance,
Primitive) {
'use strict';
/**
* Draws the axes of a reference frame defined by a matrix that transforms to world
* coordinates, i.e., Earth's WGS84 coordinates. The most prominent example is
* a primitives modelMatrix.
*
* The X axis is red; Y is green; and Z is blue.
*
*
* This is for debugging only; it is not optimized for production use.
*
*
* @alias DebugModelMatrixPrimitive
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Number} [options.length=10000000.0] The length of the axes in meters.
* @param {Number} [options.width=2.0] The width of the axes in pixels.
* @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The 4x4 matrix that defines the reference frame, i.e., origin plus axes, to visualize.
* @param {Boolean} [options.show=true] Determines if this primitive will be shown.
* @param {Object} [options.id] A user-defined object to return when the instance is picked with {@link Scene#pick}
*
* @example
* primitives.add(new Cesium.DebugModelMatrixPrimitive({
* modelMatrix : primitive.modelMatrix, // primitive to debug
* length : 100000.0,
* width : 10.0
* }));
*/
function DebugModelMatrixPrimitive(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
/**
* The length of the axes in meters.
*
* @type {Number}
* @default 10000000.0
*/
this.length = defaultValue(options.length, 10000000.0);
this._length = undefined;
/**
* The width of the axes in pixels.
*
* @type {Number}
* @default 2.0
*/
this.width = defaultValue(options.width, 2.0);
this._width = undefined;
/**
* Determines if this primitive will be shown.
*
* @type Boolean
* @default true
*/
this.show = defaultValue(options.show, true);
/**
* The 4x4 matrix that defines the reference frame, i.e., origin plus axes, to visualize.
*
* @type {Matrix4}
* @default {@link Matrix4.IDENTITY}
*/
this.modelMatrix = Matrix4.clone(defaultValue(options.modelMatrix, Matrix4.IDENTITY));
this._modelMatrix = new Matrix4();
/**
* User-defined object returned when the primitive is picked.
*
* @type {Object}
* @default undefined
*
* @see Scene#pick
*/
this.id = options.id;
this._id = undefined;
this._primitive = undefined;
}
/**
* @private
*/
DebugModelMatrixPrimitive.prototype.update = function(frameState) {
if (!this.show) {
return;
}
if (!defined(this._primitive) ||
(!Matrix4.equals(this._modelMatrix, this.modelMatrix)) ||
(this._length !== this.length) ||
(this._width !== this.width) ||
(this._id !== this.id)) {
this._modelMatrix = Matrix4.clone(this.modelMatrix, this._modelMatrix);
this._length = this.length;
this._width = this.width;
this._id = this.id;
if (defined(this._primitive)) {
this._primitive.destroy();
}
// Workaround projecting (0, 0, 0)
if ((this.modelMatrix[12] === 0.0 && this.modelMatrix[13] === 0.0 && this.modelMatrix[14] === 0.0)) {
this.modelMatrix[14] = 0.01;
}
var x = new GeometryInstance({
geometry : new PolylineGeometry({
positions : [
Cartesian3.ZERO,
Cartesian3.UNIT_X
],
width : this.width,
vertexFormat : PolylineColorAppearance.VERTEX_FORMAT,
colors : [
Color.RED,
Color.RED
],
followSurface: false
}),
modelMatrix : Matrix4.multiplyByUniformScale(this.modelMatrix, this.length, new Matrix4()),
id : this.id,
pickPrimitive : this
});
var y = new GeometryInstance({
geometry : new PolylineGeometry({
positions : [
Cartesian3.ZERO,
Cartesian3.UNIT_Y
],
width : this.width,
vertexFormat : PolylineColorAppearance.VERTEX_FORMAT,
colors : [
Color.GREEN,
Color.GREEN
],
followSurface: false
}),
modelMatrix : Matrix4.multiplyByUniformScale(this.modelMatrix, this.length, new Matrix4()),
id : this.id,
pickPrimitive : this
});
var z = new GeometryInstance({
geometry : new PolylineGeometry({
positions : [
Cartesian3.ZERO,
Cartesian3.UNIT_Z
],
width : this.width,
vertexFormat : PolylineColorAppearance.VERTEX_FORMAT,
colors : [
Color.BLUE,
Color.BLUE
],
followSurface: false
}),
modelMatrix : Matrix4.multiplyByUniformScale(this.modelMatrix, this.length, new Matrix4()),
id : this.id,
pickPrimitive : this
});
this._primitive = new Primitive({
geometryInstances : [x, y, z],
appearance : new PolylineColorAppearance(),
asynchronous : false
});
}
this._primitive.update(frameState);
};
/**
* Returns true if this object was destroyed; otherwise, false.
*
* If this object was destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception.
*
*
* @returns {Boolean} true if this object was destroyed; otherwise, false.
*
* @see DebugModelMatrixPrimitive#destroy
*/
DebugModelMatrixPrimitive.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
*
* Once an object is destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (undefined) to the object as done in the example.
*
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @example
* p = p && p.destroy();
*
* @see DebugModelMatrixPrimitive#isDestroyed
*/
DebugModelMatrixPrimitive.prototype.destroy = function() {
this._primitive = this._primitive && this._primitive.destroy();
return destroyObject(this);
};
return DebugModelMatrixPrimitive;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/DepthPlaneFS',[],function() {
'use strict';
return "varying vec4 positionEC;\n\
void main()\n\
{\n\
czm_ellipsoid ellipsoid = czm_getWgs84EllipsoidEC();\n\
vec3 direction = normalize(positionEC.xyz);\n\
czm_ray ray = czm_ray(vec3(0.0), direction);\n\
czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid);\n\
if (!czm_isEmpty(intersection))\n\
{\n\
gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);\n\
}\n\
else\n\
{\n\
discard;\n\
}\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/DepthPlaneVS',[],function() {
'use strict';
return "attribute vec4 position;\n\
varying vec4 positionEC;\n\
void main()\n\
{\n\
positionEC = czm_modelView * position;\n\
gl_Position = czm_projection * positionEC;\n\
}\n\
";
});
/*global define*/
define('Scene/DepthPlane',[
'../Core/BoundingSphere',
'../Core/Cartesian3',
'../Core/ComponentDatatype',
'../Core/defined',
'../Core/FeatureDetection',
'../Core/Geometry',
'../Core/GeometryAttribute',
'../Core/PrimitiveType',
'../Renderer/BufferUsage',
'../Renderer/DrawCommand',
'../Renderer/Pass',
'../Renderer/RenderState',
'../Renderer/ShaderProgram',
'../Renderer/VertexArray',
'../Shaders/DepthPlaneFS',
'../Shaders/DepthPlaneVS',
'./DepthFunction',
'./SceneMode'
], function(
BoundingSphere,
Cartesian3,
ComponentDatatype,
defined,
FeatureDetection,
Geometry,
GeometryAttribute,
PrimitiveType,
BufferUsage,
DrawCommand,
Pass,
RenderState,
ShaderProgram,
VertexArray,
DepthPlaneFS,
DepthPlaneVS,
DepthFunction,
SceneMode) {
'use strict';
/**
* @private
*/
function DepthPlane() {
this._rs = undefined;
this._sp = undefined;
this._va = undefined;
this._command = undefined;
this._mode = undefined;
}
var depthQuadScratch = FeatureDetection.supportsTypedArrays() ? new Float32Array(12) : [];
var scratchCartesian1 = new Cartesian3();
var scratchCartesian2 = new Cartesian3();
var scratchCartesian3 = new Cartesian3();
var scratchCartesian4 = new Cartesian3();
function computeDepthQuad(ellipsoid, frameState) {
var radii = ellipsoid.radii;
var p = frameState.camera.positionWC;
// Find the corresponding position in the scaled space of the ellipsoid.
var q = Cartesian3.multiplyComponents(ellipsoid.oneOverRadii, p, scratchCartesian1);
var qMagnitude = Cartesian3.magnitude(q);
var qUnit = Cartesian3.normalize(q, scratchCartesian2);
// Determine the east and north directions at q.
var eUnit = Cartesian3.normalize(Cartesian3.cross(Cartesian3.UNIT_Z, q, scratchCartesian3), scratchCartesian3);
var nUnit = Cartesian3.normalize(Cartesian3.cross(qUnit, eUnit, scratchCartesian4), scratchCartesian4);
// Determine the radius of the 'limb' of the ellipsoid.
var wMagnitude = Math.sqrt(Cartesian3.magnitudeSquared(q) - 1.0);
// Compute the center and offsets.
var center = Cartesian3.multiplyByScalar(qUnit, 1.0 / qMagnitude, scratchCartesian1);
var scalar = wMagnitude / qMagnitude;
var eastOffset = Cartesian3.multiplyByScalar(eUnit, scalar, scratchCartesian2);
var northOffset = Cartesian3.multiplyByScalar(nUnit, scalar, scratchCartesian3);
// A conservative measure for the longitudes would be to use the min/max longitudes of the bounding frustum.
var upperLeft = Cartesian3.add(center, northOffset, scratchCartesian4);
Cartesian3.subtract(upperLeft, eastOffset, upperLeft);
Cartesian3.multiplyComponents(radii, upperLeft, upperLeft);
Cartesian3.pack(upperLeft, depthQuadScratch, 0);
var lowerLeft = Cartesian3.subtract(center, northOffset, scratchCartesian4);
Cartesian3.subtract(lowerLeft, eastOffset, lowerLeft);
Cartesian3.multiplyComponents(radii, lowerLeft, lowerLeft);
Cartesian3.pack(lowerLeft, depthQuadScratch, 3);
var upperRight = Cartesian3.add(center, northOffset, scratchCartesian4);
Cartesian3.add(upperRight, eastOffset, upperRight);
Cartesian3.multiplyComponents(radii, upperRight, upperRight);
Cartesian3.pack(upperRight, depthQuadScratch, 6);
var lowerRight = Cartesian3.subtract(center, northOffset, scratchCartesian4);
Cartesian3.add(lowerRight, eastOffset, lowerRight);
Cartesian3.multiplyComponents(radii, lowerRight, lowerRight);
Cartesian3.pack(lowerRight, depthQuadScratch, 9);
return depthQuadScratch;
}
DepthPlane.prototype.update = function(frameState) {
this._mode = frameState.mode;
if (frameState.mode !== SceneMode.SCENE3D) {
return;
}
var context = frameState.context;
var ellipsoid = frameState.mapProjection.ellipsoid;
if (!defined(this._command)) {
this._rs = RenderState.fromCache({ // Write depth, not color
cull : {
enabled : true
},
depthTest : {
enabled : true,
func : DepthFunction.ALWAYS
},
colorMask : {
red : false,
green : false,
blue : false,
alpha : false
}
});
this._sp = ShaderProgram.fromCache({
context : context,
vertexShaderSource : DepthPlaneVS,
fragmentShaderSource : DepthPlaneFS,
attributeLocations : {
position : 0
}
});
this._command = new DrawCommand({
renderState : this._rs,
shaderProgram : this._sp,
boundingVolume : new BoundingSphere(Cartesian3.ZERO, ellipsoid.maximumRadius),
pass : Pass.OPAQUE,
owner : this
});
}
// update depth plane
var depthQuad = computeDepthQuad(ellipsoid, frameState);
// depth plane
if (!defined(this._va)) {
var geometry = new Geometry({
attributes : {
position : new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 3,
values : depthQuad
})
},
indices : [0, 1, 2, 2, 1, 3],
primitiveType : PrimitiveType.TRIANGLES
});
this._va = VertexArray.fromGeometry({
context : context,
geometry : geometry,
attributeLocations : {
position : 0
},
bufferUsage : BufferUsage.DYNAMIC_DRAW
});
this._command.vertexArray = this._va;
} else {
this._va.getAttribute(0).vertexBuffer.copyFromArrayView(depthQuad);
}
};
DepthPlane.prototype.execute = function(context, passState) {
if (this._mode === SceneMode.SCENE3D) {
this._command.execute(context, passState);
}
};
DepthPlane.prototype.isDestroyed = function() {
return false;
};
DepthPlane.prototype.destroy = function() {
this._sp = this._sp && this._sp.destroy();
this._va = this._va && this._va.destroy();
};
return DepthPlane;
});
/*global define*/
define('Scene/DeviceOrientationCameraController',[
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/Math',
'../Core/Matrix3',
'../Core/Quaternion'
], function(
defined,
destroyObject,
DeveloperError,
CesiumMath,
Matrix3,
Quaternion) {
'use strict';
/**
* @private
*/
function DeviceOrientationCameraController(scene) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
this._scene = scene;
this._lastAlpha = undefined;
this._lastBeta = undefined;
this._lastGamma = undefined;
this._alpha = undefined;
this._beta = undefined;
this._gamma = undefined;
var that = this;
function callback(e) {
var alpha = e.alpha;
if (!defined(alpha)) {
that._alpha = undefined;
that._beta = undefined;
that._gamma = undefined;
return;
}
that._alpha = CesiumMath.toRadians(alpha);
that._beta = CesiumMath.toRadians(e.beta);
that._gamma = CesiumMath.toRadians(e.gamma);
}
window.addEventListener('deviceorientation', callback, false);
this._removeListener = function() {
window.removeEventListener('deviceorientation', callback, false);
};
}
var scratchQuaternion1 = new Quaternion();
var scratchQuaternion2 = new Quaternion();
var scratchMatrix3 = new Matrix3();
function rotate(camera, alpha, beta, gamma) {
var direction = camera.direction;
var right = camera.right;
var up = camera.up;
var bQuat = Quaternion.fromAxisAngle(direction, beta, scratchQuaternion2);
var gQuat = Quaternion.fromAxisAngle(right, gamma, scratchQuaternion1);
var rotQuat = Quaternion.multiply(gQuat, bQuat, gQuat);
var aQuat = Quaternion.fromAxisAngle(up, alpha, scratchQuaternion2);
Quaternion.multiply(aQuat, rotQuat, rotQuat);
var matrix = Matrix3.fromQuaternion(rotQuat, scratchMatrix3);
Matrix3.multiplyByVector(matrix, right, right);
Matrix3.multiplyByVector(matrix, up, up);
Matrix3.multiplyByVector(matrix, direction, direction);
}
DeviceOrientationCameraController.prototype.update = function() {
if (!defined(this._alpha)) {
return;
}
if (!defined(this._lastAlpha)) {
this._lastAlpha = this._alpha;
this._lastBeta = this._beta;
this._lastGamma = this._gamma;
}
var a = this._lastAlpha - this._alpha;
var b = this._lastBeta - this._beta;
var g = this._lastGamma - this._gamma;
rotate(this._scene.camera, -a, b, g);
this._lastAlpha = this._alpha;
this._lastBeta = this._beta;
this._lastGamma = this._gamma;
};
/**
* Returns true if this object was destroyed; otherwise, false.
*
*
* @returns {Boolean} true if this object was destroyed; otherwise, false.
*/
DeviceOrientationCameraController.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the resources held by this object. Destroying an object allows for deterministic
* release of resources, instead of relying on the garbage collector to destroy this object.
*
* Once an object is destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (undefined) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*/
DeviceOrientationCameraController.prototype.destroy = function() {
this._removeListener();
return destroyObject(this);
};
return DeviceOrientationCameraController;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/EllipsoidFS',[],function() {
'use strict';
return "#ifdef WRITE_DEPTH\n\
#ifdef GL_EXT_frag_depth\n\
#extension GL_EXT_frag_depth : enable\n\
#endif\n\
#endif\n\
uniform vec3 u_radii;\n\
uniform vec3 u_oneOverEllipsoidRadiiSquared;\n\
varying vec3 v_positionEC;\n\
vec4 computeEllipsoidColor(czm_ray ray, float intersection, float side)\n\
{\n\
vec3 positionEC = czm_pointAlongRay(ray, intersection);\n\
vec3 positionMC = (czm_inverseModelView * vec4(positionEC, 1.0)).xyz;\n\
vec3 geodeticNormal = normalize(czm_geodeticSurfaceNormal(positionMC, vec3(0.0), u_oneOverEllipsoidRadiiSquared));\n\
vec3 sphericalNormal = normalize(positionMC / u_radii);\n\
vec3 normalMC = geodeticNormal * side;\n\
vec3 normalEC = normalize(czm_normal * normalMC);\n\
vec2 st = czm_ellipsoidWgs84TextureCoordinates(sphericalNormal);\n\
vec3 positionToEyeEC = -positionEC;\n\
czm_materialInput materialInput;\n\
materialInput.s = st.s;\n\
materialInput.st = st;\n\
materialInput.str = (positionMC + u_radii) / u_radii;\n\
materialInput.normalEC = normalEC;\n\
materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(positionMC, normalEC);\n\
materialInput.positionToEyeEC = positionToEyeEC;\n\
czm_material material = czm_getMaterial(materialInput);\n\
#ifdef ONLY_SUN_LIGHTING\n\
return czm_private_phong(normalize(positionToEyeEC), material);\n\
#else\n\
return czm_phong(normalize(positionToEyeEC), material);\n\
#endif\n\
}\n\
void main()\n\
{\n\
float maxRadius = max(u_radii.x, max(u_radii.y, u_radii.z)) * 1.5;\n\
vec3 direction = normalize(v_positionEC);\n\
vec3 ellipsoidCenter = czm_modelView[3].xyz;\n\
float t1 = -1.0;\n\
float t2 = -1.0;\n\
float b = -2.0 * dot(direction, ellipsoidCenter);\n\
float c = dot(ellipsoidCenter, ellipsoidCenter) - maxRadius * maxRadius;\n\
float discriminant = b * b - 4.0 * c;\n\
if (discriminant >= 0.0) {\n\
t1 = (-b - sqrt(discriminant)) * 0.5;\n\
t2 = (-b + sqrt(discriminant)) * 0.5;\n\
}\n\
if (t1 < 0.0 && t2 < 0.0) {\n\
discard;\n\
}\n\
float t = min(t1, t2);\n\
if (t < 0.0) {\n\
t = 0.0;\n\
}\n\
czm_ellipsoid ellipsoid = czm_ellipsoidNew(ellipsoidCenter, u_radii);\n\
czm_ray ray = czm_ray(t * direction, direction);\n\
czm_raySegment intersection = czm_rayEllipsoidIntersectionInterval(ray, ellipsoid);\n\
if (czm_isEmpty(intersection))\n\
{\n\
discard;\n\
}\n\
vec4 outsideFaceColor = (intersection.start != 0.0) ? computeEllipsoidColor(ray, intersection.start, 1.0) : vec4(0.0);\n\
vec4 insideFaceColor = (outsideFaceColor.a < 1.0) ? computeEllipsoidColor(ray, intersection.stop, -1.0) : vec4(0.0);\n\
gl_FragColor = mix(insideFaceColor, outsideFaceColor, outsideFaceColor.a);\n\
gl_FragColor.a = 1.0 - (1.0 - insideFaceColor.a) * (1.0 - outsideFaceColor.a);\n\
#ifdef WRITE_DEPTH\n\
#ifdef GL_EXT_frag_depth\n\
t = (intersection.start != 0.0) ? intersection.start : intersection.stop;\n\
vec3 positionEC = czm_pointAlongRay(ray, t);\n\
vec4 positionCC = czm_projection * vec4(positionEC, 1.0);\n\
float z = positionCC.z / positionCC.w;\n\
float n = czm_depthRange.near;\n\
float f = czm_depthRange.far;\n\
gl_FragDepthEXT = (z * (f - n) + f + n) * 0.5;\n\
#endif\n\
#endif\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/EllipsoidVS',[],function() {
'use strict';
return "attribute vec3 position;\n\
uniform vec3 u_radii;\n\
varying vec3 v_positionEC;\n\
void main()\n\
{\n\
vec4 p = vec4(u_radii * position, 1.0);\n\
v_positionEC = (czm_modelView * p).xyz;\n\
gl_Position = czm_modelViewProjection * p;\n\
gl_Position.z = clamp(gl_Position.z, czm_depthRange.near, czm_depthRange.far);\n\
}\n\
";
});
/*global define*/
define('Scene/EllipsoidPrimitive',[
'../Core/BoundingSphere',
'../Core/BoxGeometry',
'../Core/Cartesian3',
'../Core/combine',
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/Matrix4',
'../Core/VertexFormat',
'../Renderer/BufferUsage',
'../Renderer/DrawCommand',
'../Renderer/Pass',
'../Renderer/RenderState',
'../Renderer/ShaderProgram',
'../Renderer/ShaderSource',
'../Renderer/VertexArray',
'../Shaders/EllipsoidFS',
'../Shaders/EllipsoidVS',
'./BlendingState',
'./CullFace',
'./Material',
'./SceneMode'
], function(
BoundingSphere,
BoxGeometry,
Cartesian3,
combine,
defaultValue,
defined,
destroyObject,
DeveloperError,
Matrix4,
VertexFormat,
BufferUsage,
DrawCommand,
Pass,
RenderState,
ShaderProgram,
ShaderSource,
VertexArray,
EllipsoidFS,
EllipsoidVS,
BlendingState,
CullFace,
Material,
SceneMode) {
'use strict';
var attributeLocations = {
position : 0
};
/**
* A renderable ellipsoid. It can also draw spheres when the three {@link EllipsoidPrimitive#radii} components are equal.
*
* This is only supported in 3D. The ellipsoid is not shown in 2D or Columbus view.
*
*
* @alias EllipsoidPrimitive
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Cartesian3} [options.center=Cartesian3.ZERO] The center of the ellipsoid in the ellipsoid's model coordinates.
* @param {Cartesian3} [options.radii] The radius of the ellipsoid along the x, y, and z axes in the ellipsoid's model coordinates.
* @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The 4x4 transformation matrix that transforms the ellipsoid from model to world coordinates.
* @param {Boolean} [options.show=true] Determines if this primitive will be shown.
* @param {Material} [options.material=Material.ColorType] The surface appearance of the primitive.
* @param {Object} [options.id] A user-defined object to return when the instance is picked with {@link Scene#pick}
* @param {Boolean} [options.debugShowBoundingVolume=false] For debugging only. Determines if this primitive's commands' bounding spheres are shown.
*
* @private
*/
function EllipsoidPrimitive(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
/**
* The center of the ellipsoid in the ellipsoid's model coordinates.
*
* The default is {@link Cartesian3.ZERO}.
*
*
* @type {Cartesian3}
* @default {@link Cartesian3.ZERO}
*
* @see EllipsoidPrimitive#modelMatrix
*/
this.center = Cartesian3.clone(defaultValue(options.center, Cartesian3.ZERO));
this._center = new Cartesian3();
/**
* The radius of the ellipsoid along the x, y, and z axes in the ellipsoid's model coordinates.
* When these are the same, the ellipsoid is a sphere.
*
* The default is undefined. The ellipsoid is not drawn until a radii is provided.
*
*
* @type {Cartesian3}
* @default undefined
*
*
* @example
* // A sphere with a radius of 2.0
* e.radii = new Cesium.Cartesian3(2.0, 2.0, 2.0);
*
* @see EllipsoidPrimitive#modelMatrix
*/
this.radii = Cartesian3.clone(options.radii);
this._radii = new Cartesian3();
this._oneOverEllipsoidRadiiSquared = new Cartesian3();
this._boundingSphere = new BoundingSphere();
/**
* The 4x4 transformation matrix that transforms the ellipsoid from model to world coordinates.
* When this is the identity matrix, the ellipsoid is drawn in world coordinates, i.e., Earth's WGS84 coordinates.
* Local reference frames can be used by providing a different transformation matrix, like that returned
* by {@link Transforms.eastNorthUpToFixedFrame}.
*
* @type {Matrix4}
* @default {@link Matrix4.IDENTITY}
*
* @example
* var origin = Cesium.Cartesian3.fromDegrees(-95.0, 40.0, 200000.0);
* e.modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(origin);
*/
this.modelMatrix = Matrix4.clone(defaultValue(options.modelMatrix, Matrix4.IDENTITY));
this._modelMatrix = new Matrix4();
this._computedModelMatrix = new Matrix4();
/**
* Determines if the ellipsoid primitive will be shown.
*
* @type {Boolean}
* @default true
*/
this.show = defaultValue(options.show, true);
/**
* The surface appearance of the ellipsoid. This can be one of several built-in {@link Material} objects or a custom material, scripted with
* {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}.
*
* The default material is Material.ColorType.
*
*
* @type {Material}
* @default Material.fromType(Material.ColorType)
*
*
* @example
* // 1. Change the color of the default material to yellow
* e.material.uniforms.color = new Cesium.Color(1.0, 1.0, 0.0, 1.0);
*
* // 2. Change material to horizontal stripes
* e.material = Cesium.Material.fromType(Cesium.Material.StripeType);
*
* @see {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}
*/
this.material = defaultValue(options.material, Material.fromType(Material.ColorType));
this._material = undefined;
this._translucent = undefined;
/**
* User-defined object returned when the ellipsoid is picked.
*
* @type Object
*
* @default undefined
*
* @see Scene#pick
*/
this.id = options.id;
this._id = undefined;
/**
* This property is for debugging only; it is not for production use nor is it optimized.
*
* Draws the bounding sphere for each draw command in the primitive.
*
*
* @type {Boolean}
*
* @default false
*/
this.debugShowBoundingVolume = defaultValue(options.debugShowBoundingVolume, false);
/**
* @private
*/
this.onlySunLighting = defaultValue(options.onlySunLighting, false);
this._onlySunLighting = false;
/**
* @private
*/
this._depthTestEnabled = defaultValue(options.depthTestEnabled, true);
this._sp = undefined;
this._rs = undefined;
this._va = undefined;
this._pickSP = undefined;
this._pickId = undefined;
this._colorCommand = new DrawCommand({
owner : defaultValue(options._owner, this)
});
this._pickCommand = new DrawCommand({
owner : defaultValue(options._owner, this)
});
var that = this;
this._uniforms = {
u_radii : function() {
return that.radii;
},
u_oneOverEllipsoidRadiiSquared : function() {
return that._oneOverEllipsoidRadiiSquared;
}
};
this._pickUniforms = {
czm_pickColor : function() {
return that._pickId.color;
}
};
}
function getVertexArray(context) {
var vertexArray = context.cache.ellipsoidPrimitive_vertexArray;
if (defined(vertexArray)) {
return vertexArray;
}
var geometry = BoxGeometry.createGeometry(BoxGeometry.fromDimensions({
dimensions : new Cartesian3(2.0, 2.0, 2.0),
vertexFormat : VertexFormat.POSITION_ONLY
}));
vertexArray = VertexArray.fromGeometry({
context : context,
geometry : geometry,
attributeLocations : attributeLocations,
bufferUsage : BufferUsage.STATIC_DRAW,
interleave : true
});
context.cache.ellipsoidPrimitive_vertexArray = vertexArray;
return vertexArray;
}
/**
* Called when {@link Viewer} or {@link CesiumWidget} render the scene to
* get the draw commands needed to render this primitive.
*
* Do not call this function directly. This is documented just to
* list the exceptions that may be propagated when the scene is rendered:
*
*
* @exception {DeveloperError} this.material must be defined.
*/
EllipsoidPrimitive.prototype.update = function(frameState) {
if (!this.show ||
(frameState.mode !== SceneMode.SCENE3D) ||
(!defined(this.center)) ||
(!defined(this.radii))) {
return;
}
if (!defined(this.material)) {
throw new DeveloperError('this.material must be defined.');
}
var context = frameState.context;
var translucent = this.material.isTranslucent();
var translucencyChanged = this._translucent !== translucent;
if (!defined(this._rs) || translucencyChanged) {
this._translucent = translucent;
// If this render state is ever updated to use a non-default
// depth range, the hard-coded values in EllipsoidVS.glsl need
// to be updated as well.
this._rs = RenderState.fromCache({
// Cull front faces - not back faces - so the ellipsoid doesn't
// disappear if the viewer enters the bounding box.
cull : {
enabled : true,
face : CullFace.FRONT
},
depthTest : {
enabled : this._depthTestEnabled
},
// Only write depth when EXT_frag_depth is supported since the depth for
// the bounding box is wrong; it is not the true depth of the ray casted ellipsoid.
depthMask : !translucent && context.fragmentDepth,
blending : translucent ? BlendingState.ALPHA_BLEND : undefined
});
}
if (!defined(this._va)) {
this._va = getVertexArray(context);
}
var boundingSphereDirty = false;
var radii = this.radii;
if (!Cartesian3.equals(this._radii, radii)) {
Cartesian3.clone(radii, this._radii);
var r = this._oneOverEllipsoidRadiiSquared;
r.x = 1.0 / (radii.x * radii.x);
r.y = 1.0 / (radii.y * radii.y);
r.z = 1.0 / (radii.z * radii.z);
boundingSphereDirty = true;
}
if (!Matrix4.equals(this.modelMatrix, this._modelMatrix) || !Cartesian3.equals(this.center, this._center)) {
Matrix4.clone(this.modelMatrix, this._modelMatrix);
Cartesian3.clone(this.center, this._center);
// Translate model coordinates used for rendering such that the origin is the center of the ellipsoid.
Matrix4.multiplyByTranslation(this.modelMatrix, this.center, this._computedModelMatrix);
boundingSphereDirty = true;
}
if (boundingSphereDirty) {
Cartesian3.clone(Cartesian3.ZERO, this._boundingSphere.center);
this._boundingSphere.radius = Cartesian3.maximumComponent(radii);
BoundingSphere.transform(this._boundingSphere, this._computedModelMatrix, this._boundingSphere);
}
var materialChanged = this._material !== this.material;
this._material = this.material;
this._material.update(context);
var lightingChanged = this.onlySunLighting !== this._onlySunLighting;
this._onlySunLighting = this.onlySunLighting;
var colorCommand = this._colorCommand;
var fs;
// Recompile shader when material, lighting, or translucency changes
if (materialChanged || lightingChanged || translucencyChanged) {
fs = new ShaderSource({
sources : [this.material.shaderSource, EllipsoidFS]
});
if (this.onlySunLighting) {
fs.defines.push('ONLY_SUN_LIGHTING');
}
if (!translucent && context.fragmentDepth) {
fs.defines.push('WRITE_DEPTH');
}
this._sp = ShaderProgram.replaceCache({
context : context,
shaderProgram : this._sp,
vertexShaderSource : EllipsoidVS,
fragmentShaderSource : fs,
attributeLocations : attributeLocations
});
colorCommand.vertexArray = this._va;
colorCommand.renderState = this._rs;
colorCommand.shaderProgram = this._sp;
colorCommand.uniformMap = combine(this._uniforms, this.material._uniforms);
colorCommand.executeInClosestFrustum = translucent;
}
var commandList = frameState.commandList;
var passes = frameState.passes;
if (passes.render) {
colorCommand.boundingVolume = this._boundingSphere;
colorCommand.debugShowBoundingVolume = this.debugShowBoundingVolume;
colorCommand.modelMatrix = this._computedModelMatrix;
colorCommand.pass = translucent ? Pass.TRANSLUCENT : Pass.OPAQUE;
commandList.push(colorCommand);
}
if (passes.pick) {
var pickCommand = this._pickCommand;
if (!defined(this._pickId) || (this._id !== this.id)) {
this._id = this.id;
this._pickId = this._pickId && this._pickId.destroy();
this._pickId = context.createPickId({
primitive : this,
id : this.id
});
}
// Recompile shader when material changes
if (materialChanged || lightingChanged || !defined(this._pickSP)) {
fs = new ShaderSource({
sources : [this.material.shaderSource, EllipsoidFS],
pickColorQualifier : 'uniform'
});
if (this.onlySunLighting) {
fs.defines.push('ONLY_SUN_LIGHTING');
}
if (!translucent && context.fragmentDepth) {
fs.defines.push('WRITE_DEPTH');
}
this._pickSP = ShaderProgram.replaceCache({
context : context,
shaderProgram : this._pickSP,
vertexShaderSource : EllipsoidVS,
fragmentShaderSource : fs,
attributeLocations : attributeLocations
});
pickCommand.vertexArray = this._va;
pickCommand.renderState = this._rs;
pickCommand.shaderProgram = this._pickSP;
pickCommand.uniformMap = combine(combine(this._uniforms, this._pickUniforms), this.material._uniforms);
pickCommand.executeInClosestFrustum = translucent;
}
pickCommand.boundingVolume = this._boundingSphere;
pickCommand.modelMatrix = this._computedModelMatrix;
pickCommand.pass = translucent ? Pass.TRANSLUCENT : Pass.OPAQUE;
commandList.push(pickCommand);
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
*
* If this object was destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} true if this object was destroyed; otherwise, false.
*
* @see EllipsoidPrimitive#destroy
*/
EllipsoidPrimitive.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
*
* Once an object is destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (undefined) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* e = e && e.destroy();
*
* @see EllipsoidPrimitive#isDestroyed
*/
EllipsoidPrimitive.prototype.destroy = function() {
this._sp = this._sp && this._sp.destroy();
this._pickSP = this._pickSP && this._pickSP.destroy();
this._pickId = this._pickId && this._pickId.destroy();
return destroyObject(this);
};
return EllipsoidPrimitive;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/Appearances/EllipsoidSurfaceAppearanceFS',[],function() {
'use strict';
return "varying vec3 v_positionMC;\n\
varying vec3 v_positionEC;\n\
varying vec2 v_st;\n\
void main()\n\
{\n\
czm_materialInput materialInput;\n\
vec3 normalEC = normalize(czm_normal3D * czm_geodeticSurfaceNormal(v_positionMC, vec3(0.0), vec3(1.0)));\n\
#ifdef FACE_FORWARD\n\
normalEC = faceforward(normalEC, vec3(0.0, 0.0, 1.0), -normalEC);\n\
#endif\n\
materialInput.s = v_st.s;\n\
materialInput.st = v_st;\n\
materialInput.str = vec3(v_st, 0.0);\n\
materialInput.normalEC = normalEC;\n\
materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(v_positionMC, materialInput.normalEC);\n\
vec3 positionToEyeEC = -v_positionEC;\n\
materialInput.positionToEyeEC = positionToEyeEC;\n\
czm_material material = czm_getMaterial(materialInput);\n\
#ifdef FLAT\n\
gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
#else\n\
gl_FragColor = czm_phong(normalize(positionToEyeEC), material);\n\
#endif\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/Appearances/EllipsoidSurfaceAppearanceVS',[],function() {
'use strict';
return "attribute vec3 position3DHigh;\n\
attribute vec3 position3DLow;\n\
attribute vec2 st;\n\
attribute float batchId;\n\
varying vec3 v_positionMC;\n\
varying vec3 v_positionEC;\n\
varying vec2 v_st;\n\
void main()\n\
{\n\
vec4 p = czm_computePosition();\n\
v_positionMC = position3DHigh + position3DLow;\n\
v_positionEC = (czm_modelViewRelativeToEye * p).xyz;\n\
v_st = st;\n\
gl_Position = czm_modelViewProjectionRelativeToEye * p;\n\
}\n\
";
});
/*global define*/
define('Scene/EllipsoidSurfaceAppearance',[
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/VertexFormat',
'../Shaders/Appearances/EllipsoidSurfaceAppearanceFS',
'../Shaders/Appearances/EllipsoidSurfaceAppearanceVS',
'./Appearance',
'./Material'
], function(
defaultValue,
defined,
defineProperties,
VertexFormat,
EllipsoidSurfaceAppearanceFS,
EllipsoidSurfaceAppearanceVS,
Appearance,
Material) {
'use strict';
/**
* An appearance for geometry on the surface of the ellipsoid like {@link PolygonGeometry}
* and {@link RectangleGeometry}, which supports all materials like {@link MaterialAppearance}
* with {@link MaterialAppearance.MaterialSupport.ALL}. However, this appearance requires
* fewer vertex attributes since the fragment shader can procedurally compute normal,
* binormal, and tangent.
*
* @alias EllipsoidSurfaceAppearance
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Boolean} [options.flat=false] When true, flat shading is used in the fragment shader, which means lighting is not taking into account.
* @param {Boolean} [options.faceForward=options.aboveGround] When true, the fragment shader flips the surface normal as needed to ensure that the normal faces the viewer to avoid dark spots. This is useful when both sides of a geometry should be shaded like {@link WallGeometry}.
* @param {Boolean} [options.translucent=true] When true, the geometry is expected to appear translucent so {@link EllipsoidSurfaceAppearance#renderState} has alpha blending enabled.
* @param {Boolean} [options.aboveGround=false] When true, the geometry is expected to be on the ellipsoid's surface - not at a constant height above it - so {@link EllipsoidSurfaceAppearance#renderState} has backface culling enabled.
* @param {Material} [options.material=Material.ColorType] The material used to determine the fragment color.
* @param {String} [options.vertexShaderSource] Optional GLSL vertex shader source to override the default vertex shader.
* @param {String} [options.fragmentShaderSource] Optional GLSL fragment shader source to override the default fragment shader.
* @param {RenderState} [options.renderState] Optional render state to override the default render state.
*
* @see {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}
*
* @example
* var primitive = new Cesium.Primitive({
* geometryInstances : new Cesium.GeometryInstance({
* geometry : new Cesium.PolygonGeometry({
* vertexFormat : Cesium.EllipsoidSurfaceAppearance.VERTEX_FORMAT,
* // ...
* })
* }),
* appearance : new Cesium.EllipsoidSurfaceAppearance({
* material : Cesium.Material.fromType('Stripe')
* })
* });
*/
function EllipsoidSurfaceAppearance(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var translucent = defaultValue(options.translucent, true);
var aboveGround = defaultValue(options.aboveGround, false);
/**
* The material used to determine the fragment color. Unlike other {@link EllipsoidSurfaceAppearance}
* properties, this is not read-only, so an appearance's material can change on the fly.
*
* @type Material
*
* @default {@link Material.ColorType}
*
* @see {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}
*/
this.material = (defined(options.material)) ? options.material : Material.fromType(Material.ColorType);
/**
* When true, the geometry is expected to appear translucent.
*
* @type {Boolean}
*
* @default true
*/
this.translucent = defaultValue(options.translucent, true);
this._vertexShaderSource = defaultValue(options.vertexShaderSource, EllipsoidSurfaceAppearanceVS);
this._fragmentShaderSource = defaultValue(options.fragmentShaderSource, EllipsoidSurfaceAppearanceFS);
this._renderState = Appearance.getDefaultRenderState(translucent, !aboveGround, options.renderState);
this._closed = false;
// Non-derived members
this._flat = defaultValue(options.flat, false);
this._faceForward = defaultValue(options.faceForward, aboveGround);
this._aboveGround = aboveGround;
}
defineProperties(EllipsoidSurfaceAppearance.prototype, {
/**
* The GLSL source code for the vertex shader.
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type {String}
* @readonly
*/
vertexShaderSource : {
get : function() {
return this._vertexShaderSource;
}
},
/**
* The GLSL source code for the fragment shader. The full fragment shader
* source is built procedurally taking into account {@link EllipsoidSurfaceAppearance#material},
* {@link EllipsoidSurfaceAppearance#flat}, and {@link EllipsoidSurfaceAppearance#faceForward}.
* Use {@link EllipsoidSurfaceAppearance#getFragmentShaderSource} to get the full source.
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type {String}
* @readonly
*/
fragmentShaderSource : {
get : function() {
return this._fragmentShaderSource;
}
},
/**
* The WebGL fixed-function state to use when rendering the geometry.
*
* The render state can be explicitly defined when constructing a {@link EllipsoidSurfaceAppearance}
* instance, or it is set implicitly via {@link EllipsoidSurfaceAppearance#translucent}
* and {@link EllipsoidSurfaceAppearance#aboveGround}.
*
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type {Object}
* @readonly
*/
renderState : {
get : function() {
return this._renderState;
}
},
/**
* When true, the geometry is expected to be closed so
* {@link EllipsoidSurfaceAppearance#renderState} has backface culling enabled.
* If the viewer enters the geometry, it will not be visible.
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type {Boolean}
* @readonly
*
* @default false
*/
closed : {
get : function() {
return this._closed;
}
},
/**
* The {@link VertexFormat} that this appearance instance is compatible with.
* A geometry can have more vertex attributes and still be compatible - at a
* potential performance cost - but it can't have less.
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type VertexFormat
* @readonly
*
* @default {@link EllipsoidSurfaceAppearance.VERTEX_FORMAT}
*/
vertexFormat : {
get : function() {
return EllipsoidSurfaceAppearance.VERTEX_FORMAT;
}
},
/**
* When true, flat shading is used in the fragment shader,
* which means lighting is not taking into account.
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type {Boolean}
* @readonly
*
* @default false
*/
flat : {
get : function() {
return this._flat;
}
},
/**
* When true, the fragment shader flips the surface normal
* as needed to ensure that the normal faces the viewer to avoid
* dark spots. This is useful when both sides of a geometry should be
* shaded like {@link WallGeometry}.
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type {Boolean}
* @readonly
*
* @default true
*/
faceForward : {
get : function() {
return this._faceForward;
}
},
/**
* When true, the geometry is expected to be on the ellipsoid's
* surface - not at a constant height above it - so {@link EllipsoidSurfaceAppearance#renderState}
* has backface culling enabled.
*
*
* @memberof EllipsoidSurfaceAppearance.prototype
*
* @type {Boolean}
* @readonly
*
* @default false
*/
aboveGround : {
get : function() {
return this._aboveGround;
}
}
});
/**
* The {@link VertexFormat} that all {@link EllipsoidSurfaceAppearance} instances
* are compatible with, which requires only position and st
* attributes. Other attributes are procedurally computed in the fragment shader.
*
* @type VertexFormat
*
* @constant
*/
EllipsoidSurfaceAppearance.VERTEX_FORMAT = VertexFormat.POSITION_AND_ST;
/**
* Procedurally creates the full GLSL fragment shader source. For {@link EllipsoidSurfaceAppearance},
* this is derived from {@link EllipsoidSurfaceAppearance#fragmentShaderSource}, {@link EllipsoidSurfaceAppearance#flat},
* and {@link EllipsoidSurfaceAppearance#faceForward}.
*
* @function
*
* @returns {String} The full GLSL fragment shader source.
*/
EllipsoidSurfaceAppearance.prototype.getFragmentShaderSource = Appearance.prototype.getFragmentShaderSource;
/**
* Determines if the geometry is translucent based on {@link EllipsoidSurfaceAppearance#translucent} and {@link Material#isTranslucent}.
*
* @function
*
* @returns {Boolean} true if the appearance is translucent.
*/
EllipsoidSurfaceAppearance.prototype.isTranslucent = Appearance.prototype.isTranslucent;
/**
* Creates a render state. This is not the final render state instance; instead,
* it can contain a subset of render state properties identical to the render state
* created in the context.
*
* @function
*
* @returns {Object} The render state.
*/
EllipsoidSurfaceAppearance.prototype.getRenderState = Appearance.prototype.getRenderState;
return EllipsoidSurfaceAppearance;
});
/*global define*/
define('Scene/Fog',[
'../Core/Cartesian3',
'../Core/defined',
'../Core/Math',
'./SceneMode'
], function(
Cartesian3,
defined,
CesiumMath,
SceneMode) {
'use strict';
/**
* Blends the atmosphere to geometry far from the camera for horizon views. Allows for additional
* performance improvements by rendering less geometry and dispatching less terrain requests.
*
* @alias Fog
* @constructor
*/
function Fog() {
/**
* true if fog is enabled, false otherwise.
* @type {Boolean}
* @default true
*/
this.enabled = true;
/**
* A scalar that determines the density of the fog. Terrain that is in full fog are culled.
* The density of the fog increases as this number approaches 1.0 and becomes less dense as it approaches zero.
* The more dense the fog is, the more aggressively the terrain is culled. For example, if the camera is a height of
* 1000.0m above the ellipsoid, increasing the value to 3.0e-3 will cause many tiles close to the viewer be culled.
* Decreasing the value will push the fog further from the viewer, but decrease performance as more of the terrain is rendered.
* @type {Number}
* @default 2.0e-4
*/
this.density = 2.0e-4;
/**
* A factor used to increase the screen space error of terrain tiles when they are partially in fog. The effect is to reduce
* the number of terrain tiles requested for rendering. If set to zero, the feature will be disabled. If the value is increased
* for mountainous regions, less tiles will need to be requested, but the terrain meshes near the horizon may be a noticeably
* lower resolution. If the value is increased in a relatively flat area, there will be little noticeable change on the horizon.
* @type {Number}
* @default 2.0
*/
this.screenSpaceErrorFactor = 2.0;
}
// These values were found by sampling the density at certain views and finding at what point culled tiles impacted the view at the horizon.
var heightsTable = [359.393, 800.749, 1275.6501, 2151.1192, 3141.7763, 4777.5198, 6281.2493, 12364.307, 15900.765, 49889.0549, 78026.8259, 99260.7344, 120036.3873, 151011.0158, 156091.1953, 203849.3112, 274866.9803, 319916.3149, 493552.0528, 628733.5874];
var densityTable = [2.0e-5, 2.0e-4, 1.0e-4, 7.0e-5, 5.0e-5, 4.0e-5, 3.0e-5, 1.9e-5, 1.0e-5, 8.5e-6, 6.2e-6, 5.8e-6, 5.3e-6, 5.2e-6, 5.1e-6, 4.2e-6, 4.0e-6, 3.4e-6, 2.6e-6, 2.2e-6];
// Scale densities by 1e6 to bring lowest value to ~1. Prevents divide by zero.
for (var i = 0; i < densityTable.length; ++i) {
densityTable[i] *= 1.0e6;
}
// Change range to [0, 1].
var tableStartDensity = densityTable[1];
var tableEndDensity = densityTable[densityTable.length - 1];
for (var j = 0; j < densityTable.length; ++j) {
densityTable[j] = (densityTable[j] - tableEndDensity) / (tableStartDensity - tableEndDensity);
}
var tableLastIndex = 0;
function findInterval(height) {
var heights = heightsTable;
var length = heights.length;
if (height < heights[0]) {
tableLastIndex = 0;
return tableLastIndex;
} else if (height > heights[length - 1]) {
tableLastIndex = length - 2;
return tableLastIndex;
}
// Take advantage of temporal coherence by checking current, next and previous intervals
// for containment of time.
if (height >= heights[tableLastIndex]) {
if (tableLastIndex + 1 < length && height < heights[tableLastIndex + 1]) {
return tableLastIndex;
} else if (tableLastIndex + 2 < length && height < heights[tableLastIndex + 2]) {
++tableLastIndex;
return tableLastIndex;
}
} else if (tableLastIndex - 1 >= 0 && height >= heights[tableLastIndex - 1]) {
--tableLastIndex;
return tableLastIndex;
}
// The above failed so do a linear search.
var i;
for (i = 0; i < length - 2; ++i) {
if (height >= heights[i] && height < heights[i + 1]) {
break;
}
}
tableLastIndex = i;
return tableLastIndex;
}
var scratchPositionNormal = new Cartesian3();
Fog.prototype.update = function(frameState) {
var enabled = frameState.fog.enabled = this.enabled;
if (!enabled) {
return;
}
var camera = frameState.camera;
var positionCartographic = camera.positionCartographic;
// Turn off fog in space.
if (!defined(positionCartographic) || positionCartographic.height > 800000.0 || frameState.mode !== SceneMode.SCENE3D) {
frameState.fog.enabled = false;
return;
}
var height = positionCartographic.height;
var i = findInterval(height);
var t = CesiumMath.clamp((height - heightsTable[i]) / (heightsTable[i + 1] - heightsTable[i]), 0.0, 1.0);
var density = CesiumMath.lerp(densityTable[i], densityTable[i + 1], t);
// Again, scale value to be in the range of densityTable (prevents divide by zero) and change to new range.
var startDensity = this.density * 1.0e6;
var endDensity = (startDensity / tableStartDensity) * tableEndDensity;
density = (density * (startDensity - endDensity)) * 1.0e-6;
// Fade fog in as the camera tilts toward the horizon.
var positionNormal = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
var dot = CesiumMath.clamp(Cartesian3.dot(camera.directionWC, positionNormal), 0.0, 1.0);
density *= 1.0 - dot;
frameState.fog.density = density;
frameState.fog.sse = this.screenSpaceErrorFactor;
};
return Fog;
});
/*global define*/
define('Scene/FrameRateMonitor',[
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/Event',
'../Core/getTimestamp',
'../Core/TimeConstants'
], function(
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
Event,
getTimestamp,
TimeConstants) {
'use strict';
/**
* Monitors the frame rate (frames per second) in a {@link Scene} and raises an event if the frame rate is
* lower than a threshold. Later, if the frame rate returns to the required level, a separate event is raised.
* To avoid creating multiple FrameRateMonitors for a single {@link Scene}, use {@link FrameRateMonitor.fromScene}
* instead of constructing an instance explicitly.
*
* @alias FrameRateMonitor
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Scene} options.scene The Scene instance for which to monitor performance.
* @param {Number} [options.samplingWindow=5.0] The length of the sliding window over which to compute the average frame rate, in seconds.
* @param {Number} [options.quietPeriod=2.0] The length of time to wait at startup and each time the page becomes visible (i.e. when the user
* switches back to the tab) before starting to measure performance, in seconds.
* @param {Number} [options.warmupPeriod=5.0] The length of the warmup period, in seconds. During the warmup period, a separate
* (usually lower) frame rate is required.
* @param {Number} [options.minimumFrameRateDuringWarmup=4] The minimum frames-per-second that are required for acceptable performance during
* the warmup period. If the frame rate averages less than this during any samplingWindow during the warmupPeriod, the
* lowFrameRate event will be raised and the page will redirect to the redirectOnLowFrameRateUrl, if any.
* @param {Number} [options.minimumFrameRateAfterWarmup=8] The minimum frames-per-second that are required for acceptable performance after
* the end of the warmup period. If the frame rate averages less than this during any samplingWindow after the warmupPeriod, the
* lowFrameRate event will be raised and the page will redirect to the redirectOnLowFrameRateUrl, if any.
*/
function FrameRateMonitor(options) {
if (!defined(options) || !defined(options.scene)) {
throw new DeveloperError('options.scene is required.');
}
this._scene = options.scene;
/**
* Gets or sets the length of the sliding window over which to compute the average frame rate, in seconds.
* @type {Number}
*/
this.samplingWindow = defaultValue(options.samplingWindow, FrameRateMonitor.defaultSettings.samplingWindow);
/**
* Gets or sets the length of time to wait at startup and each time the page becomes visible (i.e. when the user
* switches back to the tab) before starting to measure performance, in seconds.
* @type {Number}
*/
this.quietPeriod = defaultValue(options.quietPeriod, FrameRateMonitor.defaultSettings.quietPeriod);
/**
* Gets or sets the length of the warmup period, in seconds. During the warmup period, a separate
* (usually lower) frame rate is required.
* @type {Number}
*/
this.warmupPeriod = defaultValue(options.warmupPeriod, FrameRateMonitor.defaultSettings.warmupPeriod);
/**
* Gets or sets the minimum frames-per-second that are required for acceptable performance during
* the warmup period. If the frame rate averages less than this during any samplingWindow during the warmupPeriod, the
* lowFrameRate event will be raised and the page will redirect to the redirectOnLowFrameRateUrl, if any.
* @type {Number}
*/
this.minimumFrameRateDuringWarmup = defaultValue(options.minimumFrameRateDuringWarmup, FrameRateMonitor.defaultSettings.minimumFrameRateDuringWarmup);
/**
* Gets or sets the minimum frames-per-second that are required for acceptable performance after
* the end of the warmup period. If the frame rate averages less than this during any samplingWindow after the warmupPeriod, the
* lowFrameRate event will be raised and the page will redirect to the redirectOnLowFrameRateUrl, if any.
* @type {Number}
*/
this.minimumFrameRateAfterWarmup = defaultValue(options.minimumFrameRateAfterWarmup, FrameRateMonitor.defaultSettings.minimumFrameRateAfterWarmup);
this._lowFrameRate = new Event();
this._nominalFrameRate = new Event();
this._frameTimes = [];
this._needsQuietPeriod = true;
this._quietPeriodEndTime = 0.0;
this._warmupPeriodEndTime = 0.0;
this._frameRateIsLow = false;
this._lastFramesPerSecond = undefined;
this._pauseCount = 0;
var that = this;
this._preRenderRemoveListener = this._scene.preRender.addEventListener(function(scene, time) {
update(that, time);
});
this._hiddenPropertyName = (document.hidden !== undefined) ? 'hidden' :
(document.mozHidden !== undefined) ? 'mozHidden' :
(document.msHidden !== undefined) ? 'msHidden' :
(document.webkitHidden !== undefined) ? 'webkitHidden' : undefined;
var visibilityChangeEventName = (document.hidden !== undefined) ? 'visibilitychange' :
(document.mozHidden !== undefined) ? 'mozvisibilitychange' :
(document.msHidden !== undefined) ? 'msvisibilitychange' :
(document.webkitHidden !== undefined) ? 'webkitvisibilitychange' : undefined;
function visibilityChangeListener() {
visibilityChanged(that);
}
this._visibilityChangeRemoveListener = undefined;
if (defined(visibilityChangeEventName)) {
document.addEventListener(visibilityChangeEventName, visibilityChangeListener, false);
this._visibilityChangeRemoveListener = function() {
document.removeEventListener(visibilityChangeEventName, visibilityChangeListener, false);
};
}
}
/**
* The default frame rate monitoring settings. These settings are used when {@link FrameRateMonitor.fromScene}
* needs to create a new frame rate monitor, and for any settings that are not passed to the
* {@link FrameRateMonitor} constructor.
*
* @memberof FrameRateMonitor
* @type {Object}
*/
FrameRateMonitor.defaultSettings = {
samplingWindow : 5.0,
quietPeriod : 2.0,
warmupPeriod : 5.0,
minimumFrameRateDuringWarmup : 4,
minimumFrameRateAfterWarmup : 8
};
/**
* Gets the {@link FrameRateMonitor} for a given scene. If the scene does not yet have
* a {@link FrameRateMonitor}, one is created with the {@link FrameRateMonitor.defaultSettings}.
*
* @param {Scene} scene The scene for which to get the {@link FrameRateMonitor}.
* @returns {FrameRateMonitor} The scene's {@link FrameRateMonitor}.
*/
FrameRateMonitor.fromScene = function(scene) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
if (!defined(scene._frameRateMonitor) || scene._frameRateMonitor.isDestroyed()) {
scene._frameRateMonitor = new FrameRateMonitor({
scene : scene
});
}
return scene._frameRateMonitor;
};
defineProperties(FrameRateMonitor.prototype, {
/**
* Gets the {@link Scene} instance for which to monitor performance.
* @memberof FrameRateMonitor.prototype
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
},
/**
* Gets the event that is raised when a low frame rate is detected. The function will be passed
* the {@link Scene} instance as its first parameter and the average number of frames per second
* over the sampling window as its second parameter.
* @memberof FrameRateMonitor.prototype
* @type {Event}
*/
lowFrameRate : {
get : function() {
return this._lowFrameRate;
}
},
/**
* Gets the event that is raised when the frame rate returns to a normal level after having been low.
* The function will be passed the {@link Scene} instance as its first parameter and the average
* number of frames per second over the sampling window as its second parameter.
* @memberof FrameRateMonitor.prototype
* @type {Event}
*/
nominalFrameRate : {
get : function() {
return this._nominalFrameRate;
}
},
/**
* Gets the most recently computed average frames-per-second over the last samplingWindow.
* This property may be undefined if the frame rate has not been computed.
* @memberof FrameRateMonitor.prototype
* @type {Number}
*/
lastFramesPerSecond : {
get : function() {
return this._lastFramesPerSecond;
}
}
});
/**
* Pauses monitoring of the frame rate. To resume monitoring, {@link FrameRateMonitor#unpause}
* must be called once for each time this function is called.
* @memberof FrameRateMonitor
*/
FrameRateMonitor.prototype.pause = function() {
++this._pauseCount;
if (this._pauseCount === 1) {
this._frameTimes.length = 0;
this._lastFramesPerSecond = undefined;
}
};
/**
* Resumes monitoring of the frame rate. If {@link FrameRateMonitor#pause} was called
* multiple times, this function must be called the same number of times in order to
* actually resume monitoring.
* @memberof FrameRateMonitor
*/
FrameRateMonitor.prototype.unpause = function() {
--this._pauseCount;
if (this._pauseCount <= 0) {
this._pauseCount = 0;
this._needsQuietPeriod = true;
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
*
* If this object was destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception.
*
* @memberof FrameRateMonitor
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see FrameRateMonitor#destroy
*/
FrameRateMonitor.prototype.isDestroyed = function() {
return false;
};
/**
* Unsubscribes this instance from all events it is listening to.
* Once an object is destroyed, it should not be used; calling any function other than
* isDestroyed will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (undefined) to the object as done in the example.
*
* @memberof FrameRateMonitor
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see FrameRateMonitor#isDestroyed
*/
FrameRateMonitor.prototype.destroy = function() {
this._preRenderRemoveListener();
if (defined(this._visibilityChangeRemoveListener)) {
this._visibilityChangeRemoveListener();
}
return destroyObject(this);
};
function update(monitor, time) {
if (monitor._pauseCount > 0) {
return;
}
var timeStamp = getTimestamp();
if (monitor._needsQuietPeriod) {
monitor._needsQuietPeriod = false;
monitor._frameTimes.length = 0;
monitor._quietPeriodEndTime = timeStamp + (monitor.quietPeriod / TimeConstants.SECONDS_PER_MILLISECOND);
monitor._warmupPeriodEndTime = monitor._quietPeriodEndTime + ((monitor.warmupPeriod + monitor.samplingWindow) / TimeConstants.SECONDS_PER_MILLISECOND);
} else if (timeStamp >= monitor._quietPeriodEndTime) {
monitor._frameTimes.push(timeStamp);
var beginningOfWindow = timeStamp - (monitor.samplingWindow / TimeConstants.SECONDS_PER_MILLISECOND);
if (monitor._frameTimes.length >= 2 && monitor._frameTimes[0] <= beginningOfWindow) {
while (monitor._frameTimes.length >= 2 && monitor._frameTimes[1] < beginningOfWindow) {
monitor._frameTimes.shift();
}
var averageTimeBetweenFrames = (timeStamp - monitor._frameTimes[0]) / (monitor._frameTimes.length - 1);
monitor._lastFramesPerSecond = 1000.0 / averageTimeBetweenFrames;
var maximumFrameTime = 1000.0 / (timeStamp > monitor._warmupPeriodEndTime ? monitor.minimumFrameRateAfterWarmup : monitor.minimumFrameRateDuringWarmup);
if (averageTimeBetweenFrames > maximumFrameTime) {
if (!monitor._frameRateIsLow) {
monitor._frameRateIsLow = true;
monitor._needsQuietPeriod = true;
monitor.lowFrameRate.raiseEvent(monitor.scene, monitor._lastFramesPerSecond);
}
} else if (monitor._frameRateIsLow) {
monitor._frameRateIsLow = false;
monitor._needsQuietPeriod = true;
monitor.nominalFrameRate.raiseEvent(monitor.scene, monitor._lastFramesPerSecond);
}
}
}
}
function visibilityChanged(monitor) {
if (document[monitor._hiddenPropertyName]) {
monitor.pause();
} else {
monitor.unpause();
}
}
return FrameRateMonitor;
});
/*global define*/
define('Scene/FrameState',[
'./SceneMode'
], function(
SceneMode) {
'use strict';
/**
* State information about the current frame. An instance of this class
* is provided to update functions.
*
* @param {CreditDisplay} creditDisplay Handles adding and removing credits from an HTML element
*
* @alias FrameState
* @constructor
*
* @private
*/
function FrameState(context, creditDisplay) {
/**
* The rendering context.
* @type {Context}
*/
this.context = context;
/**
* An array of rendering commands.
* @type {DrawCommand[]}
*/
this.commandList = [];
/**
* An array of shadow maps.
* @type {ShadowMap[]}
*/
this.shadowMaps = [];
/**
* The current mode of the scene.
* @type {SceneMode}
* @default {@link SceneMode.SCENE3D}
*/
this.mode = SceneMode.SCENE3D;
/**
* The current morph transition time between 2D/Columbus View and 3D,
* with 0.0 being 2D or Columbus View and 1.0 being 3D.
*
* @type {Number}
*/
this.morphTime = SceneMode.getMorphTime(SceneMode.SCENE3D);
/**
* The current frame number.
*
* @type {Number}
* @default 0
*/
this.frameNumber = 0;
/**
* The scene's current time.
*
* @type {JulianDate}
* @default undefined
*/
this.time = undefined;
/**
* The map projection to use in 2D and Columbus View modes.
*
* @type {MapProjection}
* @default undefined
*/
this.mapProjection = undefined;
/**
* The current camera.
* @type {Camera}
* @default undefined
*/
this.camera = undefined;
/**
* The culling volume.
* @type {CullingVolume}
* @default undefined
*/
this.cullingVolume = undefined;
/**
* The current occluder.
* @type {Occluder}
* @default undefined
*/
this.occluder = undefined;
this.passes = {
/**
* true if the primitive should update for a render pass, false otherwise.
* @type {Boolean}
* @default false
*/
render : false,
/**
* true if the primitive should update for a picking pass, false otherwise.
* @type {Boolean}
* @default false
*/
pick : false
};
/**
* The credit display.
* @type {CreditDisplay}
*/
this.creditDisplay = creditDisplay;
/**
* An array of functions to be called at the end of the frame. This array
* will be cleared after each frame.
*
* This allows queueing up events in update functions and
* firing them at a time when the subscribers are free to change the
* scene state, e.g., manipulate the camera, instead of firing events
* directly in update functions.
*
*
* @type {FrameState~AfterRenderCallback[]}
*
* @example
* frameState.afterRender.push(function() {
* // take some action, raise an event, etc.
* });
*/
this.afterRender = [];
/**
* Gets whether or not to optimized for 3D only.
* @type {Boolean}
* @default false
*/
this.scene3DOnly = false;
this.fog = {
/**
* true if fog is enabled, false otherwise.
* @type {Boolean}
* @default false
*/
enabled : false,
/**
* A positive number used to mix the color and fog color based on camera distance.
* @type {Number}
* @default undefined
*/
density : undefined,
/**
* A scalar used to modify the screen space error of geometry partially in fog.
* @type {Number}
* @default undefined
*/
sse : undefined
};
/**
* A scalar used to exaggerate the terrain.
* @type {Number}
*/
this.terrainExaggeration = 1.0;
this.shadowHints = {
/**
* Whether there are any active shadow maps this frame.
* @type {Boolean}
*/
shadowsEnabled : true,
/**
* All shadow maps that are enabled this frame.
*/
shadowMaps : [],
/**
* Shadow maps that originate from light sources. Does not include shadow maps that are used for
* analytical purposes. Only these shadow maps will be used to generate receive shadows shaders.
*/
lightShadowMaps : [],
/**
* The near plane of the scene's frustum commands. Used for fitting cascaded shadow maps.
* @type {Number}
*/
nearPlane : 1.0,
/**
* The far plane of the scene's frustum commands. Used for fitting cascaded shadow maps.
* @type {Number}
*/
farPlane : 5000.0,
/**
* The size of the bounding volume that is closest to the camera. This is used to place more shadow detail near the object.
* @type {Number}
*/
closestObjectSize : 1000.0,
/**
* The time when a shadow map was last dirty
* @type {Number}
*/
lastDirtyTime : 0,
/**
* Whether the shadows maps are out of view this frame
* @type {Boolean}
*/
outOfView : true
};
}
/**
* A function that will be called at the end of the frame.
* @callback FrameState~AfterRenderCallback
*/
return FrameState;
});
/*global define*/
define('Scene/FrustumCommands',[
'../Core/defaultValue',
'../Renderer/Pass'
], function(
defaultValue,
Pass) {
'use strict';
/**
* Defines a list of commands whose geometry are bound by near and far distances from the camera.
* @alias FrustumCommands
* @constructor
*
* @param {Number} [near=0.0] The lower bound or closest distance from the camera.
* @param {Number} [far=0.0] The upper bound or farthest distance from the camera.
*
* @private
*/
function FrustumCommands(near, far) {
this.near = defaultValue(near, 0.0);
this.far = defaultValue(far, 0.0);
var numPasses = Pass.NUMBER_OF_PASSES;
var commands = new Array(numPasses);
var indices = new Array(numPasses);
for (var i = 0; i < numPasses; ++i) {
commands[i] = [];
indices[i] = 0;
}
this.commands = commands;
this.indices = indices;
}
return FrustumCommands;
});
/**
* @license
* Copyright (c) 2011 NVIDIA Corporation. All rights reserved.
*
* TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
* *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
* OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, NONINFRINGEMENT,IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA
* OR ITS SUPPLIERS BE LIABLE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT, OR
* CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS
* OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY
* OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
* EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
*/
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/PostProcessFilters/FXAA',[],function() {
'use strict';
return "#ifndef FXAA_PRESET\n\
#define FXAA_PRESET 3\n\
#endif\n\
#if (FXAA_PRESET == 3)\n\
#define FXAA_EDGE_THRESHOLD (1.0/8.0)\n\
#define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0)\n\
#define FXAA_SEARCH_STEPS 16\n\
#define FXAA_SEARCH_THRESHOLD (1.0/4.0)\n\
#define FXAA_SUBPIX_CAP (3.0/4.0)\n\
#define FXAA_SUBPIX_TRIM (1.0/4.0)\n\
#endif\n\
#if (FXAA_PRESET == 4)\n\
#define FXAA_EDGE_THRESHOLD (1.0/8.0)\n\
#define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0)\n\
#define FXAA_SEARCH_STEPS 24\n\
#define FXAA_SEARCH_THRESHOLD (1.0/4.0)\n\
#define FXAA_SUBPIX_CAP (3.0/4.0)\n\
#define FXAA_SUBPIX_TRIM (1.0/4.0)\n\
#endif\n\
#if (FXAA_PRESET == 5)\n\
#define FXAA_EDGE_THRESHOLD (1.0/8.0)\n\
#define FXAA_EDGE_THRESHOLD_MIN (1.0/24.0)\n\
#define FXAA_SEARCH_STEPS 32\n\
#define FXAA_SEARCH_THRESHOLD (1.0/4.0)\n\
#define FXAA_SUBPIX_CAP (3.0/4.0)\n\
#define FXAA_SUBPIX_TRIM (1.0/4.0)\n\
#endif\n\
#define FXAA_SUBPIX_TRIM_SCALE (1.0/(1.0 - FXAA_SUBPIX_TRIM))\n\
float FxaaLuma(vec3 rgb) {\n\
return rgb.y * (0.587/0.299) + rgb.x;\n\
}\n\
vec3 FxaaLerp3(vec3 a, vec3 b, float amountOfA) {\n\
return (vec3(-amountOfA) * b) + ((a * vec3(amountOfA)) + b);\n\
}\n\
vec4 FxaaTexOff(sampler2D tex, vec2 pos, ivec2 off, vec2 rcpFrame) {\n\
float x = pos.x + float(off.x) * rcpFrame.x;\n\
float y = pos.y + float(off.y) * rcpFrame.y;\n\
return texture2D(tex, vec2(x, y));\n\
}\n\
vec3 FxaaPixelShader(vec2 pos, sampler2D tex, vec2 rcpFrame)\n\
{\n\
vec3 rgbN = FxaaTexOff(tex, pos.xy, ivec2( 0,-1), rcpFrame).xyz;\n\
vec3 rgbW = FxaaTexOff(tex, pos.xy, ivec2(-1, 0), rcpFrame).xyz;\n\
vec3 rgbM = FxaaTexOff(tex, pos.xy, ivec2( 0, 0), rcpFrame).xyz;\n\
vec3 rgbE = FxaaTexOff(tex, pos.xy, ivec2( 1, 0), rcpFrame).xyz;\n\
vec3 rgbS = FxaaTexOff(tex, pos.xy, ivec2( 0, 1), rcpFrame).xyz;\n\
float lumaN = FxaaLuma(rgbN);\n\
float lumaW = FxaaLuma(rgbW);\n\
float lumaM = FxaaLuma(rgbM);\n\
float lumaE = FxaaLuma(rgbE);\n\
float lumaS = FxaaLuma(rgbS);\n\
float rangeMin = min(lumaM, min(min(lumaN, lumaW), min(lumaS, lumaE)));\n\
float rangeMax = max(lumaM, max(max(lumaN, lumaW), max(lumaS, lumaE)));\n\
float range = rangeMax - rangeMin;\n\
if(range < max(FXAA_EDGE_THRESHOLD_MIN, rangeMax * FXAA_EDGE_THRESHOLD))\n\
{\n\
return rgbM;\n\
}\n\
vec3 rgbL = rgbN + rgbW + rgbM + rgbE + rgbS;\n\
float lumaL = (lumaN + lumaW + lumaE + lumaS) * 0.25;\n\
float rangeL = abs(lumaL - lumaM);\n\
float blendL = max(0.0, (rangeL / range) - FXAA_SUBPIX_TRIM) * FXAA_SUBPIX_TRIM_SCALE;\n\
blendL = min(FXAA_SUBPIX_CAP, blendL);\n\
vec3 rgbNW = FxaaTexOff(tex, pos.xy, ivec2(-1,-1), rcpFrame).xyz;\n\
vec3 rgbNE = FxaaTexOff(tex, pos.xy, ivec2( 1,-1), rcpFrame).xyz;\n\
vec3 rgbSW = FxaaTexOff(tex, pos.xy, ivec2(-1, 1), rcpFrame).xyz;\n\
vec3 rgbSE = FxaaTexOff(tex, pos.xy, ivec2( 1, 1), rcpFrame).xyz;\n\
rgbL += (rgbNW + rgbNE + rgbSW + rgbSE);\n\
rgbL *= vec3(1.0/9.0);\n\
float lumaNW = FxaaLuma(rgbNW);\n\
float lumaNE = FxaaLuma(rgbNE);\n\
float lumaSW = FxaaLuma(rgbSW);\n\
float lumaSE = FxaaLuma(rgbSE);\n\
float edgeVert =\n\
abs((0.25 * lumaNW) + (-0.5 * lumaN) + (0.25 * lumaNE)) +\n\
abs((0.50 * lumaW ) + (-1.0 * lumaM) + (0.50 * lumaE )) +\n\
abs((0.25 * lumaSW) + (-0.5 * lumaS) + (0.25 * lumaSE));\n\
float edgeHorz =\n\
abs((0.25 * lumaNW) + (-0.5 * lumaW) + (0.25 * lumaSW)) +\n\
abs((0.50 * lumaN ) + (-1.0 * lumaM) + (0.50 * lumaS )) +\n\
abs((0.25 * lumaNE) + (-0.5 * lumaE) + (0.25 * lumaSE));\n\
bool horzSpan = edgeHorz >= edgeVert;\n\
float lengthSign = horzSpan ? -rcpFrame.y : -rcpFrame.x;\n\
if(!horzSpan)\n\
{\n\
lumaN = lumaW;\n\
lumaS = lumaE;\n\
}\n\
float gradientN = abs(lumaN - lumaM);\n\
float gradientS = abs(lumaS - lumaM);\n\
lumaN = (lumaN + lumaM) * 0.5;\n\
lumaS = (lumaS + lumaM) * 0.5;\n\
if (gradientN < gradientS)\n\
{\n\
lumaN = lumaS;\n\
lumaN = lumaS;\n\
gradientN = gradientS;\n\
lengthSign *= -1.0;\n\
}\n\
vec2 posN;\n\
posN.x = pos.x + (horzSpan ? 0.0 : lengthSign * 0.5);\n\
posN.y = pos.y + (horzSpan ? lengthSign * 0.5 : 0.0);\n\
gradientN *= FXAA_SEARCH_THRESHOLD;\n\
vec2 posP = posN;\n\
vec2 offNP = horzSpan ? vec2(rcpFrame.x, 0.0) : vec2(0.0, rcpFrame.y);\n\
float lumaEndN = lumaN;\n\
float lumaEndP = lumaN;\n\
bool doneN = false;\n\
bool doneP = false;\n\
posN += offNP * vec2(-1.0, -1.0);\n\
posP += offNP * vec2( 1.0, 1.0);\n\
for(int i = 0; i < FXAA_SEARCH_STEPS; i++) {\n\
if(!doneN)\n\
{\n\
lumaEndN = FxaaLuma(texture2D(tex, posN.xy).xyz);\n\
}\n\
if(!doneP)\n\
{\n\
lumaEndP = FxaaLuma(texture2D(tex, posP.xy).xyz);\n\
}\n\
doneN = doneN || (abs(lumaEndN - lumaN) >= gradientN);\n\
doneP = doneP || (abs(lumaEndP - lumaN) >= gradientN);\n\
if(doneN && doneP)\n\
{\n\
break;\n\
}\n\
if(!doneN)\n\
{\n\
posN -= offNP;\n\
}\n\
if(!doneP)\n\
{\n\
posP += offNP;\n\
}\n\
}\n\
float dstN = horzSpan ? pos.x - posN.x : pos.y - posN.y;\n\
float dstP = horzSpan ? posP.x - pos.x : posP.y - pos.y;\n\
bool directionN = dstN < dstP;\n\
lumaEndN = directionN ? lumaEndN : lumaEndP;\n\
if(((lumaM - lumaN) < 0.0) == ((lumaEndN - lumaN) < 0.0))\n\
{\n\
lengthSign = 0.0;\n\
}\n\
float spanLength = (dstP + dstN);\n\
dstN = directionN ? dstN : dstP;\n\
float subPixelOffset = (0.5 + (dstN * (-1.0/spanLength))) * lengthSign;\n\
vec3 rgbF = texture2D(tex, vec2(\n\
pos.x + (horzSpan ? 0.0 : subPixelOffset),\n\
pos.y + (horzSpan ? subPixelOffset : 0.0))).xyz;\n\
return FxaaLerp3(rgbL, rgbF, blendL);\n\
}\n\
uniform sampler2D u_texture;\n\
uniform vec2 u_step;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
gl_FragColor = vec4(FxaaPixelShader(v_textureCoordinates, u_texture, u_step), 1.0);\n\
}\n\
";
});
/*global define*/
define('Scene/FXAA',[
'../Core/BoundingRectangle',
'../Core/Cartesian2',
'../Core/Color',
'../Core/defined',
'../Core/destroyObject',
'../Core/PixelFormat',
'../Renderer/ClearCommand',
'../Renderer/Framebuffer',
'../Renderer/PixelDatatype',
'../Renderer/Renderbuffer',
'../Renderer/RenderbufferFormat',
'../Renderer/RenderState',
'../Renderer/Texture',
'../Shaders/PostProcessFilters/FXAA'
], function(
BoundingRectangle,
Cartesian2,
Color,
defined,
destroyObject,
PixelFormat,
ClearCommand,
Framebuffer,
PixelDatatype,
Renderbuffer,
RenderbufferFormat,
RenderState,
Texture,
FXAAFS) {
'use strict';
/**
* @private
*/
function FXAA(context) {
this._texture = undefined;
this._depthStencilTexture = undefined;
this._depthStencilRenderbuffer = undefined;
this._fbo = undefined;
this._command = undefined;
this._viewport = new BoundingRectangle();
this._rs = undefined;
var clearCommand = new ClearCommand({
color : new Color(0.0, 0.0, 0.0, 0.0),
depth : 1.0,
owner : this
});
this._clearCommand = clearCommand;
}
function destroyResources(fxaa) {
fxaa._fbo = fxaa._fbo && fxaa._fbo.destroy();
fxaa._texture = fxaa._texture && fxaa._texture.destroy();
fxaa._depthStencilTexture = fxaa._depthStencilTexture && fxaa._depthStencilTexture.destroy();
fxaa._depthStencilRenderbuffer = fxaa._depthStencilRenderbuffer && fxaa._depthStencilRenderbuffer.destroy();
fxaa._fbo = undefined;
fxaa._texture = undefined;
fxaa._depthStencilTexture = undefined;
fxaa._depthStencilRenderbuffer = undefined;
if (defined(fxaa._command)) {
fxaa._command.shaderProgram = fxaa._command.shaderProgram && fxaa._command.shaderProgram.destroy();
fxaa._command = undefined;
}
}
FXAA.prototype.update = function(context) {
var width = context.drawingBufferWidth;
var height = context.drawingBufferHeight;
var fxaaTexture = this._texture;
var textureChanged = !defined(fxaaTexture) || fxaaTexture.width !== width || fxaaTexture.height !== height;
if (textureChanged) {
this._texture = this._texture && this._texture.destroy();
this._depthStencilTexture = this._depthStencilTexture && this._depthStencilTexture.destroy();
this._depthStencilRenderbuffer = this._depthStencilRenderbuffer && this._depthStencilRenderbuffer.destroy();
this._texture = new Texture({
context : context,
width : width,
height : height,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE
});
if (context.depthTexture) {
this._depthStencilTexture = new Texture({
context : context,
width : width,
height : height,
pixelFormat : PixelFormat.DEPTH_STENCIL,
pixelDatatype : PixelDatatype.UNSIGNED_INT_24_8
});
} else {
this._depthStencilRenderbuffer = new Renderbuffer({
context : context,
width : width,
height : height,
format : RenderbufferFormat.DEPTH_STENCIL
});
}
}
if (!defined(this._fbo) || textureChanged) {
this._fbo = this._fbo && this._fbo.destroy();
this._fbo = new Framebuffer({
context : context,
colorTextures : [this._texture],
depthStencilTexture : this._depthStencilTexture,
depthStencilRenderbuffer : this._depthStencilRenderbuffer,
destroyAttachments : false
});
}
if (!defined(this._command)) {
this._command = context.createViewportQuadCommand(FXAAFS, {
owner : this
});
}
this._viewport.width = width;
this._viewport.height = height;
if (!defined(this._rs) || !BoundingRectangle.equals(this._rs.viewport, this._viewport)) {
this._rs = RenderState.fromCache({
viewport : this._viewport
});
}
this._command.renderState = this._rs;
if (textureChanged) {
var that = this;
var step = new Cartesian2(1.0 / this._texture.width, 1.0 / this._texture.height);
this._command.uniformMap = {
u_texture : function() {
return that._texture;
},
u_step : function() {
return step;
}
};
}
};
FXAA.prototype.execute = function(context, passState) {
this._command.execute(context, passState);
};
FXAA.prototype.clear = function(context, passState, clearColor) {
var framebuffer = passState.framebuffer;
passState.framebuffer = this._fbo;
Color.clone(clearColor, this._clearCommand.color);
this._clearCommand.execute(context, passState);
passState.framebuffer = framebuffer;
};
FXAA.prototype.getColorFramebuffer = function() {
return this._fbo;
};
FXAA.prototype.isDestroyed = function() {
return false;
};
FXAA.prototype.destroy = function() {
destroyResources(this);
return destroyObject(this);
};
return FXAA;
});
/*global define*/
define('Scene/GetFeatureInfoFormat',[
'../Core/Cartographic',
'../Core/defined',
'../Core/DeveloperError',
'../Core/RuntimeError',
'./ImageryLayerFeatureInfo'
], function(
Cartographic,
defined,
DeveloperError,
RuntimeError,
ImageryLayerFeatureInfo) {
'use strict';
/**
* Describes the format in which to request GetFeatureInfo from a Web Map Service (WMS) server.
*
* @alias GetFeatureInfoFormat
* @constructor
*
* @param {String} type The type of response to expect from a GetFeatureInfo request. Valid
* values are 'json', 'xml', 'html', or 'text'.
* @param {String} [format] The info format to request from the WMS server. This is usually a
* MIME type such as 'application/json' or text/xml'. If this parameter is not specified, the provider will request 'json'
* using 'application/json', 'xml' using 'text/xml', 'html' using 'text/html', and 'text' using 'text/plain'.
* @param {Function} [callback] A function to invoke with the GetFeatureInfo response from the WMS server
* in order to produce an array of picked {@link ImageryLayerFeatureInfo} instances. If this parameter is not specified,
* a default function for the type of response is used.
*/
function GetFeatureInfoFormat(type, format, callback) {
if (!defined(type)) {
throw new DeveloperError('type is required.');
}
this.type = type;
if (!defined(format)) {
if (type === 'json') {
format = 'application/json';
} else if (type === 'xml') {
format = 'text/xml';
} else if (type === 'html') {
format = 'text/html';
} else if (type === 'text') {
format = 'text/plain';
}
else {
throw new DeveloperError('format is required when type is not "json", "xml", "html", or "text".');
}
}
this.format = format;
if (!defined(callback)) {
if (type === 'json') {
callback = geoJsonToFeatureInfo;
} else if (type === 'xml') {
callback = xmlToFeatureInfo;
} else if (type === 'html') {
callback = textToFeatureInfo;
} else if (type === 'text') {
callback = textToFeatureInfo;
}
else {
throw new DeveloperError('callback is required when type is not "json", "xml", "html", or "text".');
}
}
this.callback = callback;
}
function geoJsonToFeatureInfo(json) {
var result = [];
var features = json.features;
for (var i = 0; i < features.length; ++i) {
var feature = features[i];
var featureInfo = new ImageryLayerFeatureInfo();
featureInfo.data = feature;
featureInfo.properties = feature.properties;
featureInfo.configureNameFromProperties(feature.properties);
featureInfo.configureDescriptionFromProperties(feature.properties);
// If this is a point feature, use the coordinates of the point.
if (defined(feature.geometry) && feature.geometry.type === 'Point') {
var longitude = feature.geometry.coordinates[0];
var latitude = feature.geometry.coordinates[1];
featureInfo.position = Cartographic.fromDegrees(longitude, latitude);
}
result.push(featureInfo);
}
return result;
}
var mapInfoMxpNamespace = 'http://www.mapinfo.com/mxp';
var esriWmsNamespace = 'http://www.esri.com/wms';
var wfsNamespace = 'http://www.opengis.net/wfs';
var gmlNamespace = 'http://www.opengis.net/gml';
function xmlToFeatureInfo(xml) {
var documentElement = xml.documentElement;
if (documentElement.localName === 'MultiFeatureCollection' && documentElement.namespaceURI === mapInfoMxpNamespace) {
// This looks like a MapInfo MXP response
return mapInfoXmlToFeatureInfo(xml);
} else if (documentElement.localName === 'FeatureInfoResponse' && documentElement.namespaceURI === esriWmsNamespace) {
// This looks like an Esri WMS response
return esriXmlToFeatureInfo(xml);
} else if (documentElement.localName === 'FeatureCollection' && documentElement.namespaceURI === wfsNamespace) {
// This looks like a WFS/GML response.
return gmlToFeatureInfo(xml);
} else if (documentElement.localName === 'ServiceExceptionReport') {
// This looks like a WMS server error, so no features picked.
throw new RuntimeError(new XMLSerializer().serializeToString(documentElement));
} else if (documentElement.localName === 'msGMLOutput') {
return msGmlToFeatureInfo(xml);
} else {
// Unknown response type, so just dump the XML itself into the description.
return unknownXmlToFeatureInfo(xml);
}
}
function mapInfoXmlToFeatureInfo(xml) {
var result = [];
var multiFeatureCollection = xml.documentElement;
var features = multiFeatureCollection.getElementsByTagNameNS(mapInfoMxpNamespace, 'Feature');
for (var featureIndex = 0; featureIndex < features.length; ++featureIndex) {
var feature = features[featureIndex];
var properties = {};
var propertyElements = feature.getElementsByTagNameNS(mapInfoMxpNamespace, 'Val');
for (var propertyIndex = 0; propertyIndex < propertyElements.length; ++propertyIndex) {
var propertyElement = propertyElements[propertyIndex];
if (propertyElement.hasAttribute('ref')) {
var name = propertyElement.getAttribute('ref');
var value = propertyElement.textContent.trim();
properties[name] = value;
}
}
var featureInfo = new ImageryLayerFeatureInfo();
featureInfo.data = feature;
featureInfo.properties = properties;
featureInfo.configureNameFromProperties(properties);
featureInfo.configureDescriptionFromProperties(properties);
result.push(featureInfo);
}
return result;
}
function esriXmlToFeatureInfo(xml) {
var featureInfoResponse = xml.documentElement;
var result = [];
var properties;
var features = featureInfoResponse.getElementsByTagNameNS('*', 'FIELDS');
if (features.length > 0) {
// Standard esri format
for (var featureIndex = 0; featureIndex < features.length; ++featureIndex) {
var feature = features[featureIndex];
properties = {};
var propertyAttributes = feature.attributes;
for (var attributeIndex = 0; attributeIndex < propertyAttributes.length; ++attributeIndex) {
var attribute = propertyAttributes[attributeIndex];
properties[attribute.name] = attribute.value;
}
result.push(imageryLayerFeatureInfoFromDataAndProperties(feature, properties));
}
} else {
// Thredds format -- looks like esri, but instead of containing FIELDS, contains FeatureInfo element
var featureInfoElements = featureInfoResponse.getElementsByTagNameNS('*', 'FeatureInfo');
for (var featureInfoElementIndex = 0; featureInfoElementIndex < featureInfoElements.length; ++featureInfoElementIndex) {
var featureInfoElement = featureInfoElements[featureInfoElementIndex];
properties = {};
// node.children is not supported in IE9-11, so use childNodes and check that child.nodeType is an element
var featureInfoChildren = featureInfoElement.childNodes;
for (var childIndex = 0; childIndex < featureInfoChildren.length; ++childIndex) {
var child = featureInfoChildren[childIndex];
if (child.nodeType === Node.ELEMENT_NODE) {
properties[child.localName] = child.textContent;
}
}
result.push(imageryLayerFeatureInfoFromDataAndProperties(featureInfoElement, properties));
}
}
return result;
}
function gmlToFeatureInfo(xml) {
var result = [];
var featureCollection = xml.documentElement;
var featureMembers = featureCollection.getElementsByTagNameNS(gmlNamespace, 'featureMember');
for (var featureIndex = 0; featureIndex < featureMembers.length; ++featureIndex) {
var featureMember = featureMembers[featureIndex];
var properties = {};
getGmlPropertiesRecursively(featureMember, properties);
result.push(imageryLayerFeatureInfoFromDataAndProperties(featureMember, properties));
}
return result;
}
// msGmlToFeatureInfo is similar to gmlToFeatureInfo, but assumes different XML structure
// eg. bar ...
function msGmlToFeatureInfo(xml) {
var result = [];
// Find the first child. Except for IE, this would work:
// var layer = xml.documentElement.children[0];
var layer;
var children = xml.documentElement.childNodes;
for (var i = 0; i < children.length; i++) {
if (children[i].nodeType === Node.ELEMENT_NODE) {
layer = children[i];
break;
}
}
var featureMembers = layer.childNodes;
for (var featureIndex = 0; featureIndex < featureMembers.length; ++featureIndex) {
var featureMember = featureMembers[featureIndex];
if (featureMember.nodeType === Node.ELEMENT_NODE) {
var properties = {};
getGmlPropertiesRecursively(featureMember, properties);
result.push(imageryLayerFeatureInfoFromDataAndProperties(featureMember, properties));
}
}
return result;
}
function getGmlPropertiesRecursively(gmlNode, properties) {
var isSingleValue = true;
for (var i = 0; i < gmlNode.childNodes.length; ++i) {
var child = gmlNode.childNodes[i];
if (child.nodeType === Node.ELEMENT_NODE) {
isSingleValue = false;
}
if (child.localName === 'Point' || child.localName === 'LineString' || child.localName === 'Polygon' || child.localName === 'boundedBy') {
continue;
}
if (child.hasChildNodes() && getGmlPropertiesRecursively(child, properties)) {
properties[child.localName] = child.textContent;
}
}
return isSingleValue;
}
function imageryLayerFeatureInfoFromDataAndProperties(data, properties) {
var featureInfo = new ImageryLayerFeatureInfo();
featureInfo.data = data;
featureInfo.properties = properties;
featureInfo.configureNameFromProperties(properties);
featureInfo.configureDescriptionFromProperties(properties);
return featureInfo;
}
function unknownXmlToFeatureInfo(xml) {
var xmlText = new XMLSerializer().serializeToString(xml);
var element = document.createElement('div');
var pre = document.createElement('pre');
pre.textContent = xmlText;
element.appendChild(pre);
var featureInfo = new ImageryLayerFeatureInfo();
featureInfo.data = xml;
featureInfo.description = element.innerHTML;
return [featureInfo];
}
var emptyBodyRegex= /\s*<\/body>/im;
var wmsServiceExceptionReportRegex = //im;
var titleRegex = /([\s\S]*)<\/title>/im;
function textToFeatureInfo(text) {
// If the text is HTML and it has an empty body tag, assume it means no features were found.
if (emptyBodyRegex.test(text)) {
return undefined;
}
// If this is a WMS exception report, treat it as "no features found" rather than showing
// bogus feature info.
if (wmsServiceExceptionReportRegex.test(text)) {
return undefined;
}
// If the text has a <title> element, use it as the name.
var name;
var title = titleRegex.exec(text);
if (title && title.length > 1) {
name = title[1];
}
var featureInfo = new ImageryLayerFeatureInfo();
featureInfo.name = name;
featureInfo.description = text;
featureInfo.data = text;
return [featureInfo];
}
return GetFeatureInfoFormat;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/GlobeFS',[],function() {
'use strict';
return "uniform vec4 u_initialColor;\n\
#if TEXTURE_UNITS > 0\n\
uniform sampler2D u_dayTextures[TEXTURE_UNITS];\n\
uniform vec4 u_dayTextureTranslationAndScale[TEXTURE_UNITS];\n\
uniform bool u_dayTextureUseWebMercatorT[TEXTURE_UNITS];\n\
#ifdef APPLY_ALPHA\n\
uniform float u_dayTextureAlpha[TEXTURE_UNITS];\n\
#endif\n\
#ifdef APPLY_BRIGHTNESS\n\
uniform float u_dayTextureBrightness[TEXTURE_UNITS];\n\
#endif\n\
#ifdef APPLY_CONTRAST\n\
uniform float u_dayTextureContrast[TEXTURE_UNITS];\n\
#endif\n\
#ifdef APPLY_HUE\n\
uniform float u_dayTextureHue[TEXTURE_UNITS];\n\
#endif\n\
#ifdef APPLY_SATURATION\n\
uniform float u_dayTextureSaturation[TEXTURE_UNITS];\n\
#endif\n\
#ifdef APPLY_GAMMA\n\
uniform float u_dayTextureOneOverGamma[TEXTURE_UNITS];\n\
#endif\n\
uniform vec4 u_dayTextureTexCoordsRectangle[TEXTURE_UNITS];\n\
#endif\n\
#ifdef SHOW_REFLECTIVE_OCEAN\n\
uniform sampler2D u_waterMask;\n\
uniform vec4 u_waterMaskTranslationAndScale;\n\
uniform float u_zoomedOutOceanSpecularIntensity;\n\
#endif\n\
#ifdef SHOW_OCEAN_WAVES\n\
uniform sampler2D u_oceanNormalMap;\n\
#endif\n\
#ifdef ENABLE_DAYNIGHT_SHADING\n\
uniform vec2 u_lightingFadeDistance;\n\
#endif\n\
varying vec3 v_positionMC;\n\
varying vec3 v_positionEC;\n\
varying vec3 v_textureCoordinates;\n\
varying vec3 v_normalMC;\n\
varying vec3 v_normalEC;\n\
#ifdef FOG\n\
varying float v_distance;\n\
varying vec3 v_rayleighColor;\n\
varying vec3 v_mieColor;\n\
#endif\n\
vec4 sampleAndBlend(\n\
vec4 previousColor,\n\
sampler2D texture,\n\
vec2 tileTextureCoordinates,\n\
vec4 textureCoordinateRectangle,\n\
vec4 textureCoordinateTranslationAndScale,\n\
float textureAlpha,\n\
float textureBrightness,\n\
float textureContrast,\n\
float textureHue,\n\
float textureSaturation,\n\
float textureOneOverGamma)\n\
{\n\
vec2 alphaMultiplier = step(textureCoordinateRectangle.st, tileTextureCoordinates);\n\
textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;\n\
alphaMultiplier = step(vec2(0.0), textureCoordinateRectangle.pq - tileTextureCoordinates);\n\
textureAlpha = textureAlpha * alphaMultiplier.x * alphaMultiplier.y;\n\
vec2 translation = textureCoordinateTranslationAndScale.xy;\n\
vec2 scale = textureCoordinateTranslationAndScale.zw;\n\
vec2 textureCoordinates = tileTextureCoordinates * scale + translation;\n\
vec4 value = texture2D(texture, textureCoordinates);\n\
vec3 color = value.rgb;\n\
float alpha = value.a;\n\
#ifdef APPLY_BRIGHTNESS\n\
color = mix(vec3(0.0), color, textureBrightness);\n\
#endif\n\
#ifdef APPLY_CONTRAST\n\
color = mix(vec3(0.5), color, textureContrast);\n\
#endif\n\
#ifdef APPLY_HUE\n\
color = czm_hue(color, textureHue);\n\
#endif\n\
#ifdef APPLY_SATURATION\n\
color = czm_saturation(color, textureSaturation);\n\
#endif\n\
#ifdef APPLY_GAMMA\n\
color = pow(color, vec3(textureOneOverGamma));\n\
#endif\n\
float sourceAlpha = alpha * textureAlpha;\n\
float outAlpha = mix(previousColor.a, 1.0, sourceAlpha);\n\
vec3 outColor = mix(previousColor.rgb * previousColor.a, color, sourceAlpha) / outAlpha;\n\
return vec4(outColor, outAlpha);\n\
}\n\
vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates);\n\
vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat3 enuToEye, vec4 imageryColor, float specularMapValue);\n\
void main()\n\
{\n\
vec4 color = computeDayColor(u_initialColor, clamp(v_textureCoordinates, 0.0, 1.0));\n\
#ifdef SHOW_TILE_BOUNDARIES\n\
if (v_textureCoordinates.x < (1.0/256.0) || v_textureCoordinates.x > (255.0/256.0) ||\n\
v_textureCoordinates.y < (1.0/256.0) || v_textureCoordinates.y > (255.0/256.0))\n\
{\n\
color = vec4(1.0, 0.0, 0.0, 1.0);\n\
}\n\
#endif\n\
#if defined(SHOW_REFLECTIVE_OCEAN) || defined(ENABLE_DAYNIGHT_SHADING)\n\
vec3 normalMC = czm_geodeticSurfaceNormal(v_positionMC, vec3(0.0), vec3(1.0));\n\
vec3 normalEC = czm_normal3D * normalMC;\n\
#endif\n\
#ifdef SHOW_REFLECTIVE_OCEAN\n\
vec2 waterMaskTranslation = u_waterMaskTranslationAndScale.xy;\n\
vec2 waterMaskScale = u_waterMaskTranslationAndScale.zw;\n\
vec2 waterMaskTextureCoordinates = v_textureCoordinates.xy * waterMaskScale + waterMaskTranslation;\n\
float mask = texture2D(u_waterMask, waterMaskTextureCoordinates).r;\n\
if (mask > 0.0)\n\
{\n\
mat3 enuToEye = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalEC);\n\
vec2 ellipsoidTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC);\n\
vec2 ellipsoidFlippedTextureCoordinates = czm_ellipsoidWgs84TextureCoordinates(normalMC.zyx);\n\
vec2 textureCoordinates = mix(ellipsoidTextureCoordinates, ellipsoidFlippedTextureCoordinates, czm_morphTime * smoothstep(0.9, 0.95, normalMC.z));\n\
color = computeWaterColor(v_positionEC, textureCoordinates, enuToEye, color, mask);\n\
}\n\
#endif\n\
#ifdef ENABLE_VERTEX_LIGHTING\n\
float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_sunDirectionEC, normalize(v_normalEC)) * 0.9 + 0.3, 0.0, 1.0);\n\
vec4 finalColor = vec4(color.rgb * diffuseIntensity, color.a);\n\
#elif defined(ENABLE_DAYNIGHT_SHADING)\n\
float diffuseIntensity = clamp(czm_getLambertDiffuse(czm_sunDirectionEC, normalEC) * 5.0 + 0.3, 0.0, 1.0);\n\
float cameraDist = length(czm_view[3]);\n\
float fadeOutDist = u_lightingFadeDistance.x;\n\
float fadeInDist = u_lightingFadeDistance.y;\n\
float t = clamp((cameraDist - fadeOutDist) / (fadeInDist - fadeOutDist), 0.0, 1.0);\n\
diffuseIntensity = mix(1.0, diffuseIntensity, t);\n\
vec4 finalColor = vec4(color.rgb * diffuseIntensity, color.a);\n\
#else\n\
vec4 finalColor = color;\n\
#endif\n\
#ifdef FOG\n\
const float fExposure = 2.0;\n\
vec3 fogColor = v_mieColor + finalColor.rgb * v_rayleighColor;\n\
fogColor = vec3(1.0) - exp(-fExposure * fogColor);\n\
gl_FragColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor), finalColor.a);\n\
#else\n\
gl_FragColor = finalColor;\n\
#endif\n\
}\n\
#ifdef SHOW_REFLECTIVE_OCEAN\n\
float waveFade(float edge0, float edge1, float x)\n\
{\n\
float y = clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n\
return pow(1.0 - y, 5.0);\n\
}\n\
float linearFade(float edge0, float edge1, float x)\n\
{\n\
return clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);\n\
}\n\
const float oceanFrequencyLowAltitude = 825000.0;\n\
const float oceanAnimationSpeedLowAltitude = 0.004;\n\
const float oceanOneOverAmplitudeLowAltitude = 1.0 / 2.0;\n\
const float oceanSpecularIntensity = 0.5;\n\
const float oceanFrequencyHighAltitude = 125000.0;\n\
const float oceanAnimationSpeedHighAltitude = 0.008;\n\
const float oceanOneOverAmplitudeHighAltitude = 1.0 / 2.0;\n\
vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat3 enuToEye, vec4 imageryColor, float maskValue)\n\
{\n\
vec3 positionToEyeEC = -positionEyeCoordinates;\n\
float positionToEyeECLength = length(positionToEyeEC);\n\
vec3 normalizedpositionToEyeEC = normalize(normalize(positionToEyeEC));\n\
float waveIntensity = waveFade(70000.0, 1000000.0, positionToEyeECLength);\n\
#ifdef SHOW_OCEAN_WAVES\n\
float time = czm_frameNumber * oceanAnimationSpeedHighAltitude;\n\
vec4 noise = czm_getWaterNoise(u_oceanNormalMap, textureCoordinates * oceanFrequencyHighAltitude, time, 0.0);\n\
vec3 normalTangentSpaceHighAltitude = vec3(noise.xy, noise.z * oceanOneOverAmplitudeHighAltitude);\n\
time = czm_frameNumber * oceanAnimationSpeedLowAltitude;\n\
noise = czm_getWaterNoise(u_oceanNormalMap, textureCoordinates * oceanFrequencyLowAltitude, time, 0.0);\n\
vec3 normalTangentSpaceLowAltitude = vec3(noise.xy, noise.z * oceanOneOverAmplitudeLowAltitude);\n\
float highAltitudeFade = linearFade(0.0, 60000.0, positionToEyeECLength);\n\
float lowAltitudeFade = 1.0 - linearFade(20000.0, 60000.0, positionToEyeECLength);\n\
vec3 normalTangentSpace =\n\
(highAltitudeFade * normalTangentSpaceHighAltitude) +\n\
(lowAltitudeFade * normalTangentSpaceLowAltitude);\n\
normalTangentSpace = normalize(normalTangentSpace);\n\
normalTangentSpace.xy *= waveIntensity;\n\
normalTangentSpace = normalize(normalTangentSpace);\n\
#else\n\
vec3 normalTangentSpace = vec3(0.0, 0.0, 1.0);\n\
#endif\n\
vec3 normalEC = enuToEye * normalTangentSpace;\n\
const vec3 waveHighlightColor = vec3(0.3, 0.45, 0.6);\n\
float diffuseIntensity = czm_getLambertDiffuse(czm_sunDirectionEC, normalEC) * maskValue;\n\
vec3 diffuseHighlight = waveHighlightColor * diffuseIntensity;\n\
#ifdef SHOW_OCEAN_WAVES\n\
float tsPerturbationRatio = normalTangentSpace.z;\n\
vec3 nonDiffuseHighlight = mix(waveHighlightColor * 5.0 * (1.0 - tsPerturbationRatio), vec3(0.0), diffuseIntensity);\n\
#else\n\
vec3 nonDiffuseHighlight = vec3(0.0);\n\
#endif\n\
float specularIntensity = czm_getSpecular(czm_sunDirectionEC, normalizedpositionToEyeEC, normalEC, 10.0) + 0.25 * czm_getSpecular(czm_moonDirectionEC, normalizedpositionToEyeEC, normalEC, 10.0);\n\
float surfaceReflectance = mix(0.0, mix(u_zoomedOutOceanSpecularIntensity, oceanSpecularIntensity, waveIntensity), maskValue);\n\
float specular = specularIntensity * surfaceReflectance;\n\
return vec4(imageryColor.rgb + diffuseHighlight + nonDiffuseHighlight + specular, imageryColor.a);\n\
}\n\
#endif // #ifdef SHOW_REFLECTIVE_OCEAN\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/GlobeVS',[],function() {
'use strict';
return "#ifdef QUANTIZATION_BITS12\n\
attribute vec4 compressed0;\n\
attribute float compressed1;\n\
#else\n\
attribute vec4 position3DAndHeight;\n\
attribute vec4 textureCoordAndEncodedNormals;\n\
#endif\n\
uniform vec3 u_center3D;\n\
uniform mat4 u_modifiedModelView;\n\
uniform mat4 u_modifiedModelViewProjection;\n\
uniform vec4 u_tileRectangle;\n\
uniform vec2 u_southAndNorthLatitude;\n\
uniform vec2 u_southMercatorYAndOneOverHeight;\n\
varying vec3 v_positionMC;\n\
varying vec3 v_positionEC;\n\
varying vec3 v_textureCoordinates;\n\
varying vec3 v_normalMC;\n\
varying vec3 v_normalEC;\n\
#ifdef FOG\n\
varying float v_distance;\n\
varying vec3 v_mieColor;\n\
varying vec3 v_rayleighColor;\n\
#endif\n\
vec4 getPosition(vec3 position, float height, vec2 textureCoordinates);\n\
float get2DYPositionFraction(vec2 textureCoordinates);\n\
vec4 getPosition3DMode(vec3 position, float height, vec2 textureCoordinates)\n\
{\n\
return u_modifiedModelViewProjection * vec4(position, 1.0);\n\
}\n\
float get2DMercatorYPositionFraction(vec2 textureCoordinates)\n\
{\n\
const float maxTileWidth = 0.003068;\n\
float positionFraction = textureCoordinates.y;\n\
float southLatitude = u_southAndNorthLatitude.x;\n\
float northLatitude = u_southAndNorthLatitude.y;\n\
if (northLatitude - southLatitude > maxTileWidth)\n\
{\n\
float southMercatorY = u_southMercatorYAndOneOverHeight.x;\n\
float oneOverMercatorHeight = u_southMercatorYAndOneOverHeight.y;\n\
float currentLatitude = mix(southLatitude, northLatitude, textureCoordinates.y);\n\
currentLatitude = clamp(currentLatitude, -czm_webMercatorMaxLatitude, czm_webMercatorMaxLatitude);\n\
positionFraction = czm_latitudeToWebMercatorFraction(currentLatitude, southMercatorY, oneOverMercatorHeight);\n\
}\n\
return positionFraction;\n\
}\n\
float get2DGeographicYPositionFraction(vec2 textureCoordinates)\n\
{\n\
return textureCoordinates.y;\n\
}\n\
vec4 getPositionPlanarEarth(vec3 position, float height, vec2 textureCoordinates)\n\
{\n\
float yPositionFraction = get2DYPositionFraction(textureCoordinates);\n\
vec4 rtcPosition2D = vec4(height, mix(u_tileRectangle.st, u_tileRectangle.pq, vec2(textureCoordinates.x, yPositionFraction)), 1.0);\n\
return u_modifiedModelViewProjection * rtcPosition2D;\n\
}\n\
vec4 getPosition2DMode(vec3 position, float height, vec2 textureCoordinates)\n\
{\n\
return getPositionPlanarEarth(position, 0.0, textureCoordinates);\n\
}\n\
vec4 getPositionColumbusViewMode(vec3 position, float height, vec2 textureCoordinates)\n\
{\n\
return getPositionPlanarEarth(position, height, textureCoordinates);\n\
}\n\
vec4 getPositionMorphingMode(vec3 position, float height, vec2 textureCoordinates)\n\
{\n\
vec3 position3DWC = position + u_center3D;\n\
float yPositionFraction = get2DYPositionFraction(textureCoordinates);\n\
vec4 position2DWC = vec4(height, mix(u_tileRectangle.st, u_tileRectangle.pq, vec2(textureCoordinates.x, yPositionFraction)), 1.0);\n\
vec4 morphPosition = czm_columbusViewMorph(position2DWC, vec4(position3DWC, 1.0), czm_morphTime);\n\
return czm_modelViewProjection * morphPosition;\n\
}\n\
#ifdef QUANTIZATION_BITS12\n\
uniform vec2 u_minMaxHeight;\n\
uniform mat4 u_scaleAndBias;\n\
#endif\n\
void main()\n\
{\n\
#ifdef QUANTIZATION_BITS12\n\
vec2 xy = czm_decompressTextureCoordinates(compressed0.x);\n\
vec2 zh = czm_decompressTextureCoordinates(compressed0.y);\n\
vec3 position = vec3(xy, zh.x);\n\
float height = zh.y;\n\
vec2 textureCoordinates = czm_decompressTextureCoordinates(compressed0.z);\n\
height = height * (u_minMaxHeight.y - u_minMaxHeight.x) + u_minMaxHeight.x;\n\
position = (u_scaleAndBias * vec4(position, 1.0)).xyz;\n\
#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)) && defined(INCLUDE_WEB_MERCATOR_Y)\n\
float webMercatorT = czm_decompressTextureCoordinates(compressed0.w).x;\n\
float encodedNormal = compressed1;\n\
#elif defined(INCLUDE_WEB_MERCATOR_Y)\n\
float webMercatorT = czm_decompressTextureCoordinates(compressed0.w).x;\n\
float encodedNormal = 0.0;\n\
#elif defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)\n\
float webMercatorT = textureCoordinates.y;\n\
float encodedNormal = compressed0.w;\n\
#else\n\
float webMercatorT = textureCoordinates.y;\n\
float encodedNormal = 0.0;\n\
#endif\n\
#else\n\
vec3 position = position3DAndHeight.xyz;\n\
float height = position3DAndHeight.w;\n\
vec2 textureCoordinates = textureCoordAndEncodedNormals.xy;\n\
#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)) && defined(INCLUDE_WEB_MERCATOR_Y)\n\
float webMercatorT = textureCoordAndEncodedNormals.z;\n\
float encodedNormal = textureCoordAndEncodedNormals.w;\n\
#elif defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)\n\
float webMercatorT = textureCoordinates.y;\n\
float encodedNormal = textureCoordAndEncodedNormals.z;\n\
#elif defined(INCLUDE_WEB_MERCATOR_Y)\n\
float webMercatorT = textureCoordAndEncodedNormals.z;\n\
float encodedNormal = 0.0;\n\
#else\n\
float webMercatorT = textureCoordinates.y;\n\
float encodedNormal = 0.0;\n\
#endif\n\
#endif\n\
vec3 position3DWC = position + u_center3D;\n\
gl_Position = getPosition(position, height, textureCoordinates);\n\
v_textureCoordinates = vec3(textureCoordinates, webMercatorT);\n\
#if defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)\n\
v_positionEC = (u_modifiedModelView * vec4(position, 1.0)).xyz;\n\
v_positionMC = position3DWC;\n\
v_normalMC = czm_octDecode(encodedNormal);\n\
v_normalEC = czm_normal3D * v_normalMC;\n\
#elif defined(SHOW_REFLECTIVE_OCEAN) || defined(ENABLE_DAYNIGHT_SHADING) || defined(GENERATE_POSITION)\n\
v_positionEC = (u_modifiedModelView * vec4(position, 1.0)).xyz;\n\
v_positionMC = position3DWC;\n\
#endif\n\
#ifdef FOG\n\
AtmosphereColor atmosColor = computeGroundAtmosphereFromSpace(position3DWC);\n\
v_mieColor = atmosColor.mie;\n\
v_rayleighColor = atmosColor.rayleigh;\n\
v_distance = length((czm_modelView3D * vec4(position3DWC, 1.0)).xyz);\n\
#endif\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/GroundAtmosphere',[],function() {
'use strict';
return "const float fInnerRadius = 6378137.0;\n\
const float fOuterRadius = 6378137.0 * 1.025;\n\
const float fOuterRadius2 = fOuterRadius * fOuterRadius;\n\
const float Kr = 0.0025;\n\
const float Km = 0.0015;\n\
const float ESun = 15.0;\n\
const float fKrESun = Kr * ESun;\n\
const float fKmESun = Km * ESun;\n\
const float fKr4PI = Kr * 4.0 * czm_pi;\n\
const float fKm4PI = Km * 4.0 * czm_pi;\n\
const float fScale = 1.0 / (fOuterRadius - fInnerRadius);\n\
const float fScaleDepth = 0.25;\n\
const float fScaleOverScaleDepth = fScale / fScaleDepth;\n\
struct AtmosphereColor\n\
{\n\
vec3 mie;\n\
vec3 rayleigh;\n\
};\n\
const int nSamples = 2;\n\
const float fSamples = 2.0;\n\
float scale(float fCos)\n\
{\n\
float x = 1.0 - fCos;\n\
return fScaleDepth * exp(-0.00287 + x*(0.459 + x*(3.83 + x*(-6.80 + x*5.25))));\n\
}\n\
AtmosphereColor computeGroundAtmosphereFromSpace(vec3 v3Pos)\n\
{\n\
vec3 v3InvWavelength = vec3(1.0 / pow(0.650, 4.0), 1.0 / pow(0.570, 4.0), 1.0 / pow(0.475, 4.0));\n\
vec3 v3Ray = v3Pos - czm_viewerPositionWC;\n\
float fFar = length(v3Ray);\n\
v3Ray /= fFar;\n\
float fCameraHeight = length(czm_viewerPositionWC);\n\
float fCameraHeight2 = fCameraHeight * fCameraHeight;\n\
float B = 2.0 * length(czm_viewerPositionWC) * dot(normalize(czm_viewerPositionWC), v3Ray);\n\
float C = fCameraHeight2 - fOuterRadius2;\n\
float fDet = max(0.0, B*B - 4.0 * C);\n\
float fNear = 0.5 * (-B - sqrt(fDet));\n\
vec3 v3Start = czm_viewerPositionWC + v3Ray * fNear;\n\
fFar -= fNear;\n\
float fDepth = exp((fInnerRadius - fOuterRadius) / fScaleDepth);\n\
float fLightAngle = 1.0;\n\
float fCameraAngle = dot(-v3Ray, v3Pos) / length(v3Pos);\n\
float fCameraScale = scale(fCameraAngle);\n\
float fLightScale = scale(fLightAngle);\n\
float fCameraOffset = fDepth*fCameraScale;\n\
float fTemp = (fLightScale + fCameraScale);\n\
float fSampleLength = fFar / fSamples;\n\
float fScaledLength = fSampleLength * fScale;\n\
vec3 v3SampleRay = v3Ray * fSampleLength;\n\
vec3 v3SamplePoint = v3Start + v3SampleRay * 0.5;\n\
vec3 v3FrontColor = vec3(0.0);\n\
vec3 v3Attenuate = vec3(0.0);\n\
for(int i=0; i<nSamples; i++)\n\
{\n\
float fHeight = length(v3SamplePoint);\n\
float fDepth = exp(fScaleOverScaleDepth * (fInnerRadius - fHeight));\n\
float fScatter = fDepth*fTemp - fCameraOffset;\n\
v3Attenuate = exp(-fScatter * (v3InvWavelength * fKr4PI + fKm4PI));\n\
v3FrontColor += v3Attenuate * (fDepth * fScaledLength);\n\
v3SamplePoint += v3SampleRay;\n\
}\n\
AtmosphereColor color;\n\
color.mie = v3FrontColor * (v3InvWavelength * fKrESun + fKmESun);\n\
color.rayleigh = v3Attenuate;\n\
return color;\n\
}\n\
";
});
/*global define*/
define('Scene/GlobeSurfaceShaderSet',[
'../Core/defined',
'../Core/destroyObject',
'../Core/TerrainQuantization',
'../Renderer/ShaderProgram',
'../Scene/SceneMode'
], function(
defined,
destroyObject,
TerrainQuantization,
ShaderProgram,
SceneMode) {
'use strict';
function GlobeSurfaceShader(numberOfDayTextures, flags, shaderProgram) {
this.numberOfDayTextures = numberOfDayTextures;
this.flags = flags;
this.shaderProgram = shaderProgram;
}
/**
* Manages the shaders used to shade the surface of a {@link Globe}.
*
* @alias GlobeSurfaceShaderSet
* @private
*/
function GlobeSurfaceShaderSet() {
this.baseVertexShaderSource = undefined;
this.baseFragmentShaderSource = undefined;
this._shadersByTexturesFlags = [];
this._pickShaderPrograms = [];
}
function getPositionMode(sceneMode) {
var getPosition3DMode = 'vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPosition3DMode(position, height, textureCoordinates); }';
var getPositionColumbusViewAnd2DMode = 'vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPositionColumbusViewMode(position, height, textureCoordinates); }';
var getPositionMorphingMode = 'vec4 getPosition(vec3 position, float height, vec2 textureCoordinates) { return getPositionMorphingMode(position, height, textureCoordinates); }';
var positionMode;
switch (sceneMode) {
case SceneMode.SCENE3D:
positionMode = getPosition3DMode;
break;
case SceneMode.SCENE2D:
case SceneMode.COLUMBUS_VIEW:
positionMode = getPositionColumbusViewAnd2DMode;
break;
case SceneMode.MORPHING:
positionMode = getPositionMorphingMode;
break;
}
return positionMode;
}
function get2DYPositionFraction(useWebMercatorProjection) {
var get2DYPositionFractionGeographicProjection = 'float get2DYPositionFraction(vec2 textureCoordinates) { return get2DGeographicYPositionFraction(textureCoordinates); }';
var get2DYPositionFractionMercatorProjection = 'float get2DYPositionFraction(vec2 textureCoordinates) { return get2DMercatorYPositionFraction(textureCoordinates); }';
return useWebMercatorProjection ? get2DYPositionFractionMercatorProjection : get2DYPositionFractionGeographicProjection;
}
GlobeSurfaceShaderSet.prototype.getShaderProgram = function(frameState, surfaceTile, numberOfDayTextures, applyBrightness, applyContrast, applyHue, applySaturation, applyGamma, applyAlpha, showReflectiveOcean, showOceanWaves, enableLighting, hasVertexNormals, useWebMercatorProjection, enableFog) {
var quantization = 0;
var quantizationDefine = '';
var terrainEncoding = surfaceTile.pickTerrain.mesh.encoding;
var quantizationMode = terrainEncoding.quantization;
if (quantizationMode === TerrainQuantization.BITS12) {
quantization = 1;
quantizationDefine = 'QUANTIZATION_BITS12';
}
var sceneMode = frameState.mode;
var flags = sceneMode |
(applyBrightness << 2) |
(applyContrast << 3) |
(applyHue << 4) |
(applySaturation << 5) |
(applyGamma << 6) |
(applyAlpha << 7) |
(showReflectiveOcean << 8) |
(showOceanWaves << 9) |
(enableLighting << 10) |
(hasVertexNormals << 11) |
(useWebMercatorProjection << 12) |
(enableFog << 13) |
(quantization << 14);
var surfaceShader = surfaceTile.surfaceShader;
if (defined(surfaceShader) &&
surfaceShader.numberOfDayTextures === numberOfDayTextures &&
surfaceShader.flags === flags) {
return surfaceShader.shaderProgram;
}
// New tile, or tile changed number of textures or flags.
var shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures];
if (!defined(shadersByFlags)) {
shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures] = [];
}
surfaceShader = shadersByFlags[flags];
if (!defined(surfaceShader)) {
// Cache miss - we've never seen this combination of numberOfDayTextures and flags before.
var vs = this.baseVertexShaderSource.clone();
var fs = this.baseFragmentShaderSource.clone();
vs.defines.push(quantizationDefine);
fs.defines.push('TEXTURE_UNITS ' + numberOfDayTextures);
if (applyBrightness) {
fs.defines.push('APPLY_BRIGHTNESS');
}
if (applyContrast) {
fs.defines.push('APPLY_CONTRAST');
}
if (applyHue) {
fs.defines.push('APPLY_HUE');
}
if (applySaturation) {
fs.defines.push('APPLY_SATURATION');
}
if (applyGamma) {
fs.defines.push('APPLY_GAMMA');
}
if (applyAlpha) {
fs.defines.push('APPLY_ALPHA');
}
if (showReflectiveOcean) {
fs.defines.push('SHOW_REFLECTIVE_OCEAN');
vs.defines.push('SHOW_REFLECTIVE_OCEAN');
}
if (showOceanWaves) {
fs.defines.push('SHOW_OCEAN_WAVES');
}
if (enableLighting) {
if (hasVertexNormals) {
vs.defines.push('ENABLE_VERTEX_LIGHTING');
fs.defines.push('ENABLE_VERTEX_LIGHTING');
} else {
vs.defines.push('ENABLE_DAYNIGHT_SHADING');
fs.defines.push('ENABLE_DAYNIGHT_SHADING');
}
}
vs.defines.push('INCLUDE_WEB_MERCATOR_Y');
fs.defines.push('INCLUDE_WEB_MERCATOR_Y');
if (enableFog) {
vs.defines.push('FOG');
fs.defines.push('FOG');
}
var computeDayColor = '\
vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates)\n\
{\n\
vec4 color = initialColor;\n';
for (var i = 0; i < numberOfDayTextures; ++i) {
computeDayColor += '\
color = sampleAndBlend(\n\
color,\n\
u_dayTextures[' + i + '],\n\
u_dayTextureUseWebMercatorT[' + i + '] ? textureCoordinates.xz : textureCoordinates.xy,\n\
u_dayTextureTexCoordsRectangle[' + i + '],\n\
u_dayTextureTranslationAndScale[' + i + '],\n\
' + (applyAlpha ? 'u_dayTextureAlpha[' + i + ']' : '1.0') + ',\n\
' + (applyBrightness ? 'u_dayTextureBrightness[' + i + ']' : '0.0') + ',\n\
' + (applyContrast ? 'u_dayTextureContrast[' + i + ']' : '0.0') + ',\n\
' + (applyHue ? 'u_dayTextureHue[' + i + ']' : '0.0') + ',\n\
' + (applySaturation ? 'u_dayTextureSaturation[' + i + ']' : '0.0') + ',\n\
' + (applyGamma ? 'u_dayTextureOneOverGamma[' + i + ']' : '0.0') + '\n\
);\n';
}
computeDayColor += '\
return color;\n\
}';
fs.sources.push(computeDayColor);
vs.sources.push(getPositionMode(sceneMode));
vs.sources.push(get2DYPositionFraction(useWebMercatorProjection));
var shader = ShaderProgram.fromCache({
context : frameState.context,
vertexShaderSource : vs,
fragmentShaderSource : fs,
attributeLocations : terrainEncoding.getAttributeLocations()
});
surfaceShader = shadersByFlags[flags] = new GlobeSurfaceShader(numberOfDayTextures, flags, shader);
}
surfaceTile.surfaceShader = surfaceShader;
return surfaceShader.shaderProgram;
};
GlobeSurfaceShaderSet.prototype.getPickShaderProgram = function(frameState, surfaceTile, useWebMercatorProjection) {
var quantization = 0;
var quantizationDefine = '';
var terrainEncoding = surfaceTile.pickTerrain.mesh.encoding;
var quantizationMode = terrainEncoding.quantization;
if (quantizationMode === TerrainQuantization.BITS12) {
quantization = 1;
quantizationDefine = 'QUANTIZATION_BITS12';
}
var sceneMode = frameState.mode;
var flags = sceneMode | (useWebMercatorProjection << 2) | (quantization << 3);
var pickShader = this._pickShaderPrograms[flags];
if (!defined(pickShader)) {
var vs = this.baseVertexShaderSource.clone();
vs.defines.push(quantizationDefine);
vs.sources.push(getPositionMode(sceneMode));
vs.sources.push(get2DYPositionFraction(useWebMercatorProjection));
// pass through fragment shader. only depth is rendered for the globe on a pick pass
var fs =
'void main()\n' +
'{\n' +
' gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);\n' +
'}\n';
pickShader = this._pickShaderPrograms[flags] = ShaderProgram.fromCache({
context : frameState.context,
vertexShaderSource : vs,
fragmentShaderSource : fs,
attributeLocations : terrainEncoding.getAttributeLocations()
});
}
return pickShader;
};
GlobeSurfaceShaderSet.prototype.destroy = function() {
var flags;
var shader;
var shadersByTexturesFlags = this._shadersByTexturesFlags;
for (var textureCount in shadersByTexturesFlags) {
if (shadersByTexturesFlags.hasOwnProperty(textureCount)) {
var shadersByFlags = shadersByTexturesFlags[textureCount];
if (!defined(shadersByFlags)) {
continue;
}
for (flags in shadersByFlags) {
if (shadersByFlags.hasOwnProperty(flags)) {
shader = shadersByFlags[flags];
if (defined(shader)) {
shader.shaderProgram.destroy();
}
}
}
}
}
var pickShaderPrograms = this._pickShaderPrograms;
for (flags in pickShaderPrograms) {
if (pickShaderPrograms.hasOwnProperty(flags)) {
shader = pickShaderPrograms[flags];
shader.destroy();
}
}
return destroyObject(this);
};
return GlobeSurfaceShaderSet;
});
/*global define*/
define('Scene/ImageryState',[
'../Core/freezeObject'
], function(
freezeObject) {
'use strict';
/**
* @private
*/
var ImageryState = {
UNLOADED : 0,
TRANSITIONING : 1,
RECEIVED : 2,
TEXTURE_LOADED : 3,
READY : 4,
FAILED : 5,
INVALID : 6,
PLACEHOLDER : 7
};
return freezeObject(ImageryState);
});
/*global define*/
define('Scene/QuadtreeTileLoadState',[
'../Core/freezeObject'
], function(
freezeObject) {
'use strict';
/**
* The state of a {@link QuadtreeTile} in the tile load pipeline.
* @exports QuadtreeTileLoadState
* @private
*/
var QuadtreeTileLoadState = {
/**
* The tile is new and loading has not yet begun.
* @type QuadtreeTileLoadState
* @constant
* @default 0
*/
START : 0,
/**
* Loading is in progress.
* @type QuadtreeTileLoadState
* @constant
* @default 1
*/
LOADING : 1,
/**
* Loading is complete.
* @type QuadtreeTileLoadState
* @constant
* @default 2
*/
DONE : 2,
/**
* The tile has failed to load.
* @type QuadtreeTileLoadState
* @constant
* @default 3
*/
FAILED : 3
};
return freezeObject(QuadtreeTileLoadState);
});
/*global define*/
define('Scene/TerrainState',[
'../Core/freezeObject'
], function(
freezeObject) {
'use strict';
/**
* @private
*/
var TerrainState = {
FAILED : 0,
UNLOADED : 1,
RECEIVING : 2,
RECEIVED : 3,
TRANSFORMING : 4,
TRANSFORMED : 5,
READY : 6
};
return freezeObject(TerrainState);
});
/*global define*/
define('Scene/TileBoundingBox',[
'../Core/Cartesian3',
'../Core/Cartographic',
'../Core/defaultValue',
'../Core/defined',
'../Core/DeveloperError',
'../Core/Ellipsoid',
'../Core/Rectangle',
'./SceneMode'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
DeveloperError,
Ellipsoid,
Rectangle,
SceneMode) {
'use strict';
/**
* @param {Object} options Object with the following properties:
* @param {Rectangle} options.rectangle
* @param {Number} [options.minimumHeight=0.0]
* @param {Number} [options.maximumHeight=0.0]
* @param {Ellipsoid} [options.ellipsoid=Cesium.Ellipsoid.WGS84]
*
* @private
*/
var TileBoundingBox = function(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(options.rectangle)) {
throw new DeveloperError('options.url is required.');
}
this.rectangle = Rectangle.clone(options.rectangle);
this.minimumHeight = defaultValue(options.minimumHeight, 0.0);
this.maximumHeight = defaultValue(options.maximumHeight, 0.0);
/**
* The world coordinates of the southwest corner of the tile's rectangle.
*
* @type {Cartesian3}
* @default Cartesian3()
*/
this.southwestCornerCartesian = new Cartesian3();
/**
* The world coordinates of the northeast corner of the tile's rectangle.
*
* @type {Cartesian3}
* @default Cartesian3()
*/
this.northeastCornerCartesian = new Cartesian3();
/**
* A normal that, along with southwestCornerCartesian, defines a plane at the western edge of
* the tile. Any position above (in the direction of the normal) this plane is outside the tile.
*
* @type {Cartesian3}
* @default Cartesian3()
*/
this.westNormal = new Cartesian3();
/**
* A normal that, along with southwestCornerCartesian, defines a plane at the southern edge of
* the tile. Any position above (in the direction of the normal) this plane is outside the tile.
* Because points of constant latitude do not necessary lie in a plane, positions below this
* plane are not necessarily inside the tile, but they are close.
*
* @type {Cartesian3}
* @default Cartesian3()
*/
this.southNormal = new Cartesian3();
/**
* A normal that, along with northeastCornerCartesian, defines a plane at the eastern edge of
* the tile. Any position above (in the direction of the normal) this plane is outside the tile.
*
* @type {Cartesian3}
* @default Cartesian3()
*/
this.eastNormal = new Cartesian3();
/**
* A normal that, along with northeastCornerCartesian, defines a plane at the eastern edge of
* the tile. Any position above (in the direction of the normal) this plane is outside the tile.
* Because points of constant latitude do not necessary lie in a plane, positions below this
* plane are not necessarily inside the tile, but they are close.
*
* @type {Cartesian3}
* @default Cartesian3()
*/
this.northNormal = new Cartesian3();
var ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
computeBox(this, options.rectangle, ellipsoid);
};
var cartesian3Scratch = new Cartesian3();
var cartesian3Scratch2 = new Cartesian3();
var westernMidpointScratch = new Cartesian3();
var easternMidpointScratch = new Cartesian3();
var cartographicScratch = new Cartographic();
function computeBox(tileBB, rectangle, ellipsoid) {
ellipsoid.cartographicToCartesian(Rectangle.southwest(rectangle), tileBB.southwestCornerCartesian);
ellipsoid.cartographicToCartesian(Rectangle.northeast(rectangle), tileBB.northeastCornerCartesian);
// The middle latitude on the western edge.
cartographicScratch.longitude = rectangle.west;
cartographicScratch.latitude = (rectangle.south + rectangle.north) * 0.5;
cartographicScratch.height = 0.0;
var westernMidpointCartesian = ellipsoid.cartographicToCartesian(cartographicScratch, westernMidpointScratch);
// Compute the normal of the plane on the western edge of the tile.
var westNormal = Cartesian3.cross(westernMidpointCartesian, Cartesian3.UNIT_Z, cartesian3Scratch);
Cartesian3.normalize(westNormal, tileBB.westNormal);
// The middle latitude on the eastern edge.
cartographicScratch.longitude = rectangle.east;
var easternMidpointCartesian = ellipsoid.cartographicToCartesian(cartographicScratch, easternMidpointScratch);
// Compute the normal of the plane on the eastern edge of the tile.
var eastNormal = Cartesian3.cross(Cartesian3.UNIT_Z, easternMidpointCartesian, cartesian3Scratch);
Cartesian3.normalize(eastNormal, tileBB.eastNormal);
// Compute the normal of the plane bounding the southern edge of the tile.
var southeastCornerNormal = ellipsoid.geodeticSurfaceNormalCartographic(Rectangle.southeast(rectangle), cartesian3Scratch2);
var westVector = Cartesian3.subtract(westernMidpointCartesian, easternMidpointCartesian, cartesian3Scratch);
var southNormal = Cartesian3.cross(southeastCornerNormal, westVector, cartesian3Scratch2);
Cartesian3.normalize(southNormal, tileBB.southNormal);
// Compute the normal of the plane bounding the northern edge of the tile.
var northwestCornerNormal = ellipsoid.geodeticSurfaceNormalCartographic(Rectangle.northwest(rectangle), cartesian3Scratch2);
var northNormal = Cartesian3.cross(westVector, northwestCornerNormal, cartesian3Scratch2);
Cartesian3.normalize(northNormal, tileBB.northNormal);
}
var southwestCornerScratch = new Cartesian3();
var northeastCornerScratch = new Cartesian3();
var negativeUnitY = new Cartesian3(0.0, -1.0, 0.0);
var negativeUnitZ = new Cartesian3(0.0, 0.0, -1.0);
var vectorScratch = new Cartesian3();
/**
* Gets the distance from the camera to the closest point on the tile. This is used for level-of-detail selection.
*
* @param {FrameState} frameState The state information of the current rendering frame.
*
* @returns {Number} The distance from the camera to the closest point on the tile, in meters.
*/
TileBoundingBox.prototype.distanceToCamera = function(frameState) {
var camera = frameState.camera;
var cameraCartesianPosition = camera.positionWC;
var cameraCartographicPosition = camera.positionCartographic;
var result = 0.0;
if (!Rectangle.contains(this.rectangle, cameraCartographicPosition)) {
var southwestCornerCartesian = this.southwestCornerCartesian;
var northeastCornerCartesian = this.northeastCornerCartesian;
var westNormal = this.westNormal;
var southNormal = this.southNormal;
var eastNormal = this.eastNormal;
var northNormal = this.northNormal;
if (frameState.mode !== SceneMode.SCENE3D) {
southwestCornerCartesian = frameState.mapProjection.project(Rectangle.southwest(this.rectangle), southwestCornerScratch);
southwestCornerCartesian.z = southwestCornerCartesian.y;
southwestCornerCartesian.y = southwestCornerCartesian.x;
southwestCornerCartesian.x = 0.0;
northeastCornerCartesian = frameState.mapProjection.project(Rectangle.northeast(this.rectangle), northeastCornerScratch);
northeastCornerCartesian.z = northeastCornerCartesian.y;
northeastCornerCartesian.y = northeastCornerCartesian.x;
northeastCornerCartesian.x = 0.0;
westNormal = negativeUnitY;
eastNormal = Cartesian3.UNIT_Y;
southNormal = negativeUnitZ;
northNormal = Cartesian3.UNIT_Z;
}
var vectorFromSouthwestCorner = Cartesian3.subtract(cameraCartesianPosition, southwestCornerCartesian, vectorScratch);
var distanceToWestPlane = Cartesian3.dot(vectorFromSouthwestCorner, westNormal);
var distanceToSouthPlane = Cartesian3.dot(vectorFromSouthwestCorner, southNormal);
var vectorFromNortheastCorner = Cartesian3.subtract(cameraCartesianPosition, northeastCornerCartesian, vectorScratch);
var distanceToEastPlane = Cartesian3.dot(vectorFromNortheastCorner, eastNormal);
var distanceToNorthPlane = Cartesian3.dot(vectorFromNortheastCorner, northNormal);
if (distanceToWestPlane > 0.0) {
result += distanceToWestPlane * distanceToWestPlane;
} else if (distanceToEastPlane > 0.0) {
result += distanceToEastPlane * distanceToEastPlane;
}
if (distanceToSouthPlane > 0.0) {
result += distanceToSouthPlane * distanceToSouthPlane;
} else if (distanceToNorthPlane > 0.0) {
result += distanceToNorthPlane * distanceToNorthPlane;
}
}
var cameraHeight;
if (frameState.mode === SceneMode.SCENE3D) {
cameraHeight = cameraCartographicPosition.height;
} else {
cameraHeight = cameraCartesianPosition.x;
}
var maximumHeight = frameState.mode === SceneMode.SCENE3D ? this.maximumHeight : 0.0;
var distanceFromTop = cameraHeight - maximumHeight;
if (distanceFromTop > 0.0) {
result += distanceFromTop * distanceFromTop;
}
return Math.sqrt(result);
};
return TileBoundingBox;
});
/*global define*/
define('Scene/TileTerrain',[
'../Core/BoundingSphere',
'../Core/Cartesian3',
'../Core/defined',
'../Core/DeveloperError',
'../Core/IndexDatatype',
'../Core/OrientedBoundingBox',
'../Core/TileProviderError',
'../Renderer/Buffer',
'../Renderer/BufferUsage',
'../Renderer/VertexArray',
'../ThirdParty/when',
'./TerrainState',
'./TileBoundingBox'
], function(
BoundingSphere,
Cartesian3,
defined,
DeveloperError,
IndexDatatype,
OrientedBoundingBox,
TileProviderError,
Buffer,
BufferUsage,
VertexArray,
when,
TerrainState,
TileBoundingBox) {
'use strict';
/**
* Manages details of the terrain load or upsample process.
*
* @alias TileTerrain
* @constructor
* @private
*
* @param {TerrainData} [upsampleDetails.data] The terrain data being upsampled.
* @param {Number} [upsampleDetails.x] The X coordinate of the tile being upsampled.
* @param {Number} [upsampleDetails.y] The Y coordinate of the tile being upsampled.
* @param {Number} [upsampleDetails.level] The level coordinate of the tile being upsampled.
*/
function TileTerrain(upsampleDetails) {
/**
* The current state of the terrain in the terrain processing pipeline.
* @type {TerrainState}
* @default {@link TerrainState.UNLOADED}
*/
this.state = TerrainState.UNLOADED;
this.data = undefined;
this.mesh = undefined;
this.vertexArray = undefined;
this.upsampleDetails = upsampleDetails;
}
TileTerrain.prototype.freeResources = function() {
this.state = TerrainState.UNLOADED;
this.data = undefined;
this.mesh = undefined;
if (defined(this.vertexArray)) {
var indexBuffer = this.vertexArray.indexBuffer;
this.vertexArray.destroy();
this.vertexArray = undefined;
if (!indexBuffer.isDestroyed() && defined(indexBuffer.referenceCount)) {
--indexBuffer.referenceCount;
if (indexBuffer.referenceCount === 0) {
indexBuffer.destroy();
}
}
}
};
TileTerrain.prototype.publishToTile = function(tile) {
var surfaceTile = tile.data;
var mesh = this.mesh;
Cartesian3.clone(mesh.center, surfaceTile.center);
surfaceTile.minimumHeight = mesh.minimumHeight;
surfaceTile.maximumHeight = mesh.maximumHeight;
surfaceTile.boundingSphere3D = BoundingSphere.clone(mesh.boundingSphere3D, surfaceTile.boundingSphere3D);
surfaceTile.orientedBoundingBox = OrientedBoundingBox.clone(mesh.orientedBoundingBox, surfaceTile.orientedBoundingBox);
surfaceTile.tileBoundingBox = new TileBoundingBox({
rectangle : tile.rectangle,
minimumHeight : mesh.minimumHeight,
maximumHeight : mesh.maximumHeight,
ellipsoid : tile.tilingScheme.ellipsoid
});
tile.data.occludeePointInScaledSpace = Cartesian3.clone(mesh.occludeePointInScaledSpace, surfaceTile.occludeePointInScaledSpace);
};
TileTerrain.prototype.processLoadStateMachine = function(frameState, terrainProvider, x, y, level) {
if (this.state === TerrainState.UNLOADED) {
requestTileGeometry(this, terrainProvider, x, y, level);
}
if (this.state === TerrainState.RECEIVED) {
transform(this, frameState, terrainProvider, x, y, level);
}
if (this.state === TerrainState.TRANSFORMED) {
createResources(this, frameState.context, terrainProvider, x, y, level);
}
};
function requestTileGeometry(tileTerrain, terrainProvider, x, y, level) {
function success(terrainData) {
tileTerrain.data = terrainData;
tileTerrain.state = TerrainState.RECEIVED;
}
function failure() {
// Initially assume failure. handleError may retry, in which case the state will
// change to RECEIVING or UNLOADED.
tileTerrain.state = TerrainState.FAILED;
var message = 'Failed to obtain terrain tile X: ' + x + ' Y: ' + y + ' Level: ' + level + '.';
terrainProvider._requestError = TileProviderError.handleError(
terrainProvider._requestError,
terrainProvider,
terrainProvider.errorEvent,
message,
x, y, level,
doRequest);
}
function doRequest() {
// Request the terrain from the terrain provider.
tileTerrain.data = terrainProvider.requestTileGeometry(x, y, level);
// If the request method returns undefined (instead of a promise), the request
// has been deferred.
if (defined(tileTerrain.data)) {
tileTerrain.state = TerrainState.RECEIVING;
when(tileTerrain.data, success, failure);
} else {
// Deferred - try again later.
tileTerrain.state = TerrainState.UNLOADED;
}
}
doRequest();
}
TileTerrain.prototype.processUpsampleStateMachine = function(frameState, terrainProvider, x, y, level) {
if (this.state === TerrainState.UNLOADED) {
var upsampleDetails = this.upsampleDetails;
if (!defined(upsampleDetails)) {
throw new DeveloperError('TileTerrain cannot upsample unless provided upsampleDetails.');
}
var sourceData = upsampleDetails.data;
var sourceX = upsampleDetails.x;
var sourceY = upsampleDetails.y;
var sourceLevel = upsampleDetails.level;
this.data = sourceData.upsample(terrainProvider.tilingScheme, sourceX, sourceY, sourceLevel, x, y, level);
if (!defined(this.data)) {
// The upsample request has been deferred - try again later.
return;
}
this.state = TerrainState.RECEIVING;
var that = this;
when(this.data, function(terrainData) {
that.data = terrainData;
that.state = TerrainState.RECEIVED;
}, function() {
that.state = TerrainState.FAILED;
});
}
if (this.state === TerrainState.RECEIVED) {
transform(this, frameState, terrainProvider, x, y, level);
}
if (this.state === TerrainState.TRANSFORMED) {
createResources(this, frameState.context, terrainProvider, x, y, level);
}
};
function transform(tileTerrain, frameState, terrainProvider, x, y, level) {
var tilingScheme = terrainProvider.tilingScheme;
var terrainData = tileTerrain.data;
var meshPromise = terrainData.createMesh(tilingScheme, x, y, level, frameState.terrainExaggeration);
if (!defined(meshPromise)) {
// Postponed.
return;
}
tileTerrain.state = TerrainState.TRANSFORMING;
when(meshPromise, function(mesh) {
tileTerrain.mesh = mesh;
tileTerrain.state = TerrainState.TRANSFORMED;
}, function() {
tileTerrain.state = TerrainState.FAILED;
});
}
function createResources(tileTerrain, context, terrainProvider, x, y, level) {
var typedArray = tileTerrain.mesh.vertices;
var buffer = Buffer.createVertexBuffer({
context : context,
typedArray : typedArray,
usage : BufferUsage.STATIC_DRAW
});
var attributes = tileTerrain.mesh.encoding.getAttributes(buffer);
var indexBuffers = tileTerrain.mesh.indices.indexBuffers || {};
var indexBuffer = indexBuffers[context.id];
if (!defined(indexBuffer) || indexBuffer.isDestroyed()) {
var indices = tileTerrain.mesh.indices;
var indexDatatype = (indices.BYTES_PER_ELEMENT === 2) ? IndexDatatype.UNSIGNED_SHORT : IndexDatatype.UNSIGNED_INT;
indexBuffer = Buffer.createIndexBuffer({
context : context,
typedArray : indices,
usage : BufferUsage.STATIC_DRAW,
indexDatatype : indexDatatype
});
indexBuffer.vertexArrayDestroyable = false;
indexBuffer.referenceCount = 1;
indexBuffers[context.id] = indexBuffer;
tileTerrain.mesh.indices.indexBuffers = indexBuffers;
} else {
++indexBuffer.referenceCount;
}
tileTerrain.vertexArray = new VertexArray({
context : context,
attributes : attributes,
indexBuffer : indexBuffer
});
tileTerrain.state = TerrainState.READY;
}
return TileTerrain;
});
/*global define*/
define('Scene/GlobeSurfaceTile',[
'../Core/BoundingSphere',
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/IntersectionTests',
'../Core/PixelFormat',
'../Renderer/PixelDatatype',
'../Renderer/Sampler',
'../Renderer/Texture',
'../Renderer/TextureMagnificationFilter',
'../Renderer/TextureMinificationFilter',
'../Renderer/TextureWrap',
'./ImageryState',
'./QuadtreeTileLoadState',
'./SceneMode',
'./TerrainState',
'./TileTerrain'
], function(
BoundingSphere,
Cartesian3,
Cartesian4,
defaultValue,
defined,
defineProperties,
IntersectionTests,
PixelFormat,
PixelDatatype,
Sampler,
Texture,
TextureMagnificationFilter,
TextureMinificationFilter,
TextureWrap,
ImageryState,
QuadtreeTileLoadState,
SceneMode,
TerrainState,
TileTerrain) {
'use strict';
/**
* Contains additional information about a {@link QuadtreeTile} of the globe's surface, and
* encapsulates state transition logic for loading tiles.
*
* @constructor
* @alias GlobeSurfaceTile
* @private
*/
function GlobeSurfaceTile() {
/**
* The {@link TileImagery} attached to this tile.
* @type {TileImagery[]}
* @default []
*/
this.imagery = [];
this.waterMaskTexture = undefined;
this.waterMaskTranslationAndScale = new Cartesian4(0.0, 0.0, 1.0, 1.0);
this.terrainData = undefined;
this.center = new Cartesian3();
this.vertexArray = undefined;
this.minimumHeight = 0.0;
this.maximumHeight = 0.0;
this.boundingSphere3D = new BoundingSphere();
this.boundingSphere2D = new BoundingSphere();
this.orientedBoundingBox = undefined;
this.tileBoundingBox = undefined;
this.occludeePointInScaledSpace = new Cartesian3();
this.loadedTerrain = undefined;
this.upsampledTerrain = undefined;
this.pickBoundingSphere = new BoundingSphere();
this.pickTerrain = undefined;
this.surfaceShader = undefined;
}
defineProperties(GlobeSurfaceTile.prototype, {
/**
* Gets a value indicating whether or not this tile is eligible to be unloaded.
* Typically, a tile is ineligible to be unloaded while an asynchronous operation,
* such as a request for data, is in progress on it. A tile will never be
* unloaded while it is needed for rendering, regardless of the value of this
* property.
* @memberof GlobeSurfaceTile.prototype
* @type {Boolean}
*/
eligibleForUnloading : {
get : function() {
// Do not remove tiles that are transitioning or that have
// imagery that is transitioning.
var loadedTerrain = this.loadedTerrain;
var loadingIsTransitioning = defined(loadedTerrain) &&
(loadedTerrain.state === TerrainState.RECEIVING || loadedTerrain.state === TerrainState.TRANSFORMING);
var upsampledTerrain = this.upsampledTerrain;
var upsamplingIsTransitioning = defined(upsampledTerrain) &&
(upsampledTerrain.state === TerrainState.RECEIVING || upsampledTerrain.state === TerrainState.TRANSFORMING);
var shouldRemoveTile = !loadingIsTransitioning && !upsamplingIsTransitioning;
var imagery = this.imagery;
for (var i = 0, len = imagery.length; shouldRemoveTile && i < len; ++i) {
var tileImagery = imagery[i];
shouldRemoveTile = !defined(tileImagery.loadingImagery) || tileImagery.loadingImagery.state !== ImageryState.TRANSITIONING;
}
return shouldRemoveTile;
}
}
});
function getPosition(encoding, mode, projection, vertices, index, result) {
encoding.decodePosition(vertices, index, result);
if (defined(mode) && mode !== SceneMode.SCENE3D) {
var ellipsoid = projection.ellipsoid;
var positionCart = ellipsoid.cartesianToCartographic(result);
projection.project(positionCart, result);
Cartesian3.fromElements(result.z, result.x, result.y, result);
}
return result;
}
var scratchV0 = new Cartesian3();
var scratchV1 = new Cartesian3();
var scratchV2 = new Cartesian3();
var scratchResult = new Cartesian3();
GlobeSurfaceTile.prototype.pick = function(ray, mode, projection, cullBackFaces, result) {
var terrain = this.pickTerrain;
if (!defined(terrain)) {
return undefined;
}
var mesh = terrain.mesh;
if (!defined(mesh)) {
return undefined;
}
var vertices = mesh.vertices;
var indices = mesh.indices;
var encoding = mesh.encoding;
var length = indices.length;
for (var i = 0; i < length; i += 3) {
var i0 = indices[i];
var i1 = indices[i + 1];
var i2 = indices[i + 2];
var v0 = getPosition(encoding, mode, projection, vertices, i0, scratchV0);
var v1 = getPosition(encoding, mode, projection, vertices, i1, scratchV1);
var v2 = getPosition(encoding, mode, projection, vertices, i2, scratchV2);
var intersection = IntersectionTests.rayTriangle(ray, v0, v1, v2, cullBackFaces, scratchResult);
if (defined(intersection)) {
return Cartesian3.clone(intersection, result);
}
}
return undefined;
};
GlobeSurfaceTile.prototype.freeResources = function() {
if (defined(this.waterMaskTexture)) {
--this.waterMaskTexture.referenceCount;
if (this.waterMaskTexture.referenceCount === 0) {
this.waterMaskTexture.destroy();
}
this.waterMaskTexture = undefined;
}
this.terrainData = undefined;
if (defined(this.loadedTerrain)) {
this.loadedTerrain.freeResources();
this.loadedTerrain = undefined;
}
if (defined(this.upsampledTerrain)) {
this.upsampledTerrain.freeResources();
this.upsampledTerrain = undefined;
}
if (defined(this.pickTerrain)) {
this.pickTerrain.freeResources();
this.pickTerrain = undefined;
}
var i, len;
var imageryList = this.imagery;
for (i = 0, len = imageryList.length; i < len; ++i) {
imageryList[i].freeResources();
}
this.imagery.length = 0;
this.freeVertexArray();
};
GlobeSurfaceTile.prototype.freeVertexArray = function() {
var indexBuffer;
if (defined(this.vertexArray)) {
indexBuffer = this.vertexArray.indexBuffer;
this.vertexArray = this.vertexArray.destroy();
if (!indexBuffer.isDestroyed() && defined(indexBuffer.referenceCount)) {
--indexBuffer.referenceCount;
if (indexBuffer.referenceCount === 0) {
indexBuffer.destroy();
}
}
}
if (defined(this.wireframeVertexArray)) {
indexBuffer = this.wireframeVertexArray.indexBuffer;
this.wireframeVertexArray = this.wireframeVertexArray.destroy();
if (!indexBuffer.isDestroyed() && defined(indexBuffer.referenceCount)) {
--indexBuffer.referenceCount;
if (indexBuffer.referenceCount === 0) {
indexBuffer.destroy();
}
}
}
};
GlobeSurfaceTile.processStateMachine = function(tile, frameState, terrainProvider, imageryLayerCollection, vertexArraysToDestroy) {
var surfaceTile = tile.data;
if (!defined(surfaceTile)) {
surfaceTile = tile.data = new GlobeSurfaceTile();
}
if (tile.state === QuadtreeTileLoadState.START) {
prepareNewTile(tile, terrainProvider, imageryLayerCollection);
tile.state = QuadtreeTileLoadState.LOADING;
}
if (tile.state === QuadtreeTileLoadState.LOADING) {
processTerrainStateMachine(tile, frameState, terrainProvider, vertexArraysToDestroy);
}
// The terrain is renderable as soon as we have a valid vertex array.
var isRenderable = defined(surfaceTile.vertexArray);
// But it's not done loading until our two state machines are terminated.
var isDoneLoading = !defined(surfaceTile.loadedTerrain) && !defined(surfaceTile.upsampledTerrain);
// If this tile's terrain and imagery are just upsampled from its parent, mark the tile as
// upsampled only. We won't refine a tile if its four children are upsampled only.
var isUpsampledOnly = defined(surfaceTile.terrainData) && surfaceTile.terrainData.wasCreatedByUpsampling();
// Transition imagery states
var tileImageryCollection = surfaceTile.imagery;
for (var i = 0, len = tileImageryCollection.length; i < len; ++i) {
var tileImagery = tileImageryCollection[i];
if (!defined(tileImagery.loadingImagery)) {
isUpsampledOnly = false;
continue;
}
if (tileImagery.loadingImagery.state === ImageryState.PLACEHOLDER) {
var imageryLayer = tileImagery.loadingImagery.imageryLayer;
if (imageryLayer.imageryProvider.ready) {
// Remove the placeholder and add the actual skeletons (if any)
// at the same position. Then continue the loop at the same index.
tileImagery.freeResources();
tileImageryCollection.splice(i, 1);
imageryLayer._createTileImagerySkeletons(tile, terrainProvider, i);
--i;
len = tileImageryCollection.length;
continue;
} else {
isUpsampledOnly = false;
}
}
var thisTileDoneLoading = tileImagery.processStateMachine(tile, frameState);
isDoneLoading = isDoneLoading && thisTileDoneLoading;
// The imagery is renderable as soon as we have any renderable imagery for this region.
isRenderable = isRenderable && (thisTileDoneLoading || defined(tileImagery.readyImagery));
isUpsampledOnly = isUpsampledOnly && defined(tileImagery.loadingImagery) &&
(tileImagery.loadingImagery.state === ImageryState.FAILED || tileImagery.loadingImagery.state === ImageryState.INVALID);
}
tile.upsampledFromParent = isUpsampledOnly;
// The tile becomes renderable when the terrain and all imagery data are loaded.
if (i === len) {
if (isRenderable) {
tile.renderable = true;
}
if (isDoneLoading) {
tile.state = QuadtreeTileLoadState.DONE;
}
}
};
function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
var surfaceTile = tile.data;
var upsampleTileDetails = getUpsampleTileDetails(tile);
if (defined(upsampleTileDetails)) {
surfaceTile.upsampledTerrain = new TileTerrain(upsampleTileDetails);
}
if (isDataAvailable(tile, terrainProvider)) {
surfaceTile.loadedTerrain = new TileTerrain();
}
// Map imagery tiles to this terrain tile
for (var i = 0, len = imageryLayerCollection.length; i < len; ++i) {
var layer = imageryLayerCollection.get(i);
if (layer.show) {
layer._createTileImagerySkeletons(tile, terrainProvider);
}
}
}
function processTerrainStateMachine(tile, frameState, terrainProvider, vertexArraysToDestroy) {
var surfaceTile = tile.data;
var loaded = surfaceTile.loadedTerrain;
var upsampled = surfaceTile.upsampledTerrain;
var suspendUpsampling = false;
if (defined(loaded)) {
loaded.processLoadStateMachine(frameState, terrainProvider, tile.x, tile.y, tile.level);
// Publish the terrain data on the tile as soon as it is available.
// We'll potentially need it to upsample child tiles.
if (loaded.state >= TerrainState.RECEIVED) {
if (surfaceTile.terrainData !== loaded.data) {
surfaceTile.terrainData = loaded.data;
// If there's a water mask included in the terrain data, create a
// texture for it.
createWaterMaskTextureIfNeeded(frameState.context, surfaceTile);
propagateNewLoadedDataToChildren(tile);
}
suspendUpsampling = true;
}
if (loaded.state === TerrainState.READY) {
loaded.publishToTile(tile);
if (defined(tile.data.vertexArray)) {
// Free the tiles existing vertex array on next render.
vertexArraysToDestroy.push(tile.data.vertexArray);
}
// Transfer ownership of the vertex array to the tile itself.
tile.data.vertexArray = loaded.vertexArray;
loaded.vertexArray = undefined;
// No further loading or upsampling is necessary.
surfaceTile.pickTerrain = defaultValue(surfaceTile.loadedTerrain, surfaceTile.upsampledTerrain);
surfaceTile.loadedTerrain = undefined;
surfaceTile.upsampledTerrain = undefined;
} else if (loaded.state === TerrainState.FAILED) {
// Loading failed for some reason, or data is simply not available,
// so no need to continue trying to load. Any retrying will happen before we
// reach this point.
surfaceTile.loadedTerrain = undefined;
}
}
if (!suspendUpsampling && defined(upsampled)) {
upsampled.processUpsampleStateMachine(frameState, terrainProvider, tile.x, tile.y, tile.level);
// Publish the terrain data on the tile as soon as it is available.
// We'll potentially need it to upsample child tiles.
// It's safe to overwrite terrainData because we won't get here after
// loaded terrain data has been received.
if (upsampled.state >= TerrainState.RECEIVED) {
if (surfaceTile.terrainData !== upsampled.data) {
surfaceTile.terrainData = upsampled.data;
// If the terrain provider has a water mask, "upsample" that as well
// by computing texture translation and scale.
if (terrainProvider.hasWaterMask) {
upsampleWaterMask(tile);
}
propagateNewUpsampledDataToChildren(tile);
}
}
if (upsampled.state === TerrainState.READY) {
upsampled.publishToTile(tile);
if (defined(tile.data.vertexArray)) {
// Free the tiles existing vertex array on next render.
vertexArraysToDestroy.push(tile.data.vertexArray);
}
// Transfer ownership of the vertex array to the tile itself.
tile.data.vertexArray = upsampled.vertexArray;
upsampled.vertexArray = undefined;
// No further upsampling is necessary. We need to continue loading, though.
surfaceTile.pickTerrain = surfaceTile.upsampledTerrain;
surfaceTile.upsampledTerrain = undefined;
} else if (upsampled.state === TerrainState.FAILED) {
// Upsampling failed for some reason. This is pretty much a catastrophic failure,
// but maybe we'll be saved by loading.
surfaceTile.upsampledTerrain = undefined;
}
}
}
function getUpsampleTileDetails(tile) {
// Find the nearest ancestor with loaded terrain.
var sourceTile = tile.parent;
while (defined(sourceTile) && defined(sourceTile.data) && !defined(sourceTile.data.terrainData)) {
sourceTile = sourceTile.parent;
}
if (!defined(sourceTile) || !defined(sourceTile.data)) {
// No ancestors have loaded terrain - try again later.
return undefined;
}
return {
data : sourceTile.data.terrainData,
x : sourceTile.x,
y : sourceTile.y,
level : sourceTile.level
};
}
function propagateNewUpsampledDataToChildren(tile) {
// Now that there's new data for this tile:
// - child tiles that were previously upsampled need to be re-upsampled based on the new data.
// Generally this is only necessary when a child tile is upsampled, and then one
// of its ancestors receives new (better) data and we want to re-upsample from the
// new data.
propagateNewUpsampledDataToChild(tile, tile._southwestChild);
propagateNewUpsampledDataToChild(tile, tile._southeastChild);
propagateNewUpsampledDataToChild(tile, tile._northwestChild);
propagateNewUpsampledDataToChild(tile, tile._northeastChild);
}
function propagateNewUpsampledDataToChild(tile, childTile) {
if (defined(childTile) && childTile.state !== QuadtreeTileLoadState.START) {
var childSurfaceTile = childTile.data;
if (defined(childSurfaceTile.terrainData) && !childSurfaceTile.terrainData.wasCreatedByUpsampling()) {
// Data for the child tile has already been loaded.
return;
}
// Restart the upsampling process, no matter its current state.
// We create a new instance rather than just restarting the existing one
// because there could be an asynchronous operation pending on the existing one.
if (defined(childSurfaceTile.upsampledTerrain)) {
childSurfaceTile.upsampledTerrain.freeResources();
}
childSurfaceTile.upsampledTerrain = new TileTerrain({
data : tile.data.terrainData,
x : tile.x,
y : tile.y,
level : tile.level
});
childTile.state = QuadtreeTileLoadState.LOADING;
}
}
function propagateNewLoadedDataToChildren(tile) {
var surfaceTile = tile.data;
// Now that there's new data for this tile:
// - child tiles that were previously upsampled need to be re-upsampled based on the new data.
// - child tiles that were previously deemed unavailable may now be available.
propagateNewLoadedDataToChildTile(tile, surfaceTile, tile.southwestChild);
propagateNewLoadedDataToChildTile(tile, surfaceTile, tile.southeastChild);
propagateNewLoadedDataToChildTile(tile, surfaceTile, tile.northwestChild);
propagateNewLoadedDataToChildTile(tile, surfaceTile, tile.northeastChild);
}
function propagateNewLoadedDataToChildTile(tile, surfaceTile, childTile) {
if (childTile.state !== QuadtreeTileLoadState.START) {
var childSurfaceTile = childTile.data;
if (defined(childSurfaceTile.terrainData) && !childSurfaceTile.terrainData.wasCreatedByUpsampling()) {
// Data for the child tile has already been loaded.
return;
}
// Restart the upsampling process, no matter its current state.
// We create a new instance rather than just restarting the existing one
// because there could be an asynchronous operation pending on the existing one.
if (defined(childSurfaceTile.upsampledTerrain)) {
childSurfaceTile.upsampledTerrain.freeResources();
}
childSurfaceTile.upsampledTerrain = new TileTerrain({
data : surfaceTile.terrainData,
x : tile.x,
y : tile.y,
level : tile.level
});
if (surfaceTile.terrainData.isChildAvailable(tile.x, tile.y, childTile.x, childTile.y)) {
// Data is available for the child now. It might have been before, too.
if (!defined(childSurfaceTile.loadedTerrain)) {
// No load process is in progress, so start one.
childSurfaceTile.loadedTerrain = new TileTerrain();
}
}
childTile.state = QuadtreeTileLoadState.LOADING;
}
}
function isDataAvailable(tile, terrainProvider) {
var tileDataAvailable = terrainProvider.getTileDataAvailable(tile.x, tile.y, tile.level);
if (defined(tileDataAvailable)) {
return tileDataAvailable;
}
var parent = tile.parent;
if (!defined(parent)) {
// Data is assumed to be available for root tiles.
return true;
}
if (!defined(parent.data) || !defined(parent.data.terrainData)) {
// Parent tile data is not yet received or upsampled, so assume (for now) that this
// child tile is not available.
return false;
}
return parent.data.terrainData.isChildAvailable(parent.x, parent.y, tile.x, tile.y);
}
function getContextWaterMaskData(context) {
var data = context.cache.tile_waterMaskData;
if (!defined(data)) {
var allWaterTexture = new Texture({
context : context,
pixelFormat : PixelFormat.LUMINANCE,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE,
source : {
arrayBufferView : new Uint8Array([255]),
width : 1,
height : 1
}
});
allWaterTexture.referenceCount = 1;
var sampler = new Sampler({
wrapS : TextureWrap.CLAMP_TO_EDGE,
wrapT : TextureWrap.CLAMP_TO_EDGE,
minificationFilter : TextureMinificationFilter.LINEAR,
magnificationFilter : TextureMagnificationFilter.LINEAR
});
data = {
allWaterTexture : allWaterTexture,
sampler : sampler,
destroy : function() {
this.allWaterTexture.destroy();
}
};
context.cache.tile_waterMaskData = data;
}
return data;
}
function createWaterMaskTextureIfNeeded(context, surfaceTile) {
var previousTexture = surfaceTile.waterMaskTexture;
if (defined(previousTexture)) {
--previousTexture.referenceCount;
if (previousTexture.referenceCount === 0) {
previousTexture.destroy();
}
surfaceTile.waterMaskTexture = undefined;
}
var waterMask = surfaceTile.terrainData.waterMask;
if (!defined(waterMask)) {
return;
}
var waterMaskData = getContextWaterMaskData(context);
var texture;
var waterMaskLength = waterMask.length;
if (waterMaskLength === 1) {
// Length 1 means the tile is entirely land or entirely water.
// A value of 0 indicates entirely land, a value of 1 indicates entirely water.
if (waterMask[0] !== 0) {
texture = waterMaskData.allWaterTexture;
} else {
// Leave the texture undefined if the tile is entirely land.
return;
}
} else {
var textureSize = Math.sqrt(waterMaskLength);
texture = new Texture({
context : context,
pixelFormat : PixelFormat.LUMINANCE,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE,
source : {
width : textureSize,
height : textureSize,
arrayBufferView : waterMask
},
sampler : waterMaskData.sampler
});
texture.referenceCount = 0;
}
++texture.referenceCount;
surfaceTile.waterMaskTexture = texture;
Cartesian4.fromElements(0.0, 0.0, 1.0, 1.0, surfaceTile.waterMaskTranslationAndScale);
}
function upsampleWaterMask(tile) {
var surfaceTile = tile.data;
// Find the nearest ancestor with loaded terrain.
var sourceTile = tile.parent;
while (defined(sourceTile) && !defined(sourceTile.data.terrainData) || sourceTile.data.terrainData.wasCreatedByUpsampling()) {
sourceTile = sourceTile.parent;
}
if (!defined(sourceTile) || !defined(sourceTile.data.waterMaskTexture)) {
// No ancestors have a water mask texture - try again later.
return;
}
surfaceTile.waterMaskTexture = sourceTile.data.waterMaskTexture;
++surfaceTile.waterMaskTexture.referenceCount;
// Compute the water mask translation and scale
var sourceTileRectangle = sourceTile.rectangle;
var tileRectangle = tile.rectangle;
var tileWidth = tileRectangle.width;
var tileHeight = tileRectangle.height;
var scaleX = tileWidth / sourceTileRectangle.width;
var scaleY = tileHeight / sourceTileRectangle.height;
surfaceTile.waterMaskTranslationAndScale.x = scaleX * (tileRectangle.west - sourceTileRectangle.west) / tileWidth;
surfaceTile.waterMaskTranslationAndScale.y = scaleY * (tileRectangle.south - sourceTileRectangle.south) / tileHeight;
surfaceTile.waterMaskTranslationAndScale.z = scaleX;
surfaceTile.waterMaskTranslationAndScale.w = scaleY;
}
return GlobeSurfaceTile;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/ReprojectWebMercatorFS',[],function() {
'use strict';
return "uniform sampler2D u_texture;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
gl_FragColor = texture2D(u_texture, v_textureCoordinates);\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/ReprojectWebMercatorVS',[],function() {
'use strict';
return "attribute vec4 position;\n\
attribute float webMercatorT;\n\
uniform vec2 u_textureDimensions;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
v_textureCoordinates = vec2(position.x, webMercatorT);\n\
gl_Position = czm_viewportOrthographic * (position * vec4(u_textureDimensions, 1.0, 1.0));\n\
}\n\
";
});
/*global define*/
define('Scene/Imagery',[
'../Core/defined',
'../Core/destroyObject',
'./ImageryState'
], function(
defined,
destroyObject,
ImageryState) {
'use strict';
/**
* Stores details about a tile of imagery.
*
* @alias Imagery
* @private
*/
function Imagery(imageryLayer, x, y, level, rectangle) {
this.imageryLayer = imageryLayer;
this.x = x;
this.y = y;
this.level = level;
if (level !== 0) {
var parentX = x / 2 | 0;
var parentY = y / 2 | 0;
var parentLevel = level - 1;
this.parent = imageryLayer.getImageryFromCache(parentX, parentY, parentLevel);
}
this.state = ImageryState.UNLOADED;
this.imageUrl = undefined;
this.image = undefined;
this.texture = undefined;
this.textureWebMercator = undefined;
this.credits = undefined;
this.referenceCount = 0;
if (!defined(rectangle) && imageryLayer.imageryProvider.ready) {
var tilingScheme = imageryLayer.imageryProvider.tilingScheme;
rectangle = tilingScheme.tileXYToRectangle(x, y, level);
}
this.rectangle = rectangle;
}
Imagery.createPlaceholder = function(imageryLayer) {
var result = new Imagery(imageryLayer, 0, 0, 0);
result.addReference();
result.state = ImageryState.PLACEHOLDER;
return result;
};
Imagery.prototype.addReference = function() {
++this.referenceCount;
};
Imagery.prototype.releaseReference = function() {
--this.referenceCount;
if (this.referenceCount === 0) {
this.imageryLayer.removeImageryFromCache(this);
if (defined(this.parent)) {
this.parent.releaseReference();
}
if (defined(this.image) && defined(this.image.destroy)) {
this.image.destroy();
}
if (defined(this.texture)) {
this.texture.destroy();
}
if (defined(this.textureWebMercator) && this.texture !== this.textureWebMercator) {
this.textureWebMercator.destroy();
}
destroyObject(this);
return 0;
}
return this.referenceCount;
};
Imagery.prototype.processStateMachine = function(frameState, needGeographicProjection) {
if (this.state === ImageryState.UNLOADED) {
this.state = ImageryState.TRANSITIONING;
this.imageryLayer._requestImagery(this);
}
if (this.state === ImageryState.RECEIVED) {
this.state = ImageryState.TRANSITIONING;
this.imageryLayer._createTexture(frameState.context, this);
}
// If the imagery is already ready, but we need a geographic version and don't have it yet,
// we still need to do the reprojection step. This can happen if the Web Mercator version
// is fine initially, but the geographic one is needed later.
var needsReprojection = this.state === ImageryState.READY && needGeographicProjection && !this.texture;
if (this.state === ImageryState.TEXTURE_LOADED || needsReprojection) {
this.state = ImageryState.TRANSITIONING;
this.imageryLayer._reprojectTexture(frameState, this, needGeographicProjection);
}
};
return Imagery;
});
/*global define*/
define('Scene/TileImagery',[
'../Core/defined',
'./ImageryState'
], function(
defined,
ImageryState) {
'use strict';
/**
* The assocation between a terrain tile and an imagery tile.
*
* @alias TileImagery
* @private
*
* @param {Imagery} imagery The imagery tile.
* @param {Cartesian4} textureCoordinateRectangle The texture rectangle of the tile that is covered
* by the imagery, where X=west, Y=south, Z=east, W=north.
* @param {Boolean} useWebMercatorT true to use the Web Mercator texture coordinates for this imagery tile.
*/
function TileImagery(imagery, textureCoordinateRectangle, useWebMercatorT) {
this.readyImagery = undefined;
this.loadingImagery = imagery;
this.textureCoordinateRectangle = textureCoordinateRectangle;
this.textureTranslationAndScale = undefined;
this.useWebMercatorT = useWebMercatorT;
}
/**
* Frees the resources held by this instance.
*/
TileImagery.prototype.freeResources = function() {
if (defined(this.readyImagery)) {
this.readyImagery.releaseReference();
}
if (defined(this.loadingImagery)) {
this.loadingImagery.releaseReference();
}
};
/**
* Processes the load state machine for this instance.
*
* @param {Tile} tile The tile to which this instance belongs.
* @param {FrameState} frameState The frameState.
* @returns {Boolean} True if this instance is done loading; otherwise, false.
*/
TileImagery.prototype.processStateMachine = function(tile, frameState) {
var loadingImagery = this.loadingImagery;
var imageryLayer = loadingImagery.imageryLayer;
loadingImagery.processStateMachine(frameState, !this.useWebMercatorT);
if (loadingImagery.state === ImageryState.READY) {
if (defined(this.readyImagery)) {
this.readyImagery.releaseReference();
}
this.readyImagery = this.loadingImagery;
this.loadingImagery = undefined;
this.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(tile, this);
return true; // done loading
}
// Find some ancestor imagery we can use while this imagery is still loading.
var ancestor = loadingImagery.parent;
var closestAncestorThatNeedsLoading;
while (defined(ancestor) && ancestor.state !== ImageryState.READY) {
if (ancestor.state !== ImageryState.FAILED && ancestor.state !== ImageryState.INVALID) {
// ancestor is still loading
closestAncestorThatNeedsLoading = closestAncestorThatNeedsLoading || ancestor;
}
ancestor = ancestor.parent;
}
if (this.readyImagery !== ancestor) {
if (defined(this.readyImagery)) {
this.readyImagery.releaseReference();
}
this.readyImagery = ancestor;
if (defined(ancestor)) {
ancestor.addReference();
this.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(tile, this);
}
}
if (loadingImagery.state === ImageryState.FAILED || loadingImagery.state === ImageryState.INVALID) {
// The imagery tile is failed or invalid, so we'd like to use an ancestor instead.
if (defined(closestAncestorThatNeedsLoading)) {
// Push the ancestor's load process along a bit. This is necessary because some ancestor imagery
// tiles may not be attached directly to a terrain tile. Such tiles will never load if
// we don't do it here.
closestAncestorThatNeedsLoading.processStateMachine(frameState, !this.useWebMercatorT);
return false; // not done loading
} else {
// This imagery tile is failed or invalid, and we have the "best available" substitute.
return true; // done loading
}
}
return false; // not done loading
};
return TileImagery;
});
/*global define*/
define('Scene/ImageryLayer',[
'../Core/Cartesian2',
'../Core/Cartesian4',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/FeatureDetection',
'../Core/GeographicTilingScheme',
'../Core/IndexDatatype',
'../Core/Math',
'../Core/PixelFormat',
'../Core/Rectangle',
'../Core/TerrainProvider',
'../Core/TileProviderError',
'../Core/WebMercatorProjection',
'../Core/WebMercatorTilingScheme',
'../Renderer/Buffer',
'../Renderer/BufferUsage',
'../Renderer/ComputeCommand',
'../Renderer/ContextLimits',
'../Renderer/MipmapHint',
'../Renderer/Sampler',
'../Renderer/ShaderProgram',
'../Renderer/ShaderSource',
'../Renderer/Texture',
'../Renderer/TextureMagnificationFilter',
'../Renderer/TextureMinificationFilter',
'../Renderer/TextureWrap',
'../Renderer/VertexArray',
'../Shaders/ReprojectWebMercatorFS',
'../Shaders/ReprojectWebMercatorVS',
'../ThirdParty/when',
'./Imagery',
'./ImageryState',
'./TileImagery'
], function(
Cartesian2,
Cartesian4,
defaultValue,
defined,
defineProperties,
destroyObject,
FeatureDetection,
GeographicTilingScheme,
IndexDatatype,
CesiumMath,
PixelFormat,
Rectangle,
TerrainProvider,
TileProviderError,
WebMercatorProjection,
WebMercatorTilingScheme,
Buffer,
BufferUsage,
ComputeCommand,
ContextLimits,
MipmapHint,
Sampler,
ShaderProgram,
ShaderSource,
Texture,
TextureMagnificationFilter,
TextureMinificationFilter,
TextureWrap,
VertexArray,
ReprojectWebMercatorFS,
ReprojectWebMercatorVS,
when,
Imagery,
ImageryState,
TileImagery) {
'use strict';
/**
* An imagery layer that displays tiled image data from a single imagery provider
* on a {@link Globe}.
*
* @alias ImageryLayer
* @constructor
*
* @param {ImageryProvider} imageryProvider The imagery provider to use.
* @param {Object} [options] Object with the following properties:
* @param {Rectangle} [options.rectangle=imageryProvider.rectangle] The rectangle of the layer. This rectangle
* can limit the visible portion of the imagery provider.
* @param {Number|Function} [options.alpha=1.0] The alpha blending value of this layer, from 0.0 to 1.0.
* This can either be a simple number or a function with the signature
* <code>function(frameState, layer, x, y, level)</code>. The function is passed the
* current frame state, this layer, and the x, y, and level coordinates of the
* imagery tile for which the alpha is required, and it is expected to return
* the alpha value to use for the tile.
* @param {Number|Function} [options.brightness=1.0] The brightness of this layer. 1.0 uses the unmodified imagery
* color. Less than 1.0 makes the imagery darker while greater than 1.0 makes it brighter.
* This can either be a simple number or a function with the signature
* <code>function(frameState, layer, x, y, level)</code>. The function is passed the
* current frame state, this layer, and the x, y, and level coordinates of the
* imagery tile for which the brightness is required, and it is expected to return
* the brightness value to use for the tile. The function is executed for every
* frame and for every tile, so it must be fast.
* @param {Number|Function} [options.contrast=1.0] The contrast of this layer. 1.0 uses the unmodified imagery color.
* Less than 1.0 reduces the contrast while greater than 1.0 increases it.
* This can either be a simple number or a function with the signature
* <code>function(frameState, layer, x, y, level)</code>. The function is passed the
* current frame state, this layer, and the x, y, and level coordinates of the
* imagery tile for which the contrast is required, and it is expected to return
* the contrast value to use for the tile. The function is executed for every
* frame and for every tile, so it must be fast.
* @param {Number|Function} [options.hue=0.0] The hue of this layer. 0.0 uses the unmodified imagery color.
* This can either be a simple number or a function with the signature
* <code>function(frameState, layer, x, y, level)</code>. The function is passed the
* current frame state, this layer, and the x, y, and level coordinates
* of the imagery tile for which the hue is required, and it is expected to return
* the contrast value to use for the tile. The function is executed for every
* frame and for every tile, so it must be fast.
* @param {Number|Function} [options.saturation=1.0] The saturation of this layer. 1.0 uses the unmodified imagery color.
* Less than 1.0 reduces the saturation while greater than 1.0 increases it.
* This can either be a simple number or a function with the signature
* <code>function(frameState, layer, x, y, level)</code>. The function is passed the
* current frame state, this layer, and the x, y, and level coordinates
* of the imagery tile for which the saturation is required, and it is expected to return
* the contrast value to use for the tile. The function is executed for every
* frame and for every tile, so it must be fast.
* @param {Number|Function} [options.gamma=1.0] The gamma correction to apply to this layer. 1.0 uses the unmodified imagery color.
* This can either be a simple number or a function with the signature
* <code>function(frameState, layer, x, y, level)</code>. The function is passed the
* current frame state, this layer, and the x, y, and level coordinates of the
* imagery tile for which the gamma is required, and it is expected to return
* the gamma value to use for the tile. The function is executed for every
* frame and for every tile, so it must be fast.
* @param {Boolean} [options.show=true] True if the layer is shown; otherwise, false.
* @param {Number} [options.maximumAnisotropy=maximum supported] The maximum anisotropy level to use
* for texture filtering. If this parameter is not specified, the maximum anisotropy supported
* by the WebGL stack will be used. Larger values make the imagery look better in horizon
* views.
* @param {Number} [options.minimumTerrainLevel] The minimum terrain level-of-detail at which to show this imagery layer,
* or undefined to show it at all levels. Level zero is the least-detailed level.
* @param {Number} [options.maximumTerrainLevel] The maximum terrain level-of-detail at which to show this imagery layer,
* or undefined to show it at all levels. Level zero is the least-detailed level.
*/
function ImageryLayer(imageryProvider, options) {
this._imageryProvider = imageryProvider;
options = defaultValue(options, {});
/**
* The alpha blending value of this layer, with 0.0 representing fully transparent and
* 1.0 representing fully opaque.
*
* @type {Number}
* @default 1.0
*/
this.alpha = defaultValue(options.alpha, defaultValue(imageryProvider.defaultAlpha, 1.0));
/**
* The brightness of this layer. 1.0 uses the unmodified imagery color. Less than 1.0
* makes the imagery darker while greater than 1.0 makes it brighter.
*
* @type {Number}
* @default {@link ImageryLayer.DEFAULT_BRIGHTNESS}
*/
this.brightness = defaultValue(options.brightness, defaultValue(imageryProvider.defaultBrightness, ImageryLayer.DEFAULT_BRIGHTNESS));
/**
* The contrast of this layer. 1.0 uses the unmodified imagery color. Less than 1.0 reduces
* the contrast while greater than 1.0 increases it.
*
* @type {Number}
* @default {@link ImageryLayer.DEFAULT_CONTRAST}
*/
this.contrast = defaultValue(options.contrast, defaultValue(imageryProvider.defaultContrast, ImageryLayer.DEFAULT_CONTRAST));
/**
* The hue of this layer in radians. 0.0 uses the unmodified imagery color.
*
* @type {Number}
* @default {@link ImageryLayer.DEFAULT_HUE}
*/
this.hue = defaultValue(options.hue, defaultValue(imageryProvider.defaultHue, ImageryLayer.DEFAULT_HUE));
/**
* The saturation of this layer. 1.0 uses the unmodified imagery color. Less than 1.0 reduces the
* saturation while greater than 1.0 increases it.
*
* @type {Number}
* @default {@link ImageryLayer.DEFAULT_SATURATION}
*/
this.saturation = defaultValue(options.saturation, defaultValue(imageryProvider.defaultSaturation, ImageryLayer.DEFAULT_SATURATION));
/**
* The gamma correction to apply to this layer. 1.0 uses the unmodified imagery color.
*
* @type {Number}
* @default {@link ImageryLayer.DEFAULT_GAMMA}
*/
this.gamma = defaultValue(options.gamma, defaultValue(imageryProvider.defaultGamma, ImageryLayer.DEFAULT_GAMMA));
/**
* Determines if this layer is shown.
*
* @type {Boolean}
* @default true
*/
this.show = defaultValue(options.show, true);
this._minimumTerrainLevel = options.minimumTerrainLevel;
this._maximumTerrainLevel = options.maximumTerrainLevel;
this._rectangle = defaultValue(options.rectangle, Rectangle.MAX_VALUE);
this._maximumAnisotropy = options.maximumAnisotropy;
this._imageryCache = {};
this._skeletonPlaceholder = new TileImagery(Imagery.createPlaceholder(this));
// The value of the show property on the last update.
this._show = true;
// The index of this layer in the ImageryLayerCollection.
this._layerIndex = -1;
// true if this is the base (lowest shown) layer.
this._isBaseLayer = false;
this._requestImageError = undefined;
this._reprojectComputeCommands = [];
}
defineProperties(ImageryLayer.prototype, {
/**
* Gets the imagery provider for this layer.
* @memberof ImageryLayer.prototype
* @type {ImageryProvider}
* @readonly
*/
imageryProvider : {
get: function() {
return this._imageryProvider;
}
},
/**
* Gets the rectangle of this layer. If this rectangle is smaller than the rectangle of the
* {@link ImageryProvider}, only a portion of the imagery provider is shown.
* @memberof ImageryLayer.prototype
* @type {Rectangle}
* @readonly
*/
rectangle: {
get: function() {
return this._rectangle;
}
}
});
/**
* This value is used as the default brightness for the imagery layer if one is not provided during construction
* or by the imagery provider. This value does not modify the brightness of the imagery.
* @type {Number}
* @default 1.0
*/
ImageryLayer.DEFAULT_BRIGHTNESS = 1.0;
/**
* This value is used as the default contrast for the imagery layer if one is not provided during construction
* or by the imagery provider. This value does not modify the contrast of the imagery.
* @type {Number}
* @default 1.0
*/
ImageryLayer.DEFAULT_CONTRAST = 1.0;
/**
* This value is used as the default hue for the imagery layer if one is not provided during construction
* or by the imagery provider. This value does not modify the hue of the imagery.
* @type {Number}
* @default 0.0
*/
ImageryLayer.DEFAULT_HUE = 0.0;
/**
* This value is used as the default saturation for the imagery layer if one is not provided during construction
* or by the imagery provider. This value does not modify the saturation of the imagery.
* @type {Number}
* @default 1.0
*/
ImageryLayer.DEFAULT_SATURATION = 1.0;
/**
* This value is used as the default gamma for the imagery layer if one is not provided during construction
* or by the imagery provider. This value does not modify the gamma of the imagery.
* @type {Number}
* @default 1.0
*/
ImageryLayer.DEFAULT_GAMMA = 1.0;
/**
* Gets a value indicating whether this layer is the base layer in the
* {@link ImageryLayerCollection}. The base layer is the one that underlies all
* others. It is special in that it is treated as if it has global rectangle, even if
* it actually does not, by stretching the texels at the edges over the entire
* globe.
*
* @returns {Boolean} true if this is the base layer; otherwise, false.
*/
ImageryLayer.prototype.isBaseLayer = function() {
return this._isBaseLayer;
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see ImageryLayer#destroy
*/
ImageryLayer.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* imageryLayer = imageryLayer && imageryLayer.destroy();
*
* @see ImageryLayer#isDestroyed
*/
ImageryLayer.prototype.destroy = function() {
return destroyObject(this);
};
var imageryBoundsScratch = new Rectangle();
var tileImageryBoundsScratch = new Rectangle();
var clippedRectangleScratch = new Rectangle();
var terrainRectangleScratch = new Rectangle();
/**
* Computes the intersection of this layer's rectangle with the imagery provider's availability rectangle,
* producing the overall bounds of imagery that can be produced by this layer.
*
* @returns {Promise.<Rectangle>} A promise to a rectangle which defines the overall bounds of imagery that can be produced by this layer.
*
* @example
* // Zoom to an imagery layer.
* imageryLayer.getViewableRectangle().then(function (rectangle) {
* return camera.flyTo({
* destination: rectangle
* });
* });
*/
ImageryLayer.prototype.getViewableRectangle = function() {
var imageryProvider = this._imageryProvider;
var rectangle = this._rectangle;
return imageryProvider.readyPromise.then(function() {
return Rectangle.intersection(imageryProvider.rectangle, rectangle);
});
};
/**
* Create skeletons for the imagery tiles that partially or completely overlap a given terrain
* tile.
*
* @private
*
* @param {Tile} tile The terrain tile.
* @param {TerrainProvider} terrainProvider The terrain provider associated with the terrain tile.
* @param {Number} insertionPoint The position to insert new skeletons before in the tile's imagery list.
* @returns {Boolean} true if this layer overlaps any portion of the terrain tile; otherwise, false.
*/
ImageryLayer.prototype._createTileImagerySkeletons = function(tile, terrainProvider, insertionPoint) {
var surfaceTile = tile.data;
if (defined(this._minimumTerrainLevel) && tile.level < this._minimumTerrainLevel) {
return false;
}
if (defined(this._maximumTerrainLevel) && tile.level > this._maximumTerrainLevel) {
return false;
}
var imageryProvider = this._imageryProvider;
if (!defined(insertionPoint)) {
insertionPoint = surfaceTile.imagery.length;
}
if (!imageryProvider.ready) {
// The imagery provider is not ready, so we can't create skeletons, yet.
// Instead, add a placeholder so that we'll know to create
// the skeletons once the provider is ready.
this._skeletonPlaceholder.loadingImagery.addReference();
surfaceTile.imagery.splice(insertionPoint, 0, this._skeletonPlaceholder);
return true;
}
// Use Web Mercator for our texture coordinate computations if this imagery layer uses
// that projection and the terrain tile falls entirely inside the valid bounds of the
// projection.
var useWebMercatorT = imageryProvider.tilingScheme instanceof WebMercatorTilingScheme &&
tile.rectangle.north < WebMercatorProjection.MaximumLatitude &&
tile.rectangle.south > -WebMercatorProjection.MaximumLatitude;
// Compute the rectangle of the imagery from this imageryProvider that overlaps
// the geometry tile. The ImageryProvider and ImageryLayer both have the
// opportunity to constrain the rectangle. The imagery TilingScheme's rectangle
// always fully contains the ImageryProvider's rectangle.
var imageryBounds = Rectangle.intersection(imageryProvider.rectangle, this._rectangle, imageryBoundsScratch);
var rectangle = Rectangle.intersection(tile.rectangle, imageryBounds, tileImageryBoundsScratch);
if (!defined(rectangle)) {
// There is no overlap between this terrain tile and this imagery
// provider. Unless this is the base layer, no skeletons need to be created.
// We stretch texels at the edge of the base layer over the entire globe.
if (!this.isBaseLayer()) {
return false;
}
var baseImageryRectangle = imageryBounds;
var baseTerrainRectangle = tile.rectangle;
rectangle = tileImageryBoundsScratch;
if (baseTerrainRectangle.south >= baseImageryRectangle.north) {
rectangle.north = rectangle.south = baseImageryRectangle.north;
} else if (baseTerrainRectangle.north <= baseImageryRectangle.south) {
rectangle.north = rectangle.south = baseImageryRectangle.south;
} else {
rectangle.south = Math.max(baseTerrainRectangle.south, baseImageryRectangle.south);
rectangle.north = Math.min(baseTerrainRectangle.north, baseImageryRectangle.north);
}
if (baseTerrainRectangle.west >= baseImageryRectangle.east) {
rectangle.west = rectangle.east = baseImageryRectangle.east;
} else if (baseTerrainRectangle.east <= baseImageryRectangle.west) {
rectangle.west = rectangle.east = baseImageryRectangle.west;
} else {
rectangle.west = Math.max(baseTerrainRectangle.west, baseImageryRectangle.west);
rectangle.east = Math.min(baseTerrainRectangle.east, baseImageryRectangle.east);
}
}
var latitudeClosestToEquator = 0.0;
if (rectangle.south > 0.0) {
latitudeClosestToEquator = rectangle.south;
} else if (rectangle.north < 0.0) {
latitudeClosestToEquator = rectangle.north;
}
// Compute the required level in the imagery tiling scheme.
// The errorRatio should really be imagerySSE / terrainSSE rather than this hard-coded value.
// But first we need configurable imagery SSE and we need the rendering to be able to handle more
// images attached to a terrain tile than there are available texture units. So that's for the future.
var errorRatio = 1.0;
var targetGeometricError = errorRatio * terrainProvider.getLevelMaximumGeometricError(tile.level);
var imageryLevel = getLevelWithMaximumTexelSpacing(this, targetGeometricError, latitudeClosestToEquator);
imageryLevel = Math.max(0, imageryLevel);
var maximumLevel = imageryProvider.maximumLevel;
if (imageryLevel > maximumLevel) {
imageryLevel = maximumLevel;
}
if (defined(imageryProvider.minimumLevel)) {
var minimumLevel = imageryProvider.minimumLevel;
if (imageryLevel < minimumLevel) {
imageryLevel = minimumLevel;
}
}
var imageryTilingScheme = imageryProvider.tilingScheme;
var northwestTileCoordinates = imageryTilingScheme.positionToTileXY(Rectangle.northwest(rectangle), imageryLevel);
var southeastTileCoordinates = imageryTilingScheme.positionToTileXY(Rectangle.southeast(rectangle), imageryLevel);
// If the southeast corner of the rectangle lies very close to the north or west side
// of the southeast tile, we don't actually need the southernmost or easternmost
// tiles.
// Similarly, if the northwest corner of the rectangle lies very close to the south or east side
// of the northwest tile, we don't actually need the northernmost or westernmost tiles.
// We define "very close" as being within 1/512 of the width of the tile.
var veryCloseX = tile.rectangle.width / 512.0;
var veryCloseY = tile.rectangle.height / 512.0;
var northwestTileRectangle = imageryTilingScheme.tileXYToRectangle(northwestTileCoordinates.x, northwestTileCoordinates.y, imageryLevel);
if (Math.abs(northwestTileRectangle.south - tile.rectangle.north) < veryCloseY && northwestTileCoordinates.y < southeastTileCoordinates.y) {
++northwestTileCoordinates.y;
}
if (Math.abs(northwestTileRectangle.east - tile.rectangle.west) < veryCloseX && northwestTileCoordinates.x < southeastTileCoordinates.x) {
++northwestTileCoordinates.x;
}
var southeastTileRectangle = imageryTilingScheme.tileXYToRectangle(southeastTileCoordinates.x, southeastTileCoordinates.y, imageryLevel);
if (Math.abs(southeastTileRectangle.north - tile.rectangle.south) < veryCloseY && southeastTileCoordinates.y > northwestTileCoordinates.y) {
--southeastTileCoordinates.y;
}
if (Math.abs(southeastTileRectangle.west - tile.rectangle.east) < veryCloseX && southeastTileCoordinates.x > northwestTileCoordinates.x) {
--southeastTileCoordinates.x;
}
// Create TileImagery instances for each imagery tile overlapping this terrain tile.
// We need to do all texture coordinate computations in the imagery tile's tiling scheme.
var terrainRectangle = Rectangle.clone(tile.rectangle, terrainRectangleScratch);
var imageryRectangle = imageryTilingScheme.tileXYToRectangle(northwestTileCoordinates.x, northwestTileCoordinates.y, imageryLevel);
var clippedImageryRectangle = Rectangle.intersection(imageryRectangle, imageryBounds, clippedRectangleScratch);
var imageryTileXYToRectangle;
if (useWebMercatorT) {
imageryTilingScheme.rectangleToNativeRectangle(terrainRectangle, terrainRectangle);
imageryTilingScheme.rectangleToNativeRectangle(imageryRectangle, imageryRectangle);
imageryTilingScheme.rectangleToNativeRectangle(clippedImageryRectangle, clippedImageryRectangle);
imageryTilingScheme.rectangleToNativeRectangle(imageryBounds, imageryBounds);
imageryTileXYToRectangle = imageryTilingScheme.tileXYToNativeRectangle.bind(imageryTilingScheme);
veryCloseX = terrainRectangle.width / 512.0;
veryCloseY = terrainRectangle.height / 512.0;
} else {
imageryTileXYToRectangle = imageryTilingScheme.tileXYToRectangle.bind(imageryTilingScheme);
}
var minU;
var maxU = 0.0;
var minV = 1.0;
var maxV;
// If this is the northern-most or western-most tile in the imagery tiling scheme,
// it may not start at the northern or western edge of the terrain tile.
// Calculate where it does start.
if (!this.isBaseLayer() && Math.abs(clippedImageryRectangle.west - terrainRectangle.west) >= veryCloseX) {
maxU = Math.min(1.0, (clippedImageryRectangle.west - terrainRectangle.west) / terrainRectangle.width);
}
if (!this.isBaseLayer() && Math.abs(clippedImageryRectangle.north - terrainRectangle.north) >= veryCloseY) {
minV = Math.max(0.0, (clippedImageryRectangle.north - terrainRectangle.south) / terrainRectangle.height);
}
var initialMinV = minV;
for ( var i = northwestTileCoordinates.x; i <= southeastTileCoordinates.x; i++) {
minU = maxU;
imageryRectangle = imageryTileXYToRectangle(i, northwestTileCoordinates.y, imageryLevel);
clippedImageryRectangle = Rectangle.simpleIntersection(imageryRectangle, imageryBounds, clippedRectangleScratch);
if (!defined(clippedImageryRectangle)) {
continue;
}
maxU = Math.min(1.0, (clippedImageryRectangle.east - terrainRectangle.west) / terrainRectangle.width);
// If this is the eastern-most imagery tile mapped to this terrain tile,
// and there are more imagery tiles to the east of this one, the maxU
// should be 1.0 to make sure rounding errors don't make the last
// image fall shy of the edge of the terrain tile.
if (i === southeastTileCoordinates.x && (this.isBaseLayer() || Math.abs(clippedImageryRectangle.east - terrainRectangle.east) < veryCloseX)) {
maxU = 1.0;
}
minV = initialMinV;
for ( var j = northwestTileCoordinates.y; j <= southeastTileCoordinates.y; j++) {
maxV = minV;
imageryRectangle = imageryTileXYToRectangle(i, j, imageryLevel);
clippedImageryRectangle = Rectangle.simpleIntersection(imageryRectangle, imageryBounds, clippedRectangleScratch);
if (!defined(clippedImageryRectangle)) {
continue;
}
minV = Math.max(0.0, (clippedImageryRectangle.south - terrainRectangle.south) / terrainRectangle.height);
// If this is the southern-most imagery tile mapped to this terrain tile,
// and there are more imagery tiles to the south of this one, the minV
// should be 0.0 to make sure rounding errors don't make the last
// image fall shy of the edge of the terrain tile.
if (j === southeastTileCoordinates.y && (this.isBaseLayer() || Math.abs(clippedImageryRectangle.south - terrainRectangle.south) < veryCloseY)) {
minV = 0.0;
}
var texCoordsRectangle = new Cartesian4(minU, minV, maxU, maxV);
var imagery = this.getImageryFromCache(i, j, imageryLevel);
surfaceTile.imagery.splice(insertionPoint, 0, new TileImagery(imagery, texCoordsRectangle, useWebMercatorT));
++insertionPoint;
}
}
return true;
};
/**
* Calculate the translation and scale for a particular {@link TileImagery} attached to a
* particular terrain tile.
*
* @private
*
* @param {Tile} tile The terrain tile.
* @param {TileImagery} tileImagery The imagery tile mapping.
* @returns {Cartesian4} The translation and scale where X and Y are the translation and Z and W
* are the scale.
*/
ImageryLayer.prototype._calculateTextureTranslationAndScale = function(tile, tileImagery) {
var imageryRectangle = tileImagery.readyImagery.rectangle;
var terrainRectangle = tile.rectangle;
if (tileImagery.useWebMercatorT) {
var tilingScheme = tileImagery.readyImagery.imageryLayer.imageryProvider.tilingScheme;
imageryRectangle = tilingScheme.rectangleToNativeRectangle(imageryRectangle, imageryBoundsScratch);
terrainRectangle = tilingScheme.rectangleToNativeRectangle(terrainRectangle, terrainRectangleScratch);
}
var terrainWidth = terrainRectangle.width;
var terrainHeight = terrainRectangle.height;
var scaleX = terrainWidth / imageryRectangle.width;
var scaleY = terrainHeight / imageryRectangle.height;
return new Cartesian4(
scaleX * (terrainRectangle.west - imageryRectangle.west) / terrainWidth,
scaleY * (terrainRectangle.south - imageryRectangle.south) / terrainHeight,
scaleX,
scaleY);
};
/**
* Request a particular piece of imagery from the imagery provider. This method handles raising an
* error event if the request fails, and retrying the request if necessary.
*
* @private
*
* @param {Imagery} imagery The imagery to request.
*/
ImageryLayer.prototype._requestImagery = function(imagery) {
var imageryProvider = this._imageryProvider;
var that = this;
function success(image) {
if (!defined(image)) {
return failure();
}
imagery.image = image;
imagery.state = ImageryState.RECEIVED;
TileProviderError.handleSuccess(that._requestImageError);
}
function failure(e) {
// Initially assume failure. handleError may retry, in which case the state will
// change to TRANSITIONING.
imagery.state = ImageryState.FAILED;
var message = 'Failed to obtain image tile X: ' + imagery.x + ' Y: ' + imagery.y + ' Level: ' + imagery.level + '.';
that._requestImageError = TileProviderError.handleError(
that._requestImageError,
imageryProvider,
imageryProvider.errorEvent,
message,
imagery.x, imagery.y, imagery.level,
doRequest,
e);
}
function doRequest() {
imagery.state = ImageryState.TRANSITIONING;
var imagePromise = imageryProvider.requestImage(imagery.x, imagery.y, imagery.level);
if (!defined(imagePromise)) {
// Too many parallel requests, so postpone loading tile.
imagery.state = ImageryState.UNLOADED;
return;
}
if (defined(imageryProvider.getTileCredits)) {
imagery.credits = imageryProvider.getTileCredits(imagery.x, imagery.y, imagery.level);
}
when(imagePromise, success, failure);
}
doRequest();
};
/**
* Create a WebGL texture for a given {@link Imagery} instance.
*
* @private
*
* @param {Context} context The rendered context to use to create textures.
* @param {Imagery} imagery The imagery for which to create a texture.
*/
ImageryLayer.prototype._createTexture = function(context, imagery) {
var imageryProvider = this._imageryProvider;
// If this imagery provider has a discard policy, use it to check if this
// image should be discarded.
if (defined(imageryProvider.tileDiscardPolicy)) {
var discardPolicy = imageryProvider.tileDiscardPolicy;
if (defined(discardPolicy)) {
// If the discard policy is not ready yet, transition back to the
// RECEIVED state and we'll try again next time.
if (!discardPolicy.isReady()) {
imagery.state = ImageryState.RECEIVED;
return;
}
// Mark discarded imagery tiles invalid. Parent imagery will be used instead.
if (discardPolicy.shouldDiscardImage(imagery.image)) {
imagery.state = ImageryState.INVALID;
return;
}
}
}
// Imagery does not need to be discarded, so upload it to WebGL.
var texture = new Texture({
context : context,
source : imagery.image,
pixelFormat : imageryProvider.hasAlphaChannel ? PixelFormat.RGBA : PixelFormat.RGB
});
if (imageryProvider.tilingScheme instanceof WebMercatorTilingScheme) {
imagery.textureWebMercator = texture;
} else {
imagery.texture = texture;
}
imagery.image = undefined;
imagery.state = ImageryState.TEXTURE_LOADED;
};
function finalizeReprojectTexture(imageryLayer, context, imagery, texture) {
// Use mipmaps if this texture has power-of-two dimensions.
if (CesiumMath.isPowerOfTwo(texture.width) && CesiumMath.isPowerOfTwo(texture.height)) {
var mipmapSampler = context.cache.imageryLayer_mipmapSampler;
if (!defined(mipmapSampler)) {
var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;
mipmapSampler = context.cache.imageryLayer_mipmapSampler = new Sampler({
wrapS : TextureWrap.CLAMP_TO_EDGE,
wrapT : TextureWrap.CLAMP_TO_EDGE,
minificationFilter : TextureMinificationFilter.LINEAR_MIPMAP_LINEAR,
magnificationFilter : TextureMagnificationFilter.LINEAR,
maximumAnisotropy : Math.min(maximumSupportedAnisotropy, defaultValue(imageryLayer._maximumAnisotropy, maximumSupportedAnisotropy))
});
}
texture.generateMipmap(MipmapHint.NICEST);
texture.sampler = mipmapSampler;
} else {
var nonMipmapSampler = context.cache.imageryLayer_nonMipmapSampler;
if (!defined(nonMipmapSampler)) {
nonMipmapSampler = context.cache.imageryLayer_nonMipmapSampler = new Sampler({
wrapS : TextureWrap.CLAMP_TO_EDGE,
wrapT : TextureWrap.CLAMP_TO_EDGE,
minificationFilter : TextureMinificationFilter.LINEAR,
magnificationFilter : TextureMagnificationFilter.LINEAR
});
}
texture.sampler = nonMipmapSampler;
}
imagery.state = ImageryState.READY;
}
/**
* Enqueues a command re-projecting a texture to a {@link GeographicProjection} on the next update, if necessary, and generate
* mipmaps for the geographic texture.
*
* @private
*
* @param {FrameState} frameState The frameState.
* @param {Imagery} imagery The imagery instance to reproject.
* @param {Boolean} [needGeographicProjection=true] True to reproject to geographic, or false if Web Mercator is fine.
*/
ImageryLayer.prototype._reprojectTexture = function(frameState, imagery, needGeographicProjection) {
var texture = imagery.textureWebMercator || imagery.texture;
var rectangle = imagery.rectangle;
var context = frameState.context;
needGeographicProjection = defaultValue(needGeographicProjection, true);
// Reproject this texture if it is not already in a geographic projection and
// the pixels are more than 1e-5 radians apart. The pixel spacing cutoff
// avoids precision problems in the reprojection transformation while making
// no noticeable difference in the georeferencing of the image.
if (needGeographicProjection &&
!(this._imageryProvider.tilingScheme instanceof GeographicTilingScheme) &&
rectangle.width / texture.width > 1e-5) {
var that = this;
imagery.addReference();
var computeCommand = new ComputeCommand({
persists : true,
owner : this,
// Update render resources right before execution instead of now.
// This allows different ImageryLayers to share the same vao and buffers.
preExecute : function(command) {
reprojectToGeographic(command, context, texture, imagery.rectangle);
},
postExecute : function(outputTexture) {
imagery.texture = outputTexture;
finalizeReprojectTexture(that, context, imagery, outputTexture);
imagery.releaseReference();
}
});
this._reprojectComputeCommands.push(computeCommand);
} else {
if (needGeographicProjection) {
imagery.texture = texture;
}
finalizeReprojectTexture(this, context, imagery, texture);
}
};
/**
* Updates frame state to execute any queued texture re-projections.
*
* @private
*
* @param {FrameState} frameState The frameState.
*/
ImageryLayer.prototype.queueReprojectionCommands = function(frameState) {
var computeCommands = this._reprojectComputeCommands;
var length = computeCommands.length;
for (var i = 0; i < length; ++i) {
frameState.commandList.push(computeCommands[i]);
}
computeCommands.length = 0;
};
/**
* Cancels re-projection commands queued for the next frame.
*
* @private
*/
ImageryLayer.prototype.cancelReprojections = function() {
this._reprojectComputeCommands.length = 0;
};
ImageryLayer.prototype.getImageryFromCache = function(x, y, level, imageryRectangle) {
var cacheKey = getImageryCacheKey(x, y, level);
var imagery = this._imageryCache[cacheKey];
if (!defined(imagery)) {
imagery = new Imagery(this, x, y, level, imageryRectangle);
this._imageryCache[cacheKey] = imagery;
}
imagery.addReference();
return imagery;
};
ImageryLayer.prototype.removeImageryFromCache = function(imagery) {
var cacheKey = getImageryCacheKey(imagery.x, imagery.y, imagery.level);
delete this._imageryCache[cacheKey];
};
function getImageryCacheKey(x, y, level) {
return JSON.stringify([x, y, level]);
}
var uniformMap = {
u_textureDimensions : function() {
return this.textureDimensions;
},
u_texture : function() {
return this.texture;
},
textureDimensions : new Cartesian2(),
texture : undefined
};
var float32ArrayScratch = FeatureDetection.supportsTypedArrays() ? new Float32Array(2 * 64) : undefined;
function reprojectToGeographic(command, context, texture, rectangle) {
// This function has gone through a number of iterations, because GPUs are awesome.
//
// Originally, we had a very simple vertex shader and computed the Web Mercator texture coordinates
// per-fragment in the fragment shader. That worked well, except on mobile devices, because
// fragment shaders have limited precision on many mobile devices. The result was smearing artifacts
// at medium zoom levels because different geographic texture coordinates would be reprojected to Web
// Mercator as the same value.
//
// Our solution was to reproject to Web Mercator in the vertex shader instead of the fragment shader.
// This required far more vertex data. With fragment shader reprojection, we only needed a single quad.
// But to achieve the same precision with vertex shader reprojection, we needed a vertex for each
// output pixel. So we used a grid of 256x256 vertices, because most of our imagery
// tiles are 256x256. Fortunately the grid could be created and uploaded to the GPU just once and
// re-used for all reprojections, so the performance was virtually unchanged from our original fragment
// shader approach. See https://github.com/AnalyticalGraphicsInc/cesium/pull/714.
//
// Over a year later, we noticed (https://github.com/AnalyticalGraphicsInc/cesium/issues/2110)
// that our reprojection code was creating a rare but severe artifact on some GPUs (Intel HD 4600
// for one). The problem was that the GLSL sin function on these GPUs had a discontinuity at fine scales in
// a few places.
//
// We solved this by implementing a more reliable sin function based on the CORDIC algorithm
// (https://github.com/AnalyticalGraphicsInc/cesium/pull/2111). Even though this was a fair
// amount of code to be executing per vertex, the performance seemed to be pretty good on most GPUs.
// Unfortunately, on some GPUs, the performance was absolutely terrible
// (https://github.com/AnalyticalGraphicsInc/cesium/issues/2258).
//
// So that brings us to our current solution, the one you see here. Effectively, we compute the Web
// Mercator texture coordinates on the CPU and store the T coordinate with each vertex (the S coordinate
// is the same in Geographic and Web Mercator). To make this faster, we reduced our reprojection mesh
// to be only 2 vertices wide and 64 vertices high. We should have reduced the width to 2 sooner,
// because the extra vertices weren't buying us anything. The height of 64 means we are technically
// doing a slightly less accurate reprojection than we were before, but we can't see the difference
// so it's worth the 4x speedup.
var reproject = context.cache.imageryLayer_reproject;
if (!defined(reproject)) {
reproject = context.cache.imageryLayer_reproject = {
vertexArray : undefined,
shaderProgram : undefined,
sampler : undefined,
destroy : function() {
if (defined(this.framebuffer)) {
this.framebuffer.destroy();
}
if (defined(this.vertexArray)) {
this.vertexArray.destroy();
}
if (defined(this.shaderProgram)) {
this.shaderProgram.destroy();
}
}
};
var positions = new Float32Array(2 * 64 * 2);
var index = 0;
for (var j = 0; j < 64; ++j) {
var y = j / 63.0;
positions[index++] = 0.0;
positions[index++] = y;
positions[index++] = 1.0;
positions[index++] = y;
}
var reprojectAttributeIndices = {
position : 0,
webMercatorT : 1
};
var indices = TerrainProvider.getRegularGridIndices(2, 64);
var indexBuffer = Buffer.createIndexBuffer({
context : context,
typedArray : indices,
usage : BufferUsage.STATIC_DRAW,
indexDatatype : IndexDatatype.UNSIGNED_SHORT
});
reproject.vertexArray = new VertexArray({
context : context,
attributes : [{
index : reprojectAttributeIndices.position,
vertexBuffer : Buffer.createVertexBuffer({
context : context,
typedArray : positions,
usage : BufferUsage.STATIC_DRAW
}),
componentsPerAttribute : 2
},{
index : reprojectAttributeIndices.webMercatorT,
vertexBuffer : Buffer.createVertexBuffer({
context : context,
sizeInBytes : 64 * 2 * 4,
usage : BufferUsage.STREAM_DRAW
}),
componentsPerAttribute : 1
}],
indexBuffer : indexBuffer
});
var vs = new ShaderSource({
sources : [ReprojectWebMercatorVS]
});
reproject.shaderProgram = ShaderProgram.fromCache({
context : context,
vertexShaderSource : vs,
fragmentShaderSource : ReprojectWebMercatorFS,
attributeLocations : reprojectAttributeIndices
});
reproject.sampler = new Sampler({
wrapS : TextureWrap.CLAMP_TO_EDGE,
wrapT : TextureWrap.CLAMP_TO_EDGE,
minificationFilter : TextureMinificationFilter.LINEAR,
magnificationFilter : TextureMagnificationFilter.LINEAR
});
}
texture.sampler = reproject.sampler;
var width = texture.width;
var height = texture.height;
uniformMap.textureDimensions.x = width;
uniformMap.textureDimensions.y = height;
uniformMap.texture = texture;
var sinLatitude = Math.sin(rectangle.south);
var southMercatorY = 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
sinLatitude = Math.sin(rectangle.north);
var northMercatorY = 0.5 * Math.log((1 + sinLatitude) / (1 - sinLatitude));
var oneOverMercatorHeight = 1.0 / (northMercatorY - southMercatorY);
var outputTexture = new Texture({
context : context,
width : width,
height : height,
pixelFormat : texture.pixelFormat,
pixelDatatype : texture.pixelDatatype,
preMultiplyAlpha : texture.preMultiplyAlpha
});
// Allocate memory for the mipmaps. Failure to do this before rendering
// to the texture via the FBO, and calling generateMipmap later,
// will result in the texture appearing blank. I can't pretend to
// understand exactly why this is.
if (CesiumMath.isPowerOfTwo(width) && CesiumMath.isPowerOfTwo(height)) {
outputTexture.generateMipmap(MipmapHint.NICEST);
}
var south = rectangle.south;
var north = rectangle.north;
var webMercatorT = float32ArrayScratch;
var outputIndex = 0;
for (var webMercatorTIndex = 0; webMercatorTIndex < 64; ++webMercatorTIndex) {
var fraction = webMercatorTIndex / 63.0;
var latitude = CesiumMath.lerp(south, north, fraction);
sinLatitude = Math.sin(latitude);
var mercatorY = 0.5 * Math.log((1.0 + sinLatitude) / (1.0 - sinLatitude));
var mercatorFraction = (mercatorY - southMercatorY) * oneOverMercatorHeight;
webMercatorT[outputIndex++] = mercatorFraction;
webMercatorT[outputIndex++] = mercatorFraction;
}
reproject.vertexArray.getAttribute(1).vertexBuffer.copyFromArrayView(webMercatorT);
command.shaderProgram = reproject.shaderProgram;
command.outputTexture = outputTexture;
command.uniformMap = uniformMap;
command.vertexArray = reproject.vertexArray;
}
/**
* Gets the level with the specified world coordinate spacing between texels, or less.
*
* @param {Number} texelSpacing The texel spacing for which to find a corresponding level.
* @param {Number} latitudeClosestToEquator The latitude closest to the equator that we're concerned with.
* @returns {Number} The level with the specified texel spacing or less.
*/
function getLevelWithMaximumTexelSpacing(layer, texelSpacing, latitudeClosestToEquator) {
// PERFORMANCE_IDEA: factor out the stuff that doesn't change.
var imageryProvider = layer._imageryProvider;
var tilingScheme = imageryProvider.tilingScheme;
var ellipsoid = tilingScheme.ellipsoid;
var latitudeFactor = !(layer._imageryProvider.tilingScheme instanceof GeographicTilingScheme) ? Math.cos(latitudeClosestToEquator) : 1.0;
var tilingSchemeRectangle = tilingScheme.rectangle;
var levelZeroMaximumTexelSpacing = ellipsoid.maximumRadius * tilingSchemeRectangle.width * latitudeFactor / (imageryProvider.tileWidth * tilingScheme.getNumberOfXTilesAtLevel(0));
var twoToTheLevelPower = levelZeroMaximumTexelSpacing / texelSpacing;
var level = Math.log(twoToTheLevelPower) / Math.log(2);
var rounded = Math.round(level);
return rounded | 0;
}
return ImageryLayer;
});
/*global define*/
define('Scene/GlobeSurfaceTileProvider',[
'../Core/BoundingSphere',
'../Core/BoxOutlineGeometry',
'../Core/Cartesian2',
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/Color',
'../Core/ColorGeometryInstanceAttribute',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/Event',
'../Core/GeometryInstance',
'../Core/GeometryPipeline',
'../Core/IndexDatatype',
'../Core/Intersect',
'../Core/Math',
'../Core/Matrix4',
'../Core/OrientedBoundingBox',
'../Core/PrimitiveType',
'../Core/Rectangle',
'../Core/SphereOutlineGeometry',
'../Core/TerrainQuantization',
'../Core/Visibility',
'../Core/WebMercatorProjection',
'../Renderer/Buffer',
'../Renderer/BufferUsage',
'../Renderer/ContextLimits',
'../Renderer/DrawCommand',
'../Renderer/Pass',
'../Renderer/RenderState',
'../Renderer/VertexArray',
'../Scene/BlendingState',
'../Scene/DepthFunction',
'../Scene/PerInstanceColorAppearance',
'../Scene/Primitive',
'./GlobeSurfaceTile',
'./ImageryLayer',
'./QuadtreeTileLoadState',
'./SceneMode',
'./ShadowMode'
], function(
BoundingSphere,
BoxOutlineGeometry,
Cartesian2,
Cartesian3,
Cartesian4,
Color,
ColorGeometryInstanceAttribute,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
Event,
GeometryInstance,
GeometryPipeline,
IndexDatatype,
Intersect,
CesiumMath,
Matrix4,
OrientedBoundingBox,
PrimitiveType,
Rectangle,
SphereOutlineGeometry,
TerrainQuantization,
Visibility,
WebMercatorProjection,
Buffer,
BufferUsage,
ContextLimits,
DrawCommand,
Pass,
RenderState,
VertexArray,
BlendingState,
DepthFunction,
PerInstanceColorAppearance,
Primitive,
GlobeSurfaceTile,
ImageryLayer,
QuadtreeTileLoadState,
SceneMode,
ShadowMode) {
'use strict';
/**
* Provides quadtree tiles representing the surface of the globe. This type is intended to be used
* with {@link QuadtreePrimitive}.
*
* @alias GlobeSurfaceTileProvider
* @constructor
*
* @param {TerrainProvider} options.terrainProvider The terrain provider that describes the surface geometry.
* @param {ImageryLayerCollection} option.imageryLayers The collection of imagery layers describing the shading of the surface.
* @param {GlobeSurfaceShaderSet} options.surfaceShaderSet The set of shaders used to render the surface.
*
* @private
*/
function GlobeSurfaceTileProvider(options) {
if (!defined(options)) {
throw new DeveloperError('options is required.');
}
if (!defined(options.terrainProvider)) {
throw new DeveloperError('options.terrainProvider is required.');
} else if (!defined(options.imageryLayers)) {
throw new DeveloperError('options.imageryLayers is required.');
} else if (!defined(options.surfaceShaderSet)) {
throw new DeveloperError('options.surfaceShaderSet is required.');
}
this.lightingFadeOutDistance = 6500000.0;
this.lightingFadeInDistance = 9000000.0;
this.hasWaterMask = false;
this.oceanNormalMap = undefined;
this.zoomedOutOceanSpecularIntensity = 0.5;
this.enableLighting = false;
this.shadows = ShadowMode.RECEIVE_ONLY;
this._quadtree = undefined;
this._terrainProvider = options.terrainProvider;
this._imageryLayers = options.imageryLayers;
this._surfaceShaderSet = options.surfaceShaderSet;
this._renderState = undefined;
this._blendRenderState = undefined;
this._pickRenderState = undefined;
this._errorEvent = new Event();
this._imageryLayers.layerAdded.addEventListener(GlobeSurfaceTileProvider.prototype._onLayerAdded, this);
this._imageryLayers.layerRemoved.addEventListener(GlobeSurfaceTileProvider.prototype._onLayerRemoved, this);
this._imageryLayers.layerMoved.addEventListener(GlobeSurfaceTileProvider.prototype._onLayerMoved, this);
this._imageryLayers.layerShownOrHidden.addEventListener(GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden, this);
this._layerOrderChanged = false;
this._tilesToRenderByTextureCount = [];
this._drawCommands = [];
this._uniformMaps = [];
this._pickCommands = [];
this._usedDrawCommands = 0;
this._usedPickCommands = 0;
this._vertexArraysToDestroy = [];
this._debug = {
wireframe : false,
boundingSphereTile : undefined
};
this._baseColor = undefined;
this._firstPassInitialColor = undefined;
this.baseColor = new Color(0.0, 0.0, 0.5, 1.0);
}
defineProperties(GlobeSurfaceTileProvider.prototype, {
/**
* Gets or sets the color of the globe when no imagery is available.
* @memberof GlobeSurfaceTileProvider.prototype
* @type {Color}
*/
baseColor : {
get : function() {
return this._baseColor;
},
set : function(value) {
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
this._baseColor = value;
this._firstPassInitialColor = Cartesian4.fromColor(value, this._firstPassInitialColor);
}
},
/**
* Gets or sets the {@link QuadtreePrimitive} for which this provider is
* providing tiles. This property may be undefined if the provider is not yet associated
* with a {@link QuadtreePrimitive}.
* @memberof GlobeSurfaceTileProvider.prototype
* @type {QuadtreePrimitive}
*/
quadtree : {
get : function() {
return this._quadtree;
},
set : function(value) {
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
this._quadtree = value;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof GlobeSurfaceTileProvider.prototype
* @type {Boolean}
*/
ready : {
get : function() {
return this._terrainProvider.ready && (this._imageryLayers.length === 0 || this._imageryLayers.get(0).imageryProvider.ready);
}
},
/**
* Gets the tiling scheme used by the provider. This property should
* not be accessed before {@link GlobeSurfaceTileProvider#ready} returns true.
* @memberof GlobeSurfaceTileProvider.prototype
* @type {TilingScheme}
*/
tilingScheme : {
get : function() {
return this._terrainProvider.tilingScheme;
}
},
/**
* Gets an event that is raised when the geometry provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof GlobeSurfaceTileProvider.prototype
* @type {Event}
*/
errorEvent : {
get : function() {
return this._errorEvent;
}
},
/**
* Gets or sets the terrain provider that describes the surface geometry.
* @memberof GlobeSurfaceTileProvider.prototype
* @type {TerrainProvider}
*/
terrainProvider : {
get : function() {
return this._terrainProvider;
},
set : function(terrainProvider) {
if (this._terrainProvider === terrainProvider) {
return;
}
if (!defined(terrainProvider)) {
throw new DeveloperError('terrainProvider is required.');
}
this._terrainProvider = terrainProvider;
if (defined(this._quadtree)) {
this._quadtree.invalidateAllTiles();
}
}
}
});
function sortTileImageryByLayerIndex(a, b) {
var aImagery = a.loadingImagery;
if (!defined(aImagery)) {
aImagery = a.readyImagery;
}
var bImagery = b.loadingImagery;
if (!defined(bImagery)) {
bImagery = b.readyImagery;
}
return aImagery.imageryLayer._layerIndex - bImagery.imageryLayer._layerIndex;
}
function freeVertexArray(vertexArray) {
var indexBuffer = vertexArray.indexBuffer;
vertexArray.destroy();
if (!indexBuffer.isDestroyed() && defined(indexBuffer.referenceCount)) {
--indexBuffer.referenceCount;
if (indexBuffer.referenceCount === 0) {
indexBuffer.destroy();
}
}
}
/**
* Called at the beginning of each render frame, before {@link QuadtreeTileProvider#showTileThisFrame}
* @param {FrameState} frameState The frame state.
*/
GlobeSurfaceTileProvider.prototype.initialize = function(frameState) {
var imageryLayers = this._imageryLayers;
// update collection: imagery indices, base layers, raise layer show/hide event
imageryLayers._update();
// update each layer for texture reprojection.
imageryLayers.queueReprojectionCommands(frameState);
if (this._layerOrderChanged) {
this._layerOrderChanged = false;
// Sort the TileImagery instances in each tile by the layer index.
this._quadtree.forEachLoadedTile(function(tile) {
tile.data.imagery.sort(sortTileImageryByLayerIndex);
});
}
// Add credits for terrain and imagery providers.
var creditDisplay = frameState.creditDisplay;
if (this._terrainProvider.ready && defined(this._terrainProvider.credit)) {
creditDisplay.addCredit(this._terrainProvider.credit);
}
for (var i = 0, len = imageryLayers.length; i < len; ++i) {
var imageryProvider = imageryLayers.get(i).imageryProvider;
if (imageryProvider.ready && defined(imageryProvider.credit)) {
creditDisplay.addCredit(imageryProvider.credit);
}
}
var vertexArraysToDestroy = this._vertexArraysToDestroy;
var length = vertexArraysToDestroy.length;
for (var j = 0; j < length; ++j) {
freeVertexArray(vertexArraysToDestroy[j]);
}
vertexArraysToDestroy.length = 0;
};
/**
* Called at the beginning of the update cycle for each render frame, before {@link QuadtreeTileProvider#showTileThisFrame}
* or any other functions.
*
* @param {FrameState} frameState The frame state.
*/
GlobeSurfaceTileProvider.prototype.beginUpdate = function(frameState) {
var tilesToRenderByTextureCount = this._tilesToRenderByTextureCount;
for (var i = 0, len = tilesToRenderByTextureCount.length; i < len; ++i) {
var tiles = tilesToRenderByTextureCount[i];
if (defined(tiles)) {
tiles.length = 0;
}
}
this._usedDrawCommands = 0;
};
/**
* Called at the end of the update cycle for each render frame, after {@link QuadtreeTileProvider#showTileThisFrame}
* and any other functions.
*
* @param {FrameState} frameState The frame state.
*/
GlobeSurfaceTileProvider.prototype.endUpdate = function(frameState) {
if (!defined(this._renderState)) {
this._renderState = RenderState.fromCache({ // Write color and depth
cull : {
enabled : true
},
depthTest : {
enabled : true,
func : DepthFunction.LESS
}
});
this._blendRenderState = RenderState.fromCache({ // Write color and depth
cull : {
enabled : true
},
depthTest : {
enabled : true,
func : DepthFunction.LESS_OR_EQUAL
},
blending : BlendingState.ALPHA_BLEND
});
}
// Add the tile render commands to the command list, sorted by texture count.
var tilesToRenderByTextureCount = this._tilesToRenderByTextureCount;
for (var textureCountIndex = 0, textureCountLength = tilesToRenderByTextureCount.length; textureCountIndex < textureCountLength; ++textureCountIndex) {
var tilesToRender = tilesToRenderByTextureCount[textureCountIndex];
if (!defined(tilesToRender)) {
continue;
}
for (var tileIndex = 0, tileLength = tilesToRender.length; tileIndex < tileLength; ++tileIndex) {
addDrawCommandsForTile(this, tilesToRender[tileIndex], frameState);
}
}
};
/**
* Adds draw commands for tiles rendered in the previous frame for a pick pass.
*
* @param {FrameState} frameState The frame state.
*/
GlobeSurfaceTileProvider.prototype.updateForPick = function(frameState) {
if (!defined(this._pickRenderState)) {
this._pickRenderState = RenderState.fromCache({
colorMask : {
red : false,
green : false,
blue : false,
alpha : false
},
depthTest : {
enabled : true
}
});
}
this._usedPickCommands = 0;
var drawCommands = this._drawCommands;
// Add the tile pick commands from the tiles drawn last frame.
for (var i = 0, length = this._usedDrawCommands; i < length; ++i) {
addPickCommandsForTile(this, drawCommands[i], frameState);
}
};
/**
* Cancels any imagery re-projections in the queue.
*/
GlobeSurfaceTileProvider.prototype.cancelReprojections = function() {
this._imageryLayers.cancelReprojections();
};
/**
* Gets the maximum geometric error allowed in a tile at a given level, in meters. This function should not be
* called before {@link GlobeSurfaceTileProvider#ready} returns true.
*
* @param {Number} level The tile level for which to get the maximum geometric error.
* @returns {Number} The maximum geometric error in meters.
*/
GlobeSurfaceTileProvider.prototype.getLevelMaximumGeometricError = function(level) {
return this._terrainProvider.getLevelMaximumGeometricError(level);
};
/**
* Loads, or continues loading, a given tile. This function will continue to be called
* until {@link QuadtreeTile#state} is no longer {@link QuadtreeTileLoadState#LOADING}. This function should
* not be called before {@link GlobeSurfaceTileProvider#ready} returns true.
*
* @param {FrameState} frameState The frame state.
* @param {QuadtreeTile} tile The tile to load.
*
* @exception {DeveloperError} <code>loadTile</code> must not be called before the tile provider is ready.
*/
GlobeSurfaceTileProvider.prototype.loadTile = function(frameState, tile) {
GlobeSurfaceTile.processStateMachine(tile, frameState, this._terrainProvider, this._imageryLayers, this._vertexArraysToDestroy);
};
var boundingSphereScratch = new BoundingSphere();
/**
* Determines the visibility of a given tile. The tile may be fully visible, partially visible, or not
* visible at all. Tiles that are renderable and are at least partially visible will be shown by a call
* to {@link GlobeSurfaceTileProvider#showTileThisFrame}.
*
* @param {QuadtreeTile} tile The tile instance.
* @param {FrameState} frameState The state information about the current frame.
* @param {QuadtreeOccluders} occluders The objects that may occlude this tile.
*
* @returns {Visibility} The visibility of the tile.
*/
GlobeSurfaceTileProvider.prototype.computeTileVisibility = function(tile, frameState, occluders) {
var distance = this.computeDistanceToTile(tile, frameState);
tile._distance = distance;
if (frameState.fog.enabled) {
if (CesiumMath.fog(distance, frameState.fog.density) >= 1.0) {
// Tile is completely in fog so return that it is not visible.
return Visibility.NONE;
}
}
var surfaceTile = tile.data;
var cullingVolume = frameState.cullingVolume;
var boundingVolume = defaultValue(surfaceTile.orientedBoundingBox, surfaceTile.boundingSphere3D);
if (frameState.mode !== SceneMode.SCENE3D) {
boundingVolume = boundingSphereScratch;
BoundingSphere.fromRectangleWithHeights2D(tile.rectangle, frameState.mapProjection, surfaceTile.minimumHeight, surfaceTile.maximumHeight, boundingVolume);
Cartesian3.fromElements(boundingVolume.center.z, boundingVolume.center.x, boundingVolume.center.y, boundingVolume.center);
if (frameState.mode === SceneMode.MORPHING) {
boundingVolume = BoundingSphere.union(surfaceTile.boundingSphere3D, boundingVolume, boundingVolume);
}
}
var intersection = cullingVolume.computeVisibility(boundingVolume);
if (intersection === Intersect.OUTSIDE) {
return Visibility.NONE;
}
if (frameState.mode === SceneMode.SCENE3D) {
var occludeePointInScaledSpace = surfaceTile.occludeePointInScaledSpace;
if (!defined(occludeePointInScaledSpace)) {
return intersection;
}
if (occluders.ellipsoid.isScaledSpacePointVisible(occludeePointInScaledSpace)) {
return intersection;
}
return Visibility.NONE;
}
return intersection;
};
var modifiedModelViewScratch = new Matrix4();
var modifiedModelViewProjectionScratch = new Matrix4();
var tileRectangleScratch = new Cartesian4();
var rtcScratch = new Cartesian3();
var centerEyeScratch = new Cartesian3();
var southwestScratch = new Cartesian3();
var northeastScratch = new Cartesian3();
/**
* Shows a specified tile in this frame. The provider can cause the tile to be shown by adding
* render commands to the commandList, or use any other method as appropriate. The tile is not
* expected to be visible next frame as well, unless this method is called next frame, too.
*
* @param {Object} tile The tile instance.
* @param {FrameState} frameState The state information of the current rendering frame.
*/
GlobeSurfaceTileProvider.prototype.showTileThisFrame = function(tile, frameState) {
var readyTextureCount = 0;
var tileImageryCollection = tile.data.imagery;
for (var i = 0, len = tileImageryCollection.length; i < len; ++i) {
var tileImagery = tileImageryCollection[i];
if (defined(tileImagery.readyImagery) && tileImagery.readyImagery.imageryLayer.alpha !== 0.0) {
++readyTextureCount;
}
}
var tileSet = this._tilesToRenderByTextureCount[readyTextureCount];
if (!defined(tileSet)) {
tileSet = [];
this._tilesToRenderByTextureCount[readyTextureCount] = tileSet;
}
tileSet.push(tile);
var debug = this._debug;
++debug.tilesRendered;
debug.texturesRendered += readyTextureCount;
};
/**
* Gets the distance from the camera to the closest point on the tile. This is used for level-of-detail selection.
*
* @param {QuadtreeTile} tile The tile instance.
* @param {FrameState} frameState The state information of the current rendering frame.
*
* @returns {Number} The distance from the camera to the closest point on the tile, in meters.
*/
GlobeSurfaceTileProvider.prototype.computeDistanceToTile = function(tile, frameState) {
var surfaceTile = tile.data;
var tileBoundingBox = surfaceTile.tileBoundingBox;
return tileBoundingBox.distanceToCamera(frameState);
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see GlobeSurfaceTileProvider#destroy
*/
GlobeSurfaceTileProvider.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* provider = provider && provider();
*
* @see GlobeSurfaceTileProvider#isDestroyed
*/
GlobeSurfaceTileProvider.prototype.destroy = function() {
this._tileProvider = this._tileProvider && this._tileProvider.destroy();
return destroyObject(this);
};
GlobeSurfaceTileProvider.prototype._onLayerAdded = function(layer, index) {
if (layer.show) {
var terrainProvider = this._terrainProvider;
// create TileImagerys for this layer for all previously loaded tiles
this._quadtree.forEachLoadedTile(function(tile) {
if (layer._createTileImagerySkeletons(tile, terrainProvider)) {
tile.state = QuadtreeTileLoadState.LOADING;
}
});
this._layerOrderChanged = true;
}
};
GlobeSurfaceTileProvider.prototype._onLayerRemoved = function(layer, index) {
// destroy TileImagerys for this layer for all previously loaded tiles
this._quadtree.forEachLoadedTile(function(tile) {
var tileImageryCollection = tile.data.imagery;
var startIndex = -1;
var numDestroyed = 0;
for (var i = 0, len = tileImageryCollection.length; i < len; ++i) {
var tileImagery = tileImageryCollection[i];
var imagery = tileImagery.loadingImagery;
if (!defined(imagery)) {
imagery = tileImagery.readyImagery;
}
if (imagery.imageryLayer === layer) {
if (startIndex === -1) {
startIndex = i;
}
tileImagery.freeResources();
++numDestroyed;
} else if (startIndex !== -1) {
// iterated past the section of TileImagerys belonging to this layer, no need to continue.
break;
}
}
if (startIndex !== -1) {
tileImageryCollection.splice(startIndex, numDestroyed);
}
});
};
GlobeSurfaceTileProvider.prototype._onLayerMoved = function(layer, newIndex, oldIndex) {
this._layerOrderChanged = true;
};
GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden = function(layer, index, show) {
if (show) {
this._onLayerAdded(layer, index);
} else {
this._onLayerRemoved(layer, index);
}
};
function createTileUniformMap(frameState) {
var uniformMap = {
u_initialColor : function() {
return this.properties.initialColor;
},
u_zoomedOutOceanSpecularIntensity : function() {
return this.properties.zoomedOutOceanSpecularIntensity;
},
u_oceanNormalMap : function() {
return this.properties.oceanNormalMap;
},
u_lightingFadeDistance : function() {
return this.properties.lightingFadeDistance;
},
u_center3D : function() {
return this.properties.center3D;
},
u_tileRectangle : function() {
return this.properties.tileRectangle;
},
u_modifiedModelView : function() {
var viewMatrix = frameState.context.uniformState.view;
var centerEye = Matrix4.multiplyByPoint(viewMatrix, this.properties.rtc, centerEyeScratch);
Matrix4.setTranslation(viewMatrix, centerEye, modifiedModelViewScratch);
return modifiedModelViewScratch;
},
u_modifiedModelViewProjection : function() {
var viewMatrix = frameState.context.uniformState.view;
var projectionMatrix = frameState.context.uniformState.projection;
var centerEye = Matrix4.multiplyByPoint(viewMatrix, this.properties.rtc, centerEyeScratch);
Matrix4.setTranslation(viewMatrix, centerEye, modifiedModelViewProjectionScratch);
Matrix4.multiply(projectionMatrix, modifiedModelViewProjectionScratch, modifiedModelViewProjectionScratch);
return modifiedModelViewProjectionScratch;
},
u_dayTextures : function() {
return this.properties.dayTextures;
},
u_dayTextureTranslationAndScale : function() {
return this.properties.dayTextureTranslationAndScale;
},
u_dayTextureTexCoordsRectangle : function() {
return this.properties.dayTextureTexCoordsRectangle;
},
u_dayTextureUseWebMercatorT : function() {
return this.properties.dayTextureUseWebMercatorT;
},
u_dayTextureAlpha : function() {
return this.properties.dayTextureAlpha;
},
u_dayTextureBrightness : function() {
return this.properties.dayTextureBrightness;
},
u_dayTextureContrast : function() {
return this.properties.dayTextureContrast;
},
u_dayTextureHue : function() {
return this.properties.dayTextureHue;
},
u_dayTextureSaturation : function() {
return this.properties.dayTextureSaturation;
},
u_dayTextureOneOverGamma : function() {
return this.properties.dayTextureOneOverGamma;
},
u_dayIntensity : function() {
return this.properties.dayIntensity;
},
u_southAndNorthLatitude : function() {
return this.properties.southAndNorthLatitude;
},
u_southMercatorYAndOneOverHeight : function() {
return this.properties.southMercatorYAndOneOverHeight;
},
u_waterMask : function() {
return this.properties.waterMask;
},
u_waterMaskTranslationAndScale : function() {
return this.properties.waterMaskTranslationAndScale;
},
u_minMaxHeight : function() {
return this.properties.minMaxHeight;
},
u_scaleAndBias : function() {
return this.properties.scaleAndBias;
},
// make a separate object so that changes to the properties are seen on
// derived commands that combine another uniform map with this one.
properties : {
initialColor : new Cartesian4(0.0, 0.0, 0.5, 1.0),
zoomedOutOceanSpecularIntensity : 0.5,
oceanNormalMap : undefined,
lightingFadeDistance : new Cartesian2(6500000.0, 9000000.0),
center3D : undefined,
rtc : new Cartesian3(),
modifiedModelView : new Matrix4(),
tileRectangle : new Cartesian4(),
dayTextures : [],
dayTextureTranslationAndScale : [],
dayTextureTexCoordsRectangle : [],
dayTextureUseWebMercatorT : [],
dayTextureAlpha : [],
dayTextureBrightness : [],
dayTextureContrast : [],
dayTextureHue : [],
dayTextureSaturation : [],
dayTextureOneOverGamma : [],
dayIntensity : 0.0,
southAndNorthLatitude : new Cartesian2(),
southMercatorYAndOneOverHeight : new Cartesian2(),
waterMask : undefined,
waterMaskTranslationAndScale : new Cartesian4(),
minMaxHeight : new Cartesian2(),
scaleAndBias : new Matrix4()
}
};
return uniformMap;
}
function createWireframeVertexArrayIfNecessary(context, provider, tile) {
var surfaceTile = tile.data;
if (defined(surfaceTile.wireframeVertexArray)) {
return;
}
if (!defined(surfaceTile.terrainData) || !defined(surfaceTile.terrainData._mesh)) {
return;
}
surfaceTile.wireframeVertexArray = createWireframeVertexArray(context, surfaceTile.vertexArray, surfaceTile.terrainData._mesh);
}
/**
* Creates a vertex array for wireframe rendering of a terrain tile.
*
* @private
*
* @param {Context} context The context in which to create the vertex array.
* @param {VertexArray} vertexArray The existing, non-wireframe vertex array. The new vertex array
* will share vertex buffers with this existing one.
* @param {TerrainMesh} terrainMesh The terrain mesh containing non-wireframe indices.
* @returns {VertexArray} The vertex array for wireframe rendering.
*/
function createWireframeVertexArray(context, vertexArray, terrainMesh) {
var geometry = {
indices : terrainMesh.indices,
primitiveType : PrimitiveType.TRIANGLES
};
GeometryPipeline.toWireframe(geometry);
var wireframeIndices = geometry.indices;
var wireframeIndexBuffer = Buffer.createIndexBuffer({
context : context,
typedArray : wireframeIndices,
usage : BufferUsage.STATIC_DRAW,
indexDatatype : IndexDatatype.UNSIGNED_SHORT
});
return new VertexArray({
context : context,
attributes : vertexArray._attributes,
indexBuffer : wireframeIndexBuffer
});
}
var getDebugOrientedBoundingBox;
var getDebugBoundingSphere;
var debugDestroyPrimitive;
(function() {
var instanceOBB = new GeometryInstance({
geometry: BoxOutlineGeometry.fromDimensions({ dimensions: new Cartesian3(2.0, 2.0, 2.0) })
});
var instanceSphere = new GeometryInstance({
geometry: new SphereOutlineGeometry({ radius: 1.0 })
});
var modelMatrix = new Matrix4();
var previousVolume;
var primitive;
function createDebugPrimitive(instance) {
return new Primitive({
geometryInstances : instance,
appearance : new PerInstanceColorAppearance({
translucent : false,
flat : true
}),
asynchronous : false
});
}
getDebugOrientedBoundingBox = function(obb, color) {
if (obb === previousVolume) {
return primitive;
}
debugDestroyPrimitive();
previousVolume = obb;
modelMatrix = Matrix4.fromRotationTranslation(obb.halfAxes, obb.center, modelMatrix);
instanceOBB.modelMatrix = modelMatrix;
instanceOBB.attributes.color = ColorGeometryInstanceAttribute.fromColor(color);
primitive = createDebugPrimitive(instanceOBB);
return primitive;
};
getDebugBoundingSphere = function(sphere, color) {
if (sphere === previousVolume) {
return primitive;
}
debugDestroyPrimitive();
previousVolume = sphere;
modelMatrix = Matrix4.fromTranslation(sphere.center, modelMatrix);
modelMatrix = Matrix4.multiplyByUniformScale(modelMatrix, sphere.radius, modelMatrix);
instanceSphere.modelMatrix = modelMatrix;
instanceSphere.attributes.color = ColorGeometryInstanceAttribute.fromColor(color);
primitive = createDebugPrimitive(instanceSphere);
return primitive;
};
debugDestroyPrimitive = function() {
if (defined(primitive)) {
primitive.destroy();
primitive = undefined;
previousVolume = undefined;
}
};
})();
var otherPassesInitialColor = new Cartesian4(0.0, 0.0, 0.0, 0.0);
function addDrawCommandsForTile(tileProvider, tile, frameState) {
var surfaceTile = tile.data;
var maxTextures = ContextLimits.maximumTextureImageUnits;
var waterMaskTexture = surfaceTile.waterMaskTexture;
var showReflectiveOcean = tileProvider.hasWaterMask && defined(waterMaskTexture);
var oceanNormalMap = tileProvider.oceanNormalMap;
var showOceanWaves = showReflectiveOcean && defined(oceanNormalMap);
var hasVertexNormals = tileProvider.terrainProvider.ready && tileProvider.terrainProvider.hasVertexNormals;
var enableFog = frameState.fog.enabled;
var castShadows = ShadowMode.castShadows(tileProvider.shadows);
var receiveShadows = ShadowMode.receiveShadows(tileProvider.shadows);
if (showReflectiveOcean) {
--maxTextures;
}
if (showOceanWaves) {
--maxTextures;
}
var rtc = surfaceTile.center;
var encoding = surfaceTile.pickTerrain.mesh.encoding;
// Not used in 3D.
var tileRectangle = tileRectangleScratch;
// Only used for Mercator projections.
var southLatitude = 0.0;
var northLatitude = 0.0;
var southMercatorY = 0.0;
var oneOverMercatorHeight = 0.0;
var useWebMercatorProjection = false;
if (frameState.mode !== SceneMode.SCENE3D) {
var projection = frameState.mapProjection;
var southwest = projection.project(Rectangle.southwest(tile.rectangle), southwestScratch);
var northeast = projection.project(Rectangle.northeast(tile.rectangle), northeastScratch);
tileRectangle.x = southwest.x;
tileRectangle.y = southwest.y;
tileRectangle.z = northeast.x;
tileRectangle.w = northeast.y;
// In 2D and Columbus View, use the center of the tile for RTC rendering.
if (frameState.mode !== SceneMode.MORPHING) {
rtc = rtcScratch;
rtc.x = 0.0;
rtc.y = (tileRectangle.z + tileRectangle.x) * 0.5;
rtc.z = (tileRectangle.w + tileRectangle.y) * 0.5;
tileRectangle.x -= rtc.y;
tileRectangle.y -= rtc.z;
tileRectangle.z -= rtc.y;
tileRectangle.w -= rtc.z;
}
if (frameState.mode === SceneMode.SCENE2D && encoding.quantization === TerrainQuantization.BITS12) {
// In 2D, the texture coordinates of the tile are interpolated over the rectangle to get the position in the vertex shader.
// When the texture coordinates are quantized, error is introduced. This can be seen through the 1px wide cracking
// between the quantized tiles in 2D. To compensate for the error, move the expand the rectangle in each direction by
// half the error amount.
var epsilon = (1.0 / (Math.pow(2.0, 12.0) - 1.0)) * 0.5;
var widthEpsilon = (tileRectangle.z - tileRectangle.x) * epsilon;
var heightEpsilon = (tileRectangle.w - tileRectangle.y) * epsilon;
tileRectangle.x -= widthEpsilon;
tileRectangle.y -= heightEpsilon;
tileRectangle.z += widthEpsilon;
tileRectangle.w += heightEpsilon;
}
if (projection instanceof WebMercatorProjection) {
southLatitude = tile.rectangle.south;
northLatitude = tile.rectangle.north;
southMercatorY = WebMercatorProjection.geodeticLatitudeToMercatorAngle(southLatitude);
oneOverMercatorHeight = 1.0 / (WebMercatorProjection.geodeticLatitudeToMercatorAngle(northLatitude) - southMercatorY);
useWebMercatorProjection = true;
}
}
var tileImageryCollection = surfaceTile.imagery;
var imageryIndex = 0;
var imageryLen = tileImageryCollection.length;
var firstPassRenderState = tileProvider._renderState;
var otherPassesRenderState = tileProvider._blendRenderState;
var renderState = firstPassRenderState;
var initialColor = tileProvider._firstPassInitialColor;
var context = frameState.context;
if (!defined(tileProvider._debug.boundingSphereTile)) {
debugDestroyPrimitive();
}
do {
var numberOfDayTextures = 0;
var command;
var uniformMap;
if (tileProvider._drawCommands.length <= tileProvider._usedDrawCommands) {
command = new DrawCommand();
command.owner = tile;
command.cull = false;
command.boundingVolume = new BoundingSphere();
command.orientedBoundingBox = undefined;
uniformMap = createTileUniformMap(frameState);
tileProvider._drawCommands.push(command);
tileProvider._uniformMaps.push(uniformMap);
} else {
command = tileProvider._drawCommands[tileProvider._usedDrawCommands];
uniformMap = tileProvider._uniformMaps[tileProvider._usedDrawCommands];
}
command.owner = tile;
++tileProvider._usedDrawCommands;
if (tile === tileProvider._debug.boundingSphereTile) {
// If a debug primitive already exists for this tile, it will not be
// re-created, to avoid allocation every frame. If it were possible
// to have more than one selected tile, this would have to change.
if (defined(surfaceTile.orientedBoundingBox)) {
getDebugOrientedBoundingBox(surfaceTile.orientedBoundingBox, Color.RED).update(frameState);
} else if (defined(surfaceTile.boundingSphere3D)) {
getDebugBoundingSphere(surfaceTile.boundingSphere3D, Color.RED).update(frameState);
}
}
var uniformMapProperties = uniformMap.properties;
Cartesian4.clone(initialColor, uniformMapProperties.initialColor);
uniformMapProperties.oceanNormalMap = oceanNormalMap;
uniformMapProperties.lightingFadeDistance.x = tileProvider.lightingFadeOutDistance;
uniformMapProperties.lightingFadeDistance.y = tileProvider.lightingFadeInDistance;
uniformMapProperties.zoomedOutOceanSpecularIntensity = tileProvider.zoomedOutOceanSpecularIntensity;
uniformMapProperties.center3D = surfaceTile.center;
Cartesian3.clone(rtc, uniformMapProperties.rtc);
Cartesian4.clone(tileRectangle, uniformMapProperties.tileRectangle);
uniformMapProperties.southAndNorthLatitude.x = southLatitude;
uniformMapProperties.southAndNorthLatitude.y = northLatitude;
uniformMapProperties.southMercatorYAndOneOverHeight.x = southMercatorY;
uniformMapProperties.southMercatorYAndOneOverHeight.y = oneOverMercatorHeight;
// For performance, use fog in the shader only when the tile is in fog.
var applyFog = enableFog && CesiumMath.fog(tile._distance, frameState.fog.density) > CesiumMath.EPSILON3;
var applyBrightness = false;
var applyContrast = false;
var applyHue = false;
var applySaturation = false;
var applyGamma = false;
var applyAlpha = false;
while (numberOfDayTextures < maxTextures && imageryIndex < imageryLen) {
var tileImagery = tileImageryCollection[imageryIndex];
var imagery = tileImagery.readyImagery;
++imageryIndex;
if (!defined(imagery) || imagery.imageryLayer.alpha === 0.0) {
continue;
}
var texture = tileImagery.useWebMercatorT ? imagery.textureWebMercator : imagery.texture;
if (!defined(texture)) {
// Our "ready" texture isn't actually ready. This should never happen.
//
// Side note: It IS possible for it to not be in the READY ImageryState, though.
// This can happen when a single imagery tile is shared by two terrain tiles (common)
// and one of them (A) needs a geographic version of the tile because it is near the poles,
// and the other (B) does not. B can and will transition the imagery tile to the READY state
// without reprojecting to geographic. Then, later, A will deem that same tile not-ready-yet
// because it only has the Web Mercator texture, and flip it back to the TRANSITIONING state.
// The imagery tile won't be in the READY state anymore, but it's still READY enough for B's
// purposes.
throw new DeveloperError('readyImagery is not actually ready!');
}
var imageryLayer = imagery.imageryLayer;
if (!defined(tileImagery.textureTranslationAndScale)) {
tileImagery.textureTranslationAndScale = imageryLayer._calculateTextureTranslationAndScale(tile, tileImagery);
}
uniformMapProperties.dayTextures[numberOfDayTextures] = texture;
uniformMapProperties.dayTextureTranslationAndScale[numberOfDayTextures] = tileImagery.textureTranslationAndScale;
uniformMapProperties.dayTextureTexCoordsRectangle[numberOfDayTextures] = tileImagery.textureCoordinateRectangle;
uniformMapProperties.dayTextureUseWebMercatorT[numberOfDayTextures] = tileImagery.useWebMercatorT;
uniformMapProperties.dayTextureAlpha[numberOfDayTextures] = imageryLayer.alpha;
applyAlpha = applyAlpha || uniformMapProperties.dayTextureAlpha[numberOfDayTextures] !== 1.0;
uniformMapProperties.dayTextureBrightness[numberOfDayTextures] = imageryLayer.brightness;
applyBrightness = applyBrightness || uniformMapProperties.dayTextureBrightness[numberOfDayTextures] !== ImageryLayer.DEFAULT_BRIGHTNESS;
uniformMapProperties.dayTextureContrast[numberOfDayTextures] = imageryLayer.contrast;
applyContrast = applyContrast || uniformMapProperties.dayTextureContrast[numberOfDayTextures] !== ImageryLayer.DEFAULT_CONTRAST;
uniformMapProperties.dayTextureHue[numberOfDayTextures] = imageryLayer.hue;
applyHue = applyHue || uniformMapProperties.dayTextureHue[numberOfDayTextures] !== ImageryLayer.DEFAULT_HUE;
uniformMapProperties.dayTextureSaturation[numberOfDayTextures] = imageryLayer.saturation;
applySaturation = applySaturation || uniformMapProperties.dayTextureSaturation[numberOfDayTextures] !== ImageryLayer.DEFAULT_SATURATION;
uniformMapProperties.dayTextureOneOverGamma[numberOfDayTextures] = 1.0 / imageryLayer.gamma;
applyGamma = applyGamma || uniformMapProperties.dayTextureOneOverGamma[numberOfDayTextures] !== 1.0 / ImageryLayer.DEFAULT_GAMMA;
if (defined(imagery.credits)) {
var creditDisplay = frameState.creditDisplay;
var credits = imagery.credits;
for (var creditIndex = 0, creditLength = credits.length; creditIndex < creditLength; ++creditIndex) {
creditDisplay.addCredit(credits[creditIndex]);
}
}
++numberOfDayTextures;
}
// trim texture array to the used length so we don't end up using old textures
// which might get destroyed eventually
uniformMapProperties.dayTextures.length = numberOfDayTextures;
uniformMapProperties.waterMask = waterMaskTexture;
Cartesian4.clone(surfaceTile.waterMaskTranslationAndScale, uniformMapProperties.waterMaskTranslationAndScale);
uniformMapProperties.minMaxHeight.x = encoding.minimumHeight;
uniformMapProperties.minMaxHeight.y = encoding.maximumHeight;
Matrix4.clone(encoding.matrix, uniformMapProperties.scaleAndBias);
command.shaderProgram = tileProvider._surfaceShaderSet.getShaderProgram(frameState, surfaceTile, numberOfDayTextures, applyBrightness, applyContrast, applyHue, applySaturation, applyGamma, applyAlpha, showReflectiveOcean, showOceanWaves, tileProvider.enableLighting, hasVertexNormals, useWebMercatorProjection, applyFog);
command.castShadows = castShadows;
command.receiveShadows = receiveShadows;
command.renderState = renderState;
command.primitiveType = PrimitiveType.TRIANGLES;
command.vertexArray = surfaceTile.vertexArray;
command.uniformMap = uniformMap;
command.pass = Pass.GLOBE;
if (tileProvider._debug.wireframe) {
createWireframeVertexArrayIfNecessary(context, tileProvider, tile);
if (defined(surfaceTile.wireframeVertexArray)) {
command.vertexArray = surfaceTile.wireframeVertexArray;
command.primitiveType = PrimitiveType.LINES;
}
}
var boundingVolume = command.boundingVolume;
var orientedBoundingBox = command.orientedBoundingBox;
if (frameState.mode !== SceneMode.SCENE3D) {
BoundingSphere.fromRectangleWithHeights2D(tile.rectangle, frameState.mapProjection, surfaceTile.minimumHeight, surfaceTile.maximumHeight, boundingVolume);
Cartesian3.fromElements(boundingVolume.center.z, boundingVolume.center.x, boundingVolume.center.y, boundingVolume.center);
if (frameState.mode === SceneMode.MORPHING) {
boundingVolume = BoundingSphere.union(surfaceTile.boundingSphere3D, boundingVolume, boundingVolume);
}
} else {
command.boundingVolume = BoundingSphere.clone(surfaceTile.boundingSphere3D, boundingVolume);
command.orientedBoundingBox = OrientedBoundingBox.clone(surfaceTile.orientedBoundingBox, orientedBoundingBox);
}
frameState.commandList.push(command);
renderState = otherPassesRenderState;
initialColor = otherPassesInitialColor;
} while (imageryIndex < imageryLen);
}
function addPickCommandsForTile(tileProvider, drawCommand, frameState) {
var pickCommand;
if (tileProvider._pickCommands.length <= tileProvider._usedPickCommands) {
pickCommand = new DrawCommand();
pickCommand.cull = false;
tileProvider._pickCommands.push(pickCommand);
} else {
pickCommand = tileProvider._pickCommands[tileProvider._usedPickCommands];
}
++tileProvider._usedPickCommands;
var surfaceTile = drawCommand.owner.data;
var useWebMercatorProjection = frameState.projection instanceof WebMercatorProjection;
pickCommand.shaderProgram = tileProvider._surfaceShaderSet.getPickShaderProgram(frameState, surfaceTile, useWebMercatorProjection);
pickCommand.renderState = tileProvider._pickRenderState;
pickCommand.owner = drawCommand.owner;
pickCommand.primitiveType = drawCommand.primitiveType;
pickCommand.vertexArray = drawCommand.vertexArray;
pickCommand.uniformMap = drawCommand.uniformMap;
pickCommand.boundingVolume = drawCommand.boundingVolume;
pickCommand.orientedBoundingBox = drawCommand.orientedBoundingBox;
pickCommand.pass = drawCommand.pass;
frameState.commandList.push(pickCommand);
}
return GlobeSurfaceTileProvider;
});
/*global define*/
define('Scene/ImageryLayerCollection',[
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/Event',
'../Core/Math',
'../Core/Rectangle',
'../ThirdParty/when',
'./ImageryLayer'
], function(
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
Event,
CesiumMath,
Rectangle,
when,
ImageryLayer) {
'use strict';
/**
* An ordered collection of imagery layers.
*
* @alias ImageryLayerCollection
* @constructor
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Imagery%20Adjustment.html|Cesium Sandcastle Imagery Adjustment Demo}
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Imagery%20Layers%20Manipulation.html|Cesium Sandcastle Imagery Manipulation Demo}
*/
function ImageryLayerCollection() {
this._layers = [];
/**
* An event that is raised when a layer is added to the collection. Event handlers are passed the layer that
* was added and the index at which it was added.
* @type {Event}
* @default Event()
*/
this.layerAdded = new Event();
/**
* An event that is raised when a layer is removed from the collection. Event handlers are passed the layer that
* was removed and the index from which it was removed.
* @type {Event}
* @default Event()
*/
this.layerRemoved = new Event();
/**
* An event that is raised when a layer changes position in the collection. Event handlers are passed the layer that
* was moved, its new index after the move, and its old index prior to the move.
* @type {Event}
* @default Event()
*/
this.layerMoved = new Event();
/**
* An event that is raised when a layer is shown or hidden by setting the
* {@link ImageryLayer#show} property. Event handlers are passed a reference to this layer,
* the index of the layer in the collection, and a flag that is true if the layer is now
* shown or false if it is now hidden.
*
* @type {Event}
* @default Event()
*/
this.layerShownOrHidden = new Event();
}
defineProperties(ImageryLayerCollection.prototype, {
/**
* Gets the number of layers in this collection.
* @memberof ImageryLayerCollection.prototype
* @type {Number}
*/
length : {
get : function() {
return this._layers.length;
}
}
});
/**
* Adds a layer to the collection.
*
* @param {ImageryLayer} layer the layer to add.
* @param {Number} [index] the index to add the layer at. If omitted, the layer will
* added on top of all existing layers.
*
* @exception {DeveloperError} index, if supplied, must be greater than or equal to zero and less than or equal to the number of the layers.
*/
ImageryLayerCollection.prototype.add = function(layer, index) {
var hasIndex = defined(index);
if (!defined(layer)) {
throw new DeveloperError('layer is required.');
}
if (hasIndex) {
if (index < 0) {
throw new DeveloperError('index must be greater than or equal to zero.');
} else if (index > this._layers.length) {
throw new DeveloperError('index must be less than or equal to the number of layers.');
}
}
if (!hasIndex) {
index = this._layers.length;
this._layers.push(layer);
} else {
this._layers.splice(index, 0, layer);
}
this._update();
this.layerAdded.raiseEvent(layer, index);
};
/**
* Creates a new layer using the given ImageryProvider and adds it to the collection.
*
* @param {ImageryProvider} imageryProvider the imagery provider to create a new layer for.
* @param {Number} [index] the index to add the layer at. If omitted, the layer will
* added on top of all existing layers.
* @returns {ImageryLayer} The newly created layer.
*/
ImageryLayerCollection.prototype.addImageryProvider = function(imageryProvider, index) {
if (!defined(imageryProvider)) {
throw new DeveloperError('imageryProvider is required.');
}
var layer = new ImageryLayer(imageryProvider);
this.add(layer, index);
return layer;
};
/**
* Removes a layer from this collection, if present.
*
* @param {ImageryLayer} layer The layer to remove.
* @param {Boolean} [destroy=true] whether to destroy the layers in addition to removing them.
* @returns {Boolean} true if the layer was in the collection and was removed,
* false if the layer was not in the collection.
*/
ImageryLayerCollection.prototype.remove = function(layer, destroy) {
destroy = defaultValue(destroy, true);
var index = this._layers.indexOf(layer);
if (index !== -1) {
this._layers.splice(index, 1);
this._update();
this.layerRemoved.raiseEvent(layer, index);
if (destroy) {
layer.destroy();
}
return true;
}
return false;
};
/**
* Removes all layers from this collection.
*
* @param {Boolean} [destroy=true] whether to destroy the layers in addition to removing them.
*/
ImageryLayerCollection.prototype.removeAll = function(destroy) {
destroy = defaultValue(destroy, true);
var layers = this._layers;
for (var i = 0, len = layers.length; i < len; i++) {
var layer = layers[i];
this.layerRemoved.raiseEvent(layer, i);
if (destroy) {
layer.destroy();
}
}
this._layers = [];
};
/**
* Checks to see if the collection contains a given layer.
*
* @param {ImageryLayer} layer the layer to check for.
*
* @returns {Boolean} true if the collection contains the layer, false otherwise.
*/
ImageryLayerCollection.prototype.contains = function(layer) {
return this.indexOf(layer) !== -1;
};
/**
* Determines the index of a given layer in the collection.
*
* @param {ImageryLayer} layer The layer to find the index of.
*
* @returns {Number} The index of the layer in the collection, or -1 if the layer does not exist in the collection.
*/
ImageryLayerCollection.prototype.indexOf = function(layer) {
return this._layers.indexOf(layer);
};
/**
* Gets a layer by index from the collection.
*
* @param {Number} index the index to retrieve.
*
* @returns {ImageryLayer} The imagery layer at the given index.
*/
ImageryLayerCollection.prototype.get = function(index) {
if (!defined(index)) {
throw new DeveloperError('index is required.', 'index');
}
return this._layers[index];
};
function getLayerIndex(layers, layer) {
if (!defined(layer)) {
throw new DeveloperError('layer is required.');
}
var index = layers.indexOf(layer);
if (index === -1) {
throw new DeveloperError('layer is not in this collection.');
}
return index;
}
function swapLayers(collection, i, j) {
var arr = collection._layers;
i = CesiumMath.clamp(i, 0, arr.length - 1);
j = CesiumMath.clamp(j, 0, arr.length - 1);
if (i === j) {
return;
}
var temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
collection._update();
collection.layerMoved.raiseEvent(temp, j, i);
}
/**
* Raises a layer up one position in the collection.
*
* @param {ImageryLayer} layer the layer to move.
*
* @exception {DeveloperError} layer is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*/
ImageryLayerCollection.prototype.raise = function(layer) {
var index = getLayerIndex(this._layers, layer);
swapLayers(this, index, index + 1);
};
/**
* Lowers a layer down one position in the collection.
*
* @param {ImageryLayer} layer the layer to move.
*
* @exception {DeveloperError} layer is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*/
ImageryLayerCollection.prototype.lower = function(layer) {
var index = getLayerIndex(this._layers, layer);
swapLayers(this, index, index - 1);
};
/**
* Raises a layer to the top of the collection.
*
* @param {ImageryLayer} layer the layer to move.
*
* @exception {DeveloperError} layer is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*/
ImageryLayerCollection.prototype.raiseToTop = function(layer) {
var index = getLayerIndex(this._layers, layer);
if (index === this._layers.length - 1) {
return;
}
this._layers.splice(index, 1);
this._layers.push(layer);
this._update();
this.layerMoved.raiseEvent(layer, this._layers.length - 1, index);
};
/**
* Lowers a layer to the bottom of the collection.
*
* @param {ImageryLayer} layer the layer to move.
*
* @exception {DeveloperError} layer is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*/
ImageryLayerCollection.prototype.lowerToBottom = function(layer) {
var index = getLayerIndex(this._layers, layer);
if (index === 0) {
return;
}
this._layers.splice(index, 1);
this._layers.splice(0, 0, layer);
this._update();
this.layerMoved.raiseEvent(layer, 0, index);
};
var applicableRectangleScratch = new Rectangle();
/**
* Asynchronously determines the imagery layer features that are intersected by a pick ray. The intersected imagery
* layer features are found by invoking {@link ImageryProvider#pickFeatures} for each imagery layer tile intersected
* by the pick ray. To compute a pick ray from a location on the screen, use {@link Camera.getPickRay}.
*
* @param {Ray} ray The ray to test for intersection.
* @param {Scene} scene The scene.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise that resolves to an array of features intersected by the pick ray.
* If it can be quickly determined that no features are intersected (for example,
* because no active imagery providers support {@link ImageryProvider#pickFeatures}
* or because the pick ray does not intersect the surface), this function will
* return undefined.
*
* @example
* var pickRay = viewer.camera.getPickRay(windowPosition);
* var featuresPromise = viewer.imageryLayers.pickImageryLayerFeatures(pickRay, viewer.scene);
* if (!Cesium.defined(featuresPromise)) {
* console.log('No features picked.');
* } else {
* Cesium.when(featuresPromise, function(features) {
* // This function is called asynchronously when the list if picked features is available.
* console.log('Number of features: ' + features.length);
* if (features.length > 0) {
* console.log('First feature name: ' + features[0].name);
* }
* });
* }
*/
ImageryLayerCollection.prototype.pickImageryLayerFeatures = function(ray, scene) {
// Find the picked location on the globe.
var pickedPosition = scene.globe.pick(ray, scene);
if (!defined(pickedPosition)) {
return undefined;
}
var pickedLocation = scene.globe.ellipsoid.cartesianToCartographic(pickedPosition);
// Find the terrain tile containing the picked location.
var tilesToRender = scene.globe._surface._tilesToRender;
var pickedTile;
for (var textureIndex = 0; !defined(pickedTile) && textureIndex < tilesToRender.length; ++textureIndex) {
var tile = tilesToRender[textureIndex];
if (Rectangle.contains(tile.rectangle, pickedLocation)) {
pickedTile = tile;
}
}
if (!defined(pickedTile)) {
return undefined;
}
// Pick against all attached imagery tiles containing the pickedLocation.
var imageryTiles = pickedTile.data.imagery;
var promises = [];
var imageryLayers = [];
for (var i = imageryTiles.length - 1; i >= 0; --i) {
var terrainImagery = imageryTiles[i];
var imagery = terrainImagery.readyImagery;
if (!defined(imagery)) {
continue;
}
var provider = imagery.imageryLayer.imageryProvider;
if (!defined(provider.pickFeatures)) {
continue;
}
if (!Rectangle.contains(imagery.rectangle, pickedLocation)) {
continue;
}
// If this imagery came from a parent, it may not be applicable to its entire rectangle.
// Check the textureCoordinateRectangle.
var applicableRectangle = applicableRectangleScratch;
var epsilon = 1 / 1024; // 1/4 of a pixel in a typical 256x256 tile.
applicableRectangle.west = CesiumMath.lerp(pickedTile.rectangle.west, pickedTile.rectangle.east, terrainImagery.textureCoordinateRectangle.x - epsilon);
applicableRectangle.east = CesiumMath.lerp(pickedTile.rectangle.west, pickedTile.rectangle.east, terrainImagery.textureCoordinateRectangle.z + epsilon);
applicableRectangle.south = CesiumMath.lerp(pickedTile.rectangle.south, pickedTile.rectangle.north, terrainImagery.textureCoordinateRectangle.y - epsilon);
applicableRectangle.north = CesiumMath.lerp(pickedTile.rectangle.south, pickedTile.rectangle.north, terrainImagery.textureCoordinateRectangle.w + epsilon);
if (!Rectangle.contains(applicableRectangle, pickedLocation)) {
continue;
}
var promise = provider.pickFeatures(imagery.x, imagery.y, imagery.level, pickedLocation.longitude, pickedLocation.latitude);
if (!defined(promise)) {
continue;
}
promises.push(promise);
imageryLayers.push(imagery.imageryLayer);
}
if (promises.length === 0) {
return undefined;
}
return when.all(promises, function(results) {
var features = [];
for (var resultIndex = 0; resultIndex < results.length; ++resultIndex) {
var result = results[resultIndex];
var image = imageryLayers[resultIndex];
if (defined(result) && result.length > 0) {
for (var featureIndex = 0; featureIndex < result.length; ++featureIndex) {
var feature = result[featureIndex];
feature.imageryLayer = image;
// For features without a position, use the picked location.
if (!defined(feature.position)) {
feature.position = pickedLocation;
}
features.push(feature);
}
}
}
return features;
});
};
/**
* Updates frame state to execute any queued texture re-projections.
*
* @private
*
* @param {FrameState} frameState The frameState.
*/
ImageryLayerCollection.prototype.queueReprojectionCommands = function(frameState) {
var layers = this._layers;
for (var i = 0, len = layers.length; i < len; ++i) {
layers[i].queueReprojectionCommands(frameState);
}
};
/**
* Cancels re-projection commands queued for the next frame.
*
* @private
*/
ImageryLayerCollection.prototype.cancelReprojections = function() {
var layers = this._layers;
for (var i = 0, len = layers.length; i < len; ++i) {
layers[i].cancelReprojections();
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} true if this object was destroyed; otherwise, false.
*
* @see ImageryLayerCollection#destroy
*/
ImageryLayerCollection.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by all layers in this collection. Explicitly destroying this
* object allows for deterministic release of WebGL resources, instead of relying on the garbage
* collector.
* <br /><br />
* Once this object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* layerCollection = layerCollection && layerCollection.destroy();
*
* @see ImageryLayerCollection#isDestroyed
*/
ImageryLayerCollection.prototype.destroy = function() {
this.removeAll(true);
return destroyObject(this);
};
ImageryLayerCollection.prototype._update = function() {
var isBaseLayer = true;
var layers = this._layers;
var layersShownOrHidden;
var layer;
for (var i = 0, len = layers.length; i < len; ++i) {
layer = layers[i];
layer._layerIndex = i;
if (layer.show) {
layer._isBaseLayer = isBaseLayer;
isBaseLayer = false;
} else {
layer._isBaseLayer = false;
}
if (layer.show !== layer._show) {
if (defined(layer._show)) {
if (!defined(layersShownOrHidden)) {
layersShownOrHidden = [];
}
layersShownOrHidden.push(layer);
}
layer._show = layer.show;
}
}
if (defined(layersShownOrHidden)) {
for (i = 0, len = layersShownOrHidden.length; i < len; ++i) {
layer = layersShownOrHidden[i];
this.layerShownOrHidden.raiseEvent(layer, layer._layerIndex, layer.show);
}
}
};
return ImageryLayerCollection;
});
/*global define*/
define('Scene/QuadtreeOccluders',[
'../Core/Cartesian3',
'../Core/defineProperties',
'../Core/EllipsoidalOccluder'
], function(
Cartesian3,
defineProperties,
EllipsoidalOccluder) {
'use strict';
/**
* A set of occluders that can be used to test quadtree tiles for occlusion.
*
* @alias QuadtreeOccluders
* @constructor
* @private
*
* @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid that potentially occludes tiles.
*/
function QuadtreeOccluders(options) {
this._ellipsoid = new EllipsoidalOccluder(options.ellipsoid, Cartesian3.ZERO);
}
defineProperties(QuadtreeOccluders.prototype, {
/**
* Gets the {@link EllipsoidalOccluder} that can be used to determine if a point is
* occluded by an {@link Ellipsoid}.
* @type {EllipsoidalOccluder}
* @memberof QuadtreeOccluders.prototype
*/
ellipsoid : {
get : function() {
return this._ellipsoid;
}
}
});
return QuadtreeOccluders;
});
/*global define*/
define('Scene/QuadtreeTile',[
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/Rectangle',
'./QuadtreeTileLoadState'
], function(
defined,
defineProperties,
DeveloperError,
Rectangle,
QuadtreeTileLoadState) {
'use strict';
/**
* A single tile in a {@link QuadtreePrimitive}.
*
* @alias QuadtreeTile
* @constructor
* @private
*
* @param {Number} options.level The level of the tile in the quadtree.
* @param {Number} options.x The X coordinate of the tile in the quadtree. 0 is the westernmost tile.
* @param {Number} options.y The Y coordinate of the tile in the quadtree. 0 is the northernmost tile.
* @param {TilingScheme} options.tilingScheme The tiling scheme in which this tile exists.
* @param {QuadtreeTile} [options.parent] This tile's parent, or undefined if this is a root tile.
*/
function QuadtreeTile(options) {
if (!defined(options)) {
throw new DeveloperError('options is required.');
}
if (!defined(options.x)) {
throw new DeveloperError('options.x is required.');
} else if (!defined(options.y)) {
throw new DeveloperError('options.y is required.');
} else if (options.x < 0 || options.y < 0) {
throw new DeveloperError('options.x and options.y must be greater than or equal to zero.');
}
if (!defined(options.level)) {
throw new DeveloperError('options.level is required and must be greater than or equal to zero.');
}
if (!defined(options.tilingScheme)) {
throw new DeveloperError('options.tilingScheme is required.');
}
this._tilingScheme = options.tilingScheme;
this._x = options.x;
this._y = options.y;
this._level = options.level;
this._parent = options.parent;
this._rectangle = this._tilingScheme.tileXYToRectangle(this._x, this._y, this._level);
this._southwestChild = undefined;
this._southeastChild = undefined;
this._northwestChild = undefined;
this._northeastChild = undefined;
// QuadtreeTileReplacementQueue gets/sets these private properties.
this._replacementPrevious = undefined;
this._replacementNext = undefined;
// The distance from the camera to this tile, updated when the tile is selected
// for rendering. We can get rid of this if we have a better way to sort by
// distance - for example, by using the natural ordering of a quadtree.
// QuadtreePrimitive gets/sets this private property.
this._distance = 0.0;
this._customData = [];
this._frameUpdated = undefined;
this._frameRendered = undefined;
/**
* Gets or sets the current state of the tile in the tile load pipeline.
* @type {QuadtreeTileLoadState}
* @default {@link QuadtreeTileLoadState.START}
*/
this.state = QuadtreeTileLoadState.START;
/**
* Gets or sets a value indicating whether or not the tile is currently renderable.
* @type {Boolean}
* @default false
*/
this.renderable = false;
/**
* Gets or set a value indicating whether or not the tile was entire upsampled from its
* parent tile. If all four children of a parent tile were upsampled from the parent,
* we will render the parent instead of the children even if the LOD indicates that
* the children would be preferable.
* @type {Boolean}
* @default false
*/
this.upsampledFromParent = false;
/**
* Gets or sets the additional data associated with this tile. The exact content is specific to the
* {@link QuadtreeTileProvider}.
* @type {Object}
* @default undefined
*/
this.data = undefined;
}
/**
* Creates a rectangular set of tiles for level of detail zero, the coarsest, least detailed level.
*
* @memberof QuadtreeTile
*
* @param {TilingScheme} tilingScheme The tiling scheme for which the tiles are to be created.
* @returns {QuadtreeTile[]} An array containing the tiles at level of detail zero, starting with the
* tile in the northwest corner and followed by the tile (if any) to its east.
*/
QuadtreeTile.createLevelZeroTiles = function(tilingScheme) {
if (!defined(tilingScheme)) {
throw new DeveloperError('tilingScheme is required.');
}
var numberOfLevelZeroTilesX = tilingScheme.getNumberOfXTilesAtLevel(0);
var numberOfLevelZeroTilesY = tilingScheme.getNumberOfYTilesAtLevel(0);
var result = new Array(numberOfLevelZeroTilesX * numberOfLevelZeroTilesY);
var index = 0;
for (var y = 0; y < numberOfLevelZeroTilesY; ++y) {
for (var x = 0; x < numberOfLevelZeroTilesX; ++x) {
result[index++] = new QuadtreeTile({
tilingScheme : tilingScheme,
x : x,
y : y,
level : 0
});
}
}
return result;
};
QuadtreeTile.prototype._updateCustomData = function(frameNumber, added, removed) {
var customData = this.customData;
var i;
var data;
var rectangle;
if (defined(added) && defined(removed)) {
customData = customData.filter(function(value) {
return removed.indexOf(value) === -1;
});
this._customData = customData;
rectangle = this._rectangle;
for (i = 0; i < added.length; ++i) {
data = added[i];
if (Rectangle.contains(rectangle, data.positionCartographic)) {
customData.push(data);
}
}
this._frameUpdated = frameNumber;
} else {
// interior or leaf tile, update from parent
var parent = this._parent;
if (defined(parent) && this._frameUpdated !== parent._frameUpdated) {
customData.length = 0;
rectangle = this._rectangle;
var parentCustomData = parent.customData;
for (i = 0; i < parentCustomData.length; ++i) {
data = parentCustomData[i];
if (Rectangle.contains(rectangle, data.positionCartographic)) {
customData.push(data);
}
}
this._frameUpdated = parent._frameUpdated;
}
}
};
defineProperties(QuadtreeTile.prototype, {
/**
* Gets the tiling scheme used to tile the surface.
* @memberof QuadtreeTile.prototype
* @type {TilingScheme}
*/
tilingScheme : {
get : function() {
return this._tilingScheme;
}
},
/**
* Gets the tile X coordinate.
* @memberof QuadtreeTile.prototype
* @type {Number}
*/
x : {
get : function() {
return this._x;
}
},
/**
* Gets the tile Y coordinate.
* @memberof QuadtreeTile.prototype
* @type {Number}
*/
y : {
get : function() {
return this._y;
}
},
/**
* Gets the level-of-detail, where zero is the coarsest, least-detailed.
* @memberof QuadtreeTile.prototype
* @type {Number}
*/
level : {
get : function() {
return this._level;
}
},
/**
* Gets the parent tile of this tile.
* @memberof QuadtreeTile.prototype
* @type {QuadtreeTile}
*/
parent : {
get : function() {
return this._parent;
}
},
/**
* Gets the cartographic rectangle of the tile, with north, south, east and
* west properties in radians.
* @memberof QuadtreeTile.prototype
* @type {Rectangle}
*/
rectangle : {
get : function() {
return this._rectangle;
}
},
/**
* An array of tiles that is at the next level of the tile tree.
* @memberof QuadtreeTile.prototype
* @type {QuadtreeTile[]}
*/
children : {
get : function() {
return [this.northwestChild, this.northeastChild, this.southwestChild, this.southeastChild];
}
},
/**
* Gets the southwest child tile.
* @memberof QuadtreeTile.prototype
* @type {QuadtreeTile}
*/
southwestChild : {
get : function() {
if (!defined(this._southwestChild)) {
this._southwestChild = new QuadtreeTile({
tilingScheme : this.tilingScheme,
x : this.x * 2,
y : this.y * 2 + 1,
level : this.level + 1,
parent : this
});
}
return this._southwestChild;
}
},
/**
* Gets the southeast child tile.
* @memberof QuadtreeTile.prototype
* @type {QuadtreeTile}
*/
southeastChild : {
get : function() {
if (!defined(this._southeastChild)) {
this._southeastChild = new QuadtreeTile({
tilingScheme : this.tilingScheme,
x : this.x * 2 + 1,
y : this.y * 2 + 1,
level : this.level + 1,
parent : this
});
}
return this._southeastChild;
}
},
/**
* Gets the northwest child tile.
* @memberof QuadtreeTile.prototype
* @type {QuadtreeTile}
*/
northwestChild : {
get : function() {
if (!defined(this._northwestChild)) {
this._northwestChild = new QuadtreeTile({
tilingScheme : this.tilingScheme,
x : this.x * 2,
y : this.y * 2,
level : this.level + 1,
parent : this
});
}
return this._northwestChild;
}
},
/**
* Gets the northeast child tile.
* @memberof QuadtreeTile.prototype
* @type {QuadtreeTile}
*/
northeastChild : {
get : function() {
if (!defined(this._northeastChild)) {
this._northeastChild = new QuadtreeTile({
tilingScheme : this.tilingScheme,
x : this.x * 2 + 1,
y : this.y * 2,
level : this.level + 1,
parent : this
});
}
return this._northeastChild;
}
},
/**
* An array of objects associated with this tile.
* @memberof QuadtreeTile.prototype
* @type {Array}
*/
customData : {
get : function() {
return this._customData;
}
},
/**
* Gets a value indicating whether or not this tile needs further loading.
* This property will return true if the {@link QuadtreeTile#state} is
* <code>START</code> or <code>LOADING</code>.
* @memberof QuadtreeTile.prototype
* @type {Boolean}
*/
needsLoading : {
get : function() {
return this.state < QuadtreeTileLoadState.DONE;
}
},
/**
* Gets a value indicating whether or not this tile is eligible to be unloaded.
* Typically, a tile is ineligible to be unloaded while an asynchronous operation,
* such as a request for data, is in progress on it. A tile will never be
* unloaded while it is needed for rendering, regardless of the value of this
* property. If {@link QuadtreeTile#data} is defined and has an
* <code>eligibleForUnloading</code> property, the value of that property is returned.
* Otherwise, this property returns true.
* @memberof QuadtreeTile.prototype
* @type {Boolean}
*/
eligibleForUnloading : {
get : function() {
var result = true;
if (defined(this.data)) {
result = this.data.eligibleForUnloading;
if (!defined(result)) {
result = true;
}
}
return result;
}
}
});
/**
* Frees the resources associated with this tile and returns it to the <code>START</code>
* {@link QuadtreeTileLoadState}. If the {@link QuadtreeTile#data} property is defined and it
* has a <code>freeResources</code> method, the method will be invoked.
*
* @memberof QuadtreeTile
*/
QuadtreeTile.prototype.freeResources = function() {
this.state = QuadtreeTileLoadState.START;
this.renderable = false;
this.upsampledFromParent = false;
if (defined(this.data) && defined(this.data.freeResources)) {
this.data.freeResources();
}
freeTile(this._southwestChild);
this._southwestChild = undefined;
freeTile(this._southeastChild);
this._southeastChild = undefined;
freeTile(this._northwestChild);
this._northwestChild = undefined;
freeTile(this._northeastChild);
this._northeastChild = undefined;
};
function freeTile(tile) {
if (defined(tile)) {
tile.freeResources();
}
}
return QuadtreeTile;
});
/*global define*/
define('Scene/TileReplacementQueue',[
'../Core/defined'
], function(
defined) {
'use strict';
/**
* A priority queue of tiles to be replaced, if necessary, to make room for new tiles. The queue
* is implemented as a linked list.
*
* @alias TileReplacementQueue
* @private
*/
function TileReplacementQueue() {
this.head = undefined;
this.tail = undefined;
this.count = 0;
this._lastBeforeStartOfFrame = undefined;
}
/**
* Marks the start of the render frame. Tiles before (closer to the head) this tile in the
* list were used last frame and must not be unloaded.
*/
TileReplacementQueue.prototype.markStartOfRenderFrame = function() {
this._lastBeforeStartOfFrame = this.head;
};
/**
* Reduces the size of the queue to a specified size by unloading the least-recently used
* tiles. Tiles that were used last frame will not be unloaded, even if that puts the number
* of tiles above the specified maximum.
*
* @param {Number} maximumTiles The maximum number of tiles in the queue.
*/
TileReplacementQueue.prototype.trimTiles = function(maximumTiles) {
var tileToTrim = this.tail;
var keepTrimming = true;
while (keepTrimming &&
defined(this._lastBeforeStartOfFrame) &&
this.count > maximumTiles &&
defined(tileToTrim)) {
// Stop trimming after we process the last tile not used in the
// current frame.
keepTrimming = tileToTrim !== this._lastBeforeStartOfFrame;
var previous = tileToTrim.replacementPrevious;
if (tileToTrim.eligibleForUnloading) {
tileToTrim.freeResources();
remove(this, tileToTrim);
}
tileToTrim = previous;
}
};
function remove(tileReplacementQueue, item) {
var previous = item.replacementPrevious;
var next = item.replacementNext;
if (item === tileReplacementQueue._lastBeforeStartOfFrame) {
tileReplacementQueue._lastBeforeStartOfFrame = next;
}
if (item === tileReplacementQueue.head) {
tileReplacementQueue.head = next;
} else {
previous.replacementNext = next;
}
if (item === tileReplacementQueue.tail) {
tileReplacementQueue.tail = previous;
} else {
next.replacementPrevious = previous;
}
item.replacementPrevious = undefined;
item.replacementNext = undefined;
--tileReplacementQueue.count;
}
/**
* Marks a tile as rendered this frame and moves it before the first tile that was not rendered
* this frame.
*
* @param {TileReplacementQueue} item The tile that was rendered.
*/
TileReplacementQueue.prototype.markTileRendered = function(item) {
var head = this.head;
if (head === item) {
if (item === this._lastBeforeStartOfFrame) {
this._lastBeforeStartOfFrame = item.replacementNext;
}
return;
}
++this.count;
if (!defined(head)) {
// no other tiles in the list
item.replacementPrevious = undefined;
item.replacementNext = undefined;
this.head = item;
this.tail = item;
return;
}
if (defined(item.replacementPrevious) || defined(item.replacementNext)) {
// tile already in the list, remove from its current location
remove(this, item);
}
item.replacementPrevious = undefined;
item.replacementNext = head;
head.replacementPrevious = item;
this.head = item;
};
return TileReplacementQueue;
});
/*global define*/
define('Scene/QuadtreePrimitive',[
'../Core/Cartesian3',
'../Core/Cartographic',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/Event',
'../Core/getTimestamp',
'../Core/Math',
'../Core/Queue',
'../Core/Ray',
'../Core/Rectangle',
'../Core/Visibility',
'./QuadtreeOccluders',
'./QuadtreeTile',
'./QuadtreeTileLoadState',
'./SceneMode',
'./TileReplacementQueue'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
defineProperties,
DeveloperError,
Event,
getTimestamp,
CesiumMath,
Queue,
Ray,
Rectangle,
Visibility,
QuadtreeOccluders,
QuadtreeTile,
QuadtreeTileLoadState,
SceneMode,
TileReplacementQueue) {
'use strict';
/**
* Renders massive sets of data by utilizing level-of-detail and culling. The globe surface is divided into
* a quadtree of tiles with large, low-detail tiles at the root and small, high-detail tiles at the leaves.
* The set of tiles to render is selected by projecting an estimate of the geometric error in a tile onto
* the screen to estimate screen-space error, in pixels, which must be below a user-specified threshold.
* The actual content of the tiles is arbitrary and is specified using a {@link QuadtreeTileProvider}.
*
* @alias QuadtreePrimitive
* @constructor
* @private
*
* @param {QuadtreeTileProvider} options.tileProvider The tile provider that loads, renders, and estimates
* the distance to individual tiles.
* @param {Number} [options.maximumScreenSpaceError=2] The maximum screen-space error, in pixels, that is allowed.
* A higher maximum error will render fewer tiles and improve performance, while a lower
* value will improve visual quality.
* @param {Number} [options.tileCacheSize=100] The maximum number of tiles that will be retained in the tile cache.
* Note that tiles will never be unloaded if they were used for rendering the last
* frame, so the actual number of resident tiles may be higher. The value of
* this property will not affect visual quality.
*/
function QuadtreePrimitive(options) {
if (!defined(options) || !defined(options.tileProvider)) {
throw new DeveloperError('options.tileProvider is required.');
}
if (defined(options.tileProvider.quadtree)) {
throw new DeveloperError('A QuadtreeTileProvider can only be used with a single QuadtreePrimitive');
}
this._tileProvider = options.tileProvider;
this._tileProvider.quadtree = this;
this._debug = {
enableDebugOutput : false,
maxDepth : 0,
tilesVisited : 0,
tilesCulled : 0,
tilesRendered : 0,
tilesWaitingForChildren : 0,
lastMaxDepth : -1,
lastTilesVisited : -1,
lastTilesCulled : -1,
lastTilesRendered : -1,
lastTilesWaitingForChildren : -1,
suspendLodUpdate : false
};
var tilingScheme = this._tileProvider.tilingScheme;
var ellipsoid = tilingScheme.ellipsoid;
this._tilesToRender = [];
this._tileLoadQueueHigh = []; // high priority tiles are preventing refinement
this._tileLoadQueueMedium = []; // medium priority tiles are being rendered
this._tileLoadQueueLow = []; // low priority tiles were refined past or are non-visible parts of quads.
this._tileReplacementQueue = new TileReplacementQueue();
this._levelZeroTiles = undefined;
this._levelZeroTilesReady = false;
this._loadQueueTimeSlice = 5.0;
this._addHeightCallbacks = [];
this._removeHeightCallbacks = [];
this._tileToUpdateHeights = [];
this._lastTileIndex = 0;
this._updateHeightsTimeSlice = 2.0;
/**
* Gets or sets the maximum screen-space error, in pixels, that is allowed.
* A higher maximum error will render fewer tiles and improve performance, while a lower
* value will improve visual quality.
* @type {Number}
* @default 2
*/
this.maximumScreenSpaceError = defaultValue(options.maximumScreenSpaceError, 2);
/**
* Gets or sets the maximum number of tiles that will be retained in the tile cache.
* Note that tiles will never be unloaded if they were used for rendering the last
* frame, so the actual number of resident tiles may be higher. The value of
* this property will not affect visual quality.
* @type {Number}
* @default 100
*/
this.tileCacheSize = defaultValue(options.tileCacheSize, 100);
this._occluders = new QuadtreeOccluders({
ellipsoid : ellipsoid
});
this._tileLoadProgressEvent = new Event();
this._lastTileLoadQueueLength = 0;
}
defineProperties(QuadtreePrimitive.prototype, {
/**
* Gets the provider of {@link QuadtreeTile} instances for this quadtree.
* @type {QuadtreeTile}
* @memberof QuadtreePrimitive.prototype
*/
tileProvider : {
get : function() {
return this._tileProvider;
}
},
/**
* Gets an event that's raised when the length of the tile load queue has changed since the last render frame. When the load queue is empty,
* all terrain and imagery for the current view have been loaded. The event passes the new length of the tile load queue.
*
* @memberof QuadtreePrimitive.prototype
* @type {Event}
*/
tileLoadProgressEvent : {
get : function() {
return this._tileLoadProgressEvent;
}
}
});
/**
* Invalidates and frees all the tiles in the quadtree. The tiles must be reloaded
* before they can be displayed.
*
* @memberof QuadtreePrimitive
*/
QuadtreePrimitive.prototype.invalidateAllTiles = function() {
// Clear the replacement queue
var replacementQueue = this._tileReplacementQueue;
replacementQueue.head = undefined;
replacementQueue.tail = undefined;
replacementQueue.count = 0;
// Free and recreate the level zero tiles.
var levelZeroTiles = this._levelZeroTiles;
if (defined(levelZeroTiles)) {
for (var i = 0; i < levelZeroTiles.length; ++i) {
var tile = levelZeroTiles[i];
var customData = tile.customData;
var customDataLength = customData.length;
for (var j = 0; j < customDataLength; ++j) {
var data = customData[j];
data.level = 0;
this._addHeightCallbacks.push(data);
}
levelZeroTiles[i].freeResources();
}
}
this._levelZeroTiles = undefined;
this._tileProvider.cancelReprojections();
};
/**
* Invokes a specified function for each {@link QuadtreeTile} that is partially
* or completely loaded.
*
* @param {Function} tileFunction The function to invoke for each loaded tile. The
* function is passed a reference to the tile as its only parameter.
*/
QuadtreePrimitive.prototype.forEachLoadedTile = function(tileFunction) {
var tile = this._tileReplacementQueue.head;
while (defined(tile)) {
if (tile.state !== QuadtreeTileLoadState.START) {
tileFunction(tile);
}
tile = tile.replacementNext;
}
};
/**
* Invokes a specified function for each {@link QuadtreeTile} that was rendered
* in the most recent frame.
*
* @param {Function} tileFunction The function to invoke for each rendered tile. The
* function is passed a reference to the tile as its only parameter.
*/
QuadtreePrimitive.prototype.forEachRenderedTile = function(tileFunction) {
var tilesRendered = this._tilesToRender;
for (var i = 0, len = tilesRendered.length; i < len; ++i) {
tileFunction(tilesRendered[i]);
}
};
/**
* Calls the callback when a new tile is rendered that contains the given cartographic. The only parameter
* is the cartesian position on the tile.
*
* @param {Cartographic} cartographic The cartographic position.
* @param {Function} callback The function to be called when a new tile is loaded containing cartographic.
* @returns {Function} The function to remove this callback from the quadtree.
*/
QuadtreePrimitive.prototype.updateHeight = function(cartographic, callback) {
var primitive = this;
var object = {
positionOnEllipsoidSurface : undefined,
positionCartographic : cartographic,
level : -1,
callback : callback
};
object.removeFunc = function() {
var addedCallbacks = primitive._addHeightCallbacks;
var length = addedCallbacks.length;
for (var i = 0; i < length; ++i) {
if (addedCallbacks[i] === object) {
addedCallbacks.splice(i, 1);
break;
}
}
primitive._removeHeightCallbacks.push(object);
};
primitive._addHeightCallbacks.push(object);
return object.removeFunc;
};
/**
* @private
*/
QuadtreePrimitive.prototype.beginFrame = function(frameState) {
var passes = frameState.passes;
if (!passes.render) {
return;
}
// Gets commands for any texture re-projections and updates the credit display
this._tileProvider.initialize(frameState);
var debug = this._debug;
if (debug.suspendLodUpdate) {
return;
}
debug.maxDepth = 0;
debug.tilesVisited = 0;
debug.tilesCulled = 0;
debug.tilesRendered = 0;
debug.tilesWaitingForChildren = 0;
this._tileLoadQueueHigh.length = 0;
this._tileLoadQueueMedium.length = 0;
this._tileLoadQueueLow.length = 0;
this._tileReplacementQueue.markStartOfRenderFrame();
};
/**
* @private
*/
QuadtreePrimitive.prototype.update = function(frameState) {
var passes = frameState.passes;
if (passes.render) {
this._tileProvider.beginUpdate(frameState);
selectTilesForRendering(this, frameState);
createRenderCommandsForSelectedTiles(this, frameState);
this._tileProvider.endUpdate(frameState);
}
if (passes.pick && this._tilesToRender.length > 0) {
this._tileProvider.updateForPick(frameState);
}
};
/**
* @private
*/
QuadtreePrimitive.prototype.endFrame = function(frameState) {
var passes = frameState.passes;
if (!passes.render || frameState.mode === SceneMode.MORPHING) {
// Only process the load queue for a single pass.
// Don't process the load queue or update heights during the morph flights.
return;
}
// Load/create resources for terrain and imagery. Prepare texture re-projections for the next frame.
processTileLoadQueue(this, frameState);
updateHeights(this, frameState);
var debug = this._debug;
if (debug.suspendLodUpdate) {
return;
}
if (debug.enableDebugOutput) {
if (debug.tilesVisited !== debug.lastTilesVisited ||
debug.tilesRendered !== debug.lastTilesRendered ||
debug.tilesCulled !== debug.lastTilesCulled ||
debug.maxDepth !== debug.lastMaxDepth ||
debug.tilesWaitingForChildren !== debug.lastTilesWaitingForChildren) {
console.log('Visited ' + debug.tilesVisited + ', Rendered: ' + debug.tilesRendered + ', Culled: ' + debug.tilesCulled + ', Max Depth: ' + debug.maxDepth + ', Waiting for children: ' + debug.tilesWaitingForChildren);
debug.lastTilesVisited = debug.tilesVisited;
debug.lastTilesRendered = debug.tilesRendered;
debug.lastTilesCulled = debug.tilesCulled;
debug.lastMaxDepth = debug.maxDepth;
debug.lastTilesWaitingForChildren = debug.tilesWaitingForChildren;
}
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @memberof QuadtreePrimitive
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see QuadtreePrimitive#destroy
*/
QuadtreePrimitive.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @memberof QuadtreePrimitive
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* primitive = primitive && primitive.destroy();
*
* @see QuadtreePrimitive#isDestroyed
*/
QuadtreePrimitive.prototype.destroy = function() {
this._tileProvider = this._tileProvider && this._tileProvider.destroy();
};
var comparisonPoint;
var centerScratch = new Cartographic();
function compareDistanceToPoint(a, b) {
var center = Rectangle.center(a.rectangle, centerScratch);
var alon = center.longitude - comparisonPoint.longitude;
var alat = center.latitude - comparisonPoint.latitude;
center = Rectangle.center(b.rectangle, centerScratch);
var blon = center.longitude - comparisonPoint.longitude;
var blat = center.latitude - comparisonPoint.latitude;
return (alon * alon + alat * alat) - (blon * blon + blat * blat);
}
function selectTilesForRendering(primitive, frameState) {
var debug = primitive._debug;
if (debug.suspendLodUpdate) {
return;
}
var i;
var len;
// Clear the render list.
var tilesToRender = primitive._tilesToRender;
tilesToRender.length = 0;
// We can't render anything before the level zero tiles exist.
if (!defined(primitive._levelZeroTiles)) {
if (primitive._tileProvider.ready) {
var tilingScheme = primitive._tileProvider.tilingScheme;
primitive._levelZeroTiles = QuadtreeTile.createLevelZeroTiles(tilingScheme);
} else {
// Nothing to do until the provider is ready.
return;
}
}
primitive._occluders.ellipsoid.cameraPosition = frameState.camera.positionWC;
var tileProvider = primitive._tileProvider;
var occluders = primitive._occluders;
var tile;
var levelZeroTiles = primitive._levelZeroTiles;
// Sort the level zero tiles by the distance from the center to the camera.
// The level zero tiles aren't necessarily a nice neat quad, so we can use the
// quadtree ordering we use elsewhere in the tree
comparisonPoint = frameState.camera.positionCartographic;
levelZeroTiles.sort(compareDistanceToPoint);
var customDataAdded = primitive._addHeightCallbacks;
var customDataRemoved = primitive._removeHeightCallbacks;
var frameNumber = frameState.frameNumber;
if (customDataAdded.length > 0 || customDataRemoved.length > 0) {
for (i = 0, len = levelZeroTiles.length; i < len; ++i) {
tile = levelZeroTiles[i];
tile._updateCustomData(frameNumber, customDataAdded, customDataRemoved);
}
customDataAdded.length = 0;
customDataRemoved.length = 0;
}
// Our goal with load ordering is to first load all of the tiles we need to
// render the current scene at full detail. Loading any other tiles is just
// a form of prefetching, and we need not do it at all (other concerns aside). This
// simple and obvious statement gets more complicated when we realize that, because
// we don't have bounding volumes for the entire terrain tile pyramid, we don't
// precisely know which tiles we need to render the scene at full detail, until we do
// some loading.
//
// So our load priority is (from high to low):
// 1. Tiles that we _would_ render, except that they're not sufficiently loaded yet.
// Ideally this would only include tiles that we've already determined to be visible,
// but since we don't have reliable visibility information until a tile is loaded,
// and because we (currently) must have all children in a quad renderable before we
// can refine, this pretty much means tiles we'd like to refine to, regardless of
// visibility. (high)
// 2. Tiles that we're rendering. (medium)
// 3. All other tiles. (low)
//
// Within each priority group, tiles should be loaded in approximate near-to-far order,
// but currently they're just loaded in our traversal order which makes no guarantees
// about depth ordering.
// Traverse in depth-first, near-to-far order.
for (i = 0, len = levelZeroTiles.length; i < len; ++i) {
tile = levelZeroTiles[i];
primitive._tileReplacementQueue.markTileRendered(tile);
if (!tile.renderable) {
if (tile.needsLoading) {
primitive._tileLoadQueueHigh.push(tile);
}
++debug.tilesWaitingForChildren;
} else if (tileProvider.computeTileVisibility(tile, frameState, occluders) !== Visibility.NONE) {
visitTile(primitive, frameState, tile);
} else {
if (tile.needsLoading) {
primitive._tileLoadQueueLow.push(tile);
}
++debug.tilesCulled;
}
}
raiseTileLoadProgressEvent(primitive);
}
function visitTile(primitive, frameState, tile) {
var debug = primitive._debug;
++debug.tilesVisited;
primitive._tileReplacementQueue.markTileRendered(tile);
tile._updateCustomData(frameState.frameNumber);
if (tile.level > debug.maxDepth) {
debug.maxDepth = tile.level;
}
if (screenSpaceError(primitive, frameState, tile) < primitive.maximumScreenSpaceError) {
// This tile meets SSE requirements, so render it.
if (tile.needsLoading) {
// Rendered tile meeting SSE loads with medium priority.
primitive._tileLoadQueueMedium.push(tile);
}
addTileToRenderList(primitive, tile);
return;
}
var southwestChild = tile.southwestChild;
var southeastChild = tile.southeastChild;
var northwestChild = tile.northwestChild;
var northeastChild = tile.northeastChild;
var allAreRenderable = southwestChild.renderable && southeastChild.renderable &&
northwestChild.renderable && northeastChild.renderable;
var allAreUpsampled = southwestChild.upsampledFromParent && southeastChild.upsampledFromParent &&
northwestChild.upsampledFromParent && northeastChild.upsampledFromParent;
if (allAreRenderable) {
if (allAreUpsampled) {
// No point in rendering the children because they're all upsampled. Render this tile instead.
addTileToRenderList(primitive, tile);
// Load the children even though we're (currently) not going to render them.
// A tile that is "upsampled only" right now might change its tune once it does more loading.
// A tile that is upsampled now and forever should also be done loading, so no harm done.
queueChildLoadNearToFar(primitive, frameState.camera.positionCartographic, southwestChild, southeastChild, northwestChild, northeastChild);
if (tile.needsLoading) {
// Rendered tile that's not waiting on children loads with medium priority.
primitive._tileLoadQueueMedium.push(tile);
}
} else {
// SSE is not good enough and children are loaded, so refine.
// No need to add the children to the load queue because they'll be added (if necessary) when they're visited.
visitVisibleChildrenNearToFar(primitive, southwestChild, southeastChild, northwestChild, northeastChild, frameState);
if (tile.needsLoading) {
// Tile is not rendered, so load it with low priority.
primitive._tileLoadQueueLow.push(tile);
}
}
} else {
// We'd like to refine but can't because not all of our children are renderable. Load the refinement blockers with high priority and
// render this tile in the meantime.
queueChildLoadNearToFar(primitive, frameState.camera.positionCartographic, southwestChild, southeastChild, northwestChild, northeastChild);
addTileToRenderList(primitive, tile);
if (tile.needsLoading) {
// We will refine this tile when it's possible, so load this tile only with low priority.
primitive._tileLoadQueueLow.push(tile);
}
}
}
function queueChildLoadNearToFar(primitive, cameraPosition, southwest, southeast, northwest, northeast) {
if (cameraPosition.longitude < southwest.east) {
if (cameraPosition.latitude < southwest.north) {
// Camera in southwest quadrant
queueChildTileLoad(primitive, southwest);
queueChildTileLoad(primitive, southeast);
queueChildTileLoad(primitive, northwest);
queueChildTileLoad(primitive, northeast);
} else {
// Camera in northwest quadrant
queueChildTileLoad(primitive, northwest);
queueChildTileLoad(primitive, southwest);
queueChildTileLoad(primitive, northeast);
queueChildTileLoad(primitive, southeast);
}
} else {
if (cameraPosition.latitude < southwest.north) {
// Camera southeast quadrant
queueChildTileLoad(primitive, southeast);
queueChildTileLoad(primitive, southwest);
queueChildTileLoad(primitive, northeast);
queueChildTileLoad(primitive, northwest);
} else {
// Camera in northeast quadrant
queueChildTileLoad(primitive, northeast);
queueChildTileLoad(primitive, northwest);
queueChildTileLoad(primitive, southeast);
queueChildTileLoad(primitive, southwest);
}
}
}
function queueChildTileLoad(primitive, childTile) {
primitive._tileReplacementQueue.markTileRendered(childTile);
if (childTile.needsLoading) {
if (childTile.renderable) {
primitive._tileLoadQueueLow.push(childTile);
} else {
// A tile blocking refine loads with high priority
primitive._tileLoadQueueHigh.push(childTile);
}
}
}
function visitVisibleChildrenNearToFar(primitive, southwest, southeast, northwest, northeast, frameState) {
var cameraPosition = frameState.camera.positionCartographic;
var tileProvider = primitive._tileProvider;
var occluders = primitive._occluders;
if (cameraPosition.longitude < southwest.rectangle.east) {
if (cameraPosition.latitude < southwest.rectangle.north) {
// Camera in southwest quadrant
visitIfVisible(primitive, southwest, tileProvider, frameState, occluders);
visitIfVisible(primitive, southeast, tileProvider, frameState, occluders);
visitIfVisible(primitive, northwest, tileProvider, frameState, occluders);
visitIfVisible(primitive, northeast, tileProvider, frameState, occluders);
} else {
// Camera in northwest quadrant
visitIfVisible(primitive, northwest, tileProvider, frameState, occluders);
visitIfVisible(primitive, southwest, tileProvider, frameState, occluders);
visitIfVisible(primitive, northeast, tileProvider, frameState, occluders);
visitIfVisible(primitive, southeast, tileProvider, frameState, occluders);
}
} else {
if (cameraPosition.latitude < southwest.rectangle.north) {
// Camera southeast quadrant
visitIfVisible(primitive, southeast, tileProvider, frameState, occluders);
visitIfVisible(primitive, southwest, tileProvider, frameState, occluders);
visitIfVisible(primitive, northeast, tileProvider, frameState, occluders);
visitIfVisible(primitive, northwest, tileProvider, frameState, occluders);
} else {
// Camera in northeast quadrant
visitIfVisible(primitive, northeast, tileProvider, frameState, occluders);
visitIfVisible(primitive, northwest, tileProvider, frameState, occluders);
visitIfVisible(primitive, southeast, tileProvider, frameState, occluders);
visitIfVisible(primitive, southwest, tileProvider, frameState, occluders);
}
}
}
function visitIfVisible(primitive, tile, tileProvider, frameState, occluders) {
if (tileProvider.computeTileVisibility(tile, frameState, occluders) !== Visibility.NONE) {
visitTile(primitive, frameState, tile);
} else {
++primitive._debug.tilesCulled;
primitive._tileReplacementQueue.markTileRendered(tile);
}
}
/**
* Checks if the load queue length has changed since the last time we raised a queue change event - if so, raises
* a new one.
*/
function raiseTileLoadProgressEvent(primitive) {
var currentLoadQueueLength = primitive._tileLoadQueueHigh.length + primitive._tileLoadQueueMedium.length + primitive._tileLoadQueueLow.length;
if (currentLoadQueueLength !== primitive._lastTileLoadQueueLength) {
primitive._tileLoadProgressEvent.raiseEvent(currentLoadQueueLength);
primitive._lastTileLoadQueueLength = currentLoadQueueLength;
}
}
function screenSpaceError(primitive, frameState, tile) {
if (frameState.mode === SceneMode.SCENE2D) {
return screenSpaceError2D(primitive, frameState, tile);
}
var maxGeometricError = primitive._tileProvider.getLevelMaximumGeometricError(tile.level);
var distance = tile._distance;
var height = frameState.context.drawingBufferHeight;
var sseDenominator = frameState.camera.frustum.sseDenominator;
var error = (maxGeometricError * height) / (distance * sseDenominator);
if (frameState.fog.enabled) {
error = error - CesiumMath.fog(distance, frameState.fog.density) * frameState.fog.sse;
}
return error;
}
function screenSpaceError2D(primitive, frameState, tile) {
var camera = frameState.camera;
var frustum = camera.frustum;
var context = frameState.context;
var width = context.drawingBufferWidth;
var height = context.drawingBufferHeight;
var maxGeometricError = primitive._tileProvider.getLevelMaximumGeometricError(tile.level);
var pixelSize = Math.max(frustum.top - frustum.bottom, frustum.right - frustum.left) / Math.max(width, height);
return maxGeometricError / pixelSize;
}
function addTileToRenderList(primitive, tile) {
primitive._tilesToRender.push(tile);
++primitive._debug.tilesRendered;
}
function processTileLoadQueue(primitive, frameState) {
var tileLoadQueueHigh = primitive._tileLoadQueueHigh;
var tileLoadQueueMedium = primitive._tileLoadQueueMedium;
var tileLoadQueueLow = primitive._tileLoadQueueLow;
var tileProvider = primitive._tileProvider;
if (tileLoadQueueHigh.length === 0 && tileLoadQueueMedium.length === 0 && tileLoadQueueLow.length === 0) {
return;
}
// Remove any tiles that were not used this frame beyond the number
// we're allowed to keep.
primitive._tileReplacementQueue.trimTiles(primitive.tileCacheSize);
var endTime = getTimestamp() + primitive._loadQueueTimeSlice;
processSinglePriorityLoadQueue(primitive, frameState, tileProvider, endTime, tileLoadQueueHigh);
processSinglePriorityLoadQueue(primitive, frameState, tileProvider, endTime, tileLoadQueueMedium);
processSinglePriorityLoadQueue(primitive, frameState, tileProvider, endTime, tileLoadQueueLow);
}
function processSinglePriorityLoadQueue(primitive, frameState, tileProvider, endTime, loadQueue) {
for (var i = 0, len = loadQueue.length; i < len && getTimestamp() < endTime; ++i) {
var tile = loadQueue[i];
primitive._tileReplacementQueue.markTileRendered(tile);
tileProvider.loadTile(frameState, tile);
}
}
var scratchRay = new Ray();
var scratchCartographic = new Cartographic();
var scratchPosition = new Cartesian3();
function updateHeights(primitive, frameState) {
var tilesToUpdateHeights = primitive._tileToUpdateHeights;
var terrainProvider = primitive._tileProvider.terrainProvider;
var startTime = getTimestamp();
var timeSlice = primitive._updateHeightsTimeSlice;
var endTime = startTime + timeSlice;
var mode = frameState.mode;
var projection = frameState.mapProjection;
var ellipsoid = projection.ellipsoid;
while (tilesToUpdateHeights.length > 0) {
var tile = tilesToUpdateHeights[0];
var customData = tile.customData;
var customDataLength = customData.length;
var timeSliceMax = false;
for (var i = primitive._lastTileIndex; i < customDataLength; ++i) {
var data = customData[i];
if (tile.level > data.level) {
if (!defined(data.positionOnEllipsoidSurface)) {
// cartesian has to be on the ellipsoid surface for `ellipsoid.geodeticSurfaceNormal`
data.positionOnEllipsoidSurface = Cartesian3.fromRadians(data.positionCartographic.longitude, data.positionCartographic.latitude, 0.0, ellipsoid);
}
if (mode === SceneMode.SCENE3D) {
var surfaceNormal = ellipsoid.geodeticSurfaceNormal(data.positionOnEllipsoidSurface, scratchRay.direction);
// compute origin point
// Try to find the intersection point between the surface normal and z-axis.
// minimum height (-11500.0) for the terrain set, need to get this information from the terrain provider
var rayOrigin = ellipsoid.getSurfaceNormalIntersectionWithZAxis(data.positionOnEllipsoidSurface, 11500.0, scratchRay.origin);
// Theoretically, not with Earth datums, the intersection point can be outside the ellipsoid
if (!defined(rayOrigin)) {
// intersection point is outside the ellipsoid, try other value
// minimum height (-11500.0) for the terrain set, need to get this information from the terrain provider
var magnitude = Math.min(defaultValue(tile.data.minimumHeight, 0.0),-11500.0);
// multiply by the *positive* value of the magnitude
var vectorToMinimumPoint = Cartesian3.multiplyByScalar(surfaceNormal, Math.abs(magnitude) + 1, scratchPosition);
Cartesian3.subtract(data.positionOnEllipsoidSurface, vectorToMinimumPoint, scratchRay.origin);
}
} else {
Cartographic.clone(data.positionCartographic, scratchCartographic);
// minimum height for the terrain set, need to get this information from the terrain provider
scratchCartographic.height = -11500.0;
projection.project(scratchCartographic, scratchPosition);
Cartesian3.fromElements(scratchPosition.z, scratchPosition.x, scratchPosition.y, scratchPosition);
Cartesian3.clone(scratchPosition, scratchRay.origin);
Cartesian3.clone(Cartesian3.UNIT_X, scratchRay.direction);
}
var position = tile.data.pick(scratchRay, mode, projection, false, scratchPosition);
if (defined(position)) {
data.callback(position);
}
data.level = tile.level;
} else if (tile.level === data.level) {
var children = tile.children;
var childrenLength = children.length;
var child;
for (var j = 0; j < childrenLength; ++j) {
child = children[j];
if (Rectangle.contains(child.rectangle, data.positionCartographic)) {
break;
}
}
var tileDataAvailable = terrainProvider.getTileDataAvailable(child.x, child.y, child.level);
var parentTile = tile.parent;
if ((defined(tileDataAvailable) && !tileDataAvailable) ||
(defined(parentTile) && defined(parentTile.data) && defined(parentTile.data.terrainData) &&
!parentTile.data.terrainData.isChildAvailable(parentTile.x, parentTile.y, child.x, child.y))) {
data.removeFunc();
}
}
if (getTimestamp() >= endTime) {
timeSliceMax = true;
break;
}
}
if (timeSliceMax) {
primitive._lastTileIndex = i;
break;
} else {
primitive._lastTileIndex = 0;
tilesToUpdateHeights.shift();
}
}
}
function createRenderCommandsForSelectedTiles(primitive, frameState) {
var tileProvider = primitive._tileProvider;
var tilesToRender = primitive._tilesToRender;
var tilesToUpdateHeights = primitive._tileToUpdateHeights;
for (var i = 0, len = tilesToRender.length; i < len; ++i) {
var tile = tilesToRender[i];
tileProvider.showTileThisFrame(tile, frameState);
if (tile._frameRendered !== frameState.frameNumber - 1) {
tilesToUpdateHeights.push(tile);
}
tile._frameRendered = frameState.frameNumber;
}
}
return QuadtreePrimitive;
});
/*global define*/
define('Scene/Globe',[
'../Core/BoundingSphere',
'../Core/buildModuleUrl',
'../Core/Cartesian3',
'../Core/Cartographic',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/Ellipsoid',
'../Core/EllipsoidTerrainProvider',
'../Core/Event',
'../Core/IntersectionTests',
'../Core/loadImage',
'../Core/Math',
'../Core/Ray',
'../Core/Rectangle',
'../Renderer/ShaderSource',
'../Renderer/Texture',
'../Shaders/GlobeFS',
'../Shaders/GlobeVS',
'../Shaders/GroundAtmosphere',
'../ThirdParty/when',
'./GlobeSurfaceShaderSet',
'./GlobeSurfaceTileProvider',
'./ImageryLayerCollection',
'./QuadtreePrimitive',
'./SceneMode',
'./ShadowMode'
], function(
BoundingSphere,
buildModuleUrl,
Cartesian3,
Cartographic,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
Ellipsoid,
EllipsoidTerrainProvider,
Event,
IntersectionTests,
loadImage,
CesiumMath,
Ray,
Rectangle,
ShaderSource,
Texture,
GlobeFS,
GlobeVS,
GroundAtmosphere,
when,
GlobeSurfaceShaderSet,
GlobeSurfaceTileProvider,
ImageryLayerCollection,
QuadtreePrimitive,
SceneMode,
ShadowMode) {
'use strict';
/**
* The globe rendered in the scene, including its terrain ({@link Globe#terrainProvider})
* and imagery layers ({@link Globe#imageryLayers}). Access the globe using {@link Scene#globe}.
*
* @alias Globe
* @constructor
*
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] Determines the size and shape of the
* globe.
*/
function Globe(ellipsoid) {
ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
var terrainProvider = new EllipsoidTerrainProvider({
ellipsoid : ellipsoid
});
var imageryLayerCollection = new ImageryLayerCollection();
this._ellipsoid = ellipsoid;
this._imageryLayerCollection = imageryLayerCollection;
this._surfaceShaderSet = new GlobeSurfaceShaderSet();
this._surfaceShaderSet.baseVertexShaderSource = new ShaderSource({
sources : [GroundAtmosphere, GlobeVS]
});
this._surfaceShaderSet.baseFragmentShaderSource = new ShaderSource({
sources : [GlobeFS]
});
this._surface = new QuadtreePrimitive({
tileProvider : new GlobeSurfaceTileProvider({
terrainProvider : terrainProvider,
imageryLayers : imageryLayerCollection,
surfaceShaderSet : this._surfaceShaderSet
})
});
this._terrainProvider = terrainProvider;
this._terrainProviderChanged = new Event();
/**
* Determines if the globe will be shown.
*
* @type {Boolean}
* @default true
*/
this.show = true;
/**
* The normal map to use for rendering waves in the ocean. Setting this property will
* only have an effect if the configured terrain provider includes a water mask.
*
* @type {String}
* @default buildModuleUrl('Assets/Textures/waterNormalsSmall.jpg')
*/
this.oceanNormalMapUrl = buildModuleUrl('Assets/Textures/waterNormalsSmall.jpg');
this._oceanNormalMapUrl = undefined;
/**
* The maximum screen-space error used to drive level-of-detail refinement. Higher
* values will provide better performance but lower visual quality.
*
* @type {Number}
* @default 2
*/
this.maximumScreenSpaceError = 2;
/**
* The size of the terrain tile cache, expressed as a number of tiles. Any additional
* tiles beyond this number will be freed, as long as they aren't needed for rendering
* this frame. A larger number will consume more memory but will show detail faster
* when, for example, zooming out and then back in.
*
* @type {Number}
* @default 100
*/
this.tileCacheSize = 100;
/**
* Enable lighting the globe with the sun as a light source.
*
* @type {Boolean}
* @default false
*/
this.enableLighting = false;
/**
* The distance where everything becomes lit. This only takes effect
* when <code>enableLighting</code> is <code>true</code>.
*
* @type {Number}
* @default 6500000.0
*/
this.lightingFadeOutDistance = 6500000.0;
/**
* The distance where lighting resumes. This only takes effect
* when <code>enableLighting</code> is <code>true</code>.
*
* @type {Number}
* @default 9000000.0
*/
this.lightingFadeInDistance = 9000000.0;
/**
* True if an animated wave effect should be shown in areas of the globe
* covered by water; otherwise, false. This property is ignored if the
* <code>terrainProvider</code> does not provide a water mask.
*
* @type {Boolean}
* @default true
*/
this.showWaterEffect = true;
/**
* True if primitives such as billboards, polylines, labels, etc. should be depth-tested
* against the terrain surface, or false if such primitives should always be drawn on top
* of terrain unless they're on the opposite side of the globe. The disadvantage of depth
* testing primitives against terrain is that slight numerical noise or terrain level-of-detail
* switched can sometimes make a primitive that should be on the surface disappear underneath it.
*
* @type {Boolean}
* @default false
*
*/
this.depthTestAgainstTerrain = false;
/**
* Determines whether the globe casts or receives shadows from each light source. Setting the globe
* to cast shadows may impact performance since the terrain is rendered again from the light's perspective.
* Currently only terrain that is in view casts shadows. By default the globe does not cast shadows.
*
* @type {ShadowMode}
* @default ShadowMode.RECEIVE_ONLY
*/
this.shadows = ShadowMode.RECEIVE_ONLY;
this._oceanNormalMap = undefined;
this._zoomedOutOceanSpecularIntensity = 0.5;
}
defineProperties(Globe.prototype, {
/**
* Gets an ellipsoid describing the shape of this globe.
* @memberof Globe.prototype
* @type {Ellipsoid}
*/
ellipsoid : {
get : function() {
return this._ellipsoid;
}
},
/**
* Gets the collection of image layers that will be rendered on this globe.
* @memberof Globe.prototype
* @type {ImageryLayerCollection}
*/
imageryLayers : {
get : function() {
return this._imageryLayerCollection;
}
},
/**
* Gets or sets the color of the globe when no imagery is available.
* @memberof Globe.prototype
* @type {Color}
*/
baseColor : {
get : function() {
return this._surface.tileProvider.baseColor;
},
set : function(value) {
this._surface.tileProvider.baseColor = value;
}
},
/**
* The terrain provider providing surface geometry for this globe.
* @type {TerrainProvider}
*
* @memberof Globe.prototype
* @type {TerrainProvider}
*
*/
terrainProvider : {
get : function() {
return this._terrainProvider;
},
set : function(value) {
if (value !== this._terrainProvider) {
this._terrainProvider = value;
this._terrainProviderChanged.raiseEvent(value);
}
}
},
/**
* Gets an event that's raised when the terrain provider is changed
*
* @memberof Globe.prototype
* @type {Event}
* @readonly
*/
terrainProviderChanged : {
get: function() {
return this._terrainProviderChanged;
}
},
/**
* Gets an event that's raised when the length of the tile load queue has changed since the last render frame. When the load queue is empty,
* all terrain and imagery for the current view have been loaded. The event passes the new length of the tile load queue.
*
* @memberof Globe.prototype
* @type {Event}
*/
tileLoadProgressEvent : {
get: function() {
return this._surface.tileLoadProgressEvent;
}
}
});
function createComparePickTileFunction(rayOrigin) {
return function(a, b) {
var aDist = BoundingSphere.distanceSquaredTo(a.pickBoundingSphere, rayOrigin);
var bDist = BoundingSphere.distanceSquaredTo(b.pickBoundingSphere, rayOrigin);
return aDist - bDist;
};
}
var scratchArray = [];
var scratchSphereIntersectionResult = {
start : 0.0,
stop : 0.0
};
/**
* Find an intersection between a ray and the globe surface that was rendered. The ray must be given in world coordinates.
*
* @param {Ray} ray The ray to test for intersection.
* @param {Scene} scene The scene.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3|undefined} The intersection or <code>undefined</code> if none was found.
*
* @example
* // find intersection of ray through a pixel and the globe
* var ray = viewer.camera.getPickRay(windowCoordinates);
* var intersection = globe.pick(ray, scene);
*/
Globe.prototype.pick = function(ray, scene, result) {
if (!defined(ray)) {
throw new DeveloperError('ray is required');
}
if (!defined(scene)) {
throw new DeveloperError('scene is required');
}
var mode = scene.mode;
var projection = scene.mapProjection;
var sphereIntersections = scratchArray;
sphereIntersections.length = 0;
var tilesToRender = this._surface._tilesToRender;
var length = tilesToRender.length;
var tile;
var i;
for (i = 0; i < length; ++i) {
tile = tilesToRender[i];
var tileData = tile.data;
if (!defined(tileData)) {
continue;
}
var boundingVolume = tileData.pickBoundingSphere;
if (mode !== SceneMode.SCENE3D) {
BoundingSphere.fromRectangleWithHeights2D(tile.rectangle, projection, tileData.minimumHeight, tileData.maximumHeight, boundingVolume);
Cartesian3.fromElements(boundingVolume.center.z, boundingVolume.center.x, boundingVolume.center.y, boundingVolume.center);
} else {
BoundingSphere.clone(tileData.boundingSphere3D, boundingVolume);
}
var boundingSphereIntersection = IntersectionTests.raySphere(ray, boundingVolume, scratchSphereIntersectionResult);
if (defined(boundingSphereIntersection)) {
sphereIntersections.push(tileData);
}
}
sphereIntersections.sort(createComparePickTileFunction(ray.origin));
var intersection;
length = sphereIntersections.length;
for (i = 0; i < length; ++i) {
intersection = sphereIntersections[i].pick(ray, scene.mode, scene.mapProjection, true, result);
if (defined(intersection)) {
break;
}
}
return intersection;
};
var scratchGetHeightCartesian = new Cartesian3();
var scratchGetHeightIntersection = new Cartesian3();
var scratchGetHeightCartographic = new Cartographic();
var scratchGetHeightRay = new Ray();
function tileIfContainsCartographic(tile, cartographic) {
return Rectangle.contains(tile.rectangle, cartographic) ? tile : undefined;
}
/**
* Get the height of the surface at a given cartographic.
*
* @param {Cartographic} cartographic The cartographic for which to find the height.
* @returns {Number|undefined} The height of the cartographic or undefined if it could not be found.
*/
Globe.prototype.getHeight = function(cartographic) {
if (!defined(cartographic)) {
throw new DeveloperError('cartographic is required');
}
var levelZeroTiles = this._surface._levelZeroTiles;
if (!defined(levelZeroTiles)) {
return;
}
var tile;
var i;
var length = levelZeroTiles.length;
for (i = 0; i < length; ++i) {
tile = levelZeroTiles[i];
if (Rectangle.contains(tile.rectangle, cartographic)) {
break;
}
}
if (!defined(tile) || !Rectangle.contains(tile.rectangle, cartographic)) {
return undefined;
}
while (tile.renderable) {
tile = tileIfContainsCartographic(tile.southwestChild, cartographic) ||
tileIfContainsCartographic(tile.southeastChild, cartographic) ||
tileIfContainsCartographic(tile.northwestChild, cartographic) ||
tile.northeastChild;
}
while (defined(tile) && (!defined(tile.data) || !defined(tile.data.pickTerrain))) {
tile = tile.parent;
}
if (!defined(tile)) {
return undefined;
}
var ellipsoid = this._surface._tileProvider.tilingScheme.ellipsoid;
//cartesian has to be on the ellipsoid surface for `ellipsoid.geodeticSurfaceNormal`
var cartesian = Cartesian3.fromRadians(cartographic.longitude, cartographic.latitude, 0.0, ellipsoid, scratchGetHeightCartesian);
var ray = scratchGetHeightRay;
var surfaceNormal = ellipsoid.geodeticSurfaceNormal(cartesian, ray.direction);
// Try to find the intersection point between the surface normal and z-axis.
// minimum height (-11500.0) for the terrain set, need to get this information from the terrain provider
var rayOrigin = ellipsoid.getSurfaceNormalIntersectionWithZAxis(cartesian, 11500.0, ray.origin);
// Theoretically, not with Earth datums, the intersection point can be outside the ellipsoid
if (!defined(rayOrigin)) {
// intersection point is outside the ellipsoid, try other value
// minimum height (-11500.0) for the terrain set, need to get this information from the terrain provider
var magnitude = Math.min(defaultValue(tile.data.minimumHeight, 0.0),-11500.0);
// multiply by the *positive* value of the magnitude
var vectorToMinimumPoint = Cartesian3.multiplyByScalar(surfaceNormal, Math.abs(magnitude) + 1, scratchGetHeightIntersection);
Cartesian3.subtract(cartesian, vectorToMinimumPoint, ray.origin);
}
var intersection = tile.data.pick(ray, undefined, undefined, false, scratchGetHeightIntersection);
if (!defined(intersection)) {
return undefined;
}
return ellipsoid.cartesianToCartographic(intersection, scratchGetHeightCartographic).height;
};
/**
* @private
*/
Globe.prototype.beginFrame = function(frameState) {
if (!this.show) {
return;
}
var surface = this._surface;
var tileProvider = surface.tileProvider;
var terrainProvider = this.terrainProvider;
var hasWaterMask = this.showWaterEffect && terrainProvider.ready && terrainProvider.hasWaterMask;
if (hasWaterMask && this.oceanNormalMapUrl !== this._oceanNormalMapUrl) {
// url changed, load new normal map asynchronously
var oceanNormalMapUrl = this.oceanNormalMapUrl;
this._oceanNormalMapUrl = oceanNormalMapUrl;
if (defined(oceanNormalMapUrl)) {
var that = this;
when(loadImage(oceanNormalMapUrl), function(image) {
if (oceanNormalMapUrl !== that.oceanNormalMapUrl) {
// url changed while we were loading
return;
}
that._oceanNormalMap = that._oceanNormalMap && that._oceanNormalMap.destroy();
that._oceanNormalMap = new Texture({
context : frameState.context,
source : image
});
});
} else {
this._oceanNormalMap = this._oceanNormalMap && this._oceanNormalMap.destroy();
}
}
var mode = frameState.mode;
var pass = frameState.passes;
if (pass.render) {
// Don't show the ocean specular highlights when zoomed out in 2D and Columbus View.
if (mode === SceneMode.SCENE3D) {
this._zoomedOutOceanSpecularIntensity = 0.5;
} else {
this._zoomedOutOceanSpecularIntensity = 0.0;
}
surface.maximumScreenSpaceError = this.maximumScreenSpaceError;
surface.tileCacheSize = this.tileCacheSize;
tileProvider.terrainProvider = this.terrainProvider;
tileProvider.lightingFadeOutDistance = this.lightingFadeOutDistance;
tileProvider.lightingFadeInDistance = this.lightingFadeInDistance;
tileProvider.zoomedOutOceanSpecularIntensity = this._zoomedOutOceanSpecularIntensity;
tileProvider.hasWaterMask = hasWaterMask;
tileProvider.oceanNormalMap = this._oceanNormalMap;
tileProvider.enableLighting = this.enableLighting;
tileProvider.shadows = this.shadows;
surface.beginFrame(frameState);
}
};
/**
* @private
*/
Globe.prototype.update = function(frameState) {
if (!this.show) {
return;
}
var surface = this._surface;
var pass = frameState.passes;
if (pass.render) {
surface.update(frameState);
}
if (pass.pick) {
surface.update(frameState);
}
};
/**
* @private
*/
Globe.prototype.endFrame = function(frameState) {
if (!this.show) {
return;
}
if (frameState.passes.render) {
this._surface.endFrame(frameState);
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see Globe#destroy
*/
Globe.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* globe = globe && globe.destroy();
*
* @see Globe#isDestroyed
*/
Globe.prototype.destroy = function() {
this._surfaceShaderSet = this._surfaceShaderSet && this._surfaceShaderSet.destroy();
this._surface = this._surface && this._surface.destroy();
this._oceanNormalMap = this._oceanNormalMap && this._oceanNormalMap.destroy();
return destroyObject(this);
};
return Globe;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/PostProcessFilters/PassThrough',[],function() {
'use strict';
return "uniform sampler2D u_texture;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
gl_FragColor = texture2D(u_texture, v_textureCoordinates);\n\
}\n\
";
});
/*global define*/
define('Scene/GlobeDepth',[
'../Core/BoundingRectangle',
'../Core/Color',
'../Core/defined',
'../Core/destroyObject',
'../Core/PixelFormat',
'../Renderer/ClearCommand',
'../Renderer/Framebuffer',
'../Renderer/PixelDatatype',
'../Renderer/RenderState',
'../Renderer/Texture',
'../Shaders/PostProcessFilters/PassThrough'
], function(
BoundingRectangle,
Color,
defined,
destroyObject,
PixelFormat,
ClearCommand,
Framebuffer,
PixelDatatype,
RenderState,
Texture,
PassThrough) {
'use strict';
/**
* @private
*/
function GlobeDepth() {
this._colorTexture = undefined;
this._depthStencilTexture = undefined;
this._globeDepthTexture = undefined;
this.framebuffer = undefined;
this._copyDepthFramebuffer = undefined;
this._clearColorCommand = undefined;
this._copyColorCommand = undefined;
this._copyDepthCommand = undefined;
this._viewport = new BoundingRectangle();
this._rs = undefined;
this._debugGlobeDepthViewportCommand = undefined;
}
function executeDebugGlobeDepth(globeDepth, context, passState) {
if (!defined(globeDepth._debugGlobeDepthViewportCommand)) {
var fs =
'uniform sampler2D u_texture;\n' +
'varying vec2 v_textureCoordinates;\n' +
'void main()\n' +
'{\n' +
' float z_window = czm_unpackDepth(texture2D(u_texture, v_textureCoordinates));\n' +
' float n_range = czm_depthRange.near;\n' +
' float f_range = czm_depthRange.far;\n' +
' float z_ndc = (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n' +
' float scale = pow(z_ndc * 0.5 + 0.5, 8.0);\n' +
' gl_FragColor = vec4(mix(vec3(0.0), vec3(1.0), scale), 1.0);\n' +
'}\n';
globeDepth._debugGlobeDepthViewportCommand = context.createViewportQuadCommand(fs, {
uniformMap : {
u_texture : function() {
return globeDepth._globeDepthTexture;
}
},
owner : globeDepth
});
}
globeDepth._debugGlobeDepthViewportCommand.execute(context, passState);
}
function destroyTextures(globeDepth) {
globeDepth._colorTexture = globeDepth._colorTexture && !globeDepth._colorTexture.isDestroyed() && globeDepth._colorTexture.destroy();
globeDepth._depthStencilTexture = globeDepth._depthStencilTexture && !globeDepth._depthStencilTexture.isDestroyed() && globeDepth._depthStencilTexture.destroy();
globeDepth._globeDepthTexture = globeDepth._globeDepthTexture && !globeDepth._globeDepthTexture.isDestroyed() && globeDepth._globeDepthTexture.destroy();
}
function destroyFramebuffers(globeDepth) {
globeDepth.framebuffer = globeDepth.framebuffer && !globeDepth.framebuffer.isDestroyed() && globeDepth.framebuffer.destroy();
globeDepth._copyDepthFramebuffer = globeDepth._copyDepthFramebuffer && !globeDepth._copyDepthFramebuffer.isDestroyed() && globeDepth._copyDepthFramebuffer.destroy();
}
function createTextures(globeDepth, context, width, height) {
globeDepth._colorTexture = new Texture({
context : context,
width : width,
height : height,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE
});
globeDepth._depthStencilTexture = new Texture({
context : context,
width : width,
height : height,
pixelFormat : PixelFormat.DEPTH_STENCIL,
pixelDatatype : PixelDatatype.UNSIGNED_INT_24_8
});
globeDepth._globeDepthTexture = new Texture({
context : context,
width : width,
height : height,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE
});
}
function createFramebuffers(globeDepth, context, width, height) {
globeDepth.framebuffer = new Framebuffer({
context : context,
colorTextures : [globeDepth._colorTexture],
depthStencilTexture : globeDepth._depthStencilTexture,
destroyAttachments : false
});
globeDepth._copyDepthFramebuffer = new Framebuffer({
context : context,
colorTextures : [globeDepth._globeDepthTexture],
destroyAttachments : false
});
}
function updateFramebuffers(globeDepth, context, width, height) {
var colorTexture = globeDepth._colorTexture;
var textureChanged = !defined(colorTexture) || colorTexture.width !== width || colorTexture.height !== height;
if (!defined(globeDepth.framebuffer) || textureChanged) {
destroyTextures(globeDepth);
destroyFramebuffers(globeDepth);
createTextures(globeDepth, context, width, height);
createFramebuffers(globeDepth, context, width, height);
}
}
function updateCopyCommands(globeDepth, context, width, height) {
globeDepth._viewport.width = width;
globeDepth._viewport.height = height;
if (!defined(globeDepth._rs) || !BoundingRectangle.equals(globeDepth._viewport, globeDepth._rs.viewport)) {
globeDepth._rs = RenderState.fromCache({
viewport : globeDepth._viewport
});
}
if (!defined(globeDepth._copyDepthCommand)) {
var fs =
'uniform sampler2D u_texture;\n' +
'varying vec2 v_textureCoordinates;\n' +
'void main()\n' +
'{\n' +
' gl_FragColor = czm_packDepth(texture2D(u_texture, v_textureCoordinates).r);\n' +
'}\n';
globeDepth._copyDepthCommand = context.createViewportQuadCommand(fs, {
uniformMap : {
u_texture : function() {
return globeDepth._depthStencilTexture;
}
},
owner : globeDepth
});
}
globeDepth._copyDepthCommand.framebuffer = globeDepth._copyDepthFramebuffer;
if (!defined(globeDepth._copyColorCommand)) {
globeDepth._copyColorCommand = context.createViewportQuadCommand(PassThrough, {
uniformMap : {
u_texture : function() {
return globeDepth._colorTexture;
}
},
owner : globeDepth
});
}
globeDepth._copyDepthCommand.renderState = globeDepth._rs;
globeDepth._copyColorCommand.renderState = globeDepth._rs;
if (!defined(globeDepth._clearColorCommand)) {
globeDepth._clearColorCommand = new ClearCommand({
color : new Color(0.0, 0.0, 0.0, 0.0),
stencil : 0.0,
owner : globeDepth
});
}
globeDepth._clearColorCommand.framebuffer = globeDepth.framebuffer;
}
GlobeDepth.prototype.executeDebugGlobeDepth = function(context, passState) {
executeDebugGlobeDepth(this, context, passState);
};
GlobeDepth.prototype.update = function(context) {
var width = context.drawingBufferWidth;
var height = context.drawingBufferHeight;
updateFramebuffers(this, context, width, height);
updateCopyCommands(this, context, width, height);
context.uniformState.globeDepthTexture = undefined;
};
GlobeDepth.prototype.executeCopyDepth = function(context, passState) {
if (defined(this._copyDepthCommand)) {
this._copyDepthCommand.execute(context, passState);
context.uniformState.globeDepthTexture = this._globeDepthTexture;
}
};
GlobeDepth.prototype.executeCopyColor = function(context, passState) {
if (defined(this._copyColorCommand)) {
this._copyColorCommand.execute(context, passState);
}
};
GlobeDepth.prototype.clear = function(context, passState, clearColor) {
var clear = this._clearColorCommand;
if (defined(clear)) {
Color.clone(clearColor, clear.color);
clear.execute(context, passState);
}
};
GlobeDepth.prototype.isDestroyed = function() {
return false;
};
GlobeDepth.prototype.destroy = function() {
destroyTextures(this);
destroyFramebuffers(this);
if (defined(this._copyColorCommand)) {
this._copyColorCommand.shaderProgram = this._copyColorCommand.shaderProgram.destroy();
}
if (defined(this._copyDepthCommand)) {
this._copyDepthCommand.shaderProgram = this._copyDepthCommand.shaderProgram.destroy();
}
var command = this._debugGlobeDepthViewportCommand;
if (defined(command)) {
command.shaderProgram = command.shaderProgram.destroy();
}
return destroyObject(this);
};
return GlobeDepth;
});
/*global define*/
define('Scene/GoogleEarthImageryProvider',[
'../Core/Credit',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/Event',
'../Core/GeographicTilingScheme',
'../Core/loadText',
'../Core/Rectangle',
'../Core/RuntimeError',
'../Core/TileProviderError',
'../Core/WebMercatorTilingScheme',
'../ThirdParty/when',
'./ImageryProvider'
], function(
Credit,
defaultValue,
defined,
defineProperties,
DeveloperError,
Event,
GeographicTilingScheme,
loadText,
Rectangle,
RuntimeError,
TileProviderError,
WebMercatorTilingScheme,
when,
ImageryProvider) {
'use strict';
/**
* Provides tiled imagery using the Google Earth Imagery API.
*
* Notes: This imagery provider does not work with the public Google Earth servers. It works with the
* Google Earth Enterprise Server.
*
* By default the Google Earth Enterprise server does not set the
* {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing} headers. You can either
* use a proxy server which adds these headers, or in the /opt/google/gehttpd/conf/gehttpd.conf
* and add the 'Header set Access-Control-Allow-Origin "*"' option to the '<Directory />' and
* '<Directory "/opt/google/gehttpd/htdocs">' directives.
*
* @alias GoogleEarthImageryProvider
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {String} options.url The url of the Google Earth server hosting the imagery.
* @param {Number} options.channel The channel (id) to be used when requesting data from the server.
* The channel number can be found by looking at the json file located at:
* earth.localdomain/default_map/query?request=Json&vars=geeServerDefs The /default_map path may
* differ depending on your Google Earth Enterprise server configuration. Look for the "id" that
* is associated with a "ImageryMaps" requestType. There may be more than one id available.
* Example:
* {
* layers: [
* {
* id: 1002,
* requestType: "ImageryMaps"
* },
* {
* id: 1007,
* requestType: "VectorMapsRaster"
* }
* ]
* }
* @param {String} [options.path="/default_map"] The path of the Google Earth server hosting the imagery.
* @param {Number} [options.maximumLevel] The maximum level-of-detail supported by the Google Earth
* Enterprise server, or undefined if there is no limit.
* @param {TileDiscardPolicy} [options.tileDiscardPolicy] The policy that determines if a tile
* is invalid and should be discarded. To ensure that no tiles are discarded, construct and pass
* a {@link NeverTileDiscardPolicy} for this parameter.
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If not specified, the WGS84 ellipsoid is used.
* @param {Proxy} [options.proxy] A proxy to use for requests. This object is
* expected to have a getURL function which returns the proxied URL, if needed.
*
* @exception {RuntimeError} Could not find layer with channel (id) of <code>options.channel</code>.
* @exception {RuntimeError} Could not find a version in channel (id) <code>options.channel</code>.
* @exception {RuntimeError} Unsupported projection <code>data.projection</code>.
*
* @see ArcGisMapServerImageryProvider
* @see BingMapsImageryProvider
* @see createOpenStreetMapImageryProvider
* @see SingleTileImageryProvider
* @see createTileMapServiceImageryProvider
* @see WebMapServiceImageryProvider
* @see WebMapTileServiceImageryProvider
* @see UrlTemplateImageryProvider
*
*
* @example
* var google = new Cesium.GoogleEarthImageryProvider({
* url : 'https://earth.localdomain',
* channel : 1008
* });
*
* @see {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing}
*/
function GoogleEarthImageryProvider(options) {
options = defaultValue(options, {});
if (!defined(options.url)) {
throw new DeveloperError('options.url is required.');
}
if (!defined(options.channel)) {
throw new DeveloperError('options.channel is required.');
}
this._url = options.url;
this._path = defaultValue(options.path, '/default_map');
this._tileDiscardPolicy = options.tileDiscardPolicy;
this._proxy = options.proxy;
this._channel = options.channel;
this._requestType = 'ImageryMaps';
this._credit = new Credit('Google Imagery', GoogleEarthImageryProvider._logoData, 'http://www.google.com/enterprise/mapsearth/products/earthenterprise.html');
/**
* The default {@link ImageryLayer#gamma} to use for imagery layers created for this provider.
* By default, this is set to 1.9. Changing this value after creating an {@link ImageryLayer} for this provider will have
* no effect. Instead, set the layer's {@link ImageryLayer#gamma} property.
*
* @type {Number}
* @default 1.9
*/
this.defaultGamma = 1.9;
this._tilingScheme = undefined;
this._version = undefined;
this._tileWidth = 256;
this._tileHeight = 256;
this._maximumLevel = options.maximumLevel;
this._imageUrlTemplate = this._url + this._path + '/query?request={request}&channel={channel}&version={version}&x={x}&y={y}&z={zoom}';
this._errorEvent = new Event();
this._ready = false;
this._readyPromise = when.defer();
var metadataUrl = this._url + this._path + '/query?request=Json&vars=geeServerDefs&is2d=t';
var that = this;
var metadataError;
function metadataSuccess(text) {
var data;
// The Google Earth server sends malformed JSON data currently...
try {
// First, try parsing it like normal in case a future version sends correctly formatted JSON
data = JSON.parse(text);
} catch(e) {
// Quote object strings manually, then try parsing again
data = JSON.parse(text.replace(/([\[\{,])[\n\r ]*([A-Za-z0-9]+)[\n\r ]*:/g, '$1"$2":'));
}
var layer;
for(var i = 0; i < data.layers.length; i++) {
if(data.layers[i].id === that._channel) {
layer = data.layers[i];
break;
}
}
var message;
if(!defined(layer)) {
message = 'Could not find layer with channel (id) of ' + that._channel + '.';
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
throw new RuntimeError(message);
}
if(!defined(layer.version)) {
message = 'Could not find a version in channel (id) ' + that._channel + '.';
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
throw new RuntimeError(message);
}
that._version = layer.version;
if(defined(data.projection) && data.projection === 'flat') {
that._tilingScheme = new GeographicTilingScheme({
numberOfLevelZeroTilesX : 2,
numberOfLevelZeroTilesY : 2,
rectangle: new Rectangle(-Math.PI, -Math.PI, Math.PI, Math.PI),
ellipsoid : options.ellipsoid
});
// Default to mercator projection when projection is undefined
} else if(!defined(data.projection) || data.projection === 'mercator') {
that._tilingScheme = new WebMercatorTilingScheme({
numberOfLevelZeroTilesX : 2,
numberOfLevelZeroTilesY : 2,
ellipsoid : options.ellipsoid
});
} else {
message = 'Unsupported projection ' + data.projection + '.';
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
throw new RuntimeError(message);
}
that._imageUrlTemplate = that._imageUrlTemplate.replace('{request}', that._requestType)
.replace('{channel}', that._channel).replace('{version}', that._version);
that._ready = true;
that._readyPromise.resolve(true);
TileProviderError.handleSuccess(metadataError);
}
function metadataFailure(e) {
var message = 'An error occurred while accessing ' + metadataUrl + '.';
metadataError = TileProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
that._readyPromise.reject(new RuntimeError(message));
}
function requestMetadata() {
var url = (!defined(that._proxy)) ? metadataUrl : that._proxy.getURL(metadataUrl);
var metadata = loadText(url);
when(metadata, metadataSuccess, metadataFailure);
}
requestMetadata();
}
defineProperties(GoogleEarthImageryProvider.prototype, {
/**
* Gets the URL of the Google Earth MapServer.
* @memberof GoogleEarthImageryProvider.prototype
* @type {String}
* @readonly
*/
url : {
get : function() {
return this._url;
}
},
/**
* Gets the url path of the data on the Google Earth server.
* @memberof GoogleEarthImageryProvider.prototype
* @type {String}
* @readonly
*/
path : {
get : function() {
return this._path;
}
},
/**
* Gets the proxy used by this provider.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Proxy}
* @readonly
*/
proxy : {
get : function() {
return this._proxy;
}
},
/**
* Gets the imagery channel (id) currently being used.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Number}
* @readonly
*/
channel : {
get : function() {
return this._channel;
}
},
/**
* Gets the width of each tile, in pixels. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileWidth : {
get : function() {
if (!this._ready) {
throw new DeveloperError('tileWidth must not be called before the imagery provider is ready.');
}
return this._tileWidth;
}
},
/**
* Gets the height of each tile, in pixels. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileHeight: {
get : function() {
if (!this._ready) {
throw new DeveloperError('tileHeight must not be called before the imagery provider is ready.');
}
return this._tileHeight;
}
},
/**
* Gets the maximum level-of-detail that can be requested. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Number}
* @readonly
*/
maximumLevel : {
get : function() {
if (!this._ready) {
throw new DeveloperError('maximumLevel must not be called before the imagery provider is ready.');
}
return this._maximumLevel;
}
},
/**
* Gets the minimum level-of-detail that can be requested. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Number}
* @readonly
*/
minimumLevel : {
get : function() {
if (!this._ready) {
throw new DeveloperError('minimumLevel must not be called before the imagery provider is ready.');
}
return 0;
}
},
/**
* Gets the tiling scheme used by this provider. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {TilingScheme}
* @readonly
*/
tilingScheme : {
get : function() {
if (!this._ready) {
throw new DeveloperError('tilingScheme must not be called before the imagery provider is ready.');
}
return this._tilingScheme;
}
},
/**
* Gets the version of the data used by this provider. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Number}
* @readonly
*/
version : {
get : function() {
if (!this._ready) {
throw new DeveloperError('version must not be called before the imagery provider is ready.');
}
return this._version;
}
},
/**
* Gets the type of data that is being requested from the provider. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {String}
* @readonly
*/
requestType : {
get : function() {
if (!this._ready) {
throw new DeveloperError('requestType must not be called before the imagery provider is ready.');
}
return this._requestType;
}
},
/**
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Rectangle}
* @readonly
*/
rectangle : {
get : function() {
if (!this._ready) {
throw new DeveloperError('rectangle must not be called before the imagery provider is ready.');
}
return this._tilingScheme.rectangle;
}
},
/**
* Gets the tile discard policy. If not undefined, the discard policy is responsible
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
* returns undefined, no tiles are filtered. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {TileDiscardPolicy}
* @readonly
*/
tileDiscardPolicy : {
get : function() {
if (!this._ready) {
throw new DeveloperError('tileDiscardPolicy must not be called before the imagery provider is ready.');
}
return this._tileDiscardPolicy;
}
},
/**
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Event}
* @readonly
*/
errorEvent : {
get : function() {
return this._errorEvent;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
ready : {
get : function() {
return this._ready;
}
},
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readyPromise : {
get : function() {
return this._readyPromise.promise;
}
},
/**
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
* the source of the imagery. This function should not be called before {@link GoogleEarthImageryProvider#ready} returns true.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Credit}
* @readonly
*/
credit : {
get : function() {
return this._credit;
}
},
/**
* Gets a value indicating whether or not the images provided by this imagery provider
* include an alpha channel. If this property is false, an alpha channel, if present, will
* be ignored. If this property is true, any images without an alpha channel will be treated
* as if their alpha is 1.0 everywhere. When this property is false, memory usage
* and texture upload time are reduced.
* @memberof GoogleEarthImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
hasAlphaChannel : {
get : function() {
return true;
}
}
});
/**
* Gets the credits to be displayed when a given tile is displayed.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level;
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
*
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
*/
GoogleEarthImageryProvider.prototype.getTileCredits = function(x, y, level) {
return undefined;
};
/**
* Requests the image for a given tile. This function should
* not be called before {@link GoogleEarthImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Promise.<Image|Canvas>|undefined} A promise for the image that will resolve when the image is available, or
* undefined if there are too many active requests to the server, and the request
* should be retried later. The resolved image may be either an
* Image or a Canvas DOM object.
*
* @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready.
*/
GoogleEarthImageryProvider.prototype.requestImage = function(x, y, level) {
if (!this._ready) {
throw new DeveloperError('requestImage must not be called before the imagery provider is ready.');
}
var url = buildImageUrl(this, x, y, level);
return ImageryProvider.loadImage(this, url);
};
/**
* Picking features is not currently supported by this imagery provider, so this function simply returns
* undefined.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @param {Number} longitude The longitude at which to pick features.
* @param {Number} latitude The latitude at which to pick features.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
* instances. The array may be empty if no features are found at the given location.
* It may also be undefined if picking is not supported.
*/
GoogleEarthImageryProvider.prototype.pickFeatures = function() {
return undefined;
};
GoogleEarthImageryProvider._logoData = 'data:image/png;base64,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';
function buildImageUrl(imageryProvider, x, y, level) {
var imageUrl = imageryProvider._imageUrlTemplate;
imageUrl = imageUrl.replace('{x}', x);
imageUrl = imageUrl.replace('{y}', y);
// Google Earth starts with a zoom level of 1, not 0
imageUrl = imageUrl.replace('{zoom}', (level + 1));
var proxy = imageryProvider._proxy;
if (defined(proxy)) {
imageUrl = proxy.getURL(imageUrl);
}
return imageUrl;
}
return GoogleEarthImageryProvider;
});
/*global define*/
define('Scene/GridImageryProvider',[
'../Core/Color',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/Event',
'../Core/GeographicTilingScheme',
'../ThirdParty/when'
], function(
Color,
defaultValue,
defined,
defineProperties,
Event,
GeographicTilingScheme,
when) {
'use strict';
var defaultColor = new Color(1.0, 1.0, 1.0, 0.4);
var defaultGlowColor = new Color(0.0, 1.0, 0.0, 0.05);
var defaultBackgroundColor = new Color(0.0, 0.5, 0.0, 0.2);
/**
* An {@link ImageryProvider} that draws a wireframe grid on every tile with controllable background and glow.
* May be useful for custom rendering effects or debugging terrain.
*
* @alias GridImageryProvider
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {TilingScheme} [options.tilingScheme=new GeographicTilingScheme()] The tiling scheme for which to draw tiles.
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If the tilingScheme is specified,
* this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
* parameter is specified, the WGS84 ellipsoid is used.
* @param {Number} [options.cells=8] The number of grids cells.
* @param {Color} [options.color=Color(1.0, 1.0, 1.0, 0.4)] The color to draw grid lines.
* @param {Color} [options.glowColor=Color(0.0, 1.0, 0.0, 0.05)] The color to draw glow for grid lines.
* @param {Number} [options.glowWidth=6] The width of lines used for rendering the line glow effect.
* @param {Color} [backgroundColor=Color(0.0, 0.5, 0.0, 0.2)] Background fill color.
* @param {Number} [options.tileWidth=256] The width of the tile for level-of-detail selection purposes.
* @param {Number} [options.tileHeight=256] The height of the tile for level-of-detail selection purposes.
* @param {Number} [options.canvasSize=256] The size of the canvas used for rendering.
*/
function GridImageryProvider(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
this._tilingScheme = defined(options.tilingScheme) ? options.tilingScheme : new GeographicTilingScheme({ ellipsoid : options.ellipsoid });
this._cells = defaultValue(options.cells, 8);
this._color = defaultValue(options.color, defaultColor);
this._glowColor = defaultValue(options.glowColor, defaultGlowColor);
this._glowWidth = defaultValue(options.glowWidth, 6);
this._backgroundColor = defaultValue(options.backgroundColor, defaultBackgroundColor);
this._errorEvent = new Event();
this._tileWidth = defaultValue(options.tileWidth, 256);
this._tileHeight = defaultValue(options.tileHeight, 256);
// A little larger than tile size so lines are sharper
// Note: can't be too much difference otherwise texture blowout
this._canvasSize = defaultValue(options.canvasSize, 256);
// We only need a single canvas since all tiles will be the same
this._canvas = this._createGridCanvas();
this._readyPromise = when.resolve(true);
}
defineProperties(GridImageryProvider.prototype, {
/**
* Gets the proxy used by this provider.
* @memberof GridImageryProvider.prototype
* @type {Proxy}
* @readonly
*/
proxy : {
get : function() {
return undefined;
}
},
/**
* Gets the width of each tile, in pixels. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileWidth : {
get : function() {
return this._tileWidth;
}
},
/**
* Gets the height of each tile, in pixels. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileHeight : {
get : function() {
return this._tileHeight;
}
},
/**
* Gets the maximum level-of-detail that can be requested. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {Number}
* @readonly
*/
maximumLevel : {
get : function() {
return undefined;
}
},
/**
* Gets the minimum level-of-detail that can be requested. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {Number}
* @readonly
*/
minimumLevel : {
get : function() {
return undefined;
}
},
/**
* Gets the tiling scheme used by this provider. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {TilingScheme}
* @readonly
*/
tilingScheme : {
get : function() {
return this._tilingScheme;
}
},
/**
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {Rectangle}
* @readonly
*/
rectangle : {
get : function() {
return this._tilingScheme.rectangle;
}
},
/**
* Gets the tile discard policy. If not undefined, the discard policy is responsible
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
* returns undefined, no tiles are filtered. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {TileDiscardPolicy}
* @readonly
*/
tileDiscardPolicy : {
get : function() {
return undefined;
}
},
/**
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof GridImageryProvider.prototype
* @type {Event}
* @readonly
*/
errorEvent : {
get : function() {
return this._errorEvent;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof GridImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
ready : {
get : function() {
return true;
}
},
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof GridImageryProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readyPromise : {
get : function() {
return this._readyPromise;
}
},
/**
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
* the source of the imagery. This function should not be called before {@link GridImageryProvider#ready} returns true.
* @memberof GridImageryProvider.prototype
* @type {Credit}
* @readonly
*/
credit : {
get : function() {
return undefined;
}
},
/**
* Gets a value indicating whether or not the images provided by this imagery provider
* include an alpha channel. If this property is false, an alpha channel, if present, will
* be ignored. If this property is true, any images without an alpha channel will be treated
* as if their alpha is 1.0 everywhere. When this property is false, memory usage
* and texture upload time are reduced.
* @memberof GridImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
hasAlphaChannel : {
get : function() {
return true;
}
}
});
/**
* Draws a grid of lines into a canvas.
*/
GridImageryProvider.prototype._drawGrid = function(context) {
var minPixel = 0;
var maxPixel = this._canvasSize;
for (var x = 0; x <= this._cells; ++x) {
var nx = x / this._cells;
var val = 1 + nx * (maxPixel - 1);
context.moveTo(val, minPixel);
context.lineTo(val, maxPixel);
context.moveTo(minPixel, val);
context.lineTo(maxPixel, val);
}
context.stroke();
};
/**
* Render a grid into a canvas with background and glow
*/
GridImageryProvider.prototype._createGridCanvas = function() {
var canvas = document.createElement('canvas');
canvas.width = this._canvasSize;
canvas.height = this._canvasSize;
var minPixel = 0;
var maxPixel = this._canvasSize;
var context = canvas.getContext('2d');
// Fill the background
var cssBackgroundColor = this._backgroundColor.toCssColorString();
context.fillStyle = cssBackgroundColor;
context.fillRect(minPixel, minPixel, maxPixel, maxPixel);
// Glow for grid lines
var cssGlowColor = this._glowColor.toCssColorString();
context.strokeStyle = cssGlowColor;
// Wide
context.lineWidth = this._glowWidth;
context.strokeRect(minPixel, minPixel, maxPixel, maxPixel);
this._drawGrid(context);
// Narrow
context.lineWidth = this._glowWidth * 0.5;
context.strokeRect(minPixel, minPixel, maxPixel, maxPixel);
this._drawGrid(context);
// Grid lines
var cssColor = this._color.toCssColorString();
// Border
context.strokeStyle = cssColor;
context.lineWidth = 2;
context.strokeRect(minPixel, minPixel, maxPixel, maxPixel);
// Inner
context.lineWidth = 1;
this._drawGrid(context);
return canvas;
};
/**
* Gets the credits to be displayed when a given tile is displayed.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level;
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
*
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
*/
GridImageryProvider.prototype.getTileCredits = function(x, y, level) {
return undefined;
};
/**
* Requests the image for a given tile. This function should
* not be called before {@link GridImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Promise.<Image|Canvas>|undefined} A promise for the image that will resolve when the image is available, or
* undefined if there are too many active requests to the server, and the request
* should be retried later. The resolved image may be either an
* Image or a Canvas DOM object.
*/
GridImageryProvider.prototype.requestImage = function(x, y, level) {
return this._canvas;
};
/**
* Picking features is not currently supported by this imagery provider, so this function simply returns
* undefined.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @param {Number} longitude The longitude at which to pick features.
* @param {Number} latitude The latitude at which to pick features.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
* instances. The array may be empty if no features are found at the given location.
* It may also be undefined if picking is not supported.
*/
GridImageryProvider.prototype.pickFeatures = function() {
return undefined;
};
return GridImageryProvider;
});
/*global define*/
define('Scene/MapboxImageryProvider',[
'../Core/Credit',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/MapboxApi',
'./UrlTemplateImageryProvider'
], function(
Credit,
defaultValue,
defined,
defineProperties,
DeveloperError,
MapboxApi,
UrlTemplateImageryProvider) {
'use strict';
var trailingSlashRegex = /\/$/;
var defaultCredit1 = new Credit('© Mapbox © OpenStreetMap', undefined, 'https://www.mapbox.com/about/maps/');
var defaultCredit2 = [new Credit('Improve this map', undefined, 'https://www.mapbox.com/map-feedback/')];
/**
* Provides tiled imagery hosted by Mapbox.
*
* @alias MapboxImageryProvider
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {String} [options.url='https://api.mapbox.com/v4/'] The Mapbox server url.
* @param {String} options.mapId The Mapbox Map ID.
* @param {String} [options.accessToken] The public access token for the imagery.
* @param {String} [options.format='png'] The format of the image request.
* @param {Object} [options.proxy] A proxy to use for requests. This object is expected to have a getURL function which returns the proxied URL.
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If not specified, the WGS84 ellipsoid is used.
* @param {Number} [options.minimumLevel=0] The minimum level-of-detail supported by the imagery provider. Take care when specifying
* this that the number of tiles at the minimum level is small, such as four or less. A larger number is likely
* to result in rendering problems.
* @param {Number} [options.maximumLevel] The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
* @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle, in radians, covered by the image.
* @param {Credit|String} [options.credit] A credit for the data source, which is displayed on the canvas.
*
*
* @example
* // Mapbox tile provider
* var mapbox = new Cesium.MapboxImageryProvider({
* mapId: 'mapbox.streets',
* accessToken: 'thisIsMyAccessToken'
* });
*
* @see {@link https://www.mapbox.com/developers/api/maps/#tiles}
* @see {@link https://www.mapbox.com/developers/api/#access-tokens}
*/
function MapboxImageryProvider(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var mapId = options.mapId;
if (!defined(mapId)) {
throw new DeveloperError('options.mapId is required.');
}
var url = defaultValue(options.url, 'https://api.mapbox.com/v4/');
this._url = url;
this._mapId = mapId;
this._accessToken = MapboxApi.getAccessToken(options.accessToken);
this._accessTokenErrorCredit = MapboxApi.getErrorCredit(options.key);
var format = defaultValue(options.format, 'png');
if (!/\./.test(format)) {
format = '.' + format;
}
this._format = format;
var templateUrl = url;
if (!trailingSlashRegex.test(url)) {
templateUrl += '/';
}
templateUrl += mapId + '/{z}/{x}/{y}' + this._format;
if (defined(this._accessToken)) {
templateUrl += '?access_token=' + this._accessToken;
}
if (defined(options.credit)) {
var credit = options.credit;
if (typeof credit === 'string') {
credit = new Credit(credit);
}
defaultCredit1 = credit;
defaultCredit2.length = 0;
}
this._imageryProvider = new UrlTemplateImageryProvider({
url: templateUrl,
proxy: options.proxy,
credit: defaultCredit1,
ellipsoid: options.ellipsoid,
minimumLevel: options.minimumLevel,
maximumLevel: options.maximumLevel,
rectangle: options.rectangle
});
}
defineProperties(MapboxImageryProvider.prototype, {
/**
* Gets the URL of the Mapbox server.
* @memberof MapboxImageryProvider.prototype
* @type {String}
* @readonly
*/
url : {
get : function() {
return this._url;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof MapboxImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
ready : {
get : function() {
return this._imageryProvider.ready;
}
},
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof MapboxImageryProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readyPromise : {
get : function() {
return this._imageryProvider.readyPromise;
}
},
/**
* Gets the rectangle, in radians, of the imagery provided by the instance. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
* @memberof MapboxImageryProvider.prototype
* @type {Rectangle}
* @readonly
*/
rectangle: {
get : function() {
return this._imageryProvider.rectangle;
}
},
/**
* Gets the width of each tile, in pixels. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
* @memberof MapboxImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileWidth : {
get : function() {
return this._imageryProvider.tileWidth;
}
},
/**
* Gets the height of each tile, in pixels. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
* @memberof MapboxImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileHeight : {
get : function() {
return this._imageryProvider.tileHeight;
}
},
/**
* Gets the maximum level-of-detail that can be requested. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
* @memberof MapboxImageryProvider.prototype
* @type {Number}
* @readonly
*/
maximumLevel : {
get : function() {
return this._imageryProvider.maximumLevel;
}
},
/**
* Gets the minimum level-of-detail that can be requested. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true. Generally,
* a minimum level should only be used when the rectangle of the imagery is small
* enough that the number of tiles at the minimum level is small. An imagery
* provider with more than a few tiles at the minimum level will lead to
* rendering problems.
* @memberof MapboxImageryProvider.prototype
* @type {Number}
* @readonly
*/
minimumLevel : {
get : function() {
return this._imageryProvider.minimumLevel;
}
},
/**
* Gets the tiling scheme used by the provider. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
* @memberof MapboxImageryProvider.prototype
* @type {TilingScheme}
* @readonly
*/
tilingScheme : {
get : function() {
return this._imageryProvider.tilingScheme;
}
},
/**
* Gets the tile discard policy. If not undefined, the discard policy is responsible
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
* returns undefined, no tiles are filtered. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
* @memberof MapboxImageryProvider.prototype
* @type {TileDiscardPolicy}
* @readonly
*/
tileDiscardPolicy : {
get : function() {
return this._imageryProvider.tileDiscardPolicy;
}
},
/**
* Gets an event that is raised when the imagery provider encounters an asynchronous error.. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof MapboxImageryProvider.prototype
* @type {Event}
* @readonly
*/
errorEvent : {
get : function() {
return this._imageryProvider.errorEvent;
}
},
/**
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
* the source of the imagery. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
* @memberof MapboxImageryProvider.prototype
* @type {Credit}
* @readonly
*/
credit : {
get : function() {
return this._imageryProvider.credit;
}
},
/**
* Gets the proxy used by this provider.
* @memberof MapboxImageryProvider.prototype
* @type {Proxy}
* @readonly
*/
proxy : {
get : function() {
return this._imageryProvider.proxy;
}
},
/**
* Gets a value indicating whether or not the images provided by this imagery provider
* include an alpha channel. If this property is false, an alpha channel, if present, will
* be ignored. If this property is true, any images without an alpha channel will be treated
* as if their alpha is 1.0 everywhere. When this property is false, memory usage
* and texture upload time are reduced.
* @memberof MapboxImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
hasAlphaChannel : {
get : function() {
return this._imageryProvider.hasAlphaChannel;
}
}
});
/**
* Gets the credits to be displayed when a given tile is displayed.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level;
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
*
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
*/
MapboxImageryProvider.prototype.getTileCredits = function(x, y, level) {
var credits = defaultCredit2.slice();
if (defined(this._accessTokenErrorCredit)) {
credits.push(this._accessTokenErrorCredit);
}
return credits;
};
/**
* Requests the image for a given tile. This function should
* not be called before {@link MapboxImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Promise.<Image|Canvas>|undefined} A promise for the image that will resolve when the image is available, or
* undefined if there are too many active requests to the server, and the request
* should be retried later. The resolved image may be either an
* Image or a Canvas DOM object.
*
* @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready.
*/
MapboxImageryProvider.prototype.requestImage = function(x, y, level) {
return this._imageryProvider.requestImage(x, y, level);
};
/**
* Asynchronously determines what features, if any, are located at a given longitude and latitude within
* a tile. This function should not be called before {@link MapboxImageryProvider#ready} returns true.
* This function is optional, so it may not exist on all ImageryProviders.
*
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @param {Number} longitude The longitude at which to pick features.
* @param {Number} latitude The latitude at which to pick features.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
* instances. The array may be empty if no features are found at the given location.
* It may also be undefined if picking is not supported.
*
* @exception {DeveloperError} <code>pickFeatures</code> must not be called before the imagery provider is ready.
*/
MapboxImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
return this._imageryProvider.pickFeatures(x, y, level, longitude, latitude);
};
return MapboxImageryProvider;
});
/*global define*/
define('Scene/Moon',[
'../Core/buildModuleUrl',
'../Core/Cartesian3',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/Ellipsoid',
'../Core/IauOrientationAxes',
'../Core/Matrix3',
'../Core/Matrix4',
'../Core/Simon1994PlanetaryPositions',
'../Core/Transforms',
'./EllipsoidPrimitive',
'./Material'
], function(
buildModuleUrl,
Cartesian3,
defaultValue,
defined,
defineProperties,
destroyObject,
Ellipsoid,
IauOrientationAxes,
Matrix3,
Matrix4,
Simon1994PlanetaryPositions,
Transforms,
EllipsoidPrimitive,
Material) {
'use strict';
/**
* Draws the Moon in 3D.
* @alias Moon
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Boolean} [options.show=true] Determines whether the moon will be rendered.
* @param {String} [options.textureUrl=buildModuleUrl('Assets/Textures/moonSmall.jpg')] The moon texture.
* @param {Ellipsoid} [options.ellipsoid=Ellipsoid.MOON] The moon ellipsoid.
* @param {Boolean} [options.onlySunLighting=true] Use the sun as the only light source.
*
*
* @example
* scene.moon = new Cesium.Moon();
*
* @see Scene#moon
*/
function Moon(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var url = options.textureUrl;
if (!defined(url)) {
url = buildModuleUrl('Assets/Textures/moonSmall.jpg');
}
/**
* Determines if the moon will be shown.
*
* @type {Boolean}
* @default true
*/
this.show = defaultValue(options.show, true);
/**
* The moon texture.
* @type {String}
* @default buildModuleUrl('Assets/Textures/moonSmall.jpg')
*/
this.textureUrl = url;
this._ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.MOON);
/**
* Use the sun as the only light source.
* @type {Boolean}
* @default true
*/
this.onlySunLighting = defaultValue(options.onlySunLighting, true);
this._ellipsoidPrimitive = new EllipsoidPrimitive({
radii : this.ellipsoid.radii,
material : Material.fromType(Material.ImageType),
depthTestEnabled : false,
_owner : this
});
this._ellipsoidPrimitive.material.translucent = false;
this._axes = new IauOrientationAxes();
}
defineProperties(Moon.prototype, {
/**
* Get the ellipsoid that defines the shape of the moon.
*
* @memberof Moon.prototype
*
* @type {Ellipsoid}
* @readonly
*
* @default {@link Ellipsoid.MOON}
*/
ellipsoid : {
get : function() {
return this._ellipsoid;
}
}
});
var icrfToFixed = new Matrix3();
var rotationScratch = new Matrix3();
var translationScratch = new Cartesian3();
var scratchCommandList = [];
/**
* @private
*/
Moon.prototype.update = function(frameState) {
if (!this.show) {
return;
}
var ellipsoidPrimitive = this._ellipsoidPrimitive;
ellipsoidPrimitive.material.uniforms.image = this.textureUrl;
ellipsoidPrimitive.onlySunLighting = this.onlySunLighting;
var date = frameState.time;
if (!defined(Transforms.computeIcrfToFixedMatrix(date, icrfToFixed))) {
Transforms.computeTemeToPseudoFixedMatrix(date, icrfToFixed);
}
var rotation = this._axes.evaluate(date, rotationScratch);
Matrix3.transpose(rotation, rotation);
Matrix3.multiply(icrfToFixed, rotation, rotation);
var translation = Simon1994PlanetaryPositions.computeMoonPositionInEarthInertialFrame(date, translationScratch);
Matrix3.multiplyByVector(icrfToFixed, translation, translation);
Matrix4.fromRotationTranslation(rotation, translation, ellipsoidPrimitive.modelMatrix);
var savedCommandList = frameState.commandList;
frameState.commandList = scratchCommandList;
scratchCommandList.length = 0;
ellipsoidPrimitive.update(frameState);
frameState.commandList = savedCommandList;
return (scratchCommandList.length === 1) ? scratchCommandList[0] : undefined;
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*
* @see Moon#destroy
*/
Moon.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* moon = moon && moon.destroy();
*
* @see Moon#isDestroyed
*/
Moon.prototype.destroy = function() {
this._ellipsoidPrimitive = this._ellipsoidPrimitive && this._ellipsoidPrimitive.destroy();
return destroyObject(this);
};
return Moon;
});
/*global define*/
define('Scene/NeverTileDiscardPolicy',[], function() {
'use strict';
/**
* A {@link TileDiscardPolicy} specifying that tile images should never be discard.
*
* @alias NeverTileDiscardPolicy
* @constructor
*
* @see DiscardMissingTileImagePolicy
*/
function NeverTileDiscardPolicy(options) {
}
/**
* Determines if the discard policy is ready to process images.
* @returns {Boolean} True if the discard policy is ready to process images; otherwise, false.
*/
NeverTileDiscardPolicy.prototype.isReady = function() {
return true;
};
/**
* Given a tile image, decide whether to discard that image.
*
* @param {Image} image An image to test.
* @returns {Boolean} True if the image should be discarded; otherwise, false.
*/
NeverTileDiscardPolicy.prototype.shouldDiscardImage = function(image) {
return false;
};
return NeverTileDiscardPolicy;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/AdjustTranslucentFS',[],function() {
'use strict';
return "#ifdef MRT\n\
#extension GL_EXT_draw_buffers : enable\n\
#endif\n\
uniform vec4 u_bgColor;\n\
uniform sampler2D u_depthTexture;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
if (texture2D(u_depthTexture, v_textureCoordinates).r < 1.0)\n\
{\n\
#ifdef MRT\n\
gl_FragData[0] = u_bgColor;\n\
gl_FragData[1] = vec4(u_bgColor.a);\n\
#else\n\
gl_FragColor = u_bgColor;\n\
#endif\n\
return;\n\
}\n\
discard;\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/CompositeOITFS',[],function() {
'use strict';
return "uniform sampler2D u_opaque;\n\
uniform sampler2D u_accumulation;\n\
uniform sampler2D u_revealage;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
vec4 opaque = texture2D(u_opaque, v_textureCoordinates);\n\
vec4 accum = texture2D(u_accumulation, v_textureCoordinates);\n\
float r = texture2D(u_revealage, v_textureCoordinates).r;\n\
#ifdef MRT\n\
vec4 transparent = vec4(accum.rgb / clamp(r, 1e-4, 5e4), accum.a);\n\
#else\n\
vec4 transparent = vec4(accum.rgb / clamp(accum.a, 1e-4, 5e4), r);\n\
#endif\n\
gl_FragColor = (1.0 - transparent.a) * transparent + transparent.a * opaque;\n\
}\n\
";
});
/*global define*/
define('Scene/OIT',[
'../Core/BoundingRectangle',
'../Core/Color',
'../Core/defined',
'../Core/destroyObject',
'../Core/PixelFormat',
'../Core/WebGLConstants',
'../Renderer/ClearCommand',
'../Renderer/DrawCommand',
'../Renderer/Framebuffer',
'../Renderer/PixelDatatype',
'../Renderer/RenderState',
'../Renderer/ShaderProgram',
'../Renderer/ShaderSource',
'../Renderer/Texture',
'../Shaders/AdjustTranslucentFS',
'../Shaders/CompositeOITFS',
'./BlendEquation',
'./BlendFunction'
], function(
BoundingRectangle,
Color,
defined,
destroyObject,
PixelFormat,
WebGLConstants,
ClearCommand,
DrawCommand,
Framebuffer,
PixelDatatype,
RenderState,
ShaderProgram,
ShaderSource,
Texture,
AdjustTranslucentFS,
CompositeOITFS,
BlendEquation,
BlendFunction) {
'use strict';
/**
* @private
*/
function OIT(context) {
// We support multipass for the Chrome D3D9 backend and ES 2.0 on mobile.
this._translucentMultipassSupport = false;
this._translucentMRTSupport = false;
var extensionsSupported = context.floatingPointTexture && context.depthTexture;
this._translucentMRTSupport = context.drawBuffers && extensionsSupported;
this._translucentMultipassSupport = !this._translucentMRTSupport && extensionsSupported;
this._opaqueFBO = undefined;
this._opaqueTexture = undefined;
this._depthStencilTexture = undefined;
this._accumulationTexture = undefined;
this._translucentFBO = undefined;
this._alphaFBO = undefined;
this._adjustTranslucentFBO = undefined;
this._adjustAlphaFBO = undefined;
this._opaqueClearCommand = new ClearCommand({
color : new Color(0.0, 0.0, 0.0, 0.0),
owner : this
});
this._translucentMRTClearCommand = new ClearCommand({
color : new Color(0.0, 0.0, 0.0, 1.0),
owner : this
});
this._translucentMultipassClearCommand = new ClearCommand({
color : new Color(0.0, 0.0, 0.0, 0.0),
owner : this
});
this._alphaClearCommand = new ClearCommand({
color : new Color(1.0, 1.0, 1.0, 1.0),
owner : this
});
this._translucentRenderStateCache = {};
this._alphaRenderStateCache = {};
this._translucentShaderCache = {};
this._alphaShaderCache = {};
this._compositeCommand = undefined;
this._adjustTranslucentCommand = undefined;
this._adjustAlphaCommand = undefined;
this._viewport = new BoundingRectangle();
this._rs = undefined;
}
function destroyTextures(oit) {
oit._accumulationTexture = oit._accumulationTexture && !oit._accumulationTexture.isDestroyed() && oit._accumulationTexture.destroy();
oit._revealageTexture = oit._revealageTexture && !oit._revealageTexture.isDestroyed() && oit._revealageTexture.destroy();
}
function destroyFramebuffers(oit) {
oit._translucentFBO = oit._translucentFBO && !oit._translucentFBO.isDestroyed() && oit._translucentFBO.destroy();
oit._alphaFBO = oit._alphaFBO && !oit._alphaFBO.isDestroyed() && oit._alphaFBO.destroy();
oit._adjustTranslucentFBO = oit._adjustTranslucentFBO && !oit._adjustTranslucentFBO.isDestroyed() && oit._adjustTranslucentFBO.destroy();
oit._adjustAlphaFBO = oit._adjustAlphaFBO && !oit._adjustAlphaFBO.isDestroyed() && oit._adjustAlphaFBO.destroy();
}
function destroyResources(oit) {
destroyTextures(oit);
destroyFramebuffers(oit);
}
function updateTextures(oit, context, width, height) {
destroyTextures(oit);
// Use zeroed arraybuffer instead of null to initialize texture
// to workaround Firefox 50. https://github.com/AnalyticalGraphicsInc/cesium/pull/4762
var source = new Float32Array(width * height * 4);
oit._accumulationTexture = new Texture({
context : context,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.FLOAT,
source : {
arrayBufferView : source,
width : width,
height : height
}
});
oit._revealageTexture = new Texture({
context : context,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.FLOAT,
source : {
arrayBufferView : source,
width : width,
height : height
}
});
}
function updateFramebuffers(oit, context) {
destroyFramebuffers(oit);
var completeFBO = WebGLConstants.FRAMEBUFFER_COMPLETE;
var supported = true;
// if MRT is supported, attempt to make an FBO with multiple color attachments
if (oit._translucentMRTSupport) {
oit._translucentFBO = new Framebuffer({
context : context,
colorTextures : [oit._accumulationTexture, oit._revealageTexture],
depthStencilTexture : oit._depthStencilTexture,
destroyAttachments : false
});
oit._adjustTranslucentFBO = new Framebuffer({
context : context,
colorTextures : [oit._accumulationTexture, oit._revealageTexture],
destroyAttachments : false
});
if (oit._translucentFBO.status !== completeFBO || oit._adjustTranslucentFBO.status !== completeFBO) {
destroyFramebuffers(oit);
oit._translucentMRTSupport = false;
}
}
// either MRT isn't supported or FBO creation failed, attempt multipass
if (!oit._translucentMRTSupport) {
oit._translucentFBO = new Framebuffer({
context : context,
colorTextures : [oit._accumulationTexture],
depthStencilTexture : oit._depthStencilTexture,
destroyAttachments : false
});
oit._alphaFBO = new Framebuffer({
context : context,
colorTextures : [oit._revealageTexture],
depthStencilTexture : oit._depthStencilTexture,
destroyAttachments : false
});
oit._adjustTranslucentFBO = new Framebuffer({
context : context,
colorTextures : [oit._accumulationTexture],
destroyAttachments : false
});
oit._adjustAlphaFBO = new Framebuffer({
context : context,
colorTextures : [oit._revealageTexture],
destroyAttachments : false
});
var translucentComplete = oit._translucentFBO.status === completeFBO;
var alphaComplete = oit._alphaFBO.status === completeFBO;
var adjustTranslucentComplete = oit._adjustTranslucentFBO.status === completeFBO;
var adjustAlphaComplete = oit._adjustAlphaFBO.status === completeFBO;
if (!translucentComplete || !alphaComplete || !adjustTranslucentComplete || !adjustAlphaComplete) {
destroyResources(oit);
oit._translucentMultipassSupport = false;
supported = false;
}
}
return supported;
}
OIT.prototype.update = function(context, framebuffer) {
if (!this.isSupported()) {
return;
}
this._opaqueFBO = framebuffer;
this._opaqueTexture = framebuffer.getColorTexture(0);
this._depthStencilTexture = framebuffer.depthStencilTexture;
var width = this._opaqueTexture.width;
var height = this._opaqueTexture.height;
var accumulationTexture = this._accumulationTexture;
var textureChanged = !defined(accumulationTexture) || accumulationTexture.width !== width || accumulationTexture.height !== height;
if (textureChanged) {
updateTextures(this, context, width, height);
}
if (!defined(this._translucentFBO) || textureChanged) {
if (!updateFramebuffers(this, context)) {
// framebuffer creation failed
return;
}
}
var that = this;
var fs;
var uniformMap;
if (!defined(this._compositeCommand)) {
fs = new ShaderSource({
sources : [CompositeOITFS]
});
if (this._translucentMRTSupport) {
fs.defines.push('MRT');
}
uniformMap = {
u_opaque : function() {
return that._opaqueTexture;
},
u_accumulation : function() {
return that._accumulationTexture;
},
u_revealage : function() {
return that._revealageTexture;
}
};
this._compositeCommand = context.createViewportQuadCommand(fs, {
uniformMap : uniformMap,
owner : this
});
}
if (!defined(this._adjustTranslucentCommand)) {
if (this._translucentMRTSupport) {
fs = new ShaderSource({
defines : ['MRT'],
sources : [AdjustTranslucentFS]
});
uniformMap = {
u_bgColor : function() {
return that._translucentMRTClearCommand.color;
},
u_depthTexture : function() {
return that._depthStencilTexture;
}
};
this._adjustTranslucentCommand = context.createViewportQuadCommand(fs, {
uniformMap : uniformMap,
owner : this
});
} else if (this._translucentMultipassSupport) {
fs = new ShaderSource({
sources : [AdjustTranslucentFS]
});
uniformMap = {
u_bgColor : function() {
return that._translucentMultipassClearCommand.color;
},
u_depthTexture : function() {
return that._depthStencilTexture;
}
};
this._adjustTranslucentCommand = context.createViewportQuadCommand(fs, {
uniformMap : uniformMap,
owner : this
});
uniformMap = {
u_bgColor : function() {
return that._alphaClearCommand.color;
},
u_depthTexture : function() {
return that._depthStencilTexture;
}
};
this._adjustAlphaCommand = context.createViewportQuadCommand(fs, {
uniformMap : uniformMap,
owner : this
});
}
}
this._viewport.width = width;
this._viewport.height = height;
if (!defined(this._rs) || !BoundingRectangle.equals(this._viewport, this._rs.viewport)) {
this._rs = RenderState.fromCache({
viewport : this._viewport
});
}
if (defined(this._compositeCommand)) {
this._compositeCommand.renderState = this._rs;
}
if (this._adjustTranslucentCommand) {
this._adjustTranslucentCommand.renderState = this._rs;
}
if (defined(this._adjustAlphaCommand)) {
this._adjustAlphaCommand.renderState = this._rs;
}
};
var translucentMRTBlend = {
enabled : true,
color : new Color(0.0, 0.0, 0.0, 0.0),
equationRgb : BlendEquation.ADD,
equationAlpha : BlendEquation.ADD,
functionSourceRgb : BlendFunction.ONE,
functionDestinationRgb : BlendFunction.ONE,
functionSourceAlpha : BlendFunction.ZERO,
functionDestinationAlpha : BlendFunction.ONE_MINUS_SOURCE_ALPHA
};
var translucentColorBlend = {
enabled : true,
color : new Color(0.0, 0.0, 0.0, 0.0),
equationRgb : BlendEquation.ADD,
equationAlpha : BlendEquation.ADD,
functionSourceRgb : BlendFunction.ONE,
functionDestinationRgb : BlendFunction.ONE,
functionSourceAlpha : BlendFunction.ONE,
functionDestinationAlpha : BlendFunction.ONE
};
var translucentAlphaBlend = {
enabled : true,
color : new Color(0.0, 0.0, 0.0, 0.0),
equationRgb : BlendEquation.ADD,
equationAlpha : BlendEquation.ADD,
functionSourceRgb : BlendFunction.ZERO,
functionDestinationRgb : BlendFunction.ONE_MINUS_SOURCE_ALPHA,
functionSourceAlpha : BlendFunction.ZERO,
functionDestinationAlpha : BlendFunction.ONE_MINUS_SOURCE_ALPHA
};
function getTranslucentRenderState(context, translucentBlending, cache, renderState) {
var translucentState = cache[renderState.id];
if (!defined(translucentState)) {
var rs = RenderState.getState(renderState);
rs.depthMask = false;
rs.blending = translucentBlending;
translucentState = RenderState.fromCache(rs);
cache[renderState.id] = translucentState;
}
return translucentState;
}
function getTranslucentMRTRenderState(oit, context, renderState) {
return getTranslucentRenderState(context, translucentMRTBlend, oit._translucentRenderStateCache, renderState);
}
function getTranslucentColorRenderState(oit, context, renderState) {
return getTranslucentRenderState(context, translucentColorBlend, oit._translucentRenderStateCache, renderState);
}
function getTranslucentAlphaRenderState(oit, context, renderState) {
return getTranslucentRenderState(context, translucentAlphaBlend, oit._alphaRenderStateCache, renderState);
}
var mrtShaderSource =
' vec3 Ci = czm_gl_FragColor.rgb * czm_gl_FragColor.a;\n' +
' float ai = czm_gl_FragColor.a;\n' +
' float wzi = czm_alphaWeight(ai);\n' +
' gl_FragData[0] = vec4(Ci * wzi, ai);\n' +
' gl_FragData[1] = vec4(ai * wzi);\n';
var colorShaderSource =
' vec3 Ci = czm_gl_FragColor.rgb * czm_gl_FragColor.a;\n' +
' float ai = czm_gl_FragColor.a;\n' +
' float wzi = czm_alphaWeight(ai);\n' +
' gl_FragColor = vec4(Ci, ai) * wzi;\n';
var alphaShaderSource =
' float ai = czm_gl_FragColor.a;\n' +
' gl_FragColor = vec4(ai);\n';
function getTranslucentShaderProgram(context, shaderProgram, cache, source) {
var id = shaderProgram.id;
var shader = cache[id];
if (!defined(shader)) {
var attributeLocations = shaderProgram._attributeLocations;
var fs = shaderProgram.fragmentShaderSource.clone();
fs.sources = fs.sources.map(function(source) {
source = ShaderSource.replaceMain(source, 'czm_translucent_main');
source = source.replace(/gl_FragColor/g, 'czm_gl_FragColor');
source = source.replace(/\bdiscard\b/g, 'czm_discard = true');
source = source.replace(/czm_phong/g, 'czm_translucentPhong');
return source;
});
// Discarding the fragment in main is a workaround for ANGLE D3D9
// shader compilation errors.
fs.sources.splice(0, 0,
(source.indexOf('gl_FragData') !== -1 ? '#extension GL_EXT_draw_buffers : enable \n' : '') +
'vec4 czm_gl_FragColor;\n' +
'bool czm_discard = false;\n');
fs.sources.push(
'void main()\n' +
'{\n' +
' czm_translucent_main();\n' +
' if (czm_discard)\n' +
' {\n' +
' discard;\n' +
' }\n' +
source +
'}\n');
shader = ShaderProgram.fromCache({
context : context,
vertexShaderSource : shaderProgram.vertexShaderSource,
fragmentShaderSource : fs,
attributeLocations : attributeLocations
});
cache[id] = shader;
}
return shader;
}
function getTranslucentMRTShaderProgram(oit, context, shaderProgram) {
return getTranslucentShaderProgram(context, shaderProgram, oit._translucentShaderCache, mrtShaderSource);
}
function getTranslucentColorShaderProgram(oit, context, shaderProgram) {
return getTranslucentShaderProgram(context, shaderProgram, oit._translucentShaderCache, colorShaderSource);
}
function getTranslucentAlphaShaderProgram(oit, context, shaderProgram) {
return getTranslucentShaderProgram(context, shaderProgram, oit._alphaShaderCache, alphaShaderSource);
}
OIT.prototype.createDerivedCommands = function(command, context, result) {
if (!defined(result)) {
result = {};
}
if (this._translucentMRTSupport) {
var translucentShader;
var translucentRenderState;
if (defined(result.translucentCommand)) {
translucentShader = result.translucentCommand.shaderProgram;
translucentRenderState = result.translucentCommand.renderState;
}
result.translucentCommand = DrawCommand.shallowClone(command, result.translucentCommand);
if (!defined(translucentShader) || result.shaderProgramId !== command.shaderProgram.id) {
result.translucentCommand.shaderProgram = getTranslucentMRTShaderProgram(this, context, command.shaderProgram);
result.translucentCommand.renderState = getTranslucentMRTRenderState(this, context, command.renderState);
result.shaderProgramId = command.shaderProgram.id;
} else {
result.translucentCommand.shaderProgram = translucentShader;
result.translucentCommand.renderState = translucentRenderState;
}
} else {
var colorShader;
var colorRenderState;
var alphaShader;
var alphaRenderState;
if (defined(result.translucentCommand)) {
colorShader = result.translucentCommand.shaderProgram;
colorRenderState = result.translucentCommand.renderState;
alphaShader = result.alphaCommand.shaderProgram;
alphaRenderState = result.alphaCommand.renderState;
}
result.translucentCommand = DrawCommand.shallowClone(command, result.translucentCommand);
result.alphaCommand = DrawCommand.shallowClone(command, result.alphaCommand);
if (!defined(colorShader) || result.shaderProgramId !== command.shaderProgram.id) {
result.translucentCommand.shaderProgram = getTranslucentColorShaderProgram(this, context, command.shaderProgram);
result.translucentCommand.renderState = getTranslucentColorRenderState(this, context, command.renderState);
result.alphaCommand.shaderProgram = getTranslucentAlphaShaderProgram(this, context, command.shaderProgram);
result.alphaCommand.renderState = getTranslucentAlphaRenderState(this, context, command.renderState);
result.shaderProgramId = command.shaderProgram.id;
} else {
result.translucentCommand.shaderProgram = colorShader;
result.translucentCommand.renderState = colorRenderState;
result.alphaCommand.shaderProgram = alphaShader;
result.alphaCommand.renderState = alphaRenderState;
}
}
return result;
};
function executeTranslucentCommandsSortedMultipass(oit, scene, executeFunction, passState, commands) {
var command;
var derivedCommand;
var j;
var context = scene.context;
var framebuffer = passState.framebuffer;
var length = commands.length;
var shadowsEnabled = scene.frameState.shadowHints.shadowsEnabled;
passState.framebuffer = oit._adjustTranslucentFBO;
oit._adjustTranslucentCommand.execute(context, passState);
passState.framebuffer = oit._adjustAlphaFBO;
oit._adjustAlphaCommand.execute(context, passState);
var debugFramebuffer = oit._opaqueFBO;
passState.framebuffer = oit._translucentFBO;
for (j = 0; j < length; ++j) {
command = commands[j];
derivedCommand = (shadowsEnabled && command.receiveShadows) ? command.derivedCommands.oit.shadows.translucentCommand : command.derivedCommands.oit.translucentCommand;
executeFunction(derivedCommand, scene, context, passState, debugFramebuffer);
}
passState.framebuffer = oit._alphaFBO;
for (j = 0; j < length; ++j) {
command = commands[j];
derivedCommand = (shadowsEnabled && command.receiveShadows) ? command.derivedCommands.oit.shadows.alphaCommand : command.derivedCommands.oit.alphaCommand;
executeFunction(derivedCommand, scene, context, passState, debugFramebuffer);
}
passState.framebuffer = framebuffer;
}
function executeTranslucentCommandsSortedMRT(oit, scene, executeFunction, passState, commands) {
var context = scene.context;
var framebuffer = passState.framebuffer;
var length = commands.length;
var shadowsEnabled = scene.frameState.shadowHints.shadowsEnabled;
passState.framebuffer = oit._adjustTranslucentFBO;
oit._adjustTranslucentCommand.execute(context, passState);
var debugFramebuffer = oit._opaqueFBO;
passState.framebuffer = oit._translucentFBO;
for (var j = 0; j < length; ++j) {
var command = commands[j];
var derivedCommand = (shadowsEnabled && command.receiveShadows) ? command.derivedCommands.oit.shadows.translucentCommand : command.derivedCommands.oit.translucentCommand;
executeFunction(derivedCommand, scene, context, passState, debugFramebuffer);
}
passState.framebuffer = framebuffer;
}
OIT.prototype.executeCommands = function(scene, executeFunction, passState, commands) {
if (this._translucentMRTSupport) {
executeTranslucentCommandsSortedMRT(this, scene, executeFunction, passState, commands);
return;
}
executeTranslucentCommandsSortedMultipass(this, scene, executeFunction, passState, commands);
};
OIT.prototype.execute = function(context, passState) {
this._compositeCommand.execute(context, passState);
};
OIT.prototype.clear = function(context, passState, clearColor) {
var framebuffer = passState.framebuffer;
passState.framebuffer = this._opaqueFBO;
Color.clone(clearColor, this._opaqueClearCommand.color);
this._opaqueClearCommand.execute(context, passState);
passState.framebuffer = this._translucentFBO;
var translucentClearCommand = this._translucentMRTSupport ? this._translucentMRTClearCommand : this._translucentMultipassClearCommand;
translucentClearCommand.execute(context, passState);
if (this._translucentMultipassSupport) {
passState.framebuffer = this._alphaFBO;
this._alphaClearCommand.execute(context, passState);
}
passState.framebuffer = framebuffer;
};
OIT.prototype.isSupported = function() {
return this._translucentMRTSupport || this._translucentMultipassSupport;
};
OIT.prototype.isDestroyed = function() {
return false;
};
OIT.prototype.destroy = function() {
destroyResources(this);
if (defined(this._compositeCommand)) {
this._compositeCommand.shaderProgram = this._compositeCommand.shaderProgram && this._compositeCommand.shaderProgram.destroy();
}
if (defined(this._adjustTranslucentCommand)) {
this._adjustTranslucentCommand.shaderProgram = this._adjustTranslucentCommand.shaderProgram && this._adjustTranslucentCommand.shaderProgram.destroy();
}
if (defined(this._adjustAlphaCommand)) {
this._adjustAlphaCommand.shaderProgram = this._adjustAlphaCommand.shaderProgram && this._adjustAlphaCommand.shaderProgram.destroy();
}
var name;
var cache = this._translucentShaderCache;
for (name in cache) {
if (cache.hasOwnProperty(name) && defined(cache[name])) {
cache[name].destroy();
}
}
this._translucentShaderCache = {};
cache = this._alphaShaderCache;
for (name in cache) {
if (cache.hasOwnProperty(name) && defined(cache[name])) {
cache[name].destroy();
}
}
this._alphaShaderCache = {};
return destroyObject(this);
};
return OIT;
});
/*global define*/
define('Scene/OrthographicFrustum',[
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/Matrix4',
'./CullingVolume'
], function(
Cartesian3,
Cartesian4,
defined,
defineProperties,
DeveloperError,
Matrix4,
CullingVolume) {
'use strict';
/**
* The viewing frustum is defined by 6 planes.
* Each plane is represented by a {@link Cartesian4} object, where the x, y, and z components
* define the unit vector normal to the plane, and the w component is the distance of the
* plane from the origin/camera position.
*
* @alias OrthographicFrustum
* @constructor
*
* @example
* var maxRadii = ellipsoid.maximumRadius;
*
* var frustum = new Cesium.OrthographicFrustum();
* frustum.right = maxRadii * Cesium.Math.PI;
* frustum.left = -c.frustum.right;
* frustum.top = c.frustum.right * (canvas.clientHeight / canvas.clientWidth);
* frustum.bottom = -c.frustum.top;
* frustum.near = 0.01 * maxRadii;
* frustum.far = 50.0 * maxRadii;
*/
function OrthographicFrustum() {
/**
* The left clipping plane.
* @type {Number}
* @default undefined
*/
this.left = undefined;
this._left = undefined;
/**
* The right clipping plane.
* @type {Number}
* @default undefined
*/
this.right = undefined;
this._right = undefined;
/**
* The top clipping plane.
* @type {Number}
* @default undefined
*/
this.top = undefined;
this._top = undefined;
/**
* The bottom clipping plane.
* @type {Number}
* @default undefined
*/
this.bottom = undefined;
this._bottom = undefined;
/**
* The distance of the near plane.
* @type {Number}
* @default 1.0
*/
this.near = 1.0;
this._near = this.near;
/**
* The distance of the far plane.
* @type {Number}
* @default 500000000.0;
*/
this.far = 500000000.0;
this._far = this.far;
this._cullingVolume = new CullingVolume();
this._orthographicMatrix = new Matrix4();
}
function update(frustum) {
if (!defined(frustum.right) || !defined(frustum.left) ||
!defined(frustum.top) || !defined(frustum.bottom) ||
!defined(frustum.near) || !defined(frustum.far)) {
throw new DeveloperError('right, left, top, bottom, near, or far parameters are not set.');
}
if (frustum.top !== frustum._top || frustum.bottom !== frustum._bottom ||
frustum.left !== frustum._left || frustum.right !== frustum._right ||
frustum.near !== frustum._near || frustum.far !== frustum._far) {
if (frustum.left > frustum.right) {
throw new DeveloperError('right must be greater than left.');
}
if (frustum.bottom > frustum.top) {
throw new DeveloperError('top must be greater than bottom.');
}
if (frustum.near <= 0 || frustum.near > frustum.far) {
throw new DeveloperError('near must be greater than zero and less than far.');
}
frustum._left = frustum.left;
frustum._right = frustum.right;
frustum._top = frustum.top;
frustum._bottom = frustum.bottom;
frustum._near = frustum.near;
frustum._far = frustum.far;
frustum._orthographicMatrix = Matrix4.computeOrthographicOffCenter(frustum.left, frustum.right, frustum.bottom, frustum.top, frustum.near, frustum.far, frustum._orthographicMatrix);
}
}
defineProperties(OrthographicFrustum.prototype, {
/**
* Gets the orthographic projection matrix computed from the view frustum.
* @memberof OrthographicFrustum.prototype
* @type {Matrix4}
* @readonly
*/
projectionMatrix : {
get : function() {
update(this);
return this._orthographicMatrix;
}
}
});
var getPlanesRight = new Cartesian3();
var getPlanesNearCenter = new Cartesian3();
var getPlanesPoint = new Cartesian3();
var negateScratch = new Cartesian3();
/**
* Creates a culling volume for this frustum.
*
* @param {Cartesian3} position The eye position.
* @param {Cartesian3} direction The view direction.
* @param {Cartesian3} up The up direction.
* @returns {CullingVolume} A culling volume at the given position and orientation.
*
* @example
* // Check if a bounding volume intersects the frustum.
* var cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
* var intersect = cullingVolume.computeVisibility(boundingVolume);
*/
OrthographicFrustum.prototype.computeCullingVolume = function(position, direction, up) {
if (!defined(position)) {
throw new DeveloperError('position is required.');
}
if (!defined(direction)) {
throw new DeveloperError('direction is required.');
}
if (!defined(up)) {
throw new DeveloperError('up is required.');
}
var planes = this._cullingVolume.planes;
var t = this.top;
var b = this.bottom;
var r = this.right;
var l = this.left;
var n = this.near;
var f = this.far;
var right = Cartesian3.cross(direction, up, getPlanesRight);
var nearCenter = getPlanesNearCenter;
Cartesian3.multiplyByScalar(direction, n, nearCenter);
Cartesian3.add(position, nearCenter, nearCenter);
var point = getPlanesPoint;
// Left plane
Cartesian3.multiplyByScalar(right, l, point);
Cartesian3.add(nearCenter, point, point);
var plane = planes[0];
if (!defined(plane)) {
plane = planes[0] = new Cartesian4();
}
plane.x = right.x;
plane.y = right.y;
plane.z = right.z;
plane.w = -Cartesian3.dot(right, point);
// Right plane
Cartesian3.multiplyByScalar(right, r, point);
Cartesian3.add(nearCenter, point, point);
plane = planes[1];
if (!defined(plane)) {
plane = planes[1] = new Cartesian4();
}
plane.x = -right.x;
plane.y = -right.y;
plane.z = -right.z;
plane.w = -Cartesian3.dot(Cartesian3.negate(right, negateScratch), point);
// Bottom plane
Cartesian3.multiplyByScalar(up, b, point);
Cartesian3.add(nearCenter, point, point);
plane = planes[2];
if (!defined(plane)) {
plane = planes[2] = new Cartesian4();
}
plane.x = up.x;
plane.y = up.y;
plane.z = up.z;
plane.w = -Cartesian3.dot(up, point);
// Top plane
Cartesian3.multiplyByScalar(up, t, point);
Cartesian3.add(nearCenter, point, point);
plane = planes[3];
if (!defined(plane)) {
plane = planes[3] = new Cartesian4();
}
plane.x = -up.x;
plane.y = -up.y;
plane.z = -up.z;
plane.w = -Cartesian3.dot(Cartesian3.negate(up, negateScratch), point);
// Near plane
plane = planes[4];
if (!defined(plane)) {
plane = planes[4] = new Cartesian4();
}
plane.x = direction.x;
plane.y = direction.y;
plane.z = direction.z;
plane.w = -Cartesian3.dot(direction, nearCenter);
// Far plane
Cartesian3.multiplyByScalar(direction, f, point);
Cartesian3.add(position, point, point);
plane = planes[5];
if (!defined(plane)) {
plane = planes[5] = new Cartesian4();
}
plane.x = -direction.x;
plane.y = -direction.y;
plane.z = -direction.z;
plane.w = -Cartesian3.dot(Cartesian3.negate(direction, negateScratch), point);
return this._cullingVolume;
};
/**
* Returns the pixel's width and height in meters.
*
* @param {Number} drawingBufferWidth The width of the drawing buffer.
* @param {Number} drawingBufferHeight The height of the drawing buffer.
* @param {Number} distance The distance to the near plane in meters.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter or a new instance of {@link Cartesian2} with the pixel's width and height in the x and y properties, respectively.
*
* @exception {DeveloperError} drawingBufferWidth must be greater than zero.
* @exception {DeveloperError} drawingBufferHeight must be greater than zero.
*
* @example
* // Example 1
* // Get the width and height of a pixel.
* var pixelSize = camera.frustum.getPixelDimensions(scene.drawingBufferWidth, scene.drawingBufferHeight, 0.0, new Cesium.Cartesian2());
*/
OrthographicFrustum.prototype.getPixelDimensions = function(drawingBufferWidth, drawingBufferHeight, distance, result) {
update(this);
if (!defined(drawingBufferWidth) || !defined(drawingBufferHeight)) {
throw new DeveloperError('Both drawingBufferWidth and drawingBufferHeight are required.');
}
if (drawingBufferWidth <= 0) {
throw new DeveloperError('drawingBufferWidth must be greater than zero.');
}
if (drawingBufferHeight <= 0) {
throw new DeveloperError('drawingBufferHeight must be greater than zero.');
}
if (!defined(distance)) {
throw new DeveloperError('distance is required.');
}
if (!defined(result)) {
throw new DeveloperError('A result object is required.');
}
var frustumWidth = this.right - this.left;
var frustumHeight = this.top - this.bottom;
var pixelWidth = frustumWidth / drawingBufferWidth;
var pixelHeight = frustumHeight / drawingBufferHeight;
result.x = pixelWidth;
result.y = pixelHeight;
return result;
};
/**
* Returns a duplicate of a OrthographicFrustum instance.
*
* @param {OrthographicFrustum} [result] The object onto which to store the result.
* @returns {OrthographicFrustum} The modified result parameter or a new PerspectiveFrustum instance if one was not provided.
*/
OrthographicFrustum.prototype.clone = function(result) {
if (!defined(result)) {
result = new OrthographicFrustum();
}
result.left = this.left;
result.right = this.right;
result.top = this.top;
result.bottom = this.bottom;
result.near = this.near;
result.far = this.far;
// force update of clone to compute matrices
result._left = undefined;
result._right = undefined;
result._top = undefined;
result._bottom = undefined;
result._near = undefined;
result._far = undefined;
return result;
};
/**
* Compares the provided OrthographicFrustum componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {OrthographicFrustum} [other] The right hand side OrthographicFrustum.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
OrthographicFrustum.prototype.equals = function(other) {
return (defined(other) &&
this.right === other.right &&
this.left === other.left &&
this.top === other.top &&
this.bottom === other.bottom &&
this.near === other.near &&
this.far === other.far);
};
return OrthographicFrustum;
});
/*global define*/
define('Widgets/getElement',[
'../Core/DeveloperError'
], function(
DeveloperError) {
'use strict';
/**
* If element is a string, look up the element in the DOM by ID. Otherwise return element.
*
* @private
*
* @exception {DeveloperError} Element with id "id" does not exist in the document.
*/
function getElement(element) {
if (typeof element === 'string') {
var foundElement = document.getElementById(element);
if (foundElement === null) {
throw new DeveloperError('Element with id "' + element + '" does not exist in the document.');
}
element = foundElement;
}
return element;
}
return getElement;
});
/*global define*/
define('Scene/PerformanceDisplay',[
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/getTimestamp',
'../Widgets/getElement'
], function(
defaultValue,
defined,
destroyObject,
DeveloperError,
getTimestamp,
getElement) {
'use strict';
/**
* @private
*/
function PerformanceDisplay(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var container = getElement(options.container);
if (!defined(container)) {
throw new DeveloperError('container is required');
}
this._container = container;
var display = document.createElement('div');
display.className = 'cesium-performanceDisplay';
var fpsElement = document.createElement('div');
fpsElement.className = 'cesium-performanceDisplay-fps';
this._fpsText = document.createTextNode("");
fpsElement.appendChild(this._fpsText);
var msElement = document.createElement('div');
msElement.className = 'cesium-performanceDisplay-ms';
this._msText = document.createTextNode("");
msElement.appendChild(this._msText);
display.appendChild(msElement);
display.appendChild(fpsElement);
this._container.appendChild(display);
this._lastFpsSampleTime = undefined;
this._frameCount = 0;
this._time = undefined;
this._fps = 0;
this._frameTime = 0;
}
/**
* Update the display. This function should only be called once per frame, because
* each call records a frame in the internal buffer and redraws the display.
*/
PerformanceDisplay.prototype.update = function() {
if (!defined(this._time)) {
//first update
this._lastFpsSampleTime = getTimestamp();
this._time = getTimestamp();
return;
}
var previousTime = this._time;
var time = getTimestamp();
this._time = time;
var frameTime = time - previousTime;
this._frameCount++;
var fps = this._fps;
var fpsElapsedTime = time - this._lastFpsSampleTime;
if (fpsElapsedTime > 1000) {
fps = this._frameCount * 1000 / fpsElapsedTime | 0;
this._lastFpsSampleTime = time;
this._frameCount = 0;
}
if (fps !== this._fps) {
this._fpsText.nodeValue = fps + ' FPS';
this._fps = fps;
}
if (frameTime !== this._frameTime) {
this._msText.nodeValue = frameTime.toFixed(2) + ' MS';
this._frameTime = frameTime;
}
};
/**
* Destroys the WebGL resources held by this object.
*/
PerformanceDisplay.prototype.destroy = function() {
return destroyObject(this);
};
return PerformanceDisplay;
});
/*global define*/
define('Scene/PickDepth',[
'../Core/defined',
'../Core/destroyObject',
'../Core/PixelFormat',
'../Renderer/Framebuffer',
'../Renderer/PixelDatatype',
'../Renderer/RenderState',
'../Renderer/Texture'
], function(
defined,
destroyObject,
PixelFormat,
Framebuffer,
PixelDatatype,
RenderState,
Texture) {
'use strict';
/**
* @private
*/
function PickDepth() {
this.framebuffer = undefined;
this._depthTexture = undefined;
this._textureToCopy = undefined;
this._copyDepthCommand = undefined;
this._debugPickDepthViewportCommand = undefined;
}
function executeDebugPickDepth(pickDepth, context, passState) {
if (!defined(pickDepth._debugPickDepthViewportCommand)) {
var fs =
'uniform sampler2D u_texture;\n' +
'varying vec2 v_textureCoordinates;\n' +
'void main()\n' +
'{\n' +
' float z_window = czm_unpackDepth(texture2D(u_texture, v_textureCoordinates));\n' +
' float n_range = czm_depthRange.near;\n' +
' float f_range = czm_depthRange.far;\n' +
' float z_ndc = (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n' +
' float scale = pow(z_ndc * 0.5 + 0.5, 8.0);\n' +
' gl_FragColor = vec4(mix(vec3(0.0), vec3(1.0), scale), 1.0);\n' +
'}\n';
pickDepth._debugPickDepthViewportCommand = context.createViewportQuadCommand(fs, {
uniformMap : {
u_texture : function() {
return pickDepth._depthTexture;
}
},
owner : pickDepth
});
}
pickDepth._debugPickDepthViewportCommand.execute(context, passState);
}
function destroyTextures(pickDepth) {
pickDepth._depthTexture = pickDepth._depthTexture && !pickDepth._depthTexture.isDestroyed() && pickDepth._depthTexture.destroy();
}
function destroyFramebuffers(pickDepth) {
pickDepth.framebuffer = pickDepth.framebuffer && !pickDepth.framebuffer.isDestroyed() && pickDepth.framebuffer.destroy();
}
function createTextures(pickDepth, context, width, height) {
pickDepth._depthTexture = new Texture({
context : context,
width : width,
height : height,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE
});
}
function createFramebuffers(pickDepth, context, width, height) {
destroyTextures(pickDepth);
destroyFramebuffers(pickDepth);
createTextures(pickDepth, context, width, height);
pickDepth.framebuffer = new Framebuffer({
context : context,
colorTextures : [pickDepth._depthTexture],
destroyAttachments : false
});
}
function updateFramebuffers(pickDepth, context, depthTexture) {
var width = depthTexture.width;
var height = depthTexture.height;
var texture = pickDepth._depthTexture;
var textureChanged = !defined(texture) || texture.width !== width || texture.height !== height;
if (!defined(pickDepth.framebuffer) || textureChanged) {
createFramebuffers(pickDepth, context, width, height);
}
}
function updateCopyCommands(pickDepth, context, depthTexture) {
if (!defined(pickDepth._copyDepthCommand)) {
var fs =
'uniform sampler2D u_texture;\n' +
'varying vec2 v_textureCoordinates;\n' +
'void main()\n' +
'{\n' +
' gl_FragColor = czm_packDepth(texture2D(u_texture, v_textureCoordinates).r);\n' +
'}\n';
pickDepth._copyDepthCommand = context.createViewportQuadCommand(fs, {
renderState : RenderState.fromCache(),
uniformMap : {
u_texture : function() {
return pickDepth._textureToCopy;
}
},
owner : pickDepth
});
}
pickDepth._textureToCopy = depthTexture;
pickDepth._copyDepthCommand.framebuffer = pickDepth.framebuffer;
}
PickDepth.prototype.executeDebugPickDepth = function(context, passState) {
executeDebugPickDepth(this, context, passState);
};
PickDepth.prototype.update = function(context, depthTexture) {
updateFramebuffers(this, context, depthTexture);
updateCopyCommands(this, context, depthTexture);
};
PickDepth.prototype.executeCopyDepth = function(context, passState) {
this._copyDepthCommand.execute(context, passState);
};
PickDepth.prototype.isDestroyed = function() {
return false;
};
PickDepth.prototype.destroy = function() {
destroyTextures(this);
destroyFramebuffers(this);
this._copyDepthCommand.shaderProgram = defined(this._copyDepthCommand.shaderProgram) && this._copyDepthCommand.shaderProgram.destroy();
return destroyObject(this);
};
return PickDepth;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/Appearances/PointAppearanceFS',[],function() {
'use strict';
return "uniform vec4 highlightColor;\n\
varying vec3 v_color;\n\
void main()\n\
{\n\
gl_FragColor = vec4(v_color * highlightColor.rgb, highlightColor.a);\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/Appearances/PointAppearanceVS',[],function() {
'use strict';
return "attribute vec3 position3DHigh;\n\
attribute vec3 position3DLow;\n\
attribute vec3 color;\n\
attribute float batchId;\n\
uniform float pointSize;\n\
varying vec3 v_positionEC;\n\
varying vec3 v_color;\n\
void main()\n\
{\n\
v_color = color;\n\
gl_Position = czm_modelViewProjectionRelativeToEye * czm_computePosition();\n\
gl_PointSize = pointSize;\n\
}\n\
";
});
/*global define*/
define('Scene/PointAppearance',[
'../Core/Color',
'../Core/combine',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/VertexFormat',
'../Shaders/Appearances/PointAppearanceFS',
'../Shaders/Appearances/PointAppearanceVS',
'./Appearance'
], function(
Color,
combine,
defaultValue,
defined,
defineProperties,
VertexFormat,
PointAppearanceFS,
PointAppearanceVS,
Appearance) {
'use strict';
/**
* An appearance for point geometry {@link PointGeometry}
*
* @alias PointAppearance
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Boolean} [options.translucent=false] When <code>true</code>, the geometry is expected to appear translucent so {@link PointAppearance#renderState} has alpha blending enabled.
* @param {String} [options.vertexShaderSource] Optional GLSL vertex shader source to override the default vertex shader.
* @param {String} [options.fragmentShaderSource] Optional GLSL fragment shader source to override the default fragment shader.
* @param {RenderState} [options.renderState] Optional render state to override the default render state.
* @param {Object} [options.uniforms] Additional uniforms that are used by the vertex and fragment shaders.
* @param {Number} [options.pointSize] Point size in pixels.
* @param {Color} [options.highlightColor] Color multiplier in the fragment shader. The alpha channel is used for alpha blending when translucency is enabled.
*
* @example
* var primitive = new Cesium.Primitive({
* geometryInstances : new Cesium.GeometryInstance({
* geometry : new Cesium.PointGeometry({
* positionsTypedArray : positions,
* colorsTypedArray : colors,
* boundingSphere : boundingSphere
* })
* }),
* appearance : new Cesium.PointAppearance({
* translucent : true
* })
* });
*
* @private
*/
function PointAppearance(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
this._vertexShaderSource = defaultValue(options.vertexShaderSource, PointAppearanceVS);
this._fragmentShaderSource = defaultValue(options.fragmentShaderSource, PointAppearanceFS);
this._renderState = Appearance.getDefaultRenderState(false, false, options.renderState);
this._pointSize = defaultValue(options.pointSize, 2.0);
this._highlightColor = defined(options.highlightColor) ? options.highlightColor : new Color();
/**
* This property is part of the {@link Appearance} interface, but is not
* used by {@link PointAppearance} since a fully custom fragment shader is used.
*
* @type Material
*
* @default undefined
*/
this.material = undefined;
/**
* When <code>true</code>, the geometry is expected to appear translucent.
*
* @type {Boolean}
*
* @default false
*/
this.translucent = defaultValue(options.translucent, false);
/**
* @private
*/
this.uniforms = {
highlightColor : this._highlightColor,
pointSize : this._pointSize
};
// Combine default uniforms and additional uniforms
var optionsUniforms = options.uniforms;
this.uniforms = combine(this.uniforms, optionsUniforms, true);
}
defineProperties(PointAppearance.prototype, {
/**
* The GLSL source code for the vertex shader.
*
* @memberof PointAppearance.prototype
*
* @type {String}
* @readonly
*/
vertexShaderSource : {
get : function() {
return this._vertexShaderSource;
}
},
/**
* The GLSL source code for the fragment shader. The full fragment shader
* source is built procedurally taking into account the {@link PointAppearance#material}.
* Use {@link PointAppearance#getFragmentShaderSource} to get the full source.
*
* @memberof PointAppearance.prototype
*
* @type {String}
* @readonly
*/
fragmentShaderSource : {
get : function() {
return this._fragmentShaderSource;
}
},
/**
* The WebGL fixed-function state to use when rendering the geometry.
*
* @memberof PointAppearance.prototype
*
* @type {Object}
* @readonly
*/
renderState : {
get : function() {
return this._renderState;
}
},
/**
* When <code>true</code>, the geometry is expected to be closed.
*
* @memberof PointAppearance.prototype
*
* @type {Boolean}
* @readonly
*
* @default false
*/
closed : {
get : function() {
return false;
}
},
/**
* The {@link VertexFormat} that this appearance instance is compatible with.
* A geometry can have more vertex attributes and still be compatible - at a
* potential performance cost - but it can't have less.
*
* @memberof PointAppearance.prototype
*
* @type VertexFormat
* @readonly
*
* @default {@link PointAppearance.VERTEX_FORMAT}
*/
vertexFormat : {
get : function() {
return PointAppearance.VERTEX_FORMAT;
}
},
/**
* The size in pixels used when rendering the primitive. This helps calculate an accurate
* bounding volume for point rendering and other appearances that are defined in pixel sizes.
*
* @memberof PointAppearance.prototype
*
* @type {Number}
* @readonly
*/
pixelSize : {
get : function() {
return this._pointSize;
}
}
});
/**
* The {@link VertexFormat} that all {@link PointAppearance} instances
* are compatible with, which requires only <code>position</code> and <code>color</code>
* attributes. Other attributes are procedurally computed in the fragment shader.
*
* @type VertexFormat
*
* @constant
*/
PointAppearance.VERTEX_FORMAT = VertexFormat.POSITION_AND_COLOR;
/**
* Returns the full GLSL fragment shader source, which for {@link PointAppearance} is just
* {@link PointAppearance#fragmentShaderSource}.
*
* @function
*
* @returns {String} The full GLSL fragment shader source.
*/
PointAppearance.prototype.getFragmentShaderSource = Appearance.prototype.getFragmentShaderSource;
/**
* Determines if the geometry is translucent based on {@link PointAppearance#translucent}.
*
* @function
*
* @returns {Boolean} <code>true</code> if the appearance is translucent.
*/
PointAppearance.prototype.isTranslucent = Appearance.prototype.isTranslucent;
/**
* Creates a render state. This is not the final render state instance; instead,
* it can contain a subset of render state properties identical to the render state
* created in the context.
*
* @function
*
* @returns {Object} The render state.
*/
PointAppearance.prototype.getRenderState = Appearance.prototype.getRenderState;
return PointAppearance;
});
/*global define*/
define('Scene/PrimitiveCollection',[
'../Core/createGuid',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/DeveloperError'
], function(
createGuid,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError) {
'use strict';
/**
* A collection of primitives. This is most often used with {@link Scene#primitives},
* but <code>PrimitiveCollection</code> is also a primitive itself so collections can
* be added to collections forming a hierarchy.
*
* @alias PrimitiveCollection
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Boolean} [options.show=true] Determines if the primitives in the collection will be shown.
* @param {Boolean} [options.destroyPrimitives=true] Determines if primitives in the collection are destroyed when they are removed.
*
* @example
* var billboards = new Cesium.BillboardCollection();
* var labels = new Cesium.LabelCollection();
*
* var collection = new Cesium.PrimitiveCollection();
* collection.add(billboards);
*
* scene.primitives.add(collection); // Add collection
* scene.primitives.add(labels); // Add regular primitive
*/
function PrimitiveCollection(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
this._primitives = [];
this._guid = createGuid();
/**
* Determines if primitives in this collection will be shown.
*
* @type {Boolean}
* @default true
*/
this.show = defaultValue(options.show, true);
/**
* Determines if primitives in the collection are destroyed when they are removed by
* {@link PrimitiveCollection#destroy} or {@link PrimitiveCollection#remove} or implicitly
* by {@link PrimitiveCollection#removeAll}.
*
* @type {Boolean}
* @default true
*
* @example
* // Example 1. Primitives are destroyed by default.
* var primitives = new Cesium.PrimitiveCollection();
* var labels = primitives.add(new Cesium.LabelCollection());
* primitives = primitives.destroy();
* var b = labels.isDestroyed(); // true
*
* @example
* // Example 2. Do not destroy primitives in a collection.
* var primitives = new Cesium.PrimitiveCollection();
* primitives.destroyPrimitives = false;
* var labels = primitives.add(new Cesium.LabelCollection());
* primitives = primitives.destroy();
* var b = labels.isDestroyed(); // false
* labels = labels.destroy(); // explicitly destroy
*/
this.destroyPrimitives = defaultValue(options.destroyPrimitives, true);
}
defineProperties(PrimitiveCollection.prototype, {
/**
* Gets the number of primitives in the collection.
*
* @memberof PrimitiveCollection.prototype
*
* @type {Number}
* @readonly
*/
length : {
get : function() {
return this._primitives.length;
}
}
});
/**
* Adds a primitive to the collection.
*
* @param {Object} primitive The primitive to add.
* @returns {Object} The primitive added to the collection.
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @example
* var billboards = scene.primitives.add(new Cesium.BillboardCollection());
*/
PrimitiveCollection.prototype.add = function(primitive) {
if (!defined(primitive)) {
throw new DeveloperError('primitive is required.');
}
var external = (primitive._external = primitive._external || {});
var composites = (external._composites = external._composites || {});
composites[this._guid] = {
collection : this
};
this._primitives.push(primitive);
return primitive;
};
/**
* Removes a primitive from the collection.
*
* @param {Object} [primitive] The primitive to remove.
* @returns {Boolean} <code>true</code> if the primitive was removed; <code>false</code> if the primitive is <code>undefined</code> or was not found in the collection.
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* var billboards = scene.primitives.add(new Cesium.BillboardCollection());
* scene.primitives.remove(p); // Returns true
*
* @see PrimitiveCollection#destroyPrimitives
*/
PrimitiveCollection.prototype.remove = function(primitive) {
// PERFORMANCE_IDEA: We can obviously make this a lot faster.
if (this.contains(primitive)) {
var index = this._primitives.indexOf(primitive);
if (index !== -1) {
this._primitives.splice(index, 1);
delete primitive._external._composites[this._guid];
if (this.destroyPrimitives) {
primitive.destroy();
}
return true;
}
// else ... this is not possible, I swear.
}
return false;
};
/**
* Removes and destroys a primitive, regardless of destroyPrimitives setting.
* @private
*/
PrimitiveCollection.prototype.removeAndDestroy = function(primitive) {
var removed = this.remove(primitive);
if (removed && !this.destroyPrimitives) {
primitive.destroy();
}
return removed;
};
/**
* Removes all primitives in the collection.
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see PrimitiveCollection#destroyPrimitives
*/
PrimitiveCollection.prototype.removeAll = function() {
if (this.destroyPrimitives) {
var primitives = this._primitives;
var length = primitives.length;
for ( var i = 0; i < length; ++i) {
primitives[i].destroy();
}
}
this._primitives = [];
};
/**
* Determines if this collection contains a primitive.
*
* @param {Object} [primitive] The primitive to check for.
* @returns {Boolean} <code>true</code> if the primitive is in the collection; <code>false</code> if the primitive is <code>undefined</code> or was not found in the collection.
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see PrimitiveCollection#get
*/
PrimitiveCollection.prototype.contains = function(primitive) {
return !!(defined(primitive) &&
primitive._external &&
primitive._external._composites &&
primitive._external._composites[this._guid]);
};
function getPrimitiveIndex(compositePrimitive, primitive) {
if (!compositePrimitive.contains(primitive)) {
throw new DeveloperError('primitive is not in this collection.');
}
return compositePrimitive._primitives.indexOf(primitive);
}
/**
* Raises a primitive "up one" in the collection. If all primitives in the collection are drawn
* on the globe surface, this visually moves the primitive up one.
*
* @param {Object} [primitive] The primitive to raise.
*
* @exception {DeveloperError} primitive is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see PrimitiveCollection#raiseToTop
* @see PrimitiveCollection#lower
* @see PrimitiveCollection#lowerToBottom
*/
PrimitiveCollection.prototype.raise = function(primitive) {
if (defined(primitive)) {
var index = getPrimitiveIndex(this, primitive);
var primitives = this._primitives;
if (index !== primitives.length - 1) {
var p = primitives[index];
primitives[index] = primitives[index + 1];
primitives[index + 1] = p;
}
}
};
/**
* Raises a primitive to the "top" of the collection. If all primitives in the collection are drawn
* on the globe surface, this visually moves the primitive to the top.
*
* @param {Object} [primitive] The primitive to raise the top.
*
* @exception {DeveloperError} primitive is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see PrimitiveCollection#raise
* @see PrimitiveCollection#lower
* @see PrimitiveCollection#lowerToBottom
*/
PrimitiveCollection.prototype.raiseToTop = function(primitive) {
if (defined(primitive)) {
var index = getPrimitiveIndex(this, primitive);
var primitives = this._primitives;
if (index !== primitives.length - 1) {
// PERFORMANCE_IDEA: Could be faster
primitives.splice(index, 1);
primitives.push(primitive);
}
}
};
/**
* Lowers a primitive "down one" in the collection. If all primitives in the collection are drawn
* on the globe surface, this visually moves the primitive down one.
*
* @param {Object} [primitive] The primitive to lower.
*
* @exception {DeveloperError} primitive is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see PrimitiveCollection#lowerToBottom
* @see PrimitiveCollection#raise
* @see PrimitiveCollection#raiseToTop
*/
PrimitiveCollection.prototype.lower = function(primitive) {
if (defined(primitive)) {
var index = getPrimitiveIndex(this, primitive);
var primitives = this._primitives;
if (index !== 0) {
var p = primitives[index];
primitives[index] = primitives[index - 1];
primitives[index - 1] = p;
}
}
};
/**
* Lowers a primitive to the "bottom" of the collection. If all primitives in the collection are drawn
* on the globe surface, this visually moves the primitive to the bottom.
*
* @param {Object} [primitive] The primitive to lower to the bottom.
*
* @exception {DeveloperError} primitive is not in this collection.
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see PrimitiveCollection#lower
* @see PrimitiveCollection#raise
* @see PrimitiveCollection#raiseToTop
*/
PrimitiveCollection.prototype.lowerToBottom = function(primitive) {
if (defined(primitive)) {
var index = getPrimitiveIndex(this, primitive);
var primitives = this._primitives;
if (index !== 0) {
// PERFORMANCE_IDEA: Could be faster
primitives.splice(index, 1);
primitives.unshift(primitive);
}
}
};
/**
* Returns the primitive in the collection at the specified index.
*
* @param {Number} index The zero-based index of the primitive to return.
* @returns {Object} The primitive at the <code>index</code>.
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* // Toggle the show property of every primitive in the collection.
* var primitives = scene.primitives;
* var length = primitives.length;
* for (var i = 0; i < length; ++i) {
* var p = primitives.get(i);
* p.show = !p.show;
* }
*
* @see PrimitiveCollection#length
*/
PrimitiveCollection.prototype.get = function(index) {
if (!defined(index)) {
throw new DeveloperError('index is required.');
}
return this._primitives[index];
};
/**
* @private
*/
PrimitiveCollection.prototype.update = function(frameState) {
if (!this.show) {
return;
}
var primitives = this._primitives;
// Using primitives.length in the loop is a temporary workaround
// to allow quadtree updates to add and remove primitives in
// update(). This will be changed to manage added and removed lists.
for (var i = 0; i < primitives.length; ++i) {
primitives[i].update(frameState);
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see PrimitiveCollection#destroy
*/
PrimitiveCollection.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by each primitive in this collection. Explicitly destroying this
* collection allows for deterministic release of WebGL resources, instead of relying on the garbage
* collector to destroy this collection.
* <br /><br />
* Since destroying a collection destroys all the contained primitives, only destroy a collection
* when you are sure no other code is still using any of the contained primitives.
* <br /><br />
* Once this collection is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* primitives = primitives && primitives.destroy();
*
* @see PrimitiveCollection#isDestroyed
*/
PrimitiveCollection.prototype.destroy = function() {
this.removeAll();
return destroyObject(this);
};
return PrimitiveCollection;
});
/*global define*/
define('Scene/QuadtreeTileProvider',[
'../Core/defineProperties',
'../Core/DeveloperError'
], function(
defineProperties,
DeveloperError) {
'use strict';
/**
* Provides general quadtree tiles to be displayed on or near the surface of an ellipsoid. It is intended to be
* used with the {@link QuadtreePrimitive}. This type describes an interface and is not intended to be
* instantiated directly.
*
* @alias QuadtreeTileProvider
* @constructor
* @private
*/
function QuadtreeTileProvider() {
DeveloperError.throwInstantiationError();
}
/**
* Computes the default geometric error for level zero of the quadtree.
*
* @memberof QuadtreeTileProvider
*
* @param {TilingScheme} tilingScheme The tiling scheme for which to compute the geometric error.
* @returns {Number} The maximum geometric error at level zero, in meters.
*/
QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError = function(tilingScheme) {
return tilingScheme.ellipsoid.maximumRadius * 2 * Math.PI * 0.25 / (65 * tilingScheme.getNumberOfXTilesAtLevel(0));
};
defineProperties(QuadtreeTileProvider.prototype, {
/**
* Gets or sets the {@link QuadtreePrimitive} for which this provider is
* providing tiles.
* @memberof QuadtreeTileProvider.prototype
* @type {QuadtreePrimitive}
*/
quadtree : {
get : DeveloperError.throwInstantiationError,
set : DeveloperError.throwInstantiationError
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof QuadtreeTileProvider.prototype
* @type {Boolean}
*/
ready : {
get : DeveloperError.throwInstantiationError
},
/**
* Gets the tiling scheme used by the provider. This property should
* not be accessed before {@link QuadtreeTileProvider#ready} returns true.
* @memberof QuadtreeTileProvider.prototype
* @type {TilingScheme}
*/
tilingScheme : {
get : DeveloperError.throwInstantiationError
},
/**
* Gets an event that is raised when the geometry provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof QuadtreeTileProvider.prototype
* @type {Event}
*/
errorEvent : {
get : DeveloperError.throwInstantiationError
}
});
/**
* Called at the beginning of the update cycle for each render frame, before {@link QuadtreeTileProvider#showTileThisFrame}
* or any other functions.
* @memberof QuadtreeTileProvider
* @function
*
* @param {Context} context The rendering context.
* @param {FrameState} frameState The frame state.
* @param {DrawCommand[]} commandList An array of rendering commands. This method may push
* commands into this array.
*/
QuadtreeTileProvider.prototype.beginUpdate = DeveloperError.throwInstantiationError;
/**
* Called at the end of the update cycle for each render frame, after {@link QuadtreeTileProvider#showTileThisFrame}
* and any other functions.
* @memberof QuadtreeTileProvider
* @function
*
* @param {Context} context The rendering context.
* @param {FrameState} frameState The frame state.
* @param {DrawCommand[]} commandList An array of rendering commands. This method may push
* commands into this array.
*/
QuadtreeTileProvider.prototype.endUpdate = DeveloperError.throwInstantiationError;
/**
* Gets the maximum geometric error allowed in a tile at a given level, in meters. This function should not be
* called before {@link QuadtreeTileProvider#ready} returns true.
*
* @see {QuadtreeTileProvider.computeDefaultLevelZeroMaximumGeometricError}
*
* @memberof QuadtreeTileProvider
* @function
*
* @param {Number} level The tile level for which to get the maximum geometric error.
* @returns {Number} The maximum geometric error in meters.
*/
QuadtreeTileProvider.prototype.getLevelMaximumGeometricError = DeveloperError.throwInstantiationError;
/**
* Loads, or continues loading, a given tile. This function will continue to be called
* until {@link QuadtreeTile#state} is no longer {@link QuadtreeTileLoadState#LOADING}. This function should
* not be called before {@link QuadtreeTileProvider#ready} returns true.
*
* @memberof QuadtreeTileProvider
* @function
*
* @param {Context} context The rendering context.
* @param {FrameState} frameState The frame state.
* @param {QuadtreeTile} tile The tile to load.
*
* @exception {DeveloperError} <code>loadTile</code> must not be called before the tile provider is ready.
*/
QuadtreeTileProvider.prototype.loadTile = DeveloperError.throwInstantiationError;
/**
* Determines the visibility of a given tile. The tile may be fully visible, partially visible, or not
* visible at all. Tiles that are renderable and are at least partially visible will be shown by a call
* to {@link QuadtreeTileProvider#showTileThisFrame}.
*
* @memberof QuadtreeTileProvider
*
* @param {QuadtreeTile} tile The tile instance.
* @param {FrameState} frameState The state information about the current frame.
* @param {QuadtreeOccluders} occluders The objects that may occlude this tile.
*
* @returns {Visibility} The visibility of the tile.
*/
QuadtreeTileProvider.prototype.computeTileVisibility = DeveloperError.throwInstantiationError;
/**
* Shows a specified tile in this frame. The provider can cause the tile to be shown by adding
* render commands to the commandList, or use any other method as appropriate. The tile is not
* expected to be visible next frame as well, unless this method is call next frame, too.
*
* @memberof QuadtreeTileProvider
* @function
*
* @param {QuadtreeTile} tile The tile instance.
* @param {Context} context The rendering context.
* @param {FrameState} frameState The state information of the current rendering frame.
* @param {DrawCommand[]} commandList The list of rendering commands. This method may add additional commands to this list.
*/
QuadtreeTileProvider.prototype.showTileThisFrame = DeveloperError.throwInstantiationError;
/**
* Gets the distance from the camera to the closest point on the tile. This is used for level-of-detail selection.
*
* @memberof QuadtreeTileProvider
* @function
*
* @param {QuadtreeTile} tile The tile instance.
* @param {FrameState} frameState The state information of the current rendering frame.
*
* @returns {Number} The distance from the camera to the closest point on the tile, in meters.
*/
QuadtreeTileProvider.prototype.computeDistanceToTile = DeveloperError.throwInstantiationError;
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @memberof QuadtreeTileProvider
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see QuadtreeTileProvider#destroy
*/
QuadtreeTileProvider.prototype.isDestroyed = DeveloperError.throwInstantiationError;
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @memberof QuadtreeTileProvider
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* provider = provider && provider();
*
* @see QuadtreeTileProvider#isDestroyed
*/
QuadtreeTileProvider.prototype.destroy = DeveloperError.throwInstantiationError;
return QuadtreeTileProvider;
});
/*global define*/
define('Scene/SceneTransitioner',[
'../Core/Cartesian3',
'../Core/Cartographic',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/EasingFunction',
'../Core/Math',
'../Core/Matrix4',
'../Core/Ray',
'../Core/ScreenSpaceEventHandler',
'../Core/ScreenSpaceEventType',
'../Core/Transforms',
'./Camera',
'./OrthographicFrustum',
'./PerspectiveFrustum',
'./SceneMode'
], function(
Cartesian3,
Cartographic,
defined,
destroyObject,
DeveloperError,
EasingFunction,
CesiumMath,
Matrix4,
Ray,
ScreenSpaceEventHandler,
ScreenSpaceEventType,
Transforms,
Camera,
OrthographicFrustum,
PerspectiveFrustum,
SceneMode) {
'use strict';
/**
* @private
*/
function SceneTransitioner(scene) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
this._scene = scene;
this._currentTweens = [];
this._morphHandler = undefined;
this._morphCancelled = false;
this._completeMorph = undefined;
}
SceneTransitioner.prototype.completeMorph = function() {
if (defined(this._completeMorph)) {
this._completeMorph();
}
};
SceneTransitioner.prototype.morphTo2D = function(duration, ellipsoid) {
if (defined(this._completeMorph)) {
this._completeMorph();
}
var scene = this._scene;
this._previousMode = scene.mode;
if (this._previousMode === SceneMode.SCENE2D || this._previousMode === SceneMode.MORPHING) {
return;
}
this._scene.morphStart.raiseEvent(this, this._previousMode, SceneMode.SCENE2D, true);
scene._mode = SceneMode.MORPHING;
scene.camera._setTransform(Matrix4.IDENTITY);
if (this._previousMode === SceneMode.COLUMBUS_VIEW) {
morphFromColumbusViewTo2D(this, duration);
} else {
morphFrom3DTo2D(this, duration, ellipsoid);
}
if (duration === 0.0 && defined(this._completeMorph)) {
this._completeMorph();
}
};
var scratchToCVPosition = new Cartesian3();
var scratchToCVDirection = new Cartesian3();
var scratchToCVUp = new Cartesian3();
var scratchToCVPosition2D = new Cartesian3();
var scratchToCVDirection2D = new Cartesian3();
var scratchToCVUp2D = new Cartesian3();
var scratchToCVSurfacePosition = new Cartesian3();
var scratchToCVCartographic = new Cartographic();
var scratchToCVToENU = new Matrix4();
var scratchToCVFrustum = new PerspectiveFrustum();
var scratchToCVCamera = {
position : undefined,
direction : undefined,
up : undefined,
position2D : undefined,
direction2D : undefined,
up2D : undefined,
frustum : undefined
};
SceneTransitioner.prototype.morphToColumbusView = function(duration, ellipsoid) {
if (defined(this._completeMorph)) {
this._completeMorph();
}
var scene = this._scene;
this._previousMode = scene.mode;
if (this._previousMode === SceneMode.COLUMBUS_VIEW || this._previousMode === SceneMode.MORPHING) {
return;
}
this._scene.morphStart.raiseEvent(this, this._previousMode, SceneMode.COLUMBUS_VIEW, true);
scene.camera._setTransform(Matrix4.IDENTITY);
var position = scratchToCVPosition;
var direction = scratchToCVDirection;
var up = scratchToCVUp;
if (duration > 0.0) {
position.x = 0.0;
position.y = 0.0;
position.z = 5.0 * ellipsoid.maximumRadius;
Cartesian3.negate(Cartesian3.UNIT_Z, direction);
Cartesian3.clone(Cartesian3.UNIT_Y, up);
} else {
var camera = scene.camera;
if (this._previousMode === SceneMode.SCENE2D) {
Cartesian3.clone(camera.position, position);
position.z = camera.frustum.right - camera.frustum.left;
Cartesian3.negate(Cartesian3.UNIT_Z, direction);
Cartesian3.clone(Cartesian3.UNIT_Y, up);
} else {
Cartesian3.clone(camera.positionWC, position);
Cartesian3.clone(camera.directionWC, direction);
Cartesian3.clone(camera.upWC, up);
var surfacePoint = ellipsoid.scaleToGeodeticSurface(position, scratchToCVSurfacePosition);
var toENU = Transforms.eastNorthUpToFixedFrame(surfacePoint, ellipsoid, scratchToCVToENU);
Matrix4.inverseTransformation(toENU, toENU);
scene.mapProjection.project(ellipsoid.cartesianToCartographic(position, scratchToCVCartographic), position);
Matrix4.multiplyByPointAsVector(toENU, direction, direction);
Matrix4.multiplyByPointAsVector(toENU, up, up);
}
}
var frustum = scratchToCVFrustum;
frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
frustum.fov = CesiumMath.toRadians(60.0);
var cameraCV = scratchToCVCamera;
cameraCV.position = position;
cameraCV.direction = direction;
cameraCV.up = up;
cameraCV.frustum = frustum;
var complete = completeColumbusViewCallback(cameraCV);
createMorphHandler(this, complete);
if (this._previousMode === SceneMode.SCENE2D) {
morphFrom2DToColumbusView(this, duration, cameraCV, complete);
} else {
cameraCV.position2D = Matrix4.multiplyByPoint(Camera.TRANSFORM_2D, position, scratchToCVPosition2D);
cameraCV.direction2D = Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D, direction, scratchToCVDirection2D);
cameraCV.up2D = Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D, up, scratchToCVUp2D);
scene._mode = SceneMode.MORPHING;
morphFrom3DToColumbusView(this, duration, cameraCV, complete);
}
if (duration === 0.0 && defined(this._completeMorph)) {
this._completeMorph();
}
};
SceneTransitioner.prototype.morphTo3D = function(duration, ellipsoid) {
if (defined(this._completeMorph)) {
this._completeMorph();
}
var scene = this._scene;
this._previousMode = scene.mode;
if (this._previousMode === SceneMode.SCENE3D || this._previousMode === SceneMode.MORPHING) {
return;
}
this._scene.morphStart.raiseEvent(this, this._previousMode, SceneMode.SCENE3D, true);
scene._mode = SceneMode.MORPHING;
scene.camera._setTransform(Matrix4.IDENTITY);
if (this._previousMode === SceneMode.SCENE2D) {
morphFrom2DTo3D(this, duration, ellipsoid);
} else {
var camera3D;
if (duration > 0.0) {
camera3D = scratchCVTo3DCamera;
Cartesian3.fromDegrees(0.0, 0.0, 5.0 * ellipsoid.maximumRadius, ellipsoid, camera3D.position);
Cartesian3.negate(camera3D.position, camera3D.direction);
Cartesian3.normalize(camera3D.direction, camera3D.direction);
Cartesian3.clone(Cartesian3.UNIT_Z, camera3D.up);
} else {
camera3D = getColumbusViewTo3DCamera(this, ellipsoid);
}
var complete = complete3DCallback(camera3D);
createMorphHandler(this, complete);
morphFromColumbusViewTo3D(this, duration, camera3D, complete);
}
if (duration === 0.0 && defined(this._completeMorph)) {
this._completeMorph();
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*/
SceneTransitioner.prototype.isDestroyed = function() {
return false;
};
/**
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @example
* transitioner = transitioner && transitioner.destroy();
*/
SceneTransitioner.prototype.destroy = function() {
destroyMorphHandler(this);
return destroyObject(this);
};
function createMorphHandler(transitioner, completeMorphFunction) {
if (transitioner._scene.completeMorphOnUserInput) {
transitioner._morphHandler = new ScreenSpaceEventHandler(transitioner._scene.canvas, false);
var completeMorph = function() {
transitioner._morphCancelled = true;
completeMorphFunction(transitioner);
};
transitioner._completeMorph = completeMorph;
transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.LEFT_DOWN);
transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.MIDDLE_DOWN);
transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.RIGHT_DOWN);
transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.WHEEL);
}
}
function destroyMorphHandler(transitioner) {
var tweens = transitioner._currentTweens;
for ( var i = 0; i < tweens.length; ++i) {
tweens[i].cancelTween();
}
transitioner._currentTweens.length = 0;
transitioner._morphHandler = transitioner._morphHandler && transitioner._morphHandler.destroy();
}
var scratchCVTo3DCartographic = new Cartographic();
var scratchCVTo3DSurfacePoint = new Cartesian3();
var scratchCVTo3DFromENU = new Matrix4();
var scratchCVTo3DCamera = {
position : new Cartesian3(),
direction : new Cartesian3(),
up : new Cartesian3(),
frustum : undefined
};
function getColumbusViewTo3DCamera(transitioner, ellipsoid) {
var scene = transitioner._scene;
var camera = scene.camera;
var camera3D = scratchCVTo3DCamera;
var position = camera3D.position;
var direction = camera3D.direction;
var up = camera3D.up;
var positionCarto = scene.mapProjection.unproject(camera.position, scratchCVTo3DCartographic);
ellipsoid.cartographicToCartesian(positionCarto, position);
var surfacePoint = ellipsoid.scaleToGeodeticSurface(position, scratchCVTo3DSurfacePoint);
var fromENU = Transforms.eastNorthUpToFixedFrame(surfacePoint, ellipsoid, scratchCVTo3DFromENU);
Matrix4.multiplyByPointAsVector(fromENU, camera.direction, direction);
Matrix4.multiplyByPointAsVector(fromENU, camera.up, up);
return camera3D;
}
var scratchCVTo3DStartPos = new Cartesian3();
var scratchCVTo3DStartDir = new Cartesian3();
var scratchCVTo3DStartUp = new Cartesian3();
var scratchCVTo3DEndPos = new Cartesian3();
var scratchCVTo3DEndDir = new Cartesian3();
var scratchCVTo3DEndUp = new Cartesian3();
function morphFromColumbusViewTo3D(transitioner, duration, endCamera, complete) {
duration *= 0.5;
var scene = transitioner._scene;
var camera = scene.camera;
var startPos = Cartesian3.clone(camera.position, scratchCVTo3DStartPos);
var startDir = Cartesian3.clone(camera.direction, scratchCVTo3DStartDir);
var startUp = Cartesian3.clone(camera.up, scratchCVTo3DStartUp);
var endPos = Matrix4.multiplyByPoint(Camera.TRANSFORM_2D_INVERSE, endCamera.position, scratchCVTo3DEndPos);
var endDir = Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D_INVERSE, endCamera.direction, scratchCVTo3DEndDir);
var endUp = Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D_INVERSE, endCamera.up, scratchCVTo3DEndUp);
function update(value) {
columbusViewMorph(startPos, endPos, value.time, camera.position);
columbusViewMorph(startDir, endDir, value.time, camera.direction);
columbusViewMorph(startUp, endUp, value.time, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
}
var tween = scene.tweens.add({
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT,
startObject : {
time : 0.0
},
stopObject : {
time : 1.0
},
update : update,
complete : function() {
addMorphTimeAnimations(transitioner, scene, 0.0, 1.0, duration, complete);
}
});
transitioner._currentTweens.push(tween);
}
var scratch2DTo3DFrustum = new PerspectiveFrustum();
function morphFrom2DTo3D(transitioner, duration, ellipsoid) {
duration /= 3.0;
var scene = transitioner._scene;
var camera = scene.camera;
var frustum = scratch2DTo3DFrustum;
frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
frustum.fov = CesiumMath.toRadians(60.0);
var camera3D;
if (duration > 0.0) {
camera3D = scratchCVTo3DCamera;
Cartesian3.fromDegrees(0.0, 0.0, 5.0 * ellipsoid.maximumRadius, ellipsoid, camera3D.position);
Cartesian3.negate(camera3D.position, camera3D.direction);
Cartesian3.normalize(camera3D.direction, camera3D.direction);
Cartesian3.clone(Cartesian3.UNIT_Z, camera3D.up);
} else {
camera.position.z = camera.frustum.right - camera.frustum.left;
camera3D = getColumbusViewTo3DCamera(transitioner, ellipsoid);
}
camera3D.frustum = frustum;
var complete = complete3DCallback(camera3D);
createMorphHandler(transitioner, complete);
var startPos = Cartesian3.clone(camera.position, scratch3DToCVStartPos);
var startDir = Cartesian3.clone(camera.direction, scratch3DToCVStartDir);
var startUp = Cartesian3.clone(camera.up, scratch3DToCVStartUp);
var endPos = Cartesian3.fromElements(0.0, 0.0, 5.0 * ellipsoid.maximumRadius, scratch3DToCVEndPos);
var endDir = Cartesian3.negate(Cartesian3.UNIT_Z, scratch3DToCVEndDir);
var endUp = Cartesian3.clone(Cartesian3.UNIT_Y, scratch3DToCVEndUp);
var startRight = camera.frustum.right;
var endRight = endPos.z * 0.5;
function update(value) {
columbusViewMorph(startPos, endPos, value.time, camera.position);
columbusViewMorph(startDir, endDir, value.time, camera.direction);
columbusViewMorph(startUp, endUp, value.time, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
var frustum = camera.frustum;
frustum.right = CesiumMath.lerp(startRight, endRight, value.time);
frustum.left = -frustum.right;
frustum.top = frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
frustum.bottom = -frustum.top;
camera.position.z = 2.0 * scene.mapProjection.ellipsoid.maximumRadius;
}
if (duration > 0.0) {
var tween = scene.tweens.add({
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT,
startObject : {
time : 0.0
},
stopObject : {
time : 1.0
},
update : update,
complete : function() {
scene._mode = SceneMode.MORPHING;
morphOrthographicToPerspective(transitioner, duration, camera3D, function() {
morphFromColumbusViewTo3D(transitioner, duration, camera3D, complete);
});
}
});
transitioner._currentTweens.push(tween);
} else {
morphOrthographicToPerspective(transitioner, duration, camera3D, function() {
morphFromColumbusViewTo3D(transitioner, duration, camera3D, complete);
});
}
}
function columbusViewMorph(startPosition, endPosition, time, result) {
// Just linear for now.
return Cartesian3.lerp(startPosition, endPosition, time, result);
}
function morphPerspectiveToOrthographic(transitioner, duration, endCamera, updateHeight, complete) {
var scene = transitioner._scene;
var camera = scene.camera;
var startFOV = camera.frustum.fov;
var endFOV = CesiumMath.RADIANS_PER_DEGREE * 0.5;
var d = endCamera.position.z * Math.tan(startFOV * 0.5);
camera.frustum.far = d / Math.tan(endFOV * 0.5) + 10000000.0;
function update(value) {
camera.frustum.fov = CesiumMath.lerp(startFOV, endFOV, value.time);
var height = d / Math.tan(camera.frustum.fov * 0.5);
updateHeight(camera, height);
}
var tween = scene.tweens.add({
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT,
startObject : {
time : 0.0
},
stopObject : {
time : 1.0
},
update : update,
complete : function() {
camera.frustum = endCamera.frustum.clone();
complete(transitioner);
}
});
transitioner._currentTweens.push(tween);
}
var scratchCVTo2DStartPos = new Cartesian3();
var scratchCVTo2DStartDir = new Cartesian3();
var scratchCVTo2DStartUp = new Cartesian3();
var scratchCVTo2DEndPos = new Cartesian3();
var scratchCVTo2DEndDir = new Cartesian3();
var scratchCVTo2DEndUp = new Cartesian3();
var scratchCVTo2DFrustum = new OrthographicFrustum();
var scratchCVTo2DRay = new Ray();
var scratchCVTo2DPickPos = new Cartesian3();
var scratchCVTo2DCamera = {
position : undefined,
direction : undefined,
up : undefined,
frustum : undefined
};
function morphFromColumbusViewTo2D(transitioner, duration) {
duration *= 0.5;
var scene = transitioner._scene;
var camera = scene.camera;
var startPos = Cartesian3.clone(camera.position, scratchCVTo2DStartPos);
var startDir = Cartesian3.clone(camera.direction, scratchCVTo2DStartDir);
var startUp = Cartesian3.clone(camera.up, scratchCVTo2DStartUp);
var endDir = Cartesian3.negate(Cartesian3.UNIT_Z, scratchCVTo2DEndDir);
var endUp = Cartesian3.clone(Cartesian3.UNIT_Y, scratchCVTo2DEndUp);
var endPos = scratchCVTo2DEndPos;
if (duration > 0.0) {
Cartesian3.clone(Cartesian3.ZERO, scratchCVTo2DEndPos);
endPos.z = 5.0 * scene.mapProjection.ellipsoid.maximumRadius;
} else {
Cartesian3.clone(startPos, scratchCVTo2DEndPos);
var ray = scratchCVTo2DRay;
Matrix4.multiplyByPoint(Camera.TRANSFORM_2D, startPos, ray.origin);
Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D, startDir, ray.direction);
var globe = scene.globe;
if (defined(globe)) {
var pickPos = globe.pick(ray, scene, scratchCVTo2DPickPos);
if (defined(pickPos)) {
Matrix4.multiplyByPoint(Camera.TRANSFORM_2D_INVERSE, pickPos, endPos);
endPos.z += Cartesian3.distance(startPos, endPos);
}
}
}
var frustum = scratchCVTo2DFrustum;
frustum.right = endPos.z * 0.5;
frustum.left = -frustum.right;
frustum.top = frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
frustum.bottom = -frustum.top;
var camera2D = scratchCVTo2DCamera;
camera2D.position = endPos;
camera2D.direction = endDir;
camera2D.up = endUp;
camera2D.frustum = frustum;
var complete = complete2DCallback(camera2D);
createMorphHandler(transitioner, complete);
function updateCV(value) {
columbusViewMorph(startPos, endPos, value.time, camera.position);
columbusViewMorph(startDir, endDir, value.time, camera.direction);
columbusViewMorph(startUp, endUp, value.time, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
}
function updateHeight(camera, height) {
camera.position.z = height;
}
var tween = scene.tweens.add({
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT,
startObject : {
time : 0.0
},
stopObject : {
time : 1.0
},
update : updateCV,
complete : function() {
morphPerspectiveToOrthographic(transitioner, duration, camera2D, updateHeight, complete);
}
});
transitioner._currentTweens.push(tween);
}
var scratch3DTo2DCartographic = new Cartographic();
var scratch3DTo2DCamera = {
position : new Cartesian3(),
direction : new Cartesian3(),
up : new Cartesian3(),
position2D : new Cartesian3(),
direction2D : new Cartesian3(),
up2D : new Cartesian3(),
frustum : new OrthographicFrustum()
};
var scratch3DTo2DEndCamera = {
position : new Cartesian3(),
direction : new Cartesian3(),
up : new Cartesian3(),
frustum : undefined
};
var scratch3DTo2DPickPosition = new Cartesian3();
var scratch3DTo2DRay = new Ray();
var scratch3DTo2DToENU = new Matrix4();
var scratch3DTo2DSurfacePoint = new Cartesian3();
function morphFrom3DTo2D(transitioner, duration, ellipsoid) {
duration *= 0.5;
var scene = transitioner._scene;
var camera = scene.camera;
var camera2D = scratch3DTo2DCamera;
if (duration > 0.0) {
Cartesian3.clone(Cartesian3.ZERO, camera2D.position);
camera2D.position.z = 5.0 * ellipsoid.maximumRadius;
Cartesian3.negate(Cartesian3.UNIT_Z, camera2D.direction);
Cartesian3.clone(Cartesian3.UNIT_Y, camera2D.up);
} else {
ellipsoid.cartesianToCartographic(camera.positionWC, scratch3DTo2DCartographic);
scene.mapProjection.project(scratch3DTo2DCartographic, camera2D.position);
Cartesian3.negate(Cartesian3.UNIT_Z, camera2D.direction);
Cartesian3.clone(Cartesian3.UNIT_Y, camera2D.up);
var ray = scratch3DTo2DRay;
Cartesian3.clone(camera2D.position2D, ray.origin);
var rayDirection = Cartesian3.clone(camera.directionWC, ray.direction);
var surfacePoint = ellipsoid.scaleToGeodeticSurface(camera.positionWC, scratch3DTo2DSurfacePoint);
var toENU = Transforms.eastNorthUpToFixedFrame(surfacePoint, ellipsoid, scratch3DTo2DToENU);
Matrix4.inverseTransformation(toENU, toENU);
Matrix4.multiplyByPointAsVector(toENU, rayDirection, rayDirection);
Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D, rayDirection, rayDirection);
var globe = scene.globe;
if (defined(globe)) {
var pickedPos = globe.pick(ray, scene, scratch3DTo2DPickPosition);
if (defined(pickedPos)) {
var height = Cartesian3.distance(camera2D.position2D, pickedPos);
pickedPos.x += height;
Cartesian3.clone(pickedPos, camera2D.position2D);
}
}
}
function updateHeight(camera, height) {
camera.position.x = height;
}
Matrix4.multiplyByPoint(Camera.TRANSFORM_2D, camera2D.position, camera2D.position2D);
Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D, camera2D.direction, camera2D.direction2D);
Matrix4.multiplyByPointAsVector(Camera.TRANSFORM_2D, camera2D.up, camera2D.up2D);
var frustum = camera2D.frustum;
frustum.right = camera2D.position.z * 0.5;
frustum.left = -frustum.right;
frustum.top = frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
frustum.bottom = -frustum.top;
var endCamera = scratch3DTo2DEndCamera;
Matrix4.multiplyByPoint(Camera.TRANSFORM_2D_INVERSE, camera2D.position2D, endCamera.position);
Cartesian3.clone(camera2D.direction, endCamera.direction);
Cartesian3.clone(camera2D.up, endCamera.up);
endCamera.frustum = frustum;
var complete = complete2DCallback(endCamera);
createMorphHandler(transitioner, complete);
function completeCallback() {
morphPerspectiveToOrthographic(transitioner, duration, camera2D, updateHeight, complete);
}
morphFrom3DToColumbusView(transitioner, duration, camera2D, completeCallback);
}
function morphOrthographicToPerspective(transitioner, duration, cameraCV, complete) {
var scene = transitioner._scene;
var camera = scene.camera;
var height = camera.frustum.right - camera.frustum.left;
camera.frustum = cameraCV.frustum.clone();
var endFOV = camera.frustum.fov;
var startFOV = CesiumMath.RADIANS_PER_DEGREE * 0.5;
var d = height * Math.tan(endFOV * 0.5);
camera.frustum.far = d / Math.tan(startFOV * 0.5) + 10000000.0;
camera.frustum.fov = startFOV;
function update(value) {
camera.frustum.fov = CesiumMath.lerp(startFOV, endFOV, value.time);
camera.position.z = d / Math.tan(camera.frustum.fov * 0.5);
}
var tween = scene.tweens.add({
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT,
startObject : {
time : 0.0
},
stopObject : {
time : 1.0
},
update : update,
complete : function() {
complete(transitioner);
}
});
transitioner._currentTweens.push(tween);
}
function morphFrom2DToColumbusView(transitioner, duration, cameraCV, complete) {
duration *= 0.5;
var scene = transitioner._scene;
var camera = scene.camera;
var startPos = Cartesian3.clone(camera.position, scratch3DToCVStartPos);
var startDir = Cartesian3.clone(camera.direction, scratch3DToCVStartDir);
var startUp = Cartesian3.clone(camera.up, scratch3DToCVStartUp);
var endPos = Cartesian3.clone(cameraCV.position, scratch3DToCVEndPos);
var endDir = Cartesian3.clone(cameraCV.direction, scratch3DToCVEndDir);
var endUp = Cartesian3.clone(cameraCV.up, scratch3DToCVEndUp);
var startRight = camera.frustum.right;
var endRight = endPos.z * 0.5;
function update(value) {
columbusViewMorph(startPos, endPos, value.time, camera.position);
columbusViewMorph(startDir, endDir, value.time, camera.direction);
columbusViewMorph(startUp, endUp, value.time, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
var frustum = camera.frustum;
frustum.right = CesiumMath.lerp(startRight, endRight, value.time);
frustum.left = -frustum.right;
frustum.top = frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
frustum.bottom = -frustum.top;
camera.position.z = 2.0 * scene.mapProjection.ellipsoid.maximumRadius;
}
var tween = scene.tweens.add({
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT,
startObject : {
time : 0.0
},
stopObject : {
time : 1.0
},
update : update,
complete : function() {
scene._mode = SceneMode.MORPHING;
morphOrthographicToPerspective(transitioner, duration, cameraCV, complete);
}
});
transitioner._currentTweens.push(tween);
}
var scratch3DToCVStartPos = new Cartesian3();
var scratch3DToCVStartDir = new Cartesian3();
var scratch3DToCVStartUp = new Cartesian3();
var scratch3DToCVEndPos = new Cartesian3();
var scratch3DToCVEndDir = new Cartesian3();
var scratch3DToCVEndUp = new Cartesian3();
function morphFrom3DToColumbusView(transitioner, duration, endCamera, complete) {
var scene = transitioner._scene;
var camera = scene.camera;
var startPos = Cartesian3.clone(camera.position, scratch3DToCVStartPos);
var startDir = Cartesian3.clone(camera.direction, scratch3DToCVStartDir);
var startUp = Cartesian3.clone(camera.up, scratch3DToCVStartUp);
var endPos = Cartesian3.clone(endCamera.position2D, scratch3DToCVEndPos);
var endDir = Cartesian3.clone(endCamera.direction2D, scratch3DToCVEndDir);
var endUp = Cartesian3.clone(endCamera.up2D, scratch3DToCVEndUp);
function update(value) {
columbusViewMorph(startPos, endPos, value.time, camera.position);
columbusViewMorph(startDir, endDir, value.time, camera.direction);
columbusViewMorph(startUp, endUp, value.time, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
}
var tween = scene.tweens.add({
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT,
startObject : {
time : 0.0
},
stopObject : {
time : 1.0
},
update : update,
complete : function() {
addMorphTimeAnimations(transitioner, scene, 1.0, 0.0, duration, complete);
}
});
transitioner._currentTweens.push(tween);
}
function addMorphTimeAnimations(transitioner, scene, start, stop, duration, complete) {
// Later, this will be linear and each object will adjust, if desired, in its vertex shader.
var options = {
object : scene,
property : 'morphTime',
startValue : start,
stopValue : stop,
duration : duration,
easingFunction : EasingFunction.QUARTIC_OUT
};
if (defined(complete)) {
options.complete = function() {
complete(transitioner);
};
}
var tween = scene.tweens.addProperty(options);
transitioner._currentTweens.push(tween);
}
function complete3DCallback(camera3D) {
return function(transitioner) {
var scene = transitioner._scene;
scene._mode = SceneMode.SCENE3D;
scene.morphTime = SceneMode.getMorphTime(SceneMode.SCENE3D);
destroyMorphHandler(transitioner);
if (transitioner._previousMode !== SceneMode.MORPHING || transitioner._morphCancelled) {
transitioner._morphCancelled = false;
var camera = scene.camera;
Cartesian3.clone(camera3D.position, camera.position);
Cartesian3.clone(camera3D.direction, camera.direction);
Cartesian3.clone(camera3D.up, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
if (defined(camera3D.frustum)) {
camera.frustum = camera3D.frustum.clone();
}
}
var wasMorphing = defined(transitioner._completeMorph);
transitioner._completeMorph = undefined;
scene.camera.update(scene.mode);
transitioner._scene.morphComplete.raiseEvent(transitioner, transitioner._previousMode, SceneMode.SCENE3D, wasMorphing);
};
}
function complete2DCallback(camera2D) {
return function(transitioner) {
var scene = transitioner._scene;
scene._mode = SceneMode.SCENE2D;
scene.morphTime = SceneMode.getMorphTime(SceneMode.SCENE2D);
destroyMorphHandler(transitioner);
var camera = scene.camera;
Cartesian3.clone(camera2D.position, camera.position);
camera.position.z = scene.mapProjection.ellipsoid.maximumRadius * 2.0;
Cartesian3.clone(camera2D.direction, camera.direction);
Cartesian3.clone(camera2D.up, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
camera.frustum = camera2D.frustum.clone();
var wasMorphing = defined(transitioner._completeMorph);
transitioner._completeMorph = undefined;
scene.camera.update(scene.mode);
transitioner._scene.morphComplete.raiseEvent(transitioner, transitioner._previousMode, SceneMode.SCENE2D, wasMorphing);
};
}
function completeColumbusViewCallback(cameraCV) {
return function(transitioner) {
var scene = transitioner._scene;
scene._mode = SceneMode.COLUMBUS_VIEW;
scene.morphTime = SceneMode.getMorphTime(SceneMode.COLUMBUS_VIEW);
destroyMorphHandler(transitioner);
scene.camera.frustum = cameraCV.frustum.clone();
if (transitioner._previousModeMode !== SceneMode.MORPHING || transitioner._morphCancelled) {
transitioner._morphCancelled = false;
var camera = scene.camera;
Cartesian3.clone(cameraCV.position, camera.position);
Cartesian3.clone(cameraCV.direction, camera.direction);
Cartesian3.clone(cameraCV.up, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.right, camera.right);
}
var wasMorphing = defined(transitioner._completeMorph);
transitioner._completeMorph = undefined;
scene.camera.update(scene.mode);
transitioner._scene.morphComplete.raiseEvent(transitioner, transitioner._previousMode, SceneMode.COLUMBUS_VIEW, wasMorphing);
};
}
return SceneTransitioner;
});
/*global define*/
define('Scene/TweenCollection',[
'../Core/clone',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/EasingFunction',
'../Core/getTimestamp',
'../Core/TimeConstants',
'../ThirdParty/Tween'
], function(
clone,
defaultValue,
defined,
defineProperties,
DeveloperError,
EasingFunction,
getTimestamp,
TimeConstants,
TweenJS) {
'use strict';
/**
* A tween is an animation that interpolates the properties of two objects using an {@link EasingFunction}. Create
* one using {@link Scene#tweens} and {@link TweenCollection#add} and related add functions.
*
* @alias Tween
* @constructor
*
* @private
*/
function Tween(tweens, tweenjs, startObject, stopObject, duration, delay, easingFunction, update, complete, cancel) {
this._tweens = tweens;
this._tweenjs = tweenjs;
this._startObject = clone(startObject);
this._stopObject = clone(stopObject);
this._duration = duration;
this._delay = delay;
this._easingFunction = easingFunction;
this._update = update;
this._complete = complete;
/**
* The callback to call if the tween is canceled either because {@link Tween#cancelTween}
* was called or because the tween was removed from the collection.
*
* @type {TweenCollection~TweenCancelledCallback}
*/
this.cancel = cancel;
/**
* @private
*/
this.needsStart = true;
}
defineProperties(Tween.prototype, {
/**
* An object with properties for initial values of the tween. The properties of this object are changed during the tween's animation.
* @memberof Tween.prototype
*
* @type {Object}
* @readonly
*/
startObject : {
get : function() {
return this._startObject;
}
},
/**
* An object with properties for the final values of the tween.
* @memberof Tween.prototype
*
* @type {Object}
* @readonly
*/
stopObject : {
get : function() {
return this._stopObject;
}
},
/**
* The duration, in seconds, for the tween. The tween is automatically removed from the collection when it stops.
* @memberof Tween.prototype
*
* @type {Number}
* @readonly
*/
duration : {
get : function() {
return this._duration;
}
},
/**
* The delay, in seconds, before the tween starts animating.
* @memberof Tween.prototype
*
* @type {Number}
* @readonly
*/
delay : {
get : function() {
return this._delay;
}
},
/**
* Determines the curve for animtion.
* @memberof Tween.prototype
*
* @type {EasingFunction}
* @readonly
*/
easingFunction : {
get : function() {
return this._easingFunction;
}
},
/**
* The callback to call at each animation update (usually tied to the a rendered frame).
* @memberof Tween.prototype
*
* @type {TweenCollection~TweenUpdateCallback}
* @readonly
*/
update : {
get : function() {
return this._update;
}
},
/**
* The callback to call when the tween finishes animating.
* @memberof Tween.prototype
*
* @type {TweenCollection~TweenCompleteCallback}
* @readonly
*/
complete : {
get : function() {
return this._complete;
}
},
/**
* @memberof Tween.prototype
*
* @private
*/
tweenjs : {
get : function() {
return this._tweenjs;
}
}
});
/**
* Cancels the tween calling the {@link Tween#cancel} callback if one exists. This
* has no effect if the tween finished or was already canceled.
*/
Tween.prototype.cancelTween = function() {
this._tweens.remove(this);
};
/**
* A collection of tweens for animating properties. Commonly accessed using {@link Scene#tweens}.
*
* @alias TweenCollection
* @constructor
*
* @private
*/
function TweenCollection() {
this._tweens = [];
}
defineProperties(TweenCollection.prototype, {
/**
* The number of tweens in the collection.
* @memberof TweenCollection.prototype
*
* @type {Number}
* @readonly
*/
length : {
get : function() {
return this._tweens.length;
}
}
});
/**
* Creates a tween for animating between two sets of properties. The tween starts animating at the next call to {@link TweenCollection#update}, which
* is implicit when {@link Viewer} or {@link CesiumWidget} render the scene.
*
* @param {Object} [options] Object with the following properties:
* @param {Object} options.startObject An object with properties for initial values of the tween. The properties of this object are changed during the tween's animation.
* @param {Object} options.stopObject An object with properties for the final values of the tween.
* @param {Number} options.duration The duration, in seconds, for the tween. The tween is automatically removed from the collection when it stops.
* @param {Number} [options.delay=0.0] The delay, in seconds, before the tween starts animating.
* @param {EasingFunction} [options.easingFunction=EasingFunction.LINEAR_NONE] Determines the curve for animtion.
* @param {TweenCollection~TweenUpdateCallback} [options.update] The callback to call at each animation update (usually tied to the a rendered frame).
* @param {TweenCollection~TweenCompleteCallback} [options.complete] The callback to call when the tween finishes animating.
* @param {TweenCollection~TweenCancelledCallback} [options.cancel] The callback to call if the tween is canceled either because {@link Tween#cancelTween} was called or because the tween was removed from the collection.
* @returns {Tween} The tween.
*
* @exception {DeveloperError} options.duration must be positive.
*/
TweenCollection.prototype.add = function(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(options.startObject) || !defined(options.stopObject)) {
throw new DeveloperError('options.startObject and options.stopObject are required.');
}
if (!defined(options.duration) || options.duration < 0.0) {
throw new DeveloperError('options.duration is required and must be positive.');
}
if (options.duration === 0.0) {
if (defined(options.complete)) {
options.complete();
}
return new Tween(this);
}
var duration = options.duration / TimeConstants.SECONDS_PER_MILLISECOND;
var delayInSeconds = defaultValue(options.delay, 0.0);
var delay = delayInSeconds / TimeConstants.SECONDS_PER_MILLISECOND;
var easingFunction = defaultValue(options.easingFunction, EasingFunction.LINEAR_NONE);
var value = options.startObject;
var tweenjs = new TweenJS.Tween(value);
tweenjs.to(clone(options.stopObject), duration);
tweenjs.delay(delay);
tweenjs.easing(easingFunction);
if (defined(options.update)) {
tweenjs.onUpdate(function() {
options.update(value);
});
}
tweenjs.onComplete(defaultValue(options.complete, null));
tweenjs.repeat(defaultValue(options._repeat, 0.0));
var tween = new Tween(this, tweenjs, options.startObject, options.stopObject, options.duration, delayInSeconds, easingFunction, options.update, options.complete, options.cancel);
this._tweens.push(tween);
return tween;
};
/**
* Creates a tween for animating a scalar property on the given object. The tween starts animating at the next call to {@link TweenCollection#update}, which
* is implicit when {@link Viewer} or {@link CesiumWidget} render the scene.
*
* @param {Object} [options] Object with the following properties:
* @param {Object} options.object The object containing the property to animate.
* @param {String} options.property The name of the property to animate.
* @param {Number} options.startValue The initial value.
* @param {Number} options.stopValue The final value.
* @param {Number} [options.duration=3.0] The duration, in seconds, for the tween. The tween is automatically removed from the collection when it stops.
* @param {Number} [options.delay=0.0] The delay, in seconds, before the tween starts animating.
* @param {EasingFunction} [options.easingFunction=EasingFunction.LINEAR_NONE] Determines the curve for animtion.
* @param {TweenCollection~TweenUpdateCallback} [options.update] The callback to call at each animation update (usually tied to the a rendered frame).
* @param {TweenCollection~TweenCompleteCallback} [options.complete] The callback to call when the tween finishes animating.
* @param {TweenCollection~TweenCancelledCallback} [options.cancel] The callback to call if the tween is canceled either because {@link Tween#cancelTween} was called or because the tween was removed from the collection.
* @returns {Tween} The tween.
*
* @exception {DeveloperError} options.object must have the specified property.
* @exception {DeveloperError} options.duration must be positive.
*/
TweenCollection.prototype.addProperty = function(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var object = options.object;
var property = options.property;
var startValue = options.startValue;
var stopValue = options.stopValue;
if (!defined(object) || !defined(options.property)) {
throw new DeveloperError('options.object and options.property are required.');
}
if (!defined(object[property])) {
throw new DeveloperError('options.object must have the specified property.');
}
if (!defined(startValue) || !defined(stopValue)) {
throw new DeveloperError('options.startValue and options.stopValue are required.');
}
function update(value) {
object[property] = value.value;
}
return this.add({
startObject : {
value : startValue
},
stopObject : {
value : stopValue
},
duration : defaultValue(options.duration, 3.0),
delay : options.delay,
easingFunction : options.easingFunction,
update : update,
complete : options.complete,
cancel : options.cancel,
_repeat : options._repeat
});
};
/**
* Creates a tween for animating the alpha of all color uniforms on a {@link Material}. The tween starts animating at the next call to {@link TweenCollection#update}, which
* is implicit when {@link Viewer} or {@link CesiumWidget} render the scene.
*
* @param {Object} [options] Object with the following properties:
* @param {Material} options.material The material to animate.
* @param {Number} [options.startValue=0.0] The initial alpha value.
* @param {Number} [options.stopValue=1.0] The final alpha value.
* @param {Number} [options.duration=3.0] The duration, in seconds, for the tween. The tween is automatically removed from the collection when it stops.
* @param {Number} [options.delay=0.0] The delay, in seconds, before the tween starts animating.
* @param {EasingFunction} [options.easingFunction=EasingFunction.LINEAR_NONE] Determines the curve for animtion.
* @param {TweenCollection~TweenUpdateCallback} [options.update] The callback to call at each animation update (usually tied to the a rendered frame).
* @param {TweenCollection~TweenCompleteCallback} [options.complete] The callback to call when the tween finishes animating.
* @param {TweenCollection~TweenCancelledCallback} [options.cancel] The callback to call if the tween is canceled either because {@link Tween#cancelTween} was called or because the tween was removed from the collection.
* @returns {Tween} The tween.
*
* @exception {DeveloperError} material has no properties with alpha components.
* @exception {DeveloperError} options.duration must be positive.
*/
TweenCollection.prototype.addAlpha = function(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var material = options.material;
if (!defined(material)) {
throw new DeveloperError('options.material is required.');
}
var properties = [];
for (var property in material.uniforms) {
if (material.uniforms.hasOwnProperty(property) &&
defined(material.uniforms[property]) &&
defined(material.uniforms[property].alpha)) {
properties.push(property);
}
}
if (properties.length === 0) {
throw new DeveloperError('material has no properties with alpha components.');
}
function update(value) {
var length = properties.length;
for (var i = 0; i < length; ++i) {
material.uniforms[properties[i]].alpha = value.alpha;
}
}
return this.add({
startObject : {
alpha : defaultValue(options.startValue, 0.0) // Default to fade in
},
stopObject : {
alpha : defaultValue(options.stopValue, 1.0)
},
duration : defaultValue(options.duration, 3.0),
delay : options.delay,
easingFunction : options.easingFunction,
update : update,
complete : options.complete,
cancel : options.cancel
});
};
/**
* Creates a tween for animating the offset uniform of a {@link Material}. The tween starts animating at the next call to {@link TweenCollection#update}, which
* is implicit when {@link Viewer} or {@link CesiumWidget} render the scene.
*
* @param {Object} [options] Object with the following properties:
* @param {Material} options.material The material to animate.
* @param {Number} options.startValue The initial alpha value.
* @param {Number} options.stopValue The final alpha value.
* @param {Number} [options.duration=3.0] The duration, in seconds, for the tween. The tween is automatically removed from the collection when it stops.
* @param {Number} [options.delay=0.0] The delay, in seconds, before the tween starts animating.
* @param {EasingFunction} [options.easingFunction=EasingFunction.LINEAR_NONE] Determines the curve for animtion.
* @param {TweenCollection~TweenUpdateCallback} [options.update] The callback to call at each animation update (usually tied to the a rendered frame).
* @param {TweenCollection~TweenCancelledCallback} [options.cancel] The callback to call if the tween is canceled either because {@link Tween#cancelTween} was called or because the tween was removed from the collection.
* @returns {Tween} The tween.
*
* @exception {DeveloperError} material.uniforms must have an offset property.
* @exception {DeveloperError} options.duration must be positive.
*/
TweenCollection.prototype.addOffsetIncrement = function(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var material = options.material;
if (!defined(material)) {
throw new DeveloperError('material is required.');
}
if (!defined(material.uniforms.offset)) {
throw new DeveloperError('material.uniforms must have an offset property.');
}
var uniforms = material.uniforms;
return this.addProperty({
object : uniforms,
property : 'offset',
startValue : uniforms.offset,
stopValue : uniforms.offset + 1,
duration : options.duration,
delay : options.delay,
easingFunction : options.easingFunction,
update : options.update,
cancel : options.cancel,
_repeat : Infinity
});
};
/**
* Removes a tween from the collection.
* <p>
* This calls the {@link Tween#cancel} callback if the tween has one.
* </p>
*
* @param {Tween} tween The tween to remove.
* @returns {Boolean} <code>true</code> if the tween was removed; <code>false</code> if the tween was not found in the collection.
*/
TweenCollection.prototype.remove = function(tween) {
if (!defined(tween)) {
return false;
}
var index = this._tweens.indexOf(tween);
if (index !== -1) {
tween.tweenjs.stop();
if (defined(tween.cancel)) {
tween.cancel();
}
this._tweens.splice(index, 1);
return true;
}
return false;
};
/**
* Removes all tweens from the collection.
* <p>
* This calls the {@link Tween#cancel} callback for each tween that has one.
* </p>
*/
TweenCollection.prototype.removeAll = function() {
var tweens = this._tweens;
for (var i = 0; i < tweens.length; ++i) {
var tween = tweens[i];
tween.tweenjs.stop();
if (defined(tween.cancel)) {
tween.cancel();
}
}
tweens.length = 0;
};
/**
* Determines whether this collection contains a given tween.
*
* @param {Tween} tween The tween to check for.
* @returns {Boolean} <code>true</code> if this collection contains the tween, <code>false</code> otherwise.
*/
TweenCollection.prototype.contains = function(tween) {
return defined(tween) && (this._tweens.indexOf(tween) !== -1);
};
/**
* Returns the tween in the collection at the specified index. Indices are zero-based
* and increase as tweens are added. Removing a tween shifts all tweens after
* it to the left, changing their indices. This function is commonly used to iterate over
* all the tween in the collection.
*
* @param {Number} index The zero-based index of the tween.
* @returns {Tween} The tween at the specified index.
*
* @example
* // Output the duration of all the tweens in the collection.
* var tweens = scene.tweens;
* var length = tweens.length;
* for (var i = 0; i < length; ++i) {
* console.log(tweens.get(i).duration);
* }
*/
TweenCollection.prototype.get = function(index) {
if (!defined(index)) {
throw new DeveloperError('index is required.');
}
return this._tweens[index];
};
/**
* Updates the tweens in the collection to be at the provide time. When a tween finishes, it is removed
* from the collection.
*
* @param {Number} [time=getTimestamp()] The time in seconds. By default tweens are synced to the system clock.
*/
TweenCollection.prototype.update = function(time) {
var tweens = this._tweens;
var i = 0;
time = defined(time) ? time / TimeConstants.SECONDS_PER_MILLISECOND : getTimestamp();
while (i < tweens.length) {
var tween = tweens[i];
var tweenjs = tween.tweenjs;
if (tween.needsStart) {
tween.needsStart = false;
tweenjs.start(time);
} else {
if (tweenjs.update(time)) {
i++;
} else {
tweenjs.stop();
tweens.splice(i, 1);
}
}
}
};
/**
* A function that will execute when a tween completes.
* @callback TweenCollection~TweenCompleteCallback
*/
/**
* A function that will execute when a tween updates.
* @callback TweenCollection~TweenUpdateCallback
*/
/**
* A function that will execute when a tween is cancelled.
* @callback TweenCollection~TweenCancelledCallback
*/
return TweenCollection;
});
/*global define*/
define('Scene/ScreenSpaceCameraController',[
'../Core/Cartesian2',
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/Cartographic',
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/Ellipsoid',
'../Core/IntersectionTests',
'../Core/isArray',
'../Core/KeyboardEventModifier',
'../Core/Math',
'../Core/Matrix3',
'../Core/Matrix4',
'../Core/Plane',
'../Core/Quaternion',
'../Core/Ray',
'../Core/Transforms',
'./CameraEventAggregator',
'./CameraEventType',
'./MapMode2D',
'./SceneMode',
'./SceneTransforms',
'./TweenCollection'
], function(
Cartesian2,
Cartesian3,
Cartesian4,
Cartographic,
defaultValue,
defined,
destroyObject,
DeveloperError,
Ellipsoid,
IntersectionTests,
isArray,
KeyboardEventModifier,
CesiumMath,
Matrix3,
Matrix4,
Plane,
Quaternion,
Ray,
Transforms,
CameraEventAggregator,
CameraEventType,
MapMode2D,
SceneMode,
SceneTransforms,
TweenCollection) {
'use strict';
/**
* Modifies the camera position and orientation based on mouse input to a canvas.
* @alias ScreenSpaceCameraController
* @constructor
*
* @param {Scene} scene The scene.
*/
function ScreenSpaceCameraController(scene) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
/**
* If true, inputs are allowed conditionally with the flags enableTranslate, enableZoom,
* enableRotate, enableTilt, and enableLook. If false, all inputs are disabled.
*
* NOTE: This setting is for temporary use cases, such as camera flights and
* drag-selection of regions (see Picking demo). It is typically set to false at the
* start of such events, and set true on completion. To keep inputs disabled
* past the end of camera flights, you must use the other booleans (enableTranslate,
* enableZoom, enableRotate, enableTilt, and enableLook).
* @type {Boolean}
* @default true
*/
this.enableInputs = true;
/**
* If true, allows the user to pan around the map. If false, the camera stays locked at the current position.
* This flag only applies in 2D and Columbus view modes.
* @type {Boolean}
* @default true
*/
this.enableTranslate = true;
/**
* If true, allows the user to zoom in and out. If false, the camera is locked to the current distance from the ellipsoid.
* @type {Boolean}
* @default true
*/
this.enableZoom = true;
/**
* If true, allows the user to rotate the camera. If false, the camera is locked to the current heading.
* This flag only applies in 2D and 3D.
* @type {Boolean}
* @default true
*/
this.enableRotate = true;
/**
* If true, allows the user to tilt the camera. If false, the camera is locked to the current heading.
* This flag only applies in 3D and Columbus view.
* @type {Boolean}
* @default true
*/
this.enableTilt = true;
/**
* If true, allows the user to use free-look. If false, the camera view direction can only be changed through translating
* or rotating. This flag only applies in 3D and Columbus view modes.
* @type {Boolean}
* @default true
*/
this.enableLook = true;
/**
* A parameter in the range <code>[0, 1)</code> used to determine how long
* the camera will continue to spin because of inertia.
* With value of zero, the camera will have no inertia.
* @type {Number}
* @default 0.9
*/
this.inertiaSpin = 0.9;
/**
* A parameter in the range <code>[0, 1)</code> used to determine how long
* the camera will continue to translate because of inertia.
* With value of zero, the camera will have no inertia.
* @type {Number}
* @default 0.9
*/
this.inertiaTranslate = 0.9;
/**
* A parameter in the range <code>[0, 1)</code> used to determine how long
* the camera will continue to zoom because of inertia.
* With value of zero, the camera will have no inertia.
* @type {Number}
* @default 0.8
*/
this.inertiaZoom = 0.8;
/**
* A parameter in the range <code>[0, 1)</code> used to limit the range
* of various user inputs to a percentage of the window width/height per animation frame.
* This helps keep the camera under control in low-frame-rate situations.
* @type {Number}
* @default 0.1
*/
this.maximumMovementRatio = 0.1;
/**
* Sets the duration, in seconds, of the bounce back animations in 2D and Columbus view.
* @type {Number}
* @default 3.0
*/
this.bounceAnimationTime = 3.0;
/**
* The minimum magnitude, in meters, of the camera position when zooming. Defaults to 1.0.
* @type {Number}
* @default 1.0
*/
this.minimumZoomDistance = 1.0;
/**
* The maximum magnitude, in meters, of the camera position when zooming. Defaults to positive infinity.
* @type {Number}
* @default {@link Number.POSITIVE_INFINITY}
*/
this.maximumZoomDistance = Number.POSITIVE_INFINITY;
/**
* The input that allows the user to pan around the map. This only applies in 2D and Columbus view modes.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default {@link CameraEventType.LEFT_DRAG}
*/
this.translateEventTypes = CameraEventType.LEFT_DRAG;
/**
* The input that allows the user to zoom in/out.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default [{@link CameraEventType.RIGHT_DRAG}, {@link CameraEventType.WHEEL}, {@link CameraEventType.PINCH}]
*/
this.zoomEventTypes = [CameraEventType.RIGHT_DRAG, CameraEventType.WHEEL, CameraEventType.PINCH];
/**
* The input that allows the user to rotate around the globe or another object. This only applies in 3D and Columbus view modes.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default {@link CameraEventType.LEFT_DRAG}
*/
this.rotateEventTypes = CameraEventType.LEFT_DRAG;
/**
* The input that allows the user to tilt in 3D and Columbus view or twist in 2D.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default [{@link CameraEventType.MIDDLE_DRAG}, {@link CameraEventType.PINCH}, {
* eventType : {@link CameraEventType.LEFT_DRAG},
* modifier : {@link KeyboardEventModifier.CTRL}
* }, {
* eventType : {@link CameraEventType.RIGHT_DRAG},
* modifier : {@link KeyboardEventModifier.CTRL}
* }]
*/
this.tiltEventTypes = [CameraEventType.MIDDLE_DRAG, CameraEventType.PINCH, {
eventType : CameraEventType.LEFT_DRAG,
modifier : KeyboardEventModifier.CTRL
}, {
eventType : CameraEventType.RIGHT_DRAG,
modifier : KeyboardEventModifier.CTRL
}];
/**
* The input that allows the user to change the direction the camera is viewing. This only applies in 3D and Columbus view modes.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default { eventType : {@link CameraEventType.LEFT_DRAG}, modifier : {@link KeyboardEventModifier.SHIFT} }
*/
this.lookEventTypes = {
eventType : CameraEventType.LEFT_DRAG,
modifier : KeyboardEventModifier.SHIFT
};
/**
* The minimum height the camera must be before picking the terrain instead of the ellipsoid.
* @type {Number}
* @default 150000.0
*/
this.minimumPickingTerrainHeight = 150000.0;
this._minimumPickingTerrainHeight = this.minimumPickingTerrainHeight;
/**
* The minimum height the camera must be before testing for collision with terrain.
* @type {Number}
* @default 10000.0
*/
this.minimumCollisionTerrainHeight = 15000.0;
this._minimumCollisionTerrainHeight = this.minimumCollisionTerrainHeight;
/**
* The minimum height the camera must be before switching from rotating a track ball to
* free look when clicks originate on the sky on in space.
* @type {Number}
* @default 7500000.0
*/
this.minimumTrackBallHeight = 7500000.0;
this._minimumTrackBallHeight = this.minimumTrackBallHeight;
/**
* Enables or disables camera collision detection with terrain.
* @type {Boolean}
* @default true
*/
this.enableCollisionDetection = true;
this._scene = scene;
this._globe = undefined;
this._ellipsoid = undefined;
this._aggregator = new CameraEventAggregator(scene.canvas);
this._lastInertiaSpinMovement = undefined;
this._lastInertiaZoomMovement = undefined;
this._lastInertiaTranslateMovement = undefined;
this._lastInertiaTiltMovement = undefined;
this._tweens = new TweenCollection();
this._tween = undefined;
this._horizontalRotationAxis = undefined;
this._tiltCenterMousePosition = new Cartesian2(-1.0, -1.0);
this._tiltCenter = new Cartesian3();
this._rotateMousePosition = new Cartesian2(-1.0, -1.0);
this._rotateStartPosition = new Cartesian3();
this._strafeStartPosition = new Cartesian3();
this._zoomMouseStart = new Cartesian2(-1.0, -1.0);
this._zoomWorldPosition = new Cartesian3();
this._useZoomWorldPosition = false;
this._tiltCVOffMap = false;
this._looking = false;
this._rotating = false;
this._strafing = false;
this._zoomingOnVector = false;
this._rotatingZoom = false;
var projection = scene.mapProjection;
this._maxCoord = projection.project(new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO));
// Constants, Make any of these public?
this._zoomFactor = 5.0;
this._rotateFactor = undefined;
this._rotateRateRangeAdjustment = undefined;
this._maximumRotateRate = 1.77;
this._minimumRotateRate = 1.0 / 5000.0;
this._minimumZoomRate = 20.0;
this._maximumZoomRate = 5906376272000.0; // distance from the Sun to Pluto in meters.
}
function decay(time, coefficient) {
if (time < 0) {
return 0.0;
}
var tau = (1.0 - coefficient) * 25.0;
return Math.exp(-tau * time);
}
function sameMousePosition(movement) {
return Cartesian2.equalsEpsilon(movement.startPosition, movement.endPosition, CesiumMath.EPSILON14);
}
// If the time between mouse down and mouse up is not between
// these thresholds, the camera will not move with inertia.
// This value is probably dependent on the browser and/or the
// hardware. Should be investigated further.
var inertiaMaxClickTimeThreshold = 0.4;
function maintainInertia(aggregator, type, modifier, decayCoef, action, object, lastMovementName) {
var movementState = object[lastMovementName];
if (!defined(movementState)) {
movementState = object[lastMovementName] = {
startPosition : new Cartesian2(),
endPosition : new Cartesian2(),
motion : new Cartesian2(),
active : false
};
}
var ts = aggregator.getButtonPressTime(type, modifier);
var tr = aggregator.getButtonReleaseTime(type, modifier);
var threshold = ts && tr && ((tr.getTime() - ts.getTime()) / 1000.0);
var now = new Date();
var fromNow = tr && ((now.getTime() - tr.getTime()) / 1000.0);
if (ts && tr && threshold < inertiaMaxClickTimeThreshold) {
var d = decay(fromNow, decayCoef);
if (!movementState.active) {
var lastMovement = aggregator.getLastMovement(type, modifier);
if (!defined(lastMovement) || sameMousePosition(lastMovement)) {
return;
}
movementState.motion.x = (lastMovement.endPosition.x - lastMovement.startPosition.x) * 0.5;
movementState.motion.y = (lastMovement.endPosition.y - lastMovement.startPosition.y) * 0.5;
movementState.startPosition = Cartesian2.clone(lastMovement.startPosition, movementState.startPosition);
movementState.endPosition = Cartesian2.multiplyByScalar(movementState.motion, d, movementState.endPosition);
movementState.endPosition = Cartesian2.add(movementState.startPosition, movementState.endPosition, movementState.endPosition);
movementState.active = true;
} else {
movementState.startPosition = Cartesian2.clone(movementState.endPosition, movementState.startPosition);
movementState.endPosition = Cartesian2.multiplyByScalar(movementState.motion, d, movementState.endPosition);
movementState.endPosition = Cartesian2.add(movementState.startPosition, movementState.endPosition, movementState.endPosition);
movementState.motion = Cartesian2.clone(Cartesian2.ZERO, movementState.motion);
}
// If value from the decreasing exponential function is close to zero,
// the end coordinates may be NaN.
if (isNaN(movementState.endPosition.x) || isNaN(movementState.endPosition.y) || Cartesian2.distance(movementState.startPosition, movementState.endPosition) < 0.5) {
movementState.active = false;
return;
}
if (!aggregator.isButtonDown(type, modifier)) {
var startPosition = aggregator.getStartMousePosition(type, modifier);
action(object, startPosition, movementState);
}
} else {
movementState.active = false;
}
}
var scratchEventTypeArray = [];
function reactToInput(controller, enabled, eventTypes, action, inertiaConstant, inertiaStateName) {
if (!defined(eventTypes)) {
return;
}
var aggregator = controller._aggregator;
if (!isArray(eventTypes)) {
scratchEventTypeArray[0] = eventTypes;
eventTypes = scratchEventTypeArray;
}
var length = eventTypes.length;
for (var i = 0; i < length; ++i) {
var eventType = eventTypes[i];
var type = defined(eventType.eventType) ? eventType.eventType : eventType;
var modifier = eventType.modifier;
var movement = aggregator.isMoving(type, modifier) && aggregator.getMovement(type, modifier);
var startPosition = aggregator.getStartMousePosition(type, modifier);
if (controller.enableInputs && enabled) {
if (movement) {
action(controller, startPosition, movement);
} else if (inertiaConstant < 1.0) {
maintainInertia(aggregator, type, modifier, inertiaConstant, action, controller, inertiaStateName);
}
}
}
}
var scratchZoomPickRay = new Ray();
var scratchPickCartesian = new Cartesian3();
var scratchZoomOffset = new Cartesian2();
var scratchZoomDirection = new Cartesian3();
var scratchCenterPixel = new Cartesian2();
var scratchCenterPosition = new Cartesian3();
var scratchPositionNormal = new Cartesian3();
var scratchPickNormal = new Cartesian3();
var scratchZoomAxis = new Cartesian3();
var scratchCameraPositionNormal = new Cartesian3();
// Scratch variables used in zooming algorithm
var scratchTargetNormal = new Cartesian3();
var scratchCameraPosition = new Cartesian3();
var scratchCameraUpNormal = new Cartesian3();
var scratchCameraRightNormal = new Cartesian3();
var scratchForwardNormal = new Cartesian3();
var scratchPositionToTarget = new Cartesian3();
var scratchPositionToTargetNormal = new Cartesian3();
var scratchPan = new Cartesian3();
var scratchCenterMovement = new Cartesian3();
var scratchCenter = new Cartesian3();
var scratchCartesian = new Cartesian3();
var scratchCartesianTwo = new Cartesian3();
var scratchCartesianThree = new Cartesian3();
function handleZoom(object, startPosition, movement, zoomFactor, distanceMeasure, unitPositionDotDirection) {
var percentage = 1.0;
if (defined(unitPositionDotDirection)) {
percentage = CesiumMath.clamp(Math.abs(unitPositionDotDirection), 0.25, 1.0);
}
// distanceMeasure should be the height above the ellipsoid.
// The zoomRate slows as it approaches the surface and stops minimumZoomDistance above it.
var minHeight = object.minimumZoomDistance * percentage;
var maxHeight = object.maximumZoomDistance;
var minDistance = distanceMeasure - minHeight;
var zoomRate = zoomFactor * minDistance;
zoomRate = CesiumMath.clamp(zoomRate, object._minimumZoomRate, object._maximumZoomRate);
var diff = movement.endPosition.y - movement.startPosition.y;
var rangeWindowRatio = diff / object._scene.canvas.clientHeight;
rangeWindowRatio = Math.min(rangeWindowRatio, object.maximumMovementRatio);
var distance = zoomRate * rangeWindowRatio;
if (distance > 0.0 && Math.abs(distanceMeasure - minHeight) < 1.0) {
return;
}
if (distance < 0.0 && Math.abs(distanceMeasure - maxHeight) < 1.0) {
return;
}
if (distanceMeasure - distance < minHeight) {
distance = distanceMeasure - minHeight - 1.0;
} else if (distanceMeasure - distance > maxHeight) {
distance = distanceMeasure - maxHeight;
}
var scene = object._scene;
var camera = scene.camera;
var mode = scene.mode;
var sameStartPosition = Cartesian2.equals(startPosition, object._zoomMouseStart);
var zoomingOnVector = object._zoomingOnVector;
var rotatingZoom = object._rotatingZoom;
var pickedPosition;
if (!sameStartPosition) {
object._zoomMouseStart = Cartesian2.clone(startPosition, object._zoomMouseStart);
if (defined(object._globe)) {
pickedPosition = mode !== SceneMode.SCENE2D ? pickGlobe(object, startPosition, scratchPickCartesian) : camera.getPickRay(startPosition, scratchZoomPickRay).origin;
}
if (defined(pickedPosition)) {
object._useZoomWorldPosition = true;
object._zoomWorldPosition = Cartesian3.clone(pickedPosition, object._zoomWorldPosition);
} else {
object._useZoomWorldPosition = false;
}
zoomingOnVector = object._zoomingOnVector = false;
rotatingZoom = object._rotatingZoom = false;
}
if (!object._useZoomWorldPosition) {
camera.zoomIn(distance);
return;
}
var zoomOnVector = mode === SceneMode.COLUMBUS_VIEW;
if (camera.positionCartographic.height < 2000000) {
rotatingZoom = true;
}
if (!sameStartPosition || rotatingZoom) {
if (mode === SceneMode.SCENE2D) {
var worldPosition = object._zoomWorldPosition;
var endPosition = camera.position;
if (!Cartesian3.equals(worldPosition, endPosition) && camera.positionCartographic.height < object._maxCoord.x * 2.0) {
var savedX = camera.position.x;
var direction = Cartesian3.subtract(worldPosition, endPosition, scratchZoomDirection);
Cartesian3.normalize(direction, direction);
var d = Cartesian3.distance(worldPosition, endPosition) * distance / (camera.getMagnitude() * 0.5);
camera.move(direction, d * 0.5);
if ((camera.position.x < 0.0 && savedX > 0.0) || (camera.position.x > 0.0 && savedX < 0.0)) {
pickedPosition = camera.getPickRay(startPosition, scratchZoomPickRay).origin;
object._zoomWorldPosition = Cartesian3.clone(pickedPosition, object._zoomWorldPosition);
}
}
} else if (mode === SceneMode.SCENE3D) {
var cameraPositionNormal = Cartesian3.normalize(camera.position, scratchCameraPositionNormal);
if (camera.positionCartographic.height < 3000.0 && Math.abs(Cartesian3.dot(camera.direction, cameraPositionNormal)) < 0.6) {
zoomOnVector = true;
} else {
var canvas = scene.canvas;
var centerPixel = scratchCenterPixel;
centerPixel.x = canvas.clientWidth / 2;
centerPixel.y = canvas.clientHeight / 2;
var centerPosition = pickGlobe(object, centerPixel, scratchCenterPosition);
// If centerPosition is not defined, it means the globe does not cover the center position of screen
if (defined(centerPosition) && camera.positionCartographic.height < 1000000) {
var cameraPosition = scratchCameraPosition;
Cartesian3.clone(camera.position, cameraPosition);
var target = object._zoomWorldPosition;
var targetNormal = scratchTargetNormal;
targetNormal = Cartesian3.normalize(target, targetNormal);
if (Cartesian3.dot(targetNormal, cameraPositionNormal) < 0.0) {
return;
}
var center = scratchCenter;
var forward = scratchForwardNormal;
Cartesian3.clone(camera.direction, forward);
Cartesian3.add(cameraPosition, Cartesian3.multiplyByScalar(forward, 1000, scratchCartesian), center);
var positionToTarget = scratchPositionToTarget;
var positionToTargetNormal = scratchPositionToTargetNormal;
Cartesian3.subtract(target, cameraPosition, positionToTarget);
Cartesian3.normalize(positionToTarget, positionToTargetNormal);
var alpha = Math.acos( -Cartesian3.dot( cameraPositionNormal, positionToTargetNormal ) );
var cameraDistance = Cartesian3.magnitude( cameraPosition );
var targetDistance = Cartesian3.magnitude( target );
var remainingDistance = cameraDistance - distance;
var positionToTargetDistance = Cartesian3.magnitude(positionToTarget);
var gamma = Math.asin( CesiumMath.clamp( positionToTargetDistance / targetDistance * Math.sin(alpha), -1.0, 1.0 ) );
var delta = Math.asin( CesiumMath.clamp( remainingDistance / targetDistance * Math.sin(alpha), -1.0, 1.0 ) );
var beta = gamma - delta + alpha;
var up = scratchCameraUpNormal;
Cartesian3.normalize(cameraPosition, up);
var right = scratchCameraRightNormal;
right = Cartesian3.cross(positionToTargetNormal, up, right);
right = Cartesian3.normalize(right, right );
Cartesian3.normalize( Cartesian3.cross(up, right, scratchCartesian), forward );
// Calculate new position to move to
Cartesian3.multiplyByScalar(Cartesian3.normalize(center, scratchCartesian), (Cartesian3.magnitude(center) - distance), center);
Cartesian3.normalize(cameraPosition, cameraPosition);
Cartesian3.multiplyByScalar(cameraPosition, remainingDistance, cameraPosition);
// Pan
var pMid = scratchPan;
Cartesian3.multiplyByScalar(Cartesian3.add(
Cartesian3.multiplyByScalar(up, Math.cos(beta) - 1, scratchCartesianTwo),
Cartesian3.multiplyByScalar(forward, Math.sin(beta), scratchCartesianThree),
scratchCartesian
), remainingDistance, pMid);
Cartesian3.add(cameraPosition, pMid, cameraPosition);
Cartesian3.normalize(center, up);
Cartesian3.normalize( Cartesian3.cross(up, right, scratchCartesian), forward );
var cMid = scratchCenterMovement;
Cartesian3.multiplyByScalar(Cartesian3.add(
Cartesian3.multiplyByScalar(up, Math.cos(beta) - 1, scratchCartesianTwo),
Cartesian3.multiplyByScalar(forward, Math.sin(beta), scratchCartesianThree),
scratchCartesian
), Cartesian3.magnitude(center), cMid);
Cartesian3.add(center, cMid, center);
// Update camera
// Set new position
Cartesian3.clone(cameraPosition, camera.position);
// Set new direction
Cartesian3.normalize(Cartesian3.subtract(center, cameraPosition, scratchCartesian), camera.direction);
Cartesian3.clone(camera.direction, camera.direction);
// Set new right & up vectors
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.cross(camera.right, camera.direction, camera.up);
return;
} else if (defined(centerPosition)) {
var positionNormal = Cartesian3.normalize(centerPosition, scratchPositionNormal);
var pickedNormal = Cartesian3.normalize(object._zoomWorldPosition, scratchPickNormal);
var dotProduct = Cartesian3.dot(pickedNormal, positionNormal);
if (dotProduct > 0.0 && dotProduct < 1.0) {
var angle = CesiumMath.acosClamped(dotProduct);
var axis = Cartesian3.cross(pickedNormal, positionNormal, scratchZoomAxis);
var denom = Math.abs(angle) > CesiumMath.toRadians(20.0) ? camera.positionCartographic.height * 0.75 : camera.positionCartographic.height - distance;
var scalar = distance / denom;
camera.rotate(axis, angle * scalar);
}
} else {
zoomOnVector = true;
}
}
}
object._rotatingZoom = !zoomOnVector;
}
if ((!sameStartPosition && zoomOnVector) || zoomingOnVector) {
var ray;
var zoomMouseStart = SceneTransforms.wgs84ToWindowCoordinates(scene, object._zoomWorldPosition, scratchZoomOffset);
if (mode !== SceneMode.COLUMBUS_VIEW && Cartesian2.equals(startPosition, object._zoomMouseStart) && defined(zoomMouseStart)) {
ray = camera.getPickRay(zoomMouseStart, scratchZoomPickRay);
} else {
ray = camera.getPickRay(startPosition, scratchZoomPickRay);
}
var rayDirection = ray.direction;
if (mode === SceneMode.COLUMBUS_VIEW) {
Cartesian3.fromElements(rayDirection.y, rayDirection.z, rayDirection.x, rayDirection);
}
camera.move(rayDirection, distance);
object._zoomingOnVector = true;
} else {
camera.zoomIn(distance);
}
}
var translate2DStart = new Ray();
var translate2DEnd = new Ray();
var scratchTranslateP0 = new Cartesian3();
function translate2D(controller, startPosition, movement) {
var scene = controller._scene;
var camera = scene.camera;
var start = camera.getPickRay(movement.startPosition, translate2DStart).origin;
var end = camera.getPickRay(movement.endPosition, translate2DEnd).origin;
var direction = Cartesian3.subtract(start, end, scratchTranslateP0);
var distance = Cartesian3.magnitude(direction);
if (distance > 0.0) {
Cartesian3.normalize(direction, direction);
camera.move(direction, distance);
}
}
function zoom2D(controller, startPosition, movement) {
if (defined(movement.distance)) {
movement = movement.distance;
}
var scene = controller._scene;
var camera = scene.camera;
handleZoom(controller, startPosition, movement, controller._zoomFactor, camera.getMagnitude());
}
var twist2DStart = new Cartesian2();
var twist2DEnd = new Cartesian2();
function twist2D(controller, startPosition, movement) {
if (defined(movement.angleAndHeight)) {
singleAxisTwist2D(controller, startPosition, movement.angleAndHeight);
return;
}
var scene = controller._scene;
var camera = scene.camera;
var canvas = scene.canvas;
var width = canvas.clientWidth;
var height = canvas.clientHeight;
var start = twist2DStart;
start.x = (2.0 / width) * movement.startPosition.x - 1.0;
start.y = (2.0 / height) * (height - movement.startPosition.y) - 1.0;
start = Cartesian2.normalize(start, start);
var end = twist2DEnd;
end.x = (2.0 / width) * movement.endPosition.x - 1.0;
end.y = (2.0 / height) * (height - movement.endPosition.y) - 1.0;
end = Cartesian2.normalize(end, end);
var startTheta = CesiumMath.acosClamped(start.x);
if (start.y < 0) {
startTheta = CesiumMath.TWO_PI - startTheta;
}
var endTheta = CesiumMath.acosClamped(end.x);
if (end.y < 0) {
endTheta = CesiumMath.TWO_PI - endTheta;
}
var theta = endTheta - startTheta;
camera.twistRight(theta);
}
function singleAxisTwist2D(controller, startPosition, movement) {
var rotateRate = controller._rotateFactor * controller._rotateRateRangeAdjustment;
if (rotateRate > controller._maximumRotateRate) {
rotateRate = controller._maximumRotateRate;
}
if (rotateRate < controller._minimumRotateRate) {
rotateRate = controller._minimumRotateRate;
}
var scene = controller._scene;
var camera = scene.camera;
var canvas = scene.canvas;
var phiWindowRatio = (movement.endPosition.x - movement.startPosition.x) / canvas.clientWidth;
phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
var deltaPhi = rotateRate * phiWindowRatio * Math.PI * 4.0;
camera.twistRight(deltaPhi);
}
function update2D(controller) {
var rotatable2D = controller._scene.mapMode2D === MapMode2D.ROTATE;
if (!Matrix4.equals(Matrix4.IDENTITY, controller._scene.camera.transform)) {
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoom2D, controller.inertiaZoom, '_lastInertiaZoomMovement');
if (rotatable2D) {
reactToInput(controller, controller.enableRotate, controller.translateEventTypes, twist2D, controller.inertiaSpin, '_lastInertiaSpinMovement');
}
} else {
reactToInput(controller, controller.enableTranslate, controller.translateEventTypes, translate2D, controller.inertiaTranslate, '_lastInertiaTranslateMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoom2D, controller.inertiaZoom, '_lastInertiaZoomMovement');
if (rotatable2D) {
reactToInput(controller, controller.enableRotate, controller.tiltEventTypes, twist2D, controller.inertiaSpin, '_lastInertiaTiltMovement');
}
}
}
var pickGlobeScratchRay = new Ray();
var scratchDepthIntersection = new Cartesian3();
var scratchRayIntersection = new Cartesian3();
function pickGlobe(controller, mousePosition, result) {
var scene = controller._scene;
var globe = controller._globe;
var camera = scene.camera;
if (!defined(globe)) {
return undefined;
}
var depthIntersection;
if (scene.pickPositionSupported) {
depthIntersection = scene.pickPosition(mousePosition, scratchDepthIntersection);
}
var ray = camera.getPickRay(mousePosition, pickGlobeScratchRay);
var rayIntersection = globe.pick(ray, scene, scratchRayIntersection);
var pickDistance = defined(depthIntersection) ? Cartesian3.distance(depthIntersection, camera.positionWC) : Number.POSITIVE_INFINITY;
var rayDistance = defined(rayIntersection) ? Cartesian3.distance(rayIntersection, camera.positionWC) : Number.POSITIVE_INFINITY;
if (pickDistance < rayDistance) {
return Cartesian3.clone(depthIntersection, result);
}
return Cartesian3.clone(rayIntersection, result);
}
var translateCVStartRay = new Ray();
var translateCVEndRay = new Ray();
var translateCVStartPos = new Cartesian3();
var translateCVEndPos = new Cartesian3();
var translatCVDifference = new Cartesian3();
var translateCVOrigin = new Cartesian3();
var translateCVPlane = new Plane(Cartesian3.ZERO, 0.0);
var translateCVStartMouse = new Cartesian2();
var translateCVEndMouse = new Cartesian2();
function translateCV(controller, startPosition, movement) {
if (!Cartesian3.equals(startPosition, controller._translateMousePosition)) {
controller._looking = false;
}
if (!Cartesian3.equals(startPosition, controller._strafeMousePosition)) {
controller._strafing = false;
}
if (controller._looking) {
look3D(controller, startPosition, movement);
return;
}
if (controller._strafing) {
strafe(controller, startPosition, movement);
return;
}
var scene = controller._scene;
var camera = scene.camera;
var startMouse = Cartesian2.clone(movement.startPosition, translateCVStartMouse);
var endMouse = Cartesian2.clone(movement.endPosition, translateCVEndMouse);
var startRay = camera.getPickRay(startMouse, translateCVStartRay);
var origin = Cartesian3.clone(Cartesian3.ZERO, translateCVOrigin);
var normal = Cartesian3.UNIT_X;
var globePos;
if (camera.position.z < controller._minimumPickingTerrainHeight) {
globePos = pickGlobe(controller, startMouse, translateCVStartPos);
if (defined(globePos)) {
origin.x = globePos.x;
}
}
if (origin.x > camera.position.z && defined(globePos)) {
Cartesian3.clone(globePos, controller._strafeStartPosition);
controller._strafing = true;
strafe(controller, startPosition, movement);
controller._strafeMousePosition = Cartesian2.clone(startPosition, controller._strafeMousePosition);
return;
}
var plane = Plane.fromPointNormal(origin, normal, translateCVPlane);
startRay = camera.getPickRay(startMouse, translateCVStartRay);
var startPlanePos = IntersectionTests.rayPlane(startRay, plane, translateCVStartPos);
var endRay = camera.getPickRay(endMouse, translateCVEndRay);
var endPlanePos = IntersectionTests.rayPlane(endRay, plane, translateCVEndPos);
if (!defined(startPlanePos) || !defined(endPlanePos)) {
controller._looking = true;
look3D(controller, startPosition, movement);
Cartesian2.clone(startPosition, controller._translateMousePosition);
return;
}
var diff = Cartesian3.subtract(startPlanePos, endPlanePos, translatCVDifference);
var temp = diff.x;
diff.x = diff.y;
diff.y = diff.z;
diff.z = temp;
var mag = Cartesian3.magnitude(diff);
if (mag > CesiumMath.EPSILON6) {
Cartesian3.normalize(diff, diff);
camera.move(diff, mag);
}
}
var rotateCVWindowPos = new Cartesian2();
var rotateCVWindowRay = new Ray();
var rotateCVCenter = new Cartesian3();
var rotateCVVerticalCenter = new Cartesian3();
var rotateCVTransform = new Matrix4();
var rotateCVVerticalTransform = new Matrix4();
var rotateCVOrigin = new Cartesian3();
var rotateCVPlane = new Plane(Cartesian3.ZERO, 0.0);
var rotateCVCartesian3 = new Cartesian3();
var rotateCVCart = new Cartographic();
var rotateCVOldTransform = new Matrix4();
var rotateCVQuaternion = new Quaternion();
var rotateCVMatrix = new Matrix3();
function rotateCV(controller, startPosition, movement) {
if (defined(movement.angleAndHeight)) {
movement = movement.angleAndHeight;
}
if (!Cartesian2.equals(startPosition, controller._tiltCenterMousePosition)) {
controller._tiltCVOffMap = false;
controller._looking = false;
}
if (controller._looking) {
look3D(controller, startPosition, movement);
return;
}
var scene = controller._scene;
var camera = scene.camera;
var maxCoord = controller._maxCoord;
var onMap = Math.abs(camera.position.x) - maxCoord.x < 0 && Math.abs(camera.position.y) - maxCoord.y < 0;
if (controller._tiltCVOffMap || !onMap || camera.position.z > controller._minimumPickingTerrainHeight) {
controller._tiltCVOffMap = true;
rotateCVOnPlane(controller, startPosition, movement);
} else {
rotateCVOnTerrain(controller, startPosition, movement);
}
}
function rotateCVOnPlane(controller, startPosition, movement) {
var scene = controller._scene;
var camera = scene.camera;
var canvas = scene.canvas;
var windowPosition = rotateCVWindowPos;
windowPosition.x = canvas.clientWidth / 2;
windowPosition.y = canvas.clientHeight / 2;
var ray = camera.getPickRay(windowPosition, rotateCVWindowRay);
var normal = Cartesian3.UNIT_X;
var position = ray.origin;
var direction = ray.direction;
var scalar;
var normalDotDirection = Cartesian3.dot(normal, direction);
if (Math.abs(normalDotDirection) > CesiumMath.EPSILON6) {
scalar = -Cartesian3.dot(normal, position) / normalDotDirection;
}
if (!defined(scalar) || scalar <= 0.0) {
controller._looking = true;
look3D(controller, startPosition, movement);
Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
return;
}
var center = Cartesian3.multiplyByScalar(direction, scalar, rotateCVCenter);
Cartesian3.add(position, center, center);
var projection = scene.mapProjection;
var ellipsoid = projection.ellipsoid;
Cartesian3.fromElements(center.y, center.z, center.x, center);
var cart = projection.unproject(center, rotateCVCart);
ellipsoid.cartographicToCartesian(cart, center);
var transform = Transforms.eastNorthUpToFixedFrame(center, ellipsoid, rotateCVTransform);
var oldGlobe = controller._globe;
var oldEllipsoid = controller._ellipsoid;
controller._globe = undefined;
controller._ellipsoid = Ellipsoid.UNIT_SPHERE;
controller._rotateFactor = 1.0;
controller._rotateRateRangeAdjustment = 1.0;
var oldTransform = Matrix4.clone(camera.transform, rotateCVOldTransform);
camera._setTransform(transform);
rotate3D(controller, startPosition, movement, Cartesian3.UNIT_Z);
camera._setTransform(oldTransform);
controller._globe = oldGlobe;
controller._ellipsoid = oldEllipsoid;
var radius = oldEllipsoid.maximumRadius;
controller._rotateFactor = 1.0 / radius;
controller._rotateRateRangeAdjustment = radius;
}
function rotateCVOnTerrain(controller, startPosition, movement) {
var scene = controller._scene;
var camera = scene.camera;
var center;
var ray;
var normal = Cartesian3.UNIT_X;
if (Cartesian2.equals(startPosition, controller._tiltCenterMousePosition)) {
center = Cartesian3.clone(controller._tiltCenter, rotateCVCenter);
} else {
if (camera.position.z < controller._minimumPickingTerrainHeight) {
center = pickGlobe(controller, startPosition, rotateCVCenter);
}
if (!defined(center)) {
ray = camera.getPickRay(startPosition, rotateCVWindowRay);
var position = ray.origin;
var direction = ray.direction;
var scalar;
var normalDotDirection = Cartesian3.dot(normal, direction);
if (Math.abs(normalDotDirection) > CesiumMath.EPSILON6) {
scalar = -Cartesian3.dot(normal, position) / normalDotDirection;
}
if (!defined(scalar) || scalar <= 0.0) {
controller._looking = true;
look3D(controller, startPosition, movement);
Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
return;
}
center = Cartesian3.multiplyByScalar(direction, scalar, rotateCVCenter);
Cartesian3.add(position, center, center);
}
Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
Cartesian3.clone(center, controller._tiltCenter);
}
var canvas = scene.canvas;
var windowPosition = rotateCVWindowPos;
windowPosition.x = canvas.clientWidth / 2;
windowPosition.y = controller._tiltCenterMousePosition.y;
ray = camera.getPickRay(windowPosition, rotateCVWindowRay);
var origin = Cartesian3.clone(Cartesian3.ZERO, rotateCVOrigin);
origin.x = center.x;
var plane = Plane.fromPointNormal(origin, normal, rotateCVPlane);
var verticalCenter = IntersectionTests.rayPlane(ray, plane, rotateCVVerticalCenter);
var projection = camera._projection;
var ellipsoid = projection.ellipsoid;
Cartesian3.fromElements(center.y, center.z, center.x, center);
var cart = projection.unproject(center, rotateCVCart);
ellipsoid.cartographicToCartesian(cart, center);
var transform = Transforms.eastNorthUpToFixedFrame(center, ellipsoid, rotateCVTransform);
var verticalTransform;
if (defined(verticalCenter)) {
Cartesian3.fromElements(verticalCenter.y, verticalCenter.z, verticalCenter.x, verticalCenter);
cart = projection.unproject(verticalCenter, rotateCVCart);
ellipsoid.cartographicToCartesian(cart, verticalCenter);
verticalTransform = Transforms.eastNorthUpToFixedFrame(verticalCenter, ellipsoid, rotateCVVerticalTransform);
} else {
verticalTransform = transform;
}
var oldGlobe = controller._globe;
var oldEllipsoid = controller._ellipsoid;
controller._globe = undefined;
controller._ellipsoid = Ellipsoid.UNIT_SPHERE;
controller._rotateFactor = 1.0;
controller._rotateRateRangeAdjustment = 1.0;
var constrainedAxis = Cartesian3.UNIT_Z;
var oldTransform = Matrix4.clone(camera.transform, rotateCVOldTransform);
camera._setTransform(transform);
var tangent = Cartesian3.cross(Cartesian3.UNIT_Z, Cartesian3.normalize(camera.position, rotateCVCartesian3), rotateCVCartesian3);
var dot = Cartesian3.dot(camera.right, tangent);
rotate3D(controller, startPosition, movement, constrainedAxis, false, true);
camera._setTransform(verticalTransform);
if (dot < 0.0) {
if (movement.startPosition.y > movement.endPosition.y) {
constrainedAxis = undefined;
}
var oldConstrainedAxis = camera.constrainedAxis;
camera.constrainedAxis = undefined;
rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
camera.constrainedAxis = oldConstrainedAxis;
} else {
rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
}
if (defined(camera.constrainedAxis)) {
var right = Cartesian3.cross(camera.direction, camera.constrainedAxis, tilt3DCartesian3);
if (!Cartesian3.equalsEpsilon(right, Cartesian3.ZERO, CesiumMath.EPSILON6)) {
if (Cartesian3.dot(right, camera.right) < 0.0) {
Cartesian3.negate(right, right);
}
Cartesian3.cross(right, camera.direction, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.up, camera.up);
Cartesian3.normalize(camera.right, camera.right);
}
}
camera._setTransform(oldTransform);
controller._globe = oldGlobe;
controller._ellipsoid = oldEllipsoid;
var radius = oldEllipsoid.maximumRadius;
controller._rotateFactor = 1.0 / radius;
controller._rotateRateRangeAdjustment = radius;
var originalPosition = Cartesian3.clone(camera.positionWC, rotateCVCartesian3);
camera._adjustHeightForTerrain();
if (!Cartesian3.equals(camera.positionWC, originalPosition)) {
camera._setTransform(verticalTransform);
camera.worldToCameraCoordinatesPoint(originalPosition, originalPosition);
var magSqrd = Cartesian3.magnitudeSquared(originalPosition);
if (Cartesian3.magnitudeSquared(camera.position) > magSqrd) {
Cartesian3.normalize(camera.position, camera.position);
Cartesian3.multiplyByScalar(camera.position, Math.sqrt(magSqrd), camera.position);
}
var angle = Cartesian3.angleBetween(originalPosition, camera.position);
var axis = Cartesian3.cross(originalPosition, camera.position, originalPosition);
Cartesian3.normalize(axis, axis);
var quaternion = Quaternion.fromAxisAngle(axis, angle, rotateCVQuaternion);
var rotation = Matrix3.fromQuaternion(quaternion, rotateCVMatrix);
Matrix3.multiplyByVector(rotation, camera.direction, camera.direction);
Matrix3.multiplyByVector(rotation, camera.up, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.cross(camera.right, camera.direction, camera.up);
camera._setTransform(oldTransform);
}
}
var zoomCVWindowPos = new Cartesian2();
var zoomCVWindowRay = new Ray();
var zoomCVIntersection = new Cartesian3();
function zoomCV(controller, startPosition, movement) {
if (defined(movement.distance)) {
movement = movement.distance;
}
var scene = controller._scene;
var camera = scene.camera;
var canvas = scene.canvas;
var windowPosition = zoomCVWindowPos;
windowPosition.x = canvas.clientWidth / 2;
windowPosition.y = canvas.clientHeight / 2;
var ray = camera.getPickRay(windowPosition, zoomCVWindowRay);
var intersection;
if (camera.position.z < controller._minimumPickingTerrainHeight) {
intersection = pickGlobe(controller, windowPosition, zoomCVIntersection);
}
var distance;
if (defined(intersection)) {
distance = Cartesian3.distance(ray.origin, intersection);
} else {
var normal = Cartesian3.UNIT_X;
var position = ray.origin;
var direction = ray.direction;
distance = -Cartesian3.dot(normal, position) / Cartesian3.dot(normal, direction);
}
handleZoom(controller, startPosition, movement, controller._zoomFactor, distance);
}
function updateCV(controller) {
var scene = controller._scene;
var camera = scene.camera;
if (!Matrix4.equals(Matrix4.IDENTITY, camera.transform)) {
reactToInput(controller, controller.enableRotate, controller.rotateEventTypes, rotate3D, controller.inertiaSpin, '_lastInertiaSpinMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoom3D, controller.inertiaZoom, '_lastInertiaZoomMovement');
} else {
var tweens = controller._tweens;
if (controller._aggregator.anyButtonDown) {
tweens.removeAll();
}
reactToInput(controller, controller.enableTilt, controller.tiltEventTypes, rotateCV, controller.inertiaSpin, '_lastInertiaTiltMovement');
reactToInput(controller, controller.enableTranslate, controller.translateEventTypes, translateCV, controller.inertiaTranslate, '_lastInertiaTranslateMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoomCV, controller.inertiaZoom, '_lastInertiaZoomMovement');
reactToInput(controller, controller.enableLook, controller.lookEventTypes, look3D);
if (!controller._aggregator.anyButtonDown &&
(!defined(controller._lastInertiaZoomMovement) || !controller._lastInertiaZoomMovement.active) &&
(!defined(controller._lastInertiaTranslateMovement) || !controller._lastInertiaTranslateMovement.active) &&
!tweens.contains(controller._tween)) {
var tween = camera.createCorrectPositionTween(controller.bounceAnimationTime);
if (defined(tween)) {
controller._tween = tweens.add(tween);
}
}
tweens.update();
}
}
var scratchStrafeRay = new Ray();
var scratchStrafePlane = new Plane(Cartesian3.ZERO, 0.0);
var scratchStrafeIntersection = new Cartesian3();
var scratchStrafeDirection = new Cartesian3();
function strafe(controller, startPosition, movement) {
var scene = controller._scene;
var camera = scene.camera;
var mouseStartPosition = pickGlobe(controller, movement.startPosition, scratchMousePos);
if (!defined(mouseStartPosition)) {
return;
}
var mousePosition = movement.endPosition;
var ray = camera.getPickRay(mousePosition, scratchStrafeRay);
var direction = Cartesian3.clone(camera.direction, scratchStrafeDirection);
if (scene.mode === SceneMode.COLUMBUS_VIEW) {
Cartesian3.fromElements(direction.z, direction.x, direction.y, direction);
}
var plane = Plane.fromPointNormal(mouseStartPosition, direction, scratchStrafePlane);
var intersection = IntersectionTests.rayPlane(ray, plane, scratchStrafeIntersection);
if (!defined(intersection)) {
return;
}
direction = Cartesian3.subtract(mouseStartPosition, intersection, direction);
if (scene.mode === SceneMode.COLUMBUS_VIEW) {
Cartesian3.fromElements(direction.y, direction.z, direction.x, direction);
}
Cartesian3.add(camera.position, direction, camera.position);
}
var spin3DPick = new Cartesian3();
var scratchCartographic = new Cartographic();
var scratchMousePos = new Cartesian3();
var scratchRadii = new Cartesian3();
var scratchEllipsoid = new Ellipsoid();
var scratchLookUp = new Cartesian3();
function spin3D(controller, startPosition, movement) {
var scene = controller._scene;
var camera = scene.camera;
if (!Matrix4.equals(camera.transform, Matrix4.IDENTITY)) {
rotate3D(controller, startPosition, movement);
return;
}
var magnitude;
var radii;
var ellipsoid;
var up = controller._ellipsoid.geodeticSurfaceNormal(camera.position, scratchLookUp);
var height = controller._ellipsoid.cartesianToCartographic(camera.positionWC, scratchCartographic).height;
var globe = controller._globe;
var mousePos;
var tangentPick = false;
if (defined(globe) && height < controller._minimumPickingTerrainHeight) {
mousePos = pickGlobe(controller, movement.startPosition, scratchMousePos);
if (defined(mousePos)) {
var ray = camera.getPickRay(movement.startPosition, pickGlobeScratchRay);
var normal = controller._ellipsoid.geodeticSurfaceNormal(mousePos);
tangentPick = Math.abs(Cartesian3.dot(ray.direction, normal)) < 0.05;
if (tangentPick && !controller._looking) {
controller._rotating = false;
controller._strafing = true;
}
}
}
if (Cartesian2.equals(startPosition, controller._rotateMousePosition)) {
if (controller._looking) {
look3D(controller, startPosition, movement, up);
} else if (controller._rotating) {
rotate3D(controller, startPosition, movement);
} else if (controller._strafing) {
Cartesian3.clone(mousePos, controller._strafeStartPosition);
strafe(controller, startPosition, movement);
} else {
magnitude = Cartesian3.magnitude(controller._rotateStartPosition);
radii = scratchRadii;
radii.x = radii.y = radii.z = magnitude;
ellipsoid = Ellipsoid.fromCartesian3(radii, scratchEllipsoid);
pan3D(controller, startPosition, movement, ellipsoid);
}
return;
} else {
controller._looking = false;
controller._rotating = false;
controller._strafing = false;
}
if (defined(globe) && height < controller._minimumPickingTerrainHeight) {
if (defined(mousePos)) {
if (Cartesian3.magnitude(camera.position) < Cartesian3.magnitude(mousePos)) {
Cartesian3.clone(mousePos, controller._strafeStartPosition);
controller._strafing = true;
strafe(controller, startPosition, movement);
} else {
magnitude = Cartesian3.magnitude(mousePos);
radii = scratchRadii;
radii.x = radii.y = radii.z = magnitude;
ellipsoid = Ellipsoid.fromCartesian3(radii, scratchEllipsoid);
pan3D(controller, startPosition, movement, ellipsoid);
Cartesian3.clone(mousePos, controller._rotateStartPosition);
}
} else {
controller._looking = true;
look3D(controller, startPosition, movement, up);
}
} else if (defined(camera.pickEllipsoid(movement.startPosition, controller._ellipsoid, spin3DPick))) {
pan3D(controller, startPosition, movement, controller._ellipsoid);
Cartesian3.clone(spin3DPick, controller._rotateStartPosition);
} else if (height > controller._minimumTrackBallHeight) {
controller._rotating = true;
rotate3D(controller, startPosition, movement);
} else {
controller._looking = true;
look3D(controller, startPosition, movement, up);
}
Cartesian2.clone(startPosition, controller._rotateMousePosition);
}
function rotate3D(controller, startPosition, movement, constrainedAxis, rotateOnlyVertical, rotateOnlyHorizontal) {
rotateOnlyVertical = defaultValue(rotateOnlyVertical, false);
rotateOnlyHorizontal = defaultValue(rotateOnlyHorizontal, false);
var scene = controller._scene;
var camera = scene.camera;
var canvas = scene.canvas;
var oldAxis = camera.constrainedAxis;
if (defined(constrainedAxis)) {
camera.constrainedAxis = constrainedAxis;
}
var rho = Cartesian3.magnitude(camera.position);
var rotateRate = controller._rotateFactor * (rho - controller._rotateRateRangeAdjustment);
if (rotateRate > controller._maximumRotateRate) {
rotateRate = controller._maximumRotateRate;
}
if (rotateRate < controller._minimumRotateRate) {
rotateRate = controller._minimumRotateRate;
}
var phiWindowRatio = (movement.startPosition.x - movement.endPosition.x) / canvas.clientWidth;
var thetaWindowRatio = (movement.startPosition.y - movement.endPosition.y) / canvas.clientHeight;
phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
thetaWindowRatio = Math.min(thetaWindowRatio, controller.maximumMovementRatio);
var deltaPhi = rotateRate * phiWindowRatio * Math.PI * 2.0;
var deltaTheta = rotateRate * thetaWindowRatio * Math.PI;
if (!rotateOnlyVertical) {
camera.rotateRight(deltaPhi);
}
if (!rotateOnlyHorizontal) {
camera.rotateUp(deltaTheta);
}
camera.constrainedAxis = oldAxis;
}
var pan3DP0 = Cartesian4.clone(Cartesian4.UNIT_W);
var pan3DP1 = Cartesian4.clone(Cartesian4.UNIT_W);
var pan3DTemp0 = new Cartesian3();
var pan3DTemp1 = new Cartesian3();
var pan3DTemp2 = new Cartesian3();
var pan3DTemp3 = new Cartesian3();
var pan3DStartMousePosition = new Cartesian2();
var pan3DEndMousePosition = new Cartesian2();
function pan3D(controller, startPosition, movement, ellipsoid) {
var scene = controller._scene;
var camera = scene.camera;
var startMousePosition = Cartesian2.clone(movement.startPosition, pan3DStartMousePosition);
var endMousePosition = Cartesian2.clone(movement.endPosition, pan3DEndMousePosition);
var p0 = camera.pickEllipsoid(startMousePosition, ellipsoid, pan3DP0);
var p1 = camera.pickEllipsoid(endMousePosition, ellipsoid, pan3DP1);
if (!defined(p0) || !defined(p1)) {
controller._rotating = true;
rotate3D(controller, startPosition, movement);
return;
}
p0 = camera.worldToCameraCoordinates(p0, p0);
p1 = camera.worldToCameraCoordinates(p1, p1);
if (!defined(camera.constrainedAxis)) {
Cartesian3.normalize(p0, p0);
Cartesian3.normalize(p1, p1);
var dot = Cartesian3.dot(p0, p1);
var axis = Cartesian3.cross(p0, p1, pan3DTemp0);
if (dot < 1.0 && !Cartesian3.equalsEpsilon(axis, Cartesian3.ZERO, CesiumMath.EPSILON14)) { // dot is in [0, 1]
var angle = Math.acos(dot);
camera.rotate(axis, angle);
}
} else {
var basis0 = camera.constrainedAxis;
var basis1 = Cartesian3.mostOrthogonalAxis(basis0, pan3DTemp0);
Cartesian3.cross(basis1, basis0, basis1);
Cartesian3.normalize(basis1, basis1);
var basis2 = Cartesian3.cross(basis0, basis1, pan3DTemp1);
var startRho = Cartesian3.magnitude(p0);
var startDot = Cartesian3.dot(basis0, p0);
var startTheta = Math.acos(startDot / startRho);
var startRej = Cartesian3.multiplyByScalar(basis0, startDot, pan3DTemp2);
Cartesian3.subtract(p0, startRej, startRej);
Cartesian3.normalize(startRej, startRej);
var endRho = Cartesian3.magnitude(p1);
var endDot = Cartesian3.dot(basis0, p1);
var endTheta = Math.acos(endDot / endRho);
var endRej = Cartesian3.multiplyByScalar(basis0, endDot, pan3DTemp3);
Cartesian3.subtract(p1, endRej, endRej);
Cartesian3.normalize(endRej, endRej);
var startPhi = Math.acos(Cartesian3.dot(startRej, basis1));
if (Cartesian3.dot(startRej, basis2) < 0) {
startPhi = CesiumMath.TWO_PI - startPhi;
}
var endPhi = Math.acos(Cartesian3.dot(endRej, basis1));
if (Cartesian3.dot(endRej, basis2) < 0) {
endPhi = CesiumMath.TWO_PI - endPhi;
}
var deltaPhi = startPhi - endPhi;
var east;
if (Cartesian3.equalsEpsilon(basis0, camera.position, CesiumMath.EPSILON2)) {
east = camera.right;
} else {
east = Cartesian3.cross(basis0, camera.position, pan3DTemp0);
}
var planeNormal = Cartesian3.cross(basis0, east, pan3DTemp0);
var side0 = Cartesian3.dot(planeNormal, Cartesian3.subtract(p0, basis0, pan3DTemp1));
var side1 = Cartesian3.dot(planeNormal, Cartesian3.subtract(p1, basis0, pan3DTemp1));
var deltaTheta;
if (side0 > 0 && side1 > 0) {
deltaTheta = endTheta - startTheta;
} else if (side0 > 0 && side1 <= 0) {
if (Cartesian3.dot(camera.position, basis0) > 0) {
deltaTheta = -startTheta - endTheta;
} else {
deltaTheta = startTheta + endTheta;
}
} else {
deltaTheta = startTheta - endTheta;
}
camera.rotateRight(deltaPhi);
camera.rotateUp(deltaTheta);
}
}
var zoom3DUnitPosition = new Cartesian3();
var zoom3DCartographic = new Cartographic();
function zoom3D(controller, startPosition, movement) {
if (defined(movement.distance)) {
movement = movement.distance;
}
var ellipsoid = controller._ellipsoid;
var scene = controller._scene;
var camera = scene.camera;
var canvas = scene.canvas;
var windowPosition = zoomCVWindowPos;
windowPosition.x = canvas.clientWidth / 2;
windowPosition.y = canvas.clientHeight / 2;
var ray = camera.getPickRay(windowPosition, zoomCVWindowRay);
var intersection;
var height = ellipsoid.cartesianToCartographic(camera.position, zoom3DCartographic).height;
if (height < controller._minimumPickingTerrainHeight) {
intersection = pickGlobe(controller, windowPosition, zoomCVIntersection);
}
var distance;
if (defined(intersection)) {
distance = Cartesian3.distance(ray.origin, intersection);
} else {
distance = height;
}
var unitPosition = Cartesian3.normalize(camera.position, zoom3DUnitPosition);
handleZoom(controller, startPosition, movement, controller._zoomFactor, distance, Cartesian3.dot(unitPosition, camera.direction));
}
var tilt3DWindowPos = new Cartesian2();
var tilt3DRay = new Ray();
var tilt3DCenter = new Cartesian3();
var tilt3DVerticalCenter = new Cartesian3();
var tilt3DTransform = new Matrix4();
var tilt3DVerticalTransform = new Matrix4();
var tilt3DCartesian3 = new Cartesian3();
var tilt3DOldTransform = new Matrix4();
var tilt3DQuaternion = new Quaternion();
var tilt3DMatrix = new Matrix3();
var tilt3DCart = new Cartographic();
var tilt3DLookUp = new Cartesian3();
function tilt3D(controller, startPosition, movement) {
var scene = controller._scene;
var camera = scene.camera;
if (!Matrix4.equals(camera.transform, Matrix4.IDENTITY)) {
return;
}
if (defined(movement.angleAndHeight)) {
movement = movement.angleAndHeight;
}
if (!Cartesian2.equals(startPosition, controller._tiltCenterMousePosition)) {
controller._tiltOnEllipsoid = false;
controller._looking = false;
}
if (controller._looking) {
var up = controller._ellipsoid.geodeticSurfaceNormal(camera.position, tilt3DLookUp);
look3D(controller, startPosition, movement, up);
return;
}
var ellipsoid = controller._ellipsoid;
var cartographic = ellipsoid.cartesianToCartographic(camera.position, tilt3DCart);
if (controller._tiltOnEllipsoid || cartographic.height > controller._minimumCollisionTerrainHeight) {
controller._tiltOnEllipsoid = true;
tilt3DOnEllipsoid(controller, startPosition, movement);
} else {
tilt3DOnTerrain(controller, startPosition, movement);
}
}
var tilt3DOnEllipsoidCartographic = new Cartographic();
function tilt3DOnEllipsoid(controller, startPosition, movement) {
var ellipsoid = controller._ellipsoid;
var scene = controller._scene;
var camera = scene.camera;
var minHeight = controller.minimumZoomDistance * 0.25;
var height = ellipsoid.cartesianToCartographic(camera.positionWC, tilt3DOnEllipsoidCartographic).height;
if (height - minHeight - 1.0 < CesiumMath.EPSILON3 &&
movement.endPosition.y - movement.startPosition.y < 0) {
return;
}
var canvas = scene.canvas;
var windowPosition = tilt3DWindowPos;
windowPosition.x = canvas.clientWidth / 2;
windowPosition.y = canvas.clientHeight / 2;
var ray = camera.getPickRay(windowPosition, tilt3DRay);
var center;
var intersection = IntersectionTests.rayEllipsoid(ray, ellipsoid);
if (defined(intersection)) {
center = Ray.getPoint(ray, intersection.start, tilt3DCenter);
} else if (height > controller._minimumTrackBallHeight) {
var grazingAltitudeLocation = IntersectionTests.grazingAltitudeLocation(ray, ellipsoid);
if (!defined(grazingAltitudeLocation)) {
return;
}
var grazingAltitudeCart = ellipsoid.cartesianToCartographic(grazingAltitudeLocation, tilt3DCart);
grazingAltitudeCart.height = 0.0;
center = ellipsoid.cartographicToCartesian(grazingAltitudeCart, tilt3DCenter);
} else {
controller._looking = true;
var up = controller._ellipsoid.geodeticSurfaceNormal(camera.position, tilt3DLookUp);
look3D(controller, startPosition, movement, up);
Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
return;
}
var transform = Transforms.eastNorthUpToFixedFrame(center, ellipsoid, tilt3DTransform);
var oldGlobe = controller._globe;
var oldEllipsoid = controller._ellipsoid;
controller._globe = undefined;
controller._ellipsoid = Ellipsoid.UNIT_SPHERE;
controller._rotateFactor = 1.0;
controller._rotateRateRangeAdjustment = 1.0;
var oldTransform = Matrix4.clone(camera.transform, tilt3DOldTransform);
camera._setTransform(transform);
rotate3D(controller, startPosition, movement, Cartesian3.UNIT_Z);
camera._setTransform(oldTransform);
controller._globe = oldGlobe;
controller._ellipsoid = oldEllipsoid;
var radius = oldEllipsoid.maximumRadius;
controller._rotateFactor = 1.0 / radius;
controller._rotateRateRangeAdjustment = radius;
}
function tilt3DOnTerrain(controller, startPosition, movement) {
var ellipsoid = controller._ellipsoid;
var scene = controller._scene;
var camera = scene.camera;
var center;
var ray;
var intersection;
if (Cartesian2.equals(startPosition, controller._tiltCenterMousePosition)) {
center = Cartesian3.clone(controller._tiltCenter, tilt3DCenter);
} else {
center = pickGlobe(controller, startPosition, tilt3DCenter);
if (!defined(center)) {
ray = camera.getPickRay(startPosition, tilt3DRay);
intersection = IntersectionTests.rayEllipsoid(ray, ellipsoid);
if (!defined(intersection)) {
var cartographic = ellipsoid.cartesianToCartographic(camera.position, tilt3DCart);
if (cartographic.height <= controller._minimumTrackBallHeight) {
controller._looking = true;
var up = controller._ellipsoid.geodeticSurfaceNormal(camera.position, tilt3DLookUp);
look3D(controller, startPosition, movement, up);
Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
}
return;
}
center = Ray.getPoint(ray, intersection.start, tilt3DCenter);
}
Cartesian2.clone(startPosition, controller._tiltCenterMousePosition);
Cartesian3.clone(center, controller._tiltCenter);
}
var canvas = scene.canvas;
var windowPosition = tilt3DWindowPos;
windowPosition.x = canvas.clientWidth / 2;
windowPosition.y = controller._tiltCenterMousePosition.y;
ray = camera.getPickRay(windowPosition, tilt3DRay);
var mag = Cartesian3.magnitude(center);
var radii = Cartesian3.fromElements(mag, mag, mag, scratchRadii);
var newEllipsoid = Ellipsoid.fromCartesian3(radii, scratchEllipsoid);
intersection = IntersectionTests.rayEllipsoid(ray, newEllipsoid);
if (!defined(intersection)) {
return;
}
var t = Cartesian3.magnitude(ray.origin) > mag ? intersection.start : intersection.stop;
var verticalCenter = Ray.getPoint(ray, t, tilt3DVerticalCenter);
var transform = Transforms.eastNorthUpToFixedFrame(center, ellipsoid, tilt3DTransform);
var verticalTransform = Transforms.eastNorthUpToFixedFrame(verticalCenter, newEllipsoid, tilt3DVerticalTransform);
var oldGlobe = controller._globe;
var oldEllipsoid = controller._ellipsoid;
controller._globe = undefined;
controller._ellipsoid = Ellipsoid.UNIT_SPHERE;
controller._rotateFactor = 1.0;
controller._rotateRateRangeAdjustment = 1.0;
var constrainedAxis = Cartesian3.UNIT_Z;
var oldTransform = Matrix4.clone(camera.transform, tilt3DOldTransform);
camera._setTransform(transform);
var tangent = Cartesian3.cross(verticalCenter, camera.positionWC, tilt3DCartesian3);
var dot = Cartesian3.dot(camera.rightWC, tangent);
rotate3D(controller, startPosition, movement, constrainedAxis, false, true);
camera._setTransform(verticalTransform);
if (dot < 0.0) {
if (movement.startPosition.y > movement.endPosition.y) {
constrainedAxis = undefined;
}
var oldConstrainedAxis = camera.constrainedAxis;
camera.constrainedAxis = undefined;
rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
camera.constrainedAxis = oldConstrainedAxis;
} else {
rotate3D(controller, startPosition, movement, constrainedAxis, true, false);
}
if (defined(camera.constrainedAxis)) {
var right = Cartesian3.cross(camera.direction, camera.constrainedAxis, tilt3DCartesian3);
if (!Cartesian3.equalsEpsilon(right, Cartesian3.ZERO, CesiumMath.EPSILON6)) {
if (Cartesian3.dot(right, camera.right) < 0.0) {
Cartesian3.negate(right, right);
}
Cartesian3.cross(right, camera.direction, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.normalize(camera.up, camera.up);
Cartesian3.normalize(camera.right, camera.right);
}
}
camera._setTransform(oldTransform);
controller._globe = oldGlobe;
controller._ellipsoid = oldEllipsoid;
var radius = oldEllipsoid.maximumRadius;
controller._rotateFactor = 1.0 / radius;
controller._rotateRateRangeAdjustment = radius;
var originalPosition = Cartesian3.clone(camera.positionWC, tilt3DCartesian3);
camera._adjustHeightForTerrain();
if (!Cartesian3.equals(camera.positionWC, originalPosition)) {
camera._setTransform(verticalTransform);
camera.worldToCameraCoordinatesPoint(originalPosition, originalPosition);
var magSqrd = Cartesian3.magnitudeSquared(originalPosition);
if (Cartesian3.magnitudeSquared(camera.position) > magSqrd) {
Cartesian3.normalize(camera.position, camera.position);
Cartesian3.multiplyByScalar(camera.position, Math.sqrt(magSqrd), camera.position);
}
var angle = Cartesian3.angleBetween(originalPosition, camera.position);
var axis = Cartesian3.cross(originalPosition, camera.position, originalPosition);
Cartesian3.normalize(axis, axis);
var quaternion = Quaternion.fromAxisAngle(axis, angle, tilt3DQuaternion);
var rotation = Matrix3.fromQuaternion(quaternion, tilt3DMatrix);
Matrix3.multiplyByVector(rotation, camera.direction, camera.direction);
Matrix3.multiplyByVector(rotation, camera.up, camera.up);
Cartesian3.cross(camera.direction, camera.up, camera.right);
Cartesian3.cross(camera.right, camera.direction, camera.up);
camera._setTransform(oldTransform);
}
}
var look3DStartPos = new Cartesian2();
var look3DEndPos = new Cartesian2();
var look3DStartRay = new Ray();
var look3DEndRay = new Ray();
var look3DNegativeRot = new Cartesian3();
var look3DTan = new Cartesian3();
function look3D(controller, startPosition, movement, rotationAxis) {
var scene = controller._scene;
var camera = scene.camera;
var startPos = look3DStartPos;
startPos.x = movement.startPosition.x;
startPos.y = 0.0;
var endPos = look3DEndPos;
endPos.x = movement.endPosition.x;
endPos.y = 0.0;
var start = camera.getPickRay(startPos, look3DStartRay).direction;
var end = camera.getPickRay(endPos, look3DEndRay).direction;
var angle = 0.0;
var dot = Cartesian3.dot(start, end);
if (dot < 1.0) { // dot is in [0, 1]
angle = Math.acos(dot);
}
angle = (movement.startPosition.x > movement.endPosition.x) ? -angle : angle;
var horizontalRotationAxis = controller._horizontalRotationAxis;
if (defined(rotationAxis)) {
camera.look(rotationAxis, -angle);
} else if (defined(horizontalRotationAxis)) {
camera.look(horizontalRotationAxis, -angle);
} else {
camera.lookLeft(angle);
}
startPos.x = 0.0;
startPos.y = movement.startPosition.y;
endPos.x = 0.0;
endPos.y = movement.endPosition.y;
start = camera.getPickRay(startPos, look3DStartRay).direction;
end = camera.getPickRay(endPos, look3DEndRay).direction;
angle = 0.0;
dot = Cartesian3.dot(start, end);
if (dot < 1.0) { // dot is in [0, 1]
angle = Math.acos(dot);
}
angle = (movement.startPosition.y > movement.endPosition.y) ? -angle : angle;
rotationAxis = defaultValue(rotationAxis, horizontalRotationAxis);
if (defined(rotationAxis)) {
var direction = camera.direction;
var negativeRotationAxis = Cartesian3.negate(rotationAxis, look3DNegativeRot);
var northParallel = Cartesian3.equalsEpsilon(direction, rotationAxis, CesiumMath.EPSILON2);
var southParallel = Cartesian3.equalsEpsilon(direction, negativeRotationAxis, CesiumMath.EPSILON2);
if ((!northParallel && !southParallel)) {
dot = Cartesian3.dot(direction, rotationAxis);
var angleToAxis = CesiumMath.acosClamped(dot);
if (angle > 0 && angle > angleToAxis) {
angle = angleToAxis - CesiumMath.EPSILON4;
}
dot = Cartesian3.dot(direction, negativeRotationAxis);
angleToAxis = CesiumMath.acosClamped(dot);
if (angle < 0 && -angle > angleToAxis) {
angle = -angleToAxis + CesiumMath.EPSILON4;
}
var tangent = Cartesian3.cross(rotationAxis, direction, look3DTan);
camera.look(tangent, angle);
} else if ((northParallel && angle < 0) || (southParallel && angle > 0)) {
camera.look(camera.right, -angle);
}
} else {
camera.lookUp(angle);
}
}
function update3D(controller) {
reactToInput(controller, controller.enableRotate, controller.rotateEventTypes, spin3D, controller.inertiaSpin, '_lastInertiaSpinMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoom3D, controller.inertiaZoom, '_lastInertiaZoomMovement');
reactToInput(controller, controller.enableTilt, controller.tiltEventTypes, tilt3D, controller.inertiaSpin, '_lastInertiaTiltMovement');
reactToInput(controller, controller.enableLook, controller.lookEventTypes, look3D);
}
/**
* @private
*/
ScreenSpaceCameraController.prototype.update = function() {
if (!Matrix4.equals(this._scene.camera.transform, Matrix4.IDENTITY)) {
this._globe = undefined;
this._ellipsoid = Ellipsoid.UNIT_SPHERE;
} else {
this._globe = this._scene.globe;
this._ellipsoid = defined(this._globe) ? this._globe.ellipsoid : this._scene.mapProjection.ellipsoid;
}
this._minimumCollisionTerrainHeight = this.minimumCollisionTerrainHeight * this._scene.terrainExaggeration;
this._minimumPickingTerrainHeight = this.minimumPickingTerrainHeight * this._scene.terrainExaggeration;
this._minimumTrackBallHeight = this.minimumTrackBallHeight * this._scene.terrainExaggeration;
var radius = this._ellipsoid.maximumRadius;
this._rotateFactor = 1.0 / radius;
this._rotateRateRangeAdjustment = radius;
var scene = this._scene;
var mode = scene.mode;
if (mode === SceneMode.SCENE2D) {
update2D(this);
} else if (mode === SceneMode.COLUMBUS_VIEW) {
this._horizontalRotationAxis = Cartesian3.UNIT_Z;
updateCV(this);
} else if (mode === SceneMode.SCENE3D) {
this._horizontalRotationAxis = undefined;
update3D(this);
}
this._aggregator.reset();
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*
* @see ScreenSpaceCameraController#destroy
*/
ScreenSpaceCameraController.prototype.isDestroyed = function() {
return false;
};
/**
* Removes mouse listeners held by this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* controller = controller && controller.destroy();
*
* @see ScreenSpaceCameraController#isDestroyed
*/
ScreenSpaceCameraController.prototype.destroy = function() {
this._tweens.removeAll();
this._aggregator = this._aggregator && this._aggregator.destroy();
return destroyObject(this);
};
return ScreenSpaceCameraController;
});
/*global define*/
define('Scene/ShadowMapShader',[
'../Core/defined',
'../Renderer/ShaderSource'
], function(
defined,
ShaderSource) {
'use strict';
/**
* @private
*/
function ShadowMapShader() {
}
ShadowMapShader.createShadowCastVertexShader = function(vs, isPointLight, isTerrain) {
var defines = vs.defines.slice(0);
var sources = vs.sources.slice(0);
if (isTerrain) {
defines.push('GENERATE_POSITION');
}
var positionVaryingName = ShaderSource.findPositionVarying(vs);
var hasPositionVarying = defined(positionVaryingName);
if (isPointLight && !hasPositionVarying) {
var length = sources.length;
for (var j = 0; j < length; ++j) {
sources[j] = ShaderSource.replaceMain(sources[j], 'czm_shadow_cast_main');
}
var shadowVS =
'varying vec3 v_positionEC; \n' +
'void main() \n' +
'{ \n' +
' czm_shadow_cast_main(); \n' +
' v_positionEC = (czm_inverseProjection * gl_Position).xyz; \n' +
'}';
sources.push(shadowVS);
}
return new ShaderSource({
defines : defines,
sources : sources
});
};
ShadowMapShader.createShadowCastFragmentShader = function(fs, isPointLight, usesDepthTexture, opaque) {
var defines = fs.defines.slice(0);
var sources = fs.sources.slice(0);
var positionVaryingName = ShaderSource.findPositionVarying(fs);
var hasPositionVarying = defined(positionVaryingName);
if (!hasPositionVarying) {
positionVaryingName = 'v_positionEC';
}
var length = sources.length;
for (var i = 0; i < length; ++i) {
sources[i] = ShaderSource.replaceMain(sources[i], 'czm_shadow_cast_main');
}
var fsSource = '';
if (isPointLight) {
if (!hasPositionVarying) {
fsSource += 'varying vec3 v_positionEC; \n';
}
fsSource += 'uniform vec4 shadowMap_lightPositionEC; \n';
}
if (opaque) {
fsSource +=
'void main() \n' +
'{ \n';
} else {
fsSource +=
'void main() \n' +
'{ \n' +
' czm_shadow_cast_main(); \n' +
' if (gl_FragColor.a == 0.0) \n' +
' { \n' +
' discard; \n' +
' } \n';
}
if (isPointLight) {
fsSource +=
'float distance = length(' + positionVaryingName + '); \n' +
'distance /= shadowMap_lightPositionEC.w; // radius \n' +
'gl_FragColor = czm_packDepth(distance); \n';
} else if (usesDepthTexture) {
fsSource += 'gl_FragColor = vec4(1.0); \n';
} else {
fsSource += 'gl_FragColor = czm_packDepth(gl_FragCoord.z); \n';
}
fsSource += '} \n';
sources.push(fsSource);
return new ShaderSource({
defines : defines,
sources : sources
});
};
ShadowMapShader.createShadowReceiveVertexShader = function(vs, isTerrain, hasTerrainNormal) {
var defines = vs.defines.slice(0);
var sources = vs.sources.slice(0);
if (isTerrain) {
if (hasTerrainNormal) {
defines.push('GENERATE_POSITION_AND_NORMAL');
} else {
defines.push('GENERATE_POSITION');
}
}
return new ShaderSource({
defines : defines,
sources : sources
});
};
ShadowMapShader.createShadowReceiveFragmentShader = function(fs, shadowMap, castShadows, isTerrain, hasTerrainNormal) {
var normalVaryingName = ShaderSource.findNormalVarying(fs);
var hasNormalVarying = (!isTerrain && defined(normalVaryingName)) || (isTerrain && hasTerrainNormal);
var positionVaryingName = ShaderSource.findPositionVarying(fs);
var hasPositionVarying = defined(positionVaryingName);
var usesDepthTexture = shadowMap._usesDepthTexture;
var polygonOffsetSupported = shadowMap._polygonOffsetSupported;
var isPointLight = shadowMap._isPointLight;
var isSpotLight = shadowMap._isSpotLight;
var hasCascades = shadowMap._numberOfCascades > 1;
var debugCascadeColors = shadowMap.debugCascadeColors;
var softShadows = shadowMap.softShadows;
var bias = isPointLight ? shadowMap._pointBias : (isTerrain ? shadowMap._terrainBias : shadowMap._primitiveBias);
var defines = fs.defines.slice(0);
var sources = fs.sources.slice(0);
var length = sources.length;
for (var i = 0; i < length; ++i) {
sources[i] = ShaderSource.replaceMain(sources[i], 'czm_shadow_receive_main');
}
if (isPointLight) {
defines.push('USE_CUBE_MAP_SHADOW');
} else if (usesDepthTexture) {
defines.push('USE_SHADOW_DEPTH_TEXTURE');
}
if (softShadows && !isPointLight) {
defines.push('USE_SOFT_SHADOWS');
}
// Enable day-night shading so that the globe is dark when the light is below the horizon
if (hasCascades && castShadows && isTerrain) {
if (hasNormalVarying) {
defines.push('ENABLE_VERTEX_LIGHTING');
} else {
defines.push('ENABLE_DAYNIGHT_SHADING');
}
}
if (castShadows && bias.normalShading && hasNormalVarying) {
defines.push('USE_NORMAL_SHADING');
if (bias.normalShadingSmooth > 0.0) {
defines.push('USE_NORMAL_SHADING_SMOOTH');
}
}
var fsSource = '';
if (isPointLight) {
fsSource += 'uniform samplerCube shadowMap_textureCube; \n';
} else {
fsSource += 'uniform sampler2D shadowMap_texture; \n';
}
fsSource +=
'uniform mat4 shadowMap_matrix; \n' +
'uniform vec3 shadowMap_lightDirectionEC; \n' +
'uniform vec4 shadowMap_lightPositionEC; \n' +
'uniform vec4 shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness; \n' +
'uniform vec4 shadowMap_texelSizeDepthBiasAndNormalShadingSmooth; \n' +
'vec4 getPositionEC() \n' +
'{ \n' +
(hasPositionVarying ?
' return vec4(' + positionVaryingName + ', 1.0); \n' :
' return czm_windowToEyeCoordinates(gl_FragCoord); \n') +
'} \n' +
'vec3 getNormalEC() \n' +
'{ \n' +
(hasNormalVarying ?
' return normalize(' + normalVaryingName + '); \n' :
' return vec3(1.0); \n') +
'} \n' +
// Offset the shadow position in the direction of the normal for perpendicular and back faces
'void applyNormalOffset(inout vec4 positionEC, vec3 normalEC, float nDotL) \n' +
'{ \n' +
(bias.normalOffset && hasNormalVarying ?
' float normalOffset = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.x; \n' +
' float normalOffsetScale = 1.0 - nDotL; \n' +
' vec3 offset = normalOffset * normalOffsetScale * normalEC; \n' +
' positionEC.xyz += offset; \n' : '') +
'} \n';
fsSource +=
'void main() \n' +
'{ \n' +
' czm_shadow_receive_main(); \n' +
' vec4 positionEC = getPositionEC(); \n' +
' vec3 normalEC = getNormalEC(); \n' +
' float depth = -positionEC.z; \n';
fsSource +=
' czm_shadowParameters shadowParameters; \n' +
' shadowParameters.texelStepSize = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.xy; \n' +
' shadowParameters.depthBias = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.z; \n' +
' shadowParameters.normalShadingSmooth = shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.w; \n' +
' shadowParameters.darkness = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.w; \n';
if (isTerrain) {
// Scale depth bias based on view distance to reduce z-fighting in distant terrain
fsSource += ' shadowParameters.depthBias *= max(depth * 0.01, 1.0); \n';
} else if (!polygonOffsetSupported) {
// If polygon offset isn't supported push the depth back based on view, however this
// causes light leaking at further away views
fsSource += ' shadowParameters.depthBias *= mix(1.0, 100.0, depth * 0.0015); \n';
}
if (isPointLight) {
fsSource +=
' vec3 directionEC = positionEC.xyz - shadowMap_lightPositionEC.xyz; \n' +
' float distance = length(directionEC); \n' +
' directionEC = normalize(directionEC); \n' +
' float radius = shadowMap_lightPositionEC.w; \n' +
' // Stop early if the fragment is beyond the point light radius \n' +
' if (distance > radius) \n' +
' { \n' +
' return; \n' +
' } \n' +
' vec3 directionWC = czm_inverseViewRotation * directionEC; \n' +
' shadowParameters.depth = distance / radius; \n' +
' shadowParameters.nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n' +
' shadowParameters.texCoords = directionWC; \n' +
' float visibility = czm_shadowVisibility(shadowMap_textureCube, shadowParameters); \n';
} else if (isSpotLight) {
fsSource +=
' vec3 directionEC = normalize(positionEC.xyz - shadowMap_lightPositionEC.xyz); \n' +
' float nDotL = clamp(dot(normalEC, -directionEC), 0.0, 1.0); \n' +
' applyNormalOffset(positionEC, normalEC, nDotL); \n' +
' vec4 shadowPosition = shadowMap_matrix * positionEC; \n' +
' // Spot light uses a perspective projection, so perform the perspective divide \n' +
' shadowPosition /= shadowPosition.w; \n' +
' // Stop early if the fragment is not in the shadow bounds \n' +
' if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n' +
' { \n' +
' return; \n' +
' } \n' +
' shadowParameters.texCoords = shadowPosition.xy; \n' +
' shadowParameters.depth = shadowPosition.z; \n' +
' shadowParameters.nDotL = nDotL; \n' +
' float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n';
} else if (hasCascades) {
fsSource +=
' float maxDepth = shadowMap_cascadeSplits[1].w; \n' +
' // Stop early if the eye depth exceeds the last cascade \n' +
' if (depth > maxDepth) \n' +
' { \n' +
' return; \n' +
' } \n' +
' // Get the cascade based on the eye-space depth \n' +
' vec4 weights = czm_cascadeWeights(depth); \n' +
' // Apply normal offset \n' +
' float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n' +
' applyNormalOffset(positionEC, normalEC, nDotL); \n' +
' // Transform position into the cascade \n' +
' vec4 shadowPosition = czm_cascadeMatrix(weights) * positionEC; \n' +
' // Get visibility \n' +
' shadowParameters.texCoords = shadowPosition.xy; \n' +
' shadowParameters.depth = shadowPosition.z; \n' +
' shadowParameters.nDotL = nDotL; \n' +
' float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n' +
' // Fade out shadows that are far away \n' +
' float shadowMapMaximumDistance = shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.z; \n' +
' float fade = max((depth - shadowMapMaximumDistance * 0.8) / (shadowMapMaximumDistance * 0.2), 0.0); \n' +
' visibility = mix(visibility, 1.0, fade); \n' +
(debugCascadeColors ?
' // Draw cascade colors for debugging \n' +
' gl_FragColor *= czm_cascadeColor(weights); \n' : '');
} else {
fsSource +=
' float nDotL = clamp(dot(normalEC, shadowMap_lightDirectionEC), 0.0, 1.0); \n' +
' applyNormalOffset(positionEC, normalEC, nDotL); \n' +
' vec4 shadowPosition = shadowMap_matrix * positionEC; \n' +
' // Stop early if the fragment is not in the shadow bounds \n' +
' if (any(lessThan(shadowPosition.xyz, vec3(0.0))) || any(greaterThan(shadowPosition.xyz, vec3(1.0)))) \n' +
' { \n' +
' return; \n' +
' } \n' +
' shadowParameters.texCoords = shadowPosition.xy; \n' +
' shadowParameters.depth = shadowPosition.z; \n' +
' shadowParameters.nDotL = nDotL; \n' +
' float visibility = czm_shadowVisibility(shadowMap_texture, shadowParameters); \n';
}
fsSource +=
' gl_FragColor.rgb *= visibility; \n' +
'} \n';
sources.push(fsSource);
return new ShaderSource({
defines : defines,
sources : sources
});
};
return ShadowMapShader;
});
/*global define*/
define('Scene/ShadowMap',[
'../Core/BoundingRectangle',
'../Core/BoundingSphere',
'../Core/BoxOutlineGeometry',
'../Core/Cartesian2',
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/Cartographic',
'../Core/clone',
'../Core/Color',
'../Core/ColorGeometryInstanceAttribute',
'../Core/combine',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/FeatureDetection',
'../Core/GeometryInstance',
'../Core/Intersect',
'../Core/Math',
'../Core/Matrix4',
'../Core/PixelFormat',
'../Core/Quaternion',
'../Core/SphereOutlineGeometry',
'../Core/WebGLConstants',
'../Renderer/ClearCommand',
'../Renderer/ContextLimits',
'../Renderer/CubeMap',
'../Renderer/DrawCommand',
'../Renderer/Framebuffer',
'../Renderer/Pass',
'../Renderer/PassState',
'../Renderer/PixelDatatype',
'../Renderer/Renderbuffer',
'../Renderer/RenderbufferFormat',
'../Renderer/RenderState',
'../Renderer/Sampler',
'../Renderer/ShaderProgram',
'../Renderer/Texture',
'../Renderer/TextureMagnificationFilter',
'../Renderer/TextureMinificationFilter',
'../Renderer/TextureWrap',
'./Camera',
'./CullFace',
'./CullingVolume',
'./DebugCameraPrimitive',
'./OrthographicFrustum',
'./PerInstanceColorAppearance',
'./PerspectiveFrustum',
'./Primitive',
'./ShadowMapShader'
], function(
BoundingRectangle,
BoundingSphere,
BoxOutlineGeometry,
Cartesian2,
Cartesian3,
Cartesian4,
Cartographic,
clone,
Color,
ColorGeometryInstanceAttribute,
combine,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
FeatureDetection,
GeometryInstance,
Intersect,
CesiumMath,
Matrix4,
PixelFormat,
Quaternion,
SphereOutlineGeometry,
WebGLConstants,
ClearCommand,
ContextLimits,
CubeMap,
DrawCommand,
Framebuffer,
Pass,
PassState,
PixelDatatype,
Renderbuffer,
RenderbufferFormat,
RenderState,
Sampler,
ShaderProgram,
Texture,
TextureMagnificationFilter,
TextureMinificationFilter,
TextureWrap,
Camera,
CullFace,
CullingVolume,
DebugCameraPrimitive,
OrthographicFrustum,
PerInstanceColorAppearance,
PerspectiveFrustum,
Primitive,
ShadowMapShader) {
'use strict';
/**
* Creates a shadow map from the provided light camera.
*
* The normalOffset bias pushes the shadows forward slightly, and may be disabled
* for applications that require ultra precise shadows.
*
* @alias ShadowMap
* @constructor
*
* @param {Object} options An object containing the following properties:
* @param {Context} options.context The context in which to create the shadow map.
* @param {Camera} options.lightCamera A camera representing the light source.
* @param {Boolean} [options.enabled=true] Whether the shadow map is enabled.
* @param {Boolean} [options.isPointLight=false] Whether the light source is a point light. Point light shadows do not use cascades.
* @param {Boolean} [options.pointLightRadius=100.0] Radius of the point light.
* @param {Boolean} [options.cascadesEnabled=true] Use multiple shadow maps to cover different partitions of the view frustum.
* @param {Number} [options.numberOfCascades=4] The number of cascades to use for the shadow map. Supported values are one and four.
* @param {Number} [options.maximumDistance=5000.0] The maximum distance used for generating cascaded shadows. Lower values improve shadow quality.
* @param {Number} [options.size=2048] The width and height, in pixels, of each shadow map.
* @param {Boolean} [options.softShadows=false] Whether percentage-closer-filtering is enabled for producing softer shadows.
* @param {Number} [options.darkness=0.3] The shadow darkness.
*
* @exception {DeveloperError} Only one or four cascades are supported.
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Shadows.html|Cesium Sandcastle Shadows Demo}
*/
function ShadowMap(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var context = options.context;
if (!defined(context)) {
throw new DeveloperError('context is required.');
}
if (!defined(options.lightCamera)) {
throw new DeveloperError('lightCamera is required.');
}
if (defined(options.numberOfCascades) && ((options.numberOfCascades !== 1) && (options.numberOfCascades !== 4))) {
throw new DeveloperError('Only one or four cascades are supported.');
}
this._enabled = defaultValue(options.enabled, true);
this._softShadows = defaultValue(options.softShadows, false);
this.dirty = true;
/**
* Specifies whether the shadow map originates from a light source. Shadow maps that are used for analytical
* purposes should set this to false so as not to affect scene rendering.
*
* @private
*/
this.fromLightSource = defaultValue(options.fromLightSource, true);
/**
* Determines the darkness of the shadows.
*
* @type {Number}
* @default 0.3
*/
this.darkness = defaultValue(options.darkness, 0.3);
this._darkness = this.darkness;
/**
* Determines the maximum distance of the shadow map. Only applicable for cascaded shadows. Larger distances may result in lower quality shadows.
*
* @type {Number}
* @default 5000.0
*/
this.maximumDistance = defaultValue(options.maximumDistance, 5000.0);
this._outOfView = false;
this._outOfViewPrevious = false;
this._needsUpdate = true;
// In IE11 and Edge polygon offset is not functional.
// TODO : Also disabled for instances of Firefox and Chrome running ANGLE that do not support depth textures.
// Re-enable once https://github.com/AnalyticalGraphicsInc/cesium/issues/4560 is resolved.
var polygonOffsetSupported = true;
if (FeatureDetection.isInternetExplorer() || FeatureDetection.isEdge() || ((FeatureDetection.isChrome() || FeatureDetection.isFirefox()) && FeatureDetection.isWindows() && !context.depthTexture)) {
polygonOffsetSupported = false;
}
this._polygonOffsetSupported = polygonOffsetSupported;
this._terrainBias = {
polygonOffset : polygonOffsetSupported,
polygonOffsetFactor : 1.1,
polygonOffsetUnits : 4.0,
normalOffset : true,
normalOffsetScale : 0.5,
normalShading : true,
normalShadingSmooth : 0.3,
depthBias : 0.0001
};
this._primitiveBias = {
polygonOffset : polygonOffsetSupported,
polygonOffsetFactor : 1.1,
polygonOffsetUnits : 4.0,
normalOffset : true,
normalOffsetScale : 0.1,
normalShading : true,
normalShadingSmooth : 0.05,
depthBias : 0.00002
};
this._pointBias = {
polygonOffset : false,
polygonOffsetFactor : 1.1,
polygonOffsetUnits : 4.0,
normalOffset : false,
normalOffsetScale : 0.0,
normalShading : true,
normalShadingSmooth : 0.1,
depthBias : 0.0005
};
// Framebuffer resources
this._depthAttachment = undefined;
this._colorAttachment = undefined;
// Uniforms
this._shadowMapMatrix = new Matrix4();
this._shadowMapTexture = undefined;
this._lightDirectionEC = new Cartesian3();
this._lightPositionEC = new Cartesian4();
this._distance = 0.0;
this._lightCamera = options.lightCamera;
this._shadowMapCamera = new ShadowMapCamera();
this._shadowMapCullingVolume = undefined;
this._sceneCamera = undefined;
this._boundingSphere = new BoundingSphere();
this._isPointLight = defaultValue(options.isPointLight, false);
this._pointLightRadius = defaultValue(options.pointLightRadius, 100.0);
this._cascadesEnabled = this._isPointLight ? false : defaultValue(options.cascadesEnabled, true);
this._numberOfCascades = !this._cascadesEnabled ? 0 : defaultValue(options.numberOfCascades, 4);
this._fitNearFar = true;
this._maximumCascadeDistances = [25.0, 150.0, 700.0, Number.MAX_VALUE];
this._textureSize = new Cartesian2();
this._isSpotLight = false;
if (this._cascadesEnabled) {
// Cascaded shadows are always orthographic. The frustum dimensions are calculated on the fly.
this._shadowMapCamera.frustum = new OrthographicFrustum();
} else if (defined(this._lightCamera.frustum.fov)) {
// If the light camera uses a perspective frustum, then the light source is a spot light
this._isSpotLight = true;
}
// Uniforms
this._cascadeSplits = [new Cartesian4(), new Cartesian4()];
this._cascadeMatrices = [new Matrix4(), new Matrix4(), new Matrix4(), new Matrix4()];
this._cascadeDistances = new Cartesian4();
var numberOfPasses;
if (this._isPointLight) {
numberOfPasses = 6; // One shadow map for each direction
} else if (!this._cascadesEnabled) {
numberOfPasses = 1;
} else {
numberOfPasses = this._numberOfCascades;
}
this._passes = new Array(numberOfPasses);
for (var i = 0; i < numberOfPasses; ++i) {
this._passes[i] = new ShadowPass(context);
}
this.debugShow = false;
this.debugFreezeFrame = false;
this._debugFreezeFrame = false;
this._debugCascadeColors = false;
this._debugLightFrustum = undefined;
this._debugCameraFrustum = undefined;
this._debugCascadeFrustums = new Array(this._numberOfCascades);
this._debugShadowViewCommand = undefined;
this._usesDepthTexture = context.depthTexture;
if (this._isPointLight) {
this._usesDepthTexture = false;
}
// Create render states for shadow casters
this._primitiveRenderState = undefined;
this._terrainRenderState = undefined;
this._pointRenderState = undefined;
createRenderStates(this);
// For clearing the shadow map texture every frame
this._clearCommand = new ClearCommand({
depth : 1.0,
color : new Color()
});
this._clearPassState = new PassState(context);
this._size = defaultValue(options.size, 2048);
this.size = this._size;
}
/**
* Global maximum shadow distance used to prevent far off receivers from extending
* the shadow far plane. This helps set a tighter near/far when viewing objects from space.
*
* @private
*/
ShadowMap.MAXIMUM_DISTANCE = 20000.0;
function ShadowPass(context) {
this.camera = new ShadowMapCamera();
this.passState = new PassState(context);
this.framebuffer = undefined;
this.textureOffsets = undefined;
this.commandList = [];
this.cullingVolume = undefined;
}
function createRenderState(colorMask, bias) {
return RenderState.fromCache({
cull : {
enabled : true,
face : CullFace.BACK
},
depthTest : {
enabled : true
},
colorMask : {
red : colorMask,
green : colorMask,
blue : colorMask,
alpha : colorMask
},
depthMask : true,
polygonOffset : {
enabled : bias.polygonOffset,
factor : bias.polygonOffsetFactor,
units : bias.polygonOffsetUnits
}
});
}
function createRenderStates(shadowMap) {
// Enable the color mask if the shadow map is backed by a color texture, e.g. when depth textures aren't supported
var colorMask = !shadowMap._usesDepthTexture;
shadowMap._primitiveRenderState = createRenderState(colorMask, shadowMap._primitiveBias);
shadowMap._terrainRenderState = createRenderState(colorMask, shadowMap._terrainBias);
shadowMap._pointRenderState = createRenderState(colorMask, shadowMap._pointBias);
}
/**
* @private
*/
ShadowMap.prototype.debugCreateRenderStates = function() {
createRenderStates(this);
};
defineProperties(ShadowMap.prototype, {
/**
* Determines if the shadow map will be shown.
*
* @memberof ShadowMap.prototype
* @type {Boolean}
* @default true
*/
enabled : {
get : function() {
return this._enabled;
},
set : function(value) {
this.dirty = this._enabled !== value;
this._enabled = value;
}
},
/**
* Determines if soft shadows are enabled. Uses pcf filtering which requires more texture reads and may hurt performance.
*
* @memberof ShadowMap.prototype
* @type {Boolean}
* @default false
*/
softShadows : {
get : function() {
return this._softShadows;
},
set : function(value) {
this.dirty = this._softShadows !== value;
this._softShadows = value;
}
},
/**
* The width and height, in pixels, of each shadow map.
*
* @memberof ShadowMap.prototype
* @type {Number}
* @default 2048
*/
size : {
get : function() {
return this._size;
},
set : function(value) {
resize(this, value);
}
},
/**
* Whether the shadow map is out of view of the scene camera.
*
* @memberof ShadowMap.prototype
* @type {Boolean}
* @readonly
* @private
*/
outOfView : {
get : function() {
return this._outOfView;
}
},
/**
* The culling volume of the shadow frustum.
*
* @memberof ShadowMap.prototype
* @type {CullingVolume}
* @readonly
* @private
*/
shadowMapCullingVolume : {
get : function() {
return this._shadowMapCullingVolume;
}
},
/**
* The passes used for rendering shadows. Each face of a point light or each cascade for a cascaded shadow map is a separate pass.
*
* @memberof ShadowMap.prototype
* @type {ShadowPass[]}
* @readonly
* @private
*/
passes : {
get : function() {
return this._passes;
}
},
/**
* Whether the light source is a point light.
*
* @memberof ShadowMap.prototype
* @type {Boolean}
* @readonly
* @private
*/
isPointLight : {
get : function() {
return this._isPointLight;
}
},
/**
* Debug option for visualizing the cascades by color.
*
* @memberof ShadowMap.prototype
* @type {Boolean}
* @default false
* @private
*/
debugCascadeColors : {
get : function() {
return this._debugCascadeColors;
},
set : function(value) {
this.dirty = this._debugCascadeColors !== value;
this._debugCascadeColors = value;
}
}
});
function destroyFramebuffer(shadowMap) {
var length = shadowMap._passes.length;
for (var i = 0; i < length; ++i) {
var pass = shadowMap._passes[i];
var framebuffer = pass.framebuffer;
if (defined(framebuffer) && !framebuffer.isDestroyed()) {
framebuffer.destroy();
}
pass.framebuffer = undefined;
}
// Destroy the framebuffer attachments
shadowMap._depthAttachment = shadowMap._depthAttachment && shadowMap._depthAttachment.destroy();
shadowMap._colorAttachment = shadowMap._colorAttachment && shadowMap._colorAttachment.destroy();
}
function createSampler() {
return new Sampler({
wrapS : TextureWrap.CLAMP_TO_EDGE,
wrapT : TextureWrap.CLAMP_TO_EDGE,
minificationFilter : TextureMinificationFilter.NEAREST,
magnificationFilter : TextureMagnificationFilter.NEAREST
});
}
function createFramebufferColor(shadowMap, context) {
var depthRenderbuffer = new Renderbuffer({
context : context,
width : shadowMap._textureSize.x,
height : shadowMap._textureSize.y,
format : RenderbufferFormat.DEPTH_COMPONENT16
});
var colorTexture = new Texture({
context : context,
width : shadowMap._textureSize.x,
height : shadowMap._textureSize.y,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE,
sampler : createSampler()
});
var framebuffer = new Framebuffer({
context : context,
depthRenderbuffer : depthRenderbuffer,
colorTextures : [colorTexture],
destroyAttachments : false
});
var length = shadowMap._passes.length;
for (var i = 0; i < length; ++i) {
var pass = shadowMap._passes[i];
pass.framebuffer = framebuffer;
pass.passState.framebuffer = framebuffer;
}
shadowMap._shadowMapTexture = colorTexture;
shadowMap._depthAttachment = depthRenderbuffer;
shadowMap._colorAttachment = colorTexture;
}
function createFramebufferDepth(shadowMap, context) {
var depthStencilTexture = new Texture({
context : context,
width : shadowMap._textureSize.x,
height : shadowMap._textureSize.y,
pixelFormat : PixelFormat.DEPTH_STENCIL,
pixelDatatype : PixelDatatype.UNSIGNED_INT_24_8,
sampler : createSampler()
});
var framebuffer = new Framebuffer({
context : context,
depthStencilTexture : depthStencilTexture,
destroyAttachments : false
});
var length = shadowMap._passes.length;
for (var i = 0; i < length; ++i) {
var pass = shadowMap._passes[i];
pass.framebuffer = framebuffer;
pass.passState.framebuffer = framebuffer;
}
shadowMap._shadowMapTexture = depthStencilTexture;
shadowMap._depthAttachment = depthStencilTexture;
}
function createFramebufferCube(shadowMap, context) {
var depthRenderbuffer = new Renderbuffer({
context : context,
width : shadowMap._textureSize.x,
height : shadowMap._textureSize.y,
format : RenderbufferFormat.DEPTH_COMPONENT16
});
var cubeMap = new CubeMap({
context : context,
width : shadowMap._textureSize.x,
height : shadowMap._textureSize.y,
pixelFormat : PixelFormat.RGBA,
pixelDatatype : PixelDatatype.UNSIGNED_BYTE,
sampler : createSampler()
});
var faces = [cubeMap.negativeX, cubeMap.negativeY, cubeMap.negativeZ, cubeMap.positiveX, cubeMap.positiveY, cubeMap.positiveZ];
for (var i = 0; i < 6; ++i) {
var framebuffer = new Framebuffer({
context : context,
depthRenderbuffer : depthRenderbuffer,
colorTextures : [faces[i]],
destroyAttachments : false
});
var pass = shadowMap._passes[i];
pass.framebuffer = framebuffer;
pass.passState.framebuffer = framebuffer;
}
shadowMap._shadowMapTexture = cubeMap;
shadowMap._depthAttachment = depthRenderbuffer;
shadowMap._colorAttachment = cubeMap;
}
function createFramebuffer(shadowMap, context) {
if (shadowMap._isPointLight) {
createFramebufferCube(shadowMap, context);
} else if (shadowMap._usesDepthTexture) {
createFramebufferDepth(shadowMap, context);
} else {
createFramebufferColor(shadowMap, context);
}
}
function checkFramebuffer(shadowMap, context) {
// Attempt to make an FBO with only a depth texture. If it fails, fallback to a color texture.
if (shadowMap._usesDepthTexture && (shadowMap._passes[0].framebuffer.status !== WebGLConstants.FRAMEBUFFER_COMPLETE)) {
shadowMap._usesDepthTexture = false;
createRenderStates(shadowMap);
destroyFramebuffer(shadowMap);
createFramebuffer(shadowMap, context);
}
}
function updateFramebuffer(shadowMap, context) {
if (!defined(shadowMap._passes[0].framebuffer) || (shadowMap._shadowMapTexture.width !== shadowMap._textureSize.x)) {
destroyFramebuffer(shadowMap);
createFramebuffer(shadowMap, context);
checkFramebuffer(shadowMap, context);
clearFramebuffer(shadowMap, context);
}
}
function clearFramebuffer(shadowMap, context, shadowPass) {
shadowPass = defaultValue(shadowPass, 0);
if (shadowMap._isPointLight || (shadowPass === 0)) {
shadowMap._clearCommand.framebuffer = shadowMap._passes[shadowPass].framebuffer;
shadowMap._clearCommand.execute(context, shadowMap._clearPassState);
}
}
function resize(shadowMap, size) {
shadowMap._size = size;
var passes = shadowMap._passes;
var numberOfPasses = passes.length;
var textureSize = shadowMap._textureSize;
if (shadowMap._isPointLight) {
size = (ContextLimits.maximumCubeMapSize >= size) ? size : ContextLimits.maximumCubeMapSize;
textureSize.x = size;
textureSize.y = size;
var faceViewport = new BoundingRectangle(0, 0, size, size);
passes[0].passState.viewport = faceViewport;
passes[1].passState.viewport = faceViewport;
passes[2].passState.viewport = faceViewport;
passes[3].passState.viewport = faceViewport;
passes[4].passState.viewport = faceViewport;
passes[5].passState.viewport = faceViewport;
} else if (numberOfPasses === 1) {
// +----+
// | 1 |
// +----+
size = (ContextLimits.maximumTextureSize >= size) ? size : ContextLimits.maximumTextureSize;
textureSize.x = size;
textureSize.y = size;
passes[0].passState.viewport = new BoundingRectangle(0, 0, size, size);
} else if (numberOfPasses === 4) {
// +----+----+
// | 3 | 4 |
// +----+----+
// | 1 | 2 |
// +----+----+
size = (ContextLimits.maximumTextureSize >= size * 2) ? size : ContextLimits.maximumTextureSize / 2;
textureSize.x = size * 2;
textureSize.y = size * 2;
passes[0].passState.viewport = new BoundingRectangle(0, 0, size, size);
passes[1].passState.viewport = new BoundingRectangle(size, 0, size, size);
passes[2].passState.viewport = new BoundingRectangle(0, size, size, size);
passes[3].passState.viewport = new BoundingRectangle(size, size, size, size);
}
// Update clear pass state
shadowMap._clearPassState.viewport = new BoundingRectangle(0, 0, textureSize.x, textureSize.y);
// Transforms shadow coordinates [0, 1] into the pass's region of the texture
for (var i = 0; i < numberOfPasses; ++i) {
var pass = passes[i];
var viewport = pass.passState.viewport;
var biasX = viewport.x / textureSize.x;
var biasY = viewport.y / textureSize.y;
var scaleX = viewport.width / textureSize.x;
var scaleY = viewport.height / textureSize.y;
pass.textureOffsets = new Matrix4(scaleX, 0.0, 0.0, biasX, 0.0, scaleY, 0.0, biasY, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
}
}
var scratchViewport = new BoundingRectangle();
function createDebugShadowViewCommand(shadowMap, context) {
var fs;
if (shadowMap._isPointLight) {
fs = 'uniform samplerCube shadowMap_textureCube; \n' +
'varying vec2 v_textureCoordinates; \n' +
'void main() \n' +
'{ \n' +
' vec2 uv = v_textureCoordinates; \n' +
' vec3 dir; \n' +
' \n' +
' if (uv.y < 0.5) \n' +
' { \n' +
' if (uv.x < 0.333) \n' +
' { \n' +
' dir.x = -1.0; \n' +
' dir.y = uv.x * 6.0 - 1.0; \n' +
' dir.z = uv.y * 4.0 - 1.0; \n' +
' } \n' +
' else if (uv.x < 0.666) \n' +
' { \n' +
' dir.y = -1.0; \n' +
' dir.x = uv.x * 6.0 - 3.0; \n' +
' dir.z = uv.y * 4.0 - 1.0; \n' +
' } \n' +
' else \n' +
' { \n' +
' dir.z = -1.0; \n' +
' dir.x = uv.x * 6.0 - 5.0; \n' +
' dir.y = uv.y * 4.0 - 1.0; \n' +
' } \n' +
' } \n' +
' else \n' +
' { \n' +
' if (uv.x < 0.333) \n' +
' { \n' +
' dir.x = 1.0; \n' +
' dir.y = uv.x * 6.0 - 1.0; \n' +
' dir.z = uv.y * 4.0 - 3.0; \n' +
' } \n' +
' else if (uv.x < 0.666) \n' +
' { \n' +
' dir.y = 1.0; \n' +
' dir.x = uv.x * 6.0 - 3.0; \n' +
' dir.z = uv.y * 4.0 - 3.0; \n' +
' } \n' +
' else \n' +
' { \n' +
' dir.z = 1.0; \n' +
' dir.x = uv.x * 6.0 - 5.0; \n' +
' dir.y = uv.y * 4.0 - 3.0; \n' +
' } \n' +
' } \n' +
' \n' +
' float shadow = czm_unpackDepth(textureCube(shadowMap_textureCube, dir)); \n' +
' gl_FragColor = vec4(vec3(shadow), 1.0); \n' +
'} \n';
} else {
fs = 'uniform sampler2D shadowMap_texture; \n' +
'varying vec2 v_textureCoordinates; \n' +
'void main() \n' +
'{ \n' +
(shadowMap._usesDepthTexture ?
' float shadow = texture2D(shadowMap_texture, v_textureCoordinates).r; \n' :
' float shadow = czm_unpackDepth(texture2D(shadowMap_texture, v_textureCoordinates)); \n') +
' gl_FragColor = vec4(vec3(shadow), 1.0); \n' +
'} \n';
}
var drawCommand = context.createViewportQuadCommand(fs, {
uniformMap : {
shadowMap_texture : function() {
return shadowMap._shadowMapTexture;
},
shadowMap_textureCube : function() {
return shadowMap._shadowMapTexture;
}
}
});
drawCommand.pass = Pass.OVERLAY;
return drawCommand;
}
function updateDebugShadowViewCommand(shadowMap, frameState) {
// Draws the shadow map on the bottom-right corner of the screen
var context = frameState.context;
var screenWidth = frameState.context.drawingBufferWidth;
var screenHeight = frameState.context.drawingBufferHeight;
var size = Math.min(screenWidth, screenHeight) * 0.3;
var viewport = scratchViewport;
viewport.x = screenWidth - size;
viewport.y = 0;
viewport.width = size;
viewport.height = size;
var debugCommand = shadowMap._debugShadowViewCommand;
if (!defined(debugCommand)) {
debugCommand = createDebugShadowViewCommand(shadowMap, context);
shadowMap._debugShadowViewCommand = debugCommand;
}
// Get a new RenderState for the updated viewport size
if (!defined(debugCommand.renderState) || !BoundingRectangle.equals(debugCommand.renderState.viewport, viewport)) {
debugCommand.renderState = RenderState.fromCache({
viewport : BoundingRectangle.clone(viewport)
});
}
frameState.commandList.push(shadowMap._debugShadowViewCommand);
}
var frustumCornersNDC = new Array(8);
frustumCornersNDC[0] = new Cartesian4(-1.0, -1.0, -1.0, 1.0);
frustumCornersNDC[1] = new Cartesian4(1.0, -1.0, -1.0, 1.0);
frustumCornersNDC[2] = new Cartesian4(1.0, 1.0, -1.0, 1.0);
frustumCornersNDC[3] = new Cartesian4(-1.0, 1.0, -1.0, 1.0);
frustumCornersNDC[4] = new Cartesian4(-1.0, -1.0, 1.0, 1.0);
frustumCornersNDC[5] = new Cartesian4(1.0, -1.0, 1.0, 1.0);
frustumCornersNDC[6] = new Cartesian4(1.0, 1.0, 1.0, 1.0);
frustumCornersNDC[7] = new Cartesian4(-1.0, 1.0, 1.0, 1.0);
var scratchMatrix = new Matrix4();
var scratchFrustumCorners = new Array(8);
for (var i = 0; i < 8; ++i) {
scratchFrustumCorners[i] = new Cartesian4();
}
function createDebugPointLight(modelMatrix, color) {
var box = new GeometryInstance({
geometry : new BoxOutlineGeometry({
minimum : new Cartesian3(-0.5, -0.5, -0.5),
maximum : new Cartesian3(0.5, 0.5, 0.5)
}),
attributes : {
color : ColorGeometryInstanceAttribute.fromColor(color)
}
});
var sphere = new GeometryInstance({
geometry : new SphereOutlineGeometry({
radius : 0.5
}),
attributes : {
color : ColorGeometryInstanceAttribute.fromColor(color)
}
});
return new Primitive({
geometryInstances : [box, sphere],
appearance : new PerInstanceColorAppearance({
translucent : false,
flat : true
}),
asynchronous : false,
modelMatrix : modelMatrix
});
}
var debugOutlineColors = [Color.RED, Color.GREEN, Color.BLUE, Color.MAGENTA];
var scratchScale = new Cartesian3();
function applyDebugSettings(shadowMap, frameState) {
updateDebugShadowViewCommand(shadowMap, frameState);
var enterFreezeFrame = shadowMap.debugFreezeFrame && !shadowMap._debugFreezeFrame;
shadowMap._debugFreezeFrame = shadowMap.debugFreezeFrame;
// Draw scene camera in freeze frame mode
if (shadowMap.debugFreezeFrame) {
if (enterFreezeFrame) {
// Recreate debug camera when entering freeze frame mode
shadowMap._debugCameraFrustum = shadowMap._debugCameraFrustum && shadowMap._debugCameraFrustum.destroy();
shadowMap._debugCameraFrustum = new DebugCameraPrimitive({
camera : shadowMap._sceneCamera,
color : Color.CYAN,
updateOnChange : false
});
}
shadowMap._debugCameraFrustum.update(frameState);
}
if (shadowMap._cascadesEnabled) {
// Draw cascades only in freeze frame mode
if (shadowMap.debugFreezeFrame) {
if (enterFreezeFrame) {
// Recreate debug frustum when entering freeze frame mode
shadowMap._debugLightFrustum = shadowMap._debugLightFrustum && shadowMap._debugLightFrustum.destroy();
shadowMap._debugLightFrustum = new DebugCameraPrimitive({
camera : shadowMap._shadowMapCamera,
color : Color.YELLOW,
updateOnChange : false
});
}
shadowMap._debugLightFrustum.update(frameState);
for (var i = 0; i < shadowMap._numberOfCascades; ++i) {
if (enterFreezeFrame) {
// Recreate debug frustum when entering freeze frame mode
shadowMap._debugCascadeFrustums[i] = shadowMap._debugCascadeFrustums[i] && shadowMap._debugCascadeFrustums[i].destroy();
shadowMap._debugCascadeFrustums[i] = new DebugCameraPrimitive({
camera : shadowMap._passes[i].camera,
color : debugOutlineColors[i],
updateOnChange : false
});
}
shadowMap._debugCascadeFrustums[i].update(frameState);
}
}
} else if (shadowMap._isPointLight) {
if (!defined(shadowMap._debugLightFrustum) || shadowMap._needsUpdate) {
var translation = shadowMap._shadowMapCamera.positionWC;
var rotation = Quaternion.IDENTITY;
var uniformScale = shadowMap._pointLightRadius * 2.0;
var scale = Cartesian3.fromElements(uniformScale, uniformScale, uniformScale, scratchScale);
var modelMatrix = Matrix4.fromTranslationQuaternionRotationScale(translation, rotation, scale, scratchMatrix);
shadowMap._debugLightFrustum = shadowMap._debugLightFrustum && shadowMap._debugLightFrustum.destroy();
shadowMap._debugLightFrustum = createDebugPointLight(modelMatrix, Color.YELLOW);
}
shadowMap._debugLightFrustum.update(frameState);
} else {
if (!defined(shadowMap._debugLightFrustum) || shadowMap._needsUpdate) {
shadowMap._debugLightFrustum = new DebugCameraPrimitive({
camera : shadowMap._shadowMapCamera,
color : Color.YELLOW,
updateOnChange : false
});
}
shadowMap._debugLightFrustum.update(frameState);
}
}
function ShadowMapCamera() {
this.viewMatrix = new Matrix4();
this.inverseViewMatrix = new Matrix4();
this.frustum = undefined;
this.positionCartographic = new Cartographic();
this.positionWC = new Cartesian3();
this.directionWC = Cartesian3.clone(Cartesian3.UNIT_Z);
this.upWC = Cartesian3.clone(Cartesian3.UNIT_Y);
this.rightWC = Cartesian3.clone(Cartesian3.UNIT_X);
this.viewProjectionMatrix = new Matrix4();
}
ShadowMapCamera.prototype.clone = function(camera) {
Matrix4.clone(camera.viewMatrix, this.viewMatrix);
Matrix4.clone(camera.inverseViewMatrix, this.inverseViewMatrix);
this.frustum = camera.frustum.clone(this.frustum);
Cartographic.clone(camera.positionCartographic, this.positionCartographic);
Cartesian3.clone(camera.positionWC, this.positionWC);
Cartesian3.clone(camera.directionWC, this.directionWC);
Cartesian3.clone(camera.upWC, this.upWC);
Cartesian3.clone(camera.rightWC, this.rightWC);
};
// Converts from NDC space to texture space
var scaleBiasMatrix = new Matrix4(0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.0, 0.5, 0.5, 0.0, 0.0, 0.0, 1.0);
ShadowMapCamera.prototype.getViewProjection = function() {
var view = this.viewMatrix;
var projection = this.frustum.projectionMatrix;
Matrix4.multiply(projection, view, this.viewProjectionMatrix);
Matrix4.multiply(scaleBiasMatrix, this.viewProjectionMatrix, this.viewProjectionMatrix);
return this.viewProjectionMatrix;
};
var scratchSplits = new Array(5);
var scratchFrustum = new PerspectiveFrustum();
var scratchCascadeDistances = new Array(4);
function computeCascades(shadowMap, frameState) {
var shadowMapCamera = shadowMap._shadowMapCamera;
var sceneCamera = shadowMap._sceneCamera;
var cameraNear = sceneCamera.frustum.near;
var cameraFar = sceneCamera.frustum.far;
var numberOfCascades = shadowMap._numberOfCascades;
// Split cascades. Use a mix of linear and log splits.
var i;
var range = cameraFar - cameraNear;
var ratio = cameraFar / cameraNear;
var lambda = 0.9;
var clampCascadeDistances = false;
// When the camera is close to a relatively small model, provide more detail in the closer cascades.
// If the camera is near or inside a large model, such as the root tile of a city, then use the default values.
// To get the most accurate cascade splits we would need to find the min and max values from the depth texture.
if (frameState.shadowHints.closestObjectSize < 200.0) {
clampCascadeDistances = true;
lambda = 0.9;
}
var cascadeDistances = scratchCascadeDistances;
var splits = scratchSplits;
splits[0] = cameraNear;
splits[numberOfCascades] = cameraFar;
// Find initial splits
for (i = 0; i < numberOfCascades; ++i) {
var p = (i + 1) / numberOfCascades;
var logScale = cameraNear * Math.pow(ratio, p);
var uniformScale = cameraNear + range * p;
var split = CesiumMath.lerp(uniformScale, logScale, lambda);
splits[i + 1] = split;
cascadeDistances[i] = split - splits[i];
}
if (clampCascadeDistances) {
// Clamp each cascade to its maximum distance
for (i = 0; i < numberOfCascades; ++i) {
cascadeDistances[i] = Math.min(cascadeDistances[i], shadowMap._maximumCascadeDistances[i]);
}
// Recompute splits
var distance = splits[0];
for (i = 0; i < numberOfCascades - 1; ++i) {
distance += cascadeDistances[i];
splits[i + 1] = distance;
}
}
Cartesian4.unpack(splits, 0, shadowMap._cascadeSplits[0]);
Cartesian4.unpack(splits, 1, shadowMap._cascadeSplits[1]);
Cartesian4.unpack(cascadeDistances, 0, shadowMap._cascadeDistances);
var shadowFrustum = shadowMapCamera.frustum;
var left = shadowFrustum.left;
var right = shadowFrustum.right;
var bottom = shadowFrustum.bottom;
var top = shadowFrustum.top;
var near = shadowFrustum.near;
var far = shadowFrustum.far;
var position = shadowMapCamera.positionWC;
var direction = shadowMapCamera.directionWC;
var up = shadowMapCamera.upWC;
var cascadeSubFrustum = sceneCamera.frustum.clone(scratchFrustum);
var shadowViewProjection = shadowMapCamera.getViewProjection();
for (i = 0; i < numberOfCascades; ++i) {
// Find the bounding box of the camera sub-frustum in shadow map texture space
cascadeSubFrustum.near = splits[i];
cascadeSubFrustum.far = splits[i + 1];
var viewProjection = Matrix4.multiply(cascadeSubFrustum.projectionMatrix, sceneCamera.viewMatrix, scratchMatrix);
var inverseViewProjection = Matrix4.inverse(viewProjection, scratchMatrix);
var shadowMapMatrix = Matrix4.multiply(shadowViewProjection, inverseViewProjection, scratchMatrix);
// Project each corner from camera NDC space to shadow map texture space. Min and max will be from 0 to 1.
var min = Cartesian3.fromElements(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, scratchMin);
var max = Cartesian3.fromElements(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, scratchMax);
for (var k = 0; k < 8; ++k) {
var corner = Cartesian4.clone(frustumCornersNDC[k], scratchFrustumCorners[k]);
Matrix4.multiplyByVector(shadowMapMatrix, corner, corner);
Cartesian3.divideByScalar(corner, corner.w, corner); // Handle the perspective divide
Cartesian3.minimumByComponent(corner, min, min);
Cartesian3.maximumByComponent(corner, max, max);
}
// Limit light-space coordinates to the [0, 1] range
min.x = Math.max(min.x, 0.0);
min.y = Math.max(min.y, 0.0);
min.z = 0.0; // Always start cascade frustum at the top of the light frustum to capture objects in the light's path
max.x = Math.min(max.x, 1.0);
max.y = Math.min(max.y, 1.0);
max.z = Math.min(max.z, 1.0);
var pass = shadowMap._passes[i];
var cascadeCamera = pass.camera;
cascadeCamera.clone(shadowMapCamera); // PERFORMANCE_IDEA : could do a shallow clone for all properties except the frustum
var frustum = cascadeCamera.frustum;
frustum.left = left + min.x * (right - left);
frustum.right = left + max.x * (right - left);
frustum.bottom = bottom + min.y * (top - bottom);
frustum.top = bottom + max.y * (top - bottom);
frustum.near = near + min.z * (far - near);
frustum.far = near + max.z * (far - near);
pass.cullingVolume = cascadeCamera.frustum.computeCullingVolume(position, direction, up);
// Transforms from eye space to the cascade's texture space
var cascadeMatrix = shadowMap._cascadeMatrices[i];
Matrix4.multiply(cascadeCamera.getViewProjection(), sceneCamera.inverseViewMatrix, cascadeMatrix);
Matrix4.multiply(pass.textureOffsets, cascadeMatrix, cascadeMatrix);
}
}
var scratchLightView = new Matrix4();
var scratchRight = new Cartesian3();
var scratchUp = new Cartesian3();
var scratchMin = new Cartesian3();
var scratchMax = new Cartesian3();
var scratchTranslation = new Cartesian3();
function fitShadowMapToScene(shadowMap, frameState) {
var shadowMapCamera = shadowMap._shadowMapCamera;
var sceneCamera = shadowMap._sceneCamera;
// 1. First find a tight bounding box in light space that contains the entire camera frustum.
var viewProjection = Matrix4.multiply(sceneCamera.frustum.projectionMatrix, sceneCamera.viewMatrix, scratchMatrix);
var inverseViewProjection = Matrix4.inverse(viewProjection, scratchMatrix);
// Start to construct the light view matrix. Set translation later once the bounding box is found.
var lightDir = shadowMapCamera.directionWC;
var lightUp = sceneCamera.directionWC; // Align shadows to the camera view.
var lightRight = Cartesian3.cross(lightDir, lightUp, scratchRight);
lightUp = Cartesian3.cross(lightRight, lightDir, scratchUp); // Recalculate up now that right is derived
Cartesian3.normalize(lightUp, lightUp);
Cartesian3.normalize(lightRight, lightRight);
var lightPosition = Cartesian3.fromElements(0.0, 0.0, 0.0, scratchTranslation);
var lightView = Matrix4.computeView(lightPosition, lightDir, lightUp, lightRight, scratchLightView);
var cameraToLight = Matrix4.multiply(lightView, inverseViewProjection, scratchMatrix);
// Project each corner from NDC space to light view space, and calculate a min and max in light view space
var min = Cartesian3.fromElements(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE, scratchMin);
var max = Cartesian3.fromElements(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE, scratchMax);
for (var i = 0; i < 8; ++i) {
var corner = Cartesian4.clone(frustumCornersNDC[i], scratchFrustumCorners[i]);
Matrix4.multiplyByVector(cameraToLight, corner, corner);
Cartesian3.divideByScalar(corner, corner.w, corner); // Handle the perspective divide
Cartesian3.minimumByComponent(corner, min, min);
Cartesian3.maximumByComponent(corner, max, max);
}
// 2. Set bounding box back to include objects in the light's view
max.z += 1000.0; // Note: in light space, a positive number is behind the camera
min.z -= 10.0; // Extend the shadow volume forward slightly to avoid problems right at the edge
// 3. Adjust light view matrix so that it is centered on the bounding volume
var translation = scratchTranslation;
translation.x = -(0.5 * (min.x + max.x));
translation.y = -(0.5 * (min.y + max.y));
translation.z = -max.z;
var translationMatrix = Matrix4.fromTranslation(translation, scratchMatrix);
lightView = Matrix4.multiply(translationMatrix, lightView, lightView);
// 4. Create an orthographic frustum that covers the bounding box extents
var halfWidth = 0.5 * (max.x - min.x);
var halfHeight = 0.5 * (max.y - min.y);
var depth = max.z - min.z;
var frustum = shadowMapCamera.frustum;
frustum.left = -halfWidth;
frustum.right = halfWidth;
frustum.bottom = -halfHeight;
frustum.top = halfHeight;
frustum.near = 0.01;
frustum.far = depth;
// 5. Update the shadow map camera
Matrix4.clone(lightView, shadowMapCamera.viewMatrix);
Matrix4.inverse(lightView, shadowMapCamera.inverseViewMatrix);
Matrix4.getTranslation(shadowMapCamera.inverseViewMatrix, shadowMapCamera.positionWC);
frameState.mapProjection.ellipsoid.cartesianToCartographic(shadowMapCamera.positionWC, shadowMapCamera.positionCartographic);
Cartesian3.clone(lightDir, shadowMapCamera.directionWC);
Cartesian3.clone(lightUp, shadowMapCamera.upWC);
Cartesian3.clone(lightRight, shadowMapCamera.rightWC);
}
var directions = [
new Cartesian3(-1.0, 0.0, 0.0),
new Cartesian3(0.0, -1.0, 0.0),
new Cartesian3(0.0, 0.0, -1.0),
new Cartesian3(1.0, 0.0, 0.0),
new Cartesian3(0.0, 1.0, 0.0),
new Cartesian3(0.0, 0.0, 1.0)
];
var ups = [
new Cartesian3(0.0, -1.0, 0.0),
new Cartesian3(0.0, 0.0, -1.0),
new Cartesian3(0.0, -1.0, 0.0),
new Cartesian3(0.0, -1.0, 0.0),
new Cartesian3(0.0, 0.0, 1.0),
new Cartesian3(0.0, -1.0, 0.0)
];
var rights = [
new Cartesian3(0.0, 0.0, 1.0),
new Cartesian3(1.0, 0.0, 0.0),
new Cartesian3(-1.0, 0.0, 0.0),
new Cartesian3(0.0, 0.0, -1.0),
new Cartesian3(1.0, 0.0, 0.0),
new Cartesian3(1.0, 0.0, 0.0)
];
function computeOmnidirectional(shadowMap, frameState) {
// All sides share the same frustum
var frustum = new PerspectiveFrustum();
frustum.fov = CesiumMath.PI_OVER_TWO;
frustum.near = 1.0;
frustum.far = shadowMap._pointLightRadius;
frustum.aspectRatio = 1.0;
for (var i = 0; i < 6; ++i) {
var camera = shadowMap._passes[i].camera;
camera.positionWC = shadowMap._shadowMapCamera.positionWC;
camera.positionCartographic = frameState.mapProjection.ellipsoid.cartesianToCartographic(camera.positionWC, camera.positionCartographic);
camera.directionWC = directions[i];
camera.upWC = ups[i];
camera.rightWC = rights[i];
Matrix4.computeView(camera.positionWC, camera.directionWC, camera.upWC, camera.rightWC, camera.viewMatrix);
Matrix4.inverse(camera.viewMatrix, camera.inverseViewMatrix);
camera.frustum = frustum;
}
}
var scratchCartesian1 = new Cartesian3();
var scratchCartesian2 = new Cartesian3();
var scratchBoundingSphere = new BoundingSphere();
var scratchCenter = scratchBoundingSphere.center;
function checkVisibility(shadowMap, frameState) {
var sceneCamera = shadowMap._sceneCamera;
var shadowMapCamera = shadowMap._shadowMapCamera;
var boundingSphere = scratchBoundingSphere;
// Check whether the shadow map is in view and needs to be updated
if (shadowMap._cascadesEnabled) {
// If the nearest shadow receiver is further than the shadow map's maximum distance then the shadow map is out of view.
if (sceneCamera.frustum.near >= shadowMap.maximumDistance) {
shadowMap._outOfView = true;
shadowMap._needsUpdate = false;
return;
}
// If the light source is below the horizon then the shadow map is out of view
var surfaceNormal = frameState.mapProjection.ellipsoid.geodeticSurfaceNormal(sceneCamera.positionWC, scratchCartesian1);
var lightDirection = Cartesian3.negate(shadowMapCamera.directionWC, scratchCartesian2);
var dot = Cartesian3.dot(surfaceNormal, lightDirection);
// Shadows start to fade out once the light gets closer to the horizon.
// At this point the globe uses vertex lighting alone to darken the surface.
var darknessAmount = CesiumMath.clamp(dot / 0.1, 0.0, 1.0);
shadowMap._darkness = CesiumMath.lerp(1.0, shadowMap.darkness, darknessAmount);
if (dot < 0.0) {
shadowMap._outOfView = true;
shadowMap._needsUpdate = false;
return;
}
// By default cascaded shadows need to update and are always in view
shadowMap._needsUpdate = true;
shadowMap._outOfView = false;
} else if (shadowMap._isPointLight) {
// Sphere-frustum intersection test
boundingSphere.center = shadowMapCamera.positionWC;
boundingSphere.radius = shadowMap._pointLightRadius;
shadowMap._outOfView = frameState.cullingVolume.computeVisibility(boundingSphere) === Intersect.OUTSIDE;
shadowMap._needsUpdate = !shadowMap._outOfView && !shadowMap._boundingSphere.equals(boundingSphere);
BoundingSphere.clone(boundingSphere, shadowMap._boundingSphere);
} else {
// Simplify frustum-frustum intersection test as a sphere-frustum test
var frustumRadius = shadowMapCamera.frustum.far / 2.0;
var frustumCenter = Cartesian3.add(shadowMapCamera.positionWC, Cartesian3.multiplyByScalar(shadowMapCamera.directionWC, frustumRadius, scratchCenter), scratchCenter);
boundingSphere.center = frustumCenter;
boundingSphere.radius = frustumRadius;
shadowMap._outOfView = frameState.cullingVolume.computeVisibility(boundingSphere) === Intersect.OUTSIDE;
shadowMap._needsUpdate = !shadowMap._outOfView && !shadowMap._boundingSphere.equals(boundingSphere);
BoundingSphere.clone(boundingSphere, shadowMap._boundingSphere);
}
}
function updateCameras(shadowMap, frameState) {
var camera = frameState.camera; // The actual camera in the scene
var lightCamera = shadowMap._lightCamera; // The external camera representing the light source
var sceneCamera = shadowMap._sceneCamera; // Clone of camera, with clamped near and far planes
var shadowMapCamera = shadowMap._shadowMapCamera; // Camera representing the shadow volume, initially cloned from lightCamera
// Clone light camera into the shadow map camera
if (shadowMap._cascadesEnabled) {
Cartesian3.clone(lightCamera.directionWC, shadowMapCamera.directionWC);
} else if (shadowMap._isPointLight) {
Cartesian3.clone(lightCamera.positionWC, shadowMapCamera.positionWC);
} else {
shadowMapCamera.clone(lightCamera);
}
// Get the light direction in eye coordinates
var lightDirection = shadowMap._lightDirectionEC;
Matrix4.multiplyByPointAsVector(camera.viewMatrix, shadowMapCamera.directionWC, lightDirection);
Cartesian3.normalize(lightDirection, lightDirection);
Cartesian3.negate(lightDirection, lightDirection);
// Get the light position in eye coordinates
Matrix4.multiplyByPoint(camera.viewMatrix, shadowMapCamera.positionWC, shadowMap._lightPositionEC);
shadowMap._lightPositionEC.w = shadowMap._pointLightRadius;
// Get the near and far of the scene camera
var near;
var far;
if (shadowMap._fitNearFar) {
// shadowFar can be very large, so limit to shadowMap.maximumDistance
// Push the far plane slightly further than the near plane to avoid degenerate frustum
near = Math.min(frameState.shadowHints.nearPlane, shadowMap.maximumDistance);
far = Math.min(frameState.shadowHints.farPlane, shadowMap.maximumDistance + 1.0);
} else {
near = camera.frustum.near;
far = shadowMap.maximumDistance;
}
shadowMap._sceneCamera = Camera.clone(camera, sceneCamera);
camera.frustum.clone(shadowMap._sceneCamera.frustum);
shadowMap._sceneCamera.frustum.near = near;
shadowMap._sceneCamera.frustum.far = far;
shadowMap._distance = far - near;
checkVisibility(shadowMap, frameState);
if (!shadowMap._outOfViewPrevious && shadowMap._outOfView) {
shadowMap._needsUpdate = true;
}
shadowMap._outOfViewPrevious = shadowMap._outOfView;
}
/**
* @private
*/
ShadowMap.prototype.update = function(frameState) {
updateCameras(this, frameState);
if (this._needsUpdate) {
updateFramebuffer(this, frameState.context);
if (this._isPointLight) {
computeOmnidirectional(this, frameState);
}
if (this._cascadesEnabled) {
fitShadowMapToScene(this, frameState);
if (this._numberOfCascades > 1) {
computeCascades(this, frameState);
}
}
if (!this._isPointLight) {
// Compute the culling volume
var shadowMapCamera = this._shadowMapCamera;
var position = shadowMapCamera.positionWC;
var direction = shadowMapCamera.directionWC;
var up = shadowMapCamera.upWC;
this._shadowMapCullingVolume = shadowMapCamera.frustum.computeCullingVolume(position, direction, up);
if (this._passes.length === 1) {
// Since there is only one pass, use the shadow map camera as the pass camera.
this._passes[0].camera.clone(shadowMapCamera);
}
} else {
this._shadowMapCullingVolume = CullingVolume.fromBoundingSphere(this._boundingSphere);
}
}
if (this._passes.length === 1) {
// Transforms from eye space to shadow texture space.
// Always requires an update since the scene camera constantly changes.
var inverseView = this._sceneCamera.inverseViewMatrix;
Matrix4.multiply(this._shadowMapCamera.getViewProjection(), inverseView, this._shadowMapMatrix);
}
if (this.debugShow) {
applyDebugSettings(this, frameState);
}
};
/**
* @private
*/
ShadowMap.prototype.updatePass = function(context, shadowPass) {
clearFramebuffer(this, context, shadowPass);
};
var scratchTexelStepSize = new Cartesian2();
function combineUniforms(shadowMap, uniforms, isTerrain) {
var bias = shadowMap._isPointLight ? shadowMap._pointBias : (isTerrain ? shadowMap._terrainBias : shadowMap._primitiveBias);
var mapUniforms = {
shadowMap_texture :function() {
return shadowMap._shadowMapTexture;
},
shadowMap_textureCube : function() {
return shadowMap._shadowMapTexture;
},
shadowMap_matrix : function() {
return shadowMap._shadowMapMatrix;
},
shadowMap_cascadeSplits : function() {
return shadowMap._cascadeSplits;
},
shadowMap_cascadeMatrices : function() {
return shadowMap._cascadeMatrices;
},
shadowMap_lightDirectionEC : function() {
return shadowMap._lightDirectionEC;
},
shadowMap_lightPositionEC : function() {
return shadowMap._lightPositionEC;
},
shadowMap_cascadeDistances : function() {
return shadowMap._cascadeDistances;
},
shadowMap_texelSizeDepthBiasAndNormalShadingSmooth : function() {
var texelStepSize = scratchTexelStepSize;
texelStepSize.x = 1.0 / shadowMap._textureSize.x;
texelStepSize.y = 1.0 / shadowMap._textureSize.y;
return Cartesian4.fromElements(texelStepSize.x, texelStepSize.y, bias.depthBias, bias.normalShadingSmooth, this.combinedUniforms1);
},
shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness : function() {
return Cartesian4.fromElements(bias.normalOffsetScale, shadowMap._distance, shadowMap.maximumDistance, shadowMap._darkness, this.combinedUniforms2);
},
combinedUniforms1 : new Cartesian4(),
combinedUniforms2 : new Cartesian4()
};
return combine(uniforms, mapUniforms, false);
}
function createCastDerivedCommand(shadowMap, shadowsDirty, command, context, oldShaderId, result) {
var castShader;
var castRenderState;
var castUniformMap;
if (defined(result)) {
castShader = result.shaderProgram;
castRenderState = result.renderState;
castUniformMap = result.uniformMap;
}
result = DrawCommand.shallowClone(command, result);
result.castShadows = true;
result.receiveShadows = false;
if (!defined(castShader) || oldShaderId !== command.shaderProgram.id || shadowsDirty) {
if (defined(castShader)) {
castShader.destroy();
}
var shaderProgram = command.shaderProgram;
var vertexShaderSource = shaderProgram.vertexShaderSource;
var fragmentShaderSource = shaderProgram.fragmentShaderSource;
var isTerrain = command.pass === Pass.GLOBE;
var isOpaque = command.pass !== Pass.TRANSLUCENT;
var isPointLight = shadowMap._isPointLight;
var usesDepthTexture= shadowMap._usesDepthTexture;
var castVS = ShadowMapShader.createShadowCastVertexShader(vertexShaderSource, isPointLight, isTerrain);
var castFS = ShadowMapShader.createShadowCastFragmentShader(fragmentShaderSource, isPointLight, usesDepthTexture, isOpaque);
castShader = ShaderProgram.fromCache({
context : context,
vertexShaderSource : castVS,
fragmentShaderSource : castFS,
attributeLocations : shaderProgram._attributeLocations
});
castRenderState = shadowMap._primitiveRenderState;
if (isPointLight) {
castRenderState = shadowMap._pointRenderState;
} else if (isTerrain) {
castRenderState = shadowMap._terrainRenderState;
}
// Modify the render state for commands that do not use back-face culling, e.g. flat textured walls
var cullEnabled = command.renderState.cull.enabled;
if (!cullEnabled) {
castRenderState = clone(castRenderState, false);
castRenderState.cull.enabled = false;
castRenderState = RenderState.fromCache(castRenderState);
}
castUniformMap = combineUniforms(shadowMap, command.uniformMap, isTerrain);
}
result.shaderProgram = castShader;
result.renderState = castRenderState;
result.uniformMap = castUniformMap;
return result;
}
ShadowMap.createDerivedCommands = function(shadowMaps, lightShadowMaps, command, shadowsDirty, context, result) {
if (!defined(result)) {
result = {};
}
var lightShadowMapsEnabled = (lightShadowMaps.length > 0);
var shaderProgram = command.shaderProgram;
var vertexShaderSource = shaderProgram.vertexShaderSource;
var fragmentShaderSource = shaderProgram.fragmentShaderSource;
var isTerrain = command.pass === Pass.GLOBE;
var hasTerrainNormal = false;
if (isTerrain) {
hasTerrainNormal = command.owner.data.pickTerrain.mesh.encoding.hasVertexNormals;
}
if (command.castShadows) {
var castCommands = result.castCommands;
if (!defined(castCommands)) {
castCommands = result.castCommands = [];
}
var oldShaderId = result.castShaderProgramId;
var shadowMapLength = shadowMaps.length;
castCommands.length = shadowMapLength;
for (var i = 0; i < shadowMapLength; ++i) {
castCommands[i] = createCastDerivedCommand(shadowMaps[i], shadowsDirty, command, context, oldShaderId, castCommands[i]);
}
result.castShaderProgramId = command.shaderProgram.id;
}
if (command.receiveShadows && lightShadowMapsEnabled) {
// Only generate a receiveCommand if there is a shadow map originating from a light source.
var receiveShader;
var receiveUniformMap;
if (defined(result.receiveCommand)) {
receiveShader = result.receiveCommand.shaderProgram;
receiveUniformMap = result.receiveCommand.uniformMap;
}
result.receiveCommand = DrawCommand.shallowClone(command, result.receiveCommand);
result.castShadows = false;
result.receiveShadows = true;
// If castShadows changed, recompile the receive shadows shader. The normal shading technique simulates
// self-shadowing so it should be turned off if castShadows is false.
var castShadowsDirty = result.receiveShaderCastShadows !== command.castShadows;
var shaderDirty = result.receiveShaderProgramId !== command.shaderProgram.id;
if (!defined(receiveShader) || shaderDirty || shadowsDirty || castShadowsDirty) {
if (defined(receiveShader)) {
receiveShader.destroy();
}
var receiveVS = ShadowMapShader.createShadowReceiveVertexShader(vertexShaderSource, isTerrain, hasTerrainNormal);
var receiveFS = ShadowMapShader.createShadowReceiveFragmentShader(fragmentShaderSource, lightShadowMaps[0], command.castShadows, isTerrain, hasTerrainNormal);
receiveShader = ShaderProgram.fromCache({
context : context,
vertexShaderSource : receiveVS,
fragmentShaderSource : receiveFS,
attributeLocations : shaderProgram._attributeLocations
});
receiveUniformMap = combineUniforms(lightShadowMaps[0], command.uniformMap, isTerrain);
}
result.receiveCommand.shaderProgram = receiveShader;
result.receiveCommand.uniformMap = receiveUniformMap;
result.receiveShaderProgramId = command.shaderProgram.id;
result.receiveShaderCastShadows = command.castShadows;
}
return result;
};
/**
* @private
*/
ShadowMap.prototype.isDestroyed = function() {
return false;
};
/**
* @private
*/
ShadowMap.prototype.destroy = function() {
destroyFramebuffer(this);
this._debugLightFrustum = this._debugLightFrustum && this._debugLightFrustum.destroy();
this._debugCameraFrustum = this._debugCameraFrustum && this._debugCameraFrustum.destroy();
this._debugShadowViewCommand = this._debugShadowViewCommand && this._debugShadowViewCommand.shaderProgram && this._debugShadowViewCommand.shaderProgram.destroy();
for (var i = 0; i < this._numberOfCascades; ++i) {
this._debugCascadeFrustums[i] = this._debugCascadeFrustums[i] && this._debugCascadeFrustums[i].destroy();
}
return destroyObject(this);
};
return ShadowMap;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/PostProcessFilters/AdditiveBlend',[],function() {
'use strict';
return "uniform sampler2D u_texture0;\n\
uniform sampler2D u_texture1;\n\
uniform vec2 u_center;\n\
uniform float u_radius;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
vec4 color0 = texture2D(u_texture0, v_textureCoordinates);\n\
vec4 color1 = texture2D(u_texture1, v_textureCoordinates);\n\
float x = length(gl_FragCoord.xy - u_center) / u_radius;\n\
float t = smoothstep(0.5, 0.8, x);\n\
gl_FragColor = mix(color0 + color1, color0, t);\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/PostProcessFilters/BrightPass',[],function() {
'use strict';
return "uniform sampler2D u_texture;\n\
uniform float u_avgLuminance;\n\
uniform float u_threshold;\n\
uniform float u_offset;\n\
varying vec2 v_textureCoordinates;\n\
float key(float avg)\n\
{\n\
float guess = 1.5 - (1.5 / (avg * 0.1 + 1.0));\n\
return max(0.0, guess) + 0.1;\n\
}\n\
void main()\n\
{\n\
vec4 color = texture2D(u_texture, v_textureCoordinates);\n\
vec3 xyz = czm_RGBToXYZ(color.rgb);\n\
float luminance = xyz.r;\n\
float scaledLum = key(u_avgLuminance) * luminance / u_avgLuminance;\n\
float brightLum = max(scaledLum - u_threshold, 0.0);\n\
float brightness = brightLum / (u_offset + brightLum);\n\
xyz.r = brightness;\n\
gl_FragColor = vec4(czm_XYZToRGB(xyz), 1.0);\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/PostProcessFilters/GaussianBlur1D',[],function() {
'use strict';
return "#define SAMPLES 8\n\
uniform float delta;\n\
uniform float sigma;\n\
uniform float direction;\n\
uniform sampler2D u_texture;\n\
uniform vec2 u_step;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
vec2 st = v_textureCoordinates;\n\
vec2 dir = vec2(1.0 - direction, direction);\n\
vec3 g;\n\
g.x = 1.0 / (sqrt(czm_twoPi) * sigma);\n\
g.y = exp((-0.5 * delta * delta) / (sigma * sigma));\n\
g.z = g.y * g.y;\n\
vec4 result = texture2D(u_texture, st) * g.x;\n\
for (int i = 1; i < SAMPLES; ++i)\n\
{\n\
g.xy *= g.yz;\n\
vec2 offset = float(i) * dir * u_step;\n\
result += texture2D(u_texture, st - offset) * g.x;\n\
result += texture2D(u_texture, st + offset) * g.x;\n\
}\n\
gl_FragColor = result;\n\
}\n\
";
});
/*global define*/
define('Scene/SunPostProcess',[
'../Core/BoundingRectangle',
'../Core/Cartesian2',
'../Core/Cartesian4',
'../Core/Color',
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/Math',
'../Core/Matrix4',
'../Core/PixelFormat',
'../Core/Transforms',
'../Renderer/ClearCommand',
'../Renderer/Framebuffer',
'../Renderer/PassState',
'../Renderer/PixelDatatype',
'../Renderer/Renderbuffer',
'../Renderer/RenderbufferFormat',
'../Renderer/RenderState',
'../Renderer/Texture',
'../Shaders/PostProcessFilters/AdditiveBlend',
'../Shaders/PostProcessFilters/BrightPass',
'../Shaders/PostProcessFilters/GaussianBlur1D',
'../Shaders/PostProcessFilters/PassThrough'
], function(
BoundingRectangle,
Cartesian2,
Cartesian4,
Color,
defaultValue,
defined,
destroyObject,
CesiumMath,
Matrix4,
PixelFormat,
Transforms,
ClearCommand,
Framebuffer,
PassState,
PixelDatatype,
Renderbuffer,
RenderbufferFormat,
RenderState,
Texture,
AdditiveBlend,
BrightPass,
GaussianBlur1D,
PassThrough) {
'use strict';
function SunPostProcess() {
this._fbo = undefined;
this._downSampleFBO1 = undefined;
this._downSampleFBO2 = undefined;
this._clearFBO1Command = undefined;
this._clearFBO2Command = undefined;
this._downSampleCommand = undefined;
this._brightPassCommand = undefined;
this._blurXCommand = undefined;
this._blurYCommand = undefined;
this._blendCommand = undefined;
this._fullScreenCommand = undefined;
this._downSamplePassState = new PassState();
this._downSamplePassState.scissorTest = {
enable : true,
rectangle : new BoundingRectangle()
};
this._upSamplePassState = new PassState();
this._upSamplePassState.scissorTest = {
enabled : true,
rectangle : new BoundingRectangle()
};
this._uCenter = new Cartesian2();
this._uRadius = undefined;
this._blurStep = new Cartesian2();
}
SunPostProcess.prototype.clear = function(context, color) {
var clear = this._clearFBO1Command;
Color.clone(defaultValue(color, Color.BLACK), clear.color);
clear.execute(context);
clear = this._clearFBO2Command;
Color.clone(defaultValue(color, Color.BLACK), clear.color);
clear.execute(context);
};
SunPostProcess.prototype.execute = function(context, framebuffer) {
this._downSampleCommand.execute(context, this._downSamplePassState);
this._brightPassCommand.execute(context, this._downSamplePassState);
this._blurXCommand.execute(context, this._downSamplePassState);
this._blurYCommand.execute(context, this._downSamplePassState);
this._fullScreenCommand.framebuffer = framebuffer;
this._blendCommand.framebuffer = framebuffer;
this._fullScreenCommand.execute(context);
this._blendCommand.execute(context, this._upSamplePassState);
};
var viewportBoundingRectangle = new BoundingRectangle();
var downSampleViewportBoundingRectangle = new BoundingRectangle();
var sunPositionECScratch = new Cartesian4();
var sunPositionWCScratch = new Cartesian2();
var sizeScratch = new Cartesian2();
var postProcessMatrix4Scratch= new Matrix4();
SunPostProcess.prototype.update = function(passState) {
var context = passState.context;
var viewport = passState.viewport;
var width = context.drawingBufferWidth;
var height = context.drawingBufferHeight;
var that = this;
if (!defined(this._downSampleCommand)) {
this._clearFBO1Command = new ClearCommand({
color : new Color()
});
this._clearFBO2Command = new ClearCommand({
color : new Color()
});
var uniformMap = {};
this._downSampleCommand = context.createViewportQuadCommand(PassThrough, {
uniformMap : uniformMap,
owner : this
});
uniformMap = {
u_avgLuminance : function() {
// A guess at the average luminance across the entire scene
return 0.5;
},
u_threshold : function() {
return 0.25;
},
u_offset : function() {
return 0.1;
}
};
this._brightPassCommand = context.createViewportQuadCommand(BrightPass, {
uniformMap : uniformMap,
owner : this
});
var delta = 1.0;
var sigma = 2.0;
uniformMap = {
delta : function() {
return delta;
},
sigma : function() {
return sigma;
},
direction : function() {
return 0.0;
}
};
this._blurXCommand = context.createViewportQuadCommand(GaussianBlur1D, {
uniformMap : uniformMap,
owner : this
});
uniformMap = {
delta : function() {
return delta;
},
sigma : function() {
return sigma;
},
direction : function() {
return 1.0;
}
};
this._blurYCommand = context.createViewportQuadCommand(GaussianBlur1D, {
uniformMap : uniformMap,
owner : this
});
uniformMap = {
u_center : function() {
return that._uCenter;
},
u_radius : function() {
return that._uRadius;
}
};
this._blendCommand = context.createViewportQuadCommand(AdditiveBlend, {
uniformMap : uniformMap,
owner : this
});
uniformMap = {};
this._fullScreenCommand = context.createViewportQuadCommand(PassThrough, {
uniformMap : uniformMap,
owner : this
});
}
var downSampleWidth = Math.pow(2.0, Math.ceil(Math.log(width) / Math.log(2)) - 2.0);
var downSampleHeight = Math.pow(2.0, Math.ceil(Math.log(height) / Math.log(2)) - 2.0);
// The size computed above can be less than 1.0 if size < 4.0. This will probably
// never happen in practice, but does in the tests. Clamp to 1.0 to prevent WebGL
// errors in the tests.
var downSampleSize = Math.max(1.0, downSampleWidth, downSampleHeight);
var downSampleViewport = downSampleViewportBoundingRectangle;
downSampleViewport.width = downSampleSize;
downSampleViewport.height = downSampleSize;
var fbo = this._fbo;
var colorTexture = (defined(fbo) && fbo.getColorTexture(0)) || undefined;
if (!defined(colorTexture) || colorTexture.width !== width || colorTexture.height !== height) {
fbo = fbo && fbo.destroy();
this._downSampleFBO1 = this._downSampleFBO1 && this._downSampleFBO1.destroy();
this._downSampleFBO2 = this._downSampleFBO2 && this._downSampleFBO2.destroy();
this._blurStep.x = this._blurStep.y = 1.0 / downSampleSize;
var colorTextures = [new Texture({
context : context,
width : width,
height : height
})];
if (context.depthTexture) {
fbo = this._fbo = new Framebuffer({
context : context,
colorTextures :colorTextures,
depthTexture : new Texture({
context : context,
width : width,
height : height,
pixelFormat : PixelFormat.DEPTH_COMPONENT,
pixelDatatype : PixelDatatype.UNSIGNED_SHORT
})
});
} else {
fbo = this._fbo = new Framebuffer({
context : context,
colorTextures : colorTextures,
depthRenderbuffer : new Renderbuffer({
context : context,
format : RenderbufferFormat.DEPTH_COMPONENT16
})
});
}
this._downSampleFBO1 = new Framebuffer({
context : context,
colorTextures : [new Texture({
context : context,
width : downSampleSize,
height : downSampleSize
})]
});
this._downSampleFBO2 = new Framebuffer({
context : context,
colorTextures : [new Texture({
context : context,
width : downSampleSize,
height : downSampleSize
})]
});
this._clearFBO1Command.framebuffer = this._downSampleFBO1;
this._clearFBO2Command.framebuffer = this._downSampleFBO2;
this._downSampleCommand.framebuffer = this._downSampleFBO1;
this._brightPassCommand.framebuffer = this._downSampleFBO2;
this._blurXCommand.framebuffer = this._downSampleFBO1;
this._blurYCommand.framebuffer = this._downSampleFBO2;
var downSampleRenderState = RenderState.fromCache({
viewport : downSampleViewport
});
this._downSampleCommand.uniformMap.u_texture = function() {
return fbo.getColorTexture(0);
};
this._downSampleCommand.renderState = downSampleRenderState;
this._brightPassCommand.uniformMap.u_texture = function() {
return that._downSampleFBO1.getColorTexture(0);
};
this._brightPassCommand.renderState = downSampleRenderState;
this._blurXCommand.uniformMap.u_texture = function() {
return that._downSampleFBO2.getColorTexture(0);
};
this._blurXCommand.uniformMap.u_step = function() {
return that._blurStep;
};
this._blurXCommand.renderState = downSampleRenderState;
this._blurYCommand.uniformMap.u_texture = function() {
return that._downSampleFBO1.getColorTexture(0);
};
this._blurYCommand.uniformMap.u_step = function() {
return that._blurStep;
};
this._blurYCommand.renderState = downSampleRenderState;
var upSampledViewport = viewportBoundingRectangle;
upSampledViewport.width = width;
upSampledViewport.height = height;
var upSampleRenderState = RenderState.fromCache({ viewport : upSampledViewport });
this._blendCommand.uniformMap.u_texture0 = function() {
return fbo.getColorTexture(0);
};
this._blendCommand.uniformMap.u_texture1 = function() {
return that._downSampleFBO2.getColorTexture(0);
};
this._blendCommand.renderState = upSampleRenderState;
this._fullScreenCommand.uniformMap.u_texture = function() {
return fbo.getColorTexture(0);
};
this._fullScreenCommand.renderState = upSampleRenderState;
}
var us = context.uniformState;
var sunPosition = us.sunPositionWC;
var viewMatrix = us.view;
var viewProjectionMatrix = us.viewProjection;
var projectionMatrix = us.projection;
// create up sampled render state
var viewportTransformation = Matrix4.computeViewportTransformation(viewport, 0.0, 1.0, postProcessMatrix4Scratch);
var sunPositionEC = Matrix4.multiplyByPoint(viewMatrix, sunPosition, sunPositionECScratch);
var sunPositionWC = Transforms.pointToGLWindowCoordinates(viewProjectionMatrix, viewportTransformation, sunPosition, sunPositionWCScratch);
sunPositionEC.x += CesiumMath.SOLAR_RADIUS;
var limbWC = Transforms.pointToGLWindowCoordinates(projectionMatrix, viewportTransformation, sunPositionEC, sunPositionEC);
var sunSize = Cartesian2.magnitude(Cartesian2.subtract(limbWC, sunPositionWC, limbWC)) * 30.0 * 2.0;
var size = sizeScratch;
size.x = sunSize;
size.y = sunSize;
var scissorRectangle = this._upSamplePassState.scissorTest.rectangle;
scissorRectangle.x = Math.max(sunPositionWC.x - size.x * 0.5, 0.0);
scissorRectangle.y = Math.max(sunPositionWC.y - size.y * 0.5, 0.0);
scissorRectangle.width = Math.min(size.x, width);
scissorRectangle.height = Math.min(size.y, height);
this._uCenter = Cartesian2.clone(sunPositionWC, this._uCenter);
this._uRadius = Math.max(size.x, size.y) * 0.5;
// create down sampled render state
viewportTransformation = Matrix4.computeViewportTransformation(downSampleViewport, 0.0, 1.0, postProcessMatrix4Scratch);
sunPositionWC = Transforms.pointToGLWindowCoordinates(viewProjectionMatrix, viewportTransformation, sunPosition, sunPositionWCScratch);
size.x *= downSampleWidth / width;
size.y *= downSampleHeight / height;
scissorRectangle = this._downSamplePassState.scissorTest.rectangle;
scissorRectangle.x = Math.max(sunPositionWC.x - size.x * 0.5, 0.0);
scissorRectangle.y = Math.max(sunPositionWC.y - size.y * 0.5, 0.0);
scissorRectangle.width = Math.min(size.x, width);
scissorRectangle.height = Math.min(size.y, height);
this._downSamplePassState.context = context;
this._upSamplePassState.context = context;
return this._fbo;
};
SunPostProcess.prototype.isDestroyed = function() {
return false;
};
SunPostProcess.prototype.destroy = function() {
this._fbo = this._fbo && this._fbo.destroy();
this._downSampleFBO1 = this._downSampleFBO1 && this._downSampleFBO1.destroy();
this._downSampleFBO2 = this._downSampleFBO2 && this._downSampleFBO2.destroy();
this._downSampleCommand = this._downSampleCommand && this._downSampleCommand.shaderProgram && this._downSampleCommand.shaderProgram.destroy();
this._brightPassCommand = this._brightPassCommand && this._brightPassCommand.shaderProgram && this._brightPassCommand.shaderProgram.destroy();
this._blurXCommand = this._blurXCommand && this._blurXCommand.shaderProgram && this._blurXCommand.shaderProgram.destroy();
this._blurYCommand = this._blurYCommand && this._blurYCommand.shaderProgram && this._blurYCommand.shaderProgram.destroy();
this._blendCommand = this._blendCommand && this._blendCommand.shaderProgram && this._blendCommand.shaderProgram.destroy();
this._fullScreenCommand = this._fullScreenCommand && this._fullScreenCommand.shaderProgram && this._fullScreenCommand.shaderProgram.destroy();
return destroyObject(this);
};
return SunPostProcess;
});
/*global define*/
define('Scene/Scene',[
'../Core/BoundingRectangle',
'../Core/BoundingSphere',
'../Core/BoxGeometry',
'../Core/Cartesian2',
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/Cartographic',
'../Core/Color',
'../Core/ColorGeometryInstanceAttribute',
'../Core/createGuid',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/EllipsoidGeometry',
'../Core/Event',
'../Core/GeographicProjection',
'../Core/GeometryInstance',
'../Core/GeometryPipeline',
'../Core/getTimestamp',
'../Core/Intersect',
'../Core/Interval',
'../Core/JulianDate',
'../Core/Math',
'../Core/Matrix4',
'../Core/mergeSort',
'../Core/Occluder',
'../Core/ShowGeometryInstanceAttribute',
'../Core/Transforms',
'../Renderer/ClearCommand',
'../Renderer/ComputeEngine',
'../Renderer/Context',
'../Renderer/ContextLimits',
'../Renderer/DrawCommand',
'../Renderer/Pass',
'../Renderer/PassState',
'../Renderer/ShaderProgram',
'../Renderer/ShaderSource',
'./Camera',
'./CreditDisplay',
'./CullingVolume',
'./DepthPlane',
'./DeviceOrientationCameraController',
'./Fog',
'./FrameState',
'./FrustumCommands',
'./FXAA',
'./GlobeDepth',
'./MapMode2D',
'./OIT',
'./OrthographicFrustum',
'./PerformanceDisplay',
'./PerInstanceColorAppearance',
'./PerspectiveFrustum',
'./PerspectiveOffCenterFrustum',
'./PickDepth',
'./Primitive',
'./PrimitiveCollection',
'./SceneMode',
'./SceneTransforms',
'./SceneTransitioner',
'./ScreenSpaceCameraController',
'./ShadowMap',
'./SunPostProcess',
'./TweenCollection'
], function(
BoundingRectangle,
BoundingSphere,
BoxGeometry,
Cartesian2,
Cartesian3,
Cartesian4,
Cartographic,
Color,
ColorGeometryInstanceAttribute,
createGuid,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
EllipsoidGeometry,
Event,
GeographicProjection,
GeometryInstance,
GeometryPipeline,
getTimestamp,
Intersect,
Interval,
JulianDate,
CesiumMath,
Matrix4,
mergeSort,
Occluder,
ShowGeometryInstanceAttribute,
Transforms,
ClearCommand,
ComputeEngine,
Context,
ContextLimits,
DrawCommand,
Pass,
PassState,
ShaderProgram,
ShaderSource,
Camera,
CreditDisplay,
CullingVolume,
DepthPlane,
DeviceOrientationCameraController,
Fog,
FrameState,
FrustumCommands,
FXAA,
GlobeDepth,
MapMode2D,
OIT,
OrthographicFrustum,
PerformanceDisplay,
PerInstanceColorAppearance,
PerspectiveFrustum,
PerspectiveOffCenterFrustum,
PickDepth,
Primitive,
PrimitiveCollection,
SceneMode,
SceneTransforms,
SceneTransitioner,
ScreenSpaceCameraController,
ShadowMap,
SunPostProcess,
TweenCollection) {
'use strict';
/**
* The container for all 3D graphical objects and state in a Cesium virtual scene. Generally,
* a scene is not created directly; instead, it is implicitly created by {@link CesiumWidget}.
* <p>
* <em><code>contextOptions</code> parameter details:</em>
* </p>
* <p>
* The default values are:
* <code>
* {
* webgl : {
* alpha : false,
* depth : true,
* stencil : false,
* antialias : true,
* premultipliedAlpha : true,
* preserveDrawingBuffer : false,
* failIfMajorPerformanceCaveat : false
* },
* allowTextureFilterAnisotropic : true
* }
* </code>
* </p>
* <p>
* The <code>webgl</code> property corresponds to the {@link http://www.khronos.org/registry/webgl/specs/latest/#5.2|WebGLContextAttributes}
* object used to create the WebGL context.
* </p>
* <p>
* <code>webgl.alpha</code> defaults to false, which can improve performance compared to the standard WebGL default
* of true. If an application needs to composite Cesium above other HTML elements using alpha-blending, set
* <code>webgl.alpha</code> to true.
* </p>
* <p>
* The other <code>webgl</code> properties match the WebGL defaults for {@link http://www.khronos.org/registry/webgl/specs/latest/#5.2|WebGLContextAttributes}.
* </p>
* <p>
* <code>allowTextureFilterAnisotropic</code> defaults to true, which enables anisotropic texture filtering when the
* WebGL extension is supported. Setting this to false will improve performance, but hurt visual quality, especially for horizon views.
* </p>
*
* @alias Scene
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Canvas} options.canvas The HTML canvas element to create the scene for.
* @param {Object} [options.contextOptions] Context and WebGL creation properties. See details above.
* @param {Element} [options.creditContainer] The HTML element in which the credits will be displayed.
* @param {MapProjection} [options.mapProjection=new GeographicProjection()] The map projection to use in 2D and Columbus View modes.
* @param {Boolean} [options.orderIndependentTranslucency=true] If true and the configuration supports it, use order independent translucency.
* @param {Boolean} [options.scene3DOnly=false] If true, optimizes memory use and performance for 3D mode but disables the ability to use 2D or Columbus View.
* @param {Number} [options.terrainExaggeration=1.0] A scalar used to exaggerate the terrain. Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
* @param {Boolean} [options.shadows=false] Determines if shadows are cast by the sun.
* @param {MapMode2D} [options.mapMode2D=MapMode2D.INFINITE_SCROLL] Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
*
* @see CesiumWidget
* @see {@link http://www.khronos.org/registry/webgl/specs/latest/#5.2|WebGLContextAttributes}
*
* @exception {DeveloperError} options and options.canvas are required.
*
* @example
* // Create scene without anisotropic texture filtering
* var scene = new Cesium.Scene({
* canvas : canvas,
* contextOptions : {
* allowTextureFilterAnisotropic : false
* }
* });
*/
function Scene(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var canvas = options.canvas;
var contextOptions = options.contextOptions;
var creditContainer = options.creditContainer;
if (!defined(canvas)) {
throw new DeveloperError('options and options.canvas are required.');
}
var context = new Context(canvas, contextOptions);
if (!defined(creditContainer)) {
creditContainer = document.createElement('div');
creditContainer.style.position = 'absolute';
creditContainer.style.bottom = '0';
creditContainer.style['text-shadow'] = '0 0 2px #000000';
creditContainer.style.color = '#ffffff';
creditContainer.style['font-size'] = '10px';
creditContainer.style['padding-right'] = '5px';
canvas.parentNode.appendChild(creditContainer);
}
this._id = createGuid();
this._frameState = new FrameState(context, new CreditDisplay(creditContainer));
this._frameState.scene3DOnly = defaultValue(options.scene3DOnly, false);
var ps = new PassState(context);
ps.viewport = new BoundingRectangle();
ps.viewport.x = 0;
ps.viewport.y = 0;
ps.viewport.width = context.drawingBufferWidth;
ps.viewport.height = context.drawingBufferHeight;
this._passState = ps;
this._canvas = canvas;
this._context = context;
this._computeEngine = new ComputeEngine(context);
this._globe = undefined;
this._primitives = new PrimitiveCollection();
this._groundPrimitives = new PrimitiveCollection();
this._tweens = new TweenCollection();
this._shaderFrameCount = 0;
this._sunPostProcess = undefined;
this._computeCommandList = [];
this._frustumCommandsList = [];
this._overlayCommandList = [];
this._pickFramebuffer = undefined;
this._useOIT = defaultValue(options.orderIndependentTranslucency, true);
this._executeOITFunction = undefined;
var globeDepth;
if (context.depthTexture) {
globeDepth = new GlobeDepth();
}
var oit;
if (this._useOIT && defined(globeDepth)) {
oit = new OIT(context);
}
this._globeDepth = globeDepth;
this._depthPlane = new DepthPlane();
this._oit = oit;
this._fxaa = new FXAA();
this._clearColorCommand = new ClearCommand({
color : new Color(),
stencil : 0,
owner : this
});
this._depthClearCommand = new ClearCommand({
depth : 1.0,
owner : this
});
this._stencilClearCommand = new ClearCommand({
stencil : 0
});
this._pickDepths = [];
this._debugGlobeDepths = [];
this._transitioner = new SceneTransitioner(this);
this._renderError = new Event();
this._preRender = new Event();
this._postRender = new Event();
this._cameraStartFired = false;
this._cameraMovedTime = undefined;
/**
* Exceptions occurring in <code>render</code> are always caught in order to raise the
* <code>renderError</code> event. If this property is true, the error is rethrown
* after the event is raised. If this property is false, the <code>render</code> function
* returns normally after raising the event.
*
* @type {Boolean}
* @default false
*/
this.rethrowRenderErrors = false;
/**
* Determines whether or not to instantly complete the
* scene transition animation on user input.
*
* @type {Boolean}
* @default true
*/
this.completeMorphOnUserInput = true;
/**
* The event fired at the beginning of a scene transition.
* @type {Event}
* @default Event()
*/
this.morphStart = new Event();
/**
* The event fired at the completion of a scene transition.
* @type {Event}
* @default Event()
*/
this.morphComplete = new Event();
/**
* The {@link SkyBox} used to draw the stars.
*
* @type {SkyBox}
* @default undefined
*
* @see Scene#backgroundColor
*/
this.skyBox = undefined;
/**
* The sky atmosphere drawn around the globe.
*
* @type {SkyAtmosphere}
* @default undefined
*/
this.skyAtmosphere = undefined;
/**
* The {@link Sun}.
*
* @type {Sun}
* @default undefined
*/
this.sun = undefined;
/**
* Uses a bloom filter on the sun when enabled.
*
* @type {Boolean}
* @default true
*/
this.sunBloom = true;
this._sunBloom = undefined;
/**
* The {@link Moon}
*
* @type Moon
* @default undefined
*/
this.moon = undefined;
/**
* The background color, which is only visible if there is no sky box, i.e., {@link Scene#skyBox} is undefined.
*
* @type {Color}
* @default {@link Color.BLACK}
*
* @see Scene#skyBox
*/
this.backgroundColor = Color.clone(Color.BLACK);
this._mode = SceneMode.SCENE3D;
this._mapProjection = defined(options.mapProjection) ? options.mapProjection : new GeographicProjection();
/**
* The current morph transition time between 2D/Columbus View and 3D,
* with 0.0 being 2D or Columbus View and 1.0 being 3D.
*
* @type {Number}
* @default 1.0
*/
this.morphTime = 1.0;
/**
* The far-to-near ratio of the multi-frustum. The default is 1,000.0.
*
* @type {Number}
* @default 1000.0
*/
this.farToNearRatio = 1000.0;
/**
* Determines the uniform depth size in meters of each frustum of the multifrustum in 2D. If a primitive or model close
* to the surface shows z-fighting, decreasing this will eliminate the artifact, but decrease performance. On the
* other hand, increasing this will increase performance but may cause z-fighting among primitives close to thesurface.
* @type {Number}
* @default 1.75e6
*/
this.nearToFarDistance2D = 1.75e6;
/**
* This property is for debugging only; it is not for production use.
* <p>
* A function that determines what commands are executed. As shown in the examples below,
* the function receives the command's <code>owner</code> as an argument, and returns a boolean indicating if the
* command should be executed.
* </p>
* <p>
* The default is <code>undefined</code>, indicating that all commands are executed.
* </p>
*
* @type Function
*
* @default undefined
*
* @example
* // Do not execute any commands.
* scene.debugCommandFilter = function(command) {
* return false;
* };
*
* // Execute only the billboard's commands. That is, only draw the billboard.
* var billboards = new Cesium.BillboardCollection();
* scene.debugCommandFilter = function(command) {
* return command.owner === billboards;
* };
*/
this.debugCommandFilter = undefined;
/**
* This property is for debugging only; it is not for production use.
* <p>
* When <code>true</code>, commands are randomly shaded. This is useful
* for performance analysis to see what parts of a scene or model are
* command-dense and could benefit from batching.
* </p>
*
* @type Boolean
*
* @default false
*/
this.debugShowCommands = false;
/**
* This property is for debugging only; it is not for production use.
* <p>
* When <code>true</code>, commands are shaded based on the frustums they
* overlap. Commands in the closest frustum are tinted red, commands in
* the next closest are green, and commands in the farthest frustum are
* blue. If a command overlaps more than one frustum, the color components
* are combined, e.g., a command overlapping the first two frustums is tinted
* yellow.
* </p>
*
* @type Boolean
*
* @default false
*/
this.debugShowFrustums = false;
this._debugFrustumStatistics = undefined;
/**
* This property is for debugging only; it is not for production use.
* <p>
* Displays frames per second and time between frames.
* </p>
*
* @type Boolean
*
* @default false
*/
this.debugShowFramesPerSecond = false;
/**
* This property is for debugging only; it is not for production use.
* <p>
* Displays depth information for the indicated frustum.
* </p>
*
* @type Boolean
*
* @default false
*/
this.debugShowGlobeDepth = false;
/**
* This property is for debugging only; it is not for production use.
* <p>
* Indicates which frustum will have depth information displayed.
* </p>
*
* @type Number
*
* @default 1
*/
this.debugShowDepthFrustum = 1;
/**
* When <code>true</code>, enables Fast Approximate Anti-aliasing even when order independent translucency
* is unsupported.
*
* @type Boolean
* @default true
*/
this.fxaa = true;
/**
* When <code>true</code>, enables picking using the depth buffer.
*
* @type Boolean
* @default true
*/
this.useDepthPicking = true;
/**
* The time in milliseconds to wait before checking if the camera has not moved and fire the cameraMoveEnd event.
* @type {Number}
* @default 500.0
* @private
*/
this.cameraEventWaitTime = 500.0;
/**
* Set to true to copy the depth texture after rendering the globe. Makes czm_globeDepthTexture valid.
* @type {Boolean}
* @default false
* @private
*/
this.copyGlobeDepth = false;
/**
* Blends the atmosphere to geometry far from the camera for horizon views. Allows for additional
* performance improvements by rendering less geometry and dispatching less terrain requests.
* @type {Fog}
*/
this.fog = new Fog();
this._sunCamera = new Camera(this);
/**
* The shadow map in the scene. When enabled, models, primitives, and the globe may cast and receive shadows.
* By default the light source of the shadow map is the sun.
* @type {ShadowMap}
*/
this.shadowMap = new ShadowMap({
context : context,
lightCamera : this._sunCamera,
enabled : defaultValue(options.shadows, false)
});
this._terrainExaggeration = defaultValue(options.terrainExaggeration, 1.0);
this._performanceDisplay = undefined;
this._debugVolume = undefined;
var camera = new Camera(this);
this._camera = camera;
this._cameraClone = Camera.clone(camera);
this._screenSpaceCameraController = new ScreenSpaceCameraController(this);
this._mapMode2D = defaultValue(options.mapMode2D, MapMode2D.INFINITE_SCROLL);
// Keeps track of the state of a frame. FrameState is the state across
// the primitives of the scene. This state is for internally keeping track
// of celestial and environment effects that need to be updated/rendered in
// a certain order as well as updating/tracking framebuffer usage.
this._environmentState = {
skyBoxCommand : undefined,
skyAtmosphereCommand : undefined,
sunDrawCommand : undefined,
sunComputeCommand : undefined,
moonCommand : undefined,
isSunVisible : false,
isMoonVisible : false,
isReadyForAtmosphere : false,
isSkyAtmosphereVisible : false,
clearGlobeDepth : false,
useDepthPlane : false,
originalFramebuffer : undefined,
useGlobeDepthFramebuffer : false,
useOIT : false,
useFXAA : false
};
this._useWebVR = false;
this._cameraVR = undefined;
this._aspectRatioVR = undefined;
// initial guess at frustums.
var near = camera.frustum.near;
var far = camera.frustum.far;
var numFrustums = Math.ceil(Math.log(far / near) / Math.log(this.farToNearRatio));
updateFrustums(near, far, this.farToNearRatio, numFrustums, this._frustumCommandsList, false, undefined);
// give frameState, camera, and screen space camera controller initial state before rendering
updateFrameState(this, 0.0, JulianDate.now());
this.initializeFrame();
}
var OPAQUE_FRUSTUM_NEAR_OFFSET = 0.99;
defineProperties(Scene.prototype, {
/**
* Gets the canvas element to which this scene is bound.
* @memberof Scene.prototype
*
* @type {Canvas}
* @readonly
*/
canvas : {
get : function() {
return this._canvas;
}
},
/**
* The drawingBufferWidth of the underlying GL context.
* @memberof Scene.prototype
*
* @type {Number}
* @readonly
*
* @see {@link https://www.khronos.org/registry/webgl/specs/1.0/#DOM-WebGLRenderingContext-drawingBufferWidth|drawingBufferWidth}
*/
drawingBufferHeight : {
get : function() {
return this._context.drawingBufferHeight;
}
},
/**
* The drawingBufferHeight of the underlying GL context.
* @memberof Scene.prototype
*
* @type {Number}
* @readonly
*
* @see {@link https://www.khronos.org/registry/webgl/specs/1.0/#DOM-WebGLRenderingContext-drawingBufferHeight|drawingBufferHeight}
*/
drawingBufferWidth : {
get : function() {
return this._context.drawingBufferWidth;
}
},
/**
* The maximum aliased line width, in pixels, supported by this WebGL implementation. It will be at least one.
* @memberof Scene.prototype
*
* @type {Number}
* @readonly
*
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glGet.xml|glGet} with <code>ALIASED_LINE_WIDTH_RANGE</code>.
*/
maximumAliasedLineWidth : {
get : function() {
return ContextLimits.maximumAliasedLineWidth;
}
},
/**
* The maximum length in pixels of one edge of a cube map, supported by this WebGL implementation. It will be at least 16.
* @memberof Scene.prototype
*
* @type {Number}
* @readonly
*
* @see {@link https://www.khronos.org/opengles/sdk/docs/man/xhtml/glGet.xml|glGet} with <code>GL_MAX_CUBE_MAP_TEXTURE_SIZE</code>.
*/
maximumCubeMapSize : {
get : function() {
return ContextLimits.maximumCubeMapSize;
}
},
/**
* Returns true if the pickPosition function is supported.
* @memberof Scene.prototype
*
* @type {Boolean}
* @readonly
*/
pickPositionSupported : {
get : function() {
return this._context.depthTexture;
}
},
/**
* Gets or sets the depth-test ellipsoid.
* @memberof Scene.prototype
*
* @type {Globe}
*/
globe : {
get: function() {
return this._globe;
},
set: function(globe) {
this._globe = this._globe && this._globe.destroy();
this._globe = globe;
}
},
/**
* Gets the collection of primitives.
* @memberof Scene.prototype
*
* @type {PrimitiveCollection}
* @readonly
*/
primitives : {
get : function() {
return this._primitives;
}
},
/**
* Gets the collection of ground primitives.
* @memberof Scene.prototype
*
* @type {PrimitiveCollection}
* @readonly
*/
groundPrimitives : {
get : function() {
return this._groundPrimitives;
}
},
/**
* Gets the camera.
* @memberof Scene.prototype
*
* @type {Camera}
* @readonly
*/
camera : {
get : function() {
return this._camera;
}
},
// TODO: setCamera
/**
* Gets the controller for camera input handling.
* @memberof Scene.prototype
*
* @type {ScreenSpaceCameraController}
* @readonly
*/
screenSpaceCameraController : {
get : function() {
return this._screenSpaceCameraController;
}
},
/**
* Get the map projection to use in 2D and Columbus View modes.
* @memberof Scene.prototype
*
* @type {MapProjection}
* @readonly
*
* @default new GeographicProjection()
*/
mapProjection : {
get: function() {
return this._mapProjection;
}
},
/**
* Gets state information about the current scene. If called outside of a primitive's <code>update</code>
* function, the previous frame's state is returned.
* @memberof Scene.prototype
*
* @type {FrameState}
* @readonly
*
* @private
*/
frameState : {
get: function() {
return this._frameState;
}
},
/**
* Gets the collection of tweens taking place in the scene.
* @memberof Scene.prototype
*
* @type {TweenCollection}
* @readonly
*
* @private
*/
tweens : {
get : function() {
return this._tweens;
}
},
/**
* Gets the collection of image layers that will be rendered on the globe.
* @memberof Scene.prototype
*
* @type {ImageryLayerCollection}
* @readonly
*/
imageryLayers : {
get : function() {
return this.globe.imageryLayers;
}
},
/**
* The terrain provider providing surface geometry for the globe.
* @memberof Scene.prototype
*
* @type {TerrainProvider}
*/
terrainProvider : {
get : function() {
return this.globe.terrainProvider;
},
set : function(terrainProvider) {
this.globe.terrainProvider = terrainProvider;
}
},
/**
* Gets an event that's raised when the terrain provider is changed
* @memberof Scene.prototype
*
* @type {Event}
* @readonly
*/
terrainProviderChanged : {
get : function() {
return this.globe.terrainProviderChanged;
}
},
/**
* Gets the event that will be raised when an error is thrown inside the <code>render</code> function.
* The Scene instance and the thrown error are the only two parameters passed to the event handler.
* By default, errors are not rethrown after this event is raised, but that can be changed by setting
* the <code>rethrowRenderErrors</code> property.
* @memberof Scene.prototype
*
* @type {Event}
* @readonly
*/
renderError : {
get : function() {
return this._renderError;
}
},
/**
* Gets the event that will be raised at the start of each call to <code>render</code>. Subscribers to the event
* receive the Scene instance as the first parameter and the current time as the second parameter.
* @memberof Scene.prototype
*
* @type {Event}
* @readonly
*/
preRender : {
get : function() {
return this._preRender;
}
},
/**
* Gets the event that will be raised at the end of each call to <code>render</code>. Subscribers to the event
* receive the Scene instance as the first parameter and the current time as the second parameter.
* @memberof Scene.prototype
*
* @type {Event}
* @readonly
*/
postRender : {
get : function() {
return this._postRender;
}
},
/**
* @memberof Scene.prototype
* @private
* @readonly
*/
context : {
get : function() {
return this._context;
}
},
/**
* This property is for debugging only; it is not for production use.
* <p>
* When {@link Scene.debugShowFrustums} is <code>true</code>, this contains
* properties with statistics about the number of command execute per frustum.
* <code>totalCommands</code> is the total number of commands executed, ignoring
* overlap. <code>commandsInFrustums</code> is an array with the number of times
* commands are executed redundantly, e.g., how many commands overlap two or
* three frustums.
* </p>
*
* @memberof Scene.prototype
*
* @type {Object}
* @readonly
*
* @default undefined
*/
debugFrustumStatistics : {
get : function() {
return this._debugFrustumStatistics;
}
},
/**
* Gets whether or not the scene is optimized for 3D only viewing.
* @memberof Scene.prototype
* @type {Boolean}
* @readonly
*/
scene3DOnly : {
get : function() {
return this._frameState.scene3DOnly;
}
},
/**
* Gets whether or not the scene has order independent translucency enabled.
* Note that this only reflects the original construction option, and there are
* other factors that could prevent OIT from functioning on a given system configuration.
* @memberof Scene.prototype
* @type {Boolean}
* @readonly
*/
orderIndependentTranslucency : {
get : function() {
return defined(this._oit);
}
},
/**
* Gets the unique identifier for this scene.
* @memberof Scene.prototype
* @type {String}
* @readonly
*/
id : {
get : function() {
return this._id;
}
},
/**
* Gets or sets the current mode of the scene.
* @memberof Scene.prototype
* @type {SceneMode}
* @default {@link SceneMode.SCENE3D}
*/
mode : {
get : function() {
return this._mode;
},
set : function(value) {
if (this.scene3DOnly && value !== SceneMode.SCENE3D) {
throw new DeveloperError('Only SceneMode.SCENE3D is valid when scene3DOnly is true.');
}
if (value === SceneMode.SCENE2D) {
this.morphTo2D(0);
} else if (value === SceneMode.SCENE3D) {
this.morphTo3D(0);
} else if (value === SceneMode.COLUMBUS_VIEW) {
this.morphToColumbusView(0);
} else {
throw new DeveloperError('value must be a valid SceneMode enumeration.');
}
this._mode = value;
}
},
/**
* Gets the number of frustums used in the last frame.
* @memberof Scene.prototype
* @type {Number}
*
* @private
*/
numberOfFrustums : {
get : function() {
return this._frustumCommandsList.length;
}
},
/**
* Gets the scalar used to exaggerate the terrain.
* @memberof Scene.prototype
* @type {Number}
*/
terrainExaggeration : {
get : function() {
return this._terrainExaggeration;
}
},
/**
* When <code>true</code>, splits the scene into two viewports with steroscopic views for the left and right eyes.
* Used for cardboard and WebVR.
* @memberof Scene.prototype
* @type {Boolean}
* @default false
*/
useWebVR : {
get : function() {
return this._useWebVR;
},
set : function(value) {
this._useWebVR = value;
if (this._useWebVR) {
this._frameState.creditDisplay.container.style.visibility = 'hidden';
this._cameraVR = new Camera(this);
if (!defined(this._deviceOrientationCameraController)) {
this._deviceOrientationCameraController = new DeviceOrientationCameraController(this);
}
this._aspectRatioVR = this._camera.frustum.aspectRatio;
} else {
this._frameState.creditDisplay.container.style.visibility = 'visible';
this._cameraVR = undefined;
this._deviceOrientationCameraController = this._deviceOrientationCameraController && !this._deviceOrientationCameraController.isDestroyed() && this._deviceOrientationCameraController.destroy();
this._camera.frustum.aspectRatio = this._aspectRatioVR;
this._camera.frustum.xOffset = 0.0;
}
}
},
/**
* Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
* @memberof Scene.prototype
* @type {Boolean}
*/
mapMode2D : {
get : function() {
return this._mapMode2D;
}
}
});
var scratchPosition0 = new Cartesian3();
var scratchPosition1 = new Cartesian3();
function maxComponent(a, b) {
var x = Math.max(Math.abs(a.x), Math.abs(b.x));
var y = Math.max(Math.abs(a.y), Math.abs(b.y));
var z = Math.max(Math.abs(a.z), Math.abs(b.z));
return Math.max(Math.max(x, y), z);
}
function cameraEqual(camera0, camera1, epsilon) {
var scalar = 1 / Math.max(1, maxComponent(camera0.position, camera1.position));
Cartesian3.multiplyByScalar(camera0.position, scalar, scratchPosition0);
Cartesian3.multiplyByScalar(camera1.position, scalar, scratchPosition1);
return Cartesian3.equalsEpsilon(scratchPosition0, scratchPosition1, epsilon) &&
Cartesian3.equalsEpsilon(camera0.direction, camera1.direction, epsilon) &&
Cartesian3.equalsEpsilon(camera0.up, camera1.up, epsilon) &&
Cartesian3.equalsEpsilon(camera0.right, camera1.right, epsilon) &&
Matrix4.equalsEpsilon(camera0.transform, camera1.transform, epsilon);
}
function updateDerivedCommands(scene, command) {
var frameState = scene.frameState;
var context = scene._context;
var shadowsEnabled = frameState.shadowHints.shadowsEnabled;
var shadowMaps = frameState.shadowHints.shadowMaps;
var lightShadowMaps = frameState.shadowHints.lightShadowMaps;
var lightShadowsEnabled = shadowsEnabled && (lightShadowMaps.length > 0);
// Update derived commands when any shadow maps become dirty
var shadowsDirty = false;
var lastDirtyTime = frameState.shadowHints.lastDirtyTime;
if (command.lastDirtyTime !== lastDirtyTime) {
command.lastDirtyTime = lastDirtyTime;
command.dirty = true;
shadowsDirty = true;
}
if (command.dirty) {
command.dirty = false;
var derivedCommands = command.derivedCommands;
if (shadowsEnabled && (command.receiveShadows || command.castShadows)) {
derivedCommands.shadows = ShadowMap.createDerivedCommands(shadowMaps, lightShadowMaps, command, shadowsDirty, context, derivedCommands.shadows);
}
var oit = scene._oit;
if (command.pass === Pass.TRANSLUCENT && defined(oit) && oit.isSupported()) {
if (lightShadowsEnabled && command.receiveShadows) {
derivedCommands.oit = defined(derivedCommands.oit) ? derivedCommands.oit : {};
derivedCommands.oit.shadows = oit.createDerivedCommands(command.derivedCommands.shadows.receiveCommand, context, derivedCommands.oit.shadows);
} else {
derivedCommands.oit = oit.createDerivedCommands(command, context, derivedCommands.oit);
}
}
}
}
var scratchOccluderBoundingSphere = new BoundingSphere();
var scratchOccluder;
function getOccluder(scene) {
// TODO: The occluder is the top-level globe. When we add
// support for multiple central bodies, this should be the closest one.
var globe = scene.globe;
if (scene._mode === SceneMode.SCENE3D && defined(globe)) {
var ellipsoid = globe.ellipsoid;
scratchOccluderBoundingSphere.radius = ellipsoid.minimumRadius;
scratchOccluder = Occluder.fromBoundingSphere(scratchOccluderBoundingSphere, scene._camera.positionWC, scratchOccluder);
return scratchOccluder;
}
return undefined;
}
function clearPasses(passes) {
passes.render = false;
passes.pick = false;
}
function updateFrameState(scene, frameNumber, time) {
var camera = scene._camera;
var frameState = scene._frameState;
frameState.commandList.length = 0;
frameState.shadowMaps.length = 0;
frameState.mode = scene._mode;
frameState.morphTime = scene.morphTime;
frameState.mapProjection = scene.mapProjection;
frameState.frameNumber = frameNumber;
frameState.time = JulianDate.clone(time, frameState.time);
frameState.camera = camera;
frameState.cullingVolume = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
frameState.occluder = getOccluder(scene);
frameState.terrainExaggeration = scene._terrainExaggeration;
clearPasses(frameState.passes);
}
function updateFrustums(near, far, farToNearRatio, numFrustums, frustumCommandsList, is2D, nearToFarDistance2D) {
frustumCommandsList.length = numFrustums;
for (var m = 0; m < numFrustums; ++m) {
var curNear;
var curFar;
if (!is2D) {
curNear = Math.max(near, Math.pow(farToNearRatio, m) * near);
curFar = Math.min(far, farToNearRatio * curNear);
} else {
curNear = Math.min(far - nearToFarDistance2D, near + m * nearToFarDistance2D);
curFar = Math.min(far, curNear + nearToFarDistance2D);
}
var frustumCommands = frustumCommandsList[m];
if (!defined(frustumCommands)) {
frustumCommands = frustumCommandsList[m] = new FrustumCommands(curNear, curFar);
} else {
frustumCommands.near = curNear;
frustumCommands.far = curFar;
}
}
}
function insertIntoBin(scene, command, distance) {
if (scene.debugShowFrustums) {
command.debugOverlappingFrustums = 0;
}
if (!scene.frameState.passes.pick) {
updateDerivedCommands(scene, command);
}
var frustumCommandsList = scene._frustumCommandsList;
var length = frustumCommandsList.length;
for (var i = 0; i < length; ++i) {
var frustumCommands = frustumCommandsList[i];
var curNear = frustumCommands.near;
var curFar = frustumCommands.far;
if (distance.start > curFar) {
continue;
}
if (distance.stop < curNear) {
break;
}
var pass = command instanceof ClearCommand ? Pass.OPAQUE : command.pass;
var index = frustumCommands.indices[pass]++;
frustumCommands.commands[pass][index] = command;
if (scene.debugShowFrustums) {
command.debugOverlappingFrustums |= (1 << i);
}
if (command.executeInClosestFrustum) {
break;
}
}
if (scene.debugShowFrustums) {
var cf = scene._debugFrustumStatistics.commandsInFrustums;
cf[command.debugOverlappingFrustums] = defined(cf[command.debugOverlappingFrustums]) ? cf[command.debugOverlappingFrustums] + 1 : 1;
++scene._debugFrustumStatistics.totalCommands;
}
}
var scratchCullingVolume = new CullingVolume();
var distances = new Interval();
function isVisible(command, cullingVolume, occluder) {
return ((defined(command)) &&
((!defined(command.boundingVolume)) ||
!command.cull ||
((cullingVolume.computeVisibility(command.boundingVolume) !== Intersect.OUTSIDE) &&
(!defined(occluder) || !command.boundingVolume.isOccluded(occluder)))));
}
function createPotentiallyVisibleSet(scene) {
var frameState = scene._frameState;
var camera = frameState.camera;
var direction = camera.directionWC;
var position = camera.positionWC;
var computeList = scene._computeCommandList;
var overlayList = scene._overlayCommandList;
var commandList = frameState.commandList;
if (scene.debugShowFrustums) {
scene._debugFrustumStatistics = {
totalCommands : 0,
commandsInFrustums : {}
};
}
var frustumCommandsList = scene._frustumCommandsList;
var numberOfFrustums = frustumCommandsList.length;
var numberOfPasses = Pass.NUMBER_OF_PASSES;
for (var n = 0; n < numberOfFrustums; ++n) {
for (var p = 0; p < numberOfPasses; ++p) {
frustumCommandsList[n].indices[p] = 0;
}
}
computeList.length = 0;
overlayList.length = 0;
var near = Number.MAX_VALUE;
var far = -Number.MAX_VALUE;
var undefBV = false;
var shadowsEnabled = frameState.shadowHints.shadowsEnabled;
var shadowNear = Number.MAX_VALUE;
var shadowFar = -Number.MAX_VALUE;
var shadowClosestObjectSize = Number.MAX_VALUE;
var occluder = (frameState.mode === SceneMode.SCENE3D) ? frameState.occluder: undefined;
var cullingVolume = frameState.cullingVolume;
// get user culling volume minus the far plane.
var planes = scratchCullingVolume.planes;
for (var k = 0; k < 5; ++k) {
planes[k] = cullingVolume.planes[k];
}
cullingVolume = scratchCullingVolume;
// Determine visibility of celestial and terrestrial environment effects.
var environmentState = scene._environmentState;
environmentState.isSkyAtmosphereVisible = defined(environmentState.skyAtmosphereCommand) && environmentState.isReadyForAtmosphere;
environmentState.isSunVisible = isVisible(environmentState.sunDrawCommand, cullingVolume, occluder);
environmentState.isMoonVisible = isVisible(environmentState.moonCommand, cullingVolume, occluder);
var length = commandList.length;
for (var i = 0; i < length; ++i) {
var command = commandList[i];
var pass = command.pass;
if (pass === Pass.COMPUTE) {
computeList.push(command);
} else if (pass === Pass.OVERLAY) {
overlayList.push(command);
} else {
var boundingVolume = command.boundingVolume;
if (defined(boundingVolume)) {
if (!isVisible(command, cullingVolume, occluder)) {
continue;
}
distances = boundingVolume.computePlaneDistances(position, direction, distances);
near = Math.min(near, distances.start);
far = Math.max(far, distances.stop);
// Compute a tight near and far plane for commands that receive shadows. This helps compute
// good splits for cascaded shadow maps. Ignore commands that exceed the maximum distance.
// When moving the camera low LOD globe tiles begin to load, whose bounding volumes
// throw off the near/far fitting for the shadow map. Only update for globe tiles that the
// camera isn't inside.
if (shadowsEnabled && command.receiveShadows && (distances.start < ShadowMap.MAXIMUM_DISTANCE) &&
!((pass === Pass.GLOBE) && (distances.start < -100.0) && (distances.stop > 100.0))) {
// Get the smallest bounding volume the camera is near. This is used to place more shadow detail near the object.
var size = distances.stop - distances.start;
if ((pass !== Pass.GLOBE) && (distances.start < 100.0)) {
shadowClosestObjectSize = Math.min(shadowClosestObjectSize, size);
}
shadowNear = Math.min(shadowNear, distances.start);
shadowFar = Math.max(shadowFar, distances.stop);
}
} else {
// Clear commands don't need a bounding volume - just add the clear to all frustums.
// If another command has no bounding volume, though, we need to use the camera's
// worst-case near and far planes to avoid clipping something important.
distances.start = camera.frustum.near;
distances.stop = camera.frustum.far;
undefBV = !(command instanceof ClearCommand);
}
insertIntoBin(scene, command, distances);
}
}
if (undefBV) {
near = camera.frustum.near;
far = camera.frustum.far;
} else {
// The computed near plane must be between the user defined near and far planes.
// The computed far plane must between the user defined far and computed near.
// This will handle the case where the computed near plane is further than the user defined far plane.
near = Math.min(Math.max(near, camera.frustum.near), camera.frustum.far);
far = Math.max(Math.min(far, camera.frustum.far), near);
if (shadowsEnabled) {
shadowNear = Math.min(Math.max(shadowNear, camera.frustum.near), camera.frustum.far);
shadowFar = Math.max(Math.min(shadowFar, camera.frustum.far), shadowNear);
}
}
// Use the computed near and far for shadows
if (shadowsEnabled) {
frameState.shadowHints.nearPlane = shadowNear;
frameState.shadowHints.farPlane = shadowFar;
frameState.shadowHints.closestObjectSize = shadowClosestObjectSize;
}
// Exploit temporal coherence. If the frustums haven't changed much, use the frustums computed
// last frame, else compute the new frustums and sort them by frustum again.
var is2D = scene.mode === SceneMode.SCENE2D;
var farToNearRatio = scene.farToNearRatio;
var numFrustums;
if (!is2D) {
// The multifrustum for 3D/CV is non-uniformly distributed.
numFrustums = Math.ceil(Math.log(far / near) / Math.log(farToNearRatio));
} else {
// The multifrustum for 2D is uniformly distributed. To avoid z-fighting in 2D,
// the camera i smoved to just before the frustum and the frustum depth is scaled
// to be in [1.0, nearToFarDistance2D].
far = Math.min(far, camera.position.z + scene.nearToFarDistance2D);
near = Math.min(near, far);
numFrustums = Math.ceil(Math.max(1.0, far - near) / scene.nearToFarDistance2D);
}
if (near !== Number.MAX_VALUE && (numFrustums !== numberOfFrustums || (frustumCommandsList.length !== 0 &&
(near < frustumCommandsList[0].near || far > frustumCommandsList[numberOfFrustums - 1].far)))) {
updateFrustums(near, far, farToNearRatio, numFrustums, frustumCommandsList, is2D, scene.nearToFarDistance2D);
createPotentiallyVisibleSet(scene);
}
}
function getAttributeLocations(shaderProgram) {
var attributeLocations = {};
var attributes = shaderProgram.vertexAttributes;
for (var a in attributes) {
if (attributes.hasOwnProperty(a)) {
attributeLocations[a] = attributes[a].index;
}
}
return attributeLocations;
}
function createDebugFragmentShaderProgram(command, scene, shaderProgram) {
var context = scene.context;
var sp = defaultValue(shaderProgram, command.shaderProgram);
var fs = sp.fragmentShaderSource.clone();
fs.sources = fs.sources.map(function(source) {
source = ShaderSource.replaceMain(source, 'czm_Debug_main');
return source;
});
var newMain =
'void main() \n' +
'{ \n' +
' czm_Debug_main(); \n';
if (scene.debugShowCommands) {
if (!defined(command._debugColor)) {
command._debugColor = Color.fromRandom();
}
var c = command._debugColor;
newMain += ' gl_FragColor.rgb *= vec3(' + c.red + ', ' + c.green + ', ' + c.blue + '); \n';
}
if (scene.debugShowFrustums) {
// Support up to three frustums. If a command overlaps all
// three, it's code is not changed.
var r = (command.debugOverlappingFrustums & (1 << 0)) ? '1.0' : '0.0';
var g = (command.debugOverlappingFrustums & (1 << 1)) ? '1.0' : '0.0';
var b = (command.debugOverlappingFrustums & (1 << 2)) ? '1.0' : '0.0';
newMain += ' gl_FragColor.rgb *= vec3(' + r + ', ' + g + ', ' + b + '); \n';
}
newMain += '}';
fs.sources.push(newMain);
var attributeLocations = getAttributeLocations(sp);
return ShaderProgram.fromCache({
context : context,
vertexShaderSource : sp.vertexShaderSource,
fragmentShaderSource : fs,
attributeLocations : attributeLocations
});
}
function executeDebugCommand(command, scene, passState) {
var debugCommand = DrawCommand.shallowClone(command);
debugCommand.shaderProgram = createDebugFragmentShaderProgram(command, scene);
debugCommand.execute(scene.context, passState);
debugCommand.shaderProgram.destroy();
}
var transformFrom2D = new Matrix4(0.0, 0.0, 1.0, 0.0,
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 0.0, 1.0);
transformFrom2D = Matrix4.inverseTransformation(transformFrom2D, transformFrom2D);
function executeCommand(command, scene, context, passState, debugFramebuffer) {
if ((defined(scene.debugCommandFilter)) && !scene.debugCommandFilter(command)) {
return;
}
var shadowsEnabled = scene.frameState.shadowHints.shadowsEnabled;
var lightShadowsEnabled = shadowsEnabled && (scene.frameState.shadowHints.lightShadowMaps.length > 0);
if (scene.debugShowCommands || scene.debugShowFrustums) {
executeDebugCommand(command, scene, passState);
} else if (lightShadowsEnabled && command.receiveShadows && defined(command.derivedCommands.shadows)) {
// If the command receives shadows, execute the derived shadows command.
// Some commands, such as OIT derived commands, do not have derived shadow commands themselves
// and instead shadowing is built-in. In this case execute the command regularly below.
command.derivedCommands.shadows.receiveCommand.execute(context, passState);
} else {
command.execute(context, passState);
}
if (command.debugShowBoundingVolume && (defined(command.boundingVolume))) {
// Debug code to draw bounding volume for command. Not optimized!
// Assumes bounding volume is a bounding sphere or box
var frameState = scene._frameState;
var boundingVolume = command.boundingVolume;
if (defined(scene._debugVolume)) {
scene._debugVolume.destroy();
}
var geometry;
var center = Cartesian3.clone(boundingVolume.center);
if (frameState.mode !== SceneMode.SCENE3D) {
center = Matrix4.multiplyByPoint(transformFrom2D, center, center);
var projection = frameState.mapProjection;
var centerCartographic = projection.unproject(center);
center = projection.ellipsoid.cartographicToCartesian(centerCartographic);
}
if (defined(boundingVolume.radius)) {
var radius = boundingVolume.radius;
geometry = GeometryPipeline.toWireframe(EllipsoidGeometry.createGeometry(new EllipsoidGeometry({
radii : new Cartesian3(radius, radius, radius),
vertexFormat : PerInstanceColorAppearance.FLAT_VERTEX_FORMAT
})));
scene._debugVolume = new Primitive({
geometryInstances : new GeometryInstance({
geometry : geometry,
modelMatrix : Matrix4.multiplyByTranslation(Matrix4.IDENTITY, center, new Matrix4()),
attributes : {
color : new ColorGeometryInstanceAttribute(1.0, 0.0, 0.0, 1.0)
}
}),
appearance : new PerInstanceColorAppearance({
flat : true,
translucent : false
}),
asynchronous : false
});
} else {
var halfAxes = boundingVolume.halfAxes;
geometry = GeometryPipeline.toWireframe(BoxGeometry.createGeometry(BoxGeometry.fromDimensions({
dimensions : new Cartesian3(2.0, 2.0, 2.0),
vertexFormat : PerInstanceColorAppearance.FLAT_VERTEX_FORMAT
})));
scene._debugVolume = new Primitive({
geometryInstances : new GeometryInstance({
geometry : geometry,
modelMatrix : Matrix4.fromRotationTranslation(halfAxes, center, new Matrix4()),
attributes : {
color : new ColorGeometryInstanceAttribute(1.0, 0.0, 0.0, 1.0)
}
}),
appearance : new PerInstanceColorAppearance({
flat : true,
translucent : false
}),
asynchronous : false
});
}
var savedCommandList = frameState.commandList;
var commandList = frameState.commandList = [];
scene._debugVolume.update(frameState);
var framebuffer;
if (defined(debugFramebuffer)) {
framebuffer = passState.framebuffer;
passState.framebuffer = debugFramebuffer;
}
commandList[0].execute(context, passState);
if (defined(framebuffer)) {
passState.framebuffer = framebuffer;
}
frameState.commandList = savedCommandList;
}
}
function translucentCompare(a, b, position) {
return b.boundingVolume.distanceSquaredTo(position) - a.boundingVolume.distanceSquaredTo(position);
}
function executeTranslucentCommandsSorted(scene, executeFunction, passState, commands) {
var context = scene.context;
mergeSort(commands, translucentCompare, scene._camera.positionWC);
var length = commands.length;
for (var j = 0; j < length; ++j) {
executeFunction(commands[j], scene, context, passState);
}
}
function getDebugGlobeDepth(scene, index) {
var globeDepth = scene._debugGlobeDepths[index];
if (!defined(globeDepth) && scene.context.depthTexture) {
globeDepth = new GlobeDepth();
scene._debugGlobeDepths[index] = globeDepth;
}
return globeDepth;
}
function getPickDepth(scene, index) {
var pickDepth = scene._pickDepths[index];
if (!defined(pickDepth)) {
pickDepth = new PickDepth();
scene._pickDepths[index] = pickDepth;
}
return pickDepth;
}
var scratchPerspectiveFrustum = new PerspectiveFrustum();
var scratchPerspectiveOffCenterFrustum = new PerspectiveOffCenterFrustum();
var scratchOrthographicFrustum = new OrthographicFrustum();
function executeCommands(scene, passState) {
var camera = scene._camera;
var context = scene.context;
var us = context.uniformState;
us.updateCamera(camera);
// Create a working frustum from the original camera frustum.
var frustum;
if (defined(camera.frustum.fov)) {
frustum = camera.frustum.clone(scratchPerspectiveFrustum);
} else if (defined(camera.frustum.infiniteProjectionMatrix)){
frustum = camera.frustum.clone(scratchPerspectiveOffCenterFrustum);
} else {
frustum = camera.frustum.clone(scratchOrthographicFrustum);
}
// Ideally, we would render the sky box and atmosphere last for
// early-z, but we would have to draw it in each frustum
frustum.near = camera.frustum.near;
frustum.far = camera.frustum.far;
us.updateFrustum(frustum);
us.updatePass(Pass.ENVIRONMENT);
var environmentState = scene._environmentState;
var skyBoxCommand = environmentState.skyBoxCommand;
if (defined(skyBoxCommand)) {
executeCommand(skyBoxCommand, scene, context, passState);
}
if (environmentState.isSkyAtmosphereVisible) {
executeCommand(environmentState.skyAtmosphereCommand, scene, context, passState);
}
var useWebVR = scene._useWebVR && scene.mode !== SceneMode.SCENE2D;
if (environmentState.isSunVisible) {
environmentState.sunDrawCommand.execute(context, passState);
if (scene.sunBloom && !useWebVR) {
var framebuffer;
if (environmentState.useGlobeDepthFramebuffer) {
framebuffer = scene._globeDepth.framebuffer;
} else if (environmentState.useFXAA) {
framebuffer = scene._fxaa.getColorFramebuffer();
} else {
framebuffer = environmentState.originalFramebuffer;
}
scene._sunPostProcess.execute(context, framebuffer);
passState.framebuffer = framebuffer;
}
}
// Moon can be seen through the atmosphere, since the sun is rendered after the atmosphere.
if (environmentState.isMoonVisible) {
environmentState.moonCommand.execute(context, passState);
}
// Determine how translucent surfaces will be handled.
var executeTranslucentCommands;
if (environmentState.useOIT) {
if (!defined(scene._executeOITFunction)) {
scene._executeOITFunction = function(scene, executeFunction, passState, commands) {
scene._oit.executeCommands(scene, executeFunction, passState, commands);
};
}
executeTranslucentCommands = scene._executeOITFunction;
} else {
executeTranslucentCommands = executeTranslucentCommandsSorted;
}
var clearGlobeDepth = environmentState.clearGlobeDepth;
var useDepthPlane = environmentState.useDepthPlane;
var clearDepth = scene._depthClearCommand;
var depthPlane = scene._depthPlane;
var height2D = camera.position.z;
// Execute commands in each frustum in back to front order
var j;
var frustumCommandsList = scene._frustumCommandsList;
var numFrustums = frustumCommandsList.length;
for (var i = 0; i < numFrustums; ++i) {
var index = numFrustums - i - 1;
var frustumCommands = frustumCommandsList[index];
if (scene.mode === SceneMode.SCENE2D) {
// To avoid z-fighting in 2D, move the camera to just before the frustum
// and scale the frustum depth to be in [1.0, nearToFarDistance2D].
camera.position.z = height2D - frustumCommands.near + 1.0;
frustum.far = Math.max(1.0, frustumCommands.far - frustumCommands.near);
frustum.near = 1.0;
us.update(scene.frameState);
us.updateFrustum(frustum);
} else {
// Avoid tearing artifacts between adjacent frustums in the opaque passes
frustum.near = index !== 0 ? frustumCommands.near * OPAQUE_FRUSTUM_NEAR_OFFSET : frustumCommands.near;
frustum.far = frustumCommands.far;
us.updateFrustum(frustum);
}
var globeDepth = scene.debugShowGlobeDepth ? getDebugGlobeDepth(scene, index) : scene._globeDepth;
var fb;
if (scene.debugShowGlobeDepth && defined(globeDepth) && environmentState.useGlobeDepthFramebuffer) {
fb = passState.framebuffer;
passState.framebuffer = globeDepth.framebuffer;
}
clearDepth.execute(context, passState);
us.updatePass(Pass.GLOBE);
var commands = frustumCommands.commands[Pass.GLOBE];
var length = frustumCommands.indices[Pass.GLOBE];
for (j = 0; j < length; ++j) {
executeCommand(commands[j], scene, context, passState);
}
if (defined(globeDepth) && environmentState.useGlobeDepthFramebuffer && (scene.copyGlobeDepth || scene.debugShowGlobeDepth)) {
globeDepth.update(context);
globeDepth.executeCopyDepth(context, passState);
}
if (scene.debugShowGlobeDepth && defined(globeDepth) && environmentState.useGlobeDepthFramebuffer) {
passState.framebuffer = fb;
}
us.updatePass(Pass.GROUND);
commands = frustumCommands.commands[Pass.GROUND];
length = frustumCommands.indices[Pass.GROUND];
for (j = 0; j < length; ++j) {
executeCommand(commands[j], scene, context, passState);
}
// Clear the stencil after the ground pass
if (length > 0 && context.stencilBuffer) {
scene._stencilClearCommand.execute(context, passState);
}
if (clearGlobeDepth) {
clearDepth.execute(context, passState);
if (useDepthPlane) {
depthPlane.execute(context, passState);
}
}
// Execute commands in order by pass up to the translucent pass.
// Translucent geometry needs special handling (sorting/OIT).
var startPass = Pass.GROUND + 1;
var endPass = Pass.TRANSLUCENT;
for (var pass = startPass; pass < endPass; ++pass) {
us.updatePass(pass);
commands = frustumCommands.commands[pass];
length = frustumCommands.indices[pass];
for (j = 0; j < length; ++j) {
executeCommand(commands[j], scene, context, passState);
}
}
if (index !== 0 && scene.mode !== SceneMode.SCENE2D) {
// Do not overlap frustums in the translucent pass to avoid blending artifacts
frustum.near = frustumCommands.near;
us.updateFrustum(frustum);
}
us.updatePass(Pass.TRANSLUCENT);
commands = frustumCommands.commands[Pass.TRANSLUCENT];
commands.length = frustumCommands.indices[Pass.TRANSLUCENT];
executeTranslucentCommands(scene, executeCommand, passState, commands);
if (defined(globeDepth) && environmentState.useGlobeDepthFramebuffer && scene.useDepthPicking) {
// PERFORMANCE_IDEA: Use MRT to avoid the extra copy.
var pickDepth = getPickDepth(scene, index);
pickDepth.update(context, globeDepth.framebuffer.depthStencilTexture);
pickDepth.executeCopyDepth(context, passState);
}
}
}
function executeComputeCommands(scene) {
var us = scene.context.uniformState;
us.updatePass(Pass.COMPUTE);
var sunComputeCommand = scene._environmentState.sunComputeCommand;
if (defined(sunComputeCommand)) {
sunComputeCommand.execute(scene._computeEngine);
}
var commandList = scene._computeCommandList;
var length = commandList.length;
for (var i = 0; i < length; ++i) {
commandList[i].execute(scene._computeEngine);
}
}
function executeOverlayCommands(scene, passState) {
var us = scene.context.uniformState;
us.updatePass(Pass.OVERLAY);
var context = scene.context;
var commandList = scene._overlayCommandList;
var length = commandList.length;
for (var i = 0; i < length; ++i) {
commandList[i].execute(context, passState);
}
}
function insertShadowCastCommands(scene, commandList, shadowMap) {
var shadowVolume = shadowMap.shadowMapCullingVolume;
var isPointLight = shadowMap.isPointLight;
var passes = shadowMap.passes;
var numberOfPasses = passes.length;
var length = commandList.length;
for (var i = 0; i < length; ++i) {
var command = commandList[i];
updateDerivedCommands(scene, command);
if (command.castShadows && (command.pass === Pass.GLOBE || command.pass === Pass.OPAQUE || command.pass === Pass.TRANSLUCENT)) {
if (isVisible(command, shadowVolume)) {
if (isPointLight) {
for (var k = 0; k < numberOfPasses; ++k) {
passes[k].commandList.push(command);
}
} else if (numberOfPasses === 1) {
passes[0].commandList.push(command);
} else {
var wasVisible = false;
// Loop over cascades from largest to smallest
for (var j = numberOfPasses - 1; j >= 0; --j) {
var cascadeVolume = passes[j].cullingVolume;
if (isVisible(command, cascadeVolume)) {
passes[j].commandList.push(command);
wasVisible = true;
} else if (wasVisible) {
// If it was visible in the previous cascade but now isn't
// then there is no need to check any more cascades
break;
}
}
}
}
}
}
}
function executeShadowMapCastCommands(scene) {
var frameState = scene.frameState;
var shadowMaps = frameState.shadowHints.shadowMaps;
var shadowMapLength = shadowMaps.length;
if (!frameState.shadowHints.shadowsEnabled) {
return;
}
var context = scene.context;
var uniformState = context.uniformState;
for (var i = 0; i < shadowMapLength; ++i) {
var shadowMap = shadowMaps[i];
if (shadowMap.outOfView) {
continue;
}
// Reset the command lists
var j;
var passes = shadowMap.passes;
var numberOfPasses = passes.length;
for (j = 0; j < numberOfPasses; ++j) {
passes[j].commandList.length = 0;
}
// Insert the primitive/model commands into the command lists
var sceneCommands = scene.frameState.commandList;
insertShadowCastCommands(scene, sceneCommands, shadowMap);
for (j = 0; j < numberOfPasses; ++j) {
var pass = shadowMap.passes[j];
uniformState.updateCamera(pass.camera);
shadowMap.updatePass(context, j);
var numberOfCommands = pass.commandList.length;
for (var k = 0; k < numberOfCommands; ++k) {
var command = pass.commandList[k];
// Set the correct pass before rendering into the shadow map because some shaders
// conditionally render based on whether the pass is translucent or opaque.
uniformState.updatePass(command.pass);
executeCommand(command.derivedCommands.shadows.castCommands[i], scene, context, pass.passState);
}
}
}
}
function updateAndExecuteCommands(scene, passState, backgroundColor, picking) {
var context = scene._context;
var viewport = passState.viewport;
var frameState = scene._frameState;
var camera = frameState.camera;
var mode = frameState.mode;
if (scene._useWebVR && mode !== SceneMode.SCENE2D) {
updatePrimitives(scene);
createPotentiallyVisibleSet(scene);
updateAndClearFramebuffers(scene, passState, backgroundColor, picking);
executeComputeCommands(scene);
executeShadowMapCastCommands(scene);
// Based on Calculating Stereo pairs by Paul Bourke
// http://paulbourke.net/stereographics/stereorender/
viewport.x = 0;
viewport.y = 0;
viewport.width = context.drawingBufferWidth * 0.5;
viewport.height = context.drawingBufferHeight;
var savedCamera = Camera.clone(camera, scene._cameraVR);
var near = camera.frustum.near;
var fo = near * 5.0;
var eyeSeparation = fo / 30.0;
var eyeTranslation = Cartesian3.multiplyByScalar(savedCamera.right, eyeSeparation * 0.5, scratchEyeTranslation);
camera.frustum.aspectRatio = viewport.width / viewport.height;
var offset = 0.5 * eyeSeparation * near / fo;
Cartesian3.add(savedCamera.position, eyeTranslation, camera.position);
camera.frustum.xOffset = offset;
executeCommands(scene, passState);
viewport.x = passState.viewport.width;
Cartesian3.subtract(savedCamera.position, eyeTranslation, camera.position);
camera.frustum.xOffset = -offset;
executeCommands(scene, passState);
Camera.clone(savedCamera, camera);
} else {
viewport.x = 0;
viewport.y = 0;
viewport.width = context.drawingBufferWidth;
viewport.height = context.drawingBufferHeight;
if (mode !== SceneMode.SCENE2D || scene._mapMode2D === MapMode2D.ROTATE) {
executeCommandsInViewport(true, scene, passState, backgroundColor, picking);
} else {
execute2DViewportCommands(scene, passState, backgroundColor, picking);
}
}
}
var scratch2DViewportCartographic = new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO);
var scratch2DViewportMaxCoord = new Cartesian3();
var scratch2DViewportSavedPosition = new Cartesian3();
var scratch2DViewportTransform = new Matrix4();
var scratch2DViewportCameraTransform = new Matrix4();
var scratch2DViewportEyePoint = new Cartesian3();
var scratch2DViewportWindowCoords = new Cartesian3();
function execute2DViewportCommands(scene, passState, backgroundColor, picking) {
var context = scene.context;
var frameState = scene.frameState;
var camera = scene.camera;
var viewport = passState.viewport;
var maxCartographic = scratch2DViewportCartographic;
var maxCoord = scratch2DViewportMaxCoord;
var projection = scene.mapProjection;
projection.project(maxCartographic, maxCoord);
var position = Cartesian3.clone(camera.position, scratch2DViewportSavedPosition);
var transform = Matrix4.clone(camera.transform, scratch2DViewportCameraTransform);
var frustum = camera.frustum.clone();
camera._setTransform(Matrix4.IDENTITY);
var viewportTransformation = Matrix4.computeViewportTransformation(viewport, 0.0, 1.0, scratch2DViewportTransform);
var projectionMatrix = camera.frustum.projectionMatrix;
var x = camera.positionWC.y;
var eyePoint = Cartesian3.fromElements(CesiumMath.sign(x) * maxCoord.x - x, 0.0, -camera.positionWC.x, scratch2DViewportEyePoint);
var windowCoordinates = Transforms.pointToGLWindowCoordinates(projectionMatrix, viewportTransformation, eyePoint, scratch2DViewportWindowCoords);
windowCoordinates.x = Math.floor(windowCoordinates.x);
var viewportX = viewport.x;
var viewportWidth = viewport.width;
if (x === 0.0 || windowCoordinates.x <= 0.0 || windowCoordinates.x >= context.drawingBufferWidth) {
executeCommandsInViewport(true, scene, passState, backgroundColor, picking);
} else if (Math.abs(context.drawingBufferWidth * 0.5 - windowCoordinates.x) < 1.0) {
viewport.width = windowCoordinates.x;
camera.position.x *= CesiumMath.sign(camera.position.x);
camera.frustum.right = 0.0;
frameState.cullingVolume = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
context.uniformState.update(frameState);
executeCommandsInViewport(true, scene, passState, backgroundColor, picking);
viewport.x = viewport.width;
camera.position.x = -camera.position.x;
camera.frustum.right = -camera.frustum.left;
camera.frustum.left = 0.0;
frameState.cullingVolume = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
context.uniformState.update(frameState);
executeCommandsInViewport(false, scene, passState, backgroundColor, picking);
} else if (windowCoordinates.x > context.drawingBufferWidth * 0.5) {
viewport.width = windowCoordinates.x;
var right = camera.frustum.right;
camera.frustum.right = maxCoord.x - x;
frameState.cullingVolume = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
context.uniformState.update(frameState);
executeCommandsInViewport(true, scene, passState, backgroundColor, picking);
viewport.x += windowCoordinates.x;
viewport.width = context.drawingBufferWidth - windowCoordinates.x;
camera.position.x = -camera.position.x;
camera.frustum.left = -camera.frustum.right;
camera.frustum.right = right - camera.frustum.right * 2.0;
frameState.cullingVolume = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
context.uniformState.update(frameState);
executeCommandsInViewport(false, scene, passState, backgroundColor, picking);
} else {
viewport.x = windowCoordinates.x;
viewport.width = context.drawingBufferWidth - windowCoordinates.x;
var left = camera.frustum.left;
camera.frustum.left = -maxCoord.x - x;
frameState.cullingVolume = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
context.uniformState.update(frameState);
executeCommandsInViewport(true, scene, passState, backgroundColor, picking);
viewport.x = 0;
viewport.width = windowCoordinates.x;
camera.position.x = -camera.position.x;
camera.frustum.right = -camera.frustum.left;
camera.frustum.left = left - camera.frustum.left * 2.0;
frameState.cullingVolume = camera.frustum.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
context.uniformState.update(frameState);
executeCommandsInViewport(false, scene, passState, backgroundColor, picking);
}
camera._setTransform(transform);
Cartesian3.clone(position, camera.position);
camera.frustum = frustum.clone();
viewport.x = viewportX;
viewport.width = viewportWidth;
}
function executeCommandsInViewport(firstViewport, scene, passState, backgroundColor, picking) {
if (!firstViewport) {
scene.frameState.commandList.length = 0;
}
updatePrimitives(scene);
createPotentiallyVisibleSet(scene);
if (firstViewport) {
updateAndClearFramebuffers(scene, passState, backgroundColor, picking);
executeComputeCommands(scene);
executeShadowMapCastCommands(scene);
}
executeCommands(scene, passState);
}
function updateEnvironment(scene) {
var frameState = scene._frameState;
// Update celestial and terrestrial environment effects.
var environmentState = scene._environmentState;
var renderPass = frameState.passes.render;
environmentState.skyBoxCommand = (renderPass && defined(scene.skyBox)) ? scene.skyBox.update(frameState) : undefined;
var skyAtmosphere = scene.skyAtmosphere;
var globe = scene.globe;
if (defined(skyAtmosphere) && defined(globe)) {
skyAtmosphere.setDynamicAtmosphereColor(globe.enableLighting);
environmentState.isReadyForAtmosphere = environmentState.isReadyForAtmosphere || globe._surface._tilesToRender.length > 0;
}
environmentState.skyAtmosphereCommand = (renderPass && defined(skyAtmosphere)) ? skyAtmosphere.update(frameState) : undefined;
var sunCommands = (renderPass && defined(scene.sun)) ? scene.sun.update(scene) : undefined;
environmentState.sunDrawCommand = defined(sunCommands) ? sunCommands.drawCommand : undefined;
environmentState.sunComputeCommand = defined(sunCommands) ? sunCommands.computeCommand : undefined;
environmentState.moonCommand = (renderPass && defined(scene.moon)) ? scene.moon.update(frameState) : undefined;
var clearGlobeDepth = environmentState.clearGlobeDepth = defined(globe) && (!globe.depthTestAgainstTerrain || scene.mode === SceneMode.SCENE2D);
var useDepthPlane = environmentState.useDepthPlane = clearGlobeDepth && scene.mode === SceneMode.SCENE3D;
if (useDepthPlane) {
// Update the depth plane that is rendered in 3D when the primitives are
// not depth tested against terrain so primitives on the backface
// of the globe are not picked.
scene._depthPlane.update(frameState);
}
}
function updateShadowMaps(scene) {
var frameState = scene._frameState;
var shadowMaps = frameState.shadowMaps;
var length = shadowMaps.length;
var shadowsEnabled = (length > 0) && !frameState.passes.pick && (scene.mode === SceneMode.SCENE3D);
if (shadowsEnabled !== frameState.shadowHints.shadowsEnabled) {
// Update derived commands when shadowsEnabled changes
++frameState.shadowHints.lastDirtyTime;
frameState.shadowHints.shadowsEnabled = shadowsEnabled;
}
if (!shadowsEnabled) {
return;
}
// Check if the shadow maps are different than the shadow maps last frame.
// If so, the derived commands need to be updated.
for (var j = 0; j < length; ++j) {
if (shadowMaps[j] !== frameState.shadowHints.shadowMaps[j]) {
++frameState.shadowHints.lastDirtyTime;
break;
}
}
frameState.shadowHints.shadowMaps.length = 0;
frameState.shadowHints.lightShadowMaps.length = 0;
for (var i = 0; i < length; ++i) {
var shadowMap = shadowMaps[i];
shadowMap.update(frameState);
frameState.shadowHints.shadowMaps.push(shadowMap);
if (shadowMap.fromLightSource) {
frameState.shadowHints.lightShadowMaps.push(shadowMap);
}
if (shadowMap.dirty) {
++frameState.shadowHints.lastDirtyTime;
shadowMap.dirty = false;
}
}
}
function updatePrimitives(scene) {
var frameState = scene._frameState;
scene._groundPrimitives.update(frameState);
scene._primitives.update(frameState);
updateShadowMaps(scene);
if (scene._globe) {
scene._globe.update(frameState);
}
}
function updateAndClearFramebuffers(scene, passState, clearColor, picking) {
var context = scene._context;
var environmentState = scene._environmentState;
var useWebVR = scene._useWebVR && scene.mode !== SceneMode.SCENE2D;
// Preserve the reference to the original framebuffer.
environmentState.originalFramebuffer = passState.framebuffer;
// Manage sun bloom post-processing effect.
if (defined(scene.sun) && scene.sunBloom !== scene._sunBloom) {
if (scene.sunBloom && !useWebVR) {
scene._sunPostProcess = new SunPostProcess();
} else if(defined(scene._sunPostProcess)){
scene._sunPostProcess = scene._sunPostProcess.destroy();
}
scene._sunBloom = scene.sunBloom;
} else if (!defined(scene.sun) && defined(scene._sunPostProcess)) {
scene._sunPostProcess = scene._sunPostProcess.destroy();
scene._sunBloom = false;
}
// Clear the pass state framebuffer.
var clear = scene._clearColorCommand;
Color.clone(clearColor, clear.color);
clear.execute(context, passState);
// Update globe depth rendering based on the current context and clear the globe depth framebuffer.
var useGlobeDepthFramebuffer = environmentState.useGlobeDepthFramebuffer = !picking && defined(scene._globeDepth);
if (useGlobeDepthFramebuffer) {
scene._globeDepth.update(context);
scene._globeDepth.clear(context, passState, clearColor);
}
// Determine if there are any translucent surfaces in any of the frustums.
var renderTranslucentCommands = false;
var frustumCommandsList = scene._frustumCommandsList;
var numFrustums = frustumCommandsList.length;
for (var i = 0; i < numFrustums; ++i) {
if (frustumCommandsList[i].indices[Pass.TRANSLUCENT] > 0) {
renderTranslucentCommands = true;
break;
}
}
// If supported, configure OIT to use the globe depth framebuffer and clear the OIT framebuffer.
var useOIT = environmentState.useOIT = !picking && renderTranslucentCommands && defined(scene._oit) && scene._oit.isSupported();
if (useOIT) {
scene._oit.update(context, scene._globeDepth.framebuffer);
scene._oit.clear(context, passState, clearColor);
environmentState.useOIT = scene._oit.isSupported();
}
// If supported, configure FXAA to use the globe depth color texture and clear the FXAA framebuffer.
var useFXAA = environmentState.useFXAA = !picking && scene.fxaa;
if (useFXAA) {
scene._fxaa.update(context);
scene._fxaa.clear(context, passState, clearColor);
}
if (environmentState.isSunVisible && scene.sunBloom && !useWebVR) {
passState.framebuffer = scene._sunPostProcess.update(passState);
} else if (useGlobeDepthFramebuffer) {
passState.framebuffer = scene._globeDepth.framebuffer;
} else if (useFXAA) {
passState.framebuffer = scene._fxaa.getColorFramebuffer();
}
if (defined(passState.framebuffer)) {
clear.execute(context, passState);
}
}
function resolveFramebuffers(scene, passState) {
var context = scene._context;
var environmentState = scene._environmentState;
var useGlobeDepthFramebuffer = environmentState.useGlobeDepthFramebuffer;
if (scene.debugShowGlobeDepth && useGlobeDepthFramebuffer) {
var gd = getDebugGlobeDepth(scene, scene.debugShowDepthFrustum - 1);
gd.executeDebugGlobeDepth(context, passState);
}
if (scene.debugShowPickDepth && useGlobeDepthFramebuffer) {
var pd = getPickDepth(scene, scene.debugShowDepthFrustum - 1);
pd.executeDebugPickDepth(context, passState);
}
var useOIT = environmentState.useOIT;
var useFXAA = environmentState.useFXAA;
if (useOIT) {
passState.framebuffer = useFXAA ? scene._fxaa.getColorFramebuffer() : undefined;
scene._oit.execute(context, passState);
}
if (useFXAA) {
if (!useOIT && useGlobeDepthFramebuffer) {
passState.framebuffer = scene._fxaa.getColorFramebuffer();
scene._globeDepth.executeCopyColor(context, passState);
}
passState.framebuffer = environmentState.originalFramebuffer;
scene._fxaa.execute(context, passState);
}
if (!useOIT && !useFXAA && useGlobeDepthFramebuffer) {
passState.framebuffer = environmentState.originalFramebuffer;
scene._globeDepth.executeCopyColor(context, passState);
}
}
function callAfterRenderFunctions(frameState) {
// Functions are queued up during primitive update and executed here in case
// the function modifies scene state that should remain constant over the frame.
var functions = frameState.afterRender;
for (var i = 0, length = functions.length; i < length; ++i) {
functions[i]();
}
functions.length = 0;
}
/**
* @private
*/
Scene.prototype.initializeFrame = function() {
// Destroy released shaders once every 120 frames to avoid thrashing the cache
if (this._shaderFrameCount++ === 120) {
this._shaderFrameCount = 0;
this._context.shaderCache.destroyReleasedShaderPrograms();
}
this._tweens.update();
this._screenSpaceCameraController.update();
if (defined(this._deviceOrientationCameraController)) {
this._deviceOrientationCameraController.update();
}
this._camera.update(this._mode);
this._camera._updateCameraChanged();
};
var scratchEyeTranslation = new Cartesian3();
function render(scene, time) {
if (!defined(time)) {
time = JulianDate.now();
}
var camera = scene._camera;
if (!cameraEqual(camera, scene._cameraClone, CesiumMath.EPSILON6)) {
if (!scene._cameraStartFired) {
camera.moveStart.raiseEvent();
scene._cameraStartFired = true;
}
scene._cameraMovedTime = getTimestamp();
Camera.clone(camera, scene._cameraClone);
} else if (scene._cameraStartFired && getTimestamp() - scene._cameraMovedTime > scene.cameraEventWaitTime) {
camera.moveEnd.raiseEvent();
scene._cameraStartFired = false;
}
scene._preRender.raiseEvent(scene, time);
var context = scene.context;
var us = context.uniformState;
var frameState = scene._frameState;
var frameNumber = CesiumMath.incrementWrap(frameState.frameNumber, 15000000.0, 1.0);
updateFrameState(scene, frameNumber, time);
frameState.passes.render = true;
frameState.creditDisplay.beginFrame();
scene.fog.update(frameState);
us.update(frameState);
var shadowMap = scene.shadowMap;
if (defined(shadowMap) && shadowMap.enabled) {
// Update the sun's direction
Cartesian3.negate(us.sunDirectionWC, scene._sunCamera.direction);
frameState.shadowMaps.push(shadowMap);
}
scene._computeCommandList.length = 0;
scene._overlayCommandList.length = 0;
var passState = scene._passState;
passState.framebuffer = undefined;
passState.blendingEnabled = undefined;
passState.scissorTest = undefined;
if (defined(scene.globe)) {
scene.globe.beginFrame(frameState);
}
updateEnvironment(scene);
updateAndExecuteCommands(scene, passState, defaultValue(scene.backgroundColor, Color.BLACK));
resolveFramebuffers(scene, passState);
executeOverlayCommands(scene, passState);
if (defined(scene.globe)) {
scene.globe.endFrame(frameState);
}
frameState.creditDisplay.endFrame();
if (scene.debugShowFramesPerSecond) {
if (!defined(scene._performanceDisplay)) {
var performanceContainer = document.createElement('div');
performanceContainer.className = 'cesium-performanceDisplay-defaultContainer';
var container = scene._canvas.parentNode;
container.appendChild(performanceContainer);
var performanceDisplay = new PerformanceDisplay({container: performanceContainer});
scene._performanceDisplay = performanceDisplay;
scene._performanceContainer = performanceContainer;
}
scene._performanceDisplay.update();
} else if (defined(scene._performanceDisplay)) {
scene._performanceDisplay = scene._performanceDisplay && scene._performanceDisplay.destroy();
scene._performanceContainer.parentNode.removeChild(scene._performanceContainer);
}
context.endFrame();
callAfterRenderFunctions(frameState);
scene._postRender.raiseEvent(scene, time);
}
/**
* @private
*/
Scene.prototype.render = function(time) {
try {
render(this, time);
} catch (error) {
this._renderError.raiseEvent(this, error);
if (this.rethrowRenderErrors) {
throw error;
}
}
};
/**
* @private
*/
Scene.prototype.clampLineWidth = function(width) {
return Math.max(ContextLimits.minimumAliasedLineWidth, Math.min(width, ContextLimits.maximumAliasedLineWidth));
};
var orthoPickingFrustum = new OrthographicFrustum();
var scratchOrigin = new Cartesian3();
var scratchDirection = new Cartesian3();
var scratchPixelSize = new Cartesian2();
var scratchPickVolumeMatrix4 = new Matrix4();
function getPickOrthographicCullingVolume(scene, drawingBufferPosition, width, height) {
var camera = scene._camera;
var frustum = camera.frustum;
var viewport = scene._passState.viewport;
var x = 2.0 * (drawingBufferPosition.x - viewport.x) / viewport.width - 1.0;
x *= (frustum.right - frustum.left) * 0.5;
var y = 2.0 * (viewport.height - drawingBufferPosition.y - viewport.y) / viewport.height - 1.0;
y *= (frustum.top - frustum.bottom) * 0.5;
var transform = Matrix4.clone(camera.transform, scratchPickVolumeMatrix4);
camera._setTransform(Matrix4.IDENTITY);
var origin = Cartesian3.clone(camera.position, scratchOrigin);
Cartesian3.multiplyByScalar(camera.right, x, scratchDirection);
Cartesian3.add(scratchDirection, origin, origin);
Cartesian3.multiplyByScalar(camera.up, y, scratchDirection);
Cartesian3.add(scratchDirection, origin, origin);
camera._setTransform(transform);
Cartesian3.fromElements(origin.z, origin.x, origin.y, origin);
var pixelSize = frustum.getPixelDimensions(viewport.width, viewport.height, 1.0, scratchPixelSize);
var ortho = orthoPickingFrustum;
ortho.right = pixelSize.x * 0.5;
ortho.left = -ortho.right;
ortho.top = pixelSize.y * 0.5;
ortho.bottom = -ortho.top;
ortho.near = frustum.near;
ortho.far = frustum.far;
return ortho.computeCullingVolume(origin, camera.directionWC, camera.upWC);
}
var perspPickingFrustum = new PerspectiveOffCenterFrustum();
function getPickPerspectiveCullingVolume(scene, drawingBufferPosition, width, height) {
var camera = scene._camera;
var frustum = camera.frustum;
var near = frustum.near;
var tanPhi = Math.tan(frustum.fovy * 0.5);
var tanTheta = frustum.aspectRatio * tanPhi;
var viewport = scene._passState.viewport;
var x = 2.0 * (drawingBufferPosition.x - viewport.x) / viewport.width - 1.0;
var y = 2.0 * (viewport.height - drawingBufferPosition.y - viewport.y) / viewport.height - 1.0;
var xDir = x * near * tanTheta;
var yDir = y * near * tanPhi;
var pixelSize = frustum.getPixelDimensions(viewport.width, viewport.height, 1.0, scratchPixelSize);
var pickWidth = pixelSize.x * width * 0.5;
var pickHeight = pixelSize.y * height * 0.5;
var offCenter = perspPickingFrustum;
offCenter.top = yDir + pickHeight;
offCenter.bottom = yDir - pickHeight;
offCenter.right = xDir + pickWidth;
offCenter.left = xDir - pickWidth;
offCenter.near = near;
offCenter.far = frustum.far;
return offCenter.computeCullingVolume(camera.positionWC, camera.directionWC, camera.upWC);
}
function getPickCullingVolume(scene, drawingBufferPosition, width, height) {
if (scene._mode === SceneMode.SCENE2D) {
return getPickOrthographicCullingVolume(scene, drawingBufferPosition, width, height);
}
return getPickPerspectiveCullingVolume(scene, drawingBufferPosition, width, height);
}
// pick rectangle width and height, assumed odd
var rectangleWidth = 3.0;
var rectangleHeight = 3.0;
var scratchRectangle = new BoundingRectangle(0.0, 0.0, rectangleWidth, rectangleHeight);
var scratchColorZero = new Color(0.0, 0.0, 0.0, 0.0);
var scratchPosition = new Cartesian2();
/**
* Returns an object with a `primitive` property that contains the first (top) primitive in the scene
* at a particular window coordinate or undefined if nothing is at the location. Other properties may
* potentially be set depending on the type of primitive.
*
* @param {Cartesian2} windowPosition Window coordinates to perform picking on.
* @returns {Object} Object containing the picked primitive.
*
* @exception {DeveloperError} windowPosition is undefined.
*/
Scene.prototype.pick = function(windowPosition) {
if(!defined(windowPosition)) {
throw new DeveloperError('windowPosition is undefined.');
}
var context = this._context;
var us = context.uniformState;
var frameState = this._frameState;
var drawingBufferPosition = SceneTransforms.transformWindowToDrawingBuffer(this, windowPosition, scratchPosition);
if (!defined(this._pickFramebuffer)) {
this._pickFramebuffer = context.createPickFramebuffer();
}
// Update with previous frame's number and time, assuming that render is called before picking.
updateFrameState(this, frameState.frameNumber, frameState.time);
frameState.cullingVolume = getPickCullingVolume(this, drawingBufferPosition, rectangleWidth, rectangleHeight);
frameState.passes.pick = true;
us.update(frameState);
scratchRectangle.x = drawingBufferPosition.x - ((rectangleWidth - 1.0) * 0.5);
scratchRectangle.y = (this.drawingBufferHeight - drawingBufferPosition.y) - ((rectangleHeight - 1.0) * 0.5);
var passState = this._pickFramebuffer.begin(scratchRectangle);
updateAndExecuteCommands(this, passState, scratchColorZero, true);
resolveFramebuffers(this, passState);
var object = this._pickFramebuffer.end(scratchRectangle);
context.endFrame();
callAfterRenderFunctions(frameState);
return object;
};
var scratchPackedDepth = new Cartesian4();
var packedDepthScale = new Cartesian4(1.0, 1.0 / 255.0, 1.0 / 65025.0, 1.0 / 16581375.0);
/**
* Returns the cartesian position reconstructed from the depth buffer and window position.
*
* @param {Cartesian2} windowPosition Window coordinates to perform picking on.
* @param {Cartesian3} [result] The object on which to restore the result.
* @returns {Cartesian3} The cartesian position.
*
* @exception {DeveloperError} Picking from the depth buffer is not supported. Check pickPositionSupported.
* @exception {DeveloperError} 2D is not supported. An orthographic projection matrix is not invertible.
*/
Scene.prototype.pickPosition = function(windowPosition, result) {
if (!this.useDepthPicking) {
return undefined;
}
if(!defined(windowPosition)) {
throw new DeveloperError('windowPosition is undefined.');
}
if (!defined(this._globeDepth)) {
throw new DeveloperError('Picking from the depth buffer is not supported. Check pickPositionSupported.');
}
var context = this._context;
var uniformState = context.uniformState;
var drawingBufferPosition = SceneTransforms.transformWindowToDrawingBuffer(this, windowPosition, scratchPosition);
drawingBufferPosition.y = this.drawingBufferHeight - drawingBufferPosition.y;
var camera = this._camera;
// Create a working frustum from the original camera frustum.
var frustum;
if (defined(camera.frustum.fov)) {
frustum = camera.frustum.clone(scratchPerspectiveFrustum);
} else if (defined(camera.frustum.infiniteProjectionMatrix)){
frustum = camera.frustum.clone(scratchPerspectiveOffCenterFrustum);
} else {
throw new DeveloperError('2D is not supported. An orthographic projection matrix is not invertible.');
}
var numFrustums = this.numberOfFrustums;
for (var i = 0; i < numFrustums; ++i) {
var pickDepth = getPickDepth(this, i);
var pixels = context.readPixels({
x : drawingBufferPosition.x,
y : drawingBufferPosition.y,
width : 1,
height : 1,
framebuffer : pickDepth.framebuffer
});
var packedDepth = Cartesian4.unpack(pixels, 0, scratchPackedDepth);
Cartesian4.divideByScalar(packedDepth, 255.0, packedDepth);
var depth = Cartesian4.dot(packedDepth, packedDepthScale);
if (depth > 0.0 && depth < 1.0) {
var renderedFrustum = this._frustumCommandsList[i];
frustum.near = renderedFrustum.near * (i !== 0 ? OPAQUE_FRUSTUM_NEAR_OFFSET : 1.0);
frustum.far = renderedFrustum.far;
uniformState.updateFrustum(frustum);
return SceneTransforms.drawingBufferToWgs84Coordinates(this, drawingBufferPosition, depth, result);
}
}
return undefined;
};
/**
* Returns a list of objects, each containing a `primitive` property, for all primitives at
* a particular window coordinate position. Other properties may also be set depending on the
* type of primitive. The primitives in the list are ordered by their visual order in the
* scene (front to back).
*
* @param {Cartesian2} windowPosition Window coordinates to perform picking on.
* @param {Number} [limit] If supplied, stop drilling after collecting this many picks.
* @returns {Object[]} Array of objects, each containing 1 picked primitives.
*
* @exception {DeveloperError} windowPosition is undefined.
*
* @example
* var pickedObjects = scene.drillPick(new Cesium.Cartesian2(100.0, 200.0));
*/
Scene.prototype.drillPick = function(windowPosition, limit) {
// PERFORMANCE_IDEA: This function calls each primitive's update for each pass. Instead
// we could update the primitive once, and then just execute their commands for each pass,
// and cull commands for picked primitives. e.g., base on the command's owner.
if (!defined(windowPosition)) {
throw new DeveloperError('windowPosition is undefined.');
}
var i;
var attributes;
var result = [];
var pickedPrimitives = [];
var pickedAttributes = [];
if (!defined(limit)) {
limit = Number.MAX_VALUE;
}
var pickedResult = this.pick(windowPosition);
while (defined(pickedResult) && defined(pickedResult.primitive)) {
result.push(pickedResult);
if (0 >= --limit) {
break;
}
var primitive = pickedResult.primitive;
var hasShowAttribute = false;
//If the picked object has a show attribute, use it.
if (typeof primitive.getGeometryInstanceAttributes === 'function') {
if (defined(pickedResult.id)) {
attributes = primitive.getGeometryInstanceAttributes(pickedResult.id);
if (defined(attributes) && defined(attributes.show)) {
hasShowAttribute = true;
attributes.show = ShowGeometryInstanceAttribute.toValue(false, attributes.show);
pickedAttributes.push(attributes);
}
}
}
//Otherwise, hide the entire primitive
if (!hasShowAttribute) {
primitive.show = false;
pickedPrimitives.push(primitive);
}
pickedResult = this.pick(windowPosition);
}
// unhide everything we hid while drill picking
for (i = 0; i < pickedPrimitives.length; ++i) {
pickedPrimitives[i].show = true;
}
for (i = 0; i < pickedAttributes.length; ++i) {
attributes = pickedAttributes[i];
attributes.show = ShowGeometryInstanceAttribute.toValue(true, attributes.show);
}
return result;
};
/**
* Instantly completes an active transition.
*/
Scene.prototype.completeMorph = function(){
this._transitioner.completeMorph();
};
/**
* Asynchronously transitions the scene to 2D.
* @param {Number} [duration=2.0] The amount of time, in seconds, for transition animations to complete.
*/
Scene.prototype.morphTo2D = function(duration) {
var ellipsoid;
var globe = this.globe;
if (defined(globe)) {
ellipsoid = globe.ellipsoid;
} else {
ellipsoid = this.mapProjection.ellipsoid;
}
duration = defaultValue(duration, 2.0);
this._transitioner.morphTo2D(duration, ellipsoid);
};
/**
* Asynchronously transitions the scene to Columbus View.
* @param {Number} [duration=2.0] The amount of time, in seconds, for transition animations to complete.
*/
Scene.prototype.morphToColumbusView = function(duration) {
var ellipsoid;
var globe = this.globe;
if (defined(globe)) {
ellipsoid = globe.ellipsoid;
} else {
ellipsoid = this.mapProjection.ellipsoid;
}
duration = defaultValue(duration, 2.0);
this._transitioner.morphToColumbusView(duration, ellipsoid);
};
/**
* Asynchronously transitions the scene to 3D.
* @param {Number} [duration=2.0] The amount of time, in seconds, for transition animations to complete.
*/
Scene.prototype.morphTo3D = function(duration) {
var ellipsoid;
var globe = this.globe;
if (defined(globe)) {
ellipsoid = globe.ellipsoid;
} else {
ellipsoid = this.mapProjection.ellipsoid;
}
duration = defaultValue(duration, 2.0);
this._transitioner.morphTo3D(duration, ellipsoid);
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*
* @see Scene#destroy
*/
Scene.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* scene = scene && scene.destroy();
*
* @see Scene#isDestroyed
*/
Scene.prototype.destroy = function() {
this._tweens.removeAll();
this._computeEngine = this._computeEngine && this._computeEngine.destroy();
this._screenSpaceCameraController = this._screenSpaceCameraController && this._screenSpaceCameraController.destroy();
this._deviceOrientationCameraController = this._deviceOrientationCameraController && !this._deviceOrientationCameraController.isDestroyed() && this._deviceOrientationCameraController.destroy();
this._pickFramebuffer = this._pickFramebuffer && this._pickFramebuffer.destroy();
this._primitives = this._primitives && this._primitives.destroy();
this._groundPrimitives = this._groundPrimitives && this._groundPrimitives.destroy();
this._globe = this._globe && this._globe.destroy();
this.skyBox = this.skyBox && this.skyBox.destroy();
this.skyAtmosphere = this.skyAtmosphere && this.skyAtmosphere.destroy();
this._debugSphere = this._debugSphere && this._debugSphere.destroy();
this.sun = this.sun && this.sun.destroy();
this._sunPostProcess = this._sunPostProcess && this._sunPostProcess.destroy();
this._depthPlane = this._depthPlane && this._depthPlane.destroy();
this._transitioner.destroy();
if (defined(this._globeDepth)) {
this._globeDepth.destroy();
}
if (defined(this._oit)) {
this._oit.destroy();
}
this._fxaa.destroy();
this._context = this._context && this._context.destroy();
this._frameState.creditDisplay.destroy();
if (defined(this._performanceDisplay)){
this._performanceDisplay = this._performanceDisplay && this._performanceDisplay.destroy();
this._performanceContainer.parentNode.removeChild(this._performanceContainer);
}
return destroyObject(this);
};
return Scene;
});
/*global define*/
define('Scene/SingleTileImageryProvider',[
'../Core/Credit',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/Event',
'../Core/GeographicTilingScheme',
'../Core/loadImage',
'../Core/Rectangle',
'../Core/RuntimeError',
'../Core/TileProviderError',
'../ThirdParty/when'
], function(
Credit,
defaultValue,
defined,
defineProperties,
DeveloperError,
Event,
GeographicTilingScheme,
loadImage,
Rectangle,
RuntimeError,
TileProviderError,
when) {
'use strict';
/**
* Provides a single, top-level imagery tile. The single image is assumed to use a
* {@link GeographicTilingScheme}.
*
* @alias SingleTileImageryProvider
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {String} options.url The url for the tile.
* @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle, in radians, covered by the image.
* @param {Credit|String} [options.credit] A credit for the data source, which is displayed on the canvas.
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If not specified, the WGS84 ellipsoid is used.
* @param {Object} [options.proxy] A proxy to use for requests. This object is expected to have a getURL function which returns the proxied URL, if needed.
*
* @see ArcGisMapServerImageryProvider
* @see BingMapsImageryProvider
* @see GoogleEarthImageryProvider
* @see createOpenStreetMapImageryProvider
* @see createTileMapServiceImageryProvider
* @see WebMapServiceImageryProvider
* @see WebMapTileServiceImageryProvider
* @see UrlTemplateImageryProvider
*/
function SingleTileImageryProvider(options) {
options = defaultValue(options, {});
var url = options.url;
if (!defined(url)) {
throw new DeveloperError('url is required.');
}
this._url = url;
var proxy = options.proxy;
this._proxy = proxy;
var rectangle = defaultValue(options.rectangle, Rectangle.MAX_VALUE);
var tilingScheme = new GeographicTilingScheme({
rectangle : rectangle,
numberOfLevelZeroTilesX : 1,
numberOfLevelZeroTilesY : 1,
ellipsoid : options.ellipsoid
});
this._tilingScheme = tilingScheme;
this._image = undefined;
this._texture = undefined;
this._tileWidth = 0;
this._tileHeight = 0;
this._errorEvent = new Event();
this._ready = false;
this._readyPromise = when.defer();
var imageUrl = url;
if (defined(proxy)) {
imageUrl = proxy.getURL(imageUrl);
}
var credit = options.credit;
if (typeof credit === 'string') {
credit = new Credit(credit);
}
this._credit = credit;
var that = this;
var error;
function success(image) {
that._image = image;
that._tileWidth = image.width;
that._tileHeight = image.height;
that._ready = true;
that._readyPromise.resolve(true);
TileProviderError.handleSuccess(that._errorEvent);
}
function failure(e) {
var message = 'Failed to load image ' + imageUrl + '.';
error = TileProviderError.handleError(
error,
that,
that._errorEvent,
message,
0, 0, 0,
doRequest,
e);
that._readyPromise.reject(new RuntimeError(message));
}
function doRequest() {
when(loadImage(imageUrl), success, failure);
}
doRequest();
}
defineProperties(SingleTileImageryProvider.prototype, {
/**
* Gets the URL of the single, top-level imagery tile.
* @memberof SingleTileImageryProvider.prototype
* @type {String}
* @readonly
*/
url : {
get : function() {
return this._url;
}
},
/**
* Gets the proxy used by this provider.
* @memberof SingleTileImageryProvider.prototype
* @type {Proxy}
* @readonly
*/
proxy : {
get : function() {
return this._proxy;
}
},
/**
* Gets the width of each tile, in pixels. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileWidth : {
get : function() {
if (!this._ready) {
throw new DeveloperError('tileWidth must not be called before the imagery provider is ready.');
}
return this._tileWidth;
}
},
/**
* Gets the height of each tile, in pixels. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileHeight: {
get : function() {
if (!this._ready) {
throw new DeveloperError('tileHeight must not be called before the imagery provider is ready.');
}
return this._tileHeight;
}
},
/**
* Gets the maximum level-of-detail that can be requested. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {Number}
* @readonly
*/
maximumLevel : {
get : function() {
if (!this._ready) {
throw new DeveloperError('maximumLevel must not be called before the imagery provider is ready.');
}
return 0;
}
},
/**
* Gets the minimum level-of-detail that can be requested. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {Number}
* @readonly
*/
minimumLevel : {
get : function() {
if (!this._ready) {
throw new DeveloperError('minimumLevel must not be called before the imagery provider is ready.');
}
return 0;
}
},
/**
* Gets the tiling scheme used by this provider. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {TilingScheme}
* @readonly
*/
tilingScheme : {
get : function() {
if (!this._ready) {
throw new DeveloperError('tilingScheme must not be called before the imagery provider is ready.');
}
return this._tilingScheme;
}
},
/**
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {Rectangle}
* @readonly
*/
rectangle : {
get : function() {
return this._tilingScheme.rectangle;
}
},
/**
* Gets the tile discard policy. If not undefined, the discard policy is responsible
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
* returns undefined, no tiles are filtered. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {TileDiscardPolicy}
* @readonly
*/
tileDiscardPolicy : {
get : function() {
if (!this._ready) {
throw new DeveloperError('tileDiscardPolicy must not be called before the imagery provider is ready.');
}
return undefined;
}
},
/**
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof SingleTileImageryProvider.prototype
* @type {Event}
* @readonly
*/
errorEvent : {
get : function() {
return this._errorEvent;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof SingleTileImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
ready : {
get : function() {
return this._ready;
}
},
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof SingleTileImageryProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readyPromise : {
get : function() {
return this._readyPromise.promise;
}
},
/**
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
* the source of the imagery. This function should not be called before {@link SingleTileImageryProvider#ready} returns true.
* @memberof SingleTileImageryProvider.prototype
* @type {Credit}
* @readonly
*/
credit : {
get : function() {
return this._credit;
}
},
/**
* Gets a value indicating whether or not the images provided by this imagery provider
* include an alpha channel. If this property is false, an alpha channel, if present, will
* be ignored. If this property is true, any images without an alpha channel will be treated
* as if their alpha is 1.0 everywhere. When this property is false, memory usage
* and texture upload time are reduced.
* @memberof SingleTileImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
hasAlphaChannel : {
get : function() {
return true;
}
}
});
/**
* Gets the credits to be displayed when a given tile is displayed.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level;
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
*
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
*/
SingleTileImageryProvider.prototype.getTileCredits = function(x, y, level) {
return undefined;
};
/**
* Requests the image for a given tile. This function should
* not be called before {@link SingleTileImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Promise.<Image|Canvas>|undefined} A promise for the image that will resolve when the image is available, or
* undefined if there are too many active requests to the server, and the request
* should be retried later. The resolved image may be either an
* Image or a Canvas DOM object.
*
* @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready.
*/
SingleTileImageryProvider.prototype.requestImage = function(x, y, level) {
if (!this._ready) {
throw new DeveloperError('requestImage must not be called before the imagery provider is ready.');
}
return this._image;
};
/**
* Picking features is not currently supported by this imagery provider, so this function simply returns
* undefined.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @param {Number} longitude The longitude at which to pick features.
* @param {Number} latitude The latitude at which to pick features.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
* instances. The array may be empty if no features are found at the given location.
* It may also be undefined if picking is not supported.
*/
SingleTileImageryProvider.prototype.pickFeatures = function() {
return undefined;
};
return SingleTileImageryProvider;
});
/**
* @license
* Copyright (c) 2000-2005, Sean O'Neil (s_p_oneil@hotmail.com)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the project nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Modifications made by Analytical Graphics, Inc.
*/
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/SkyAtmosphereFS',[],function() {
'use strict';
return "#ifdef COLOR_CORRECT\n\
uniform vec3 u_hsbShift;\n\
#endif\n\
const float g = -0.95;\n\
const float g2 = g * g;\n\
const vec4 K_RGB2HSB = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n\
const vec4 K_HSB2RGB = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n\
varying vec3 v_rayleighColor;\n\
varying vec3 v_mieColor;\n\
varying vec3 v_toCamera;\n\
varying vec3 v_positionEC;\n\
#ifdef COLOR_CORRECT\n\
vec3 rgb2hsb(vec3 rgbColor)\n\
{\n\
vec4 p = mix(vec4(rgbColor.bg, K_RGB2HSB.wz), vec4(rgbColor.gb, K_RGB2HSB.xy), step(rgbColor.b, rgbColor.g));\n\
vec4 q = mix(vec4(p.xyw, rgbColor.r), vec4(rgbColor.r, p.yzx), step(p.x, rgbColor.r));\n\
float d = q.x - min(q.w, q.y);\n\
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + czm_epsilon7)), d / (q.x + czm_epsilon7), q.x);\n\
}\n\
vec3 hsb2rgb(vec3 hsbColor)\n\
{\n\
vec3 p = abs(fract(hsbColor.xxx + K_HSB2RGB.xyz) * 6.0 - K_HSB2RGB.www);\n\
return hsbColor.z * mix(K_HSB2RGB.xxx, clamp(p - K_HSB2RGB.xxx, 0.0, 1.0), hsbColor.y);\n\
}\n\
#endif\n\
void main (void)\n\
{\n\
float cosAngle = dot(czm_sunDirectionWC, normalize(v_toCamera)) / length(v_toCamera);\n\
float rayleighPhase = 0.75 * (1.0 + cosAngle * cosAngle);\n\
float miePhase = 1.5 * ((1.0 - g2) / (2.0 + g2)) * (1.0 + cosAngle * cosAngle) / pow(1.0 + g2 - 2.0 * g * cosAngle, 1.5);\n\
const float exposure = 2.0;\n\
vec3 rgb = rayleighPhase * v_rayleighColor + miePhase * v_mieColor;\n\
rgb = vec3(1.0) - exp(-exposure * rgb);\n\
float l = czm_luminance(rgb);\n\
#ifdef COLOR_CORRECT\n\
vec3 hsb = rgb2hsb(rgb);\n\
hsb.x += u_hsbShift.x;\n\
hsb.y = clamp(hsb.y + u_hsbShift.y, 0.0, 1.0);\n\
hsb.z = hsb.z > czm_epsilon7 ? hsb.z + u_hsbShift.z : 0.0;\n\
rgb = hsb2rgb(hsb);\n\
l = min(l, czm_luminance(rgb));\n\
#endif\n\
gl_FragColor = vec4(rgb, min(smoothstep(0.0, 0.1, l), 1.0) * smoothstep(0.0, 1.0, czm_morphTime));\n\
}\n\
";
});
/**
* @license
* Copyright (c) 2000-2005, Sean O'Neil (s_p_oneil@hotmail.com)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* * Neither the name of the project nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Modifications made by Analytical Graphics, Inc.
*/
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/SkyAtmosphereVS',[],function() {
'use strict';
return "attribute vec4 position;\n\
uniform vec4 u_cameraAndRadiiAndDynamicAtmosphereColor;\n\
const float Kr = 0.0025;\n\
const float Kr4PI = Kr * 4.0 * czm_pi;\n\
const float Km = 0.0015;\n\
const float Km4PI = Km * 4.0 * czm_pi;\n\
const float ESun = 15.0;\n\
const float KmESun = Km * ESun;\n\
const float KrESun = Kr * ESun;\n\
const vec3 InvWavelength = vec3(\n\
5.60204474633241,\n\
9.473284437923038,\n\
19.643802610477206);\n\
const float rayleighScaleDepth = 0.25;\n\
const int nSamples = 2;\n\
const float fSamples = 2.0;\n\
varying vec3 v_rayleighColor;\n\
varying vec3 v_mieColor;\n\
varying vec3 v_toCamera;\n\
float scale(float cosAngle)\n\
{\n\
float x = 1.0 - cosAngle;\n\
return rayleighScaleDepth * exp(-0.00287 + x*(0.459 + x*(3.83 + x*(-6.80 + x*5.25))));\n\
}\n\
void main(void)\n\
{\n\
float cameraHeight = u_cameraAndRadiiAndDynamicAtmosphereColor.x;\n\
float outerRadius = u_cameraAndRadiiAndDynamicAtmosphereColor.y;\n\
float innerRadius = u_cameraAndRadiiAndDynamicAtmosphereColor.z;\n\
vec3 positionV3 = position.xyz;\n\
vec3 ray = positionV3 - czm_viewerPositionWC;\n\
float far = length(ray);\n\
ray /= far;\n\
float atmosphereScale = 1.0 / (outerRadius - innerRadius);\n\
#ifdef SKY_FROM_SPACE\n\
float B = 2.0 * dot(czm_viewerPositionWC, ray);\n\
float C = cameraHeight * cameraHeight - outerRadius * outerRadius;\n\
float det = max(0.0, B*B - 4.0 * C);\n\
float near = 0.5 * (-B - sqrt(det));\n\
vec3 start = czm_viewerPositionWC + ray * near;\n\
far -= near;\n\
float startAngle = dot(ray, start) / outerRadius;\n\
float startDepth = exp(-1.0 / rayleighScaleDepth );\n\
float startOffset = startDepth*scale(startAngle);\n\
#else // SKY_FROM_ATMOSPHERE\n\
vec3 start = czm_viewerPositionWC;\n\
float height = length(start);\n\
float depth = exp((atmosphereScale / rayleighScaleDepth ) * (innerRadius - cameraHeight));\n\
float startAngle = dot(ray, start) / height;\n\
float startOffset = depth*scale(startAngle);\n\
#endif\n\
float sampleLength = far / fSamples;\n\
float scaledLength = sampleLength * atmosphereScale;\n\
vec3 sampleRay = ray * sampleLength;\n\
vec3 samplePoint = start + sampleRay * 0.5;\n\
vec3 frontColor = vec3(0.0, 0.0, 0.0);\n\
vec3 lightDir = (u_cameraAndRadiiAndDynamicAtmosphereColor.w > 0.0) ? czm_sunPositionWC - czm_viewerPositionWC : czm_viewerPositionWC;\n\
lightDir = normalize(lightDir);\n\
for(int i=0; i<nSamples; i++)\n\
{\n\
float height = length(samplePoint);\n\
float depth = exp((atmosphereScale / rayleighScaleDepth ) * (innerRadius - height));\n\
float fLightAngle = dot(lightDir, samplePoint) / height;\n\
float fCameraAngle = dot(ray, samplePoint) / height;\n\
float fScatter = (startOffset + depth*(scale(fLightAngle) - scale(fCameraAngle)));\n\
vec3 attenuate = exp(-fScatter * (InvWavelength * Kr4PI + Km4PI));\n\
frontColor += attenuate * (depth * scaledLength);\n\
samplePoint += sampleRay;\n\
}\n\
v_mieColor = frontColor * KmESun;\n\
v_rayleighColor = frontColor * (InvWavelength * KrESun);\n\
v_toCamera = czm_viewerPositionWC - positionV3;\n\
gl_Position = czm_modelViewProjection * position;\n\
}\n\
";
});
/*global define*/
define('Scene/SkyAtmosphere',[
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/Ellipsoid',
'../Core/EllipsoidGeometry',
'../Core/GeometryPipeline',
'../Core/Math',
'../Core/VertexFormat',
'../Renderer/BufferUsage',
'../Renderer/DrawCommand',
'../Renderer/RenderState',
'../Renderer/ShaderProgram',
'../Renderer/ShaderSource',
'../Renderer/VertexArray',
'../Shaders/SkyAtmosphereFS',
'../Shaders/SkyAtmosphereVS',
'./BlendingState',
'./CullFace',
'./SceneMode'
], function(
Cartesian3,
Cartesian4,
defaultValue,
defined,
defineProperties,
destroyObject,
Ellipsoid,
EllipsoidGeometry,
GeometryPipeline,
CesiumMath,
VertexFormat,
BufferUsage,
DrawCommand,
RenderState,
ShaderProgram,
ShaderSource,
VertexArray,
SkyAtmosphereFS,
SkyAtmosphereVS,
BlendingState,
CullFace,
SceneMode) {
'use strict';
/**
* An atmosphere drawn around the limb of the provided ellipsoid. Based on
* {@link http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter16.html|Accurate Atmospheric Scattering}
* in GPU Gems 2.
* <p>
* This is only supported in 3D. atmosphere is faded out when morphing to 2D or Columbus view.
* </p>
*
* @alias SkyAtmosphere
* @constructor
*
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid that the atmosphere is drawn around.
*
* @example
* scene.skyAtmosphere = new Cesium.SkyAtmosphere();
*
* @see Scene.skyAtmosphere
*/
function SkyAtmosphere(ellipsoid) {
ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
/**
* Determines if the atmosphere is shown.
*
* @type {Boolean}
* @default true
*/
this.show = true;
this._ellipsoid = ellipsoid;
this._command = new DrawCommand({
owner : this
});
this._spSkyFromSpace = undefined;
this._spSkyFromAtmosphere = undefined;
this._spSkyFromSpaceColorCorrect = undefined;
this._spSkyFromAtmosphereColorCorrect = undefined;
/**
* The hue shift to apply to the atmosphere. Defaults to 0.0 (no shift).
* A hue shift of 1.0 indicates a complete rotation of the hues available.
* @type {Number}
* @default 0.0
*/
this.hueShift = 0.0;
/**
* The saturation shift to apply to the atmosphere. Defaults to 0.0 (no shift).
* A saturation shift of -1.0 is monochrome.
* @type {Number}
* @default 0.0
*/
this.saturationShift = 0.0;
/**
* The brightness shift to apply to the atmosphere. Defaults to 0.0 (no shift).
* A brightness shift of -1.0 is complete darkness, which will let space show through.
* @type {Number}
* @default 0.0
*/
this.brightnessShift = 0.0;
this._hueSaturationBrightness = new Cartesian3();
// camera height, outer radius, inner radius, dynamic atmosphere color flag
var cameraAndRadiiAndDynamicAtmosphereColor = new Cartesian4();
// Toggles whether the sun position is used. 0 treats the sun as always directly overhead.
cameraAndRadiiAndDynamicAtmosphereColor.w = 0;
cameraAndRadiiAndDynamicAtmosphereColor.y = Cartesian3.maximumComponent(Cartesian3.multiplyByScalar(ellipsoid.radii, 1.025, new Cartesian3()));
cameraAndRadiiAndDynamicAtmosphereColor.z = ellipsoid.maximumRadius;
this._cameraAndRadiiAndDynamicAtmosphereColor = cameraAndRadiiAndDynamicAtmosphereColor;
var that = this;
this._command.uniformMap = {
u_cameraAndRadiiAndDynamicAtmosphereColor : function() {
return that._cameraAndRadiiAndDynamicAtmosphereColor;
},
u_hsbShift : function() {
that._hueSaturationBrightness.x = that.hueShift;
that._hueSaturationBrightness.y = that.saturationShift;
that._hueSaturationBrightness.z = that.brightnessShift;
return that._hueSaturationBrightness;
}
};
}
defineProperties(SkyAtmosphere.prototype, {
/**
* Gets the ellipsoid the atmosphere is drawn around.
* @memberof SkyAtmosphere.prototype
*
* @type {Ellipsoid}
* @readonly
*/
ellipsoid : {
get : function() {
return this._ellipsoid;
}
}
});
/**
* @private
*/
SkyAtmosphere.prototype.setDynamicAtmosphereColor = function(enableLighting) {
this._cameraAndRadiiAndDynamicAtmosphereColor.w = enableLighting ? 1 : 0;
};
/**
* @private
*/
SkyAtmosphere.prototype.update = function(frameState) {
if (!this.show) {
return undefined;
}
if ((frameState.mode !== SceneMode.SCENE3D) &&
(frameState.mode !== SceneMode.MORPHING)) {
return undefined;
}
// The atmosphere is only rendered during the render pass; it is not pickable, it doesn't cast shadows, etc.
if (!frameState.passes.render) {
return undefined;
}
var command = this._command;
if (!defined(command.vertexArray)) {
var context = frameState.context;
var geometry = EllipsoidGeometry.createGeometry(new EllipsoidGeometry({
radii : Cartesian3.multiplyByScalar(this._ellipsoid.radii, 1.025, new Cartesian3()),
slicePartitions : 256,
stackPartitions : 256,
vertexFormat : VertexFormat.POSITION_ONLY
}));
command.vertexArray = VertexArray.fromGeometry({
context : context,
geometry : geometry,
attributeLocations : GeometryPipeline.createAttributeLocations(geometry),
bufferUsage : BufferUsage.STATIC_DRAW
});
command.renderState = RenderState.fromCache({
cull : {
enabled : true,
face : CullFace.FRONT
},
blending : BlendingState.ALPHA_BLEND
});
var vs = new ShaderSource({
defines : ['SKY_FROM_SPACE'],
sources : [SkyAtmosphereVS]
});
this._spSkyFromSpace = ShaderProgram.fromCache({
context : context,
vertexShaderSource : vs,
fragmentShaderSource : SkyAtmosphereFS
});
vs = new ShaderSource({
defines : ['SKY_FROM_ATMOSPHERE'],
sources : [SkyAtmosphereVS]
});
this._spSkyFromAtmosphere = ShaderProgram.fromCache({
context : context,
vertexShaderSource : vs,
fragmentShaderSource : SkyAtmosphereFS
});
}
// Compile the color correcting versions of the shader on demand
var useColorCorrect = colorCorrect(this);
if (useColorCorrect && (!defined(this._spSkyFromSpaceColorCorrect) || !defined(this._spSkyFromAtmosphereColorCorrect))) {
var contextColorCorrect = frameState.context;
var vsColorCorrect = new ShaderSource({
defines : ['SKY_FROM_SPACE'],
sources : [SkyAtmosphereVS]
});
var fsColorCorrect = new ShaderSource({
defines : ['COLOR_CORRECT'],
sources : [SkyAtmosphereFS]
});
this._spSkyFromSpaceColorCorrect = ShaderProgram.fromCache({
context : contextColorCorrect,
vertexShaderSource : vsColorCorrect,
fragmentShaderSource : fsColorCorrect
});
vsColorCorrect = new ShaderSource({
defines : ['SKY_FROM_ATMOSPHERE'],
sources : [SkyAtmosphereVS]
});
this._spSkyFromAtmosphereColorCorrect = ShaderProgram.fromCache({
context : contextColorCorrect,
vertexShaderSource : vsColorCorrect,
fragmentShaderSource : fsColorCorrect
});
}
var cameraPosition = frameState.camera.positionWC;
var cameraHeight = Cartesian3.magnitude(cameraPosition);
this._cameraAndRadiiAndDynamicAtmosphereColor.x = cameraHeight;
if (cameraHeight > this._cameraAndRadiiAndDynamicAtmosphereColor.y) {
// Camera in space
command.shaderProgram = useColorCorrect ? this._spSkyFromSpaceColorCorrect : this._spSkyFromSpace;
} else {
// Camera in atmosphere
command.shaderProgram = useColorCorrect ? this._spSkyFromAtmosphereColorCorrect : this._spSkyFromAtmosphere;
}
return command;
};
function colorCorrect(skyAtmosphere) {
return !(CesiumMath.equalsEpsilon(skyAtmosphere.hueShift, 0.0, CesiumMath.EPSILON7) &&
CesiumMath.equalsEpsilon(skyAtmosphere.saturationShift, 0.0, CesiumMath.EPSILON7) &&
CesiumMath.equalsEpsilon(skyAtmosphere.brightnessShift, 0.0, CesiumMath.EPSILON7));
}
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*
* @see SkyAtmosphere#destroy
*/
SkyAtmosphere.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* skyAtmosphere = skyAtmosphere && skyAtmosphere.destroy();
*
* @see SkyAtmosphere#isDestroyed
*/
SkyAtmosphere.prototype.destroy = function() {
var command = this._command;
command.vertexArray = command.vertexArray && command.vertexArray.destroy();
this._spSkyFromSpace = this._spSkyFromSpace && this._spSkyFromSpace.destroy();
this._spSkyFromAtmosphere = this._spSkyFromAtmosphere && this._spSkyFromAtmosphere.destroy();
this._spSkyFromSpaceColorCorrect = this._spSkyFromSpaceColorCorrect && this._spSkyFromSpaceColorCorrect.destroy();
this._spSkyFromAtmosphereColorCorrect = this._spSkyFromAtmosphereColorCorrect && this._spSkyFromAtmosphereColorCorrect.destroy();
return destroyObject(this);
};
return SkyAtmosphere;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/SkyBoxFS',[],function() {
'use strict';
return "uniform samplerCube u_cubeMap;\n\
varying vec3 v_texCoord;\n\
void main()\n\
{\n\
vec3 rgb = textureCube(u_cubeMap, normalize(v_texCoord)).rgb;\n\
gl_FragColor = vec4(rgb, czm_morphTime);\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/SkyBoxVS',[],function() {
'use strict';
return "attribute vec3 position;\n\
varying vec3 v_texCoord;\n\
void main()\n\
{\n\
vec3 p = czm_viewRotation * (czm_temeToPseudoFixed * (czm_entireFrustum.y * position));\n\
gl_Position = czm_projection * vec4(p, 1.0);\n\
v_texCoord = position.xyz;\n\
}\n\
";
});
/*global define*/
define('Scene/SkyBox',[
'../Core/BoxGeometry',
'../Core/Cartesian3',
'../Core/defaultValue',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Core/GeometryPipeline',
'../Core/Matrix4',
'../Core/VertexFormat',
'../Renderer/BufferUsage',
'../Renderer/CubeMap',
'../Renderer/DrawCommand',
'../Renderer/loadCubeMap',
'../Renderer/RenderState',
'../Renderer/ShaderProgram',
'../Renderer/VertexArray',
'../Shaders/SkyBoxFS',
'../Shaders/SkyBoxVS',
'./BlendingState',
'./SceneMode'
], function(
BoxGeometry,
Cartesian3,
defaultValue,
defined,
destroyObject,
DeveloperError,
GeometryPipeline,
Matrix4,
VertexFormat,
BufferUsage,
CubeMap,
DrawCommand,
loadCubeMap,
RenderState,
ShaderProgram,
VertexArray,
SkyBoxFS,
SkyBoxVS,
BlendingState,
SceneMode) {
'use strict';
/**
* A sky box around the scene to draw stars. The sky box is defined using the True Equator Mean Equinox (TEME) axes.
* <p>
* This is only supported in 3D. The sky box is faded out when morphing to 2D or Columbus view. The size of
* the sky box must not exceed {@link Scene#maximumCubeMapSize}.
* </p>
*
* @alias SkyBox
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Object} [options.sources] The source URL or <code>Image</code> object for each of the six cube map faces. See the example below.
* @param {Boolean} [options.show=true] Determines if this primitive will be shown.
*
*
* @example
* scene.skyBox = new Cesium.SkyBox({
* sources : {
* positiveX : 'skybox_px.png',
* negativeX : 'skybox_nx.png',
* positiveY : 'skybox_py.png',
* negativeY : 'skybox_ny.png',
* positiveZ : 'skybox_pz.png',
* negativeZ : 'skybox_nz.png'
* }
* });
*
* @see Scene#skyBox
* @see Transforms.computeTemeToPseudoFixedMatrix
*/
function SkyBox(options) {
/**
* The sources used to create the cube map faces: an object
* with <code>positiveX</code>, <code>negativeX</code>, <code>positiveY</code>,
* <code>negativeY</code>, <code>positiveZ</code>, and <code>negativeZ</code> properties.
* These can be either URLs or <code>Image</code> objects.
*
* @type Object
* @default undefined
*/
this.sources = options.sources;
this._sources = undefined;
/**
* Determines if the sky box will be shown.
*
* @type {Boolean}
* @default true
*/
this.show = defaultValue(options.show, true);
this._command = new DrawCommand({
modelMatrix : Matrix4.clone(Matrix4.IDENTITY),
owner : this
});
this._cubeMap = undefined;
}
/**
* Called when {@link Viewer} or {@link CesiumWidget} render the scene to
* get the draw commands needed to render this primitive.
* <p>
* Do not call this function directly. This is documented just to
* list the exceptions that may be propagated when the scene is rendered:
* </p>
*
* @exception {DeveloperError} this.sources is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties.
* @exception {DeveloperError} this.sources properties must all be the same type.
*/
SkyBox.prototype.update = function(frameState) {
if (!this.show) {
return undefined;
}
if ((frameState.mode !== SceneMode.SCENE3D) &&
(frameState.mode !== SceneMode.MORPHING)) {
return undefined;
}
// The sky box is only rendered during the render pass; it is not pickable, it doesn't cast shadows, etc.
if (!frameState.passes.render) {
return undefined;
}
var context = frameState.context;
if (this._sources !== this.sources) {
this._sources = this.sources;
var sources = this.sources;
if ((!defined(sources.positiveX)) ||
(!defined(sources.negativeX)) ||
(!defined(sources.positiveY)) ||
(!defined(sources.negativeY)) ||
(!defined(sources.positiveZ)) ||
(!defined(sources.negativeZ))) {
throw new DeveloperError('this.sources is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties.');
}
if ((typeof sources.positiveX !== typeof sources.negativeX) ||
(typeof sources.positiveX !== typeof sources.positiveY) ||
(typeof sources.positiveX !== typeof sources.negativeY) ||
(typeof sources.positiveX !== typeof sources.positiveZ) ||
(typeof sources.positiveX !== typeof sources.negativeZ)) {
throw new DeveloperError('this.sources properties must all be the same type.');
}
if (typeof sources.positiveX === 'string') {
// Given urls for cube-map images. Load them.
loadCubeMap(context, this._sources).then(function(cubeMap) {
that._cubeMap = that._cubeMap && that._cubeMap.destroy();
that._cubeMap = cubeMap;
});
} else {
this._cubeMap = this._cubeMap && this._cubeMap.destroy();
this._cubeMap = new CubeMap({
context : context,
source : sources
});
}
}
var command = this._command;
if (!defined(command.vertexArray)) {
var that = this;
command.uniformMap = {
u_cubeMap: function() {
return that._cubeMap;
}
};
var geometry = BoxGeometry.createGeometry(BoxGeometry.fromDimensions({
dimensions : new Cartesian3(2.0, 2.0, 2.0),
vertexFormat : VertexFormat.POSITION_ONLY
}));
var attributeLocations = GeometryPipeline.createAttributeLocations(geometry);
command.vertexArray = VertexArray.fromGeometry({
context : context,
geometry : geometry,
attributeLocations : attributeLocations,
bufferUsage : BufferUsage.STATIC_DRAW
});
command.shaderProgram = ShaderProgram.fromCache({
context : context,
vertexShaderSource : SkyBoxVS,
fragmentShaderSource : SkyBoxFS,
attributeLocations : attributeLocations
});
command.renderState = RenderState.fromCache({
blending : BlendingState.ALPHA_BLEND
});
}
if (!defined(this._cubeMap)) {
return undefined;
}
return command;
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*
* @see SkyBox#destroy
*/
SkyBox.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* skyBox = skyBox && skyBox.destroy();
*
* @see SkyBox#isDestroyed
*/
SkyBox.prototype.destroy = function() {
var command = this._command;
command.vertexArray = command.vertexArray && command.vertexArray.destroy();
command.shaderProgram = command.shaderProgram && command.shaderProgram.destroy();
this._cubeMap = this._cubeMap && this._cubeMap.destroy();
return destroyObject(this);
};
return SkyBox;
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/SunFS',[],function() {
'use strict';
return "uniform sampler2D u_texture;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
gl_FragColor = texture2D(u_texture, v_textureCoordinates);\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/SunTextureFS',[],function() {
'use strict';
return "uniform float u_glowLengthTS;\n\
uniform float u_radiusTS;\n\
varying vec2 v_textureCoordinates;\n\
vec2 rotate(vec2 p, vec2 direction)\n\
{\n\
return vec2(p.x * direction.x - p.y * direction.y, p.x * direction.y + p.y * direction.x);\n\
}\n\
vec4 addBurst(vec2 position, vec2 direction)\n\
{\n\
vec2 rotatedPosition = rotate(position, direction) * vec2(25.0, 0.75);\n\
float radius = length(rotatedPosition);\n\
float burst = 1.0 - smoothstep(0.0, 0.55, radius);\n\
return vec4(burst);\n\
}\n\
void main()\n\
{\n\
vec2 position = v_textureCoordinates - vec2(0.5);\n\
float radius = length(position);\n\
float surface = step(radius, u_radiusTS);\n\
vec4 color = vec4(1.0, 1.0, surface + 0.2, surface);\n\
float glow = 1.0 - smoothstep(0.0, 0.55, radius);\n\
color.ba += mix(vec2(0.0), vec2(1.0), glow) * 0.75;\n\
vec4 burst = vec4(0.0);\n\
burst += 0.4 * addBurst(position, vec2(0.38942, 0.92106));\n\
burst += 0.4 * addBurst(position, vec2(0.99235, 0.12348));\n\
burst += 0.4 * addBurst(position, vec2(0.60327, -0.79754));\n\
burst += 0.3 * addBurst(position, vec2(0.31457, 0.94924));\n\
burst += 0.3 * addBurst(position, vec2(0.97931, 0.20239));\n\
burst += 0.3 * addBurst(position, vec2(0.66507, -0.74678));\n\
color += clamp(burst, vec4(0.0), vec4(1.0)) * 0.15;\n\
gl_FragColor = clamp(color, vec4(0.0), vec4(1.0));\n\
}\n\
";
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/SunVS',[],function() {
'use strict';
return "attribute vec2 direction;\n\
uniform float u_size;\n\
varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
vec4 position;\n\
if (czm_morphTime == 1.0)\n\
{\n\
position = vec4(czm_sunPositionWC, 1.0);\n\
}\n\
else\n\
{\n\
position = vec4(czm_sunPositionColumbusView.zxy, 1.0);\n\
}\n\
vec4 positionEC = czm_view * position;\n\
vec4 positionWC = czm_eyeToWindowCoordinates(positionEC);\n\
vec2 halfSize = vec2(u_size * 0.5);\n\
halfSize *= ((direction * 2.0) - 1.0);\n\
gl_Position = czm_viewportOrthographic * vec4(positionWC.xy + halfSize, -positionWC.z, 1.0);\n\
v_textureCoordinates = direction;\n\
}\n\
";
});
/*global define*/
define('Scene/Sun',[
'../Core/BoundingSphere',
'../Core/Cartesian2',
'../Core/Cartesian3',
'../Core/Cartesian4',
'../Core/ComponentDatatype',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/IndexDatatype',
'../Core/Math',
'../Core/Matrix4',
'../Core/PixelFormat',
'../Core/PrimitiveType',
'../Renderer/Buffer',
'../Renderer/BufferUsage',
'../Renderer/ComputeCommand',
'../Renderer/DrawCommand',
'../Renderer/RenderState',
'../Renderer/ShaderProgram',
'../Renderer/Texture',
'../Renderer/VertexArray',
'../Shaders/SunFS',
'../Shaders/SunTextureFS',
'../Shaders/SunVS',
'./BlendingState',
'./SceneMode',
'./SceneTransforms'
], function(
BoundingSphere,
Cartesian2,
Cartesian3,
Cartesian4,
ComponentDatatype,
defined,
defineProperties,
destroyObject,
IndexDatatype,
CesiumMath,
Matrix4,
PixelFormat,
PrimitiveType,
Buffer,
BufferUsage,
ComputeCommand,
DrawCommand,
RenderState,
ShaderProgram,
Texture,
VertexArray,
SunFS,
SunTextureFS,
SunVS,
BlendingState,
SceneMode,
SceneTransforms) {
'use strict';
/**
* Draws a sun billboard.
* <p>This is only supported in 3D and Columbus view.</p>
*
* @alias Sun
* @constructor
*
*
* @example
* scene.sun = new Cesium.Sun();
*
* @see Scene#sun
*/
function Sun() {
/**
* Determines if the sun will be shown.
*
* @type {Boolean}
* @default true
*/
this.show = true;
this._drawCommand = new DrawCommand({
primitiveType : PrimitiveType.TRIANGLES,
boundingVolume : new BoundingSphere(),
owner : this
});
this._commands = {
drawCommand : this._drawCommand,
computeCommand : undefined
};
this._boundingVolume = new BoundingSphere();
this._boundingVolume2D = new BoundingSphere();
this._texture = undefined;
this._drawingBufferWidth = undefined;
this._drawingBufferHeight = undefined;
this._radiusTS = undefined;
this._size = undefined;
this.glowFactor = 1.0;
this._glowFactorDirty = false;
var that = this;
this._uniformMap = {
u_texture : function() {
return that._texture;
},
u_size : function() {
return that._size;
}
};
}
defineProperties(Sun.prototype, {
/**
* Gets or sets a number that controls how "bright" the Sun's lens flare appears
* to be. Zero shows just the Sun's disc without any flare.
* Use larger values for a more pronounced flare around the Sun.
*
* @memberof Sun.prototype
* @type {Number}
* @default 1.0
*/
glowFactor : {
get : function () { return this._glowFactor; },
set : function (glowFactor) {
glowFactor = Math.max(glowFactor, 0.0);
this._glowFactor = glowFactor;
this._glowFactorDirty = true;
}
}
});
var scratchPositionWC = new Cartesian2();
var scratchLimbWC = new Cartesian2();
var scratchPositionEC = new Cartesian4();
var scratchCartesian4 = new Cartesian4();
/**
* @private
*/
Sun.prototype.update = function(scene) {
var passState = scene._passState;
var frameState = scene.frameState;
var context = scene.context;
if (!this.show) {
return undefined;
}
var mode = frameState.mode;
if (mode === SceneMode.SCENE2D || mode === SceneMode.MORPHING) {
return undefined;
}
if (!frameState.passes.render) {
return undefined;
}
var drawingBufferWidth = passState.viewport.width;
var drawingBufferHeight = passState.viewport.height;
if (!defined(this._texture) ||
drawingBufferWidth !== this._drawingBufferWidth ||
drawingBufferHeight !== this._drawingBufferHeight ||
this._glowFactorDirty) {
this._texture = this._texture && this._texture.destroy();
this._drawingBufferWidth = drawingBufferWidth;
this._drawingBufferHeight = drawingBufferHeight;
this._glowFactorDirty = false;
var size = Math.max(drawingBufferWidth, drawingBufferHeight);
size = Math.pow(2.0, Math.ceil(Math.log(size) / Math.log(2.0)) - 2.0);
// The size computed above can be less than 1.0 if size < 4.0. This will probably
// never happen in practice, but does in the tests. Clamp to 1.0 to prevent WebGL
// errors in the tests.
size = Math.max(1.0, size);
this._texture = new Texture({
context : context,
width : size,
height : size,
pixelFormat : PixelFormat.RGBA
});
this._glowLengthTS = this._glowFactor * 5.0;
this._radiusTS = (1.0 / (1.0 + 2.0 * this._glowLengthTS)) * 0.5;
var that = this;
var uniformMap = {
u_glowLengthTS : function() {
return that._glowLengthTS;
},
u_radiusTS : function() {
return that._radiusTS;
}
};
this._commands.computeCommand = new ComputeCommand({
fragmentShaderSource : SunTextureFS,
outputTexture : this._texture,
uniformMap : uniformMap,
persists : false,
owner : this,
postExecute : function() {
that._commands.computeCommand = undefined;
}
});
}
var drawCommand = this._drawCommand;
if (!defined(drawCommand.vertexArray)) {
var attributeLocations = {
direction : 0
};
var directions = new Uint8Array(4 * 2);
directions[0] = 0;
directions[1] = 0;
directions[2] = 255;
directions[3] = 0.0;
directions[4] = 255;
directions[5] = 255;
directions[6] = 0.0;
directions[7] = 255;
var vertexBuffer = Buffer.createVertexBuffer({
context : context,
typedArray : directions,
usage : BufferUsage.STATIC_DRAW
});
var attributes = [{
index : attributeLocations.direction,
vertexBuffer : vertexBuffer,
componentsPerAttribute : 2,
normalize : true,
componentDatatype : ComponentDatatype.UNSIGNED_BYTE
}];
// Workaround Internet Explorer 11.0.8 lack of TRIANGLE_FAN
var indexBuffer = Buffer.createIndexBuffer({
context : context,
typedArray : new Uint16Array([0, 1, 2, 0, 2, 3]),
usage : BufferUsage.STATIC_DRAW,
indexDatatype : IndexDatatype.UNSIGNED_SHORT
});
drawCommand.vertexArray = new VertexArray({
context : context,
attributes : attributes,
indexBuffer : indexBuffer
});
drawCommand.shaderProgram = ShaderProgram.fromCache({
context : context,
vertexShaderSource : SunVS,
fragmentShaderSource : SunFS,
attributeLocations : attributeLocations
});
drawCommand.renderState = RenderState.fromCache({
blending : BlendingState.ALPHA_BLEND
});
drawCommand.uniformMap = this._uniformMap;
}
var sunPosition = context.uniformState.sunPositionWC;
var sunPositionCV = context.uniformState.sunPositionColumbusView;
var boundingVolume = this._boundingVolume;
var boundingVolume2D = this._boundingVolume2D;
Cartesian3.clone(sunPosition, boundingVolume.center);
boundingVolume2D.center.x = sunPositionCV.z;
boundingVolume2D.center.y = sunPositionCV.x;
boundingVolume2D.center.z = sunPositionCV.y;
boundingVolume.radius = CesiumMath.SOLAR_RADIUS + CesiumMath.SOLAR_RADIUS * this._glowLengthTS;
boundingVolume2D.radius = boundingVolume.radius;
if (mode === SceneMode.SCENE3D) {
BoundingSphere.clone(boundingVolume, drawCommand.boundingVolume);
} else if (mode === SceneMode.COLUMBUS_VIEW) {
BoundingSphere.clone(boundingVolume2D, drawCommand.boundingVolume);
}
var position = SceneTransforms.computeActualWgs84Position(frameState, sunPosition, scratchCartesian4);
var dist = Cartesian3.magnitude(Cartesian3.subtract(position, scene.camera.position, scratchCartesian4));
var projMatrix = context.uniformState.projection;
var positionEC = scratchPositionEC;
positionEC.x = 0;
positionEC.y = 0;
positionEC.z = -dist;
positionEC.w = 1;
var positionCC = Matrix4.multiplyByVector(projMatrix, positionEC, scratchCartesian4);
var positionWC = SceneTransforms.clipToDrawingBufferCoordinates(passState.viewport, positionCC, scratchPositionWC);
positionEC.x = CesiumMath.SOLAR_RADIUS;
var limbCC = Matrix4.multiplyByVector(projMatrix, positionEC, scratchCartesian4);
var limbWC = SceneTransforms.clipToDrawingBufferCoordinates(passState.viewport, limbCC, scratchLimbWC);
this._size = Math.ceil(Cartesian2.magnitude(Cartesian2.subtract(limbWC, positionWC, scratchCartesian4)));
this._size = 2.0 * this._size * (1.0 + 2.0 * this._glowLengthTS);
return this._commands;
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*
* @see Sun#destroy
*/
Sun.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* sun = sun && sun.destroy();
*
* @see Sun#isDestroyed
*/
Sun.prototype.destroy = function() {
var command = this._drawCommand;
command.vertexArray = command.vertexArray && command.vertexArray.destroy();
command.shaderProgram = command.shaderProgram && command.shaderProgram.destroy();
this._texture = this._texture && this._texture.destroy();
return destroyObject(this);
};
return Sun;
});
/*global define*/
define('Scene/TileCoordinatesImageryProvider',[
'../Core/Color',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/Event',
'../Core/GeographicTilingScheme',
'../ThirdParty/when'
], function(
Color,
defaultValue,
defined,
defineProperties,
Event,
GeographicTilingScheme,
when) {
'use strict';
/**
* An {@link ImageryProvider} that draws a box around every rendered tile in the tiling scheme, and draws
* a label inside it indicating the X, Y, Level coordinates of the tile. This is mostly useful for
* debugging terrain and imagery rendering problems.
*
* @alias TileCoordinatesImageryProvider
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {TilingScheme} [options.tilingScheme=new GeographicTilingScheme()] The tiling scheme for which to draw tiles.
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If the tilingScheme is specified,
* this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
* parameter is specified, the WGS84 ellipsoid is used.
* @param {Color} [options.color=Color.YELLOW] The color to draw the tile box and label.
* @param {Number} [options.tileWidth=256] The width of the tile for level-of-detail selection purposes.
* @param {Number} [options.tileHeight=256] The height of the tile for level-of-detail selection purposes.
*/
function TileCoordinatesImageryProvider(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
this._tilingScheme = defined(options.tilingScheme) ? options.tilingScheme : new GeographicTilingScheme({ ellipsoid : options.ellipsoid });
this._color = defaultValue(options.color, Color.YELLOW);
this._errorEvent = new Event();
this._tileWidth = defaultValue(options.tileWidth, 256);
this._tileHeight = defaultValue(options.tileHeight, 256);
this._readyPromise = when.resolve(true);
}
defineProperties(TileCoordinatesImageryProvider.prototype, {
/**
* Gets the proxy used by this provider.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Proxy}
* @readonly
*/
proxy : {
get : function() {
return undefined;
}
},
/**
* Gets the width of each tile, in pixels. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileWidth : {
get : function() {
return this._tileWidth;
}
},
/**
* Gets the height of each tile, in pixels. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileHeight: {
get : function() {
return this._tileHeight;
}
},
/**
* Gets the maximum level-of-detail that can be requested. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Number}
* @readonly
*/
maximumLevel : {
get : function() {
return undefined;
}
},
/**
* Gets the minimum level-of-detail that can be requested. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Number}
* @readonly
*/
minimumLevel : {
get : function() {
return undefined;
}
},
/**
* Gets the tiling scheme used by this provider. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {TilingScheme}
* @readonly
*/
tilingScheme : {
get : function() {
return this._tilingScheme;
}
},
/**
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Rectangle}
* @readonly
*/
rectangle : {
get : function() {
return this._tilingScheme.rectangle;
}
},
/**
* Gets the tile discard policy. If not undefined, the discard policy is responsible
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
* returns undefined, no tiles are filtered. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {TileDiscardPolicy}
* @readonly
*/
tileDiscardPolicy : {
get : function() {
return undefined;
}
},
/**
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Event}
* @readonly
*/
errorEvent : {
get : function() {
return this._errorEvent;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
ready : {
get : function() {
return true;
}
},
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readyPromise : {
get : function() {
return this._readyPromise;
}
},
/**
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
* the source of the imagery. This function should not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Credit}
* @readonly
*/
credit : {
get : function() {
return undefined;
}
},
/**
* Gets a value indicating whether or not the images provided by this imagery provider
* include an alpha channel. If this property is false, an alpha channel, if present, will
* be ignored. If this property is true, any images without an alpha channel will be treated
* as if their alpha is 1.0 everywhere. Setting this property to false reduces memory usage
* and texture upload time.
* @memberof TileCoordinatesImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
hasAlphaChannel : {
get : function() {
return true;
}
}
});
/**
* Gets the credits to be displayed when a given tile is displayed.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level;
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
*
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
*/
TileCoordinatesImageryProvider.prototype.getTileCredits = function(x, y, level) {
return undefined;
};
/**
* Requests the image for a given tile. This function should
* not be called before {@link TileCoordinatesImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Promise.<Image|Canvas>|undefined} A promise for the image that will resolve when the image is available, or
* undefined if there are too many active requests to the server, and the request
* should be retried later. The resolved image may be either an
* Image or a Canvas DOM object.
*/
TileCoordinatesImageryProvider.prototype.requestImage = function(x, y, level) {
var canvas = document.createElement('canvas');
canvas.width = 256;
canvas.height = 256;
var context = canvas.getContext('2d');
var cssColor = this._color.toCssColorString();
context.strokeStyle = cssColor;
context.lineWidth = 2;
context.strokeRect(1, 1, 255, 255);
var label = 'L' + level + 'X' + x + 'Y' + y;
context.font = 'bold 25px Arial';
context.textAlign = 'center';
context.fillStyle = 'black';
context.fillText(label, 127, 127);
context.fillStyle = cssColor;
context.fillText(label, 124, 124);
return canvas;
};
/**
* Picking features is not currently supported by this imagery provider, so this function simply returns
* undefined.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @param {Number} longitude The longitude at which to pick features.
* @param {Number} latitude The latitude at which to pick features.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
* instances. The array may be empty if no features are found at the given location.
* It may also be undefined if picking is not supported.
*/
TileCoordinatesImageryProvider.prototype.pickFeatures = function() {
return undefined;
};
return TileCoordinatesImageryProvider;
});
/*global define*/
define('Scene/TileDiscardPolicy',[
'../Core/DeveloperError'
], function(
DeveloperError) {
'use strict';
/**
* A policy for discarding tile images according to some criteria. This type describes an
* interface and is not intended to be instantiated directly.
*
* @alias TileDiscardPolicy
* @constructor
*
* @see DiscardMissingTileImagePolicy
* @see NeverTileDiscardPolicy
*/
function TileDiscardPolicy(options) {
DeveloperError.throwInstantiationError();
}
/**
* Determines if the discard policy is ready to process images.
* @function
*
* @returns {Boolean} True if the discard policy is ready to process images; otherwise, false.
*/
TileDiscardPolicy.prototype.isReady = DeveloperError.throwInstantiationError;
/**
* Given a tile image, decide whether to discard that image.
* @function
*
* @param {Image} image An image to test.
* @returns {Boolean} True if the image should be discarded; otherwise, false.
*/
TileDiscardPolicy.prototype.shouldDiscardImage = DeveloperError.throwInstantiationError;
return TileDiscardPolicy;
});
/*global define*/
define('Scene/TileState',[
'../Core/freezeObject'
], function(
freezeObject) {
'use strict';
/**
* @private
*/
var TileState = {
START : 0,
LOADING : 1,
READY : 2,
UPSAMPLED_ONLY : 3
};
return freezeObject(TileState);
});
//This file is automatically rebuilt by the Cesium build process.
/*global define*/
define('Shaders/ViewportQuadFS',[],function() {
'use strict';
return "varying vec2 v_textureCoordinates;\n\
void main()\n\
{\n\
czm_materialInput materialInput;\n\
materialInput.s = v_textureCoordinates.s;\n\
materialInput.st = v_textureCoordinates;\n\
materialInput.str = vec3(v_textureCoordinates, 0.0);\n\
materialInput.normalEC = vec3(0.0, 0.0, -1.0);\n\
czm_material material = czm_getMaterial(materialInput);\n\
gl_FragColor = vec4(material.diffuse + material.emission, material.alpha);\n\
}\n\
";
});
/*global define*/
define('Scene/ViewportQuad',[
'../Core/BoundingRectangle',
'../Core/Color',
'../Core/defined',
'../Core/destroyObject',
'../Core/DeveloperError',
'../Renderer/Pass',
'../Renderer/RenderState',
'../Renderer/ShaderSource',
'../Shaders/ViewportQuadFS',
'./BlendingState',
'./Material'
], function(
BoundingRectangle,
Color,
defined,
destroyObject,
DeveloperError,
Pass,
RenderState,
ShaderSource,
ViewportQuadFS,
BlendingState,
Material) {
'use strict';
/**
* A viewport aligned quad.
*
* @alias ViewportQuad
* @constructor
*
* @param {BoundingRectangle} [rectangle] The {@link BoundingRectangle} defining the quad's position within the viewport.
* @param {Material} [material] The {@link Material} defining the surface appearance of the viewport quad.
*
* @example
* var viewportQuad = new Cesium.ViewportQuad(new Cesium.BoundingRectangle(0, 0, 80, 40));
* viewportQuad.material.uniforms.color = new Cesium.Color(1.0, 0.0, 0.0, 1.0);
*/
function ViewportQuad(rectangle, material) {
/**
* Determines if the viewport quad primitive will be shown.
*
* @type {Boolean}
* @default true
*/
this.show = true;
if (!defined(rectangle)) {
rectangle = new BoundingRectangle();
}
/**
* The BoundingRectangle defining the quad's position within the viewport.
*
* @type {BoundingRectangle}
*
* @example
* viewportQuad.rectangle = new Cesium.BoundingRectangle(0, 0, 80, 40);
*/
this.rectangle = BoundingRectangle.clone(rectangle);
if (!defined(material)) {
material = Material.fromType(Material.ColorType, {
color : new Color(1.0, 1.0, 1.0, 1.0)
});
}
/**
* The surface appearance of the viewport quad. This can be one of several built-in {@link Material} objects or a custom material, scripted with
* {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}.
* <p>
* The default material is <code>Material.ColorType</code>.
* </p>
*
* @type Material
*
* @example
* // 1. Change the color of the default material to yellow
* viewportQuad.material.uniforms.color = new Cesium.Color(1.0, 1.0, 0.0, 1.0);
*
* // 2. Change material to horizontal stripes
* viewportQuad.material = Cesium.Material.fromType(Cesium.Material.StripeType);
*
* @see {@link https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric|Fabric}
*/
this.material = material;
this._material = undefined;
this._overlayCommand = undefined;
this._rs = undefined;
}
/**
* Called when {@link Viewer} or {@link CesiumWidget} render the scene to
* get the draw commands needed to render this primitive.
* <p>
* Do not call this function directly. This is documented just to
* list the exceptions that may be propagated when the scene is rendered:
* </p>
*
* @exception {DeveloperError} this.material must be defined.
* @exception {DeveloperError} this.rectangle must be defined.
*/
ViewportQuad.prototype.update = function(frameState) {
if (!this.show) {
return;
}
if (!defined(this.material)) {
throw new DeveloperError('this.material must be defined.');
}
if (!defined(this.rectangle)) {
throw new DeveloperError('this.rectangle must be defined.');
}
var rs = this._rs;
if ((!defined(rs)) || !BoundingRectangle.equals(rs.viewport, this.rectangle)) {
this._rs = RenderState.fromCache({
blending : BlendingState.ALPHA_BLEND,
viewport : this.rectangle
});
}
var pass = frameState.passes;
if (pass.render) {
var context = frameState.context;
if (this._material !== this.material || !defined(this._overlayCommand)) {
// Recompile shader when material changes
this._material = this.material;
if (defined(this._overlayCommand)) {
this._overlayCommand.shaderProgram.destroy();
}
var fs = new ShaderSource({
sources : [this._material.shaderSource, ViewportQuadFS]
});
this._overlayCommand = context.createViewportQuadCommand(fs, {
renderState : this._rs,
uniformMap : this._material._uniforms,
owner : this
});
this._overlayCommand.pass = Pass.OVERLAY;
}
this._material.update(context);
this._overlayCommand.uniformMap = this._material._uniforms;
frameState.commandList.push(this._overlayCommand);
}
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @returns {Boolean} True if this object was destroyed; otherwise, false.
*
* @see ViewportQuad#destroy
*/
ViewportQuad.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
* release of WebGL resources, instead of relying on the garbage collector to destroy this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
*
* @example
* quad = quad && quad.destroy();
*
* @see ViewportQuad#isDestroyed
*/
ViewportQuad.prototype.destroy = function() {
if (defined(this._overlayCommand)) {
this._overlayCommand.shaderProgram = this._overlayCommand.shaderProgram && this._overlayCommand.shaderProgram.destroy();
}
return destroyObject(this);
};
return ViewportQuad;
});
/*global define*/
define('Scene/WebMapServiceImageryProvider',[
'../Core/combine',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/freezeObject',
'../Core/GeographicTilingScheme',
'../Core/objectToQuery',
'../Core/queryToObject',
'../Core/WebMercatorTilingScheme',
'../ThirdParty/Uri',
'./GetFeatureInfoFormat',
'./UrlTemplateImageryProvider'
], function(
combine,
defaultValue,
defined,
defineProperties,
DeveloperError,
freezeObject,
GeographicTilingScheme,
objectToQuery,
queryToObject,
WebMercatorTilingScheme,
Uri,
GetFeatureInfoFormat,
UrlTemplateImageryProvider) {
'use strict';
/**
* Provides tiled imagery hosted by a Web Map Service (WMS) server.
*
* @alias WebMapServiceImageryProvider
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {String} options.url The URL of the WMS service. The URL supports the same keywords as the {@link UrlTemplateImageryProvider}.
* @param {String} options.layers The layers to include, separated by commas.
* @param {Object} [options.parameters=WebMapServiceImageryProvider.DefaultParameters] Additional parameters
* to pass to the WMS server in the GetMap URL.
* @param {Object} [options.getFeatureInfoParameters=WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters] Additional
* parameters to pass to the WMS server in the GetFeatureInfo URL.
* @param {Boolean} [options.enablePickFeatures=true] If true, {@link WebMapServiceImageryProvider#pickFeatures} will invoke
* the GetFeatureInfo operation on the WMS server and return the features included in the response. If false,
* {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable features)
* without communicating with the server. Set this property to false if you know your WMS server does not support
* GetFeatureInfo or if you don't want this provider's features to be pickable. Note that this can be dynamically
* overridden by modifying the WebMapServiceImageryProvider#enablePickFeatures property.
* @param {GetFeatureInfoFormat[]} [options.getFeatureInfoFormats=WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats] The formats
* in which to try WMS GetFeatureInfo requests.
* @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle of the layer.
* @param {TilingScheme} [options.tilingScheme=new GeographicTilingScheme()] The tiling scheme to use to divide the world into tiles.
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If the tilingScheme is specified,
* this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
* parameter is specified, the WGS84 ellipsoid is used.
* @param {Number} [options.tileWidth=256] The width of each tile in pixels.
* @param {Number} [options.tileHeight=256] The height of each tile in pixels.
* @param {Number} [options.minimumLevel=0] The minimum level-of-detail supported by the imagery provider. Take care when
* specifying this that the number of tiles at the minimum level is small, such as four or less. A larger number is
* likely to result in rendering problems.
* @param {Number} [options.maximumLevel] The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
* If not specified, there is no limit.
* @param {Credit|String} [options.credit] A credit for the data source, which is displayed on the canvas.
* @param {Object} [options.proxy] A proxy to use for requests. This object is
* expected to have a getURL function which returns the proxied URL, if needed.
* @param {String|String[]} [options.subdomains='abc'] The subdomains to use for the <code>{s}</code> placeholder in the URL template.
* If this parameter is a single string, each character in the string is a subdomain. If it is
* an array, each element in the array is a subdomain.
*
* @see ArcGisMapServerImageryProvider
* @see BingMapsImageryProvider
* @see GoogleEarthImageryProvider
* @see createOpenStreetMapImageryProvider
* @see SingleTileImageryProvider
* @see createTileMapServiceImageryProvider
* @see WebMapTileServiceImageryProvider
* @see UrlTemplateImageryProvider
*
* @see {@link http://resources.esri.com/help/9.3/arcgisserver/apis/rest/|ArcGIS Server REST API}
* @see {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing}
*
* @example
* var provider = new Cesium.WebMapServiceImageryProvider({
* url : 'https://sampleserver1.arcgisonline.com/ArcGIS/services/Specialty/ESRI_StatesCitiesRivers_USA/MapServer/WMSServer',
* layers : '0',
* proxy: new Cesium.DefaultProxy('/proxy/')
* });
*
* viewer.imageryLayers.addImageryProvider(provider);
*/
function WebMapServiceImageryProvider(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(options.url)) {
throw new DeveloperError('options.url is required.');
}
if (!defined(options.layers)) {
throw new DeveloperError('options.layers is required.');
}
this._url = options.url;
this._layers = options.layers;
var getFeatureInfoFormats = defaultValue(options.getFeatureInfoFormats, WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats);
// Build the template URLs for tiles and pickFeatures.
var uri = new Uri(options.url);
var queryOptions = queryToObject(defaultValue(uri.query, ''));
var parameters = combine(objectToLowercase(defaultValue(options.parameters, defaultValue.EMPTY_OBJECT)), WebMapServiceImageryProvider.DefaultParameters);
queryOptions = combine(parameters, queryOptions);
var pickFeaturesUri;
var pickFeaturesQueryOptions;
pickFeaturesUri = new Uri(options.url);
pickFeaturesQueryOptions = queryToObject(defaultValue(pickFeaturesUri.query, ''));
var pickFeaturesParameters = combine(objectToLowercase(defaultValue(options.getFeatureInfoParameters, defaultValue.EMPTY_OBJECT)), WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters);
pickFeaturesQueryOptions = combine(pickFeaturesParameters, pickFeaturesQueryOptions);
function setParameter(name, value) {
if (!defined(queryOptions[name])) {
queryOptions[name] = value;
}
if (defined(pickFeaturesQueryOptions) && !defined(pickFeaturesQueryOptions[name])) {
pickFeaturesQueryOptions[name] = value;
}
}
setParameter('layers', options.layers);
setParameter('srs', options.tilingScheme instanceof WebMercatorTilingScheme ? 'EPSG:3857' : 'EPSG:4326');
setParameter('bbox', '{westProjected},{southProjected},{eastProjected},{northProjected}');
setParameter('width', '{width}');
setParameter('height', '{height}');
uri.query = objectToQuery(queryOptions);
// objectToQuery escapes the placeholders. Undo that.
var templateUrl = uri.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
var pickFeaturesTemplateUrl;
if (defined(pickFeaturesQueryOptions)) {
if (!defined(pickFeaturesQueryOptions.query_layers)) {
pickFeaturesQueryOptions.query_layers = options.layers;
}
if (!defined(pickFeaturesQueryOptions.x)) {
pickFeaturesQueryOptions.x = '{i}';
}
if (!defined(pickFeaturesQueryOptions.y)) {
pickFeaturesQueryOptions.y = '{j}';
}
if (!defined(pickFeaturesQueryOptions.info_format)) {
pickFeaturesQueryOptions.info_format = '{format}';
}
pickFeaturesUri.query = objectToQuery(pickFeaturesQueryOptions);
pickFeaturesTemplateUrl = pickFeaturesUri.toString().replace(/%7B/g, '{').replace(/%7D/g, '}');
}
// Let UrlTemplateImageryProvider do the actual URL building.
this._tileProvider = new UrlTemplateImageryProvider({
url : templateUrl,
pickFeaturesUrl : pickFeaturesTemplateUrl,
tilingScheme : defaultValue(options.tilingScheme, new GeographicTilingScheme({ ellipsoid : options.ellipsoid})),
rectangle : options.rectangle,
tileWidth : options.tileWidth,
tileHeight : options.tileHeight,
minimumLevel : options.minimumLevel,
maximumLevel : options.maximumLevel,
proxy : options.proxy,
subdomains: options.subdomains,
tileDiscardPolicy : options.tileDiscardPolicy,
credit : options.credit,
getFeatureInfoFormats : getFeatureInfoFormats,
enablePickFeatures: options.enablePickFeatures
});
}
defineProperties(WebMapServiceImageryProvider.prototype, {
/**
* Gets the URL of the WMS server.
* @memberof WebMapServiceImageryProvider.prototype
* @type {String}
* @readonly
*/
url : {
get : function() {
return this._url;
}
},
/**
* Gets the proxy used by this provider.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Proxy}
* @readonly
*/
proxy : {
get : function() {
return this._tileProvider.proxy;
}
},
/**
* Gets the names of the WMS layers, separated by commas.
* @memberof WebMapServiceImageryProvider.prototype
* @type {String}
* @readonly
*/
layers : {
get : function() {
return this._layers;
}
},
/**
* Gets the width of each tile, in pixels. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileWidth : {
get : function() {
return this._tileProvider.tileWidth;
}
},
/**
* Gets the height of each tile, in pixels. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileHeight : {
get : function() {
return this._tileProvider.tileHeight;
}
},
/**
* Gets the maximum level-of-detail that can be requested. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
maximumLevel : {
get : function() {
return this._tileProvider.maximumLevel;
}
},
/**
* Gets the minimum level-of-detail that can be requested. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
minimumLevel : {
get : function() {
return this._tileProvider.minimumLevel;
}
},
/**
* Gets the tiling scheme used by this provider. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {TilingScheme}
* @readonly
*/
tilingScheme : {
get : function() {
return this._tileProvider.tilingScheme;
}
},
/**
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Rectangle}
* @readonly
*/
rectangle : {
get : function() {
return this._tileProvider.rectangle;
}
},
/**
* Gets the tile discard policy. If not undefined, the discard policy is responsible
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
* returns undefined, no tiles are filtered. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {TileDiscardPolicy}
* @readonly
*/
tileDiscardPolicy : {
get : function() {
return this._tileProvider.tileDiscardPolicy;
}
},
/**
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Event}
* @readonly
*/
errorEvent : {
get : function() {
return this._tileProvider.errorEvent;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
ready : {
get : function() {
return this._tileProvider.ready;
}
},
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readyPromise : {
get : function() {
return this._tileProvider.readyPromise;
}
},
/**
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
* the source of the imagery. This function should not be called before {@link WebMapServiceImageryProvider#ready} returns true.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Credit}
* @readonly
*/
credit : {
get : function() {
return this._tileProvider.credit;
}
},
/**
* Gets a value indicating whether or not the images provided by this imagery provider
* include an alpha channel. If this property is false, an alpha channel, if present, will
* be ignored. If this property is true, any images without an alpha channel will be treated
* as if their alpha is 1.0 everywhere. When this property is false, memory usage
* and texture upload time are reduced.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
hasAlphaChannel : {
get : function() {
return this._tileProvider.hasAlphaChannel;
}
},
/**
* Gets or sets a value indicating whether feature picking is enabled. If true, {@link WebMapServiceImageryProvider#pickFeatures} will
* invoke the <code>GetFeatureInfo</code> service on the WMS server and attempt to interpret the features included in the response. If false,
* {@link WebMapServiceImageryProvider#pickFeatures} will immediately return undefined (indicating no pickable
* features) without communicating with the server. Set this property to false if you know your data
* source does not support picking features or if you don't want this provider's features to be pickable.
* @memberof WebMapServiceImageryProvider.prototype
* @type {Boolean}
* @default true
*/
enablePickFeatures : {
get : function() {
return this._tileProvider.enablePickFeatures;
},
set : function(enablePickFeatures) {
this._tileProvider.enablePickFeatures = enablePickFeatures;
}
}
});
/**
* Gets the credits to be displayed when a given tile is displayed.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level;
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
*
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
*/
WebMapServiceImageryProvider.prototype.getTileCredits = function(x, y, level) {
return this._tileProvider.getTileCredits(x, y, level);
};
/**
* Requests the image for a given tile. This function should
* not be called before {@link WebMapServiceImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Promise.<Image|Canvas>|undefined} A promise for the image that will resolve when the image is available, or
* undefined if there are too many active requests to the server, and the request
* should be retried later. The resolved image may be either an
* Image or a Canvas DOM object.
*
* @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready.
*/
WebMapServiceImageryProvider.prototype.requestImage = function(x, y, level) {
return this._tileProvider.requestImage(x, y, level);
};
/**
* Asynchronously determines what features, if any, are located at a given longitude and latitude within
* a tile. This function should not be called before {@link ImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @param {Number} longitude The longitude at which to pick features.
* @param {Number} latitude The latitude at which to pick features.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
* instances. The array may be empty if no features are found at the given location.
*
* @exception {DeveloperError} <code>pickFeatures</code> must not be called before the imagery provider is ready.
*/
WebMapServiceImageryProvider.prototype.pickFeatures = function(x, y, level, longitude, latitude) {
return this._tileProvider.pickFeatures(x, y, level, longitude, latitude);
};
/**
* The default parameters to include in the WMS URL to obtain images. The values are as follows:
* service=WMS
* version=1.1.1
* request=GetMap
* styles=
* format=image/jpeg
*
* @constant
*/
WebMapServiceImageryProvider.DefaultParameters = freezeObject({
service : 'WMS',
version : '1.1.1',
request : 'GetMap',
styles : '',
format : 'image/jpeg'
});
/**
* The default parameters to include in the WMS URL to get feature information. The values are as follows:
* service=WMS
* version=1.1.1
* request=GetFeatureInfo
*
* @constant
*/
WebMapServiceImageryProvider.GetFeatureInfoDefaultParameters = freezeObject({
service : 'WMS',
version : '1.1.1',
request : 'GetFeatureInfo'
});
WebMapServiceImageryProvider.DefaultGetFeatureInfoFormats = freezeObject([
freezeObject(new GetFeatureInfoFormat('json', 'application/json')),
freezeObject(new GetFeatureInfoFormat('xml', 'text/xml')),
freezeObject(new GetFeatureInfoFormat('text', 'text/html'))
]);
function objectToLowercase(obj) {
var result = {};
for ( var key in obj) {
if (obj.hasOwnProperty(key)) {
result[key.toLowerCase()] = obj[key];
}
}
return result;
}
return WebMapServiceImageryProvider;
});
/*global define*/
define('Scene/WebMapTileServiceImageryProvider',[
'../Core/combine',
'../Core/Credit',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/Event',
'../Core/freezeObject',
'../Core/isArray',
'../Core/objectToQuery',
'../Core/queryToObject',
'../Core/Rectangle',
'../Core/WebMercatorTilingScheme',
'../ThirdParty/Uri',
'../ThirdParty/when',
'./ImageryProvider'
], function(
combine,
Credit,
defaultValue,
defined,
defineProperties,
DeveloperError,
Event,
freezeObject,
isArray,
objectToQuery,
queryToObject,
Rectangle,
WebMercatorTilingScheme,
Uri,
when,
ImageryProvider) {
'use strict';
/**
* Provides tiled imagery served by {@link http://www.opengeospatial.org/standards/wmts|WMTS 1.0.0} compliant servers.
* This provider supports HTTP KVP-encoded and RESTful GetTile requests, but does not yet support the SOAP encoding.
*
* @alias WebMapTileServiceImageryProvider
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {String} options.url The base URL for the WMTS GetTile operation (for KVP-encoded requests) or the tile-URL template (for RESTful requests). The tile-URL template should contain the following variables: {style}, {TileMatrixSet}, {TileMatrix}, {TileRow}, {TileCol}. The first two are optional if actual values are hardcoded or not required by the server. The {s} keyword may be used to specify subdomains.
* @param {String} [options.format='image/jpeg'] The MIME type for images to retrieve from the server.
* @param {String} options.layer The layer name for WMTS requests.
* @param {String} options.style The style name for WMTS requests.
* @param {String} options.tileMatrixSetID The identifier of the TileMatrixSet to use for WMTS requests.
* @param {Array} [options.tileMatrixLabels] A list of identifiers in the TileMatrix to use for WMTS requests, one per TileMatrix level.
* @param {Number} [options.tileWidth=256] The tile width in pixels.
* @param {Number} [options.tileHeight=256] The tile height in pixels.
* @param {TilingScheme} [options.tilingScheme] The tiling scheme corresponding to the organization of the tiles in the TileMatrixSet.
* @param {Object} [options.proxy] A proxy to use for requests. This object is expected to have a getURL function which returns the proxied URL.
* @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle covered by the layer.
* @param {Number} [options.minimumLevel=0] The minimum level-of-detail supported by the imagery provider.
* @param {Number} [options.maximumLevel] The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
* @param {Ellipsoid} [options.ellipsoid] The ellipsoid. If not specified, the WGS84 ellipsoid is used.
* @param {Credit|String} [options.credit] A credit for the data source, which is displayed on the canvas.
* @param {String|String[]} [options.subdomains='abc'] The subdomains to use for the <code>{s}</code> placeholder in the URL template.
* If this parameter is a single string, each character in the string is a subdomain. If it is
* an array, each element in the array is a subdomain.
*
*
* @example
* // Example 1. USGS shaded relief tiles (KVP)
* var shadedRelief1 = new Cesium.WebMapTileServiceImageryProvider({
* url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS',
* layer : 'USGSShadedReliefOnly',
* style : 'default',
* format : 'image/jpeg',
* tileMatrixSetID : 'default028mm',
* // tileMatrixLabels : ['default028mm:0', 'default028mm:1', 'default028mm:2' ...],
* maximumLevel: 19,
* credit : new Cesium.Credit('U. S. Geological Survey')
* });
* viewer.imageryLayers.addImageryProvider(shadedRelief1);
*
* @example
* // Example 2. USGS shaded relief tiles (RESTful)
* var shadedRelief2 = new Cesium.WebMapTileServiceImageryProvider({
* url : 'http://basemap.nationalmap.gov/arcgis/rest/services/USGSShadedReliefOnly/MapServer/WMTS/tile/1.0.0/USGSShadedReliefOnly/{Style}/{TileMatrixSet}/{TileMatrix}/{TileRow}/{TileCol}.jpg',
* layer : 'USGSShadedReliefOnly',
* style : 'default',
* format : 'image/jpeg',
* tileMatrixSetID : 'default028mm',
* maximumLevel: 19,
* credit : new Cesium.Credit('U. S. Geological Survey')
* });
* viewer.imageryLayers.addImageryProvider(shadedRelief2);
*
* @see ArcGisMapServerImageryProvider
* @see BingMapsImageryProvider
* @see GoogleEarthImageryProvider
* @see createOpenStreetMapImageryProvider
* @see SingleTileImageryProvider
* @see createTileMapServiceImageryProvider
* @see WebMapServiceImageryProvider
* @see UrlTemplateImageryProvider
*/
function WebMapTileServiceImageryProvider(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(options.url)) {
throw new DeveloperError('options.url is required.');
}
if (!defined(options.layer)) {
throw new DeveloperError('options.layer is required.');
}
if (!defined(options.style)) {
throw new DeveloperError('options.style is required.');
}
if (!defined(options.tileMatrixSetID)) {
throw new DeveloperError('options.tileMatrixSetID is required.');
}
this._url = options.url;
this._layer = options.layer;
this._style = options.style;
this._tileMatrixSetID = options.tileMatrixSetID;
this._tileMatrixLabels = options.tileMatrixLabels;
this._format = defaultValue(options.format, 'image/jpeg');
this._proxy = options.proxy;
this._tileDiscardPolicy = options.tileDiscardPolicy;
this._tilingScheme = defined(options.tilingScheme) ? options.tilingScheme : new WebMercatorTilingScheme({ ellipsoid : options.ellipsoid });
this._tileWidth = defaultValue(options.tileWidth, 256);
this._tileHeight = defaultValue(options.tileHeight, 256);
this._minimumLevel = defaultValue(options.minimumLevel, 0);
this._maximumLevel = options.maximumLevel;
this._rectangle = defaultValue(options.rectangle, this._tilingScheme.rectangle);
this._readyPromise = when.resolve(true);
// Check the number of tiles at the minimum level. If it's more than four,
// throw an exception, because starting at the higher minimum
// level will cause too many tiles to be downloaded and rendered.
var swTile = this._tilingScheme.positionToTileXY(Rectangle.southwest(this._rectangle), this._minimumLevel);
var neTile = this._tilingScheme.positionToTileXY(Rectangle.northeast(this._rectangle), this._minimumLevel);
var tileCount = (Math.abs(neTile.x - swTile.x) + 1) * (Math.abs(neTile.y - swTile.y) + 1);
if (tileCount > 4) {
throw new DeveloperError('The imagery provider\'s rectangle and minimumLevel indicate that there are ' + tileCount + ' tiles at the minimum level. Imagery providers with more than four tiles at the minimum level are not supported.');
}
this._errorEvent = new Event();
var credit = options.credit;
this._credit = typeof credit === 'string' ? new Credit(credit) : credit;
this._subdomains = options.subdomains;
if (isArray(this._subdomains)) {
this._subdomains = this._subdomains.slice();
} else if (defined(this._subdomains) && this._subdomains.length > 0) {
this._subdomains = this._subdomains.split('');
} else {
this._subdomains = ['a', 'b', 'c'];
}
}
var defaultParameters = freezeObject({
service : 'WMTS',
version : '1.0.0',
request : 'GetTile'
});
function buildImageUrl(imageryProvider, col, row, level) {
var labels = imageryProvider._tileMatrixLabels;
var tileMatrix = defined(labels) ? labels[level] : level.toString();
var subdomains = imageryProvider._subdomains;
var url;
if (imageryProvider._url.indexOf('{') >= 0) {
// resolve tile-URL template
url = imageryProvider._url
.replace('{style}', imageryProvider._style)
.replace('{Style}', imageryProvider._style)
.replace('{TileMatrixSet}', imageryProvider._tileMatrixSetID)
.replace('{TileMatrix}', tileMatrix)
.replace('{TileRow}', row.toString())
.replace('{TileCol}', col.toString())
.replace('{s}', subdomains[(col + row + level) % subdomains.length]);
}
else {
// build KVP request
var uri = new Uri(imageryProvider._url);
var queryOptions = queryToObject(defaultValue(uri.query, ''));
queryOptions = combine(defaultParameters, queryOptions);
queryOptions.tilematrix = tileMatrix;
queryOptions.layer = imageryProvider._layer;
queryOptions.style = imageryProvider._style;
queryOptions.tilerow = row;
queryOptions.tilecol = col;
queryOptions.tilematrixset = imageryProvider._tileMatrixSetID;
queryOptions.format = imageryProvider._format;
uri.query = objectToQuery(queryOptions);
url = uri.toString();
}
var proxy = imageryProvider._proxy;
if (defined(proxy)) {
url = proxy.getURL(url);
}
return url;
}
defineProperties(WebMapTileServiceImageryProvider.prototype, {
/**
* Gets the URL of the service hosting the imagery.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {String}
* @readonly
*/
url : {
get : function() {
return this._url;
}
},
/**
* Gets the proxy used by this provider.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Proxy}
* @readonly
*/
proxy : {
get : function() {
return this._proxy;
}
},
/**
* Gets the width of each tile, in pixels. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileWidth : {
get : function() {
return this._tileWidth;
}
},
/**
* Gets the height of each tile, in pixels. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
tileHeight : {
get : function() {
return this._tileHeight;
}
},
/**
* Gets the maximum level-of-detail that can be requested. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
maximumLevel : {
get : function() {
return this._maximumLevel;
}
},
/**
* Gets the minimum level-of-detail that can be requested. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Number}
* @readonly
*/
minimumLevel : {
get : function() {
return this._minimumLevel;
}
},
/**
* Gets the tiling scheme used by this provider. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {TilingScheme}
* @readonly
*/
tilingScheme : {
get : function() {
return this._tilingScheme;
}
},
/**
* Gets the rectangle, in radians, of the imagery provided by this instance. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Rectangle}
* @readonly
*/
rectangle : {
get : function() {
return this._rectangle;
}
},
/**
* Gets the tile discard policy. If not undefined, the discard policy is responsible
* for filtering out "missing" tiles via its shouldDiscardImage function. If this function
* returns undefined, no tiles are filtered. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {TileDiscardPolicy}
* @readonly
*/
tileDiscardPolicy : {
get : function() {
return this._tileDiscardPolicy;
}
},
/**
* Gets an event that is raised when the imagery provider encounters an asynchronous error. By subscribing
* to the event, you will be notified of the error and can potentially recover from it. Event listeners
* are passed an instance of {@link TileProviderError}.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Event}
* @readonly
*/
errorEvent : {
get : function() {
return this._errorEvent;
}
},
/**
* Gets the mime type of images returned by this imagery provider.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {String}
* @readonly
*/
format : {
get : function() {
return this._format;
}
},
/**
* Gets a value indicating whether or not the provider is ready for use.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
ready : {
value: true
},
/**
* Gets a promise that resolves to true when the provider is ready for use.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Promise.<Boolean>}
* @readonly
*/
readyPromise : {
get : function() {
return this._readyPromise;
}
},
/**
* Gets the credit to display when this imagery provider is active. Typically this is used to credit
* the source of the imagery. This function should not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Credit}
* @readonly
*/
credit : {
get : function() {
return this._credit;
}
},
/**
* Gets a value indicating whether or not the images provided by this imagery provider
* include an alpha channel. If this property is false, an alpha channel, if present, will
* be ignored. If this property is true, any images without an alpha channel will be treated
* as if their alpha is 1.0 everywhere. When this property is false, memory usage
* and texture upload time are reduced.
* @memberof WebMapTileServiceImageryProvider.prototype
* @type {Boolean}
* @readonly
*/
hasAlphaChannel : {
get : function() {
return true;
}
}
});
/**
* Gets the credits to be displayed when a given tile is displayed.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level;
* @returns {Credit[]} The credits to be displayed when the tile is displayed.
*
* @exception {DeveloperError} <code>getTileCredits</code> must not be called before the imagery provider is ready.
*/
WebMapTileServiceImageryProvider.prototype.getTileCredits = function(x, y, level) {
return undefined;
};
/**
* Requests the image for a given tile. This function should
* not be called before {@link WebMapTileServiceImageryProvider#ready} returns true.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @returns {Promise.<Image|Canvas>|undefined} A promise for the image that will resolve when the image is available, or
* undefined if there are too many active requests to the server, and the request
* should be retried later. The resolved image may be either an
* Image or a Canvas DOM object.
*
* @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready.
*/
WebMapTileServiceImageryProvider.prototype.requestImage = function(x, y, level) {
var url = buildImageUrl(this, x, y, level);
return ImageryProvider.loadImage(this, url);
};
/**
* Picking features is not currently supported by this imagery provider, so this function simply returns
* undefined.
*
* @param {Number} x The tile X coordinate.
* @param {Number} y The tile Y coordinate.
* @param {Number} level The tile level.
* @param {Number} longitude The longitude at which to pick features.
* @param {Number} latitude The latitude at which to pick features.
* @return {Promise.<ImageryLayerFeatureInfo[]>|undefined} A promise for the picked features that will resolve when the asynchronous
* picking completes. The resolved value is an array of {@link ImageryLayerFeatureInfo}
* instances. The array may be empty if no features are found at the given location.
* It may also be undefined if picking is not supported.
*/
WebMapTileServiceImageryProvider.prototype.pickFeatures = function() {
return undefined;
};
return WebMapTileServiceImageryProvider;
});
/*!
* Knockout JavaScript library v3.4.0
* (c) Steven Sanderson - http://knockoutjs.com/
* License: MIT (http://www.opensource.org/licenses/mit-license.php)
*/
(function() {(function(n){var x=this||(0,eval)("this"),u=x.document,M=x.navigator,v=x.jQuery,F=x.JSON;(function(n){"function"===typeof define&&define.amd?define('ThirdParty/knockout-3.4.0',["exports","require"],n):"object"===typeof exports&&"object"===typeof module?n(module.exports||exports):n(x.ko={})})(function(N,O){function J(a,c){return null===a||typeof a in T?a===c:!1}function U(b,c){var d;return function(){d||(d=a.a.setTimeout(function(){d=n;b()},c))}}function V(b,c){var d;return function(){clearTimeout(d);d=a.a.setTimeout(b,c)}}function W(a,
c){c&&c!==I?"beforeChange"===c?this.Kb(a):this.Ha(a,c):this.Lb(a)}function X(a,c){null!==c&&c.k&&c.k()}function Y(a,c){var d=this.Hc,e=d[s];e.R||(this.lb&&this.Ma[c]?(d.Pb(c,a,this.Ma[c]),this.Ma[c]=null,--this.lb):e.r[c]||d.Pb(c,a,e.s?{ia:a}:d.uc(a)))}function K(b,c,d,e){a.d[b]={init:function(b,g,k,l,m){var h,r;a.m(function(){var q=a.a.c(g()),p=!d!==!q,A=!r;if(A||c||p!==h)A&&a.va.Aa()&&(r=a.a.ua(a.f.childNodes(b),!0)),p?(A||a.f.da(b,a.a.ua(r)),a.eb(e?e(m,q):m,b)):a.f.xa(b),h=p},null,{i:b});return{controlsDescendantBindings:!0}}};
a.h.ta[b]=!1;a.f.Z[b]=!0}var a="undefined"!==typeof N?N:{};a.b=function(b,c){for(var d=b.split("."),e=a,f=0;f<d.length-1;f++)e=e[d[f]];e[d[d.length-1]]=c};a.G=function(a,c,d){a[c]=d};a.version="3.4.0";a.b("version",a.version);a.options={deferUpdates:!1,useOnlyNativeEvents:!1};a.a=function(){function b(a,b){for(var c in a)a.hasOwnProperty(c)&&b(c,a[c])}function c(a,b){if(b)for(var c in b)b.hasOwnProperty(c)&&(a[c]=b[c]);return a}function d(a,b){a.__proto__=b;return a}function e(b,c,d,e){var h=b[c].match(r)||
[];a.a.q(d.match(r),function(b){a.a.pa(h,b,e)});b[c]=h.join(" ")}var f={__proto__:[]}instanceof Array,g="function"===typeof Symbol,k={},l={};k[M&&/Firefox\/2/i.test(M.userAgent)?"KeyboardEvent":"UIEvents"]=["keyup","keydown","keypress"];k.MouseEvents="click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave".split(" ");b(k,function(a,b){if(b.length)for(var c=0,d=b.length;c<d;c++)l[b[c]]=a});var m={propertychange:!0},h=u&&function(){for(var a=3,b=u.createElement("div"),c=
b.getElementsByTagName("i");b.innerHTML="\x3c!--[if gt IE "+ ++a+"]><i></i><![endif]--\x3e",c[0];);return 4<a?a:n}(),r=/\S+/g;return{cc:["authenticity_token",/^__RequestVerificationToken(_.*)?$/],q:function(a,b){for(var c=0,d=a.length;c<d;c++)b(a[c],c)},o:function(a,b){if("function"==typeof Array.prototype.indexOf)return Array.prototype.indexOf.call(a,b);for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1},Sb:function(a,b,c){for(var d=0,e=a.length;d<e;d++)if(b.call(c,a[d],d))return a[d];
return null},La:function(b,c){var d=a.a.o(b,c);0<d?b.splice(d,1):0===d&&b.shift()},Tb:function(b){b=b||[];for(var c=[],d=0,e=b.length;d<e;d++)0>a.a.o(c,b[d])&&c.push(b[d]);return c},fb:function(a,b){a=a||[];for(var c=[],d=0,e=a.length;d<e;d++)c.push(b(a[d],d));return c},Ka:function(a,b){a=a||[];for(var c=[],d=0,e=a.length;d<e;d++)b(a[d],d)&&c.push(a[d]);return c},ra:function(a,b){if(b instanceof Array)a.push.apply(a,b);else for(var c=0,d=b.length;c<d;c++)a.push(b[c]);return a},pa:function(b,c,d){var e=
a.a.o(a.a.zb(b),c);0>e?d&&b.push(c):d||b.splice(e,1)},ka:f,extend:c,Xa:d,Ya:f?d:c,D:b,Ca:function(a,b){if(!a)return a;var c={},d;for(d in a)a.hasOwnProperty(d)&&(c[d]=b(a[d],d,a));return c},ob:function(b){for(;b.firstChild;)a.removeNode(b.firstChild)},jc:function(b){b=a.a.V(b);for(var c=(b[0]&&b[0].ownerDocument||u).createElement("div"),d=0,e=b.length;d<e;d++)c.appendChild(a.$(b[d]));return c},ua:function(b,c){for(var d=0,e=b.length,h=[];d<e;d++){var m=b[d].cloneNode(!0);h.push(c?a.$(m):m)}return h},
da:function(b,c){a.a.ob(b);if(c)for(var d=0,e=c.length;d<e;d++)b.appendChild(c[d])},qc:function(b,c){var d=b.nodeType?[b]:b;if(0<d.length){for(var e=d[0],h=e.parentNode,m=0,l=c.length;m<l;m++)h.insertBefore(c[m],e);m=0;for(l=d.length;m<l;m++)a.removeNode(d[m])}},za:function(a,b){if(a.length){for(b=8===b.nodeType&&b.parentNode||b;a.length&&a[0].parentNode!==b;)a.splice(0,1);for(;1<a.length&&a[a.length-1].parentNode!==b;)a.length--;if(1<a.length){var c=a[0],d=a[a.length-1];for(a.length=0;c!==d;)a.push(c),
c=c.nextSibling;a.push(d)}}return a},sc:function(a,b){7>h?a.setAttribute("selected",b):a.selected=b},$a:function(a){return null===a||a===n?"":a.trim?a.trim():a.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g,"")},nd:function(a,b){a=a||"";return b.length>a.length?!1:a.substring(0,b.length)===b},Mc:function(a,b){if(a===b)return!0;if(11===a.nodeType)return!1;if(b.contains)return b.contains(3===a.nodeType?a.parentNode:a);if(b.compareDocumentPosition)return 16==(b.compareDocumentPosition(a)&16);for(;a&&a!=
b;)a=a.parentNode;return!!a},nb:function(b){return a.a.Mc(b,b.ownerDocument.documentElement)},Qb:function(b){return!!a.a.Sb(b,a.a.nb)},A:function(a){return a&&a.tagName&&a.tagName.toLowerCase()},Wb:function(b){return a.onError?function(){try{return b.apply(this,arguments)}catch(c){throw a.onError&&a.onError(c),c;}}:b},setTimeout:function(b,c){return setTimeout(a.a.Wb(b),c)},$b:function(b){setTimeout(function(){a.onError&&a.onError(b);throw b;},0)},p:function(b,c,d){var e=a.a.Wb(d);d=h&&m[c];if(a.options.useOnlyNativeEvents||
d||!v)if(d||"function"!=typeof b.addEventListener)if("undefined"!=typeof b.attachEvent){var l=function(a){e.call(b,a)},f="on"+c;b.attachEvent(f,l);a.a.F.oa(b,function(){b.detachEvent(f,l)})}else throw Error("Browser doesn't support addEventListener or attachEvent");else b.addEventListener(c,e,!1);else v(b).bind(c,e)},Da:function(b,c){if(!b||!b.nodeType)throw Error("element must be a DOM node when calling triggerEvent");var d;"input"===a.a.A(b)&&b.type&&"click"==c.toLowerCase()?(d=b.type,d="checkbox"==
d||"radio"==d):d=!1;if(a.options.useOnlyNativeEvents||!v||d)if("function"==typeof u.createEvent)if("function"==typeof b.dispatchEvent)d=u.createEvent(l[c]||"HTMLEvents"),d.initEvent(c,!0,!0,x,0,0,0,0,0,!1,!1,!1,!1,0,b),b.dispatchEvent(d);else throw Error("The supplied element doesn't support dispatchEvent");else if(d&&b.click)b.click();else if("undefined"!=typeof b.fireEvent)b.fireEvent("on"+c);else throw Error("Browser doesn't support triggering events");else v(b).trigger(c)},c:function(b){return a.H(b)?
b():b},zb:function(b){return a.H(b)?b.t():b},bb:function(b,c,d){var h;c&&("object"===typeof b.classList?(h=b.classList[d?"add":"remove"],a.a.q(c.match(r),function(a){h.call(b.classList,a)})):"string"===typeof b.className.baseVal?e(b.className,"baseVal",c,d):e(b,"className",c,d))},Za:function(b,c){var d=a.a.c(c);if(null===d||d===n)d="";var e=a.f.firstChild(b);!e||3!=e.nodeType||a.f.nextSibling(e)?a.f.da(b,[b.ownerDocument.createTextNode(d)]):e.data=d;a.a.Rc(b)},rc:function(a,b){a.name=b;if(7>=h)try{a.mergeAttributes(u.createElement("<input name='"+
a.name+"'/>"),!1)}catch(c){}},Rc:function(a){9<=h&&(a=1==a.nodeType?a:a.parentNode,a.style&&(a.style.zoom=a.style.zoom))},Nc:function(a){if(h){var b=a.style.width;a.style.width=0;a.style.width=b}},hd:function(b,c){b=a.a.c(b);c=a.a.c(c);for(var d=[],e=b;e<=c;e++)d.push(e);return d},V:function(a){for(var b=[],c=0,d=a.length;c<d;c++)b.push(a[c]);return b},Yb:function(a){return g?Symbol(a):a},rd:6===h,sd:7===h,C:h,ec:function(b,c){for(var d=a.a.V(b.getElementsByTagName("input")).concat(a.a.V(b.getElementsByTagName("textarea"))),
e="string"==typeof c?function(a){return a.name===c}:function(a){return c.test(a.name)},h=[],m=d.length-1;0<=m;m--)e(d[m])&&h.push(d[m]);return h},ed:function(b){return"string"==typeof b&&(b=a.a.$a(b))?F&&F.parse?F.parse(b):(new Function("return "+b))():null},Eb:function(b,c,d){if(!F||!F.stringify)throw Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js");
return F.stringify(a.a.c(b),c,d)},fd:function(c,d,e){e=e||{};var h=e.params||{},m=e.includeFields||this.cc,l=c;if("object"==typeof c&&"form"===a.a.A(c))for(var l=c.action,f=m.length-1;0<=f;f--)for(var g=a.a.ec(c,m[f]),k=g.length-1;0<=k;k--)h[g[k].name]=g[k].value;d=a.a.c(d);var r=u.createElement("form");r.style.display="none";r.action=l;r.method="post";for(var n in d)c=u.createElement("input"),c.type="hidden",c.name=n,c.value=a.a.Eb(a.a.c(d[n])),r.appendChild(c);b(h,function(a,b){var c=u.createElement("input");
c.type="hidden";c.name=a;c.value=b;r.appendChild(c)});u.body.appendChild(r);e.submitter?e.submitter(r):r.submit();setTimeout(function(){r.parentNode.removeChild(r)},0)}}}();a.b("utils",a.a);a.b("utils.arrayForEach",a.a.q);a.b("utils.arrayFirst",a.a.Sb);a.b("utils.arrayFilter",a.a.Ka);a.b("utils.arrayGetDistinctValues",a.a.Tb);a.b("utils.arrayIndexOf",a.a.o);a.b("utils.arrayMap",a.a.fb);a.b("utils.arrayPushAll",a.a.ra);a.b("utils.arrayRemoveItem",a.a.La);a.b("utils.extend",a.a.extend);a.b("utils.fieldsIncludedWithJsonPost",
a.a.cc);a.b("utils.getFormFields",a.a.ec);a.b("utils.peekObservable",a.a.zb);a.b("utils.postJson",a.a.fd);a.b("utils.parseJson",a.a.ed);a.b("utils.registerEventHandler",a.a.p);a.b("utils.stringifyJson",a.a.Eb);a.b("utils.range",a.a.hd);a.b("utils.toggleDomNodeCssClass",a.a.bb);a.b("utils.triggerEvent",a.a.Da);a.b("utils.unwrapObservable",a.a.c);a.b("utils.objectForEach",a.a.D);a.b("utils.addOrRemoveItem",a.a.pa);a.b("utils.setTextContent",a.a.Za);a.b("unwrap",a.a.c);Function.prototype.bind||(Function.prototype.bind=
function(a){var c=this;if(1===arguments.length)return function(){return c.apply(a,arguments)};var d=Array.prototype.slice.call(arguments,1);return function(){var e=d.slice(0);e.push.apply(e,arguments);return c.apply(a,e)}});a.a.e=new function(){function a(b,g){var k=b[d];if(!k||"null"===k||!e[k]){if(!g)return n;k=b[d]="ko"+c++;e[k]={}}return e[k]}var c=0,d="__ko__"+(new Date).getTime(),e={};return{get:function(c,d){var e=a(c,!1);return e===n?n:e[d]},set:function(c,d,e){if(e!==n||a(c,!1)!==n)a(c,!0)[d]=
e},clear:function(a){var b=a[d];return b?(delete e[b],a[d]=null,!0):!1},I:function(){return c++ +d}}};a.b("utils.domData",a.a.e);a.b("utils.domData.clear",a.a.e.clear);a.a.F=new function(){function b(b,c){var e=a.a.e.get(b,d);e===n&&c&&(e=[],a.a.e.set(b,d,e));return e}function c(d){var e=b(d,!1);if(e)for(var e=e.slice(0),l=0;l<e.length;l++)e[l](d);a.a.e.clear(d);a.a.F.cleanExternalData(d);if(f[d.nodeType])for(e=d.firstChild;d=e;)e=d.nextSibling,8===d.nodeType&&c(d)}var d=a.a.e.I(),e={1:!0,8:!0,9:!0},
f={1:!0,9:!0};return{oa:function(a,c){if("function"!=typeof c)throw Error("Callback must be a function");b(a,!0).push(c)},pc:function(c,e){var l=b(c,!1);l&&(a.a.La(l,e),0==l.length&&a.a.e.set(c,d,n))},$:function(b){if(e[b.nodeType]&&(c(b),f[b.nodeType])){var d=[];a.a.ra(d,b.getElementsByTagName("*"));for(var l=0,m=d.length;l<m;l++)c(d[l])}return b},removeNode:function(b){a.$(b);b.parentNode&&b.parentNode.removeChild(b)},cleanExternalData:function(a){v&&"function"==typeof v.cleanData&&v.cleanData([a])}}};
a.$=a.a.F.$;a.removeNode=a.a.F.removeNode;a.b("cleanNode",a.$);a.b("removeNode",a.removeNode);a.b("utils.domNodeDisposal",a.a.F);a.b("utils.domNodeDisposal.addDisposeCallback",a.a.F.oa);a.b("utils.domNodeDisposal.removeDisposeCallback",a.a.F.pc);(function(){var b=[0,"",""],c=[1,"<table>","</table>"],d=[3,"<table><tbody><tr>","</tr></tbody></table>"],e=[1,"<select multiple='multiple'>","</select>"],f={thead:c,tbody:c,tfoot:c,tr:[2,"<table><tbody>","</tbody></table>"],td:d,th:d,option:e,optgroup:e},
g=8>=a.a.C;a.a.ma=function(c,d){var e;if(v)if(v.parseHTML)e=v.parseHTML(c,d)||[];else{if((e=v.clean([c],d))&&e[0]){for(var h=e[0];h.parentNode&&11!==h.parentNode.nodeType;)h=h.parentNode;h.parentNode&&h.parentNode.removeChild(h)}}else{(e=d)||(e=u);var h=e.parentWindow||e.defaultView||x,r=a.a.$a(c).toLowerCase(),q=e.createElement("div"),p;p=(r=r.match(/^<([a-z]+)[ >]/))&&f[r[1]]||b;r=p[0];p="ignored<div>"+p[1]+c+p[2]+"</div>";"function"==typeof h.innerShiv?q.appendChild(h.innerShiv(p)):(g&&e.appendChild(q),
q.innerHTML=p,g&&q.parentNode.removeChild(q));for(;r--;)q=q.lastChild;e=a.a.V(q.lastChild.childNodes)}return e};a.a.Cb=function(b,c){a.a.ob(b);c=a.a.c(c);if(null!==c&&c!==n)if("string"!=typeof c&&(c=c.toString()),v)v(b).html(c);else for(var d=a.a.ma(c,b.ownerDocument),e=0;e<d.length;e++)b.appendChild(d[e])}})();a.b("utils.parseHtmlFragment",a.a.ma);a.b("utils.setHtml",a.a.Cb);a.M=function(){function b(c,e){if(c)if(8==c.nodeType){var f=a.M.lc(c.nodeValue);null!=f&&e.push({Lc:c,cd:f})}else if(1==c.nodeType)for(var f=
0,g=c.childNodes,k=g.length;f<k;f++)b(g[f],e)}var c={};return{wb:function(a){if("function"!=typeof a)throw Error("You can only pass a function to ko.memoization.memoize()");var b=(4294967296*(1+Math.random())|0).toString(16).substring(1)+(4294967296*(1+Math.random())|0).toString(16).substring(1);c[b]=a;return"\x3c!--[ko_memo:"+b+"]--\x3e"},xc:function(a,b){var f=c[a];if(f===n)throw Error("Couldn't find any memo with ID "+a+". Perhaps it's already been unmemoized.");try{return f.apply(null,b||[]),
!0}finally{delete c[a]}},yc:function(c,e){var f=[];b(c,f);for(var g=0,k=f.length;g<k;g++){var l=f[g].Lc,m=[l];e&&a.a.ra(m,e);a.M.xc(f[g].cd,m);l.nodeValue="";l.parentNode&&l.parentNode.removeChild(l)}},lc:function(a){return(a=a.match(/^\[ko_memo\:(.*?)\]$/))?a[1]:null}}}();a.b("memoization",a.M);a.b("memoization.memoize",a.M.wb);a.b("memoization.unmemoize",a.M.xc);a.b("memoization.parseMemoText",a.M.lc);a.b("memoization.unmemoizeDomNodeAndDescendants",a.M.yc);a.Y=function(){function b(){if(e)for(var b=
e,c=0,m;g<e;)if(m=d[g++]){if(g>b){if(5E3<=++c){g=e;a.a.$b(Error("'Too much recursion' after processing "+c+" task groups."));break}b=e}try{m()}catch(h){a.a.$b(h)}}}function c(){b();g=e=d.length=0}var d=[],e=0,f=1,g=0;return{scheduler:x.MutationObserver?function(a){var b=u.createElement("div");(new MutationObserver(a)).observe(b,{attributes:!0});return function(){b.classList.toggle("foo")}}(c):u&&"onreadystatechange"in u.createElement("script")?function(a){var b=u.createElement("script");b.onreadystatechange=
function(){b.onreadystatechange=null;u.documentElement.removeChild(b);b=null;a()};u.documentElement.appendChild(b)}:function(a){setTimeout(a,0)},Wa:function(b){e||a.Y.scheduler(c);d[e++]=b;return f++},cancel:function(a){a-=f-e;a>=g&&a<e&&(d[a]=null)},resetForTesting:function(){var a=e-g;g=e=d.length=0;return a},md:b}}();a.b("tasks",a.Y);a.b("tasks.schedule",a.Y.Wa);a.b("tasks.runEarly",a.Y.md);a.ya={throttle:function(b,c){b.throttleEvaluation=c;var d=null;return a.B({read:b,write:function(e){clearTimeout(d);
d=a.a.setTimeout(function(){b(e)},c)}})},rateLimit:function(a,c){var d,e,f;"number"==typeof c?d=c:(d=c.timeout,e=c.method);a.cb=!1;f="notifyWhenChangesStop"==e?V:U;a.Ta(function(a){return f(a,d)})},deferred:function(b,c){if(!0!==c)throw Error("The 'deferred' extender only accepts the value 'true', because it is not supported to turn deferral off once enabled.");b.cb||(b.cb=!0,b.Ta(function(c){var e;return function(){a.Y.cancel(e);e=a.Y.Wa(c);b.notifySubscribers(n,"dirty")}}))},notify:function(a,c){a.equalityComparer=
"always"==c?null:J}};var T={undefined:1,"boolean":1,number:1,string:1};a.b("extenders",a.ya);a.vc=function(b,c,d){this.ia=b;this.gb=c;this.Kc=d;this.R=!1;a.G(this,"dispose",this.k)};a.vc.prototype.k=function(){this.R=!0;this.Kc()};a.J=function(){a.a.Ya(this,D);D.rb(this)};var I="change",D={rb:function(a){a.K={};a.Nb=1},X:function(b,c,d){var e=this;d=d||I;var f=new a.vc(e,c?b.bind(c):b,function(){a.a.La(e.K[d],f);e.Ia&&e.Ia(d)});e.sa&&e.sa(d);e.K[d]||(e.K[d]=[]);e.K[d].push(f);return f},notifySubscribers:function(b,
c){c=c||I;c===I&&this.zc();if(this.Pa(c))try{a.l.Ub();for(var d=this.K[c].slice(0),e=0,f;f=d[e];++e)f.R||f.gb(b)}finally{a.l.end()}},Na:function(){return this.Nb},Uc:function(a){return this.Na()!==a},zc:function(){++this.Nb},Ta:function(b){var c=this,d=a.H(c),e,f,g;c.Ha||(c.Ha=c.notifySubscribers,c.notifySubscribers=W);var k=b(function(){c.Mb=!1;d&&g===c&&(g=c());e=!1;c.tb(f,g)&&c.Ha(f=g)});c.Lb=function(a){c.Mb=e=!0;g=a;k()};c.Kb=function(a){e||(f=a,c.Ha(a,"beforeChange"))}},Pa:function(a){return this.K[a]&&
this.K[a].length},Sc:function(b){if(b)return this.K[b]&&this.K[b].length||0;var c=0;a.a.D(this.K,function(a,b){"dirty"!==a&&(c+=b.length)});return c},tb:function(a,c){return!this.equalityComparer||!this.equalityComparer(a,c)},extend:function(b){var c=this;b&&a.a.D(b,function(b,e){var f=a.ya[b];"function"==typeof f&&(c=f(c,e)||c)});return c}};a.G(D,"subscribe",D.X);a.G(D,"extend",D.extend);a.G(D,"getSubscriptionsCount",D.Sc);a.a.ka&&a.a.Xa(D,Function.prototype);a.J.fn=D;a.hc=function(a){return null!=
a&&"function"==typeof a.X&&"function"==typeof a.notifySubscribers};a.b("subscribable",a.J);a.b("isSubscribable",a.hc);a.va=a.l=function(){function b(a){d.push(e);e=a}function c(){e=d.pop()}var d=[],e,f=0;return{Ub:b,end:c,oc:function(b){if(e){if(!a.hc(b))throw Error("Only subscribable things can act as dependencies");e.gb.call(e.Gc,b,b.Cc||(b.Cc=++f))}},w:function(a,d,e){try{return b(),a.apply(d,e||[])}finally{c()}},Aa:function(){if(e)return e.m.Aa()},Sa:function(){if(e)return e.Sa}}}();a.b("computedContext",
a.va);a.b("computedContext.getDependenciesCount",a.va.Aa);a.b("computedContext.isInitial",a.va.Sa);a.b("ignoreDependencies",a.qd=a.l.w);var E=a.a.Yb("_latestValue");a.N=function(b){function c(){if(0<arguments.length)return c.tb(c[E],arguments[0])&&(c.ga(),c[E]=arguments[0],c.fa()),this;a.l.oc(c);return c[E]}c[E]=b;a.a.ka||a.a.extend(c,a.J.fn);a.J.fn.rb(c);a.a.Ya(c,B);a.options.deferUpdates&&a.ya.deferred(c,!0);return c};var B={equalityComparer:J,t:function(){return this[E]},fa:function(){this.notifySubscribers(this[E])},
ga:function(){this.notifySubscribers(this[E],"beforeChange")}};a.a.ka&&a.a.Xa(B,a.J.fn);var H=a.N.gd="__ko_proto__";B[H]=a.N;a.Oa=function(b,c){return null===b||b===n||b[H]===n?!1:b[H]===c?!0:a.Oa(b[H],c)};a.H=function(b){return a.Oa(b,a.N)};a.Ba=function(b){return"function"==typeof b&&b[H]===a.N||"function"==typeof b&&b[H]===a.B&&b.Vc?!0:!1};a.b("observable",a.N);a.b("isObservable",a.H);a.b("isWriteableObservable",a.Ba);a.b("isWritableObservable",a.Ba);a.b("observable.fn",B);a.G(B,"peek",B.t);a.G(B,
"valueHasMutated",B.fa);a.G(B,"valueWillMutate",B.ga);a.la=function(b){b=b||[];if("object"!=typeof b||!("length"in b))throw Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");b=a.N(b);a.a.Ya(b,a.la.fn);return b.extend({trackArrayChanges:!0})};a.la.fn={remove:function(b){for(var c=this.t(),d=[],e="function"!=typeof b||a.H(b)?function(a){return a===b}:b,f=0;f<c.length;f++){var g=c[f];e(g)&&(0===d.length&&this.ga(),d.push(g),c.splice(f,1),f--)}d.length&&
this.fa();return d},removeAll:function(b){if(b===n){var c=this.t(),d=c.slice(0);this.ga();c.splice(0,c.length);this.fa();return d}return b?this.remove(function(c){return 0<=a.a.o(b,c)}):[]},destroy:function(b){var c=this.t(),d="function"!=typeof b||a.H(b)?function(a){return a===b}:b;this.ga();for(var e=c.length-1;0<=e;e--)d(c[e])&&(c[e]._destroy=!0);this.fa()},destroyAll:function(b){return b===n?this.destroy(function(){return!0}):b?this.destroy(function(c){return 0<=a.a.o(b,c)}):[]},indexOf:function(b){var c=
this();return a.a.o(c,b)},replace:function(a,c){var d=this.indexOf(a);0<=d&&(this.ga(),this.t()[d]=c,this.fa())}};a.a.ka&&a.a.Xa(a.la.fn,a.N.fn);a.a.q("pop push reverse shift sort splice unshift".split(" "),function(b){a.la.fn[b]=function(){var a=this.t();this.ga();this.Vb(a,b,arguments);var d=a[b].apply(a,arguments);this.fa();return d===a?this:d}});a.a.q(["slice"],function(b){a.la.fn[b]=function(){var a=this();return a[b].apply(a,arguments)}});a.b("observableArray",a.la);a.ya.trackArrayChanges=function(b,
c){function d(){if(!e){e=!0;var c=b.notifySubscribers;b.notifySubscribers=function(a,b){b&&b!==I||++k;return c.apply(this,arguments)};var d=[].concat(b.t()||[]);f=null;g=b.X(function(c){c=[].concat(c||[]);if(b.Pa("arrayChange")){var e;if(!f||1<k)f=a.a.ib(d,c,b.hb);e=f}d=c;f=null;k=0;e&&e.length&&b.notifySubscribers(e,"arrayChange")})}}b.hb={};c&&"object"==typeof c&&a.a.extend(b.hb,c);b.hb.sparse=!0;if(!b.Vb){var e=!1,f=null,g,k=0,l=b.sa,m=b.Ia;b.sa=function(a){l&&l.call(b,a);"arrayChange"===a&&d()};
b.Ia=function(a){m&&m.call(b,a);"arrayChange"!==a||b.Pa("arrayChange")||(g.k(),e=!1)};b.Vb=function(b,c,d){function m(a,b,c){return l[l.length]={status:a,value:b,index:c}}if(e&&!k){var l=[],g=b.length,t=d.length,G=0;switch(c){case "push":G=g;case "unshift":for(c=0;c<t;c++)m("added",d[c],G+c);break;case "pop":G=g-1;case "shift":g&&m("deleted",b[G],G);break;case "splice":c=Math.min(Math.max(0,0>d[0]?g+d[0]:d[0]),g);for(var g=1===t?g:Math.min(c+(d[1]||0),g),t=c+t-2,G=Math.max(g,t),P=[],n=[],Q=2;c<G;++c,
++Q)c<g&&n.push(m("deleted",b[c],c)),c<t&&P.push(m("added",d[Q],c));a.a.dc(n,P);break;default:return}f=l}}}};var s=a.a.Yb("_state");a.m=a.B=function(b,c,d){function e(){if(0<arguments.length){if("function"===typeof f)f.apply(g.pb,arguments);else throw Error("Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");return this}a.l.oc(e);(g.S||g.s&&e.Qa())&&e.aa();return g.T}"object"===typeof b?d=b:(d=d||{},b&&(d.read=
b));if("function"!=typeof d.read)throw Error("Pass a function that returns the value of the ko.computed");var f=d.write,g={T:n,S:!0,Ra:!1,Fb:!1,R:!1,Va:!1,s:!1,jd:d.read,pb:c||d.owner,i:d.disposeWhenNodeIsRemoved||d.i||null,wa:d.disposeWhen||d.wa,mb:null,r:{},L:0,bc:null};e[s]=g;e.Vc="function"===typeof f;a.a.ka||a.a.extend(e,a.J.fn);a.J.fn.rb(e);a.a.Ya(e,z);d.pure?(g.Va=!0,g.s=!0,a.a.extend(e,$)):d.deferEvaluation&&a.a.extend(e,aa);a.options.deferUpdates&&a.ya.deferred(e,!0);g.i&&(g.Fb=!0,g.i.nodeType||
(g.i=null));g.s||d.deferEvaluation||e.aa();g.i&&e.ba()&&a.a.F.oa(g.i,g.mb=function(){e.k()});return e};var z={equalityComparer:J,Aa:function(){return this[s].L},Pb:function(a,c,d){if(this[s].Va&&c===this)throw Error("A 'pure' computed must not be called recursively");this[s].r[a]=d;d.Ga=this[s].L++;d.na=c.Na()},Qa:function(){var a,c,d=this[s].r;for(a in d)if(d.hasOwnProperty(a)&&(c=d[a],c.ia.Uc(c.na)))return!0},bd:function(){this.Fa&&!this[s].Ra&&this.Fa()},ba:function(){return this[s].S||0<this[s].L},
ld:function(){this.Mb||this.ac()},uc:function(a){if(a.cb&&!this[s].i){var c=a.X(this.bd,this,"dirty"),d=a.X(this.ld,this);return{ia:a,k:function(){c.k();d.k()}}}return a.X(this.ac,this)},ac:function(){var b=this,c=b.throttleEvaluation;c&&0<=c?(clearTimeout(this[s].bc),this[s].bc=a.a.setTimeout(function(){b.aa(!0)},c)):b.Fa?b.Fa():b.aa(!0)},aa:function(b){var c=this[s],d=c.wa;if(!c.Ra&&!c.R){if(c.i&&!a.a.nb(c.i)||d&&d()){if(!c.Fb){this.k();return}}else c.Fb=!1;c.Ra=!0;try{this.Qc(b)}finally{c.Ra=!1}c.L||
this.k()}},Qc:function(b){var c=this[s],d=c.Va?n:!c.L,e={Hc:this,Ma:c.r,lb:c.L};a.l.Ub({Gc:e,gb:Y,m:this,Sa:d});c.r={};c.L=0;e=this.Pc(c,e);this.tb(c.T,e)&&(c.s||this.notifySubscribers(c.T,"beforeChange"),c.T=e,c.s?this.zc():b&&this.notifySubscribers(c.T));d&&this.notifySubscribers(c.T,"awake")},Pc:function(b,c){try{var d=b.jd;return b.pb?d.call(b.pb):d()}finally{a.l.end(),c.lb&&!b.s&&a.a.D(c.Ma,X),b.S=!1}},t:function(){var a=this[s];(a.S&&!a.L||a.s&&this.Qa())&&this.aa();return a.T},Ta:function(b){a.J.fn.Ta.call(this,
b);this.Fa=function(){this.Kb(this[s].T);this[s].S=!0;this.Lb(this)}},k:function(){var b=this[s];!b.s&&b.r&&a.a.D(b.r,function(a,b){b.k&&b.k()});b.i&&b.mb&&a.a.F.pc(b.i,b.mb);b.r=null;b.L=0;b.R=!0;b.S=!1;b.s=!1;b.i=null}},$={sa:function(b){var c=this,d=c[s];if(!d.R&&d.s&&"change"==b){d.s=!1;if(d.S||c.Qa())d.r=null,d.L=0,d.S=!0,c.aa();else{var e=[];a.a.D(d.r,function(a,b){e[b.Ga]=a});a.a.q(e,function(a,b){var e=d.r[a],l=c.uc(e.ia);l.Ga=b;l.na=e.na;d.r[a]=l})}d.R||c.notifySubscribers(d.T,"awake")}},
Ia:function(b){var c=this[s];c.R||"change"!=b||this.Pa("change")||(a.a.D(c.r,function(a,b){b.k&&(c.r[a]={ia:b.ia,Ga:b.Ga,na:b.na},b.k())}),c.s=!0,this.notifySubscribers(n,"asleep"))},Na:function(){var b=this[s];b.s&&(b.S||this.Qa())&&this.aa();return a.J.fn.Na.call(this)}},aa={sa:function(a){"change"!=a&&"beforeChange"!=a||this.t()}};a.a.ka&&a.a.Xa(z,a.J.fn);var R=a.N.gd;a.m[R]=a.N;z[R]=a.m;a.Xc=function(b){return a.Oa(b,a.m)};a.Yc=function(b){return a.Oa(b,a.m)&&b[s]&&b[s].Va};a.b("computed",a.m);
a.b("dependentObservable",a.m);a.b("isComputed",a.Xc);a.b("isPureComputed",a.Yc);a.b("computed.fn",z);a.G(z,"peek",z.t);a.G(z,"dispose",z.k);a.G(z,"isActive",z.ba);a.G(z,"getDependenciesCount",z.Aa);a.nc=function(b,c){if("function"===typeof b)return a.m(b,c,{pure:!0});b=a.a.extend({},b);b.pure=!0;return a.m(b,c)};a.b("pureComputed",a.nc);(function(){function b(a,f,g){g=g||new d;a=f(a);if("object"!=typeof a||null===a||a===n||a instanceof RegExp||a instanceof Date||a instanceof String||a instanceof
Number||a instanceof Boolean)return a;var k=a instanceof Array?[]:{};g.save(a,k);c(a,function(c){var d=f(a[c]);switch(typeof d){case "boolean":case "number":case "string":case "function":k[c]=d;break;case "object":case "undefined":var h=g.get(d);k[c]=h!==n?h:b(d,f,g)}});return k}function c(a,b){if(a instanceof Array){for(var c=0;c<a.length;c++)b(c);"function"==typeof a.toJSON&&b("toJSON")}else for(c in a)b(c)}function d(){this.keys=[];this.Ib=[]}a.wc=function(c){if(0==arguments.length)throw Error("When calling ko.toJS, pass the object you want to convert.");
return b(c,function(b){for(var c=0;a.H(b)&&10>c;c++)b=b();return b})};a.toJSON=function(b,c,d){b=a.wc(b);return a.a.Eb(b,c,d)};d.prototype={save:function(b,c){var d=a.a.o(this.keys,b);0<=d?this.Ib[d]=c:(this.keys.push(b),this.Ib.push(c))},get:function(b){b=a.a.o(this.keys,b);return 0<=b?this.Ib[b]:n}}})();a.b("toJS",a.wc);a.b("toJSON",a.toJSON);(function(){a.j={u:function(b){switch(a.a.A(b)){case "option":return!0===b.__ko__hasDomDataOptionValue__?a.a.e.get(b,a.d.options.xb):7>=a.a.C?b.getAttributeNode("value")&&
b.getAttributeNode("value").specified?b.value:b.text:b.value;case "select":return 0<=b.selectedIndex?a.j.u(b.options[b.selectedIndex]):n;default:return b.value}},ha:function(b,c,d){switch(a.a.A(b)){case "option":switch(typeof c){case "string":a.a.e.set(b,a.d.options.xb,n);"__ko__hasDomDataOptionValue__"in b&&delete b.__ko__hasDomDataOptionValue__;b.value=c;break;default:a.a.e.set(b,a.d.options.xb,c),b.__ko__hasDomDataOptionValue__=!0,b.value="number"===typeof c?c:""}break;case "select":if(""===c||
null===c)c=n;for(var e=-1,f=0,g=b.options.length,k;f<g;++f)if(k=a.j.u(b.options[f]),k==c||""==k&&c===n){e=f;break}if(d||0<=e||c===n&&1<b.size)b.selectedIndex=e;break;default:if(null===c||c===n)c="";b.value=c}}}})();a.b("selectExtensions",a.j);a.b("selectExtensions.readValue",a.j.u);a.b("selectExtensions.writeValue",a.j.ha);a.h=function(){function b(b){b=a.a.$a(b);123===b.charCodeAt(0)&&(b=b.slice(1,-1));var c=[],d=b.match(e),r,k=[],p=0;if(d){d.push(",");for(var A=0,y;y=d[A];++A){var t=y.charCodeAt(0);
if(44===t){if(0>=p){c.push(r&&k.length?{key:r,value:k.join("")}:{unknown:r||k.join("")});r=p=0;k=[];continue}}else if(58===t){if(!p&&!r&&1===k.length){r=k.pop();continue}}else 47===t&&A&&1<y.length?(t=d[A-1].match(f))&&!g[t[0]]&&(b=b.substr(b.indexOf(y)+1),d=b.match(e),d.push(","),A=-1,y="/"):40===t||123===t||91===t?++p:41===t||125===t||93===t?--p:r||k.length||34!==t&&39!==t||(y=y.slice(1,-1));k.push(y)}}return c}var c=["true","false","null","undefined"],d=/^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i,
e=RegExp("\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)*'|/(?:[^/\\\\]|\\\\.)*/w*|[^\\s:,/][^,\"'{}()/:[\\]]*[^\\s,\"'{}()/:[\\]]|[^\\s]","g"),f=/[\])"'A-Za-z0-9_$]+$/,g={"in":1,"return":1,"typeof":1},k={};return{ta:[],ea:k,yb:b,Ua:function(e,m){function h(b,e){var m;if(!A){var l=a.getBindingHandler(b);if(l&&l.preprocess&&!(e=l.preprocess(e,b,h)))return;if(l=k[b])m=e,0<=a.a.o(c,m)?m=!1:(l=m.match(d),m=null===l?!1:l[1]?"Object("+l[1]+")"+l[2]:m),l=m;l&&g.push("'"+b+"':function(_z){"+m+"=_z}")}p&&(e=
"function(){return "+e+" }");f.push("'"+b+"':"+e)}m=m||{};var f=[],g=[],p=m.valueAccessors,A=m.bindingParams,y="string"===typeof e?b(e):e;a.a.q(y,function(a){h(a.key||a.unknown,a.value)});g.length&&h("_ko_property_writers","{"+g.join(",")+" }");return f.join(",")},ad:function(a,b){for(var c=0;c<a.length;c++)if(a[c].key==b)return!0;return!1},Ea:function(b,c,d,e,f){if(b&&a.H(b))!a.Ba(b)||f&&b.t()===e||b(e);else if((b=c.get("_ko_property_writers"))&&b[d])b[d](e)}}}();a.b("expressionRewriting",a.h);a.b("expressionRewriting.bindingRewriteValidators",
a.h.ta);a.b("expressionRewriting.parseObjectLiteral",a.h.yb);a.b("expressionRewriting.preProcessBindings",a.h.Ua);a.b("expressionRewriting._twoWayBindings",a.h.ea);a.b("jsonExpressionRewriting",a.h);a.b("jsonExpressionRewriting.insertPropertyAccessorsIntoJson",a.h.Ua);(function(){function b(a){return 8==a.nodeType&&g.test(f?a.text:a.nodeValue)}function c(a){return 8==a.nodeType&&k.test(f?a.text:a.nodeValue)}function d(a,d){for(var e=a,f=1,l=[];e=e.nextSibling;){if(c(e)&&(f--,0===f))return l;l.push(e);
b(e)&&f++}if(!d)throw Error("Cannot find closing comment tag to match: "+a.nodeValue);return null}function e(a,b){var c=d(a,b);return c?0<c.length?c[c.length-1].nextSibling:a.nextSibling:null}var f=u&&"\x3c!--test--\x3e"===u.createComment("test").text,g=f?/^\x3c!--\s*ko(?:\s+([\s\S]+))?\s*--\x3e$/:/^\s*ko(?:\s+([\s\S]+))?\s*$/,k=f?/^\x3c!--\s*\/ko\s*--\x3e$/:/^\s*\/ko\s*$/,l={ul:!0,ol:!0};a.f={Z:{},childNodes:function(a){return b(a)?d(a):a.childNodes},xa:function(c){if(b(c)){c=a.f.childNodes(c);for(var d=
0,e=c.length;d<e;d++)a.removeNode(c[d])}else a.a.ob(c)},da:function(c,d){if(b(c)){a.f.xa(c);for(var e=c.nextSibling,f=0,l=d.length;f<l;f++)e.parentNode.insertBefore(d[f],e)}else a.a.da(c,d)},mc:function(a,c){b(a)?a.parentNode.insertBefore(c,a.nextSibling):a.firstChild?a.insertBefore(c,a.firstChild):a.appendChild(c)},gc:function(c,d,e){e?b(c)?c.parentNode.insertBefore(d,e.nextSibling):e.nextSibling?c.insertBefore(d,e.nextSibling):c.appendChild(d):a.f.mc(c,d)},firstChild:function(a){return b(a)?!a.nextSibling||
c(a.nextSibling)?null:a.nextSibling:a.firstChild},nextSibling:function(a){b(a)&&(a=e(a));return a.nextSibling&&c(a.nextSibling)?null:a.nextSibling},Tc:b,pd:function(a){return(a=(f?a.text:a.nodeValue).match(g))?a[1]:null},kc:function(d){if(l[a.a.A(d)]){var h=d.firstChild;if(h){do if(1===h.nodeType){var f;f=h.firstChild;var g=null;if(f){do if(g)g.push(f);else if(b(f)){var k=e(f,!0);k?f=k:g=[f]}else c(f)&&(g=[f]);while(f=f.nextSibling)}if(f=g)for(g=h.nextSibling,k=0;k<f.length;k++)g?d.insertBefore(f[k],
g):d.appendChild(f[k])}while(h=h.nextSibling)}}}}})();a.b("virtualElements",a.f);a.b("virtualElements.allowedBindings",a.f.Z);a.b("virtualElements.emptyNode",a.f.xa);a.b("virtualElements.insertAfter",a.f.gc);a.b("virtualElements.prepend",a.f.mc);a.b("virtualElements.setDomNodeChildren",a.f.da);(function(){a.Q=function(){this.Fc={}};a.a.extend(a.Q.prototype,{nodeHasBindings:function(b){switch(b.nodeType){case 1:return null!=b.getAttribute("data-bind")||a.g.getComponentNameForNode(b);case 8:return a.f.Tc(b);
default:return!1}},getBindings:function(b,c){var d=this.getBindingsString(b,c),d=d?this.parseBindingsString(d,c,b):null;return a.g.Ob(d,b,c,!1)},getBindingAccessors:function(b,c){var d=this.getBindingsString(b,c),d=d?this.parseBindingsString(d,c,b,{valueAccessors:!0}):null;return a.g.Ob(d,b,c,!0)},getBindingsString:function(b){switch(b.nodeType){case 1:return b.getAttribute("data-bind");case 8:return a.f.pd(b);default:return null}},parseBindingsString:function(b,c,d,e){try{var f=this.Fc,g=b+(e&&e.valueAccessors||
""),k;if(!(k=f[g])){var l,m="with($context){with($data||{}){return{"+a.h.Ua(b,e)+"}}}";l=new Function("$context","$element",m);k=f[g]=l}return k(c,d)}catch(h){throw h.message="Unable to parse bindings.\nBindings value: "+b+"\nMessage: "+h.message,h;}}});a.Q.instance=new a.Q})();a.b("bindingProvider",a.Q);(function(){function b(a){return function(){return a}}function c(a){return a()}function d(b){return a.a.Ca(a.l.w(b),function(a,c){return function(){return b()[c]}})}function e(c,e,h){return"function"===
typeof c?d(c.bind(null,e,h)):a.a.Ca(c,b)}function f(a,b){return d(this.getBindings.bind(this,a,b))}function g(b,c,d){var e,h=a.f.firstChild(c),f=a.Q.instance,m=f.preprocessNode;if(m){for(;e=h;)h=a.f.nextSibling(e),m.call(f,e);h=a.f.firstChild(c)}for(;e=h;)h=a.f.nextSibling(e),k(b,e,d)}function k(b,c,d){var e=!0,h=1===c.nodeType;h&&a.f.kc(c);if(h&&d||a.Q.instance.nodeHasBindings(c))e=m(c,null,b,d).shouldBindDescendants;e&&!r[a.a.A(c)]&&g(b,c,!h)}function l(b){var c=[],d={},e=[];a.a.D(b,function Z(h){if(!d[h]){var f=
a.getBindingHandler(h);f&&(f.after&&(e.push(h),a.a.q(f.after,function(c){if(b[c]){if(-1!==a.a.o(e,c))throw Error("Cannot combine the following bindings, because they have a cyclic dependency: "+e.join(", "));Z(c)}}),e.length--),c.push({key:h,fc:f}));d[h]=!0}});return c}function m(b,d,e,h){var m=a.a.e.get(b,q);if(!d){if(m)throw Error("You cannot apply bindings multiple times to the same element.");a.a.e.set(b,q,!0)}!m&&h&&a.tc(b,e);var g;if(d&&"function"!==typeof d)g=d;else{var k=a.Q.instance,r=k.getBindingAccessors||
f,p=a.B(function(){(g=d?d(e,b):r.call(k,b,e))&&e.P&&e.P();return g},null,{i:b});g&&p.ba()||(p=null)}var u;if(g){var v=p?function(a){return function(){return c(p()[a])}}:function(a){return g[a]},s=function(){return a.a.Ca(p?p():g,c)};s.get=function(a){return g[a]&&c(v(a))};s.has=function(a){return a in g};h=l(g);a.a.q(h,function(c){var d=c.fc.init,h=c.fc.update,f=c.key;if(8===b.nodeType&&!a.f.Z[f])throw Error("The binding '"+f+"' cannot be used with virtual elements");try{"function"==typeof d&&a.l.w(function(){var a=
d(b,v(f),s,e.$data,e);if(a&&a.controlsDescendantBindings){if(u!==n)throw Error("Multiple bindings ("+u+" and "+f+") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");u=f}}),"function"==typeof h&&a.B(function(){h(b,v(f),s,e.$data,e)},null,{i:b})}catch(m){throw m.message='Unable to process binding "'+f+": "+g[f]+'"\nMessage: '+m.message,m;}})}return{shouldBindDescendants:u===n}}function h(b){return b&&b instanceof a.U?b:new a.U(b)}
a.d={};var r={script:!0,textarea:!0,template:!0};a.getBindingHandler=function(b){return a.d[b]};a.U=function(b,c,d,e){var h=this,f="function"==typeof b&&!a.H(b),m,g=a.B(function(){var m=f?b():b,l=a.a.c(m);c?(c.P&&c.P(),a.a.extend(h,c),g&&(h.P=g)):(h.$parents=[],h.$root=l,h.ko=a);h.$rawData=m;h.$data=l;d&&(h[d]=l);e&&e(h,c,l);return h.$data},null,{wa:function(){return m&&!a.a.Qb(m)},i:!0});g.ba()&&(h.P=g,g.equalityComparer=null,m=[],g.Ac=function(b){m.push(b);a.a.F.oa(b,function(b){a.a.La(m,b);m.length||
(g.k(),h.P=g=n)})})};a.U.prototype.createChildContext=function(b,c,d){return new a.U(b,this,c,function(a,b){a.$parentContext=b;a.$parent=b.$data;a.$parents=(b.$parents||[]).slice(0);a.$parents.unshift(a.$parent);d&&d(a)})};a.U.prototype.extend=function(b){return new a.U(this.P||this.$data,this,null,function(c,d){c.$rawData=d.$rawData;a.a.extend(c,"function"==typeof b?b():b)})};var q=a.a.e.I(),p=a.a.e.I();a.tc=function(b,c){if(2==arguments.length)a.a.e.set(b,p,c),c.P&&c.P.Ac(b);else return a.a.e.get(b,
p)};a.Ja=function(b,c,d){1===b.nodeType&&a.f.kc(b);return m(b,c,h(d),!0)};a.Dc=function(b,c,d){d=h(d);return a.Ja(b,e(c,d,b),d)};a.eb=function(a,b){1!==b.nodeType&&8!==b.nodeType||g(h(a),b,!0)};a.Rb=function(a,b){!v&&x.jQuery&&(v=x.jQuery);if(b&&1!==b.nodeType&&8!==b.nodeType)throw Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");b=b||x.document.body;k(h(a),b,!0)};a.kb=function(b){switch(b.nodeType){case 1:case 8:var c=a.tc(b);if(c)return c;
if(b.parentNode)return a.kb(b.parentNode)}return n};a.Jc=function(b){return(b=a.kb(b))?b.$data:n};a.b("bindingHandlers",a.d);a.b("applyBindings",a.Rb);a.b("applyBindingsToDescendants",a.eb);a.b("applyBindingAccessorsToNode",a.Ja);a.b("applyBindingsToNode",a.Dc);a.b("contextFor",a.kb);a.b("dataFor",a.Jc)})();(function(b){function c(c,e){var m=f.hasOwnProperty(c)?f[c]:b,h;m?m.X(e):(m=f[c]=new a.J,m.X(e),d(c,function(b,d){var e=!(!d||!d.synchronous);g[c]={definition:b,Zc:e};delete f[c];h||e?m.notifySubscribers(b):
a.Y.Wa(function(){m.notifySubscribers(b)})}),h=!0)}function d(a,b){e("getConfig",[a],function(c){c?e("loadComponent",[a,c],function(a){b(a,c)}):b(null,null)})}function e(c,d,f,h){h||(h=a.g.loaders.slice(0));var g=h.shift();if(g){var q=g[c];if(q){var p=!1;if(q.apply(g,d.concat(function(a){p?f(null):null!==a?f(a):e(c,d,f,h)}))!==b&&(p=!0,!g.suppressLoaderExceptions))throw Error("Component loaders must supply values by invoking the callback, not by returning values synchronously.");}else e(c,d,f,h)}else f(null)}
var f={},g={};a.g={get:function(d,e){var f=g.hasOwnProperty(d)?g[d]:b;f?f.Zc?a.l.w(function(){e(f.definition)}):a.Y.Wa(function(){e(f.definition)}):c(d,e)},Xb:function(a){delete g[a]},Jb:e};a.g.loaders=[];a.b("components",a.g);a.b("components.get",a.g.get);a.b("components.clearCachedDefinition",a.g.Xb)})();(function(){function b(b,c,d,e){function g(){0===--y&&e(k)}var k={},y=2,t=d.template;d=d.viewModel;t?f(c,t,function(c){a.g.Jb("loadTemplate",[b,c],function(a){k.template=a;g()})}):g();d?f(c,d,function(c){a.g.Jb("loadViewModel",
[b,c],function(a){k[l]=a;g()})}):g()}function c(a,b,d){if("function"===typeof b)d(function(a){return new b(a)});else if("function"===typeof b[l])d(b[l]);else if("instance"in b){var e=b.instance;d(function(){return e})}else"viewModel"in b?c(a,b.viewModel,d):a("Unknown viewModel value: "+b)}function d(b){switch(a.a.A(b)){case "script":return a.a.ma(b.text);case "textarea":return a.a.ma(b.value);case "template":if(e(b.content))return a.a.ua(b.content.childNodes)}return a.a.ua(b.childNodes)}function e(a){return x.DocumentFragment?
a instanceof DocumentFragment:a&&11===a.nodeType}function f(a,b,c){"string"===typeof b.require?O||x.require?(O||x.require)([b.require],c):a("Uses require, but no AMD loader is present"):c(b)}function g(a){return function(b){throw Error("Component '"+a+"': "+b);}}var k={};a.g.register=function(b,c){if(!c)throw Error("Invalid configuration for "+b);if(a.g.ub(b))throw Error("Component "+b+" is already registered");k[b]=c};a.g.ub=function(a){return k.hasOwnProperty(a)};a.g.od=function(b){delete k[b];
a.g.Xb(b)};a.g.Zb={getConfig:function(a,b){b(k.hasOwnProperty(a)?k[a]:null)},loadComponent:function(a,c,d){var e=g(a);f(e,c,function(c){b(a,e,c,d)})},loadTemplate:function(b,c,f){b=g(b);if("string"===typeof c)f(a.a.ma(c));else if(c instanceof Array)f(c);else if(e(c))f(a.a.V(c.childNodes));else if(c.element)if(c=c.element,x.HTMLElement?c instanceof HTMLElement:c&&c.tagName&&1===c.nodeType)f(d(c));else if("string"===typeof c){var l=u.getElementById(c);l?f(d(l)):b("Cannot find element with ID "+c)}else b("Unknown element type: "+
c);else b("Unknown template value: "+c)},loadViewModel:function(a,b,d){c(g(a),b,d)}};var l="createViewModel";a.b("components.register",a.g.register);a.b("components.isRegistered",a.g.ub);a.b("components.unregister",a.g.od);a.b("components.defaultLoader",a.g.Zb);a.g.loaders.push(a.g.Zb);a.g.Bc=k})();(function(){function b(b,e){var f=b.getAttribute("params");if(f){var f=c.parseBindingsString(f,e,b,{valueAccessors:!0,bindingParams:!0}),f=a.a.Ca(f,function(c){return a.m(c,null,{i:b})}),g=a.a.Ca(f,function(c){var e=
c.t();return c.ba()?a.m({read:function(){return a.a.c(c())},write:a.Ba(e)&&function(a){c()(a)},i:b}):e});g.hasOwnProperty("$raw")||(g.$raw=f);return g}return{$raw:{}}}a.g.getComponentNameForNode=function(b){var c=a.a.A(b);if(a.g.ub(c)&&(-1!=c.indexOf("-")||"[object HTMLUnknownElement]"==""+b||8>=a.a.C&&b.tagName===c))return c};a.g.Ob=function(c,e,f,g){if(1===e.nodeType){var k=a.g.getComponentNameForNode(e);if(k){c=c||{};if(c.component)throw Error('Cannot use the "component" binding on a custom element matching a component');
var l={name:k,params:b(e,f)};c.component=g?function(){return l}:l}}return c};var c=new a.Q;9>a.a.C&&(a.g.register=function(a){return function(b){u.createElement(b);return a.apply(this,arguments)}}(a.g.register),u.createDocumentFragment=function(b){return function(){var c=b(),f=a.g.Bc,g;for(g in f)f.hasOwnProperty(g)&&c.createElement(g);return c}}(u.createDocumentFragment))})();(function(b){function c(b,c,d){c=c.template;if(!c)throw Error("Component '"+b+"' has no template");b=a.a.ua(c);a.f.da(d,b)}
function d(a,b,c,d){var e=a.createViewModel;return e?e.call(a,d,{element:b,templateNodes:c}):d}var e=0;a.d.component={init:function(f,g,k,l,m){function h(){var a=r&&r.dispose;"function"===typeof a&&a.call(r);q=r=null}var r,q,p=a.a.V(a.f.childNodes(f));a.a.F.oa(f,h);a.m(function(){var l=a.a.c(g()),k,t;"string"===typeof l?k=l:(k=a.a.c(l.name),t=a.a.c(l.params));if(!k)throw Error("No component name specified");var n=q=++e;a.g.get(k,function(e){if(q===n){h();if(!e)throw Error("Unknown component '"+k+
"'");c(k,e,f);var g=d(e,f,p,t);e=m.createChildContext(g,b,function(a){a.$component=g;a.$componentTemplateNodes=p});r=g;a.eb(e,f)}})},null,{i:f});return{controlsDescendantBindings:!0}}};a.f.Z.component=!0})();var S={"class":"className","for":"htmlFor"};a.d.attr={update:function(b,c){var d=a.a.c(c())||{};a.a.D(d,function(c,d){d=a.a.c(d);var g=!1===d||null===d||d===n;g&&b.removeAttribute(c);8>=a.a.C&&c in S?(c=S[c],g?b.removeAttribute(c):b[c]=d):g||b.setAttribute(c,d.toString());"name"===c&&a.a.rc(b,
g?"":d.toString())})}};(function(){a.d.checked={after:["value","attr"],init:function(b,c,d){function e(){var e=b.checked,f=p?g():e;if(!a.va.Sa()&&(!l||e)){var m=a.l.w(c);if(h){var k=r?m.t():m;q!==f?(e&&(a.a.pa(k,f,!0),a.a.pa(k,q,!1)),q=f):a.a.pa(k,f,e);r&&a.Ba(m)&&m(k)}else a.h.Ea(m,d,"checked",f,!0)}}function f(){var d=a.a.c(c());b.checked=h?0<=a.a.o(d,g()):k?d:g()===d}var g=a.nc(function(){return d.has("checkedValue")?a.a.c(d.get("checkedValue")):d.has("value")?a.a.c(d.get("value")):b.value}),k=
"checkbox"==b.type,l="radio"==b.type;if(k||l){var m=c(),h=k&&a.a.c(m)instanceof Array,r=!(h&&m.push&&m.splice),q=h?g():n,p=l||h;l&&!b.name&&a.d.uniqueName.init(b,function(){return!0});a.m(e,null,{i:b});a.a.p(b,"click",e);a.m(f,null,{i:b});m=n}}};a.h.ea.checked=!0;a.d.checkedValue={update:function(b,c){b.value=a.a.c(c())}}})();a.d.css={update:function(b,c){var d=a.a.c(c());null!==d&&"object"==typeof d?a.a.D(d,function(c,d){d=a.a.c(d);a.a.bb(b,c,d)}):(d=a.a.$a(String(d||"")),a.a.bb(b,b.__ko__cssValue,
!1),b.__ko__cssValue=d,a.a.bb(b,d,!0))}};a.d.enable={update:function(b,c){var d=a.a.c(c());d&&b.disabled?b.removeAttribute("disabled"):d||b.disabled||(b.disabled=!0)}};a.d.disable={update:function(b,c){a.d.enable.update(b,function(){return!a.a.c(c())})}};a.d.event={init:function(b,c,d,e,f){var g=c()||{};a.a.D(g,function(g){"string"==typeof g&&a.a.p(b,g,function(b){var m,h=c()[g];if(h){try{var r=a.a.V(arguments);e=f.$data;r.unshift(e);m=h.apply(e,r)}finally{!0!==m&&(b.preventDefault?b.preventDefault():
b.returnValue=!1)}!1===d.get(g+"Bubble")&&(b.cancelBubble=!0,b.stopPropagation&&b.stopPropagation())}})})}};a.d.foreach={ic:function(b){return function(){var c=b(),d=a.a.zb(c);if(!d||"number"==typeof d.length)return{foreach:c,templateEngine:a.W.sb};a.a.c(c);return{foreach:d.data,as:d.as,includeDestroyed:d.includeDestroyed,afterAdd:d.afterAdd,beforeRemove:d.beforeRemove,afterRender:d.afterRender,beforeMove:d.beforeMove,afterMove:d.afterMove,templateEngine:a.W.sb}}},init:function(b,c){return a.d.template.init(b,
a.d.foreach.ic(c))},update:function(b,c,d,e,f){return a.d.template.update(b,a.d.foreach.ic(c),d,e,f)}};a.h.ta.foreach=!1;a.f.Z.foreach=!0;a.d.hasfocus={init:function(b,c,d){function e(e){b.__ko_hasfocusUpdating=!0;var f=b.ownerDocument;if("activeElement"in f){var g;try{g=f.activeElement}catch(h){g=f.body}e=g===b}f=c();a.h.Ea(f,d,"hasfocus",e,!0);b.__ko_hasfocusLastValue=e;b.__ko_hasfocusUpdating=!1}var f=e.bind(null,!0),g=e.bind(null,!1);a.a.p(b,"focus",f);a.a.p(b,"focusin",f);a.a.p(b,"blur",g);a.a.p(b,
"focusout",g)},update:function(b,c){var d=!!a.a.c(c());b.__ko_hasfocusUpdating||b.__ko_hasfocusLastValue===d||(d?b.focus():b.blur(),!d&&b.__ko_hasfocusLastValue&&b.ownerDocument.body.focus(),a.l.w(a.a.Da,null,[b,d?"focusin":"focusout"]))}};a.h.ea.hasfocus=!0;a.d.hasFocus=a.d.hasfocus;a.h.ea.hasFocus=!0;a.d.html={init:function(){return{controlsDescendantBindings:!0}},update:function(b,c){a.a.Cb(b,c())}};K("if");K("ifnot",!1,!0);K("with",!0,!1,function(a,c){return a.createChildContext(c)});var L={};
a.d.options={init:function(b){if("select"!==a.a.A(b))throw Error("options binding applies only to SELECT elements");for(;0<b.length;)b.remove(0);return{controlsDescendantBindings:!0}},update:function(b,c,d){function e(){return a.a.Ka(b.options,function(a){return a.selected})}function f(a,b,c){var d=typeof b;return"function"==d?b(a):"string"==d?a[b]:c}function g(c,e){if(A&&h)a.j.ha(b,a.a.c(d.get("value")),!0);else if(p.length){var f=0<=a.a.o(p,a.j.u(e[0]));a.a.sc(e[0],f);A&&!f&&a.l.w(a.a.Da,null,[b,
"change"])}}var k=b.multiple,l=0!=b.length&&k?b.scrollTop:null,m=a.a.c(c()),h=d.get("valueAllowUnset")&&d.has("value"),r=d.get("optionsIncludeDestroyed");c={};var q,p=[];h||(k?p=a.a.fb(e(),a.j.u):0<=b.selectedIndex&&p.push(a.j.u(b.options[b.selectedIndex])));m&&("undefined"==typeof m.length&&(m=[m]),q=a.a.Ka(m,function(b){return r||b===n||null===b||!a.a.c(b._destroy)}),d.has("optionsCaption")&&(m=a.a.c(d.get("optionsCaption")),null!==m&&m!==n&&q.unshift(L)));var A=!1;c.beforeRemove=function(a){b.removeChild(a)};
m=g;d.has("optionsAfterRender")&&"function"==typeof d.get("optionsAfterRender")&&(m=function(b,c){g(0,c);a.l.w(d.get("optionsAfterRender"),null,[c[0],b!==L?b:n])});a.a.Bb(b,q,function(c,e,g){g.length&&(p=!h&&g[0].selected?[a.j.u(g[0])]:[],A=!0);e=b.ownerDocument.createElement("option");c===L?(a.a.Za(e,d.get("optionsCaption")),a.j.ha(e,n)):(g=f(c,d.get("optionsValue"),c),a.j.ha(e,a.a.c(g)),c=f(c,d.get("optionsText"),g),a.a.Za(e,c));return[e]},c,m);a.l.w(function(){h?a.j.ha(b,a.a.c(d.get("value")),
!0):(k?p.length&&e().length<p.length:p.length&&0<=b.selectedIndex?a.j.u(b.options[b.selectedIndex])!==p[0]:p.length||0<=b.selectedIndex)&&a.a.Da(b,"change")});a.a.Nc(b);l&&20<Math.abs(l-b.scrollTop)&&(b.scrollTop=l)}};a.d.options.xb=a.a.e.I();a.d.selectedOptions={after:["options","foreach"],init:function(b,c,d){a.a.p(b,"change",function(){var e=c(),f=[];a.a.q(b.getElementsByTagName("option"),function(b){b.selected&&f.push(a.j.u(b))});a.h.Ea(e,d,"selectedOptions",f)})},update:function(b,c){if("select"!=
a.a.A(b))throw Error("values binding applies only to SELECT elements");var d=a.a.c(c()),e=b.scrollTop;d&&"number"==typeof d.length&&a.a.q(b.getElementsByTagName("option"),function(b){var c=0<=a.a.o(d,a.j.u(b));b.selected!=c&&a.a.sc(b,c)});b.scrollTop=e}};a.h.ea.selectedOptions=!0;a.d.style={update:function(b,c){var d=a.a.c(c()||{});a.a.D(d,function(c,d){d=a.a.c(d);if(null===d||d===n||!1===d)d="";b.style[c]=d})}};a.d.submit={init:function(b,c,d,e,f){if("function"!=typeof c())throw Error("The value for a submit binding must be a function");
a.a.p(b,"submit",function(a){var d,e=c();try{d=e.call(f.$data,b)}finally{!0!==d&&(a.preventDefault?a.preventDefault():a.returnValue=!1)}})}};a.d.text={init:function(){return{controlsDescendantBindings:!0}},update:function(b,c){a.a.Za(b,c())}};a.f.Z.text=!0;(function(){if(x&&x.navigator)var b=function(a){if(a)return parseFloat(a[1])},c=x.opera&&x.opera.version&&parseInt(x.opera.version()),d=x.navigator.userAgent,e=b(d.match(/^(?:(?!chrome).)*version\/([^ ]*) safari/i)),f=b(d.match(/Firefox\/([^ ]*)/));
if(10>a.a.C)var g=a.a.e.I(),k=a.a.e.I(),l=function(b){var c=this.activeElement;(c=c&&a.a.e.get(c,k))&&c(b)},m=function(b,c){var d=b.ownerDocument;a.a.e.get(d,g)||(a.a.e.set(d,g,!0),a.a.p(d,"selectionchange",l));a.a.e.set(b,k,c)};a.d.textInput={init:function(b,d,g){function l(c,d){a.a.p(b,c,d)}function k(){var c=a.a.c(d());if(null===c||c===n)c="";v!==n&&c===v?a.a.setTimeout(k,4):b.value!==c&&(u=c,b.value=c)}function y(){s||(v=b.value,s=a.a.setTimeout(t,4))}function t(){clearTimeout(s);v=s=n;var c=
b.value;u!==c&&(u=c,a.h.Ea(d(),g,"textInput",c))}var u=b.value,s,v,x=9==a.a.C?y:t;10>a.a.C?(l("propertychange",function(a){"value"===a.propertyName&&x(a)}),8==a.a.C&&(l("keyup",t),l("keydown",t)),8<=a.a.C&&(m(b,x),l("dragend",y))):(l("input",t),5>e&&"textarea"===a.a.A(b)?(l("keydown",y),l("paste",y),l("cut",y)):11>c?l("keydown",y):4>f&&(l("DOMAutoComplete",t),l("dragdrop",t),l("drop",t)));l("change",t);a.m(k,null,{i:b})}};a.h.ea.textInput=!0;a.d.textinput={preprocess:function(a,b,c){c("textInput",
a)}}})();a.d.uniqueName={init:function(b,c){if(c()){var d="ko_unique_"+ ++a.d.uniqueName.Ic;a.a.rc(b,d)}}};a.d.uniqueName.Ic=0;a.d.value={after:["options","foreach"],init:function(b,c,d){if("input"!=b.tagName.toLowerCase()||"checkbox"!=b.type&&"radio"!=b.type){var e=["change"],f=d.get("valueUpdate"),g=!1,k=null;f&&("string"==typeof f&&(f=[f]),a.a.ra(e,f),e=a.a.Tb(e));var l=function(){k=null;g=!1;var e=c(),f=a.j.u(b);a.h.Ea(e,d,"value",f)};!a.a.C||"input"!=b.tagName.toLowerCase()||"text"!=b.type||
"off"==b.autocomplete||b.form&&"off"==b.form.autocomplete||-1!=a.a.o(e,"propertychange")||(a.a.p(b,"propertychange",function(){g=!0}),a.a.p(b,"focus",function(){g=!1}),a.a.p(b,"blur",function(){g&&l()}));a.a.q(e,function(c){var d=l;a.a.nd(c,"after")&&(d=function(){k=a.j.u(b);a.a.setTimeout(l,0)},c=c.substring(5));a.a.p(b,c,d)});var m=function(){var e=a.a.c(c()),f=a.j.u(b);if(null!==k&&e===k)a.a.setTimeout(m,0);else if(e!==f)if("select"===a.a.A(b)){var g=d.get("valueAllowUnset"),f=function(){a.j.ha(b,
e,g)};f();g||e===a.j.u(b)?a.a.setTimeout(f,0):a.l.w(a.a.Da,null,[b,"change"])}else a.j.ha(b,e)};a.m(m,null,{i:b})}else a.Ja(b,{checkedValue:c})},update:function(){}};a.h.ea.value=!0;a.d.visible={update:function(b,c){var d=a.a.c(c()),e="none"!=b.style.display;d&&!e?b.style.display="":!d&&e&&(b.style.display="none")}};(function(b){a.d[b]={init:function(c,d,e,f,g){return a.d.event.init.call(this,c,function(){var a={};a[b]=d();return a},e,f,g)}}})("click");a.O=function(){};a.O.prototype.renderTemplateSource=
function(){throw Error("Override renderTemplateSource");};a.O.prototype.createJavaScriptEvaluatorBlock=function(){throw Error("Override createJavaScriptEvaluatorBlock");};a.O.prototype.makeTemplateSource=function(b,c){if("string"==typeof b){c=c||u;var d=c.getElementById(b);if(!d)throw Error("Cannot find template with ID "+b);return new a.v.n(d)}if(1==b.nodeType||8==b.nodeType)return new a.v.qa(b);throw Error("Unknown template type: "+b);};a.O.prototype.renderTemplate=function(a,c,d,e){a=this.makeTemplateSource(a,
e);return this.renderTemplateSource(a,c,d,e)};a.O.prototype.isTemplateRewritten=function(a,c){return!1===this.allowTemplateRewriting?!0:this.makeTemplateSource(a,c).data("isRewritten")};a.O.prototype.rewriteTemplate=function(a,c,d){a=this.makeTemplateSource(a,d);c=c(a.text());a.text(c);a.data("isRewritten",!0)};a.b("templateEngine",a.O);a.Gb=function(){function b(b,c,d,k){b=a.h.yb(b);for(var l=a.h.ta,m=0;m<b.length;m++){var h=b[m].key;if(l.hasOwnProperty(h)){var r=l[h];if("function"===typeof r){if(h=
r(b[m].value))throw Error(h);}else if(!r)throw Error("This template engine does not support the '"+h+"' binding within its templates");}}d="ko.__tr_ambtns(function($context,$element){return(function(){return{ "+a.h.Ua(b,{valueAccessors:!0})+" } })()},'"+d.toLowerCase()+"')";return k.createJavaScriptEvaluatorBlock(d)+c}var c=/(<([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\"[^\"]*\"|\'[^\']*\'|[^>]*))?)*\s+)data-bind\s*=\s*(["'])([\s\S]*?)\3/gi,d=/\x3c!--\s*ko\b\s*([\s\S]*?)\s*--\x3e/g;return{Oc:function(b,
c,d){c.isTemplateRewritten(b,d)||c.rewriteTemplate(b,function(b){return a.Gb.dd(b,c)},d)},dd:function(a,f){return a.replace(c,function(a,c,d,e,h){return b(h,c,d,f)}).replace(d,function(a,c){return b(c,"\x3c!-- ko --\x3e","#comment",f)})},Ec:function(b,c){return a.M.wb(function(d,k){var l=d.nextSibling;l&&l.nodeName.toLowerCase()===c&&a.Ja(l,b,k)})}}}();a.b("__tr_ambtns",a.Gb.Ec);(function(){a.v={};a.v.n=function(b){if(this.n=b){var c=a.a.A(b);this.ab="script"===c?1:"textarea"===c?2:"template"==c&&
b.content&&11===b.content.nodeType?3:4}};a.v.n.prototype.text=function(){var b=1===this.ab?"text":2===this.ab?"value":"innerHTML";if(0==arguments.length)return this.n[b];var c=arguments[0];"innerHTML"===b?a.a.Cb(this.n,c):this.n[b]=c};var b=a.a.e.I()+"_";a.v.n.prototype.data=function(c){if(1===arguments.length)return a.a.e.get(this.n,b+c);a.a.e.set(this.n,b+c,arguments[1])};var c=a.a.e.I();a.v.n.prototype.nodes=function(){var b=this.n;if(0==arguments.length)return(a.a.e.get(b,c)||{}).jb||(3===this.ab?
b.content:4===this.ab?b:n);a.a.e.set(b,c,{jb:arguments[0]})};a.v.qa=function(a){this.n=a};a.v.qa.prototype=new a.v.n;a.v.qa.prototype.text=function(){if(0==arguments.length){var b=a.a.e.get(this.n,c)||{};b.Hb===n&&b.jb&&(b.Hb=b.jb.innerHTML);return b.Hb}a.a.e.set(this.n,c,{Hb:arguments[0]})};a.b("templateSources",a.v);a.b("templateSources.domElement",a.v.n);a.b("templateSources.anonymousTemplate",a.v.qa)})();(function(){function b(b,c,d){var e;for(c=a.f.nextSibling(c);b&&(e=b)!==c;)b=a.f.nextSibling(e),
d(e,b)}function c(c,d){if(c.length){var e=c[0],f=c[c.length-1],g=e.parentNode,k=a.Q.instance,n=k.preprocessNode;if(n){b(e,f,function(a,b){var c=a.previousSibling,d=n.call(k,a);d&&(a===e&&(e=d[0]||b),a===f&&(f=d[d.length-1]||c))});c.length=0;if(!e)return;e===f?c.push(e):(c.push(e,f),a.a.za(c,g))}b(e,f,function(b){1!==b.nodeType&&8!==b.nodeType||a.Rb(d,b)});b(e,f,function(b){1!==b.nodeType&&8!==b.nodeType||a.M.yc(b,[d])});a.a.za(c,g)}}function d(a){return a.nodeType?a:0<a.length?a[0]:null}function e(b,
e,f,k,q){q=q||{};var p=(b&&d(b)||f||{}).ownerDocument,n=q.templateEngine||g;a.Gb.Oc(f,n,p);f=n.renderTemplate(f,k,q,p);if("number"!=typeof f.length||0<f.length&&"number"!=typeof f[0].nodeType)throw Error("Template engine must return an array of DOM nodes");p=!1;switch(e){case "replaceChildren":a.f.da(b,f);p=!0;break;case "replaceNode":a.a.qc(b,f);p=!0;break;case "ignoreTargetNode":break;default:throw Error("Unknown renderMode: "+e);}p&&(c(f,k),q.afterRender&&a.l.w(q.afterRender,null,[f,k.$data]));
return f}function f(b,c,d){return a.H(b)?b():"function"===typeof b?b(c,d):b}var g;a.Db=function(b){if(b!=n&&!(b instanceof a.O))throw Error("templateEngine must inherit from ko.templateEngine");g=b};a.Ab=function(b,c,h,k,q){h=h||{};if((h.templateEngine||g)==n)throw Error("Set a template engine before calling renderTemplate");q=q||"replaceChildren";if(k){var p=d(k);return a.B(function(){var g=c&&c instanceof a.U?c:new a.U(a.a.c(c)),n=f(b,g.$data,g),g=e(k,q,n,g,h);"replaceNode"==q&&(k=g,p=d(k))},null,
{wa:function(){return!p||!a.a.nb(p)},i:p&&"replaceNode"==q?p.parentNode:p})}return a.M.wb(function(d){a.Ab(b,c,h,d,"replaceNode")})};a.kd=function(b,d,g,k,q){function p(a,b){c(b,s);g.afterRender&&g.afterRender(b,a);s=null}function u(a,c){s=q.createChildContext(a,g.as,function(a){a.$index=c});var d=f(b,a,s);return e(null,"ignoreTargetNode",d,s,g)}var s;return a.B(function(){var b=a.a.c(d)||[];"undefined"==typeof b.length&&(b=[b]);b=a.a.Ka(b,function(b){return g.includeDestroyed||b===n||null===b||!a.a.c(b._destroy)});
a.l.w(a.a.Bb,null,[k,b,u,g,p])},null,{i:k})};var k=a.a.e.I();a.d.template={init:function(b,c){var d=a.a.c(c());if("string"==typeof d||d.name)a.f.xa(b);else{if("nodes"in d){if(d=d.nodes||[],a.H(d))throw Error('The "nodes" option must be a plain, non-observable array.');}else d=a.f.childNodes(b);d=a.a.jc(d);(new a.v.qa(b)).nodes(d)}return{controlsDescendantBindings:!0}},update:function(b,c,d,e,f){var g=c(),s;c=a.a.c(g);d=!0;e=null;"string"==typeof c?c={}:(g=c.name,"if"in c&&(d=a.a.c(c["if"])),d&&"ifnot"in
c&&(d=!a.a.c(c.ifnot)),s=a.a.c(c.data));"foreach"in c?e=a.kd(g||b,d&&c.foreach||[],c,b,f):d?(f="data"in c?f.createChildContext(s,c.as):f,e=a.Ab(g||b,f,c,b)):a.f.xa(b);f=e;(s=a.a.e.get(b,k))&&"function"==typeof s.k&&s.k();a.a.e.set(b,k,f&&f.ba()?f:n)}};a.h.ta.template=function(b){b=a.h.yb(b);return 1==b.length&&b[0].unknown||a.h.ad(b,"name")?null:"This template engine does not support anonymous templates nested within its templates"};a.f.Z.template=!0})();a.b("setTemplateEngine",a.Db);a.b("renderTemplate",
a.Ab);a.a.dc=function(a,c,d){if(a.length&&c.length){var e,f,g,k,l;for(e=f=0;(!d||e<d)&&(k=a[f]);++f){for(g=0;l=c[g];++g)if(k.value===l.value){k.moved=l.index;l.moved=k.index;c.splice(g,1);e=g=0;break}e+=g}}};a.a.ib=function(){function b(b,d,e,f,g){var k=Math.min,l=Math.max,m=[],h,n=b.length,q,p=d.length,s=p-n||1,u=n+p+1,t,v,x;for(h=0;h<=n;h++)for(v=t,m.push(t=[]),x=k(p,h+s),q=l(0,h-1);q<=x;q++)t[q]=q?h?b[h-1]===d[q-1]?v[q-1]:k(v[q]||u,t[q-1]||u)+1:q+1:h+1;k=[];l=[];s=[];h=n;for(q=p;h||q;)p=m[h][q]-
1,q&&p===m[h][q-1]?l.push(k[k.length]={status:e,value:d[--q],index:q}):h&&p===m[h-1][q]?s.push(k[k.length]={status:f,value:b[--h],index:h}):(--q,--h,g.sparse||k.push({status:"retained",value:d[q]}));a.a.dc(s,l,!g.dontLimitMoves&&10*n);return k.reverse()}return function(a,d,e){e="boolean"===typeof e?{dontLimitMoves:e}:e||{};a=a||[];d=d||[];return a.length<d.length?b(a,d,"added","deleted",e):b(d,a,"deleted","added",e)}}();a.b("utils.compareArrays",a.a.ib);(function(){function b(b,c,d,k,l){var m=[],
h=a.B(function(){var h=c(d,l,a.a.za(m,b))||[];0<m.length&&(a.a.qc(m,h),k&&a.l.w(k,null,[d,h,l]));m.length=0;a.a.ra(m,h)},null,{i:b,wa:function(){return!a.a.Qb(m)}});return{ca:m,B:h.ba()?h:n}}var c=a.a.e.I(),d=a.a.e.I();a.a.Bb=function(e,f,g,k,l){function m(b,c){w=q[c];v!==c&&(D[b]=w);w.qb(v++);a.a.za(w.ca,e);u.push(w);z.push(w)}function h(b,c){if(b)for(var d=0,e=c.length;d<e;d++)c[d]&&a.a.q(c[d].ca,function(a){b(a,d,c[d].ja)})}f=f||[];k=k||{};var r=a.a.e.get(e,c)===n,q=a.a.e.get(e,c)||[],p=a.a.fb(q,
function(a){return a.ja}),s=a.a.ib(p,f,k.dontLimitMoves),u=[],t=0,v=0,x=[],z=[];f=[];for(var D=[],p=[],w,C=0,B,E;B=s[C];C++)switch(E=B.moved,B.status){case "deleted":E===n&&(w=q[t],w.B&&(w.B.k(),w.B=n),a.a.za(w.ca,e).length&&(k.beforeRemove&&(u.push(w),z.push(w),w.ja===d?w=null:f[C]=w),w&&x.push.apply(x,w.ca)));t++;break;case "retained":m(C,t++);break;case "added":E!==n?m(C,E):(w={ja:B.value,qb:a.N(v++)},u.push(w),z.push(w),r||(p[C]=w))}a.a.e.set(e,c,u);h(k.beforeMove,D);a.a.q(x,k.beforeRemove?a.$:
a.removeNode);for(var C=0,r=a.f.firstChild(e),F;w=z[C];C++){w.ca||a.a.extend(w,b(e,g,w.ja,l,w.qb));for(t=0;s=w.ca[t];r=s.nextSibling,F=s,t++)s!==r&&a.f.gc(e,s,F);!w.Wc&&l&&(l(w.ja,w.ca,w.qb),w.Wc=!0)}h(k.beforeRemove,f);for(C=0;C<f.length;++C)f[C]&&(f[C].ja=d);h(k.afterMove,D);h(k.afterAdd,p)}})();a.b("utils.setDomNodeChildrenFromArrayMapping",a.a.Bb);a.W=function(){this.allowTemplateRewriting=!1};a.W.prototype=new a.O;a.W.prototype.renderTemplateSource=function(b,c,d,e){if(c=(9>a.a.C?0:b.nodes)?
b.nodes():null)return a.a.V(c.cloneNode(!0).childNodes);b=b.text();return a.a.ma(b,e)};a.W.sb=new a.W;a.Db(a.W.sb);a.b("nativeTemplateEngine",a.W);(function(){a.vb=function(){var a=this.$c=function(){if(!v||!v.tmpl)return 0;try{if(0<=v.tmpl.tag.tmpl.open.toString().indexOf("__"))return 2}catch(a){}return 1}();this.renderTemplateSource=function(b,e,f,g){g=g||u;f=f||{};if(2>a)throw Error("Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later.");var k=b.data("precompiled");
k||(k=b.text()||"",k=v.template(null,"{{ko_with $item.koBindingContext}}"+k+"{{/ko_with}}"),b.data("precompiled",k));b=[e.$data];e=v.extend({koBindingContext:e},f.templateOptions);e=v.tmpl(k,b,e);e.appendTo(g.createElement("div"));v.fragments={};return e};this.createJavaScriptEvaluatorBlock=function(a){return"{{ko_code ((function() { return "+a+" })()) }}"};this.addTemplate=function(a,b){u.write("<script type='text/html' id='"+a+"'>"+b+"\x3c/script>")};0<a&&(v.tmpl.tag.ko_code={open:"__.push($1 || '');"},
v.tmpl.tag.ko_with={open:"with($1) {",close:"} "})};a.vb.prototype=new a.O;var b=new a.vb;0<b.$c&&a.Db(b);a.b("jqueryTmplTemplateEngine",a.vb)})()})})();})();
/**
* @license
* Knockout ES5 plugin - https://github.com/SteveSanderson/knockout-es5
* Copyright (c) Steve Sanderson
* MIT license
*/
define('ThirdParty/knockout-es5',[],function() {
'use strict';
var OBSERVABLES_PROPERTY = '__knockoutObservables';
var SUBSCRIBABLE_PROPERTY = '__knockoutSubscribable';
// Model tracking
// --------------
//
// This is the central feature of Knockout-ES5. We augment model objects by converting properties
// into ES5 getter/setter pairs that read/write an underlying Knockout observable. This means you can
// use plain JavaScript syntax to read/write the property while still getting the full benefits of
// Knockout's automatic dependency detection and notification triggering.
//
// For comparison, here's Knockout ES3-compatible syntax:
//
// var firstNameLength = myModel.user().firstName().length; // Read
// myModel.user().firstName('Bert'); // Write
//
// ... versus Knockout-ES5 syntax:
//
// var firstNameLength = myModel.user.firstName.length; // Read
// myModel.user.firstName = 'Bert'; // Write
// `ko.track(model)` converts each property on the given model object into a getter/setter pair that
// wraps a Knockout observable. Optionally specify an array of property names to wrap; otherwise we
// wrap all properties. If any of the properties are already observables, we replace them with
// ES5 getter/setter pairs that wrap your original observable instances. In the case of readonly
// ko.computed properties, we simply do not define a setter (so attempted writes will be ignored,
// which is how ES5 readonly properties normally behave).
//
// By design, this does *not* recursively walk child object properties, because making literally
// everything everywhere independently observable is usually unhelpful. When you do want to track
// child object properties independently, define your own class for those child objects and put
// a separate ko.track call into its constructor --- this gives you far more control.
function track(obj, propertyNames) {
if (!obj /*|| typeof obj !== 'object'*/) {
throw new Error('When calling ko.track, you must pass an object as the first parameter.');
}
var ko = this,
allObservablesForObject = getAllObservablesForObject(obj, true);
propertyNames = propertyNames || Object.getOwnPropertyNames(obj);
propertyNames.forEach(function(propertyName) {
// Skip storage properties
if (propertyName === OBSERVABLES_PROPERTY || propertyName === SUBSCRIBABLE_PROPERTY) {
return;
}
// Skip properties that are already tracked
if (propertyName in allObservablesForObject) {
return;
}
var origValue = obj[propertyName],
isArray = origValue instanceof Array,
observable = ko.isObservable(origValue) ? origValue
: isArray ? ko.observableArray(origValue)
: ko.observable(origValue);
Object.defineProperty(obj, propertyName, {
configurable: true,
enumerable: true,
get: observable,
set: ko.isWriteableObservable(observable) ? observable : undefined
});
allObservablesForObject[propertyName] = observable;
if (isArray) {
notifyWhenPresentOrFutureArrayValuesMutate(ko, observable);
}
});
return obj;
}
// Gets or creates the hidden internal key-value collection of observables corresponding to
// properties on the model object.
function getAllObservablesForObject(obj, createIfNotDefined) {
var result = obj[OBSERVABLES_PROPERTY];
if (!result && createIfNotDefined) {
result = {};
Object.defineProperty(obj, OBSERVABLES_PROPERTY, {
value : result
});
}
return result;
}
// Computed properties
// -------------------
//
// The preceding code is already sufficient to upgrade ko.computed model properties to ES5
// getter/setter pairs (or in the case of readonly ko.computed properties, just a getter).
// These then behave like a regular property with a getter function, except they are smarter:
// your evaluator is only invoked when one of its dependencies changes. The result is cached
// and used for all evaluations until the next time a dependency changes).
//
// However, instead of forcing developers to declare a ko.computed property explicitly, it's
// nice to offer a utility function that declares a computed getter directly.
// Implements `ko.defineProperty`
function defineComputedProperty(obj, propertyName, evaluatorOrOptions) {
var ko = this,
computedOptions = { owner: obj, deferEvaluation: true };
if (typeof evaluatorOrOptions === 'function') {
computedOptions.read = evaluatorOrOptions;
} else {
if ('value' in evaluatorOrOptions) {
throw new Error('For ko.defineProperty, you must not specify a "value" for the property. You must provide a "get" function.');
}
if (typeof evaluatorOrOptions.get !== 'function') {
throw new Error('For ko.defineProperty, the third parameter must be either an evaluator function, or an options object containing a function called "get".');
}
computedOptions.read = evaluatorOrOptions.get;
computedOptions.write = evaluatorOrOptions.set;
}
obj[propertyName] = ko.computed(computedOptions);
track.call(ko, obj, [propertyName]);
return obj;
}
// Array handling
// --------------
//
// Arrays are special, because unlike other property types, they have standard mutator functions
// (`push`/`pop`/`splice`/etc.) and it's desirable to trigger a change notification whenever one of
// those mutator functions is invoked.
//
// Traditionally, Knockout handles this by putting special versions of `push`/`pop`/etc. on observable
// arrays that mutate the underlying array and then trigger a notification. That approach doesn't
// work for Knockout-ES5 because properties now return the underlying arrays, so the mutator runs
// in the context of the underlying array, not any particular observable:
//
// // Operates on the underlying array value
// myModel.someCollection.push('New value');
//
// To solve this, Knockout-ES5 detects array values, and modifies them as follows:
// 1. Associates a hidden subscribable with each array instance that it encounters
// 2. Intercepts standard mutators (`push`/`pop`/etc.) and makes them trigger the subscribable
// Then, for model properties whose values are arrays, the property's underlying observable
// subscribes to the array subscribable, so it can trigger a change notification after mutation.
// Given an observable that underlies a model property, watch for any array value that might
// be assigned as the property value, and hook into its change events
function notifyWhenPresentOrFutureArrayValuesMutate(ko, observable) {
var watchingArraySubscription = null;
ko.computed(function () {
// Unsubscribe to any earlier array instance
if (watchingArraySubscription) {
watchingArraySubscription.dispose();
watchingArraySubscription = null;
}
// Subscribe to the new array instance
var newArrayInstance = observable();
if (newArrayInstance instanceof Array) {
watchingArraySubscription = startWatchingArrayInstance(ko, observable, newArrayInstance);
}
});
}
// Listens for array mutations, and when they happen, cause the observable to fire notifications.
// This is used to make model properties of type array fire notifications when the array changes.
// Returns a subscribable that can later be disposed.
function startWatchingArrayInstance(ko, observable, arrayInstance) {
var subscribable = getSubscribableForArray(ko, arrayInstance);
return subscribable.subscribe(observable);
}
// Gets or creates a subscribable that fires after each array mutation
function getSubscribableForArray(ko, arrayInstance) {
var subscribable = arrayInstance[SUBSCRIBABLE_PROPERTY];
if (!subscribable) {
subscribable = new ko.subscribable();
Object.defineProperty(arrayInstance, SUBSCRIBABLE_PROPERTY, {
value : subscribable
});
var notificationPauseSignal = {};
wrapStandardArrayMutators(arrayInstance, subscribable, notificationPauseSignal);
addKnockoutArrayMutators(ko, arrayInstance, subscribable, notificationPauseSignal);
}
return subscribable;
}
// After each array mutation, fires a notification on the given subscribable
function wrapStandardArrayMutators(arrayInstance, subscribable, notificationPauseSignal) {
['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'].forEach(function(fnName) {
var origMutator = arrayInstance[fnName];
arrayInstance[fnName] = function() {
var result = origMutator.apply(this, arguments);
if (notificationPauseSignal.pause !== true) {
subscribable.notifySubscribers(this);
}
return result;
};
});
}
// Adds Knockout's additional array mutation functions to the array
function addKnockoutArrayMutators(ko, arrayInstance, subscribable, notificationPauseSignal) {
['remove', 'removeAll', 'destroy', 'destroyAll', 'replace'].forEach(function(fnName) {
// Make it a non-enumerable property for consistency with standard Array functions
Object.defineProperty(arrayInstance, fnName, {
enumerable: false,
value: function() {
var result;
// These additional array mutators are built using the underlying push/pop/etc.
// mutators, which are wrapped to trigger notifications. But we don't want to
// trigger multiple notifications, so pause the push/pop/etc. wrappers and
// delivery only one notification at the end of the process.
notificationPauseSignal.pause = true;
try {
// Creates a temporary observableArray that can perform the operation.
result = ko.observableArray.fn[fnName].apply(ko.observableArray(arrayInstance), arguments);
}
finally {
notificationPauseSignal.pause = false;
}
subscribable.notifySubscribers(arrayInstance);
return result;
}
});
});
}
// Static utility functions
// ------------------------
//
// Since Knockout-ES5 sets up properties that return values, not observables, you can't
// trivially subscribe to the underlying observables (e.g., `someProperty.subscribe(...)`),
// or tell them that object values have mutated, etc. To handle this, we set up some
// extra utility functions that can return or work with the underlying observables.
// Returns the underlying observable associated with a model property (or `null` if the
// model or property doesn't exist, or isn't associated with an observable). This means
// you can subscribe to the property, e.g.:
//
// ko.getObservable(model, 'propertyName')
// .subscribe(function(newValue) { ... });
function getObservable(obj, propertyName) {
if (!obj /*|| typeof obj !== 'object'*/) {
return null;
}
var allObservablesForObject = getAllObservablesForObject(obj, false);
return (allObservablesForObject && allObservablesForObject[propertyName]) || null;
}
// Causes a property's associated observable to fire a change notification. Useful when
// the property value is a complex object and you've modified a child property.
function valueHasMutated(obj, propertyName) {
var observable = getObservable(obj, propertyName);
if (observable) {
observable.valueHasMutated();
}
}
// Extends a Knockout instance with Knockout-ES5 functionality
function attachToKo(ko) {
ko.track = track;
ko.getObservable = getObservable;
ko.valueHasMutated = valueHasMutated;
ko.defineProperty = defineComputedProperty;
}
return {
attachToKo : attachToKo
};
});
/*global define*/
define('Widgets/SvgPathBindingHandler',[],function() {
'use strict';
var svgNS = 'http://www.w3.org/2000/svg';
var svgClassName = 'cesium-svgPath-svg';
/**
* A Knockout binding handler that creates a DOM element for a single SVG path.
* This binding handler will be registered as cesiumSvgPath.
*
* <p>
* The parameter to this binding is an object with the following properties:
* </p>
*
* <ul>
* <li>path: The SVG path as a string.</li>
* <li>width: The width of the SVG path with no transformations applied.</li>
* <li>height: The height of the SVG path with no transformations applied.</li>
* <li>css: Optional. A string containing additional CSS classes to apply to the SVG. 'cesium-svgPath-svg' is always applied.</li>
* </ul>
*
* @exports SvgPathBindingHandler
*
* @example
* // Create an SVG as a child of a div
* <div data-bind="cesiumSvgPath: { path: 'M 100 100 L 300 100 L 200 300 z', width: 28, height: 28 }"></div>
*
* // parameters can be observable from the view model
* <div data-bind="cesiumSvgPath: { path: currentPath, width: currentWidth, height: currentHeight }"></div>
*
* // or the whole object can be observable from the view model
* <div data-bind="cesiumSvgPath: svgPathOptions"></div>
*/
var SvgPathBindingHandler = {
register : function(knockout) {
knockout.bindingHandlers.cesiumSvgPath = {
init : function(element, valueAccessor) {
var svg = document.createElementNS(svgNS, 'svg:svg');
svg.setAttribute('class', svgClassName);
var pathElement = document.createElementNS(svgNS, 'path');
svg.appendChild(pathElement);
knockout.virtualElements.setDomNodeChildren(element, [svg]);
knockout.computed({
read : function() {
var value = knockout.unwrap(valueAccessor());
pathElement.setAttribute('d', knockout.unwrap(value.path));
var pathWidth = knockout.unwrap(value.width);
var pathHeight = knockout.unwrap(value.height);
svg.setAttribute('width', pathWidth);
svg.setAttribute('height', pathHeight);
svg.setAttribute('viewBox', '0 0 ' + pathWidth + ' ' + pathHeight);
if (value.css) {
svg.setAttribute('class', svgClassName + ' ' + knockout.unwrap(value.css));
}
},
disposeWhenNodeIsRemoved : element
});
return {
controlsDescendantBindings : true
};
}
};
knockout.virtualElements.allowedBindings.cesiumSvgPath = true;
}
};
return SvgPathBindingHandler;
});
/*global define*/
define('ThirdParty/knockout',[
'./knockout-3.4.0',
'./knockout-es5',
'../Widgets/SvgPathBindingHandler'
], function(
knockout,
knockout_es5,
SvgPathBindingHandler) {
"use strict";
// install the Knockout-ES5 plugin
knockout_es5.attachToKo(knockout);
// Register all Cesium binding handlers
SvgPathBindingHandler.register(knockout);
return knockout;
});
/**
* @license
* NoSleep.js v0.5.0 - git.io/vfn01
* Rich Tibbett
* MIT license
**/
/*global define*/
define('ThirdParty/NoSleep',[],function() {
"use strict";
// UA matching
var ua = {
Android: typeof navigator !== 'undefined' && /Android/ig.test(navigator.userAgent),
iOS: typeof navigator !== 'undefined' && /AppleWebKit/.test(navigator.userAgent) && /Mobile\/\w+/.test(navigator.userAgent)
};
var media = {
WebM: "data:video/webm;base64,GkXfo0AgQoaBAUL3gQFC8oEEQvOBCEKCQAR3ZWJtQoeBAkKFgQIYU4BnQI0VSalmQCgq17FAAw9CQE2AQAZ3aGFtbXlXQUAGd2hhbW15RIlACECPQAAAAAAAFlSua0AxrkAu14EBY8WBAZyBACK1nEADdW5khkAFVl9WUDglhohAA1ZQOIOBAeBABrCBCLqBCB9DtnVAIueBAKNAHIEAAIAwAQCdASoIAAgAAUAmJaQAA3AA/vz0AAA=",
MP4: "data:video/mp4;base64,AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAAAAhmcmVlAAAAG21kYXQAAAGzABAHAAABthADAowdbb9/AAAC6W1vb3YAAABsbXZoZAAAAAB8JbCAfCWwgAAAA+gAAAAAAAEAAAEAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAIVdHJhawAAAFx0a2hkAAAAD3wlsIB8JbCAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAAIAAAACAAAAAABsW1kaWEAAAAgbWRoZAAAAAB8JbCAfCWwgAAAA+gAAAAAVcQAAAAAAC1oZGxyAAAAAAAAAAB2aWRlAAAAAAAAAAAAAAAAVmlkZW9IYW5kbGVyAAAAAVxtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAEcc3RibAAAALhzdHNkAAAAAAAAAAEAAACobXA0dgAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAIAAgASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAAFJlc2RzAAAAAANEAAEABDwgEQAAAAADDUAAAAAABS0AAAGwAQAAAbWJEwAAAQAAAAEgAMSNiB9FAEQBFGMAAAGyTGF2YzUyLjg3LjQGAQIAAAAYc3R0cwAAAAAAAAABAAAAAQAAAAAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAAEAAAABAAAAFHN0c3oAAAAAAAAAEwAAAAEAAAAUc3RjbwAAAAAAAAABAAAALAAAAGB1ZHRhAAAAWG1ldGEAAAAAAAAAIWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAAK2lsc3QAAAAjqXRvbwAAABtkYXRhAAAAAQAAAABMYXZmNTIuNzguMw=="
};
function addSourceToVideo(element, type, dataURI) {
var source = document.createElement('source');
source.src = dataURI;
source.type = "video/" + type;
element.appendChild(source);
}
// NoSleep instance constructor
var NoSleep = function() {
if (ua.iOS) {
this.noSleepTimer = null;
} else if (ua.Android) {
// Set up no sleep video element
this.noSleepVideo = document.createElement('video');
this.noSleepVideo.setAttribute("loop", "");
// Append nosleep video sources
addSourceToVideo(this.noSleepVideo, "webm", media.WebM);
addSourceToVideo(this.noSleepVideo, "mp4", media.MP4);
}
return this;
};
// Enable NoSleep instance
NoSleep.prototype.enable = function(duration) {
if (ua.iOS) {
this.disable();
this.noSleepTimer = window.setInterval(function() {
window.location = window.location;
window.setTimeout(window.stop, 0);
}, duration || 15000);
} else if (ua.Android) {
this.noSleepVideo.play();
}
};
// Disable NoSleep instance
NoSleep.prototype.disable = function() {
if (ua.iOS) {
if (this.noSleepTimer) {
window.clearInterval(this.noSleepTimer);
this.noSleepTimer = null;
}
} else if (ua.Android) {
this.noSleepVideo.pause();
}
};
// Append NoSleep API to root object
//root.NoSleep = NoSleep;
return NoSleep;
});
/*global define*/
define('Widgets/subscribeAndEvaluate',[
'../ThirdParty/knockout'
], function(
knockout) {
'use strict';
/**
* Subscribe to a Knockout observable ES5 property, and immediately fire
* the callback with the current value of the property.
*
* @private
*
* @exports subscribeAndEvaluate
*
* @param {Object} owner The object containing the observable property.
* @param {String} observablePropertyName The name of the observable property.
* @param {Function} callback The callback function.
* @param {Object} [target] The value of this in the callback function.
* @param {String} [event='change'] The name of the event to receive notification for.
* @returns The subscription object from Knockout which can be used to dispose the subscription later.
*/
function subscribeAndEvaluate(owner, observablePropertyName, callback, target, event) {
callback.call(target, owner[observablePropertyName]);
return knockout.getObservable(owner, observablePropertyName).subscribe(callback, target, event);
}
return subscribeAndEvaluate;
});
/*global define*/
define('Widgets/Animation/Animation',[
'../../Core/Color',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../getElement',
'../subscribeAndEvaluate'
], function(
Color,
defined,
defineProperties,
destroyObject,
DeveloperError,
getElement,
subscribeAndEvaluate) {
'use strict';
var svgNS = "http://www.w3.org/2000/svg";
var xlinkNS = "http://www.w3.org/1999/xlink";
var widgetForDrag;
var gradientEnabledColor0 = Color.fromCssColorString('rgba(247,250,255,0.384)');
var gradientEnabledColor1 = Color.fromCssColorString('rgba(143,191,255,0.216)');
var gradientEnabledColor2 = Color.fromCssColorString('rgba(153,197,255,0.098)');
var gradientEnabledColor3 = Color.fromCssColorString('rgba(255,255,255,0.086)');
var gradientDisabledColor0 = Color.fromCssColorString('rgba(255,255,255,0.267)');
var gradientDisabledColor1 = Color.fromCssColorString('rgba(255,255,255,0)');
var gradientKnobColor = Color.fromCssColorString('rgba(66,67,68,0.3)');
var gradientPointerColor = Color.fromCssColorString('rgba(0,0,0,0.5)');
function getElementColor(element) {
return Color.fromCssColorString(window.getComputedStyle(element).getPropertyValue('color'));
}
//Dynamically builds an SVG element from a JSON object.
function svgFromObject(obj) {
var ele = document.createElementNS(svgNS, obj.tagName);
for ( var field in obj) {
if (obj.hasOwnProperty(field) && field !== 'tagName') {
if (field === 'children') {
var i;
var len = obj.children.length;
for (i = 0; i < len; ++i) {
ele.appendChild(svgFromObject(obj.children[i]));
}
} else if (field.indexOf('xlink:') === 0) {
ele.setAttributeNS(xlinkNS, field.substring(6), obj[field]);
} else if (field === 'textContent') {
ele.textContent = obj[field];
} else {
ele.setAttribute(field, obj[field]);
}
}
}
return ele;
}
function svgText(x, y, msg) {
var text = document.createElementNS(svgNS, 'text');
text.setAttribute('x', x);
text.setAttribute('y', y);
text.setAttribute('class', 'cesium-animation-svgText');
var tspan = document.createElementNS(svgNS, 'tspan');
tspan.textContent = msg;
text.appendChild(tspan);
return text;
}
function setShuttleRingPointer(shuttleRingPointer, knobOuter, angle) {
shuttleRingPointer.setAttribute('transform', 'translate(100,100) rotate(' + angle + ')');
knobOuter.setAttribute('transform', 'rotate(' + angle + ')');
}
var makeColorStringScratch = new Color();
function makeColorString(background, gradient) {
var gradientAlpha = gradient.alpha;
var backgroundAlpha = 1.0 - gradientAlpha;
makeColorStringScratch.red = (background.red * backgroundAlpha) + (gradient.red * gradientAlpha);
makeColorStringScratch.green = (background.green * backgroundAlpha) + (gradient.green * gradientAlpha);
makeColorStringScratch.blue = (background.blue * backgroundAlpha) + (gradient.blue * gradientAlpha);
return makeColorStringScratch.toCssColorString();
}
function rectButton(x, y, path) {
var button = {
tagName : 'g',
'class' : 'cesium-animation-rectButton',
transform : 'translate(' + x + ',' + y + ')',
children : [{
tagName : 'rect',
'class' : 'cesium-animation-buttonGlow',
width : 32,
height : 32,
rx : 2,
ry : 2
}, {
tagName : 'rect',
'class' : 'cesium-animation-buttonMain',
width : 32,
height : 32,
rx : 4,
ry : 4
}, {
tagName : 'use',
'class' : 'cesium-animation-buttonPath',
'xlink:href' : path
}, {
tagName : 'title',
textContent : ''
}]
};
return svgFromObject(button);
}
function wingButton(x, y, path) {
var button = {
tagName : 'g',
'class' : 'cesium-animation-rectButton',
transform : 'translate(' + x + ',' + y + ')',
children : [{
tagName : 'use',
'class' : 'cesium-animation-buttonGlow',
'xlink:href' : '#animation_pathWingButton'
}, {
tagName : 'use',
'class' : 'cesium-animation-buttonMain',
'xlink:href' : '#animation_pathWingButton'
}, {
tagName : 'use',
'class' : 'cesium-animation-buttonPath',
'xlink:href' : path
}, {
tagName : 'title',
textContent : ''
}]
};
return svgFromObject(button);
}
function setShuttleRingFromMouseOrTouch(widget, e) {
var viewModel = widget._viewModel;
var shuttleRingDragging = viewModel.shuttleRingDragging;
if (shuttleRingDragging && (widgetForDrag !== widget)) {
return;
}
if (e.type === 'mousedown' || (shuttleRingDragging && e.type === 'mousemove') ||
(e.type === 'touchstart' && e.touches.length === 1) ||
(shuttleRingDragging && e.type === 'touchmove' && e.touches.length === 1)) {
var centerX = widget._centerX;
var centerY = widget._centerY;
var svg = widget._svgNode;
var rect = svg.getBoundingClientRect();
var clientX;
var clientY;
if (e.type === 'touchstart' || e.type === 'touchmove') {
clientX = e.touches[0].clientX;
clientY = e.touches[0].clientY;
} else {
clientX = e.clientX;
clientY = e.clientY;
}
if (!shuttleRingDragging &&
(clientX > rect.right ||
clientX < rect.left ||
clientY < rect.top ||
clientY > rect.bottom)) {
return;
}
var pointerRect = widget._shuttleRingPointer.getBoundingClientRect();
var x = clientX - centerX - rect.left;
var y = clientY - centerY - rect.top;
var angle = Math.atan2(y, x) * 180 / Math.PI + 90;
if (angle > 180) {
angle -= 360;
}
var shuttleRingAngle = viewModel.shuttleRingAngle;
if (shuttleRingDragging || (clientX < pointerRect.right && clientX > pointerRect.left && clientY > pointerRect.top && clientY < pointerRect.bottom)) {
widgetForDrag = widget;
viewModel.shuttleRingDragging = true;
viewModel.shuttleRingAngle = angle;
} else if (angle < shuttleRingAngle) {
viewModel.slower();
} else if (angle > shuttleRingAngle) {
viewModel.faster();
}
e.preventDefault();
} else {
if (widget === widgetForDrag) {
widgetForDrag = undefined;
}
viewModel.shuttleRingDragging = false;
}
}
//This is a private class for treating an SVG element like a button.
//If we ever need a general purpose SVG button, we can make this generic.
function SvgButton(svgElement, viewModel) {
this._viewModel = viewModel;
this.svgElement = svgElement;
this._enabled = undefined;
this._toggled = undefined;
var that = this;
this._clickFunction = function() {
var command = that._viewModel.command;
if (command.canExecute) {
command();
}
};
svgElement.addEventListener('click', this._clickFunction, true);
//TODO: Since the animation widget uses SVG and has no HTML backing,
//we need to wire everything up manually. Knockout can supposedly
//bind to SVG, so we we figure that out we can modify our SVG
//to include the binding information directly.
this._subscriptions = [//
subscribeAndEvaluate(viewModel, 'toggled', this.setToggled, this),//
subscribeAndEvaluate(viewModel, 'tooltip', this.setTooltip, this),//
subscribeAndEvaluate(viewModel.command, 'canExecute', this.setEnabled, this)];
}
SvgButton.prototype.destroy = function() {
this.svgElement.removeEventListener('click', this._clickFunction, true);
var subscriptions = this._subscriptions;
for ( var i = 0, len = subscriptions.length; i < len; i++) {
subscriptions[i].dispose();
}
destroyObject(this);
};
SvgButton.prototype.isDestroyed = function() {
return false;
};
SvgButton.prototype.setEnabled = function(enabled) {
if (this._enabled !== enabled) {
this._enabled = enabled;
if (!enabled) {
this.svgElement.setAttribute('class', 'cesium-animation-buttonDisabled');
return;
}
if (this._toggled) {
this.svgElement.setAttribute('class', 'cesium-animation-rectButton cesium-animation-buttonToggled');
return;
}
this.svgElement.setAttribute('class', 'cesium-animation-rectButton');
}
};
SvgButton.prototype.setToggled = function(toggled) {
if (this._toggled !== toggled) {
this._toggled = toggled;
if (this._enabled) {
if (toggled) {
this.svgElement.setAttribute('class', 'cesium-animation-rectButton cesium-animation-buttonToggled');
} else {
this.svgElement.setAttribute('class', 'cesium-animation-rectButton');
}
}
}
};
SvgButton.prototype.setTooltip = function(tooltip) {
this.svgElement.getElementsByTagName('title')[0].textContent = tooltip;
};
/**
* <span style="display: block; text-align: center;">
* <img src="images/AnimationWidget.png" width="211" height="142" alt="" />
* <br />Animation widget
* </span>
* <br /><br />
* The Animation widget provides buttons for play, pause, and reverse, along with the
* current time and date, surrounded by a "shuttle ring" for controlling the speed of animation.
* <br /><br />
* The "shuttle ring" concept is borrowed from video editing, where typically a
* "jog wheel" can be rotated to move past individual animation frames very slowly, and
* a surrounding shuttle ring can be twisted to control direction and speed of fast playback.
* Cesium typically treats time as continuous (not broken into pre-defined animation frames),
* so this widget offers no jog wheel. Instead, the shuttle ring is capable of both fast and
* very slow playback. Click and drag the shuttle ring pointer itself (shown above in green),
* or click in the rest of the ring area to nudge the pointer to the next preset speed in that direction.
* <br /><br />
* The Animation widget also provides a "realtime" button (in the upper-left) that keeps
* animation time in sync with the end user's system clock, typically displaying
* "today" or "right now." This mode is not available in {@link ClockRange.CLAMPED} or
* {@link ClockRange.LOOP_STOP} mode if the current time is outside of {@link Clock}'s startTime and endTime.
*
* @alias Animation
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {AnimationViewModel} viewModel The view model used by this widget.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*
*
* @example
* // In HTML head, include a link to Animation.css stylesheet,
* // and in the body, include: <div id="animationContainer"></div>
*
* var clock = new Cesium.Clock();
* var clockViewModel = new Cesium.ClockViewModel(clock);
* var viewModel = new Cesium.AnimationViewModel(clockViewModel);
* var widget = new Cesium.Animation('animationContainer', viewModel);
*
* function tick() {
* clock.tick();
* Cesium.requestAnimationFrame(tick);
* }
* Cesium.requestAnimationFrame(tick);
*
* @see AnimationViewModel
* @see Clock
*/
function Animation(container, viewModel) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
if (!defined(viewModel)) {
throw new DeveloperError('viewModel is required.');
}
container = getElement(container);
this._viewModel = viewModel;
this._container = container;
this._centerX = 0;
this._centerY = 0;
this._defsElement = undefined;
this._svgNode = undefined;
this._topG = undefined;
this._lastHeight = undefined;
this._lastWidth = undefined;
// Firefox requires SVG references to be included directly, not imported from external CSS.
// Also, CSS minifiers get confused by this being in an external CSS file.
var cssStyle = document.createElement('style');
cssStyle.textContent = '.cesium-animation-rectButton .cesium-animation-buttonGlow { filter: url(#animation_blurred); }\
.cesium-animation-rectButton .cesium-animation-buttonMain { fill: url(#animation_buttonNormal); }\
.cesium-animation-buttonToggled .cesium-animation-buttonMain { fill: url(#animation_buttonToggled); }\
.cesium-animation-rectButton:hover .cesium-animation-buttonMain { fill: url(#animation_buttonHovered); }\
.cesium-animation-buttonDisabled .cesium-animation-buttonMain { fill: url(#animation_buttonDisabled); }\
.cesium-animation-shuttleRingG .cesium-animation-shuttleRingSwoosh { fill: url(#animation_shuttleRingSwooshGradient); }\
.cesium-animation-shuttleRingG:hover .cesium-animation-shuttleRingSwoosh { fill: url(#animation_shuttleRingSwooshHovered); }\
.cesium-animation-shuttleRingPointer { fill: url(#animation_shuttleRingPointerGradient); }\
.cesium-animation-shuttleRingPausePointer { fill: url(#animation_shuttleRingPointerPaused); }\
.cesium-animation-knobOuter { fill: url(#animation_knobOuter); }\
.cesium-animation-knobInner { fill: url(#animation_knobInner); }';
document.head.insertBefore(cssStyle, document.head.childNodes[0]);
var themeEle = document.createElement('div');
themeEle.className = 'cesium-animation-theme';
themeEle.innerHTML = '<div class="cesium-animation-themeNormal"></div>\
<div class="cesium-animation-themeHover"></div>\
<div class="cesium-animation-themeSelect"></div>\
<div class="cesium-animation-themeDisabled"></div>\
<div class="cesium-animation-themeKnob"></div>\
<div class="cesium-animation-themePointer"></div>\
<div class="cesium-animation-themeSwoosh"></div>\
<div class="cesium-animation-themeSwooshHover"></div>';
this._theme = themeEle;
this._themeNormal = themeEle.childNodes[0];
this._themeHover = themeEle.childNodes[1];
this._themeSelect = themeEle.childNodes[2];
this._themeDisabled = themeEle.childNodes[3];
this._themeKnob = themeEle.childNodes[4];
this._themePointer = themeEle.childNodes[5];
this._themeSwoosh = themeEle.childNodes[6];
this._themeSwooshHover = themeEle.childNodes[7];
var svg = document.createElementNS(svgNS, 'svg:svg');
this._svgNode = svg;
// Define the XLink namespace that SVG uses
svg.setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:xlink', xlinkNS);
var topG = document.createElementNS(svgNS, 'g');
this._topG = topG;
this._realtimeSVG = new SvgButton(wingButton(3, 4, '#animation_pathClock'), viewModel.playRealtimeViewModel);
this._playReverseSVG = new SvgButton(rectButton(44, 99, '#animation_pathPlayReverse'), viewModel.playReverseViewModel);
this._playForwardSVG = new SvgButton(rectButton(124, 99, '#animation_pathPlay'), viewModel.playForwardViewModel);
this._pauseSVG = new SvgButton(rectButton(84, 99, '#animation_pathPause'), viewModel.pauseViewModel);
var buttonsG = document.createElementNS(svgNS, 'g');
buttonsG.appendChild(this._realtimeSVG.svgElement);
buttonsG.appendChild(this._playReverseSVG.svgElement);
buttonsG.appendChild(this._playForwardSVG.svgElement);
buttonsG.appendChild(this._pauseSVG.svgElement);
var shuttleRingBackPanel = svgFromObject({
tagName : 'circle',
'class' : 'cesium-animation-shuttleRingBack',
cx : 100,
cy : 100,
r : 99
});
this._shuttleRingBackPanel = shuttleRingBackPanel;
var shuttleRingSwooshG = svgFromObject({
tagName : 'g',
'class' : 'cesium-animation-shuttleRingSwoosh',
children : [{
tagName : 'use',
transform : 'translate(100,97) scale(-1,1)',
'xlink:href' : '#animation_pathSwooshFX'
}, {
tagName : 'use',
transform : 'translate(100,97)',
'xlink:href' : '#animation_pathSwooshFX'
}, {
tagName : 'line',
x1 : 100,
y1 : 8,
x2 : 100,
y2 : 22
}]
});
this._shuttleRingSwooshG = shuttleRingSwooshG;
this._shuttleRingPointer = svgFromObject({
tagName : 'use',
'class' : 'cesium-animation-shuttleRingPointer',
'xlink:href' : '#animation_pathPointer'
});
var knobG = svgFromObject({
tagName : 'g',
transform : 'translate(100,100)'
});
this._knobOuter = svgFromObject({
tagName : 'circle',
'class' : 'cesium-animation-knobOuter',
cx : 0,
cy : 0,
r : 71
});
var knobInnerAndShieldSize = 61;
var knobInner = svgFromObject({
tagName : 'circle',
'class' : 'cesium-animation-knobInner',
cx : 0,
cy : 0,
r : knobInnerAndShieldSize
});
this._knobDate = svgText(0, -24, '');
this._knobTime = svgText(0, -7, '');
this._knobStatus = svgText(0, -41, '');
// widget shield catches clicks on the knob itself (even while DOM elements underneath are changing).
var knobShield = svgFromObject({
tagName : 'circle',
'class' : 'cesium-animation-blank',
cx : 0,
cy : 0,
r : knobInnerAndShieldSize
});
var shuttleRingBackG = document.createElementNS(svgNS, 'g');
shuttleRingBackG.setAttribute('class', 'cesium-animation-shuttleRingG');
container.appendChild(themeEle);
topG.appendChild(shuttleRingBackG);
topG.appendChild(knobG);
topG.appendChild(buttonsG);
shuttleRingBackG.appendChild(shuttleRingBackPanel);
shuttleRingBackG.appendChild(shuttleRingSwooshG);
shuttleRingBackG.appendChild(this._shuttleRingPointer);
knobG.appendChild(this._knobOuter);
knobG.appendChild(knobInner);
knobG.appendChild(this._knobDate);
knobG.appendChild(this._knobTime);
knobG.appendChild(this._knobStatus);
knobG.appendChild(knobShield);
svg.appendChild(topG);
container.appendChild(svg);
var that = this;
function mouseCallback(e) {
setShuttleRingFromMouseOrTouch(that, e);
}
this._mouseCallback = mouseCallback;
shuttleRingBackPanel.addEventListener('mousedown', mouseCallback, true);
shuttleRingBackPanel.addEventListener('touchstart', mouseCallback, true);
shuttleRingSwooshG.addEventListener('mousedown', mouseCallback, true);
shuttleRingSwooshG.addEventListener('touchstart', mouseCallback, true);
document.addEventListener('mousemove', mouseCallback, true);
document.addEventListener('touchmove', mouseCallback, true);
document.addEventListener('mouseup', mouseCallback, true);
document.addEventListener('touchend', mouseCallback, true);
document.addEventListener('touchcancel', mouseCallback, true);
this._shuttleRingPointer.addEventListener('mousedown', mouseCallback, true);
this._shuttleRingPointer.addEventListener('touchstart', mouseCallback, true);
this._knobOuter.addEventListener('mousedown', mouseCallback, true);
this._knobOuter.addEventListener('touchstart', mouseCallback, true);
//TODO: Since the animation widget uses SVG and has no HTML backing,
//we need to wire everything up manually. Knockout can supposedly
//bind to SVG, so we we figure that out we can modify our SVG
//to include the binding information directly.
var timeNode = this._knobTime.childNodes[0];
var dateNode = this._knobDate.childNodes[0];
var statusNode = this._knobStatus.childNodes[0];
var isPaused;
this._subscriptions = [//
subscribeAndEvaluate(viewModel.pauseViewModel, 'toggled', function(value) {
if (isPaused !== value) {
isPaused = value;
if (isPaused) {
that._shuttleRingPointer.setAttribute('class', 'cesium-animation-shuttleRingPausePointer');
} else {
that._shuttleRingPointer.setAttribute('class', 'cesium-animation-shuttleRingPointer');
}
}
}),
subscribeAndEvaluate(viewModel, 'shuttleRingAngle', function(value) {
setShuttleRingPointer(that._shuttleRingPointer, that._knobOuter, value);
}),
subscribeAndEvaluate(viewModel, 'dateLabel', function(value) {
if (dateNode.textContent !== value) {
dateNode.textContent = value;
}
}),
subscribeAndEvaluate(viewModel, 'timeLabel', function(value) {
if (timeNode.textContent !== value) {
timeNode.textContent = value;
}
}),
subscribeAndEvaluate(viewModel, 'multiplierLabel', function(value) {
if (statusNode.textContent !== value) {
statusNode.textContent = value;
}
})];
this.applyThemeChanges();
this.resize();
}
defineProperties(Animation.prototype, {
/**
* Gets the parent container.
*
* @memberof Animation.prototype
* @type {Element}
* @readonly
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
*
* @memberof Animation.prototype
* @type {AnimationViewModel}
* @readonly
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
Animation.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the animation widget. Should be called if permanently
* removing the widget from layout.
*/
Animation.prototype.destroy = function() {
var mouseCallback = this._mouseCallback;
this._shuttleRingBackPanel.removeEventListener('mousedown', mouseCallback, true);
this._shuttleRingBackPanel.removeEventListener('touchstart', mouseCallback, true);
this._shuttleRingSwooshG.removeEventListener('mousedown', mouseCallback, true);
this._shuttleRingSwooshG.removeEventListener('touchstart', mouseCallback, true);
document.removeEventListener('mousemove', mouseCallback, true);
document.removeEventListener('touchmove', mouseCallback, true);
document.removeEventListener('mouseup', mouseCallback, true);
document.removeEventListener('touchend', mouseCallback, true);
document.removeEventListener('touchcancel', mouseCallback, true);
this._shuttleRingPointer.removeEventListener('mousedown', mouseCallback, true);
this._shuttleRingPointer.removeEventListener('touchstart', mouseCallback, true);
this._knobOuter.removeEventListener('mousedown', mouseCallback, true);
this._knobOuter.removeEventListener('touchstart', mouseCallback, true);
this._container.removeChild(this._svgNode);
this._container.removeChild(this._theme);
this._realtimeSVG.destroy();
this._playReverseSVG.destroy();
this._playForwardSVG.destroy();
this._pauseSVG.destroy();
var subscriptions = this._subscriptions;
for ( var i = 0, len = subscriptions.length; i < len; i++) {
subscriptions[i].dispose();
}
return destroyObject(this);
};
/**
* Resizes the widget to match the container size.
* This function should be called whenever the container size is changed.
*/
Animation.prototype.resize = function() {
var parentWidth = this._container.clientWidth;
var parentHeight = this._container.clientHeight;
if (parentWidth === this._lastWidth && parentHeight === this._lastHeight) {
return;
}
var svg = this._svgNode;
//The width and height as the SVG was originally drawn.
var baseWidth = 200;
var baseHeight = 132;
var width = parentWidth;
var height = parentHeight;
if (parentWidth === 0 && parentHeight === 0) {
width = baseWidth;
height = baseHeight;
} else if (parentWidth === 0) {
height = parentHeight;
width = baseWidth * (parentHeight / baseHeight);
} else if (parentHeight === 0) {
width = parentWidth;
height = baseHeight * (parentWidth / baseWidth);
}
var scaleX = width / baseWidth;
var scaleY = height / baseHeight;
svg.style.cssText = 'width: ' + width + 'px; height: ' + height + 'px; position: absolute; bottom: 0; left: 0; overflow: hidden;';
svg.setAttribute('width', width);
svg.setAttribute('height', height);
svg.setAttribute('viewBox', '0 0 ' + width + ' ' + height);
this._topG.setAttribute('transform', 'scale(' + scaleX + ',' + scaleY + ')');
this._centerX = Math.max(1, 100.0 * scaleX);
this._centerY = Math.max(1, 100.0 * scaleY);
this._lastHeight = parentWidth;
this._lastWidth = parentHeight;
};
/**
* Updates the widget to reflect any modified CSS rules for theming.
*
* @example
* //Switch to the cesium-lighter theme.
* document.body.className = 'cesium-lighter';
* animation.applyThemeChanges();
*/
Animation.prototype.applyThemeChanges = function() {
var buttonNormalBackColor = getElementColor(this._themeNormal);
var buttonHoverBackColor = getElementColor(this._themeHover);
var buttonToggledBackColor = getElementColor(this._themeSelect);
var buttonDisabledBackColor = getElementColor(this._themeDisabled);
var knobBackColor = getElementColor(this._themeKnob);
var pointerColor = getElementColor(this._themePointer);
var swooshColor = getElementColor(this._themeSwoosh);
var swooshHoverColor = getElementColor(this._themeSwooshHover);
var defsElement = svgFromObject({
tagName : 'defs',
children : [{
id : 'animation_buttonNormal',
tagName : 'linearGradient',
x1 : '50%',
y1 : '0%',
x2 : '50%',
y2 : '100%',
children : [
//add a 'stop-opacity' field to make translucent.
{
tagName : 'stop',
offset : '0%',
'stop-color' : makeColorString(buttonNormalBackColor, gradientEnabledColor0)
}, {
tagName : 'stop',
offset : '12%',
'stop-color' : makeColorString(buttonNormalBackColor, gradientEnabledColor1)
}, {
tagName : 'stop',
offset : '46%',
'stop-color' : makeColorString(buttonNormalBackColor, gradientEnabledColor2)
}, {
tagName : 'stop',
offset : '81%',
'stop-color' : makeColorString(buttonNormalBackColor, gradientEnabledColor3)
}]
}, {
id : 'animation_buttonHovered',
tagName : 'linearGradient',
x1 : '50%',
y1 : '0%',
x2 : '50%',
y2 : '100%',
children : [{
tagName : 'stop',
offset : '0%',
'stop-color' : makeColorString(buttonHoverBackColor, gradientEnabledColor0)
}, {
tagName : 'stop',
offset : '12%',
'stop-color' : makeColorString(buttonHoverBackColor, gradientEnabledColor1)
}, {
tagName : 'stop',
offset : '46%',
'stop-color' : makeColorString(buttonHoverBackColor, gradientEnabledColor2)
}, {
tagName : 'stop',
offset : '81%',
'stop-color' : makeColorString(buttonHoverBackColor, gradientEnabledColor3)
}]
}, {
id : 'animation_buttonToggled',
tagName : 'linearGradient',
x1 : '50%',
y1 : '0%',
x2 : '50%',
y2 : '100%',
children : [{
tagName : 'stop',
offset : '0%',
'stop-color' : makeColorString(buttonToggledBackColor, gradientEnabledColor0)
}, {
tagName : 'stop',
offset : '12%',
'stop-color' : makeColorString(buttonToggledBackColor, gradientEnabledColor1)
}, {
tagName : 'stop',
offset : '46%',
'stop-color' : makeColorString(buttonToggledBackColor, gradientEnabledColor2)
}, {
tagName : 'stop',
offset : '81%',
'stop-color' : makeColorString(buttonToggledBackColor, gradientEnabledColor3)
}]
}, {
id : 'animation_buttonDisabled',
tagName : 'linearGradient',
x1 : '50%',
y1 : '0%',
x2 : '50%',
y2 : '100%',
children : [{
tagName : 'stop',
offset : '0%',
'stop-color' : makeColorString(buttonDisabledBackColor, gradientDisabledColor0)
}, {
tagName : 'stop',
offset : '75%',
'stop-color' : makeColorString(buttonDisabledBackColor, gradientDisabledColor1)
}]
}, {
id : 'animation_blurred',
tagName : 'filter',
width : '200%',
height : '200%',
x : '-50%',
y : '-50%',
children : [{
tagName : 'feGaussianBlur',
stdDeviation : 4,
'in' : 'SourceGraphic'
}]
}, {
id : 'animation_shuttleRingSwooshGradient',
tagName : 'linearGradient',
x1 : '50%',
y1 : '0%',
x2 : '50%',
y2 : '100%',
children : [{
tagName : 'stop',
offset : '0%',
'stop-opacity' : 0.2,
'stop-color' : swooshColor.toCssColorString()
}, {
tagName : 'stop',
offset : '85%',
'stop-opacity' : 0.85,
'stop-color' : swooshColor.toCssColorString()
}, {
tagName : 'stop',
offset : '95%',
'stop-opacity' : 0.05,
'stop-color' : swooshColor.toCssColorString()
}]
}, {
id : 'animation_shuttleRingSwooshHovered',
tagName : 'linearGradient',
x1 : '50%',
y1 : '0%',
x2 : '50%',
y2 : '100%',
children : [{
tagName : 'stop',
offset : '0%',
'stop-opacity' : 0.2,
'stop-color' : swooshHoverColor.toCssColorString()
}, {
tagName : 'stop',
offset : '85%',
'stop-opacity' : 0.85,
'stop-color' : swooshHoverColor.toCssColorString()
}, {
tagName : 'stop',
offset : '95%',
'stop-opacity' : 0.05,
'stop-color' : swooshHoverColor.toCssColorString()
}]
}, {
id : 'animation_shuttleRingPointerGradient',
tagName : 'linearGradient',
x1 : '0%',
y1 : '50%',
x2 : '100%',
y2 : '50%',
children : [{
tagName : 'stop',
offset : '0%',
'stop-color' : pointerColor.toCssColorString()
}, {
tagName : 'stop',
offset : '40%',
'stop-color' : pointerColor.toCssColorString()
}, {
tagName : 'stop',
offset : '60%',
'stop-color' : makeColorString(pointerColor, gradientPointerColor)
}, {
tagName : 'stop',
offset : '100%',
'stop-color' : makeColorString(pointerColor, gradientPointerColor)
}]
}, {
id : 'animation_shuttleRingPointerPaused',
tagName : 'linearGradient',
x1 : '0%',
y1 : '50%',
x2 : '100%',
y2 : '50%',
children : [{
tagName : 'stop',
offset : '0%',
'stop-color' : '#CCC'
}, {
tagName : 'stop',
offset : '40%',
'stop-color' : '#CCC'
}, {
tagName : 'stop',
offset : '60%',
'stop-color' : '#555'
}, {
tagName : 'stop',
offset : '100%',
'stop-color' : '#555'
}]
}, {
id : 'animation_knobOuter',
tagName : 'linearGradient',
x1 : '20%',
y1 : '0%',
x2 : '90%',
y2 : '100%',
children : [{
tagName : 'stop',
offset : '5%',
'stop-color' : makeColorString(knobBackColor, gradientEnabledColor0)
}, {
tagName : 'stop',
offset : '60%',
'stop-color' : makeColorString(knobBackColor, gradientKnobColor)
}, {
tagName : 'stop',
offset : '85%',
'stop-color' : makeColorString(knobBackColor, gradientEnabledColor1)
}]
}, {
id : 'animation_knobInner',
tagName : 'linearGradient',
x1 : '20%',
y1 : '0%',
x2 : '90%',
y2 : '100%',
children : [{
tagName : 'stop',
offset : '5%',
'stop-color' : makeColorString(knobBackColor, gradientKnobColor)
}, {
tagName : 'stop',
offset : '60%',
'stop-color' : makeColorString(knobBackColor, gradientEnabledColor0)
}, {
tagName : 'stop',
offset : '85%',
'stop-color' : makeColorString(knobBackColor, gradientEnabledColor3)
}]
}, {
id : 'animation_pathReset',
tagName : 'path',
transform : 'translate(16,16) scale(0.85) translate(-16,-16)',
d : 'M24.316,5.318,9.833,13.682,9.833,5.5,5.5,5.5,5.5,25.5,9.833,25.5,9.833,17.318,24.316,25.682z'
}, {
id : 'animation_pathPause',
tagName : 'path',
transform : 'translate(16,16) scale(0.85) translate(-16,-16)',
d : 'M13,5.5,7.5,5.5,7.5,25.5,13,25.5zM24.5,5.5,19,5.5,19,25.5,24.5,25.5z'
}, {
id : 'animation_pathPlay',
tagName : 'path',
transform : 'translate(16,16) scale(0.85) translate(-16,-16)',
d : 'M6.684,25.682L24.316,15.5L6.684,5.318V25.682z'
}, {
id : 'animation_pathPlayReverse',
tagName : 'path',
transform : 'translate(16,16) scale(-0.85,0.85) translate(-16,-16)',
d : 'M6.684,25.682L24.316,15.5L6.684,5.318V25.682z'
}, {
id : 'animation_pathLoop',
tagName : 'path',
transform : 'translate(16,16) scale(0.85) translate(-16,-16)',
d : 'M24.249,15.499c-0.009,4.832-3.918,8.741-8.75,8.75c-2.515,0-4.768-1.064-6.365-2.763l2.068-1.442l-7.901-3.703l0.744,8.694l2.193-1.529c2.244,2.594,5.562,4.242,9.26,4.242c6.767,0,12.249-5.482,12.249-12.249H24.249zM15.499,6.75c2.516,0,4.769,1.065,6.367,2.764l-2.068,1.443l7.901,3.701l-0.746-8.693l-2.192,1.529c-2.245-2.594-5.562-4.245-9.262-4.245C8.734,3.25,3.25,8.734,3.249,15.499H6.75C6.758,10.668,10.668,6.758,15.499,6.75z'
}, {
id : 'animation_pathClock',
tagName : 'path',
transform : 'translate(16,16) scale(0.85) translate(-16,-15.5)',
d : 'M15.5,2.374C8.251,2.375,2.376,8.251,2.374,15.5C2.376,22.748,8.251,28.623,15.5,28.627c7.249-0.004,13.124-5.879,13.125-13.127C28.624,8.251,22.749,2.375,15.5,2.374zM15.5,25.623C9.909,25.615,5.385,21.09,5.375,15.5C5.385,9.909,9.909,5.384,15.5,5.374c5.59,0.01,10.115,4.535,10.124,10.125C25.615,21.09,21.091,25.615,15.5,25.623zM8.625,15.5c-0.001-0.552-0.448-0.999-1.001-1c-0.553,0-1,0.448-1,1c0,0.553,0.449,1,1,1C8.176,16.5,8.624,16.053,8.625,15.5zM8.179,18.572c-0.478,0.277-0.642,0.889-0.365,1.367c0.275,0.479,0.889,0.641,1.365,0.365c0.479-0.275,0.643-0.887,0.367-1.367C9.27,18.461,8.658,18.297,8.179,18.572zM9.18,10.696c-0.479-0.276-1.09-0.112-1.366,0.366s-0.111,1.09,0.365,1.366c0.479,0.276,1.09,0.113,1.367-0.366C9.821,11.584,9.657,10.973,9.18,10.696zM22.822,12.428c0.478-0.275,0.643-0.888,0.366-1.366c-0.275-0.478-0.89-0.642-1.366-0.366c-0.479,0.278-0.642,0.89-0.366,1.367C21.732,12.54,22.344,12.705,22.822,12.428zM12.062,21.455c-0.478-0.275-1.089-0.111-1.366,0.367c-0.275,0.479-0.111,1.09,0.366,1.365c0.478,0.277,1.091,0.111,1.365-0.365C12.704,22.344,12.54,21.732,12.062,21.455zM12.062,9.545c0.479-0.276,0.642-0.888,0.366-1.366c-0.276-0.478-0.888-0.642-1.366-0.366s-0.642,0.888-0.366,1.366C10.973,9.658,11.584,9.822,12.062,9.545zM22.823,18.572c-0.48-0.275-1.092-0.111-1.367,0.365c-0.275,0.479-0.112,1.092,0.367,1.367c0.477,0.275,1.089,0.113,1.365-0.365C23.464,19.461,23.3,18.848,22.823,18.572zM19.938,7.813c-0.477-0.276-1.091-0.111-1.365,0.366c-0.275,0.48-0.111,1.091,0.366,1.367s1.089,0.112,1.366-0.366C20.581,8.702,20.418,8.089,19.938,7.813zM23.378,14.5c-0.554,0.002-1.001,0.45-1.001,1c0.001,0.552,0.448,1,1.001,1c0.551,0,1-0.447,1-1C24.378,14.949,23.929,14.5,23.378,14.5zM15.501,6.624c-0.552,0-1,0.448-1,1l-0.466,7.343l-3.004,1.96c-0.478,0.277-0.642,0.889-0.365,1.365c0.275,0.479,0.889,0.643,1.365,0.367l3.305-1.676C15.39,16.99,15.444,17,15.501,17c0.828,0,1.5-0.671,1.5-1.5l-0.5-7.876C16.501,7.072,16.053,6.624,15.501,6.624zM15.501,22.377c-0.552,0-1,0.447-1,1s0.448,1,1,1s1-0.447,1-1S16.053,22.377,15.501,22.377zM18.939,21.455c-0.479,0.277-0.643,0.889-0.366,1.367c0.275,0.477,0.888,0.643,1.366,0.365c0.478-0.275,0.642-0.889,0.366-1.365C20.028,21.344,19.417,21.18,18.939,21.455z'
}, {
id : 'animation_pathWingButton',
tagName : 'path',
d : 'm 4.5,0.5 c -2.216,0 -4,1.784 -4,4 l 0,24 c 0,2.216 1.784,4 4,4 l 13.71875,0 C 22.478584,27.272785 27.273681,22.511272 32.5,18.25 l 0,-13.75 c 0,-2.216 -1.784,-4 -4,-4 l -24,0 z'
}, {
id : 'animation_pathPointer',
tagName : 'path',
d : 'M-15,-65,-15,-55,15,-55,15,-65,0,-95z'
}, {
id : 'animation_pathSwooshFX',
tagName : 'path',
d : 'm 85,0 c 0,16.617 -4.813944,35.356 -13.131081,48.4508 h 6.099803 c 8.317138,-13.0948 13.13322,-28.5955 13.13322,-45.2124 0,-46.94483 -38.402714,-85.00262 -85.7743869,-85.00262 -1.0218522,0 -2.0373001,0.0241 -3.0506131,0.0589 45.958443,1.59437 82.723058,35.77285 82.723058,81.70532 z'
}]
});
if (!defined(this._defsElement)) {
this._svgNode.appendChild(defsElement);
} else {
this._svgNode.replaceChild(defsElement, this._defsElement);
}
this._defsElement = defsElement;
};
return Animation;
});
/*global define*/
define('Widgets/createCommand',[
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../Core/Event',
'../ThirdParty/knockout'
], function(
defaultValue,
defined,
defineProperties,
DeveloperError,
Event,
knockout) {
'use strict';
/**
* Create a Command from a given function, for use with ViewModels.
*
* A Command is a function with an extra <code>canExecute</code> observable property to determine
* whether the command can be executed. When executed, a Command function will check the
* value of <code>canExecute</code> and throw if false. It also provides events for when
* a command has been or is about to be executed.
*
* @exports createCommand
*
* @param {Function} func The function to execute.
* @param {Boolean} [canExecute=true] A boolean indicating whether the function can currently be executed.
*/
function createCommand(func, canExecute) {
if (!defined(func)) {
throw new DeveloperError('func is required.');
}
canExecute = defaultValue(canExecute, true);
var beforeExecute = new Event();
var afterExecute = new Event();
function command() {
if (!command.canExecute) {
throw new DeveloperError('Cannot execute command, canExecute is false.');
}
var commandInfo = {
args : arguments,
cancel : false
};
var result;
beforeExecute.raiseEvent(commandInfo);
if (!commandInfo.cancel) {
result = func.apply(null, arguments);
afterExecute.raiseEvent(result);
}
return result;
}
command.canExecute = canExecute;
knockout.track(command, ['canExecute']);
defineProperties(command, {
beforeExecute : {
value : beforeExecute
},
afterExecute : {
value : afterExecute
}
});
return command;
}
return createCommand;
});
/*global define*/
define('Widgets/ToggleButtonViewModel',[
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
'../Core/DeveloperError',
'../ThirdParty/knockout'
], function(
defaultValue,
defined,
defineProperties,
DeveloperError,
knockout) {
'use strict';
/**
* A view model which exposes the properties of a toggle button.
* @alias ToggleButtonViewModel
* @constructor
*
* @param {Command} command The command which will be executed when the button is toggled.
* @param {Object} [options] Object with the following properties:
* @param {Boolean} [options.toggled=false] A boolean indicating whether the button should be initially toggled.
* @param {String} [options.tooltip=''] A string containing the button's tooltip.
*/
function ToggleButtonViewModel(command, options) {
if (!defined(command)) {
throw new DeveloperError('command is required.');
}
this._command = command;
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
/**
* Gets or sets whether the button is currently toggled. This property is observable.
* @type {Boolean}
* @default false
*/
this.toggled = defaultValue(options.toggled, false);
/**
* Gets or sets the button's tooltip. This property is observable.
* @type {String}
* @default ''
*/
this.tooltip = defaultValue(options.tooltip, '');
knockout.track(this, ['toggled', 'tooltip']);
}
defineProperties(ToggleButtonViewModel.prototype, {
/**
* Gets the command which will be executed when the button is toggled.
* @memberof ToggleButtonViewModel.prototype
* @type {Command}
*/
command : {
get : function() {
return this._command;
}
}
});
return ToggleButtonViewModel;
});
/*global define*/
define('Widgets/Animation/AnimationViewModel',[
'../../Core/binarySearch',
'../../Core/ClockRange',
'../../Core/ClockStep',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../../Core/JulianDate',
'../../ThirdParty/knockout',
'../../ThirdParty/sprintf',
'../createCommand',
'../ToggleButtonViewModel'
], function(
binarySearch,
ClockRange,
ClockStep,
defined,
defineProperties,
DeveloperError,
JulianDate,
knockout,
sprintf,
createCommand,
ToggleButtonViewModel) {
'use strict';
var monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
var realtimeShuttleRingAngle = 15;
var maxShuttleRingAngle = 105;
function numberComparator(left, right) {
return left - right;
}
function getTypicalMultiplierIndex(multiplier, shuttleRingTicks) {
var index = binarySearch(shuttleRingTicks, multiplier, numberComparator);
return index < 0 ? ~index : index;
}
function angleToMultiplier(angle, shuttleRingTicks) {
//Use a linear scale for -1 to 1 between -15 < angle < 15 degrees
if (Math.abs(angle) <= realtimeShuttleRingAngle) {
return angle / realtimeShuttleRingAngle;
}
var minp = realtimeShuttleRingAngle;
var maxp = maxShuttleRingAngle;
var maxv;
var minv = 0;
var scale;
if (angle > 0) {
maxv = Math.log(shuttleRingTicks[shuttleRingTicks.length - 1]);
scale = (maxv - minv) / (maxp - minp);
return Math.exp(minv + scale * (angle - minp));
}
maxv = Math.log(-shuttleRingTicks[0]);
scale = (maxv - minv) / (maxp - minp);
return -Math.exp(minv + scale * (Math.abs(angle) - minp));
}
function multiplierToAngle(multiplier, shuttleRingTicks, clockViewModel) {
if (clockViewModel.clockStep === ClockStep.SYSTEM_CLOCK) {
return realtimeShuttleRingAngle;
}
if (Math.abs(multiplier) <= 1) {
return multiplier * realtimeShuttleRingAngle;
}
var fastedMultipler = shuttleRingTicks[shuttleRingTicks.length - 1];
if(multiplier > fastedMultipler){
multiplier = fastedMultipler;
} else if(multiplier < -fastedMultipler){
multiplier = -fastedMultipler;
}
var minp = realtimeShuttleRingAngle;
var maxp = maxShuttleRingAngle;
var maxv;
var minv = 0;
var scale;
if (multiplier > 0) {
maxv = Math.log(fastedMultipler);
scale = (maxv - minv) / (maxp - minp);
return (Math.log(multiplier) - minv) / scale + minp;
}
maxv = Math.log(-shuttleRingTicks[0]);
scale = (maxv - minv) / (maxp - minp);
return -((Math.log(Math.abs(multiplier)) - minv) / scale + minp);
}
/**
* The view model for the {@link Animation} widget.
* @alias AnimationViewModel
* @constructor
*
* @param {ClockViewModel} clockViewModel The ClockViewModel instance to use.
*
* @see Animation
*/
function AnimationViewModel(clockViewModel) {
if (!defined(clockViewModel)) {
throw new DeveloperError('clockViewModel is required.');
}
var that = this;
this._clockViewModel = clockViewModel;
this._allShuttleRingTicks = [];
this._dateFormatter = AnimationViewModel.defaultDateFormatter;
this._timeFormatter = AnimationViewModel.defaultTimeFormatter;
/**
* Gets or sets whether the shuttle ring is currently being dragged. This property is observable.
* @type {Boolean}
* @default false
*/
this.shuttleRingDragging = false;
/**
* Gets or sets whether dragging the shuttle ring should cause the multiplier
* to snap to the defined tick values rather than interpolating between them.
* This property is observable.
* @type {Boolean}
* @default false
*/
this.snapToTicks = false;
knockout.track(this, ['_allShuttleRingTicks', '_dateFormatter', '_timeFormatter', 'shuttleRingDragging', 'snapToTicks']);
this._sortedFilteredPositiveTicks = [];
this.setShuttleRingTicks(AnimationViewModel.defaultTicks);
/**
* Gets the string representation of the current time. This property is observable.
* @type {String}
*/
this.timeLabel = undefined;
knockout.defineProperty(this, 'timeLabel', function() {
return that._timeFormatter(that._clockViewModel.currentTime, that);
});
/**
* Gets the string representation of the current date. This property is observable.
* @type {String}
*/
this.dateLabel = undefined;
knockout.defineProperty(this, 'dateLabel', function() {
return that._dateFormatter(that._clockViewModel.currentTime, that);
});
/**
* Gets the string representation of the current multiplier. This property is observable.
* @type {String}
*/
this.multiplierLabel = undefined;
knockout.defineProperty(this, 'multiplierLabel', function() {
var clockViewModel = that._clockViewModel;
if (clockViewModel.clockStep === ClockStep.SYSTEM_CLOCK) {
return 'Today';
}
var multiplier = clockViewModel.multiplier;
//If it's a whole number, just return it.
if (multiplier % 1 === 0) {
return multiplier.toFixed(0) + 'x';
}
//Convert to decimal string and remove any trailing zeroes
return multiplier.toFixed(3).replace(/0{0,3}$/, "") + 'x';
});
/**
* Gets or sets the current shuttle ring angle. This property is observable.
* @type {Number}
*/
this.shuttleRingAngle = undefined;
knockout.defineProperty(this, 'shuttleRingAngle', {
get : function() {
return multiplierToAngle(clockViewModel.multiplier, that._allShuttleRingTicks, clockViewModel);
},
set : function(angle) {
angle = Math.max(Math.min(angle, maxShuttleRingAngle), -maxShuttleRingAngle);
var ticks = that._allShuttleRingTicks;
var clockViewModel = that._clockViewModel;
clockViewModel.clockStep = ClockStep.SYSTEM_CLOCK_MULTIPLIER;
//If we are at the max angle, simply return the max value in either direction.
if (Math.abs(angle) === maxShuttleRingAngle) {
clockViewModel.multiplier = angle > 0 ? ticks[ticks.length - 1] : ticks[0];
return;
}
var multiplier = angleToMultiplier(angle, ticks);
if (that.snapToTicks) {
multiplier = ticks[getTypicalMultiplierIndex(multiplier, ticks)];
} else {
if (multiplier !== 0) {
var positiveMultiplier = Math.abs(multiplier);
if (positiveMultiplier > 100) {
var numDigits = positiveMultiplier.toFixed(0).length - 2;
var divisor = Math.pow(10, numDigits);
multiplier = (Math.round(multiplier / divisor) * divisor) | 0;
} else if (positiveMultiplier > realtimeShuttleRingAngle) {
multiplier = Math.round(multiplier);
} else if (positiveMultiplier > 1) {
multiplier = +multiplier.toFixed(1);
} else if (positiveMultiplier > 0) {
multiplier = +multiplier.toFixed(2);
}
}
}
clockViewModel.multiplier = multiplier;
}
});
this._canAnimate = undefined;
knockout.defineProperty(this, '_canAnimate', function() {
var clockViewModel = that._clockViewModel;
var clockRange = clockViewModel.clockRange;
if (that.shuttleRingDragging || clockRange === ClockRange.UNBOUNDED) {
return true;
}
var multiplier = clockViewModel.multiplier;
var currentTime = clockViewModel.currentTime;
var startTime = clockViewModel.startTime;
var result = false;
if (clockRange === ClockRange.LOOP_STOP) {
result = JulianDate.greaterThan(currentTime, startTime) || (currentTime.equals(startTime) && multiplier > 0);
} else {
var stopTime = clockViewModel.stopTime;
result = (JulianDate.greaterThan(currentTime, startTime) && JulianDate.lessThan(currentTime, stopTime)) || //
(currentTime.equals(startTime) && multiplier > 0) || //
(currentTime.equals(stopTime) && multiplier < 0);
}
if (!result) {
clockViewModel.shouldAnimate = false;
}
return result;
});
this._isSystemTimeAvailable = undefined;
knockout.defineProperty(this, '_isSystemTimeAvailable', function() {
var clockViewModel = that._clockViewModel;
var clockRange = clockViewModel.clockRange;
if (clockRange === ClockRange.UNBOUNDED) {
return true;
}
var systemTime = clockViewModel.systemTime;
return JulianDate.greaterThanOrEquals(systemTime, clockViewModel.startTime) && JulianDate.lessThanOrEquals(systemTime, clockViewModel.stopTime);
});
this._isAnimating = undefined;
knockout.defineProperty(this, '_isAnimating', function() {
return that._clockViewModel.shouldAnimate && (that._canAnimate || that.shuttleRingDragging);
});
var pauseCommand = createCommand(function() {
var clockViewModel = that._clockViewModel;
if (clockViewModel.shouldAnimate) {
clockViewModel.shouldAnimate = false;
} else if (that._canAnimate) {
clockViewModel.shouldAnimate = true;
}
});
this._pauseViewModel = new ToggleButtonViewModel(pauseCommand, {
toggled : knockout.computed(function() {
return !that._isAnimating;
}),
tooltip : 'Pause'
});
var playReverseCommand = createCommand(function() {
var clockViewModel = that._clockViewModel;
var multiplier = clockViewModel.multiplier;
if (multiplier > 0) {
clockViewModel.multiplier = -multiplier;
}
clockViewModel.shouldAnimate = true;
});
this._playReverseViewModel = new ToggleButtonViewModel(playReverseCommand, {
toggled : knockout.computed(function() {
return that._isAnimating && (clockViewModel.multiplier < 0);
}),
tooltip : 'Play Reverse'
});
var playForwardCommand = createCommand(function() {
var clockViewModel = that._clockViewModel;
var multiplier = clockViewModel.multiplier;
if (multiplier < 0) {
clockViewModel.multiplier = -multiplier;
}
clockViewModel.shouldAnimate = true;
});
this._playForwardViewModel = new ToggleButtonViewModel(playForwardCommand, {
toggled : knockout.computed(function() {
return that._isAnimating && clockViewModel.multiplier > 0 && clockViewModel.clockStep !== ClockStep.SYSTEM_CLOCK;
}),
tooltip : 'Play Forward'
});
var playRealtimeCommand = createCommand(function() {
that._clockViewModel.clockStep = ClockStep.SYSTEM_CLOCK;
}, knockout.getObservable(this, '_isSystemTimeAvailable'));
this._playRealtimeViewModel = new ToggleButtonViewModel(playRealtimeCommand, {
toggled : knockout.computed(function() {
return clockViewModel.clockStep === ClockStep.SYSTEM_CLOCK;
}),
tooltip : knockout.computed(function() {
return that._isSystemTimeAvailable ? 'Today (real-time)' : 'Current time not in range';
})
});
this._slower = createCommand(function() {
var clockViewModel = that._clockViewModel;
var shuttleRingTicks = that._allShuttleRingTicks;
var multiplier = clockViewModel.multiplier;
var index = getTypicalMultiplierIndex(multiplier, shuttleRingTicks) - 1;
if (index >= 0) {
clockViewModel.multiplier = shuttleRingTicks[index];
}
});
this._faster = createCommand(function() {
var clockViewModel = that._clockViewModel;
var shuttleRingTicks = that._allShuttleRingTicks;
var multiplier = clockViewModel.multiplier;
var index = getTypicalMultiplierIndex(multiplier, shuttleRingTicks) + 1;
if (index < shuttleRingTicks.length) {
clockViewModel.multiplier = shuttleRingTicks[index];
}
});
}
/**
* Gets or sets the default date formatter used by new instances.
*
* @member
* @type {AnimationViewModel~DateFormatter}
*/
AnimationViewModel.defaultDateFormatter = function(date, viewModel) {
var gregorianDate = JulianDate.toGregorianDate(date);
return monthNames[gregorianDate.month - 1] + ' ' + gregorianDate.day + ' ' + gregorianDate.year;
};
/**
* Gets or sets the default array of known clock multipliers associated with new instances of the shuttle ring.
* @type {Number[]}
*/
AnimationViewModel.defaultTicks = [//
0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.25, 0.5, 1.0, 2.0, 5.0, 10.0,//
15.0, 30.0, 60.0, 120.0, 300.0, 600.0, 900.0, 1800.0, 3600.0, 7200.0, 14400.0,//
21600.0, 43200.0, 86400.0, 172800.0, 345600.0, 604800.0];
/**
* Gets or sets the default time formatter used by new instances.
*
* @member
* @type {AnimationViewModel~TimeFormatter}
*/
AnimationViewModel.defaultTimeFormatter = function(date, viewModel) {
var gregorianDate = JulianDate.toGregorianDate(date);
var millisecond = Math.round(gregorianDate.millisecond);
if (Math.abs(viewModel._clockViewModel.multiplier) < 1) {
return sprintf("%02d:%02d:%02d.%03d", gregorianDate.hour, gregorianDate.minute, gregorianDate.second, millisecond);
}
return sprintf("%02d:%02d:%02d UTC", gregorianDate.hour, gregorianDate.minute, gregorianDate.second);
};
/**
* Gets a copy of the array of positive known clock multipliers to associate with the shuttle ring.
*
* @returns {Number[]} The array of known clock multipliers associated with the shuttle ring.
*/
AnimationViewModel.prototype.getShuttleRingTicks = function() {
return this._sortedFilteredPositiveTicks.slice(0);
};
/**
* Sets the array of positive known clock multipliers to associate with the shuttle ring.
* These values will have negative equivalents created for them and sets both the minimum
* and maximum range of values for the shuttle ring as well as the values that are snapped
* to when a single click is made. The values need not be in order, as they will be sorted
* automatically, and duplicate values will be removed.
*
* @param {Number[]} positiveTicks The list of known positive clock multipliers to associate with the shuttle ring.
*/
AnimationViewModel.prototype.setShuttleRingTicks = function(positiveTicks) {
if (!defined(positiveTicks)) {
throw new DeveloperError('positiveTicks is required.');
}
var i;
var len;
var tick;
var hash = {};
var sortedFilteredPositiveTicks = this._sortedFilteredPositiveTicks;
sortedFilteredPositiveTicks.length = 0;
for (i = 0, len = positiveTicks.length; i < len; ++i) {
tick = positiveTicks[i];
//filter duplicates
if (!hash.hasOwnProperty(tick)) {
hash[tick] = true;
sortedFilteredPositiveTicks.push(tick);
}
}
sortedFilteredPositiveTicks.sort(numberComparator);
var allTicks = [];
for (len = sortedFilteredPositiveTicks.length, i = len - 1; i >= 0; --i) {
tick = sortedFilteredPositiveTicks[i];
if (tick !== 0) {
allTicks.push(-tick);
}
}
Array.prototype.push.apply(allTicks, sortedFilteredPositiveTicks);
this._allShuttleRingTicks = allTicks;
};
defineProperties(AnimationViewModel.prototype, {
/**
* Gets a command that decreases the speed of animation.
* @memberof AnimationViewModel.prototype
* @type {Command}
*/
slower : {
get : function() {
return this._slower;
}
},
/**
* Gets a command that increases the speed of animation.
* @memberof AnimationViewModel.prototype
* @type {Command}
*/
faster : {
get : function() {
return this._faster;
}
},
/**
* Gets the clock view model.
* @memberof AnimationViewModel.prototype
*
* @type {ClockViewModel}
*/
clockViewModel : {
get : function() {
return this._clockViewModel;
}
},
/**
* Gets the pause toggle button view model.
* @memberof AnimationViewModel.prototype
*
* @type {ToggleButtonViewModel}
*/
pauseViewModel : {
get : function() {
return this._pauseViewModel;
}
},
/**
* Gets the reverse toggle button view model.
* @memberof AnimationViewModel.prototype
*
* @type {ToggleButtonViewModel}
*/
playReverseViewModel : {
get : function() {
return this._playReverseViewModel;
}
},
/**
* Gets the play toggle button view model.
* @memberof AnimationViewModel.prototype
*
* @type {ToggleButtonViewModel}
*/
playForwardViewModel : {
get : function() {
return this._playForwardViewModel;
}
},
/**
* Gets the realtime toggle button view model.
* @memberof AnimationViewModel.prototype
*
* @type {ToggleButtonViewModel}
*/
playRealtimeViewModel : {
get : function() {
return this._playRealtimeViewModel;
}
},
/**
* Gets or sets the function which formats a date for display.
* @memberof AnimationViewModel.prototype
*
* @type {AnimationViewModel~DateFormatter}
* @default AnimationViewModel.defaultDateFormatter
*/
dateFormatter : {
//TODO:@exception {DeveloperError} dateFormatter must be a function.
get : function() {
return this._dateFormatter;
},
set : function(dateFormatter) {
if (typeof dateFormatter !== 'function') {
throw new DeveloperError('dateFormatter must be a function');
}
this._dateFormatter = dateFormatter;
}
},
/**
* Gets or sets the function which formats a time for display.
* @memberof AnimationViewModel.prototype
*
* @type {AnimationViewModel~TimeFormatter}
* @default AnimationViewModel.defaultTimeFormatter
*/
timeFormatter : {
//TODO:@exception {DeveloperError} timeFormatter must be a function.
get : function() {
return this._timeFormatter;
},
set : function(timeFormatter) {
if (typeof timeFormatter !== 'function') {
throw new DeveloperError('timeFormatter must be a function');
}
this._timeFormatter = timeFormatter;
}
}
});
//Currently exposed for tests.
AnimationViewModel._maxShuttleRingAngle = maxShuttleRingAngle;
AnimationViewModel._realtimeShuttleRingAngle = realtimeShuttleRingAngle;
/**
* A function that formats a date for display.
* @callback AnimationViewModel~DateFormatter
*
* @param {JulianDate} date The date to be formatted
* @param {AnimationViewModel} viewModel The AnimationViewModel instance requesting formatting.
* @returns {String} The string representation of the calendar date portion of the provided date.
*/
/**
* A function that formats a time for display.
* @callback AnimationViewModel~TimeFormatter
*
* @param {JulianDate} date The date to be formatted
* @param {AnimationViewModel} viewModel The AnimationViewModel instance requesting formatting.
* @returns {String} The string representation of the time portion of the provided date.
*/
return AnimationViewModel;
});
/*global define*/
define('Widgets/BaseLayerPicker/BaseLayerPickerViewModel',[
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../../Core/EllipsoidTerrainProvider',
'../../Core/isArray',
'../../ThirdParty/knockout',
'../createCommand'
], function(
defaultValue,
defined,
defineProperties,
DeveloperError,
EllipsoidTerrainProvider,
isArray,
knockout,
createCommand) {
'use strict';
/**
* The view model for {@link BaseLayerPicker}.
* @alias BaseLayerPickerViewModel
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Globe} options.globe The Globe to use.
* @param {ProviderViewModel[]} [options.imageryProviderViewModels=[]] The array of ProviderViewModel instances to use for imagery.
* @param {ProviderViewModel} [options.selectedImageryProviderViewModel] The view model for the current base imagery layer, if not supplied the first available imagery layer is used.
* @param {ProviderViewModel[]} [options.terrainProviderViewModels=[]] The array of ProviderViewModel instances to use for terrain.
* @param {ProviderViewModel} [options.selectedTerrainProviderViewModel] The view model for the current base terrain layer, if not supplied the first available terrain layer is used.
*
* @exception {DeveloperError} imageryProviderViewModels must be an array.
* @exception {DeveloperError} terrainProviderViewModels must be an array.
*/
function BaseLayerPickerViewModel(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var globe = options.globe;
var imageryProviderViewModels = defaultValue(options.imageryProviderViewModels, []);
var terrainProviderViewModels = defaultValue(options.terrainProviderViewModels, []);
if (!defined(globe)) {
throw new DeveloperError('globe is required');
}
this._globe = globe;
/**
* Gets or sets an array of ProviderViewModel instances available for imagery selection.
* This property is observable.
* @type {ProviderViewModel[]}
*/
this.imageryProviderViewModels = imageryProviderViewModels.slice(0);
/**
* Gets or sets an array of ProviderViewModel instances available for terrain selection.
* This property is observable.
* @type {ProviderViewModel[]}
*/
this.terrainProviderViewModels = terrainProviderViewModels.slice(0);
/**
* Gets or sets whether the imagery selection drop-down is currently visible.
* @type {Boolean}
* @default false
*/
this.dropDownVisible = false;
knockout.track(this, ['imageryProviderViewModels', 'terrainProviderViewModels', 'dropDownVisible']);
/**
* Gets the button tooltip. This property is observable.
* @type {String}
*/
this.buttonTooltip = undefined;
knockout.defineProperty(this, 'buttonTooltip', function() {
var selectedImagery = this.selectedImagery;
var selectedTerrain = this.selectedTerrain;
var imageryTip = defined(selectedImagery) ? selectedImagery.name : undefined;
var terrainTip = defined(selectedTerrain) ? selectedTerrain.name : undefined;
if (defined(imageryTip) && defined(terrainTip)) {
return imageryTip + '\n' + terrainTip;
} else if (defined(imageryTip)) {
return imageryTip;
}
return terrainTip;
});
/**
* Gets the button background image. This property is observable.
* @type {String}
*/
this.buttonImageUrl = undefined;
knockout.defineProperty(this, 'buttonImageUrl', function() {
var viewModel = this.selectedImagery;
return defined(viewModel) ? viewModel.iconUrl : undefined;
});
/**
* Gets or sets the currently selected imagery. This property is observable.
* @type {ProviderViewModel}
* @default undefined
*/
this.selectedImagery = undefined;
var selectedImageryViewModel = knockout.observable();
this._currentImageryProviders = [];
knockout.defineProperty(this, 'selectedImagery', {
get : function() {
return selectedImageryViewModel();
},
set : function(value) {
if (selectedImageryViewModel() === value) {
this.dropDownVisible = false;
return;
}
var i;
var currentImageryProviders = this._currentImageryProviders;
var currentImageryProvidersLength = currentImageryProviders.length;
var imageryLayers = this._globe.imageryLayers;
for (i = 0; i < currentImageryProvidersLength; i++) {
var layersLength = imageryLayers.length;
for ( var x = 0; x < layersLength; x++) {
var layer = imageryLayers.get(x);
if (layer.imageryProvider === currentImageryProviders[i]) {
imageryLayers.remove(layer);
break;
}
}
}
if (defined(value)) {
var newProviders = value.creationCommand();
if (isArray(newProviders)) {
var newProvidersLength = newProviders.length;
for (i = newProvidersLength - 1; i >= 0; i--) {
imageryLayers.addImageryProvider(newProviders[i], 0);
}
this._currentImageryProviders = newProviders.slice(0);
} else {
this._currentImageryProviders = [newProviders];
imageryLayers.addImageryProvider(newProviders, 0);
}
}
selectedImageryViewModel(value);
this.dropDownVisible = false;
}
});
/**
* Gets or sets the currently selected terrain. This property is observable.
* @type {ProviderViewModel}
* @default undefined
*/
this.selectedTerrain = undefined;
var selectedTerrainViewModel = knockout.observable();
knockout.defineProperty(this, 'selectedTerrain', {
get : function() {
return selectedTerrainViewModel();
},
set : function(value) {
if (selectedTerrainViewModel() === value) {
this.dropDownVisible = false;
return;
}
var newProvider;
if (defined(value)) {
newProvider = value.creationCommand();
}
this._globe.depthTestAgainstTerrain = !(newProvider instanceof EllipsoidTerrainProvider);
this._globe.terrainProvider = newProvider;
selectedTerrainViewModel(value);
this.dropDownVisible = false;
}
});
var that = this;
this._toggleDropDown = createCommand(function() {
that.dropDownVisible = !that.dropDownVisible;
});
this.selectedImagery = defaultValue(options.selectedImageryProviderViewModel, imageryProviderViewModels[0]);
this.selectedTerrain = defaultValue(options.selectedTerrainProviderViewModel, terrainProviderViewModels[0]);
}
defineProperties(BaseLayerPickerViewModel.prototype, {
/**
* Gets the command to toggle the visibility of the drop down.
* @memberof BaseLayerPickerViewModel.prototype
*
* @type {Command}
*/
toggleDropDown : {
get : function() {
return this._toggleDropDown;
}
},
/**
* Gets the globe.
* @memberof BaseLayerPickerViewModel.prototype
*
* @type {Globe}
*/
globe : {
get : function() {
return this._globe;
}
}
});
return BaseLayerPickerViewModel;
});
/*global define*/
define('Widgets/BaseLayerPicker/BaseLayerPicker',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/FeatureDetection',
'../../ThirdParty/knockout',
'../getElement',
'./BaseLayerPickerViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
FeatureDetection,
knockout,
getElement,
BaseLayerPickerViewModel) {
'use strict';
/**
* <span style="display: block; text-align: center;">
* <img src="images/BaseLayerPicker.png" width="264" height="287" alt="" />
* <br />BaseLayerPicker with its drop-panel open.
* </span>
* <br /><br />
* The BaseLayerPicker is a single button widget that displays a panel of available imagery and
* terrain providers. When imagery is selected, the corresponding imagery layer is created and inserted
* as the base layer of the imagery collection; removing the existing base. When terrain is selected,
* it replaces the current terrain provider. Each item in the available providers list contains a name,
* a representative icon, and a tooltip to display more information when hovered. The list is initially
* empty, and must be configured before use, as illustrated in the below example.
*
* @alias BaseLayerPicker
* @constructor
*
* @param {Element|String} container The parent HTML container node or ID for this widget.
* @param {Object} options Object with the following properties:
* @param {Globe} options.globe The Globe to use.
* @param {ProviderViewModel[]} [options.imageryProviderViewModels=[]] The array of ProviderViewModel instances to use for imagery.
* @param {ProviderViewModel} [options.selectedImageryProviderViewModel] The view model for the current base imagery layer, if not supplied the first available imagery layer is used.
* @param {ProviderViewModel[]} [options.terrainProviderViewModels=[]] The array of ProviderViewModel instances to use for terrain.
* @param {ProviderViewModel} [options.selectedTerrainProviderViewModel] The view model for the current base terrain layer, if not supplied the first available terrain layer is used.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*
*
* @example
* // In HTML head, include a link to the BaseLayerPicker.css stylesheet,
* // and in the body, include: <div id="baseLayerPickerContainer"
* // style="position:absolute;top:24px;right:24px;width:38px;height:38px;"></div>
*
* //Create the list of available providers we would like the user to select from.
* //This example uses 3, OpenStreetMap, The Black Marble, and a single, non-streaming world image.
* var imageryViewModels = [];
* imageryViewModels.push(new Cesium.ProviderViewModel({
* name : 'Open\u00adStreet\u00adMap',
* iconUrl : Cesium.buildModuleUrl('Widgets/Images/ImageryProviders/openStreetMap.png'),
* tooltip : 'OpenStreetMap (OSM) is a collaborative project to create a free editable \
* map of the world.\nhttp://www.openstreetmap.org',
* creationFunction : function() {
* return Cesium.createOpenStreetMapImageryProvider({
* url : 'https://a.tile.openstreetmap.org/'
* });
* }
* }));
*
* imageryViewModels.push(new Cesium.ProviderViewModel({
* name : 'Black Marble',
* iconUrl : Cesium.buildModuleUrl('Widgets/Images/ImageryProviders/blackMarble.png'),
* tooltip : 'The lights of cities and villages trace the outlines of civilization \
* in this global view of the Earth at night as seen by NASA/NOAA\'s Suomi NPP satellite.',
* creationFunction : function() {
* return Cesium.createTileMapServiceImageryProvider({
* url : 'https://cesiumjs.org/blackmarble',
* credit : 'Black Marble imagery courtesy NASA Earth Observatory',
* flipXY : true
* });
* }
* }));
*
* imageryViewModels.push(new Cesium.ProviderViewModel({
* name : 'Natural Earth\u00a0II',
* iconUrl : Cesium.buildModuleUrl('Widgets/Images/ImageryProviders/naturalEarthII.png'),
* tooltip : 'Natural Earth II, darkened for contrast.\nhttp://www.naturalearthdata.com/',
* creationFunction : function() {
* return Cesium.createTileMapServiceImageryProvider({
* url : Cesium.buildModuleUrl('Assets/Textures/NaturalEarthII')
* });
* }
* }));
*
* //Create a CesiumWidget without imagery, if you haven't already done so.
* var cesiumWidget = new Cesium.CesiumWidget('cesiumContainer', { imageryProvider: false });
*
* //Finally, create the baseLayerPicker widget using our view models.
* var layers = cesiumWidget.imageryLayers;
* var baseLayerPicker = new Cesium.BaseLayerPicker('baseLayerPickerContainer', {
* globe : cesiumWidget.scene.globe,
* imageryProviderViewModels : imageryViewModels
* });
*
* @see TerrainProvider
* @see ImageryProvider
* @see ImageryLayerCollection
*/
function BaseLayerPicker(container, options) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
container = getElement(container);
var viewModel = new BaseLayerPickerViewModel(options);
var element = document.createElement('button');
element.type = 'button';
element.className = 'cesium-button cesium-toolbar-button';
element.setAttribute('data-bind', '\
attr: { title: buttonTooltip },\
click: toggleDropDown');
container.appendChild(element);
var imgElement = document.createElement('img');
imgElement.setAttribute('draggable', 'false');
imgElement.className = 'cesium-baseLayerPicker-selected';
imgElement.setAttribute('data-bind', '\
attr: { src: buttonImageUrl }');
element.appendChild(imgElement);
var dropPanel = document.createElement('div');
dropPanel.className = 'cesium-baseLayerPicker-dropDown';
dropPanel.setAttribute('data-bind', '\
css: { "cesium-baseLayerPicker-dropDown-visible" : dropDownVisible }');
container.appendChild(dropPanel);
var imageryTitle = document.createElement('div');
imageryTitle.className = 'cesium-baseLayerPicker-sectionTitle';
imageryTitle.setAttribute('data-bind', 'visible: imageryProviderViewModels.length > 0');
imageryTitle.innerHTML = 'Imagery';
dropPanel.appendChild(imageryTitle);
var imageryChoices = document.createElement('div');
imageryChoices.className = 'cesium-baseLayerPicker-choices';
imageryChoices.setAttribute('data-bind', 'foreach: imageryProviderViewModels');
dropPanel.appendChild(imageryChoices);
var imageryProvider = document.createElement('div');
imageryProvider.className = 'cesium-baseLayerPicker-item';
imageryProvider.setAttribute('data-bind', '\
css: { "cesium-baseLayerPicker-selectedItem" : $data === $parent.selectedImagery },\
attr: { title: tooltip },\
visible: creationCommand.canExecute,\
click: function($data) { $parent.selectedImagery = $data; }');
imageryChoices.appendChild(imageryProvider);
var providerIcon = document.createElement('img');
providerIcon.className = 'cesium-baseLayerPicker-itemIcon';
providerIcon.setAttribute('data-bind', 'attr: { src: iconUrl }');
providerIcon.setAttribute('draggable', 'false');
imageryProvider.appendChild(providerIcon);
var providerLabel = document.createElement('div');
providerLabel.className = 'cesium-baseLayerPicker-itemLabel';
providerLabel.setAttribute('data-bind', 'text: name');
imageryProvider.appendChild(providerLabel);
var terrainTitle = document.createElement('div');
terrainTitle.className = 'cesium-baseLayerPicker-sectionTitle';
terrainTitle.setAttribute('data-bind', 'visible: terrainProviderViewModels.length > 0');
terrainTitle.innerHTML = 'Terrain';
dropPanel.appendChild(terrainTitle);
var terrainChoices = document.createElement('div');
terrainChoices.className = 'cesium-baseLayerPicker-choices';
terrainChoices.setAttribute('data-bind', 'foreach: terrainProviderViewModels');
dropPanel.appendChild(terrainChoices);
var terrainProvider = document.createElement('div');
terrainProvider.className = 'cesium-baseLayerPicker-item';
terrainProvider.setAttribute('data-bind', '\
css: { "cesium-baseLayerPicker-selectedItem" : $data === $parent.selectedTerrain },\
attr: { title: tooltip },\
visible: creationCommand.canExecute,\
click: function($data) { $parent.selectedTerrain = $data; }');
terrainChoices.appendChild(terrainProvider);
var terrainProviderIcon = document.createElement('img');
terrainProviderIcon.className = 'cesium-baseLayerPicker-itemIcon';
terrainProviderIcon.setAttribute('data-bind', 'attr: { src: iconUrl }');
terrainProviderIcon.setAttribute('draggable', 'false');
terrainProvider.appendChild(terrainProviderIcon);
var terrainProviderLabel = document.createElement('div');
terrainProviderLabel.className = 'cesium-baseLayerPicker-itemLabel';
terrainProviderLabel.setAttribute('data-bind', 'text: name');
terrainProvider.appendChild(terrainProviderLabel);
knockout.applyBindings(viewModel, element);
knockout.applyBindings(viewModel, dropPanel);
this._viewModel = viewModel;
this._container = container;
this._element = element;
this._dropPanel = dropPanel;
this._closeDropDown = function(e) {
if (!(element.contains(e.target) || dropPanel.contains(e.target))) {
viewModel.dropDownVisible = false;
}
};
if (FeatureDetection.supportsPointerEvents()) {
document.addEventListener('pointerdown', this._closeDropDown, true);
} else {
document.addEventListener('mousedown', this._closeDropDown, true);
document.addEventListener('touchstart', this._closeDropDown, true);
}
}
defineProperties(BaseLayerPicker.prototype, {
/**
* Gets the parent container.
* @memberof BaseLayerPicker.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof BaseLayerPicker.prototype
*
* @type {BaseLayerPickerViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
BaseLayerPicker.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
BaseLayerPicker.prototype.destroy = function() {
if (FeatureDetection.supportsPointerEvents()) {
document.removeEventListener('pointerdown', this._closeDropDown, true);
} else {
document.removeEventListener('mousedown', this._closeDropDown, true);
document.removeEventListener('touchstart', this._closeDropDown, true);
}
knockout.cleanNode(this._element);
knockout.cleanNode(this._dropPanel);
this._container.removeChild(this._element);
this._container.removeChild(this._dropPanel);
return destroyObject(this);
};
return BaseLayerPicker;
});
/*global define*/
define('Widgets/BaseLayerPicker/ProviderViewModel',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../createCommand'
], function(
defined,
defineProperties,
DeveloperError,
knockout,
createCommand) {
'use strict';
/**
* A view model that represents each item in the {@link BaseLayerPicker}.
*
* @alias ProviderViewModel
* @constructor
*
* @param {Object} options The object containing all parameters.
* @param {String} options.name The name of the layer.
* @param {String} options.tooltip The tooltip to show when the item is moused over.
* @param {String} options.iconUrl An icon representing the layer.
* @param {ProviderViewModel~CreationFunction|Command} options.creationFunction A function or Command
* that creates one or more providers which will be added to the globe when this item is selected.
*
* @see BaseLayerPicker
* @see ImageryProvider
* @see TerrainProvider
*/
function ProviderViewModel(options) {
if (!defined(options.name)) {
throw new DeveloperError('options.name is required.');
}
if (!defined(options.tooltip)) {
throw new DeveloperError('options.tooltip is required.');
}
if (!defined(options.iconUrl)) {
throw new DeveloperError('options.iconUrl is required.');
}
if (typeof options.creationFunction !== 'function') {
throw new DeveloperError('options.creationFunction is required.');
}
var creationCommand = options.creationFunction;
if (!defined(creationCommand.canExecute)) {
creationCommand = createCommand(creationCommand);
}
this._creationCommand = creationCommand;
/**
* Gets the display name. This property is observable.
* @type {String}
*/
this.name = options.name;
/**
* Gets the tooltip. This property is observable.
* @type {String}
*/
this.tooltip = options.tooltip;
/**
* Gets the icon. This property is observable.
* @type {String}
*/
this.iconUrl = options.iconUrl;
knockout.track(this, ['name', 'tooltip', 'iconUrl']);
}
defineProperties(ProviderViewModel.prototype, {
/**
* Gets the Command that creates one or more providers which will be added to
* the globe when this item is selected.
* @memberof ProviderViewModel.prototype
*
* @type {Command}
*/
creationCommand : {
get : function() {
return this._creationCommand;
}
}
});
/**
* A function which creates one or more providers.
* @callback ProviderViewModel~CreationFunction
* @returns {ImageryProvider|TerrainProvider|ImageryProvider[]|TerrainProvider[]}
* The ImageryProvider or TerrainProvider, or array of providers, to be added
* to the globe.
*/
return ProviderViewModel;
});
/*global define*/
define('Widgets/BaseLayerPicker/createDefaultImageryProviderViewModels',[
'../../Core/buildModuleUrl',
'../../Scene/ArcGisMapServerImageryProvider',
'../../Scene/BingMapsImageryProvider',
'../../Scene/BingMapsStyle',
'../../Scene/createOpenStreetMapImageryProvider',
'../../Scene/createTileMapServiceImageryProvider',
'../../Scene/MapboxImageryProvider',
'../BaseLayerPicker/ProviderViewModel'
], function(
buildModuleUrl,
ArcGisMapServerImageryProvider,
BingMapsImageryProvider,
BingMapsStyle,
createOpenStreetMapImageryProvider,
createTileMapServiceImageryProvider,
MapboxImageryProvider,
ProviderViewModel) {
'use strict';
/**
* @private
*/
function createDefaultImageryProviderViewModels() {
var providerViewModels = [];
providerViewModels.push(new ProviderViewModel({
name : 'Bing Maps Aerial',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/bingAerial.png'),
tooltip : 'Bing Maps aerial imagery \nhttp://www.bing.com/maps',
creationFunction : function() {
return new BingMapsImageryProvider({
url : 'https://dev.virtualearth.net',
mapStyle : BingMapsStyle.AERIAL
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'Bing Maps Aerial with Labels',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/bingAerialLabels.png'),
tooltip : 'Bing Maps aerial imagery with label overlays \nhttp://www.bing.com/maps',
creationFunction : function() {
return new BingMapsImageryProvider({
url : 'https://dev.virtualearth.net',
mapStyle : BingMapsStyle.AERIAL_WITH_LABELS
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'Bing Maps Roads',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/bingRoads.png'),
tooltip : 'Bing Maps standard road maps\nhttp://www.bing.com/maps',
creationFunction : function() {
return new BingMapsImageryProvider({
url : 'https://dev.virtualearth.net',
mapStyle : BingMapsStyle.ROAD
});
}
}));
providerViewModels.push(new ProviderViewModel({
name: 'Mapbox Satellite',
tooltip: 'Mapbox satellite imagery https://www.mapbox.com/maps/',
iconUrl: buildModuleUrl('Widgets/Images/ImageryProviders/mapboxSatellite.png'),
creationFunction: function() {
return new MapboxImageryProvider({
mapId: 'mapbox.satellite'
});
}
}));
providerViewModels.push(new ProviderViewModel({
name: 'Mapbox Streets',
tooltip: 'Mapbox streets imagery https://www.mapbox.com/maps/',
iconUrl: buildModuleUrl('Widgets/Images/ImageryProviders/mapboxTerrain.png'),
creationFunction: function() {
return new MapboxImageryProvider({
mapId: 'mapbox.streets'
});
}
}));
providerViewModels.push(new ProviderViewModel({
name: 'Mapbox Streets Classic',
tooltip: 'Mapbox streets basic imagery https://www.mapbox.com/maps/',
iconUrl: buildModuleUrl('Widgets/Images/ImageryProviders/mapboxStreets.png'),
creationFunction: function() {
return new MapboxImageryProvider({
mapId: 'mapbox.streets-basic'
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'ESRI World Imagery',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/esriWorldImagery.png'),
tooltip : '\
World Imagery provides one meter or better satellite and aerial imagery in many parts of the world and lower resolution \
satellite imagery worldwide. The map includes NASA Blue Marble: Next Generation 500m resolution imagery at small scales \
(above 1:1,000,000), i-cubed 15m eSAT imagery at medium-to-large scales (down to 1:70,000) for the world, and USGS 15m Landsat \
imagery for Antarctica. The map features 0.3m resolution imagery in the continental United States and 0.6m resolution imagery in \
parts of Western Europe from DigitalGlobe. In other parts of the world, 1 meter resolution imagery is available from GeoEye IKONOS, \
i-cubed Nationwide Prime, Getmapping, AeroGRID, IGN Spain, and IGP Portugal. Additionally, imagery at different resolutions has been \
contributed by the GIS User Community.\nhttp://www.esri.com',
creationFunction : function() {
return new ArcGisMapServerImageryProvider({
url : 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer',
enablePickFeatures : false
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'ESRI World Street Map',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/esriWorldStreetMap.png'),
tooltip : '\
This worldwide street map presents highway-level data for the world. Street-level data includes the United States; much of \
Canada; Japan; most countries in Europe; Australia and New Zealand; India; parts of South America including Argentina, Brazil, \
Chile, Colombia, and Venezuela; Ghana; and parts of southern Africa including Botswana, Lesotho, Namibia, South Africa, and Swaziland.\n\
http://www.esri.com',
creationFunction : function() {
return new ArcGisMapServerImageryProvider({
url : 'https://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer',
enablePickFeatures : false
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'ESRI National Geographic',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/esriNationalGeographic.png'),
tooltip : '\
This web map contains the National Geographic World Map service. This map service is designed to be used as a general reference map \
for informational and educational purposes as well as a basemap by GIS professionals and other users for creating web maps and web \
mapping applications.\nhttp://www.esri.com',
creationFunction : function() {
return new ArcGisMapServerImageryProvider({
url : 'https://services.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/',
enablePickFeatures : false
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'Open\u00adStreet\u00adMap',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/openStreetMap.png'),
tooltip : 'OpenStreetMap (OSM) is a collaborative project to create a free editable map \
of the world.\nhttp://www.openstreetmap.org',
creationFunction : function() {
return createOpenStreetMapImageryProvider({
url : 'https://a.tile.openstreetmap.org/'
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'Stamen Watercolor',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/stamenWatercolor.png'),
tooltip : 'Reminiscent of hand drawn maps, Stamen watercolor maps apply raster effect \
area washes and organic edges over a paper texture to add warm pop to any map.\nhttp://maps.stamen.com',
creationFunction : function() {
return createOpenStreetMapImageryProvider({
url : 'https://stamen-tiles.a.ssl.fastly.net/watercolor/',
credit : 'Map tiles by Stamen Design, under CC BY 3.0. Data by OpenStreetMap, under CC BY SA.'
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'Stamen Toner',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/stamenToner.png'),
tooltip : 'A high contrast black and white map.\nhttp://maps.stamen.com',
creationFunction : function() {
return createOpenStreetMapImageryProvider({
url : 'https://stamen-tiles.a.ssl.fastly.net/toner/',
credit : 'Map tiles by Stamen Design, under CC BY 3.0. Data by OpenStreetMap, under CC BY SA.'
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'The Black Marble',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/blackMarble.png'),
tooltip : 'The lights of cities and villages trace the outlines of civilization in this global view of the \
Earth at night as seen by NASA/NOAA\'s Suomi NPP satellite.',
creationFunction : function() {
return createTileMapServiceImageryProvider({
url : 'https://cesiumjs.org/blackmarble',
flipXY : true,
credit : 'Black Marble imagery courtesy NASA Earth Observatory'
});
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'Natural Earth\u00a0II',
iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/naturalEarthII.png'),
tooltip : 'Natural Earth II, darkened for contrast.\nhttp://www.naturalearthdata.com/',
creationFunction : function() {
return createTileMapServiceImageryProvider({
url : buildModuleUrl('Assets/Textures/NaturalEarthII')
});
}
}));
return providerViewModels;
}
return createDefaultImageryProviderViewModels;
});
/*global define*/
define('Widgets/BaseLayerPicker/createDefaultTerrainProviderViewModels',[
'../../Core/buildModuleUrl',
'../../Core/CesiumTerrainProvider',
'../../Core/EllipsoidTerrainProvider',
'../BaseLayerPicker/ProviderViewModel'
], function(
buildModuleUrl,
CesiumTerrainProvider,
EllipsoidTerrainProvider,
ProviderViewModel) {
'use strict';
/**
* @private
*/
function createDefaultTerrainProviderViewModels() {
var providerViewModels = [];
providerViewModels.push(new ProviderViewModel({
name : 'WGS84 Ellipsoid',
iconUrl : buildModuleUrl('Widgets/Images/TerrainProviders/Ellipsoid.png'),
tooltip : 'WGS84 standard ellipsoid, also known as EPSG:4326',
creationFunction : function() {
return new EllipsoidTerrainProvider();
}
}));
providerViewModels.push(new ProviderViewModel({
name : 'STK World Terrain meshes',
iconUrl : buildModuleUrl('Widgets/Images/TerrainProviders/STK.png'),
tooltip : 'High-resolution, mesh-based terrain for the entire globe. Free for use on the Internet. Closed-network options are available.\nhttp://www.agi.com',
creationFunction : function() {
return new CesiumTerrainProvider({
url : 'https://assets.agi.com/stk-terrain/world',
requestWaterMask : true,
requestVertexNormals : true
});
}
}));
return providerViewModels;
}
return createDefaultTerrainProviderViewModels;
});
/*global define*/
define('Widgets/CesiumInspector/CesiumInspectorViewModel',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/Rectangle',
'../../Core/ScreenSpaceEventHandler',
'../../Core/ScreenSpaceEventType',
'../../Scene/DebugModelMatrixPrimitive',
'../../Scene/PerformanceDisplay',
'../../Scene/TileCoordinatesImageryProvider',
'../../ThirdParty/knockout',
'../createCommand'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
Rectangle,
ScreenSpaceEventHandler,
ScreenSpaceEventType,
DebugModelMatrixPrimitive,
PerformanceDisplay,
TileCoordinatesImageryProvider,
knockout,
createCommand) {
'use strict';
function frustumStatsToString(stats) {
var str;
if (defined(stats)) {
str = 'Command Statistics';
var com = stats.commandsInFrustums;
for (var n in com) {
if (com.hasOwnProperty(n)) {
var num = parseInt(n, 10);
var s;
if (num === 7) {
s = '1, 2 and 3';
} else {
var f = [];
for (var i = 2; i >= 0; i--) {
var p = Math.pow(2, i);
if (num >= p) {
f.push(i + 1);
num -= p;
}
}
s = f.reverse().join(' and ');
}
str += '<br> ' + com[n] + ' in frustum ' + s;
}
}
str += '<br>Total: ' + stats.totalCommands;
}
return str;
}
function boundDepthFrustum(lower, upper, proposed) {
var bounded = Math.min(proposed, upper);
bounded = Math.max(bounded, lower);
return bounded;
}
/**
* The view model for {@link CesiumInspector}.
* @alias CesiumInspectorViewModel
* @constructor
*
* @param {Scene} scene The scene instance to use.
*
* @exception {DeveloperError} scene is required.
*/
function CesiumInspectorViewModel(scene, performanceContainer) {
if (!defined(scene)) {
throw new DeveloperError('scene is required');
}
if (!defined(performanceContainer)) {
throw new DeveloperError('performanceContainer is required');
}
var that = this;
var canvas = scene.canvas;
var eventHandler = new ScreenSpaceEventHandler(canvas);
this._eventHandler = eventHandler;
this._scene = scene;
this._canvas = canvas;
this._primitive = undefined;
this._tile = undefined;
this._modelMatrixPrimitive = undefined;
this._performanceDisplay = undefined;
this._performanceContainer = performanceContainer;
var globe = this._scene.globe;
globe.depthTestAgainstTerrain = true;
/**
* Gets or sets the show frustums state. This property is observable.
* @type {Boolean}
* @default false
*/
this.frustums = false;
/**
* Gets or sets the show performance display state. This property is observable.
* @type {Boolean}
* @default false
*/
this.performance = false;
/**
* Gets or sets the shader cache text. This property is observable.
* @type {String}
* @default ''
*/
this.shaderCacheText = '';
/**
* Gets or sets the show primitive bounding sphere state. This property is observable.
* @type {Boolean}
* @default false
*/
this.primitiveBoundingSphere = false;
/**
* Gets or sets the show primitive reference frame state. This property is observable.
* @type {Boolean}
* @default false
*/
this.primitiveReferenceFrame = false;
/**
* Gets or sets the filter primitive state. This property is observable.
* @type {Boolean}
* @default false
*/
this.filterPrimitive = false;
/**
* Gets or sets the show tile bounding sphere state. This property is observable.
* @type {Boolean}
* @default false
*/
this.tileBoundingSphere = false;
/**
* Gets or sets the filter tile state. This property is observable.
* @type {Boolean}
* @default false
*/
this.filterTile = false;
/**
* Gets or sets the show wireframe state. This property is observable.
* @type {Boolean}
* @default false
*/
this.wireframe = false;
/**
* Gets or sets the show globe depth state. This property is observable.
* @type {Boolean}
* @default false
*/
this.globeDepth = false;
/**
* Gets or sets the show pick depth state. This property is observable.
* @type {Boolean}
* @default false
*/
this.pickDepth = false;
/**
* Gets or sets the index of the depth frustum to display. This property is observable.
* @type {Number}
* @default 1
*/
this.depthFrustum = 1;
this._numberOfFrustums = 1;
/**
* Gets or sets the index of the depth frustum text. This property is observable.
* @type {String}
* @default '1 of 1'
*/
this.depthFrustumText = '1 of 1';
/**
* Gets or sets the suspend updates state. This property is observable.
* @type {Boolean}
* @default false
*/
this.suspendUpdates = false;
/**
* Gets or sets the show tile coordinates state. This property is observable.
* @type {Boolean}
* @default false
*/
this.tileCoordinates = false;
/**
* Gets or sets the frustum statistic text. This property is observable.
* @type {String}
* @default ''
*/
this.frustumStatisticText = '';
/**
* Gets or sets the selected tile information text. This property is observable.
* @type {String}
* @default ''
*/
this.tileText = '';
/**
* Gets if a primitive has been selected. This property is observable.
* @type {Boolean}
* @default false
*/
this.hasPickedPrimitive = false;
/**
* Gets if a tile has been selected. This property is observable
* @type {Boolean}
* @default false
*/
this.hasPickedTile = false;
/**
* Gets if the picking primitive command is active. This property is observable.
* @type {Boolean}
* @default false
*/
this.pickPimitiveActive = false;
/**
* Gets if the picking tile command is active. This property is observable.
* @type {Boolean}
* @default false
*/
this.pickTileActive = false;
/**
* Gets or sets if the cesium inspector drop down is visible. This property is observable.
* @type {Boolean}
* @default true
*/
this.dropDownVisible = true;
/**
* Gets or sets if the general section is visible. This property is observable.
* @type {Boolean}
* @default true
*/
this.generalVisible = true;
/**
* Gets or sets if the primitive section is visible. This property is observable.
* @type {Boolean}
* @default false
*/
this.primitivesVisible = false;
/**
* Gets or sets if the terrain section is visible. This property is observable.
* @type {Boolean}
* @default false
*/
this.terrainVisible = false;
/**
* Gets or sets if the text on the general section expand button. This property is observable.
* @type {String}
* @default '-'
*/
this.generalSwitchText = '-';
/**
* Gets or sets if the text on the primitive section expand button. This property is observable.
* @type {String}
* @default '+'
*/
this.primitivesSwitchText = '+';
/**
* Gets or sets if the text on the terrain section expand button. This property is observable.
* @type {String}
* @default '+'
*/
this.terrainSwitchText = '+';
knockout.track(this, ['filterTile', 'suspendUpdates', 'dropDownVisible', 'shaderCacheText', 'frustums',
'frustumStatisticText', 'pickTileActive', 'pickPrimitiveActive', 'hasPickedPrimitive',
'hasPickedTile', 'tileText', 'generalVisible', 'generalSwitchText',
'primitivesVisible', 'primitivesSwitchText', 'terrainVisible', 'terrainSwitchText', 'depthFrustumText']);
this._toggleDropDown = createCommand(function() {
that.dropDownVisible = !that.dropDownVisible;
});
this._toggleGeneral = createCommand(function() {
that.generalVisible = !that.generalVisible;
that.generalSwitchText = that.generalVisible ? '-' : '+';
});
this._togglePrimitives = createCommand(function() {
that.primitivesVisible = !that.primitivesVisible;
that.primitivesSwitchText = that.primitivesVisible ? '-' : '+';
});
this._toggleTerrain = createCommand(function() {
that.terrainVisible = !that.terrainVisible;
that.terrainSwitchText = that.terrainVisible ? '-' : '+';
});
this._showFrustums = createCommand(function() {
if (that.frustums) {
that._scene.debugShowFrustums = true;
} else {
that._scene.debugShowFrustums = false;
}
return true;
});
this._showPerformance = createCommand(function() {
if (that.performance) {
that._performanceDisplay = new PerformanceDisplay({
container : that._performanceContainer
});
} else {
that._performanceContainer.innerHTML = '';
}
return true;
});
this._showPrimitiveBoundingSphere = createCommand(function() {
that._primitive.debugShowBoundingVolume = that.primitiveBoundingSphere;
return true;
});
this._showPrimitiveReferenceFrame = createCommand(function() {
if (that.primitiveReferenceFrame) {
var modelMatrix = that._primitive.modelMatrix;
that._modelMatrixPrimitive = new DebugModelMatrixPrimitive({
modelMatrix : modelMatrix
});
that._scene.primitives.add(that._modelMatrixPrimitive);
} else if (defined(that._modelMatrixPrimitive)) {
that._scene.primitives.remove(that._modelMatrixPrimitive);
that._modelMatrixPrimitive = undefined;
}
return true;
});
this._doFilterPrimitive = createCommand(function() {
if (that.filterPrimitive) {
that._scene.debugCommandFilter = function(command) {
if (defined(that._modelMatrixPrimitive) && command.owner === that._modelMatrixPrimitive._primitive) {
return true;
} else if (defined(that._primitive)) {
return command.owner === that._primitive || command.owner === that._primitive._billboardCollection || command.owner.primitive === that._primitive;
}
return false;
};
} else {
that._scene.debugCommandFilter = undefined;
}
return true;
});
this._showWireframe = createCommand(function() {
globe._surface.tileProvider._debug.wireframe = that.wireframe;
return true;
});
this._showGlobeDepth = createCommand(function() {
that._scene.debugShowGlobeDepth = that.globeDepth;
return true;
});
this._showPickDepth = createCommand(function() {
that._scene.debugShowPickDepth = that.pickDepth;
return true;
});
this._incrementDepthFrustum = createCommand(function() {
var next = that.depthFrustum + 1;
that.depthFrustum = boundDepthFrustum(1, that._numberOfFrustums, next);
that.scene.debugShowDepthFrustum = that.depthFrustum;
return true;
});
this._decrementDepthFrustum = createCommand(function() {
var next = that.depthFrustum - 1;
that.depthFrustum = boundDepthFrustum(1, that._numberOfFrustums, next);
that.scene.debugShowDepthFrustum = that.depthFrustum;
return true;
});
this._doSuspendUpdates = createCommand(function() {
globe._surface._debug.suspendLodUpdate = that.suspendUpdates;
if (!that.suspendUpdates) {
that.filterTile = false;
}
return true;
});
var tileBoundariesLayer;
this._showTileCoordinates = createCommand(function() {
if (that.tileCoordinates && !defined(tileBoundariesLayer)) {
tileBoundariesLayer = scene.imageryLayers.addImageryProvider(new TileCoordinatesImageryProvider({
tilingScheme : scene.terrainProvider.tilingScheme
}));
} else if (!that.tileCoordinates && defined(tileBoundariesLayer)) {
scene.imageryLayers.remove(tileBoundariesLayer);
tileBoundariesLayer = undefined;
}
return true;
});
this._showTileBoundingSphere = createCommand(function() {
if (that.tileBoundingSphere) {
globe._surface.tileProvider._debug.boundingSphereTile = that._tile;
} else {
globe._surface.tileProvider._debug.boundingSphereTile = undefined;
}
return true;
});
this._doFilterTile = createCommand(function() {
if (!that.filterTile) {
that.suspendUpdates = false;
that.doSuspendUpdates();
} else {
that.suspendUpdates = true;
that.doSuspendUpdates();
globe._surface._tilesToRender = [];
if (defined(that._tile)) {
globe._surface._tilesToRender.push(that._tile);
}
}
return true;
});
function pickPrimitive(e) {
eventHandler.removeInputAction(ScreenSpaceEventType.LEFT_CLICK);
that.pickPrimitiveActive = false;
var newPick = that._scene.pick({
x : e.position.x,
y : e.position.y
});
if (defined(newPick)) {
that.primitive = defined(newPick.collection) ? newPick.collection : newPick.primitive;
}
}
this._pickPrimitive = createCommand(function() {
that.pickPrimitiveActive = !that.pickPrimitiveActive;
if (that.pickPrimitiveActive) {
eventHandler.setInputAction(pickPrimitive, ScreenSpaceEventType.LEFT_CLICK);
} else {
eventHandler.removeInputAction(ScreenSpaceEventType.LEFT_CLICK);
}
});
function selectTile(e) {
var selectedTile;
var ellipsoid = globe.ellipsoid;
var cartesian = that._scene.camera.pickEllipsoid({
x : e.position.x,
y : e.position.y
}, ellipsoid);
if (defined(cartesian)) {
var cartographic = ellipsoid.cartesianToCartographic(cartesian);
var tilesRendered = globe._surface.tileProvider._tilesToRenderByTextureCount;
for (var textureCount = 0; !selectedTile && textureCount < tilesRendered.length; ++textureCount) {
var tilesRenderedByTextureCount = tilesRendered[textureCount];
if (!defined(tilesRenderedByTextureCount)) {
continue;
}
for (var tileIndex = 0; !selectedTile && tileIndex < tilesRenderedByTextureCount.length; ++tileIndex) {
var tile = tilesRenderedByTextureCount[tileIndex];
if (Rectangle.contains(tile.rectangle, cartographic)) {
selectedTile = tile;
}
}
}
}
that.tile = selectedTile;
eventHandler.removeInputAction(ScreenSpaceEventType.LEFT_CLICK);
that.pickTileActive = false;
}
this._pickTile = createCommand(function() {
that.pickTileActive = !that.pickTileActive;
if (that.pickTileActive) {
eventHandler.setInputAction(selectTile, ScreenSpaceEventType.LEFT_CLICK);
} else {
eventHandler.removeInputAction(ScreenSpaceEventType.LEFT_CLICK);
}
});
}
defineProperties(CesiumInspectorViewModel.prototype, {
/**
* Gets the scene to control.
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
},
/**
* Gets the container of the PerformanceDisplay
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Element}
*/
performanceContainer : {
get : function() {
return this._performanceContainer;
}
},
/**
* Gets the command to toggle the visibility of the drop down.
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
toggleDropDown : {
get : function() {
return this._toggleDropDown;
}
},
/**
* Gets the command to toggle {@link Scene.debugShowFrustums}
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showFrustums : {
get : function() {
return this._showFrustums;
}
},
/**
* Gets the command to toggle the visibility of the performance display.
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showPerformance : {
get : function() {
return this._showPerformance;
}
},
/**
* Gets the command to toggle the visibility of a BoundingSphere for a primitive
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showPrimitiveBoundingSphere : {
get : function() {
return this._showPrimitiveBoundingSphere;
}
},
/**
* Gets the command to toggle the visibility of a {@link DebugModelMatrixPrimitive} for the model matrix of a primitive
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showPrimitiveReferenceFrame : {
get : function() {
return this._showPrimitiveReferenceFrame;
}
},
/**
* Gets the command to toggle a filter that renders only a selected primitive
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
doFilterPrimitive : {
get : function() {
return this._doFilterPrimitive;
}
},
/**
* Gets the command to toggle the view of the Globe as a wireframe
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showWireframe : {
get : function() {
return this._showWireframe;
}
},
/**
* Gets the command to toggle the view of the Globe depth buffer
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showGlobeDepth : {
get : function() {
return this._showGlobeDepth;
}
},
/**
* Gets the command to toggle the view of the pick depth buffer
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showPickDepth : {
get : function() {
return this._showPickDepth;
}
},
/**
* Gets the command to increment the depth frustum index to be shown
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
incrementDepthFrustum : {
get : function() {
return this._incrementDepthFrustum;
}
},
/**
* Gets the command to decrement the depth frustum index to be shown
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
decrementDepthFrustum : {
get : function() {
return this._decrementDepthFrustum;
}
},
/**
* Gets the command to toggle whether to suspend tile updates
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
doSuspendUpdates : {
get : function() {
return this._doSuspendUpdates;
}
},
/**
* Gets the command to toggle the visibility of tile coordinates
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showTileCoordinates : {
get : function() {
return this._showTileCoordinates;
}
},
/**
* Gets the command to toggle the visibility of a BoundingSphere for a selected tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
showTileBoundingSphere : {
get : function() {
return this._showTileBoundingSphere;
}
},
/**
* Gets the command to toggle a filter that renders only a selected tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
doFilterTile : {
get : function() {
return this._doFilterTile;
}
},
/**
* Gets the command to expand and collapse the general section
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
toggleGeneral : {
get : function() {
return this._toggleGeneral;
}
},
/**
* Gets the command to expand and collapse the primitives section
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
togglePrimitives : {
get : function() {
return this._togglePrimitives;
}
},
/**
* Gets the command to expand and collapse the terrain section
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
toggleTerrain : {
get : function() {
return this._toggleTerrain;
}
},
/**
* Gets the command to pick a primitive
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
pickPrimitive : {
get : function() {
return this._pickPrimitive;
}
},
/**
* Gets the command to pick a tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
pickTile : {
get : function() {
return this._pickTile;
}
},
/**
* Gets the command to pick a tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
selectParent : {
get : function() {
var that = this;
return createCommand(function() {
that.tile = that.tile.parent;
});
}
},
/**
* Gets the command to pick a tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
selectNW : {
get : function() {
var that = this;
return createCommand(function() {
that.tile = that.tile.northwestChild;
});
}
},
/**
* Gets the command to pick a tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
selectNE : {
get : function() {
var that = this;
return createCommand(function() {
that.tile = that.tile.northeastChild;
});
}
},
/**
* Gets the command to pick a tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
selectSW : {
get : function() {
var that = this;
return createCommand(function() {
that.tile = that.tile.southwestChild;
});
}
},
/**
* Gets the command to pick a tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
selectSE : {
get : function() {
var that = this;
return createCommand(function() {
that.tile = that.tile.southeastChild;
});
}
},
/**
* Gets or sets the current selected primitive
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
primitive : {
set : function(newPrimitive) {
var oldPrimitive = this._primitive;
if (newPrimitive !== oldPrimitive) {
this.hasPickedPrimitive = true;
if (defined(oldPrimitive)) {
oldPrimitive.debugShowBoundingVolume = false;
}
this._scene.debugCommandFilter = undefined;
if (defined(this._modelMatrixPrimitive)) {
this._scene.primitives.remove(this._modelMatrixPrimitive);
this._modelMatrixPrimitive = undefined;
}
this._primitive = newPrimitive;
newPrimitive.show = false;
setTimeout(function() {
newPrimitive.show = true;
}, 50);
this.showPrimitiveBoundingSphere();
this.showPrimitiveReferenceFrame();
this.doFilterPrimitive();
}
},
get : function() {
return this._primitive;
}
},
/**
* Gets or sets the current selected tile
* @memberof CesiumInspectorViewModel.prototype
*
* @type {Command}
*/
tile : {
set : function(newTile) {
if (defined(newTile)) {
this.hasPickedTile = true;
var oldTile = this._tile;
if (newTile !== oldTile) {
this.tileText = 'L: ' + newTile.level + ' X: ' + newTile.x + ' Y: ' + newTile.y;
this.tileText += '<br>SW corner: ' + newTile.rectangle.west + ', ' + newTile.rectangle.south;
this.tileText += '<br>NE corner: ' + newTile.rectangle.east + ', ' + newTile.rectangle.north;
this.tileText += '<br>Min: ' + newTile.data.minimumHeight + ' Max: ' + newTile.data.maximumHeight;
}
this._tile = newTile;
this.showTileBoundingSphere();
this.doFilterTile();
} else {
this.hasPickedTile = false;
this._tile = undefined;
}
},
get : function() {
return this._tile;
}
},
update : {
get : function() {
var that = this;
return function() {
if (that.frustums) {
that.frustumStatisticText = frustumStatsToString(that._scene.debugFrustumStatistics);
}
// Determine the number of frustums being used.
var numberOfFrustums = that._scene.numberOfFrustums;
that._numberOfFrustums = numberOfFrustums;
// Bound the frustum to be displayed.
var depthFrustum = boundDepthFrustum(1, numberOfFrustums, that.depthFrustum);
that.depthFrustum = depthFrustum;
that.scene.debugShowDepthFrustum = depthFrustum;
// Update the displayed text.
that.depthFrustumText = depthFrustum + ' of ' + numberOfFrustums;
if (that.performance) {
that._performanceDisplay.update();
}
if (that.primitiveReferenceFrame) {
that._modelMatrixPrimitive.modelMatrix = that._primitive.modelMatrix;
}
that.shaderCacheText = 'Cached shaders: ' + that._scene.context.shaderCache.numberOfShaders;
};
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
CesiumInspectorViewModel.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
CesiumInspectorViewModel.prototype.destroy = function() {
this._eventHandler.destroy();
return destroyObject(this);
};
return CesiumInspectorViewModel;
});
/*global define*/
define('Widgets/CesiumInspector/CesiumInspector',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../getElement',
'./CesiumInspectorViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
knockout,
getElement,
CesiumInspectorViewModel) {
'use strict';
/**
* Inspector widget to aid in debugging
*
* @alias CesiumInspector
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Scene} scene The Scene instance to use.
*
* @exception {DeveloperError} container is required.
* @exception {DeveloperError} scene is required.
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Cesium%20Inspector.html|Cesium Sandcastle Cesium Inspector Demo}
*/
function CesiumInspector(container, scene) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
container = getElement(container);
var performanceContainer = document.createElement('div');
var viewModel = new CesiumInspectorViewModel(scene, performanceContainer);
this._viewModel = viewModel;
this._container = container;
var element = document.createElement('div');
this._element = element;
var text = document.createElement('div');
text.textContent = 'Cesium Inspector';
text.className = 'cesium-cesiumInspector-button';
text.setAttribute('data-bind', 'click: toggleDropDown');
element.appendChild(text);
element.className = 'cesium-cesiumInspector';
element.setAttribute('data-bind', 'css: { "cesium-cesiumInspector-visible" : dropDownVisible, "cesium-cesiumInspector-hidden" : !dropDownVisible }');
container.appendChild(this._element);
var panel = document.createElement('div');
this._panel = panel;
panel.className = 'cesium-cesiumInspector-dropDown';
element.appendChild(panel);
// General
var general = document.createElement('div');
general.className = 'cesium-cesiumInspector-sectionHeader';
var plus = document.createElement('span');
plus.className = 'cesium-cesiumInspector-toggleSwitch';
plus.setAttribute('data-bind', 'click: toggleGeneral, text: generalSwitchText');
general.appendChild(plus);
general.appendChild(document.createTextNode('General'));
panel.appendChild(general);
var generalSection = document.createElement('div');
generalSection.className = 'cesium-cesiumInspector-section';
generalSection.setAttribute('data-bind', 'css: {"cesium-cesiumInspector-show" : generalVisible, "cesium-cesiumInspector-hide" : !generalVisible}');
panel.appendChild(generalSection);
var debugShowFrustums = document.createElement('div');
generalSection.appendChild(debugShowFrustums);
var frustumStats = document.createElement('div');
frustumStats.className = 'cesium-cesiumInspector-frustumStats';
frustumStats.setAttribute('data-bind', 'css: {"cesium-cesiumInspector-show" : frustums, "cesium-cesiumInspector-hide" : !frustums}, html: frustumStatisticText');
var frustumsCheckbox = document.createElement('input');
frustumsCheckbox.type = 'checkbox';
frustumsCheckbox.setAttribute('data-bind', 'checked: frustums, click: showFrustums');
debugShowFrustums.appendChild(frustumsCheckbox);
debugShowFrustums.appendChild(document.createTextNode('Show Frustums'));
debugShowFrustums.appendChild(frustumStats);
var performanceDisplay = document.createElement('div');
generalSection.appendChild(performanceDisplay);
var pdCheckbox = document.createElement('input');
pdCheckbox.type = 'checkbox';
pdCheckbox.setAttribute('data-bind', 'checked: performance, click: showPerformance');
performanceDisplay.appendChild(pdCheckbox);
performanceDisplay.appendChild(document.createTextNode('Performance Display'));
performanceContainer.className = 'cesium-cesiumInspector-performanceDisplay';
generalSection.appendChild(performanceContainer);
var shaderCacheDisplay = document.createElement('div');
shaderCacheDisplay.className = 'cesium-cesiumInspector-shaderCache';
shaderCacheDisplay.setAttribute('data-bind', 'html: shaderCacheText');
generalSection.appendChild(shaderCacheDisplay);
var globeDepth = document.createElement('div');
generalSection.appendChild(globeDepth);
var gCheckbox = document.createElement('input');
gCheckbox.type = 'checkbox';
gCheckbox.setAttribute('data-bind', 'checked: globeDepth, click: showGlobeDepth');
globeDepth.appendChild(gCheckbox);
globeDepth.appendChild(document.createTextNode('Show globe depth'));
var globeDepthFrustum = document.createElement('div');
globeDepth.appendChild(globeDepthFrustum);
var pickDepth = document.createElement('div');
generalSection.appendChild(pickDepth);
var pCheckbox = document.createElement('input');
pCheckbox.type = 'checkbox';
pCheckbox.setAttribute('data-bind', 'checked: pickDepth, click: showPickDepth');
pickDepth.appendChild(pCheckbox);
pickDepth.appendChild(document.createTextNode('Show pick depth'));
var depthFrustum = document.createElement('div');
generalSection.appendChild(depthFrustum);
// Use a span with HTML binding so that we can indent with non-breaking spaces.
var gLabel = document.createElement('span');
gLabel.setAttribute('data-bind', 'html: " Frustum:"');
depthFrustum.appendChild(gLabel);
var gText = document.createElement('span');
gText.setAttribute('data-bind', 'text: depthFrustumText');
depthFrustum.appendChild(gText);
var gMinusButton = document.createElement('input');
gMinusButton.type = 'button';
gMinusButton.value = '-';
gMinusButton.className = 'cesium-cesiumInspector-pickButton';
gMinusButton.setAttribute('data-bind', 'click: decrementDepthFrustum');
depthFrustum.appendChild(gMinusButton);
var gPlusButton = document.createElement('input');
gPlusButton.type = 'button';
gPlusButton.value = '+';
gPlusButton.className = 'cesium-cesiumInspector-pickButton';
gPlusButton.setAttribute('data-bind', 'click: incrementDepthFrustum');
depthFrustum.appendChild(gPlusButton);
// Primitives
var prim = document.createElement('div');
prim.className = 'cesium-cesiumInspector-sectionHeader';
plus = document.createElement('span');
plus.className = 'cesium-cesiumInspector-toggleSwitch';
plus.setAttribute('data-bind', 'click: togglePrimitives, text: primitivesSwitchText');
prim.appendChild(plus);
prim.appendChild(document.createTextNode('Primitives'));
panel.appendChild(prim);
var primitivesSection = document.createElement('div');
primitivesSection.className = 'cesium-cesiumInspector-section';
primitivesSection.setAttribute('data-bind', 'css: {"cesium-cesiumInspector-show" : primitivesVisible, "cesium-cesiumInspector-hide" : !primitivesVisible}');
panel.appendChild(primitivesSection);
var pickPrimRequired = document.createElement('div');
pickPrimRequired.className = 'cesium-cesiumInspector-pickSection';
primitivesSection.appendChild(pickPrimRequired);
var pickPrimitiveButton = document.createElement('input');
pickPrimitiveButton.type = 'button';
pickPrimitiveButton.value = 'Pick a primitive';
pickPrimitiveButton.className = 'cesium-cesiumInspector-pickButton';
pickPrimitiveButton.setAttribute('data-bind', 'css: {"cesium-cesiumInspector-pickButtonHighlight" : pickPrimitiveActive}, click: pickPrimitive');
var buttonWrap = document.createElement('div');
buttonWrap.className = 'cesium-cesiumInspector-center';
buttonWrap.appendChild(pickPrimitiveButton);
pickPrimRequired.appendChild(buttonWrap);
var debugSphere = document.createElement('div');
pickPrimRequired.appendChild(debugSphere);
var bsCheckbox = document.createElement('input');
bsCheckbox.type = 'checkbox';
bsCheckbox.setAttribute('data-bind', 'checked: primitiveBoundingSphere, click: showPrimitiveBoundingSphere, enable: hasPickedPrimitive');
debugSphere.appendChild(bsCheckbox);
debugSphere.appendChild(document.createTextNode('Show bounding sphere'));
var refFrame = document.createElement('div');
pickPrimRequired.appendChild(refFrame);
var rfCheckbox = document.createElement('input');
rfCheckbox.type = 'checkbox';
rfCheckbox.setAttribute('data-bind', 'checked: primitiveReferenceFrame, click: showPrimitiveReferenceFrame, enable: hasPickedPrimitive');
refFrame.appendChild(rfCheckbox);
refFrame.appendChild(document.createTextNode('Show reference frame'));
var primitiveOnly = document.createElement('div');
this._primitiveOnly = primitiveOnly;
pickPrimRequired.appendChild(primitiveOnly);
var primitiveOnlyCheckbox = document.createElement('input');
primitiveOnlyCheckbox.type = 'checkbox';
primitiveOnlyCheckbox.setAttribute('data-bind', 'checked: filterPrimitive, click: doFilterPrimitive, enable: hasPickedPrimitive');
primitiveOnly.appendChild(primitiveOnlyCheckbox);
primitiveOnly.appendChild(document.createTextNode('Show only selected'));
// Terrain
var terrain = document.createElement('div');
terrain.className = 'cesium-cesiumInspector-sectionHeader';
plus = document.createElement('span');
plus.className = 'cesium-cesiumInspector-toggleSwitch';
plus.setAttribute('data-bind', 'click: toggleTerrain, text: terrainSwitchText');
terrain.appendChild(plus);
terrain.appendChild(document.createTextNode('Terrain'));
panel.appendChild(terrain);
var terrainSection = document.createElement('div');
terrainSection.className = 'cesium-cesiumInspector-section';
terrainSection.setAttribute('data-bind', 'css: {"cesium-cesiumInspector-show" : terrainVisible, "cesium-cesiumInspector-hide" : !terrainVisible}');
panel.appendChild(terrainSection);
var pickTileRequired = document.createElement('div');
pickTileRequired.className = 'cesium-cesiumInspector-pickSection';
terrainSection.appendChild(pickTileRequired);
var pickTileButton = document.createElement('input');
pickTileButton.type = 'button';
pickTileButton.value = 'Pick a tile';
pickTileButton.className = 'cesium-cesiumInspector-pickButton';
pickTileButton.setAttribute('data-bind', 'css: {"cesium-cesiumInspector-pickButtonHighlight" : pickTileActive}, click: pickTile');
buttonWrap = document.createElement('div');
buttonWrap.appendChild(pickTileButton);
buttonWrap.className = 'cesium-cesiumInspector-center';
pickTileRequired.appendChild(buttonWrap);
var tileInfo = document.createElement('div');
pickTileRequired.appendChild(tileInfo);
var parentTile = document.createElement('input');
parentTile.type = 'button';
parentTile.value = 'Parent';
parentTile.className = 'cesium-cesiumInspector-pickButton';
parentTile.setAttribute('data-bind', 'click: selectParent');
var nwTile = document.createElement('input');
nwTile.type = 'button';
nwTile.value = 'NW';
nwTile.className = 'cesium-cesiumInspector-pickButton';
nwTile.setAttribute('data-bind', 'click: selectNW');
var neTile = document.createElement('input');
neTile.type = 'button';
neTile.value = 'NE';
neTile.className = 'cesium-cesiumInspector-pickButton';
neTile.setAttribute('data-bind', 'click: selectNE');
var swTile = document.createElement('input');
swTile.type = 'button';
swTile.value = 'SW';
swTile.className = 'cesium-cesiumInspector-pickButton';
swTile.setAttribute('data-bind', 'click: selectSW');
var seTile = document.createElement('input');
seTile.type = 'button';
seTile.value = 'SE';
seTile.className = 'cesium-cesiumInspector-pickButton';
seTile.setAttribute('data-bind', 'click: selectSE');
var tileText = document.createElement('div');
tileText.className = 'cesium-cesiumInspector-tileText';
tileInfo.className = 'cesium-cesiumInspector-frustumStats';
tileInfo.appendChild(tileText);
tileInfo.setAttribute('data-bind', 'css: {"cesium-cesiumInspector-show" : hasPickedTile, "cesium-cesiumInspector-hide" : !hasPickedTile}');
tileText.setAttribute('data-bind', 'html: tileText');
var relativeText = document.createElement('div');
relativeText.className = 'cesium-cesiumInspector-relativeText';
relativeText.textContent = 'Select relative:';
tileInfo.appendChild(relativeText);
var table = document.createElement('table');
var tr1 = document.createElement('tr');
var tr2 = document.createElement('tr');
var td1 = document.createElement('td');
td1.appendChild(parentTile);
var td2 = document.createElement('td');
td2.appendChild(nwTile);
var td3 = document.createElement('td');
td3.appendChild(neTile);
tr1.appendChild(td1);
tr1.appendChild(td2);
tr1.appendChild(td3);
var td4 = document.createElement('td');
var td5 = document.createElement('td');
td5.appendChild(swTile);
var td6 = document.createElement('td');
td6.appendChild(seTile);
tr2.appendChild(td4);
tr2.appendChild(td5);
tr2.appendChild(td6);
table.appendChild(tr1);
table.appendChild(tr2);
tileInfo.appendChild(table);
var tileBoundingSphere = document.createElement('div');
pickTileRequired.appendChild(tileBoundingSphere);
var tbsCheck = document.createElement('input');
tbsCheck.type = 'checkbox';
tbsCheck.setAttribute('data-bind', 'checked: tileBoundingSphere, enable: hasPickedTile, click: showTileBoundingSphere');
tileBoundingSphere.appendChild(tbsCheck);
tileBoundingSphere.appendChild(document.createTextNode('Show bounding volume'));
var renderTile = document.createElement('div');
pickTileRequired.appendChild(renderTile);
var rCheck = document.createElement('input');
rCheck.type = 'checkbox';
rCheck.setAttribute('data-bind', 'checked: filterTile, enable: hasPickedTile, click: doFilterTile');
renderTile.appendChild(rCheck);
renderTile.appendChild(document.createTextNode('Show only selected'));
var wireframe = document.createElement('div');
terrainSection.appendChild(wireframe);
var wCheckbox = document.createElement('input');
wCheckbox.type = 'checkbox';
wCheckbox.setAttribute('data-bind', 'checked: wireframe, click: showWireframe');
wireframe.appendChild(wCheckbox);
wireframe.appendChild(document.createTextNode('Wireframe'));
var suspendUpdates = document.createElement('div');
terrainSection.appendChild(suspendUpdates);
var upCheckbox = document.createElement('input');
upCheckbox.type = 'checkbox';
upCheckbox.setAttribute('data-bind', 'checked: suspendUpdates, click: doSuspendUpdates');
suspendUpdates.appendChild(upCheckbox);
suspendUpdates.appendChild(document.createTextNode('Suspend LOD update'));
var tileCoords = document.createElement('div');
terrainSection.appendChild(tileCoords);
var coordCheck = document.createElement('input');
coordCheck.type = 'checkbox';
coordCheck.setAttribute('data-bind', 'checked: tileCoordinates, click: showTileCoordinates');
tileCoords.appendChild(coordCheck);
tileCoords.appendChild(document.createTextNode('Show tile coordinates'));
knockout.applyBindings(viewModel, this._element);
}
defineProperties(CesiumInspector.prototype, {
/**
* Gets the parent container.
* @memberof CesiumInspector.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof CesiumInspector.prototype
*
* @type {CesiumInspectorViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
CesiumInspector.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
CesiumInspector.prototype.destroy = function() {
knockout.cleanNode(this._element);
this._container.removeChild(this._element);
this.viewModel.destroy();
return destroyObject(this);
};
return CesiumInspector;
});
/*global define*/
define('Widgets/CesiumWidget/CesiumWidget',[
'../../Core/buildModuleUrl',
'../../Core/Cartesian3',
'../../Core/Clock',
'../../Core/Credit',
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/Ellipsoid',
'../../Core/FeatureDetection',
'../../Core/formatError',
'../../Core/requestAnimationFrame',
'../../Core/ScreenSpaceEventHandler',
'../../Scene/BingMapsImageryProvider',
'../../Scene/Globe',
'../../Scene/Moon',
'../../Scene/Scene',
'../../Scene/SceneMode',
'../../Scene/ShadowMode',
'../../Scene/SkyAtmosphere',
'../../Scene/SkyBox',
'../../Scene/Sun',
'../getElement'
], function(
buildModuleUrl,
Cartesian3,
Clock,
Credit,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
Ellipsoid,
FeatureDetection,
formatError,
requestAnimationFrame,
ScreenSpaceEventHandler,
BingMapsImageryProvider,
Globe,
Moon,
Scene,
SceneMode,
ShadowMode,
SkyAtmosphere,
SkyBox,
Sun,
getElement) {
'use strict';
function getDefaultSkyBoxUrl(suffix) {
return buildModuleUrl('Assets/Textures/SkyBox/tycho2t3_80_' + suffix + '.jpg');
}
function startRenderLoop(widget) {
widget._renderLoopRunning = true;
var lastFrameTime = 0;
function render(frameTime) {
if (widget.isDestroyed()) {
return;
}
if (widget._useDefaultRenderLoop) {
try {
var targetFrameRate = widget._targetFrameRate;
if (!defined(targetFrameRate)) {
widget.resize();
widget.render();
requestAnimationFrame(render);
} else {
var interval = 1000.0 / targetFrameRate;
var delta = frameTime - lastFrameTime;
if (delta > interval) {
widget.resize();
widget.render();
lastFrameTime = frameTime - (delta % interval);
}
requestAnimationFrame(render);
}
} catch (error) {
widget._useDefaultRenderLoop = false;
widget._renderLoopRunning = false;
if (widget._showRenderLoopErrors) {
var title = 'An error occurred while rendering. Rendering has stopped.';
widget.showErrorPanel(title, undefined, error);
}
}
} else {
widget._renderLoopRunning = false;
}
}
requestAnimationFrame(render);
}
function configureCanvasSize(widget) {
var canvas = widget._canvas;
var width = canvas.clientWidth;
var height = canvas.clientHeight;
var resolutionScale = widget._resolutionScale;
if (!widget._supportsImageRenderingPixelated) {
resolutionScale *= defaultValue(window.devicePixelRatio, 1.0);
}
widget._canvasWidth = width;
widget._canvasHeight = height;
width *= resolutionScale;
height *= resolutionScale;
canvas.width = width;
canvas.height = height;
widget._canRender = width !== 0 && height !== 0;
}
function configureCameraFrustum(widget) {
var canvas = widget._canvas;
var width = canvas.width;
var height = canvas.height;
if (width !== 0 && height !== 0) {
var frustum = widget._scene.camera.frustum;
if (defined(frustum.aspectRatio)) {
frustum.aspectRatio = width / height;
} else {
frustum.top = frustum.right * (height / width);
frustum.bottom = -frustum.top;
}
}
}
var cesiumLogoData = 'data:image/png;base64,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';
/**
* A widget containing a Cesium scene.
*
* @alias CesiumWidget
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Object} [options] Object with the following properties:
* @param {Clock} [options.clock=new Clock()] The clock to use to control current time.
* @param {ImageryProvider} [options.imageryProvider=new BingMapsImageryProvider()] The imagery provider to serve as the base layer. If set to <code>false</code>, no imagery provider will be added.
* @param {TerrainProvider} [options.terrainProvider=new EllipsoidTerrainProvider] The terrain provider.
* @param {SkyBox} [options.skyBox] The skybox used to render the stars. When <code>undefined</code>, the default stars are used. If set to <code>false</code>, no skyBox, Sun, or Moon will be added.
* @param {SkyAtmosphere} [options.skyAtmosphere] Blue sky, and the glow around the Earth's limb. Set to <code>false</code> to turn it off.
* @param {SceneMode} [options.sceneMode=SceneMode.SCENE3D] The initial scene mode.
* @param {Boolean} [options.scene3DOnly=false] When <code>true</code>, each geometry instance will only be rendered in 3D to save GPU memory.
* @param {Boolean} [options.orderIndependentTranslucency=true] If true and the configuration supports it, use order independent translucency.
* @param {MapProjection} [options.mapProjection=new GeographicProjection()] The map projection to use in 2D and Columbus View modes.
* @param {Globe} [options.globe=new Globe(mapProjection.ellipsoid)] The globe to use in the scene. If set to <code>false</code>, no globe will be added.
* @param {Boolean} [options.useDefaultRenderLoop=true] True if this widget should control the render loop, false otherwise.
* @param {Number} [options.targetFrameRate] The target frame rate when using the default render loop.
* @param {Boolean} [options.showRenderLoopErrors=true] If true, this widget will automatically display an HTML panel to the user containing the error, if a render loop error occurs.
* @param {Object} [options.contextOptions] Context and WebGL creation properties corresponding to <code>options</code> passed to {@link Scene}.
* @param {Element|String} [options.creditContainer] The DOM element or ID that will contain the {@link CreditDisplay}. If not specified, the credits are added
* to the bottom of the widget itself.
* @param {Number} [options.terrainExaggeration=1.0] A scalar used to exaggerate the terrain. Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
* @param {Boolean} [options.shadows=false] Determines if shadows are cast by the sun.
* @param {ShadowMode} [options.terrainShadows=ShadowMode.RECEIVE_ONLY] Determines if the terrain casts or receives shadows from the sun.
* @param {MapMode2D} [options.mapMode2D=MapMode2D.INFINITE_SCROLL] Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Cesium%20Widget.html|Cesium Sandcastle Cesium Widget Demo}
*
* @example
* // For each example, include a link to CesiumWidget.css stylesheet in HTML head,
* // and in the body, include: <div id="cesiumContainer"></div>
*
* //Widget with no terrain and default Bing Maps imagery provider.
* var widget = new Cesium.CesiumWidget('cesiumContainer');
*
* //Widget with OpenStreetMaps imagery provider and Cesium terrain provider hosted by AGI.
* var widget = new Cesium.CesiumWidget('cesiumContainer', {
* imageryProvider : Cesium.createOpenStreetMapImageryProvider(),
* terrainProvider : new Cesium.CesiumTerrainProvider({
* url : 'https://assets.agi.com/stk-terrain/world'
* }),
* // Use high-res stars downloaded from https://github.com/AnalyticalGraphicsInc/cesium-assets
* skyBox : new Cesium.SkyBox({
* sources : {
* positiveX : 'stars/TychoSkymapII.t3_08192x04096_80_px.jpg',
* negativeX : 'stars/TychoSkymapII.t3_08192x04096_80_mx.jpg',
* positiveY : 'stars/TychoSkymapII.t3_08192x04096_80_py.jpg',
* negativeY : 'stars/TychoSkymapII.t3_08192x04096_80_my.jpg',
* positiveZ : 'stars/TychoSkymapII.t3_08192x04096_80_pz.jpg',
* negativeZ : 'stars/TychoSkymapII.t3_08192x04096_80_mz.jpg'
* }
* }),
* // Show Columbus View map with Web Mercator projection
* sceneMode : Cesium.SceneMode.COLUMBUS_VIEW,
* mapProjection : new Cesium.WebMercatorProjection()
* });
*/
function CesiumWidget(container, options) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
container = getElement(container);
options = defaultValue(options, {});
//Configure the widget DOM elements
var element = document.createElement('div');
element.className = 'cesium-widget';
container.appendChild(element);
var canvas = document.createElement('canvas');
var supportsImageRenderingPixelated = FeatureDetection.supportsImageRenderingPixelated();
this._supportsImageRenderingPixelated = supportsImageRenderingPixelated;
if (supportsImageRenderingPixelated) {
canvas.style.imageRendering = FeatureDetection.imageRenderingValue();
}
canvas.oncontextmenu = function() {
return false;
};
canvas.onselectstart = function() {
return false;
};
element.appendChild(canvas);
var creditContainer = document.createElement('div');
creditContainer.className = 'cesium-widget-credits';
var creditContainerContainer = defined(options.creditContainer) ? getElement(options.creditContainer) : element;
creditContainerContainer.appendChild(creditContainer);
var showRenderLoopErrors = defaultValue(options.showRenderLoopErrors, true);
this._element = element;
this._container = container;
this._canvas = canvas;
this._canvasWidth = 0;
this._canvasHeight = 0;
this._creditContainer = creditContainer;
this._canRender = false;
this._renderLoopRunning = false;
this._showRenderLoopErrors = showRenderLoopErrors;
this._resolutionScale = 1.0;
this._forceResize = false;
this._clock = defined(options.clock) ? options.clock : new Clock();
configureCanvasSize(this);
try {
var scene = new Scene({
canvas : canvas,
contextOptions : options.contextOptions,
creditContainer : creditContainer,
mapProjection : options.mapProjection,
orderIndependentTranslucency : options.orderIndependentTranslucency,
scene3DOnly : defaultValue(options.scene3DOnly, false),
terrainExaggeration : options.terrainExaggeration,
shadows : options.shadows,
mapMode2D : options.mapMode2D
});
this._scene = scene;
scene.camera.constrainedAxis = Cartesian3.UNIT_Z;
configureCameraFrustum(this);
var ellipsoid = defaultValue(scene.mapProjection.ellipsoid, Ellipsoid.WGS84);
var creditDisplay = scene.frameState.creditDisplay;
var cesiumCredit = new Credit('Cesium', cesiumLogoData, 'http://cesiumjs.org/');
creditDisplay.addDefaultCredit(cesiumCredit);
var globe = options.globe;
if (!defined(globe)) {
globe = new Globe(ellipsoid);
}
if (globe !== false) {
scene.globe = globe;
scene.globe.shadows = defaultValue(options.terrainShadows, ShadowMode.RECEIVE_ONLY);
}
var skyBox = options.skyBox;
if (!defined(skyBox)) {
skyBox = new SkyBox({
sources : {
positiveX : getDefaultSkyBoxUrl('px'),
negativeX : getDefaultSkyBoxUrl('mx'),
positiveY : getDefaultSkyBoxUrl('py'),
negativeY : getDefaultSkyBoxUrl('my'),
positiveZ : getDefaultSkyBoxUrl('pz'),
negativeZ : getDefaultSkyBoxUrl('mz')
}
});
}
if (skyBox !== false) {
scene.skyBox = skyBox;
scene.sun = new Sun();
scene.moon = new Moon();
}
// Blue sky, and the glow around the Earth's limb.
var skyAtmosphere = options.skyAtmosphere;
if (!defined(skyAtmosphere)) {
skyAtmosphere = new SkyAtmosphere(ellipsoid);
}
if (skyAtmosphere !== false) {
scene.skyAtmosphere = skyAtmosphere;
}
//Set the base imagery layer
var imageryProvider = (options.globe === false) ? false : options.imageryProvider;
if (!defined(imageryProvider)) {
imageryProvider = new BingMapsImageryProvider({
url : 'https://dev.virtualearth.net'
});
}
if (imageryProvider !== false) {
scene.imageryLayers.addImageryProvider(imageryProvider);
}
//Set the terrain provider if one is provided.
if (defined(options.terrainProvider) && options.globe !== false) {
scene.terrainProvider = options.terrainProvider;
}
this._screenSpaceEventHandler = new ScreenSpaceEventHandler(canvas, false);
if (defined(options.sceneMode)) {
if (options.sceneMode === SceneMode.SCENE2D) {
this._scene.morphTo2D(0);
}
if (options.sceneMode === SceneMode.COLUMBUS_VIEW) {
this._scene.morphToColumbusView(0);
}
}
this._useDefaultRenderLoop = undefined;
this.useDefaultRenderLoop = defaultValue(options.useDefaultRenderLoop, true);
this._targetFrameRate = undefined;
this.targetFrameRate = options.targetFrameRate;
var that = this;
scene.renderError.addEventListener(function(scene, error) {
that._useDefaultRenderLoop = false;
that._renderLoopRunning = false;
if (that._showRenderLoopErrors) {
var title = 'An error occurred while rendering. Rendering has stopped.';
that.showErrorPanel(title, undefined, error);
}
});
} catch (error) {
if (showRenderLoopErrors) {
var title = 'Error constructing CesiumWidget.';
var message = 'Visit <a href="http://get.webgl.org">http://get.webgl.org</a> to verify that your web browser and hardware support WebGL. Consider trying a different web browser or updating your video drivers. Detailed error information is below:';
this.showErrorPanel(title, message, error);
}
throw error;
}
}
defineProperties(CesiumWidget.prototype, {
/**
* Gets the parent container.
* @memberof CesiumWidget.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the canvas.
* @memberof CesiumWidget.prototype
*
* @type {Canvas}
*/
canvas : {
get : function() {
return this._canvas;
}
},
/**
* Gets the credit container.
* @memberof CesiumWidget.prototype
*
* @type {Element}
*/
creditContainer: {
get : function() {
return this._creditContainer;
}
},
/**
* Gets the scene.
* @memberof CesiumWidget.prototype
*
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
},
/**
* Gets the collection of image layers that will be rendered on the globe.
* @memberof CesiumWidget.prototype
*
* @type {ImageryLayerCollection}
* @readonly
*/
imageryLayers : {
get : function() {
return this._scene.imageryLayers;
}
},
/**
* The terrain provider providing surface geometry for the globe.
* @memberof CesiumWidget.prototype
*
* @type {TerrainProvider}
*/
terrainProvider : {
get : function() {
return this._scene.terrainProvider;
},
set : function(terrainProvider) {
this._scene.terrainProvider = terrainProvider;
}
},
/**
* Gets the camera.
* @memberof CesiumWidget.prototype
*
* @type {Camera}
* @readonly
*/
camera : {
get : function() {
return this._scene.camera;
}
},
/**
* Gets the clock.
* @memberof CesiumWidget.prototype
*
* @type {Clock}
*/
clock : {
get : function() {
return this._clock;
}
},
/**
* Gets the screen space event handler.
* @memberof CesiumWidget.prototype
*
* @type {ScreenSpaceEventHandler}
*/
screenSpaceEventHandler : {
get : function() {
return this._screenSpaceEventHandler;
}
},
/**
* Gets or sets the target frame rate of the widget when <code>useDefaultRenderLoop</code>
* is true. If undefined, the browser's {@link requestAnimationFrame} implementation
* determines the frame rate. If defined, this value must be greater than 0. A value higher
* than the underlying requestAnimationFrame implementation will have no effect.
* @memberof CesiumWidget.prototype
*
* @type {Number}
*/
targetFrameRate : {
get : function() {
return this._targetFrameRate;
},
set : function(value) {
if (value <= 0) {
throw new DeveloperError('targetFrameRate must be greater than 0, or undefined.');
}
this._targetFrameRate = value;
}
},
/**
* Gets or sets whether or not this widget should control the render loop.
* If set to true the widget will use {@link requestAnimationFrame} to
* perform rendering and resizing of the widget, as well as drive the
* simulation clock. If set to false, you must manually call the
* <code>resize</code>, <code>render</code> methods as part of a custom
* render loop. If an error occurs during rendering, {@link Scene}'s
* <code>renderError</code> event will be raised and this property
* will be set to false. It must be set back to true to continue rendering
* after the error.
* @memberof CesiumWidget.prototype
*
* @type {Boolean}
*/
useDefaultRenderLoop : {
get : function() {
return this._useDefaultRenderLoop;
},
set : function(value) {
if (this._useDefaultRenderLoop !== value) {
this._useDefaultRenderLoop = value;
if (value && !this._renderLoopRunning) {
startRenderLoop(this);
}
}
}
},
/**
* Gets or sets a scaling factor for rendering resolution. Values less than 1.0 can improve
* performance on less powerful devices while values greater than 1.0 will render at a higher
* resolution and then scale down, resulting in improved visual fidelity.
* For example, if the widget is laid out at a size of 640x480, setting this value to 0.5
* will cause the scene to be rendered at 320x240 and then scaled up while setting
* it to 2.0 will cause the scene to be rendered at 1280x960 and then scaled down.
* @memberof CesiumWidget.prototype
*
* @type {Number}
* @default 1.0
*/
resolutionScale : {
get : function() {
return this._resolutionScale;
},
set : function(value) {
if (value <= 0) {
throw new DeveloperError('resolutionScale must be greater than 0.');
}
this._resolutionScale = value;
this._forceResize = true;
}
}
});
/**
* Show an error panel to the user containing a title and a longer error message,
* which can be dismissed using an OK button. This panel is displayed automatically
* when a render loop error occurs, if showRenderLoopErrors was not false when the
* widget was constructed.
*
* @param {String} title The title to be displayed on the error panel. This string is interpreted as text.
* @param {String} message A helpful, user-facing message to display prior to the detailed error information. This string is interpreted as HTML.
* @param {String} [error] The error to be displayed on the error panel. This string is formatted using {@link formatError} and then displayed as text.
*/
CesiumWidget.prototype.showErrorPanel = function(title, message, error) {
var element = this._element;
var overlay = document.createElement('div');
overlay.className = 'cesium-widget-errorPanel';
var content = document.createElement('div');
content.className = 'cesium-widget-errorPanel-content';
overlay.appendChild(content);
var errorHeader = document.createElement('div');
errorHeader.className = 'cesium-widget-errorPanel-header';
errorHeader.appendChild(document.createTextNode(title));
content.appendChild(errorHeader);
var errorPanelScroller = document.createElement('div');
errorPanelScroller.className = 'cesium-widget-errorPanel-scroll';
content.appendChild(errorPanelScroller);
function resizeCallback() {
errorPanelScroller.style.maxHeight = Math.max(Math.round(element.clientHeight * 0.9 - 100), 30) + 'px';
}
resizeCallback();
if (defined(window.addEventListener)) {
window.addEventListener('resize', resizeCallback, false);
}
if (defined(message)) {
var errorMessage = document.createElement('div');
errorMessage.className = 'cesium-widget-errorPanel-message';
errorMessage.innerHTML = '<p>' + message + '</p>';
errorPanelScroller.appendChild(errorMessage);
}
var errorDetails = '(no error details available)';
if (defined(error)) {
errorDetails = formatError(error);
}
var errorMessageDetails = document.createElement('div');
errorMessageDetails.className = 'cesium-widget-errorPanel-message';
errorMessageDetails.appendChild(document.createTextNode(errorDetails));
errorPanelScroller.appendChild(errorMessageDetails);
var buttonPanel = document.createElement('div');
buttonPanel.className = 'cesium-widget-errorPanel-buttonPanel';
content.appendChild(buttonPanel);
var okButton = document.createElement('button');
okButton.setAttribute('type', 'button');
okButton.className = 'cesium-button';
okButton.appendChild(document.createTextNode('OK'));
okButton.onclick = function() {
if (defined(resizeCallback) && defined(window.removeEventListener)) {
window.removeEventListener('resize', resizeCallback, false);
}
element.removeChild(overlay);
};
buttonPanel.appendChild(okButton);
element.appendChild(overlay);
//IE8 does not have a console object unless the dev tools are open.
if (typeof console !== 'undefined') {
console.error(title + '\n' + message + '\n' + errorDetails);
}
};
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
CesiumWidget.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
CesiumWidget.prototype.destroy = function() {
this._scene = this._scene && this._scene.destroy();
this._container.removeChild(this._element);
destroyObject(this);
};
/**
* Updates the canvas size, camera aspect ratio, and viewport size.
* This function is called automatically as needed unless
* <code>useDefaultRenderLoop</code> is set to false.
*/
CesiumWidget.prototype.resize = function() {
var canvas = this._canvas;
var width = canvas.clientWidth;
var height = canvas.clientHeight;
if (!this._forceResize && this._canvasWidth === width && this._canvasHeight === height) {
return;
}
this._forceResize = false;
configureCanvasSize(this);
configureCameraFrustum(this);
};
/**
* Renders the scene. This function is called automatically
* unless <code>useDefaultRenderLoop</code> is set to false;
*/
CesiumWidget.prototype.render = function() {
if (this._canRender) {
this._scene.initializeFrame();
var currentTime = this._clock.tick();
this._scene.render(currentTime);
} else {
this._clock.tick();
}
};
return CesiumWidget;
});
/*global define*/
define('Widgets/ClockViewModel',[
'../Core/Clock',
'../Core/defined',
'../Core/defineProperties',
'../Core/destroyObject',
'../Core/EventHelper',
'../Core/JulianDate',
'../ThirdParty/knockout'
], function(
Clock,
defined,
defineProperties,
destroyObject,
EventHelper,
JulianDate,
knockout) {
'use strict';
/**
* A view model which exposes a {@link Clock} for user interfaces.
* @alias ClockViewModel
* @constructor
*
* @param {Clock} [clock] The clock object wrapped by this view model, if undefined a new instance will be created.
*
* @see Clock
*/
function ClockViewModel(clock) {
if (!defined(clock)) {
clock = new Clock();
}
this._clock = clock;
this._eventHelper = new EventHelper();
this._eventHelper.add(clock.onTick, this.synchronize, this);
/**
* Gets the current system time.
* This property is observable.
* @type {JulianDate}
*/
this.systemTime = knockout.observable(JulianDate.now());
this.systemTime.equalityComparer = JulianDate.equals;
/**
* Gets or sets the start time of the clock.
* See {@link Clock#startTime}.
* This property is observable.
* @type {JulianDate}
*/
this.startTime = knockout.observable(clock.startTime);
this.startTime.equalityComparer = JulianDate.equals;
this.startTime.subscribe(function(value) {
clock.startTime = value;
this.synchronize();
}, this);
/**
* Gets or sets the stop time of the clock.
* See {@link Clock#stopTime}.
* This property is observable.
* @type {JulianDate}
*/
this.stopTime = knockout.observable(clock.stopTime);
this.stopTime.equalityComparer = JulianDate.equals;
this.stopTime.subscribe(function(value) {
clock.stopTime = value;
this.synchronize();
}, this);
/**
* Gets or sets the current time.
* See {@link Clock#currentTime}.
* This property is observable.
* @type {JulianDate}
*/
this.currentTime = knockout.observable(clock.currentTime);
this.currentTime.equalityComparer = JulianDate.equals;
this.currentTime.subscribe(function(value) {
clock.currentTime = value;
this.synchronize();
}, this);
/**
* Gets or sets the clock multiplier.
* See {@link Clock#multiplier}.
* This property is observable.
* @type {Number}
*/
this.multiplier = knockout.observable(clock.multiplier);
this.multiplier.subscribe(function(value) {
clock.multiplier = value;
this.synchronize();
}, this);
/**
* Gets or sets the clock step setting.
* See {@link Clock#clockStep}.
* This property is observable.
* @type {ClockStep}
*/
this.clockStep = knockout.observable(clock.clockStep);
this.clockStep.subscribe(function(value) {
clock.clockStep = value;
this.synchronize();
}, this);
/**
* Gets or sets the clock range setting.
* See {@link Clock#clockRange}.
* This property is observable.
* @type {ClockRange}
*/
this.clockRange = knockout.observable(clock.clockRange);
this.clockRange.subscribe(function(value) {
clock.clockRange = value;
this.synchronize();
}, this);
/**
* Gets or sets whether the clock can animate.
* See {@link Clock#canAnimate}.
* This property is observable.
* @type {Boolean}
*/
this.canAnimate = knockout.observable(clock.canAnimate);
this.canAnimate.subscribe(function(value) {
clock.canAnimate = value;
this.synchronize();
}, this);
/**
* Gets or sets whether the clock should animate.
* See {@link Clock#shouldAnimate}.
* This property is observable.
* @type {Boolean}
*/
this.shouldAnimate = knockout.observable(clock.shouldAnimate);
this.shouldAnimate.subscribe(function(value) {
clock.shouldAnimate = value;
this.synchronize();
}, this);
knockout.track(this, ['systemTime', 'startTime', 'stopTime', 'currentTime', 'multiplier', 'clockStep', 'clockRange', 'canAnimate', 'shouldAnimate']);
}
defineProperties(ClockViewModel.prototype, {
/**
* Gets the underlying Clock.
* @memberof ClockViewModel.prototype
* @type {Clock}
*/
clock : {
get : function() {
return this._clock;
}
}
});
/**
* Updates the view model with the contents of the underlying clock.
* Can be called to force an update of the viewModel if the underlying
* clock has changed and <code>Clock.tick</code> has not yet been called.
*/
ClockViewModel.prototype.synchronize = function() {
var clock = this._clock;
this.systemTime = JulianDate.now();
this.startTime = clock.startTime;
this.stopTime = clock.stopTime;
this.currentTime = clock.currentTime;
this.multiplier = clock.multiplier;
this.clockStep = clock.clockStep;
this.clockRange = clock.clockRange;
this.canAnimate = clock.canAnimate;
this.shouldAnimate = clock.shouldAnimate;
};
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
ClockViewModel.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the view model. Should be called to
* properly clean up the view model when it is no longer needed.
*/
ClockViewModel.prototype.destroy = function() {
this._eventHelper.removeAll();
destroyObject(this);
};
return ClockViewModel;
});
/*global define*/
define('Widgets/Command',[
'../Core/DeveloperError'
], function(
DeveloperError) {
'use strict';
/**
* A Command is a function with an extra <code>canExecute</code> observable property to determine
* whether the command can be executed. When executed, a Command function will check the
* value of <code>canExecute</code> and throw if false.
*
* This type describes an interface and is not intended to be instantiated directly.
* See {@link createCommand} to create a command from a function.
*
* @alias Command
* @constructor
*/
function Command() {
/**
* Gets whether this command can currently be executed. This property is observable.
* @type {Boolean}
* @default undefined
*/
this.canExecute = undefined;
/**
* Gets an event which is raised before the command executes, the event
* is raised with an object containing two properties: a <code>cancel</code> property,
* which if set to false by the listener will prevent the command from being executed, and
* an <code>args</code> property, which is the array of arguments being passed to the command.
* @type {Event}
* @default undefined
*/
this.beforeExecute = undefined;
/**
* Gets an event which is raised after the command executes, the event
* is raised with the return value of the command as its only parameter.
* @type {Event}
* @default undefined
*/
this.afterExecute = undefined;
DeveloperError.throwInstantiationError();
}
return Command;
});
/*global define*/
define('Widgets/FullscreenButton/FullscreenButtonViewModel',[
'../../Core/defaultValue',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/Fullscreen',
'../../ThirdParty/knockout',
'../createCommand',
'../getElement'
], function(
defaultValue,
defineProperties,
destroyObject,
DeveloperError,
Fullscreen,
knockout,
createCommand,
getElement) {
'use strict';
/**
* The view model for {@link FullscreenButton}.
* @alias FullscreenButtonViewModel
* @constructor
*
* @param {Element|String} [fullscreenElement=document.body] The element or id to be placed into fullscreen mode.
*/
function FullscreenButtonViewModel(fullscreenElement) {
var that = this;
var tmpIsFullscreen = knockout.observable(Fullscreen.fullscreen);
var tmpIsEnabled = knockout.observable(Fullscreen.enabled);
/**
* Gets whether or not fullscreen mode is active. This property is observable.
*
* @type {Boolean}
*/
this.isFullscreen = undefined;
knockout.defineProperty(this, 'isFullscreen', {
get : function() {
return tmpIsFullscreen();
}
});
/**
* Gets or sets whether or not fullscreen functionality should be enabled. This property is observable.
*
* @type {Boolean}
* @see Fullscreen.enabled
*/
this.isFullscreenEnabled = undefined;
knockout.defineProperty(this, 'isFullscreenEnabled', {
get : function() {
return tmpIsEnabled();
},
set : function(value) {
tmpIsEnabled(value && Fullscreen.enabled);
}
});
/**
* Gets the tooltip. This property is observable.
*
* @type {String}
*/
this.tooltip = undefined;
knockout.defineProperty(this, 'tooltip', function() {
if (!this.isFullscreenEnabled) {
return 'Full screen unavailable';
}
return tmpIsFullscreen() ? 'Exit full screen' : 'Full screen';
});
this._command = createCommand(function() {
if (Fullscreen.fullscreen) {
Fullscreen.exitFullscreen();
} else {
Fullscreen.requestFullscreen(that._fullscreenElement);
}
}, knockout.getObservable(this, 'isFullscreenEnabled'));
this._fullscreenElement = defaultValue(getElement(fullscreenElement), document.body);
this._callback = function() {
tmpIsFullscreen(Fullscreen.fullscreen);
};
document.addEventListener(Fullscreen.changeEventName, this._callback);
}
defineProperties(FullscreenButtonViewModel.prototype, {
/**
* Gets or sets the HTML element to place into fullscreen mode when the
* corresponding button is pressed.
* @memberof FullscreenButtonViewModel.prototype
*
* @type {Element}
*/
fullscreenElement : {
//TODO:@exception {DeveloperError} value must be a valid HTML Element.
get : function() {
return this._fullscreenElement;
},
set : function(value) {
if (!(value instanceof Element)) {
throw new DeveloperError('value must be a valid Element.');
}
this._fullscreenElement = value;
}
},
/**
* Gets the Command to toggle fullscreen mode.
* @memberof FullscreenButtonViewModel.prototype
*
* @type {Command}
*/
command : {
get : function() {
return this._command;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
FullscreenButtonViewModel.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the view model. Should be called to
* properly clean up the view model when it is no longer needed.
*/
FullscreenButtonViewModel.prototype.destroy = function() {
document.removeEventListener(Fullscreen.changeEventName, this._callback);
destroyObject(this);
};
return FullscreenButtonViewModel;
});
/*global define*/
define('Widgets/FullscreenButton/FullscreenButton',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../getElement',
'./FullscreenButtonViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
knockout,
getElement,
FullscreenButtonViewModel) {
'use strict';
var enterFullScreenPath = 'M 83.96875 17.5625 L 83.96875 17.59375 L 76.65625 24.875 L 97.09375 24.96875 L 76.09375 45.96875 L 81.9375 51.8125 L 102.78125 30.9375 L 102.875 51.15625 L 110.15625 43.875 L 110.1875 17.59375 L 83.96875 17.5625 z M 44.125 17.59375 L 17.90625 17.625 L 17.9375 43.90625 L 25.21875 51.1875 L 25.3125 30.96875 L 46.15625 51.8125 L 52 45.96875 L 31 25 L 51.4375 24.90625 L 44.125 17.59375 z M 46.0625 76.03125 L 25.1875 96.875 L 25.09375 76.65625 L 17.8125 83.9375 L 17.8125 110.21875 L 44 110.25 L 51.3125 102.9375 L 30.90625 102.84375 L 51.875 81.875 L 46.0625 76.03125 z M 82 76.15625 L 76.15625 82 L 97.15625 103 L 76.71875 103.0625 L 84.03125 110.375 L 110.25 110.34375 L 110.21875 84.0625 L 102.9375 76.8125 L 102.84375 97 L 82 76.15625 z';
var exitFullScreenPath = 'M 104.34375 17.5625 L 83.5 38.4375 L 83.40625 18.21875 L 76.125 25.5 L 76.09375 51.78125 L 102.3125 51.8125 L 102.3125 51.78125 L 109.625 44.5 L 89.1875 44.40625 L 110.1875 23.40625 L 104.34375 17.5625 z M 23.75 17.59375 L 17.90625 23.4375 L 38.90625 44.4375 L 18.5 44.53125 L 25.78125 51.8125 L 52 51.78125 L 51.96875 25.53125 L 44.6875 18.25 L 44.625 38.46875 L 23.75 17.59375 z M 25.6875 76.03125 L 18.375 83.3125 L 38.78125 83.40625 L 17.8125 104.40625 L 23.625 110.25 L 44.5 89.375 L 44.59375 109.59375 L 51.875 102.3125 L 51.875 76.0625 L 25.6875 76.03125 z M 102.375 76.15625 L 76.15625 76.1875 L 76.1875 102.4375 L 83.46875 109.71875 L 83.5625 89.53125 L 104.40625 110.375 L 110.25 104.53125 L 89.25 83.53125 L 109.6875 83.46875 L 102.375 76.15625 z';
/**
* A single button widget for toggling fullscreen mode.
*
* @alias FullscreenButton
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Element|String} [fullscreenElement=document.body] The element or id to be placed into fullscreen mode.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*
* @see Fullscreen
*/
function FullscreenButton(container, fullscreenElement) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
container = getElement(container);
var viewModel = new FullscreenButtonViewModel(fullscreenElement);
viewModel._exitFullScreenPath = exitFullScreenPath;
viewModel._enterFullScreenPath = enterFullScreenPath;
var element = document.createElement('button');
element.type = 'button';
element.className = 'cesium-button cesium-fullscreenButton';
element.setAttribute('data-bind', '\
attr: { title: tooltip },\
click: command,\
enable: isFullscreenEnabled,\
cesiumSvgPath: { path: isFullscreen ? _exitFullScreenPath : _enterFullScreenPath, width: 128, height: 128 }');
container.appendChild(element);
knockout.applyBindings(viewModel, element);
this._container = container;
this._viewModel = viewModel;
this._element = element;
}
defineProperties(FullscreenButton.prototype, {
/**
* Gets the parent container.
* @memberof FullscreenButton.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof FullscreenButton.prototype
*
* @type {FullscreenButtonViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
FullscreenButton.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
FullscreenButton.prototype.destroy = function() {
this._viewModel.destroy();
knockout.cleanNode(this._element);
this._container.removeChild(this._element);
return destroyObject(this);
};
return FullscreenButton;
});
/*global define*/
define('Widgets/Geocoder/GeocoderViewModel',[
'../../Core/BingMapsApi',
'../../Core/Cartesian3',
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../../Core/Event',
'../../Core/loadJsonp',
'../../Core/Matrix4',
'../../Core/Rectangle',
'../../ThirdParty/knockout',
'../../ThirdParty/when',
'../createCommand'
], function(
BingMapsApi,
Cartesian3,
defaultValue,
defined,
defineProperties,
DeveloperError,
Event,
loadJsonp,
Matrix4,
Rectangle,
knockout,
when,
createCommand) {
'use strict';
/**
* The view model for the {@link Geocoder} widget.
* @alias GeocoderViewModel
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Scene} options.scene The Scene instance to use.
* @param {String} [options.url='https://dev.virtualearth.net'] The base URL of the Bing Maps API.
* @param {String} [options.key] The Bing Maps key for your application, which can be
* created at {@link https://www.bingmapsportal.com}.
* If this parameter is not provided, {@link BingMapsApi.defaultKey} is used.
* If {@link BingMapsApi.defaultKey} is undefined as well, a message is
* written to the console reminding you that you must create and supply a Bing Maps
* key as soon as possible. Please do not deploy an application that uses
* this widget without creating a separate key for your application.
* @param {Number} [options.flightDuration] The duration of the camera flight to an entered location, in seconds.
*/
function GeocoderViewModel(options) {
if (!defined(options) || !defined(options.scene)) {
throw new DeveloperError('options.scene is required.');
}
this._url = defaultValue(options.url, 'https://dev.virtualearth.net/');
if (this._url.length > 0 && this._url[this._url.length - 1] !== '/') {
this._url += '/';
}
this._key = BingMapsApi.getKey(options.key);
var errorCredit = BingMapsApi.getErrorCredit(options.key);
if (defined(errorCredit)) {
options.scene._frameState.creditDisplay.addDefaultCredit(errorCredit);
}
this._scene = options.scene;
this._flightDuration = options.flightDuration;
this._searchText = '';
this._isSearchInProgress = false;
this._geocodeInProgress = undefined;
this._complete = new Event();
var that = this;
this._searchCommand = createCommand(function() {
if (that.isSearchInProgress) {
cancelGeocode(that);
} else {
geocode(that);
}
});
/**
* Gets or sets a value indicating if this instance should always show its text input field.
*
* @type {Boolean}
* @default false
*/
this.keepExpanded = false;
knockout.track(this, ['_searchText', '_isSearchInProgress', 'keepExpanded']);
/**
* Gets a value indicating whether a search is currently in progress. This property is observable.
*
* @type {Boolean}
*/
this.isSearchInProgress = undefined;
knockout.defineProperty(this, 'isSearchInProgress', {
get : function() {
return this._isSearchInProgress;
}
});
/**
* Gets or sets the text to search for. The text can be an address, or longitude, latitude,
* and optional height, where longitude and latitude are in degrees and height is in meters.
*
* @type {String}
*/
this.searchText = undefined;
knockout.defineProperty(this, 'searchText', {
get : function() {
if (this.isSearchInProgress) {
return 'Searching...';
}
return this._searchText;
},
set : function(value) {
if (typeof value !== 'string') {
throw new DeveloperError('value must be a valid string.');
}
this._searchText = value;
}
});
/**
* Gets or sets the the duration of the camera flight in seconds.
* A value of zero causes the camera to instantly switch to the geocoding location.
* The duration will be computed based on the distance when undefined.
*
* @type {Number|undefined}
* @default undefined
*/
this.flightDuration = undefined;
knockout.defineProperty(this, 'flightDuration', {
get : function() {
return this._flightDuration;
},
set : function(value) {
if (defined(value) && value < 0) {
throw new DeveloperError('value must be positive.');
}
this._flightDuration = value;
}
});
}
defineProperties(GeocoderViewModel.prototype, {
/**
* Gets the Bing maps url.
* @memberof GeocoderViewModel.prototype
*
* @type {String}
*/
url : {
get : function() {
return this._url;
}
},
/**
* Gets the Bing maps key.
* @memberof GeocoderViewModel.prototype
*
* @type {String}
*/
key : {
get : function() {
return this._key;
}
},
/**
* Gets the event triggered on flight completion.
* @memberof GeocoderViewModel.prototype
*
* @type {Event}
*/
complete : {
get : function() {
return this._complete;
}
},
/**
* Gets the scene to control.
* @memberof GeocoderViewModel.prototype
*
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
},
/**
* Gets the Command that is executed when the button is clicked.
* @memberof GeocoderViewModel.prototype
*
* @type {Command}
*/
search : {
get : function() {
return this._searchCommand;
}
}
});
function updateCamera(viewModel, destination) {
viewModel._scene.camera.flyTo({
destination : destination,
complete: function() {
viewModel._complete.raiseEvent();
},
duration : viewModel._flightDuration,
endTransform : Matrix4.IDENTITY
});
}
function geocode(viewModel) {
var query = viewModel.searchText;
if (/^\s*$/.test(query)) {
//whitespace string
return;
}
// If the user entered (longitude, latitude, [height]) in degrees/meters,
// fly without calling the geocoder.
var splitQuery = query.match(/[^\s,\n]+/g);
if ((splitQuery.length === 2) || (splitQuery.length === 3)) {
var longitude = +splitQuery[0];
var latitude = +splitQuery[1];
var height = (splitQuery.length === 3) ? +splitQuery[2] : 300.0;
if (!isNaN(longitude) && !isNaN(latitude) && !isNaN(height)) {
updateCamera(viewModel, Cartesian3.fromDegrees(longitude, latitude, height));
return;
}
}
viewModel._isSearchInProgress = true;
var promise = loadJsonp(viewModel._url + 'REST/v1/Locations', {
parameters : {
query : query,
key : viewModel._key
},
callbackParameterName : 'jsonp'
});
var geocodeInProgress = viewModel._geocodeInProgress = when(promise, function(result) {
if (geocodeInProgress.cancel) {
return;
}
viewModel._isSearchInProgress = false;
if (result.resourceSets.length === 0) {
viewModel.searchText = viewModel._searchText + ' (not found)';
return;
}
var resourceSet = result.resourceSets[0];
if (resourceSet.resources.length === 0) {
viewModel.searchText = viewModel._searchText + ' (not found)';
return;
}
var resource = resourceSet.resources[0];
viewModel._searchText = resource.name;
var bbox = resource.bbox;
var south = bbox[0];
var west = bbox[1];
var north = bbox[2];
var east = bbox[3];
updateCamera(viewModel, Rectangle.fromDegrees(west, south, east, north));
}, function() {
if (geocodeInProgress.cancel) {
return;
}
viewModel._isSearchInProgress = false;
viewModel.searchText = viewModel._searchText + ' (error)';
});
}
function cancelGeocode(viewModel) {
viewModel._isSearchInProgress = false;
if (defined(viewModel._geocodeInProgress)) {
viewModel._geocodeInProgress.cancel = true;
viewModel._geocodeInProgress = undefined;
}
}
return GeocoderViewModel;
});
/*global define*/
define('Widgets/Geocoder/Geocoder',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/FeatureDetection',
'../../ThirdParty/knockout',
'../getElement',
'./GeocoderViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
FeatureDetection,
knockout,
getElement,
GeocoderViewModel) {
'use strict';
var startSearchPath = 'M29.772,26.433l-7.126-7.126c0.96-1.583,1.523-3.435,1.524-5.421C24.169,8.093,19.478,3.401,13.688,3.399C7.897,3.401,3.204,8.093,3.204,13.885c0,5.789,4.693,10.481,10.484,10.481c1.987,0,3.839-0.563,5.422-1.523l7.128,7.127L29.772,26.433zM7.203,13.885c0.006-3.582,2.903-6.478,6.484-6.486c3.579,0.008,6.478,2.904,6.484,6.486c-0.007,3.58-2.905,6.476-6.484,6.484C10.106,20.361,7.209,17.465,7.203,13.885z';
var stopSearchPath = 'M24.778,21.419 19.276,15.917 24.777,10.415 21.949,7.585 16.447,13.087 10.945,7.585 8.117,10.415 13.618,15.917 8.116,21.419 10.946,24.248 16.447,18.746 21.948,24.248z';
/**
* A widget for finding addresses and landmarks, and flying the camera to them. Geocoding is
* performed using the {@link http://msdn.microsoft.com/en-us/library/ff701715.aspx|Bing Maps Locations API}.
*
* @alias Geocoder
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Element|String} options.container The DOM element or ID that will contain the widget.
* @param {Scene} options.scene The Scene instance to use.
* @param {String} [options.url='https://dev.virtualearth.net'] The base URL of the Bing Maps API.
* @param {String} [options.key] The Bing Maps key for your application, which can be
* created at {@link https://www.bingmapsportal.com}.
* If this parameter is not provided, {@link BingMapsApi.defaultKey} is used.
* If {@link BingMapsApi.defaultKey} is undefined as well, a message is
* written to the console reminding you that you must create and supply a Bing Maps
* key as soon as possible. Please do not deploy an application that uses
* this widget without creating a separate key for your application.
* @param {Number} [options.flightDuration=1.5] The duration of the camera flight to an entered location, in seconds.
*/
function Geocoder(options) {
if (!defined(options) || !defined(options.container)) {
throw new DeveloperError('options.container is required.');
}
if (!defined(options.scene)) {
throw new DeveloperError('options.scene is required.');
}
var container = getElement(options.container);
var viewModel = new GeocoderViewModel(options);
viewModel._startSearchPath = startSearchPath;
viewModel._stopSearchPath = stopSearchPath;
var form = document.createElement('form');
form.setAttribute('data-bind', 'submit: search');
var textBox = document.createElement('input');
textBox.type = 'search';
textBox.className = 'cesium-geocoder-input';
textBox.setAttribute('placeholder', 'Enter an address or landmark...');
textBox.setAttribute('data-bind', '\
value: searchText,\
valueUpdate: "afterkeydown",\
disable: isSearchInProgress,\
css: { "cesium-geocoder-input-wide" : keepExpanded || searchText.length > 0 }');
this._onTextBoxFocus = function() {
// as of 2016-10-19, setTimeout is required to ensure that the
// text is focused on Safari 10
setTimeout(function() {
textBox.select();
}, 0);
};
textBox.addEventListener('focus', this._onTextBoxFocus, false);
form.appendChild(textBox);
this._textBox = textBox;
var searchButton = document.createElement('span');
searchButton.className = 'cesium-geocoder-searchButton';
searchButton.setAttribute('data-bind', '\
click: search,\
cesiumSvgPath: { path: isSearchInProgress ? _stopSearchPath : _startSearchPath, width: 32, height: 32 }');
form.appendChild(searchButton);
container.appendChild(form);
knockout.applyBindings(viewModel, form);
this._container = container;
this._viewModel = viewModel;
this._form = form;
this._onInputBegin = function(e) {
if (!container.contains(e.target)) {
textBox.blur();
}
};
this._onInputEnd = function(e) {
if (container.contains(e.target)) {
textBox.focus();
}
};
//We subscribe to both begin and end events in order to give the text box
//focus no matter where on the widget is clicked.
if (FeatureDetection.supportsPointerEvents()) {
document.addEventListener('pointerdown', this._onInputBegin, true);
document.addEventListener('pointerup', this._onInputEnd, true);
document.addEventListener('pointercancel', this._onInputEnd, true);
} else {
document.addEventListener('mousedown', this._onInputBegin, true);
document.addEventListener('mouseup', this._onInputEnd, true);
document.addEventListener('touchstart', this._onInputBegin, true);
document.addEventListener('touchend', this._onInputEnd, true);
document.addEventListener('touchcancel', this._onInputEnd, true);
}
}
defineProperties(Geocoder.prototype, {
/**
* Gets the parent container.
* @memberof Geocoder.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof Geocoder.prototype
*
* @type {GeocoderViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
Geocoder.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
Geocoder.prototype.destroy = function() {
if (FeatureDetection.supportsPointerEvents()) {
document.removeEventListener('pointerdown', this._onInputBegin, true);
document.removeEventListener('pointerup', this._onInputEnd, true);
} else {
document.removeEventListener('mousedown', this._onInputBegin, true);
document.removeEventListener('mouseup', this._onInputEnd, true);
document.removeEventListener('touchstart', this._onInputBegin, true);
document.removeEventListener('touchend', this._onInputEnd, true);
}
knockout.cleanNode(this._form);
this._container.removeChild(this._form);
this._textBox.removeEventListener('focus', this._onTextBoxFocus, false);
return destroyObject(this);
};
return Geocoder;
});
/*global define*/
define('Widgets/HomeButton/HomeButtonViewModel',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../createCommand'
], function(
defined,
defineProperties,
DeveloperError,
knockout,
createCommand) {
'use strict';
/**
* The view model for {@link HomeButton}.
* @alias HomeButtonViewModel
* @constructor
*
* @param {Scene} scene The scene instance to use.
* @param {Number} [duration] The duration of the camera flight in seconds.
*/
function HomeButtonViewModel(scene, duration) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
this._scene = scene;
this._duration = duration;
var that = this;
this._command = createCommand(function() {
that._scene.camera.flyHome(that._duration);
});
/**
* Gets or sets the tooltip. This property is observable.
*
* @type {String}
*/
this.tooltip = 'View Home';
knockout.track(this, ['tooltip']);
}
defineProperties(HomeButtonViewModel.prototype, {
/**
* Gets the scene to control.
* @memberof HomeButtonViewModel.prototype
*
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
},
/**
* Gets the Command that is executed when the button is clicked.
* @memberof HomeButtonViewModel.prototype
*
* @type {Command}
*/
command : {
get : function() {
return this._command;
}
},
/**
* Gets or sets the the duration of the camera flight in seconds.
* A value of zero causes the camera to instantly switch to home view.
* The duration will be computed based on the distance when undefined.
* @memberof HomeButtonViewModel.prototype
*
* @type {Number|undefined}
*/
duration : {
get : function() {
return this._duration;
},
set : function(value) {
if (defined(value) && value < 0) {
throw new DeveloperError('value must be positive.');
}
this._duration = value;
}
}
});
return HomeButtonViewModel;
});
/*global define*/
define('Widgets/HomeButton/HomeButton',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../getElement',
'./HomeButtonViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
knockout,
getElement,
HomeButtonViewModel) {
'use strict';
/**
* A single button widget for returning to the default camera view of the current scene.
*
* @alias HomeButton
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Scene} scene The Scene instance to use.
* @param {Number} [duration] The time, in seconds, it takes to complete the camera flight home.
*/
function HomeButton(container, scene, duration) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
container = getElement(container);
var viewModel = new HomeButtonViewModel(scene, duration);
viewModel._svgPath = 'M14,4l-10,8.75h20l-4.25-3.7188v-4.6562h-2.812v2.1875l-2.938-2.5625zm-7.0938,9.906v10.094h14.094v-10.094h-14.094zm2.1876,2.313h3.3122v4.25h-3.3122v-4.25zm5.8442,1.281h3.406v6.438h-3.406v-6.438z';
var element = document.createElement('button');
element.type = 'button';
element.className = 'cesium-button cesium-toolbar-button cesium-home-button';
element.setAttribute('data-bind', '\
attr: { title: tooltip },\
click: command,\
cesiumSvgPath: { path: _svgPath, width: 28, height: 28 }');
container.appendChild(element);
knockout.applyBindings(viewModel, element);
this._container = container;
this._viewModel = viewModel;
this._element = element;
}
defineProperties(HomeButton.prototype, {
/**
* Gets the parent container.
* @memberof HomeButton.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof HomeButton.prototype
*
* @type {HomeButtonViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
HomeButton.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
HomeButton.prototype.destroy = function() {
knockout.cleanNode(this._element);
this._container.removeChild(this._element);
return destroyObject(this);
};
return HomeButton;
});
/*global define*/
define('Widgets/InfoBox/InfoBoxViewModel',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/Event',
'../../ThirdParty/knockout'
], function(
defined,
defineProperties,
Event,
knockout) {
'use strict';
var cameraEnabledPath = 'M 13.84375 7.03125 C 11.412798 7.03125 9.46875 8.975298 9.46875 11.40625 L 9.46875 11.59375 L 2.53125 7.21875 L 2.53125 24.0625 L 9.46875 19.6875 C 9.4853444 22.104033 11.423165 24.0625 13.84375 24.0625 L 25.875 24.0625 C 28.305952 24.0625 30.28125 22.087202 30.28125 19.65625 L 30.28125 11.40625 C 30.28125 8.975298 28.305952 7.03125 25.875 7.03125 L 13.84375 7.03125 z';
var cameraDisabledPath = 'M 27.34375 1.65625 L 5.28125 27.9375 L 8.09375 30.3125 L 30.15625 4.03125 L 27.34375 1.65625 z M 13.84375 7.03125 C 11.412798 7.03125 9.46875 8.975298 9.46875 11.40625 L 9.46875 11.59375 L 2.53125 7.21875 L 2.53125 24.0625 L 9.46875 19.6875 C 9.4724893 20.232036 9.5676108 20.7379 9.75 21.21875 L 21.65625 7.03125 L 13.84375 7.03125 z M 28.21875 7.71875 L 14.53125 24.0625 L 25.875 24.0625 C 28.305952 24.0625 30.28125 22.087202 30.28125 19.65625 L 30.28125 11.40625 C 30.28125 9.8371439 29.456025 8.4902779 28.21875 7.71875 z';
/**
* The view model for {@link InfoBox}.
* @alias InfoBoxViewModel
* @constructor
*/
function InfoBoxViewModel() {
this._cameraClicked = new Event();
this._closeClicked = new Event();
/**
* Gets or sets the maximum height of the info box in pixels. This property is observable.
* @type {Number}
*/
this.maxHeight = 500;
/**
* Gets or sets whether the camera tracking icon is enabled.
* @type {Boolean}
*/
this.enableCamera = false;
/**
* Gets or sets the status of current camera tracking of the selected object.
* @type {Boolean}
*/
this.isCameraTracking = false;
/**
* Gets or sets the visibility of the info box.
* @type {Boolean}
*/
this.showInfo = false;
/**
* Gets or sets the title text in the info box.
* @type {String}
*/
this.titleText = '';
/**
* Gets or sets the description HTML for the info box.
* @type {String}
*/
this.description = '';
knockout.track(this, ['showInfo', 'titleText', 'description', 'maxHeight', 'enableCamera', 'isCameraTracking']);
this._loadingIndicatorHtml = '<div class="cesium-infoBox-loadingContainer"><span class="cesium-infoBox-loading"></span></div>';
/**
* Gets the SVG path of the camera icon, which can change to be "crossed out" or not.
* @type {String}
*/
this.cameraIconPath = undefined;
knockout.defineProperty(this, 'cameraIconPath', {
get : function() {
return (!this.enableCamera || this.isCameraTracking) ? cameraDisabledPath : cameraEnabledPath;
}
});
knockout.defineProperty(this, '_bodyless', {
get : function() {
return !defined(this.description) || this.description.length === 0;
}
});
}
/**
* Gets the maximum height of sections within the info box, minus an offset, in CSS-ready form.
* @param {Number} offset The offset in pixels.
* @returns {String}
*/
InfoBoxViewModel.prototype.maxHeightOffset = function(offset) {
return (this.maxHeight - offset) + 'px';
};
defineProperties(InfoBoxViewModel.prototype, {
/**
* Gets an {@link Event} that is fired when the user clicks the camera icon.
* @memberof InfoBoxViewModel.prototype
* @type {Event}
*/
cameraClicked : {
get : function() {
return this._cameraClicked;
}
},
/**
* Gets an {@link Event} that is fired when the user closes the info box.
* @memberof InfoBoxViewModel.prototype
* @type {Event}
*/
closeClicked : {
get : function() {
return this._closeClicked;
}
}
});
return InfoBoxViewModel;
});
/*global define*/
define('Widgets/InfoBox/InfoBox',[
'../../Core/buildModuleUrl',
'../../Core/Color',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../getElement',
'../subscribeAndEvaluate',
'./InfoBoxViewModel'
], function(
buildModuleUrl,
Color,
defined,
defineProperties,
destroyObject,
DeveloperError,
knockout,
getElement,
subscribeAndEvaluate,
InfoBoxViewModel) {
'use strict';
/**
* A widget for displaying information or a description.
*
* @alias InfoBox
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*/
function InfoBox(container) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
container = getElement(container);
var infoElement = document.createElement('div');
infoElement.className = 'cesium-infoBox';
infoElement.setAttribute('data-bind', '\
css: { "cesium-infoBox-visible" : showInfo, "cesium-infoBox-bodyless" : _bodyless }');
container.appendChild(infoElement);
var titleElement = document.createElement('div');
titleElement.className = 'cesium-infoBox-title';
titleElement.setAttribute('data-bind', 'text: titleText');
infoElement.appendChild(titleElement);
var cameraElement = document.createElement('button');
cameraElement.type = 'button';
cameraElement.className = 'cesium-button cesium-infoBox-camera';
cameraElement.setAttribute('data-bind', '\
attr: { title: "Focus camera on object" },\
click: function () { cameraClicked.raiseEvent(this); },\
enable: enableCamera,\
cesiumSvgPath: { path: cameraIconPath, width: 32, height: 32 }');
infoElement.appendChild(cameraElement);
var closeElement = document.createElement('button');
closeElement.type = 'button';
closeElement.className = 'cesium-infoBox-close';
closeElement.setAttribute('data-bind', '\
click: function () { closeClicked.raiseEvent(this); }');
closeElement.innerHTML = '×';
infoElement.appendChild(closeElement);
var frame = document.createElement('iframe');
frame.className = 'cesium-infoBox-iframe';
frame.setAttribute('sandbox', 'allow-same-origin allow-popups allow-forms'); //allow-pointer-lock allow-scripts allow-top-navigation
frame.setAttribute('data-bind', 'style : { maxHeight : maxHeightOffset(40) }');
frame.setAttribute('allowfullscreen', true);
infoElement.appendChild(frame);
var viewModel = new InfoBoxViewModel();
knockout.applyBindings(viewModel, infoElement);
this._container = container;
this._element = infoElement;
this._frame = frame;
this._viewModel = viewModel;
this._descriptionSubscription = undefined;
var that = this;
//We can't actually add anything into the frame until the load event is fired
frame.addEventListener('load', function() {
var frameDocument = frame.contentDocument;
//We inject default css into the content iframe,
//end users can remove it or add their own via the exposed frame property.
var cssLink = frameDocument.createElement("link");
cssLink.href = buildModuleUrl('Widgets/InfoBox/InfoBoxDescription.css');
cssLink.rel = "stylesheet";
cssLink.type = "text/css";
//div to use for description content.
var frameContent = frameDocument.createElement("div");
frameContent.className = 'cesium-infoBox-description';
frameDocument.head.appendChild(cssLink);
frameDocument.body.appendChild(frameContent);
//We manually subscribe to the description event rather than through a binding for two reasons.
//1. It's an easy way to ensure order of operation so that we can adjust the height.
//2. Knockout does not bind to elements inside of an iFrame, so we would have to apply a second binding
// model anyway.
that._descriptionSubscription = subscribeAndEvaluate(viewModel, 'description', function(value) {
// Set the frame to small height, force vertical scroll bar to appear, and text to wrap accordingly.
frame.style.height = '5px';
frameContent.innerHTML = value;
//If the snippet is a single element, then use its background
//color for the body of the InfoBox. This makes the padding match
//the content and produces much nicer results.
var background = null;
var firstElementChild = frameContent.firstElementChild;
if (firstElementChild !== null && frameContent.childNodes.length === 1) {
var style = window.getComputedStyle(firstElementChild);
if (style !== null) {
var backgroundColor = style['background-color'];
var color = Color.fromCssColorString(backgroundColor);
if (defined(color) && color.alpha !== 0) {
background = style['background-color'];
}
}
}
infoElement.style['background-color'] = background;
// Measure and set the new custom height, based on text wrapped above.
var height = frameContent.getBoundingClientRect().height;
frame.style.height = height + 'px';
});
});
//Chrome does not send the load event unless we explicitly set a src
frame.setAttribute('src', 'about:blank');
}
defineProperties(InfoBox.prototype, {
/**
* Gets the parent container.
* @memberof InfoBox.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof InfoBox.prototype
*
* @type {InfoBoxViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
},
/**
* Gets the iframe used to display the description.
* @memberof InfoBox.prototype
*
* @type {HTMLIFrameElement}
*/
frame : {
get : function() {
return this._frame;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
InfoBox.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
InfoBox.prototype.destroy = function() {
var container = this._container;
knockout.cleanNode(this._element);
container.removeChild(this._element);
if (defined(this._descriptionSubscription)) {
this._descriptionSubscription.dispose();
}
return destroyObject(this);
};
return InfoBox;
});
/*global define*/
define('Widgets/NavigationHelpButton/NavigationHelpButtonViewModel',[
'../../Core/defineProperties',
'../../ThirdParty/knockout',
'../createCommand'
], function(
defineProperties,
knockout,
createCommand) {
'use strict';
/**
* The view model for {@link NavigationHelpButton}.
* @alias NavigationHelpButtonViewModel
* @constructor
*/
function NavigationHelpButtonViewModel() {
/**
* Gets or sets whether the instructions are currently shown. This property is observable.
* @type {Boolean}
* @default false
*/
this.showInstructions = false;
var that = this;
this._command = createCommand(function() {
that.showInstructions = !that.showInstructions;
});
this._showClick = createCommand(function() {
that._touch = false;
});
this._showTouch = createCommand(function() {
that._touch = true;
});
this._touch = false;
/**
* Gets or sets the tooltip. This property is observable.
*
* @type {String}
*/
this.tooltip = 'Navigation Instructions';
knockout.track(this, ['tooltip', 'showInstructions', '_touch']);
}
defineProperties(NavigationHelpButtonViewModel.prototype, {
/**
* Gets the Command that is executed when the button is clicked.
* @memberof NavigationHelpButtonViewModel.prototype
*
* @type {Command}
*/
command : {
get : function() {
return this._command;
}
},
/**
* Gets the Command that is executed when the mouse instructions should be shown.
* @memberof NavigationHelpButtonViewModel.prototype
*
* @type {Command}
*/
showClick : {
get : function() {
return this._showClick;
}
},
/**
* Gets the Command that is executed when the touch instructions should be shown.
* @memberof NavigationHelpButtonViewModel.prototype
*
* @type {Command}
*/
showTouch : {
get: function() {
return this._showTouch;
}
}
});
return NavigationHelpButtonViewModel;
});
/*global define*/
define('Widgets/NavigationHelpButton/NavigationHelpButton',[
'../../Core/buildModuleUrl',
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/FeatureDetection',
'../../ThirdParty/knockout',
'../getElement',
'./NavigationHelpButtonViewModel'
], function(
buildModuleUrl,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
FeatureDetection,
knockout,
getElement,
NavigationHelpButtonViewModel) {
'use strict';
/**
* <p>The NavigationHelpButton is a single button widget for displaying instructions for
* navigating the globe with the mouse.</p><p style="clear: both;"></p><br/>
*
* @alias NavigationHelpButton
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Element|String} options.container The DOM element or ID that will contain the widget.
* @param {Boolean} [options.instructionsInitiallyVisible=false] True if the navigation instructions should initially be visible; otherwise, false.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*
* @example
* // In HTML head, include a link to the NavigationHelpButton.css stylesheet,
* // and in the body, include: <div id="navigationHelpButtonContainer"></div>
*
* var navigationHelpButton = new Cesium.NavigationHelpButton({
* container : 'navigationHelpButtonContainer'
* });
*/
function NavigationHelpButton(options) {
if (!defined(options) || !defined(options.container)) {
throw new DeveloperError('options.container is required.');
}
var container = getElement(options.container);
var viewModel = new NavigationHelpButtonViewModel();
var showInsructionsDefault = defaultValue(options.instructionsInitiallyVisible, false);
viewModel.showInstructions = showInsructionsDefault;
viewModel._svgPath = 'M16,1.466C7.973,1.466,1.466,7.973,1.466,16c0,8.027,6.507,14.534,14.534,14.534c8.027,0,14.534-6.507,14.534-14.534C30.534,7.973,24.027,1.466,16,1.466z M17.328,24.371h-2.707v-2.596h2.707V24.371zM17.328,19.003v0.858h-2.707v-1.057c0-3.19,3.63-3.696,3.63-5.963c0-1.034-0.924-1.826-2.134-1.826c-1.254,0-2.354,0.924-2.354,0.924l-1.541-1.915c0,0,1.519-1.584,4.137-1.584c2.487,0,4.796,1.54,4.796,4.136C21.156,16.208,17.328,16.627,17.328,19.003z';
var wrapper = document.createElement('span');
wrapper.className = 'cesium-navigationHelpButton-wrapper';
container.appendChild(wrapper);
var button = document.createElement('button');
button.type = 'button';
button.className = 'cesium-button cesium-toolbar-button cesium-navigation-help-button';
button.setAttribute('data-bind', '\
attr: { title: tooltip },\
click: command,\
cesiumSvgPath: { path: _svgPath, width: 32, height: 32 }');
wrapper.appendChild(button);
var instructionContainer = document.createElement('div');
instructionContainer.className = 'cesium-navigation-help';
instructionContainer.setAttribute('data-bind', 'css: { "cesium-navigation-help-visible" : showInstructions}');
wrapper.appendChild(instructionContainer);
var mouseButton = document.createElement('button');
mouseButton.type = 'button';
mouseButton.className = 'cesium-navigation-button cesium-navigation-button-left';
mouseButton.setAttribute('data-bind', 'click: showClick, css: {"cesium-navigation-button-selected": !_touch, "cesium-navigation-button-unselected": _touch}');
var mouseIcon = document.createElement('img');
mouseIcon.src = buildModuleUrl('Widgets/Images/NavigationHelp/Mouse.svg');
mouseIcon.className = 'cesium-navigation-button-icon';
mouseIcon.style.width = '25px';
mouseIcon.style.height = '25px';
mouseButton.appendChild(mouseIcon);
mouseButton.appendChild(document.createTextNode('Mouse'));
var touchButton = document.createElement('button');
touchButton.type = 'button';
touchButton.className = 'cesium-navigation-button cesium-navigation-button-right';
touchButton.setAttribute('data-bind', 'click: showTouch, css: {"cesium-navigation-button-selected": _touch, "cesium-navigation-button-unselected": !_touch}');
var touchIcon = document.createElement('img');
touchIcon.src = buildModuleUrl('Widgets/Images/NavigationHelp/Touch.svg');
touchIcon.className = 'cesium-navigation-button-icon';
touchIcon.style.width = '25px';
touchIcon.style.height = '25px';
touchButton.appendChild(touchIcon);
touchButton.appendChild(document.createTextNode('Touch'));
instructionContainer.appendChild(mouseButton);
instructionContainer.appendChild(touchButton);
var clickInstructions = document.createElement('div');
clickInstructions.className = 'cesium-click-navigation-help cesium-navigation-help-instructions';
clickInstructions.setAttribute('data-bind', 'css: { "cesium-click-navigation-help-visible" : !_touch}');
clickInstructions.innerHTML = '\
<table>\
<tr>\
<td><img src="' + buildModuleUrl('Widgets/Images/NavigationHelp/MouseLeft.svg') + '" width="48" height="48" /></td>\
<td>\
<div class="cesium-navigation-help-pan">Pan view</div>\
<div class="cesium-navigation-help-details">Left click + drag</div>\
</td>\
</tr>\
<tr>\
<td><img src="' + buildModuleUrl('Widgets/Images/NavigationHelp/MouseRight.svg') + '" width="48" height="48" /></td>\
<td>\
<div class="cesium-navigation-help-zoom">Zoom view</div>\
<div class="cesium-navigation-help-details">Right click + drag, or</div>\
<div class="cesium-navigation-help-details">Mouse wheel scroll</div>\
</td>\
</tr>\
<tr>\
<td><img src="' + buildModuleUrl('Widgets/Images/NavigationHelp/MouseMiddle.svg') + '" width="48" height="48" /></td>\
<td>\
<div class="cesium-navigation-help-rotate">Rotate view</div>\
<div class="cesium-navigation-help-details">Middle click + drag, or</div>\
<div class="cesium-navigation-help-details">CTRL + Left/Right click + drag</div>\
</td>\
</tr>\
</table>';
instructionContainer.appendChild(clickInstructions);
var touchInstructions = document.createElement('div');
touchInstructions.className = 'cesium-touch-navigation-help cesium-navigation-help-instructions';
touchInstructions.setAttribute('data-bind', 'css: { "cesium-touch-navigation-help-visible" : _touch}');
touchInstructions.innerHTML = '\
<table>\
<tr>\
<td><img src="' + buildModuleUrl('Widgets/Images/NavigationHelp/TouchDrag.svg') + '" width="70" height="48" /></td>\
<td>\
<div class="cesium-navigation-help-pan">Pan view</div>\
<div class="cesium-navigation-help-details">One finger drag</div>\
</td>\
</tr>\
<tr>\
<td><img src="' + buildModuleUrl('Widgets/Images/NavigationHelp/TouchZoom.svg') + '" width="70" height="48" /></td>\
<td>\
<div class="cesium-navigation-help-zoom">Zoom view</div>\
<div class="cesium-navigation-help-details">Two finger pinch</div>\
</td>\
</tr>\
<tr>\
<td><img src="' + buildModuleUrl('Widgets/Images/NavigationHelp/TouchTilt.svg') + '" width="70" height="48" /></td>\
<td>\
<div class="cesium-navigation-help-rotate">Tilt view</div>\
<div class="cesium-navigation-help-details">Two finger drag, same direction</div>\
</td>\
</tr>\
<tr>\
<td><img src="' + buildModuleUrl('Widgets/Images/NavigationHelp/TouchRotate.svg') + '" width="70" height="48" /></td>\
<td>\
<div class="cesium-navigation-help-tilt">Rotate view</div>\
<div class="cesium-navigation-help-details">Two finger drag, opposite direction</div>\
</td>\
</tr>\
</table>';
instructionContainer.appendChild(touchInstructions);
knockout.applyBindings(viewModel, wrapper);
this._container = container;
this._viewModel = viewModel;
this._wrapper = wrapper;
this._closeInstructions = function(e) {
if (!wrapper.contains(e.target)) {
viewModel.showInstructions = false;
}
};
if (FeatureDetection.supportsPointerEvents()) {
document.addEventListener('pointerdown', this._closeInstructions, true);
} else {
document.addEventListener('mousedown', this._closeInstructions, true);
document.addEventListener('touchstart', this._closeInstructions, true);
}
}
defineProperties(NavigationHelpButton.prototype, {
/**
* Gets the parent container.
* @memberof NavigationHelpButton.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof NavigationHelpButton.prototype
*
* @type {NavigationHelpButtonViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
NavigationHelpButton.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
NavigationHelpButton.prototype.destroy = function() {
if (FeatureDetection.supportsPointerEvents()) {
document.removeEventListener('pointerdown', this._closeInstructions, true);
} else {
document.removeEventListener('mousedown', this._closeInstructions, true);
document.removeEventListener('touchstart', this._closeInstructions, true);
}
knockout.cleanNode(this._wrapper);
this._container.removeChild(this._wrapper);
return destroyObject(this);
};
return NavigationHelpButton;
});
/*global define*/
define('Widgets/PerformanceWatchdog/PerformanceWatchdogViewModel',[
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Scene/FrameRateMonitor',
'../../ThirdParty/knockout',
'../createCommand'
], function(
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
FrameRateMonitor,
knockout,
createCommand) {
'use strict';
/**
* The view model for {@link PerformanceWatchdog}.
*
* @alias PerformanceWatchdogViewModel
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Scene} options.scene The Scene instance for which to monitor performance.
* @param {String} [options.lowFrameRateMessage='This application appears to be performing poorly on your system. Please try using a different web browser or updating your video drivers.'] The
* message to display when a low frame rate is detected. The message is interpeted as HTML, so make sure
* it comes from a trusted source so that your application is not vulnerable to cross-site scripting attacks.
*/
function PerformanceWatchdogViewModel(options) {
if (!defined(options) || !defined(options.scene)) {
throw new DeveloperError('options.scene is required.');
}
this._scene = options.scene;
/**
* Gets or sets the message to display when a low frame rate is detected. This string will be interpreted as HTML.
* @type {String}
*/
this.lowFrameRateMessage = defaultValue(options.lowFrameRateMessage, 'This application appears to be performing poorly on your system. Please try using a different web browser or updating your video drivers.');
/**
* Gets or sets a value indicating whether the low frame rate message has previously been dismissed by the user. If it has
* been dismissed, the message will not be redisplayed, no matter the frame rate.
* @type {Boolean}
*/
this.lowFrameRateMessageDismissed = false;
/**
* Gets or sets a value indicating whether the low frame rate message is currently being displayed.
* @type {Boolean}
*/
this.showingLowFrameRateMessage = false;
knockout.track(this, ['lowFrameRateMessage', 'lowFrameRateMessageDismissed', 'showingLowFrameRateMessage']);
var that = this;
this._dismissMessage = createCommand(function() {
that.showingLowFrameRateMessage = false;
that.lowFrameRateMessageDismissed = true;
});
var monitor = FrameRateMonitor.fromScene(options.scene);
this._unsubscribeLowFrameRate = monitor.lowFrameRate.addEventListener(function() {
if (!that.lowFrameRateMessageDismissed) {
that.showingLowFrameRateMessage = true;
}
});
this._unsubscribeNominalFrameRate = monitor.nominalFrameRate.addEventListener(function() {
that.showingLowFrameRateMessage = false;
});
}
defineProperties(PerformanceWatchdogViewModel.prototype, {
/**
* Gets the {@link Scene} instance for which to monitor performance.
* @memberof PerformanceWatchdogViewModel.prototype
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
},
/**
* Gets a command that dismisses the low frame rate message. Once it is dismissed, the message
* will not be redisplayed.
* @memberof PerformanceWatchdogViewModel.prototype
* @type {Command}
*/
dismissMessage : {
get : function() {
return this._dismissMessage;
}
}
});
PerformanceWatchdogViewModel.prototype.destroy = function() {
this._unsubscribeLowFrameRate();
this._unsubscribeNominalFrameRate();
return destroyObject(this);
};
return PerformanceWatchdogViewModel;
});
/*global define*/
define('Widgets/PerformanceWatchdog/PerformanceWatchdog',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../getElement',
'./PerformanceWatchdogViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
knockout,
getElement,
PerformanceWatchdogViewModel) {
'use strict';
/**
* Monitors performance of the application and displays a message if poor performance is detected.
*
* @alias PerformanceWatchdog
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {Element|String} options.container The DOM element or ID that will contain the widget.
* @param {Scene} options.scene The {@link Scene} for which to monitor performance.
* @param {String} [options.lowFrameRateMessage='This application appears to be performing poorly on your system. Please try using a different web browser or updating your video drivers.'] The
* message to display when a low frame rate is detected. The message is interpeted as HTML, so make sure
* it comes from a trusted source so that your application is not vulnerable to cross-site scripting attacks.
*/
function PerformanceWatchdog(options) {
if (!defined(options) || !defined(options.container)) {
throw new DeveloperError('options.container is required.');
}
if (!defined(options.scene)) {
throw new DeveloperError('options.scene is required.');
}
var container = getElement(options.container);
var viewModel = new PerformanceWatchdogViewModel(options);
var element = document.createElement('div');
element.className = 'cesium-performance-watchdog-message-area';
element.setAttribute('data-bind', 'visible: showingLowFrameRateMessage');
var dismissButton = document.createElement('button');
dismissButton.setAttribute('type', 'button');
dismissButton.className = 'cesium-performance-watchdog-message-dismiss';
dismissButton.innerHTML = '×';
dismissButton.setAttribute('data-bind', 'click: dismissMessage');
element.appendChild(dismissButton);
var message = document.createElement('div');
message.className = 'cesium-performance-watchdog-message';
message.setAttribute('data-bind', 'html: lowFrameRateMessage');
element.appendChild(message);
container.appendChild(element);
knockout.applyBindings(viewModel, element);
this._container = container;
this._viewModel = viewModel;
this._element = element;
}
defineProperties(PerformanceWatchdog.prototype, {
/**
* Gets the parent container.
* @memberof PerformanceWatchdog.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof PerformanceWatchdog.prototype
*
* @type {PerformanceWatchdogViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @memberof PerformanceWatchdog
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
PerformanceWatchdog.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
* @memberof PerformanceWatchdog
*/
PerformanceWatchdog.prototype.destroy = function() {
this._viewModel.destroy();
knockout.cleanNode(this._element);
this._container.removeChild(this._element);
return destroyObject(this);
};
return PerformanceWatchdog;
});
/*global define*/
define('Widgets/SceneModePicker/SceneModePickerViewModel',[
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/EventHelper',
'../../Scene/SceneMode',
'../../ThirdParty/knockout',
'../createCommand'
], function(
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
EventHelper,
SceneMode,
knockout,
createCommand) {
'use strict';
/**
* The view model for {@link SceneModePicker}.
* @alias SceneModePickerViewModel
* @constructor
*
* @param {Scene} scene The Scene to morph
* @param {Number} [duration=2.0] The duration of scene morph animations, in seconds
*/
function SceneModePickerViewModel(scene, duration) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
this._scene = scene;
var that = this;
var morphStart = function(transitioner, oldMode, newMode, isMorphing) {
that.sceneMode = newMode;
that.dropDownVisible = false;
};
this._eventHelper = new EventHelper();
this._eventHelper.add(scene.morphStart, morphStart);
this._duration = defaultValue(duration, 2.0);
/**
* Gets or sets the current SceneMode. This property is observable.
* @type {SceneMode}
*/
this.sceneMode = scene.mode;
/**
* Gets or sets whether the button drop-down is currently visible. This property is observable.
* @type {Boolean}
* @default false
*/
this.dropDownVisible = false;
/**
* Gets or sets the 2D tooltip. This property is observable.
* @type {String}
* @default '2D'
*/
this.tooltip2D = '2D';
/**
* Gets or sets the 3D tooltip. This property is observable.
* @type {String}
* @default '3D'
*/
this.tooltip3D = '3D';
/**
* Gets or sets the Columbus View tooltip. This property is observable.
* @type {String}
* @default 'Columbus View'
*/
this.tooltipColumbusView = 'Columbus View';
knockout.track(this, ['sceneMode', 'dropDownVisible', 'tooltip2D', 'tooltip3D', 'tooltipColumbusView']);
/**
* Gets the currently active tooltip. This property is observable.
* @type {String}
*/
this.selectedTooltip = undefined;
knockout.defineProperty(this, 'selectedTooltip', function() {
var mode = that.sceneMode;
if (mode === SceneMode.SCENE2D) {
return that.tooltip2D;
}
if (mode === SceneMode.SCENE3D) {
return that.tooltip3D;
}
return that.tooltipColumbusView;
});
this._toggleDropDown = createCommand(function() {
that.dropDownVisible = !that.dropDownVisible;
});
this._morphTo2D = createCommand(function() {
scene.morphTo2D(that._duration);
});
this._morphTo3D = createCommand(function() {
scene.morphTo3D(that._duration);
});
this._morphToColumbusView = createCommand(function() {
scene.morphToColumbusView(that._duration);
});
//Used by knockout
this._sceneMode = SceneMode;
}
defineProperties(SceneModePickerViewModel.prototype, {
/**
* Gets the scene
* @memberof SceneModePickerViewModel.prototype
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
},
/**
* Gets or sets the the duration of scene mode transition animations in seconds.
* A value of zero causes the scene to instantly change modes.
* @memberof SceneModePickerViewModel.prototype
* @type {Number}
*/
duration : {
get : function() {
return this._duration;
},
set : function(value) {
if (value < 0.0) {
throw new DeveloperError('duration value must be positive.');
}
this._duration = value;
}
},
/**
* Gets the command to toggle the drop down box.
* @memberof SceneModePickerViewModel.prototype
*
* @type {Command}
*/
toggleDropDown : {
get : function() {
return this._toggleDropDown;
}
},
/**
* Gets the command to morph to 2D.
* @memberof SceneModePickerViewModel.prototype
*
* @type {Command}
*/
morphTo2D : {
get : function() {
return this._morphTo2D;
}
},
/**
* Gets the command to morph to 3D.
* @memberof SceneModePickerViewModel.prototype
*
* @type {Command}
*/
morphTo3D : {
get : function() {
return this._morphTo3D;
}
},
/**
* Gets the command to morph to Columbus View.
* @memberof SceneModePickerViewModel.prototype
*
* @type {Command}
*/
morphToColumbusView : {
get : function() {
return this._morphToColumbusView;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
SceneModePickerViewModel.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the view model.
*/
SceneModePickerViewModel.prototype.destroy = function() {
this._eventHelper.removeAll();
destroyObject(this);
};
return SceneModePickerViewModel;
});
/*global define*/
define('Widgets/SceneModePicker/SceneModePicker',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/FeatureDetection',
'../../ThirdParty/knockout',
'../getElement',
'./SceneModePickerViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
FeatureDetection,
knockout,
getElement,
SceneModePickerViewModel) {
'use strict';
var globePath = 'm 32.401392,4.9330437 c -7.087603,0 -14.096095,2.884602 -19.10793,7.8946843 -5.0118352,5.010083 -7.9296167,11.987468 -7.9296167,19.072999 0,7.085531 2.9177815,14.097848 7.9296167,19.107931 4.837653,4.835961 11.541408,7.631372 18.374354,7.82482 0.05712,0.01231 0.454119,0.139729 0.454119,0.139729 l 0.03493,-0.104797 c 0.08246,7.84e-4 0.162033,0.03493 0.244525,0.03493 0.08304,0 0.161515,-0.03414 0.244526,-0.03493 l 0.03493,0.104797 c 0,0 0.309474,-0.129487 0.349323,-0.139729 6.867765,-0.168094 13.582903,-2.965206 18.444218,-7.82482 2.558195,-2.5573 4.551081,-5.638134 5.903547,-8.977584 1.297191,-3.202966 2.02607,-6.661489 2.02607,-10.130347 0,-6.237309 -2.366261,-12.31219 -6.322734,-17.116794 -0.0034,-0.02316 0.0049,-0.04488 0,-0.06986 -0.01733,-0.08745 -0.104529,-0.278855 -0.104797,-0.279458 -5.31e-4,-0.0012 -0.522988,-0.628147 -0.523984,-0.62878 \
-3.47e-4,-2.2e-4 -0.133444,-0.03532 -0.244525,-0.06987 C 51.944299,13.447603 51.751076,13.104317 51.474391,12.827728 46.462556,7.8176457 39.488996,4.9330437 32.401392,4.9330437 z m -2.130866,3.5281554 0.104797,9.6762289 c -4.111695,-0.08361 -7.109829,-0.423664 -9.257041,-0.943171 1.198093,-2.269271 2.524531,-4.124404 3.91241,-5.414496 2.167498,-2.0147811 3.950145,-2.8540169 5.239834,-3.3185619 z m 2.794579,0 c 1.280302,0.4754953 3.022186,1.3285948 5.065173,3.2486979 1.424667,1.338973 2.788862,3.303645 3.982275,5.728886 -2.29082,0.403367 -5.381258,0.621049 -8.942651,0.698645 L 33.065105,8.4611991 z m 5.728886,0.2445256 c 4.004072,1.1230822 7.793098,3.1481363 10.724195,6.0782083 0.03468,0.03466 0.07033,0.06991 0.104797,0.104797 -0.45375,0.313891 -0.923054,0.663002 -1.956205,1.082899 -0.647388,0.263114 -1.906242,0.477396 -2.829511,0.733577 -1.382296,-2.988132 \
-3.027146,-5.368585 -4.785716,-7.0213781 -0.422866,-0.397432 -0.835818,-0.6453247 -1.25756,-0.9781032 z m -15.33525,0.7685092 c -0.106753,0.09503 -0.207753,0.145402 -0.31439,0.244526 -1.684973,1.5662541 -3.298068,3.8232211 -4.680919,6.5672591 -0.343797,-0.14942 -1.035052,-0.273198 -1.292493,-0.419186 -0.956528,-0.542427 -1.362964,-1.022024 -1.537018,-1.292493 -0.0241,-0.03745 -0.01868,-0.0401 -0.03493,-0.06986 2.250095,-2.163342 4.948824,-3.869984 7.859752,-5.0302421 z m -9.641296,7.0912431 c 0.464973,0.571618 0.937729,1.169056 1.956205,1.746612 0.349907,0.198425 1.107143,0.335404 1.537018,0.523983 -1.20166,3.172984 -1.998037,7.051901 -2.165798,11.772162 C 14.256557,30.361384 12.934823,30.161483 12.280427,29.90959 10.644437,29.279855 9.6888882,28.674891 9.1714586,28.267775 8.6540289,27.860658 8.6474751,27.778724 8.6474751,27.778724 l -0.069864,0.03493 C 9.3100294,23.691285 \
11.163248,19.798527 13.817445,16.565477 z m 37.552149,0.523984 c 2.548924,3.289983 4.265057,7.202594 4.890513,11.318043 -0.650428,0.410896 -1.756876,1.001936 -3.563088,1.606882 -1.171552,0.392383 -3.163859,0.759153 -4.960377,1.117832 -0.04367,-4.752703 -0.784809,-8.591423 -1.88634,-11.807094 0.917574,-0.263678 2.170552,-0.486495 2.864443,-0.76851 1.274693,-0.518066 2.003942,-1.001558 2.654849,-1.467153 z m -31.439008,2.619917 c 2.487341,0.672766 5.775813,1.137775 10.479669,1.222628 l 0.104797,10.689263 0,0.03493 0,0.733577 c -5.435005,-0.09059 -9.512219,-0.519044 -12.610536,-1.117831 0.106127,-4.776683 0.879334,-8.55791 2.02607,-11.562569 z m 23.264866,0.31439 c 1.073459,3.067541 1.833795,6.821314 1.816476,11.702298 -3.054474,0.423245 -7.062018,0.648559 -11.702298,0.698644 l 0,-0.838373 -0.104796,-10.654331 c 4.082416,-0.0864 7.404468,-0.403886 9.990618,-0.908238 z \
M 8.2632205,30.922625 c 0.7558676,0.510548 1.5529563,1.013339 3.0041715,1.57195 0.937518,0.360875 2.612202,0.647642 3.91241,0.978102 0.112814,3.85566 0.703989,7.107756 1.606883,9.920754 -1.147172,-0.324262 -2.644553,-0.640648 -3.423359,-0.978102 -1.516688,-0.657177 -2.386627,-1.287332 -2.864443,-1.71168 -0.477816,-0.424347 -0.489051,-0.489051 -0.489051,-0.489051 L 9.8002387,40.319395 C 8.791691,37.621767 8.1584238,34.769583 8.1584238,31.900727 c 0,-0.330153 0.090589,-0.648169 0.1047967,-0.978102 z m 48.2763445,0.419186 c 0.0047,0.188973 0.06986,0.36991 0.06986,0.558916 0,2.938869 -0.620228,5.873558 -1.676747,8.628261 -0.07435,0.07583 -0.06552,0.07411 -0.454119,0.349323 -0.606965,0.429857 -1.631665,1.042044 -3.318562,1.676747 -1.208528,0.454713 -3.204964,0.850894 -5.135038,1.25756 0.84593,-2.765726 1.41808,-6.005357 1.606883,-9.815957 2.232369,-0.413371 4.483758,-0.840201 \
5.938479,-1.327425 1.410632,-0.472457 2.153108,-0.89469 2.96924,-1.327425 z m -38.530252,2.864443 c 3.208141,0.56697 7.372279,0.898588 12.575603,0.978103 l 0.174662,9.885821 c -4.392517,-0.06139 -8.106722,-0.320566 -10.863925,-0.803441 -1.051954,-2.664695 -1.692909,-6.043794 -1.88634,-10.060483 z m 26.793022,0.31439 c -0.246298,3.923551 -0.877762,7.263679 -1.816476,9.885822 -2.561957,0.361954 -5.766249,0.560708 -9.431703,0.62878 l -0.174661,-9.815957 c 4.491734,-0.04969 8.334769,-0.293032 11.42284,-0.698645 z M 12.035901,44.860585 c 0.09977,0.04523 0.105535,0.09465 0.209594,0.139729 1.337656,0.579602 3.441099,1.058072 5.589157,1.537018 1.545042,3.399208 3.548524,5.969402 5.589157,7.789888 -3.034411,-1.215537 -5.871615,-3.007978 -8.174142,-5.309699 -1.245911,-1.245475 -2.271794,-2.662961 -3.213766,-4.156936 z m 40.69605,0 c -0.941972,1.493975 -1.967855,2.911461 \
-3.213765,4.156936 -2.74253,2.741571 -6.244106,4.696717 -9.955686,5.868615 0.261347,-0.241079 0.507495,-0.394491 0.768509,-0.663713 1.674841,-1.727516 3.320792,-4.181056 4.645987,-7.265904 2.962447,-0.503021 5.408965,-1.122293 7.161107,-1.781544 0.284034,-0.106865 0.337297,-0.207323 0.593848,-0.31439 z m -31.404076,2.305527 c 2.645807,0.376448 5.701178,0.649995 9.466635,0.698645 l 0.139729,7.789888 c -1.38739,-0.480844 -3.316218,-1.29837 -5.659022,-3.388427 -1.388822,-1.238993 -2.743668,-3.0113 -3.947342,-5.100106 z m 20.365491,0.104797 c -1.04872,2.041937 -2.174337,3.779068 -3.353494,4.995309 -1.853177,1.911459 -3.425515,2.82679 -4.611055,3.353494 l -0.139729,-7.789887 c 3.13091,-0.05714 5.728238,-0.278725 8.104278,-0.558916 z';
var flatMapPath = 'm 2.9825053,17.550598 0,1.368113 0,26.267766 0,1.368113 1.36811,0 54.9981397,0 1.36811,0 0,-1.368113 0,-26.267766 0,-1.368113 -1.36811,0 -54.9981397,0 -1.36811,0 z m 2.73623,2.736226 10.3292497,0 0,10.466063 -10.3292497,0 0,-10.466063 z m 13.0654697,0 11.69737,0 0,10.466063 -11.69737,0 0,-10.466063 z m 14.43359,0 11.69737,0 0,10.466063 -11.69737,0 0,-10.466063 z m 14.43359,0 10.32926,0 0,10.466063 -10.32926,0 0,-10.466063 z m -41.9326497,13.202288 10.3292497,0 0,10.329252 -10.3292497,0 0,-10.329252 z m 13.0654697,0 11.69737,0 0,10.329252 -11.69737,0 0,-10.329252 z m 14.43359,0 11.69737,0 0,10.329252 -11.69737,0 0,-10.329252 z m 14.43359,0 10.32926,0 0,10.329252 -10.32926,0 0,-10.329252 z';
var columbusViewPath = 'm 14.723969,17.675598 -0.340489,0.817175 -11.1680536,26.183638 -0.817175,1.872692 2.076986,0 54.7506996,0 2.07698,0 -0.81717,-1.872692 -11.16805,-26.183638 -0.34049,-0.817175 -0.91933,0 -32.414586,0 -0.919322,0 z m 1.838643,2.723916 6.196908,0 -2.928209,10.418977 -7.729111,0 4.460412,-10.418977 z m 9.02297,0 4.903049,0 0,10.418977 -7.831258,0 2.928209,-10.418977 z m 7.626964,0 5.584031,0 2.62176,10.418977 -8.205791,0 0,-10.418977 z m 8.410081,0 5.51593,0 4.46042,10.418977 -7.38863,0 -2.58772,-10.418977 z m -30.678091,13.142892 8.103649,0 -2.89416,10.282782 -9.6018026,0 4.3923136,-10.282782 z m 10.929711,0 8.614384,0 0,10.282782 -11.508544,0 2.89416,-10.282782 z m 11.338299,0 8.852721,0 2.58772,10.282782 -11.440441,0 0,-10.282782 z m 11.678781,0 7.86531,0 4.39231,10.282782 -9.6699,0 -2.58772,-10.282782 z';
/**
* <img src="images/sceneModePicker.png" style="float: left; margin-right: 10px;" width="44" height="116" />
* <p>The SceneModePicker is a single button widget for switching between scene modes;
* shown to the left in its expanded state. Programatic switching of scene modes will
* be automatically reflected in the widget as long as the specified Scene
* is used to perform the change.</p><p style="clear: both;"></p><br/>
*
* @alias SceneModePicker
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Scene} scene The Scene instance to use.
* @param {Number} [duration=2.0] The time, in seconds, it takes for the scene to transition.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*
* @example
* // In HTML head, include a link to the SceneModePicker.css stylesheet,
* // and in the body, include: <div id="sceneModePickerContainer"></div>
* // Note: This code assumes you already have a Scene instance.
*
* var sceneModePicker = new Cesium.SceneModePicker('sceneModePickerContainer', scene);
*/
function SceneModePicker(container, scene, duration) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
container = getElement(container);
var viewModel = new SceneModePickerViewModel(scene, duration);
viewModel._globePath = globePath;
viewModel._flatMapPath = flatMapPath;
viewModel._columbusViewPath = columbusViewPath;
var wrapper = document.createElement('span');
wrapper.className = 'cesium-sceneModePicker-wrapper cesium-toolbar-button';
container.appendChild(wrapper);
var button = document.createElement('button');
button.type = 'button';
button.className = 'cesium-button cesium-toolbar-button';
button.setAttribute('data-bind', '\
css: { "cesium-sceneModePicker-button2D": sceneMode === _sceneMode.SCENE2D,\
"cesium-sceneModePicker-button3D": sceneMode === _sceneMode.SCENE3D,\
"cesium-sceneModePicker-buttonColumbusView": sceneMode === _sceneMode.COLUMBUS_VIEW,\
"cesium-sceneModePicker-selected": dropDownVisible },\
attr: { title: selectedTooltip },\
click: toggleDropDown');
button.innerHTML = '\
<!-- ko cesiumSvgPath: { path: _globePath, width: 64, height: 64, css: "cesium-sceneModePicker-slide-svg cesium-sceneModePicker-icon3D" } --><!-- /ko -->\
<!-- ko cesiumSvgPath: { path: _flatMapPath, width: 64, height: 64, css: "cesium-sceneModePicker-slide-svg cesium-sceneModePicker-icon2D" } --><!-- /ko -->\
<!-- ko cesiumSvgPath: { path: _columbusViewPath, width: 64, height: 64, css: "cesium-sceneModePicker-slide-svg cesium-sceneModePicker-iconColumbusView" } --><!-- /ko -->';
wrapper.appendChild(button);
var morphTo3DButton = document.createElement('button');
morphTo3DButton.type = 'button';
morphTo3DButton.className = 'cesium-button cesium-toolbar-button cesium-sceneModePicker-dropDown-icon';
morphTo3DButton.setAttribute('data-bind', '\
css: { "cesium-sceneModePicker-visible" : (dropDownVisible && (sceneMode !== _sceneMode.SCENE3D)) || (!dropDownVisible && (sceneMode === _sceneMode.SCENE3D)),\
"cesium-sceneModePicker-none" : sceneMode === _sceneMode.SCENE3D,\
"cesium-sceneModePicker-hidden" : !dropDownVisible },\
attr: { title: tooltip3D },\
click: morphTo3D,\
cesiumSvgPath: { path: _globePath, width: 64, height: 64 }');
wrapper.appendChild(morphTo3DButton);
var morphTo2DButton = document.createElement('button');
morphTo2DButton.type = 'button';
morphTo2DButton.className = 'cesium-button cesium-toolbar-button cesium-sceneModePicker-dropDown-icon';
morphTo2DButton.setAttribute('data-bind', '\
css: { "cesium-sceneModePicker-visible" : (dropDownVisible && (sceneMode !== _sceneMode.SCENE2D)),\
"cesium-sceneModePicker-none" : sceneMode === _sceneMode.SCENE2D,\
"cesium-sceneModePicker-hidden" : !dropDownVisible },\
attr: { title: tooltip2D },\
click: morphTo2D,\
cesiumSvgPath: { path: _flatMapPath, width: 64, height: 64 }');
wrapper.appendChild(morphTo2DButton);
var morphToCVButton = document.createElement('button');
morphToCVButton.type = 'button';
morphToCVButton.className = 'cesium-button cesium-toolbar-button cesium-sceneModePicker-dropDown-icon';
morphToCVButton.setAttribute('data-bind', '\
css: { "cesium-sceneModePicker-visible" : (dropDownVisible && (sceneMode !== _sceneMode.COLUMBUS_VIEW)) || (!dropDownVisible && (sceneMode === _sceneMode.COLUMBUS_VIEW)),\
"cesium-sceneModePicker-none" : sceneMode === _sceneMode.COLUMBUS_VIEW,\
"cesium-sceneModePicker-hidden" : !dropDownVisible},\
attr: { title: tooltipColumbusView },\
click: morphToColumbusView,\
cesiumSvgPath: { path: _columbusViewPath, width: 64, height: 64 }');
wrapper.appendChild(morphToCVButton);
knockout.applyBindings(viewModel, wrapper);
this._viewModel = viewModel;
this._container = container;
this._wrapper = wrapper;
this._closeDropDown = function(e) {
if (!wrapper.contains(e.target)) {
viewModel.dropDownVisible = false;
}
};
if (FeatureDetection.supportsPointerEvents()) {
document.addEventListener('pointerdown', this._closeDropDown, true);
} else {
document.addEventListener('mousedown', this._closeDropDown, true);
document.addEventListener('touchstart', this._closeDropDown, true);
}
}
defineProperties(SceneModePicker.prototype, {
/**
* Gets the parent container.
* @memberof SceneModePicker.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof SceneModePicker.prototype
*
* @type {SceneModePickerViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
SceneModePicker.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
SceneModePicker.prototype.destroy = function() {
this._viewModel.destroy();
if (FeatureDetection.supportsPointerEvents()) {
document.removeEventListener('pointerdown', this._closeDropDown, true);
} else {
document.removeEventListener('mousedown', this._closeDropDown, true);
document.removeEventListener('touchstart', this._closeDropDown, true);
}
knockout.cleanNode(this._wrapper);
this._container.removeChild(this._wrapper);
return destroyObject(this);
};
return SceneModePicker;
});
/*global define*/
define('Widgets/SelectionIndicator/SelectionIndicatorViewModel',[
'../../Core/Cartesian2',
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../../Core/EasingFunction',
'../../Scene/SceneTransforms',
'../../ThirdParty/knockout'
], function(
Cartesian2,
defaultValue,
defined,
defineProperties,
DeveloperError,
EasingFunction,
SceneTransforms,
knockout) {
'use strict';
var screenSpacePos = new Cartesian2();
var offScreen = '-1000px';
/**
* The view model for {@link SelectionIndicator}.
* @alias SelectionIndicatorViewModel
* @constructor
*
* @param {Scene} scene The scene instance to use for screen-space coordinate conversion.
* @param {Element} selectionIndicatorElement The element containing all elements that make up the selection indicator.
* @param {Element} container The DOM element that contains the widget.
*/
function SelectionIndicatorViewModel(scene, selectionIndicatorElement, container) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
if (!defined(selectionIndicatorElement)) {
throw new DeveloperError('selectionIndicatorElement is required.');
}
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
this._scene = scene;
this._screenPositionX = offScreen;
this._screenPositionY = offScreen;
this._tweens = scene.tweens;
this._container = defaultValue(container, document.body);
this._selectionIndicatorElement = selectionIndicatorElement;
this._scale = 1;
/**
* Gets or sets the world position of the object for which to display the selection indicator.
* @type {Cartesian3}
*/
this.position = undefined;
/**
* Gets or sets the visibility of the selection indicator.
* @type {Boolean}
*/
this.showSelection = false;
knockout.track(this, ['position', '_screenPositionX', '_screenPositionY', '_scale', 'showSelection']);
/**
* Gets the visibility of the position indicator. This can be false even if an
* object is selected, when the selected object has no position.
* @type {Boolean}
*/
this.isVisible = undefined;
knockout.defineProperty(this, 'isVisible', {
get : function() {
return this.showSelection && defined(this.position);
}
});
knockout.defineProperty(this, '_transform', {
get : function() {
return 'scale(' + (this._scale) + ')';
}
});
/**
* Gets or sets the function for converting the world position of the object to the screen space position.
*
* @member
* @type {SelectionIndicatorViewModel~ComputeScreenSpacePosition}
* @default SceneTransforms.wgs84ToWindowCoordinates
*
* @example
* selectionIndicatorViewModel.computeScreenSpacePosition = function(position, result) {
* return Cesium.SceneTransforms.wgs84ToWindowCoordinates(scene, position, result);
* };
*/
this.computeScreenSpacePosition = function(position, result) {
return SceneTransforms.wgs84ToWindowCoordinates(scene, position, result);
};
}
/**
* Updates the view of the selection indicator to match the position and content properties of the view model.
* This function should be called as part of the render loop.
*/
SelectionIndicatorViewModel.prototype.update = function() {
if (this.showSelection && defined(this.position)) {
var screenPosition = this.computeScreenSpacePosition(this.position, screenSpacePos);
if (!defined(screenPosition)) {
this._screenPositionX = offScreen;
this._screenPositionY = offScreen;
} else {
var container = this._container;
var containerWidth = container.parentNode.clientWidth;
var containerHeight = container.parentNode.clientHeight;
var indicatorSize = this._selectionIndicatorElement.clientWidth;
var halfSize = indicatorSize * 0.5;
screenPosition.x = Math.min(Math.max(screenPosition.x, -indicatorSize), containerWidth + indicatorSize) - halfSize;
screenPosition.y = Math.min(Math.max(screenPosition.y, -indicatorSize), containerHeight + indicatorSize) - halfSize;
this._screenPositionX = Math.floor(screenPosition.x + 0.25) + 'px';
this._screenPositionY = Math.floor(screenPosition.y + 0.25) + 'px';
}
}
};
/**
* Animate the indicator to draw attention to the selection.
*/
SelectionIndicatorViewModel.prototype.animateAppear = function() {
this._tweens.addProperty({
object : this,
property : '_scale',
startValue : 2,
stopValue : 1,
duration : 0.8,
easingFunction : EasingFunction.EXPONENTIAL_OUT
});
};
/**
* Animate the indicator to release the selection.
*/
SelectionIndicatorViewModel.prototype.animateDepart = function() {
this._tweens.addProperty({
object : this,
property : '_scale',
startValue : this._scale,
stopValue : 1.5,
duration : 0.8,
easingFunction : EasingFunction.EXPONENTIAL_OUT
});
};
defineProperties(SelectionIndicatorViewModel.prototype, {
/**
* Gets the HTML element containing the selection indicator.
* @memberof SelectionIndicatorViewModel.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the HTML element that holds the selection indicator.
* @memberof SelectionIndicatorViewModel.prototype
*
* @type {Element}
*/
selectionIndicatorElement : {
get : function() {
return this._selectionIndicatorElement;
}
},
/**
* Gets the scene being used.
* @memberof SelectionIndicatorViewModel.prototype
*
* @type {Scene}
*/
scene : {
get : function() {
return this._scene;
}
}
});
/**
* A function that converts the world position of an object to a screen space position.
* @callback SelectionIndicatorViewModel~ComputeScreenSpacePosition
* @param {Cartesian3} position The position in WGS84 (world) coordinates.
* @param {Cartesian2} result An object to return the input position transformed to window coordinates.
* @returns {Cartesian2} The modified result parameter.
*/
return SelectionIndicatorViewModel;
});
/*global define*/
define('Widgets/SelectionIndicator/SelectionIndicator',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../getElement',
'./SelectionIndicatorViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
knockout,
getElement,
SelectionIndicatorViewModel) {
'use strict';
/**
* A widget for displaying an indicator on a selected object.
*
* @alias SelectionIndicator
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Scene} scene The Scene instance to use.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*/
function SelectionIndicator(container, scene) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
container = getElement(container);
this._container = container;
var el = document.createElement('div');
el.className = 'cesium-selection-wrapper';
el.setAttribute('data-bind', '\
style: { "top" : _screenPositionY, "left" : _screenPositionX },\
css: { "cesium-selection-wrapper-visible" : isVisible }');
container.appendChild(el);
this._element = el;
var svgNS = 'http://www.w3.org/2000/svg';
var path = 'M -34 -34 L -34 -11.25 L -30 -15.25 L -30 -30 L -15.25 -30 L -11.25 -34 L -34 -34 z M 11.25 -34 L 15.25 -30 L 30 -30 L 30 -15.25 L 34 -11.25 L 34 -34 L 11.25 -34 z M -34 11.25 L -34 34 L -11.25 34 L -15.25 30 L -30 30 L -30 15.25 L -34 11.25 z M 34 11.25 L 30 15.25 L 30 30 L 15.25 30 L 11.25 34 L 34 34 L 34 11.25 z';
var svg = document.createElementNS(svgNS, 'svg:svg');
svg.setAttribute('width', 160);
svg.setAttribute('height', 160);
svg.setAttribute('viewBox', '0 0 160 160');
var group = document.createElementNS(svgNS, 'g');
group.setAttribute('transform', 'translate(80,80)');
svg.appendChild(group);
var pathElement = document.createElementNS(svgNS, 'path');
pathElement.setAttribute('data-bind', 'attr: { transform: _transform }');
pathElement.setAttribute('d', path);
group.appendChild(pathElement);
el.appendChild(svg);
var viewModel = new SelectionIndicatorViewModel(scene, this._element, this._container);
this._viewModel = viewModel;
knockout.applyBindings(this._viewModel, this._element);
}
defineProperties(SelectionIndicator.prototype, {
/**
* Gets the parent container.
* @memberof SelectionIndicator.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof SelectionIndicator.prototype
*
* @type {SelectionIndicatorViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
SelectionIndicator.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
SelectionIndicator.prototype.destroy = function() {
var container = this._container;
knockout.cleanNode(this._element);
container.removeChild(this._element);
return destroyObject(this);
};
return SelectionIndicator;
});
/*global define*/
define('Widgets/Timeline/TimelineHighlightRange',[
'../../Core/defaultValue',
'../../Core/JulianDate'
], function(
defaultValue,
JulianDate) {
'use strict';
/**
* @private
*/
function TimelineHighlightRange(color, heightInPx, base) {
this._color = color;
this._height = heightInPx;
this._base = defaultValue(base, 0);
}
TimelineHighlightRange.prototype.getHeight = function() {
return this._height;
};
TimelineHighlightRange.prototype.getBase = function() {
return this._base;
};
TimelineHighlightRange.prototype.getStartTime = function() {
return this._start;
};
TimelineHighlightRange.prototype.getStopTime = function() {
return this._stop;
};
TimelineHighlightRange.prototype.setRange = function(start, stop) {
this._start = start;
this._stop = stop;
};
TimelineHighlightRange.prototype.render = function(renderState) {
var range = '';
if (this._start && this._stop && this._color) {
var highlightStart = JulianDate.secondsDifference(this._start, renderState.epochJulian);
var highlightLeft = Math.round(renderState.timeBarWidth * renderState.getAlpha(highlightStart));
var highlightStop = JulianDate.secondsDifference(this._stop, renderState.epochJulian);
var highlightWidth = Math.round(renderState.timeBarWidth * renderState.getAlpha(highlightStop)) - highlightLeft;
if (highlightLeft < 0) {
highlightWidth += highlightLeft;
highlightLeft = 0;
}
if ((highlightLeft + highlightWidth) > renderState.timeBarWidth) {
highlightWidth = renderState.timeBarWidth - highlightLeft;
}
if (highlightWidth > 0) {
range = '<span class="cesium-timeline-highlight" style="left: ' + highlightLeft.toString() +
'px; width: ' + highlightWidth.toString() + 'px; bottom: ' + this._base.toString() +
'px; height: ' + this._height + 'px; background-color: ' + this._color + ';"></span>';
}
}
return range;
};
return TimelineHighlightRange;
});
/*global define*/
define('Widgets/Timeline/TimelineTrack',[
'../../Core/Color',
'../../Core/defined',
'../../Core/JulianDate'
], function(
Color,
defined,
JulianDate) {
'use strict';
/**
* @private
*/
function TimelineTrack(interval, pixelHeight, color, backgroundColor) {
this.interval = interval;
this.height = pixelHeight;
this.color = color || new Color(0.5, 0.5, 0.5, 1.0);
this.backgroundColor = backgroundColor || new Color(0.0, 0.0, 0.0, 0.0);
}
TimelineTrack.prototype.render = function(context, renderState) {
var startInterval = this.interval.start;
var stopInterval = this.interval.stop;
var spanStart = renderState.startJulian;
var spanStop = JulianDate.addSeconds(renderState.startJulian, renderState.duration, new JulianDate());
if (JulianDate.lessThan(startInterval, spanStart) && JulianDate.greaterThan(stopInterval, spanStop)) {
//The track takes up the entire visible span.
context.fillStyle = this.color.toCssColorString();
context.fillRect(0, renderState.y, renderState.timeBarWidth, this.height);
} else if (JulianDate.lessThanOrEquals(startInterval, spanStop) && JulianDate.greaterThanOrEquals(stopInterval, spanStart)) {
//The track only takes up some of the visible span, compute that span.
var x;
var start, stop;
for (x = 0; x < renderState.timeBarWidth; ++x) {
var currentTime = JulianDate.addSeconds(renderState.startJulian, (x / renderState.timeBarWidth) * renderState.duration, new JulianDate());
if (!defined(start) && JulianDate.greaterThanOrEquals(currentTime, startInterval)) {
start = x;
} else if (!defined(stop) && JulianDate.greaterThanOrEquals(currentTime, stopInterval)) {
stop = x;
}
}
context.fillStyle = this.backgroundColor.toCssColorString();
context.fillRect(0, renderState.y, renderState.timeBarWidth, this.height);
if (defined(start)) {
if (!defined(stop)) {
stop = renderState.timeBarWidth;
}
context.fillStyle = this.color.toCssColorString();
context.fillRect(start, renderState.y, Math.max(stop - start, 1), this.height);
}
}
};
return TimelineTrack;
});
/*global define*/
define('Widgets/Timeline/Timeline',[
'../../Core/ClockRange',
'../../Core/defined',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/JulianDate',
'../getElement',
'./TimelineHighlightRange',
'./TimelineTrack'
], function(
ClockRange,
defined,
destroyObject,
DeveloperError,
JulianDate,
getElement,
TimelineHighlightRange,
TimelineTrack) {
'use strict';
var timelineWheelDelta = 1e12;
var timelineMouseMode = {
none : 0,
scrub : 1,
slide : 2,
zoom : 3,
touchOnly : 4
};
var timelineTouchMode = {
none : 0,
scrub : 1,
slideZoom : 2,
singleTap : 3,
ignore : 4
};
var timelineTicScales = [0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.25, 0.5, 1.0, 2.0, 5.0, 10.0, 15.0, 30.0, 60.0, // 1min
120.0, // 2min
300.0, // 5min
600.0, // 10min
900.0, // 15min
1800.0, // 30min
3600.0, // 1hr
7200.0, // 2hr
14400.0, // 4hr
21600.0, // 6hr
43200.0, // 12hr
86400.0, // 24hr
172800.0, // 2days
345600.0, // 4days
604800.0, // 7days
1296000.0, // 15days
2592000.0, // 30days
5184000.0, // 60days
7776000.0, // 90days
15552000.0, // 180days
31536000.0, // 365days
63072000.0, // 2years
126144000.0, // 4years
157680000.0, // 5years
315360000.0, // 10years
630720000.0, // 20years
1261440000.0, // 40years
1576800000.0, // 50years
3153600000.0, // 100years
6307200000.0, // 200years
12614400000.0, // 400years
15768000000.0, // 500years
31536000000.0 // 1000years
];
var timelineMonthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
/**
* The Timeline is a widget for displaying and controlling the current scene time.
* @alias Timeline
* @constructor
*
* @param {Element} container The parent HTML container node for this widget.
* @param {Clock} clock The clock to use.
*/
function Timeline(container, clock) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
if (!defined(clock)) {
throw new DeveloperError('clock is required.');
}
container = getElement(container);
/**
* Gets the parent container.
* @type {Element}
*/
this.container = container;
var topDiv = document.createElement('div');
topDiv.className = 'cesium-timeline-main';
container.appendChild(topDiv);
this._topDiv = topDiv;
this._endJulian = undefined;
this._epochJulian = undefined;
this._lastXPos = undefined;
this._scrubElement = undefined;
this._startJulian = undefined;
this._timeBarSecondsSpan = undefined;
this._clock = clock;
this._scrubJulian = clock.currentTime;
this._mainTicSpan = -1;
this._mouseMode = timelineMouseMode.none;
this._touchMode = timelineTouchMode.none;
this._touchState = {
centerX : 0,
spanX : 0
};
this._mouseX = 0;
this._timelineDrag = 0;
this._timelineDragLocation = undefined;
this._lastHeight = undefined;
this._lastWidth = undefined;
this._topDiv.innerHTML = '<div class="cesium-timeline-bar"></div><div class="cesium-timeline-trackContainer">' +
'<canvas class="cesium-timeline-tracks" width="10" height="1">' +
'</canvas></div><div class="cesium-timeline-needle"></div><span class="cesium-timeline-ruler"></span>';
this._timeBarEle = this._topDiv.childNodes[0];
this._trackContainer = this._topDiv.childNodes[1];
this._trackListEle = this._topDiv.childNodes[1].childNodes[0];
this._needleEle = this._topDiv.childNodes[2];
this._rulerEle = this._topDiv.childNodes[3];
this._context = this._trackListEle.getContext('2d');
this._trackList = [];
this._highlightRanges = [];
this.zoomTo(clock.startTime, clock.stopTime);
this._onMouseDown = createMouseDownCallback(this);
this._onMouseUp = createMouseUpCallback(this);
this._onMouseMove = createMouseMoveCallback(this);
this._onMouseWheel = createMouseWheelCallback(this);
this._onTouchStart = createTouchStartCallback(this);
this._onTouchMove = createTouchMoveCallback(this);
this._onTouchEnd = createTouchEndCallback(this);
var timeBarEle = this._timeBarEle;
document.addEventListener('mouseup', this._onMouseUp, false);
document.addEventListener('mousemove', this._onMouseMove, false);
timeBarEle.addEventListener('mousedown', this._onMouseDown, false);
timeBarEle.addEventListener('DOMMouseScroll', this._onMouseWheel, false); // Mozilla mouse wheel
timeBarEle.addEventListener('mousewheel', this._onMouseWheel, false);
timeBarEle.addEventListener('touchstart', this._onTouchStart, false);
timeBarEle.addEventListener('touchmove', this._onTouchMove, false);
timeBarEle.addEventListener('touchend', this._onTouchEnd, false);
timeBarEle.addEventListener('touchcancel', this._onTouchEnd, false);
this._topDiv.oncontextmenu = function() {
return false;
};
clock.onTick.addEventListener(this.updateFromClock, this);
this.updateFromClock();
}
/**
* @private
*/
Timeline.prototype.addEventListener = function(type, listener, useCapture) {
this._topDiv.addEventListener(type, listener, useCapture);
};
/**
* @private
*/
Timeline.prototype.removeEventListener = function(type, listener, useCapture) {
this._topDiv.removeEventListener(type, listener, useCapture);
};
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
Timeline.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
Timeline.prototype.destroy = function() {
this._clock.onTick.removeEventListener(this.updateFromClock, this);
document.removeEventListener('mouseup', this._onMouseUp, false);
document.removeEventListener('mousemove', this._onMouseMove, false);
var timeBarEle = this._timeBarEle;
timeBarEle.removeEventListener('mousedown', this._onMouseDown, false);
timeBarEle.removeEventListener('DOMMouseScroll', this._onMouseWheel, false); // Mozilla mouse wheel
timeBarEle.removeEventListener('mousewheel', this._onMouseWheel, false);
timeBarEle.removeEventListener('touchstart', this._onTouchStart, false);
timeBarEle.removeEventListener('touchmove', this._onTouchMove, false);
timeBarEle.removeEventListener('touchend', this._onTouchEnd, false);
timeBarEle.removeEventListener('touchcancel', this._onTouchEnd, false);
this.container.removeChild(this._topDiv);
destroyObject(this);
};
/**
* @private
*/
Timeline.prototype.addHighlightRange = function(color, heightInPx, base) {
var newHighlightRange = new TimelineHighlightRange(color, heightInPx, base);
this._highlightRanges.push(newHighlightRange);
this.resize();
return newHighlightRange;
};
/**
* @private
*/
Timeline.prototype.addTrack = function(interval, heightInPx, color, backgroundColor) {
var newTrack = new TimelineTrack(interval, heightInPx, color, backgroundColor);
this._trackList.push(newTrack);
this._lastHeight = undefined;
this.resize();
return newTrack;
};
/**
* Sets the view to the provided times.
*
* @param {JulianDate} startTime The start time.
* @param {JulianDate} stopTime The stop time.
*/
Timeline.prototype.zoomTo = function(startTime, stopTime) {
if (!defined(startTime)) {
throw new DeveloperError('startTime is required.');
}
if (!defined(stopTime)) {
throw new DeveloperError('stopTime is required');
}
if (JulianDate.lessThanOrEquals(stopTime, startTime)) {
throw new DeveloperError('Start time must come before end time.');
}
this._startJulian = startTime;
this._endJulian = stopTime;
this._timeBarSecondsSpan = JulianDate.secondsDifference(stopTime, startTime);
// If clock is not unbounded, clamp timeline range to clock.
if (this._clock && (this._clock.clockRange !== ClockRange.UNBOUNDED)) {
var clockStart = this._clock.startTime;
var clockEnd = this._clock.stopTime;
var clockSpan = JulianDate.secondsDifference(clockEnd, clockStart);
var startOffset = JulianDate.secondsDifference(clockStart, this._startJulian);
var endOffset = JulianDate.secondsDifference(clockEnd, this._endJulian);
if (this._timeBarSecondsSpan >= clockSpan) {
// if new duration longer than clock range duration, clamp to full range.
this._timeBarSecondsSpan = clockSpan;
this._startJulian = this._clock.startTime;
this._endJulian = this._clock.stopTime;
} else if (startOffset > 0) {
// if timeline start is before clock start, shift right
this._endJulian = JulianDate.addSeconds(this._endJulian, startOffset, new JulianDate());
this._startJulian = clockStart;
this._timeBarSecondsSpan = JulianDate.secondsDifference(this._endJulian, this._startJulian);
} else if (endOffset < 0) {
// if timeline end is after clock end, shift left
this._startJulian = JulianDate.addSeconds(this._startJulian, endOffset, new JulianDate());
this._endJulian = clockEnd;
this._timeBarSecondsSpan = JulianDate.secondsDifference(this._endJulian, this._startJulian);
}
}
this._makeTics();
var evt = document.createEvent('Event');
evt.initEvent('setzoom', true, true);
evt.startJulian = this._startJulian;
evt.endJulian = this._endJulian;
evt.epochJulian = this._epochJulian;
evt.totalSpan = this._timeBarSecondsSpan;
evt.mainTicSpan = this._mainTicSpan;
this._topDiv.dispatchEvent(evt);
};
/**
* @private
*/
Timeline.prototype.zoomFrom = function(amount) {
var centerSec = JulianDate.secondsDifference(this._scrubJulian, this._startJulian);
if ((amount > 1) || (centerSec < 0) || (centerSec > this._timeBarSecondsSpan)) {
centerSec = this._timeBarSecondsSpan * 0.5;
} else {
centerSec += (centerSec - this._timeBarSecondsSpan * 0.5);
}
var centerSecFlip = this._timeBarSecondsSpan - centerSec;
this.zoomTo(JulianDate.addSeconds(this._startJulian, centerSec - (centerSec * amount), new JulianDate()), JulianDate.addSeconds(this._endJulian, (centerSecFlip * amount) - centerSecFlip, new JulianDate()));
};
function twoDigits(num) {
return ((num < 10) ? ('0' + num.toString()) : num.toString());
}
/**
* @private
*/
Timeline.prototype.makeLabel = function(time) {
var gregorian = JulianDate.toGregorianDate(time);
var millisecond = gregorian.millisecond, millisecondString = ' UTC';
if ((millisecond > 0) && (this._timeBarSecondsSpan < 3600)) {
millisecondString = Math.floor(millisecond).toString();
while (millisecondString.length < 3) {
millisecondString = '0' + millisecondString;
}
millisecondString = '.' + millisecondString;
}
return timelineMonthNames[gregorian.month - 1] + ' ' + gregorian.day + ' ' + gregorian.year + ' ' + twoDigits(gregorian.hour) +
':' + twoDigits(gregorian.minute) + ':' + twoDigits(gregorian.second) + millisecondString;
};
/**
* @private
*/
Timeline.prototype.smallestTicInPixels = 7.0;
/**
* @private
*/
Timeline.prototype._makeTics = function() {
var timeBar = this._timeBarEle;
var seconds = JulianDate.secondsDifference(this._scrubJulian, this._startJulian);
var xPos = Math.round(seconds * this._topDiv.clientWidth / this._timeBarSecondsSpan);
var scrubX = xPos - 8, tic;
var widget = this;
this._needleEle.style.left = xPos.toString() + 'px';
var tics = '';
var minimumDuration = 0.01;
var maximumDuration = 31536000000.0; // ~1000 years
var epsilon = 1e-10;
// If time step size is known, enter it here...
var minSize = 0;
var duration = this._timeBarSecondsSpan;
if (duration < minimumDuration) {
duration = minimumDuration;
this._timeBarSecondsSpan = minimumDuration;
this._endJulian = JulianDate.addSeconds(this._startJulian, minimumDuration, new JulianDate());
} else if (duration > maximumDuration) {
duration = maximumDuration;
this._timeBarSecondsSpan = maximumDuration;
this._endJulian = JulianDate.addSeconds(this._startJulian, maximumDuration, new JulianDate());
}
var timeBarWidth = this._timeBarEle.clientWidth;
if (timeBarWidth < 10) {
timeBarWidth = 10;
}
var startJulian = this._startJulian;
// epsilonTime: a small fraction of one pixel width of the timeline, measured in seconds.
var epsilonTime = Math.min((duration / timeBarWidth) * 1e-5, 0.4);
// epochJulian: a nearby time to be considered "zero seconds", should be a round-ish number by human standards.
var epochJulian;
var gregorianDate = JulianDate.toGregorianDate(startJulian);
if (duration > 315360000) { // 3650+ days visible, epoch is start of the first visible century.
epochJulian = JulianDate.fromDate(new Date(Date.UTC(Math.floor(gregorianDate.year / 100) * 100, 0)));
} else if (duration > 31536000) { // 365+ days visible, epoch is start of the first visible decade.
epochJulian = JulianDate.fromDate(new Date(Date.UTC(Math.floor(gregorianDate.year / 10) * 10, 0)));
} else if (duration > 86400) { // 1+ day(s) visible, epoch is start of the year.
epochJulian = JulianDate.fromDate(new Date(Date.UTC(gregorianDate.year, 0)));
} else { // Less than a day on timeline, epoch is midnight of the visible day.
epochJulian = JulianDate.fromDate(new Date(Date.UTC(gregorianDate.year, gregorianDate.month, gregorianDate.day)));
}
// startTime: Seconds offset of the left side of the timeline from epochJulian.
var startTime = JulianDate.secondsDifference(this._startJulian, JulianDate.addSeconds(epochJulian, epsilonTime, new JulianDate()));
// endTime: Seconds offset of the right side of the timeline from epochJulian.
var endTime = startTime + duration;
this._epochJulian = epochJulian;
function getStartTic(ticScale) {
return Math.floor(startTime / ticScale) * ticScale;
}
function getNextTic(tic, ticScale) {
return Math.ceil((tic / ticScale) + 0.5) * ticScale;
}
function getAlpha(time) {
return (time - startTime) / duration;
}
function remainder(x, y) {
//return x % y;
return x - (y * Math.round(x / y));
}
// Width in pixels of a typical label, plus padding
this._rulerEle.innerHTML = this.makeLabel(JulianDate.addSeconds(this._endJulian, -minimumDuration, new JulianDate()));
var sampleWidth = this._rulerEle.offsetWidth + 20;
if (sampleWidth < 30) {
// Workaround an apparent IE bug with measuring the width after going full-screen from inside an iframe.
sampleWidth = 180;
}
var origMinSize = minSize;
minSize -= epsilon;
var renderState = {
startTime : startTime,
startJulian : startJulian,
epochJulian : epochJulian,
duration : duration,
timeBarWidth : timeBarWidth,
getAlpha : getAlpha
};
this._highlightRanges.forEach(function(highlightRange) {
tics += highlightRange.render(renderState);
});
// Calculate tic mark label spacing in the TimeBar.
var mainTic = 0.0, subTic = 0.0, tinyTic = 0.0;
// Ideal labeled tic as percentage of zoom interval
var idealTic = sampleWidth / timeBarWidth;
if (idealTic > 1.0) {
// Clamp to width of window, for thin windows.
idealTic = 1.0;
}
// Ideal labeled tic size in seconds
idealTic *= this._timeBarSecondsSpan;
var ticIndex = -1, smallestIndex = -1;
var i, ticScaleLen = timelineTicScales.length;
for (i = 0; i < ticScaleLen; ++i) {
var sc = timelineTicScales[i];
++ticIndex;
mainTic = sc;
// Find acceptable main tic size not smaller than ideal size.
if ((sc > idealTic) && (sc > minSize)) {
break;
}
if ((smallestIndex < 0) && ((timeBarWidth * (sc / this._timeBarSecondsSpan)) >= this.smallestTicInPixels)) {
smallestIndex = ticIndex;
}
}
if (ticIndex > 0) {
while (ticIndex > 0) // Compute sub-tic size that evenly divides main tic.
{
--ticIndex;
if (Math.abs(remainder(mainTic, timelineTicScales[ticIndex])) < 0.00001) {
if (timelineTicScales[ticIndex] >= minSize) {
subTic = timelineTicScales[ticIndex];
}
break;
}
}
if (smallestIndex >= 0) {
while (smallestIndex < ticIndex) // Compute tiny tic size that evenly divides sub-tic.
{
if ((Math.abs(remainder(subTic, timelineTicScales[smallestIndex])) < 0.00001) && (timelineTicScales[smallestIndex] >= minSize)) {
tinyTic = timelineTicScales[smallestIndex];
break;
}
++smallestIndex;
}
}
}
minSize = origMinSize;
if ((minSize > epsilon) && (tinyTic < 0.00001) && (Math.abs(minSize - mainTic) > epsilon)) {
tinyTic = minSize;
if (minSize <= (mainTic + epsilon)) {
subTic = 0.0;
}
}
var lastTextLeft = -999999, textWidth;
if ((timeBarWidth * (tinyTic / this._timeBarSecondsSpan)) >= 3.0) {
for (tic = getStartTic(tinyTic); tic <= endTime; tic = getNextTic(tic, tinyTic)) {
tics += '<span class="cesium-timeline-ticTiny" style="left: ' + Math.round(timeBarWidth * getAlpha(tic)).toString() + 'px;"></span>';
}
}
if ((timeBarWidth * (subTic / this._timeBarSecondsSpan)) >= 3.0) {
for (tic = getStartTic(subTic); tic <= endTime; tic = getNextTic(tic, subTic)) {
tics += '<span class="cesium-timeline-ticSub" style="left: ' + Math.round(timeBarWidth * getAlpha(tic)).toString() + 'px;"></span>';
}
}
if ((timeBarWidth * (mainTic / this._timeBarSecondsSpan)) >= 2.0) {
this._mainTicSpan = mainTic;
endTime += mainTic;
tic = getStartTic(mainTic);
var leapSecond = JulianDate.computeTaiMinusUtc(epochJulian);
while (tic <= endTime) {
var ticTime = JulianDate.addSeconds(startJulian, tic - startTime, new JulianDate());
if (mainTic > 2.1) {
var ticLeap = JulianDate.computeTaiMinusUtc(ticTime);
if (Math.abs(ticLeap - leapSecond) > 0.1) {
tic += (ticLeap - leapSecond);
ticTime = JulianDate.addSeconds(startJulian, tic - startTime, new JulianDate());
}
}
var ticLeft = Math.round(timeBarWidth * getAlpha(tic));
var ticLabel = this.makeLabel(ticTime);
this._rulerEle.innerHTML = ticLabel;
textWidth = this._rulerEle.offsetWidth;
if (textWidth < 10) {
// IE iframe fullscreen sampleWidth workaround, continued.
textWidth = sampleWidth;
}
var labelLeft = ticLeft - ((textWidth / 2) - 1);
if (labelLeft > lastTextLeft) {
lastTextLeft = labelLeft + textWidth + 5;
tics += '<span class="cesium-timeline-ticMain" style="left: ' + ticLeft.toString() + 'px;"></span>' + '<span class="cesium-timeline-ticLabel" style="left: ' + labelLeft.toString() +
'px;">' + ticLabel + '</span>';
} else {
tics += '<span class="cesium-timeline-ticSub" style="left: ' + ticLeft.toString() + 'px;"></span>';
}
tic = getNextTic(tic, mainTic);
}
} else {
this._mainTicSpan = -1;
}
tics += '<span class="cesium-timeline-icon16" style="left:' + scrubX + 'px;bottom:0;background-position: 0 0;"></span>';
timeBar.innerHTML = tics;
this._scrubElement = timeBar.lastChild;
// Clear track canvas.
this._context.clearRect(0, 0, this._trackListEle.width, this._trackListEle.height);
renderState.y = 0;
this._trackList.forEach(function(track) {
track.render(widget._context, renderState);
renderState.y += track.height;
});
};
/**
* @private
*/
Timeline.prototype.updateFromClock = function() {
this._scrubJulian = this._clock.currentTime;
var scrubElement = this._scrubElement;
if (defined(this._scrubElement)) {
var seconds = JulianDate.secondsDifference(this._scrubJulian, this._startJulian);
var xPos = Math.round(seconds * this._topDiv.clientWidth / this._timeBarSecondsSpan);
if (this._lastXPos !== xPos) {
this._lastXPos = xPos;
scrubElement.style.left = (xPos - 8) + 'px';
this._needleEle.style.left = xPos + 'px';
}
}
if (defined(this._timelineDragLocation)) {
this._setTimeBarTime(this._timelineDragLocation, this._timelineDragLocation * this._timeBarSecondsSpan / this._topDiv.clientWidth);
this.zoomTo(JulianDate.addSeconds(this._startJulian, this._timelineDrag, new JulianDate()), JulianDate.addSeconds(this._endJulian, this._timelineDrag, new JulianDate()));
}
};
/**
* @private
*/
Timeline.prototype._setTimeBarTime = function(xPos, seconds) {
xPos = Math.round(xPos);
this._scrubJulian = JulianDate.addSeconds(this._startJulian, seconds, new JulianDate());
if (this._scrubElement) {
var scrubX = xPos - 8;
this._scrubElement.style.left = scrubX.toString() + 'px';
this._needleEle.style.left = xPos.toString() + 'px';
}
var evt = document.createEvent('Event');
evt.initEvent('settime', true, true);
evt.clientX = xPos;
evt.timeSeconds = seconds;
evt.timeJulian = this._scrubJulian;
evt.clock = this._clock;
this._topDiv.dispatchEvent(evt);
};
function createMouseDownCallback(timeline) {
return function(e) {
if (timeline._mouseMode !== timelineMouseMode.touchOnly) {
if (e.button === 0) {
timeline._mouseMode = timelineMouseMode.scrub;
if (timeline._scrubElement) {
timeline._scrubElement.style.backgroundPosition = '-16px 0';
}
timeline._onMouseMove(e);
} else {
timeline._mouseX = e.clientX;
if (e.button === 2) {
timeline._mouseMode = timelineMouseMode.zoom;
} else {
timeline._mouseMode = timelineMouseMode.slide;
}
}
}
e.preventDefault();
};
}
function createMouseUpCallback(timeline) {
return function(e) {
timeline._mouseMode = timelineMouseMode.none;
if (timeline._scrubElement) {
timeline._scrubElement.style.backgroundPosition = '0 0';
}
timeline._timelineDrag = 0;
timeline._timelineDragLocation = undefined;
};
}
function createMouseMoveCallback(timeline) {
return function(e) {
var dx;
if (timeline._mouseMode === timelineMouseMode.scrub) {
e.preventDefault();
var x = e.clientX - timeline._topDiv.getBoundingClientRect().left;
if (x < 0) {
timeline._timelineDragLocation = 0;
timeline._timelineDrag = -0.01 * timeline._timeBarSecondsSpan;
} else if (x > timeline._topDiv.clientWidth) {
timeline._timelineDragLocation = timeline._topDiv.clientWidth;
timeline._timelineDrag = 0.01 * timeline._timeBarSecondsSpan;
} else {
timeline._timelineDragLocation = undefined;
timeline._setTimeBarTime(x, x * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth);
}
} else if (timeline._mouseMode === timelineMouseMode.slide) {
dx = timeline._mouseX - e.clientX;
timeline._mouseX = e.clientX;
if (dx !== 0) {
var dsec = dx * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth;
timeline.zoomTo(JulianDate.addSeconds(timeline._startJulian, dsec, new JulianDate()), JulianDate.addSeconds(timeline._endJulian, dsec, new JulianDate()));
}
} else if (timeline._mouseMode === timelineMouseMode.zoom) {
dx = timeline._mouseX - e.clientX;
timeline._mouseX = e.clientX;
if (dx !== 0) {
timeline.zoomFrom(Math.pow(1.01, dx));
}
}
};
}
function createMouseWheelCallback(timeline) {
return function(e) {
var dy = e.wheelDeltaY || e.wheelDelta || (-e.detail);
timelineWheelDelta = Math.max(Math.min(Math.abs(dy), timelineWheelDelta), 1);
dy /= timelineWheelDelta;
timeline.zoomFrom(Math.pow(1.05, -dy));
};
}
function createTouchStartCallback(timeline) {
return function(e) {
var len = e.touches.length, seconds, xPos, leftX = timeline._topDiv.getBoundingClientRect().left;
e.preventDefault();
timeline._mouseMode = timelineMouseMode.touchOnly;
if (len === 1) {
seconds = JulianDate.secondsDifference(timeline._scrubJulian, timeline._startJulian);
xPos = Math.round(seconds * timeline._topDiv.clientWidth / timeline._timeBarSecondsSpan + leftX);
if (Math.abs(e.touches[0].clientX - xPos) < 50) {
timeline._touchMode = timelineTouchMode.scrub;
if (timeline._scrubElement) {
timeline._scrubElement.style.backgroundPosition = (len === 1) ? '-16px 0' : '0 0';
}
} else {
timeline._touchMode = timelineTouchMode.singleTap;
timeline._touchState.centerX = e.touches[0].clientX - leftX;
}
} else if (len === 2) {
timeline._touchMode = timelineTouchMode.slideZoom;
timeline._touchState.centerX = (e.touches[0].clientX + e.touches[1].clientX) * 0.5 - leftX;
timeline._touchState.spanX = Math.abs(e.touches[0].clientX - e.touches[1].clientX);
} else {
timeline._touchMode = timelineTouchMode.ignore;
}
};
}
function createTouchEndCallback(timeline) {
return function(e) {
var len = e.touches.length, leftX = timeline._topDiv.getBoundingClientRect().left;
if (timeline._touchMode === timelineTouchMode.singleTap) {
timeline._touchMode = timelineTouchMode.scrub;
timeline._onTouchMove(e);
} else if (timeline._touchMode === timelineTouchMode.scrub) {
timeline._onTouchMove(e);
}
timeline._mouseMode = timelineMouseMode.touchOnly;
if (len !== 1) {
timeline._touchMode = (len > 0) ? timelineTouchMode.ignore : timelineTouchMode.none;
} else if (timeline._touchMode === timelineTouchMode.slideZoom) {
timeline._touchState.centerX = e.touches[0].clientX - leftX;
}
if (timeline._scrubElement) {
timeline._scrubElement.style.backgroundPosition = '0 0';
}
};
}
function createTouchMoveCallback(timeline) {
return function(e) {
var dx, x, len, newCenter, newSpan, newStartTime, zoom = 1, leftX = timeline._topDiv.getBoundingClientRect().left;
if (timeline._touchMode === timelineTouchMode.singleTap) {
timeline._touchMode = timelineTouchMode.slideZoom;
}
timeline._mouseMode = timelineMouseMode.touchOnly;
if (timeline._touchMode === timelineTouchMode.scrub) {
e.preventDefault();
if (e.changedTouches.length === 1) {
x = e.changedTouches[0].clientX - leftX;
if ((x >= 0) && (x <= timeline._topDiv.clientWidth)) {
timeline._setTimeBarTime(x, x * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth);
}
}
} else if (timeline._touchMode === timelineTouchMode.slideZoom) {
len = e.touches.length;
if (len === 2) {
newCenter = (e.touches[0].clientX + e.touches[1].clientX) * 0.5 - leftX;
newSpan = Math.abs(e.touches[0].clientX - e.touches[1].clientX);
} else if (len === 1) {
newCenter = e.touches[0].clientX - leftX;
newSpan = 0;
}
if (defined(newCenter)) {
if ((newSpan > 0) && (timeline._touchState.spanX > 0)) {
// Zoom and slide
zoom = (timeline._touchState.spanX / newSpan);
newStartTime = JulianDate.addSeconds(timeline._startJulian, ((timeline._touchState.centerX * timeline._timeBarSecondsSpan) - (newCenter * timeline._timeBarSecondsSpan * zoom)) / timeline._topDiv.clientWidth, new JulianDate());
} else {
// Slide to newCenter
dx = timeline._touchState.centerX - newCenter;
newStartTime = JulianDate.addSeconds(timeline._startJulian, dx * timeline._timeBarSecondsSpan / timeline._topDiv.clientWidth, new JulianDate());
}
timeline.zoomTo(newStartTime, JulianDate.addSeconds(newStartTime, timeline._timeBarSecondsSpan * zoom, new JulianDate()));
timeline._touchState.centerX = newCenter;
timeline._touchState.spanX = newSpan;
}
}
};
}
/**
* Resizes the widget to match the container size.
*/
Timeline.prototype.resize = function() {
var width = this.container.clientWidth;
var height = this.container.clientHeight;
if (width === this._lastWidth && height === this._lastHeight) {
return;
}
this._trackContainer.style.height = height + 'px';
var trackListHeight = 1;
this._trackList.forEach(function(track) {
trackListHeight += track.height;
});
this._trackListEle.style.height = trackListHeight.toString() + 'px';
this._trackListEle.width = this._trackListEle.clientWidth;
this._trackListEle.height = trackListHeight;
this._makeTics();
this._lastXPos = undefined;
this._lastWidth = width;
this._lastHeight = height;
};
return Timeline;
});
/*global define*/
define('Widgets/VRButton/VRButtonViewModel',[
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/Fullscreen',
'../../ThirdParty/knockout',
'../../ThirdParty/NoSleep',
'../createCommand',
'../getElement'
], function(
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
Fullscreen,
knockout,
NoSleep,
createCommand,
getElement) {
'use strict';
function lockScreen(orientation) {
var locked = false;
var screen = window.screen;
if (defined(screen)) {
if (defined(screen.lockOrientation)) {
locked = screen.lockOrientation(orientation);
} else if (defined(screen.mozLockOrientation)) {
locked = screen.mozLockOrientation(orientation);
} else if (defined(screen.msLockOrientation)) {
locked = screen.msLockOrientation(orientation);
} else if (defined(screen.orientation && screen.orientation.lock)) {
locked = screen.orientation.lock(orientation);
}
}
return locked;
}
function unlockScreen() {
var screen = window.screen;
if (defined(screen)) {
if (defined(screen.unlockOrientation)) {
screen.unlockOrientation();
} else if (defined(screen.mozUnlockOrientation)) {
screen.mozUnlockOrientation();
} else if (defined(screen.msUnlockOrientation)) {
screen.msUnlockOrientation();
} else if (defined(screen.orientation && screen.orientation.unlock)) {
screen.orientation.unlock();
}
}
}
function toggleVR(viewModel, scene, isVRMode) {
if (isVRMode()) {
scene.useWebVR = false;
if (viewModel._locked) {
unlockScreen();
viewModel._locked = false;
}
viewModel._noSleep.disable();
Fullscreen.exitFullscreen();
isVRMode(false);
} else {
if (!Fullscreen.fullscreen) {
Fullscreen.requestFullscreen(viewModel._vrElement);
}
viewModel._noSleep.enable();
if (!viewModel._locked) {
viewModel._locked = lockScreen('landscape');
}
scene.useWebVR = true;
isVRMode(true);
}
}
/**
* The view model for {@link VRButton}.
* @alias VRButtonViewModel
* @constructor
*
* @param {Scene} scene The scene.
* @param {Element|String} [vrElement=document.body] The element or id to be placed into VR mode.
*/
function VRButtonViewModel(scene, vrElement) {
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
var that = this;
var isEnabled = knockout.observable(Fullscreen.enabled);
var isVRMode = knockout.observable(false);
/**
* Gets whether or not VR mode is active.
*
* @type {Boolean}
*/
this.isVRMode = undefined;
knockout.defineProperty(this, 'isVRMode', {
get : function() {
return isVRMode();
}
});
/**
* Gets or sets whether or not VR functionality should be enabled.
*
* @type {Boolean}
* @see Fullscreen.enabled
*/
this.isVREnabled = undefined;
knockout.defineProperty(this, 'isVREnabled', {
get : function() {
return isEnabled();
},
set : function(value) {
isEnabled(value && Fullscreen.enabled);
}
});
/**
* Gets the tooltip. This property is observable.
*
* @type {String}
*/
this.tooltip = undefined;
knockout.defineProperty(this, 'tooltip', function() {
if (!isEnabled()) {
return 'VR mode is unavailable';
}
return isVRMode() ? 'Exit VR mode' : 'Enter VR mode';
});
this._locked = false;
this._noSleep = new NoSleep();
this._command = createCommand(function() {
toggleVR(that, scene, isVRMode);
}, knockout.getObservable(this, 'isVREnabled'));
this._vrElement = defaultValue(getElement(vrElement), document.body);
this._callback = function() {
if (!Fullscreen.fullscreen && isVRMode()) {
scene.useWebVR = false;
if (that._locked) {
unlockScreen();
that._locked = false;
}
that._noSleep.disable();
isVRMode(false);
}
};
document.addEventListener(Fullscreen.changeEventName, this._callback);
}
defineProperties(VRButtonViewModel.prototype, {
/**
* Gets or sets the HTML element to place into VR mode when the
* corresponding button is pressed.
* @memberof VRButtonViewModel.prototype
*
* @type {Element}
*/
vrElement : {
//TODO:@exception {DeveloperError} value must be a valid HTML Element.
get : function() {
return this._vrElement;
},
set : function(value) {
if (!(value instanceof Element)) {
throw new DeveloperError('value must be a valid Element.');
}
this._vrElement = value;
}
},
/**
* Gets the Command to toggle VR mode.
* @memberof VRButtonViewModel.prototype
*
* @type {Command}
*/
command : {
get : function() {
return this._command;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
VRButtonViewModel.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the view model. Should be called to
* properly clean up the view model when it is no longer needed.
*/
VRButtonViewModel.prototype.destroy = function() {
destroyObject(this);
};
return VRButtonViewModel;
});
/*global define*/
define('Widgets/VRButton/VRButton',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../ThirdParty/knockout',
'../getElement',
'./VRButtonViewModel'
], function(
defined,
defineProperties,
destroyObject,
DeveloperError,
knockout,
getElement,
VRButtonViewModel) {
'use strict';
var enterVRPath = 'M 5.3125 6.375 C 4.008126 6.375 2.96875 7.4141499 2.96875 8.71875 L 2.96875 19.5 C 2.96875 20.8043 4.008126 21.875 5.3125 21.875 L 13.65625 21.875 C 13.71832 20.0547 14.845166 18.59375 16.21875 18.59375 C 17.592088 18.59375 18.71881 20.0552 18.78125 21.875 L 27.09375 21.875 C 28.398125 21.875 29.4375 20.8043 29.4375 19.5 L 29.4375 8.71875 C 29.4375 7.4141499 28.398125 6.375 27.09375 6.375 L 5.3125 6.375 z M 9.625 10.4375 C 11.55989 10.4375 13.125 12.03385 13.125 13.96875 C 13.125 15.90365 11.55989 17.46875 9.625 17.46875 C 7.69011 17.46875 6.125 15.90365 6.125 13.96875 C 6.125 12.03385 7.69011 10.4375 9.625 10.4375 z M 22.46875 10.4375 C 24.40364 10.4375 25.96875 12.03385 25.96875 13.96875 C 25.96875 15.90365 24.40364 17.46875 22.46875 17.46875 C 20.53386 17.46875 18.96875 15.90365 18.96875 13.96875 C 18.96875 12.03385 20.53386 10.4375 22.46875 10.4375 z';
var exitVRPath = 'M 25.770585,2.4552065 C 15.72282,13.962707 10.699956,19.704407 8.1768352,22.580207 c -1.261561,1.4379 -1.902282,2.1427 -2.21875,2.5 -0.141624,0.1599 -0.208984,0.2355 -0.25,0.2813 l 0.6875,0.75 c 10e-5,-10e-5 0.679191,0.727 0.6875,0.7187 0.01662,-0.016 0.02451,-0.024 0.03125,-0.031 0.01348,-0.014 0.04013,-0.038 0.0625,-0.062 0.04474,-0.05 0.120921,-0.1315 0.28125,-0.3126 0.320657,-0.3619 0.956139,-1.0921 2.2187499,-2.5312 2.5252219,-2.8781 7.5454589,-8.6169 17.5937499,-20.1250005 l -1.5,-1.3125 z m -20.5624998,3.9063 c -1.304375,0 -2.34375,1.0391 -2.34375,2.3437 l 0,10.8125005 c 0,1.3043 1.039375,2.375 2.34375,2.375 l 2.25,0 c 1.9518039,-2.2246 7.4710958,-8.5584 13.5624998,-15.5312005 l -15.8124998,0 z m 21.1249998,0 c -1.855467,2.1245 -2.114296,2.4005 -3.59375,4.0936995 1.767282,0.1815 3.15625,1.685301 3.15625,3.500001 0,1.9349 -1.56511,3.5 -3.5,3.5 -1.658043,0 -3.043426,-1.1411 -3.40625,-2.6875 -1.089617,1.2461 -2.647139,2.9988 -3.46875,3.9375 0.191501,-0.062 0.388502,-0.094 0.59375,-0.094 1.373338,0 2.50006,1.4614 2.5625,3.2812 l 8.3125,0 c 1.304375,0 2.34375,-1.0707 2.34375,-2.375 l 0,-10.8125005 c 0,-1.3046 -1.039375,-2.3437 -2.34375,-2.3437 l -0.65625,0 z M 9.5518351,10.423906 c 1.9348899,0 3.4999999,1.596401 3.4999999,3.531301 0,1.9349 -1.56511,3.5 -3.4999999,3.5 -1.9348899,0 -3.4999999,-1.5651 -3.4999999,-3.5 0,-1.9349 1.56511,-3.531301 3.4999999,-3.531301 z m 4.2187499,10.312601 c -0.206517,0.2356 -0.844218,0.9428 -1.03125,1.1562 l 0.8125,0 c 0.01392,-0.4081 0.107026,-0.7968 0.21875,-1.1562 z';
/**
* A single button widget for toggling vr mode.
*
* @alias VRButton
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Scene} scene The scene.
* @param {Element|String} [vrElement=document.body] The element or id to be placed into vr mode.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
*/
function VRButton(container, scene, vrElement) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
if (!defined(scene)) {
throw new DeveloperError('scene is required.');
}
container = getElement(container);
var viewModel = new VRButtonViewModel(scene, vrElement);
viewModel._exitVRPath = exitVRPath;
viewModel._enterVRPath = enterVRPath;
var element = document.createElement('button');
element.type = 'button';
element.className = 'cesium-button cesium-vrButton';
element.setAttribute('data-bind', '\
attr: { title: tooltip },\
click: command,\
enable: isVREnabled,\
cesiumSvgPath: { path: isVRMode ? _exitVRPath : _enterVRPath, width: 32, height: 32 }');
container.appendChild(element);
knockout.applyBindings(viewModel, element);
this._container = container;
this._viewModel = viewModel;
this._element = element;
}
defineProperties(VRButton.prototype, {
/**
* Gets the parent container.
* @memberof VRButton.prototype
*
* @type {Element}
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the view model.
* @memberof VRButton.prototype
*
* @type {VRButtonViewModel}
*/
viewModel : {
get : function() {
return this._viewModel;
}
}
});
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
VRButton.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
VRButton.prototype.destroy = function() {
this._viewModel.destroy();
knockout.cleanNode(this._element);
this._container.removeChild(this._element);
return destroyObject(this);
};
return VRButton;
});
/*global define*/
define('Widgets/Viewer/Viewer',[
'../../Core/BoundingSphere',
'../../Core/Cartesian3',
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/destroyObject',
'../../Core/DeveloperError',
'../../Core/EventHelper',
'../../Core/isArray',
'../../Core/Matrix4',
'../../Core/Rectangle',
'../../Core/ScreenSpaceEventType',
'../../DataSources/BoundingSphereState',
'../../DataSources/ConstantPositionProperty',
'../../DataSources/DataSourceCollection',
'../../DataSources/DataSourceDisplay',
'../../DataSources/Entity',
'../../DataSources/EntityView',
'../../DataSources/Property',
'../../Scene/ImageryLayer',
'../../Scene/SceneMode',
'../../ThirdParty/knockout',
'../../ThirdParty/when',
'../Animation/Animation',
'../Animation/AnimationViewModel',
'../BaseLayerPicker/BaseLayerPicker',
'../BaseLayerPicker/createDefaultImageryProviderViewModels',
'../BaseLayerPicker/createDefaultTerrainProviderViewModels',
'../CesiumWidget/CesiumWidget',
'../ClockViewModel',
'../FullscreenButton/FullscreenButton',
'../Geocoder/Geocoder',
'../getElement',
'../HomeButton/HomeButton',
'../InfoBox/InfoBox',
'../NavigationHelpButton/NavigationHelpButton',
'../SceneModePicker/SceneModePicker',
'../SelectionIndicator/SelectionIndicator',
'../subscribeAndEvaluate',
'../Timeline/Timeline',
'../VRButton/VRButton'
], function(
BoundingSphere,
Cartesian3,
defaultValue,
defined,
defineProperties,
destroyObject,
DeveloperError,
EventHelper,
isArray,
Matrix4,
Rectangle,
ScreenSpaceEventType,
BoundingSphereState,
ConstantPositionProperty,
DataSourceCollection,
DataSourceDisplay,
Entity,
EntityView,
Property,
ImageryLayer,
SceneMode,
knockout,
when,
Animation,
AnimationViewModel,
BaseLayerPicker,
createDefaultImageryProviderViewModels,
createDefaultTerrainProviderViewModels,
CesiumWidget,
ClockViewModel,
FullscreenButton,
Geocoder,
getElement,
HomeButton,
InfoBox,
NavigationHelpButton,
SceneModePicker,
SelectionIndicator,
subscribeAndEvaluate,
Timeline,
VRButton) {
'use strict';
var boundingSphereScratch = new BoundingSphere();
function onTimelineScrubfunction(e) {
var clock = e.clock;
clock.currentTime = e.timeJulian;
clock.shouldAnimate = false;
}
function pickEntity(viewer, e) {
var picked = viewer.scene.pick(e.position);
if (defined(picked)) {
var id = defaultValue(picked.id, picked.primitive.id);
if (id instanceof Entity) {
return id;
}
}
// No regular entity picked. Try picking features from imagery layers.
if (defined(viewer.scene.globe)) {
return pickImageryLayerFeature(viewer, e.position);
}
}
function trackDataSourceClock(timeline, clock, dataSource) {
if (defined(dataSource)) {
var dataSourceClock = dataSource.clock;
if (defined(dataSourceClock)) {
dataSourceClock.getValue(clock);
if (defined(timeline)) {
timeline.updateFromClock();
timeline.zoomTo(dataSourceClock.startTime, dataSourceClock.stopTime);
}
}
}
}
var cartesian3Scratch = new Cartesian3();
function pickImageryLayerFeature(viewer, windowPosition) {
var scene = viewer.scene;
var pickRay = scene.camera.getPickRay(windowPosition);
var imageryLayerFeaturePromise = scene.imageryLayers.pickImageryLayerFeatures(pickRay, scene);
if (!defined(imageryLayerFeaturePromise)) {
return;
}
// Imagery layer feature picking is asynchronous, so put up a message while loading.
var loadingMessage = new Entity({
id : 'Loading...',
description : 'Loading feature information...'
});
when(imageryLayerFeaturePromise, function(features) {
// Has this async pick been superseded by a later one?
if (viewer.selectedEntity !== loadingMessage) {
return;
}
if (!defined(features) || features.length === 0) {
viewer.selectedEntity = createNoFeaturesEntity();
return;
}
// Select the first feature.
var feature = features[0];
var entity = new Entity({
id : feature.name,
description : feature.description
});
if (defined(feature.position)) {
var ecfPosition = viewer.scene.globe.ellipsoid.cartographicToCartesian(feature.position, cartesian3Scratch);
entity.position = new ConstantPositionProperty(ecfPosition);
}
viewer.selectedEntity = entity;
}, function() {
// Has this async pick been superseded by a later one?
if (viewer.selectedEntity !== loadingMessage) {
return;
}
viewer.selectedEntity = createNoFeaturesEntity();
});
return loadingMessage;
}
function createNoFeaturesEntity() {
return new Entity({
id : 'None',
description : 'No features found.'
});
}
function enableVRUI(viewer, enabled) {
var geocoder = viewer._geocoder;
var homeButton = viewer._homeButton;
var sceneModePicker = viewer._sceneModePicker;
var baseLayerPicker = viewer._baseLayerPicker;
var animation = viewer._animation;
var timeline = viewer._timeline;
var fullscreenButton = viewer._fullscreenButton;
var infoBox = viewer._infoBox;
var selectionIndicator = viewer._selectionIndicator;
var visibility = enabled ? 'hidden' : 'visible';
if (defined(geocoder)) {
geocoder.container.style.visibility = visibility;
}
if (defined(homeButton)) {
homeButton.container.style.visibility = visibility;
}
if(defined(sceneModePicker)) {
sceneModePicker.container.style.visibility = visibility;
}
if(defined(baseLayerPicker)) {
baseLayerPicker.container.style.visibility = visibility;
}
if (defined(animation)) {
animation.container.style.visibility = visibility;
}
if (defined(timeline)) {
timeline.container.style.visibility = visibility;
}
if (defined(fullscreenButton) && fullscreenButton.viewModel.isFullscreenEnabled) {
fullscreenButton.container.style.visibility = visibility;
}
if (defined(infoBox)) {
infoBox.container.style.visibility = visibility;
}
if (defined(selectionIndicator)) {
selectionIndicator.container.style.visibility = visibility;
}
if (viewer._container) {
var right = enabled || !defined(fullscreenButton) ? 0 : fullscreenButton.container.clientWidth;
viewer._vrButton.container.style.right = right + 'px';
viewer.forceResize();
}
}
/**
* A base widget for building applications. It composites all of the standard Cesium widgets into one reusable package.
* The widget can always be extended by using mixins, which add functionality useful for a variety of applications.
*
* @alias Viewer
* @constructor
*
* @param {Element|String} container The DOM element or ID that will contain the widget.
* @param {Object} [options] Object with the following properties:
* @param {Boolean} [options.animation=true] If set to false, the Animation widget will not be created.
* @param {Boolean} [options.baseLayerPicker=true] If set to false, the BaseLayerPicker widget will not be created.
* @param {Boolean} [options.fullscreenButton=true] If set to false, the FullscreenButton widget will not be created.
* @param {Boolean} [options.vrButton=false] If set to true, the VRButton widget will be created.
* @param {Boolean} [options.geocoder=true] If set to false, the Geocoder widget will not be created.
* @param {Boolean} [options.homeButton=true] If set to false, the HomeButton widget will not be created.
* @param {Boolean} [options.infoBox=true] If set to false, the InfoBox widget will not be created.
* @param {Boolean} [options.sceneModePicker=true] If set to false, the SceneModePicker widget will not be created.
* @param {Boolean} [options.selectionIndicator=true] If set to false, the SelectionIndicator widget will not be created.
* @param {Boolean} [options.timeline=true] If set to false, the Timeline widget will not be created.
* @param {Boolean} [options.navigationHelpButton=true] If set to false, the navigation help button will not be created.
* @param {Boolean} [options.navigationInstructionsInitiallyVisible=true] True if the navigation instructions should initially be visible, or false if the should not be shown until the user explicitly clicks the button.
* @param {Boolean} [options.scene3DOnly=false] When <code>true</code>, each geometry instance will only be rendered in 3D to save GPU memory.
* @param {Clock} [options.clock=new Clock()] The clock to use to control current time.
* @param {ProviderViewModel} [options.selectedImageryProviderViewModel] The view model for the current base imagery layer, if not supplied the first available base layer is used. This value is only valid if options.baseLayerPicker is set to true.
* @param {ProviderViewModel[]} [options.imageryProviderViewModels=createDefaultImageryProviderViewModels()] The array of ProviderViewModels to be selectable from the BaseLayerPicker. This value is only valid if options.baseLayerPicker is set to true.
* @param {ProviderViewModel} [options.selectedTerrainProviderViewModel] The view model for the current base terrain layer, if not supplied the first available base layer is used. This value is only valid if options.baseLayerPicker is set to true.
* @param {ProviderViewModel[]} [options.terrainProviderViewModels=createDefaultTerrainProviderViewModels()] The array of ProviderViewModels to be selectable from the BaseLayerPicker. This value is only valid if options.baseLayerPicker is set to true.
* @param {ImageryProvider} [options.imageryProvider=new BingMapsImageryProvider()] The imagery provider to use. This value is only valid if options.baseLayerPicker is set to false.
* @param {TerrainProvider} [options.terrainProvider=new EllipsoidTerrainProvider()] The terrain provider to use
* @param {SkyBox} [options.skyBox] The skybox used to render the stars. When <code>undefined</code>, the default stars are used.
* @param {SkyAtmosphere} [options.skyAtmosphere] Blue sky, and the glow around the Earth's limb. Set to <code>false</code> to turn it off.
* @param {Element|String} [options.fullscreenElement=document.body] The element or id to be placed into fullscreen mode when the full screen button is pressed.
* @param {Boolean} [options.useDefaultRenderLoop=true] True if this widget should control the render loop, false otherwise.
* @param {Number} [options.targetFrameRate] The target frame rate when using the default render loop.
* @param {Boolean} [options.showRenderLoopErrors=true] If true, this widget will automatically display an HTML panel to the user containing the error, if a render loop error occurs.
* @param {Boolean} [options.automaticallyTrackDataSourceClocks=true] If true, this widget will automatically track the clock settings of newly added DataSources, updating if the DataSource's clock changes. Set this to false if you want to configure the clock independently.
* @param {Object} [options.contextOptions] Context and WebGL creation properties corresponding to <code>options</code> passed to {@link Scene}.
* @param {SceneMode} [options.sceneMode=SceneMode.SCENE3D] The initial scene mode.
* @param {MapProjection} [options.mapProjection=new GeographicProjection()] The map projection to use in 2D and Columbus View modes.
* @param {Globe} [options.globe=new Globe(mapProjection.ellipsoid)] The globe to use in the scene. If set to <code>false</code>, no globe will be added.
* @param {Boolean} [options.orderIndependentTranslucency=true] If true and the configuration supports it, use order independent translucency.
* @param {Element|String} [options.creditContainer] The DOM element or ID that will contain the {@link CreditDisplay}. If not specified, the credits are added to the bottom of the widget itself.
* @param {DataSourceCollection} [options.dataSources=new DataSourceCollection()] The collection of data sources visualized by the widget. If this parameter is provided,
* the instance is assumed to be owned by the caller and will not be destroyed when the viewer is destroyed.
* @param {Number} [options.terrainExaggeration=1.0] A scalar used to exaggerate the terrain. Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
* @param {Boolean} [options.shadows=false] Determines if shadows are cast by the sun.
* @param {ShadowMode} [options.terrainShadows=ShadowMode.RECEIVE_ONLY] Determines if the terrain casts or receives shadows from the sun.
* @param {MapMode2D} [options.mapMode2D=MapMode2D.INFINITE_SCROLL] Determines if the 2D map is rotatable or can be scrolled infinitely in the horizontal direction.
*
* @exception {DeveloperError} Element with id "container" does not exist in the document.
* @exception {DeveloperError} options.imageryProvider is not available when using the BaseLayerPicker widget, specify options.selectedImageryProviderViewModel instead.
* @exception {DeveloperError} options.terrainProvider is not available when using the BaseLayerPicker widget, specify options.selectedTerrainProviderViewModel instead.
* @exception {DeveloperError} options.selectedImageryProviderViewModel is not available when not using the BaseLayerPicker widget, specify options.imageryProvider instead.
* @exception {DeveloperError} options.selectedTerrainProviderViewModel is not available when not using the BaseLayerPicker widget, specify options.terrainProvider instead.
*
* @see Animation
* @see BaseLayerPicker
* @see CesiumWidget
* @see FullscreenButton
* @see HomeButton
* @see SceneModePicker
* @see Timeline
* @see viewerDragDropMixin
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Hello%20World.html|Cesium Sandcastle Hello World Demo}
*
* @example
* //Initialize the viewer widget with several custom options and mixins.
* var viewer = new Cesium.Viewer('cesiumContainer', {
* //Start in Columbus Viewer
* sceneMode : Cesium.SceneMode.COLUMBUS_VIEW,
* //Use standard Cesium terrain
* terrainProvider : new Cesium.CesiumTerrainProvider({
* url : 'https://assets.agi.com/stk-terrain/world'
* }),
* //Hide the base layer picker
* baseLayerPicker : false,
* //Use OpenStreetMaps
* imageryProvider : Cesium.createOpenStreetMapImageryProvider({
* url : 'https://a.tile.openstreetmap.org/'
* }),
* // Use high-res stars downloaded from https://github.com/AnalyticalGraphicsInc/cesium-assets
* skyBox : new Cesium.SkyBox({
* sources : {
* positiveX : 'stars/TychoSkymapII.t3_08192x04096_80_px.jpg',
* negativeX : 'stars/TychoSkymapII.t3_08192x04096_80_mx.jpg',
* positiveY : 'stars/TychoSkymapII.t3_08192x04096_80_py.jpg',
* negativeY : 'stars/TychoSkymapII.t3_08192x04096_80_my.jpg',
* positiveZ : 'stars/TychoSkymapII.t3_08192x04096_80_pz.jpg',
* negativeZ : 'stars/TychoSkymapII.t3_08192x04096_80_mz.jpg'
* }
* }),
* // Show Columbus View map with Web Mercator projection
* mapProjection : new Cesium.WebMercatorProjection()
* });
*
* //Add basic drag and drop functionality
* viewer.extend(Cesium.viewerDragDropMixin);
*
* //Show a pop-up alert if we encounter an error when processing a dropped file
* viewer.dropError.addEventListener(function(dropHandler, name, error) {
* console.log(error);
* window.alert(error);
* });
*/
function Viewer(container, options) {
if (!defined(container)) {
throw new DeveloperError('container is required.');
}
container = getElement(container);
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var createBaseLayerPicker = (!defined(options.globe) || options.globe !== false) &&
(!defined(options.baseLayerPicker) || options.baseLayerPicker !== false);
// If using BaseLayerPicker, imageryProvider is an invalid option
if (createBaseLayerPicker && defined(options.imageryProvider)) {
throw new DeveloperError('options.imageryProvider is not available when using the BaseLayerPicker widget. \
Either specify options.selectedImageryProviderViewModel instead or set options.baseLayerPicker to false.');
}
// If not using BaseLayerPicker, selectedImageryProviderViewModel is an invalid option
if (!createBaseLayerPicker && defined(options.selectedImageryProviderViewModel)) {
throw new DeveloperError('options.selectedImageryProviderViewModel is not available when not using the BaseLayerPicker widget. \
Either specify options.imageryProvider instead or set options.baseLayerPicker to true.');
}
// If using BaseLayerPicker, terrainProvider is an invalid option
if (createBaseLayerPicker && defined(options.terrainProvider)) {
throw new DeveloperError('options.terrainProvider is not available when using the BaseLayerPicker widget. \
Either specify options.selectedTerrainProviderViewModel instead or set options.baseLayerPicker to false.');
}
// If not using BaseLayerPicker, selectedTerrainProviderViewModel is an invalid option
if (!createBaseLayerPicker && defined(options.selectedTerrainProviderViewModel)) {
throw new DeveloperError('options.selectedTerrainProviderViewModel is not available when not using the BaseLayerPicker widget. \
Either specify options.terrainProvider instead or set options.baseLayerPicker to true.');
}
var that = this;
var viewerContainer = document.createElement('div');
viewerContainer.className = 'cesium-viewer';
container.appendChild(viewerContainer);
// Cesium widget container
var cesiumWidgetContainer = document.createElement('div');
cesiumWidgetContainer.className = 'cesium-viewer-cesiumWidgetContainer';
viewerContainer.appendChild(cesiumWidgetContainer);
// Bottom container
var bottomContainer = document.createElement('div');
bottomContainer.className = 'cesium-viewer-bottom';
viewerContainer.appendChild(bottomContainer);
var scene3DOnly = defaultValue(options.scene3DOnly, false);
// Cesium widget
var cesiumWidget = new CesiumWidget(cesiumWidgetContainer, {
terrainProvider : options.terrainProvider,
imageryProvider : createBaseLayerPicker ? false : options.imageryProvider,
clock : options.clock,
skyBox : options.skyBox,
skyAtmosphere : options.skyAtmosphere,
sceneMode : options.sceneMode,
mapProjection : options.mapProjection,
globe : options.globe,
orderIndependentTranslucency : options.orderIndependentTranslucency,
contextOptions : options.contextOptions,
useDefaultRenderLoop : options.useDefaultRenderLoop,
targetFrameRate : options.targetFrameRate,
showRenderLoopErrors : options.showRenderLoopErrors,
creditContainer : defined(options.creditContainer) ? options.creditContainer : bottomContainer,
scene3DOnly : scene3DOnly,
terrainExaggeration : options.terrainExaggeration,
shadows : options.shadows,
terrainShadows : options.terrainShadows,
mapMode2D : options.mapMode2D
});
var dataSourceCollection = options.dataSources;
var destroyDataSourceCollection = false;
if (!defined(dataSourceCollection)) {
dataSourceCollection = new DataSourceCollection();
destroyDataSourceCollection = true;
}
var dataSourceDisplay = new DataSourceDisplay({
scene : cesiumWidget.scene,
dataSourceCollection : dataSourceCollection
});
var clock = cesiumWidget.clock;
var clockViewModel = new ClockViewModel(clock);
var eventHelper = new EventHelper();
eventHelper.add(clock.onTick, Viewer.prototype._onTick, this);
eventHelper.add(cesiumWidget.scene.morphStart, Viewer.prototype._clearTrackedObject, this);
// Selection Indicator
var selectionIndicator;
if (!defined(options.selectionIndicator) || options.selectionIndicator !== false) {
var selectionIndicatorContainer = document.createElement('div');
selectionIndicatorContainer.className = 'cesium-viewer-selectionIndicatorContainer';
viewerContainer.appendChild(selectionIndicatorContainer);
selectionIndicator = new SelectionIndicator(selectionIndicatorContainer, cesiumWidget.scene);
}
// Info Box
var infoBox;
if (!defined(options.infoBox) || options.infoBox !== false) {
var infoBoxContainer = document.createElement('div');
infoBoxContainer.className = 'cesium-viewer-infoBoxContainer';
viewerContainer.appendChild(infoBoxContainer);
infoBox = new InfoBox(infoBoxContainer);
var infoBoxViewModel = infoBox.viewModel;
eventHelper.add(infoBoxViewModel.cameraClicked, Viewer.prototype._onInfoBoxCameraClicked, this);
eventHelper.add(infoBoxViewModel.closeClicked, Viewer.prototype._onInfoBoxClockClicked, this);
}
// Main Toolbar
var toolbar = document.createElement('div');
toolbar.className = 'cesium-viewer-toolbar';
viewerContainer.appendChild(toolbar);
// Geocoder
var geocoder;
if (!defined(options.geocoder) || options.geocoder !== false) {
var geocoderContainer = document.createElement('div');
geocoderContainer.className = 'cesium-viewer-geocoderContainer';
toolbar.appendChild(geocoderContainer);
geocoder = new Geocoder({
container : geocoderContainer,
scene : cesiumWidget.scene
});
// Subscribe to search so that we can clear the trackedEntity when it is clicked.
eventHelper.add(geocoder.viewModel.search.beforeExecute, Viewer.prototype._clearObjects, this);
}
// HomeButton
var homeButton;
if (!defined(options.homeButton) || options.homeButton !== false) {
homeButton = new HomeButton(toolbar, cesiumWidget.scene);
if (defined(geocoder)) {
eventHelper.add(homeButton.viewModel.command.afterExecute, function() {
var viewModel = geocoder.viewModel;
viewModel.searchText = '';
if (viewModel.isSearchInProgress) {
viewModel.search();
}
});
}
// Subscribe to the home button beforeExecute event so that we can clear the trackedEntity.
eventHelper.add(homeButton.viewModel.command.beforeExecute, Viewer.prototype._clearTrackedObject, this);
}
// SceneModePicker
// By default, we silently disable the scene mode picker if scene3DOnly is true,
// but if sceneModePicker is explicitly set to true, throw an error.
if ((options.sceneModePicker === true) && scene3DOnly) {
throw new DeveloperError('options.sceneModePicker is not available when options.scene3DOnly is set to true.');
}
var sceneModePicker;
if (!scene3DOnly && (!defined(options.sceneModePicker) || options.sceneModePicker !== false)) {
sceneModePicker = new SceneModePicker(toolbar, cesiumWidget.scene);
}
// BaseLayerPicker
var baseLayerPicker;
var baseLayerPickerDropDown;
if (createBaseLayerPicker) {
var imageryProviderViewModels = defaultValue(options.imageryProviderViewModels, createDefaultImageryProviderViewModels());
var terrainProviderViewModels = defaultValue(options.terrainProviderViewModels, createDefaultTerrainProviderViewModels());
baseLayerPicker = new BaseLayerPicker(toolbar, {
globe : cesiumWidget.scene.globe,
imageryProviderViewModels : imageryProviderViewModels,
selectedImageryProviderViewModel : options.selectedImageryProviderViewModel,
terrainProviderViewModels : terrainProviderViewModels,
selectedTerrainProviderViewModel : options.selectedTerrainProviderViewModel
});
//Grab the dropdown for resize code.
var elements = toolbar.getElementsByClassName('cesium-baseLayerPicker-dropDown');
baseLayerPickerDropDown = elements[0];
}
// Navigation Help Button
var navigationHelpButton;
if (!defined(options.navigationHelpButton) || options.navigationHelpButton !== false) {
var showNavHelp = true;
try {
//window.localStorage is null if disabled in Firefox or undefined in browsers with implementation
if (defined(window.localStorage)) {
var hasSeenNavHelp = window.localStorage.getItem('cesium-hasSeenNavHelp');
if (defined(hasSeenNavHelp) && Boolean(hasSeenNavHelp)) {
showNavHelp = false;
} else {
window.localStorage.setItem('cesium-hasSeenNavHelp', 'true');
}
}
} catch (e) {
//Accessing window.localStorage throws if disabled in Chrome
//window.localStorage.setItem throws if in Safari private browsing mode or in any browser if we are over quota.
}
navigationHelpButton = new NavigationHelpButton({
container : toolbar,
instructionsInitiallyVisible : defaultValue(options.navigationInstructionsInitiallyVisible, showNavHelp)
});
}
// Animation
var animation;
if (!defined(options.animation) || options.animation !== false) {
var animationContainer = document.createElement('div');
animationContainer.className = 'cesium-viewer-animationContainer';
viewerContainer.appendChild(animationContainer);
animation = new Animation(animationContainer, new AnimationViewModel(clockViewModel));
}
// Timeline
var timeline;
if (!defined(options.timeline) || options.timeline !== false) {
var timelineContainer = document.createElement('div');
timelineContainer.className = 'cesium-viewer-timelineContainer';
viewerContainer.appendChild(timelineContainer);
timeline = new Timeline(timelineContainer, clock);
timeline.addEventListener('settime', onTimelineScrubfunction, false);
timeline.zoomTo(clock.startTime, clock.stopTime);
}
// Fullscreen
var fullscreenButton;
var fullscreenSubscription;
if (!defined(options.fullscreenButton) || options.fullscreenButton !== false) {
var fullscreenContainer = document.createElement('div');
fullscreenContainer.className = 'cesium-viewer-fullscreenContainer';
viewerContainer.appendChild(fullscreenContainer);
fullscreenButton = new FullscreenButton(fullscreenContainer, options.fullscreenElement);
//Subscribe to fullscreenButton.viewModel.isFullscreenEnabled so
//that we can hide/show the button as well as size the timeline.
fullscreenSubscription = subscribeAndEvaluate(fullscreenButton.viewModel, 'isFullscreenEnabled', function(isFullscreenEnabled) {
fullscreenContainer.style.display = isFullscreenEnabled ? 'block' : 'none';
if (defined(timeline)) {
timeline.container.style.right = fullscreenContainer.clientWidth + 'px';
timeline.resize();
}
});
}
// VR
var vrButton;
var vrSubscription;
var vrModeSubscription;
if (options.vrButton) {
var vrContainer = document.createElement('div');
vrContainer.className = 'cesium-viewer-vrContainer';
viewerContainer.appendChild(vrContainer);
vrButton = new VRButton(vrContainer, cesiumWidget.scene, options.fullScreenElement);
vrSubscription = subscribeAndEvaluate(vrButton.viewModel, 'isVREnabled', function(isVREnabled) {
vrContainer.style.display = isVREnabled ? 'block' : 'none';
if (defined(fullscreenButton)) {
vrContainer.style.right = fullscreenContainer.clientWidth + 'px';
}
if (defined(timeline)) {
timeline.container.style.right = vrContainer.clientWidth + 'px';
timeline.resize();
}
});
vrModeSubscription = subscribeAndEvaluate(vrButton.viewModel, 'isVRMode', function(isVRMode) {
enableVRUI(that, isVRMode);
});
}
//Assign all properties to this instance. No "this" assignments should
//take place above this line.
this._baseLayerPickerDropDown = baseLayerPickerDropDown;
this._fullscreenSubscription = fullscreenSubscription;
this._vrSubscription = vrSubscription;
this._vrModeSubscription = vrModeSubscription;
this._dataSourceChangedListeners = {};
this._automaticallyTrackDataSourceClocks = defaultValue(options.automaticallyTrackDataSourceClocks, true);
this._container = container;
this._bottomContainer = bottomContainer;
this._element = viewerContainer;
this._cesiumWidget = cesiumWidget;
this._selectionIndicator = selectionIndicator;
this._infoBox = infoBox;
this._dataSourceCollection = dataSourceCollection;
this._destroyDataSourceCollection = destroyDataSourceCollection;
this._dataSourceDisplay = dataSourceDisplay;
this._clockViewModel = clockViewModel;
this._toolbar = toolbar;
this._homeButton = homeButton;
this._sceneModePicker = sceneModePicker;
this._baseLayerPicker = baseLayerPicker;
this._navigationHelpButton = navigationHelpButton;
this._animation = animation;
this._timeline = timeline;
this._fullscreenButton = fullscreenButton;
this._vrButton = vrButton;
this._geocoder = geocoder;
this._eventHelper = eventHelper;
this._lastWidth = 0;
this._lastHeight = 0;
this._allowDataSourcesToSuspendAnimation = true;
this._entityView = undefined;
this._enableInfoOrSelection = defined(infoBox) || defined(selectionIndicator);
this._clockTrackedDataSource = undefined;
this._trackedEntity = undefined;
this._needTrackedEntityUpdate = false;
this._selectedEntity = undefined;
this._clockTrackedDataSource = undefined;
this._forceResize = false;
this._zoomIsFlight = false;
this._zoomTarget = undefined;
this._zoomPromise = undefined;
this._zoomOptions = undefined;
knockout.track(this, ['_trackedEntity', '_selectedEntity', '_clockTrackedDataSource']);
//Listen to data source events in order to track clock changes.
eventHelper.add(dataSourceCollection.dataSourceAdded, Viewer.prototype._onDataSourceAdded, this);
eventHelper.add(dataSourceCollection.dataSourceRemoved, Viewer.prototype._onDataSourceRemoved, this);
// Prior to each render, check if anything needs to be resized.
eventHelper.add(cesiumWidget.scene.preRender, Viewer.prototype.resize, this);
eventHelper.add(cesiumWidget.scene.postRender, Viewer.prototype._postRender, this);
// We need to subscribe to the data sources and collections so that we can clear the
// tracked object when it is removed from the scene.
// Subscribe to current data sources
var dataSourceLength = dataSourceCollection.length;
for (var i = 0; i < dataSourceLength; i++) {
this._dataSourceAdded(dataSourceCollection, dataSourceCollection.get(i));
}
this._dataSourceAdded(undefined, dataSourceDisplay.defaultDataSource);
// Hook up events so that we can subscribe to future sources.
eventHelper.add(dataSourceCollection.dataSourceAdded, Viewer.prototype._dataSourceAdded, this);
eventHelper.add(dataSourceCollection.dataSourceRemoved, Viewer.prototype._dataSourceRemoved, this);
// Subscribe to left clicks and zoom to the picked object.
function pickAndTrackObject(e) {
var entity = pickEntity(that, e);
if (defined(entity)) {
//Only track the entity if it has a valid position at the current time.
if (Property.getValueOrUndefined(entity.position, that.clock.currentTime)) {
that.trackedEntity = entity;
} else {
that.zoomTo(entity);
}
}
}
function pickAndSelectObject(e) {
that.selectedEntity = pickEntity(that, e);
}
cesiumWidget.screenSpaceEventHandler.setInputAction(pickAndSelectObject, ScreenSpaceEventType.LEFT_CLICK);
cesiumWidget.screenSpaceEventHandler.setInputAction(pickAndTrackObject, ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
}
defineProperties(Viewer.prototype, {
/**
* Gets the parent container.
* @memberof Viewer.prototype
* @type {Element}
* @readonly
*/
container : {
get : function() {
return this._container;
}
},
/**
* Gets the DOM element for the area at the bottom of the window containing the
* {@link CreditDisplay} and potentially other things.
* @memberof Viewer.prototype
* @type {Element}
* @readonly
*/
bottomContainer : {
get : function() {
return this._bottomContainer;
}
},
/**
* Gets the CesiumWidget.
* @memberof Viewer.prototype
* @type {CesiumWidget}
* @readonly
*/
cesiumWidget : {
get : function() {
return this._cesiumWidget;
}
},
/**
* Gets the selection indicator.
* @memberof Viewer.prototype
* @type {SelectionIndicator}
* @readonly
*/
selectionIndicator : {
get : function() {
return this._selectionIndicator;
}
},
/**
* Gets the info box.
* @memberof Viewer.prototype
* @type {InfoBox}
* @readonly
*/
infoBox : {
get : function() {
return this._infoBox;
}
},
/**
* Gets the Geocoder.
* @memberof Viewer.prototype
* @type {Geocoder}
* @readonly
*/
geocoder : {
get : function() {
return this._geocoder;
}
},
/**
* Gets the HomeButton.
* @memberof Viewer.prototype
* @type {HomeButton}
* @readonly
*/
homeButton : {
get : function() {
return this._homeButton;
}
},
/**
* Gets the SceneModePicker.
* @memberof Viewer.prototype
* @type {SceneModePicker}
* @readonly
*/
sceneModePicker : {
get : function() {
return this._sceneModePicker;
}
},
/**
* Gets the BaseLayerPicker.
* @memberof Viewer.prototype
* @type {BaseLayerPicker}
* @readonly
*/
baseLayerPicker : {
get : function() {
return this._baseLayerPicker;
}
},
/**
* Gets the NavigationHelpButton.
* @memberof Viewer.prototype
* @type {NavigationHelpButton}
* @readonly
*/
navigationHelpButton : {
get : function() {
return this._navigationHelpButton;
}
},
/**
* Gets the Animation widget.
* @memberof Viewer.prototype
* @type {Animation}
* @readonly
*/
animation : {
get : function() {
return this._animation;
}
},
/**
* Gets the Timeline widget.
* @memberof Viewer.prototype
* @type {Timeline}
* @readonly
*/
timeline : {
get : function() {
return this._timeline;
}
},
/**
* Gets the FullscreenButton.
* @memberof Viewer.prototype
* @type {FullscreenButton}
* @readonly
*/
fullscreenButton : {
get : function() {
return this._fullscreenButton;
}
},
/**
* Gets the VRButton.
* @memberof Viewer.prototype
* @type {VRButton}
* @readonly
*/
vrButton : {
get : function() {
return this._vrButton;
}
},
/**
* Gets the display used for {@link DataSource} visualization.
* @memberof Viewer.prototype
* @type {DataSourceDisplay}
* @readonly
*/
dataSourceDisplay : {
get : function() {
return this._dataSourceDisplay;
}
},
/**
* Gets the collection of entities not tied to a particular data source.
* This is a shortcut to [dataSourceDisplay.defaultDataSource.entities]{@link Viewer#dataSourceDisplay}.
* @memberof Viewer.prototype
* @type {EntityCollection}
* @readonly
*/
entities : {
get : function() {
return this._dataSourceDisplay.defaultDataSource.entities;
}
},
/**
* Gets the set of {@link DataSource} instances to be visualized.
* @memberof Viewer.prototype
* @type {DataSourceCollection}
* @readonly
*/
dataSources : {
get : function() {
return this._dataSourceCollection;
}
},
/**
* Gets the canvas.
* @memberof Viewer.prototype
* @type {Canvas}
* @readonly
*/
canvas : {
get : function() {
return this._cesiumWidget.canvas;
}
},
/**
* Gets the Cesium logo element.
* @memberof Viewer.prototype
* @type {Element}
* @readonly
*/
cesiumLogo : {
get : function() {
return this._cesiumWidget.cesiumLogo;
}
},
/**
* Gets the scene.
* @memberof Viewer.prototype
* @type {Scene}
* @readonly
*/
scene : {
get : function() {
return this._cesiumWidget.scene;
}
},
/**
* Determines if shadows are cast by the sun.
* @memberof Viewer.prototype
* @type {Boolean}
*/
shadows : {
get : function() {
return this.scene.shadowMap.enabled;
},
set : function(value) {
this.scene.shadowMap.enabled = value;
}
},
/**
* Determines if the terrain casts or shadows from the sun.
* @memberof Viewer.prototype
* @type {ShadowMode}
*/
terrainShadows : {
get : function() {
return this.scene.globe.shadows;
},
set : function(value) {
this.scene.globe.shadows = value;
}
},
/**
* Get the scene's shadow map
* @memberof Viewer.prototype
* @type {ShadowMap}
* @readonly
*/
shadowMap : {
get : function() {
return this.scene.shadowMap;
}
},
/**
* Gets the collection of image layers that will be rendered on the globe.
* @memberof Viewer.prototype
*
* @type {ImageryLayerCollection}
* @readonly
*/
imageryLayers : {
get : function() {
return this.scene.imageryLayers;
}
},
/**
* The terrain provider providing surface geometry for the globe.
* @memberof Viewer.prototype
*
* @type {TerrainProvider}
*/
terrainProvider : {
get : function() {
return this.scene.terrainProvider;
},
set : function(terrainProvider) {
this.scene.terrainProvider = terrainProvider;
}
},
/**
* Gets the camera.
* @memberof Viewer.prototype
*
* @type {Camera}
* @readonly
*/
camera : {
get : function() {
return this.scene.camera;
}
},
/**
* Gets the clock.
* @memberof Viewer.prototype
* @type {Clock}
* @readonly
*/
clock : {
get : function() {
return this._cesiumWidget.clock;
}
},
/**
* Gets the screen space event handler.
* @memberof Viewer.prototype
* @type {ScreenSpaceEventHandler}
* @readonly
*/
screenSpaceEventHandler : {
get : function() {
return this._cesiumWidget.screenSpaceEventHandler;
}
},
/**
* Gets or sets the target frame rate of the widget when <code>useDefaultRenderLoop</code>
* is true. If undefined, the browser's {@link requestAnimationFrame} implementation
* determines the frame rate. If defined, this value must be greater than 0. A value higher
* than the underlying requestAnimationFrame implementation will have no effect.
* @memberof Viewer.prototype
*
* @type {Number}
*/
targetFrameRate : {
get : function() {
return this._cesiumWidget.targetFrameRate;
},
set : function(value) {
this._cesiumWidget.targetFrameRate = value;
}
},
/**
* Gets or sets whether or not this widget should control the render loop.
* If set to true the widget will use {@link requestAnimationFrame} to
* perform rendering and resizing of the widget, as well as drive the
* simulation clock. If set to false, you must manually call the
* <code>resize</code>, <code>render</code> methods
* as part of a custom render loop. If an error occurs during rendering, {@link Scene}'s
* <code>renderError</code> event will be raised and this property
* will be set to false. It must be set back to true to continue rendering
* after the error.
* @memberof Viewer.prototype
*
* @type {Boolean}
*/
useDefaultRenderLoop : {
get : function() {
return this._cesiumWidget.useDefaultRenderLoop;
},
set : function(value) {
this._cesiumWidget.useDefaultRenderLoop = value;
}
},
/**
* Gets or sets a scaling factor for rendering resolution. Values less than 1.0 can improve
* performance on less powerful devices while values greater than 1.0 will render at a higher
* resolution and then scale down, resulting in improved visual fidelity.
* For example, if the widget is laid out at a size of 640x480, setting this value to 0.5
* will cause the scene to be rendered at 320x240 and then scaled up while setting
* it to 2.0 will cause the scene to be rendered at 1280x960 and then scaled down.
* @memberof Viewer.prototype
*
* @type {Number}
* @default 1.0
*/
resolutionScale : {
get : function() {
return this._cesiumWidget.resolutionScale;
},
set : function(value) {
this._cesiumWidget.resolutionScale = value;
this._forceResize = true;
}
},
/**
* Gets or sets whether or not data sources can temporarily pause
* animation in order to avoid showing an incomplete picture to the user.
* For example, if asynchronous primitives are being processed in the
* background, the clock will not advance until the geometry is ready.
*
* @memberof Viewer.prototype
*
* @type {Boolean}
*/
allowDataSourcesToSuspendAnimation : {
get : function() {
return this._allowDataSourcesToSuspendAnimation;
},
set : function(value) {
this._allowDataSourcesToSuspendAnimation = value;
}
},
/**
* Gets or sets the Entity instance currently being tracked by the camera.
* @memberof Viewer.prototype
* @type {Entity}
*/
trackedEntity : {
get : function() {
return this._trackedEntity;
},
set : function(value) {
if (this._trackedEntity !== value) {
this._trackedEntity = value;
//Cancel any pending zoom
cancelZoom(this);
var scene = this.scene;
var sceneMode = scene.mode;
//Stop tracking
if (!defined(value) || !defined(value.position)) {
this._needTrackedEntityUpdate = false;
if (sceneMode === SceneMode.COLUMBUS_VIEW || sceneMode === SceneMode.SCENE2D) {
scene.screenSpaceCameraController.enableTranslate = true;
}
if (sceneMode === SceneMode.COLUMBUS_VIEW || sceneMode === SceneMode.SCENE3D) {
scene.screenSpaceCameraController.enableTilt = true;
}
this._entityView = undefined;
this.camera.lookAtTransform(Matrix4.IDENTITY);
return;
}
//We can't start tracking immediately, so we set a flag and start tracking
//when the bounding sphere is ready (most likely next frame).
this._needTrackedEntityUpdate = true;
}
}
},
/**
* Gets or sets the object instance for which to display a selection indicator.
* @memberof Viewer.prototype
* @type {Entity}
*/
selectedEntity : {
get : function() {
return this._selectedEntity;
},
set : function(value) {
if (this._selectedEntity !== value) {
this._selectedEntity = value;
var selectionIndicatorViewModel = defined(this._selectionIndicator) ? this._selectionIndicator.viewModel : undefined;
if (defined(value)) {
if (defined(selectionIndicatorViewModel)) {
selectionIndicatorViewModel.animateAppear();
}
} else {
// Leave the info text in place here, it is needed during the exit animation.
if (defined(selectionIndicatorViewModel)) {
selectionIndicatorViewModel.animateDepart();
}
}
}
}
},
/**
* Gets or sets the data source to track with the viewer's clock.
* @memberof Viewer.prototype
* @type {DataSource}
*/
clockTrackedDataSource : {
get : function() {
return this._clockTrackedDataSource;
},
set : function(value) {
if (this._clockTrackedDataSource !== value) {
this._clockTrackedDataSource = value;
trackDataSourceClock(this._timeline, this.clock, value);
}
}
}
});
/**
* Extends the base viewer functionality with the provided mixin.
* A mixin may add additional properties, functions, or other behavior
* to the provided viewer instance.
*
* @param {Viewer~ViewerMixin} mixin The Viewer mixin to add to this instance.
* @param {Object} [options] The options object to be passed to the mixin function.
*
* @see viewerDragDropMixin
*/
Viewer.prototype.extend = function(mixin, options) {
if (!defined(mixin)) {
throw new DeveloperError('mixin is required.');
}
mixin(this, options);
};
/**
* Resizes the widget to match the container size.
* This function is called automatically as needed unless
* <code>useDefaultRenderLoop</code> is set to false.
*/
Viewer.prototype.resize = function() {
var cesiumWidget = this._cesiumWidget;
var container = this._container;
var width = container.clientWidth;
var height = container.clientHeight;
var animationExists = defined(this._animation);
var timelineExists = defined(this._timeline);
if (!this._forceResize && width === this._lastWidth && height === this._lastHeight) {
return;
}
cesiumWidget.resize();
this._forceResize = false;
var panelMaxHeight = height - 125;
var baseLayerPickerDropDown = this._baseLayerPickerDropDown;
if (defined(baseLayerPickerDropDown)) {
baseLayerPickerDropDown.style.maxHeight = panelMaxHeight + 'px';
}
if (defined(this._infoBox)) {
this._infoBox.viewModel.maxHeight = panelMaxHeight;
}
var timeline = this._timeline;
var animationContainer;
var animationWidth = 0;
var creditLeft = 0;
var creditBottom = 0;
if (animationExists && window.getComputedStyle(this._animation.container).visibility !== 'hidden') {
var lastWidth = this._lastWidth;
animationContainer = this._animation.container;
if (width > 900) {
animationWidth = 169;
if (lastWidth <= 900) {
animationContainer.style.width = '169px';
animationContainer.style.height = '112px';
this._animation.resize();
}
} else if (width >= 600) {
animationWidth = 136;
if (lastWidth < 600 || lastWidth > 900) {
animationContainer.style.width = '136px';
animationContainer.style.height = '90px';
this._animation.resize();
}
} else {
animationWidth = 106;
if (lastWidth > 600 || lastWidth === 0) {
animationContainer.style.width = '106px';
animationContainer.style.height = '70px';
this._animation.resize();
}
}
creditLeft = animationWidth + 5;
}
if (timelineExists && window.getComputedStyle(this._timeline.container).visibility !== 'hidden') {
var fullscreenButton = this._fullscreenButton;
var vrButton = this._vrButton;
var timelineContainer = timeline.container;
var timelineStyle = timelineContainer.style;
creditBottom = timelineContainer.clientHeight + 3;
timelineStyle.left = animationWidth + 'px';
var pixels = 0;
if (defined(fullscreenButton)) {
pixels += fullscreenButton.container.clientWidth;
}
if (defined(vrButton)) {
pixels += vrButton.container.clientWidth;
}
timelineStyle.right = pixels + 'px';
timeline.resize();
}
this._bottomContainer.style.left = creditLeft + 'px';
this._bottomContainer.style.bottom = creditBottom + 'px';
this._lastWidth = width;
this._lastHeight = height;
};
/**
* This forces the widget to re-think its layout, including
* widget sizes and credit placement.
*/
Viewer.prototype.forceResize = function() {
this._lastWidth = 0;
this.resize();
};
/**
* Renders the scene. This function is called automatically
* unless <code>useDefaultRenderLoop</code> is set to false;
*/
Viewer.prototype.render = function() {
this._cesiumWidget.render();
};
/**
* @returns {Boolean} true if the object has been destroyed, false otherwise.
*/
Viewer.prototype.isDestroyed = function() {
return false;
};
/**
* Destroys the widget. Should be called if permanently
* removing the widget from layout.
*/
Viewer.prototype.destroy = function() {
var i;
this.screenSpaceEventHandler.removeInputAction(ScreenSpaceEventType.LEFT_CLICK);
this.screenSpaceEventHandler.removeInputAction(ScreenSpaceEventType.LEFT_DOUBLE_CLICK);
// Unsubscribe from data sources
var dataSources = this.dataSources;
var dataSourceLength = dataSources.length;
for (i = 0; i < dataSourceLength; i++) {
this._dataSourceRemoved(dataSources, dataSources.get(i));
}
this._dataSourceRemoved(undefined, this._dataSourceDisplay.defaultDataSource);
this._container.removeChild(this._element);
this._element.removeChild(this._toolbar);
this._eventHelper.removeAll();
if (defined(this._geocoder)) {
this._geocoder = this._geocoder.destroy();
}
if (defined(this._homeButton)) {
this._homeButton = this._homeButton.destroy();
}
if (defined(this._sceneModePicker)) {
this._sceneModePicker = this._sceneModePicker.destroy();
}
if (defined(this._baseLayerPicker)) {
this._baseLayerPicker = this._baseLayerPicker.destroy();
}
if (defined(this._animation)) {
this._element.removeChild(this._animation.container);
this._animation = this._animation.destroy();
}
if (defined(this._timeline)) {
this._timeline.removeEventListener('settime', onTimelineScrubfunction, false);
this._element.removeChild(this._timeline.container);
this._timeline = this._timeline.destroy();
}
if (defined(this._fullscreenButton)) {
this._fullscreenSubscription.dispose();
this._element.removeChild(this._fullscreenButton.container);
this._fullscreenButton = this._fullscreenButton.destroy();
}
if (defined(this._vrButton)) {
this._vrSubscription.dispose();
this._vrModeSubscription.dispose();
this._element.removeChild(this._vrButton.container);
this._vrButton = this._vrButton.destroy();
}
if (defined(this._infoBox)) {
this._element.removeChild(this._infoBox.container);
this._infoBox = this._infoBox.destroy();
}
if (defined(this._selectionIndicator)) {
this._element.removeChild(this._selectionIndicator.container);
this._selectionIndicator = this._selectionIndicator.destroy();
}
this._clockViewModel = this._clockViewModel.destroy();
this._dataSourceDisplay = this._dataSourceDisplay.destroy();
this._cesiumWidget = this._cesiumWidget.destroy();
if (this._destroyDataSourceCollection) {
this._dataSourceCollection = this._dataSourceCollection.destroy();
}
return destroyObject(this);
};
/**
* @private
*/
Viewer.prototype._dataSourceAdded = function(dataSourceCollection, dataSource) {
var entityCollection = dataSource.entities;
entityCollection.collectionChanged.addEventListener(Viewer.prototype._onEntityCollectionChanged, this);
};
/**
* @private
*/
Viewer.prototype._dataSourceRemoved = function(dataSourceCollection, dataSource) {
var entityCollection = dataSource.entities;
entityCollection.collectionChanged.removeEventListener(Viewer.prototype._onEntityCollectionChanged, this);
if (defined(this.trackedEntity)) {
if (entityCollection.getById(this.trackedEntity.id) === this.trackedEntity) {
this.trackedEntity = undefined;
}
}
if (defined(this.selectedEntity)) {
if (entityCollection.getById(this.selectedEntity.id) === this.selectedEntity) {
this.selectedEntity = undefined;
}
}
};
/**
* @private
*/
Viewer.prototype._onTick = function(clock) {
var time = clock.currentTime;
var isUpdated = this._dataSourceDisplay.update(time);
if (this._allowDataSourcesToSuspendAnimation) {
this._clockViewModel.canAnimate = isUpdated;
}
var entityView = this._entityView;
if (defined(entityView)) {
var trackedEntity = this._trackedEntity;
var trackedState = this._dataSourceDisplay.getBoundingSphere(trackedEntity, false, boundingSphereScratch);
if (trackedState === BoundingSphereState.DONE) {
entityView.update(time, boundingSphereScratch);
}
}
var position;
var enableCamera = false;
var selectedEntity = this.selectedEntity;
var showSelection = defined(selectedEntity) && this._enableInfoOrSelection;
if (showSelection && selectedEntity.isShowing && selectedEntity.isAvailable(time)) {
var state = this._dataSourceDisplay.getBoundingSphere(selectedEntity, true, boundingSphereScratch);
if (state !== BoundingSphereState.FAILED) {
position = boundingSphereScratch.center;
} else if (defined(selectedEntity.position)) {
position = selectedEntity.position.getValue(time, position);
}
enableCamera = defined(position);
}
var selectionIndicatorViewModel = defined(this._selectionIndicator) ? this._selectionIndicator.viewModel : undefined;
if (defined(selectionIndicatorViewModel)) {
selectionIndicatorViewModel.position = Cartesian3.clone(position, selectionIndicatorViewModel.position);
selectionIndicatorViewModel.showSelection = showSelection && enableCamera;
selectionIndicatorViewModel.update();
}
var infoBoxViewModel = defined(this._infoBox) ? this._infoBox.viewModel : undefined;
if (defined(infoBoxViewModel)) {
infoBoxViewModel.showInfo = showSelection;
infoBoxViewModel.enableCamera = enableCamera;
infoBoxViewModel.isCameraTracking = (this.trackedEntity === this.selectedEntity);
if (showSelection) {
infoBoxViewModel.titleText = defaultValue(selectedEntity.name, selectedEntity.id);
infoBoxViewModel.description = Property.getValueOrDefault(selectedEntity.description, time, '');
} else {
infoBoxViewModel.titleText = '';
infoBoxViewModel.description = '';
}
}
};
/**
* @private
*/
Viewer.prototype._onEntityCollectionChanged = function(collection, added, removed) {
var length = removed.length;
for (var i = 0; i < length; i++) {
var removedObject = removed[i];
if (this.trackedEntity === removedObject) {
this.trackedEntity = undefined;
}
if (this.selectedEntity === removedObject) {
this.selectedEntity = undefined;
}
}
};
/**
* @private
*/
Viewer.prototype._onInfoBoxCameraClicked = function(infoBoxViewModel) {
if (infoBoxViewModel.isCameraTracking && (this.trackedEntity === this.selectedEntity)) {
this.trackedEntity = undefined;
} else {
var selectedEntity = this.selectedEntity;
var position = selectedEntity.position;
if (defined(position)) {
this.trackedEntity = this.selectedEntity;
} else {
this.zoomTo(this.selectedEntity);
}
}
};
/**
* @private
*/
Viewer.prototype._clearTrackedObject = function() {
this.trackedEntity = undefined;
};
/**
* @private
*/
Viewer.prototype._onInfoBoxClockClicked = function(infoBoxViewModel) {
this.selectedEntity = undefined;
};
/**
* @private
*/
Viewer.prototype._clearObjects = function() {
this.trackedEntity = undefined;
this.selectedEntity = undefined;
};
/**
* @private
*/
Viewer.prototype._onDataSourceChanged = function(dataSource) {
if (this.clockTrackedDataSource === dataSource) {
trackDataSourceClock(this.timeline, this.clock, dataSource);
}
};
/**
* @private
*/
Viewer.prototype._onDataSourceAdded = function(dataSourceCollection, dataSource) {
if (this._automaticallyTrackDataSourceClocks) {
this.clockTrackedDataSource = dataSource;
}
var id = dataSource.entities.id;
var removalFunc = this._eventHelper.add(dataSource.changedEvent, Viewer.prototype._onDataSourceChanged, this);
this._dataSourceChangedListeners[id] = removalFunc;
};
/**
* @private
*/
Viewer.prototype._onDataSourceRemoved = function(dataSourceCollection, dataSource) {
var resetClock = (this.clockTrackedDataSource === dataSource);
var id = dataSource.entities.id;
this._dataSourceChangedListeners[id]();
this._dataSourceChangedListeners[id] = undefined;
if (resetClock) {
var numDataSources = dataSourceCollection.length;
if (this._automaticallyTrackDataSourceClocks && numDataSources > 0) {
this.clockTrackedDataSource = dataSourceCollection.get(numDataSources - 1);
} else {
this.clockTrackedDataSource = undefined;
}
}
};
/**
* Asynchronously sets the camera to view the provided entity, entities, or data source.
* If the data source is still in the process of loading or the visualization is otherwise still loading,
* this method waits for the data to be ready before performing the zoom.
*
* <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
* The heading and the pitch angles are defined in the local east-north-up reference frame.
* The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
* angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
* zero, a range will be computed such that the whole bounding sphere is visible.</p>
*
* <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
* target will be the range. The heading will be determined from the offset. If the heading cannot be
* determined from the offset, the heading will be north.</p>
*
* @param {Entity|Entity[]|EntityCollection|DataSource|ImageryLayer|Promise.<Entity|Entity[]|EntityCollection|DataSource|ImageryLayer>} target The entity, array of entities, entity collection, data source or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
* @param {HeadingPitchRange} [offset] The offset from the center of the entity in the local east-north-up reference frame.
* @returns {Promise.<Boolean>} A Promise that resolves to true if the zoom was successful or false if the entity is not currently visualized in the scene or the zoom was cancelled.
*/
Viewer.prototype.zoomTo = function(target, offset) {
return zoomToOrFly(this, target, offset, false);
};
/**
* Flies the camera to the provided entity, entities, or data source.
* If the data source is still in the process of loading or the visualization is otherwise still loading,
* this method waits for the data to be ready before performing the flight.
*
* <p>The offset is heading/pitch/range in the local east-north-up reference frame centered at the center of the bounding sphere.
* The heading and the pitch angles are defined in the local east-north-up reference frame.
* The heading is the angle from y axis and increasing towards the x axis. Pitch is the rotation from the xy-plane. Positive pitch
* angles are above the plane. Negative pitch angles are below the plane. The range is the distance from the center. If the range is
* zero, a range will be computed such that the whole bounding sphere is visible.</p>
*
* <p>In 2D, there must be a top down view. The camera will be placed above the target looking down. The height above the
* target will be the range. The heading will be determined from the offset. If the heading cannot be
* determined from the offset, the heading will be north.</p>
*
* @param {Entity|Entity[]|EntityCollection|DataSource|ImageryLayer|Promise.<Entity|Entity[]|EntityCollection|DataSource|ImageryLayer>} target The entity, array of entities, entity collection, data source or imagery layer to view. You can also pass a promise that resolves to one of the previously mentioned types.
* @param {Object} [options] Object with the following properties:
* @param {Number} [options.duration=3.0] The duration of the flight in seconds.
* @param {Number} [options.maximumHeight] The maximum height at the peak of the flight.
* @param {HeadingPitchRange} [options.offset] The offset from the target in the local east-north-up reference frame centered at the target.
* @returns {Promise.<Boolean>} A Promise that resolves to true if the flight was successful or false if the entity is not currently visualized in the scene or the flight was cancelled.
*/
Viewer.prototype.flyTo = function(target, options) {
return zoomToOrFly(this, target, options, true);
};
function zoomToOrFly(that, zoomTarget, options, isFlight) {
if (!defined(zoomTarget)) {
throw new DeveloperError('zoomTarget is required.');
}
cancelZoom(that);
//We can't actually perform the zoom until all visualization is ready and
//bounding spheres have been computed. Therefore we create and return
//a deferred which will be resolved as part of the post-render step in the
//frame that actually performs the zoom
var zoomPromise = when.defer();
that._zoomPromise = zoomPromise;
that._zoomIsFlight = isFlight;
that._zoomOptions = options;
when(zoomTarget, function(zoomTarget) {
//Only perform the zoom if it wasn't cancelled before the promise resolved.
if (that._zoomPromise !== zoomPromise) {
return;
}
//If the zoom target is a rectangular imagery in an ImageLayer
if (zoomTarget instanceof ImageryLayer) {
zoomTarget.getViewableRectangle().then(function(rectangle) {
//Only perform the zoom if it wasn't cancelled before the promise was resolved
if (that._zoomPromise === zoomPromise) {
that._zoomTarget = rectangle;
}
});
return;
}
//If the zoom target is a data source, and it's in the middle of loading, wait for it to finish loading.
if (zoomTarget.isLoading && defined(zoomTarget.loadingEvent)) {
var removeEvent = zoomTarget.loadingEvent.addEventListener(function() {
removeEvent();
//Only perform the zoom if it wasn't cancelled before the data source finished.
if (that._zoomPromise === zoomPromise) {
that._zoomTarget = zoomTarget.entities.values.slice(0);
}
});
return;
}
//Zoom target is already an array, just copy it and return.
if (isArray(zoomTarget)) {
that._zoomTarget = zoomTarget.slice(0);
return;
}
//If zoomTarget is an EntityCollection, this will retrieve the array
zoomTarget = defaultValue(zoomTarget.values, zoomTarget);
//If zoomTarget is a DataSource, this will retrieve the array.
if (defined(zoomTarget.entities)) {
zoomTarget = zoomTarget.entities.values;
}
if (isArray(zoomTarget)) {
that._zoomTarget = zoomTarget.slice(0);
} else {
//Single entity
that._zoomTarget = [zoomTarget];
}
});
return zoomPromise.promise;
}
function clearZoom(viewer) {
viewer._zoomPromise = undefined;
viewer._zoomTarget = undefined;
viewer._zoomOptions = undefined;
}
function cancelZoom(viewer) {
var zoomPromise = viewer._zoomPromise;
if (defined(zoomPromise)) {
clearZoom(viewer);
zoomPromise.resolve(false);
}
}
/**
* @private
*/
Viewer.prototype._postRender = function() {
updateZoomTarget(this);
updateTrackedEntity(this);
};
function updateZoomTarget(viewer) {
var entities = viewer._zoomTarget;
if (!defined(entities) || viewer.scene.mode === SceneMode.MORPHING) {
return;
}
var scene = viewer.scene;
var camera = scene.camera;
var zoomPromise = viewer._zoomPromise;
var zoomOptions = defaultValue(viewer._zoomOptions, {});
//If zoomTarget was an ImageryLayer
if (entities instanceof Rectangle) {
var options = {
destination : entities,
duration : zoomOptions.duration,
maximumHeight : zoomOptions.maximumHeight,
complete : function() {
zoomPromise.resolve(true);
},
cancel : function() {
zoomPromise.resolve(false);
}
};
if (viewer._zoomIsFlight) {
camera.flyTo(options);
} else {
camera.setView(options);
zoomPromise.resolve(true);
}
clearZoom(viewer);
return;
}
var boundingSpheres = [];
for (var i = 0, len = entities.length; i < len; i++) {
var state = viewer._dataSourceDisplay.getBoundingSphere(entities[i], false, boundingSphereScratch);
if (state === BoundingSphereState.PENDING) {
return;
} else if (state !== BoundingSphereState.FAILED) {
boundingSpheres.push(BoundingSphere.clone(boundingSphereScratch));
}
}
if (boundingSpheres.length === 0) {
cancelZoom(viewer);
return;
}
//Stop tracking the current entity.
viewer.trackedEntity = undefined;
var boundingSphere = BoundingSphere.fromBoundingSpheres(boundingSpheres);
var controller = scene.screenSpaceCameraController;
controller.minimumZoomDistance = Math.min(controller.minimumZoomDistance, boundingSphere.radius * 0.5);
if (!viewer._zoomIsFlight) {
camera.viewBoundingSphere(boundingSphere, viewer._zoomOptions);
camera.lookAtTransform(Matrix4.IDENTITY);
clearZoom(viewer);
zoomPromise.resolve(true);
} else {
clearZoom(viewer);
camera.flyToBoundingSphere(boundingSphere, {
duration : zoomOptions.duration,
maximumHeight : zoomOptions.maximumHeight,
complete : function() {
zoomPromise.resolve(true);
},
cancel : function() {
zoomPromise.resolve(false);
},
offset : zoomOptions.offset
});
}
}
function updateTrackedEntity(viewer) {
if (!viewer._needTrackedEntityUpdate) {
return;
}
var trackedEntity = viewer._trackedEntity;
var currentTime = viewer.clock.currentTime;
//Verify we have a current position at this time. This is only triggered if a position
//has become undefined after trackedEntity is set but before the boundingSphere has been
//computed. In this case, we will track the entity once it comes back into existence.
var currentPosition = Property.getValueOrUndefined(trackedEntity.position, currentTime);
if (!defined(currentPosition)) {
return;
}
var scene = viewer.scene;
var state = viewer._dataSourceDisplay.getBoundingSphere(trackedEntity, false, boundingSphereScratch);
if (state === BoundingSphereState.PENDING) {
return;
}
var sceneMode = scene.mode;
if (sceneMode === SceneMode.COLUMBUS_VIEW || sceneMode === SceneMode.SCENE2D) {
scene.screenSpaceCameraController.enableTranslate = false;
}
if (sceneMode === SceneMode.COLUMBUS_VIEW || sceneMode === SceneMode.SCENE3D) {
scene.screenSpaceCameraController.enableTilt = false;
}
var bs = state !== BoundingSphereState.FAILED ? boundingSphereScratch : undefined;
viewer._entityView = new EntityView(trackedEntity, scene, scene.mapProjection.ellipsoid);
viewer._entityView.update(currentTime, bs);
viewer._needTrackedEntityUpdate = false;
}
/**
* A function that augments a Viewer instance with additional functionality.
* @callback Viewer~ViewerMixin
* @param {Viewer} viewer The viewer instance.
* @param {Object} options Options object to be passed to the mixin function.
*
* @see Viewer#extend
*/
return Viewer;
});
/*global define*/
define('Widgets/Viewer/viewerCesiumInspectorMixin',[
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../CesiumInspector/CesiumInspector'
], function(
defined,
defineProperties,
DeveloperError,
CesiumInspector) {
'use strict';
/**
* A mixin which adds the CesiumInspector widget to the Viewer widget.
* Rather than being called directly, this function is normally passed as
* a parameter to {@link Viewer#extend}, as shown in the example below.
* @exports viewerCesiumInspectorMixin
*
* @param {Viewer} viewer The viewer instance.
*
* @exception {DeveloperError} viewer is required.
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Cesium%20Inspector.html|Cesium Sandcastle Cesium Inspector Demo}
*
* @example
* var viewer = new Cesium.Viewer('cesiumContainer');
* viewer.extend(Cesium.viewerCesiumInspectorMixin);
*/
function viewerCesiumInspectorMixin(viewer) {
if (!defined(viewer)) {
throw new DeveloperError('viewer is required.');
}
var cesiumInspectorContainer = document.createElement('div');
cesiumInspectorContainer.className = 'cesium-viewer-cesiumInspectorContainer';
viewer.container.appendChild(cesiumInspectorContainer);
var cesiumInspector = new CesiumInspector(cesiumInspectorContainer, viewer.scene);
defineProperties(viewer, {
cesiumInspector : {
get : function() {
return cesiumInspector;
}
}
});
viewer.scene.postRender.addEventListener(function() {
viewer.cesiumInspector.viewModel.update();
});
}
return viewerCesiumInspectorMixin;
});
/*global define*/
define('Widgets/Viewer/viewerDragDropMixin',[
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../../Core/Event',
'../../Core/wrapFunction',
'../../DataSources/CzmlDataSource',
'../../DataSources/GeoJsonDataSource',
'../../DataSources/KmlDataSource',
'../getElement'
], function(
defaultValue,
defined,
defineProperties,
DeveloperError,
Event,
wrapFunction,
CzmlDataSource,
GeoJsonDataSource,
KmlDataSource,
getElement) {
'use strict';
/**
* A mixin which adds default drag and drop support for CZML files to the Viewer widget.
* Rather than being called directly, this function is normally passed as
* a parameter to {@link Viewer#extend}, as shown in the example below.
* @exports viewerDragDropMixin
*
* @param {Viewer} viewer The viewer instance.
* @param {Object} [options] Object with the following properties:
* @param {Element|String} [options.dropTarget=viewer.container] The DOM element which will serve as the drop target.
* @param {Boolean} [options.clearOnDrop=true] When true, dropping files will clear all existing data sources first, when false, new data sources will be loaded after the existing ones.
* @param {Boolean} [options.flyToOnDrop=true] When true, dropping files will fly to the data source once it is loaded.
* @param {Boolean} [options.clampToGround=true] When true, datasources are clamped to the ground.
* @param {DefaultProxy} [options.proxy] The proxy to be used for KML network links.
*
* @exception {DeveloperError} Element with id <options.dropTarget> does not exist in the document.
* @exception {DeveloperError} dropTarget is already defined by another mixin.
* @exception {DeveloperError} dropEnabled is already defined by another mixin.
* @exception {DeveloperError} dropError is already defined by another mixin.
* @exception {DeveloperError} clearOnDrop is already defined by another mixin.
*
* @example
* // Add basic drag and drop support and pop up an alert window on error.
* var viewer = new Cesium.Viewer('cesiumContainer');
* viewer.extend(Cesium.viewerDragDropMixin);
* viewer.dropError.addEventListener(function(viewerArg, source, error) {
* window.alert('Error processing ' + source + ':' + error);
* });
*/
function viewerDragDropMixin(viewer, options) {
if (!defined(viewer)) {
throw new DeveloperError('viewer is required.');
}
if (viewer.hasOwnProperty('dropTarget')) {
throw new DeveloperError('dropTarget is already defined by another mixin.');
}
if (viewer.hasOwnProperty('dropEnabled')) {
throw new DeveloperError('dropEnabled is already defined by another mixin.');
}
if (viewer.hasOwnProperty('dropError')) {
throw new DeveloperError('dropError is already defined by another mixin.');
}
if (viewer.hasOwnProperty('clearOnDrop')) {
throw new DeveloperError('clearOnDrop is already defined by another mixin.');
}
if (viewer.hasOwnProperty('flyToOnDrop')) {
throw new DeveloperError('flyToOnDrop is already defined by another mixin.');
}
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
//Local variables to be closed over by defineProperties.
var dropEnabled = true;
var flyToOnDrop = defaultValue(options.flyToOnDrop, true);
var dropError = new Event();
var clearOnDrop = defaultValue(options.clearOnDrop, true);
var dropTarget = defaultValue(options.dropTarget, viewer.container);
var clampToGround = defaultValue(options.clampToGround, true);
var proxy = options.proxy;
dropTarget = getElement(dropTarget);
defineProperties(viewer, {
/**
* Gets or sets the element to serve as the drop target.
* @memberof viewerDragDropMixin.prototype
* @type {Element}
*/
dropTarget : {
//TODO See https://github.com/AnalyticalGraphicsInc/cesium/issues/832
get : function() {
return dropTarget;
},
set : function(value) {
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
unsubscribe(dropTarget, handleDrop);
dropTarget = value;
subscribe(dropTarget, handleDrop);
}
},
/**
* Gets or sets a value indicating if drag and drop support is enabled.
* @memberof viewerDragDropMixin.prototype
* @type {Element}
*/
dropEnabled : {
get : function() {
return dropEnabled;
},
set : function(value) {
if (value !== dropEnabled) {
if (value) {
subscribe(dropTarget, handleDrop);
} else {
unsubscribe(dropTarget, handleDrop);
}
dropEnabled = value;
}
}
},
/**
* Gets the event that will be raised when an error is encountered during drop processing.
* @memberof viewerDragDropMixin.prototype
* @type {Event}
*/
dropError : {
get : function() {
return dropError;
}
},
/**
* Gets or sets a value indicating if existing data sources should be cleared before adding the newly dropped sources.
* @memberof viewerDragDropMixin.prototype
* @type {Boolean}
*/
clearOnDrop : {
get : function() {
return clearOnDrop;
},
set : function(value) {
clearOnDrop = value;
}
},
/**
* Gets or sets a value indicating if the camera should fly to the data source after it is loaded.
* @memberof viewerDragDropMixin.prototype
* @type {Boolean}
*/
flyToOnDrop : {
get : function() {
return flyToOnDrop;
},
set : function(value) {
flyToOnDrop = value;
}
},
/**
* Gets or sets the proxy to be used for KML.
* @memberof viewerDragDropMixin.prototype
* @type {DefaultProxy}
*/
proxy : {
get : function() {
return proxy;
},
set : function(value) {
proxy = value;
}
},
/**
* Gets or sets a value indicating if the datasources should be clamped to the ground
* @memberof viewerDragDropMixin.prototype
* @type {Boolean}
*/
clampToGround : {
get : function() {
return clampToGround;
},
set : function(value) {
clampToGround = value;
}
}
});
function handleDrop(event) {
stop(event);
if (clearOnDrop) {
viewer.entities.removeAll();
viewer.dataSources.removeAll();
}
var files = event.dataTransfer.files;
var length = files.length;
for (var i = 0; i < length; i++) {
var file = files[i];
var reader = new FileReader();
reader.onload = createOnLoadCallback(viewer, file, proxy, clampToGround);
reader.onerror = createDropErrorCallback(viewer, file);
reader.readAsText(file);
}
}
//Enable drop by default;
subscribe(dropTarget, handleDrop);
//Wrap the destroy function to make sure all events are unsubscribed from
viewer.destroy = wrapFunction(viewer, viewer.destroy, function() {
viewer.dropEnabled = false;
});
//Specs need access to handleDrop
viewer._handleDrop = handleDrop;
}
function stop(event) {
event.stopPropagation();
event.preventDefault();
}
function unsubscribe(dropTarget, handleDrop) {
var currentTarget = dropTarget;
if (defined(currentTarget)) {
currentTarget.removeEventListener('drop', handleDrop, false);
currentTarget.removeEventListener('dragenter', stop, false);
currentTarget.removeEventListener('dragover', stop, false);
currentTarget.removeEventListener('dragexit', stop, false);
}
}
function subscribe(dropTarget, handleDrop) {
dropTarget.addEventListener('drop', handleDrop, false);
dropTarget.addEventListener('dragenter', stop, false);
dropTarget.addEventListener('dragover', stop, false);
dropTarget.addEventListener('dragexit', stop, false);
}
function createOnLoadCallback(viewer, file, proxy, clampToGround) {
var scene = viewer.scene;
return function(evt) {
var fileName = file.name;
try {
var loadPromise;
if (/\.czml$/i.test(fileName)) {
loadPromise = CzmlDataSource.load(JSON.parse(evt.target.result), {
sourceUri : fileName
});
} else if (/\.geojson$/i.test(fileName) || /\.json$/i.test(fileName) || /\.topojson$/i.test(fileName)) {
loadPromise = GeoJsonDataSource.load(JSON.parse(evt.target.result), {
sourceUri : fileName,
clampToGround : clampToGround
});
} else if (/\.(kml|kmz)$/i.test(fileName)) {
loadPromise = KmlDataSource.load(file, {
sourceUri : fileName,
proxy : proxy,
camera : scene.camera,
canvas : scene.canvas
});
} else {
viewer.dropError.raiseEvent(viewer, fileName, 'Unrecognized file: ' + fileName);
return;
}
if (defined(loadPromise)) {
viewer.dataSources.add(loadPromise).then(function(dataSource) {
if (viewer.flyToOnDrop) {
viewer.flyTo(dataSource);
}
}).otherwise(function(error) {
viewer.dropError.raiseEvent(viewer, fileName, error);
});
}
} catch (error) {
viewer.dropError.raiseEvent(viewer, fileName, error);
}
};
}
function createDropErrorCallback(viewer, file) {
return function(evt) {
viewer.dropError.raiseEvent(viewer, file.name, evt.target.error);
};
}
return viewerDragDropMixin;
});
/*global define*/
define('Widgets/Viewer/viewerPerformanceWatchdogMixin',[
'../../Core/defaultValue',
'../../Core/defined',
'../../Core/defineProperties',
'../../Core/DeveloperError',
'../PerformanceWatchdog/PerformanceWatchdog'
], function(
defaultValue,
defined,
defineProperties,
DeveloperError,
PerformanceWatchdog) {
'use strict';
/**
* A mixin which adds the {@link PerformanceWatchdog} widget to the {@link Viewer} widget.
* Rather than being called directly, this function is normally passed as
* a parameter to {@link Viewer#extend}, as shown in the example below.
* @exports viewerPerformanceWatchdogMixin
*
* @param {Viewer} viewer The viewer instance.
* @param {String} [options.lowFrameRateMessage='This application appears to be performing poorly on your system. Please try using a different web browser or updating your video drivers.'] The
* message to display when a low frame rate is detected. The message is interpeted as HTML, so make sure
* it comes from a trusted source so that your application is not vulnerable to cross-site scripting attacks.
*
* @exception {DeveloperError} viewer is required.
*
* @example
* var viewer = new Cesium.Viewer('cesiumContainer');
* viewer.extend(Cesium.viewerPerformanceWatchdogMixin, {
* lowFrameRateMessage : 'Why is this going so <em>slowly</em>?'
* });
*/
function viewerPerformanceWatchdogMixin(viewer, options) {
if (!defined(viewer)) {
throw new DeveloperError('viewer is required.');
}
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var performanceWatchdog = new PerformanceWatchdog({
scene : viewer.scene,
container : viewer.bottomContainer,
lowFrameRateMessage : options.lowFrameRateMessage
});
defineProperties(viewer, {
performanceWatchdog : {
get : function() {
return performanceWatchdog;
}
}
});
}
return viewerPerformanceWatchdogMixin;
});
/*global define*/
define('Workers/createTaskProcessorWorker',[
'../Core/defaultValue',
'../Core/defined',
'../Core/formatError'
], function(
defaultValue,
defined,
formatError) {
'use strict';
/**
* Creates an adapter function to allow a calculation function to operate as a Web Worker,
* paired with TaskProcessor, to receive tasks and return results.
*
* @exports createTaskProcessorWorker
*
* @param {createTaskProcessorWorker~WorkerFunction} workerFunction The calculation function,
* which takes parameters and returns a result.
* @returns {createTaskProcessorWorker~TaskProcessorWorkerFunction} A function that adapts the
* calculation function to work as a Web Worker onmessage listener with TaskProcessor.
*
*
* @example
* function doCalculation(parameters, transferableObjects) {
* // calculate some result using the inputs in parameters
* return result;
* }
*
* return Cesium.createTaskProcessorWorker(doCalculation);
* // the resulting function is compatible with TaskProcessor
*
* @see TaskProcessor
* @see {@link http://www.w3.org/TR/workers/|Web Workers}
* @see {@link http://www.w3.org/TR/html5/common-dom-interfaces.html#transferable-objects|Transferable objects}
*/
function createTaskProcessorWorker(workerFunction) {
var postMessage;
var transferableObjects = [];
var responseMessage = {
id : undefined,
result : undefined,
error : undefined
};
return function(event) {
/*global self*/
var data = event.data;
transferableObjects.length = 0;
responseMessage.id = data.id;
responseMessage.error = undefined;
responseMessage.result = undefined;
try {
responseMessage.result = workerFunction(data.parameters, transferableObjects);
} catch (e) {
if (e instanceof Error) {
// Errors can't be posted in a message, copy the properties
responseMessage.error = {
name : e.name,
message : e.message,
stack : e.stack
};
} else {
responseMessage.error = e;
}
}
if (!defined(postMessage)) {
postMessage = defaultValue(self.webkitPostMessage, self.postMessage);
}
if (!data.canTransferArrayBuffer) {
transferableObjects.length = 0;
}
try {
postMessage(responseMessage, transferableObjects);
} catch (e) {
// something went wrong trying to post the message, post a simpler
// error that we can be sure will be cloneable
responseMessage.result = undefined;
responseMessage.error = 'postMessage failed with error: ' + formatError(e) + '\n with responseMessage: ' + JSON.stringify(responseMessage);
postMessage(responseMessage);
}
};
}
/**
* A function that performs a calculation in a Web Worker.
* @callback createTaskProcessorWorker~WorkerFunction
*
* @param {Object} parameters Parameters to the calculation.
* @param {Array} transferableObjects An array that should be filled with references to objects inside
* the result that should be transferred back to the main document instead of copied.
* @returns {Object} The result of the calculation.
*
* @example
* function calculate(parameters, transferableObjects) {
* // perform whatever calculation is necessary.
* var typedArray = new Float32Array(0);
*
* // typed arrays are transferable
* transferableObjects.push(typedArray)
*
* return {
* typedArray : typedArray
* };
* }
*/
/**
* A Web Worker message event handler function that handles the interaction with TaskProcessor,
* specifically, task ID management and posting a response message containing the result.
* @callback createTaskProcessorWorker~TaskProcessorWorkerFunction
*
* @param {Object} event The onmessage event object.
*/
return createTaskProcessorWorker;
});
/*global define*/
define('Cesium',['./Core/appendForwardSlash', './Core/ArcGisImageServerTerrainProvider', './Core/arrayRemoveDuplicates', './Core/AssociativeArray', './Core/AttributeCompression', './Core/AxisAlignedBoundingBox', './Core/barycentricCoordinates', './Core/binarySearch', './Core/BingMapsApi', './Core/BoundingRectangle', './Core/BoundingSphere', './Core/BoxGeometry', './Core/BoxOutlineGeometry', './Core/buildModuleUrl', './Core/cancelAnimationFrame', './Core/Cartesian2', './Core/Cartesian3', './Core/Cartesian4', './Core/Cartographic', './Core/CatmullRomSpline', './Core/CesiumTerrainProvider', './Core/Check', './Core/CircleGeometry', './Core/CircleOutlineGeometry', './Core/Clock', './Core/ClockRange', './Core/ClockStep', './Core/clone', './Core/Color', './Core/ColorGeometryInstanceAttribute', './Core/combine', './Core/ComponentDatatype', './Core/CornerType', './Core/CorridorGeometry', './Core/CorridorGeometryLibrary', './Core/CorridorOutlineGeometry', './Core/createGuid', './Core/Credit', './Core/CubicRealPolynomial', './Core/CylinderGeometry', './Core/CylinderGeometryLibrary', './Core/CylinderOutlineGeometry', './Core/DefaultProxy', './Core/defaultValue', './Core/defined', './Core/defineProperties', './Core/deprecationWarning', './Core/destroyObject', './Core/DeveloperError', './Core/DistanceDisplayCondition', './Core/DistanceDisplayConditionGeometryInstanceAttribute', './Core/EarthOrientationParameters', './Core/EarthOrientationParametersSample', './Core/EasingFunction', './Core/EllipseGeometry', './Core/EllipseGeometryLibrary', './Core/EllipseOutlineGeometry', './Core/Ellipsoid', './Core/EllipsoidalOccluder', './Core/EllipsoidGeodesic', './Core/EllipsoidGeometry', './Core/EllipsoidOutlineGeometry', './Core/EllipsoidTangentPlane', './Core/EllipsoidTerrainProvider', './Core/EncodedCartesian3', './Core/Event', './Core/EventHelper', './Core/ExtrapolationType', './Core/FeatureDetection', './Core/formatError', './Core/freezeObject', './Core/Fullscreen', './Core/GeographicProjection', './Core/GeographicTilingScheme', './Core/Geometry', './Core/GeometryAttribute', './Core/GeometryAttributes', './Core/GeometryInstance', './Core/GeometryInstanceAttribute', './Core/GeometryPipeline', './Core/GeometryType', './Core/getAbsoluteUri', './Core/getBaseUri', './Core/getExtensionFromUri', './Core/getFilenameFromUri', './Core/getImagePixels', './Core/getMagic', './Core/getStringFromTypedArray', './Core/getTimestamp', './Core/GregorianDate', './Core/HeadingPitchRange', './Core/HeadingPitchRoll', './Core/HeightmapTerrainData', './Core/HeightmapTessellator', './Core/HermitePolynomialApproximation', './Core/HermiteSpline', './Core/Iau2000Orientation', './Core/Iau2006XysData', './Core/Iau2006XysSample', './Core/IauOrientationAxes', './Core/IauOrientationParameters', './Core/IndexDatatype', './Core/InterpolationAlgorithm', './Core/Intersect', './Core/Intersections2D', './Core/IntersectionTests', './Core/Interval', './Core/isArray', './Core/isCrossOriginUrl', './Core/isLeapYear', './Core/Iso8601', './Core/joinUrls', './Core/JulianDate', './Core/KeyboardEventModifier', './Core/LagrangePolynomialApproximation', './Core/LeapSecond', './Core/LinearApproximation', './Core/LinearSpline', './Core/loadArrayBuffer', './Core/loadBlob', './Core/loadImage', './Core/loadImageFromTypedArray', './Core/loadImageViaBlob', './Core/loadJson', './Core/loadJsonp', './Core/loadText', './Core/loadWithXhr', './Core/loadXML', './Core/MapboxApi', './Core/MapProjection', './Core/Math', './Core/Matrix2', './Core/Matrix3', './Core/Matrix4', './Core/mergeSort', './Core/NearFarScalar', './Core/objectToQuery', './Core/Occluder', './Core/oneTimeWarning', './Core/OrientedBoundingBox', './Core/Packable', './Core/PackableForInterpolation', './Core/parseResponseHeaders', './Core/PinBuilder', './Core/PixelFormat', './Core/Plane', './Core/PointGeometry', './Core/pointInsideTriangle', './Core/PolygonGeometry', './Core/PolygonGeometryLibrary', './Core/PolygonHierarchy', './Core/PolygonOutlineGeometry', './Core/PolygonPipeline', './Core/PolylineGeometry', './Core/PolylinePipeline', './Core/PolylineVolumeGeometry', './Core/PolylineVolumeGeometryLibrary', './Core/PolylineVolumeOutlineGeometry', './Core/PrimitiveType', './Core/QuadraticRealPolynomial', './Core/QuantizedMeshTerrainData', './Core/QuarticRealPolynomial', './Core/Quaternion', './Core/QuaternionSpline', './Core/queryToObject', './Core/Queue', './Core/Ray', './Core/Rectangle', './Core/RectangleGeometry', './Core/RectangleGeometryLibrary', './Core/RectangleOutlineGeometry', './Core/ReferenceFrame', './Core/requestAnimationFrame', './Core/RequestErrorEvent', './Core/RuntimeError', './Core/sampleTerrain', './Core/scaleToGeodeticSurface', './Core/ScreenSpaceEventHandler', './Core/ScreenSpaceEventType', './Core/ShowGeometryInstanceAttribute', './Core/Simon1994PlanetaryPositions', './Core/SimplePolylineGeometry', './Core/SphereGeometry', './Core/SphereOutlineGeometry', './Core/Spherical', './Core/Spline', './Core/subdivideArray', './Core/TaskProcessor', './Core/TerrainData', './Core/TerrainEncoding', './Core/TerrainMesh', './Core/TerrainProvider', './Core/TerrainQuantization', './Core/throttleRequestByServer', './Core/TileProviderError', './Core/TilingScheme', './Core/TimeConstants', './Core/TimeInterval', './Core/TimeIntervalCollection', './Core/TimeStandard', './Core/Tipsify', './Core/Transforms', './Core/TranslationRotationScale', './Core/TridiagonalSystemSolver', './Core/TrustedServers', './Core/VertexFormat', './Core/VideoSynchronizer', './Core/Visibility', './Core/VRTheWorldTerrainProvider', './Core/WallGeometry', './Core/WallGeometryLibrary', './Core/WallOutlineGeometry', './Core/WebGLConstants', './Core/WebMercatorProjection', './Core/WebMercatorTilingScheme', './Core/WindingOrder', './Core/wrapFunction', './Core/writeTextToCanvas', './DataSources/BillboardGraphics', './DataSources/BillboardVisualizer', './DataSources/BoundingSphereState', './DataSources/BoxGeometryUpdater', './DataSources/BoxGraphics', './DataSources/CallbackProperty', './DataSources/CheckerboardMaterialProperty', './DataSources/ColorMaterialProperty', './DataSources/CompositeEntityCollection', './DataSources/CompositeMaterialProperty', './DataSources/CompositePositionProperty', './DataSources/CompositeProperty', './DataSources/ConstantPositionProperty', './DataSources/ConstantProperty', './DataSources/CorridorGeometryUpdater', './DataSources/CorridorGraphics', './DataSources/createMaterialPropertyDescriptor', './DataSources/createPropertyDescriptor', './DataSources/createRawPropertyDescriptor', './DataSources/CustomDataSource', './DataSources/CylinderGeometryUpdater', './DataSources/CylinderGraphics', './DataSources/CzmlDataSource', './DataSources/DataSource', './DataSources/DataSourceClock', './DataSources/DataSourceCollection', './DataSources/DataSourceDisplay', './DataSources/dynamicGeometryGetBoundingSphere', './DataSources/DynamicGeometryUpdater', './DataSources/EllipseGeometryUpdater', './DataSources/EllipseGraphics', './DataSources/EllipsoidGeometryUpdater', './DataSources/EllipsoidGraphics', './DataSources/Entity', './DataSources/EntityCluster', './DataSources/EntityCollection', './DataSources/EntityView', './DataSources/GeoJsonDataSource', './DataSources/GeometryUpdater', './DataSources/GeometryVisualizer', './DataSources/GridMaterialProperty', './DataSources/ImageMaterialProperty', './DataSources/KmlDataSource', './DataSources/LabelGraphics', './DataSources/LabelVisualizer', './DataSources/MaterialProperty', './DataSources/ModelGraphics', './DataSources/ModelVisualizer', './DataSources/NodeTransformationProperty', './DataSources/PathGraphics', './DataSources/PathVisualizer', './DataSources/PointGraphics', './DataSources/PointVisualizer', './DataSources/PolygonGeometryUpdater', './DataSources/PolygonGraphics', './DataSources/PolylineArrowMaterialProperty', './DataSources/PolylineGeometryUpdater', './DataSources/PolylineGlowMaterialProperty', './DataSources/PolylineGraphics', './DataSources/PolylineOutlineMaterialProperty', './DataSources/PolylineVolumeGeometryUpdater', './DataSources/PolylineVolumeGraphics', './DataSources/PositionProperty', './DataSources/PositionPropertyArray', './DataSources/Property', './DataSources/PropertyArray', './DataSources/PropertyBag', './DataSources/RectangleGeometryUpdater', './DataSources/RectangleGraphics', './DataSources/ReferenceProperty', './DataSources/Rotation', './DataSources/SampledPositionProperty', './DataSources/SampledProperty', './DataSources/ScaledPositionProperty', './DataSources/StaticGeometryColorBatch', './DataSources/StaticGeometryPerMaterialBatch', './DataSources/StaticGroundGeometryColorBatch', './DataSources/StaticOutlineGeometryBatch', './DataSources/StripeMaterialProperty', './DataSources/StripeOrientation', './DataSources/TimeIntervalCollectionPositionProperty', './DataSources/TimeIntervalCollectionProperty', './DataSources/VelocityOrientationProperty', './DataSources/VelocityVectorProperty', './DataSources/Visualizer', './DataSources/WallGeometryUpdater', './DataSources/WallGraphics', './Renderer/AutomaticUniforms', './Renderer/Buffer', './Renderer/BufferUsage', './Renderer/ClearCommand', './Renderer/ComputeCommand', './Renderer/ComputeEngine', './Renderer/Context', './Renderer/ContextLimits', './Renderer/createUniform', './Renderer/createUniformArray', './Renderer/CubeMap', './Renderer/CubeMapFace', './Renderer/DrawCommand', './Renderer/Framebuffer', './Renderer/loadCubeMap', './Renderer/MipmapHint', './Renderer/Pass', './Renderer/PassState', './Renderer/PickFramebuffer', './Renderer/PixelDatatype', './Renderer/Renderbuffer', './Renderer/RenderbufferFormat', './Renderer/RenderState', './Renderer/Sampler', './Renderer/ShaderCache', './Renderer/ShaderProgram', './Renderer/ShaderSource', './Renderer/Texture', './Renderer/TextureMagnificationFilter', './Renderer/TextureMinificationFilter', './Renderer/TextureWrap', './Renderer/UniformState', './Renderer/VertexArray', './Renderer/VertexArrayFacade', './Scene/Appearance', './Scene/ArcGisMapServerImageryProvider', './Scene/BatchTable', './Scene/Billboard', './Scene/BillboardCollection', './Scene/BingMapsImageryProvider', './Scene/BingMapsStyle', './Scene/BlendEquation', './Scene/BlendFunction', './Scene/BlendingState', './Scene/Camera', './Scene/CameraEventAggregator', './Scene/CameraEventType', './Scene/CameraFlightPath', './Scene/ColorBlendMode', './Scene/createOpenStreetMapImageryProvider', './Scene/createTangentSpaceDebugPrimitive', './Scene/createTileMapServiceImageryProvider', './Scene/CreditDisplay', './Scene/CullFace', './Scene/CullingVolume', './Scene/DebugAppearance', './Scene/DebugCameraPrimitive', './Scene/DebugModelMatrixPrimitive', './Scene/DepthFunction', './Scene/DepthPlane', './Scene/DeviceOrientationCameraController', './Scene/DiscardMissingTileImagePolicy', './Scene/EllipsoidPrimitive', './Scene/EllipsoidSurfaceAppearance', './Scene/Fog', './Scene/FrameRateMonitor', './Scene/FrameState', './Scene/FrustumCommands', './Scene/FXAA', './Scene/getAttributeOrUniformBySemantic', './Scene/getBinaryAccessor', './Scene/GetFeatureInfoFormat', './Scene/Globe', './Scene/GlobeDepth', './Scene/GlobeSurfaceShaderSet', './Scene/GlobeSurfaceTile', './Scene/GlobeSurfaceTileProvider', './Scene/GoogleEarthImageryProvider', './Scene/GridImageryProvider', './Scene/GroundPrimitive', './Scene/HeightReference', './Scene/HorizontalOrigin', './Scene/Imagery', './Scene/ImageryLayer', './Scene/ImageryLayerCollection', './Scene/ImageryLayerFeatureInfo', './Scene/ImageryProvider', './Scene/ImageryState', './Scene/Label', './Scene/LabelCollection', './Scene/LabelStyle', './Scene/MapboxImageryProvider', './Scene/MapMode2D', './Scene/Material', './Scene/MaterialAppearance', './Scene/Model', './Scene/ModelAnimation', './Scene/ModelAnimationCache', './Scene/ModelAnimationCollection', './Scene/ModelAnimationLoop', './Scene/ModelAnimationState', './Scene/ModelMaterial', './Scene/modelMaterialsCommon', './Scene/ModelMesh', './Scene/ModelNode', './Scene/Moon', './Scene/NeverTileDiscardPolicy', './Scene/OIT', './Scene/OrthographicFrustum', './Scene/PerformanceDisplay', './Scene/PerInstanceColorAppearance', './Scene/PerspectiveFrustum', './Scene/PerspectiveOffCenterFrustum', './Scene/PickDepth', './Scene/PointAppearance', './Scene/PointPrimitive', './Scene/PointPrimitiveCollection', './Scene/Polyline', './Scene/PolylineCollection', './Scene/PolylineColorAppearance', './Scene/PolylineMaterialAppearance', './Scene/Primitive', './Scene/PrimitiveCollection', './Scene/PrimitivePipeline', './Scene/PrimitiveState', './Scene/QuadtreeOccluders', './Scene/QuadtreePrimitive', './Scene/QuadtreeTile', './Scene/QuadtreeTileLoadState', './Scene/QuadtreeTileProvider', './Scene/Scene', './Scene/SceneMode', './Scene/SceneTransforms', './Scene/SceneTransitioner', './Scene/ScreenSpaceCameraController', './Scene/ShadowMap', './Scene/ShadowMapShader', './Scene/ShadowMode', './Scene/SingleTileImageryProvider', './Scene/SkyAtmosphere', './Scene/SkyBox', './Scene/StencilFunction', './Scene/StencilOperation', './Scene/Sun', './Scene/SunPostProcess', './Scene/TerrainState', './Scene/TextureAtlas', './Scene/TileBoundingBox', './Scene/TileCoordinatesImageryProvider', './Scene/TileDiscardPolicy', './Scene/TileImagery', './Scene/TileReplacementQueue', './Scene/TileState', './Scene/TileTerrain', './Scene/TweenCollection', './Scene/UrlTemplateImageryProvider', './Scene/VerticalOrigin', './Scene/ViewportQuad', './Scene/WebMapServiceImageryProvider', './Scene/WebMapTileServiceImageryProvider', './Shaders/AdjustTranslucentFS', './Shaders/Appearances/AllMaterialAppearanceFS', './Shaders/Appearances/AllMaterialAppearanceVS', './Shaders/Appearances/BasicMaterialAppearanceFS', './Shaders/Appearances/BasicMaterialAppearanceVS', './Shaders/Appearances/EllipsoidSurfaceAppearanceFS', './Shaders/Appearances/EllipsoidSurfaceAppearanceVS', './Shaders/Appearances/PerInstanceColorAppearanceFS', './Shaders/Appearances/PerInstanceColorAppearanceVS', './Shaders/Appearances/PerInstanceFlatColorAppearanceFS', './Shaders/Appearances/PerInstanceFlatColorAppearanceVS', './Shaders/Appearances/PointAppearanceFS', './Shaders/Appearances/PointAppearanceVS', './Shaders/Appearances/PolylineColorAppearanceVS', './Shaders/Appearances/PolylineMaterialAppearanceVS', './Shaders/Appearances/TexturedMaterialAppearanceFS', './Shaders/Appearances/TexturedMaterialAppearanceVS', './Shaders/BillboardCollectionFS', './Shaders/BillboardCollectionVS', './Shaders/Builtin/Constants/degreesPerRadian', './Shaders/Builtin/Constants/depthRange', './Shaders/Builtin/Constants/epsilon1', './Shaders/Builtin/Constants/epsilon2', './Shaders/Builtin/Constants/epsilon3', './Shaders/Builtin/Constants/epsilon4', './Shaders/Builtin/Constants/epsilon5', './Shaders/Builtin/Constants/epsilon6', './Shaders/Builtin/Constants/epsilon7', './Shaders/Builtin/Constants/infinity', './Shaders/Builtin/Constants/oneOverPi', './Shaders/Builtin/Constants/oneOverTwoPi', './Shaders/Builtin/Constants/passCompute', './Shaders/Builtin/Constants/passEnvironment', './Shaders/Builtin/Constants/passGlobe', './Shaders/Builtin/Constants/passGround', './Shaders/Builtin/Constants/passOpaque', './Shaders/Builtin/Constants/passOverlay', './Shaders/Builtin/Constants/passTranslucent', './Shaders/Builtin/Constants/pi', './Shaders/Builtin/Constants/piOverFour', './Shaders/Builtin/Constants/piOverSix', './Shaders/Builtin/Constants/piOverThree', './Shaders/Builtin/Constants/piOverTwo', './Shaders/Builtin/Constants/radiansPerDegree', './Shaders/Builtin/Constants/sceneMode2D', './Shaders/Builtin/Constants/sceneMode3D', './Shaders/Builtin/Constants/sceneModeColumbusView', './Shaders/Builtin/Constants/sceneModeMorphing', './Shaders/Builtin/Constants/solarRadius', './Shaders/Builtin/Constants/threePiOver2', './Shaders/Builtin/Constants/twoPi', './Shaders/Builtin/Constants/webMercatorMaxLatitude', './Shaders/Builtin/CzmBuiltins', './Shaders/Builtin/Functions/alphaWeight', './Shaders/Builtin/Functions/antialias', './Shaders/Builtin/Functions/cascadeColor', './Shaders/Builtin/Functions/cascadeDistance', './Shaders/Builtin/Functions/cascadeMatrix', './Shaders/Builtin/Functions/cascadeWeights', './Shaders/Builtin/Functions/columbusViewMorph', './Shaders/Builtin/Functions/computePosition', './Shaders/Builtin/Functions/cosineAndSine', './Shaders/Builtin/Functions/decompressTextureCoordinates', './Shaders/Builtin/Functions/eastNorthUpToEyeCoordinates', './Shaders/Builtin/Functions/ellipsoidContainsPoint', './Shaders/Builtin/Functions/ellipsoidNew', './Shaders/Builtin/Functions/ellipsoidWgs84TextureCoordinates', './Shaders/Builtin/Functions/equalsEpsilon', './Shaders/Builtin/Functions/eyeOffset', './Shaders/Builtin/Functions/eyeToWindowCoordinates', './Shaders/Builtin/Functions/fog', './Shaders/Builtin/Functions/geodeticSurfaceNormal', './Shaders/Builtin/Functions/getDefaultMaterial', './Shaders/Builtin/Functions/getLambertDiffuse', './Shaders/Builtin/Functions/getSpecular', './Shaders/Builtin/Functions/getWaterNoise', './Shaders/Builtin/Functions/getWgs84EllipsoidEC', './Shaders/Builtin/Functions/hue', './Shaders/Builtin/Functions/isEmpty', './Shaders/Builtin/Functions/isFull', './Shaders/Builtin/Functions/latitudeToWebMercatorFraction', './Shaders/Builtin/Functions/luminance', './Shaders/Builtin/Functions/metersPerPixel', './Shaders/Builtin/Functions/modelToWindowCoordinates', './Shaders/Builtin/Functions/multiplyWithColorBalance', './Shaders/Builtin/Functions/nearFarScalar', './Shaders/Builtin/Functions/octDecode', './Shaders/Builtin/Functions/packDepth', './Shaders/Builtin/Functions/phong', './Shaders/Builtin/Functions/pointAlongRay', './Shaders/Builtin/Functions/rayEllipsoidIntersectionInterval', './Shaders/Builtin/Functions/RGBToXYZ', './Shaders/Builtin/Functions/saturation', './Shaders/Builtin/Functions/shadowDepthCompare', './Shaders/Builtin/Functions/shadowVisibility', './Shaders/Builtin/Functions/signNotZero', './Shaders/Builtin/Functions/tangentToEyeSpaceMatrix', './Shaders/Builtin/Functions/translateRelativeToEye', './Shaders/Builtin/Functions/translucentPhong', './Shaders/Builtin/Functions/transpose', './Shaders/Builtin/Functions/unpackDepth', './Shaders/Builtin/Functions/windowToEyeCoordinates', './Shaders/Builtin/Functions/XYZToRGB', './Shaders/Builtin/Structs/depthRangeStruct', './Shaders/Builtin/Structs/ellipsoid', './Shaders/Builtin/Structs/material', './Shaders/Builtin/Structs/materialInput', './Shaders/Builtin/Structs/ray', './Shaders/Builtin/Structs/raySegment', './Shaders/Builtin/Structs/shadowParameters', './Shaders/CompositeOITFS', './Shaders/DepthPlaneFS', './Shaders/DepthPlaneVS', './Shaders/EllipsoidFS', './Shaders/EllipsoidVS', './Shaders/GlobeFS', './Shaders/GlobeVS', './Shaders/GroundAtmosphere', './Shaders/Materials/BumpMapMaterial', './Shaders/Materials/CheckerboardMaterial', './Shaders/Materials/DotMaterial', './Shaders/Materials/FadeMaterial', './Shaders/Materials/GridMaterial', './Shaders/Materials/NormalMapMaterial', './Shaders/Materials/PolylineArrowMaterial', './Shaders/Materials/PolylineGlowMaterial', './Shaders/Materials/PolylineOutlineMaterial', './Shaders/Materials/RimLightingMaterial', './Shaders/Materials/StripeMaterial', './Shaders/Materials/Water', './Shaders/PointPrimitiveCollectionFS', './Shaders/PointPrimitiveCollectionVS', './Shaders/PolylineCommon', './Shaders/PolylineFS', './Shaders/PolylineVS', './Shaders/PostProcessFilters/AdditiveBlend', './Shaders/PostProcessFilters/BrightPass', './Shaders/PostProcessFilters/FXAA', './Shaders/PostProcessFilters/GaussianBlur1D', './Shaders/PostProcessFilters/PassThrough', './Shaders/ReprojectWebMercatorFS', './Shaders/ReprojectWebMercatorVS', './Shaders/ShadowVolumeFS', './Shaders/ShadowVolumeVS', './Shaders/SkyAtmosphereFS', './Shaders/SkyAtmosphereVS', './Shaders/SkyBoxFS', './Shaders/SkyBoxVS', './Shaders/SunFS', './Shaders/SunTextureFS', './Shaders/SunVS', './Shaders/ViewportQuadFS', './Shaders/ViewportQuadVS', './ThirdParty/Autolinker', './ThirdParty/earcut-2.1.1', './ThirdParty/gltfDefaults', './ThirdParty/kdbush', './ThirdParty/knockout-3.4.0', './ThirdParty/knockout-es5', './ThirdParty/knockout', './ThirdParty/measureText', './ThirdParty/mersenne-twister', './ThirdParty/NoSleep', './ThirdParty/sprintf', './ThirdParty/topojson', './ThirdParty/Tween', './ThirdParty/Uri', './ThirdParty/when', './ThirdParty/zip', './Widgets/Animation/Animation', './Widgets/Animation/AnimationViewModel', './Widgets/BaseLayerPicker/BaseLayerPicker', './Widgets/BaseLayerPicker/BaseLayerPickerViewModel', './Widgets/BaseLayerPicker/createDefaultImageryProviderViewModels', './Widgets/BaseLayerPicker/createDefaultTerrainProviderViewModels', './Widgets/BaseLayerPicker/ProviderViewModel', './Widgets/CesiumInspector/CesiumInspector', './Widgets/CesiumInspector/CesiumInspectorViewModel', './Widgets/CesiumWidget/CesiumWidget', './Widgets/ClockViewModel', './Widgets/Command', './Widgets/createCommand', './Widgets/FullscreenButton/FullscreenButton', './Widgets/FullscreenButton/FullscreenButtonViewModel', './Widgets/Geocoder/Geocoder', './Widgets/Geocoder/GeocoderViewModel', './Widgets/getElement', './Widgets/HomeButton/HomeButton', './Widgets/HomeButton/HomeButtonViewModel', './Widgets/InfoBox/InfoBox', './Widgets/InfoBox/InfoBoxViewModel', './Widgets/NavigationHelpButton/NavigationHelpButton', './Widgets/NavigationHelpButton/NavigationHelpButtonViewModel', './Widgets/PerformanceWatchdog/PerformanceWatchdog', './Widgets/PerformanceWatchdog/PerformanceWatchdogViewModel', './Widgets/SceneModePicker/SceneModePicker', './Widgets/SceneModePicker/SceneModePickerViewModel', './Widgets/SelectionIndicator/SelectionIndicator', './Widgets/SelectionIndicator/SelectionIndicatorViewModel', './Widgets/subscribeAndEvaluate', './Widgets/SvgPathBindingHandler', './Widgets/Timeline/Timeline', './Widgets/Timeline/TimelineHighlightRange', './Widgets/Timeline/TimelineTrack', './Widgets/ToggleButtonViewModel', './Widgets/Viewer/Viewer', './Widgets/Viewer/viewerCesiumInspectorMixin', './Widgets/Viewer/viewerDragDropMixin', './Widgets/Viewer/viewerPerformanceWatchdogMixin', './Widgets/VRButton/VRButton', './Widgets/VRButton/VRButtonViewModel', './Workers/createTaskProcessorWorker'], function(Core_appendForwardSlash, Core_ArcGisImageServerTerrainProvider, Core_arrayRemoveDuplicates, Core_AssociativeArray, Core_AttributeCompression, Core_AxisAlignedBoundingBox, Core_barycentricCoordinates, Core_binarySearch, Core_BingMapsApi, Core_BoundingRectangle, Core_BoundingSphere, Core_BoxGeometry, Core_BoxOutlineGeometry, Core_buildModuleUrl, Core_cancelAnimationFrame, Core_Cartesian2, Core_Cartesian3, Core_Cartesian4, Core_Cartographic, Core_CatmullRomSpline, Core_CesiumTerrainProvider, Core_Check, Core_CircleGeometry, Core_CircleOutlineGeometry, Core_Clock, Core_ClockRange, Core_ClockStep, Core_clone, Core_Color, Core_ColorGeometryInstanceAttribute, Core_combine, Core_ComponentDatatype, Core_CornerType, Core_CorridorGeometry, Core_CorridorGeometryLibrary, Core_CorridorOutlineGeometry, Core_createGuid, Core_Credit, Core_CubicRealPolynomial, Core_CylinderGeometry, Core_CylinderGeometryLibrary, Core_CylinderOutlineGeometry, Core_DefaultProxy, Core_defaultValue, Core_defined, Core_defineProperties, Core_deprecationWarning, Core_destroyObject, Core_DeveloperError, Core_DistanceDisplayCondition, Core_DistanceDisplayConditionGeometryInstanceAttribute, Core_EarthOrientationParameters, Core_EarthOrientationParametersSample, Core_EasingFunction, Core_EllipseGeometry, Core_EllipseGeometryLibrary, Core_EllipseOutlineGeometry, Core_Ellipsoid, Core_EllipsoidalOccluder, Core_EllipsoidGeodesic, Core_EllipsoidGeometry, Core_EllipsoidOutlineGeometry, Core_EllipsoidTangentPlane, Core_EllipsoidTerrainProvider, Core_EncodedCartesian3, Core_Event, Core_EventHelper, Core_ExtrapolationType, Core_FeatureDetection, Core_formatError, Core_freezeObject, Core_Fullscreen, Core_GeographicProjection, Core_GeographicTilingScheme, Core_Geometry, Core_GeometryAttribute, Core_GeometryAttributes, Core_GeometryInstance, Core_GeometryInstanceAttribute, Core_GeometryPipeline, Core_GeometryType, Core_getAbsoluteUri, Core_getBaseUri, Core_getExtensionFromUri, Core_getFilenameFromUri, Core_getImagePixels, Core_getMagic, Core_getStringFromTypedArray, Core_getTimestamp, Core_GregorianDate, Core_HeadingPitchRange, Core_HeadingPitchRoll, Core_HeightmapTerrainData, Core_HeightmapTessellator, Core_HermitePolynomialApproximation, Core_HermiteSpline, Core_Iau2000Orientation, Core_Iau2006XysData, Core_Iau2006XysSample, Core_IauOrientationAxes, Core_IauOrientationParameters, Core_IndexDatatype, Core_InterpolationAlgorithm, Core_Intersect, Core_Intersections2D, Core_IntersectionTests, Core_Interval, Core_isArray, Core_isCrossOriginUrl, Core_isLeapYear, Core_Iso8601, Core_joinUrls, Core_JulianDate, Core_KeyboardEventModifier, Core_LagrangePolynomialApproximation, Core_LeapSecond, Core_LinearApproximation, Core_LinearSpline, Core_loadArrayBuffer, Core_loadBlob, Core_loadImage, Core_loadImageFromTypedArray, Core_loadImageViaBlob, Core_loadJson, Core_loadJsonp, Core_loadText, Core_loadWithXhr, Core_loadXML, Core_MapboxApi, Core_MapProjection, Core_Math, Core_Matrix2, Core_Matrix3, Core_Matrix4, Core_mergeSort, Core_NearFarScalar, Core_objectToQuery, Core_Occluder, Core_oneTimeWarning, Core_OrientedBoundingBox, Core_Packable, Core_PackableForInterpolation, Core_parseResponseHeaders, Core_PinBuilder, Core_PixelFormat, Core_Plane, Core_PointGeometry, Core_pointInsideTriangle, Core_PolygonGeometry, Core_PolygonGeometryLibrary, Core_PolygonHierarchy, Core_PolygonOutlineGeometry, Core_PolygonPipeline, Core_PolylineGeometry, Core_PolylinePipeline, Core_PolylineVolumeGeometry, Core_PolylineVolumeGeometryLibrary, Core_PolylineVolumeOutlineGeometry, Core_PrimitiveType, Core_QuadraticRealPolynomial, Core_QuantizedMeshTerrainData, Core_QuarticRealPolynomial, Core_Quaternion, Core_QuaternionSpline, Core_queryToObject, Core_Queue, Core_Ray, Core_Rectangle, Core_RectangleGeometry, Core_RectangleGeometryLibrary, Core_RectangleOutlineGeometry, Core_ReferenceFrame, Core_requestAnimationFrame, Core_RequestErrorEvent, Core_RuntimeError, Core_sampleTerrain, Core_scaleToGeodeticSurface, Core_ScreenSpaceEventHandler, Core_ScreenSpaceEventType, Core_ShowGeometryInstanceAttribute, Core_Simon1994PlanetaryPositions, Core_SimplePolylineGeometry, Core_SphereGeometry, Core_SphereOutlineGeometry, Core_Spherical, Core_Spline, Core_subdivideArray, Core_TaskProcessor, Core_TerrainData, Core_TerrainEncoding, Core_TerrainMesh, Core_TerrainProvider, Core_TerrainQuantization, Core_throttleRequestByServer, Core_TileProviderError, Core_TilingScheme, Core_TimeConstants, Core_TimeInterval, Core_TimeIntervalCollection, Core_TimeStandard, Core_Tipsify, Core_Transforms, Core_TranslationRotationScale, Core_TridiagonalSystemSolver, Core_TrustedServers, Core_VertexFormat, Core_VideoSynchronizer, Core_Visibility, Core_VRTheWorldTerrainProvider, Core_WallGeometry, Core_WallGeometryLibrary, Core_WallOutlineGeometry, Core_WebGLConstants, Core_WebMercatorProjection, Core_WebMercatorTilingScheme, Core_WindingOrder, Core_wrapFunction, Core_writeTextToCanvas, DataSources_BillboardGraphics, DataSources_BillboardVisualizer, DataSources_BoundingSphereState, DataSources_BoxGeometryUpdater, DataSources_BoxGraphics, DataSources_CallbackProperty, DataSources_CheckerboardMaterialProperty, DataSources_ColorMaterialProperty, DataSources_CompositeEntityCollection, DataSources_CompositeMaterialProperty, DataSources_CompositePositionProperty, DataSources_CompositeProperty, DataSources_ConstantPositionProperty, DataSources_ConstantProperty, DataSources_CorridorGeometryUpdater, DataSources_CorridorGraphics, DataSources_createMaterialPropertyDescriptor, DataSources_createPropertyDescriptor, DataSources_createRawPropertyDescriptor, DataSources_CustomDataSource, DataSources_CylinderGeometryUpdater, DataSources_CylinderGraphics, DataSources_CzmlDataSource, DataSources_DataSource, DataSources_DataSourceClock, DataSources_DataSourceCollection, DataSources_DataSourceDisplay, DataSources_dynamicGeometryGetBoundingSphere, DataSources_DynamicGeometryUpdater, DataSources_EllipseGeometryUpdater, DataSources_EllipseGraphics, DataSources_EllipsoidGeometryUpdater, DataSources_EllipsoidGraphics, DataSources_Entity, DataSources_EntityCluster, DataSources_EntityCollection, DataSources_EntityView, DataSources_GeoJsonDataSource, DataSources_GeometryUpdater, DataSources_GeometryVisualizer, DataSources_GridMaterialProperty, DataSources_ImageMaterialProperty, DataSources_KmlDataSource, DataSources_LabelGraphics, DataSources_LabelVisualizer, DataSources_MaterialProperty, DataSources_ModelGraphics, DataSources_ModelVisualizer, DataSources_NodeTransformationProperty, DataSources_PathGraphics, DataSources_PathVisualizer, DataSources_PointGraphics, DataSources_PointVisualizer, DataSources_PolygonGeometryUpdater, DataSources_PolygonGraphics, DataSources_PolylineArrowMaterialProperty, DataSources_PolylineGeometryUpdater, DataSources_PolylineGlowMaterialProperty, DataSources_PolylineGraphics, DataSources_PolylineOutlineMaterialProperty, DataSources_PolylineVolumeGeometryUpdater, DataSources_PolylineVolumeGraphics, DataSources_PositionProperty, DataSources_PositionPropertyArray, DataSources_Property, DataSources_PropertyArray, DataSources_PropertyBag, DataSources_RectangleGeometryUpdater, DataSources_RectangleGraphics, DataSources_ReferenceProperty, DataSources_Rotation, DataSources_SampledPositionProperty, DataSources_SampledProperty, DataSources_ScaledPositionProperty, DataSources_StaticGeometryColorBatch, DataSources_StaticGeometryPerMaterialBatch, DataSources_StaticGroundGeometryColorBatch, DataSources_StaticOutlineGeometryBatch, DataSources_StripeMaterialProperty, DataSources_StripeOrientation, DataSources_TimeIntervalCollectionPositionProperty, DataSources_TimeIntervalCollectionProperty, DataSources_VelocityOrientationProperty, DataSources_VelocityVectorProperty, DataSources_Visualizer, DataSources_WallGeometryUpdater, DataSources_WallGraphics, Renderer_AutomaticUniforms, Renderer_Buffer, Renderer_BufferUsage, Renderer_ClearCommand, Renderer_ComputeCommand, Renderer_ComputeEngine, Renderer_Context, Renderer_ContextLimits, Renderer_createUniform, Renderer_createUniformArray, Renderer_CubeMap, Renderer_CubeMapFace, Renderer_DrawCommand, Renderer_Framebuffer, Renderer_loadCubeMap, Renderer_MipmapHint, Renderer_Pass, Renderer_PassState, Renderer_PickFramebuffer, Renderer_PixelDatatype, Renderer_Renderbuffer, Renderer_RenderbufferFormat, Renderer_RenderState, Renderer_Sampler, Renderer_ShaderCache, Renderer_ShaderProgram, Renderer_ShaderSource, Renderer_Texture, Renderer_TextureMagnificationFilter, Renderer_TextureMinificationFilter, Renderer_TextureWrap, Renderer_UniformState, Renderer_VertexArray, Renderer_VertexArrayFacade, Scene_Appearance, Scene_ArcGisMapServerImageryProvider, Scene_BatchTable, Scene_Billboard, Scene_BillboardCollection, Scene_BingMapsImageryProvider, Scene_BingMapsStyle, Scene_BlendEquation, Scene_BlendFunction, Scene_BlendingState, Scene_Camera, Scene_CameraEventAggregator, Scene_CameraEventType, Scene_CameraFlightPath, Scene_ColorBlendMode, Scene_createOpenStreetMapImageryProvider, Scene_createTangentSpaceDebugPrimitive, Scene_createTileMapServiceImageryProvider, Scene_CreditDisplay, Scene_CullFace, Scene_CullingVolume, Scene_DebugAppearance, Scene_DebugCameraPrimitive, Scene_DebugModelMatrixPrimitive, Scene_DepthFunction, Scene_DepthPlane, Scene_DeviceOrientationCameraController, Scene_DiscardMissingTileImagePolicy, Scene_EllipsoidPrimitive, Scene_EllipsoidSurfaceAppearance, Scene_Fog, Scene_FrameRateMonitor, Scene_FrameState, Scene_FrustumCommands, Scene_FXAA, Scene_getAttributeOrUniformBySemantic, Scene_getBinaryAccessor, Scene_GetFeatureInfoFormat, Scene_Globe, Scene_GlobeDepth, Scene_GlobeSurfaceShaderSet, Scene_GlobeSurfaceTile, Scene_GlobeSurfaceTileProvider, Scene_GoogleEarthImageryProvider, Scene_GridImageryProvider, Scene_GroundPrimitive, Scene_HeightReference, Scene_HorizontalOrigin, Scene_Imagery, Scene_ImageryLayer, Scene_ImageryLayerCollection, Scene_ImageryLayerFeatureInfo, Scene_ImageryProvider, Scene_ImageryState, Scene_Label, Scene_LabelCollection, Scene_LabelStyle, Scene_MapboxImageryProvider, Scene_MapMode2D, Scene_Material, Scene_MaterialAppearance, Scene_Model, Scene_ModelAnimation, Scene_ModelAnimationCache, Scene_ModelAnimationCollection, Scene_ModelAnimationLoop, Scene_ModelAnimationState, Scene_ModelMaterial, Scene_modelMaterialsCommon, Scene_ModelMesh, Scene_ModelNode, Scene_Moon, Scene_NeverTileDiscardPolicy, Scene_OIT, Scene_OrthographicFrustum, Scene_PerformanceDisplay, Scene_PerInstanceColorAppearance, Scene_PerspectiveFrustum, Scene_PerspectiveOffCenterFrustum, Scene_PickDepth, Scene_PointAppearance, Scene_PointPrimitive, Scene_PointPrimitiveCollection, Scene_Polyline, Scene_PolylineCollection, Scene_PolylineColorAppearance, Scene_PolylineMaterialAppearance, Scene_Primitive, Scene_PrimitiveCollection, Scene_PrimitivePipeline, Scene_PrimitiveState, Scene_QuadtreeOccluders, Scene_QuadtreePrimitive, Scene_QuadtreeTile, Scene_QuadtreeTileLoadState, Scene_QuadtreeTileProvider, Scene_Scene, Scene_SceneMode, Scene_SceneTransforms, Scene_SceneTransitioner, Scene_ScreenSpaceCameraController, Scene_ShadowMap, Scene_ShadowMapShader, Scene_ShadowMode, Scene_SingleTileImageryProvider, Scene_SkyAtmosphere, Scene_SkyBox, Scene_StencilFunction, Scene_StencilOperation, Scene_Sun, Scene_SunPostProcess, Scene_TerrainState, Scene_TextureAtlas, Scene_TileBoundingBox, Scene_TileCoordinatesImageryProvider, Scene_TileDiscardPolicy, Scene_TileImagery, Scene_TileReplacementQueue, Scene_TileState, Scene_TileTerrain, Scene_TweenCollection, Scene_UrlTemplateImageryProvider, Scene_VerticalOrigin, Scene_ViewportQuad, Scene_WebMapServiceImageryProvider, Scene_WebMapTileServiceImageryProvider, Shaders_AdjustTranslucentFS, Shaders_Appearances_AllMaterialAppearanceFS, Shaders_Appearances_AllMaterialAppearanceVS, Shaders_Appearances_BasicMaterialAppearanceFS, Shaders_Appearances_BasicMaterialAppearanceVS, Shaders_Appearances_EllipsoidSurfaceAppearanceFS, Shaders_Appearances_EllipsoidSurfaceAppearanceVS, Shaders_Appearances_PerInstanceColorAppearanceFS, Shaders_Appearances_PerInstanceColorAppearanceVS, Shaders_Appearances_PerInstanceFlatColorAppearanceFS, Shaders_Appearances_PerInstanceFlatColorAppearanceVS, Shaders_Appearances_PointAppearanceFS, Shaders_Appearances_PointAppearanceVS, Shaders_Appearances_PolylineColorAppearanceVS, Shaders_Appearances_PolylineMaterialAppearanceVS, Shaders_Appearances_TexturedMaterialAppearanceFS, Shaders_Appearances_TexturedMaterialAppearanceVS, Shaders_BillboardCollectionFS, Shaders_BillboardCollectionVS, Shaders_Builtin_Constants_degreesPerRadian, Shaders_Builtin_Constants_depthRange, Shaders_Builtin_Constants_epsilon1, Shaders_Builtin_Constants_epsilon2, Shaders_Builtin_Constants_epsilon3, Shaders_Builtin_Constants_epsilon4, Shaders_Builtin_Constants_epsilon5, Shaders_Builtin_Constants_epsilon6, Shaders_Builtin_Constants_epsilon7, Shaders_Builtin_Constants_infinity, Shaders_Builtin_Constants_oneOverPi, Shaders_Builtin_Constants_oneOverTwoPi, Shaders_Builtin_Constants_passCompute, Shaders_Builtin_Constants_passEnvironment, Shaders_Builtin_Constants_passGlobe, Shaders_Builtin_Constants_passGround, Shaders_Builtin_Constants_passOpaque, Shaders_Builtin_Constants_passOverlay, Shaders_Builtin_Constants_passTranslucent, Shaders_Builtin_Constants_pi, Shaders_Builtin_Constants_piOverFour, Shaders_Builtin_Constants_piOverSix, Shaders_Builtin_Constants_piOverThree, Shaders_Builtin_Constants_piOverTwo, Shaders_Builtin_Constants_radiansPerDegree, Shaders_Builtin_Constants_sceneMode2D, Shaders_Builtin_Constants_sceneMode3D, Shaders_Builtin_Constants_sceneModeColumbusView, Shaders_Builtin_Constants_sceneModeMorphing, Shaders_Builtin_Constants_solarRadius, Shaders_Builtin_Constants_threePiOver2, Shaders_Builtin_Constants_twoPi, Shaders_Builtin_Constants_webMercatorMaxLatitude, Shaders_Builtin_CzmBuiltins, Shaders_Builtin_Functions_alphaWeight, Shaders_Builtin_Functions_antialias, Shaders_Builtin_Functions_cascadeColor, Shaders_Builtin_Functions_cascadeDistance, Shaders_Builtin_Functions_cascadeMatrix, Shaders_Builtin_Functions_cascadeWeights, Shaders_Builtin_Functions_columbusViewMorph, Shaders_Builtin_Functions_computePosition, Shaders_Builtin_Functions_cosineAndSine, Shaders_Builtin_Functions_decompressTextureCoordinates, Shaders_Builtin_Functions_eastNorthUpToEyeCoordinates, Shaders_Builtin_Functions_ellipsoidContainsPoint, Shaders_Builtin_Functions_ellipsoidNew, Shaders_Builtin_Functions_ellipsoidWgs84TextureCoordinates, Shaders_Builtin_Functions_equalsEpsilon, Shaders_Builtin_Functions_eyeOffset, Shaders_Builtin_Functions_eyeToWindowCoordinates, Shaders_Builtin_Functions_fog, Shaders_Builtin_Functions_geodeticSurfaceNormal, Shaders_Builtin_Functions_getDefaultMaterial, Shaders_Builtin_Functions_getLambertDiffuse, Shaders_Builtin_Functions_getSpecular, Shaders_Builtin_Functions_getWaterNoise, Shaders_Builtin_Functions_getWgs84EllipsoidEC, Shaders_Builtin_Functions_hue, Shaders_Builtin_Functions_isEmpty, Shaders_Builtin_Functions_isFull, Shaders_Builtin_Functions_latitudeToWebMercatorFraction, Shaders_Builtin_Functions_luminance, Shaders_Builtin_Functions_metersPerPixel, Shaders_Builtin_Functions_modelToWindowCoordinates, Shaders_Builtin_Functions_multiplyWithColorBalance, Shaders_Builtin_Functions_nearFarScalar, Shaders_Builtin_Functions_octDecode, Shaders_Builtin_Functions_packDepth, Shaders_Builtin_Functions_phong, Shaders_Builtin_Functions_pointAlongRay, Shaders_Builtin_Functions_rayEllipsoidIntersectionInterval, Shaders_Builtin_Functions_RGBToXYZ, Shaders_Builtin_Functions_saturation, Shaders_Builtin_Functions_shadowDepthCompare, Shaders_Builtin_Functions_shadowVisibility, Shaders_Builtin_Functions_signNotZero, Shaders_Builtin_Functions_tangentToEyeSpaceMatrix, Shaders_Builtin_Functions_translateRelativeToEye, Shaders_Builtin_Functions_translucentPhong, Shaders_Builtin_Functions_transpose, Shaders_Builtin_Functions_unpackDepth, Shaders_Builtin_Functions_windowToEyeCoordinates, Shaders_Builtin_Functions_XYZToRGB, Shaders_Builtin_Structs_depthRangeStruct, Shaders_Builtin_Structs_ellipsoid, Shaders_Builtin_Structs_material, Shaders_Builtin_Structs_materialInput, Shaders_Builtin_Structs_ray, Shaders_Builtin_Structs_raySegment, Shaders_Builtin_Structs_shadowParameters, Shaders_CompositeOITFS, Shaders_DepthPlaneFS, Shaders_DepthPlaneVS, Shaders_EllipsoidFS, Shaders_EllipsoidVS, Shaders_GlobeFS, Shaders_GlobeVS, Shaders_GroundAtmosphere, Shaders_Materials_BumpMapMaterial, Shaders_Materials_CheckerboardMaterial, Shaders_Materials_DotMaterial, Shaders_Materials_FadeMaterial, Shaders_Materials_GridMaterial, Shaders_Materials_NormalMapMaterial, Shaders_Materials_PolylineArrowMaterial, Shaders_Materials_PolylineGlowMaterial, Shaders_Materials_PolylineOutlineMaterial, Shaders_Materials_RimLightingMaterial, Shaders_Materials_StripeMaterial, Shaders_Materials_Water, Shaders_PointPrimitiveCollectionFS, Shaders_PointPrimitiveCollectionVS, Shaders_PolylineCommon, Shaders_PolylineFS, Shaders_PolylineVS, Shaders_PostProcessFilters_AdditiveBlend, Shaders_PostProcessFilters_BrightPass, Shaders_PostProcessFilters_FXAA, Shaders_PostProcessFilters_GaussianBlur1D, Shaders_PostProcessFilters_PassThrough, Shaders_ReprojectWebMercatorFS, Shaders_ReprojectWebMercatorVS, Shaders_ShadowVolumeFS, Shaders_ShadowVolumeVS, Shaders_SkyAtmosphereFS, Shaders_SkyAtmosphereVS, Shaders_SkyBoxFS, Shaders_SkyBoxVS, Shaders_SunFS, Shaders_SunTextureFS, Shaders_SunVS, Shaders_ViewportQuadFS, Shaders_ViewportQuadVS, ThirdParty_Autolinker, ThirdParty_earcut_2_1_1, ThirdParty_gltfDefaults, ThirdParty_kdbush, ThirdParty_knockout_3_4_0, ThirdParty_knockout_es5, ThirdParty_knockout, ThirdParty_measureText, ThirdParty_mersenne_twister, ThirdParty_NoSleep, ThirdParty_sprintf, ThirdParty_topojson, ThirdParty_Tween, ThirdParty_Uri, ThirdParty_when, ThirdParty_zip, Widgets_Animation_Animation, Widgets_Animation_AnimationViewModel, Widgets_BaseLayerPicker_BaseLayerPicker, Widgets_BaseLayerPicker_BaseLayerPickerViewModel, Widgets_BaseLayerPicker_createDefaultImageryProviderViewModels, Widgets_BaseLayerPicker_createDefaultTerrainProviderViewModels, Widgets_BaseLayerPicker_ProviderViewModel, Widgets_CesiumInspector_CesiumInspector, Widgets_CesiumInspector_CesiumInspectorViewModel, Widgets_CesiumWidget_CesiumWidget, Widgets_ClockViewModel, Widgets_Command, Widgets_createCommand, Widgets_FullscreenButton_FullscreenButton, Widgets_FullscreenButton_FullscreenButtonViewModel, Widgets_Geocoder_Geocoder, Widgets_Geocoder_GeocoderViewModel, Widgets_getElement, Widgets_HomeButton_HomeButton, Widgets_HomeButton_HomeButtonViewModel, Widgets_InfoBox_InfoBox, Widgets_InfoBox_InfoBoxViewModel, Widgets_NavigationHelpButton_NavigationHelpButton, Widgets_NavigationHelpButton_NavigationHelpButtonViewModel, Widgets_PerformanceWatchdog_PerformanceWatchdog, Widgets_PerformanceWatchdog_PerformanceWatchdogViewModel, Widgets_SceneModePicker_SceneModePicker, Widgets_SceneModePicker_SceneModePickerViewModel, Widgets_SelectionIndicator_SelectionIndicator, Widgets_SelectionIndicator_SelectionIndicatorViewModel, Widgets_subscribeAndEvaluate, Widgets_SvgPathBindingHandler, Widgets_Timeline_Timeline, Widgets_Timeline_TimelineHighlightRange, Widgets_Timeline_TimelineTrack, Widgets_ToggleButtonViewModel, Widgets_Viewer_Viewer, Widgets_Viewer_viewerCesiumInspectorMixin, Widgets_Viewer_viewerDragDropMixin, Widgets_Viewer_viewerPerformanceWatchdogMixin, Widgets_VRButton_VRButton, Widgets_VRButton_VRButtonViewModel, Workers_createTaskProcessorWorker) {
'use strict';
/*jshint sub:true*/
var Cesium = {
VERSION : "1.29",
_shaders : {}
};
Cesium['appendForwardSlash'] = Core_appendForwardSlash;
Cesium['ArcGisImageServerTerrainProvider'] = Core_ArcGisImageServerTerrainProvider;
Cesium['arrayRemoveDuplicates'] = Core_arrayRemoveDuplicates;
Cesium['AssociativeArray'] = Core_AssociativeArray;
Cesium['AttributeCompression'] = Core_AttributeCompression;
Cesium['AxisAlignedBoundingBox'] = Core_AxisAlignedBoundingBox;
Cesium['barycentricCoordinates'] = Core_barycentricCoordinates;
Cesium['binarySearch'] = Core_binarySearch;
Cesium['BingMapsApi'] = Core_BingMapsApi;
Cesium['BoundingRectangle'] = Core_BoundingRectangle;
Cesium['BoundingSphere'] = Core_BoundingSphere;
Cesium['BoxGeometry'] = Core_BoxGeometry;
Cesium['BoxOutlineGeometry'] = Core_BoxOutlineGeometry;
Cesium['buildModuleUrl'] = Core_buildModuleUrl;
Cesium['cancelAnimationFrame'] = Core_cancelAnimationFrame;
Cesium['Cartesian2'] = Core_Cartesian2;
Cesium['Cartesian3'] = Core_Cartesian3;
Cesium['Cartesian4'] = Core_Cartesian4;
Cesium['Cartographic'] = Core_Cartographic;
Cesium['CatmullRomSpline'] = Core_CatmullRomSpline;
Cesium['CesiumTerrainProvider'] = Core_CesiumTerrainProvider;
Cesium['Check'] = Core_Check;
Cesium['CircleGeometry'] = Core_CircleGeometry;
Cesium['CircleOutlineGeometry'] = Core_CircleOutlineGeometry;
Cesium['Clock'] = Core_Clock;
Cesium['ClockRange'] = Core_ClockRange;
Cesium['ClockStep'] = Core_ClockStep;
Cesium['clone'] = Core_clone;
Cesium['Color'] = Core_Color;
Cesium['ColorGeometryInstanceAttribute'] = Core_ColorGeometryInstanceAttribute;
Cesium['combine'] = Core_combine;
Cesium['ComponentDatatype'] = Core_ComponentDatatype;
Cesium['CornerType'] = Core_CornerType;
Cesium['CorridorGeometry'] = Core_CorridorGeometry;
Cesium['CorridorGeometryLibrary'] = Core_CorridorGeometryLibrary;
Cesium['CorridorOutlineGeometry'] = Core_CorridorOutlineGeometry;
Cesium['createGuid'] = Core_createGuid;
Cesium['Credit'] = Core_Credit;
Cesium['CubicRealPolynomial'] = Core_CubicRealPolynomial;
Cesium['CylinderGeometry'] = Core_CylinderGeometry;
Cesium['CylinderGeometryLibrary'] = Core_CylinderGeometryLibrary;
Cesium['CylinderOutlineGeometry'] = Core_CylinderOutlineGeometry;
Cesium['DefaultProxy'] = Core_DefaultProxy;
Cesium['defaultValue'] = Core_defaultValue;
Cesium['defined'] = Core_defined;
Cesium['defineProperties'] = Core_defineProperties;
Cesium['deprecationWarning'] = Core_deprecationWarning;
Cesium['destroyObject'] = Core_destroyObject;
Cesium['DeveloperError'] = Core_DeveloperError;
Cesium['DistanceDisplayCondition'] = Core_DistanceDisplayCondition;
Cesium['DistanceDisplayConditionGeometryInstanceAttribute'] = Core_DistanceDisplayConditionGeometryInstanceAttribute;
Cesium['EarthOrientationParameters'] = Core_EarthOrientationParameters;
Cesium['EarthOrientationParametersSample'] = Core_EarthOrientationParametersSample;
Cesium['EasingFunction'] = Core_EasingFunction;
Cesium['EllipseGeometry'] = Core_EllipseGeometry;
Cesium['EllipseGeometryLibrary'] = Core_EllipseGeometryLibrary;
Cesium['EllipseOutlineGeometry'] = Core_EllipseOutlineGeometry;
Cesium['Ellipsoid'] = Core_Ellipsoid;
Cesium['EllipsoidalOccluder'] = Core_EllipsoidalOccluder;
Cesium['EllipsoidGeodesic'] = Core_EllipsoidGeodesic;
Cesium['EllipsoidGeometry'] = Core_EllipsoidGeometry;
Cesium['EllipsoidOutlineGeometry'] = Core_EllipsoidOutlineGeometry;
Cesium['EllipsoidTangentPlane'] = Core_EllipsoidTangentPlane;
Cesium['EllipsoidTerrainProvider'] = Core_EllipsoidTerrainProvider;
Cesium['EncodedCartesian3'] = Core_EncodedCartesian3;
Cesium['Event'] = Core_Event;
Cesium['EventHelper'] = Core_EventHelper;
Cesium['ExtrapolationType'] = Core_ExtrapolationType;
Cesium['FeatureDetection'] = Core_FeatureDetection;
Cesium['formatError'] = Core_formatError;
Cesium['freezeObject'] = Core_freezeObject;
Cesium['Fullscreen'] = Core_Fullscreen;
Cesium['GeographicProjection'] = Core_GeographicProjection;
Cesium['GeographicTilingScheme'] = Core_GeographicTilingScheme;
Cesium['Geometry'] = Core_Geometry;
Cesium['GeometryAttribute'] = Core_GeometryAttribute;
Cesium['GeometryAttributes'] = Core_GeometryAttributes;
Cesium['GeometryInstance'] = Core_GeometryInstance;
Cesium['GeometryInstanceAttribute'] = Core_GeometryInstanceAttribute;
Cesium['GeometryPipeline'] = Core_GeometryPipeline;
Cesium['GeometryType'] = Core_GeometryType;
Cesium['getAbsoluteUri'] = Core_getAbsoluteUri;
Cesium['getBaseUri'] = Core_getBaseUri;
Cesium['getExtensionFromUri'] = Core_getExtensionFromUri;
Cesium['getFilenameFromUri'] = Core_getFilenameFromUri;
Cesium['getImagePixels'] = Core_getImagePixels;
Cesium['getMagic'] = Core_getMagic;
Cesium['getStringFromTypedArray'] = Core_getStringFromTypedArray;
Cesium['getTimestamp'] = Core_getTimestamp;
Cesium['GregorianDate'] = Core_GregorianDate;
Cesium['HeadingPitchRange'] = Core_HeadingPitchRange;
Cesium['HeadingPitchRoll'] = Core_HeadingPitchRoll;
Cesium['HeightmapTerrainData'] = Core_HeightmapTerrainData;
Cesium['HeightmapTessellator'] = Core_HeightmapTessellator;
Cesium['HermitePolynomialApproximation'] = Core_HermitePolynomialApproximation;
Cesium['HermiteSpline'] = Core_HermiteSpline;
Cesium['Iau2000Orientation'] = Core_Iau2000Orientation;
Cesium['Iau2006XysData'] = Core_Iau2006XysData;
Cesium['Iau2006XysSample'] = Core_Iau2006XysSample;
Cesium['IauOrientationAxes'] = Core_IauOrientationAxes;
Cesium['IauOrientationParameters'] = Core_IauOrientationParameters;
Cesium['IndexDatatype'] = Core_IndexDatatype;
Cesium['InterpolationAlgorithm'] = Core_InterpolationAlgorithm;
Cesium['Intersect'] = Core_Intersect;
Cesium['Intersections2D'] = Core_Intersections2D;
Cesium['IntersectionTests'] = Core_IntersectionTests;
Cesium['Interval'] = Core_Interval;
Cesium['isArray'] = Core_isArray;
Cesium['isCrossOriginUrl'] = Core_isCrossOriginUrl;
Cesium['isLeapYear'] = Core_isLeapYear;
Cesium['Iso8601'] = Core_Iso8601;
Cesium['joinUrls'] = Core_joinUrls;
Cesium['JulianDate'] = Core_JulianDate;
Cesium['KeyboardEventModifier'] = Core_KeyboardEventModifier;
Cesium['LagrangePolynomialApproximation'] = Core_LagrangePolynomialApproximation;
Cesium['LeapSecond'] = Core_LeapSecond;
Cesium['LinearApproximation'] = Core_LinearApproximation;
Cesium['LinearSpline'] = Core_LinearSpline;
Cesium['loadArrayBuffer'] = Core_loadArrayBuffer;
Cesium['loadBlob'] = Core_loadBlob;
Cesium['loadImage'] = Core_loadImage;
Cesium['loadImageFromTypedArray'] = Core_loadImageFromTypedArray;
Cesium['loadImageViaBlob'] = Core_loadImageViaBlob;
Cesium['loadJson'] = Core_loadJson;
Cesium['loadJsonp'] = Core_loadJsonp;
Cesium['loadText'] = Core_loadText;
Cesium['loadWithXhr'] = Core_loadWithXhr;
Cesium['loadXML'] = Core_loadXML;
Cesium['MapboxApi'] = Core_MapboxApi;
Cesium['MapProjection'] = Core_MapProjection;
Cesium['Math'] = Core_Math;
Cesium['Matrix2'] = Core_Matrix2;
Cesium['Matrix3'] = Core_Matrix3;
Cesium['Matrix4'] = Core_Matrix4;
Cesium['mergeSort'] = Core_mergeSort;
Cesium['NearFarScalar'] = Core_NearFarScalar;
Cesium['objectToQuery'] = Core_objectToQuery;
Cesium['Occluder'] = Core_Occluder;
Cesium['oneTimeWarning'] = Core_oneTimeWarning;
Cesium['OrientedBoundingBox'] = Core_OrientedBoundingBox;
Cesium['Packable'] = Core_Packable;
Cesium['PackableForInterpolation'] = Core_PackableForInterpolation;
Cesium['parseResponseHeaders'] = Core_parseResponseHeaders;
Cesium['PinBuilder'] = Core_PinBuilder;
Cesium['PixelFormat'] = Core_PixelFormat;
Cesium['Plane'] = Core_Plane;
Cesium['PointGeometry'] = Core_PointGeometry;
Cesium['pointInsideTriangle'] = Core_pointInsideTriangle;
Cesium['PolygonGeometry'] = Core_PolygonGeometry;
Cesium['PolygonGeometryLibrary'] = Core_PolygonGeometryLibrary;
Cesium['PolygonHierarchy'] = Core_PolygonHierarchy;
Cesium['PolygonOutlineGeometry'] = Core_PolygonOutlineGeometry;
Cesium['PolygonPipeline'] = Core_PolygonPipeline;
Cesium['PolylineGeometry'] = Core_PolylineGeometry;
Cesium['PolylinePipeline'] = Core_PolylinePipeline;
Cesium['PolylineVolumeGeometry'] = Core_PolylineVolumeGeometry;
Cesium['PolylineVolumeGeometryLibrary'] = Core_PolylineVolumeGeometryLibrary;
Cesium['PolylineVolumeOutlineGeometry'] = Core_PolylineVolumeOutlineGeometry;
Cesium['PrimitiveType'] = Core_PrimitiveType;
Cesium['QuadraticRealPolynomial'] = Core_QuadraticRealPolynomial;
Cesium['QuantizedMeshTerrainData'] = Core_QuantizedMeshTerrainData;
Cesium['QuarticRealPolynomial'] = Core_QuarticRealPolynomial;
Cesium['Quaternion'] = Core_Quaternion;
Cesium['QuaternionSpline'] = Core_QuaternionSpline;
Cesium['queryToObject'] = Core_queryToObject;
Cesium['Queue'] = Core_Queue;
Cesium['Ray'] = Core_Ray;
Cesium['Rectangle'] = Core_Rectangle;
Cesium['RectangleGeometry'] = Core_RectangleGeometry;
Cesium['RectangleGeometryLibrary'] = Core_RectangleGeometryLibrary;
Cesium['RectangleOutlineGeometry'] = Core_RectangleOutlineGeometry;
Cesium['ReferenceFrame'] = Core_ReferenceFrame;
Cesium['requestAnimationFrame'] = Core_requestAnimationFrame;
Cesium['RequestErrorEvent'] = Core_RequestErrorEvent;
Cesium['RuntimeError'] = Core_RuntimeError;
Cesium['sampleTerrain'] = Core_sampleTerrain;
Cesium['scaleToGeodeticSurface'] = Core_scaleToGeodeticSurface;
Cesium['ScreenSpaceEventHandler'] = Core_ScreenSpaceEventHandler;
Cesium['ScreenSpaceEventType'] = Core_ScreenSpaceEventType;
Cesium['ShowGeometryInstanceAttribute'] = Core_ShowGeometryInstanceAttribute;
Cesium['Simon1994PlanetaryPositions'] = Core_Simon1994PlanetaryPositions;
Cesium['SimplePolylineGeometry'] = Core_SimplePolylineGeometry;
Cesium['SphereGeometry'] = Core_SphereGeometry;
Cesium['SphereOutlineGeometry'] = Core_SphereOutlineGeometry;
Cesium['Spherical'] = Core_Spherical;
Cesium['Spline'] = Core_Spline;
Cesium['subdivideArray'] = Core_subdivideArray;
Cesium['TaskProcessor'] = Core_TaskProcessor;
Cesium['TerrainData'] = Core_TerrainData;
Cesium['TerrainEncoding'] = Core_TerrainEncoding;
Cesium['TerrainMesh'] = Core_TerrainMesh;
Cesium['TerrainProvider'] = Core_TerrainProvider;
Cesium['TerrainQuantization'] = Core_TerrainQuantization;
Cesium['throttleRequestByServer'] = Core_throttleRequestByServer;
Cesium['TileProviderError'] = Core_TileProviderError;
Cesium['TilingScheme'] = Core_TilingScheme;
Cesium['TimeConstants'] = Core_TimeConstants;
Cesium['TimeInterval'] = Core_TimeInterval;
Cesium['TimeIntervalCollection'] = Core_TimeIntervalCollection;
Cesium['TimeStandard'] = Core_TimeStandard;
Cesium['Tipsify'] = Core_Tipsify;
Cesium['Transforms'] = Core_Transforms;
Cesium['TranslationRotationScale'] = Core_TranslationRotationScale;
Cesium['TridiagonalSystemSolver'] = Core_TridiagonalSystemSolver;
Cesium['TrustedServers'] = Core_TrustedServers;
Cesium['VertexFormat'] = Core_VertexFormat;
Cesium['VideoSynchronizer'] = Core_VideoSynchronizer;
Cesium['Visibility'] = Core_Visibility;
Cesium['VRTheWorldTerrainProvider'] = Core_VRTheWorldTerrainProvider;
Cesium['WallGeometry'] = Core_WallGeometry;
Cesium['WallGeometryLibrary'] = Core_WallGeometryLibrary;
Cesium['WallOutlineGeometry'] = Core_WallOutlineGeometry;
Cesium['WebGLConstants'] = Core_WebGLConstants;
Cesium['WebMercatorProjection'] = Core_WebMercatorProjection;
Cesium['WebMercatorTilingScheme'] = Core_WebMercatorTilingScheme;
Cesium['WindingOrder'] = Core_WindingOrder;
Cesium['wrapFunction'] = Core_wrapFunction;
Cesium['writeTextToCanvas'] = Core_writeTextToCanvas;
Cesium['BillboardGraphics'] = DataSources_BillboardGraphics;
Cesium['BillboardVisualizer'] = DataSources_BillboardVisualizer;
Cesium['BoundingSphereState'] = DataSources_BoundingSphereState;
Cesium['BoxGeometryUpdater'] = DataSources_BoxGeometryUpdater;
Cesium['BoxGraphics'] = DataSources_BoxGraphics;
Cesium['CallbackProperty'] = DataSources_CallbackProperty;
Cesium['CheckerboardMaterialProperty'] = DataSources_CheckerboardMaterialProperty;
Cesium['ColorMaterialProperty'] = DataSources_ColorMaterialProperty;
Cesium['CompositeEntityCollection'] = DataSources_CompositeEntityCollection;
Cesium['CompositeMaterialProperty'] = DataSources_CompositeMaterialProperty;
Cesium['CompositePositionProperty'] = DataSources_CompositePositionProperty;
Cesium['CompositeProperty'] = DataSources_CompositeProperty;
Cesium['ConstantPositionProperty'] = DataSources_ConstantPositionProperty;
Cesium['ConstantProperty'] = DataSources_ConstantProperty;
Cesium['CorridorGeometryUpdater'] = DataSources_CorridorGeometryUpdater;
Cesium['CorridorGraphics'] = DataSources_CorridorGraphics;
Cesium['createMaterialPropertyDescriptor'] = DataSources_createMaterialPropertyDescriptor;
Cesium['createPropertyDescriptor'] = DataSources_createPropertyDescriptor;
Cesium['createRawPropertyDescriptor'] = DataSources_createRawPropertyDescriptor;
Cesium['CustomDataSource'] = DataSources_CustomDataSource;
Cesium['CylinderGeometryUpdater'] = DataSources_CylinderGeometryUpdater;
Cesium['CylinderGraphics'] = DataSources_CylinderGraphics;
Cesium['CzmlDataSource'] = DataSources_CzmlDataSource;
Cesium['DataSource'] = DataSources_DataSource;
Cesium['DataSourceClock'] = DataSources_DataSourceClock;
Cesium['DataSourceCollection'] = DataSources_DataSourceCollection;
Cesium['DataSourceDisplay'] = DataSources_DataSourceDisplay;
Cesium['dynamicGeometryGetBoundingSphere'] = DataSources_dynamicGeometryGetBoundingSphere;
Cesium['DynamicGeometryUpdater'] = DataSources_DynamicGeometryUpdater;
Cesium['EllipseGeometryUpdater'] = DataSources_EllipseGeometryUpdater;
Cesium['EllipseGraphics'] = DataSources_EllipseGraphics;
Cesium['EllipsoidGeometryUpdater'] = DataSources_EllipsoidGeometryUpdater;
Cesium['EllipsoidGraphics'] = DataSources_EllipsoidGraphics;
Cesium['Entity'] = DataSources_Entity;
Cesium['EntityCluster'] = DataSources_EntityCluster;
Cesium['EntityCollection'] = DataSources_EntityCollection;
Cesium['EntityView'] = DataSources_EntityView;
Cesium['GeoJsonDataSource'] = DataSources_GeoJsonDataSource;
Cesium['GeometryUpdater'] = DataSources_GeometryUpdater;
Cesium['GeometryVisualizer'] = DataSources_GeometryVisualizer;
Cesium['GridMaterialProperty'] = DataSources_GridMaterialProperty;
Cesium['ImageMaterialProperty'] = DataSources_ImageMaterialProperty;
Cesium['KmlDataSource'] = DataSources_KmlDataSource;
Cesium['LabelGraphics'] = DataSources_LabelGraphics;
Cesium['LabelVisualizer'] = DataSources_LabelVisualizer;
Cesium['MaterialProperty'] = DataSources_MaterialProperty;
Cesium['ModelGraphics'] = DataSources_ModelGraphics;
Cesium['ModelVisualizer'] = DataSources_ModelVisualizer;
Cesium['NodeTransformationProperty'] = DataSources_NodeTransformationProperty;
Cesium['PathGraphics'] = DataSources_PathGraphics;
Cesium['PathVisualizer'] = DataSources_PathVisualizer;
Cesium['PointGraphics'] = DataSources_PointGraphics;
Cesium['PointVisualizer'] = DataSources_PointVisualizer;
Cesium['PolygonGeometryUpdater'] = DataSources_PolygonGeometryUpdater;
Cesium['PolygonGraphics'] = DataSources_PolygonGraphics;
Cesium['PolylineArrowMaterialProperty'] = DataSources_PolylineArrowMaterialProperty;
Cesium['PolylineGeometryUpdater'] = DataSources_PolylineGeometryUpdater;
Cesium['PolylineGlowMaterialProperty'] = DataSources_PolylineGlowMaterialProperty;
Cesium['PolylineGraphics'] = DataSources_PolylineGraphics;
Cesium['PolylineOutlineMaterialProperty'] = DataSources_PolylineOutlineMaterialProperty;
Cesium['PolylineVolumeGeometryUpdater'] = DataSources_PolylineVolumeGeometryUpdater;
Cesium['PolylineVolumeGraphics'] = DataSources_PolylineVolumeGraphics;
Cesium['PositionProperty'] = DataSources_PositionProperty;
Cesium['PositionPropertyArray'] = DataSources_PositionPropertyArray;
Cesium['Property'] = DataSources_Property;
Cesium['PropertyArray'] = DataSources_PropertyArray;
Cesium['PropertyBag'] = DataSources_PropertyBag;
Cesium['RectangleGeometryUpdater'] = DataSources_RectangleGeometryUpdater;
Cesium['RectangleGraphics'] = DataSources_RectangleGraphics;
Cesium['ReferenceProperty'] = DataSources_ReferenceProperty;
Cesium['Rotation'] = DataSources_Rotation;
Cesium['SampledPositionProperty'] = DataSources_SampledPositionProperty;
Cesium['SampledProperty'] = DataSources_SampledProperty;
Cesium['ScaledPositionProperty'] = DataSources_ScaledPositionProperty;
Cesium['StaticGeometryColorBatch'] = DataSources_StaticGeometryColorBatch;
Cesium['StaticGeometryPerMaterialBatch'] = DataSources_StaticGeometryPerMaterialBatch;
Cesium['StaticGroundGeometryColorBatch'] = DataSources_StaticGroundGeometryColorBatch;
Cesium['StaticOutlineGeometryBatch'] = DataSources_StaticOutlineGeometryBatch;
Cesium['StripeMaterialProperty'] = DataSources_StripeMaterialProperty;
Cesium['StripeOrientation'] = DataSources_StripeOrientation;
Cesium['TimeIntervalCollectionPositionProperty'] = DataSources_TimeIntervalCollectionPositionProperty;
Cesium['TimeIntervalCollectionProperty'] = DataSources_TimeIntervalCollectionProperty;
Cesium['VelocityOrientationProperty'] = DataSources_VelocityOrientationProperty;
Cesium['VelocityVectorProperty'] = DataSources_VelocityVectorProperty;
Cesium['Visualizer'] = DataSources_Visualizer;
Cesium['WallGeometryUpdater'] = DataSources_WallGeometryUpdater;
Cesium['WallGraphics'] = DataSources_WallGraphics;
Cesium['AutomaticUniforms'] = Renderer_AutomaticUniforms;
Cesium['Buffer'] = Renderer_Buffer;
Cesium['BufferUsage'] = Renderer_BufferUsage;
Cesium['ClearCommand'] = Renderer_ClearCommand;
Cesium['ComputeCommand'] = Renderer_ComputeCommand;
Cesium['ComputeEngine'] = Renderer_ComputeEngine;
Cesium['Context'] = Renderer_Context;
Cesium['ContextLimits'] = Renderer_ContextLimits;
Cesium['createUniform'] = Renderer_createUniform;
Cesium['createUniformArray'] = Renderer_createUniformArray;
Cesium['CubeMap'] = Renderer_CubeMap;
Cesium['CubeMapFace'] = Renderer_CubeMapFace;
Cesium['DrawCommand'] = Renderer_DrawCommand;
Cesium['Framebuffer'] = Renderer_Framebuffer;
Cesium['loadCubeMap'] = Renderer_loadCubeMap;
Cesium['MipmapHint'] = Renderer_MipmapHint;
Cesium['Pass'] = Renderer_Pass;
Cesium['PassState'] = Renderer_PassState;
Cesium['PickFramebuffer'] = Renderer_PickFramebuffer;
Cesium['PixelDatatype'] = Renderer_PixelDatatype;
Cesium['Renderbuffer'] = Renderer_Renderbuffer;
Cesium['RenderbufferFormat'] = Renderer_RenderbufferFormat;
Cesium['RenderState'] = Renderer_RenderState;
Cesium['Sampler'] = Renderer_Sampler;
Cesium['ShaderCache'] = Renderer_ShaderCache;
Cesium['ShaderProgram'] = Renderer_ShaderProgram;
Cesium['ShaderSource'] = Renderer_ShaderSource;
Cesium['Texture'] = Renderer_Texture;
Cesium['TextureMagnificationFilter'] = Renderer_TextureMagnificationFilter;
Cesium['TextureMinificationFilter'] = Renderer_TextureMinificationFilter;
Cesium['TextureWrap'] = Renderer_TextureWrap;
Cesium['UniformState'] = Renderer_UniformState;
Cesium['VertexArray'] = Renderer_VertexArray;
Cesium['VertexArrayFacade'] = Renderer_VertexArrayFacade;
Cesium['Appearance'] = Scene_Appearance;
Cesium['ArcGisMapServerImageryProvider'] = Scene_ArcGisMapServerImageryProvider;
Cesium['BatchTable'] = Scene_BatchTable;
Cesium['Billboard'] = Scene_Billboard;
Cesium['BillboardCollection'] = Scene_BillboardCollection;
Cesium['BingMapsImageryProvider'] = Scene_BingMapsImageryProvider;
Cesium['BingMapsStyle'] = Scene_BingMapsStyle;
Cesium['BlendEquation'] = Scene_BlendEquation;
Cesium['BlendFunction'] = Scene_BlendFunction;
Cesium['BlendingState'] = Scene_BlendingState;
Cesium['Camera'] = Scene_Camera;
Cesium['CameraEventAggregator'] = Scene_CameraEventAggregator;
Cesium['CameraEventType'] = Scene_CameraEventType;
Cesium['CameraFlightPath'] = Scene_CameraFlightPath;
Cesium['ColorBlendMode'] = Scene_ColorBlendMode;
Cesium['createOpenStreetMapImageryProvider'] = Scene_createOpenStreetMapImageryProvider;
Cesium['createTangentSpaceDebugPrimitive'] = Scene_createTangentSpaceDebugPrimitive;
Cesium['createTileMapServiceImageryProvider'] = Scene_createTileMapServiceImageryProvider;
Cesium['CreditDisplay'] = Scene_CreditDisplay;
Cesium['CullFace'] = Scene_CullFace;
Cesium['CullingVolume'] = Scene_CullingVolume;
Cesium['DebugAppearance'] = Scene_DebugAppearance;
Cesium['DebugCameraPrimitive'] = Scene_DebugCameraPrimitive;
Cesium['DebugModelMatrixPrimitive'] = Scene_DebugModelMatrixPrimitive;
Cesium['DepthFunction'] = Scene_DepthFunction;
Cesium['DepthPlane'] = Scene_DepthPlane;
Cesium['DeviceOrientationCameraController'] = Scene_DeviceOrientationCameraController;
Cesium['DiscardMissingTileImagePolicy'] = Scene_DiscardMissingTileImagePolicy;
Cesium['EllipsoidPrimitive'] = Scene_EllipsoidPrimitive;
Cesium['EllipsoidSurfaceAppearance'] = Scene_EllipsoidSurfaceAppearance;
Cesium['Fog'] = Scene_Fog;
Cesium['FrameRateMonitor'] = Scene_FrameRateMonitor;
Cesium['FrameState'] = Scene_FrameState;
Cesium['FrustumCommands'] = Scene_FrustumCommands;
Cesium['FXAA'] = Scene_FXAA;
Cesium['getAttributeOrUniformBySemantic'] = Scene_getAttributeOrUniformBySemantic;
Cesium['getBinaryAccessor'] = Scene_getBinaryAccessor;
Cesium['GetFeatureInfoFormat'] = Scene_GetFeatureInfoFormat;
Cesium['Globe'] = Scene_Globe;
Cesium['GlobeDepth'] = Scene_GlobeDepth;
Cesium['GlobeSurfaceShaderSet'] = Scene_GlobeSurfaceShaderSet;
Cesium['GlobeSurfaceTile'] = Scene_GlobeSurfaceTile;
Cesium['GlobeSurfaceTileProvider'] = Scene_GlobeSurfaceTileProvider;
Cesium['GoogleEarthImageryProvider'] = Scene_GoogleEarthImageryProvider;
Cesium['GridImageryProvider'] = Scene_GridImageryProvider;
Cesium['GroundPrimitive'] = Scene_GroundPrimitive;
Cesium['HeightReference'] = Scene_HeightReference;
Cesium['HorizontalOrigin'] = Scene_HorizontalOrigin;
Cesium['Imagery'] = Scene_Imagery;
Cesium['ImageryLayer'] = Scene_ImageryLayer;
Cesium['ImageryLayerCollection'] = Scene_ImageryLayerCollection;
Cesium['ImageryLayerFeatureInfo'] = Scene_ImageryLayerFeatureInfo;
Cesium['ImageryProvider'] = Scene_ImageryProvider;
Cesium['ImageryState'] = Scene_ImageryState;
Cesium['Label'] = Scene_Label;
Cesium['LabelCollection'] = Scene_LabelCollection;
Cesium['LabelStyle'] = Scene_LabelStyle;
Cesium['MapboxImageryProvider'] = Scene_MapboxImageryProvider;
Cesium['MapMode2D'] = Scene_MapMode2D;
Cesium['Material'] = Scene_Material;
Cesium['MaterialAppearance'] = Scene_MaterialAppearance;
Cesium['Model'] = Scene_Model;
Cesium['ModelAnimation'] = Scene_ModelAnimation;
Cesium['ModelAnimationCache'] = Scene_ModelAnimationCache;
Cesium['ModelAnimationCollection'] = Scene_ModelAnimationCollection;
Cesium['ModelAnimationLoop'] = Scene_ModelAnimationLoop;
Cesium['ModelAnimationState'] = Scene_ModelAnimationState;
Cesium['ModelMaterial'] = Scene_ModelMaterial;
Cesium['modelMaterialsCommon'] = Scene_modelMaterialsCommon;
Cesium['ModelMesh'] = Scene_ModelMesh;
Cesium['ModelNode'] = Scene_ModelNode;
Cesium['Moon'] = Scene_Moon;
Cesium['NeverTileDiscardPolicy'] = Scene_NeverTileDiscardPolicy;
Cesium['OIT'] = Scene_OIT;
Cesium['OrthographicFrustum'] = Scene_OrthographicFrustum;
Cesium['PerformanceDisplay'] = Scene_PerformanceDisplay;
Cesium['PerInstanceColorAppearance'] = Scene_PerInstanceColorAppearance;
Cesium['PerspectiveFrustum'] = Scene_PerspectiveFrustum;
Cesium['PerspectiveOffCenterFrustum'] = Scene_PerspectiveOffCenterFrustum;
Cesium['PickDepth'] = Scene_PickDepth;
Cesium['PointAppearance'] = Scene_PointAppearance;
Cesium['PointPrimitive'] = Scene_PointPrimitive;
Cesium['PointPrimitiveCollection'] = Scene_PointPrimitiveCollection;
Cesium['Polyline'] = Scene_Polyline;
Cesium['PolylineCollection'] = Scene_PolylineCollection;
Cesium['PolylineColorAppearance'] = Scene_PolylineColorAppearance;
Cesium['PolylineMaterialAppearance'] = Scene_PolylineMaterialAppearance;
Cesium['Primitive'] = Scene_Primitive;
Cesium['PrimitiveCollection'] = Scene_PrimitiveCollection;
Cesium['PrimitivePipeline'] = Scene_PrimitivePipeline;
Cesium['PrimitiveState'] = Scene_PrimitiveState;
Cesium['QuadtreeOccluders'] = Scene_QuadtreeOccluders;
Cesium['QuadtreePrimitive'] = Scene_QuadtreePrimitive;
Cesium['QuadtreeTile'] = Scene_QuadtreeTile;
Cesium['QuadtreeTileLoadState'] = Scene_QuadtreeTileLoadState;
Cesium['QuadtreeTileProvider'] = Scene_QuadtreeTileProvider;
Cesium['Scene'] = Scene_Scene;
Cesium['SceneMode'] = Scene_SceneMode;
Cesium['SceneTransforms'] = Scene_SceneTransforms;
Cesium['SceneTransitioner'] = Scene_SceneTransitioner;
Cesium['ScreenSpaceCameraController'] = Scene_ScreenSpaceCameraController;
Cesium['ShadowMap'] = Scene_ShadowMap;
Cesium['ShadowMapShader'] = Scene_ShadowMapShader;
Cesium['ShadowMode'] = Scene_ShadowMode;
Cesium['SingleTileImageryProvider'] = Scene_SingleTileImageryProvider;
Cesium['SkyAtmosphere'] = Scene_SkyAtmosphere;
Cesium['SkyBox'] = Scene_SkyBox;
Cesium['StencilFunction'] = Scene_StencilFunction;
Cesium['StencilOperation'] = Scene_StencilOperation;
Cesium['Sun'] = Scene_Sun;
Cesium['SunPostProcess'] = Scene_SunPostProcess;
Cesium['TerrainState'] = Scene_TerrainState;
Cesium['TextureAtlas'] = Scene_TextureAtlas;
Cesium['TileBoundingBox'] = Scene_TileBoundingBox;
Cesium['TileCoordinatesImageryProvider'] = Scene_TileCoordinatesImageryProvider;
Cesium['TileDiscardPolicy'] = Scene_TileDiscardPolicy;
Cesium['TileImagery'] = Scene_TileImagery;
Cesium['TileReplacementQueue'] = Scene_TileReplacementQueue;
Cesium['TileState'] = Scene_TileState;
Cesium['TileTerrain'] = Scene_TileTerrain;
Cesium['TweenCollection'] = Scene_TweenCollection;
Cesium['UrlTemplateImageryProvider'] = Scene_UrlTemplateImageryProvider;
Cesium['VerticalOrigin'] = Scene_VerticalOrigin;
Cesium['ViewportQuad'] = Scene_ViewportQuad;
Cesium['WebMapServiceImageryProvider'] = Scene_WebMapServiceImageryProvider;
Cesium['WebMapTileServiceImageryProvider'] = Scene_WebMapTileServiceImageryProvider;
Cesium._shaders['AdjustTranslucentFS'] = Shaders_AdjustTranslucentFS;
Cesium._shaders['AllMaterialAppearanceFS'] = Shaders_Appearances_AllMaterialAppearanceFS;
Cesium._shaders['AllMaterialAppearanceVS'] = Shaders_Appearances_AllMaterialAppearanceVS;
Cesium._shaders['BasicMaterialAppearanceFS'] = Shaders_Appearances_BasicMaterialAppearanceFS;
Cesium._shaders['BasicMaterialAppearanceVS'] = Shaders_Appearances_BasicMaterialAppearanceVS;
Cesium._shaders['EllipsoidSurfaceAppearanceFS'] = Shaders_Appearances_EllipsoidSurfaceAppearanceFS;
Cesium._shaders['EllipsoidSurfaceAppearanceVS'] = Shaders_Appearances_EllipsoidSurfaceAppearanceVS;
Cesium._shaders['PerInstanceColorAppearanceFS'] = Shaders_Appearances_PerInstanceColorAppearanceFS;
Cesium._shaders['PerInstanceColorAppearanceVS'] = Shaders_Appearances_PerInstanceColorAppearanceVS;
Cesium._shaders['PerInstanceFlatColorAppearanceFS'] = Shaders_Appearances_PerInstanceFlatColorAppearanceFS;
Cesium._shaders['PerInstanceFlatColorAppearanceVS'] = Shaders_Appearances_PerInstanceFlatColorAppearanceVS;
Cesium._shaders['PointAppearanceFS'] = Shaders_Appearances_PointAppearanceFS;
Cesium._shaders['PointAppearanceVS'] = Shaders_Appearances_PointAppearanceVS;
Cesium._shaders['PolylineColorAppearanceVS'] = Shaders_Appearances_PolylineColorAppearanceVS;
Cesium._shaders['PolylineMaterialAppearanceVS'] = Shaders_Appearances_PolylineMaterialAppearanceVS;
Cesium._shaders['TexturedMaterialAppearanceFS'] = Shaders_Appearances_TexturedMaterialAppearanceFS;
Cesium._shaders['TexturedMaterialAppearanceVS'] = Shaders_Appearances_TexturedMaterialAppearanceVS;
Cesium._shaders['BillboardCollectionFS'] = Shaders_BillboardCollectionFS;
Cesium._shaders['BillboardCollectionVS'] = Shaders_BillboardCollectionVS;
Cesium._shaders['degreesPerRadian'] = Shaders_Builtin_Constants_degreesPerRadian;
Cesium._shaders['depthRange'] = Shaders_Builtin_Constants_depthRange;
Cesium._shaders['epsilon1'] = Shaders_Builtin_Constants_epsilon1;
Cesium._shaders['epsilon2'] = Shaders_Builtin_Constants_epsilon2;
Cesium._shaders['epsilon3'] = Shaders_Builtin_Constants_epsilon3;
Cesium._shaders['epsilon4'] = Shaders_Builtin_Constants_epsilon4;
Cesium._shaders['epsilon5'] = Shaders_Builtin_Constants_epsilon5;
Cesium._shaders['epsilon6'] = Shaders_Builtin_Constants_epsilon6;
Cesium._shaders['epsilon7'] = Shaders_Builtin_Constants_epsilon7;
Cesium._shaders['infinity'] = Shaders_Builtin_Constants_infinity;
Cesium._shaders['oneOverPi'] = Shaders_Builtin_Constants_oneOverPi;
Cesium._shaders['oneOverTwoPi'] = Shaders_Builtin_Constants_oneOverTwoPi;
Cesium._shaders['passCompute'] = Shaders_Builtin_Constants_passCompute;
Cesium._shaders['passEnvironment'] = Shaders_Builtin_Constants_passEnvironment;
Cesium._shaders['passGlobe'] = Shaders_Builtin_Constants_passGlobe;
Cesium._shaders['passGround'] = Shaders_Builtin_Constants_passGround;
Cesium._shaders['passOpaque'] = Shaders_Builtin_Constants_passOpaque;
Cesium._shaders['passOverlay'] = Shaders_Builtin_Constants_passOverlay;
Cesium._shaders['passTranslucent'] = Shaders_Builtin_Constants_passTranslucent;
Cesium._shaders['pi'] = Shaders_Builtin_Constants_pi;
Cesium._shaders['piOverFour'] = Shaders_Builtin_Constants_piOverFour;
Cesium._shaders['piOverSix'] = Shaders_Builtin_Constants_piOverSix;
Cesium._shaders['piOverThree'] = Shaders_Builtin_Constants_piOverThree;
Cesium._shaders['piOverTwo'] = Shaders_Builtin_Constants_piOverTwo;
Cesium._shaders['radiansPerDegree'] = Shaders_Builtin_Constants_radiansPerDegree;
Cesium._shaders['sceneMode2D'] = Shaders_Builtin_Constants_sceneMode2D;
Cesium._shaders['sceneMode3D'] = Shaders_Builtin_Constants_sceneMode3D;
Cesium._shaders['sceneModeColumbusView'] = Shaders_Builtin_Constants_sceneModeColumbusView;
Cesium._shaders['sceneModeMorphing'] = Shaders_Builtin_Constants_sceneModeMorphing;
Cesium._shaders['solarRadius'] = Shaders_Builtin_Constants_solarRadius;
Cesium._shaders['threePiOver2'] = Shaders_Builtin_Constants_threePiOver2;
Cesium._shaders['twoPi'] = Shaders_Builtin_Constants_twoPi;
Cesium._shaders['webMercatorMaxLatitude'] = Shaders_Builtin_Constants_webMercatorMaxLatitude;
Cesium._shaders['CzmBuiltins'] = Shaders_Builtin_CzmBuiltins;
Cesium._shaders['alphaWeight'] = Shaders_Builtin_Functions_alphaWeight;
Cesium._shaders['antialias'] = Shaders_Builtin_Functions_antialias;
Cesium._shaders['cascadeColor'] = Shaders_Builtin_Functions_cascadeColor;
Cesium._shaders['cascadeDistance'] = Shaders_Builtin_Functions_cascadeDistance;
Cesium._shaders['cascadeMatrix'] = Shaders_Builtin_Functions_cascadeMatrix;
Cesium._shaders['cascadeWeights'] = Shaders_Builtin_Functions_cascadeWeights;
Cesium._shaders['columbusViewMorph'] = Shaders_Builtin_Functions_columbusViewMorph;
Cesium._shaders['computePosition'] = Shaders_Builtin_Functions_computePosition;
Cesium._shaders['cosineAndSine'] = Shaders_Builtin_Functions_cosineAndSine;
Cesium._shaders['decompressTextureCoordinates'] = Shaders_Builtin_Functions_decompressTextureCoordinates;
Cesium._shaders['eastNorthUpToEyeCoordinates'] = Shaders_Builtin_Functions_eastNorthUpToEyeCoordinates;
Cesium._shaders['ellipsoidContainsPoint'] = Shaders_Builtin_Functions_ellipsoidContainsPoint;
Cesium._shaders['ellipsoidNew'] = Shaders_Builtin_Functions_ellipsoidNew;
Cesium._shaders['ellipsoidWgs84TextureCoordinates'] = Shaders_Builtin_Functions_ellipsoidWgs84TextureCoordinates;
Cesium._shaders['equalsEpsilon'] = Shaders_Builtin_Functions_equalsEpsilon;
Cesium._shaders['eyeOffset'] = Shaders_Builtin_Functions_eyeOffset;
Cesium._shaders['eyeToWindowCoordinates'] = Shaders_Builtin_Functions_eyeToWindowCoordinates;
Cesium._shaders['fog'] = Shaders_Builtin_Functions_fog;
Cesium._shaders['geodeticSurfaceNormal'] = Shaders_Builtin_Functions_geodeticSurfaceNormal;
Cesium._shaders['getDefaultMaterial'] = Shaders_Builtin_Functions_getDefaultMaterial;
Cesium._shaders['getLambertDiffuse'] = Shaders_Builtin_Functions_getLambertDiffuse;
Cesium._shaders['getSpecular'] = Shaders_Builtin_Functions_getSpecular;
Cesium._shaders['getWaterNoise'] = Shaders_Builtin_Functions_getWaterNoise;
Cesium._shaders['getWgs84EllipsoidEC'] = Shaders_Builtin_Functions_getWgs84EllipsoidEC;
Cesium._shaders['hue'] = Shaders_Builtin_Functions_hue;
Cesium._shaders['isEmpty'] = Shaders_Builtin_Functions_isEmpty;
Cesium._shaders['isFull'] = Shaders_Builtin_Functions_isFull;
Cesium._shaders['latitudeToWebMercatorFraction'] = Shaders_Builtin_Functions_latitudeToWebMercatorFraction;
Cesium._shaders['luminance'] = Shaders_Builtin_Functions_luminance;
Cesium._shaders['metersPerPixel'] = Shaders_Builtin_Functions_metersPerPixel;
Cesium._shaders['modelToWindowCoordinates'] = Shaders_Builtin_Functions_modelToWindowCoordinates;
Cesium._shaders['multiplyWithColorBalance'] = Shaders_Builtin_Functions_multiplyWithColorBalance;
Cesium._shaders['nearFarScalar'] = Shaders_Builtin_Functions_nearFarScalar;
Cesium._shaders['octDecode'] = Shaders_Builtin_Functions_octDecode;
Cesium._shaders['packDepth'] = Shaders_Builtin_Functions_packDepth;
Cesium._shaders['phong'] = Shaders_Builtin_Functions_phong;
Cesium._shaders['pointAlongRay'] = Shaders_Builtin_Functions_pointAlongRay;
Cesium._shaders['rayEllipsoidIntersectionInterval'] = Shaders_Builtin_Functions_rayEllipsoidIntersectionInterval;
Cesium._shaders['RGBToXYZ'] = Shaders_Builtin_Functions_RGBToXYZ;
Cesium._shaders['saturation'] = Shaders_Builtin_Functions_saturation;
Cesium._shaders['shadowDepthCompare'] = Shaders_Builtin_Functions_shadowDepthCompare;
Cesium._shaders['shadowVisibility'] = Shaders_Builtin_Functions_shadowVisibility;
Cesium._shaders['signNotZero'] = Shaders_Builtin_Functions_signNotZero;
Cesium._shaders['tangentToEyeSpaceMatrix'] = Shaders_Builtin_Functions_tangentToEyeSpaceMatrix;
Cesium._shaders['translateRelativeToEye'] = Shaders_Builtin_Functions_translateRelativeToEye;
Cesium._shaders['translucentPhong'] = Shaders_Builtin_Functions_translucentPhong;
Cesium._shaders['transpose'] = Shaders_Builtin_Functions_transpose;
Cesium._shaders['unpackDepth'] = Shaders_Builtin_Functions_unpackDepth;
Cesium._shaders['windowToEyeCoordinates'] = Shaders_Builtin_Functions_windowToEyeCoordinates;
Cesium._shaders['XYZToRGB'] = Shaders_Builtin_Functions_XYZToRGB;
Cesium._shaders['depthRangeStruct'] = Shaders_Builtin_Structs_depthRangeStruct;
Cesium._shaders['ellipsoid'] = Shaders_Builtin_Structs_ellipsoid;
Cesium._shaders['material'] = Shaders_Builtin_Structs_material;
Cesium._shaders['materialInput'] = Shaders_Builtin_Structs_materialInput;
Cesium._shaders['ray'] = Shaders_Builtin_Structs_ray;
Cesium._shaders['raySegment'] = Shaders_Builtin_Structs_raySegment;
Cesium._shaders['shadowParameters'] = Shaders_Builtin_Structs_shadowParameters;
Cesium._shaders['CompositeOITFS'] = Shaders_CompositeOITFS;
Cesium._shaders['DepthPlaneFS'] = Shaders_DepthPlaneFS;
Cesium._shaders['DepthPlaneVS'] = Shaders_DepthPlaneVS;
Cesium._shaders['EllipsoidFS'] = Shaders_EllipsoidFS;
Cesium._shaders['EllipsoidVS'] = Shaders_EllipsoidVS;
Cesium._shaders['GlobeFS'] = Shaders_GlobeFS;
Cesium._shaders['GlobeVS'] = Shaders_GlobeVS;
Cesium._shaders['GroundAtmosphere'] = Shaders_GroundAtmosphere;
Cesium._shaders['BumpMapMaterial'] = Shaders_Materials_BumpMapMaterial;
Cesium._shaders['CheckerboardMaterial'] = Shaders_Materials_CheckerboardMaterial;
Cesium._shaders['DotMaterial'] = Shaders_Materials_DotMaterial;
Cesium._shaders['FadeMaterial'] = Shaders_Materials_FadeMaterial;
Cesium._shaders['GridMaterial'] = Shaders_Materials_GridMaterial;
Cesium._shaders['NormalMapMaterial'] = Shaders_Materials_NormalMapMaterial;
Cesium._shaders['PolylineArrowMaterial'] = Shaders_Materials_PolylineArrowMaterial;
Cesium._shaders['PolylineGlowMaterial'] = Shaders_Materials_PolylineGlowMaterial;
Cesium._shaders['PolylineOutlineMaterial'] = Shaders_Materials_PolylineOutlineMaterial;
Cesium._shaders['RimLightingMaterial'] = Shaders_Materials_RimLightingMaterial;
Cesium._shaders['StripeMaterial'] = Shaders_Materials_StripeMaterial;
Cesium._shaders['Water'] = Shaders_Materials_Water;
Cesium._shaders['PointPrimitiveCollectionFS'] = Shaders_PointPrimitiveCollectionFS;
Cesium._shaders['PointPrimitiveCollectionVS'] = Shaders_PointPrimitiveCollectionVS;
Cesium._shaders['PolylineCommon'] = Shaders_PolylineCommon;
Cesium._shaders['PolylineFS'] = Shaders_PolylineFS;
Cesium._shaders['PolylineVS'] = Shaders_PolylineVS;
Cesium._shaders['AdditiveBlend'] = Shaders_PostProcessFilters_AdditiveBlend;
Cesium._shaders['BrightPass'] = Shaders_PostProcessFilters_BrightPass;
Cesium._shaders['FXAA'] = Shaders_PostProcessFilters_FXAA;
Cesium._shaders['GaussianBlur1D'] = Shaders_PostProcessFilters_GaussianBlur1D;
Cesium._shaders['PassThrough'] = Shaders_PostProcessFilters_PassThrough;
Cesium._shaders['ReprojectWebMercatorFS'] = Shaders_ReprojectWebMercatorFS;
Cesium._shaders['ReprojectWebMercatorVS'] = Shaders_ReprojectWebMercatorVS;
Cesium._shaders['ShadowVolumeFS'] = Shaders_ShadowVolumeFS;
Cesium._shaders['ShadowVolumeVS'] = Shaders_ShadowVolumeVS;
Cesium._shaders['SkyAtmosphereFS'] = Shaders_SkyAtmosphereFS;
Cesium._shaders['SkyAtmosphereVS'] = Shaders_SkyAtmosphereVS;
Cesium._shaders['SkyBoxFS'] = Shaders_SkyBoxFS;
Cesium._shaders['SkyBoxVS'] = Shaders_SkyBoxVS;
Cesium._shaders['SunFS'] = Shaders_SunFS;
Cesium._shaders['SunTextureFS'] = Shaders_SunTextureFS;
Cesium._shaders['SunVS'] = Shaders_SunVS;
Cesium._shaders['ViewportQuadFS'] = Shaders_ViewportQuadFS;
Cesium._shaders['ViewportQuadVS'] = Shaders_ViewportQuadVS;
Cesium['Autolinker'] = ThirdParty_Autolinker;
Cesium['earcut-2.1.1'] = ThirdParty_earcut_2_1_1;
Cesium['gltfDefaults'] = ThirdParty_gltfDefaults;
Cesium['kdbush'] = ThirdParty_kdbush;
Cesium['knockout-3.4.0'] = ThirdParty_knockout_3_4_0;
Cesium['knockout-es5'] = ThirdParty_knockout_es5;
Cesium['knockout'] = ThirdParty_knockout;
Cesium['measureText'] = ThirdParty_measureText;
Cesium['mersenne-twister'] = ThirdParty_mersenne_twister;
Cesium['NoSleep'] = ThirdParty_NoSleep;
Cesium['sprintf'] = ThirdParty_sprintf;
Cesium['topojson'] = ThirdParty_topojson;
Cesium['Tween'] = ThirdParty_Tween;
Cesium['Uri'] = ThirdParty_Uri;
Cesium['when'] = ThirdParty_when;
Cesium['zip'] = ThirdParty_zip;
Cesium['Animation'] = Widgets_Animation_Animation;
Cesium['AnimationViewModel'] = Widgets_Animation_AnimationViewModel;
Cesium['BaseLayerPicker'] = Widgets_BaseLayerPicker_BaseLayerPicker;
Cesium['BaseLayerPickerViewModel'] = Widgets_BaseLayerPicker_BaseLayerPickerViewModel;
Cesium['createDefaultImageryProviderViewModels'] = Widgets_BaseLayerPicker_createDefaultImageryProviderViewModels;
Cesium['createDefaultTerrainProviderViewModels'] = Widgets_BaseLayerPicker_createDefaultTerrainProviderViewModels;
Cesium['ProviderViewModel'] = Widgets_BaseLayerPicker_ProviderViewModel;
Cesium['CesiumInspector'] = Widgets_CesiumInspector_CesiumInspector;
Cesium['CesiumInspectorViewModel'] = Widgets_CesiumInspector_CesiumInspectorViewModel;
Cesium['CesiumWidget'] = Widgets_CesiumWidget_CesiumWidget;
Cesium['ClockViewModel'] = Widgets_ClockViewModel;
Cesium['Command'] = Widgets_Command;
Cesium['createCommand'] = Widgets_createCommand;
Cesium['FullscreenButton'] = Widgets_FullscreenButton_FullscreenButton;
Cesium['FullscreenButtonViewModel'] = Widgets_FullscreenButton_FullscreenButtonViewModel;
Cesium['Geocoder'] = Widgets_Geocoder_Geocoder;
Cesium['GeocoderViewModel'] = Widgets_Geocoder_GeocoderViewModel;
Cesium['getElement'] = Widgets_getElement;
Cesium['HomeButton'] = Widgets_HomeButton_HomeButton;
Cesium['HomeButtonViewModel'] = Widgets_HomeButton_HomeButtonViewModel;
Cesium['InfoBox'] = Widgets_InfoBox_InfoBox;
Cesium['InfoBoxViewModel'] = Widgets_InfoBox_InfoBoxViewModel;
Cesium['NavigationHelpButton'] = Widgets_NavigationHelpButton_NavigationHelpButton;
Cesium['NavigationHelpButtonViewModel'] = Widgets_NavigationHelpButton_NavigationHelpButtonViewModel;
Cesium['PerformanceWatchdog'] = Widgets_PerformanceWatchdog_PerformanceWatchdog;
Cesium['PerformanceWatchdogViewModel'] = Widgets_PerformanceWatchdog_PerformanceWatchdogViewModel;
Cesium['SceneModePicker'] = Widgets_SceneModePicker_SceneModePicker;
Cesium['SceneModePickerViewModel'] = Widgets_SceneModePicker_SceneModePickerViewModel;
Cesium['SelectionIndicator'] = Widgets_SelectionIndicator_SelectionIndicator;
Cesium['SelectionIndicatorViewModel'] = Widgets_SelectionIndicator_SelectionIndicatorViewModel;
Cesium['subscribeAndEvaluate'] = Widgets_subscribeAndEvaluate;
Cesium['SvgPathBindingHandler'] = Widgets_SvgPathBindingHandler;
Cesium['Timeline'] = Widgets_Timeline_Timeline;
Cesium['TimelineHighlightRange'] = Widgets_Timeline_TimelineHighlightRange;
Cesium['TimelineTrack'] = Widgets_Timeline_TimelineTrack;
Cesium['ToggleButtonViewModel'] = Widgets_ToggleButtonViewModel;
Cesium['Viewer'] = Widgets_Viewer_Viewer;
Cesium['viewerCesiumInspectorMixin'] = Widgets_Viewer_viewerCesiumInspectorMixin;
Cesium['viewerDragDropMixin'] = Widgets_Viewer_viewerDragDropMixin;
Cesium['viewerPerformanceWatchdogMixin'] = Widgets_Viewer_viewerPerformanceWatchdogMixin;
Cesium['VRButton'] = Widgets_VRButton_VRButton;
Cesium['VRButtonViewModel'] = Widgets_VRButton_VRButtonViewModel;
Cesium['createTaskProcessorWorker'] = Workers_createTaskProcessorWorker;
return Cesium;
});
/*global require*/
// require in the complete Cesium object and reassign it globally.
// This is meant for use with the Almond loader.
require([
'Cesium'
], function(
Cesium) {
'use strict';
/*global self*/
var scope = typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {};
scope.Cesium = Cesium;
}, undefined, true);
}());