Added compute pass

Source/Renderer/ComputeCommand.js

@@ -0,0 +1,120 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/PrimitiveType',
+        '../Scene/Pass'
+    ], function(
+        defaultValue,
+        PrimitiveType,
+        Pass) {
+    "use strict";
+
+    /**
+     * Represents a command to the renderer for GPU Compute (using old-school GPGPU).
+     *
+     * @private
+     */
+    var ComputeCommand = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+        /**
+         * The vertex array. If none is provided, a viewport quad will be used.
+         *
+         * @type {VertexArray}
+         * @default undefined
+         */
+        this.vertexArray = options.vertexArray;
+
+        /**
+         * The fragment shader source. The default vertex shader is ViewportQuadVS.
+         *
+         * @type {ShaderSource}
+         * @default undefined
+         */
+        this.fragmentShaderSource = options.fragmentShaderSource;
+
+        /**
+         * The shader program to apply.
+         *
+         * @type {ShaderProgram}
+         * @default undefined
+         */
+        this.shaderProgram = options.shaderProgram;
+
+        /**
+         * An object with functions whose names match the uniforms in the shader program
+         * and return values to set those uniforms.
+         *
+         * @type {Object}
+         * @default undefined
+         */
+        this.uniformMap = options.uniformMap;
+
+        /**
+         * Texture to use for offscreen rendering.
+         *
+         * @type {Texture}
+         * @default undefined
+         */
+        this.outputTexture = options.outputTexture;
+
+        /**
+         * Function that is called immediately before the ComputeCommand is executed. Used to
+         * update any renderer resources. Takes the ComputeCommand as its single argument.
+         *
+         * @type {Function}
+         * @default undefined
+         */
+        this.preExecute = options.preExecute;
+
+        /**
+         * Function that is called after the ComputeCommand is executed. Takes the output
+         * texture as its single argument.
+         *
+         * @type {Function}
+         * @default undefined
+         */
+        this.postExecute = options.postExecute;
+
+        /**
+         * Whether the renderer resources will persist beyond this call. If not, they
+         * will be destroyed after completion.
+         *
+         * @type {Boolean}
+         * @default false
+         */
+        this.persists = defaultValue(options.persists, false);
+
+        /**
+         * The pass when to render. Always compute pass.
+         *
+         * @type {Pass}
+         * @default Pass.COMPUTE;
+         */
+        this.pass = Pass.COMPUTE;
+
+        /**
+         * The object who created this command.  This is useful for debugging command
+         * execution; it allows us to see who created a command when we only have a
+         * reference to the command, and can be used to selectively execute commands
+         * with {@link Scene#debugCommandFilter}.
+         *
+         * @type {Object}
+         * @default undefined
+         *
+         * @see Scene#debugCommandFilter
+         */
+        this.owner = options.owner;
+    };
+
+    /**
+     * Executes the compute command.
+     *
+     * @param {Context} context The context that processes the compute command.
+     */
+    ComputeCommand.prototype.execute = function(computeEngine) {
+        computeEngine.execute(this);
+    };
+
+    return ComputeCommand;
+});

Source/Renderer/ComputeEngine.js

