cesium 0.16.0 → 0.17.0

data/app/assets/javascripts/Scene/Polyline.js

@@ -2,9 +2,7 @@
 define([
         '../Core/defaultValue',
         '../Core/DeveloperError',
-        '../Core/destroyObject',
         '../Core/BoundingSphere',
-        '../Core/Cartesian3',
         '../Core/Color',
         '../Core/PolylinePipeline',
         '../Core/Matrix4',
@@ -12,9 +10,7 @@ define([
     ], function(
         defaultValue,
         DeveloperError,
-        destroyObject,
         BoundingSphere,
-        Cartesian3,
         Color,
         PolylinePipeline,
         Matrix4,

data/app/assets/javascripts/Scene/Scene.js

@@ -6,15 +6,12 @@ define([
         '../Core/destroyObject',
         '../Core/GeographicProjection',
         '../Core/Ellipsoid',
-        '../Core/DeveloperError',
         '../Core/Occluder',
         '../Core/BoundingRectangle',
         '../Core/BoundingSphere',
         '../Core/Cartesian2',
         '../Core/Cartesian3',
-        '../Core/Cartesian4',
         '../Core/Intersect',
-        '../Core/IntersectionTests',
         '../Core/Interval',
         '../Core/Matrix4',
         '../Core/JulianDate',
@@ -30,7 +27,8 @@ define([
         './FrameState',
         './OrthographicFrustum',
         './PerspectiveOffCenterFrustum',
-        './FrustumCommands'
+        './FrustumCommands',
+        './SunPostProcess'
     ], function(
         CesiumMath,
         Color,
@@ -38,15 +36,12 @@ define([
         destroyObject,
         GeographicProjection,
         Ellipsoid,
-        DeveloperError,
         Occluder,
         BoundingRectangle,
         BoundingSphere,
         Cartesian2,
         Cartesian3,
-        Cartesian4,
         Intersect,
-        IntersectionTests,
         Interval,
         Matrix4,
         JulianDate,
@@ -62,7 +57,8 @@ define([
         FrameState,
         OrthographicFrustum,
         PerspectiveOffCenterFrustum,
-        FrustumCommands) {
+        FrustumCommands,
+        SunPostProcess) {
     "use strict";
 
     /**
@@ -87,6 +83,8 @@ define([
 
         this._shaderFrameCount = 0;
 
+        this._sunPostProcess = new SunPostProcess();
+
         this._commandList = [];
         this._frustumCommandsList = [];
 
@@ -118,6 +116,15 @@ define([
          */
         this.skyAtmosphere = undefined;
 
+        /**
+         * The {@link Sun}.
+         *
+         * @type Sun
+         *
+         * @default undefined
+         */
+        this.sun = undefined;
+
         /**
          * The background color, which is only visible if there is no sky box, i.e., {@link Scene#skyBox} is undefined.
          *
@@ -232,10 +239,6 @@ define([
         return this._animations;
     };
 
-    /**
-     * DOC_TBA
-     * @memberof Scene
-     */
     function clearPasses(passes) {
         passes.color = false;
         passes.pick = false;
@@ -315,6 +318,7 @@ define([
 
     var scratchCullingVolume = new CullingVolume();
     var distances = new Interval();
+
     function createPotentiallyVisibleSet(scene, listName) {
         var commandLists = scene._commandList;
         var cullingVolume = scene._frameState.cullingVolume;
@@ -398,18 +402,48 @@ define([
         }
     }
 
+    function isSunVisible(command, frameState) {
+        var occluder = (frameState.mode === SceneMode.SCENE3D) ? frameState.occluder: undefined;
+        var cullingVolume = frameState.cullingVolume;
+
+        // get user culling volume minus the far plane.
+        var planes = scratchCullingVolume.planes;
+        for (var k = 0; k < 5; ++k) {
+            planes[k] = cullingVolume.planes[k];
+        }
+        cullingVolume = scratchCullingVolume;
+
+        return ((typeof command !== 'undefined') &&
+                 ((typeof command.boundingVolume === 'undefined') ||
+                  !command.cull ||
+                  ((cullingVolume.getVisibility(command.boundingVolume) !== Intersect.OUTSIDE) &&
+                   (typeof occluder === 'undefined' || occluder.isBoundingSphereVisible(command.boundingVolume)))));
+    }
+
     function executeCommands(scene, passState) {
+        var frameState = scene._frameState;
         var camera = scene._camera;
         var frustum = camera.frustum.clone();
         var context = scene._context;
         var us = context.getUniformState();
-        var skyBoxCommand = typeof scene.skyBox !== 'undefined' ? scene.skyBox.update(context, scene._frameState) : undefined;
-        var skyAtmosphereCommand = typeof scene.skyAtmosphere !== 'undefined' ? scene.skyAtmosphere.update(context, scene._frameState) : undefined;
+
+        var skyBoxCommand = (frameState.passes.color && typeof scene.skyBox !== 'undefined') ? scene.skyBox.update(context, frameState) : undefined;
+        var skyAtmosphereCommand = (frameState.passes.color && typeof scene.skyAtmosphere !== 'undefined') ? scene.skyAtmosphere.update(context, frameState) : undefined;
+        var sunCommand = (frameState.passes.color && typeof scene.sun !== 'undefined') ? scene.sun.update(context, frameState) : undefined;
+        var sunVisible = isSunVisible(sunCommand, frameState);
+
+        if (sunVisible) {
+            passState.framebuffer = scene._sunPostProcess.update(context);
+        }
 
         var clear = scene._clearColorCommand;
         Color.clone(defaultValue(scene.backgroundColor, Color.BLACK), clear.color);
         clear.execute(context, passState);
 
+        if (sunVisible) {
+            scene._sunPostProcess.clear(context, scene.backgroundColor);
+        }
+
         // Ideally, we would render the sky box and atmosphere last for
         // early-z, but we would have to draw it in each frustum
         frustum.near = camera.frustum.near;
@@ -424,6 +458,10 @@ define([
             skyAtmosphereCommand.execute(context, passState);
         }
 
+        if (typeof sunCommand !== 'undefined' && sunVisible) {
+            sunCommand.execute(context, passState);
+        }
+
         var clearDepthStencil = scene._clearDepthStencilCommand;
 
         var frustumCommandsList = scene._frustumCommandsList;
@@ -444,6 +482,11 @@ define([
                 commands[j].execute(context, passState);
             }
         }
+
+        if (sunVisible) {
+            scene._sunPostProcess.execute(context);
+            passState.framebuffer = undefined;
+        }
     }
 
     function executeOverlayCommands(scene, passState) {
@@ -494,13 +537,14 @@ define([
 
         us.update(frameState);
 
-        this._commandList.length = 0;
-        this._primitives.update(this._context, frameState, this._commandList);
+        var context = this._context;
 
-        var passState = this._passState;
-        passState.framebuffer = undefined;
+        this._commandList.length = 0;
+        this._primitives.update(context, frameState, this._commandList);
 
         createPotentiallyVisibleSet(this, 'colorList');
+
+        var passState = this._passState;
         executeCommands(this, passState);
         executeOverlayCommands(this, passState);
     };
@@ -632,6 +676,8 @@ define([
         this._primitives = this._primitives && this._primitives.destroy();
         this.skyBox = this.skyBox && this.skyBox.destroy();
         this.skyAtmosphere = this.skyAtmosphere && this.skyAtmosphere.destroy();
+        this.sun = this.sun && this.sun.destroy();
+        this._sunPostProcess = this._sunPostProcess && this._sunPostProcess.destroy();
         this._context = this._context && this._context.destroy();
         return destroyObject(this);
     };

data/app/assets/javascripts/Scene/SceneTransforms.js

@@ -0,0 +1,151 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/Cartographic',
+        '../Core/Cartesian2',
+        '../Core/Cartesian3',
+        '../Core/Cartesian4',
+        '../Core/Matrix4',
+        '../Core/BoundingRectangle',
+        '../Core/Math',
+        './SceneMode'
+    ],
+    function(
+        defaultValue,
+        DeveloperError,
+        Cartographic,
+        Cartesian2,
+        Cartesian3,
+        Cartesian4,
+        Matrix4,
+        BoundingRectangle,
+        CesiumMath,
+        SceneMode) {
+    "use strict";
+
+    /**
+     * Functions that do scene-dependent transforms between rendering-related coordinate systems.
+     *
+     * @exports SceneTransforms
+     */
+    var SceneTransforms = {};
+
+    var actualPosition = new Cartesian3();
+    var positionCC = new Cartesian4();
+
+    /**
+     * Transforms a position in WGS84 coordinates to window coordinates.  This is commonly used to place an
+     * HTML element at the same screen position as an object in the scene.
+     *
+     * @memberof SceneTransforms
+     *
+     * @param {Scene} scene The scene.
+     * @param {Cartesian3} position The position in WGS84 (world) coordinates.
+     * @param {Cartesian2} [result=undefined] An optional object to return the input position transformed to window coordinates.
+     *
+     * @return {Cartesian2} The modified result parameter or a new Cartesian3 instance if one was not provided.  This may be <code>undefined</code> if the input position is near the center of the ellipsoid.
+     *
+     * @exception {DeveloperError} scene is required.
+     * @exception {DeveloperError} position is required.
+     *
+     * @example
+     * // Output the window position of longitude/latitude (0, 0) every time the mouse moves.
+     * var scene = widget.scene;
+     * var ellipsoid = widget.centralBody.getEllipsoid();
+     * var position = ellipsoid.cartographicToCartesian(new Cartographic(0.0, 0.0));
+     * var handler = new Cesium.ScreenSpaceEventHandler(scene.getCanvas());
+     * handler.setInputAction(function(movement) {
+     *     console.log(Cesium.SceneTransforms.wgs84ToWindowCoordinates(scene, position));
+     * }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
+     */
+    SceneTransforms.wgs84ToWindowCoordinates = function(scene, position, result) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+
+        if (typeof position === 'undefined') {
+            throw new DeveloperError('position is required.');
+        }
+
+        // Transform for 3D, 2D, or Columbus view
+        SceneTransforms.computeActualWgs84Position(scene.getFrameState(), position, actualPosition);
+
+        if (typeof actualPosition === 'undefined') {
+            result = undefined;
+            return undefined;
+        }
+
+        // View-projection matrix to transform from world coordinates to clip coordinates
+        var viewProjection = scene.getUniformState().getViewProjection();
+        viewProjection.multiplyByPoint(actualPosition, positionCC);
+
+        return SceneTransforms.clipToWindowCoordinates(scene.getCanvas(), positionCC, result);
+    };
+
+    var projectedPosition = new Cartesian3();
+    var positionInCartographic = new Cartographic();
+
+    /**
+     * @private
+     */
+    SceneTransforms.computeActualWgs84Position = function(frameState, position, result) {
+        var mode = frameState.mode;
+
+        if (mode === SceneMode.SCENE3D) {
+            return Cartesian3.clone(position, result);
+        }
+
+        var projection = frameState.scene2D.projection;
+        projection.getEllipsoid().cartesianToCartographic(position, positionInCartographic);
+        if (typeof positionInCartographic === 'undefined') {
+            result = undefined;
+            return result;
+        }
+
+        projection.project(positionInCartographic, projectedPosition);
+
+        if (mode === SceneMode.COLUMBUS_VIEW) {
+            return Cartesian3.fromElements(projectedPosition.z, projectedPosition.x, projectedPosition.y, result);
+        }
+
+        if (mode === SceneMode.SCENE2D) {
+            return Cartesian3.fromElements(0.0, projectedPosition.x, projectedPosition.y, result);
+        }
+
+        // mode === SceneMode.MORPHING
+        var morphTime = frameState.morphTime;
+        return Cartesian3.fromElements(
+            CesiumMath.lerp(projectedPosition.z, position.x, morphTime),
+            CesiumMath.lerp(projectedPosition.x, position.y, morphTime),
+            CesiumMath.lerp(projectedPosition.y, position.z, morphTime),
+            result);
+    };
+
+    var positionNDC = new Cartesian3();
+    var positionWC = new Cartesian4();
+    var viewport = new BoundingRectangle();
+    var viewportTransform = new Matrix4();
+
+    /**
+     * @private
+     */
+    SceneTransforms.clipToWindowCoordinates = function(canvas, position, result) {
+        // Perspective divide to transform from clip coordinates to normalized device coordinates
+        positionNDC.x = position.x / position.w;
+        positionNDC.y = position.y / position.w;
+        positionNDC.z = position.z / position.w;
+
+        // Assuming viewport takes up the entire canvas...
+        viewport.width = canvas.clientWidth;
+        viewport.height = canvas.clientHeight;
+        Matrix4.computeViewportTransformation(viewport, 0.0, 1.0, viewportTransform);
+
+        // Viewport transform to transform from clip coordinates to window coordinates
+        viewportTransform.multiplyByPoint(positionNDC, positionWC);
+
+        return Cartesian2.fromCartesian4(positionWC, result);
+    };
+
+    return SceneTransforms;
+});

data/app/assets/javascripts/Scene/SceneTransitioner.js

@@ -8,7 +8,6 @@ define([
         '../Core/ScreenSpaceEventHandler',
         '../Core/ScreenSpaceEventType',
         '../Core/Ellipsoid',
-        '../Core/Cartesian2',
         '../Core/Cartesian3',
         '../Core/Cartesian4',
         '../Core/Cartographic',
@@ -26,7 +25,6 @@ define([
         ScreenSpaceEventHandler,
         ScreenSpaceEventType,
         Ellipsoid,
-        Cartesian2,
         Cartesian3,
         Cartesian4,
         Cartographic,

data/app/assets/javascripts/Scene/ScreenSpaceCameraController.js

@@ -11,9 +11,7 @@ define([
         '../Core/FAR',
         '../Core/IntersectionTests',
         '../Core/Math',
-        '../Core/Matrix3',
         '../Core/Matrix4',
-        '../Core/Quaternion',
         '../Core/Ray',
         '../Core/Transforms',
         './AnimationCollection',
@@ -33,9 +31,7 @@ define([
         FAR,
         IntersectionTests,
         CesiumMath,
-        Matrix3,
         Matrix4,
-        Quaternion,
         Ray,
         Transforms,
         AnimationCollection,

data/app/assets/javascripts/Scene/SensorVolumeCollection.js

@@ -1,25 +1,13 @@
 /*global define*/
 define([
-        '../Core/defaultValue',
         '../Core/destroyObject',
-        '../Core/BoundingSphere',
-        '../Core/Cartesian3',
-        '../Core/Cartesian4',
         '../Core/DeveloperError',
-        '../Core/Intersect',
-        '../Core/Matrix4',
         './CustomSensorVolume',
         './RectangularPyramidSensorVolume',
         './SceneMode'
     ], function(
-        defaultValue,
         destroyObject,
-        BoundingSphere,
-        Cartesian3,
-        Cartesian4,
         DeveloperError,
-        Intersect,
-        Matrix4,
         CustomSensorVolume,
         RectangularPyramidSensorVolume,
         SceneMode) {

data/app/assets/javascripts/Scene/Sun.js

@@ -0,0 +1,180 @@
+/*global define*/
+define([
+        '../Core/BoundingSphere',
+        '../Core/Cartesian3',
+        '../Core/ComponentDatatype',
+        '../Core/destroyObject',
+        '../Core/Math',
+        '../Core/PrimitiveType',
+        '../Renderer/BlendingState',
+        '../Renderer/BufferUsage',
+        '../Renderer/DrawCommand',
+        './SceneMode',
+        '../Shaders/SunVS',
+        '../Shaders/SunFS'
+    ], function(
+        BoundingSphere,
+        Cartesian3,
+        ComponentDatatype,
+        destroyObject,
+        CesiumMath,
+        PrimitiveType,
+        BlendingState,
+        BufferUsage,
+        DrawCommand,
+        SceneMode,
+        SunVS,
+        SunFS) {
+    "use strict";
+
+    /**
+     * Draws a sun billboard.
+     * <p>This is only supported in 3D and Columbus view.</p>
+     *
+     * @alias Sun
+     * @constructor
+     *
+     * @example
+     * scene.sun = new Sun();
+     *
+     * @see Scene.sun
+     */
+    var Sun = function() {
+        this._command = new DrawCommand();
+
+        this._boundingVolume = new BoundingSphere();
+        this._boundingVolume.radius = CesiumMath.SOLAR_RADIUS * 30.0;
+
+        this._boundingVolume2D = new BoundingSphere();
+        this._boundingVolume2D.radius = this._boundingVolume.radius;
+
+        /**
+         * Determines if the sun will be shown.
+         * <p>
+         * The default is <code>true</code>.
+         * </p>
+         *
+         * @type Boolean
+         */
+        this.show = true;
+    };
+
+    /**
+     * @private
+     */
+    Sun.prototype.update = function(context, frameState) {
+        if (!this.show) {
+            return undefined;
+        }
+
+        var mode = frameState.mode;
+        if (mode === SceneMode.SCENE2D || mode === SceneMode.MORPHING) {
+            return undefined;
+        }
+
+        if (!frameState.passes.color) {
+            return undefined;
+        }
+
+        var command = this._command;
+
+        if (typeof command.vertexArray === 'undefined') {
+            var attributeIndices = {
+                direction : 0
+            };
+
+            var directions = new Uint8Array(4 * 2);
+            directions[0] = 0;
+            directions[1] = 0;
+
+            directions[2] = 255;
+            directions[3] = 0.0;
+
+            directions[4] = 255;
+            directions[5] = 255;
+
+            directions[6] = 0.0;
+            directions[7] = 255;
+
+            var vertexBuffer = context.createVertexBuffer(directions, BufferUsage.STATIC_DRAW);
+            var attributes = [{
+                index : attributeIndices.direction,
+                vertexBuffer : vertexBuffer,
+                componentsPerAttribute : 2,
+                normalize : true,
+                componentDatatype : ComponentDatatype.UNSIGNED_BYTE
+            }];
+            command.vertexArray = context.createVertexArray(attributes);
+            command.primitiveType = PrimitiveType.TRIANGLE_FAN;
+
+            command.shaderProgram = context.getShaderCache().getShaderProgram(SunVS, SunFS, attributeIndices);
+            command.renderState = context.createRenderState({
+                blending : BlendingState.ALPHA_BLEND
+            });
+            command.boundingVolume = new BoundingSphere();
+        }
+
+        var sunPosition = context.getUniformState().getSunPositionWC();
+        var sunPositionCV = context.getUniformState().getSunPositionColumbusView();
+
+        var boundingVolume = this._boundingVolume;
+        var boundingVolume2D = this._boundingVolume2D;
+
+        Cartesian3.clone(sunPosition, boundingVolume.center);
+        boundingVolume2D.center.x = sunPositionCV.z;
+        boundingVolume2D.center.y = sunPositionCV.x;
+        boundingVolume2D.center.z = sunPositionCV.y;
+
+        if (mode === SceneMode.SCENE3D) {
+            BoundingSphere.clone(boundingVolume, command.boundingVolume);
+        } else if (mode === SceneMode.COLUMBUS_VIEW) {
+            BoundingSphere.clone(boundingVolume2D, command.boundingVolume);
+        }
+
+        return command;
+    };
+
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     *
+     * @memberof Sun
+     *
+     * @return {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     *
+     * @see Sun#destroy
+     */
+    Sun.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     *
+     * @memberof Sun
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see Sun#isDestroyed
+     *
+     * @example
+     * sun = sun && sun.destroy();
+     */
+    Sun.prototype.destroy = function() {
+        var command = this._command;
+        command.vertexArray = command.vertexArray && command.vertexArray.destroy();
+        command.shaderProgram = command.shaderProgram && command.shaderProgram.release();
+        return destroyObject(this);
+    };
+
+    return Sun;
+});