cesium 0.13.0

data/app/assets/javascripts/Scene/EllipsoidTerrainProvider.js

@@ -0,0 +1,182 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/Math',
+        '../Core/BoundingSphere',
+        '../Core/Cartesian2',
+        '../Core/Cartesian3',
+        '../Core/Cartographic',
+        '../Core/Ellipsoid',
+        '../Core/ExtentTessellator',
+        '../Core/Occluder',
+        '../Core/PlaneTessellator',
+        '../Core/TaskProcessor',
+        './TerrainProvider',
+        './TileState',
+        './GeographicTilingScheme',
+        '../ThirdParty/when'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        CesiumMath,
+        BoundingSphere,
+        Cartesian2,
+        Cartesian3,
+        Cartographic,
+        Ellipsoid,
+        ExtentTessellator,
+        Occluder,
+        PlaneTessellator,
+        TaskProcessor,
+        TerrainProvider,
+        TileState,
+        GeographicTilingScheme,
+        when) {
+    "use strict";
+
+    /**
+     * A very simple {@link TerrainProvider} that produces geometry by tessellating an ellipsoidal
+     * surface.
+     *
+     * @alias EllipsoidTerrainProvider
+     * @constructor
+     * @private
+     *
+     * @param {TilingScheme} [description.tilingScheme] The tiling scheme specifying how the ellipsoidal
+     * surface is broken into tiles.  If this parameter is not provided, a {@link GeographicTilingScheme}
+     * is used.
+     * @param {Ellipsoid} [description.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.
+     *
+     * @see TerrainProvider
+     */
+    function EllipsoidTerrainProvider(description) {
+        description = defaultValue(description, {});
+
+        /**
+         * The tiling scheme used to tile the surface.
+         *
+         * @type TilingScheme
+         */
+        this.tilingScheme = defaultValue(description.tilingScheme, new GeographicTilingScheme({ ellipsoid : defaultValue(description.ellipsoid, Ellipsoid.WGS84) }));
+
+        // Note: the 64 below does NOT need to match the actual vertex dimensions.
+        this.levelZeroMaximumGeometricError = TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap(this.tilingScheme.getEllipsoid(), 64, this.tilingScheme.getNumberOfXTilesAtLevel(0));
+
+        this.ready = true;
+    }
+
+    /**
+     * Gets the maximum geometric error allowed in a tile at a given level.
+     *
+     * @param {Number} level The tile level for which to get the maximum geometric error.
+     * @returns {Number} The maximum geometric error.
+     */
+    EllipsoidTerrainProvider.prototype.getLevelMaximumGeometricError = TerrainProvider.prototype.getLevelMaximumGeometricError;
+
+    /**
+     * Request the tile geometry from the remote server.  Once complete, the
+     * tile state should be set to RECEIVED.  Alternatively, tile state can be set to
+     * UNLOADED to indicate that the request should be attempted again next update, if the tile
+     * is still needed.
+     *
+     * @param {Tile} The tile to request geometry for.
+     */
+    EllipsoidTerrainProvider.prototype.requestTileGeometry = function(tile) {
+        tile.state = TileState.RECEIVED;
+    };
+
+    var taskProcessor = new TaskProcessor('createVerticesFromExtent');
+
+    /**
+     * Transform the tile geometry from the format requested from the remote server
+     * into a format suitable for resource creation.  Once complete, the tile
+     * state should be set to TRANSFORMED.  Alternatively, tile state can be set to
+     * RECEIVED to indicate that the transformation should be attempted again next update, if the tile
+     * is still needed.
+     *
+     * @param {Context} context The context to use to create resources.
+     * @param {Tile} tile The tile to transform geometry for.
+     */
+    EllipsoidTerrainProvider.prototype.transformGeometry = function(context, tile) {
+        var tilingScheme = this.tilingScheme;
+        var ellipsoid = tilingScheme.getEllipsoid();
+        var extent = tile.extent;
+
+        tile.center = ellipsoid.cartographicToCartesian(extent.getCenter());
+
+        var width = 16;
+        var height = 16;
+
+        var verticesPromise = taskProcessor.scheduleTask({
+            extent : extent,
+            surfaceHeight : 0,
+            width : width,
+            height : height,
+            relativeToCenter : tile.center,
+            radiiSquared : ellipsoid.getRadiiSquared()
+        });
+
+        if (typeof verticesPromise === 'undefined') {
+            //postponed
+            tile.state = TileState.RECEIVED;
+            return;
+        }
+
+        when(verticesPromise, function(result) {
+            tile.transientData = {
+                vertices : new Float32Array(result),
+                indices : TerrainProvider.getRegularGridIndices(width, height)
+            };
+            tile.state = TileState.TRANSFORMED;
+        }, function(e) {
+            /*global console*/
+            console.error('failed to transform geometry: ' + e);
+            tile.state = TileState.FAILED;
+        });
+    };
+
+    var scratch = new Cartesian3();
+
+    /**
+     * Create WebGL resources for the tile using whatever data the transformGeometry step produced.
+     * Once complete, the tile state should be set to READY.  Alternatively, tile state can be set to
+     * TRANSFORMED to indicate that resource creation should be attempted again next update, if the tile
+     * is still needed.
+     *
+     * @param {Context} context The context to use to create resources.
+     * @param {Tile} tile The tile to create resources for.
+     */
+    EllipsoidTerrainProvider.prototype.createResources = function(context, tile) {
+        var buffers = tile.transientData;
+        tile.transientData = undefined;
+
+        TerrainProvider.createTileEllipsoidGeometryFromBuffers(context, tile, buffers);
+        tile.maxHeight = 0;
+        tile.boundingSphere3D = BoundingSphere.fromVertices(buffers.vertices, tile.center, 5);
+
+        var ellipsoid = this.tilingScheme.getEllipsoid();
+        var extent = tile.extent;
+        tile.southwestCornerCartesian = ellipsoid.cartographicToCartesian(extent.getSouthwest());
+        tile.southeastCornerCartesian = ellipsoid.cartographicToCartesian(extent.getSoutheast());
+        tile.northeastCornerCartesian = ellipsoid.cartographicToCartesian(extent.getNortheast());
+        tile.northwestCornerCartesian = ellipsoid.cartographicToCartesian(extent.getNorthwest());
+
+        tile.westNormal = Cartesian3.UNIT_Z.cross(tile.southwestCornerCartesian.negate(scratch), scratch).normalize();
+        tile.eastNormal = tile.northeastCornerCartesian.negate(scratch).cross(Cartesian3.UNIT_Z, scratch).normalize();
+        tile.southNormal = ellipsoid.geodeticSurfaceNormal(tile.southeastCornerCartesian).cross(tile.southwestCornerCartesian.subtract(tile.southeastCornerCartesian, scratch)).normalize();
+        tile.northNormal = ellipsoid.geodeticSurfaceNormal(tile.northwestCornerCartesian).cross(tile.northeastCornerCartesian.subtract(tile.northwestCornerCartesian, scratch)).normalize();
+
+        var occludeePoint = Occluder.computeOccludeePointFromExtent(tile.extent, ellipsoid);
+        if (typeof occludeePoint !== 'undefined') {
+            Cartesian3.multiplyComponents(occludeePoint, ellipsoid.getOneOverRadii(), occludeePoint);
+        }
+        tile.occludeePointInScaledSpace = occludeePoint;
+
+        tile.state = TileState.READY;
+    };
+
+    return EllipsoidTerrainProvider;
+});

