cesium 0.13.0

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

@@ -0,0 +1,239 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/CubeMapEllipsoidTessellator',
+        '../Core/destroyObject',
+        '../Core/MeshFilters',
+        '../Core/PrimitiveType',
+        '../Core/Ellipsoid',
+        '../Renderer/BufferUsage',
+        '../Renderer/DrawCommand',
+        '../Renderer/CullFace',
+        '../Renderer/BlendingState',
+        '../Scene/SceneMode',
+        '../Shaders/SkyAtmosphereVS',
+        '../Shaders/SkyAtmosphereFS'
+    ], function(
+        defaultValue,
+        CubeMapEllipsoidTessellator,
+        destroyObject,
+        MeshFilters,
+        PrimitiveType,
+        Ellipsoid,
+        BufferUsage,
+        DrawCommand,
+        CullFace,
+        BlendingState,
+        SceneMode,
+        SkyAtmosphereVS,
+        SkyAtmosphereFS) {
+    "use strict";
+
+    /**
+     * An atmosphere drawn around the limb of the provided ellipsoid.  Based on
+     * <a href="http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter16.html" target="_blank">Accurate Atmospheric Scattering</a>
+     * in GPU Gems 2.
+     * <p>
+     * This is only supported in 3D.  atmosphere is faded out when morphing to 2D or Columbus view.
+     * </p>
+     *
+     * @alias SkyAtmosphere
+     * @constructor
+     *
+     * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid that the atmosphere is drawn around.
+     *
+     * @example
+     * scene.skyAtmosphere = new SkyAtmosphere();
+     *
+     * @see Scene.skyAtmosphere
+     */
+    var SkyAtmosphere = function(ellipsoid) {
+        ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
+
+        /**
+         * Determines if the atmosphere is shown.
+         * <p>
+         * The default is <code>true</code>.
+         * </p>
+         *
+         * @type Boolean
+         */
+        this.show = true;
+
+        /**
+         * The current morph transition time between 2D/Columbus View and 3D,
+         * with 0.0 being 2D or Columbus View and 1.0 being 3D.
+         *
+         * @type Number
+         */
+        this.morphTime = 1.0;
+
+        this._ellipsoid = ellipsoid;
+        this._command = new DrawCommand();
+        this._spSkyFromSpace = undefined;
+        this._spSkyFromAtmosphere = undefined;
+
+        this._fCameraHeight = undefined;
+        this._fCameraHeight2 = undefined;
+        this._outerRadius = ellipsoid.getRadii().multiplyByScalar(1.025).getMaximumComponent();
+        var innerRadius = ellipsoid.getMaximumRadius();
+        var rayleighScaleDepth = 0.25;
+
+        var that = this;
+
+        this._command.uniformMap = {
+            fCameraHeight : function() {
+                return that._fCameraHeight;
+            },
+            fCameraHeight2 : function() {
+                return that._fCameraHeight2;
+            },
+            fOuterRadius : function() {
+                return that._outerRadius;
+            },
+            fOuterRadius2 : function() {
+                return that._outerRadius * that._outerRadius;
+            },
+            fInnerRadius : function() {
+                return innerRadius;
+            },
+            fScale : function() {
+                return 1.0 / (that._outerRadius - innerRadius);
+            },
+            fScaleDepth : function() {
+                return rayleighScaleDepth;
+            },
+            fScaleOverScaleDepth : function() {
+                return (1.0 / (that._outerRadius - innerRadius)) / rayleighScaleDepth;
+            },
+            u_morphTime : function() {
+                return that.morphTime;
+            }
+        };
+    };
+
+    /**
+     * Gets the ellipsoid the atmosphere is drawn around.
+     *
+     * @memberof SkyAtmosphere
+     *
+     * @return {Ellipsoid}
+     */
+    SkyAtmosphere.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
+
+    /**
+     * @private
+     */
+    SkyAtmosphere.prototype.update = function(context, frameState) {
+        if (!this.show) {
+            return undefined;
+        }
+
+        if ((frameState.mode !== SceneMode.SCENE3D) &&
+            (frameState.mode !== SceneMode.MORPHING)) {
+            return undefined;
+        }
+
+        // The atmosphere is only rendered during the color pass; it is not pickable, it doesn't cast shadows, etc.
+        if (!frameState.passes.color) {
+            return undefined;
+        }
+
+        var command = this._command;
+
+        if (typeof command.vertexArray === 'undefined') {
+            var mesh = CubeMapEllipsoidTessellator.compute(Ellipsoid.fromCartesian3(this._ellipsoid.getRadii().multiplyByScalar(1.025)), 60);
+            command.vertexArray = context.createVertexArrayFromMesh({
+                mesh : mesh,
+                attributeIndices : MeshFilters.createAttributeIndices(mesh),
+                bufferUsage : BufferUsage.STATIC_DRAW
+            });
+            command.primitiveType = PrimitiveType.TRIANGLES;
+            command.renderState = context.createRenderState({
+                cull : {
+                    enabled : true,
+                    face : CullFace.FRONT
+                },
+                blending : BlendingState.ALPHA_BLEND
+            });
+
+            var vs;
+            var fs;
+            var shaderCache = context.getShaderCache();
+
+            vs = '#define SKY_FROM_SPACE\n' +
+                 '#line 0\n' +
+                 SkyAtmosphereVS;
+            fs = '#line 0\n' +
+                 SkyAtmosphereFS;
+            this._spSkyFromSpace = shaderCache.getShaderProgram(vs, fs);
+
+            vs = '#define SKY_FROM_ATMOSPHERE\n' +
+                 '#line 0\n' +
+                 SkyAtmosphereVS;
+            this._spSkyFromAtmosphere = shaderCache.getShaderProgram(vs, fs);
+        }
+
+        var cameraPosition = frameState.camera.getPositionWC();
+
+        this._fCameraHeight2 = cameraPosition.magnitudeSquared();
+        this._fCameraHeight = Math.sqrt(this._fCameraHeight2);
+
+        if (this._fCameraHeight > this._outerRadius) {
+            // Camera in space
+            command.shaderProgram = this._spSkyFromSpace;
+        } else {
+            // Camera in atmosphere
+            command.shaderProgram = this._spSkyFromAtmosphere;
+        }
+
+        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 SkyAtmosphere
+     *
+     * @return {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     *
+     * @see SkyAtmosphere#destroy
+     */
+    SkyAtmosphere.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 SkyAtmosphere
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see SkyAtmosphere#isDestroyed
+     *
+     * @example
+     * skyAtmosphere = skyAtmosphere && skyAtmosphere.destroy();
+     */
+    SkyAtmosphere.prototype.destroy = function() {
+        var command = this._command;
+        command.vertexArray = command.vertexArray && command.vertexArray.destroy();
+        this._spSkyFromSpace = this._spSkyFromSpace && this._spSkyFromSpace.release();
+        this._spSkyFromAtmosphere = this._spSkyFromAtmosphere && this._spSkyFromAtmosphere.release();
+        return destroyObject(this);
+    };
+
+    return SkyAtmosphere;
+});

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

@@ -0,0 +1,231 @@
+/*global define*/
+define([
+        '../Core/BoxTessellator',
+        '../Core/Cartesian3',
+        '../Core/destroyObject',
+        '../Core/DeveloperError',
+        '../Core/Matrix4',
+        '../Core/MeshFilters',
+        '../Core/PrimitiveType',
+        '../Renderer/loadCubeMap',
+        '../Renderer/BufferUsage',
+        '../Renderer/DrawCommand',
+        '../Renderer/BlendingState',
+        '../Scene/SceneMode',
+        '../Shaders/SkyBoxVS',
+        '../Shaders/SkyBoxFS'
+    ], function(
+        BoxTessellator,
+        Cartesian3,
+        destroyObject,
+        DeveloperError,
+        Matrix4,
+        MeshFilters,
+        PrimitiveType,
+        loadCubeMap,
+        BufferUsage,
+        DrawCommand,
+        BlendingState,
+        SceneMode,
+        SkyBoxVS,
+        SkyBoxFS) {
+    "use strict";
+
+    /**
+     * A sky box around the scene to draw stars.  The sky box is defined using the True Equator Mean Equinox (TEME) axes.
+     * <p>
+     * This is only supported in 3D.  The sky box is faded out when morphing to 2D or Columbus view.
+     * </p>
+     *
+     * @alias SkyBox
+     * @constructor
+     *
+     * @param {Object} sources The source URL or <code>Image</code> object for each of the six cube map faces.  See the example below.
+     *
+     * @exception {DeveloperError} sources is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties.
+     * @exception {DeveloperError} sources properties must all be the same type.
+     *
+     * @example
+     * scene.skyBox = new SkyBox({
+     *     positiveX : 'skybox_px.png',
+     *     negativeX : 'skybox_nx.png',
+     *     positiveY : 'skybox_py.png',
+     *     negativeY : 'skybox_ny.png',
+     *     positiveZ : 'skybox_pz.png',
+     *     negativeZ : 'skybox_nz.png'
+     * });
+     *
+     * @see Scene#skyBox
+     * @see Transforms.computeTemeToPseudoFixedMatrix
+     */
+    var SkyBox = function(sources) {
+        if ((typeof sources === 'undefined') ||
+            (typeof sources.positiveX === 'undefined') ||
+            (typeof sources.negativeX === 'undefined') ||
+            (typeof sources.positiveY === 'undefined') ||
+            (typeof sources.negativeY === 'undefined') ||
+            (typeof sources.positiveZ === 'undefined') ||
+            (typeof sources.negativeZ === 'undefined')) {
+            throw new DeveloperError('sources is required and must have positiveX, negativeX, positiveY, negativeY, positiveZ, and negativeZ properties.');
+        }
+
+        if ((typeof sources.positiveX !== typeof sources.negativeX) ||
+            (typeof sources.positiveX !== typeof sources.positiveY) ||
+            (typeof sources.positiveX !== typeof sources.negativeY) ||
+            (typeof sources.positiveX !== typeof sources.positiveZ) ||
+            (typeof sources.positiveX !== typeof sources.negativeZ)) {
+            throw new DeveloperError('sources properties must all be the same type.');
+        }
+
+        this._command = new DrawCommand();
+        this._cubeMap = undefined;
+        this._sources = sources;
+
+        /**
+         * Determines if the sky box will be shown.
+         * <p>
+         * The default is <code>true</code>.
+         * </p>
+         *
+         * @type Boolean
+         */
+        this.show = true;
+
+        /**
+         * The current morph transition time between 2D/Columbus View and 3D,
+         * with 0.0 being 2D or Columbus View and 1.0 being 3D.
+         *
+         * @type Number
+         */
+        this.morphTime = 1.0;
+    };
+
+    /**
+     * Returns the sources used to create the cube map faces: an object
+     * with <code>positiveX</code>, <code>negativeX</code>, <code>positiveY</code>,
+     * <code>negativeY</code>, <code>positiveZ</code>, and <code>negativeZ</code> properties.
+     * These are either URLs or <code>Image</code> objects, depending on how the sky box
+     * was constructed.
+     *
+     * @memberof SkyBox
+     *
+     * @return {Object} The sources used to create the cube map faces.
+     */
+    SkyBox.prototype.getSources = function() {
+        return this._sources;
+    };
+
+    /**
+     * @private
+     */
+    SkyBox.prototype.update = function(context, frameState) {
+        if (!this.show) {
+            return undefined;
+        }
+
+        if ((frameState.mode !== SceneMode.SCENE3D) &&
+            (frameState.mode !== SceneMode.MORPHING)) {
+            return undefined;
+        }
+
+        // The sky box is only rendered during the color pass; it is not pickable, it doesn't cast shadows, etc.
+        if (!frameState.passes.color) {
+            return undefined;
+        }
+
+        var command = this._command;
+
+        if (typeof command.vertexArray === 'undefined') {
+            var sources = this._sources;
+            var that = this;
+
+            if (typeof sources.positiveX === 'string') {
+                // Given urls for cube-map images.  Load them.
+                loadCubeMap(context, this._sources).then(function(cubeMap) {
+                    that._cubeMap = cubeMap;
+                });
+            } else {
+                this._cubeMap = context.createCubeMap({
+                    source : sources
+                });
+            }
+
+            command.uniformMap = {
+                u_cubeMap: function() {
+                    return that._cubeMap;
+                },
+                u_morphTime : function() {
+                    return that.morphTime;
+                }
+            };
+
+            var mesh = BoxTessellator.compute({
+                dimensions : new Cartesian3(2.0, 2.0, 2.0)
+            });
+            var attributeIndices = MeshFilters.createAttributeIndices(mesh);
+
+            command.primitiveType = PrimitiveType.TRIANGLES;
+            command.modelMatrix = Matrix4.IDENTITY.clone();
+            command.vertexArray = context.createVertexArrayFromMesh({
+                mesh: mesh,
+                attributeIndices: attributeIndices,
+                bufferUsage: BufferUsage.STATIC_DRAW
+            });
+            command.shaderProgram = context.getShaderCache().getShaderProgram(SkyBoxVS, SkyBoxFS, attributeIndices);
+            command.renderState = context.createRenderState({
+                blending : BlendingState.ALPHA_BLEND
+            });
+        }
+
+        if (typeof this._cubeMap === 'undefined') {
+            return undefined;
+        }
+
+        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 SkyBox
+     *
+     * @return {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     *
+     * @see SkyBox#destroy
+     */
+    SkyBox.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 SkyBox
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see SkyBox#isDestroyed
+     *
+     * @example
+     * skyBox = skyBox && skyBox.destroy();
+     */
+    SkyBox.prototype.destroy = function() {
+        var command = this._command;
+        command.vertexArray = command.vertexArray && command.vertexArray.destroy();
+        command.shaderProgram = command.shaderProgram && command.shaderProgram.release();
+        this._cubeMap = this._cubeMap && this._cubeMap.destroy();
+        return destroyObject(this);
+    };
+
+    return SkyBox;
+});