cesium 0.21 → 0.21.1

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

@@ -119,7 +119,8 @@ define(['Core/DeveloperError'], function(
     Event.prototype.raiseEvent = function() {
         var listeners = this._listeners;
         var scopes = this._scopes;
-        for ( var i = listeners.length - 1; i > -1; i--) {
+        var length = listeners.length;
+        for (var i = 0; i < length; i++) {
             listeners[i].apply(scopes[i], arguments);
         }
     };

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

@@ -718,7 +718,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
 
             Cartesian3.subtract(nw, center, nw);
             Matrix2.fromRotation(rotation, rotationMatrix);
-            rotationMatrix.multiplyByVector(nw, nw);
+            Matrix2.multiplyByVector(rotationMatrix, nw, nw);
             Cartesian3.add(nw, center, nw);
             proj.unproject(nw, nwCartographic);
 

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

@@ -343,7 +343,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
 
             Cartesian3.subtract(nw, center, nw);
             Matrix2.fromRotation(rotation, rotationMatrix);
-            rotationMatrix.multiplyByVector(nw, nw);
+            Matrix2.multiplyByVector(rotationMatrix, nw, nw);
             Cartesian3.add(nw, center, nw);
             proj.unproject(nw, nwCartographic);
 

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

@@ -11,7 +11,7 @@ define(['Core/defaultValue'], function(defaultValue) {
      * into the vertex buffer for better rendering performance.
      * </p>
      *
-     * @alias VertexFormat
+     * @alias GeometryAttributes
      * @constructor
      */
     var GeometryAttributes = function(options) {

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

@@ -19,7 +19,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Matrix
      *
      * @param {Geometry} options.geometry The geometry to instance.
      * @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The model matrix that transforms to transform the geometry from model to world coordinates.
-     * @param {Object} [options.id=undefined] A user-defined object to return when the instance is picked with {@link Context#pick} or get/set per-instance attributes with {@link Primitive#getGeometryInstanceAttributes}.
+     * @param {Object} [options.id=undefined] A user-defined object to return when the instance is picked with {@link Scene#pick} or get/set per-instance attributes with {@link Primitive#getGeometryInstanceAttributes}.
      * @param {Object} [options.attributes] Per-instance attributes like a show or color attribute shown in the example below.
      *
      * @exception {DeveloperError} options.geometry is required.
@@ -88,7 +88,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Matrix
          *
          * @default undefined
          *
-         * @see Context#pick
+         * @see Scene#pick
          * @see Primitive#getGeometryInstanceAttributes
          */
         this.id = options.id;

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

@@ -351,11 +351,13 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
                     var elementsIn = attribute.values;
                     var intoElementsIn = 0;
                     var numComponents = attribute.componentsPerAttribute;
-                    var elementsOut = ComponentDatatype.createTypedArray(attribute.componentDatatype, elementsIn.length);
+                    var elementsOut = ComponentDatatype.createTypedArray(attribute.componentDatatype, nextIndex * numComponents);
                     while (intoElementsIn < numVertices) {
                         var temp = indexCrossReferenceOldToNew[intoElementsIn];
-                        for (i = 0; i < numComponents; i++) {
-                            elementsOut[numComponents * temp + i] = elementsIn[numComponents * intoElementsIn + i];
+                        if (temp !== -1) {
+                            for (i = 0; i < numComponents; i++) {
+                                elementsOut[numComponents * temp + i] = elementsIn[numComponents * intoElementsIn + i];
+                            }
                         }
                         ++intoElementsIn;
                     }
@@ -571,6 +573,7 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
      * @exception {DeveloperError} attributeName2D is required.
      * @exception {DeveloperError} geometry must have attribute matching the attributeName argument.
      * @exception {DeveloperError} The attribute componentDatatype must be ComponentDatatype.DOUBLE.
+     * @exception {DeveloperError} Could not project a point to 2D.
      *
      * @example
      * geometry = GeometryPipeline.projectTo2D(geometry, 'position', 'position3D', 'position2D');
@@ -612,11 +615,11 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
         for ( var i = 0; i < values3D.length; i += 3) {
             var value = Cartesian3.fromArray(values3D, i, scratchProjectTo2DCartesian3);
 
-            if (Cartesian3.equals(value, Cartesian3.ZERO)) {
-                continue;
+            var lonLat = ellipsoid.cartesianToCartographic(value, scratchProjectTo2DCartographic);
+            if (!defined(lonLat)) {
+                throw new DeveloperError('Could not project point (' + value.x + ', ' + value.y + ', ' + value.z + ') to 2D.');
             }
 
-            var lonLat = ellipsoid.cartesianToCartographic(value, scratchProjectTo2DCartographic);
             var projectedLonLat = projection.project(lonLat, scratchProjectTo2DCartesian3);
 
             projectedValues[index++] = projectedLonLat.x;
@@ -812,7 +815,7 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
             instance.geometry.boundingSphere = BoundingSphere.transform(boundingSphere, modelMatrix, boundingSphere);
         }
 
-        instance.modelMatrix = Matrix4.IDENTITY.clone();
+        instance.modelMatrix = Matrix4.clone(Matrix4.IDENTITY);
 
         return instance;
     };

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

@@ -218,7 +218,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
         var timeVec = new Cartesian4(0.0, u * u, u);
         timeVec.x = timeVec.y * u;
 
-        var coefs = HermiteSpline.hermiteCoefficientMatrix.multiplyByPoint(timeVec);
+        var coefs = Matrix4.multiplyByPoint(HermiteSpline.hermiteCoefficientMatrix, timeVec);
         var p0 = Cartesian3.multiplyByScalar(this._points[i].point,       coefs.x);
         var p1 = Cartesian3.multiplyByScalar(this._points[i + 1].point,   coefs.y);
         var p2 = Cartesian3.multiplyByScalar(this._points[i].tangent,     coefs.z);

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

@@ -0,0 +1,132 @@
+/*global define*/
+define(['Core/defined', 'Core/IauOrientationParameters', 'Core/JulianDate', 'Core/Math', 'Core/TimeConstants'], function(
+        defined,
+        IauOrientationParameters,
+        JulianDate,
+        CesiumMath,
+        TimeConstants) {
+    "use strict";
+
+    /**
+     * This is a collection of the orientation information available for central bodies.
+     * The data comes from the Report of the IAU/IAG Working Group on Cartographic
+     * Coordinates and Rotational Elements: 2000.
+     * @exports Iau2000Orientation
+     *
+     * @private
+     */
+    var Iau2000Orientation = {};
+
+    var TdtMinusTai = 32.184;
+    var J2000d = 2451545.0;
+
+    var c1 = -0.0529921;
+    var c2 = -0.1059842;
+    var c3 = 13.0120009;
+    var c4 = 13.3407154;
+    var c5 = 0.9856003;
+    var c6 = 26.4057084;
+    var c7 = 13.0649930;
+    var c8 = 0.3287146;
+    var c9 = 1.7484877;
+    var c10 = -0.1589763;
+    var c11 = 0.0036096;
+    var c12 = 0.1643573;
+    var c13 = 12.9590088;
+
+    /**
+     * Compute the orientation parameters for the Moon.
+     *
+     * @param {JulianDate} [date=new JulianDate()] The date to evaluate the parameters.
+     * @param {IauOrientationParameters} [result] The object onto which to store the result.
+     *
+     * @returns {IauOrientationParameters} The modified result parameter or a new instance representing the orientation of the Earth's Moon.
+     */
+    Iau2000Orientation.ComputeMoon = function(date, result) {
+        if (!defined(date)) {
+            date = new JulianDate();
+        }
+
+        var dateTT = date.addSeconds(TdtMinusTai);
+        var d = dateTT.getTotalDays() - J2000d;
+        var T = d / TimeConstants.DAYS_PER_JULIAN_CENTURY;
+
+        var E1 = (125.045 + c1 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E2 = (250.089 + c2 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E3 = (260.008 + c3 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E4 = (176.625 + c4 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E5 = (357.529 + c5 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E6 = (311.589 + c6 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E7 = (134.963 + c7 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E8 = (276.617 + c8 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E9 = (34.226 + c9 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E10 = (15.134 + c10 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E11 = (119.743 + c11 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E12 = (239.961 + c12 * d) * CesiumMath.RADIANS_PER_DEGREE;
+        var E13 = (25.053 + c13 * d) * CesiumMath.RADIANS_PER_DEGREE;
+
+        var sinE1 = Math.sin(E1);
+        var sinE2 = Math.sin(E2);
+        var sinE3 = Math.sin(E3);
+        var sinE4 = Math.sin(E4);
+        var sinE5 = Math.sin(E5);
+        var sinE6 = Math.sin(E6);
+        var sinE7 = Math.sin(E7);
+        var sinE8 = Math.sin(E8);
+        var sinE9 = Math.sin(E9);
+        var sinE10 = Math.sin(E10);
+        var sinE11 = Math.sin(E11);
+        var sinE12 = Math.sin(E12);
+        var sinE13 = Math.sin(E13);
+
+        var cosE1 = Math.cos(E1);
+        var cosE2 = Math.cos(E2);
+        var cosE3 = Math.cos(E3);
+        var cosE4 = Math.cos(E4);
+        var cosE5 = Math.cos(E5);
+        var cosE6 = Math.cos(E6);
+        var cosE7 = Math.cos(E7);
+        var cosE8 = Math.cos(E8);
+        var cosE9 = Math.cos(E9);
+        var cosE10 = Math.cos(E10);
+        var cosE11 = Math.cos(E11);
+        var cosE12 = Math.cos(E12);
+        var cosE13 = Math.cos(E13);
+
+        var rightAscension = (269.9949 + 0.0031 * T - 3.8787 * sinE1 - 0.1204 * sinE2 +
+            0.0700 * sinE3 - 0.0172 * sinE4 + 0.0072 * sinE6 -
+            0.0052 * sinE10 + 0.0043 * sinE13) *
+            CesiumMath.RADIANS_PER_DEGREE;
+        var declination = (66.5392 + 0.013 * T + 1.5419 * cosE1 + 0.0239 * cosE2 -
+            0.0278 * cosE3 + 0.0068 * cosE4 - 0.0029 * cosE6 +
+            0.0009 * cosE7 + 0.0008 * cosE10 - 0.0009 * cosE13) *
+            CesiumMath.RADIANS_PER_DEGREE;
+        var rotation = (38.3213 + 13.17635815 * d - 1.4e-12 * d * d + 3.5610 * sinE1 +
+            0.1208 * sinE2 - 0.0642 * sinE3 + 0.0158 * sinE4 +
+            0.0252 * sinE5 - 0.0066 * sinE6 - 0.0047 * sinE7 -
+            0.0046 * sinE8 + 0.0028 * sinE9 + 0.0052 * sinE10 +
+            0.004 * sinE11 + 0.0019 * sinE12 - 0.0044 * sinE13) *
+            CesiumMath.RADIANS_PER_DEGREE;
+
+        var rotationRate = ((13.17635815 - 1.4e-12 * (2.0 * d)) +
+            3.5610 * cosE1 * c1 +
+            0.1208 * cosE2*c2 - 0.0642 * cosE3*c3 + 0.0158 * cosE4*c4 +
+            0.0252 * cosE5*c5 - 0.0066 * cosE6*c6 - 0.0047 * cosE7*c7 -
+            0.0046 * cosE8*c8 + 0.0028 * cosE9*c9 + 0.0052 * cosE10*c10 +
+            0.004 * cosE11*c11 + 0.0019 * cosE12*c12 - 0.0044 * cosE13*c13) /
+            86400.0 * CesiumMath.RADIANS_PER_DEGREE;
+
+        if (!defined(result)) {
+            result = new IauOrientationParameters();
+        }
+
+        result.rightAscension = rightAscension;
+        result.declination = declination;
+        result.rotation = rotation;
+        result.rotationRate = rotationRate;
+
+        return result;
+    };
+
+    return Iau2000Orientation;
+});

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

@@ -0,0 +1,98 @@
+/*global define*/
+define(['Core/Cartesian3', 'Core/defined', 'Core/DeveloperError', 'Core/Iau2000Orientation', 'Core/JulianDate', 'Core/Math', 'Core/Matrix3', 'Core/Quaternion'], function(
+        Cartesian3,
+        defined,
+        DeveloperError,
+        Iau2000Orientation,
+        JulianDate,
+        CesiumMath,
+        Matrix3,
+        Quaternion) {
+    "use strict";
+
+    /**
+     * The Axes representing the orientation of a Central Body as represented by the data
+     * from the IAU/IAG Working Group reports on rotational elements.
+     * @alias IauOrientationAxes
+     * @constructor
+     *
+     * @param {Function} [computeFunction] The function that computes the {@link IauOrientationParameters} given a {@link JulianDate}.
+     *
+     * @exception {DeveloperError} computeFunction is required.
+     *
+     * @see Iau2000Orientation
+     */
+    var IauOrientationAxes = function (computeFunction) {
+        if (!defined(computeFunction) || typeof computeFunction !== 'function') {
+            computeFunction = Iau2000Orientation.ComputeMoon;
+        }
+
+        this._computeFunction = computeFunction;
+    };
+
+    var xAxisScratch = new Cartesian3();
+    var yAxisScratch = new Cartesian3();
+    var zAxisScratch = new Cartesian3();
+
+    function computeRotationMatrix(alpha, delta, result) {
+        var xAxis = xAxisScratch;
+        xAxis.x = Math.cos(alpha + CesiumMath.PI_OVER_TWO);
+        xAxis.y = Math.sin(alpha + CesiumMath.PI_OVER_TWO);
+        xAxis.z = 0.0;
+
+        var cosDec = Math.cos(delta);
+
+        var zAxis = zAxisScratch;
+        zAxis.x = cosDec * Math.cos(alpha);
+        zAxis.y = cosDec * Math.sin(alpha);
+        zAxis.z = Math.sin(delta);
+
+        var yAxis = Cartesian3.cross(zAxis, xAxis, yAxisScratch);
+
+        if (!defined(result)) {
+            result = new Matrix3();
+        }
+
+        result[0] = xAxis.x;
+        result[1] = yAxis.x;
+        result[2] = zAxis.x;
+        result[3] = xAxis.y;
+        result[4] = yAxis.y;
+        result[5] = zAxis.y;
+        result[6] = xAxis.z;
+        result[7] = yAxis.z;
+        result[8] = zAxis.z;
+
+        return result;
+    }
+
+    var rotMtxScratch = new Matrix3();
+    var quatScratch = new Quaternion();
+
+    /**
+     * Computes a rotation from ICRF to a Central Body's Fixed axes.
+     * @memberof IauOrientationAxes
+     *
+     * @param {JulianDate} date The date to evaluate the matrix.
+     * @param {Matrix3} result The object onto which to store the result.
+     *
+     * @returns {Matrix} The modified result parameter or a new instance of the rotation from ICRF to Fixed.
+     */
+    IauOrientationAxes.prototype.evaluate = function(date, result) {
+        if (!defined(date)) {
+            date = new JulianDate();
+        }
+
+        var alphaDeltaW = this._computeFunction(date);
+        var precMtx = computeRotationMatrix(alphaDeltaW.rightAscension, alphaDeltaW.declination, result);
+
+        var rot = CesiumMath.zeroToTwoPi(alphaDeltaW.rotation);
+        var quat = Quaternion.fromAxisAngle(Cartesian3.UNIT_Z, rot, quatScratch);
+        var rotMtx = Matrix3.fromQuaternion(Quaternion.conjugate(quat, quat), rotMtxScratch);
+
+        var cbi2cbf = Matrix3.multiply(rotMtx, precMtx, precMtx);
+        return cbi2cbf;
+    };
+
+    return IauOrientationAxes;
+});

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

@@ -0,0 +1,48 @@
+/*global define*/
+define(['Core/defined', 'Core/DeveloperError'], function(
+        defined,
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * A structure containing the orientation data computed at a particular time. The data
+     * represents the direction of the pole of rotation and the rotation about that pole.
+     * <p>
+     * These parameters correspond to the parameters in the Report from the IAU/IAG Working Group
+     * except that they are expressed in radians.
+     * </p>
+     * @exports IauOrientationParameters
+     *
+     * @private
+     */
+    var IauOrientationParameters = function(rightAscension, declination, rotation, rotationRate) {
+        /**
+         * The right ascension of the north pole of the body with respect to
+         * the International Celestial Reference Frame, in radians.
+         * @type {Number}
+         */
+        this.rightAscension = rightAscension;
+
+        /**
+         * The declination of the north pole of the body with respect to
+         * the International Celestial Reference Frame, in radians.
+         * @type {Number}
+         */
+        this.declination = declination;
+
+        /**
+         * The rotation about the north pole used to align a set of axes with
+         * the meridian defined by the IAU report, in radians.
+         * @type {Number}
+         */
+        this.rotation = rotation;
+
+        /**
+         * The instantaneous rotation rate about the north pole, in radians per second.
+         * @type {Number}
+         */
+        this.rotationRate = rotationRate;
+    };
+
+    return IauOrientationParameters;
+});

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

@@ -298,7 +298,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', '
         var B = new Matrix3(firstAxis.x, secondAxis.x, thirdAxis.x,
                             firstAxis.y, secondAxis.y, thirdAxis.y,
                             firstAxis.z, secondAxis.z, thirdAxis.z);
-        var B_T = B.transpose();
+        var B_T = Matrix3.transpose(B);
 
         // Get the scaling matrix and its inverse.
         var D_I = Matrix3.fromScale(ellipsoid.getRadii());
@@ -308,9 +308,9 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', '
                             -direction.z, 0.0, direction.x,
                             direction.y, -direction.x, 0.0);
 
-        var temp = B_T.multiply(D).multiply(C);
-        var A = temp.multiply(D_I).multiply(B);
-        var b = temp.multiplyByVector(position);
+        var temp = Matrix3.multiply(Matrix3.multiply(B_T, D), C);
+        var A = Matrix3.multiply(Matrix3.multiply(temp, D_I), B);
+        var b = Matrix3.multiplyByVector(temp, position);
 
         // Solve for the solutions to the expression in standard form:
         var solutions = quadraticVectorExpression(A, Cartesian3.negate(b), 0.0, 0.0, 1.0);
@@ -323,7 +323,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', '
             var maximumValue = Number.NEGATIVE_INFINITY;
 
             for ( var i = 0; i < length; ++i) {
-                s = D_I.multiplyByVector(B.multiplyByVector(solutions[i]));
+                s = Matrix3.multiplyByVector(D_I, Matrix3.multiplyByVector(B, solutions[i]));
                 var v = Cartesian3.normalize(Cartesian3.subtract(s, position));
                 var dotProduct = Cartesian3.dot(v, direction);
 

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

@@ -669,6 +669,31 @@ define(['Core/DeveloperError', 'Core/binarySearch', 'Core/defined', 'Core/TimeCo
                 left._secondsOfDay === right._secondsOfDay);
     };
 
+    /**
+     * Returns <code>true</code> if the provided dates are within <code>epsilon</code> seconds of
+     * each other.  That is, in order for the dates to be considered equal (and for
+     * this function to return <code>true</code>), the absolute value of the difference between them, in
+     * seconds, must be less than <code>epsilon</code>.
+     *
+     * @memberof JulianDate
+     *
+     * @param {JulianDate} left The first JulianDate to be compared.
+     * @param {JulianDate} right The second JulianDate to be compared.
+     * @param {Number} epsilon The number of seconds that should separate the two JulianDates
+     *
+     * @returns {Boolean} <code>true</code> if the two JulianDates are within <code>epsilon</code> seconds of each other; otherwise <code>false</code>.
+     *
+     * @exception {DeveloperError} epsilon is required and must be a number.
+     *
+     * @see JulianDate#equals
+     */
+    JulianDate.equalsEpsilon = function(left, right, epsilon) {
+        if (epsilon === null || isNaN(epsilon)) {
+            throw new DeveloperError('epsilon is required and must be a number.');
+        }
+        return Math.abs(left.getSecondsDifference(right)) <= epsilon;
+    };
+
     /**
      * Duplicates this JulianDate.
      * @memberof JulianDate
@@ -1201,7 +1226,7 @@ define(['Core/DeveloperError', 'Core/binarySearch', 'Core/defined', 'Core/TimeCo
      *
      * @returns {Boolean} <code>true</code> if the two JulianDates are within <code>epsilon</code> seconds of each other; otherwise <code>false</code>.
      *
-     * @exception {DeveloperError} epsilon is required and must be number.
+     * @exception {DeveloperError} epsilon is required and must be a number.
      *
      * @see JulianDate#equals
      *
@@ -1211,10 +1236,7 @@ define(['Core/DeveloperError', 'Core/binarySearch', 'Core/defined', 'Core/TimeCo
      * original.equalsEpsilon(clone, 2);    // true
      */
     JulianDate.prototype.equalsEpsilon = function(other, epsilon) {
-        if (epsilon === null || isNaN(epsilon)) {
-            throw new DeveloperError('epsilon is required and must be number.');
-        }
-        return Math.abs(this.getSecondsDifference(other)) <= epsilon;
+        return JulianDate.equalsEpsilon(this, other, epsilon);
     };
 
     //To avoid circular dependencies, we load the default list of leap seconds