cesium 1.17.0 → 1.18.0

data/app/assets/javascripts/Cesium/Scene/WebMapServiceImageryProvider.js

@@ -74,7 +74,7 @@ define([
      * @see GoogleEarthImageryProvider
      * @see createOpenStreetMapImageryProvider
      * @see SingleTileImageryProvider
-     * @see TileMapServiceImageryProvider
+     * @see createTileMapServiceImageryProvider
      * @see WebMapTileServiceImageryProvider
      * @see UrlTemplateImageryProvider
      *

data/app/assets/javascripts/Cesium/Scene/WebMapTileServiceImageryProvider.js

@@ -93,7 +93,7 @@ define([
      * @see GoogleEarthImageryProvider
      * @see createOpenStreetMapImageryProvider
      * @see SingleTileImageryProvider
-     * @see TileMapServiceImageryProvider
+     * @see createTileMapServiceImageryProvider
      * @see WebMapServiceImageryProvider
      * @see UrlTemplateImageryProvider
      */

data/app/assets/javascripts/Cesium/Scene/createOpenStreetMapImageryProvider.js

@@ -42,7 +42,7 @@ define([
      * @see BingMapsImageryProvider
      * @see GoogleEarthImageryProvider
      * @see SingleTileImageryProvider
-     * @see TileMapServiceImageryProvider
+     * @see createTileMapServiceImageryProvider
      * @see WebMapServiceImageryProvider
      * @see WebMapTileServiceImageryProvider
      * @see UrlTemplateImageryProvider

data/app/assets/javascripts/Cesium/Scene/createTileMapServiceImageryProvider.js

@@ -0,0 +1,286 @@
+/*global define*/
+define([
+        '../Core/Cartesian2',
+        '../Core/Cartographic',
+        '../Core/Credit',
+        '../Core/defaultValue',
+        '../Core/defined',
+        '../Core/defineProperties',
+        '../Core/DeveloperError',
+        '../Core/Event',
+        '../Core/GeographicTilingScheme',
+        '../Core/joinUrls',
+        '../Core/loadXML',
+        '../Core/Rectangle',
+        '../Core/RuntimeError',
+        '../Core/TileProviderError',
+        '../Core/WebMercatorTilingScheme',
+        '../ThirdParty/when',
+        './UrlTemplateImageryProvider'
+    ], function(
+        Cartesian2,
+        Cartographic,
+        Credit,
+        defaultValue,
+        defined,
+        defineProperties,
+        DeveloperError,
+        Event,
+        GeographicTilingScheme,
+        joinUrls,
+        loadXML,
+        Rectangle,
+        RuntimeError,
+        TileProviderError,
+        WebMercatorTilingScheme,
+        when,
+        UrlTemplateImageryProvider) {
+    "use strict";
+
+    /**
+     * Creates a {@link UrlTemplateImageryProvider} instance that provides tiled imagery as generated by
+     * {@link http://www.maptiler.org/'>MapTiler</a> / <a href='http://www.klokan.cz/projects/gdal2tiles/|GDDAL2Tiles} etc.
+     *
+     * @exports createTileMapServiceImageryProvider
+     *
+     * @param {Object} [options] Object with the following properties:
+     * @param {String} [options.url='.'] Path to image tiles on server.
+     * @param {String} [options.fileExtension='png'] The file extension for images on the server.
+     * @param {Object} [options.proxy] A proxy to use for requests. This object is expected to have a getURL function which returns the proxied URL.
+     * @param {Credit|String} [options.credit=''] A credit for the data source, which is displayed on the canvas.
+     * @param {Number} [options.minimumLevel=0] The minimum level-of-detail supported by the imagery provider.  Take care when specifying
+     *                 this that the number of tiles at the minimum level is small, such as four or less.  A larger number is likely
+     *                 to result in rendering problems.
+     * @param {Number} [options.maximumLevel] The maximum level-of-detail supported by the imagery provider, or undefined if there is no limit.
+     * @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle, in radians, covered by the image.
+     * @param {TilingScheme} [options.tilingScheme] The tiling scheme specifying how the ellipsoidal
+     * surface is broken into tiles.  If this parameter is not provided, a {@link WebMercatorTilingScheme}
+     * is used.
+     * @param {Ellipsoid} [options.ellipsoid] The ellipsoid.  If the tilingScheme is specified,
+     *                    this parameter is ignored and the tiling scheme's ellipsoid is used instead. If neither
+     *                    parameter is specified, the WGS84 ellipsoid is used.
+     * @param {Number} [options.tileWidth=256] Pixel width of image tiles.
+     * @param {Number} [options.tileHeight=256] Pixel height of image tiles.
+     *
+     * @see ArcGisMapServerImageryProvider
+     * @see BingMapsImageryProvider
+     * @see GoogleEarthImageryProvider
+     * @see createOpenStreetMapImageryProvider
+     * @see SingleTileImageryProvider
+     * @see WebMapServiceImageryProvider
+     * @see WebMapTileServiceImageryProvider
+     * @see UrlTemplateImageryProvider
+     *
+     * @see {@link http://www.maptiler.org/|MapTiler}
+     * @see {@link http://www.klokan.cz/projects/gdal2tiles/|GDDAL2Tiles}
+     * @see {@link http://www.w3.org/TR/cors/|Cross-Origin Resource Sharing}
+     *
+     * @example
+     * var tms = Cesium.createTileMapServiceImageryProvider({
+     *    url : '../images/cesium_maptiler/Cesium_Logo_Color',
+     *    fileExtension: 'png',
+     *    maximumLevel: 4,
+     *    rectangle: new Cesium.Rectangle(
+     *        Cesium.Math.toRadians(-120.0),
+     *        Cesium.Math.toRadians(20.0),
+     *        Cesium.Math.toRadians(-60.0),
+     *        Cesium.Math.toRadians(40.0))
+     * });
+     */
+    function createTileMapServiceImageryProvider(options) {
+        options = defaultValue(options, {});
+
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(options.url)) {
+            throw new DeveloperError('options.url is required.');
+        }
+        //>>includeEnd('debug');
+
+        var url = options.url;
+
+        var deferred = when.defer();
+        var imageryProvider = new UrlTemplateImageryProvider(deferred.promise);
+
+        var metadataError;
+
+        function metadataSuccess(xml) {
+            var tileFormatRegex = /tileformat/i;
+            var tileSetRegex = /tileset/i;
+            var tileSetsRegex = /tilesets/i;
+            var bboxRegex = /boundingbox/i;
+            var srsRegex = /srs/i;
+            var format, bbox, tilesets, srs;
+            var tilesetsList = []; //list of TileSets
+
+            // Allowing options properties (already copied to that) to override XML values
+
+            // Iterate XML Document nodes for properties
+            var nodeList = xml.childNodes[0].childNodes;
+            for (var i = 0; i < nodeList.length; i++){
+                if (tileFormatRegex.test(nodeList.item(i).nodeName)) {
+                    format = nodeList.item(i);
+                } else if (tileSetsRegex.test(nodeList.item(i).nodeName)) {
+                    tilesets = nodeList.item(i); // Node list of TileSets
+                    var tileSetNodes = nodeList.item(i).childNodes;
+                    // Iterate the nodes to find all TileSets
+                    for(var j = 0; j < tileSetNodes.length; j++) {
+                        if (tileSetRegex.test(tileSetNodes.item(j).nodeName)) {
+                            // Add them to tilesets list
+                            tilesetsList.push(tileSetNodes.item(j));
+                        }
+                    }
+                } else if (bboxRegex.test(nodeList.item(i).nodeName)) {
+                    bbox = nodeList.item(i);
+                } else if (srsRegex.test(nodeList.item(i).nodeName)) {
+                    srs = nodeList.item(i).textContent;
+                }
+            }
+
+            var fileExtension = defaultValue(options.fileExtension, format.getAttribute('extension'));
+            var tileWidth = defaultValue(options.tileWidth, parseInt(format.getAttribute('width'), 10));
+            var tileHeight = defaultValue(options.tileHeight, parseInt(format.getAttribute('height'), 10));
+            var minimumLevel = defaultValue(options.minimumLevel, parseInt(tilesetsList[0].getAttribute('order'), 10));
+            var maximumLevel = defaultValue(options.maximumLevel, parseInt(tilesetsList[tilesetsList.length - 1].getAttribute('order'), 10));
+
+            // Determine based on the profile attribute if this tileset was generated by gdal2tiles.py ('mercator' or 'geodetic' profile, in which
+            // case X is latitude and Y is longitude) or by a tool compliant with the TMS standard ('global-mercator' or 'global-geodetic' profile,
+            // in which case X is longitude and Y is latitude).
+            var tilingSchemeName = tilesets.getAttribute('profile');
+
+            var flipXY = false;
+            if (tilingSchemeName === 'geodetic' || tilingSchemeName === 'mercator') {
+                flipXY = true;
+            }
+
+            var tilingScheme = options.tilingScheme;
+
+            if (!defined(tilingScheme)) {
+                if (tilingSchemeName === 'geodetic' || tilingSchemeName === 'global-geodetic') {
+                    tilingScheme = new GeographicTilingScheme({ ellipsoid : options.ellipsoid });
+                } else if (tilingSchemeName === 'mercator' || tilingSchemeName === 'global-mercator') {
+                    tilingScheme = new WebMercatorTilingScheme({ ellipsoid : options.ellipsoid });
+                } else {
+                    var message = joinUrls(url, 'tilemapresource.xml') + 'specifies an unsupported profile attribute, ' + tilingSchemeName + '.';
+                    metadataError = TileProviderError.handleError(metadataError, imageryProvider, imageryProvider.errorEvent, message, undefined, undefined, undefined, requestMetadata);
+                    if(!metadataError.retry) {
+                        deferred.reject(new RuntimeError(message));
+                    }
+                    return;
+                }
+            }
+
+            // rectangle handling
+            var rectangle = Rectangle.clone(options.rectangle);
+
+            if (!defined(rectangle)) {
+                var swXY;
+                var neXY;
+                var sw;
+                var ne;
+
+                if (flipXY) {
+                    swXY = new Cartesian2(parseFloat(bbox.getAttribute('miny')), parseFloat(bbox.getAttribute('minx')));
+                    neXY = new Cartesian2(parseFloat(bbox.getAttribute('maxy')), parseFloat(bbox.getAttribute('maxx')));
+
+                    // In old tilers with X/Y flipped, coordinate are always geodetic degrees.
+                    sw = Cartographic.fromDegrees(swXY.x, swXY.y);
+                    ne = Cartographic.fromDegrees(neXY.x, neXY.y);
+                } else {
+                    swXY = new Cartesian2(parseFloat(bbox.getAttribute('minx')), parseFloat(bbox.getAttribute('miny')));
+                    neXY = new Cartesian2(parseFloat(bbox.getAttribute('maxx')), parseFloat(bbox.getAttribute('maxy')));
+
+                    if (tilingScheme instanceof GeographicTilingScheme) {
+                        sw = Cartographic.fromDegrees(swXY.x, swXY.y);
+                        ne = Cartographic.fromDegrees(neXY.x, neXY.y);
+                    } else {
+                        var projection = tilingScheme.projection;
+                        sw = projection.unproject(swXY);
+                        ne = projection.unproject(neXY);
+                    }
+                }
+
+                rectangle = new Rectangle(sw.longitude, sw.latitude, ne.longitude, ne.latitude);
+            }
+
+            // The rectangle must not be outside the bounds allowed by the tiling scheme.
+            if (rectangle.west < tilingScheme.rectangle.west) {
+                rectangle.west = tilingScheme.rectangle.west;
+            }
+            if (rectangle.east > tilingScheme.rectangle.east) {
+                rectangle.east = tilingScheme.rectangle.east;
+            }
+            if (rectangle.south < tilingScheme.rectangle.south) {
+                rectangle.south = tilingScheme.rectangle.south;
+            }
+            if (rectangle.north > tilingScheme.rectangle.north) {
+                rectangle.north = tilingScheme.rectangle.north;
+            }
+
+            // Check the number of tiles at the minimum level.  If it's more than four,
+            // try requesting the lower levels anyway, because starting at the higher minimum
+            // level will cause too many tiles to be downloaded and rendered.
+            var swTile = tilingScheme.positionToTileXY(Rectangle.southwest(rectangle), minimumLevel);
+            var neTile = tilingScheme.positionToTileXY(Rectangle.northeast(rectangle), minimumLevel);
+            var tileCount = (Math.abs(neTile.x - swTile.x) + 1) * (Math.abs(neTile.y - swTile.y) + 1);
+            if (tileCount > 4) {
+                minimumLevel = 0;
+            }
+
+            var templateUrl = joinUrls(url, '{z}/{x}/{reverseY}.' + fileExtension);
+
+            deferred.resolve({
+                url : templateUrl,
+                tilingScheme : tilingScheme,
+                rectangle : rectangle,
+                tileWidth : tileWidth,
+                tileHeight : tileHeight,
+                minimumLevel : minimumLevel,
+                maximumLevel : maximumLevel,
+                proxy : options.proxy,
+                tileDiscardPolicy : options.tileDiscardPolicy,
+                credit: options.credit
+            });
+        }
+
+        function metadataFailure(error) {
+            // Can't load XML, still allow options and defaults
+            var fileExtension = defaultValue(options.fileExtension, 'png');
+            var tileWidth = defaultValue(options.tileWidth, 256);
+            var tileHeight = defaultValue(options.tileHeight, 256);
+            var minimumLevel = defaultValue(options.minimumLevel, 0);
+            var maximumLevel = options.maximumLevel;
+            var tilingScheme = defined(options.tilingScheme) ? options.tilingScheme : new WebMercatorTilingScheme({ ellipsoid : options.ellipsoid });
+            var rectangle = defaultValue(options.rectangle, tilingScheme.rectangle);
+
+            var templateUrl = joinUrls(url, '{z}/{x}/{reverseY}.' + fileExtension);
+
+            deferred.resolve({
+                url : templateUrl,
+                tilingScheme : tilingScheme,
+                rectangle : rectangle,
+                tileWidth : tileWidth,
+                tileHeight : tileHeight,
+                minimumLevel : minimumLevel,
+                maximumLevel : maximumLevel,
+                proxy : options.proxy,
+                tileDiscardPolicy : options.tileDiscardPolicy,
+                credit: options.credit
+            });
+        }
+
+        function requestMetadata() {
+            var resourceUrl = joinUrls(url, 'tilemapresource.xml');
+            var proxy = options.proxy;
+            if (defined(proxy)) {
+                resourceUrl = proxy.getURL(resourceUrl);
+            }
+            // Try to load remaining parameters from XML
+            when(loadXML(resourceUrl), metadataSuccess, metadataFailure);
+        }
+
+        requestMetadata();
+        return imageryProvider;
+    }
+
+    return createTileMapServiceImageryProvider;
+});

data/app/assets/javascripts/Cesium/Scene/modelMaterialsCommon.js

@@ -223,14 +223,16 @@ define([
         var lowerCase;
         var hasTexCoords = false;
         for(var name in parameterValues) {
-            if (parameterValues.hasOwnProperty(name)) {
-                var value = parameterValues[name];
+            //generate shader parameters for KHR_materials_common attributes
+            //(including a check, because some boolean flags should not be used as shader parameters)
+            if (parameterValues.hasOwnProperty(name) && (name !== 'transparent') && (name !== 'doubleSided')) {
+                var valType = getKHRMaterialsCommonValueType(name, parameterValues[name]);
                 lowerCase = name.toLowerCase();
-                if (!hasTexCoords && (value.type === WebGLConstants.SAMPLER_2D)) {
+                if (!hasTexCoords && (valType === WebGLConstants.SAMPLER_2D)) {
                     hasTexCoords = true;
                 }
                 techniqueParameters[lowerCase] = {
-                    type: value.type
+                    type: valType
                 };
             }
         }
@@ -609,18 +611,54 @@ define([
         return techniqueId;
     }
 
+    function getKHRMaterialsCommonValueType(paramName, paramValue)
+    {
+        var value;
+
+        // Backwards compatibility for COLLADA2GLTF v1.0-draft when it encoding
+        // materials using KHR_materials_common with explicit type/value members
+        if (defined(paramValue.value)) {
+            value = paramValue.value;
+        } else {
+            value = paramValue;
+        }
+     
+        switch (paramName)  {
+            case 'ambient':
+                return (value instanceof String || typeof value === 'string') ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
+            case 'diffuse':
+                return (value instanceof String || typeof value === 'string') ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
+            case 'emission':
+                return (value instanceof String || typeof value === 'string') ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
+            case 'specular':
+                return (value instanceof String || typeof value === 'string') ? WebGLConstants.SAMPLER_2D : WebGLConstants.FLOAT_VEC4;
+            case 'shininess':
+                return WebGLConstants.FLOAT;
+            case 'transparency':
+                return WebGLConstants.FLOAT;
+                
+            // these two are usually not used directly within shaders,
+            // they are just added here for completeness
+            case 'transparent':
+                return WebGLConstants.BOOL;                
+            case 'doubleSided':
+                return WebGLConstants.BOOL;                
+        }
+    }
+
     function getTechniqueKey(khrMaterialsCommon) {
         var techniqueKey = '';
-         techniqueKey += 'technique:' + khrMaterialsCommon.technique + ';';
+        techniqueKey += 'technique:' + khrMaterialsCommon.technique + ';';
 
         var values = khrMaterialsCommon.values;
         var keys = Object.keys(values).sort();
         var keysCount = keys.length;
         for (var i=0;i<keysCount;++i) {
             var name = keys[i];
-            if (values.hasOwnProperty(name)) {
-                var value = values[name];
-                techniqueKey += name + ':' + value.type.toString();
+            //generate first part of key using shader parameters for KHR_materials_common attributes
+            //(including a check, because some boolean flags should not be used as shader parameters)
+            if (values.hasOwnProperty(name) && (name !== 'transparent') && (name !== 'doubleSided')) {
+                techniqueKey += name + ':' + getKHRMaterialsCommonValueType(name, values[name]);
                 techniqueKey += ';';
             }
         }
@@ -692,7 +730,14 @@ define([
                         for (var valueName in values) {
                             if (values.hasOwnProperty(valueName)) {
                                 var value = values[valueName];
-                                material.values[valueName] = value.value;
+
+                                // Backwards compatibility for COLLADA2GLTF v1.0-draft when it encoding
+                                // materials using KHR_materials_common with explicit type/value members
+                                if (defined(value.value)) {
+                                    material.values[valueName] = value.value;
+                                } else {
+                                    material.values[valueName] = value;
+                                }
                             }
                         }
 

data/app/assets/javascripts/Cesium/Widgets/BaseLayerPicker/BaseLayerPicker.js

@@ -72,7 +72,7 @@ define([
      *      tooltip : 'The lights of cities and villages trace the outlines of civilization \
      * in this global view of the Earth at night as seen by NASA/NOAA\'s Suomi NPP satellite.',
      *      creationFunction : function() {
-     *          return new Cesium.TileMapServiceImageryProvider({
+     *          return Cesium.createTileMapServiceImageryProvider({
      *              url : '//cesiumjs.org/blackmarble',
      *              maximumLevel : 8,
      *              credit : 'Black Marble imagery courtesy NASA Earth Observatory'
@@ -85,7 +85,7 @@ define([
      *      iconUrl : Cesium.buildModuleUrl('Widgets/Images/ImageryProviders/naturalEarthII.png'),
      *      tooltip : 'Natural Earth II, darkened for contrast.\nhttp://www.naturalearthdata.com/',
      *      creationFunction : function() {
-     *          return new Cesium.TileMapServiceImageryProvider({
+     *          return Cesium.createTileMapServiceImageryProvider({
      *              url : Cesium.buildModuleUrl('Assets/Textures/NaturalEarthII')
      *          });
      *      }

data/app/assets/javascripts/Cesium/Widgets/BaseLayerPicker/createDefaultImageryProviderViewModels.js

@@ -5,8 +5,8 @@ define([
         '../../Scene/BingMapsImageryProvider',
         '../../Scene/BingMapsStyle',
         '../../Scene/createOpenStreetMapImageryProvider',
+        '../../Scene/createTileMapServiceImageryProvider',
         '../../Scene/MapboxImageryProvider',
-        '../../Scene/TileMapServiceImageryProvider',
         '../BaseLayerPicker/ProviderViewModel'
     ], function(
         buildModuleUrl,
@@ -14,8 +14,8 @@ define([
         BingMapsImageryProvider,
         BingMapsStyle,
         createOpenStreetMapImageryProvider,
+        createTileMapServiceImageryProvider,
         MapboxImageryProvider,
-        TileMapServiceImageryProvider,
         ProviderViewModel) {
     "use strict";
 
@@ -198,7 +198,7 @@ map of the world.\nhttp://www.openstreetmap.org',
             tooltip : 'The lights of cities and villages trace the outlines of civilization in this global view of the \
 Earth at night as seen by NASA/NOAA\'s Suomi NPP satellite.',
             creationFunction : function() {
-                return new TileMapServiceImageryProvider({
+                return createTileMapServiceImageryProvider({
                     url : '//cesiumjs.org/blackmarble',
                     maximumLevel : 8,
                     credit : 'Black Marble imagery courtesy NASA Earth Observatory'
@@ -211,7 +211,7 @@ Earth at night as seen by NASA/NOAA\'s Suomi NPP satellite.',
             iconUrl : buildModuleUrl('Widgets/Images/ImageryProviders/naturalEarthII.png'),
             tooltip : 'Natural Earth II, darkened for contrast.\nhttp://www.naturalearthdata.com/',
             creationFunction : function() {
-                return new TileMapServiceImageryProvider({
+                return createTileMapServiceImageryProvider({
                     url : buildModuleUrl('Assets/Textures/NaturalEarthII')
                 });
             }