Revert of 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 "GrGLGeometryProcessor.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 GrFragmentStage& processorStage,
+static SkMatrix get_transform_matrix(const GrProcessorStage& 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 14 matching lines @@
     return combined;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLProgram::GrGLProgram(GrGpuGL* gpu,
                          const GrGLProgramDesc& desc,
                          const BuiltinUniformHandles& builtinUniforms,
                          GrGLuint programID,
                          const UniformInfoArray& uniforms,
-                         GrGLInstalledGeoProc* geometryProcessor,
-                         GrGLInstalledFragProcs* fragmentProcessors)
+                         GrGLInstalledProcessors* geometryProcessor,
+                         GrGLInstalledProcessors* colorProcessors,
+                         GrGLInstalledProcessors* coverageProcessors)
     : fColor(GrColor_ILLEGAL)
     , fCoverage(GrColor_ILLEGAL)
     , fDstCopyTexUnit(-1)
     , fBuiltinUniformHandles(builtinUniforms)
     , fProgramID(programID)
-    , fGeometryProcessor(geometryProcessor)
-    , fFragmentProcessors(SkRef(fragmentProcessors))
+    , fGeometryProcessor(SkSafeRef(geometryProcessor))
+    , fColorEffects(SkRef(colorProcessors))
+    , fCoverageEffects(SkRef(coverageProcessors))
     , fDesc(desc)
     , fGpu(gpu)
     , fProgramDataManager(gpu, uniforms) {
     this->initSamplerUniforms();
 }
 
 GrGLProgram::~GrGLProgram() {
     if (fProgramID) {
         GL_CALL(DeleteProgram(fProgramID));
     }
 }
 
 void GrGLProgram::abandon() {
     fProgramID = 0;
 }
 
 void GrGLProgram::initSamplerUniforms() {
     GL_CALL(UseProgram(fProgramID));
     GrGLint texUnitIdx = 0;
     if (fBuiltinUniformHandles.fDstCopySamplerUni.isValid()) {
         fProgramDataManager.setSampler(fBuiltinUniformHandles.fDstCopySamplerUni, texUnitIdx);
         fDstCopyTexUnit = texUnitIdx++;
     }
     if (fGeometryProcessor.get()) {
         this->initSamplers(fGeometryProcessor.get(), &texUnitIdx);
     }
-    int numProcs = fFragmentProcessors->fProcs.count();
-    for (int i = 0; i < numProcs; i++) {
-        this->initSamplers(fFragmentProcessors->fProcs[i], &texUnitIdx);
+    this->initSamplers(fColorEffects.get(), &texUnitIdx);
+    this->initSamplers(fCoverageEffects.get(), &texUnitIdx);
+}
+
+void GrGLProgram::initSamplers(GrGLInstalledProcessors* ip, int* texUnitIdx) {
+    int numEffects = ip->fGLProcessors.count();
+    SkASSERT(numEffects == ip->fSamplers.count());
+    for (int e = 0; e < numEffects; ++e) {
+        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::initSamplers(GrGLInstalledProc* ip, int* texUnitIdx) {
-    SkTArray<GrGLInstalledProc::Sampler, true>& samplers = ip->fSamplers;
-    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 GrGLInstalledProc* ip, const GrProcessor& processor) {
-    const SkTArray<GrGLInstalledProc::Sampler, true>& samplers = ip->fSamplers;
+void GrGLProgram::bindTextures(const GrGLInstalledProcessors* ip,
+                               const GrProcessor& processor,
+                               int 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()));
     }
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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(optState.hasGeometryProcessor());
-        const GrGeometryProcessor& gp = *optState.getGeometryProcessor();
-        fGeometryProcessor->fGLProc->setData(fProgramDataManager, gp);
-        this->bindTextures(fGeometryProcessor, gp);
+        SkASSERT(geometryProcessor);
+        this->setData<GrGeometryStage>(&geometryProcessor, fGeometryProcessor.get());
     }
-    this->setFragmentData(optState);
+    this->setData<GrFragmentStage>(colorStages, fColorEffects.get());
+    this->setData<GrFragmentStage>(coverageStages, fCoverageEffects.get());
 
     // Some of GrGLProgram subclasses need to update state here
     this->didSetData(drawType);
 }
 
-void GrGLProgram::setFragmentData(const GrOptDrawState& optState) {
-    int numProcessors = fFragmentProcessors->fProcs.count();
-    for (int e = 0; e < numProcessors; ++e) {
-        const GrFragmentStage& stage = optState.getFragmentStage(e);
-        const GrProcessor& processor = *stage.getProcessor();
-        fFragmentProcessors->fProcs[e]->fGLProc->setData(fProgramDataManager, processor);
-        this->setTransformData(stage, fFragmentProcessors->fProcs[e]);
-        this->bindTextures(fFragmentProcessors->fProcs[e], processor);
-    }
-}
-void GrGLProgram::setTransformData(const GrFragmentStage& processor, GrGLInstalledFragProc* ip) {
-    SkTArray<GrGLInstalledFragProc::Transform, true>& transforms = ip->fTransforms;
+void GrGLProgram::setTransformData(const GrProcessorStage& 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->fLocalCoordAttrib, t);
+        const SkMatrix& matrix = get_transform_matrix(processor, ip->fHasExplicitLocalCoords, t);
         if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) {
             fProgramDataManager.setSkMatrix(transforms[t].fHandle.convertToUniformHandle(), matrix);
             transforms[t].fCurrentValue = matrix;
         }
     }
 }
 
 void GrGLProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(!GrGpu::IsPathRenderingDrawType(drawType));
 }
