Implement NVPR on GLES

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 75 matching lines @@
     if (fBuilderOutput.fUniformHandles.fDstCopySamplerUni.isValid()) {
         fUniformManager->setSampler(fBuilderOutput.fUniformHandles.fDstCopySamplerUni, texUnitIdx);
         fDstCopyTexUnit = texUnitIdx++;
     }
     fBuilderOutput.fColorEffects->initSamplers(*fUniformManager, &texUnitIdx);
     fBuilderOutput.fCoverageEffects->initSamplers(*fUniformManager, &texUnitIdx);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGLProgram::setData(GrDrawState::BlendOptFlags blendOpts,
+void GrGLProgram::setData(GrGpu::DrawType drawType,
+                          GrDrawState::BlendOptFlags blendOpts,
                           const GrEffectStage* colorStages[],
                           const GrEffectStage* coverageStages[],
                           const GrDeviceCoordTexture* dstCopy,
                           SharedGLState* sharedState) {
     const GrDrawState& drawState = fGpu->getDrawState();
 
     GrColor color;
     GrColor coverage;
     if (blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag) {
         color = 0;
         coverage = 0;
     } else if (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) {
         color = 0xffffffff;
         coverage = drawState.getCoverageColor();
     } else {
         color = drawState.getColor();
         coverage = drawState.getCoverageColor();
     }
 
     this->setColor(drawState, color, sharedState);
     this->setCoverage(drawState, coverage, sharedState);
-    this->setMatrixAndRenderTargetHeight(drawState);
+    this->setMatrixAndRenderTargetHeight(drawType, drawState);
 
     if (NULL != dstCopy) {
         if (fBuilderOutput.fUniformHandles.fDstCopyTopLeftUni.isValid()) {
             fUniformManager->set2f(fBuilderOutput.fUniformHandles.fDstCopyTopLeftUni,
                                    static_cast<GrGLfloat>(dstCopy->offset().fX),
                                    static_cast<GrGLfloat>(dstCopy->offset().fY));
             fUniformManager->set2f(fBuilderOutput.fUniformHandles.fDstCopyScaleUni,
                                    1.f / dstCopy->texture()->width(),
                                    1.f / dstCopy->texture()->height());
             GrGLTexture* texture = static_cast<GrGLTexture*>(dstCopy->texture());
             static GrTextureParams kParams; // the default is clamp, nearest filtering.
             fGpu->bindTexture(fDstCopyTexUnit, kParams, texture);
         } else {
             SkASSERT(!fBuilderOutput.fUniformHandles.fDstCopyScaleUni.isValid());
             SkASSERT(!fBuilderOutput.fUniformHandles.fDstCopySamplerUni.isValid());
         }
     } else {
         SkASSERT(!fBuilderOutput.fUniformHandles.fDstCopyTopLeftUni.isValid());
         SkASSERT(!fBuilderOutput.fUniformHandles.fDstCopyScaleUni.isValid());
         SkASSERT(!fBuilderOutput.fUniformHandles.fDstCopySamplerUni.isValid());
     }
 
-    fBuilderOutput.fColorEffects->setData(fGpu, *fUniformManager, colorStages);
-    fBuilderOutput.fCoverageEffects->setData(fGpu, *fUniformManager, coverageStages);
+    fBuilderOutput.fColorEffects->setData(fGpu, drawType, *fUniformManager, colorStages);
+    fBuilderOutput.fCoverageEffects->setData(fGpu, drawType, *fUniformManager, coverageStages);
 
 
     // PathTexGen state applies to the the fixed function vertex shader. For
     // custom shaders, it's ignored, so we don't need to change the texgen
     // settings in that case.
     if (!fBuilderOutput.fHasVertexShader) {
         fGpu->flushPathTexGenSettings(fBuilderOutput.fTexCoordSetCnt);
     }
 }
 
@@ skipping 69 matching lines @@
                 sharedState->fConstAttribCoverageIndex = -1;
                 break;
             default:
                 SkFAIL("Unknown coverage type.");
         }
     } else {
         sharedState->fConstAttribCoverageIndex = -1;
     }
 }
 
-void GrGLProgram::setMatrixAndRenderTargetHeight(const GrDrawState& drawState) {
+void GrGLProgram::setMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
+                                                 const GrDrawState& drawState) {
     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 (fBuilderOutput.fUniformHandles.fRTHeightUni.isValid() &&
         fMatrixState.fRenderTargetSize.fHeight != size.fHeight) {
         fUniformManager->set1f(fBuilderOutput.fUniformHandles.fRTHeightUni,
                                SkIntToScalar(size.fHeight));
     }
 
-    if (!fBuilderOutput.fHasVertexShader) {
-        SkASSERT(!fBuilderOutput.fUniformHandles.fViewMatrixUni.isValid());
-        SkASSERT(!fBuilderOutput.fUniformHandles.fRTAdjustmentUni.isValid());
+    if (GrGpu::IsPathRenderingDrawType(drawType)) {
         fGpu->setProjectionMatrix(drawState.getViewMatrix(), size, rt->origin());
     } else if (fMatrixState.fRenderTargetOrigin != rt->origin() ||
                fMatrixState.fRenderTargetSize != size ||
                !fMatrixState.fViewMatrix.cheapEqualTo(drawState.getViewMatrix())) {
         SkASSERT(fBuilderOutput.fUniformHandles.fViewMatrixUni.isValid());
 
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
 
         GrGLfloat viewMatrix[3 * 3];
         fMatrixState.getGLMatrix<3>(viewMatrix);
         fUniformManager->setMatrix3f(fBuilderOutput.fUniformHandles.fViewMatrixUni, viewMatrix);
 
         GrGLfloat rtAdjustmentVec[4];
         fMatrixState.getRTAdjustmentVec(rtAdjustmentVec);
         fUniformManager->set4fv(fBuilderOutput.fUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
     }
 }