cesium 0.13.0

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

@@ -0,0 +1,229 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/ComponentDatatype',
+        '../Renderer/BufferUsage',
+        '../Core/IndexDatatype'
+    ], function(
+        DeveloperError,
+        ComponentDatatype,
+        BufferUsage,
+        IndexDatatype) {
+    "use strict";
+
+    /**
+     * Provides terrain or other geometry for the surface of an ellipsoid.  The surface geometry is
+     * organized into a pyramid of tiles according to a {@link TilingScheme}.  This type describes an
+     * interface and is not intended to be instantiated directly.
+     *
+     * @alias TerrainProvider
+     * @constructor
+     * @private
+     *
+     * @see EllipsoidTerrainProvider
+     */
+    function TerrainProvider() {
+        /**
+         * The tiling scheme used to tile the surface.
+         *
+         * @type TilingScheme
+         */
+        this.tilingScheme = undefined;
+
+        this.levelZeroMaximumGeometricError = undefined;
+
+        throw new DeveloperError('This type should not be instantiated directly.');
+    }
+
+    /**
+     * Specifies the indices of the attributes of the terrain geometry.
+     *
+     * @memberof TerrainProvider
+     */
+    TerrainProvider.attributeIndices = {
+        position3D : 0,
+        textureCoordinates : 1
+    };
+
+    TerrainProvider.wireframe = false;
+
+    var regularGridIndexArrays = [];
+
+    TerrainProvider.getRegularGridIndices = function(width, height) {
+        var byWidth = regularGridIndexArrays[width];
+        if (typeof byWidth === 'undefined') {
+            regularGridIndexArrays[width] = byWidth = [];
+        }
+
+        var indices = byWidth[height];
+        if (typeof indices === 'undefined') {
+            indices = byWidth[height] = new Uint16Array((width - 1) * (height - 1) * 6);
+
+            var index = 0;
+            var indicesIndex = 0;
+            for ( var i = 0; i < height - 1; ++i) {
+                for ( var j = 0; j < width - 1; ++j) {
+                    var upperLeft = index;
+                    var lowerLeft = upperLeft + width;
+                    var lowerRight = lowerLeft + 1;
+                    var upperRight = upperLeft + 1;
+
+                    indices[indicesIndex++] = upperLeft;
+                    indices[indicesIndex++] = lowerLeft;
+                    indices[indicesIndex++] = upperRight;
+                    indices[indicesIndex++] = upperRight;
+                    indices[indicesIndex++] = lowerLeft;
+                    indices[indicesIndex++] = lowerRight;
+
+                    ++index;
+                }
+                ++index;
+            }
+        }
+
+        return indices;
+    };
+
+    function addTriangle(lines, linesIndex, i0, i1, i2) {
+        lines[linesIndex++] = i0;
+        lines[linesIndex++] = i1;
+
+        lines[linesIndex++] = i1;
+        lines[linesIndex++] = i2;
+
+        lines[linesIndex++] = i2;
+        lines[linesIndex++] = i0;
+
+        return linesIndex;
+    }
+
+    function trianglesToLines(triangles) {
+        var count = triangles.length;
+        var lines = new Uint16Array(2 * count);
+        var linesIndex = 0;
+        for ( var i = 0; i < count; i += 3) {
+            linesIndex = addTriangle(lines, linesIndex, triangles[i], triangles[i + 1], triangles[i + 2]);
+        }
+
+        return lines;
+    }
+
+    TerrainProvider.createTileEllipsoidGeometryFromBuffers = function(context, tile, buffers) {
+        var datatype = ComponentDatatype.FLOAT;
+        var typedArray = buffers.vertices;
+        var buffer = context.createVertexBuffer(typedArray, BufferUsage.STATIC_DRAW);
+        var stride = 5 * datatype.sizeInBytes;
+        var attributes = [{
+            index : TerrainProvider.attributeIndices.position3D,
+            vertexBuffer : buffer,
+            componentDatatype : datatype,
+            componentsPerAttribute : 3,
+            offsetInBytes : 0,
+            strideInBytes : stride
+        }, {
+            index : TerrainProvider.attributeIndices.textureCoordinates,
+            vertexBuffer : buffer,
+            componentDatatype : datatype,
+            componentsPerAttribute : 2,
+            offsetInBytes : 3 * datatype.sizeInBytes,
+            strideInBytes : stride
+        }];
+
+        var indexBuffers = buffers.indices.indexBuffers || {};
+        var indexBuffer = indexBuffers[context.getId()];
+        if (typeof indexBuffer === 'undefined' || indexBuffer.isDestroyed()) {
+            var indices = buffers.indices;
+            if (TerrainProvider.wireframe) {
+                indices = trianglesToLines(buffers.indices);
+            }
+            indexBuffer = context.createIndexBuffer(indices, BufferUsage.STATIC_DRAW, IndexDatatype.UNSIGNED_SHORT);
+            indexBuffer.setVertexArrayDestroyable(false);
+            indexBuffer.referenceCount = 1;
+            indexBuffers[context.getId()] = indexBuffer;
+            buffers.indices.indexBuffers = indexBuffers;
+        } else {
+            ++indexBuffer.referenceCount;
+        }
+
+        tile.vertexArray = context.createVertexArray(attributes, indexBuffer);
+    };
+
+    /**
+     * Specifies the quality of terrain created from heightmaps.  A value of 1.0 will
+     * ensure that adjacent heightmap vertices are separated by no more than
+     * {@link CentralBodySurface._maxScreenSpaceError} screen pixels and will probably go very slowly.
+     * A value of 0.5 will cut the estimated level zero geometric error in half, allowing twice the
+     * screen pixels between adjacent heightmap vertices and thus rendering more quickly.
+     */
+    TerrainProvider.heightmapTerrainQuality = 0.25;
+
+    /**
+     * Determines an appropriate geometric error estimate when the geometry comes from a heightmap.
+     *
+     * @param ellipsoid The ellipsoid to which the terrain is attached.
+     * @param tileImageWidth The width, in pixels, of the heightmap associated with a single tile.
+     * @param numberOfTilesAtLevelZero The number of tiles in the horizontal direction at tile level zero.
+     * @returns {Number} An estimated geometric error.
+     */
+    TerrainProvider.getEstimatedLevelZeroGeometricErrorForAHeightmap = function(ellipsoid, tileImageWidth, numberOfTilesAtLevelZero) {
+        return ellipsoid.getMaximumRadius() * 2 * Math.PI * TerrainProvider.heightmapTerrainQuality / (tileImageWidth * numberOfTilesAtLevelZero);
+    };
+
+    /**
+     * 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.
+     */
+    TerrainProvider.prototype.getLevelMaximumGeometricError = function(level) {
+        return this.levelZeroMaximumGeometricError / (1 << level);
+    };
+
+    // Is there a limit on 'level' of the tile that can be passed in?  It seems
+    // natural to have a maxLevel, but this would cause problems if we have hi-res imagery
+    // and low-res terrain.  So I'd say we can continue to refine terrain tiles arbitrarily
+    // until both the terrain and all the imagery layers have no more detail to give.  In that
+    // case, this method is expected to be able to produce geometry for an arbitrarily-deep
+    // tile tree.
+
+    /**
+     * 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.
+     */
+    TerrainProvider.prototype.requestTileGeometry = function(tile) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * 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.
+     */
+    TerrainProvider.prototype.transformGeometry = function(context, tile) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * 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.
+     */
+    TerrainProvider.prototype.createResources = function(context, tile) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    return TerrainProvider;
+});

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

