cesium 0.23.0 → 0.24.0

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

@@ -75,6 +75,57 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         return result;
     };
 
+    /**
+     * Creates a Matrix3 from 9 consecutive elements in an array.
+     * @memberof Matrix3
+     *
+     * @param {Array} array The array whose 9 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 {Matrix3} [result] The object onto which to store the result.
+     *
+     * @returns {Matrix3} The modified result parameter or a new Matrix3 instance if one was not provided.
+     *
+     * @exception {DeveloperError} array is required.
+     *
+     * @example
+     * // Create the Matrix3:
+     * // [1.0, 2.0, 3.0]
+     * // [1.0, 2.0, 3.0]
+     * // [1.0, 2.0, 3.0]
+     *
+     * var v = [1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0];
+     * var m = Matrix3.fromArray(v);
+     *
+     * // Create same Matrix3 with using an offset into an array
+     * var v2 = [0.0, 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0];
+     * var m2 = Matrix3.fromArray(v2, 2);
+     */
+    Matrix3.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 Matrix3();
+        }
+
+        result[0] = array[startingIndex];
+        result[1] = array[startingIndex + 1];
+        result[2] = array[startingIndex + 2];
+        result[3] = array[startingIndex + 3];
+        result[4] = array[startingIndex + 4];
+        result[5] = array[startingIndex + 5];
+        result[6] = array[startingIndex + 6];
+        result[7] = array[startingIndex + 7];
+        result[8] = array[startingIndex + 8];
+        result[9] = array[startingIndex + 9];
+        return result;
+    };
+
     /**
      * Creates a Matrix3 instance from a column-major order array.
      * @memberof Matrix3
@@ -87,9 +138,12 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} values is required.
      */
     Matrix3.fromColumnMajorArray = function(values, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(values)) {
             throw new DeveloperError('values parameter is required');
         }
+        //>>includeEnd('debug');
+
         return Matrix3.clone(values, result);
     };
 
@@ -105,9 +159,12 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} values is required.
      */
     Matrix3.fromRowMajorArray = function(values, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(values)) {
             throw new DeveloperError('values is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix3(values[0], values[1], values[2],
                                values[3], values[4], values[5],
@@ -134,9 +191,12 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @returns {Matrix3} The 3x3 rotation matrix from this quaternion.
      */
     Matrix3.fromQuaternion = function(quaternion, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(quaternion)) {
             throw new DeveloperError('quaternion is required');
         }
+        //>>includeEnd('debug');
+
         var x2 = quaternion.x * quaternion.x;
         var xy = quaternion.x * quaternion.y;
         var xz = quaternion.x * quaternion.z;
@@ -195,9 +255,12 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var m = Matrix3.fromScale(new Cartesian3(7.0, 8.0, 9.0));
      */
     Matrix3.fromScale = function(scale, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(scale)) {
             throw new DeveloperError('scale is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix3(
                 scale.x, 0.0,     0.0,
@@ -235,9 +298,12 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var m = Matrix3.fromUniformScale(2.0);
      */
     Matrix3.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 Matrix3(
                 scale, 0.0,   0.0,
@@ -274,9 +340,11 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var rotated = Matrix3.multiplyByVector(m, p);
      */
     Matrix3.fromRotationX = 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);
@@ -318,9 +386,11 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var rotated = Matrix3.multiplyByVector(m, p);
      */
     Matrix3.fromRotationY = 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);
@@ -362,9 +432,11 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var rotated = Matrix3.multiplyByVector(m, p);
      */
     Matrix3.fromRotationZ = 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);
@@ -401,9 +473,12 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix3.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], matrix[4], matrix[5], matrix[6], matrix[7], matrix[8]];
         }
@@ -437,12 +512,15 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * myMatrix[column1Row0Index] = 10.0;
      */
     Matrix3.getElementIndex = function(column, row) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof row !== 'number' || row < 0 || row > 2) {
             throw new DeveloperError('row is required and must be 0, 1, or 2.');
         }
         if (typeof column !== 'number' || column < 0 || column > 2) {
             throw new DeveloperError('column is required and must be 0, 1, or 2.');
         }
