cesium 0.22.0 → 0.23.0

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

@@ -1,20 +1,12 @@
 /*global define*/
-define(['Core/Enumeration', 'Core/defined', 'Core/DeveloperError', 'Core/FeatureDetection', 'Core/Math'], function(
-        Enumeration,
+define(['Core/defined', 'Core/DeveloperError', 'Core/Math'], function(
         defined,
         DeveloperError,
-        FeatureDetection,
         CesiumMath) {
     "use strict";
 
-    // Bail out if the browser doesn't support typed arrays, to prevent the setup function
-    // from failing, since we won't be able to create a WebGL context anyway.
-    if (!FeatureDetection.supportsTypedArrays()) {
-        return {};
-    }
-
     /**
-     * Enumerations for WebGL index datatypes.  These corresponds to the
+     * Constants for WebGL index datatypes.  These corresponds to the
      * <code>type</code> parameter of <a href="http://www.khronos.org/opengles/sdk/docs/man/xhtml/glDrawElements.xml">drawElements</a>.
      *
      * @alias IndexDatatype
@@ -22,40 +14,57 @@ define(['Core/Enumeration', 'Core/defined', 'Core/DeveloperError', 'Core/Feature
      */
     var IndexDatatype = {
         /**
-         * 8-bit unsigned byte enumeration corresponding to <code>UNSIGNED_BYTE</code> and the type
+         * 0x1401.  8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
          * of an element in <code>Uint8Array</code>.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x1401
          */
-        UNSIGNED_BYTE : new Enumeration(0x1401, 'UNSIGNED_BYTE', {
-            sizeInBytes : Uint8Array.BYTES_PER_ELEMENT
-        }),
+        UNSIGNED_BYTE : 0x1401,
 
         /**
-         * 16-bit unsigned short enumeration corresponding to <code>UNSIGNED_SHORT</code> and the type
+         * 0x1403.  16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
          * of an element in <code>Uint16Array</code>.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x1403
          */
-        UNSIGNED_SHORT : new Enumeration(0x1403, 'UNSIGNED_SHORT', {
-            sizeInBytes : Uint16Array.BYTES_PER_ELEMENT
-        }),
+        UNSIGNED_SHORT : 0x1403,
 
         /**
-         * 32-bit unsigned int enumeration corresponding to <code>UNSIGNED_INT</code> and the type
+         * 0x1405.  32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
          * of an element in <code>Uint32Array</code>.
          *
-         * @type {Enumeration}
+         * @type {Number}
          * @constant
-         * @default 0x1405
          */
-        UNSIGNED_INT : new Enumeration(0x1405, 'UNSIGNED_INT', {
-            sizeInBytes : Uint32Array.BYTES_PER_ELEMENT
-        })
+        UNSIGNED_INT : 0x1405
+    };
+
+    /**
+     * Returns the size, in bytes, of the corresponding datatype.
+     *
+     * @param {IndexDatatype} indexDatatype The index datatype to get the size of.
+     *
+     * @returns {Number} The size in bytes.
+     *
+     * @exception {DeveloperError} indexDatatype is required and must be a valid IndexDatatype constant.
+     *
+     * @example
+     * // Returns 2
+     * var size = IndexDatatype.getSizeInBytes(IndexDatatype.UNSIGNED_SHORT);
+     */
+    IndexDatatype.getSizeInBytes = function(indexDatatype) {
+        switch(indexDatatype) {
+            case IndexDatatype.UNSIGNED_BYTE:
+                return Uint8Array.BYTES_PER_ELEMENT;
+            case IndexDatatype.UNSIGNED_SHORT:
+                return Uint16Array.BYTES_PER_ELEMENT;
+            case IndexDatatype.UNSIGNED_INT:
+                return Uint32Array.BYTES_PER_ELEMENT;
+        }
+
+        throw new DeveloperError('indexDatatype is required and must be a valid IndexDatatype constant.');
     };
 
     /**
@@ -63,18 +72,18 @@ define(['Core/Enumeration', 'Core/defined', 'Core/DeveloperError', 'Core/Feature
      *
      * @param {IndexDatatype} indexDatatype The index datatype to validate.
      *
-     * @returns {Boolean} <code>true</code> if the provided index datatype is a valid enumeration value; otherwise, <code>false</code>.
+     * @returns {Boolean} <code>true</code> if the provided index datatype is a valid value; otherwise, <code>false</code>.
      *
      * @example
      * if (!IndexDatatype.validate(indexDatatype)) {
-     *   throw new DeveloperError('indexDatatype must be a valid enumeration value.');
+     *   throw new DeveloperError('indexDatatype must be a valid value.');
      * }
      */
     IndexDatatype.validate = function(indexDatatype) {
-        return defined(indexDatatype) && defined(indexDatatype.value) &&
-               (indexDatatype.value === IndexDatatype.UNSIGNED_BYTE.value ||
-                indexDatatype.value === IndexDatatype.UNSIGNED_SHORT.value ||
-                indexDatatype.value === IndexDatatype.UNSIGNED_INT.value);
+        return defined(indexDatatype) &&
+               (indexDatatype === IndexDatatype.UNSIGNED_BYTE ||
+                indexDatatype === IndexDatatype.UNSIGNED_SHORT ||
+                indexDatatype === IndexDatatype.UNSIGNED_INT);
     };
 
     /**

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

@@ -0,0 +1,118 @@
+/*global define*/
+define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Spline', 'Core/Cartesian3'], function(
+        defaultValue,
+        defined,
+        DeveloperError,
+        Spline,
+        Cartesian3) {
+    "use strict";
+
+    /**
+     * A spline that uses piecewise linear interpolation to create a curve.
+     *
+     * @alias LinearSpline
+     * @constructor
+     *
+     * @param {Array} options.times The array of control point times.
+     * @param {Array} options.points The array of control points.
+     *
+     * @exception {DeveloperError} points is required.
+     * @exception {DeveloperError} points.length must be greater than or equal to 2.
+     * @exception {DeveloperError} times is required.
+     * @exception {DeveloperError} times.length must be equal to points.length.
+     *
+     * @example
+     * var spline = new LinearSpline({
+     *     times : [ 0.0, 1.5, 3.0, 4.5, 6.0 ],
+     *     points : [
+     *         new Cartesian3(1235398.0, -4810983.0, 4146266.0),
+     *         new Cartesian3(1372574.0, -5345182.0, 4606657.0),
+     *         new Cartesian3(-757983.0, -5542796.0, 4514323.0),
+     *         new Cartesian3(-2821260.0, -5248423.0, 4021290.0),
+     *         new Cartesian3(-2539788.0, -4724797.0, 3620093.0)
+     *     ]
+     * });
+     */
+    var LinearSpline = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+        var points = options.points;
+        var times = options.times;
+
+        if (!defined(points)) {
+            throw new DeveloperError('points is required.');
+        }
+
+        if (points.length < 2) {
+            throw new DeveloperError('points.length must be greater than or equal to 2.');
+        }
+
+        if (!defined(times)) {
+            throw new DeveloperError('times is required.');
+        }
+
+        if (times.length !== points.length) {
+            throw new DeveloperError('times.length must be equal to points.length.');
+        }
+
+        /**
+         * An array of times for the control points.
+         * @type {Array}
+         * @readonly
+         */
+        this.times = times;
+
+        /**
+         * An array of {@link Cartesian3} control points.
+         * @type {Array}
+         * @readonly
+         */
+        this.points = points;
+
+        this._lastTimeIndex = 0;
+    };
+
+    /**
+     * Finds an index <code>i</code> in <code>times</code> such that the parameter
+     * <code>time</code> is in the interval <code>[times[i], times[i + 1]]</code>.
+     * @memberof QuaternionSpline
+     *
+     * @param {Number} time The time.
+     * @returns {Number} The index for the element at the start of the interval.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
+     */
+    LinearSpline.prototype.findTimeInterval = Spline.prototype.findTimeInterval;
+
+    /**
+     * Evaluates the curve at a given time.
+     * @memberof LinearSpline
+     *
+     * @param {Number} time The time at which to evaluate the curve.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @returns {Cartesian3} The modified result parameter or a new instance of the point on the curve at the given time.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
+     */
+    LinearSpline.prototype.evaluate = function(time, result) {
+        var points = this.points;
+        var times = this.times;
+
+        var i = this._lastTimeIndex = this.findTimeInterval(time, this._lastTimeIndex);
+        var u = (time - times[i]) / (times[i + 1] - times[i]);
+
+        if (!defined(result)) {
+            result = new Cartesian3();
+        }
+
+        return Cartesian3.lerp(points[i], points[i + 1], u, result);
+    };
+
+    return LinearSpline;
+});

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

@@ -535,19 +535,50 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'ThirdParty/
      *
      * @returns {Boolean} <code>true</code> if the number if a power of two; otherwise, <code>false</code>.
      *
+     * @exception {DeveloperError} A number greater than or equal to 0 is required.
+     *
      * @example
      * var t = CesiumMath.isPowerOfTwo(16); // true
      * var f = CesiumMath.isPowerOfTwo(20); // false
+     */
+    CesiumMath.isPowerOfTwo = function(n) {
+        if (typeof n !== 'number' || n < 0) {
+            throw new DeveloperError('A number greater than or equal to 0 is required.');
+        }
+
+        return (n !== 0) && ((n & (n - 1)) === 0);
+    };
+
+    /**
+     * Computes the next power-of-two integer greater than or equal to the provided positive integer.
+     *
+     * @memberof CesiumMath
+     *
+     * @param {Number} n The positive integer to test.
+     *
+     * @returns {Number} The next power-of-two integer.
      *
      * @exception {DeveloperError} A number greater than or equal to 0 is required.
+     *
+     * @example
+     * var n = CesiumMath.nextPowerOfTwo(29); // 32
+     * var m = CesiumMath.nextPowerOfTwo(32); // 32
      */
-    CesiumMath.isPowerOfTwo = function(n) {
+    CesiumMath.nextPowerOfTwo = function(n) {
         if (typeof n !== 'number' || n < 0) {
             throw new DeveloperError('A number greater than or equal to 0 is required.');
         }
 
-        var m = defaultValue(n, 0);
-        return (m !== 0) && ((m & (m - 1)) === 0);
+        // From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+        --n;
+        n |= n >> 1;
+        n |= n >> 2;
+        n |= n >> 4;
+        n |= n >> 8;
+        n |= n >> 16;
+        ++n;
+
+        return n;
     };
 
     /**

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

@@ -543,6 +543,32 @@ define(['Core/Cartesian2', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         return result;
     };
 
+    /**
+     * Computes a matrix, which contains the absolute (unsigned) values of the provided matrix's elements.
+     * @memberof Matrix2
+     *
+     * @param {Matrix2} matrix The matrix with signed elements.
+     * @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} matrix is required.
+     */
+    Matrix2.abs = function(matrix, result) {
+        if (!defined(matrix)) {
+            throw new DeveloperError('matrix is required');
+        }
+        if (!defined(result)) {
+            return new Matrix2(Math.abs(matrix[0]), Math.abs(matrix[2]),
+                               Math.abs(matrix[1]), Math.abs(matrix[3]));
+        }
+        result[0] = Math.abs(matrix[0]);
+        result[1] = Math.abs(matrix[1]);
+        result[2] = Math.abs(matrix[2]);
+        result[3] = Math.abs(matrix[3]);
+
+        return result;
+    };
+
     /**
      * Compares the provided matrices componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.

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

@@ -939,6 +939,104 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         return result;
     };
 
+    /**
+     * Computes a matrix, which contains the absolute (unsigned) values of the provided matrix's elements.
+     * @memberof Matrix3
+     *
+     * @param {Matrix3} matrix The matrix with signed elements.
+     * @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} matrix is required.
+     */
+    Matrix3.abs = function(matrix, result) {
+        if (!defined(matrix)) {
+            throw new DeveloperError('matrix is required');
+        }
+        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]),
+                               Math.abs(matrix[2]), Math.abs(matrix[5]), Math.abs(matrix[8]));
+        }
+        result[0] = Math.abs(matrix[0]);
+        result[1] = Math.abs(matrix[1]);
+        result[2] = Math.abs(matrix[2]);
+        result[3] = Math.abs(matrix[3]);
+        result[4] = Math.abs(matrix[4]);
+        result[5] = Math.abs(matrix[5]);
+        result[6] = Math.abs(matrix[6]);
+        result[7] = Math.abs(matrix[7]);
+        result[8] = Math.abs(matrix[8]);
+
+        return result;
+    };
+
+    /**
+     * Computes the determinant of the provided matrix.
+     * @memberof Matrix3
+     *
+     * @param {Matrix3} matrix The matrix to use.
+     * @returns {Number} The value of the determinant of the matrix.
+     *
+     * @exception {DeveloperError} matrix is required.
+     */
+    Matrix3.determinant = function(matrix) {
+        if (!defined(matrix)) {
+            throw new DeveloperError('matrix is required');
+        }
+
+        var m11 = matrix[0];
+        var m21 = matrix[3];
+        var m31 = matrix[6];
+        var m12 = matrix[1];
+        var m22 = matrix[4];
+        var m32 = matrix[7];
+        var m13 = matrix[2];
+        var m23 = matrix[5];
+        var m33 = matrix[8];
+
+        return m11 * (m22 * m33 - m23 * m32) + m12 * (m23 * m31 - m21 * m33) + m13 * (m21 * m32 - m22 * m31);
+    };
+
+    /**
+     * Computes the inverse of the provided matrix.
+     * @memberof Matrix3
+     *
+     * @param {Matrix3} matrix The matrix to invert.
+     * @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} matrix is required.
+     * @exception {DeveloperError} matrix is not invertible.
+     */
+    Matrix3.inverse = function(matrix, result) {
+        if (!defined(matrix)) {
+            throw new DeveloperError('matrix is required');
+        }
+
+        var m11 = matrix[0];
+        var m21 = matrix[1];
+        var m31 = matrix[2];
+        var m12 = matrix[3];
+        var m22 = matrix[4];
+        var m32 = matrix[5];
+        var m13 = matrix[6];
+        var m23 = matrix[7];
+        var m33 = matrix[8];
+
+        var determinant = Matrix3.determinant(matrix);
+
+        if (Math.abs(determinant) <= CesiumMath.EPSILON15) {
+            throw new DeveloperError('matrix is not invertible');
+        }
+
+        var m = new Matrix3(m22 * m33 - m23 * m32, m13 * m32 - m12 * m33, m12 * m23 - m13 * m22,
+                            m23 * m31 - m21 * m33, m11 * m33 - m13 * m31, m13 * m21 - m11 * m23,
+                            m21 * m32 - m22 * m31, m12 * m31 - m11 * m32, m11 * m22 - m12 * m21);
+       var scale = 1.0 / determinant;
+       return Matrix3.multiplyByScalar(m, scale, result);
+    };
+
     /**
      * Compares the provided matrices componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.

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

@@ -1681,6 +1681,48 @@ define(['Core/Cartesian3', 'Core/Cartesian4', 'Core/defaultValue', 'Core/defined
         return result;
     };
 
+    /**
+     * Computes a matrix, which contains the absolute (unsigned) values of the provided matrix's elements.
+     * @memberof Matrix4
+     *
+     * @param {Matrix4} matrix The matrix with signed elements.
+     * @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} matrix is required.
+     */
+    Matrix4.abs = function(matrix, result) {
+        if (!defined(matrix)) {
+            throw new DeveloperError('matrix is required');
+        }
+        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]),
+                               Math.abs(matrix[2]), Math.abs(matrix[6]), Math.abs(matrix[10]), Math.abs(matrix[14]),
+                               Math.abs(matrix[3]), Math.abs(matrix[7]), Math.abs(matrix[11]), Math.abs(matrix[15]));
+
+        }
+
+        result[0] = Math.abs(matrix[0]);
+        result[1] = Math.abs(matrix[1]);
+        result[2] = Math.abs(matrix[2]);
+        result[3] = Math.abs(matrix[3]);
+        result[4] = Math.abs(matrix[4]);
+        result[5] = Math.abs(matrix[5]);
+        result[6] = Math.abs(matrix[6]);
+        result[7] = Math.abs(matrix[7]);
+        result[8] = Math.abs(matrix[8]);
+        result[9] = Math.abs(matrix[9]);
+        result[10] = Math.abs(matrix[10]);
+        result[11] = Math.abs(matrix[11]);
+        result[12] = Math.abs(matrix[12]);
+        result[13] = Math.abs(matrix[13]);
+        result[14] = Math.abs(matrix[14]);
+        result[15] = Math.abs(matrix[15]);
+
+        return result;
+    };
+
     /**
      * Compares the provided matrices componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.