cesium 0.23.0 → 0.24.0

data/app/assets/javascripts/Core/CatmullRomSpline.js

@@ -39,6 +39,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Matrix
             timeVec.z = u;
             timeVec.y = u * u;
             timeVec.x = timeVec.y * u;
+            timeVec.w = 1.0;
 
             var p0, p1, p2, p3, coefs;
             if (i === 0) {
@@ -49,7 +50,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Matrix
                 p3 = Cartesian3.subtract(points[2], p0, scratchTemp0);
                 Cartesian3.multiplyByScalar(p3, 0.5, p3);
 
-                coefs = Matrix4.multiplyByPoint(HermiteSpline.hermiteCoefficientMatrix, timeVec, timeVec);
+                coefs = Matrix4.multiplyByVector(HermiteSpline.hermiteCoefficientMatrix, timeVec, timeVec);
             } else if (i === points.length - 2) {
                 p0 = points[i];
                 p1 = points[i + 1];
@@ -58,15 +59,14 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Matrix
                 p2 = Cartesian3.subtract(p1, points[i - 1], scratchTemp0);
                 Cartesian3.multiplyByScalar(p2, 0.5, p2);
 
-                coefs = Matrix4.multiplyByPoint(HermiteSpline.hermiteCoefficientMatrix, timeVec, timeVec);
+                coefs = Matrix4.multiplyByVector(HermiteSpline.hermiteCoefficientMatrix, timeVec, timeVec);
             } else {
                 p0 = points[i - 1];
                 p1 = points[i];
                 p2 = points[i + 1];
                 p3 = points[i + 2];
-                coefs = Matrix4.multiplyByPoint(CatmullRomSpline.catmullRomCoefficientMatrix, timeVec, timeVec);
+                coefs = Matrix4.multiplyByVector(CatmullRomSpline.catmullRomCoefficientMatrix, timeVec, timeVec);
             }
-
             result = Cartesian3.multiplyByScalar(p0, coefs.x, result);
             Cartesian3.multiplyByScalar(p1, coefs.y, scratchTemp1);
             Cartesian3.add(result, scratchTemp1, result);

data/app/assets/javascripts/Core/EllipsoidalOccluder.js

@@ -11,7 +11,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
      * Determine whether or not other objects are visible or hidden behind the visible horizon defined by
      * an {@link Ellipsoid} and a camera position.  The ellipsoid is assumed to be located at the
      * origin of the coordinate system.  This class uses the algorithm described in the
-     * <a href="http://cesium.agi.com/2013/04/25/Horizon-culling/">Horizon Culling</a> blog post.
+     * <a href="http://cesiumjs.org/2013/04/25/Horizon-culling/">Horizon Culling</a> blog post.
      *
      * @alias EllipsoidalOccluder
      *
@@ -65,7 +65,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
      * @param {Cartesian3} cameraPosition The new position of the camera.
      */
     EllipsoidalOccluder.prototype.setCameraPosition = function(cameraPosition) {
-        // See http://cesium.agi.com/2013/04/25/Horizon-culling/
+        // See http://cesiumjs.org/2013/04/25/Horizon-culling/
         var ellipsoid = this._ellipsoid;
         var cv = ellipsoid.transformPositionToScaledSpace(cameraPosition, this._cameraPositionInScaledSpace);
         var vhMagnitudeSquared = Cartesian3.magnitudeSquared(cv) - 1.0;
@@ -130,7 +130,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
      * occluder.isScaledSpacePointVisible(scaledSpacePoint); //returns true
      */
     EllipsoidalOccluder.prototype.isScaledSpacePointVisible = function(occludeeScaledSpacePosition) {
-        // See http://cesium.agi.com/2013/04/25/Horizon-culling/
+        // See http://cesiumjs.org/2013/04/25/Horizon-culling/
         var cv = this._cameraPositionInScaledSpace;
         var vhMagnitudeSquared = this._distanceToLimbInScaledSpaceSquared;
         var vt = Cartesian3.subtract(occludeeScaledSpacePosition, cv, scratchCartesian);

data/app/assets/javascripts/Core/Fullscreen.js

@@ -103,11 +103,19 @@ define(['Core/defined'], function(defined) {
             name = prefix + 'fullscreenchange';
             // event names do not have 'on' in the front, but the property on the document does
             if (defined(document['on' + name])) {
+                //except on IE
+                if (prefix === 'ms') {
+                    name = 'MSFullscreenChange';
+                }
                 _names.fullscreenchange = name;
             }
 
             name = prefix + 'fullscreenerror';
             if (defined(document['on' + name])) {
+                //except on IE
+                if (prefix === 'ms') {
+                    name = 'MSFullscreenError';
+                }
                 _names.fullscreenerror = name;
             }
         }

data/app/assets/javascripts/Core/Geometry.js

@@ -51,7 +51,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Boundi
      *   boundingSphere : BoundingSphere.fromVertices(positions)
      * });
      *
-     * @demo <a href="http://cesium.agi.com/Cesium/Apps/Sandcastle/index.html?src=Geometry%20and%20Appearances.html">Geometry and Appearances Demo</a>
+     * @demo <a href="http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Geometry%20and%20Appearances.html">Geometry and Appearances Demo</a>
      *
      * @see PolygonGeometry
      * @see ExtentGeometry

data/app/assets/javascripts/Core/GeometryPipeline.js

@@ -728,7 +728,6 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
     };
 
     var scratchCartesian3 = new Cartesian3();
