Draft change to start pulling uniform color into GP

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 113 matching lines @@
         fGpu->bindTexture(samplers[s].fTextureUnit,
                           textureAccess.getParams(),
                           static_cast<GrGLTexture*>(textureAccess.getTexture()));
     }
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLProgram::setData(const GrOptDrawState& optState) {
-    GrColor color = optState.getColor();
-    uint8_t coverage = optState.getCoverage();
-
-    this->setColor(optState, color);
-    this->setCoverage(optState, coverage);
     this->setMatrixAndRenderTargetHeight(optState);
 
     const GrDeviceCoordTexture* dstCopy = optState.getDstCopy();
     if (dstCopy) {
         if (fBuiltinUniformHandles.fDstCopyTopLeftUni.isValid()) {
             fProgramDataManager.set2f(fBuiltinUniformHandles.fDstCopyTopLeftUni,
                                        static_cast<GrGLfloat>(dstCopy->offset().fX),
                                        static_cast<GrGLfloat>(dstCopy->offset().fY));
             fProgramDataManager.set2f(fBuiltinUniformHandles.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(!fBuiltinUniformHandles.fDstCopyScaleUni.isValid());
             SkASSERT(!fBuiltinUniformHandles.fDstCopySamplerUni.isValid());
         }
     } else {
         SkASSERT(!fBuiltinUniformHandles.fDstCopyTopLeftUni.isValid());
         SkASSERT(!fBuiltinUniformHandles.fDstCopyScaleUni.isValid());
         SkASSERT(!fBuiltinUniformHandles.fDstCopySamplerUni.isValid());
     }
 
     // we set the textures, and uniforms for installed processors in a generic way, but subclasses
     // of GLProgram determine how to set coord transforms
-    if (fGeometryProcessor.get()) {
-        SkASSERT(optState.hasGeometryProcessor());
-        const GrGeometryProcessor& gp = *optState.getGeometryProcessor();
-        const GrBatchTracker& bt = optState.getBatchTracker();
-        fGeometryProcessor->fGLProc->setData(fProgramDataManager, gp, bt);
-        this->bindTextures(fGeometryProcessor, gp);
-    }
+    const GrPrimitiveProcessor& primProc = *optState.getPrimitiveProcessor();
+    const GrBatchTracker& bt = optState.getBatchTracker();
+    fGeometryProcessor->fGLProc->setData(fProgramDataManager, primProc, bt);
+    this->bindTextures(fGeometryProcessor, primProc);
+
     if (fXferProcessor.get()) {
         const GrXferProcessor& xp = *optState.getXferProcessor();
         fXferProcessor->fGLProc->setData(fProgramDataManager, xp);
         this->bindTextures(fXferProcessor, xp);
     }
     this->setFragmentData(optState);
 
     // Some of GrGLProgram subclasses need to update state here
     this->didSetData(optState.drawType());
 }
@@ skipping 20 matching lines @@
             fProgramDataManager.setSkMatrix(transforms[t].fHandle.convertToUniformHandle(), matrix);
             transforms[t].fCurrentValue = matrix;
         }
     }
 }
 
 void GrGLProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(!GrGpu::IsPathRenderingDrawType(drawType));
 }
 