data/app/assets/javascripts/Scene/FrameState.js

@@ -0,0 +1,86 @@
+/*global define*/
+define([], function() {
+    "use strict";
+
+    /**
+     * State information about the current frame.  An instance of this class
+     * is provided to update functions.
+     *
+     * @alias FrameState
+     * @constructor
+     */
+    var FrameState = function() {
+        /**
+         * The current mode of the scene.
+         * @type SceneMode
+         */
+        this.mode = undefined;
+
+        /**
+         * 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 = undefined;
+
+        /**
+         * The current frame number.
+         *
+         * @type Number
+         */
+        this.frameNumber = undefined;
+
+        /**
+         * The scene's current time.
+         *
+         * @type JulianDate
+         */
+        this.time = undefined;
+
+        this.scene2D = {
+            /**
+             * The projection to use in 2D mode.
+             */
+            projection : undefined
+        };
+
+        /**
+         * The current camera.
+         * @type Camera
+         */
+        this.camera = undefined;
+
+        /**
+         * The culling volume.
+         * @type CullingVolume
+         */
+        this.cullingVolume = undefined;
+
+        /**
+         * The current occluder.
+         * @type Occluder
+         */
+        this.occluder = undefined;
+
+        this.passes = {
+                /**
+                 * <code>true</code> if the primitive should update for a color pass, <code>false</code> otherwise.
+                 * @type Boolean
+                 */
+                color : false,
+                /**
+                 * <code>true</code> if the primitive should update for a picking pass, <code>false</code> otherwise.
+                 * @type Boolean
+                 */
+                pick : false,
+                /**
+                 * <code>true</code> if the primitive should update for an overlay pass, <code>false</code> otherwise.
+                 * @type Boolean
+                 */
+                overlay : false
+        };
+    };
+
+    return FrameState;
+});

data/app/assets/javascripts/Scene/FrustumCommands.js

