cesium 0.15.0 → 0.16.0

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

@@ -13,7 +13,7 @@ define([
         '../Core/EncodedCartesian3',
         '../Core/BoundingRectangle',
         '../Core/Transforms',
-        '../Core/computeSunPosition',
+        '../Core/Simon1994PlanetaryPositions',
         '../Scene/SceneMode'
     ], function(
         DeveloperError,
@@ -29,7 +29,7 @@ define([
         EncodedCartesian3,
         BoundingRectangle,
         Transforms,
-        computeSunPosition,
+        Simon1994PlanetaryPositions,
         SceneMode) {
     "use strict";
 
@@ -52,9 +52,10 @@ define([
         this._projection = Matrix4.IDENTITY.clone();
         this._infiniteProjection = Matrix4.IDENTITY.clone();
         this._entireFrustum = new Cartesian2();
+        this._currentFrustum = new Cartesian2();
+        this._pixelSize = 0.0;
 
-        this._frameNumber = 1.0;
-        this._time = undefined;
+        this._frameState = undefined;
         this._temeToPseudoFixed = Matrix3.IDENTITY.clone();
 
         // Derived members
@@ -180,18 +181,23 @@ define([
         uniformState._encodedCameraPositionMCDirty = true;
     }
 
-    var sunPositionWC = new Cartesian3();
-    var sunPositionScratch = new Cartesian3();
-
+    var position = new Cartesian3();
+    var transformMatrix = new Matrix3();
     function setSunAndMoonDirections(uniformState, frameState) {
-        computeSunPosition(frameState.time, sunPositionWC);
+        if (typeof Transforms.computeIcrfToFixedMatrix(frameState.time, transformMatrix) === 'undefined') {
+            transformMatrix = Transforms.computeTemeToPseudoFixedMatrix(frameState.time, transformMatrix);
+        }
 
-        Cartesian3.normalize(sunPositionWC, uniformState._sunDirectionWC);
-        Matrix3.multiplyByVector(uniformState.getViewRotation3D(), sunPositionWC, sunPositionScratch);
-        Cartesian3.normalize(sunPositionScratch, uniformState._sunDirectionEC);
+        position = Simon1994PlanetaryPositions.ComputeSunPositionInEarthInertialFrame(frameState.time, position);
+        transformMatrix.multiplyByVector(position, position);
+        Cartesian3.normalize(position, uniformState._sunDirectionWC);
+        Matrix3.multiplyByVector(uniformState.getViewRotation3D(), position, position);
+        Cartesian3.normalize(position, uniformState._sunDirectionEC);
 
-        // Pseudo direction for now just for lighting
-        Cartesian3.negate(uniformState._sunDirectionEC, uniformState._moonDirectionEC);
+        position = Simon1994PlanetaryPositions.ComputeMoonPositionInEarthInertialFrame(frameState.time, position);
+        transformMatrix.multiplyByVector(position, position);
+        Matrix3.multiplyByVector(uniformState.getViewRotation3D(), position, position);
+        Cartesian3.normalize(position, uniformState._moonDirectionEC);
     }
 
     /**
@@ -208,6 +214,8 @@ define([
         if (typeof frustum.getInfiniteProjectionMatrix !== 'undefined') {
             setInfiniteProjection(this, frustum.getInfiniteProjectionMatrix());
         }
+        this._currentFrustum.x = frustum.near;
+        this._currentFrustum.y = frustum.far;
     };
 
     /**
@@ -237,12 +245,14 @@ define([
 
         setSunAndMoonDirections(this, frameState);
 
+        var pixelSize = camera.frustum.getPixelSize(frameState.canvasDimensions);
+        this._pixelSize = Math.max(pixelSize.x, pixelSize.y);
+
         this._entireFrustum.x = camera.frustum.near;
         this._entireFrustum.y = camera.frustum.far;
         this.updateFrustum(camera.frustum);
 
-        this._frameNumber = frameState.frameNumber;
-        this._time = frameState.time;
+        this._frameState = frameState;
         this._temeToPseudoFixed = Transforms.computeTemeToPseudoFixedMatrix(frameState.time);
     };
 
@@ -873,17 +883,47 @@ define([
 
     /**
      * Returns 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 multi-frustum rendering.
      *
      * @memberof UniformState
      *
      * @return {Cartesian2} Returns the near distance and the far distance of the frustum defined by the camera.
      *
      * @see czm_entireFrustum
+     * @see UniformState#getCurrentFrustum
      */
     UniformState.prototype.getEntireFrustum = function() {
         return this._entireFrustum;
     };
 
+    /**
+     * Returns 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.
+     *
+     * @memberof UniformState
+     *
+     * @return {Cartesian2} Returns the near distance and the far distance of the frustum defined by the camera.
+     *
+     * @see czm_currentFrustum
+     * @see UniformState#getEntireFrustum
+     */
+    UniformState.prototype.getCurrentFrustum = function() {
+        return this._currentFrustum;
+    };
+
+    /**
+     * Returns the size of a pixel in meters at a distance of one meter from the camera.
+     *
+     * @memberof UniformState
+     *
+     * @return {Number} Returns the size of a pixel in meters at a distance of one meter from the camera.
+     *
+     * @see czm_pixelSizeInMeters
+     */
+    UniformState.prototype.getPixelSize = function() {
+        return this._pixelSize;
+    };
+
     /**
      * Returns a normalized vector to the sun in 3D world coordinates at the current scene time.  Even in 2D or
      * Columbus View mode, this returns the position of the sun in the 3D scene.
@@ -968,27 +1008,16 @@ define([
     };
 
     /**
-     * Gets the current frame number.
+     * Gets the current frame state.
      *
      * @memberof UniformState
      *
-     * @return {number} A number representing the current frame number.
+     * @return {FrameState} The current frame state.
      *
      * @see czm_frameNumber
      */
-    UniformState.prototype.getFrameNumber = function() {
-        return this._frameNumber;
-    };
-
-    /**
-     * Gets the scene's current time.
-     *
-     * @memberof UniformState
-     *
-     * @return {JulianDate} The scene's current time.
-     */
-    UniformState.prototype.getTime = function() {
-        return this._time;
+    UniformState.prototype.getFrameState = function() {
+        return this._frameState;
     };
 
     /**

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

@@ -1,11 +1,13 @@
 /*global define*/
 define([
-        '../Core/DeveloperError',
+        '../Core/defaultValue',
         '../Core/destroyObject',
+        '../Core/DeveloperError',
         '../Core/ComponentDatatype'
     ], function(
-        DeveloperError,
+        defaultValue,
         destroyObject,
+        DeveloperError,
         ComponentDatatype) {
     "use strict";
 
@@ -82,8 +84,8 @@ define([
 
         // Shallow copy the attribute; we do not want to copy the vertex buffer.
         var attr = {
-            index : (typeof attribute.index === 'undefined') ? index : attribute.index,
-            enabled : (typeof attribute.enabled === 'undefined') ? true : attribute.enabled,
+            index : defaultValue(attribute.index, index),
+            enabled : defaultValue(attribute.enabled, true),
             vertexBuffer : attribute.vertexBuffer,
             value : attribute.value ? attribute.value.slice(0) : undefined,
             componentsPerAttribute : componentsPerAttribute,
@@ -180,7 +182,7 @@ define([
     VertexArray.prototype.addAttribute = function(attribute) {
         if (attribute) {
             var attributes = this._attributes;
-            var index = (typeof attribute.index === 'undefined') ? attributes.length : attribute.index;
+            var index = defaultValue(attribute.index, attributes.length);
             for ( var i = 0; i < attributes.length; ++i) {
                 if (index === attributes[i].index) {
                     throw new DeveloperError('Index ' + index + ' is already in use.');
@@ -354,8 +356,8 @@ define([
         }
 
         var indexBuffer = this._indexBuffer;
-        if (indexBuffer && indexBuffer.getVertexArrayDestroyable()) {
-            this._indexBuffer = indexBuffer.destroy();
+        if (indexBuffer && !indexBuffer.isDestroyed() && indexBuffer.getVertexArrayDestroyable()) {
+            indexBuffer.destroy();
         }
 
         return destroyObject(this);

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

@@ -1,15 +1,15 @@
 /*global define*/
 define([
-        '../Core/DeveloperError',
+        '../Core/ComponentDatatype',
         '../Core/defaultValue',
         '../Core/destroyObject',
-        '../Core/ComponentDatatype',
+        '../Core/DeveloperError',
         './BufferUsage'
     ], function(
-        DeveloperError,
+        ComponentDatatype,
         defaultValue,
         destroyObject,
-        ComponentDatatype,
+        DeveloperError,
         BufferUsage) {
     "use strict";
 
@@ -159,8 +159,8 @@ define([
             var attribute = attributes[i];
 
             var attr = {
-                index : (typeof attribute.index === 'undefined') ? i : attribute.index,
-                enabled : (typeof attribute.enabled === 'undefined') ? true : attribute.enabled,
+                index : defaultValue(attribute.index, i),
+                enabled : defaultValue(attribute.enabled, true),
                 componentsPerAttribute : attribute.componentsPerAttribute,
                 componentDatatype : attribute.componentDatatype || ComponentDatatype.FLOAT,
                 normalize : attribute.normalize || false,
@@ -290,7 +290,7 @@ define([
         }
 
         // VAs are recreated next time commit is called.
-        this._destroyVA();
+        destroyVA(this);
     };
 
     VertexArrayFacade._resize = function(buffer, size) {
@@ -371,6 +371,9 @@ define([
         }
     };
 
+    // Using unsigned short indices, 64K vertices can be indexed by one index buffer
+    var sixtyFourK = 64 * 1024;
+
     /**
      * DOC_TBA
      *
@@ -384,18 +387,15 @@ define([
 
         for (var i = 0, len = allBuffers.length; i < len; ++i) {
             buffer = allBuffers[i];
-            recreateVA = this._commit(buffer) || recreateVA;
+            recreateVA = commit(this, buffer) || recreateVA;
         }
 
         ///////////////////////////////////////////////////////////////////////
 
-        if (recreateVA || !this.va) {
-            // Using unsigned short indices, 64K vertices can be indexed by one index buffer
-            var sixtyFourK = 64 * 1024;
-
+        if (recreateVA || typeof this.vaByPurpose === 'undefined') {
             var buffersByPurposeAndUsage = this._buffersByPurposeAndUsage;
 
-            this._destroyVA();
+            destroyVA(this);
             this.vaByPurpose = {};
 
             for (var purpose in buffersByPurposeAndUsage) {
@@ -441,17 +441,18 @@ define([
         }
     };
 
-    VertexArrayFacade.prototype._commit = function(buffer) {
+    function commit(vertexArrayFacade, buffer) {
         if (buffer.needsCommit && (buffer.vertexSizeInBytes > 0)) {
             buffer.needsCommit = false;
 
             var vertexBuffer = buffer.vertexBuffer;
-            var vertexBufferSizeInBytes = this._size * buffer.vertexSizeInBytes;
-            if (!vertexBuffer || (vertexBuffer.getSizeInBytes() < vertexBufferSizeInBytes)) {
-                if (vertexBuffer) {
+            var vertexBufferSizeInBytes = vertexArrayFacade._size * buffer.vertexSizeInBytes;
+            var vertexBufferDefined = typeof vertexBuffer !== 'undefined';
+            if (!vertexBufferDefined || (vertexBuffer.getSizeInBytes() < vertexBufferSizeInBytes)) {
+                if (vertexBufferDefined) {
                     vertexBuffer.destroy();
                 }
-                buffer.vertexBuffer = this._context.createVertexBuffer(buffer.arrayBuffer, buffer.usage);
+                buffer.vertexBuffer = vertexArrayFacade._context.createVertexBuffer(buffer.arrayBuffer, buffer.usage);
                 buffer.vertexBuffer.setVertexArrayDestroyable(false);
 
                 return true; // Created new vertex buffer
@@ -461,7 +462,7 @@ define([
         }
 
         return false; // Did not create new vertex buffer
-    };
+    }
 
     VertexArrayFacade._appendAttributes = function(attributes, buffer, vertexBufferOffset) {
         var arrayViews = buffer.arrayViews;
@@ -498,11 +499,11 @@ define([
         var allBuffers = this._allBuffers;
 
         for (var i = 0, len = allBuffers.length; i < len; ++i) {
-            this._subCommit(allBuffers[i], offsetInVertices, lengthInVertices);
+            subCommit(this, allBuffers[i], offsetInVertices, lengthInVertices);
         }
     };
 
-    VertexArrayFacade.prototype._subCommit = function(buffer, offsetInVertices, lengthInVertices) {
+    function subCommit(vertexArrayFacade, buffer, offsetInVertices, lengthInVertices) {
         if (buffer.needsCommit && (buffer.vertexSizeInBytes > 0)) {
             var byteOffset = buffer.vertexSizeInBytes * offsetInVertices;
             var byteLength = buffer.vertexSizeInBytes * lengthInVertices;
@@ -513,7 +514,7 @@ define([
             // PERFORMANCE_IDEA: Does creating the typed view add too much GC overhead?
             buffer.vertexBuffer.copyFromArrayView(new Uint8Array(buffer.arrayBuffer, byteOffset, byteLength), byteOffset);
         }
-    };
+    }
 
     /**
      * DOC_TBA
@@ -527,8 +528,8 @@ define([
         }
     };
 
-    VertexArrayFacade.prototype._destroyVA = function() {
-        var vaByPurpose = this.vaByPurpose;
+    function destroyVA(vertexArrayFacade) {
+        var vaByPurpose = vertexArrayFacade.vaByPurpose;
         if (typeof vaByPurpose === 'undefined') {
             return;
         }
@@ -543,8 +544,8 @@ define([
             }
         }
 
-        this.vaByPurpose = undefined;
-    };
+        vertexArrayFacade.vaByPurpose = undefined;
+    }
 
     /**
      * DOC_TBA
@@ -565,7 +566,7 @@ define([
             buffer.vertexBuffer = buffer.vertexBuffer && buffer.vertexBuffer.destroy();
         }
 
-        this._destroyVA();
+        destroyVA(this);
 
         return destroyObject(this);
     };

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

@@ -0,0 +1,53 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError'
+    ], function(
+        defaultValue,
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * Modifies a fragment shader for use with color-buffer picking.  The returned fragment shader source
+     * sets <code>gl_FragColor</code> to a new <code>vec4</code> uniform or varying, <code>czm_pickColor</code>,
+     * but still discards if the original fragment shader discards or outputs an alpha of 0.0.  This allows correct
+     * picking when a material contains transparent parts.
+     *
+     * @exports createPickFragmentShaderSource
+     *
+     * @param {String} fragmentShaderSource The original fragment shader source.
+     * @param {String} qualifier The GLSL qualifier, <code>uniform</code> or <code>varying</code>, for the input <code>czm_pickColor</code>.
+     *
+     * @returns {String} The modified fragment shader source.
+     *
+     * @exception {DeveloperError} fragmentShaderSource is required.
+     * @exception {DeveloperError} qualifier must be 'uniform' or 'varying'.
+     *
+     * @example
+     * var pickFS = createPickFragmentShaderSource('void main() { gl_FragColor = vec4(1.0); }', 'uniform');
+     */
+    function createPickFragmentShaderSource(fragmentShaderSource, qualifier) {
+        if (typeof fragmentShaderSource === 'undefined') {
+            throw new DeveloperError('fragmentShaderSource is required.');
+        }
+        if (qualifier !== 'uniform' && qualifier !== 'varying') {
+            throw new DeveloperError('qualifier must be \'uniform\' or \'varying\'.');
+        }
+
+        var renamedFS = fragmentShaderSource.replace(/void\s+main\s*\(\s*(?:void)?\s*\)/g, 'void czm_old_main()');
+        var pickMain =
+            qualifier + ' vec4 czm_pickColor; \n' +
+            'void main() \n' +
+            '{ \n' +
+            '    czm_old_main(); \n' +
+            '    if (gl_FragColor.a == 0.0) { \n' +
+            '        discard; \n' +
+            '    } \n' +
+            '    gl_FragColor = czm_pickColor; \n' +
+            '}';
+
+        return renamedFS + '\n' + pickMain;
+    }
+
+    return createPickFragmentShaderSource;
+});

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

@@ -1,11 +1,9 @@
 /*global define*/
 define([
-        '../Core/defaultValue',
         '../Core/DeveloperError',
         '../Core/loadImage',
         '../ThirdParty/when'
     ], function(
-        defaultValue,
         DeveloperError,
         loadImage,
         when) {
@@ -19,8 +17,9 @@ define([
      *
      * @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.
+     * @param {Boolean} [allowCrossOrigin=true] Whether to request the image using Cross-Origin
+     *        Resource Sharing (CORS).  CORS is only actually used if the image URL is actually cross-origin.
+     *        Data URIs are never requested using CORS.
      *
      * @returns {Promise} a promise that will resolve to the requested {@link CubeMap} when loaded.
      *
@@ -44,7 +43,7 @@ define([
      * @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) {
+    var loadCubeMap = function(context, urls, allowCrossOrigin) {
         if (typeof context === 'undefined') {
             throw new DeveloperError('context is required.');
         }
@@ -66,12 +65,12 @@ define([
         // 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)
+            loadImage(urls.positiveX, allowCrossOrigin),
+            loadImage(urls.negativeX, allowCrossOrigin),
+            loadImage(urls.positiveY, allowCrossOrigin),
+            loadImage(urls.negativeY, allowCrossOrigin),
+            loadImage(urls.positiveZ, allowCrossOrigin),
+            loadImage(urls.negativeZ, allowCrossOrigin)
         ];
 
         return when.all(facePromises, function(images) {