cesium 0.13.0

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

@@ -0,0 +1,119 @@
+/*global define*/
+define(['./Enumeration'], function(Enumeration) {
+    "use strict";
+
+    // Earlier versions of IE do not support typed arrays, and as a result,
+    // using them below will cause the setup function itself to fail, causing
+    // the page to abort load, and preventing us from prompting to install
+    // Chrome Frame.  To avoid this, bail out early and return a dummy object,
+    // since we won't be able to create a WebGL context anyway.
+    if (typeof Int8Array === 'undefined') {
+        return {};
+    }
+
+    /**
+     * DOC_TBA
+     *
+     * @alias ComponentDatatype
+     * @enumeration
+     */
+    var ComponentDatatype = {};
+
+    /**
+     * DOC_TBA
+     *
+     * @constant
+     * @type {Enumeration}
+     * @memberOf ComponentDatatype
+     */
+    ComponentDatatype.BYTE = new Enumeration(0x1400, 'BYTE');
+    ComponentDatatype.BYTE.sizeInBytes = Int8Array.BYTES_PER_ELEMENT;
+    ComponentDatatype.BYTE.toTypedArray = function(values) {
+        return new Int8Array(values);
+    };
+
+    ComponentDatatype.BYTE.createArrayBufferView = function(buffer, byteOffset) {
+        return new Int8Array(buffer, byteOffset);
+    };
+
+    /**
+     * DOC_TBA
+     *
+     * @constant
+     * @type {Enumeration}
+     * @memberOf ComponentDatatype
+     */
+    ComponentDatatype.UNSIGNED_BYTE = new Enumeration(0x1401, 'UNSIGNED_BYTE');
+    ComponentDatatype.UNSIGNED_BYTE.sizeInBytes = Uint8Array.BYTES_PER_ELEMENT;
+    ComponentDatatype.UNSIGNED_BYTE.toTypedArray = function(values) {
+        return new Uint8Array(values);
+    };
+
+    ComponentDatatype.UNSIGNED_BYTE.createArrayBufferView = function(buffer, byteOffset) {
+        return new Uint8Array(buffer, byteOffset);
+    };
+
+    /**
+     * DOC_TBA
+     *
+     * @constant
+     * @type {Enumeration}
+     * @memberOf ComponentDatatype
+     */
+    ComponentDatatype.SHORT = new Enumeration(0x1402, 'SHORT');
+    ComponentDatatype.SHORT.sizeInBytes = Int16Array.BYTES_PER_ELEMENT;
+    ComponentDatatype.SHORT.toTypedArray = function(values) {
+        return new Int16Array(values);
+    };
+
+    ComponentDatatype.SHORT.createArrayBufferView = function(buffer, byteOffset) {
+        return new Int16Array(buffer, byteOffset);
+    };
+
+    /**
+     * DOC_TBA
+     *
+     * @constant
+     * @type {Enumeration}
+     * @memberOf ComponentDatatype
+     */
+    ComponentDatatype.UNSIGNED_SHORT = new Enumeration(0x1403, 'UNSIGNED_SHORT');
+    ComponentDatatype.UNSIGNED_SHORT.sizeInBytes = Uint16Array.BYTES_PER_ELEMENT;
+    ComponentDatatype.UNSIGNED_SHORT.toTypedArray = function(values) {
+        return new Uint16Array(values);
+    };
+
+    ComponentDatatype.UNSIGNED_SHORT.createArrayBufferView = function(buffer, byteOffset) {
+        return new Uint16Array(buffer, byteOffset);
+    };
+
+    /**
+     * DOC_TBA
+     *
+     * @constant
+     * @type {Enumeration}
+     * @memberOf ComponentDatatype
+     */
+    ComponentDatatype.FLOAT = new Enumeration(0x1406, 'FLOAT');
+    ComponentDatatype.FLOAT.sizeInBytes = Float32Array.BYTES_PER_ELEMENT;
+    ComponentDatatype.FLOAT.toTypedArray = function(values) {
+        return new Float32Array(values);
+    };
+
+    ComponentDatatype.FLOAT.createArrayBufferView = function(buffer, byteOffset) {
+        return new Float32Array(buffer, byteOffset);
+    };
+
+    /**
+     * DOC_TBA
+     */
+    ComponentDatatype.validate = function(componentDatatype) {
+        return ((componentDatatype === ComponentDatatype.BYTE) ||
+                (componentDatatype === ComponentDatatype.UNSIGNED_BYTE) ||
+                (componentDatatype === ComponentDatatype.SHORT) ||
+                (componentDatatype === ComponentDatatype.UNSIGNED_SHORT) ||
+                (componentDatatype === ComponentDatatype.FLOAT));
+    };
+
+    return ComponentDatatype;
+});

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