@@ -0,0 +1,154 @@
+/*global define*/
+define([
+        '../Core/destroyObject',
+        '../Core/DeveloperError',
+        '../Renderer/PixelDatatype',
+        '../Renderer/PixelFormat',
+        '../Renderer/Texture'
+    ], function(
+        destroyObject,
+        DeveloperError,
+        PixelDatatype,
+        PixelFormat,
+        Texture) {
+    "use strict";
+
+    var PooledTexture;
+    function createPooledTexture(texture, textureTypeKey, pool) {
+        if (typeof PooledTexture === 'undefined') {
+            // define the class only when needed, so we can use modern
+            // language features without breaking legacy browsers at setup time.
+            PooledTexture = function(texture, textureTypeKey, pool) {
+                this._texture = texture;
+                this._textureTypeKey = textureTypeKey;
+                this._pool = pool;
+            };
+
+            // pass through all methods to the underlying texture
+            Object.keys(Texture.prototype).forEach(function(methodName) {
+                PooledTexture.prototype[methodName] = function() {
+                    var texture = this._texture;
+                    return texture[methodName].apply(texture, arguments);
+                };
+            });
+
+            // except for destroy, which releases back into the pool
+            PooledTexture.prototype.destroy = function() {
+                var freeList = this._pool._free[this._textureTypeKey];
+                if (typeof freeList === 'undefined') {
+                    freeList = this._pool._free[this._textureTypeKey] = [];
+                }
+
+                if (freeList.length >= 8) {
+                    this._texture.destroy();
+                } else {
+                    freeList.push(this);
+                }
+            };
+        }
+
+        return new PooledTexture(texture, textureTypeKey, pool);
+    }
+
+    /**
+     * A pool of textures.  Textures created from the pool will be released back into the pool
+     * when destroy() is called, so future calls to create may re-use a released texture.
+     * <br/><br/>
+     * Texture pools are useful when textures are being created and destroyed repeatedly.
+     *
+     * @alias Texture2DPool
+     * @constructor
+     *
+     * @see Texture
+     */
+    var TexturePool = function() {
+        this._free = {};
+    };
+
+    /**
+     * Create a texture.  This function takes the same arguments as {@link Context#createTexture2D},
+     * but may return a pooled texture if there are any available.  If a pooled texture is re-used,
+     * and no source is provided, the new texture will still retain its old contents.
+     *
+     * @memberof TexturePool
+     *
+     * @param {Context} context The context to use to create textures when needed.
+     *
+     * @exception {DeveloperError} description is required.
+     *
+     * @see Context#createTexture2D
+     */
+    TexturePool.prototype.createTexture2D = function(context, description) {
+        if (!description) {
+            throw new DeveloperError('description is required.');
+        }
+
+        var source = description.source;
+        var width = typeof source !== 'undefined' ? source.width : description.width;
+        var height = typeof source !== 'undefined' ? source.height : description.height;
+        //coerce values to primitive numbers to make textureTypeKey smaller.
+        var pixelFormat = +(description.pixelFormat || PixelFormat.RGBA);
+        var pixelDatatype = +(description.pixelDatatype || PixelDatatype.UNSIGNED_BYTE);
+        var preMultiplyAlpha = +(description.preMultiplyAlpha || pixelFormat === PixelFormat.RGB || pixelFormat === PixelFormat.LUMINANCE);
+
+        var textureTypeKey = JSON.stringify([width, height, pixelFormat, pixelDatatype, preMultiplyAlpha]);
+
+        var freeList = this._free[textureTypeKey];
+        if (typeof freeList !== 'undefined' && freeList.length > 0) {
+            var texture = freeList.pop();
+            if (typeof source !== 'undefined') {
+                texture.copyFrom(source);
+            }
+            return texture;
+        }
+
+        return createPooledTexture(context.createTexture2D(description), textureTypeKey, this);
+    };
+
+    /**
+     * 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 TexturePool
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see TexturePool#destroy
+     */
+    TexturePool.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 TexturePool
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see TexturePool#isDestroyed
+     *
+     * @example
+     * pool = pool && pool.destroy();
+     */
+    TexturePool.prototype.destroy = function() {
+        var free = this._free;
+        Object.keys(free).forEach(function(textureTypeKey) {
+            free[textureTypeKey].forEach(function(texture) {
+                texture._texture.destroy();
+            });
+        });
+        return destroyObject(this);
+    };
+
+    return TexturePool;
+});

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

