Rename GrOptDrawState to GrPipeline and GrDrawState to GrPipelineBuilder

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 "GrContextFactory.h"
 #include "GrInvariantOutput.h"
-#include "GrOptDrawState.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"
@@ skipping 86 matching lines @@
     SkAutoTUnref<GrTexture> texture(context->findAndRefTexture(texDesc, cacheId, &params));
     if (!texture) {
         texture.reset(context->createTexture(&params, texDesc, cacheId, 0, 0));
         if (!texture) {
             return NULL;
         }
     }
     return SkRef(texture->asRenderTarget());
 }
 
-static void set_random_xpf(GrContext* context, const GrDrawTargetCaps& caps, GrDrawState* ds,
-                           SkRandom* random, GrTexture* dummyTextures[]) {
+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);
-    ds->setXPFactory(xpf.get());
+    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,
-                                             GrDrawState* ds,
+                                             GrPipelineBuilder* pipelineBuilder,
                                              int maxStages,
                                              bool usePathRendering,
                                              SkRandom* random,
                                              GrTexture* dummyTextures[]) {
     int numProcs = random->nextULessThan(maxStages + 1);
     int numColorProcs = random->nextULessThan(numProcs + 1);
 
     int currTextureCoordSet = 0;
     for (int s = 0; s < numProcs;) {
         SkAutoTUnref<const GrFragmentProcessor> fp(
@@ skipping 10 matching lines @@
             int numTransforms = fp->numTransforms();
             if (currTextureCoordSet + numTransforms >
                 gpu->glCaps().maxFixedFunctionTextureCoords()) {
                 continue;
             }
             currTextureCoordSet += numTransforms;
         }
 
         // finally add the stage to the correct pipeline in the drawstate
         if (s < numColorProcs) {
-            ds->addColorProcessor(fp);
+            pipelineBuilder->addColorProcessor(fp);
         } else {
-            ds->addCoverageProcessor(fp);
+            pipelineBuilder->addCoverageProcessor(fp);
         }
         ++s;
     }
 }
 
-static void set_random_state(GrDrawState* ds, SkRandom* random) {
+static void set_random_state(GrPipelineBuilder* pipelineBuilder, SkRandom* random) {
     int state = 0;
-    for (int i = 1; i <= GrDrawState::kLast_StateBit; i <<= 1) {
+    for (int i = 1; i <= GrPipelineBuilder::kLast_StateBit; i <<= 1) {
         state |= random->nextBool() * i;
     }
-    ds->enableState(state);
+    pipelineBuilder->enableState(state);
 }
 
 // right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()'
-static void set_random_stencil(GrDrawState* ds, SkRandom* random) {
+static void set_random_stencil(GrPipelineBuilder* pipelineBuilder, SkRandom* random) {
     GR_STATIC_CONST_SAME_STENCIL(kDoesWriteStencil,
                                  kReplace_StencilOp,
                                  kReplace_StencilOp,
                                  kAlways_StencilFunc,
                                  0xffff,
                                  0xffff,
                                  0xffff);
     GR_STATIC_CONST_SAME_STENCIL(kDoesNotWriteStencil,
                                  kKeep_StencilOp,
                                  kKeep_StencilOp,
                                  kNever_StencilFunc,
                                  0xffff,
                                  0xffff,
                                  0xffff);
 
     if (random->nextBool()) {
-        ds->setStencil(kDoesWriteStencil);
+        pipelineBuilder->setStencil(kDoesWriteStencil);
     } else {
-        ds->setStencil(kDoesNotWriteStencil);
+        pipelineBuilder->setStencil(kDoesNotWriteStencil);
     }
 }
 
 bool GrDrawTarget::programUnitTest(int maxStages) {
     GrGLGpu* gpu = static_cast<GrGLGpu*>(fContext->getGpu());
     // setup dummy textures
     GrSurfaceDesc dummyDesc;
     dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     dummyDesc.fConfig = kSkia8888_GrPixelConfig;
     dummyDesc.fWidth = 34;
@@ skipping 38 matching lines @@
     SkRandom random;
     static const int NUM_TESTS = 512;
     for (int t = 0; t < NUM_TESTS;) {
         // setup random render target(can fail)
         SkAutoTUnref<GrRenderTarget> rt(random_render_target(fContext, glProgramsCacheID, &random));
         if (!rt.get()) {
             SkDebugf("Could not allocate render target");
             return false;
         }
 
-        GrDrawState ds;
-        ds.setRenderTarget(rt.get());
+        GrPipelineBuilder pipelineBuilder;
+        pipelineBuilder.setRenderTarget(rt.get());
 
         // if path rendering we have to setup a couple of things like the draw type
         bool usePathRendering = gpu->glCaps().pathRenderingSupport() && random.nextBool();
 
         // 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,
-                                         &ds,
+                                         &pipelineBuilder,
                                          maxStages - hasGeometryProcessor,
                                          usePathRendering,
                                          &random,
                                          dummyTextures);
 
         // creates a random xfer processor factory on the draw state 
-        set_random_xpf(fContext, gpu->glCaps(), &ds, &random, dummyTextures);
+        set_random_xpf(fContext, gpu->glCaps(), &pipelineBuilder, &random, dummyTextures);
 
-        set_random_state(&ds, &random);
-        set_random_stencil(&ds, &random);
+        set_random_state(&pipelineBuilder, &random);
+        set_random_stencil(&pipelineBuilder, &random);
 
         GrDeviceCoordTexture dstCopy;
 
         const GrPrimitiveProcessor* primProc;
         if (hasGeometryProcessor) {
             primProc = gp.get();
         } else {
             primProc = pathProc.get();
         }
-        if (!this->setupDstReadIfNecessary(&ds, &dstCopy, NULL)) {
+        if (!this->setupDstReadIfNecessary(&pipelineBuilder, &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
-        GrOptDrawState ods(ds, primProc, *gpu->caps(), scissor, &dstCopy);
-        if (ods.mustSkip()) {
+        GrPipeline pipeline(pipelineBuilder, primProc, *gpu->caps(), scissor, &dstCopy);
+        if (pipeline.mustSkip()) {
             continue;
         }
         GrBatchTracker bt;
-        primProc->initBatchTracker(&bt, ods.getInitBatchTracker());
+        primProc->initBatchTracker(&bt, pipeline.getInitBatchTracker());
 
         GrProgramDesc desc;
-        gpu->buildProgramDesc(&desc, *primProc, ods, ods.descInfo(), bt);
+        gpu->buildProgramDesc(&desc, *primProc, pipeline, pipeline.descInfo(), bt);
 
-        GrGpu::DrawArgs args(primProc, &ods, &desc, &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;
@@ skipping 29 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif