Change GrGLProgramDesc header to have DoPathRendering flag instead of RequiresVertexShader

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 24 matching lines @@
 }
 
 bool GrGLProgramDesc::setRandom(SkRandom* random,
                                 const GrGpuGL* gpu,
                                 const GrRenderTarget* dstRenderTarget,
                                 const GrTexture* dstCopyTexture,
                                 const GrEffectStage* geometryProcessor,
                                 const GrEffectStage* stages[],
                                 int numColorStages,
                                 int numCoverageStages,
-                                int currAttribIndex) {
-    bool useLocalCoords = random->nextBool() && currAttribIndex < GrDrawState::kMaxVertexAttribCnt;
+                                int currAttribIndex,
+                                GrGpu::DrawType drawType) {
+    bool isPathRendering = GrGpu::IsPathRenderingDrawType(drawType);
+    bool useLocalCoords = !isPathRendering &&
+                          random->nextBool() &&
+                          currAttribIndex < GrDrawState::kMaxVertexAttribCnt;
 
     int numStages = numColorStages + numCoverageStages;
     fKey.reset();
 
     GR_STATIC_ASSERT(0 == kEffectKeyOffsetsAndLengthOffset % sizeof(uint32_t));
 
     // Make room for everything up to and including the array of offsets to effect keys.
     fKey.push_back_n(kEffectKeyOffsetsAndLengthOffset + 2 * sizeof(uint16_t) * (numStages +
             (geometryProcessor ? 1 : 0)));
 
@@ skipping 46 matching lines @@
 
     KeyHeader* header = this->header();
     memset(header, 0, kHeaderSize);
     header->fEmitsPointSize = random->nextBool();
 
     header->fPositionAttributeIndex = 0;
 
     // if the effects have used up all off the available attributes,
     // don't try to use color or coverage attributes as input
     do {
-        uint32_t colorRand = random->nextULessThan(2);
-        header->fColorInput = (0 == colorRand) ? GrGLProgramDesc::kAttribute_ColorInput :
-                                                 GrGLProgramDesc::kUniform_ColorInput;
-    } while (GrDrawState::kMaxVertexAttribCnt <= currAttribIndex &&
+        header->fColorInput = static_cast<GrGLProgramDesc::ColorInput>(
+                                     random->nextULessThan(kColorInputCnt));
+    } while ((GrDrawState::kMaxVertexAttribCnt <= currAttribIndex || isPathRendering) &&
              kAttribute_ColorInput == header->fColorInput);
-
     header->fColorAttributeIndex = (header->fColorInput == kAttribute_ColorInput) ?
                                         currAttribIndex++ :
                                         -1;
 
     do {
         header->fCoverageInput = static_cast<GrGLProgramDesc::ColorInput>(
                                      random->nextULessThan(kColorInputCnt));
-    } while (GrDrawState::kMaxVertexAttribCnt <= currAttribIndex  &&
+    } while ((GrDrawState::kMaxVertexAttribCnt <= currAttribIndex || isPathRendering)  &&
              kAttribute_ColorInput == header->fCoverageInput);
     header->fCoverageAttributeIndex = (header->fCoverageInput == kAttribute_ColorInput) ?
                                         currAttribIndex++ :
                                         -1;
 
 #if GR_GL_EXPERIMENTAL_GS
     header->fExperimentalGS = gpu->caps()->geometryShaderSupport() && random->nextBool();
 #endif
 
     header->fLocalCoordAttributeIndex = useLocalCoords ? currAttribIndex++ : -1;
 
     header->fColorEffectCnt = numColorStages;
     header->fCoverageEffectCnt = numCoverageStages;
 
     if (dstRead) {
         header->fDstReadKey = SkToU8(GrGLFragmentShaderBuilder::KeyForDstRead(dstCopyTexture,
                                                                       gpu->glCaps()));
     } else {
         header->fDstReadKey = 0;
     }
     if (fragPos) {
         header->fFragPosKey = SkToU8(GrGLFragmentShaderBuilder::KeyForFragmentPosition(dstRenderTarget,
                                                                                gpu->glCaps()));
     } else {
         header->fFragPosKey = 0;
     }
 
-    header->fRequiresVertexShader = vertexShader ||
-                                    useLocalCoords ||
-                                    kAttribute_ColorInput == header->fColorInput ||
-                                    kAttribute_ColorInput == header->fCoverageInput;
+    header->fDoPathRendering = isPathRendering; 
     header->fHasGeometryProcessor = vertexShader;
 
     CoverageOutput coverageOutput;
     bool illegalCoverageOutput;
     do {
         coverageOutput = static_cast<CoverageOutput>(random->nextULessThan(kCoverageOutputCnt));
         illegalCoverageOutput = (!gpu->caps()->dualSourceBlendingSupport() &&
                                  CoverageOutputUsesSecondaryOutput(coverageOutput)) ||
                                 (!dstRead && kCombineWithDst_CoverageOutput == coverageOutput);
     } while (illegalCoverageOutput);
@@ skipping 72 matching lines @@
         int currTextureCoordSet = 0;
         GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
 
         int numStages = random.nextULessThan(maxStages + 1);
         int numColorStages = random.nextULessThan(numStages + 1);
         int numCoverageStages = numStages - numColorStages;
 
         SkAutoSTMalloc<8, const GrEffectStage*> stages(numStages);
 
         bool useFixedFunctionPathRendering = this->glCaps().pathRenderingSupport() &&
-            this->glPathRendering()->texturingMode() == GrGLPathRendering::FixedFunction_TexturingMode &&
-            random.nextBool();
+            this->glPathRendering()->texturingMode() == GrGLPathRendering::FixedFunction_TexturingMode;
+        bool usePathRenderingDrawType = useFixedFunctionPathRendering && random.nextBool();
+        
+        GrGpu::DrawType drawType = usePathRenderingDrawType ? GrGpu::kDrawPath_DrawType :
+                                                              GrGpu::kDrawPoints_DrawType;
 
         SkAutoTDelete<GrEffectStage> geometryProcessor;
         bool hasGeometryProcessor = useFixedFunctionPathRendering ? false : random.nextBool();
         if (hasGeometryProcessor) {
             while (true) {
                 SkAutoTUnref<const GrEffect> effect(GrEffectTestFactory::CreateStage(
                                                                                 &random,
                                                                                 this->getContext(),
                                                                                 *this->caps(),
                                                                                 dummyTextures));
@@ skipping 56 matching lines @@
         }
         const GrTexture* dstTexture = random.nextBool() ? dummyTextures[0] : dummyTextures[1];
         if (!pdesc.setRandom(&random,
                              this,
                              dummyTextures[0]->asRenderTarget(),
                              dstTexture,
                              geometryProcessor.get(),
                              stages.get(),
                              numColorStages,
                              numCoverageStages,
-                             currAttribIndex)) {
+                             currAttribIndex,
+                             drawType)) {
             return false;
         }
 
         SkAutoTUnref<GrGLProgram> program(GrGLProgram::Create(this,
                                                               pdesc,
                                                               geometryProcessor.get(),
                                                               stages,
                                                               stages + numColorStages));
         for (int s = 0; s < numStages; ++s) {
             SkDELETE(stages[s]);
@@ skipping 44 matching lines @@
         SkRect::MakeWH(SK_Scalar1, SK_Scalar1), SK_Scalar1));
     GrConfigConversionEffect::Create(NULL,
                                      false,
                                      GrConfigConversionEffect::kNone_PMConversion,
                                      SkMatrix::I());
     SkScalar matrix[20];
     SkAutoTUnref<SkColorMatrixFilter> cmf(SkColorMatrixFilter::Create(matrix));
 }
 
 #endif