cesium 0.13.0

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

@@ -0,0 +1,139 @@
+/*global define*/
+define([
+        './ImageryState',
+        './TileState'
+    ], function(
+        ImageryState,
+        TileState) {
+    "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
+     */
+    var TileReplacementQueue = 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.
+     *
+     * @memberof TileReplacementQueue
+     *
+     * @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 &&
+               typeof this._lastBeforeStartOfFrame !== 'undefined' &&
+               this.count > maximumTiles &&
+               typeof tileToTrim !== 'undefined') {
+            // Stop trimming after we process the last tile not used in the
+            // current frame.
+            keepTrimming = tileToTrim !== this._lastBeforeStartOfFrame;
+
+            var previous = tileToTrim.replacementPrevious;
+
+            // Do not remove tiles that are transitioning or that have
+            // imagery that is transitioning.
+            var shouldRemoveTile = tileToTrim.state !== TileState.TRANSITIONING;
+            var imagery = tileToTrim.imagery;
+            for (var i = 0, len = imagery.length; shouldRemoveTile && i < len; ++i) {
+                var tileImagery = imagery[i];
+                shouldRemoveTile = tileImagery.imagery.state !== ImageryState.TRANSITIONING;
+            }
+
+            if (shouldRemoveTile) {
+                tileToTrim.freeResources();
+                this._remove(tileToTrim);
+            }
+
+            tileToTrim = previous;
+        }
+    };
+
+    TileReplacementQueue.prototype._remove = function(item) {
+        var previous = item.replacementPrevious;
+        var next = item.replacementNext;
+
+        if (item === this._lastBeforeStartOfFrame) {
+            this._lastBeforeStartOfFrame = next;
+        }
+
+        if (item === this.head) {
+            this.head = next;
+        } else {
+            previous.replacementNext = next;
+        }
+
+        if (item === this.tail) {
+            this.tail = previous;
+        } else {
+            next.replacementPrevious = previous;
+        }
+
+        item.replacementPrevious = undefined;
+        item.replacementNext = undefined;
+
+        --this.count;
+    };
+
+    /**
+     * Marks a tile as rendered this frame and moves it before the first tile that was not rendered
+     * this frame.
+     *
+     * @memberof TileReplacementQueue
+     *
+     * @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 (typeof head === 'undefined') {
+            // no other tiles in the list
+            item.replacementPrevious = undefined;
+            item.replacementNext = undefined;
+            this.head = item;
+            this.tail = item;
+            return;
+        }
+
+        if (typeof item.replacementPrevious !== 'undefined' || typeof item.replacementNext !== 'undefined') {
+            // tile already in the list, remove from its current location
+            this._remove(item);
+        }
+
+        item.replacementPrevious = undefined;
+        item.replacementNext = head;
+        head.replacementPrevious = item;
+
+        this.head = item;
+    };
+
+    return TileReplacementQueue;
+});

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

@@ -0,0 +1,19 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * @private
+     */
+    var TileState = {
+        UNLOADED : new Enumeration(0, 'UNLOADED'),
+        TRANSITIONING : new Enumeration(1, 'TRANSITIONING'),
+        RECEIVED : new Enumeration(2, 'RECEIVED'),
+        TRANSFORMED : new Enumeration(3, 'TRANSFORMED'),
+        READY : new Enumeration(4, 'READY'),
+        FAILED : new Enumeration(5, 'FAILED'),
+        INVALID : new Enumeration(6, 'INVALID')
+    };
+
+    return TileState;
+});

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

