Use vertexless shaders when NVpr is available

src/gpu/gl/GrGLProgram.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.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 21 matching lines @@
         program = NULL;
     }
     return program;
 }
 
 GrGLProgram::GrGLProgram(GrGpuGL* gpu,
                          const GrGLProgramDesc& desc,
                          const GrEffectStage* colorStages[],
                          const GrEffectStage* coverageStages[])
 : fGpu(gpu)
-, fUniformManager(gpu) {
+, fUniformManager(gpu)
+, fHasVertexShader(false)
+, fNumTexCoordSets(0) {
     fDesc = desc;
     fProgramID = 0;
 
     fDstCopyTexUnit = -1;
 
     fColor = GrColor_ILLEGAL;
     fColorFilterColor = GrColor_ILLEGAL;
 
-    this->genProgram(colorStages, coverageStages);
+    if (fDesc.getHeader().fHasVertexCode ||
+        !fGpu->glCaps().fixedFunctionSupport() ||
+        !fGpu->glCaps().pathStencilingSupport()) {
+
+        GrGLFullShaderBuilder fullBuilder(fGpu, fUniformManager, fDesc);
+        if (this->genProgram(&fullBuilder, colorStages, coverageStages)) {
+            fUniformHandles.fViewMatrixUni = fullBuilder.getViewMatrixUniform();
+            fHasVertexShader = true;
+        }
+    } else {
+        GrGLFragmentOnlyShaderBuilder fragmentOnlyBuilder(fGpu, fUniformManager, fDesc);
+        if (this->genProgram(&fragmentOnlyBuilder, colorStages, coverageStages)) {
+            fNumTexCoordSets = fragmentOnlyBuilder.getNumTexCoordSets();
+        }
+    }
 }
 
 GrGLProgram::~GrGLProgram() {
     if (fProgramID) {
         GL_CALL(DeleteProgram(fProgramID));
     }
 }
 
 void GrGLProgram::abandon() {
     fProgramID = 0;
@@ skipping 136 matching lines @@
             *string = GrGLSLZerosVecf(4);
             break;
         case kOnes_GrSLConstantVec:
             *string = GrGLSLOnesVecf(4);
             break;
     }
 }
 
 }
 