+        //>>includeEnd('debug');
+
         return column * 3 + row;
     };
 
@@ -461,6 +539,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian3
      */
     Matrix3.getColumn = function(matrix, index, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required.');
         }
@@ -468,6 +547,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 2) {
             throw new DeveloperError('index is required and must be 0, 1, or 2.');
         }
+        //>>includeEnd('debug');
 
         var startIndex = index * 3;
         var x = matrix[startIndex];
@@ -500,6 +580,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian3
      */
     Matrix3.setColumn = function(matrix, index, cartesian, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
@@ -509,6 +590,8 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 2) {
             throw new DeveloperError('index is required and must be 0, 1, or 2.');
         }
+        //>>includeEnd('debug');
+
         result = Matrix3.clone(matrix, result);
         var startIndex = index * 3;
         result[startIndex] = cartesian.x;
@@ -532,6 +615,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian3
      */
     Matrix3.getRow = function(matrix, index, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required.');
         }
@@ -539,6 +623,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 2) {
             throw new DeveloperError('index is required and must be 0, 1, or 2.');
         }
+        //>>includeEnd('debug');
 
         var x = matrix[index];
         var y = matrix[index + 3];
@@ -570,6 +655,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @see Cartesian3
      */
     Matrix3.setRow = function(matrix, index, cartesian, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
@@ -579,6 +665,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (typeof index !== 'number' || index < 0 || index > 2) {
             throw new DeveloperError('index is required and must be 0, 1, or 2.');
         }
+        //>>includeEnd('debug');
 
         result = Matrix3.clone(matrix, result);
         result[index] = cartesian.x;
@@ -600,12 +687,14 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} right is required.
      */
     Matrix3.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[3] * right[1] + left[6] * right[2];
         var column0Row1 = left[1] * right[0] + left[4] * right[1] + left[7] * right[2];
@@ -649,12 +738,14 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} cartesian is required.
      */
     Matrix3.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 vX = cartesian.x;
         var vY = cartesian.y;
@@ -686,12 +777,14 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} scalar is required and must be a number.
      */
     Matrix3.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 Matrix3(matrix[0] * scalar, matrix[3] * scalar, matrix[6] * scalar,
@@ -721,9 +814,11 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix3.negate = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
 
         if (!defined(result)) {
             return new Matrix3(-matrix[0], -matrix[3], -matrix[6],
@@ -753,9 +848,11 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix3.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[3];
@@ -901,9 +998,11 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * var c = Cartesian3.multiplyByScalar(v, lambda);        // equal to Matrix3.multiplyByVector(a, v)
      */
     Matrix3.getEigenDecomposition = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required.');
         }
+        //>>includeEnd('debug');
 
         // This routine was created based upon Matrix Computations, 3rd ed., by Golub and Van Loan,
         // section 8.4.3 The Classical Jacobi Algorithm
@@ -950,9 +1049,12 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} matrix is required.
      */
     Matrix3.abs = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix3(Math.abs(matrix[0]), Math.abs(matrix[3]), Math.abs(matrix[6]),
                                Math.abs(matrix[1]), Math.abs(matrix[4]), Math.abs(matrix[7]),
@@ -1075,9 +1177,11 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
      * @exception {DeveloperError} epsilon is required and must be a number.
      */
     Matrix3.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) &&

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

@@ -109,6 +109,64 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         return result;
     };
 