@@ skipping 112 matching lines @@
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLNvprProgramBase::GrGLNvprProgramBase(GrGpuGL* gpu,
                                          const GrGLProgramDesc& desc,
                                          const BuiltinUniformHandles& builtinUniforms,
                                          GrGLuint programID,
                                          const UniformInfoArray& uniforms,
-                                         GrGLInstalledFragProcs* fragmentProcessors)
-    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, NULL, fragmentProcessors) {
+                                         GrGLInstalledProcessors* colorProcessors,
+                                         GrGLInstalledProcessors* coverageProcessors)
+    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, NULL, colorProcessors,
+                coverageProcessors) {
 }
 
 void GrGLNvprProgramBase::onSetMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
                                                            const GrOptDrawState& optState) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(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 GrGLProgramDesc& desc,
                                  const BuiltinUniformHandles& builtinUniforms,
                                  GrGLuint programID,
                                  const UniformInfoArray& uniforms,
-                                 GrGLInstalledFragProcs* fragmentProcessors,
+                                 GrGLInstalledProcessors* colorProcessors,
+                                 GrGLInstalledProcessors* coverageProcessors,
                                  const SeparableVaryingInfoArray& separableVaryings)
-    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, fragmentProcessors) {
+    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, colorProcessors,
+                coverageProcessors) {
     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();
         );
         varying.fLocation = builderVarying.fLocation;
     }
 }
 
 void GrGLNvprProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
 }
 
-void GrGLNvprProgram::setTransformData(const GrFragmentStage& proc, GrGLInstalledFragProc* ip) {
-    SkTArray<GrGLInstalledFragProc::Transform, true>& transforms = ip->fTransforms;
+void GrGLNvprProgram::setTransformData(const GrProcessorStage& processor,
+                                       int effectIdx,
+                                       GrGLInstalledProcessors* ip) {
+    SkTArray<GrGLInstalledProcessors::Transform, true>& transforms = ip->fTransforms[effectIdx];
     int numTransforms = transforms.count();
-    SkASSERT(numTransforms == proc.getProcessor()->numTransforms());
+    SkASSERT(numTransforms == processor.getProcessor()->numTransforms());
     for (int t = 0; t < numTransforms; ++t) {
         SkASSERT(transforms[t].fHandle.isValid());
-        const SkMatrix& transform = get_transform_matrix(proc, ip->fLocalCoordAttrib, t);
+        const SkMatrix& transform = get_transform_matrix(processor, ip->fHasExplicitLocalCoords, t);
         if (transforms[t].fCurrentValue.cheapEqualTo(transform)) {
             continue;
         }
         transforms[t].fCurrentValue = transform;
         const Varying& fragmentInput = fVaryings[transforms[t].fHandle.handle()];
         SkASSERT(transforms[t].fType == kVec2f_GrSLType || transforms[t].fType == kVec3f_GrSLType);
         unsigned components = transforms[t].fType == kVec2f_GrSLType ? 2 : 3;
         fGpu->glPathRendering()->setProgramPathFragmentInputTransform(fProgramID,
                                                                       fragmentInput.fLocation,
                                                                       GR_GL_OBJECT_LINEAR,
                                                                       components,
                                                                       transform);
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 GrGLLegacyNvprProgram::GrGLLegacyNvprProgram(GrGpuGL* gpu,
-                                             const GrGLProgramDesc& desc,
-                                             const BuiltinUniformHandles& builtinUniforms,
-                                             GrGLuint programID,
-                                             const UniformInfoArray& uniforms,
-                                             GrGLInstalledFragProcs* fps,
-                                             int texCoordSetCnt)
-    : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, fps)
+                                 const GrGLProgramDesc& desc,
+                                 const BuiltinUniformHandles& builtinUniforms,
+                                 GrGLuint programID,
+                                 const UniformInfoArray& uniforms,
+                                 GrGLInstalledProcessors* colorProcessors,
+                                 GrGLInstalledProcessors* coverageProcessors,
+                                 int texCoordSetCnt)
+    : 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 GrFragmentStage& proc, GrGLInstalledFragProc* ip) {
+void GrGLLegacyNvprProgram::setTransformData(const GrProcessorStage& 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[0].fHandle.handle();
-    int numTransforms = proc.getProcessor()->numTransforms();
+    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(proc, false, t);
+        const SkMatrix& transform = get_transform_matrix(processorStage, false, t);
         GrGLPathRendering::PathTexGenComponents components =
                 GrGLPathRendering::kST_PathTexGenComponents;
-        if (proc.isPerspectiveCoordTransform(t, false)) {
+        if (processorStage.isPerspectiveCoordTransform(t, false)) {
             components = GrGLPathRendering::kSTR_PathTexGenComponents;
         }
         fGpu->glPathRendering()->enablePathTexGen(texCoordIndex++, components, transform);
     }
 }