@@ -0,0 +1,8 @@
+var profile = {
+    resourceTags : {
+        amd : function(filename, mid) {
+            "use strict";
+            return (/\.js$/).test(filename);
+        }
+    }
+};

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

@@ -0,0 +1,198 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './Cartesian3',
+        './ComponentDatatype',
+        './PrimitiveType'
+    ], function(
+        DeveloperError,
+        Cartesian3,
+        ComponentDatatype,
+        PrimitiveType) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports CubeMapEllipsoidTessellator
+     *
+     * @see BoxTessellator
+     */
+    var CubeMapEllipsoidTessellator = {};
+
+    /**
+     * DOC_TBA
+     *
+     * @param {Ellipsoid} ellipsoid DOC_TBA.
+     * @param {Number} numberOfPartitions DOC_TBA.
+     * @param {String} attributeName DOC_TBA.
+     *
+     * @exception {DeveloperError} numberOfPartitions must be greater than zero.
+     */
+    CubeMapEllipsoidTessellator.compute = function(ellipsoid, numberOfPartitions, attributeName) {
+        if (numberOfPartitions <= 0) {
+            throw new DeveloperError('numberOfPartitions must be greater than zero.');
+        }
+
+        attributeName = attributeName || 'position';
+
+        var positions = [];
+        var indices = [];
+
+        function addEdgePositions(i0, i1) {
+            var indices = [];
+            indices[0] = i0;
+            indices[2 + (numberOfPartitions - 1) - 1] = i1;
+
+            var origin = positions[i0];
+            var direction = positions[i1].subtract(positions[i0]);
+
+            for ( var i = 1; i < numberOfPartitions; ++i) {
+                var delta = i / numberOfPartitions;
+
+                indices[i] = positions.length;
+                positions.push(origin.add(direction.multiplyByScalar(delta)));
+            }
+
+            return indices;
+        }
+
+        function addFaceTriangles(leftBottomToTop, bottomLeftToRight, rightBottomToTop, topLeftToRight) {
+            var origin = positions[bottomLeftToRight[0]];
+            var x = positions[bottomLeftToRight[bottomLeftToRight.length - 1]].subtract(origin);
+            var y = positions[topLeftToRight[0]].subtract(origin);
+
+            var bottomIndicesBuffer = [];
+            var topIndicesBuffer = [];
+
+            var bottomIndices = bottomLeftToRight;
+            var topIndices = topIndicesBuffer;
+
+            for ( var j = 1; j <= numberOfPartitions; ++j) {
+                if (j !== numberOfPartitions) {
+                    if (j !== 1) {
+                        //
+                        // This copy could be avoided by ping ponging buffers.
+                        //
+                        bottomIndicesBuffer = topIndicesBuffer.slice(0);
+                        bottomIndices = bottomIndicesBuffer;
+                    }
+
+                    topIndicesBuffer[0] = leftBottomToTop[j];
+                    topIndicesBuffer[numberOfPartitions] = rightBottomToTop[j];
+
+                    var deltaY = j / numberOfPartitions;
+                    var offsetY = y.multiplyByScalar(deltaY);
+
+                    for ( var i = 1; i < numberOfPartitions; ++i) {
+                        var deltaX = i / numberOfPartitions;
+                        var offsetX = x.multiplyByScalar(deltaX);
+
+                        topIndicesBuffer[i] = positions.length;
+                        positions.push(origin.add(offsetX).add(offsetY));
+                    }
+                } else {
+                    if (j !== 1) {
+                        bottomIndices = topIndicesBuffer;
+                    }
+                    topIndices = topLeftToRight;
+                }
+
+                for ( var k = 0; k < numberOfPartitions; ++k) {
+                    indices.push(bottomIndices[k]);
+                    indices.push(bottomIndices[k + 1]);
+                    indices.push(topIndices[k + 1]);
+
+                    indices.push(bottomIndices[k]);
+                    indices.push(topIndices[k + 1]);
+                    indices.push(topIndices[k]);
+                }
+            }
+        }
+
+        //
+        // Initial cube.  In the plane, z = -1:
+        //
+        //                   +y
+        //                    |
+        //             Q2     * p3     Q1
+        //                  / | \
+        //              p0 *--+--* p2   +x
+        //                  \ | /
+        //             Q3     * p1     Q4
+        //                    |
+        //
+        // Similarly, p4 to p7 are in the plane z = 1.
+        //
+        positions.push(new Cartesian3(-1, 0, -1));
+        positions.push(new Cartesian3(0, -1, -1));
+        positions.push(new Cartesian3(1, 0, -1));
+        positions.push(new Cartesian3(0, 1, -1));
+        positions.push(new Cartesian3(-1, 0, 1));
+        positions.push(new Cartesian3(0, -1, 1));
+        positions.push(new Cartesian3(1, 0, 1));
+        positions.push(new Cartesian3(0, 1, 1));
+
+        //
+        // Edges
+        //
+        // 0 -> 1, 1 -> 2, 2 -> 3, 3 -> 0.  Plane z = -1
+        // 4 -> 5, 5 -> 6, 6 -> 7, 7 -> 4.  Plane z = 1
+        // 0 -> 4, 1 -> 5, 2 -> 6, 3 -> 7.  From plane z = -1 to plane z - 1
+        //
+        var edge0to1 = addEdgePositions(0, 1);
+        var edge1to2 = addEdgePositions(1, 2);
+        var edge2to3 = addEdgePositions(2, 3);
+        var edge3to0 = addEdgePositions(3, 0);
+
+        var edge4to5 = addEdgePositions(4, 5);
+        var edge5to6 = addEdgePositions(5, 6);
+        var edge6to7 = addEdgePositions(6, 7);
+        var edge7to4 = addEdgePositions(7, 4);
+
+        var edge0to4 = addEdgePositions(0, 4);
+        var edge1to5 = addEdgePositions(1, 5);
+        var edge2to6 = addEdgePositions(2, 6);
+        var edge3to7 = addEdgePositions(3, 7);
+
+        addFaceTriangles(edge0to4, edge0to1, edge1to5, edge4to5); // Q3 Face
+        addFaceTriangles(edge1to5, edge1to2, edge2to6, edge5to6); // Q4 Face
+        addFaceTriangles(edge2to6, edge2to3, edge3to7, edge6to7); // Q1 Face
+        addFaceTriangles(edge3to7, edge3to0, edge0to4, edge7to4); // Q2 Face
+        addFaceTriangles(edge7to4.slice(0).reverse(), edge4to5, edge5to6, edge6to7.slice(0).reverse()); // Plane z = 1
+        addFaceTriangles(edge1to2, edge0to1.slice(0).reverse(), edge3to0.slice(0).reverse(), edge2to3); // Plane z = -1
+
+        // Expand cube into ellipsoid and flatten values
+        var radii = ellipsoid.getRadii();
+        var length = positions.length;
+        var q = 0;
+        var flattenedPositions = new Array(length * 3);
+        for ( var i = 0; i < length; ++i) {
+            var item = positions[i];
+            Cartesian3.normalize(item, item);
+            Cartesian3.multiplyComponents(item, radii, item);
+            flattenedPositions[q++] = item.x;
+            flattenedPositions[q++] = item.y;
+            flattenedPositions[q++] = item.z;
+        }
+
+        var mesh = {};
+        mesh.attributes = {};
+        mesh.indexLists = [];
+
+        mesh.attributes[attributeName] = {
+            componentDatatype : ComponentDatatype.FLOAT,
+            componentsPerAttribute : 3,
+            values : flattenedPositions
+        };
+
+        mesh.indexLists.push({
+            primitiveType : PrimitiveType.TRIANGLES,
+            values : indices
+        });
+
+        return mesh;
+    };
+
+    return CubeMapEllipsoidTessellator;
+});

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