-    var scratchCartesian4 = new Cartesian4();
 
     function transformPoint(matrix, attribute) {
         if (defined(attribute)) {
@@ -736,8 +735,8 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
             var length = values.length;
             for (var i = 0; i < length; i += 3) {
                 Cartesian3.unpack(values, i, scratchCartesian3);
-                Matrix4.multiplyByPoint(matrix, scratchCartesian3, scratchCartesian4);
-                Cartesian3.pack(scratchCartesian4, values, i);
+                Matrix4.multiplyByPoint(matrix, scratchCartesian3, scratchCartesian3);
+                Cartesian3.pack(scratchCartesian3, values, i);
             }
         }
     }

data/app/assets/javascripts/Core/HermiteSpline.js

@@ -141,8 +141,9 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
             timeVec.z = u;
             timeVec.y = u * u;
             timeVec.x = timeVec.y * u;
+            timeVec.w = 1;
 
-            var coefs = Matrix4.multiplyByPoint(HermiteSpline.hermiteCoefficientMatrix, timeVec, timeVec);
+            var coefs = Matrix4.multiplyByVector(HermiteSpline.hermiteCoefficientMatrix, timeVec, timeVec);
 
             result = Cartesian3.multiplyByScalar(points[i], coefs.x, result);
             Cartesian3.multiplyByScalar(points[i + 1], coefs.y, scratchTemp);

data/app/assets/javascripts/Core/IntersectionTests.js

@@ -58,6 +58,9 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', '
         return Cartesian3.add(origin, result, result);
     };
 
+    var scratchQ = new Cartesian3();
+    var scratchW = new Cartesian3();
+
     /**
      * Computes the intersection points of a ray with an ellipsoid.
      * @memberof IntersectionTests
@@ -79,8 +82,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', '
         }
 
         var inverseRadii = ellipsoid.getOneOverRadii();
-        var q = Cartesian3.multiplyComponents(inverseRadii, ray.origin);
-        var w = Cartesian3.multiplyComponents(inverseRadii, ray.direction);
+        var q = Cartesian3.multiplyComponents(inverseRadii, ray.origin, scratchQ);
+        var w = Cartesian3.multiplyComponents(inverseRadii, ray.direction, scratchW);
 
         var q2 = Cartesian3.magnitudeSquared(q);
         var qw = Cartesian3.dot(q, w);

data/app/assets/javascripts/Core/Math.js

@@ -481,9 +481,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'ThirdParty/
      * @exception {DeveloperError} A number greater than or equal to 0 is required.
      */
     CesiumMath.factorial = function(n) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof n !== 'number' || n < 0) {
             throw new DeveloperError('A number greater than or equal to 0 is required.');
         }