+    /**
+     * Creates a Matrix4 from 16 consecutive elements in an array.
+     * @memberof Matrix4
+     *
+     * @param {Array} array The array whose 16 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 {Matrix4} [result] The object onto which to store the result.
+     *
+     * @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
+     *
+     * @exception {DeveloperError} array is required.
+     *
+     * @example
+     * // Create the Matrix4:
+     * // [1.0, 2.0, 3.0, 4.0]
+     * // [1.0, 2.0, 3.0, 4.0]
+     * // [1.0, 2.0, 3.0, 4.0]
+     * // [1.0, 2.0, 3.0, 4.0]
+     *
+     * var v = [1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0];
+     * var m = Matrix4.fromArray(v);
+     *
+     * // Create same Matrix4 with using an offset into an array
+     * var v2 = [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0];
+     * var m2 = Matrix4.fromArray(v2, 2);
+     */
+    Matrix4.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 Matrix4();
+        }
+
+        result[0] = array[startingIndex];
+        result[1] = array[startingIndex + 1];
+        result[2] = array[startingIndex + 2];
+        result[3] = array[startingIndex + 3];
+        result[4] = array[startingIndex + 4];
+        result[5] = array[startingIndex + 5];
+        result[6] = array[startingIndex + 6];
+        result[7] = array[startingIndex + 7];
+        result[8] = array[startingIndex + 8];
+        result[9] = array[startingIndex + 9];
+        result[10] = array[startingIndex + 10];
+        result[11] = array[startingIndex + 11];
+        result[12] = array[startingIndex + 12];
+        result[13] = array[startingIndex + 13];
+        result[14] = array[startingIndex + 14];
+        result[15] = array[startingIndex + 15];
+        return result;
+    };
+
     /**
      * Computes a Matrix4 instance from a column-major order array.
      * @memberof Matrix4
@@ -121,9 +179,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} values is required.
      */
     Matrix4.fromColumnMajorArray = function(values, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(values)) {
             throw new DeveloperError('values parameter is required');
         }
+        //>>includeEnd('debug');
+
         return Matrix4.clone(values, result);
     };
 
