Post processing

Source/Scene/PostProcessStage.js

@@ -161,8 +161,6 @@ define([
         this._enabled = true;
     }
 
-    var depthTextureRegex = /uniform\s+sampler2D\s+depthTexture/g;
-
     defineProperties(PostProcessStage.prototype, {
         /**
          * Determines if this post-process stage is ready to be executed. A stage is only executed when both <code>ready</code>
@@ -335,25 +333,32 @@ define([
                 }
                 return undefined;
             }
-        },
-        /**
-         * Whether or not this post process stage requires a depth texture. If <code>true</code> and the WEBGL_depth_texture
-         * extension is unavailable, this stage will not execute.
-         *
-         * @memberof PostProcessStage.prototype
-         * @type {Boolean}
-         * @readonly
-         *
-         * @see {Context#depthTexture}
-         * @see {@link http://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/|WEBGL_depth_texture}
-         */
-        requiresDepthTexture : {
-            get : function() {
-                return depthTextureRegex.test(this._fragmentShader);
-            }
         }
     });
 
+    var depthTextureRegex = /uniform\s+sampler2D\s+depthTexture/g;
+
+    /**
+     * Whether or not this post process stage is supported.
+     * <p>
+     * A post process stage is not supported when it requires a depth texture and the WEBGL_depth_texture extension is not
+     * supported.
+     * </p>
+     *
+     * @param {Context} context The context.
+     * @return {Boolean} Whether this post process stage is supported.
+     *
+     * @see {Context#depthTexture}
+     * @see {@link http://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/|WEBGL_depth_texture}
+     */
+    PostProcessStage.prototype.isSupported = function(context) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.object('context', context);
+        //>>includeEnd('debug');
+
+        return !depthTextureRegex.test(this._fragmentShader) || context.depthTexture;
+    };
+
     function getUniformValueGetterAndSetter(stage, uniforms, name) {
         var currentValue = uniforms[name];
         if (typeof currentValue === 'string' || currentValue instanceof HTMLCanvasElement || currentValue instanceof HTMLImageElement ||

Source/Scene/PostProcessStageCollection.js

@@ -450,7 +450,7 @@ define([
         var count = 0;
         for (i = 0; i < length; ++i) {
             stage = stages[i];
-            if (stage.ready && stage.enabled && (!stage.requiresDepthTexture || context.depthTexture)) {
+            if (stage.ready && stage.enabled && stage.isSupported(context)) {
                 activeStages[count++] = stage;
             }
         }

Source/Scene/PostProcessStageComposite.js

@@ -193,31 +193,36 @@ define([
             get : function() {
                 return this._stages.length;
             }
-        },
-        /**
-         * Whether or not this post process stage requires a depth texture. If <code>true</code> and the WEBGL_depth_texture
-         * extension is unavailable, this stage will not execute.
-         *
-         * @memberof PostProcessStageComposite.prototype
-         * @type {Boolean}
-         * @readonly
-         *
-         * @see {Context#depthTexture}
-         * @see {@link http://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/|WEBGL_depth_texture}
-         */
-        requiresDepthTexture : {
-            get : function() {
-                var stages = this._stages;
-                var length = stages.length;
-                for (var i = 0; i < length; ++i) {
-                    if (stages[i].requiresDepthTexture) {
-                        return true;
-                    }
-                }
+        }
+    });
+
+    /**
+     * Whether or not this post process stage is supported.
+     * <p>
+     * A post process stage is not supported when it requires a depth texture and the WEBGL_depth_texture extension is not
+     * supported.
+     * </p>
+     *
+     * @param {Context} context The context.
+     * @return {Boolean} Whether this post process stage is supported.
+     *
+     * @see {Context#depthTexture}
+     * @see {@link http://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/|WEBGL_depth_texture}
+     */
+    PostProcessStageComposite.prototype.isSupported = function(context) {
+        //>>includeStart('debug', pragmas.debug);
+        Check.typeOf.object('context', context);
+        //>>includeEnd('debug');
+
+        var stages = this._stages;
+        var length = stages.length;
+        for (var i = 0; i < length; ++i) {
+            if (!stages[i].isSupported(context)) {
                 return false;
             }
         }
-    });
+        return true;
+    };
 
     /**
      * Gets the post-process stage at <code>index</code>

Source/Scene/PostProcessStageTextureCache.js

@@ -45,7 +45,7 @@ define([
     }
 
     function getStageDependencies(collection, context, dependencies, stage, previousName) {
-        if (!stage.enabled || (stage.requiresDepthTexture && !context.depthTexture)) {
+        if (!stage.enabled || !stage.isSupported(context)) {
             return previousName;
         }
 
@@ -71,7 +71,7 @@ define([
     }
 
     function getCompositeDependencies(collection, context, dependencies, composite, previousName) {
-        if ((defined(composite.enabled) && !composite.enabled) || (defined(composite.requiresDepthTexture) && composite.requiresDepthTexture && !context.depthTexture)) {
+        if ((defined(composite.enabled) && !composite.enabled) || (defined(composite.isSupported) && !composite.isSupported(context))) {
             return previousName;
         }
 

Specs/Scene/PostProcessStageCompositeSpec.js

@@ -1,13 +1,19 @@
 defineSuite([
         'Scene/PostProcessStageComposite',
         'Core/Color',
+        'Core/defined',
         'Scene/PostProcessStage',
-        'Specs/createScene'
+        'Specs/createScene',
+        'Specs/pollToPromise',
+        'ThirdParty/when'
     ], function(
         PostProcessStageComposite,
         Color,
+        defined,
         PostProcessStage,
-        createScene) {
+        createScene,
+        pollToPromise,
+        when) {
     'use strict';
 
     var scene;
@@ -161,6 +167,64 @@ defineSuite([
         expect(scene).toRender([0, 0, 255, 255]);
     });
 
+    it('isSupported throws without a context', function() {
+        var stage = new PostProcessStageComposite({
+            stages : [new PostProcessStage({
+                fragmentShader : 'void main() { gl_FragColor = vec4(1.0); }'
+            })]
+        });
+        expect(function() {
+            return stage.isSupported();
+        }).toThrowDeveloperError();
+    });
+
+    it('isSupported', function() {
+        var stage = new PostProcessStageComposite({
+            stages : [new PostProcessStage({
+                fragmentShader : 'void main() { gl_FragColor = vec4(1.0); }'
+            })]
+        });
+        expect(stage.isSupported(scene.context)).toEqual(true);
+        stage = new PostProcessStageComposite({
+            stages : [new PostProcessStage({
+                fragmentShader : 'uniform sampler2D depthTexture; void main() { texture2D(depthTexture, vec2(0.5)); }'
+            })]
+        });
+        expect(stage.isSupported(scene.context)).toEqual(scene.context.depthTexture);
+    });
+
+    it('does not run a stage that requires depth textures when depth textures are not supported', function() {
+        var s = createScene();
+        s.context._depthTexture = false;
+
+        if (defined(s._globeDepth)) {
+            s._globeDepth.destroy();
+            s._globeDepth = undefined;
+            if (defined(s._oit)) {
+                s._oit.destroy();
+                s._oit = undefined;
+            }
+        }
+
+        expect(s).toRender([0, 0, 0, 255]);
+        var stage = new PostProcessStageComposite({
+            stages : [new PostProcessStage({
+                fragmentShader : 'uniform sampler2D depthTexture; void main() { gl_FragColor = vec4(1.0); }'
+            })]
+        });
+        return pollToPromise(function() {
+            s.renderForSpecs();
+            return stage.ready;
+        }).then(function() {
+            expect(s).toRender([0, 0, 0, 255]);
+        }).always(function(e) {
+            s.destroyForSpecs();
+            if (e) {
+                return when.reject(e);
+            }
+        });
+    });
+
     it('destroys', function() {
         var stage1 = new PostProcessStage({
             fragmentShader : 'void main() { gl_FragColor = vec4(1.0); }'

Specs/Scene/PostProcessStageLibrarySpec.js

@@ -193,6 +193,10 @@ defineSuite([
     });
 
     it('depth view', function() {
+        if (!scene.context.depthTexture) {
+            return;
+        }
+
         var fs =
             'void main() { \n' +
             '    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); \n' +
@@ -279,6 +283,10 @@ defineSuite([
     });
 
     it('depth of field', function() {
+        if (!scene.context.depthTexture) {
+            return;
+        }
+
         var origin = Cartesian3.fromDegrees(-123.0744619, 44.0503706, 100.0);
         var modelMatrix = Transforms.headingPitchRollToFixedFrame(origin, new HeadingPitchRoll());
 
@@ -343,6 +351,10 @@ defineSuite([
     });
 
     it('ambient occlusion', function() {
+        if (!scene.context.depthTexture) {
+            return;
+        }
+
         scene.postProcessStages.ambientOcclusion.enabled = true;
         scene.postProcessStages.ambientOcclusion.uniforms.ambientOcclusionOnly = true;
         scene.renderForSpecs();

Specs/Scene/PostProcessStageSpec.js

@@ -2,20 +2,24 @@ defineSuite([
         'Scene/PostProcessStage',
         'Core/BoundingRectangle',
         'Core/Color',
+        'Core/defined',
         'Core/PixelFormat',
         'Renderer/PixelDatatype',
         'Scene/PostProcessStageSampleMode',
         'Specs/createScene',
-        'Specs/pollToPromise'
+        'Specs/pollToPromise',
+        'ThirdParty/when'
     ], function(
         PostProcessStage,
         BoundingRectangle,
         Color,
+        defined,
         PixelFormat,
         PixelDatatype,
         PostProcessStageSampleMode,
         createScene,
-        pollToPromise) {
+        pollToPromise,
+        when) {
     'use strict';
 
     var scene;
@@ -177,6 +181,56 @@ defineSuite([
         });
     });
 
+    it('isSupported throws without a context', function() {
+        var stage = new PostProcessStage({
+            fragmentShader : 'void main() { gl_FragColor = vec4(1.0); }'
+        });
+        expect(function() {
+            return stage.isSupported();
+        }).toThrowDeveloperError();
+    });
+
+    it('isSupported', function() {
+        var stage = new PostProcessStage({
+            fragmentShader : 'void main() { gl_FragColor = vec4(1.0); }'
+        });
+        expect(stage.isSupported(scene.context)).toEqual(true);
+        stage = new PostProcessStage({
+            fragmentShader : 'uniform sampler2D depthTexture; void main() { texture2D(depthTexture, vec2(0.5)); }'
+        });
+        expect(stage.isSupported(scene.context)).toEqual(scene.context.depthTexture);
+    });
+
+    it('does not run a stage that requires depth textures when depth textures are not supported', function() {
+        var s = createScene();
+        s.context._depthTexture = false;
+
+        if (defined(s._globeDepth)) {
+            s._globeDepth.destroy();
+            s._globeDepth = undefined;
+            if (defined(s._oit)) {
+                s._oit.destroy();
+                s._oit = undefined;
+            }
+        }
+
+        expect(s).toRender([0, 0, 0, 255]);
+        var stage = s.postProcessStages.add(new PostProcessStage({
+            fragmentShader : 'uniform sampler2D depthTexture; void main() { gl_FragColor = vec4(1.0); }'
+        }));
+        return pollToPromise(function() {
+            s.renderForSpecs();
+            return stage.ready;
+        }).then(function() {
+            expect(s).toRender([0, 0, 0, 255]);
+        }).always(function(e) {
+            s.destroyForSpecs();
+            if (e) {
+                return when.reject(e);
+            }
+        });
+    });
+
     it('destroys', function() {
         var stage = new PostProcessStage({
             fragmentShader : 'void main() { gl_FragColor = vec4(1.0); }'