GLProgramsTest 3.0

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
 
 #include "SkTypes.h"
 
 #if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
 
 #include "GrAutoLocaleSetter.h"
+#include "GrBatch.h"
+#include "GrBatchTest.h"
 #include "GrContextFactory.h"
 #include "GrInvariantOutput.h"
 #include "GrPipeline.h"
 #include "GrTest.h"
 #include "GrXferProcessor.h"
 #include "SkChecksum.h"
 #include "SkRandom.h"
 #include "Test.h"
 #include "effects/GrConfigConversionEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "gl/GrGLGpu.h"
 #include "gl/GrGLPathRendering.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 /*
  * A dummy processor which just tries to insert a massive key and verify that it can retrieve the
  * whole thing correctly
  */
 static const uint32_t kMaxKeySize = 1024;
 
 class GLBigKeyProcessor : public GrGLFragmentProcessor {
 public:
     GLBigKeyProcessor(const GrProcessor&) {}
 
     virtual void emitCode(GrGLFPBuilder* builder,
                           const GrFragmentProcessor& fp,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
-                          const TextureSamplerArray&) {}
+                          const TextureSamplerArray&) {
+        // pass through
+        GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
+        fsBuilder->codeAppendf("%s = %s;\n", outputColor, inputColor);
+    }
 
     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 46 matching lines @@
 static GrRenderTarget* random_render_target(GrContext* context, SkRandom* random) {
     // setup render target
     GrTextureParams params;
     GrSurfaceDesc texDesc;
     texDesc.fWidth = kRenderTargetWidth;
     texDesc.fHeight = kRenderTargetHeight;
     texDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     texDesc.fConfig = kRGBA_8888_GrPixelConfig;
     texDesc.fOrigin = random->nextBool() == true ? kTopLeft_GrSurfaceOrigin :
                                                    kBottomLeft_GrSurfaceOrigin;
+    texDesc.fSampleCnt = random->nextBool() == true ? 4 : 0;
+
     GrUniqueKey key;
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
-    GrUniqueKey::Builder builder(&key, kDomain, 1);
+    GrUniqueKey::Builder builder(&key, kDomain, 2);
     builder[0] = texDesc.fOrigin;
+    builder[1] = texDesc.fSampleCnt;
     builder.finish();
 
     GrTexture* texture = context->textureProvider()->findAndRefTextureByUniqueKey(key);
     if (!texture) {
         texture = context->textureProvider()->createTexture(texDesc, true);
         if (texture) {
             context->textureProvider()->assignUniqueKeyToTexture(key, texture);
         }
     }
     return texture ? texture->asRenderTarget() : NULL;
 }
 
 static void set_random_xpf(GrContext* context, const GrDrawTargetCaps& caps,
                            GrPipelineBuilder* pipelineBuilder, SkRandom* random,
                            GrTexture* dummyTextures[]) {
     SkAutoTUnref<const GrXPFactory> xpf(
         GrProcessorTestFactory<GrXPFactory>::CreateStage(random, context, caps, dummyTextures));
     SkASSERT(xpf);
     pipelineBuilder->setXPFactory(xpf.get());
 }
 