@@ -139,9 +200,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} values is required.
      */
     Matrix4.fromRowMajorArray = function(values, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(values)) {
             throw new DeveloperError('values is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix4(values[0], values[1], values[2], values[3],
                                values[4], values[5], values[6], values[7],
@@ -181,12 +245,15 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} translation is required.
      */
     Matrix4.fromRotationTranslation = function(rotation, translation, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(rotation)) {
             throw new DeveloperError('rotation is required.');
         }
         if (!defined(translation)) {
             throw new DeveloperError('translation is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix4(rotation[0], rotation[3], rotation[6], translation.x,
                                rotation[1], rotation[4], rotation[7], translation.y,
@@ -239,6 +306,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *   result);
      */
     Matrix4.fromTranslationQuaternionRotationScale = function(translation, rotation, scale, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(translation)) {
             throw new DeveloperError('translation is required.');
         }
@@ -248,6 +316,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (!defined(scale)) {
             throw new DeveloperError('scale is required.');
         }
+        //>>includeEnd('debug');
 
         if (!defined(result)) {
             result = new Matrix4();
@@ -335,9 +404,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * var m = Matrix4.fromScale(new Cartesian3(7.0, 8.0, 9.0));
      */
     Matrix4.fromScale = function(scale, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(scale)) {
             throw new DeveloperError('scale is required.');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix4(
                 scale.x, 0.0,     0.0,     0.0,
@@ -384,9 +456,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * var m = Matrix4.fromScale(2.0);
      */
     Matrix4.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 Matrix4(scale, 0.0,   0.0,   0.0,
                                0.0,   scale, 0.0,   0.0,
@@ -431,14 +506,17 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} camera.up is required.
      */
     Matrix4.fromCamera = function(camera, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(camera)) {
             throw new DeveloperError('camera is required.');
         }
+        //>>includeEnd('debug');
 
         var eye = camera.eye;
         var target = camera.target;
         var up = camera.up;
 
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(eye)) {
             throw new DeveloperError('camera.eye is required.');
         }
@@ -448,6 +526,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (!defined(up)) {
             throw new DeveloperError('camera.up is required.');
         }
+        //>>includeEnd('debug');
 
         Cartesian3.normalize(Cartesian3.subtract(target, eye, fromCameraF), fromCameraF);
         Cartesian3.normalize(Cartesian3.cross(fromCameraF, up, fromCameraS), fromCameraS);
@@ -528,6 +607,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
       * @exception {DeveloperError} far must be greater than zero.
       */
     Matrix4.computePerspectiveFieldOfView = function(fovY, aspectRatio, near, far, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (fovY <= 0.0 || fovY > Math.PI) {
             throw new DeveloperError('fovY must be in [0, PI).');
         }
@@ -543,6 +623,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (far <= 0.0) {
             throw new DeveloperError('far must be greater than zero.');
         }
+        //>>includeEnd('debug');
 
         var bottom = Math.tan(fovY * 0.5);
 
@@ -598,6 +679,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
     * @exception {DeveloperError} far is required.
     */
     Matrix4.computeOrthographicOffCenter = function(left, right, bottom, top, near, far, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(left)) {
             throw new DeveloperError('left is required.');
         }
@@ -616,6 +698,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (!defined(far)) {
             throw new DeveloperError('far is required.');
         }
+        //>>includeEnd('debug');
 
         var a = 1.0 / (right - left);
         var b = 1.0 / (top - bottom);
@@ -675,6 +758,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} far is required.
      */
     Matrix4.computePerspectiveOffCenter = function(left, right, bottom, top, near, far, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(left)) {
             throw new DeveloperError('left is required.');
         }
@@ -693,6 +777,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (!defined(far)) {
             throw new DeveloperError('far is required.');
         }
+        //>>includeEnd('debug');
 
         var column0Row0 = 2.0 * near / (right - left);
         var column1Row1 = 2.0 * near / (top - bottom);
@@ -748,6 +833,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} near is required.
      */
     Matrix4.computeInfinitePerspectiveOffCenter = function(left, right, bottom, top, near, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(left)) {
             throw new DeveloperError('left is required.');
         }
@@ -763,6 +849,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (!defined(near)) {
             throw new DeveloperError('near is required.');
         }
+        //>>includeEnd('debug');
 
         var column0Row0 = 2.0 * near / (right - left);
         var column1Row1 = 2.0 * near / (top - bottom);
@@ -893,9 +980,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.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],
                     matrix[4], matrix[5], matrix[6], matrix[7],
@@ -939,12 +1029,15 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * myMatrix[column1Row0Index] = 10.0;
      */
     Matrix4.getElementIndex = function(column, row) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof row !== 'number' || row < 0 || row > 3) {
             throw new DeveloperError('row is required and must be 0, 1, 2, or 3.');
         }
         if (typeof column !== 'number' || column < 0 || column > 3) {
             throw new DeveloperError('column is required and must be 0, 1, 2, or 3.');
         }
+        //>>includeEnd('debug');
+
         return column * 4 + row;
     };
 
@@ -980,6 +1073,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.getColumn = function(matrix, index, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required.');
         }
@@ -987,6 +1081,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (typeof index !== 'number' || index < 0 || index > 3) {
             throw new DeveloperError('index is required and must be 0, 1, 2, or 3.');
         }
+        //>>includeEnd('debug');
 
         var startIndex = index * 4;
         var x = matrix[startIndex];
