cesium 0.15.0 → 0.16.0

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

@@ -20,12 +20,45 @@ define([
         this._shadersToRelease = {};
     };
 
+    /**
+     * Returns a shader program from the cache, or creates and caches a new shader program,
+     * given the GLSL vertex and fragment shader source and attribute locations.
+     * <p>
+     * The difference between this and {@link ShaderCache#getShaderProgram}, is this is used to
+     * replace an existing reference to a shader program, which is passed as the first argument.
+     * </p>
+     *
+     * @memberof ShaderCache
+     *
+     * @param {ShaderProgram} shaderProgram The shader program that is being reassigned.  This can be <code>undefined</code>.
+     * @param {String} vertexShaderSource The GLSL source for the vertex shader.
+     * @param {String} fragmentShaderSource The GLSL source for the fragment shader.
+     * @param {Object} attributeLocations Indices for the attribute inputs to the vertex shader.
+     *
+     * @returns {ShaderProgram} The cached or newly created shader program.
+     *
+     * @see ShaderCache#getShaderProgram
+     *
+     * @example
+     * this._shaderProgram = context.getShaderCache().replaceShaderProgram(
+     *     this._shaderProgram, vs, fs, attributeLocations);
+     */
+    ShaderCache.prototype.replaceShaderProgram = function(shaderProgram, vertexShaderSource, fragmentShaderSource, attributeLocations) {
+        if (typeof shaderProgram !== 'undefined') {
+            shaderProgram.release();
+        }
+
+        return this.getShaderProgram(vertexShaderSource, fragmentShaderSource, attributeLocations);
+    };
+
     /**
      * DOC_TBA
      *
      * @memberof ShaderCache
      *
      * @returns {ShaderProgram} DOC_TBA.
+     *
+     * @see ShaderCache#replaceShaderProgram
      */
     ShaderCache.prototype.getShaderProgram = function(vertexShaderSource, fragmentShaderSource, attributeLocations) {
         // TODO: compare attributeLocations!
@@ -90,7 +123,7 @@ define([
             }
         }
 
-        return null;
+        return undefined;
     };
 
     /**

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

@@ -1191,7 +1191,7 @@ define([
         /**
          * An automatic GLSL uniform containing the near distance (<code>x</code>) and the far distance (<code>y</code>)
          * of the frustum defined by the camera.  This is the largest possible frustum, not an individual
-         * frustum used for mult-frustum rendering.
+         * frustum used for multi-frustum rendering.
          * <br /><br />
          * Like all automatic uniforms, <code>czm_entireFrustum</code> does not need to be explicitly declared.
          * However, it can be explicitly declared when a shader is also used by other applications such
@@ -1201,6 +1201,7 @@ define([
          * @glslUniform
          *
          * @see UniformState#getEntireFrustum
+         * @see czm_currentFrustum
          *
          * @example
          * // GLSL declaration
@@ -1223,6 +1224,74 @@ define([
             }
         },
 
+        /**
+         * An automatic GLSL uniform containing the near distance (<code>x</code>) and the far distance (<code>y</code>)
+         * of the frustum defined by the camera.  This is the individual
+         * frustum used for multi-frustum rendering.
+         * <br /><br />
+         * Like all automatic uniforms, <code>czm_currentFrustum</code> does not need to be explicitly declared.
+         * However, it can be explicitly declared when a shader is also used by other applications such
+         * as a third-party authoring tool.
+         *
+         * @alias czm_currentFrustum
+         * @glslUniform
+         *
+         * @see UniformState#getCurrentFrustum
+         * @see czm_entireFrustum
+         *
+         * @example
+         * // GLSL declaration
+         * uniform vec2 czm_currentFrustum;
+         *
+         * // Example
+         * float frustumLength = czm_currentFrustum.y - czm_currentFrustum.x;
+         */
+        czm_currentFrustum : {
+            getSize : function() {
+                return 1;
+            },
+
+            getDatatype : function() {
+                return UniformDatatype.FLOAT_VECTOR2;
+            },
+
+            getValue : function(uniformState) {
+                return uniformState.getCurrentFrustum();
+            }
+        },
+
+        /**
+         * An automatic GLSL uniform representing the size of a pixel in meters at a distance of one meter
+         * from the camera. The pixel size is linearly proportional to the distance from the camera.
+         * <br /><br />
+         * Like all automatic uniforms, <code>czm_pixelSizeInMeters</code> does not need to be explicitly declared.
+         * However, it can be explicitly declared when a shader is also used by other applications such
+         * as a third-party authoring tool.
+         *
+         * @alias czm_pixelSizeInMeters
+         * @glslUniform
+         *
+         * @example
+         * // GLSL declaration
+         * uniform float czm_pixelSizeInMeters;
+         *
+         * // Example: the pixel size at a position in eye coordinates
+         * float pixelSize = czm_pixelSizeInMeters * positionEC.z;
+         */
+        czm_pixelSizeInMeters : {
+            getSize : function() {
+                return 1;
+            },
+
+            getDatatype : function() {
+                return UniformDatatype.FLOAT;
+            },
+
+            getValue : function(uniformState) {
+                return uniformState.getPixelSize();
+            }
+        },
+
         /**
          * An automatic GLSL uniform representing the normalized direction to the sun in eye coordinates.
          * This is commonly used for directional lighting computations.
@@ -1447,7 +1516,39 @@ define([
             },
 
             getValue : function(uniformState) {
-                return uniformState.getFrameNumber();
+                return uniformState.getFrameState().frameNumber;
+            }
+        },
+
+        /**
+         * An automatic GLSL uniform representing the current morph transition time between
+         * 2D/Columbus View and 3D, with 0.0 being 2D or Columbus View and 1.0 being 3D.
+         * <br /><br />
+         * Like all automatic uniforms, <code>czm_morphTime</code> does not need to be explicitly declared.
+         * However, it can be explicitly declared when a shader is also used by other applications such
+         * as a third-party authoring tool.
+         *
+         * @alias czm_morphTime
+         * @glslUniform
+         *
+         * @example
+         * // GLSL declaration
+         * uniform float czm_morphTime;
+         *
+         * // Example
+         * vec4 p = czm_columbusViewMorph(position2D, position3D, czm_morphTime);
+         */
+        czm_morphTime : {
+            getSize : function() {
+                return 1;
+            },
+
+            getDatatype : function() {
+                return UniformDatatype.FLOAT;
+            },
+
+            getValue : function(uniformState) {
+                return uniformState.getFrameState().morphTime;
             }
         },
 
@@ -1562,9 +1663,14 @@ define([
         }
     }
 
-    var scratchUniformMatrix2 = (typeof Float32Array !== 'undefined') ? new Float32Array(4) : undefined;
-    var scratchUniformMatrix3 = (typeof Float32Array !== 'undefined') ? new Float32Array(9) : undefined;
-    var scratchUniformMatrix4 = (typeof Float32Array !== 'undefined') ? new Float32Array(16) : undefined;
+    var scratchUniformMatrix2;
+    var scratchUniformMatrix3;
+    var scratchUniformMatrix4;
+    if (typeof Float32Array !== 'undefined') {
+        scratchUniformMatrix2 = new Float32Array(4);
+        scratchUniformMatrix3 = new Float32Array(9);
+        scratchUniformMatrix4 = new Float32Array(16);
+    }
 
     /**
      * A shader program's uniform, including the uniform's value.  This is most commonly used to change
@@ -2450,7 +2556,7 @@ define([
         return attributes;
     }
 
-    function findUniforms(gl ,program) {
+    function findUniforms(gl, program) {
         var allUniforms = {};
         var uniforms = [];
         var samplerUniforms = [];

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

@@ -1,29 +1,33 @@
 /*global define*/
 define([
-        '../Core/DeveloperError',
-        '../Core/destroyObject',
-        '../Core/Cartesian2',
         '../Core/BoundingRectangle',
+        '../Core/Cartesian2',
         '../Core/createGuid',
+        '../Core/defaultValue',
+        '../Core/destroyObject',
+        '../Core/DeveloperError',
         './PixelFormat'
     ], function(
-        DeveloperError,
-        destroyObject,
-        Cartesian2,
         BoundingRectangle,
+        Cartesian2,
         createGuid,
+        defaultValue,
+        destroyObject,
+        DeveloperError,
         PixelFormat) {
     "use strict";
 
     // The atlas is made up of regions of space called nodes that contain images or child nodes.
     function TextureAtlasNode(bottomLeft, topRight, childNode1, childNode2, imageIndex) {
-        this.bottomLeft = (typeof bottomLeft !== 'undefined') ? bottomLeft : new Cartesian2();
-        this.topRight = (typeof topRight !== 'undefined') ? topRight : new Cartesian2();
+        this.bottomLeft = defaultValue(bottomLeft, Cartesian2.ZERO);
+        this.topRight = defaultValue(topRight, Cartesian2.ZERO);
         this.childNode1 = childNode1;
         this.childNode2 = childNode2;
         this.imageIndex = imageIndex;
     }
 
+    var defaultInitialSize = new Cartesian2(16.0, 16.0);
+
     /**
      * A TextureAtlas stores multiple images in one square texture and keeps
      * track of the texture coordinates for each image. TextureAtlas is dynamic,
@@ -48,36 +52,25 @@ define([
      * @exception {DeveloperError} initialSize must be greater than zero.
      */
     var TextureAtlas = function(description) {
-        description = (typeof description !== 'undefined') ? description : {};
-        var context = description.context;
-        var pixelFormat = description.pixelFormat;
-        var borderWidthInPixels = description.borderWidthInPixels;
-        var initialSize = description.initialSize;
-        var images = description.images;
-        var image = description.image;
+        description = defaultValue(description, defaultValue.EMPTY_OBJECT);
 
-        // Context
+        var context = description.context;
         if (typeof context === 'undefined') {
             throw new DeveloperError('context is required.');
         }
 
-        // Pixel Format
-        pixelFormat = (typeof pixelFormat !== 'undefined') ? pixelFormat : PixelFormat.RGBA;
-
-        // Border
-        borderWidthInPixels = (typeof borderWidthInPixels !== 'undefined') ? borderWidthInPixels : 1.0;
+        var borderWidthInPixels = defaultValue(description.borderWidthInPixels, 1.0);
         if (borderWidthInPixels < 0) {
             throw new DeveloperError('borderWidthInPixels must be greater than or equal to zero.');
         }
 
-        // Initial size
-        initialSize = (typeof initialSize !== 'undefined') ? initialSize : new Cartesian2(16.0, 16.0);
+        var initialSize = defaultValue(description.initialSize, defaultInitialSize);
         if (initialSize.x < 1 || initialSize.y < 1) {
             throw new DeveloperError('initialSize must be greater than zero.');
         }
 
         this._context = context;
-        this._pixelFormat = pixelFormat;
+        this._pixelFormat = defaultValue(description.pixelFormat, PixelFormat.RGBA);
         this._borderWidthInPixels = borderWidthInPixels;
         this._textureCoordinates = [];
         this._guid = createGuid();
@@ -91,36 +84,39 @@ define([
         this._root = new TextureAtlasNode(new Cartesian2(), new Cartesian2(initialSize.x, initialSize.y));
 
         // Add initial images if there are any.
-        if (typeof images !== 'undefined' && (images.length > 0)) {
+        var images = description.images;
+        if (typeof images !== 'undefined' && images.length > 0) {
             this.addImages(images);
         }
+
+        var image = description.image;
         if (typeof image !== 'undefined') {
             this.addImage(image);
         }
     };
 
     // Builds a larger texture and copies the old texture into the new one.
-    TextureAtlas.prototype._resizeAtlas = function(image) {
-        var numImages = this.getNumberOfImages();
+    function resizeAtlas(textureAtlas, image) {
+        var numImages = textureAtlas.getNumberOfImages();
         var scalingFactor = 2.0;
         if (numImages > 0) {
-            var oldAtlasWidth = this._texture.getWidth();
-            var oldAtlasHeight = this._texture.getHeight();
-            var atlasWidth = scalingFactor * (oldAtlasWidth + image.width + this._borderWidthInPixels);
-            var atlasHeight = scalingFactor * (oldAtlasHeight + image.height + this._borderWidthInPixels);
+            var oldAtlasWidth = textureAtlas._texture.getWidth();
+            var oldAtlasHeight = textureAtlas._texture.getHeight();
+            var atlasWidth = scalingFactor * (oldAtlasWidth + image.width + textureAtlas._borderWidthInPixels);
+            var atlasHeight = scalingFactor * (oldAtlasHeight + image.height + textureAtlas._borderWidthInPixels);
             var widthRatio = oldAtlasWidth / atlasWidth;
             var heightRatio = oldAtlasHeight / atlasHeight;
 
             // Create new node structure, putting the old root node in the bottom left.
-            var nodeBottomRight = new TextureAtlasNode(new Cartesian2(oldAtlasWidth + this._borderWidthInPixels, 0.0), new Cartesian2(atlasWidth, oldAtlasHeight));
-            var nodeBottomHalf = new TextureAtlasNode(new Cartesian2(), new Cartesian2(atlasWidth, oldAtlasHeight), this._root, nodeBottomRight);
-            var nodeTopHalf = new TextureAtlasNode(new Cartesian2(0.0, oldAtlasHeight + this._borderWidthInPixels), new Cartesian2(atlasWidth, atlasHeight));
+            var nodeBottomRight = new TextureAtlasNode(new Cartesian2(oldAtlasWidth + textureAtlas._borderWidthInPixels, 0.0), new Cartesian2(atlasWidth, oldAtlasHeight));
+            var nodeBottomHalf = new TextureAtlasNode(new Cartesian2(), new Cartesian2(atlasWidth, oldAtlasHeight), textureAtlas._root, nodeBottomRight);
+            var nodeTopHalf = new TextureAtlasNode(new Cartesian2(0.0, oldAtlasHeight + textureAtlas._borderWidthInPixels), new Cartesian2(atlasWidth, atlasHeight));
             var nodeMain = new TextureAtlasNode(new Cartesian2(), new Cartesian2(atlasWidth, atlasHeight), nodeBottomHalf, nodeTopHalf);
-            this._root = nodeMain;
+            textureAtlas._root = nodeMain;
 
             // Resize texture coordinates.
-            for ( var i = 0; i < this._textureCoordinates.length; i++) {
-                var texCoord = this._textureCoordinates[i];
+            for ( var i = 0; i < textureAtlas._textureCoordinates.length; i++) {
+                var texCoord = textureAtlas._textureCoordinates[i];
                 if (typeof texCoord !== 'undefined') {
                     texCoord.x *= widthRatio;
                     texCoord.y *= heightRatio;
@@ -130,40 +126,40 @@ define([
             }
 
             // Copy larger texture.
-            var newTexture = this._context.createTexture2D({
+            var newTexture = textureAtlas._context.createTexture2D({
                 width : atlasWidth,
                 height : atlasHeight,
-                pixelFormat : this._pixelFormat
+                pixelFormat : textureAtlas._pixelFormat
             });
 
             // Copy old texture into new using an fbo.
-            var framebuffer = this._context.createFramebuffer({
-                colorTexture : this._texture
+            var framebuffer = textureAtlas._context.createFramebuffer({
+                colorTexture : textureAtlas._texture
             });
             framebuffer._bind();
             newTexture.copyFromFramebuffer(0, 0, 0, 0, oldAtlasWidth, oldAtlasHeight);
             framebuffer._unBind();
             framebuffer.destroy();
-            this._texture = newTexture;
+            textureAtlas._texture = newTexture;
         }
         // First image exceeds initialSize
         else {
-            var initialWidth = scalingFactor * (image.width + this._borderWidthInPixels);
-            var initialHeight = scalingFactor * (image.height + this._borderWidthInPixels);
-            this._texture = this._texture && this._texture.destroy();
-            this._texture = this._context.createTexture2D({
+            var initialWidth = scalingFactor * (image.width + textureAtlas._borderWidthInPixels);
+            var initialHeight = scalingFactor * (image.height + textureAtlas._borderWidthInPixels);
+            textureAtlas._texture = textureAtlas._texture && textureAtlas._texture.destroy();
+            textureAtlas._texture = textureAtlas._context.createTexture2D({
                 width : initialWidth,
                 height : initialHeight,
-                pixelFormat : this._pixelFormat
+                pixelFormat : textureAtlas._pixelFormat
             });
-            this._root = new TextureAtlasNode(new Cartesian2(), new Cartesian2(initialWidth, initialHeight));
+            textureAtlas._root = new TextureAtlasNode(new Cartesian2(), new Cartesian2(initialWidth, initialHeight));
         }
-    };
+    }
 
     // A recursive function that finds the best place to insert
     // a new image based on existing image 'nodes'.
     // Inspired by: http://blackpawn.com/texts/lightmaps/default.html
-    TextureAtlas.prototype._findNode = function (node, image) {
+    function findNode(textureAtlas, node, image) {
         if (typeof node === 'undefined') {
             return undefined;
         }
@@ -196,7 +192,7 @@ define([
             if (widthDifference > heightDifference) {
                 node.childNode1 = new TextureAtlasNode(new Cartesian2(node.bottomLeft.x, node.bottomLeft.y), new Cartesian2(node.bottomLeft.x + image.width, node.topRight.y));
                 // Only make a second child if the border gives enough space.
-                var childNode2BottomLeftX = node.bottomLeft.x + image.width + this._borderWidthInPixels;
+                var childNode2BottomLeftX = node.bottomLeft.x + image.width + textureAtlas._borderWidthInPixels;
                 if (childNode2BottomLeftX < node.topRight.x) {
                     node.childNode2 = new TextureAtlasNode(new Cartesian2(childNode2BottomLeftX, node.bottomLeft.y), new Cartesian2(node.topRight.x, node.topRight.y));
                 }
@@ -205,48 +201,48 @@ define([
             else {
                 node.childNode1 = new TextureAtlasNode(new Cartesian2(node.bottomLeft.x, node.bottomLeft.y), new Cartesian2(node.topRight.x, node.bottomLeft.y + image.height));
                 // Only make a second child if the border gives enough space.
-                var childNode2BottomLeftY = node.bottomLeft.y + image.height + this._borderWidthInPixels;
+                var childNode2BottomLeftY = node.bottomLeft.y + image.height + textureAtlas._borderWidthInPixels;
                 if (childNode2BottomLeftY < node.topRight.y) {
                     node.childNode2 = new TextureAtlasNode(new Cartesian2(node.bottomLeft.x, childNode2BottomLeftY), new Cartesian2(node.topRight.x, node.topRight.y));
                 }
             }
-            return this._findNode(node.childNode1, image);
+            return findNode(textureAtlas, node.childNode1, image);
         }
 
         // If not a leaf node
-        return this._findNode(node.childNode1, image) ||
-               this._findNode(node.childNode2, image);
-    };
+        return findNode(textureAtlas, node.childNode1, image) ||
+            findNode(textureAtlas, node.childNode2, image);
+    }
 
     // Adds image of given index to the texture atlas. Called from addImage and addImages.
-    TextureAtlas.prototype._addImage = function(image, index) {
+    function addImage(textureAtlas, image, index) {
         if (typeof image === 'undefined') {
             throw new DeveloperError('image is required.');
         }
 
-        var node = this._findNode(this._root, image);
+        var node = findNode(textureAtlas, textureAtlas._root, image);
 
         // Found a node that can hold the image.
         if (typeof node !== 'undefined') {
             node.imageIndex = index;
 
             // Add texture coordinate and write to texture
-            var atlasWidth = this._texture.getWidth();
-            var atlasHeight = this._texture.getHeight();
+            var atlasWidth = textureAtlas._texture.getWidth();
+            var atlasHeight = textureAtlas._texture.getHeight();
             var nodeWidth = node.topRight.x - node.bottomLeft.x;
             var nodeHeight = node.topRight.y - node.bottomLeft.y;
-            this._textureCoordinates[index] = new BoundingRectangle(
+            textureAtlas._textureCoordinates[index] = new BoundingRectangle(
                 node.bottomLeft.x / atlasWidth, node.bottomLeft.y / atlasHeight,
                 nodeWidth / atlasWidth, nodeHeight / atlasHeight
             );
-            this._texture.copyFrom(image, node.bottomLeft.x, node.bottomLeft.y);
+            textureAtlas._texture.copyFrom(image, node.bottomLeft.x, node.bottomLeft.y);
         }
         // No node found, must resize the texture atlas.
         else {
-            this._resizeAtlas(image);
-            this._addImage(image, index);
+            resizeAtlas(textureAtlas, image);
+            addImage(textureAtlas, image, index);
         }
-    };
+    }
 
     /**
      * Adds an image to the texture atlas.
@@ -267,7 +263,7 @@ define([
      */
     TextureAtlas.prototype.addImage = function(image) {
         var index = this.getNumberOfImages();
-        this._addImage(image, index);
+        addImage(this, image, index);
 
         this._guid = createGuid();
 
@@ -318,7 +314,7 @@ define([
         // Add images to the texture atlas.
         for (i = 0; i < numberOfImages; ++i) {
             var annotatedImage = annotatedImages[i];
-            this._addImage(annotatedImage.image, annotatedImage.index);
+            addImage(this, annotatedImage.image, annotatedImage.index);
         }
 
         this._guid = createGuid();