@@ -0,0 +1,213 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        './Tile'
+    ], function(
+        DeveloperError,
+        Tile) {
+    "use strict";
+
+    /**
+     * A tiling scheme for geometry or imagery on the surface of an ellipsoid.  At level-of-detail zero,
+     * the coarsest, least-detailed level, the number of tiles is configurable.
+     * At level of detail one, each of the level zero tiles has four children, two in each direction.
+     * At level of detail two, each of the level one tiles has four children, two in each direction.
+     * This continues for as many levels as are present in the geometry or imagery source.
+     *
+     * @alias TilingScheme
+     * @constructor
+     *
+     * @see WebMercatorTilingScheme
+     * @see GeographicTilingScheme
+     */
+    var TilingScheme = function TilingScheme(description) {
+        throw new DeveloperError('This type should not be instantiated directly.  Instead, use WebMercatorTilingScheme or GeographicTilingScheme.');
+    };
+
+    /**
+     * Gets the ellipsoid that is tiled by this tiling scheme.
+     *
+     * @memberof TilingScheme
+     *
+     * @returns {Ellipsoid} The ellipsoid.
+     */
+    TilingScheme.prototype.getEllipsoid = function() {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Gets the extent, in radians, covered by this tiling scheme.
+     *
+     * @memberof TilingScheme
+     *
+     * @returns {Extent} The extent.
+     */
+    TilingScheme.prototype.getExtent = function() {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Gets the map projection used by this tiling scheme.
+     *
+     * @memberof TilingScheme
+     *
+     * @returns {Projection} The map projection.
+     */
+    TilingScheme.prototype.getProjection = function() {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Gets the total number of tiles in the X direction at a specified level-of-detail.
+     *
+     * @memberof TilingScheme
+     *
+     * @param {Number} level The level-of-detail.
+     * @returns {Number} The number of tiles in the X direction at the given level.
+     */
+    TilingScheme.prototype.getNumberOfXTilesAtLevel = function(level) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Gets the total number of tiles in the Y direction at a specified level-of-detail.
+     *
+     * @memberof TilingScheme
+     *
+     * @param {Number} level The level-of-detail.
+     * @returns {Number} The number of tiles in the Y direction at the given level.
+     */
+    TilingScheme.prototype.getNumberOfYTilesAtLevel = function(level) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Creates the tile or tiles at level of detail zero, the coarsest, least detailed level.
+     *
+     * @memberof TilingScheme
+     *
+     * @returns {Array} 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.
+     */
+    TilingScheme.prototype.createLevelZeroTiles = function() {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Transforms an extent specified in geodetic radians to the native coordinate system
+     * of this tiling scheme.
+     *
+     * @memberof TilingScheme
+     *
+     * @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.
+     */
+    TilingScheme.prototype.extentToNativeExtent = function(extent, result) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Converts tile x, y coordinates and level to an extent expressed in the native coordinates
+     * of the tiling scheme.
+     *
+     * @memberof TilingScheme
+     *
+     * @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.
+     */
+    TilingScheme.prototype.tileXYToNativeExtent = function(x, y, level, result) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Converts tile x, y coordinates and level to a cartographic extent in radians.
+     *
+     * @memberof TilingScheme
+     *
+     * @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.
+     */
+    TilingScheme.prototype.tileXYToExtent = function(x, y, level, result) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Calculates the tile x, y coordinates of the tile containing
+     * a given cartographic position.
+     *
+     * @memberof TilingScheme
+     *
+     * @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.
+     */
+    TilingScheme.prototype.positionToTileXY = function(position, level, result) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Creates a rectangular set of tiles for level of detail zero, the coarsest, least detailed level.
+     *
+     * @memberof TilingScheme
+     *
+     * @param {TilingScheme} tilingScheme The tiling scheme for which the tiles are to be created.
+     * @param {Number} numberOfLevelZeroTilesX The number of tiles in the X direction at level zero of
+     *        the tile tree.
+     * @param {Number} numberOfLevelZeroTilesY The number of tiles in the Y direction at level zero of
+     *        the tile tree.
+     * @returns {Array} 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.
+     *
+     * @exception {DeveloperError} <code>tilingScheme</code> is required.
+     * @exception {DeveloperError} <code>numberOfLevelZeroTilesX</code> is required.
+     * @exception {DeveloperError} <code>numberOfLevelZeroTilesY</code> is required.
+     */
+    TilingScheme.createRectangleOfLevelZeroTiles = function(tilingScheme, numberOfLevelZeroTilesX, numberOfLevelZeroTilesY) {
+        if (typeof tilingScheme === 'undefined') {
+            throw new DeveloperError('tilingScheme is required.');
+        }
+        if (typeof numberOfLevelZeroTilesX === 'undefined') {
+            throw new DeveloperError('numberOfLevelZeroTilesX is required.');
+        }
+        if (typeof numberOfLevelZeroTilesY === 'undefined') {
+            throw new DeveloperError('numberOfLevelZeroTilesY is required.');
+        }
+
+        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 Tile({
+                    tilingScheme : tilingScheme,
+                    x : x,
+                    y : y,
+                    level : 0
+                });
+            }
+        }
+
+        return result;
+    };
+
+    return TilingScheme;
+});

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

@@ -0,0 +1,39 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * The vertical location of an origin relative to an object, e.g., a {@link Billboard}.
+     * For example, the vertical origin is used to display a billboard above or below (in
+     * screen space) of the actual position.
+     *
+     * @exports VerticalOrigin
+     *
+     * @see Billboard#setVerticalOrigin
+     */
+    var VerticalOrigin = {
+        /**
+         * The origin is at the vertical center of the object.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        CENTER : new Enumeration(0, 'CENTER'),
+        /**
+         * The origin is at the bottom of the object.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        BOTTOM : new Enumeration(1, 'BOTTOM'),
+        /**
+         * The origin is at the top of the object.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        TOP : new Enumeration(-1, 'TOP')
+    };
+
+    return VerticalOrigin;
+});

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

@@ -0,0 +1,256 @@
+/*global define*/
+define([
+        '../Core/Color',
+        '../Core/combine',
+        '../Core/destroyObject',
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/BoundingRectangle',
+        '../Core/ComponentDatatype',
+        '../Core/PrimitiveType',
+        './Material',
+        '../Renderer/BufferUsage',
+        '../Renderer/BlendingState',
+        '../Renderer/CommandLists',
+        '../Renderer/DrawCommand',
+        '../Shaders/Noise',
+        '../Shaders/ViewportQuadVS',
+        '../Shaders/ViewportQuadFS'
+    ], function(
+        Color,
+        combine,
+        destroyObject,
+        defaultValue,
+        DeveloperError,
+        BoundingRectangle,
+        ComponentDatatype,
+        PrimitiveType,
+        Material,
+        BufferUsage,
+        BlendingState,
+        CommandLists,
+        DrawCommand,
+        Noise,
+        ViewportQuadVS,
+        ViewportQuadFS) {
+    "use strict";
+
+    /**
+     * A viewport aligned quad.
+     *
+     * @alias ViewportQuad
+     * @constructor
+     *
+     * @param {BoundingRectangle} rectangle The BoundingRectangle defining the quad's position within the viewport.
+     *
+     * @example
+     * var viewportQuad = new ViewportQuad();
+     * var viewportQuad = new BoundingRectangle(0, 0, 80, 40);
+     * viewportQuad.material.uniforms.color = new Color(1.0, 0.0, 0.0, 1.0);
+     */
+    var ViewportQuad = function(rectangle) {
+
+        this._va = undefined;
+        this._overlayCommand = new DrawCommand();
+        this._overlayCommand.primitiveType = PrimitiveType.TRIANGLE_FAN;
+        this._commandLists = new CommandLists();
+        this._commandLists.overlayList.push(this._overlayCommand);
+
+
+        /**
+         * The BoundingRectangle defining the quad's position within the viewport.
+         *
+         * @type BoundingRectangle
+         *
+         * @example
+         * viewportQuad.rectangle = new BoundingRectangle(0, 0, 80, 40);
+         */
+        this.rectangle = new BoundingRectangle(0, 0, 10, 10);
+
+
+        /**
+         * The surface appearance of the viewport quad.  This can be one of several built-in {@link Material} objects or a custom material, scripted with
+         * <a href='https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric'>Fabric</a>.
+         * <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 Color(1.0, 1.0, 0.0, 1.0);
+         *
+         * // 2. Change material to horizontal stripes
+         * viewportQuad.material = Material.fromType(scene.getContext(), Material.StripeType);
+         *
+         * @see <a href='https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric'>Fabric</a>
+         */
+        this.material = Material.fromType(undefined, Material.ColorType);
+        this.material.uniforms.color = new Color(1.0, 1.0, 1.0, 1.0);
+        this._material = undefined;
+    };
+
+    var attributeIndices = {
+        position : 0,
+        textureCoordinates : 1
+    };
+
+    var vertexArrayCache = {};
+
+    function getVertexArray(context) {
+        // Per-context cache for viewport quads
+        var c = vertexArrayCache[context.getId()];
+
+        if (typeof c !== 'undefined' &&
+            typeof c.vertexArray !== 'undefined') {
+
+            ++c.referenceCount;
+            return c;
+        }
+
+        var mesh = {
+            attributes : {
+                position : {
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 2,
+                    values : [
+                       -1.0, -1.0,
+                        1.0, -1.0,
+                        1.0,  1.0,
+                       -1.0,  1.0
+                    ]
+                },
+
+                textureCoordinates : {
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 2,
+                    values : [
+                        0.0, 0.0,
+                        1.0, 0.0,
+                        1.0, 1.0,
+                        0.0, 1.0
+                    ]
+                }
+            }
+        };
+
+        var va = context.createVertexArrayFromMesh({
+            mesh : mesh,
+            attributeIndices : attributeIndices,
+            bufferUsage : BufferUsage.STATIC_DRAW
+        });
+
+        var cachedVA = {
+            vertexArray : va,
+            referenceCount : 1,
+
+            release : function() {
+                if (typeof this.vertexArray !== 'undefined' &&
+                    --this.referenceCount === 0) {
+
+                    // TODO: Schedule this for a few hundred frames later so we don't thrash the cache
+                    this.vertexArray = this.vertexArray.destroy();
+                }
+
+                return undefined;
+            }
+        };
+
+        vertexArrayCache[context.getId()] = cachedVA;
+        return cachedVA;
+    }
+
+    /**
+     * Commits changes to properties before rendering by updating the object's WebGL resources.
+     *
+     * @memberof ViewportQuad
+     *
+     * @exception {DeveloperError} this.material must be defined.
+     * @exception {DeveloperError} this.rectangle must be defined.
+     */
+    ViewportQuad.prototype.update = function(context, frameState, commandList) {
+        if (typeof this.material === 'undefined') {
+            throw new DeveloperError('this.material must be defined.');
+        }
+
+        if (typeof this.rectangle === 'undefined') {
+            throw new DeveloperError('this.rectangle must be defined.');
+        }
+
+        if (typeof this._va === 'undefined') {
+            this._va = getVertexArray(context);
+            this._overlayCommand.vertexArray = this._va.vertexArray;
+            this._overlayCommand.renderState = context.createRenderState({
+                blending : BlendingState.ALPHA_BLEND
+            });
+        }
+
+        var pass = frameState.passes;
+        if (pass.overlay) {
+            if (this._material !== this.material) {
+                // Recompile shader when material changes
+                this._material = this.material;
+
+                var fsSource =
+                    '#line 0\n' +
+                    Noise +
+                    '#line 0\n' +
+                    this._material.shaderSource +
+                    '#line 0\n' +
+                    ViewportQuadFS;
+
+                this._overlayCommand.shaderProgram = this._overlayCommand.shaderProgram && this._overlayCommand.shaderProgram.release();
+                this._overlayCommand.shaderProgram = context.getShaderCache().getShaderProgram(ViewportQuadVS, fsSource, attributeIndices);
+            }
+
+            this._overlayCommand.renderState.viewport = this.rectangle;
+            this._overlayCommand.uniformMap = this._material._uniforms;
+            commandList.push(this._commandLists);
+        }
+    };
+
+    /**
+     * 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 ViewportQuad
+     *
+     * @return {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.
+     *
+     * @memberof ViewportQuad
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see ViewportQuad#isDestroyed
+     *
+     * @example
+     * quad = quad && quad.destroy();
+     */
+    ViewportQuad.prototype.destroy = function() {
+        this._va = this._va && this._va.release();
+        this._overlayCommand.shaderProgram = this._overlayCommand.shaderProgram && this._overlayCommand.shaderProgram.release();
+
+        return destroyObject(this);
+    };
+
+    return ViewportQuad;
+});