@@ -0,0 +1,251 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './Math',
+        './QuadraticRealPolynomial'
+    ],
+    function(
+        DeveloperError,
+        CesiumMath,
+        QuadraticRealPolynomial) {
+    "use strict";
+
+    /**
+     * Defines functions for 3rd order polynomial functions of one variable with only real coefficients.
+     *
+     * @exports CubicRealPolynomial
+     */
+    var CubicRealPolynomial = {};
+
+    /**
+     * Provides the discriminant of the cubic equation from the supplied coefficients.
+     * @memberof CubicRealPolynomial
+     *
+     * @param {Number} a The coefficient of the 3rd order monomial.
+     * @param {Number} b The coefficient of the 2nd order monomial.
+     * @param {Number} c The coefficient of the 1st order monomial.
+     * @param {Number} d The coefficient of the 0th order monomial.
+     * @returns {Number} The value of the discriminant.
+     *
+     * @exception {DeveloperError} a is a required number.
+     * @exception {DeveloperError} b is a required number.
+     * @exception {DeveloperError} c is a required number.
+     * @exception {DeveloperError} d is a required number.
+     */
+    CubicRealPolynomial.discriminant = function(a, b, c, d) {
+        if (typeof a !== 'number') {
+            throw new DeveloperError('a is a required number.');
+        }
+        if (typeof b !== 'number') {
+            throw new DeveloperError('b is a required number.');
+        }
+        if (typeof c !== 'number') {
+            throw new DeveloperError('c is a required number.');
+        }
+        if (typeof d !== 'number') {
+            throw new DeveloperError('d is a required number.');
+        }
+
+        var a2 = a * a;
+        var b2 = b * b;
+        var c2 = c * c;
+        var d2 = d * d;
+
+        var discriminant = 18.0 * a * b * c * d + b2 * c2 - 27.0 * a2 * d2 - 4.0 * (a * c2 * c + b2 * b * d);
+        return discriminant;
+    };
+
+    function computeRealRoots(a, b, c, d) {
+        var A = a;
+        var B = b / 3.0;
+        var C = c / 3.0;
+        var D = d;
+
+        var AC = A * C;
+        var BD = B * D;
+        var B2 = B * B;
+        var C2 = C * C;
+        var delta1 = A * C - B2;
+        var delta2 = A * D - B * C;
+        var delta3 = B * D - C2;
+
+        var discriminant = 4.0 * delta1 * delta3 - delta2 * delta2;
+        var temp;
+        var temp1;
+
+        if (discriminant < 0.0) {
+            var ABar;
+            var CBar;
+            var DBar;
+
+            if (B2 * BD >= AC * C2) {
+                ABar = A;
+                CBar = delta1;
+                DBar = -2.0 * B * delta1 + A * delta2;
+            } else {
+                ABar = D;
+                CBar = delta3;
+                DBar = -D * delta2 + 2.0 * C * delta3;
+            }
+
+            var s = (DBar < 0.0) ? -1.0 : 1.0; // This is not Math.Sign()!
+            var temp0 = -s * Math.abs(ABar) * Math.sqrt(-discriminant);
+            temp1 = -DBar + temp0;
+
+            var x = temp1 / 2.0;
+            var p = x < 0.0 ? -Math.pow(-x, 1.0 / 3.0) : Math.pow(x, 1.0 / 3.0);
+            var q = (temp1 === temp0) ? -p : -CBar / p;
+
+            temp = (CBar <= 0.0) ? p + q : -DBar / (p * p + q * q + CBar);
+
+            if (B2 * BD >= AC * C2) {
+                return [(temp - B) / A];
+            }
+
+            return [-D / (temp + C)];
+        }
+
+        var CBarA = delta1;
+        var DBarA = -2.0 * B * delta1 + A * delta2;
+
+        var CBarD = delta3;
+        var DBarD = -D * delta2 + 2.0 * C * delta3;
+
+        var squareRootOfDiscriminant = Math.sqrt(discriminant);
+        var halfSquareRootOf3 = Math.sqrt(3.0) / 2.0;
+
+        var theta = Math.abs(Math.atan2(A * squareRootOfDiscriminant, -DBarA) / 3.0);
+        temp = 2.0 * Math.sqrt(-CBarA);
+        var cosine = Math.cos(theta);
+        temp1 = temp * cosine;
+        var temp3 = temp * (-cosine / 2.0 - halfSquareRootOf3 * Math.sin(theta));
+
+        var numeratorLarge = (temp1 + temp3 > 2.0 * B) ? temp1 - B : temp3 - B;
+        var denominatorLarge = A;
+
+        var root1 = numeratorLarge / denominatorLarge;
+
+        theta = Math.abs(Math.atan2(D * squareRootOfDiscriminant, -DBarD) / 3.0);
+        temp = 2.0 * Math.sqrt(-CBarD);
+        cosine = Math.cos(theta);
+        temp1 = temp * cosine;
+        temp3 = temp * (-cosine / 2.0 - halfSquareRootOf3 * Math.sin(theta));
+
+        var numeratorSmall = -D;
+        var denominatorSmall = (temp1 + temp3 < 2.0 * C) ? temp1 + C : temp3 + C;
+
+        var root3 = numeratorSmall / denominatorSmall;
+
+        var E = denominatorLarge * denominatorSmall;
+        var F = -numeratorLarge * denominatorSmall - denominatorLarge * numeratorSmall;
+        var G = numeratorLarge * numeratorSmall;
+
+        var root2 = (C * F - B * G) / (-B * F + C * E);
+
+        if (root1 <= root2) {
+            if (root1 <= root3) {
+                if (root2 <= root3) {
+                    return [root1, root2, root3];
+                }
+                return [root1, root3, root2];
+            }
+            return [root3, root1, root2];
+        }
+        if (root1 <= root3) {
+            return [root2, root1, root3];
+        }
+        if (root2 <= root3) {
+            return [root2, root3, root1];
+        }
+        return [root3, root2, root1];
+    }
+
+    /**
+     * Provides the real valued roots of the cubic polynomial with the provided coefficients.
+     * @memberof CubicRealPolynomial
+     *
+     * @param {Number} a The coefficient of the 3rd order monomial.
+     * @param {Number} b The coefficient of the 2nd order monomial.
+     * @param {Number} c The coefficient of the 1st order monomial.
+     * @param {Number} d The coefficient of the 0th order monomial.
+     * @returns {Array} The real valued roots.
+     *
+     * @exception {DeveloperError} a is a required number.
+     * @exception {DeveloperError} b is a required number.
+     * @exception {DeveloperError} c is a required number.
+     * @exception {DeveloperError} d is a required number.
+     */
+    CubicRealPolynomial.realRoots = function(a, b, c, d) {
+        if (typeof a !== 'number') {
+            throw new DeveloperError('a is a required number.');
+        }
+        if (typeof b !== 'number') {
+            throw new DeveloperError('b is a required number.');
+        }
+        if (typeof c !== 'number') {
+            throw new DeveloperError('c is a required number.');
+        }
+        if (typeof d !== 'number') {
+            throw new DeveloperError('d is a required number.');
+        }
+
+        var roots;
+        var ratio;
+        if (a === 0.0) {
+            // Quadratic function: b * x^2 + c * x + d = 0.
+            return QuadraticRealPolynomial.realRoots(b, c, d);
+        } else if (b === 0.0) {
+            if (c === 0.0) {
+                if (d === 0.0) {
+                    // 3rd order monomial: a * x^3 = 0.
+                    return [0.0, 0.0, 0.0];
+                }
+
+                // a * x^3 + d = 0
+                ratio = -d / a;
+                var root = (ratio < 0.0) ? -Math.pow(-ratio, 1.0 / 3.0) : Math.pow(ratio, 1.0 / 3.0);
+                return [root, root, root];
+            } else if (d === 0.0) {
+                // x * (a * x^2 + c) = 0.
+                roots = QuadraticRealPolynomial.realRoots(a, 0, c);
+
+                // Return the roots in ascending order.
+                if (roots.Length === 0) {
+                    return [0.0];
+                }
+                return [roots[0], 0.0, roots[1]];
+            }
+
+            // Deflated cubic polynomial: a * x^3 + c * x + d= 0.
+            return computeRealRoots(a, 0, c, d);
+        } else if (c === 0.0) {
+            if (d === 0.0) {
+                // x^2 * (a * x + b) = 0.
+                ratio = -b / a;
+                if (ratio < 0.0) {
+                    return [ratio, 0.0, 0.0];
+                }
+                return [0.0, 0.0, ratio];
+            }
+            // a * x^3 + b * x^2 + d = 0.
+            return computeRealRoots(a, b, 0, d);
+        } else if (d === 0.0) {
+            // x * (a * x^2 + b * x + c) = 0
+            roots = QuadraticRealPolynomial.realRoots(a, b, c);
+
+            // Return the roots in ascending order.
+            if (roots.length === 0) {
+                return [0.0];
+            } else if (roots[1] <= 0.0) {
+                return [roots[0], roots[1], 0.0];
+            } else if (roots[0] >= 0.0) {
+                return [0.0, roots[0], roots[1]];
+            }
+            return [roots[0], 0.0, roots[1]];
+        }
+
+        return computeRealRoots(a, b, c, d);
+    };
+
+    return CubicRealPolynomial;
+});