cesium 0.16.0 → 0.17.0

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

@@ -0,0 +1,417 @@
+/*global define*/
+define([
+        '../Core/BoundingRectangle',
+        '../Core/Cartesian2',
+        '../Core/Cartesian4',
+        '../Core/Color',
+        '../Core/ComponentDatatype',
+        '../Core/defaultValue',
+        '../Core/destroyObject',
+        '../Core/Math',
+        '../Core/Matrix4',
+        '../Core/PrimitiveType',
+        '../Core/Transforms',
+        '../Renderer/BufferUsage',
+        '../Renderer/ClearCommand',
+        '../Renderer/DrawCommand',
+        '../Renderer/PassState',
+        '../Renderer/PixelDatatype',
+        '../Renderer/PixelFormat',
+        '../Renderer/RenderbufferFormat',
+        '../Shaders/PostProcessFilters/AdditiveBlend',
+        '../Shaders/PostProcessFilters/BrightPass',
+        '../Shaders/PostProcessFilters/GaussianBlur1D',
+        '../Shaders/PostProcessFilters/PassThrough',
+        '../Shaders/ViewportQuadVS'
+    ], function(
+        BoundingRectangle,
+        Cartesian2,
+        Cartesian4,
+        Color,
+        ComponentDatatype,
+        defaultValue,
+        destroyObject,
+        CesiumMath,
+        Matrix4,
+        PrimitiveType,
+        Transforms,
+        BufferUsage,
+        ClearCommand,
+        DrawCommand,
+        PassState,
+        PixelDatatype,
+        PixelFormat,
+        RenderbufferFormat,
+        AdditiveBlend,
+        BrightPass,
+        GaussianBlur1D,
+        PassThrough,
+        ViewportQuadVS) {
+    "use strict";
+
+    var SunPostProcess = function() {
+        this._fbo = undefined;
+
+        this._downSampleFBO1 = undefined;
+        this._downSampleFBO2 = undefined;
+
+        this._clearFBO1Command = undefined;
+        this._clearFBO2Command = undefined;
+
+        this._downSampleCommand = undefined;
+        this._brightPassCommand = undefined;
+        this._blurXCommand = undefined;
+        this._blurYCommand = undefined;
+        this._blendCommand = undefined;
+        this._fullScreenCommand = undefined;
+
+        this._downSamplePassState = new PassState();
+        this._downSamplePassState.scissorTest = {
+            enable : true,
+            rectangle : new BoundingRectangle()
+        };
+
+        this._upSamplePassState = new PassState();
+        this._upSamplePassState.scissorTest = {
+            enabled : true,
+            rectangle : new BoundingRectangle()
+        };
+
+        this._uCenter = new Cartesian2();
+        this._uRadius = undefined;
+    };
+
+    SunPostProcess.prototype.clear = function(context, color) {
+        var clear = this._clearFBO1Command;
+        Color.clone(defaultValue(color, Color.BLACK), clear.color);
+        clear.execute(context);
+
+        clear = this._clearFBO2Command;
+        Color.clone(defaultValue(color, Color.BLACK), clear.color);
+        clear.execute(context);
+    };
+
+    SunPostProcess.prototype.execute = function(context) {
+        this._downSampleCommand.execute(context, this._downSamplePassState);
+        this._brightPassCommand.execute(context, this._downSamplePassState);
+        this._blurXCommand.execute(context, this._downSamplePassState);
+        this._blurYCommand.execute(context, this._downSamplePassState);
+        this._fullScreenCommand.execute(context);
+        this._blendCommand.execute(context, this._upSamplePassState);
+    };
+
+    var attributeIndices = {
+        position : 0,
+        textureCoordinates : 1
+    };
+
+    function getVertexArray(context) {
+        // Per-context cache for viewport quads
+        var vertexArray = context.cache.viewportQuad_vertexArray;
+
+        if (typeof vertexArray !== 'undefined') {
+            return vertexArray;
+        }
+
+        var mesh = {
+            attributes : {
+                position : {
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 2,
+                    values : [
+                       -1.0, -1.0,
+                        1.0, -1.0,
+                        1.0,  1.0,
+                       -1.0,  1.0
+                    ]
+                },
+
+                textureCoordinates : {
+                    componentDatatype : ComponentDatatype.FLOAT,
+                    componentsPerAttribute : 2,
+                    values : [
+                        0.0, 0.0,
+                        1.0, 0.0,
+                        1.0, 1.0,
+                        0.0, 1.0
+                    ]
+                }
+            }
+        };
+
+        vertexArray = context.createVertexArrayFromMesh({
+            mesh : mesh,
+            attributeIndices : attributeIndices,
+            bufferUsage : BufferUsage.STATIC_DRAW
+        });
+
+        context.cache.viewportQuad_vertexArray = vertexArray;
+        return vertexArray;
+    }
+
+    var viewportBoundingRectangle  = new BoundingRectangle();
+    var downSampleViewportBoundingRectangle = new BoundingRectangle();
+    var sunPositionECScratch = new Cartesian4();
+    var sunPositionWCScratch = new Cartesian2();
+    var sizeScratch = new Cartesian2();
+    var postProcessMatrix4Scratch= new Matrix4();
+
+    SunPostProcess.prototype.update = function(context) {
+        var canvas = context.getCanvas();
+        var width = canvas.clientWidth;
+        var height = canvas.clientHeight;
+
+        var that = this;
+
+        if (typeof this._fbo === 'undefined') {
+            this._fbo = context.createFramebuffer();
+
+            this._downSampleFBO1 = context.createFramebuffer();
+            this._downSampleFBO2 = context.createFramebuffer();
+
+            this._clearFBO1Command = new ClearCommand();
+            this._clearFBO1Command.color = new Color();
+            this._clearFBO1Command.framebuffer = this._downSampleFBO1;
+
+            this._clearFBO2Command = new ClearCommand();
+            this._clearFBO2Command.color = new Color();
+            this._clearFBO2Command.framebuffer = this._downSampleFBO2;
+
+            var primitiveType = PrimitiveType.TRIANGLE_FAN;
+            var vertexArray = getVertexArray(context);
+
+            var downSampleCommand = this._downSampleCommand = new DrawCommand();
+            downSampleCommand.primitiveType = primitiveType;
+            downSampleCommand.vertexArray = vertexArray;
+            downSampleCommand.shaderProgram = context.getShaderCache().getShaderProgram(ViewportQuadVS, PassThrough, attributeIndices);
+            downSampleCommand.uniformMap = {};
+            downSampleCommand.framebuffer = this._downSampleFBO1;
+
+            var brightPassCommand = this._brightPassCommand = new DrawCommand();
+            brightPassCommand.primitiveType = primitiveType;
+            brightPassCommand.vertexArray = vertexArray;
+            brightPassCommand.shaderProgram = context.getShaderCache().getShaderProgram(ViewportQuadVS, BrightPass, attributeIndices);
+            brightPassCommand.uniformMap = {
+                u_avgLuminance : function() {
+                    // A guess at the average luminance across the entire scene
+                    return 0.5;
+                },
+                u_threshold : function() {
+                    return 0.25;
+                },
+                u_offset : function() {
+                    return 0.1;
+                }
+            };
+            brightPassCommand.framebuffer = this._downSampleFBO2;
+
+            var delta = 1.0;
+            var sigma = 2.0;
+
+            var blurXCommand = this._blurXCommand = new DrawCommand();
+            blurXCommand.primitiveType = primitiveType;
+            blurXCommand.vertexArray = vertexArray;
+            blurXCommand.shaderProgram = context.getShaderCache().getShaderProgram(ViewportQuadVS, GaussianBlur1D, attributeIndices);
+            blurXCommand.uniformMap = {
+                delta : function() {
+                    return delta;
+                },
+                sigma : function() {
+                    return sigma;
+                },
+                direction : function() {
+                    return 0.0;
+                }
+            };
+            blurXCommand.framebuffer = this._downSampleFBO1;
+
+            var blurYCommand = this._blurYCommand = new DrawCommand();
+            blurYCommand.primitiveType = primitiveType;
+            blurYCommand.vertexArray = vertexArray;
+            blurYCommand.shaderProgram = context.getShaderCache().getShaderProgram(ViewportQuadVS, GaussianBlur1D, attributeIndices);
+            blurYCommand.uniformMap = {
+                delta : function() {
+                    return delta;
+                },
+                sigma : function() {
+                    return sigma;
+                },
+                direction : function() {
+                    return 1.0;
+                }
+            };
+            blurYCommand.framebuffer = this._downSampleFBO2;
+
+            var additiveBlendCommand = this._blendCommand = new DrawCommand();
+            additiveBlendCommand.primitiveType = primitiveType;
+            additiveBlendCommand.vertexArray = vertexArray;
+            additiveBlendCommand.shaderProgram = context.getShaderCache().getShaderProgram(ViewportQuadVS, AdditiveBlend, attributeIndices);
+            additiveBlendCommand.uniformMap = {
+                u_center : function() {
+                    return that._uCenter;
+                },
+                u_radius : function() {
+                    return that._uRadius;
+                }
+            };
+
+            var fullScreenCommand = this._fullScreenCommand = new DrawCommand();
+            fullScreenCommand.primitiveType = primitiveType;
+            fullScreenCommand.vertexArray = vertexArray;
+            fullScreenCommand.shaderProgram = context.getShaderCache().getShaderProgram(ViewportQuadVS, PassThrough, attributeIndices);
+            fullScreenCommand.uniformMap = {};
+        }
+
+        var downSampleWidth = Math.pow(2.0, Math.ceil(Math.log(width) / Math.log(2)) - 2.0);
+        var downSampleHeight = Math.pow(2.0, Math.ceil(Math.log(height) / Math.log(2)) - 2.0);
+        var downSampleSize = Math.max(downSampleWidth, downSampleHeight);
+
+        var viewport = viewportBoundingRectangle;
+        viewport.width = width;
+        viewport.height = height;
+
+        var downSampleViewport = downSampleViewportBoundingRectangle;
+        downSampleViewport.width = downSampleSize;
+        downSampleViewport.height = downSampleSize;
+
+        var fbo = this._fbo;
+        var colorTexture = fbo.getColorTexture();
+        if (typeof colorTexture === 'undefined' || colorTexture.getWidth() !== width || colorTexture.getHeight() !== height) {
+            fbo.setColorTexture(context.createTexture2D({
+                width : width,
+                height : height
+            }));
+
+            if (context.getDepthTexture()) {
+                fbo.setDepthTexture(context.createTexture2D({
+                    width : width,
+                    height : height,
+                    pixelFormat : PixelFormat.DEPTH_COMPONENT,
+                    pixelDatatype : PixelDatatype.UNSIGNED_SHORT
+                }));
+            } else {
+                fbo.setDepthRenderbuffer(context.createRenderbuffer({
+                    format : RenderbufferFormat.DEPTH_COMPONENT16
+                }));
+            }
+
+            this._downSampleFBO1.setColorTexture(context.createTexture2D({
+                width : downSampleSize,
+                height : downSampleSize
+            }));
+            this._downSampleFBO2.setColorTexture(context.createTexture2D({
+                width : downSampleSize,
+                height : downSampleSize
+            }));
+
+            var downSampleRenderState = context.createRenderState({
+                viewport : downSampleViewport
+            });
+            var upSampleRenderState = context.createRenderState();
+
+            this._downSampleCommand.uniformMap.u_texture = function() {
+                return fbo.getColorTexture();
+            };
+            this._downSampleCommand.renderState = downSampleRenderState;
+
+            this._brightPassCommand.uniformMap.u_texture = function() {
+                return that._downSampleFBO1.getColorTexture();
+            };
+            this._brightPassCommand.renderState = downSampleRenderState;
+
+            this._blurXCommand.uniformMap.u_texture = function() {
+                return that._downSampleFBO2.getColorTexture();
+            };
+            this._blurXCommand.uniformMap.u_step = function() {
+                return new Cartesian2(1.0 / downSampleSize, 1.0 / downSampleSize);
+            };
+            this._blurXCommand.renderState = downSampleRenderState;
+
+            this._blurYCommand.uniformMap.u_texture = function() {
+                return that._downSampleFBO1.getColorTexture();
+            };
+            this._blurYCommand.uniformMap.u_step = function() {
+                return new Cartesian2(1.0 / downSampleSize, 1.0 / downSampleSize);
+            };
+            this._blurYCommand.renderState = downSampleRenderState;
+
+            this._blendCommand.uniformMap.u_texture0 = function() {
+                return fbo.getColorTexture();
+            };
+            this._blendCommand.uniformMap.u_texture1 = function() {
+                return that._downSampleFBO2.getColorTexture();
+            };
+            this._blendCommand.renderState = upSampleRenderState;
+
+            this._fullScreenCommand.uniformMap.u_texture = function() {
+                return fbo.getColorTexture();
+            };
+            this._fullScreenCommand.renderState = upSampleRenderState;
+        }
+
+        var us = context.getUniformState();
+        var sunPosition = us.getSunPositionWC();
+        var viewMatrix = us.getView();
+        var viewProjectionMatrix = us.getViewProjection();
+        var projectionMatrix = us.getProjection();
+
+        // create up sampled render state
+        var viewportTransformation = Matrix4.computeViewportTransformation(viewport, 0.0, 1.0, postProcessMatrix4Scratch);
+        var sunPositionEC = Matrix4.multiplyByPoint(viewMatrix, sunPosition, sunPositionECScratch);
+        var sunPositionWC = Transforms.pointToWindowCoordinates(viewProjectionMatrix, viewportTransformation, sunPosition, sunPositionWCScratch);
+
+        sunPositionEC.x += CesiumMath.SOLAR_RADIUS;
+        var limbWC = Transforms.pointToWindowCoordinates(projectionMatrix, viewportTransformation, sunPositionEC, sunPositionEC);
+        var sunSize = Cartesian2.subtract(limbWC, sunPositionWC, limbWC).magnitude() * 30.0 * 2.0;
+
+        var size = sizeScratch;
+        size.x = sunSize;
+        size.y = sunSize;
+
+        var scissorRectangle = this._upSamplePassState.scissorTest.rectangle;
+        scissorRectangle.x = Math.max(sunPositionWC.x - size.x * 0.5, 0.0);
+        scissorRectangle.y = Math.max(sunPositionWC.y - size.y * 0.5, 0.0);
+        scissorRectangle.width = Math.min(size.x, width);
+        scissorRectangle.height = Math.min(size.y, height);
+
+        Cartesian2.clone(sunPositionWC, this._uCenter);
+        this._uRadius = Math.max(size.x, size.y) * 0.5;
+
+        // create down sampled render state
+        viewportTransformation = Matrix4.computeViewportTransformation(downSampleViewport, 0.0, 1.0, postProcessMatrix4Scratch);
+        sunPositionWC = Transforms.pointToWindowCoordinates(viewProjectionMatrix, viewportTransformation, sunPosition, sunPositionWCScratch);
+
+        size.x *= downSampleWidth / width;
+        size.y *= downSampleHeight / height;
+
+        scissorRectangle = this._downSamplePassState.scissorTest.rectangle;
+        scissorRectangle.x = Math.max(sunPositionWC.x - size.x * 0.5, 0.0);
+        scissorRectangle.y = Math.max(sunPositionWC.y - size.y * 0.5, 0.0);
+        scissorRectangle.width = Math.min(size.x, width);
+        scissorRectangle.height = Math.min(size.y, height);
+
+        this._downSamplePassState.context = context;
+        this._upSamplePassState.context = context;
+
+        return this._fbo;
+    };
+
+    SunPostProcess.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    SunPostProcess.prototype.destroy = function() {
+        this._fbo = this._fbo && this._fbo.destroy();
+        this._downSampleFBO1 = this._downSampleFBO1 && this._downSampleFBO1.destroy();
+        this._downSampleFBO2 = this._downSampleFBO2 && this._downSampleFBO2.destroy();
+        this._downSampleCommand = this._downSampleCommand && this._downSampleCommand.shaderProgram && this._downSampleCommand.release();
+        this._brightPassCommand = this._brightPassCommand && this._brightPassCommand.shaderProgram && this._brightPassCommand.release();
+        this._blurXCommand = this._blurXCommand && this._blurXCommand.shaderProgram && this._blurXCommand.release();
+        this._blurYCommand = this._blurYCommand && this._blurYCommand.shaderProgram && this._blurYCommand.release();
+        this._blendCommand = this._blendCommand && this._blendCommand.shaderProgram && this._blendCommand.release();
+        this._fullScreenCommand = this._fullScreenCommand && this._fullScreenCommand.shaderProgram && this._fullScreenCommand.release();
+        return destroyObject(this);
+    };
+
+    return SunPostProcess;
+});

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

@@ -118,18 +118,6 @@ define([
          */
         this.state = TileState.START;
 
-        /**
-         * The previous tile in the {@link TileLoadQueue}.
-         * @type Tile
-         */
-        this.loadPrevious = undefined;
-
-        /**
-         * The next tile in the {@link TileLoadQueue}.
-         * @type Tile
-         */
-        this.loadNext = undefined;
-
         /**
          * The previous tile in the {@link TileReplacementQueue}.
          * @type Tile

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

@@ -1,14 +1,8 @@
 /*global define*/
 define([
-        '../Core/defaultValue',
-        '../Core/loadImage',
-        '../Core/DeveloperError',
-        '../Core/throttleRequestByServer'
+        '../Core/defaultValue'
     ], function(
-        defaultValue,
-        loadImage,
-        DeveloperError,
-        throttleRequestByServer) {
+        defaultValue) {
     "use strict";
 
     /**