Test that GrFragmentProcessors work without input colors.

tests/GLProgramsTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
@@ skipping 29 matching lines @@
  */
 static const uint32_t kMaxKeySize = 1024;
 
 class GLBigKeyProcessor : public GrGLFragmentProcessor {
 public:
     GLBigKeyProcessor(const GrProcessor&) {}
 
     virtual void emitCode(EmitArgs& args) override {
         // pass through
         GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
-        fsBuilder->codeAppendf("%s = %s;\n", args.fOutputColor, args.fInputColor);
+        if (args.fInputColor) {
+            fsBuilder->codeAppendf("%s = %s;\n", args.fOutputColor, args.fInputColor);
+        } else {
+            fsBuilder->codeAppendf("%s = vec4(1.0);\n", args.fOutputColor);
+        }
     }
 
     static void GenKey(const GrProcessor& processor, const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
         for (uint32_t i = 0; i < kMaxKeySize; i++) {
             b->add32(i);
         }
     }
 
 private:
     typedef GrGLFragmentProcessor INHERITED;
@@ skipping 27 matching lines @@
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(BigKeyProcessor);
 
 const GrFragmentProcessor* BigKeyProcessor::TestCreate(GrProcessorTestData*) {
     return BigKeyProcessor::Create();
 }
 
+//////////////////////////////////////////////////////////////////////////////
+
+class BlockInputFragmentProcessor : public GrFragmentProcessor {
+public:
+    static GrFragmentProcessor* Create(const GrFragmentProcessor* fp) {
+        return new BlockInputFragmentProcessor(fp);
+    }
+
+    const char* name() const override { return "Block Input"; }
+
+    GrGLFragmentProcessor* onCreateGLInstance() const override { return new GLFP; }
+
+private:
+    class GLFP : public GrGLFragmentProcessor {
+    public:
+        void emitCode(EmitArgs& args) override {
+            this->emitChild(0, nullptr, args.fOutputColor, args);
+        }
+
+    private:
+        typedef GrGLFragmentProcessor INHERITED;
+    };
+
+    BlockInputFragmentProcessor(const GrFragmentProcessor* child) {
+        this->initClassID<BlockInputFragmentProcessor>();
+        this->registerChildProcessor(child);
+    }
+
+    void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {}
+
+    bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
+
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
+        inout->setToOther(kRGBA_GrColorComponentFlags, GrColor_WHITE,
+                          GrInvariantOutput::kWillNot_ReadInput);
+        this->childProcessor(0).computeInvariantOutput(inout);
+    }
+
+    typedef GrFragmentProcessor INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
 /*
  * Begin test code
  */
 static const int kRenderTargetHeight = 1;
 static const int kRenderTargetWidth = 1;
 
 static GrRenderTarget* random_render_target(GrTextureProvider* textureProvider, SkRandom* random,
                                             const GrCaps* caps) {
     // setup render target
     GrTextureParams params;
@@ skipping 17 matching lines @@
     if (!texture) {
         texture = textureProvider->createTexture(texDesc, true);
         if (texture) {
             textureProvider->assignUniqueKeyToTexture(key, texture);
         }
     }
     return texture ? texture->asRenderTarget() : nullptr;
 }
 
 static void set_random_xpf(GrPipelineBuilder* pipelineBuilder, GrProcessorTestData* d) {
-    SkAutoTUnref<const GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::CreateStage(d));
+    SkAutoTUnref<const GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::Create(d));
     SkASSERT(xpf);
     pipelineBuilder->setXPFactory(xpf.get());
 }
 
 static const GrFragmentProcessor* create_random_proc_tree(GrProcessorTestData* d,
                                                            int minLevels, int maxLevels) {
     SkASSERT(1 <= minLevels);
     SkASSERT(minLevels <= maxLevels);
 
     // Return a leaf node if maxLevels is 1 or if we randomly chose to terminate.
     // If returning a leaf node, make sure that it doesn't have children (e.g. another
     // GrComposeEffect)
     const float terminateProbability = 0.3f;
     if (1 == minLevels) {
         bool terminate = (1 == maxLevels) || (d->fRandom->nextF() < terminateProbability);
         if (terminate) {
             const GrFragmentProcessor* fp;
             while (true) {
-                fp = GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d);
+                fp = GrProcessorTestFactory<GrFragmentProcessor>::Create(d);
                 SkASSERT(fp);
                 if (0 == fp->numChildProcessors()) {
                     break;
                 }
                 fp->unref();
             }
             return fp;
         }
     }
     // If we didn't terminate, choose either the left or right subtree to fulfill