@@ -0,0 +1,158 @@
+/*global define*/
+define([
+        '../Core/BoundingRectangle',
+        '../Core/Color',
+        '../Core/ComponentDatatype',
+        '../Core/defaultValue',
+        '../Core/defined',
+        '../Core/defineProperties',
+        '../Core/destroyObject',
+        '../Core/DeveloperError',
+        '../Core/Geometry',
+        '../Core/GeometryAttribute',
+        '../Core/PrimitiveType',
+        '../Shaders/ViewportQuadVS',
+        './BufferUsage',
+        './ClearCommand',
+        './DrawCommand',
+        './Framebuffer',
+        './RenderState',
+        './ShaderProgram'
+    ], function(
+        BoundingRectangle,
+        Color,
+        ComponentDatatype,
+        defaultValue,
+        defined,
+        defineProperties,
+        destroyObject,
+        DeveloperError,
+        Geometry,
+        GeometryAttribute,
+        PrimitiveType,
+        ViewportQuadVS,
+        BufferUsage,
+        ClearCommand,
+        DrawCommand,
+        Framebuffer,
+        RenderState,
+        ShaderProgram) {
+    "use strict";
+
+    /**
+     * @private
+     */
+    var ComputeEngine = function(context) {
+        this._context = context;
+    };
+
+    var renderStateScratch;
+    var drawCommandScratch = new DrawCommand({
+        primitiveType : PrimitiveType.TRIANGLES
+    });
+    var clearCommandScratch = new ClearCommand({
+        color : new Color(0.0, 0.0, 0.0, 0.0)
+    });
+
+    function createFramebuffer(context, outputTexture) {
+        return new Framebuffer({
+            context : context,
+            colorTextures : [outputTexture],
+            destroyAttachments : false
+        });
+    }
+
+    function createViewportQuadShader(context, fragmentShaderSource) {
+        return ShaderProgram.fromCache({
+            context : context,
+            vertexShaderSource : ViewportQuadVS,
+            fragmentShaderSource : fragmentShaderSource,
+            attributeLocations : {
+                position : 0,
+                textureCoordinates : 1
+            }
+        });
+    }
+
+    function createRenderState(width, height) {
+        if ((!defined(renderStateScratch)) ||
+            (renderStateScratch.viewport.width !== width) ||
+            (renderStateScratch.viewport.height !== height)) {
+
+            renderStateScratch = RenderState.fromCache({
+                viewport : new BoundingRectangle(0, 0, width, height)
+            });
+        }
+        return renderStateScratch;
+    }
+
+    ComputeEngine.prototype.execute = function(computeCommand) {
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(computeCommand)) {
+            throw new DeveloperError('computeCommand is required.');
+        }
+        //>>includeEnd('debug');
+
+        // This may modify the command's resources, so do error checking afterwards
+        if (defined(computeCommand.preExecute)) {
+            computeCommand.preExecute(computeCommand);
+        }
+
+        //>>includeStart('debug', pragmas.debug);
+        if (!defined(computeCommand.fragmentShaderSource) && !defined(computeCommand.shaderProgram)) {
+            throw new DeveloperError('computeCommand.fragmentShaderSource or computeCommand.shaderProgram is required.');
+        }
+
+        if (!defined(computeCommand.outputTexture)) {
+            throw new DeveloperError('computeCommand.outputTexture is required.');
+        }
+        //>>includeEnd('debug');
+
+        var outputTexture = computeCommand.outputTexture;
+        var width = outputTexture.width;
+        var height = outputTexture.height;
+
+        var context = this._context;
+        var vertexArray = defined(computeCommand.vertexArray) ? computeCommand.vertexArray : context.getViewportQuadVertexArray();
+        var shaderProgram = defined(computeCommand.shaderProgram) ? computeCommand.shaderProgram : createViewportQuadShader(context, computeCommand.fragmentShaderSource);
+        var framebuffer = createFramebuffer(context, outputTexture);
+        var renderState = createRenderState(width, height);
+        var uniformMap = computeCommand.uniformMap;
+
+        var clearCommand = clearCommandScratch;
+        clearCommand.framebuffer = framebuffer;
+        clearCommand.renderState = renderState;
+        clearCommand.execute(context);
+
+        var drawCommand = drawCommandScratch;
+        drawCommand.vertexArray = vertexArray;
+        drawCommand.renderState = renderState;
+        drawCommand.shaderProgram = shaderProgram;
+        drawCommand.uniformMap = uniformMap;
+        drawCommand.framebuffer = framebuffer;
+        drawCommand.execute(context);
+
+        framebuffer.destroy();
+
+        if (!computeCommand.persists) {
+            shaderProgram.destroy();
+            if (defined(computeCommand.vertexArray)) {
+                vertexArray.destroy();
+            }
+        }
+
+        if (defined(computeCommand.postExecute)) {
+            computeCommand.postExecute(outputTexture);
+        }
+    };
+
+    ComputeEngine.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    ComputeEngine.prototype.destroy = function() {
+        return destroyObject(this);
+    };
+
+    return ComputeEngine;
+});

Source/Renderer/Context.js

