cesium 0.13.0

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

@@ -0,0 +1,207 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        './Transforms',
+        './AxisAlignedBoundingBox',
+        './IntersectionTests',
+        './Cartesian2',
+        './Cartesian3',
+        './Ellipsoid',
+        './Ray'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        Transforms,
+        AxisAlignedBoundingBox,
+        IntersectionTests,
+        Cartesian2,
+        Cartesian3,
+        Ellipsoid,
+        Ray) {
+    "use strict";
+
+    /**
+     * A plane tangent to the provided ellipsoid at the provided origin.
+     * If origin is not on the surface of the ellipsoid, it's surface projection will be used.
+     * If origin as at the center of the ellipsoid, an exception will be thrown.
+     * @alias EllipsoidTangentPlane
+     * @constructor
+     *
+     * @param {Ellipsoid} ellipsoid The ellipsoid to use.
+     * @param {Cartesian3} origin The point on the surface of the ellipsoid where the tangent plane touches.
+     *
+     * @exception {DeveloperError} origin is required.
+     * @exception {DeveloperError} origin must not be at the center of the ellipsoid.
+     */
+    var EllipsoidTangentPlane = function(origin, ellipsoid) {
+        if (typeof origin === 'undefined') {
+            throw new DeveloperError('origin is required.');
+        }
+
+        ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
+
+        origin = ellipsoid.scaleToGeodeticSurface(origin);
+        if (typeof origin === 'undefined') {
+            throw new DeveloperError('origin must not be at the center of the ellipsoid.');
+        }
+        var eastNorthUp = Transforms.eastNorthUpToFixedFrame(origin, ellipsoid);
+        this._ellipsoid = ellipsoid;
+        this._origin = Cartesian3.clone(origin);
+        this._xAxis = Cartesian3.fromCartesian4(eastNorthUp.getColumn(0));
+        this._yAxis = Cartesian3.fromCartesian4(eastNorthUp.getColumn(1));
+        this._normal = Cartesian3.fromCartesian4(eastNorthUp.getColumn(2));
+        this._distance = -Cartesian3.dot(origin, origin); //The shortest distance from the origin to the plane.
+    };
+
+    var tmp = new AxisAlignedBoundingBox();
+    /**
+     * Creates a new instance from the provided ellipsoid and the center
+     * point of the provided Cartesians.
+     * @memberof EllipsoidTangentPlane
+     *
+     * @param {Ellipsoid} ellipsoid The ellipsoid to use.
+     * @param {Cartesian3} cartesians The list of positions surrounding the center point.
+     *
+     * @exception {DeveloperError} cartesians is required.
+     */
+    EllipsoidTangentPlane.fromPoints = function(cartesians, ellipsoid) {
+        if (typeof cartesians === 'undefined') {
+            throw new DeveloperError('cartesians is required.');
+        }
+
+        var box = AxisAlignedBoundingBox.fromPoints(cartesians, tmp);
+        return new EllipsoidTangentPlane(box.center, ellipsoid);
+    };
+
+    /**
+     * @memberof EllipsoidTangentPlane
+     * @returns {Ellipsoid} Gets the ellipsoid.
+     */
+    EllipsoidTangentPlane.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
+
+    /**
+     * @memberof EllipsoidTangentPlane
+     * @returns {Cartesian3} Gets the origin.
+     */
+    EllipsoidTangentPlane.prototype.getOrigin = function() {
+        return this._origin;
+    };
+
+    var projectPointOntoPlaneRay = new Ray();
+    var projectPointOntoPlaneCartesian3 = new Cartesian3();
+
+    /**
+     * Computes the projection of the provided 3D position onto the 2D plane.
+     * @memberof EllipsoidTangentPlane
+     *
+     * @param {Cartesian3} cartesian The point to project.
+     * @param {Cartesian2} [result] The object onto which to store the result.
+     * @return {Cartesian2} The modified result parameter or a new Cartesian2 instance if none was provided.
+     *
+     * @exception {DeveloperError} cartesian is required.
+     */
+    EllipsoidTangentPlane.prototype.projectPointOntoPlane = function(cartesian, result) {
+        if (typeof cartesian === 'undefined') {
+            throw new DeveloperError('cartesian is required.');
+        }
+
+        var ray = projectPointOntoPlaneRay;
+        ray.origin = cartesian;
+        Cartesian3.normalize(cartesian, ray.direction);
+
+        var intersectionPoint = IntersectionTests.rayPlane(ray, this._normal, this._distance, projectPointOntoPlaneCartesian3);
+
+        if (typeof intersectionPoint !== 'undefined') {
+            var v = intersectionPoint.subtract(this._origin, intersectionPoint);
+            var x = this._xAxis.dot(v);
+            var y = this._yAxis.dot(v);
+
+            if (typeof result === 'undefined') {
+                return new Cartesian2(x, y);
+            }
+            result.x = x;
+            result.y = y;
+            return result;
+        }
+        return undefined;
+    };
+
+    /**
+     * Computes the projection of the provided 3D positions onto the 2D plane.
+     * @memberof EllipsoidTangentPlane
+     *
+     * @param {Array} cartesians The array of points to project.
+     * @param {Array} [result] The array of Cartesian2 instances onto which to store results.
+     * @return {Array} The modified result parameter or a new array of Cartesian2 instances if none was provided.
+     *
+     * @exception {DeveloperError} cartesians is required.
+     */
+    EllipsoidTangentPlane.prototype.projectPointsOntoPlane = function(cartesians, result) {
+        if (typeof cartesians === 'undefined') {
+            throw new DeveloperError('cartesians is required.');
+        }
+
+        if (typeof result === 'undefined') {
+            result = [];
+        }
+
+        var count = 0;
+        var length = cartesians.length;
+        for ( var i = 0; i < length; i++) {
+            var p = this.projectPointOntoPlane(cartesians[i], result[count]);
+            if (typeof p !== 'undefined') {
+                result[count] = p;
+                count++;
+            }
+        }
+        result.length = count;
+        return result;
+    };
+
+
+    var projectPointsOntoEllipsoidScratch = new Cartesian3();
+    /**
+     * Computes the projection of the provided 2D positions onto the 3D ellipsoid.
+     * @memberof EllipsoidTangentPlane
+     *
+     * @param {Array} cartesians The array of points to project.
+     * @param {Array} [result] The array of Cartesian3 instances onto which to store results.
+     * @return {Array} The modified result parameter or a new array of Cartesian3 instances if none was provided.
+     *
+     * @exception {DeveloperError} cartesians is required.
+     */
+    EllipsoidTangentPlane.prototype.projectPointsOntoEllipsoid = function(cartesians, result) {
+        if (typeof cartesians === 'undefined') {
+            throw new DeveloperError('cartesians is required.');
+        }
+
+        var length = cartesians.length;
+        if (typeof result === 'undefined') {
+            result = new Array(length);
+        } else {
+            result.length = length;
+        }
+
+        var ellipsoid = this._ellipsoid;
+        var origin = this._origin;
+        var xAxis = this._xAxis;
+        var yAxis = this._yAxis;
+        var tmp = projectPointsOntoEllipsoidScratch;
+
+        for ( var i = 0; i < length; ++i) {
+            var position = cartesians[i];
+            xAxis.multiplyByScalar(position.x, tmp);
+            var point = result[i] = Cartesian3.add(origin, tmp, result[i]);
+            yAxis.multiplyByScalar(position.y, tmp);
+            Cartesian3.add(point, tmp, point);
+            ellipsoid.scaleToGeocentricSurface(point, point);
+        }
+
+        return result;
+    };
+
+    return EllipsoidTangentPlane;
+});

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