@@ -1037,6 +1132,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.setColumn = function(matrix, index, cartesian, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
@@ -1046,6 +1142,8 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (typeof index !== 'number' || index < 0 || index > 3) {
             throw new DeveloperError('index is required and must be 0, 1, 2, or 3.');
         }
+        //>>includeEnd('debug');
+
         result = Matrix4.clone(matrix, result);
         var startIndex = index * 4;
         result[startIndex] = cartesian.x;
@@ -1086,6 +1184,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * // a.x = 18.0; a.y = 19.0; a.z = 20.0; a.w = 21.0;
      */
     Matrix4.getRow = function(matrix, index, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required.');
         }
@@ -1093,6 +1192,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (typeof index !== 'number' || index < 0 || index > 3) {
             throw new DeveloperError('index is required and must be 0, 1, 2, or 3.');
         }
+        //>>includeEnd('debug');
 
         var x = matrix[index];
         var y = matrix[index + 4];
@@ -1142,6 +1242,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.setRow = function(matrix, index, cartesian, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
@@ -1151,6 +1252,7 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         if (typeof index !== 'number' || index < 0 || index > 3) {
             throw new DeveloperError('index is required and must be 0, 1, 2, or 3.');
         }
+        //>>includeEnd('debug');
 
         result = Matrix4.clone(matrix, result);
         result[index] = cartesian.x;
@@ -1173,12 +1275,14 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} right is required.
      */
     Matrix4.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 left0 = left[0];
         var left1 = left[1];
@@ -1259,6 +1363,106 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         return result;
     };
 