@@ skipping 29 matching lines @@
         const int maxTreeLevels = 4;
         SkAutoTUnref<const GrFragmentProcessor> fp(
                                         create_random_proc_tree(d, 2, maxTreeLevels));
         pipelineBuilder->addColorFragmentProcessor(fp);
     } else {
         int numProcs = d->fRandom->nextULessThan(maxStages + 1);
         int numColorProcs = d->fRandom->nextULessThan(numProcs + 1);
 
         for (int s = 0; s < numProcs;) {
             SkAutoTUnref<const GrFragmentProcessor> fp(
-                    GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d));
+                    GrProcessorTestFactory<GrFragmentProcessor>::Create(d));
             SkASSERT(fp);
 
             // finally add the stage to the correct pipeline in the drawstate
             if (s < numColorProcs) {
                 pipelineBuilder->addColorFragmentProcessor(fp);
             } else {
                 pipelineBuilder->addCoverageFragmentProcessor(fp);
             }
             ++s;
         }
@@ skipping 87 matching lines @@
 
         GrProcessorDataManager procDataManager;
         GrProcessorTestData ptd(&random, context, &procDataManager, fGpu->caps(), dummyTextures);
         set_random_color_coverage_stages(&pipelineBuilder, &ptd, maxStages);
         set_random_xpf(&pipelineBuilder, &ptd);
         set_random_state(&pipelineBuilder, &random);
         set_random_stencil(&pipelineBuilder, &random);
 
         this->drawBatch(pipelineBuilder, batch);
     }
-
     // Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
     this->flush();
+
+    // Validate that GrFPs work correctly without an input.
+    GrSurfaceDesc rtDesc;
+    rtDesc.fWidth = kRenderTargetWidth;
+    rtDesc.fHeight = kRenderTargetHeight;
+    rtDesc.fFlags = kRenderTarget_GrSurfaceFlag;
+    rtDesc.fConfig = kRGBA_8888_GrPixelConfig;
+    SkAutoTUnref<GrRenderTarget> rt(
+        fContext->textureProvider()->createTexture(rtDesc, false)->asRenderTarget());
+    int fpFactoryCnt = GrProcessorTestFactory<GrFragmentProcessor>::Count();
+    for (int i = 0; i < fpFactoryCnt; ++i) {
+        // Since FP factories internally randomize, call each 10 times.
+        for (int j = 0; j < 10; ++j) {
+            SkAutoTUnref<GrDrawBatch> batch(GrRandomDrawBatch(&random, context));
+            SkASSERT(batch);
+            GrProcessorDataManager procDataManager;
+            GrProcessorTestData ptd(&random, context, &procDataManager, this->caps(),
+                                    dummyTextures);
+            GrPipelineBuilder builder;
+            builder.setXPFactory(GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
+            builder.setRenderTarget(rt);
+            builder.setClip(clip);
+
+            SkAutoTUnref<const GrFragmentProcessor> fp(
+                GrProcessorTestFactory<GrFragmentProcessor>::CreateIdx(i, &ptd));
+            SkAutoTUnref<const GrFragmentProcessor> blockFP(
+                BlockInputFragmentProcessor::Create(fp));
+            builder.addColorFragmentProcessor(blockFP);
+
+            this->drawBatch(builder, batch);
+            this->flush();
+        }
+    }
+
     return true;
 }
 
 DEF_GPUTEST(GLPrograms, reporter, factory) {
     // Set a locale that would cause shader compilation to fail because of , as decimal separator.
     // skbug 3330
 #ifdef SK_BUILD_FOR_WIN
     GrAutoLocaleSetter als("sv-SE");
 #else
     GrAutoLocaleSetter als("sv_SE.UTF-8");
@@ skipping 37 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(context, maxStages));
         }
     }
 }
 
 #endif