@@ -0,0 +1,151 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        './Math',
+        './Cartesian3',
+        './Visibility',
+        './Ellipsoid',
+        './BoundingSphere'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        CesiumMath,
+        Cartesian3,
+        Visibility,
+        Ellipsoid,
+        BoundingSphere) {
+    "use strict";
+
+    /**
+     * Determine whether or not other objects are visible or hidden behind the visible horizon defined by
+     * an {@link Ellipsoid} and a camera position.  The ellipsoid is assumed to be located at the
+     * origin of the coordinate system.
+     *
+     * @alias EllipsoidalOccluder
+     *
+     * @param {Ellipsoid} ellipsoid The ellipsoid to use as an occluder.
+     * @param {Cartesian3} [cameraPosition] The coordinate of the viewer/camera.  If this parameter is not
+     *        specified, {@link EllipsoidalOccluder#setCameraPosition} must be called before
+     *        testing visibility.
+     *
+     * @exception {DeveloperError} <code>ellipsoid</code> is required.
+     *
+     * @constructor
+     *
+     * @example
+     * // Construct an ellipsoidal occluder with radii 1.0, 1.1, and 0.9.
+     * var cameraPosition = new Cartesian3(5.0, 6.0, 7.0);
+     * var occluderEllipsoid = new Ellipsoid(1.0, 1.1, 0.9);
+     * var occluder = new EllipsoidalOccluder(occluderEllipsoid, cameraPosition);
+     */
+    var EllipsoidalOccluder = function(ellipsoid, cameraPosition) {
+        if (typeof ellipsoid === 'undefined') {
+            throw new DeveloperError('ellipsoid is required.');
+        }
+
+        this._ellipsoid = ellipsoid;
+        this._cameraPosition = new Cartesian3(0.0, 0.0, 0.0);
+        this._cameraPositionInScaledSpace = new Cartesian3(0.0, 0.0, 0.0);
+        this._distanceToLimbInScaledSpaceSquared = 0.0;
+
+        // setCameraPosition fills in the above values
+        if (typeof cameraPosition !== 'undefined') {
+            this.setCameraPosition(cameraPosition);
+        }
+    };
+
+    /**
+     * Returns the occluding ellipsoid.
+     *
+     * @memberof EllipsoidalOccluder
+     *
+     * @return {Ellipsoid} The ellipsoid.
+     */
+    EllipsoidalOccluder.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
+
+    /**
+     * Sets the position of the camera.
+     *
+     * @memberof EllipsoidalOccluder
+     *
+     * @param {Cartesian3} cameraPosition The new position of the camera.
+     */
+    EllipsoidalOccluder.prototype.setCameraPosition = function(cameraPosition) {
+        var ellipsoid = this._ellipsoid;
+        var cameraPositionInScaledSpace = ellipsoid.transformPositionToScaledSpace(cameraPosition, this._cameraPositionInScaledSpace);
+        var magnitudeCameraPositionInScaledSpace = Cartesian3.magnitude(cameraPositionInScaledSpace);
+        var distanceToLimbInScaledSpaceSquared = magnitudeCameraPositionInScaledSpace * magnitudeCameraPositionInScaledSpace - 1.0;
+
+        Cartesian3.clone(cameraPosition, this._cameraPosition);
+        this._cameraPositionInScaledSpace = cameraPositionInScaledSpace;
+        this._distanceToLimbInScaledSpaceSquared = distanceToLimbInScaledSpaceSquared;
+    };
+
+    /**
+     * Gets the position of the camera.
+     *
+     * @memberof EllipsoidalOccluder
+     *
+     * @returns {Cartesian3} The position of the camera.
+     */
+    EllipsoidalOccluder.prototype.getCameraPosition = function() {
+        return this._cameraPosition;
+    };
+
+    var scratchCartesian = new Cartesian3(0.0, 0.0, 0.0);
+
+    /**
+     * Determines whether or not a point, the <code>occludee</code>, is hidden from view by the occluder.
+     *
+     * @memberof EllipsoidalOccluder
+     *
+     * @param {Cartesian3} occludee The point to test for visibility.
+     *
+     * @return {boolean} <code>true</code> if the occludee is visible; otherwise <code>false</code>.
+     *
+     * @example
+     * var cameraPosition = new Cartesian3(0, 0, 2.5);
+     * var ellipsoid = new Ellipsoid(1.0, 1.1, 0.9);
+     * var occluder = new EllipsoidalOccluder(ellipsoid, cameraPosition);
+     * var point = new Cartesian3(0, -3, -3);
+     * occluder.isPointVisible(point); //returns true
+     */
+    EllipsoidalOccluder.prototype.isPointVisible = function(occludee) {
+        var ellipsoid = this._ellipsoid;
+        var occludeeScaledSpacePosition = ellipsoid.transformPositionToScaledSpace(occludee, scratchCartesian);
+        return this.isScaledSpacePointVisible(occludeeScaledSpacePosition);
+    };
+
+    /**
+     * Determines whether or not a point expressed in the ellipsoid scaled space, is hidden from view by the
+     * occluder.  To transform a Cartesian X, Y, Z position in the coordinate system aligned with the ellipsoid
+     * into the scaled space, call {@link Ellipsoid#transformPositionToScaledSpace}.
+     *
+     * @memberof EllipsoidalOccluder
+     *
+     * @param {Cartesian3} occludeeScaledSpacePosition The point to test for visibility, represented in the scaled space.
+     *
+     * @return {boolean} <code>true</code> if the occludee is visible; otherwise <code>false</code>.
+     *
+     * @example
+     * var cameraPosition = new Cartesian3(0, 0, 2.5);
+     * var ellipsoid = new Ellipsoid(1.0, 1.1, 0.9);
+     * var occluder = new EllipsoidalOccluder(ellipsoid, cameraPosition);
+     * var point = new Cartesian3(0, -3, -3);
+     * var scaledSpacePoint = ellipsoid.transformPositionToScaledSpace(point);
+     * occluder.isScaledSpacePointVisible(scaledSpacePoint); //returns true
+     */
+    EllipsoidalOccluder.prototype.isScaledSpacePointVisible = function(occludeeScaledSpacePosition) {
+        // Based on Cozzi and Stoner's paper, "GPU Ray Casting of Virtual Globes Supplement"
+        var q = this._cameraPositionInScaledSpace;
+        var wMagnitudeSquared = this._distanceToLimbInScaledSpaceSquared;
+        var b = Cartesian3.subtract(occludeeScaledSpacePosition, q, scratchCartesian);
+        var d = -b.dot(q);
+        return d < wMagnitudeSquared || d * d / b.magnitudeSquared() < wMagnitudeSquared;
+    };
+
+    return EllipsoidalOccluder;
+});

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