+    /**
+     * Computes the product of two matrices assuming the matrices are
+     * affine transformation matrices, where the upper left 3x3 elements
+     * are a rotation matrix, and the upper three elements in the fourth
+     * column are the translation.  The bottom row is assumed to be [0, 0, 0, 1].
+     * The matrix is not verified to be in the proper form.
+     * This method is faster than computing the product for general 4x4
+     * matrices using {@link #multiply}.
+     * @memberof Matrix4
+     *
+     * @param {Matrix4} left The first matrix.
+     * @param {Matrix4} right The second matrix.
+     * @param {Matrix4} [result] The object onto which to store the result.
+     * @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
+     *
+     * @exception {DeveloperError} left is required.
+     * @exception {DeveloperError} right is required.
+     *
+     * @example
+     * var m1 = new Matrix4(1.0, 6.0, 7.0, 0.0, 2.0, 5.0, 8.0, 0.0, 3.0, 4.0, 9.0, 0.0, 0.0, 0.0, 0.0, 1.0];
+     * var m2 = Transforms.eastNorthUpToFixedFrame(new Cartesian3(1.0, 1.0, 1.0));
+     * var m3 = Matrix4.multiplyTransformation(m1, m2);
+     */
+    Matrix4.multiplyTransformation = 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 left0 = left[0];
+        var left1 = left[1];
+        var left2 = left[2];
+        var left4 = left[4];
+        var left5 = left[5];
+        var left6 = left[6];
+        var left8 = left[8];
+        var left9 = left[9];
+        var left10 = left[10];
+        var left12 = left[12];
+        var left13 = left[13];
+        var left14 = left[14];
+
+        var right0 = right[0];
+        var right1 = right[1];
+        var right2 = right[2];
+        var right4 = right[4];
+        var right5 = right[5];
+        var right6 = right[6];
+        var right8 = right[8];
+        var right9 = right[9];
+        var right10 = right[10];
+        var right12 = right[12];
+        var right13 = right[13];
+        var right14 = right[14];
+
+        var column0Row0 = left0 * right0 + left4 * right1 + left8 * right2;
+        var column0Row1 = left1 * right0 + left5 * right1 + left9 * right2;
+        var column0Row2 = left2 * right0 + left6 * right1 + left10 * right2;
+
+        var column1Row0 = left0 * right4 + left4 * right5 + left8 * right6;
+        var column1Row1 = left1 * right4 + left5 * right5 + left9 * right6;
+        var column1Row2 = left2 * right4 + left6 * right5 + left10 * right6;
+
+        var column2Row0 = left0 * right8 + left4 * right9 + left8 * right10;
+        var column2Row1 = left1 * right8 + left5 * right9 + left9 * right10;
+        var column2Row2 = left2 * right8 + left6 * right9 + left10 * right10;
+
+        var column3Row0 = left0 * right12 + left4 * right13 + left8 * right14 + left12;
+        var column3Row1 = left1 * right12 + left5 * right13 + left9 * right14 + left13;
+        var column3Row2 = left2 * right12 + left6 * right13 + left10 * right14 + left14;
+
+        if (!defined(result)) {
+            return new Matrix4(column0Row0, column1Row0, column2Row0, column3Row0,
+                               column0Row1, column1Row1, column2Row1, column3Row1,
+                               column0Row2, column1Row2, column2Row2, column3Row2,
+                               0.0, 0.0, 0.0, 1.0);
+        }
+        result[0] = column0Row0;
+        result[1] = column0Row1;
+        result[2] = column0Row2;
+        result[3] = 0.0;
+        result[4] = column1Row0;
+        result[5] = column1Row1;
+        result[6] = column1Row2;
+        result[7] = 0.0;
+        result[8] = column2Row0;
+        result[9] = column2Row1;
+        result[10] = column2Row2;
+        result[11] = 0.0;
+        result[12] = column3Row0;
+        result[13] = column3Row1;
+        result[14] = column3Row2;
+        result[15] = 1.0;
+        return result;
+    };
+
     /**
      * Multiplies a transformation matrix (with a bottom row of <code>[0.0, 0.0, 0.0, 1.0]</code>)
      * by an implicit translation matrix defined by a {@link Cartesian3}.  This is an optimization
@@ -1282,12 +1486,14 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * Matrix4.multiplyByTranslation(m, position, m);
      */
     Matrix4.multiplyByTranslation = function(matrix, translation, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
         if (!defined(translation)) {
             throw new DeveloperError('translation is required');
         }
+        //>>includeEnd('debug');
 
         var x = translation.x;
         var y = translation.y;
@@ -1349,9 +1555,11 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * Matrix4.multiplyByUniformScale(m, scale, m);
      */
     Matrix4.multiplyByUniformScale = function(matrix, scale, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (typeof scale !== 'number') {
             throw new DeveloperError('scale is required');
         }
+        //>>includeEnd('debug');
 
         uniformScaleScratch.x = scale;
         uniformScaleScratch.y = scale;
@@ -1383,12 +1591,14 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * Matrix4.multiplyByUniformScale(m, scale, m);
      */
     Matrix4.multiplyByScale = function(matrix, scale, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
         if (!defined(scale)) {
             throw new DeveloperError('scale is required');
         }
+        //>>includeEnd('debug');
 
         var scaleX = scale.x;
         var scaleY = scale.y;
@@ -1439,12 +1649,14 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} cartesian is required.
      */
     Matrix4.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 vX = cartesian.x;
         var vY = cartesian.y;
@@ -1466,39 +1678,96 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         return result;
     };
 
-    var scratchPoint = new Cartesian4(0.0, 0.0, 0.0, 1.0);
-
     /**
      * Computes the product of a matrix and a {@link Cartesian3}.  This is equivalent to calling {@link Matrix4.multiplyByVector}
-     * with a {@link Cartesian4} with a <code>w</code> component of one.
+     * with a {@link Cartesian4} with a <code>w</code> component of zero.
      * @memberof Matrix4
      *
      * @param {Matrix4} matrix The matrix.
      * @param {Cartesian3} cartesian The point.
-     * @param {Cartesian4} [result] The object onto which to store the result.
-     * @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
      *
      * @exception {DeveloperError} cartesian is required.
      * @exception {DeveloperError} matrix is required.
      *
      * @example
      * Cartesian3 p = new Cartesian3(1.0, 2.0, 3.0);
-     * Matrix4.multiplyByPoint(matrix, p, result);
+     * Matrix4.multiplyByPointAsVector(matrix, p, result);
      * // A shortcut for
      * //   Cartesian3 p = ...
-     * //   Matrix4.multiplyByVector(matrix, new Cartesian4(p.x, p.y, p.z, 1.0), result);
+     * //   Matrix4.multiplyByVector(matrix, new Cartesian4(p.x, p.y, p.z, 0.0), result);
+     */
+    Matrix4.multiplyByPointAsVector = 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 vX = cartesian.x;
+        var vY = cartesian.y;
+        var vZ = cartesian.z;
+
+        var x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ;
+        var y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ;
+        var z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ;
+
+        if (!defined(result)) {
+            return new Cartesian3(x, y, z);
+        }
+        result.x = x;
+        result.y = y;
+        result.z = z;
+        return result;
+    };
+
+    /**
+     * Computes the product of a matrix and a {@link Cartesian3}. This is equivalent to calling {@link Matrix4.multiplyByVector}
+     * with a {@link Cartesian4} with a <code>w</code> component of 1, but returns a {@link Cartesian3} instead of a {@link Cartesian4}.
+     * @memberof Matrix4
+     *
+     * @param {Matrix4} matrix The matrix.
+     * @param {Cartesian3} cartesian The point.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
+     *
+     * @exception {DeveloperError} cartesian is required.
+     * @exception {DeveloperError} matrix is required.
+     *
+     * @example
+     * Cartesian3 p = new Cartesian3(1.0, 2.0, 3.0);
+     * Matrix4.multiplyByPoint(matrix, p, result);
      */
     Matrix4.multiplyByPoint = 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 vX = cartesian.x;
