cesium 0.13.0

data/app/assets/javascripts/Renderer/VertexLayout.js

@@ -0,0 +1,49 @@
+/*global define*/
+define(['../Core/Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * Determines if vertex attributes are interleaved in a single vertex buffer or if each attribute is stored in a separate vertex buffer.
+     *
+     * @exports VertexLayout
+     *
+     * @see Context#createVertexArrayFromMesh
+     */
+    var VertexLayout = {
+        /**
+         * Each attribute will be stored in a separate vertex buffer.  This can be slightly slower
+         * than using a single interleaved vertex buffer, but it is more flexible; more easily allowing
+         * the sharing of vertex buffers among vertex arrays.  It also requires much less initial CPU
+         * processing than interleaving.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SEPARATE : new Enumeration(0, 'SEPARATE'),
+        /**
+         * Each attribute will be interleaved in a single vertex buffer.  This can have a slight
+         * performance advantage over using a separate vertex buffer per attribute, but it requires
+         * extra CPU processing to initially interleave the vertex data.  This is recommended for
+         * static data that will be rendered over several frames.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        INTERLEAVED : new Enumeration(1, 'INTERLEAVED'),
+
+        /**
+         * DOC_TBA
+         *
+         * @param vertexLayout
+         *
+         * @returns {Boolean}
+         */
+        validate : function(vertexLayout) {
+            return ((vertexLayout === VertexLayout.SEPARATE) ||
+                    (vertexLayout === VertexLayout.INTERLEAVED));
+        }
+
+    };
+
+    return VertexLayout;
+});

data/app/assets/javascripts/Renderer/loadCubeMap.js

@@ -0,0 +1,92 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/loadImage',
+        '../ThirdParty/when'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        loadImage,
+        when) {
+    "use strict";
+
+    /**
+     * Asynchronously loads six images and creates a cube map.  Returns a promise that
+     * will resolve to a {@link CubeMap} once loaded, or reject if any image fails to load.
+     *
+     * @exports loadCubeMap
+     *
+     * @param {Context} context The context to use to create the cube map.
+     * @param {Object} urls The source of each image, or a promise for each URL.  See the example below.
+     * @param {Boolean} [crossOrigin=true] Whether to request images using Cross-Origin
+     *        Resource Sharing (CORS).  Data URIs are never requested using CORS.
+     *
+     * @returns {Promise} a promise that will resolve to the requested {@link CubeMap} when loaded.
+     *
+     * @exception {DeveloperError} context is required.
+     * @exception {DeveloperError} urls is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties.
+     *
+     * @example
+     * loadCubeMap(context, {
+     *     positiveX : 'skybox_px.png',
+     *     negativeX : 'skybox_nx.png',
+     *     positiveY : 'skybox_py.png',
+     *     negativeY : 'skybox_ny.png',
+     *     positiveZ : 'skybox_pz.png',
+     *     negativeZ : 'skybox_nz.png'
+     * }).then(function(cubeMap) {
+     *     // use the cubemap
+     * }, function() {
+     *     // an error occurred
+     * });
+     *
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     */
+    var loadCubeMap = function(context, urls, crossOrigin) {
+        if (typeof context === 'undefined') {
+            throw new DeveloperError('context is required.');
+        }
+
+        if ((typeof urls === 'undefined') ||
+            (typeof urls.positiveX === 'undefined') ||
+            (typeof urls.negativeX === 'undefined') ||
+            (typeof urls.positiveY === 'undefined') ||
+            (typeof urls.negativeY === 'undefined') ||
+            (typeof urls.positiveZ === 'undefined') ||
+            (typeof urls.negativeZ === 'undefined')) {
+            throw new DeveloperError('urls is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties.');
+        }
+
+        // PERFORMANCE_IDEA: Given the size of some cube maps, we should consider tiling them, which
+        // would prevent hiccups when uploading, for example, six 4096x4096 textures to the GPU.
+        //
+        // Also, it is perhaps acceptable to use the context here in the callbacks, but
+        // ideally, we would do it in the primitive's update function.
+
+        var facePromises = [
+            loadImage(urls.positiveX, crossOrigin),
+            loadImage(urls.negativeX, crossOrigin),
+            loadImage(urls.positiveY, crossOrigin),
+            loadImage(urls.negativeY, crossOrigin),
+            loadImage(urls.positiveZ, crossOrigin),
+            loadImage(urls.negativeZ, crossOrigin)
+        ];
+
+        return when.all(facePromises, function(images) {
+            return context.createCubeMap({
+                source : {
+                    positiveX : images[0],
+                    negativeX : images[1],
+                    positiveY : images[2],
+                    negativeY : images[3],
+                    positiveZ : images[4],
+                    negativeZ : images[5]
+                }
+            });
+        });
+    };
+
+    return loadCubeMap;
+});