@@ -0,0 +1,322 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        './TileState'
+    ], function(
+        DeveloperError,
+        TileState) {
+    "use strict";
+
+    /**
+     * A node in the quadtree representing the surface of a {@link CentralBody}.
+     * A tile holds the surface geometry for its horizontal extent and zero or
+     * more imagery textures overlaid on the geometry.
+     *
+     * @alias Tile
+     * @constructor
+     * @private
+     *
+     * @param {TilingScheme} description.tilingScheme The tiling scheme of which the new tile is a part, such as a
+     *                                                {@link WebMercatorTilingScheme} or a {@link GeographicTilingScheme}.
+     * @param {Number} description.x The tile x coordinate.
+     * @param {Number} description.y The tile y coordinate.
+     * @param {Number} description.level The tile level-of-detail.
+     * @param {Tile} description.parent The parent of this tile in a tile tree system.
+     *
+     * @exception {DeveloperError} Either description.extent or both description.x and description.y is required.
+     * @exception {DeveloperError} description.level is required.
+     */
+    var Tile = function(description) {
+        if (typeof description === 'undefined') {
+            throw new DeveloperError('description is required.');
+        }
+
+        if (typeof description.x === 'undefined' || typeof description.y === 'undefined') {
+            if (typeof description.extent === 'undefined') {
+                throw new DeveloperError('Either description.extent is required or description.x and description.y are required.');
+            }
+        } else if (description.x < 0 || description.y < 0) {
+            throw new DeveloperError('description.x and description.y must be greater than or equal to zero.');
+        }
+
+        if (typeof description.level === 'undefined' || description.zoom < 0) {
+            throw new DeveloperError('description.level is required and must be greater than or equal to zero.');
+        }
+
+        if (typeof description.tilingScheme === 'undefined') {
+            throw new DeveloperError('description.tilingScheme is required.');
+        }
+
+        /**
+         * The tiling scheme used to tile the surface.
+         * @type TilingScheme
+         */
+        this.tilingScheme = description.tilingScheme;
+
+        /**
+         * The x coordinate.
+         * @type Number
+         */
+        this.x = description.x;
+
+        /**
+         * The y coordinate.
+         * @type Number
+         */
+        this.y = description.y;
+
+        /**
+         * The level-of-detail, where zero is the coarsest, least-detailed.
+         * @type Number
+         */
+        this.level = description.level;
+
+        /**
+         * The parent of this tile in a tiling scheme.
+         * @type Tile
+         */
+        this.parent = description.parent;
+
+        /**
+         * The children of this tile in a tiling scheme.
+         * @type Array
+         */
+        this.children = undefined;
+
+        /**
+         * The cartographic extent of the tile, with north, south, east and
+         * west properties in radians.
+         * @type Extent
+         */
+        this.extent = this.tilingScheme.tileXYToExtent(this.x, this.y, this.level);
+
+        /**
+         * The {@link VertexArray} defining the geometry of this tile.  This property
+         * is expected to be set before the tile enter's the {@link TileState.READY}
+         * {@link state}.
+         * @type VertexArray
+         */
+        this.vertexArray = undefined;
+
+        /**
+         * The center of this tile.  The {@link vertexArray} is rendered
+         * relative-to-center (RTC) using this center.  Note that the center of the
+         * {@link boundingSphere3D} is not necessarily the same as this center.
+         * This property is expected to be set before the tile enter's the
+         * {@link TileState.READY} {@link state}.
+         * @type Cartesian3
+         */
+        this.center = undefined;
+
+        /**
+         * The maximum height of terrain in this tile, in meters above the ellipsoid.
+         * @type Number
+         */
+        this.maxHeight = undefined;
+
+        /**
+         * A sphere that completely contains this tile on the globe.  This property may be
+         * undefined until the tile's {@link vertexArray} is loaded.
+         * @type BoundingSphere
+         */
+        this.boundingSphere3D = undefined;
+
+        /**
+         * The current state of the tile in the tile load pipeline.
+         * @type TileState
+         */
+        this.state = TileState.UNLOADED;
+
+        /**
+         * The previous tile in the {@link TileLoadQueue}.
+         * @type Tile
+         */
+        this.loadPrevious = undefined;
+
+        /**
+         * The next tile in the {@link TileLoadQueue}.
+         * @type Tile
+         */
+        this.loadNext = undefined;
+
+        /**
+         * The previous tile in the {@link TileReplacementQueue}.
+         * @type Tile
+         */
+        this.replacementPrevious = undefined;
+
+        /**
+         * The next tile in the {@link TileReplacementQueue}.
+         * @type Tile
+         */
+        this.replacementNext = undefined;
+
+        /**
+         * The {@link TileImagery} attached to this tile.
+         * @type Array
+         */
+        this.imagery = [];
+
+        /**
+         * Transient data stored during the load process.  The exact content
+         * of this property is a function of the tile's current {@link state} and
+         * the {@link TerrainProvider} that is loading the tile.
+         * @type Object
+         */
+        this.transientData = 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.
+         * @type Number
+         */
+        this.distance = 0.0;
+
+        /**
+         * The world coordinates of the southwest corner of the tile's extent.
+         *
+         * @type Cartesian3
+         */
+        this.southwestCornerCartesian = undefined;
+
+        /**
+         * The world coordinates of the northeast corner of the tile's extent.
+         *
+         * @type Cartesian3
+         */
+        this.northeastCornerCartesian = undefined;
+
+        /**
+         * 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
+         */
+        this.westNormal = undefined;
+
+        /**
+         * 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
+         */
+        this.southNormal = undefined;
+
+        /**
+         * 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
+         */
+        this.eastNormal = undefined;
+
+        /**
+         * 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
+         */
+        this.northNormal = undefined;
+
+        /**
+         * A proxy point to use for this tile for horizon culling.  If this point is below the horizon, the
+         * entire tile is below the horizon as well.  The point is expressed in the ellipsoid-scaled
+         * space.  To transform a point from world coordinates centered on the ellipsoid to ellipsoid-scaled
+         * coordinates, multiply the world coordinates by {@link Ellipsoid#getOneOverRadii}.  See
+         * <a href="http://blogs.agi.com/insight3d/index.php/2009/03/25/horizon-culling-2/">http://blogs.agi.com/insight3d/index.php/2009/03/25/horizon-culling-2/</a>
+         * for information the proxy point.
+         *
+         * @type {Cartesian3}
+         */
+        this.occludeePointInScaledSpace = undefined;
+    };
+
+    /**
+     * Returns an array of tiles that would be at the next level of the tile tree.
+     *
+     * @memberof Tile
+     *
+     * @return {Array} The list of child tiles.
+     */
+    Tile.prototype.getChildren = function() {
+        if (typeof this.children === 'undefined') {
+            var tilingScheme = this.tilingScheme;
+            var level = this.level + 1;
+            var x = this.x * 2;
+            var y = this.y * 2;
+            this.children = [new Tile({
+                tilingScheme : tilingScheme,
+                x : x,
+                y : y,
+                level : level,
+                parent : this
+            }), new Tile({
+                tilingScheme : tilingScheme,
+                x : x + 1,
+                y : y,
+                level : level,
+                parent : this
+            }), new Tile({
+                tilingScheme : tilingScheme,
+                x : x,
+                y : y + 1,
+                level : level,
+                parent : this
+            }), new Tile({
+                tilingScheme : tilingScheme,
+                x : x + 1,
+                y : y + 1,
+                level : level,
+                parent : this
+            })];
+        }
+
+        return this.children;
+    };
+
+    Tile.prototype.freeResources = function() {
+        this.state = TileState.UNLOADED;
+        this.doneLoading = false;
+        this.renderable = false;
+
+        if (typeof this.vertexArray !== 'undefined') {
+            var indexBuffer = this.vertexArray.getIndexBuffer();
+
+            this.vertexArray.destroy();
+            this.vertexArray = undefined;
+
+            if (!indexBuffer.isDestroyed() && typeof indexBuffer.referenceCount !== 'undefined') {
+                --indexBuffer.referenceCount;
+                if (indexBuffer.referenceCount === 0) {
+                    indexBuffer.destroy();
+                }
+            }
+        }
+
+        if (typeof this.transientData !== 'undefined' && typeof this.transientData.destroy !== 'undefined') {
+            this.transientData.destroy();
+        }
+        this.transientData = undefined;
+
+        var i, len;
+
+        var imageryList = this.imagery;
+        for (i = 0, len = imageryList.length; i < len; ++i) {
+            imageryList[i].freeResources();
+        }
+        this.imagery.length = 0;
+
+        if (typeof this.children !== 'undefined') {
+            for (i = 0, len = this.children.length; i < len; ++i) {
+                this.children[i].freeResources();
+            }
+        }
+    };
+
+    return Tile;
+});