+        var vY = cartesian.y;
+        var vZ = cartesian.z;
 
-        scratchPoint.x = cartesian.x;
-        scratchPoint.y = cartesian.y;
-        scratchPoint.z = cartesian.z;
-        // scratchPoint.w is one.  See above.
+        var x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ + matrix[12];
+        var y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ + matrix[13];
+        var z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ + matrix[14];
 
-        return Matrix4.multiplyByVector(matrix, scratchPoint, result);
+        if (!defined(result)) {
+            return new Cartesian3(x, y, z);
+        }
+        result.x = x;
+        result.y = y;
+        result.z = z;
+        return result;
     };
 
     /**
@@ -1530,12 +1799,14 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.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 Matrix4(matrix[0] * scalar, matrix[4] * scalar, matrix[8] * scalar, matrix[12] * scalar,
@@ -1589,9 +1860,11 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.negate = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
 
         if (!defined(result)) {
             return new Matrix4(-matrix[0], -matrix[4], -matrix[8], -matrix[12],
@@ -1645,9 +1918,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.transpose = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix4(matrix[0], matrix[1], matrix[2], matrix[3],
                                matrix[4], matrix[5], matrix[6], matrix[7],
@@ -1692,9 +1968,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} matrix is required.
      */
     Matrix4.abs = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix4(Math.abs(matrix[0]), Math.abs(matrix[4]), Math.abs(matrix[8]), Math.abs(matrix[12]),
                                Math.abs(matrix[1]), Math.abs(matrix[5]), Math.abs(matrix[9]), Math.abs(matrix[13]),
@@ -1812,9 +2091,11 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.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) &&
@@ -1850,9 +2131,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @see Cartesian3
      */
     Matrix4.getTranslation = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Cartesian3(matrix[12], matrix[13], matrix[14]);
         }
@@ -1891,9 +2175,12 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      *
      */
     Matrix4.getRotation = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
+
         if (!defined(result)) {
             return new Matrix3(matrix[0], matrix[4], matrix[8],
                                matrix[1], matrix[5], matrix[9],
@@ -1926,9 +2213,11 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
       * @exception {RuntimeError} matrix is not invertible because its determinate is zero.
       */
     Matrix4.inverse = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
 
         //
         // Ported from:
@@ -2051,9 +2340,11 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
      * @exception {DeveloperError} matrix is required.
      */
     Matrix4.inverseTransformation = function(matrix, result) {
+        //>>includeStart('debug', pragmas.debug);
         if (!defined(matrix)) {
             throw new DeveloperError('matrix is required');
         }
+        //>>includeEnd('debug');
 
         //This function is an optimized version of the below 4 lines.
         //var rT = Matrix3.transpose(Matrix4.getRotation(matrix));