-static const GrGeometryProcessor* get_random_gp(GrContext* context,
-                                                const GrDrawTargetCaps& caps,
-                                                SkRandom* random,
-                                                GrTexture* dummyTextures[]) {
-    return GrProcessorTestFactory<GrGeometryProcessor>::CreateStage(random,
-                                                                    context,
-                                                                    caps,
-                                                                    dummyTextures);
-}
-
 static void set_random_color_coverage_stages(GrGLGpu* gpu,
                                              GrPipelineBuilder* pipelineBuilder,
                                              int maxStages,
-                                             bool usePathRendering,
                                              SkRandom* random,
                                              GrTexture* dummyTextures[]) {
     int numProcs = random->nextULessThan(maxStages + 1);
     int numColorProcs = random->nextULessThan(numProcs + 1);
 
     for (int s = 0; s < numProcs;) {
         SkAutoTUnref<const GrFragmentProcessor> fp(
                 GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(random,
                                                                          gpu->getContext(),
                                                                          *gpu->caps(),
                                                                          dummyTextures));
         SkASSERT(fp);
 
         // finally add the stage to the correct pipeline in the drawstate
         if (s < numColorProcs) {
             pipelineBuilder->addColorProcessor(fp);
         } else {
             pipelineBuilder->addCoverageProcessor(fp);
         }
         ++s;
     }
 }
 
 static void set_random_state(GrPipelineBuilder* pipelineBuilder, SkRandom* random) {
     int state = 0;
     for (int i = 1; i <= GrPipelineBuilder::kLast_Flag; i <<= 1) {
         state |= random->nextBool() * i;
     }
+
+    // If we don't have an MSAA rendertarget then we have to disable useHWAA
+    if ((state | GrPipelineBuilder::kHWAntialias_Flag) &&
+        !pipelineBuilder->getRenderTarget()->isMultisampled()) {
+        state &= ~GrPipelineBuilder::kHWAntialias_Flag;
+    }
     pipelineBuilder->enableState(state);
 }
 
 // right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()'
 static void set_random_stencil(GrPipelineBuilder* pipelineBuilder, SkRandom* random) {
     GR_STATIC_CONST_SAME_STENCIL(kDoesWriteStencil,
                                  kReplace_StencilOp,
                                  kReplace_StencilOp,
                                  kAlways_StencilFunc,
                                  0xffff,
@@ skipping 32 matching lines @@
     if (!dummyTexture1 || ! dummyTexture2) {
         SkDebugf("Could not allocate dummy textures");
         return false;
     }
 
     GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
 
     // dummy scissor state
     GrScissorState scissor;
 
-    // setup clip
-    SkRect screen = SkRect::MakeWH(SkIntToScalar(kRenderTargetWidth),
-                                   SkIntToScalar(kRenderTargetHeight));
-
-    SkClipStack stack;
-    stack.clipDevRect(screen, SkRegion::kReplace_Op, false);
-
-    // wrap the SkClipStack in a GrClip
+    // wide open clip
     GrClip clip;
-    clip.setClipStack(&stack);
 
     SkRandom random;
-    static const int NUM_TESTS = 512;
-    for (int t = 0; t < NUM_TESTS;) {
+    static const int NUM_TESTS = 2048;
+    for (int t = 0; t < NUM_TESTS; t++) {
         // setup random render target(can fail)
         SkAutoTUnref<GrRenderTarget> rt(random_render_target(fContext, &random));
         if (!rt.get()) {
             SkDebugf("Could not allocate render target");
             return false;
         }
 
         GrPipelineBuilder pipelineBuilder;
         pipelineBuilder.setRenderTarget(rt.get());
         pipelineBuilder.setClip(clip);
 
-        // if path rendering we have to setup a couple of things like the draw type
-        bool usePathRendering = gpu->glCaps().shaderCaps()->pathRenderingSupport() &&
-                                random.nextBool();
+        SkAutoTUnref<GrBatch> batch(GrRandomBatch(&random, fContext));
+        SkASSERT(batch);
 
-        // twiddle drawstate knobs randomly
-        bool hasGeometryProcessor = !usePathRendering;
-        SkAutoTUnref<const GrGeometryProcessor> gp;
-        SkAutoTUnref<const GrPathProcessor> pathProc;
-        if (hasGeometryProcessor) {
-            gp.reset(get_random_gp(fContext, gpu->glCaps(), &random, dummyTextures));
-        } else {
-            pathProc.reset(GrPathProcessor::Create(GrColor_WHITE));
-        }
         set_random_color_coverage_stages(gpu,
                                          &pipelineBuilder,
-                                         maxStages - hasGeometryProcessor,
-                                         usePathRendering,
+                                         maxStages,
                                          &random,
                                          dummyTextures);
 
         // creates a random xfer processor factory on the draw state 
         set_random_xpf(fContext, gpu->glCaps(), &pipelineBuilder, &random, dummyTextures);
 
         set_random_state(&pipelineBuilder, &random);
         set_random_stencil(&pipelineBuilder, &random);
 
-        GrDeviceCoordTexture dstCopy;
+        this->drawBatch(&pipelineBuilder, batch);
+    }
 
-        const GrPrimitiveProcessor* primProc;
-        if (hasGeometryProcessor) {
-            primProc = gp.get();
-        } else {
-            primProc = pathProc.get();
-        }
-
-        const GrProcOptInfo& colorPOI = pipelineBuilder.colorProcInfo(primProc);
-        const GrProcOptInfo& coveragePOI = pipelineBuilder.coverageProcInfo(primProc);
-
-        if (!this->setupDstReadIfNecessary(pipelineBuilder, colorPOI, coveragePOI, &dstCopy,
-                                           NULL)) {
-            SkDebugf("Couldn't setup dst read texture");
-            return false;
-        }
-
-        // create optimized draw state, setup readDst texture if required, and build a descriptor
-        // and program.  ODS creation can fail, so we have to check
-        GrPipeline pipeline(pipelineBuilder, colorPOI, coveragePOI,
-                            *gpu->caps(), scissor, &dstCopy);
-        if (pipeline.mustSkip()) {
-            continue;
-        }
-
-        GrXferBarrierType barrierType;
-        if (pipeline.getXferProcessor()->willNeedXferBarrier(rt, *gpu->caps(), &barrierType)) {
-            gpu->xferBarrier(barrierType);
-        }
-
-        GrBatchTracker bt;
-        primProc->initBatchTracker(&bt, pipeline.getInitBatchTracker());
-
-        GrProgramDesc desc;
-        gpu->buildProgramDesc(&desc, *primProc, pipeline, bt);
-
-        GrGpu::DrawArgs args(primProc, &pipeline, &desc, &bt);
-        SkAutoTUnref<GrGLProgram> program(GrGLProgramBuilder::CreateProgram(args, gpu));
-
-        if (NULL == program.get()) {
-            SkDebugf("Failed to create program!");
-            return false;
-        }
-
-        // because occasionally optimized drawstate creation will fail for valid reasons, we only
-        // want to increment on success
-        ++t;
-    }
+    // Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
+    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");
 #endif
 
+    // We suppress prints to avoid spew
+    GrContext::Options opts;
+    opts.fSuppressPrints = true;
+    GrContextFactory debugFactory(opts);
     for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
-        GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(type));
+        GrContext* context = debugFactory.get(static_cast<GrContextFactory::GLContextType>(type));
         if (context) {
             GrGLGpu* gpu = static_cast<GrGLGpu*>(context->getGpu());
 
             /*
              * For the time being, we only support the test with desktop GL or for android on
              * ARM platforms
              * TODO When we run ES 3.00 GLSL in more places, test again
              */
             int maxStages;
             if (kGL_GrGLStandard == gpu->glStandard() ||
@@ skipping 12 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif