cesium 0.16.0 → 0.17.0

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

@@ -2,26 +2,22 @@
 define([
         './defaultValue',
         './DeveloperError',
-        './Cartesian2',
         './Cartesian3',
         './Cartesian4',
         './Cartographic',
         './Ellipsoid',
         './GeographicProjection',
-        './Extent',
         './Intersect',
         './Interval',
         './Matrix4'
     ], function(
         defaultValue,
         DeveloperError,
-        Cartesian2,
         Cartesian3,
         Cartesian4,
         Cartographic,
         Ellipsoid,
         GeographicProjection,
-        Extent,
         Intersect,
         Interval,
         Matrix4) {

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

@@ -76,6 +76,25 @@ define([
         return result;
     };
 
+    /**
+     * Creates a Cartesian2 instance from x and y coordinates.
+     * @memberof Cartesian2
+     *
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Cartesian2} [result] The object onto which to store the result.
+     * @return {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
+     */
+    Cartesian2.fromElements = function(x, y, result) {
+        if (typeof result === 'undefined') {
+            return new Cartesian2(x, y);
+        }
+
+        result.x = x;
+        result.y = y;
+        return result;
+    };
+
     /**
      * Duplicates a Cartesian2 instance.
      * @memberof Cartesian2

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

@@ -111,6 +111,27 @@ define([
         return result;
     };
 
+    /**
+     * Creates a Cartesian3 instance from x, y and z coordinates.
+     * @memberof Cartesian3
+     *
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @return {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
+     */
+    Cartesian3.fromElements = function(x, y, z, result) {
+        if (typeof result === 'undefined') {
+            return new Cartesian3(x, y, z);
+        }
+
+        result.x = x;
+        result.y = y;
+        result.z = z;
+        return result;
+    };
+
     /**
      * Duplicates a Cartesian3 instance.
      * @memberof Cartesian3
@@ -609,7 +630,8 @@ define([
      *
      * @param {Cartesian3} left The first Cartesian.
      * @param {Cartesian3} right The second Cartesian.
-     * @return {Number} The cross product.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @return {Cartesian3} The cross product.
      *
      * @exception {DeveloperError} left is required.
      * @exception {DeveloperError} right is required.
@@ -918,7 +940,8 @@ define([
      * @memberof Cartesian3
      *
      * @param {Cartesian3} right The right hand side Cartesian.
-     * @return {Number} The cross product.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @return {Cartesian3} The cross product.
      *
      * @exception {DeveloperError} right is required.
      */

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

@@ -92,6 +92,29 @@ define([
         return result;
     };
 
+    /**
+     * Creates a Cartesian4 instance from x, y, z and w coordinates.
+     * @memberof Cartesian4
+     *
+     * @param {Number} x The x coordinate.
+     * @param {Number} y The y coordinate.
+     * @param {Number} z The z coordinate.
+     * @param {Number} w The w coordinate.
+     * @param {Cartesian4} [result] The object onto which to store the result.
+     * @return {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
+     */
+    Cartesian4.fromElements = function(x, y, z, w, result) {
+        if (typeof result === 'undefined') {
+            return new Cartesian4(x, y, z, w);
+        }
+
+        result.x = x;
+        result.y = y;
+        result.z = z;
+        result.w = w;
+        return result;
+    };
+
     /**
      * Duplicates a Cartesian4 instance.
      * @memberof Cartesian4

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

@@ -4,15 +4,12 @@ define([
         './DeveloperError',
         './Matrix4',
         './Cartesian3',
-        './Cartesian4',
         './HermiteSpline'
-    ],
-    function(
+    ], function(
         defaultValue,
         DeveloperError,
         Matrix4,
         Cartesian3,
-        Cartesian4,
         HermiteSpline) {
     "use strict";
 

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

@@ -141,46 +141,39 @@ define([
      * or not.  To control animation, use the <code>shouldAnimate</code> property.
      * @memberof Clock
      *
-     * @param {Number} [secondsToTick] optional parameter to force the clock to tick the provided number of seconds,
-     * regardless of other settings.
      * @returns {JulianDate} The new value of the <code>currentTime</code> property.
      */
-    Clock.prototype.tick = function(secondsToTick) {
+    Clock.prototype.tick = function() {
         var currentSystemTime = Date.now();
-
-        var currentTime;
-        if (this.clockStep === ClockStep.SYSTEM_CLOCK) {
-            currentTime = new JulianDate();
-        } else {
-            var startTime = this.startTime;
-            var stopTime = this.stopTime;
-            var multiplier = this.multiplier;
-            var shouldAnimate = this.shouldAnimate;
-            currentTime = this.currentTime;
-
-            if (typeof secondsToTick !== 'undefined') {
-                currentTime = currentTime.addSeconds(secondsToTick);
-            } else if (shouldAnimate) {
+        var currentTime = this.currentTime;
+        var startTime = this.startTime;
+        var stopTime = this.stopTime;
+        var multiplier = this.multiplier;
+
+        if (this.shouldAnimate) {
+            if (this.clockStep === ClockStep.SYSTEM_CLOCK) {
+                currentTime = new JulianDate();
+            } else {
                 if (this.clockStep === ClockStep.TICK_DEPENDENT) {
                     currentTime = currentTime.addSeconds(multiplier);
                 } else {
                     var milliseconds = currentSystemTime - this._lastSystemTime;
                     currentTime = currentTime.addSeconds(multiplier * (milliseconds / 1000.0));
                 }
-            }
 
-            if (this.clockRange === ClockRange.CLAMPED) {
-                if (currentTime.lessThan(startTime)) {
-                    currentTime = startTime;
-                } else if (currentTime.greaterThan(stopTime)) {
-                    currentTime = stopTime;
-                }
-            } else if (this.clockRange === ClockRange.LOOP_STOP) {
-                if (currentTime.lessThan(startTime)) {
-                    currentTime = startTime.clone();
-                }
-                while (currentTime.greaterThan(stopTime)) {
-                    currentTime = startTime.addSeconds(stopTime.getSecondsDifference(currentTime));
+                if (this.clockRange === ClockRange.CLAMPED) {
+                    if (currentTime.lessThan(startTime)) {
+                        currentTime = startTime;
+                    } else if (currentTime.greaterThan(stopTime)) {
+                        currentTime = stopTime;
+                    }
+                } else if (this.clockRange === ClockRange.LOOP_STOP) {
+                    if (currentTime.lessThan(startTime)) {
+                        currentTime = startTime.clone();
+                    }
+                    while (currentTime.greaterThan(stopTime)) {
+                        currentTime = startTime.addSeconds(stopTime.getSecondsDifference(currentTime));
+                    }
                 }
             }
         }

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

@@ -1,12 +1,9 @@
 /*global define*/
 define([
         './DeveloperError',
-        './Math',
         './QuadraticRealPolynomial'
-    ],
-    function(
+    ], function(
         DeveloperError,
-        CesiumMath,
         QuadraticRealPolynomial) {
     "use strict";
 

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

@@ -208,4 +208,4 @@ define([
     };
 
     return EllipsoidTangentPlane;
-});
+});

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

@@ -2,18 +2,12 @@
 define([
         './defaultValue',
         './DeveloperError',
-        './Math',
         './Cartesian3',
-        './Visibility',
-        './Ellipsoid',
         './BoundingSphere'
     ], function(
         defaultValue,
         DeveloperError,
-        CesiumMath,
         Cartesian3,
-        Visibility,
-        Ellipsoid,
         BoundingSphere) {
     "use strict";
 
@@ -150,5 +144,164 @@ define([
         return !isOccluded;
     };
 
+    /**
+     * Computes a point that can be used for horizon culling from a list of positions.  If the point is below
+     * the horizon, all of the positions are guaranteed to be below the horizon as well.  The returned point
+     * is expressed in the ellipsoid-scaled space and is suitable for use with
+     * {@link EllipsoidalOccluder#isScaledSpacePointVisible}.
+     *
+     * @param {Cartesian3} directionToPoint The direction that the computed point will lie along.
+     *                     A reasonable direction to use is the direction from the center of the ellipsoid to
+     *                     the center of the bounding sphere computed from the positions.  The direction need not
+     *                     be normalized.
+     * @param {Cartesian3[]} positions The positions from which to compute the horizon culling point.  The positions
+     *                       must be expressed in a reference frame centered at the ellipsoid and aligned with the
+     *                       ellipsoid's axes.
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
+     */
+    EllipsoidalOccluder.prototype.computeHorizonCullingPoint = function(directionToPoint, positions, result) {
+        if (typeof directionToPoint === 'undefined') {
+            throw new DeveloperError('directionToPoint is required');
+        }
+        if (typeof positions === 'undefined') {
+            throw new DeveloperError('positions is required');
+        }
+
+        var ellipsoid = this._ellipsoid;
+
+        var scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(ellipsoid, directionToPoint);
+
+        var resultMagnitude = 0.0;
+
+        for (var i = 0, len = positions.length; i < len; ++i) {
+            var position = positions[i];
+            var candidateMagnitude = computeMagnitude(ellipsoid, position, scaledSpaceDirectionToPoint);
+            resultMagnitude = Math.max(resultMagnitude, candidateMagnitude);
+        }
+
+        return magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result);
+    };
+
+    var positionScratch = new Cartesian3();
+
+    /**
+     * Computes a point that can be used for horizon culling from a list of positions.  If the point is below
+     * the horizon, all of the positions are guaranteed to be below the horizon as well.  The returned point
+     * is expressed in the ellipsoid-scaled space and is suitable for use with
+     * {@link EllipsoidalOccluder#isScaledSpacePointVisible}.
+     *
+     * @param {Cartesian3} directionToPoint The direction that the computed point will lie along.
+     *                     A reasonable direction to use is the direction from the center of the ellipsoid to
+     *                     the center of the bounding sphere computed from the positions.  The direction need not
+     *                     be normalized.
+     * @param {Number[]} vertices  The vertices from which to compute the horizon culling point.  The positions
+     *                   must be expressed in a reference frame centered at the ellipsoid and aligned with the
+     *                   ellipsoid's axes.
+     * @param {Number} [stride=3]
+     * @param {Cartesian3} [center=Cartesian3.ZERO]
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
+     */
+    EllipsoidalOccluder.prototype.computeHorizonCullingPointFromVertices = function(directionToPoint, vertices, stride, center, result) {
+        if (typeof directionToPoint === 'undefined') {
+            throw new DeveloperError('directionToPoint is required');
+        }
+        if (typeof vertices === 'undefined') {
+            throw new DeveloperError('vertices is required');
+        }
+        if (typeof stride === 'undefined') {
+            throw new DeveloperError('stride is required');
+        }
+
+        center = defaultValue(center, Cartesian3.ZERO);
+
+        var ellipsoid = this._ellipsoid;
+
+        var scaledSpaceDirectionToPoint = computeScaledSpaceDirectionToPoint(ellipsoid, directionToPoint);
+
+        var resultMagnitude = 0.0;
+
+        for (var i = 0, len = vertices.length; i < len; i += stride) {
+            positionScratch.x = vertices[i] + center.x;
+            positionScratch.y = vertices[i + 1] + center.y;
+            positionScratch.z = vertices[i + 2] + center.z;
+
+            var candidateMagnitude = computeMagnitude(ellipsoid, positionScratch, scaledSpaceDirectionToPoint);
+            resultMagnitude = Math.max(resultMagnitude, candidateMagnitude);
+        }
+
+        return magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result);
+    };
+
+    var subsampleScratch = [];
+
+    /**
+     * Computes a point that can be used for horizon culling of an extent.  If the point is below
+     * the horizon, the ellipsoid-conforming extent is guaranteed to be below the horizon as well.
+     * The returned point is expressed in the ellipsoid-scaled space and is suitable for use with
+     * {@link EllipsoidalOccluder#isScaledSpacePointVisible}.
+     *
+     * @param {Extent} extent The extent for which to compute the horizon culling point.
+     * @param {Ellipsoid} ellipsoid The ellipsoid on which the extent is defined.  This may be different from
+     *                    the ellipsoid used by this instance for occlusion testing.
+     * @param {Cartesian3} [result] The instance on which to store the result instead of allocating a new instance.
+     * @returns {Cartesian3} The computed horizon culling point, expressed in the ellipsoid-scaled space.
+     */
+    EllipsoidalOccluder.prototype.computeHorizonCullingPointFromExtent = function(extent, ellipsoid, result) {
+        if (typeof extent === 'undefined') {
+            throw new DeveloperError('extent is required.');
+        }
+
+        var positions = extent.subsample(ellipsoid, subsampleScratch);
+        var bs = BoundingSphere.fromPoints(positions);
+
+        // If the bounding sphere center is too close to the center of the occluder, it doesn't make
+        // sense to try to horizon cull it.
+        if (bs.center.magnitude() < 0.1 * ellipsoid.getMinimumRadius()) {
+            return undefined;
+        }
+
+        return this.computeHorizonCullingPoint(bs.center, positions, result);
+    };
+
+    var scaledSpaceScratch = new Cartesian3();
+    var directionScratch = new Cartesian3();
+
+    function computeMagnitude(ellipsoid, position, scaledSpaceDirectionToPoint) {
+        var scaledSpacePosition = ellipsoid.transformPositionToScaledSpace(position, scaledSpaceScratch);
+        var magnitudeSquared = scaledSpacePosition.magnitudeSquared();
+        var magnitude = Math.sqrt(magnitudeSquared);
+        var direction = scaledSpacePosition.divideByScalar(magnitude, directionScratch);
+
+        // For the purpose of this computation, points below the ellipsoid are consider to be on it instead.
+        magnitudeSquared = Math.max(1.0, magnitudeSquared);
+        magnitude = Math.max(1.0, magnitude);
+
+        var cosAlpha = direction.dot(scaledSpaceDirectionToPoint);
+        var sinAlpha = direction.cross(scaledSpaceDirectionToPoint).magnitude();
+        var cosBeta = 1.0 / magnitude;
+        var sinBeta = Math.sqrt(magnitudeSquared - 1.0) * cosBeta;
+
+        return 1.0 / (cosAlpha * cosBeta - sinAlpha * sinBeta);
+    }
+
+    function magnitudeToPoint(scaledSpaceDirectionToPoint, resultMagnitude, result) {
+        // The horizon culling point is undefined if there were no positions from which to compute it,
+        // the directionToPoint is pointing opposite all of the positions,  or if we computed NaN or infinity.
+        if (resultMagnitude <= 0.0 || resultMagnitude === 1.0 / 0.0 || resultMagnitude !== resultMagnitude) {
+            return undefined;
+        }
+
+        return scaledSpaceDirectionToPoint.multiplyByScalar(resultMagnitude, result);
+    }
+
+    var directionToPointScratch = new Cartesian3();
+
+    function computeScaledSpaceDirectionToPoint(ellipsoid, directionToPoint) {
+        ellipsoid.transformPositionToScaledSpace(directionToPoint, directionToPointScratch);
+        return directionToPointScratch.normalize(directionToPointScratch);
+    }
+
     return EllipsoidalOccluder;
 });

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

@@ -432,4 +432,4 @@ define([
     Extent.MAX_VALUE = freezeObject(new Extent(-Math.PI, -CesiumMath.PI_OVER_TWO, Math.PI, CesiumMath.PI_OVER_TWO));
 
     return Extent;
-});
+});

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

@@ -2,21 +2,23 @@
 define([
         './clone',
         './defaultValue',
-        './DeveloperError',
         './Math',
         './Ellipsoid',
-        './Extent',
         './Cartesian3',
+        './Cartographic',
+        './Matrix2',
+        './GeographicProjection',
         './ComponentDatatype',
         './PrimitiveType'
     ], function(
         clone,
         defaultValue,
-        DeveloperError,
         CesiumMath,
         Ellipsoid,
-        Extent,
         Cartesian3,
+        Cartographic,
+        Matrix2,
+        GeographicProjection,
         ComponentDatatype,
         PrimitiveType) {
     "use strict";
@@ -33,16 +35,24 @@ define([
      */
     var ExtentTessellator = {};
 
+    function isValidLatLon(latitude, longitude) {
+        if (latitude < -CesiumMath.PI_OVER_TWO || latitude > CesiumMath.PI_OVER_TWO) {
+            return false;
+        }
+        if (longitude > CesiumMath.PI || longitude < -CesiumMath.PI) {
+            return false;
+        }
+        return true;
+    }
     /**
      * Compute vertices from a cartographic extent.  This function is different from
      * {@link ExtentTessellator#compute} and {@link ExtentTessellator#computeBuffers}
      * in that it assumes that you have already allocated output arrays of the correct size.
      *
      * @param {Extent} description.extent A cartographic extent with north, south, east and west properties in radians.
+     * @param {Number} description.rotation The rotation of the extent in radians.
      * @param {Number} description.width The number of vertices in the longitude direction.
      * @param {Number} description.height The number of vertices in the latitude direction.
-     * @param {Number} description.granularityX The distance, in radians, between each longitude.
-     * @param {Number} description.granularityY The distance, in radians, between each latitude.
      * @param {Number} description.surfaceHeight The height from the surface of the ellipsoid.
      * @param {Boolean} description.generateTextureCoordinates Whether to generate texture coordinates.
      * @param {Boolean} description.interleaveTextureCoordinates Whether to interleave the texture coordinates into the vertex array.
@@ -52,10 +62,17 @@ define([
      * @param {Array|Float32Array} description.textureCoordinates The array to use to store computed texture coordinates, unless interleaved.
      * @param {Array|Float32Array} [description.indices] The array to use to store computed indices.  If undefined, indices will be not computed.
      */
+    var nw = new Cartesian3();
+    var nwCartographic = new Cartographic();
+    var centerCartographic = new Cartographic();
+    var center = new Cartesian3();
+    var rotationMatrix = new Matrix2();
+    var proj = new GeographicProjection();
     ExtentTessellator.computeVertices = function(description) {
         description = defaultValue(description, defaultValue.EMPTY_OBJECT);
-
         var extent = description.extent;
+        extent.validate();
+        var rotation = description.rotation;
         var surfaceHeight = description.surfaceHeight;
         var width = description.width;
         var height = description.height;
@@ -86,18 +103,51 @@ define([
         var vertexArrayIndex = 0;
         var textureCoordinatesIndex = 0;
 
-        for ( var row = 0; row < height; ++row) {
-            var latitude = extent.north - granularityY * row;
-            var cosLatitude = cos(latitude);
-            var nZ = sin(latitude);
-            var kZ = radiiSquaredZ * nZ;
+        extent.getNorthwest(nwCartographic);
+        extent.getCenter(centerCartographic);
+        var latitude, longitude;
 
-            var geographicV = (latitude - extent.south) * latScalar;
+        if (typeof rotation === 'undefined') {
+            rotation = 0;
+        }
 
-            var v = geographicV;
+        var granYCos = granularityY * cos(rotation);
+        var granYSin = granularityY * sin(rotation);
+        var granXCos = granularityX * cos(rotation);
+        var granXSin = granularityX * sin(rotation);
+
+        if (rotation !== 0) {
+            proj.project(nwCartographic, nw);
+            proj.project(centerCartographic, center);
+            nw.subtract(center, nw);
+            Matrix2.fromRotation(rotation, rotationMatrix);
+            rotationMatrix.multiplyByVector(nw, nw);
+            nw.add(center, nw);
+            proj.unproject(nw, nwCartographic);
+            latitude = nwCartographic.latitude;
+            longitude = nwCartographic.longitude;
+            if (!isValidLatLon(latitude, longitude)) { //NW corner
+                return;
+            }
+            if (!isValidLatLon(latitude + (width-1)*granXSin, longitude + (width-1)*granXCos)) { //NE corner
+                return;
+            }
+            if (!isValidLatLon(latitude - granYCos*(height-1), longitude + (height-1)*granYSin)) { //SW corner
+                return;
+            }
+            if (!isValidLatLon(latitude - granYCos*(height-1) + (width-1)*granXSin, longitude + (height-1)*granYSin + (width-1)*granXCos)) { //SE corner
+                return;
+            }
+        }
 
+        for ( var row = 0; row < height; ++row) {
             for ( var col = 0; col < width; ++col) {
-                var longitude = extent.west + granularityX * col;
+                latitude = nwCartographic.latitude - granYCos*row + col*granXSin;
+                var cosLatitude = cos(latitude);
+                var nZ = sin(latitude);
+                var kZ = radiiSquaredZ * nZ;
+
+                longitude = nwCartographic.longitude + row*granYSin + col*granXCos;
 
                 var nX = cosLatitude * cos(longitude);
                 var nY = cosLatitude * sin(longitude);
@@ -116,9 +166,8 @@ define([
                 vertices[vertexArrayIndex++] = rSurfaceZ + nZ * surfaceHeight - relativeToCenter.z;
 
                 if (generateTextureCoordinates) {
-                    var geographicU = (longitude - extent.west) * lonScalar;
-
-                    var u = geographicU;
+                    var u = (longitude - extent.west) * lonScalar;
+                    var v = (latitude - extent.south) * latScalar;
 
                     if (interleaveTextureCoordinates) {
                         vertices[vertexArrayIndex++] = u;
@@ -175,7 +224,7 @@ define([
      * @exception {DeveloperError} <code>description.context</code> is required.
      *
      * @return {Object} A mesh containing attributes for positions, possibly texture coordinates and indices
-     * from the extent for creating a vertex array.
+     * from the extent for creating a vertex array. (returns undefined if no indices are found)
      *
      * @see Context#createVertexArrayFromMesh
      * @see MeshFilters.createAttributeIndices
@@ -232,6 +281,10 @@ define([
 
         ExtentTessellator.computeVertices(computeVerticesDescription);
 
+        if (indices.length === 0) {
+            return undefined;
+        }
+
         var mesh = {
             attributes : {},
             indexLists : [{