Opt state takes a GP instead of a GeometryStage

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"
 #include "GrProcessor.h"
 #include "GrCoordTransform.h"
 #include "GrGLProcessor.h"
 #include "GrGpuGL.h"
 #include "GrGLPathRendering.h"
 #include "GrGLShaderVar.h"
 #include "GrGLSL.h"
 #include "GrOptDrawState.h"
 #include "SkXfermode.h"
 
 #define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(fGpu->glInterface(), R, X)
 
 /**
  * Retrieves the final matrix that a transform needs to apply to its source coords.
  */
-static SkMatrix get_transform_matrix(const GrProcessorStage& processorStage,
+static SkMatrix get_transform_matrix(const GrFragmentStage& processorStage,
                                      bool useExplicitLocalCoords,
                                      int transformIdx) {
     const GrCoordTransform& coordTransform =
             processorStage.getProcessor()->coordTransform(transformIdx);
     SkMatrix combined;
 
     if (kLocal_GrCoordSet == coordTransform.sourceCoords()) {
         // If we have explicit local coords then we shouldn't need a coord change.
         const SkMatrix& ccm =
                 useExplicitLocalCoords ? SkMatrix::I() : processorStage.getCoordChangeMatrix();
@@ skipping 69 matching lines @@
         SkTArray<GrGLInstalledProcessors::Sampler, true>& samplers = ip->fSamplers[e];
         int numSamplers = samplers.count();
         for (int s = 0; s < numSamplers; ++s) {
             SkASSERT(samplers[s].fUniform.isValid());
             fProgramDataManager.setSampler(samplers[s].fUniform, *texUnitIdx);
             samplers[s].fTextureUnit = (*texUnitIdx)++;
         }
     }
 }
 
-void GrGLProgram::bindTextures(const GrGLInstalledProcessors* ip,
+void GrGLProgram::bindTextures(const GrGLInstalledProcessors& ip,
                                const GrProcessor& processor,
                                int effectIdx) {
-    const SkTArray<GrGLInstalledProcessors::Sampler, true>& samplers = ip->fSamplers[effectIdx];
+    const SkTArray<GrGLInstalledProcessors::Sampler, true>& samplers = ip.fSamplers[effectIdx];
     int numSamplers = samplers.count();
     SkASSERT(numSamplers == processor.numTextures());
     for (int s = 0; s < numSamplers; ++s) {
         SkASSERT(samplers[s].fTextureUnit >= 0);
         const GrTextureAccess& textureAccess = processor.textureAccess(s);
         fGpu->bindTexture(samplers[s].fTextureUnit,
                           textureAccess.getParams(),
                           static_cast<GrGLTexture*>(textureAccess.getTexture()));
     }
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
+struct ColorStageMapper {
+    static const GrFragmentStage& GetStage(const GrOptDrawState& optState, int index) {
+        return optState.getColorStage(index);
+    }
+};
+
+struct CoverageStageMapper {
+    static const GrFragmentStage& GetStage(const GrOptDrawState& optState, int index) {
+        return optState.getCoverageStage(index);
+    }
+};
+
 void GrGLProgram::setData(const GrOptDrawState& optState,
                           GrGpu::DrawType drawType,
-                          const GrGeometryStage* geometryProcessor,
-                          const GrFragmentStage* colorStages[],
-                          const GrFragmentStage* coverageStages[],
                           const GrDeviceCoordTexture* dstCopy,
                           SharedGLState* sharedState) {
     GrColor color = optState.getColor();
     GrColor coverage = optState.getCoverageColor();
 
     this->setColor(optState, color, sharedState);
     this->setCoverage(optState, coverage, sharedState);
     this->setMatrixAndRenderTargetHeight(drawType, optState);
 
     if (dstCopy) {
@@ skipping 13 matching lines @@
         }
     } 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(geometryProcessor);
-        this->setData<GrGeometryStage>(&geometryProcessor, fGeometryProcessor.get());
+        SkASSERT(optState.hasGeometryProcessor());

[bsalomon, 2014/10/09 18:35:45]

Something feels off here... all these asserts make it seem like a round
peg/square hole problem. Is the problem that we have GrGLInstalledProcessors
which always assumes it is an array?

+        const GrGLInstalledProcessors& ip = *fGeometryProcessor.get();
+        SkASSERT(1 == ip.fGLProcessors.count());
+        // GPs do not have coord transforms
+        SkASSERT(0 == ip.fTransforms.count());
+        SkASSERT(1 == ip.fSamplers.count());
+        ip.fGLProcessors[0]->setData(fProgramDataManager, *optState.getGeometryProcessor());
+        this->bindTextures(ip, *optState.getGeometryProcessor(), 0);
     }
-    this->setData<GrFragmentStage>(colorStages, fColorEffects.get());
-    this->setData<GrFragmentStage>(coverageStages, fCoverageEffects.get());
+    this->setData<ColorStageMapper>(optState, fColorEffects.get());
+    this->setData<CoverageStageMapper>(optState, fCoverageEffects.get());
 
     // Some of GrGLProgram subclasses need to update state here
     this->didSetData(drawType);
 }
 
-void GrGLProgram::setTransformData(const GrProcessorStage& processor,
+void GrGLProgram::setTransformData(const GrFragmentStage& processor,
                                    int effectIdx,
                                    GrGLInstalledProcessors* ip) {
     SkTArray<GrGLInstalledProcessors::Transform, true>& transforms = ip->fTransforms[effectIdx];
     int numTransforms = transforms.count();
     SkASSERT(numTransforms == processor.getProcessor()->numTransforms());
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(transforms[t].fHandle.isValid());
         const SkMatrix& matrix = get_transform_matrix(processor, ip->fHasExplicitLocalCoords, t);
         if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) {
             fProgramDataManager.setSkMatrix(transforms[t].fHandle.convertToUniformHandle(), matrix);
@@ skipping 164 matching lines @@
             varying.fType = builderVarying.fVariable.getType();
         );
         varying.fLocation = builderVarying.fLocation;
     }
 }
 
 void GrGLNvprProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
 }
 