@@ -0,0 +1,32 @@
+/*global define*/
+define(['../Core/defaultValue'], function(defaultValue) {
+    "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.
+     */
+    var FrustumCommands = function(near, far) {
+        /**
+         * The lower bound or closest distance from the camera.
+         * @type {Number}
+         */
+        this.near = defaultValue(near, 0.0);
+        /**
+         * The upper bound or farthest distance from the camera.
+         * @type {Number}
+         */
+        this.far = defaultValue(far, 0.0);
+        /**
+         * The list of commands.
+         * @type {Array}
+         */
+        this.commands = [];
+    };
+
+    return FrustumCommands;
+});

data/app/assets/javascripts/Scene/GeographicTilingScheme.js

@@ -0,0 +1,265 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/Math',
+        '../Core/Cartesian2',
+        '../Core/Ellipsoid',
+        '../Core/Extent',
+        '../Core/GeographicProjection',
+        './TilingScheme'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        CesiumMath,
+        Cartesian2,
+        Ellipsoid,
+        Extent,
+        GeographicProjection,
+        TilingScheme) {
+    "use strict";
+
+    /**
+     * A tiling scheme for geometry referenced to a simple {@link GeographicProjection} where
+     * longitude and latitude are directly mapped to X and Y.  This projection is commonly
+     * known as geographic, equirectangular, equidistant cylindrical, or plate carrée.
+     *
+     * @alias GeographicTilingScheme
+     * @constructor
+     *
+     * @param {Ellipsoid} [description.ellipsoid=Ellipsoid.WGS84] The ellipsoid whose surface is being tiled. Defaults to
+     * the WGS84 ellipsoid.
+     * @param {Extent} [description.extent=Extent.MAX_VALUE] The extent, in radians, covered by the tiling scheme.
+     * @param {Number} [description.numberOfLevelZeroTilesX=2] The number of tiles in the X direction at level zero of
+     * the tile tree.
+     * @param {Number} [description.numberOfLevelZeroTilesY=1] The number of tiles in the Y direction at level zero of
+     * the tile tree.
+     */
+    var GeographicTilingScheme = function GeographicTilingScheme(description) {
+        description = defaultValue(description, {});
+
+        this._ellipsoid = defaultValue(description.ellipsoid, Ellipsoid.WGS84);
+        this._extent = defaultValue(description.extent, Extent.MAX_VALUE);
+        this._projection = new GeographicProjection(this._ellipsoid);
+        this._numberOfLevelZeroTilesX = defaultValue(description.numberOfLevelZeroTilesX, 2);
+        this._numberOfLevelZeroTilesY = defaultValue(description.numberOfLevelZeroTilesY, 1);
+    };
+
+    /**
+     * Gets the ellipsoid that is tiled by this tiling scheme.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @returns {Ellipsoid} The ellipsoid.
+     */
+    GeographicTilingScheme.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
+
+    /**
+     * Gets the extent, in radians, covered by this tiling scheme.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @returns {Extent} The extent.
+     */
+    GeographicTilingScheme.prototype.getExtent = function() {
+        return this._extent;
+    };
+
+    /**
+     * Gets the map projection used by this tiling scheme.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @returns {Projection} The map projection.
+     */
+    GeographicTilingScheme.prototype.getProjection = function() {
+        return this._projection;
+    };
+
+    /**
+     * Gets the total number of tiles in the X direction at a specified level-of-detail.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Number} level The level-of-detail.
+     * @returns {Number} The number of tiles in the X direction at the given level.
+     */
+    GeographicTilingScheme.prototype.getNumberOfXTilesAtLevel = function(level) {
+        return this._numberOfLevelZeroTilesX << level;
+    };
+
+    /**
+     * Gets the total number of tiles in the Y direction at a specified level-of-detail.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Number} level The level-of-detail.
+     * @returns {Number} The number of tiles in the Y direction at the given level.
+     */
+    GeographicTilingScheme.prototype.getNumberOfYTilesAtLevel = function(level) {
+        return this._numberOfLevelZeroTilesY << level;
+    };
+
+    /**
+     * Creates the tile or tiles at level of detail zero, the coarsest, least detailed level.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @return {Array} An array containing the tiles at level of detail zero, starting with the
+     * tile in the northwest corner of the globe and followed by the tile (if any) to its east.
+     */
+    GeographicTilingScheme.prototype.createLevelZeroTiles = function() {
+        return TilingScheme.createRectangleOfLevelZeroTiles(this, this._numberOfLevelZeroTilesX, this._numberOfLevelZeroTilesY);
+    };
+
+    /**
+     * Transforms an extent specified in geodetic radians to the native coordinate system
+     * of this tiling scheme.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Extent} extent The extent to transform.
+     * @param {Extent} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     * @returns {Extent} The specified 'result', or a new object containing the native extent if 'result'
+     *          is undefined.
+     *
+     * @exception {DeveloperError} <code>extent</code> is required.
+     */
+    GeographicTilingScheme.prototype.extentToNativeExtent = function(extent, result) {
+        if (typeof extent === 'undefined') {
+            throw new DeveloperError('extent is required.');
+        }
+
+        var west = CesiumMath.toDegrees(extent.west);
+        var south = CesiumMath.toDegrees(extent.south);
+        var east = CesiumMath.toDegrees(extent.east);
+        var north = CesiumMath.toDegrees(extent.north);
+
+        if (typeof result === 'undefined') {
+            return new Extent(west, south, east, north);
+        }
+
+        result.west = west;
+        result.south = south;
+        result.east = east;
+        result.north = north;
+        return result;
+    };
+
+    /**
+     * Converts tile x, y coordinates and level to an extent expressed in the native coordinates
+     * of the tiling scheme.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Number} x The integer x coordinate of the tile.
+     * @param {Number} y The integer y coordinate of the tile.
+     * @param {Number} level The tile level-of-detail.  Zero is the least detailed.
+     * @param {Object} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     *
+     * @returns {Extent} The specified 'result', or a new object containing the extent
+     *          if 'result' is undefined.
+     */
+    GeographicTilingScheme.prototype.tileXYToNativeExtent = function(x, y, level, result) {
+        var extentRadians = this.tileXYToExtent(x, y, level, result);
+        extentRadians.west = CesiumMath.toDegrees(extentRadians.west);
+        extentRadians.south = CesiumMath.toDegrees(extentRadians.south);
+        extentRadians.east = CesiumMath.toDegrees(extentRadians.east);
+        extentRadians.north = CesiumMath.toDegrees(extentRadians.north);
+        return extentRadians;
+    };
+
+    /**
+     * Converts tile x, y coordinates and level to a cartographic extent in radians.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Number} x The integer x coordinate of the tile.
+     * @param {Number} y The integer y coordinate of the tile.
+     * @param {Number} level The tile level-of-detail.  Zero is the least detailed.
+     * @param {Object} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     *
+     * @returns {Extent} The specified 'result', or a new object containing the extent
+     *          if 'result' is undefined.
+     */
+    GeographicTilingScheme.prototype.tileXYToExtent = function(x, y, level, result) {
+        var extent = this._extent;
+
+        var xTiles = this.getNumberOfXTilesAtLevel(level);
+        var yTiles = this.getNumberOfYTilesAtLevel(level);
+
+        var xTileWidth = (extent.east - extent.west) / xTiles;
+        var west = x * xTileWidth + extent.west;
+        var east = (x + 1) * xTileWidth + extent.west;
+
+        var yTileHeight = (extent.north - extent.south) / yTiles;
+        var north = extent.north - y * yTileHeight;
+        var south = extent.north - (y + 1) * yTileHeight;
+
+        if (typeof result === 'undefined') {
+            result = new Extent(west, south, east, north);
+        }
+
+        result.west = west;
+        result.south = south;
+        result.east = east;
+        result.north = north;
+        return result;
+    };
+
+    /**
+     * Calculates the tile x, y coordinates of the tile containing
+     * a given cartographic position.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Cartographic} position The position.
+     * @param {Number} level The tile level-of-detail.  Zero is the least detailed.
+     * @param {Cartesian} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     *
+     * @returns {Cartesian2} The specified 'result', or a new object containing the tile x, y coordinates
+     *          if 'result' is undefined.
+     */
+    GeographicTilingScheme.prototype.positionToTileXY = function(position, level, result) {
+        var extent = this._extent;
+        if (position.latitude > extent.north ||
+            position.latitude < extent.south ||
+            position.longitude < extent.west ||
+            position.longitude > extent.east) {
+            // outside the bounds of the tiling scheme
+            return undefined;
+        }
+
+        var xTiles = this.getNumberOfXTilesAtLevel(level);
+        var yTiles = this.getNumberOfYTilesAtLevel(level);
+
+        var xTileWidth = (extent.east - extent.west) / xTiles;
+        var yTileHeight = (extent.north - extent.south) / yTiles;
+
+        var xTileCoordinate = (position.longitude - extent.west) / xTileWidth | 0;
+        if (xTileCoordinate >= xTiles) {
+            xTileCoordinate = xTiles - 1;
+        }
+
+        var yTileCoordinate = (extent.north - position.latitude) / yTileHeight | 0;
+        if (yTileCoordinate >= yTiles) {
+            yTileCoordinate = yTiles - 1;
+        }
+
+        if (typeof result === 'undefined') {
+            return new Cartesian2(xTileCoordinate, yTileCoordinate);
+        }
+
+        result.x = xTileCoordinate;
+        result.y = yTileCoordinate;
+        return result;
+    };
+
+    return GeographicTilingScheme;
+});