+        //>>includeEnd('debug');
 
         var length = factorials.length;
         if (n >= length) {
@@ -515,9 +517,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'ThirdParty/
     CesiumMath.incrementWrap = function(n, maximumValue, minimumValue) {
         minimumValue = defaultValue(minimumValue, 0.0);
 
+        //>>includeStart('debug', pragmas.debug);
         if (maximumValue <= minimumValue) {
             throw new DeveloperError('Maximum value must be greater than minimum value.');
         }
+        //>>includeEnd('debug');
 
         ++n;
         if (n > maximumValue) {
@@ -542,9 +546,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'ThirdParty/
      * var f = CesiumMath.isPowerOfTwo(20); // false
      */
     CesiumMath.isPowerOfTwo = function(n) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof n !== 'number' || n < 0) {
             throw new DeveloperError('A number greater than or equal to 0 is required.');
         }
+        //>>includeEnd('debug');
 
         return (n !== 0) && ((n & (n - 1)) === 0);
     };
@@ -565,9 +571,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'ThirdParty/
      * var m = CesiumMath.nextPowerOfTwo(32); // 32
      */
     CesiumMath.nextPowerOfTwo = function(n) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof n !== 'number' || n < 0) {
             throw new DeveloperError('A number greater than or equal to 0 is required.');
         }
+        //>>includeEnd('debug');
 
         // From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
         --n;
@@ -608,9 +616,12 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'ThirdParty/
      * @exception {DeveloperError} seed is required.
      */
     CesiumMath.setRandomNumberSeed = function(seed) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(seed)) {
             throw new DeveloperError('seed is required.');
         }
+        //>>includeEnd('debug');
+
         randomNumberGenerator = new MersenneTwister(seed);
     };
 

data/app/assets/javascripts/Core/Matrix2.js

@@ -55,6 +55,50 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         return result;
     };
 
+    /**
+     * Creates a Matrix2 from 4 consecutive elements in an array.
+     * @memberof Matrix2
+     *
+     * @param {Array} array The array whose 4 consecutive elements correspond to the positions of the matrix.  Assumes column-major order.
+     * @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to first column first row position in the matrix.
+     * @param {Matrix2} [result] The object onto which to store the result.
+     *
+     * @returns {Matrix2} The modified result parameter or a new Matrix2 instance if one was not provided.
+     *
+     * @exception {DeveloperError} array is required.
+     *
+     * @example
+     * // Create the Matrix2:
+     * // [1.0, 2.0]
+     * // [1.0, 2.0]
+     *
+     * var v = [1.0, 1.0, 2.0, 2.0];
+     * var m = Matrix2.fromArray(v);
+     *
+     * // Create same Matrix2 with using an offset into an array
+     * var v2 = [0.0, 0.0, 1.0, 1.0, 2.0, 2.0];
+     * var m2 = Matrix2.fromArray(v2, 2);
+     */
+    Matrix2.fromArray = function(array, startingIndex, result) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(array)) {
+            throw new DeveloperError('array is required');
+        }
+        //>>includeEnd('debug');
+
+        startingIndex = defaultValue(startingIndex, 0);
+
+        if (!defined(result)) {
+            result = new Matrix2();
+        }
+
+        result[0] = array[startingIndex];
+        result[1] = array[startingIndex + 1];
+        result[2] = array[startingIndex + 2];
+        result[3] = array[startingIndex + 3];
+        return result;
+    };
+
     /**
      * Creates a Matrix2 instance from a column-major order array.
      * @memberof Matrix2
@@ -67,9 +111,12 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} values is required.
      */
     Matrix2.fromColumnMajorArray = function(values, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(values)) {
             throw new DeveloperError('values parameter is required');
         }
+        //>>includeEnd('debug');
+
         return Matrix2.clone(values, result);
     };
 