-void GrGLNvprProgram::setTransformData(const GrProcessorStage& processor,
+void GrGLNvprProgram::setTransformData(const GrFragmentStage& processor,
                                        int effectIdx,
                                        GrGLInstalledProcessors* ip) {
     SkTArray<GrGLInstalledProcessors::Transform, true>& transforms = ip->fTransforms[effectIdx];
     int numTransforms = transforms.count();
     SkASSERT(numTransforms == processor.getProcessor()->numTransforms());
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(transforms[t].fHandle.isValid());
         const SkMatrix& transform = get_transform_matrix(processor, ip->fHasExplicitLocalCoords, t);
         if (transforms[t].fCurrentValue.cheapEqualTo(transform)) {
             continue;
@@ skipping 23 matching lines @@
     : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, colorProcessors,
                 coverageProcessors)
     , fTexCoordSetCnt(texCoordSetCnt) {
 }
 
 void GrGLLegacyNvprProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
     fGpu->glPathRendering()->flushPathTexGenSettings(fTexCoordSetCnt);
 }
 
-void GrGLLegacyNvprProgram::setTransformData(const GrProcessorStage& processorStage,
+void GrGLLegacyNvprProgram::setTransformData(const GrFragmentStage& processorStage,
                                        int effectIdx,
                                        GrGLInstalledProcessors* ip) {
     // We've hidden the texcoord index in the first entry of the transforms array for each effect
     int texCoordIndex = ip->fTransforms[effectIdx][0].fHandle.handle();
     int numTransforms = processorStage.getProcessor()->numTransforms();
     for (int t = 0; t < numTransforms; ++t) {
         const SkMatrix& transform = get_transform_matrix(processorStage, false, t);
         GrGLPathRendering::PathTexGenComponents components =
                 GrGLPathRendering::kST_PathTexGenComponents;
         if (processorStage.isPerspectiveCoordTransform(t, false)) {
             components = GrGLPathRendering::kSTR_PathTexGenComponents;
         }
         fGpu->glPathRendering()->enablePathTexGen(texCoordIndex++, components, transform);
     }
 }