-bool GrGLProgram::genProgram(const GrEffectStage* colorStages[],
+bool GrGLProgram::genProgram(GrGLShaderBuilder* builder,
+                             const GrEffectStage* colorStages[],
                              const GrEffectStage* coverageStages[]) {
     SkASSERT(0 == fProgramID);
 
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
 
-    GrGLFullShaderBuilder builder(fGpu, fUniformManager, fDesc);
-    fUniformHandles.fViewMatrixUni = builder.getViewMatrixUniform();
-
     // incoming color to current stage being processed.
-    SkString inColor = builder.getInputColor();
-    GrSLConstantVec knownColorValue = builder.getKnownColorValue();
+    SkString inColor = builder->getInputColor();
+    GrSLConstantVec knownColorValue = builder->getKnownColorValue();
 
     // Get the coeffs for the Mode-based color filter, determine if color is needed.
     SkXfermode::Coeff colorCoeff;
     SkXfermode::Coeff filterColorCoeff;
     SkAssertResult(
         SkXfermode::ModeAsCoeff(header.fColorFilterXfermode,
                                 &filterColorCoeff,
                                 &colorCoeff));
     bool needColor, needFilterColor;
     need_blend_inputs(filterColorCoeff, colorCoeff, &needFilterColor, &needColor);
 
     fColorEffects.reset(
-        builder.createAndEmitEffects(colorStages,
-                                     fDesc.effectKeys(),
-                                     needColor ? fDesc.numColorEffects() : 0,
-                                     &inColor,
-                                     &knownColorValue));
+        builder->createAndEmitEffects(colorStages,
+                                      fDesc.effectKeys(),
+                                      needColor ? fDesc.numColorEffects() : 0,
+                                      &inColor,
+                                      &knownColorValue));
 
     // Insert the color filter. This will soon be replaced by a color effect.
     if (SkXfermode::kDst_Mode != header.fColorFilterXfermode) {
         const char* colorFilterColorUniName = NULL;
-        fUniformHandles.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_Visibility,
-                                                             kVec4f_GrSLType, "FilterColor",
-                                                             &colorFilterColorUniName);
+        fUniformHandles.fColorFilterUni = builder->addUniform(GrGLShaderBuilder::kFragment_Visibility,
+                                                              kVec4f_GrSLType, "FilterColor",
+                                                              &colorFilterColorUniName);
 
-        builder.fsCodeAppend("\tvec4 filteredColor;\n");
+        builder->fsCodeAppend("\tvec4 filteredColor;\n");
         const char* color;
         // add_color_filter requires a real input string.
         if (knownColorValue == kOnes_GrSLConstantVec) {
             color = GrGLSLOnesVecf(4);
         } else if (knownColorValue == kZeros_GrSLConstantVec) {
             color = GrGLSLZerosVecf(4);
         } else {
             color = inColor.c_str();
         }
-        add_color_filter(&builder, "filteredColor", filterColorCoeff,
+        add_color_filter(builder, "filteredColor", filterColorCoeff,
                          colorCoeff, colorFilterColorUniName, color);
         inColor = "filteredColor";
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // compute the partial coverage
-    SkString inCoverage = builder.getInputCoverage();
-    GrSLConstantVec knownCoverageValue = builder.getKnownCoverageValue();
+    SkString inCoverage = builder->getInputCoverage();
+    GrSLConstantVec knownCoverageValue = builder->getKnownCoverageValue();
 
     fCoverageEffects.reset(
-        builder.createAndEmitEffects(coverageStages,
-                                     fDesc.getEffectKeys() + fDesc.numColorEffects(),
-                                     fDesc.numCoverageEffects(),
-                                     &inCoverage,
-                                     &knownCoverageValue));
+        builder->createAndEmitEffects(coverageStages,
+                                      fDesc.getEffectKeys() + fDesc.numColorEffects(),
+                                      fDesc.numCoverageEffects(),
+                                      &inCoverage,
+                                      &knownCoverageValue));
 
     // discard if coverage is zero
     if (header.fDiscardIfZeroCoverage && kOnes_GrSLConstantVec != knownCoverageValue) {
         if (kZeros_GrSLConstantVec == knownCoverageValue) {
             // This is unfortunate.
-            builder.fsCodeAppend("\tdiscard;\n");
+            builder->fsCodeAppend("\tdiscard;\n");
         } else {
-            builder.fsCodeAppendf("\tif (all(lessThanEqual(%s, vec4(0.0)))) {\n\t\tdiscard;\n\t}\n",
-                                  inCoverage.c_str());
+            builder->fsCodeAppendf("\tif (all(lessThanEqual(%s, vec4(0.0)))) {\n\t\tdiscard;\n\t}\n",
+                                   inCoverage.c_str());
         }
     }
 
     if (GrGLProgramDesc::CoverageOutputUsesSecondaryOutput(header.fCoverageOutput)) {
-        const char* secondaryOutputName = builder.enableSecondaryOutput();
+        const char* secondaryOutputName = builder->enableSecondaryOutput();
 
         // default coeff to ones for kCoverage_DualSrcOutput
         SkString coeff;
         GrSLConstantVec knownCoeffValue = kOnes_GrSLConstantVec;
         if (GrGLProgramDesc::kSecondaryCoverageISA_CoverageOutput == header.fCoverageOutput) {
             // Get (1-A) into coeff
             SkString inColorAlpha;
             GrGLSLGetComponent4f(&inColorAlpha,
                                     inColor.c_str(),
                                     kA_GrColorComponentFlag,
@@ skipping 15 matching lines @@
                                                  true);
         }
         // Get coeff * coverage into modulate and then write that to the dual source output.
         SkString modulate;
         GrGLSLModulatef<4>(&modulate,
                            coeff.c_str(),
                            inCoverage.c_str(),
                            knownCoeffValue,
                            knownCoverageValue,
                            false);
-        builder.fsCodeAppendf("\t%s = %s;\n", secondaryOutputName, modulate.c_str());
+        builder->fsCodeAppendf("\t%s = %s;\n", secondaryOutputName, modulate.c_str());
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // combine color and coverage as frag color
 
     // Get "color * coverage" into fragColor
     SkString fragColor;
     GrSLConstantVec knownFragColorValue = GrGLSLModulatef<4>(&fragColor,
                                                              inColor.c_str(),
                                                              inCoverage.c_str(),
                                                              knownColorValue,
                                                              knownCoverageValue,
                                                              true);
     // Now tack on "+(1-coverage)dst onto the frag color if we were asked to do so.
     if (GrGLProgramDesc::kCombineWithDst_CoverageOutput == header.fCoverageOutput) {
         SkString dstCoeff;
         GrSLConstantVec knownDstCoeffValue = GrGLSLSubtractf<4>(&dstCoeff,
                                                                 NULL,
                                                                 inCoverage.c_str(),
                                                                 kOnes_GrSLConstantVec,
                                                                 knownCoverageValue,
                                                                 true);
         SkString dstContribution;
         GrSLConstantVec knownDstContributionValue = GrGLSLModulatef<4>(&dstContribution,
                                                                        dstCoeff.c_str(),
-                                                                       builder.dstColor(),
+                                                                       builder->dstColor(),
                                                                        knownDstCoeffValue,
                                                                        kNone_GrSLConstantVec,
                                                                        true);
         SkString oldFragColor = fragColor;
         fragColor.reset();
         GrGLSLAddf<4>(&fragColor,
                       oldFragColor.c_str(),
                       dstContribution.c_str(),
                       knownFragColorValue,
                       knownDstContributionValue,
                       false);
     } else {
         expand_known_value4f(&fragColor, knownFragColorValue);
     }
-    builder.fsCodeAppendf("\t%s = %s;\n", builder.getColorOutputName(), fragColor.c_str());
+    builder->fsCodeAppendf("\t%s = %s;\n", builder->getColorOutputName(), fragColor.c_str());
 
-    if (!builder.finish(&fProgramID)) {
+    if (!builder->finish(&fProgramID)) {
         return false;
     }
 
-    fUniformHandles.fRTHeightUni = builder.getRTHeightUniform();
-    fUniformHandles.fDstCopyTopLeftUni = builder.getDstCopyTopLeftUniform();
-    fUniformHandles.fDstCopyScaleUni = builder.getDstCopyScaleUniform();
-    fUniformHandles.fColorUni = builder.getColorUniform();
-    fUniformHandles.fCoverageUni = builder.getCoverageUniform();
-    fUniformHandles.fDstCopySamplerUni = builder.getDstCopySamplerUniform();
+    fUniformHandles.fRTHeightUni = builder->getRTHeightUniform();
+    fUniformHandles.fDstCopyTopLeftUni = builder->getDstCopyTopLeftUniform();
+    fUniformHandles.fDstCopyScaleUni = builder->getDstCopyScaleUniform();
+    fUniformHandles.fColorUni = builder->getColorUniform();
+    fUniformHandles.fCoverageUni = builder->getCoverageUniform();
+    fUniformHandles.fDstCopySamplerUni = builder->getDstCopySamplerUniform();
     // This must be called after we set fDstCopySamplerUni above.
     this->initSamplerUniforms();
 
     return true;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
     GrGLint texUnitIdx = 0;
     if (fUniformHandles.fDstCopySamplerUni.isValid()) {
@@ skipping 55 matching lines @@
             SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
         }
     } else {
         SkASSERT(!fUniformHandles.fDstCopyTopLeftUni.isValid());
         SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
         SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
     }
 
     fColorEffects->setData(fGpu, fUniformManager, colorStages);
     fCoverageEffects->setData(fGpu, fUniformManager, coverageStages);
+
+    if (!fHasVertexShader) {
+        fGpu->disableUnusedTexGen(fNumTexCoordSets);
+    }
 }
 
 void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
     if (!drawState.hasColorVertexAttribute()) {
         switch (header.fColorInput) {
             case GrGLProgramDesc::kAttribute_ColorInput:
                 SkASSERT(-1 != header.fColorAttributeIndex);
@@ skipping 72 matching lines @@
     const GrRenderTarget* rt = drawState.getRenderTarget();
     SkISize size;
     size.set(rt->width(), rt->height());
 
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
     if (fUniformHandles.fRTHeightUni.isValid() &&
         fMatrixState.fRenderTargetSize.fHeight != size.fHeight) {
         fUniformManager.set1f(fUniformHandles.fRTHeightUni, SkIntToScalar(size.fHeight));
     }
 
-    if (fMatrixState.fRenderTargetOrigin != rt->origin() ||
-        !fMatrixState.fViewMatrix.cheapEqualTo(drawState.getViewMatrix()) ||
-        fMatrixState.fRenderTargetSize != size) {
+    if (!fHasVertexShader) {
+        SkASSERT(!fUniformHandles.fViewMatrixUni.isValid());
+        fGpu->setProjectionMatrix(drawState.getViewMatrix(), size, rt->origin());
+    } else if (fMatrixState.fRenderTargetOrigin != rt->origin() ||
+               fMatrixState.fRenderTargetSize != size ||
+               !fMatrixState.fViewMatrix.cheapEqualTo(drawState.getViewMatrix())) {
+        SkASSERT(fUniformHandles.fViewMatrixUni.isValid());
 
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
 
         GrGLfloat viewMatrix[3 * 3];
         fMatrixState.getGLMatrix<3>(viewMatrix);
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, viewMatrix);
     }
 }