@@ -0,0 +1,197 @@
+/*global define*/
+define([
+        './Cartesian3',
+        './DeveloperError'
+    ], function(
+        Cartesian3,
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * A fixed-point encoding of a {@link Cartesian3} with 64-bit floating-point components, as two {@link Cartesian3}
+     * values that, when converted to 32-bit floating-point and added, approximate the original input.
+     * <p>
+     * This is used to encode positions in vertex buffers for rendering without jittering artifacts
+     * as described in <a href="http://blogs.agi.com/insight3d/index.php/2008/09/03/precisions-precisions/">Precisions, Precisions</a>.
+     * </p>
+     *
+     * @alias EncodedCartesian3
+     * @constructor
+     *
+     * @see czm_modelViewRelativeToEye
+     * @see czm_modelViewProjectionRelativeToEye
+     */
+    var EncodedCartesian3 = function() {
+        /**
+         * The high bits for each component.  Bits 0 to 22 store the whole value.  Bits 23 to 31 are not used.
+         * <p>
+         * The default is {@link Cartesian3.ZERO}.
+         * </p>
+         *
+         * @type Number
+         */
+        this.high = Cartesian3.ZERO.clone();
+
+        /**
+         * The low bits for each component.  Bits 7 to 22 store the whole value, and bits 0 to 6 store the fraction.  Bits 23 to 31 are not used.
+         * <p>
+         * The default is {@link Cartesian3.ZERO}.
+         * </p>
+         *
+         * @type Number
+         */
+        this.low = Cartesian3.ZERO.clone();
+    };
+
+    /**
+     * Encodes a 64-bit floating-point value as two floating-point values that, when converted to
+     * 32-bit floating-point and added, approximate the original input.  The returned object
+     * has <code>high</code> and <code>low</code> properties for the high and low bits, respectively.
+     * <p>
+     * The fixed-point encoding follows <a href="http://blogs.agi.com/insight3d/index.php/2008/09/03/precisions-precisions/">Precisions, Precisions</a>.
+     * </p>
+     * @memberof EncodedCartesian3
+     *
+     * @param {Number} value The floating-point value to encode.
+     * @param {Object} [result] The object onto which to store the result.
+     *
+     * @return {Object} The modified result parameter or a new instance if one was not provided.
+     *
+     * @exception {DeveloperError} value is required.
+     *
+     * @example
+     * var value = 1234567.1234567;
+     * var splitValue = EncodedCartesian3.encode(value);
+     */
+    EncodedCartesian3.encode = function(value, result) {
+        if (typeof value === 'undefined') {
+            throw new DeveloperError('value is required');
+        }
+
+        if (typeof result === 'undefined') {
+            result = {
+                high : 0.0,
+                low : 0.0
+            };
+        }
+
+        var doubleHigh;
+        if (value >= 0.0) {
+            doubleHigh = Math.floor(value / 65536.0) * 65536.0;
+            result.high = doubleHigh;
+            result.low = value - doubleHigh;
+        } else {
+            doubleHigh = Math.floor(-value / 65536.0) * 65536.0;
+            result.high = -doubleHigh;
+            result.low = value + doubleHigh;
+        }
+
+        return result;
+    };
+
+    var scratchEncode = {
+        high : 0.0,
+        low : 0.0
+    };
+
+    /**
+     * Encodes a {@link Cartesian3} with 64-bit floating-point components as two {@link Cartesian3}
+     * values that, when converted to 32-bit floating-point and added, approximate the original input.
+     * <p>
+     * The fixed-point encoding follows <a href="http://blogs.agi.com/insight3d/index.php/2008/09/03/precisions-precisions/">Precisions, Precisions</a>.
+     * </p>
+     * @memberof EncodedCartesian3
+     *
+     * @param {Cartesian3} cartesian The cartesian to encode.
+     * @param {EncodedCartesian3} [result] The object onto which to store the result.
+     * @return {EncodedCartesian3} The modified result parameter or a new EncodedCartesian3 instance if one was not provided.
+     *
+     * @exception {DeveloperError} cartesian is required.
+     *
+     * @example
+     * var cart = new Cartesian3(-10000000.0, 0.0, 10000000.0);
+     * var encoded = EncodedCartesian3.fromCartesian(cart);
+     */
+    EncodedCartesian3.fromCartesian = function(cartesian, result) {
+        if (typeof cartesian === 'undefined') {
+            throw new DeveloperError('cartesian is required');
+        }
+
+        if (typeof result === 'undefined') {
+            result = new EncodedCartesian3();
+        }
+
+        var high = result.high;
+        var low = result.low;
+
+        EncodedCartesian3.encode(cartesian.x, scratchEncode);
+        high.x = scratchEncode.high;
+        low.x = scratchEncode.low;
+
+        EncodedCartesian3.encode(cartesian.y, scratchEncode);
+        high.y = scratchEncode.high;
+        low.y = scratchEncode.low;
+
+        EncodedCartesian3.encode(cartesian.z, scratchEncode);
+        high.z = scratchEncode.high;
+        low.z = scratchEncode.low;
+
+        return result;
+    };
+
+    var encodedP = new EncodedCartesian3();
+
+    /**
+     * Encodes the provided <code>cartesian</code>, and writes it to an array with <code>high</code>
+     * components followed by <code>low</code> components, i.e. <code>[high.x, high.y, high.z, low.x, low.y, low.z]</code>.
+     * <p>
+     * This is used to create interleaved high-precision position vertex attributes.
+     * </p>
+     *
+     * @param {Cartesian3} cartesian The cartesian to encode.
+     * @param {Array} cartesianArray The array to write to.
+     * @param {Number} index The index into the array to start writing.  Six elements will be written.
+     *
+     * @exception {DeveloperError} cartesian is required.
+     * @exception {DeveloperError} cartesianArray is required.
+     * @exception {DeveloperError} index must be a number greater than or equal to 0.
+     *
+     * @example
+     * var positions = [
+     *    new Cartesian3(),
+     *    // ...
+     * ];
+     * var encodedPositions = new Float32Array(2 * 3 * positions.length);
+     * var j = 0;
+     * for (var i = 0; i < positions.length; ++i) {
+     *   EncodedCartesian3.writeElement(positions[i], encodedPositions, j);
+     *   j += 6;
+     * }
+     */
+    EncodedCartesian3.writeElements = function(cartesian, cartesianArray, index) {
+        if (typeof cartesian === 'undefined') {
+            throw new DeveloperError('cartesian is required');
+        }
+
+        if (typeof cartesianArray === 'undefined') {
+            throw new DeveloperError('cartesianArray is required');
+        }
+
+        if (typeof index !== 'number' || index < 0) {
+            throw new DeveloperError('index must be a number greater than or equal to 0.');
+        }
+
+        EncodedCartesian3.fromCartesian(cartesian, encodedP);
+        var high = encodedP.high;
+        var low = encodedP.low;
+
+        cartesianArray[index] = high.x;
+        cartesianArray[index + 1] = high.y;
+        cartesianArray[index + 2] = high.z;
+        cartesianArray[index + 3] = low.x;
+        cartesianArray[index + 4] = low.y;
+        cartesianArray[index + 5] = low.z;
+    };
+
+    return EncodedCartesian3;
+});