@@ -85,9 +132,12 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} values is required.
      */
     Matrix2.fromRowMajorArray = function(values, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(values)) {
             throw new DeveloperError('values is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix2(values[0], values[1],
                                values[2], values[3]);
@@ -116,9 +166,12 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var m = Matrix2.fromScale(new Cartesian2(7.0, 8.0));
      */
     Matrix2.fromScale = function(scale, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(scale)) {
             throw new DeveloperError('scale is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix2(
                 scale.x, 0.0,
@@ -149,9 +202,12 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var m = Matrix2.fromUniformScale(2.0);
      */
     Matrix2.fromUniformScale = function(scale, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof scale !== 'number') {
             throw new DeveloperError('scale is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix2(
                 scale, 0.0,
@@ -182,9 +238,11 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var rotated = Matrix2.multiplyByVector(m, p);
      */
     Matrix2.fromRotation = function(angle, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(angle)) {
             throw new DeveloperError('angle is required.');
         }
+        //>>includeEnd('debug');
 
         var cosAngle = Math.cos(angle);
         var sinAngle = Math.sin(angle);
@@ -213,9 +271,12 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix2.toArray = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return [matrix[0], matrix[1], matrix[2], matrix[3]];
         }
@@ -244,12 +305,15 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * myMatrix[column1Row0Index] = 10.0;
      */
     Matrix2.getElementIndex = function(column, row) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof row !== 'number' || row < 0 || row > 1) {
             throw new DeveloperError('row is required and must be 0 or 1.');
         }
         if (typeof column !== 'number' || column < 0 || column > 1) {
             throw new DeveloperError('column is required and must be 0 or 1.');
         }
+        //>>includeEnd('debug');
+
         return column * 2 + row;
     };
 
@@ -268,6 +332,7 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian2
      */
     Matrix2.getColumn = function(matrix, index, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required.');
         }
@@ -275,6 +340,7 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 1) {
             throw new DeveloperError('index is required and must be 0 or 1.');
         }
+        //>>includeEnd('debug');
 
         var startIndex = index * 2;
         var x = matrix[startIndex];
@@ -305,6 +371,7 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian2
      */
     Matrix2.setColumn = function(matrix, index, cartesian, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
@@ -314,6 +381,8 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 1) {
             throw new DeveloperError('index is required and must be 0 or 1.');
         }
+        //>>includeEnd('debug');
+
         result = Matrix2.clone(matrix, result);
         var startIndex = index * 2;
         result[startIndex] = cartesian.x;
@@ -336,6 +405,7 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian2
      */
     Matrix2.getRow = function(matrix, index, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required.');
         }
@@ -343,6 +413,7 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 1) {
             throw new DeveloperError('index is required and must be 0 or 1.');
         }
+        //>>includeEnd('debug');
 
         var x = matrix[index];
         var y = matrix[index + 2];
@@ -372,6 +443,7 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian2
      */
     Matrix2.setRow = function(matrix, index, cartesian, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
@@ -381,6 +453,7 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 1) {
             throw new DeveloperError('index is required and must be 0 or 1.');
         }
+        //>>includeEnd('debug');
 
         result = Matrix2.clone(matrix, result);
         result[index] = cartesian.x;
@@ -401,12 +474,14 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} right is required.
      */
     Matrix2.multiply = function(left, right, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(left)) {
             throw new DeveloperError('left is required');
         }
         if (!defined(right)) {
             throw new DeveloperError('right is required');
         }
+        //>>includeEnd('debug');
 
         var column0Row0 = left[0] * right[0] + left[2] * right[1];
         var column1Row0 = left[0] * right[2] + left[2] * right[3];
@@ -437,12 +512,14 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} cartesian is required.
      */
     Matrix2.multiplyByVector = function(matrix, cartesian, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
         if (!defined(cartesian)) {
             throw new DeveloperError('cartesian is required');
         }
+        //>>includeEnd('debug');
 
         var x = matrix[0] * cartesian.x + matrix[2] * cartesian.y;
         var y = matrix[1] * cartesian.x + matrix[3] * cartesian.y;
@@ -468,12 +545,14 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} scalar is required and must be a number.
      */
     Matrix2.multiplyByScalar = function(matrix, scalar, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
         if (typeof scalar !== 'number') {
             throw new DeveloperError('scalar is required and must be a number');
         }
+        //>>includeEnd('debug');
 
         if (!defined(result)) {
             return new Matrix2(matrix[0] * scalar, matrix[2] * scalar,
@@ -497,9 +576,11 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix2.negate = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
 
         if (!defined(result)) {
             return new Matrix2(-matrix[0], -matrix[2],
@@ -523,9 +604,11 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix2.transpose = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
 
         var column0Row0 = matrix[0];
         var column0Row1 = matrix[2];
@@ -554,9 +637,12 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix2.abs = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix2(Math.abs(matrix[0]), Math.abs(matrix[2]),
                                Math.abs(matrix[1]), Math.abs(matrix[3]));
@@ -602,9 +688,11 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} epsilon is required and must be a number.
      */
     Matrix2.equalsEpsilon = function(left, right, epsilon) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof epsilon !== 'number') {
             throw new DeveloperError('epsilon is required and must be a number');
         }
+        //>>includeEnd('debug');
 
         return (left === right) ||
                 (defined(left) &&