data/app/assets/javascripts/Renderer/package.json

@@ -0,0 +1,6 @@
+{
+	"name": "Renderer",
+	"description": "Cesium Renderer",
+	"version": "0.6.0",
+	"dojoBuild": "Renderer.profile.js"
+}

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

@@ -0,0 +1,249 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/clone',
+        '../ThirdParty/Tween'
+    ], function(
+        DeveloperError,
+        clone,
+        Tween) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @alias AnimationCollection
+     * @constructor
+     */
+    var AnimationCollection = function() {
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof AnimationCollection
+     *
+     * @exception {DeveloperError} duration is required.
+     */
+    AnimationCollection.prototype.add = function(template) {
+        var t = template || {};
+
+        if (typeof t.duration === 'undefined') {
+            throw new DeveloperError('duration is required.');
+        }
+
+        t.delayDuration = (typeof t.delayDuration === 'undefined') ? 0 : t.delayDuration;
+        t.easingFunction = (typeof t.easingFunction === 'undefined') ? Tween.Easing.Linear.None : t.easingFunction;
+
+        var value = clone(t.startValue);
+        var tween = new Tween.Tween(value);
+        tween.to(t.stopValue, t.duration);
+        tween.delay(t.delayDuration);
+        tween.easing(t.easingFunction);
+        if (t.onUpdate) {
+            tween.onUpdate(function() {
+                t.onUpdate(value);
+            });
+        }
+        tween.onComplete(t.onComplete || null);
+        tween.start();
+
+        return {
+            _tween : tween
+        };
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof AnimationCollection
+     *
+     * @exception {DeveloperError} material is required.
+     * @exception {DeveloperError} material has no properties with alpha components.
+     */
+    AnimationCollection.prototype.addAlpha = function(material, start, stop, template) {
+        if (typeof material === 'undefined') {
+            throw new DeveloperError('material is required.');
+        }
+
+        var properties = [];
+
+        for ( var property in material.uniforms) {
+            if (material.uniforms.hasOwnProperty(property) &&
+                typeof material.uniforms[property] !== 'undefined' &&
+                typeof material.uniforms[property].alpha !== 'undefined') {
+                properties.push(property);
+            }
+        }
+
+        if (properties.length === 0) {
+            throw new DeveloperError('material has no properties with alpha components.');
+        }
+
+        // Default to fade in
+        start = (typeof start === 'undefined') ? 0.0 : start;
+        stop = (typeof stop === 'undefined') ? 1.0 : stop;
+
+        var t = template || {};
+        t.duration = (typeof t.duration === 'undefined') ? 3000 : t.duration;
+        t.delayDuration = (typeof t.delayDuration === 'undefined') ? 0 : t.delayDuration;
+        t.easingFunction = (typeof t.easingFunction === 'undefined') ? Tween.Easing.Linear.None : t.easingFunction;
+
+        var value = {
+            alpha : start
+        };
+        var tween = new Tween.Tween(value);
+        tween.to({
+            alpha : stop
+        }, t.duration);
+        tween.delay(t.delayDuration);
+        tween.easing(t.easingFunction);
+        tween.onUpdate(function() {
+            var length = properties.length;
+            for ( var i = 0; i < length; ++i) {
+                material.uniforms[properties[i]].alpha = value.alpha;
+            }
+        });
+        tween.onComplete(t.onComplete || null);
+        tween.start();
+
+        return {
+            _tween : tween
+        };
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof AnimationCollection
+     *
+     * @exception {DeveloperError} object is required.
+     * @exception {DeveloperError} property is required.
+     * @exception {DeveloperError} pbject must have the specified property.
+     */
+    AnimationCollection.prototype.addProperty = function(object, property, start, stop, template) {
+        if (typeof object === 'undefined') {
+            throw new DeveloperError('object is required.');
+        }
+
+        if (typeof property === 'undefined') {
+            throw new DeveloperError('property is required.');
+        }
+
+        if (typeof object[property] === 'undefined') {
+            throw new DeveloperError('object must have the specified property.');
+        }
+
+        var t = template || {};
+        t.duration = (typeof t.duration === 'undefined') ? 3000 : t.duration;
+        t.delayDuration = (typeof t.delayDuration === 'undefined') ? 0 : t.delayDuration;
+        t.easingFunction = (typeof t.easingFunction === 'undefined') ? Tween.Easing.Linear.None : t.easingFunction;
+
+        var value = {
+            value : start
+        };
+        var tween = new Tween.Tween(value);
+        tween.to({
+            value : stop
+        }, t.duration);
+        tween.delay(t.delayDuration);
+        tween.easing(t.easingFunction);
+        tween.onUpdate(function() {
+            object[property] = value.value;
+        });
+        tween.onComplete(t.onComplete || null);
+        tween.start();
+
+        return {
+            _tween : tween
+        };
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof AnimationCollection
+     *
+     * @exception {DeveloperError} material is required.
+     * @exception {DeveloperError} material must have an offset property.
+     */
+    AnimationCollection.prototype.addOffsetIncrement = function(material, template) {
+        if (typeof material === 'undefined') {
+            throw new DeveloperError('material is required.');
+        }
+
+        if (typeof material.uniforms.offset === 'undefined') {
+            throw new DeveloperError('material must have an offset property.');
+        }
+
+        var t = template || {};
+        t.duration = (typeof t.duration === 'undefined') ? 3000 : t.duration;
+        t.delayDuration = (typeof t.delayDuration === 'undefined') ? 0 : t.delayDuration;
+        t.easingFunction = (typeof t.easingFunction === 'undefined') ? Tween.Easing.Linear.None : t.easingFunction;
+
+        var value = {
+            offset : material.uniforms.offset
+        };
+        var tween = new Tween.Tween(value);
+        tween.to({
+            offset : material.uniforms.offset + 1.0
+        }, t.duration);
+        tween.delay(t.delayDuration);
+        tween.easing(t.easingFunction);
+        tween.onUpdate(function() {
+            material.uniforms.offset = value.offset;
+        });
+        // t.onComplete is ignored.
+        tween.onComplete(function() {
+            tween.to({
+                offset : material.uniforms.offset + 1.0
+            }, t.duration);
+            tween.start();
+        });
+        tween.start();
+
+        return {
+            _tween : tween
+        };
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof AnimationCollection
+     */
+    AnimationCollection.prototype.remove = function(animation) {
+        if (typeof animation !== 'undefined') {
+            var count = Tween.getAll().length;
+            Tween.remove(animation._tween);
+
+            return Tween.getAll().length === (count - 1);
+        }
+
+        return false;
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof AnimationCollection
+     */
+    AnimationCollection.prototype.removeAll = function() {
+        Tween.removeAll();
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof Animationcollection
+     */
+    AnimationCollection.prototype.contains = function(animation) {
+        if (typeof animation !== 'undefined') {
+            return Tween.getAll().indexOf(animation._tween) !== -1;
+        }
+        return false;
+    };
+
+    /**
+     * DOC_TBA
+     * @memberof AnimationCollection
+     */
+    AnimationCollection.prototype.update = function() {
+        Tween.update();
+    };
+
+    return AnimationCollection;
+});

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

@@ -0,0 +1,384 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/jsonp',
+        '../Core/writeTextToCanvas',
+        '../Core/Cartesian2',
+        '../Core/DeveloperError',
+        '../Core/Event',
+        '../Core/RuntimeError',
+        './DiscardMissingTileImagePolicy',
+        './GeographicTilingScheme',
+        './ImageryProvider',
+        './ImageryProviderError',
+        './WebMercatorTilingScheme',
+        '../ThirdParty/when'
+    ], function(
+        defaultValue,
+        jsonp,
+        writeTextToCanvas,
+        Cartesian2,
+        DeveloperError,
+        Event,
+        RuntimeError,
+        DiscardMissingTileImagePolicy,
+        GeographicTilingScheme,
+        ImageryProvider,
+        ImageryProviderError,
+        WebMercatorTilingScheme,
+        when) {
+    "use strict";
+
+    /**
+     * Provides tiled imagery hosted by an ArcGIS MapServer.  By default, the server's pre-cached tiles are
+     * used, if available.
+     *
+     * @alias ArcGisMapServerImageryProvider
+     * @constructor
+     *
+     * @param {String} description.url The URL of the ArcGIS MapServer service.
+     * @param {TileDiscardPolicy} [description.tileDiscardPolicy] The policy that determines if a tile
+     *        is invalid and should be discarded.  If this value is not specified, a default
+     *        {@link DiscardMissingTileImagePolicy} is used for tiled map servers, and a
+     *        {@link NeverTileDiscardPolicy} is used for non-tiled map servers.  In the former case,
+     *        we request tile 0,0 at the maximum tile level and check pixels (0,0), (200,20), (20,200),
+     *        (80,110), and (160, 130).  If all of these pixels are transparent, the discard check is
+     *        disabled and no tiles are discarded.  If any of them have a non-transparent color, any
+     *        tile that has the same values in these pixel locations is discarded.  The end result of
+     *        these defaults should be correct tile discarding for a standard ArcGIS Server.  To ensure
+     *        that no tiles are discarded, construct and pass a {@link NeverTileDiscardPolicy} for this
+     *        parameter.
+     * @param {Proxy} [description.proxy] A proxy to use for requests. This object is
+     *        expected to have a getURL function which returns the proxied URL, if needed.
+     * @param {Boolean} [description.usePreCachedTilesIfAvailable=true] If true, the server's pre-cached
+     *        tiles are used if they are available.  If false, any pre-cached tiles are ignored and the
+     *        'export' service is used.
+     *
+     * @exception {DeveloperError} <code>description.url</code> is required.
+     *
+     * @see BingMapsImageryProvider
+     * @see OpenStreetMapImageryProvider
+     * @see SingleTileImageryProvider
+     * @see TileMapServiceImageryProvider
+     * @see WebMapServiceImageryProvider
+     *
+     * @see <a href='http://resources.esri.com/help/9.3/arcgisserver/apis/rest/'>ArcGIS Server REST API</a>
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     *
+     * @example
+     * var esri = new ArcGisMapServerImageryProvider({
+     *     url: 'http://services.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer'
+     * });
+     */
+    var ArcGisMapServerImageryProvider = function ArcGisMapServerImageryProvider(description) {
+        description = defaultValue(description, {});
+
+        if (typeof description.url === 'undefined') {
+            throw new DeveloperError('description.url is required.');
+        }
+
+        this._url = description.url;
+        this._tileDiscardPolicy = description.tileDiscardPolicy;
+        this._proxy = description.proxy;
+
+        this._tileWidth = undefined;
+        this._tileHeight = undefined;
+        this._maximumLevel = undefined;
+        this._tilingScheme = undefined;
+        this._logo = undefined;
+        this._useTiles = defaultValue(description.usePreCachedTilesIfAvailable, true);
+
+        this._errorEvent = new Event();
+
+        this._ready = false;
+
+        // Grab the details of this MapServer.
+        var that = this;
+        var metadataError;
+
+        function metadataSuccess(data) {
+            var tileInfo = data.tileInfo;
+            if (!that._useTiles || typeof tileInfo === 'undefined') {
+                that._tileWidth = 256;
+                that._tileHeight = 256;
+                that._tilingScheme = new GeographicTilingScheme();
+                that._useTiles = false;
+            } else {
+                that._tileWidth = tileInfo.rows;
+                that._tileHeight = tileInfo.cols;
+
+                if (tileInfo.spatialReference.wkid === 102100) {
+                    that._tilingScheme = new WebMercatorTilingScheme();
+                } else if (data.tileInfo.spatialReference.wkid === 4326) {
+                    that._tilingScheme = new GeographicTilingScheme();
+                } else {
+                    var message = 'Tile spatial reference WKID ' + data.tileInfo.spatialReference.wkid + ' is not supported.';
+                    metadataError = ImageryProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
+                    return;
+                }
+                that._maximumLevel = data.tileInfo.lods.length - 1;
+
+                // Install the default tile discard policy if none has been supplied.
+                if (typeof that._tileDiscardPolicy === 'undefined') {
+                    that._tileDiscardPolicy = new DiscardMissingTileImagePolicy({
+                        missingImageUrl : buildImageUrl(that, 0, 0, that._maximumLevel),
+                        pixelsToCheck : [new Cartesian2(0, 0), new Cartesian2(200, 20), new Cartesian2(20, 200), new Cartesian2(80, 110), new Cartesian2(160, 130)],
+                        disableCheckIfAllPixelsAreTransparent : true
+                    });
+                }
+
+                that._useTiles = true;
+            }
+
+            if (typeof data.copyrightText !== 'undefined' && data.copyrightText.length > 0) {
+                that._logo = writeTextToCanvas(data.copyrightText, {
+                    font : '12px sans-serif'
+                });
+            }
+
+            that._ready = true;
+            ImageryProviderError.handleSuccess(metadataError);
+        }
+
+        function metadataFailure(e) {
+            var message = 'An error occurred while accessing ' + that._url + '.';
+            metadataError = ImageryProviderError.handleError(metadataError, that, that._errorEvent, message, undefined, undefined, undefined, requestMetadata);
+        }
+
+        function requestMetadata() {
+            var metadata = jsonp(that._url, {
+                parameters : {
+                    f : 'json'
+                },
+                proxy : that._proxy
+            });
+            when(metadata, metadataSuccess, metadataFailure);
+        }
+
+        requestMetadata();
+    };
+
+    function buildImageUrl(imageryProvider, x, y, level) {
+        var url;
+        if (imageryProvider._useTiles) {
+            url = imageryProvider._url + '/tile/' + level + '/' + y + '/' + x;
+        } else {
+            var nativeExtent = imageryProvider._tilingScheme.tileXYToNativeExtent(x, y, level);
+            var bbox = nativeExtent.west + '%2C' + nativeExtent.south + '%2C' + nativeExtent.east + '%2C' + nativeExtent.north;
+
+            url = imageryProvider._url + '/export?';
+            url += 'bbox=' + bbox;
+            url += '&bboxSR=4326&size=256%2C256&imageSR=4326&format=png&transparent=true&f=image';
+        }
+
+        var proxy = imageryProvider._proxy;
+        if (typeof proxy !== 'undefined') {
+            url = proxy.getURL(url);
+        }
+
+        return url;
+    }
+
+    /**
+     * Gets a value indicating whether this imagery provider is using pre-cached tiles from the
+     * ArcGIS MapServer.  If the imagery provider is not yet ready ({@link ArcGisMapServerImageryProvider#isReady}), this function
+     * will return the value of `description.usePreCachedTilesIfAvailable`, even if the MapServer does
+     * not have pre-cached tiles.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Boolean} true if this imagery provider is using pre-cached tiles from the ArcGIS MapServer;
+     *          otherwise, false.
+     */
+    ArcGisMapServerImageryProvider.prototype.isUsingPrecachedTiles = function() {
+        return this._useTiles;
+    };
+
+    /**
+     * Gets the URL of the ArcGIS MapServer.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {String} The URL.
+     */
+    ArcGisMapServerImageryProvider.prototype.getUrl = function() {
+        return this._url;
+    };
+
+    /**
+     * Gets the width of each tile, in pixels. This function should
+     * not be called before {@link ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Number} The width.
+     *
+     * @exception {DeveloperError} <code>getTileWidth</code> must not be called before the imagery provider is ready.
+     */
+    ArcGisMapServerImageryProvider.prototype.getTileWidth = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTileWidth 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 ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Number} The height.
+     *
+     * @exception {DeveloperError} <code>getTileHeight</code> must not be called before the imagery provider is ready.
+     */
+    ArcGisMapServerImageryProvider.prototype.getTileHeight = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTileHeight 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 ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Number} The maximum level, or undefined if there is no maximum level.
+     *
+     * @exception {DeveloperError} <code>getMaximumLevel</code> must not be called before the imagery provider is ready.
+     */
+    ArcGisMapServerImageryProvider.prototype.getMaximumLevel = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getMaximumLevel must not be called before the imagery provider is ready.');
+        }
+        return this._maximumLevel;
+    };
+
+    /**
+     * Gets the tiling scheme used by this provider.  This function should
+     * not be called before {@link ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {TilingScheme} The tiling scheme.
+     * @see WebMercatorTilingScheme
+     * @see GeographicTilingScheme
+     *
+     * @exception {DeveloperError} <code>getTilingScheme</code> must not be called before the imagery provider is ready.
+     */
+    ArcGisMapServerImageryProvider.prototype.getTilingScheme = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTilingScheme must not be called before the imagery provider is ready.');
+        }
+        return this._tilingScheme;
+    };
+
+    /**
+     * Gets the extent, in radians, of the imagery provided by this instance.  This function should
+     * not be called before {@link ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Extent} The extent.
+     *
+     * @exception {DeveloperError} <code>getExtent</code> must not be called before the imagery provider is ready.
+     */
+    ArcGisMapServerImageryProvider.prototype.getExtent = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getExtent must not be called before the imagery provider is ready.');
+        }
+        return this._tilingScheme.getExtent();
+    };
+
+    /**
+     * 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 ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {TileDiscardPolicy} The discard policy.
+     *
+     * @see DiscardMissingTileImagePolicy
+     * @see NeverTileDiscardPolicy
+     *
+     * @exception {DeveloperError} <code>getTileDiscardPolicy</code> must not be called before the imagery provider is ready.
+     */
+    ArcGisMapServerImageryProvider.prototype.getTileDiscardPolicy = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTileDiscardPolicy 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 ImageryProviderError}.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Event} The event.
+     */
+    ArcGisMapServerImageryProvider.prototype.getErrorEvent = function() {
+        return this._errorEvent;
+    };
+
+    /**
+     * Gets a value indicating whether or not the provider is ready for use.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Boolean} True if the provider is ready to use; otherwise, false.
+     */
+    ArcGisMapServerImageryProvider.prototype.isReady = function() {
+        return this._ready;
+    };
+
+    /**
+     * Requests the image for a given tile.  This function should
+     * not be called before {@link ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @param {Number} x The tile X coordinate.
+     * @param {Number} y The tile Y coordinate.
+     * @param {Number} level The tile level.
+     *
+     * @returns {Promise} 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.
+     */
+    ArcGisMapServerImageryProvider.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(url);
+    };
+
+    /**
+     * Gets the logo 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 ArcGisMapServerImageryProvider#isReady} returns true.
+     *
+     * @memberof ArcGisMapServerImageryProvider
+     *
+     * @returns {Image|Canvas} A canvas or image containing the log to display, or undefined if there is no logo.
+     *
+     * @exception {DeveloperError} <code>getLogo</code> must not be called before the imagery provider is ready.
+     */
+    ArcGisMapServerImageryProvider.prototype.getLogo = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getLogo must not be called before the imagery provider is ready.');
+        }
+        return this._logo;
+    };
+
+    return ArcGisMapServerImageryProvider;
+});