@@ -918,7 +918,7 @@ define([
         textureCoordinates : 1
     };
 
-    Context.prototype.createViewportQuadCommand = function(fragmentShaderSource, overrides) {
+    Context.prototype.getViewportQuadVertexArray = function() {
         // Per-context cache for viewport quads
         var vertexArray = this.cache.viewportQuad_vertexArray;
 
@@ -955,21 +955,22 @@ define([
             vertexArray = VertexArray.fromGeometry({
                 context : this,
                 geometry : geometry,
-                attributeLocations : {
-                    position : 0,
-                    textureCoordinates : 1
-                },
+                attributeLocations : viewportQuadAttributeLocations,
                 bufferUsage : BufferUsage.STATIC_DRAW,
                 interleave : true
             });
 
             this.cache.viewportQuad_vertexArray = vertexArray;
         }
 
+        return vertexArray;
+    };
+
+    Context.prototype.createViewportQuadCommand = function(fragmentShaderSource, overrides) {
         overrides = defaultValue(overrides, defaultValue.EMPTY_OBJECT);
 
         return new DrawCommand({
-            vertexArray : vertexArray,
+            vertexArray : this.getViewportQuadVertexArray(),
             primitiveType : PrimitiveType.TRIANGLES,
             renderState : overrides.renderState,
             shaderProgram : ShaderProgram.fromCache({

Source/Renderer/VertexArray.js

@@ -185,7 +185,8 @@ define([
      *     context : context,
      *     sizeInBytes : 12,
      *     usage : BufferUsage.STATIC_DRAW
-     * });     * var attributes = [
+     * });
+     * var attributes = [
      *     {
      *         index                  : 0,
      *         vertexBuffer           : positionBuffer,

Source/Scene/Camera.js

@@ -1953,7 +1953,7 @@ define([
     };
 
     /**
-     * View an rectangle on an ellipsoid or map.
+     * View a rectangle on an ellipsoid or map.
      *
      * @param {Rectangle} rectangle The rectangle to view.
      * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid to view.

Source/Scene/GlobeSurfaceTile.js

@@ -295,7 +295,7 @@ define([
         }
     };
 
-    GlobeSurfaceTile.processStateMachine = function(tile, context, terrainProvider, imageryLayerCollection) {
+    GlobeSurfaceTile.processStateMachine = function(tile, context, commandList, terrainProvider, imageryLayerCollection) {
         var surfaceTile = tile.data;
         if (!defined(surfaceTile)) {
             surfaceTile = tile.data = new GlobeSurfaceTile();
@@ -345,7 +345,7 @@ define([
                 }
             }
 
-            var thisTileDoneLoading = tileImagery.processStateMachine(tile, context);
+            var thisTileDoneLoading = tileImagery.processStateMachine(tile, context, commandList);
             isDoneLoading = isDoneLoading && thisTileDoneLoading;
 
             // The imagery is renderable as soon as we have any renderable imagery for this region.

Source/Scene/GlobeSurfaceTileProvider.js

@@ -430,8 +430,8 @@ define([
      *
      * @exception {DeveloperError} <code>loadTile</code> must not be called before the tile provider is ready.
      */
-    GlobeSurfaceTileProvider.prototype.loadTile = function(context, frameState, tile) {
-        GlobeSurfaceTile.processStateMachine(tile, context, this._terrainProvider, this._imageryLayers);
+    GlobeSurfaceTileProvider.prototype.loadTile = function(context, frameState, commandList, tile) {
+        GlobeSurfaceTile.processStateMachine(tile, context, commandList, this._terrainProvider, this._imageryLayers);
     };
 
     var boundingSphereScratch = new BoundingSphere();

Source/Scene/Imagery.js

@@ -80,7 +80,7 @@ define([
         return this.referenceCount;
     };
 
-    Imagery.prototype.processStateMachine = function(context) {
+    Imagery.prototype.processStateMachine = function(context, commandList) {
         if (this.state === ImageryState.UNLOADED) {
             this.state = ImageryState.TRANSITIONING;
             this.imageryLayer._requestImagery(this);
@@ -93,7 +93,7 @@ define([
 
         if (this.state === ImageryState.TEXTURE_LOADED) {
             this.state = ImageryState.TRANSITIONING;
-            this.imageryLayer._reprojectTexture(context, this);
+            this.imageryLayer._reprojectTexture(context, commandList, this);
         }
     };