-void GrGLProgram::setColor(const GrOptDrawState& optState, GrColor color) {
-    const GrProgramDesc::KeyHeader& header = fDesc.header();
-    switch (header.fColorInput) {
-        case GrProgramDesc::kAttribute_ColorInput:
-            // Attribute case is handled in GrGpuGL::setupGeometry
-            break;
-        case GrProgramDesc::kUniform_ColorInput:
-            if (fColor != color && fBuiltinUniformHandles.fColorUni.isValid()) {
-                // OpenGL ES doesn't support unsigned byte varieties of glUniform
-                GrGLfloat c[4];
-                GrColorToRGBAFloat(color, c);
-                fProgramDataManager.set4fv(fBuiltinUniformHandles.fColorUni, 1, c);
-                fColor = color;
-            }
-            break;
-        case GrProgramDesc::kAllOnes_ColorInput:
-            // Handled by shader creation
-            break;
-        default:
-            SkFAIL("Unexpected color type.");
-    }
-}
-
-void GrGLProgram::setCoverage(const GrOptDrawState& optState, uint8_t coverage) {
-    const GrProgramDesc::KeyHeader& header = fDesc.header();
-    switch (header.fCoverageInput) {
-        case GrProgramDesc::kAttribute_ColorInput:
-            // Attribute case is handled in GrGpuGL::setupGeometry
-            break;
-        case GrProgramDesc::kUniform_ColorInput:
-            if (fCoverage != coverage) {
-                // OpenGL ES doesn't support unsigned byte varieties of glUniform
-                GrGLfloat c = GrNormalizeByteToFloat(coverage);
-                fProgramDataManager.set1f(fBuiltinUniformHandles.fCoverageUni, c);
-                fCoverage = coverage;
-            }
-            break;
-        case GrProgramDesc::kAllOnes_ColorInput:
-            // Handled by shader creation
-            break;
-        default:
-            SkFAIL("Unexpected coverage type.");
-    }
-}
-
 void GrGLProgram::setMatrixAndRenderTargetHeight(const GrOptDrawState& optState) {
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
     if (fBuiltinUniformHandles.fRTHeightUni.isValid() &&
         fMatrixState.fRenderTargetSize.fHeight != optState.getRenderTarget()->height()) {
         fProgramDataManager.set1f(fBuiltinUniformHandles.fRTHeightUni,
                                    SkIntToScalar(optState.getRenderTarget()->height()));
     }
 
     // call subclasses to set the actual view matrix
     this->onSetMatrixAndRenderTargetHeight(optState);
@@ skipping 22 matching lines @@
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLNvprProgramBase::GrGLNvprProgramBase(GrGpuGL* gpu,
                                          const GrProgramDesc& desc,
                                          const BuiltinUniformHandles& builtinUniforms,
                                          GrGLuint programID,
                                          const UniformInfoArray& uniforms,
+                                         GrGLInstalledGeoProc* primProc,
                                          GrGLInstalledXferProc* xferProcessor,
                                          GrGLInstalledFragProcs* fragmentProcessors)
-    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, NULL,
+    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, primProc,
                 xferProcessor, fragmentProcessors) {
 }
 
 void GrGLNvprProgramBase::onSetMatrixAndRenderTargetHeight(const GrOptDrawState& optState) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(optState.drawType()));
     const GrRenderTarget* rt = optState.getRenderTarget();
     SkISize size;
     size.set(rt->width(), rt->height());
     fGpu->glPathRendering()->setProjectionMatrix(optState.getViewMatrix(), size, rt->origin());
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLNvprProgram::GrGLNvprProgram(GrGpuGL* gpu,
                                  const GrProgramDesc& desc,
                                  const BuiltinUniformHandles& builtinUniforms,
                                  GrGLuint programID,
                                  const UniformInfoArray& uniforms,
+                                 GrGLInstalledGeoProc* primProc,
                                  GrGLInstalledXferProc* xferProcessor,
                                  GrGLInstalledFragProcs* fragmentProcessors,
                                  const SeparableVaryingInfoArray& separableVaryings)
-    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms,
+    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, primProc,
                 xferProcessor, fragmentProcessors) {
     int count = separableVaryings.count();
     fVaryings.push_back_n(count);
     for (int i = 0; i < count; i++) {
         Varying& varying = fVaryings[i];
         const SeparableVaryingInfo& builderVarying = separableVaryings[i];
         SkASSERT(GrGLShaderVar::kNonArray == builderVarying.fVariable.getArrayCount());
         SkDEBUGCODE(
             varying.fType = builderVarying.fVariable.getType();
         );
@@ skipping 28 matching lines @@
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 GrGLLegacyNvprProgram::GrGLLegacyNvprProgram(GrGpuGL* gpu,
                                              const GrProgramDesc& desc,
                                              const BuiltinUniformHandles& builtinUniforms,
                                              GrGLuint programID,
                                              const UniformInfoArray& uniforms,
+                                             GrGLInstalledGeoProc* primProc,
                                              GrGLInstalledXferProc* xp,
                                              GrGLInstalledFragProcs* fps,
                                              int texCoordSetCnt)
-    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, xp, fps)
+    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, primProc, xp, fps)
     , fTexCoordSetCnt(texCoordSetCnt) {
 }
 
 void GrGLLegacyNvprProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
     fGpu->glPathRendering()->flushPathTexGenSettings(fTexCoordSetCnt);
 }
 
 void
 GrGLLegacyNvprProgram::setTransformData(const GrPendingFragmentStage& proc,
                                         GrGLInstalledFragProc* ip) {
     // We've hidden the texcoord index in the first entry of the transforms array for each effect
     int texCoordIndex = ip->fTransforms[0].fHandle.handle();
     int numTransforms = proc.getProcessor()->numTransforms();
     for (int t = 0; t < numTransforms; ++t) {
         const SkMatrix& transform = get_transform_matrix(proc, t);
         GrGLPathRendering::PathTexGenComponents components =
                 GrGLPathRendering::kST_PathTexGenComponents;
         if (proc.isPerspectiveCoordTransform(t)) {
             components = GrGLPathRendering::kSTR_PathTexGenComponents;
         }
         fGpu->glPathRendering()->enablePathTexGen(texCoordIndex++, components, transform);
     }
 }