OptState owns program descriptor

src/gpu/gl/builders/GrGLProgramBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgramBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
@@ skipping 11 matching lines @@
 #define GL_CALL_RET(R, X) GR_GL_CALL_RET(this->gpu()->glInterface(), R, X)
 
 // ES2 FS only guarantees mediump and lowp support
 static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision;
 
 //////////////////////////////////////////////////////////////////////////////
 
 const int GrGLProgramBuilder::kVarsPerBlock = 8;
 
 GrGLProgram* GrGLProgramBuilder::CreateProgram(const GrOptDrawState& optState,
-                                               const GrGLProgramDesc& desc,
                                                GrGpu::DrawType drawType,
                                                GrGpuGL* gpu) {
     // create a builder.  This will be handed off to effects so they can use it to add
     // uniforms, varyings, textures, etc
-    SkAutoTDelete<GrGLProgramBuilder> builder(CreateProgramBuilder(desc,
-                                                                   optState,
+    SkAutoTDelete<GrGLProgramBuilder> builder(CreateProgramBuilder(optState,
                                                                    drawType,
                                                                    optState.hasGeometryProcessor(),
                                                                    gpu));
 
     GrGLProgramBuilder* pb = builder.get();
-    const GrGLProgramDesc::KeyHeader& header = pb->header();
+    const GrGLProgramDesc::GLKeyHeader& header = pb->header();
 
     // emit code to read the dst copy texture, if necessary
     if (GrGLFragmentShaderBuilder::kNoDstRead_DstReadKey != header.fDstReadKey
             && !gpu->glCaps().fbFetchSupport()) {
         pb->fFS.emitCodeToReadDstTexture();
     }
 
     // get the initial color and coverage to feed into the first effect in each effect chain
     GrGLSLExpr4 inputColor, inputCoverage;
     pb->setupUniformColorAndCoverageIfNeeded(&inputColor,  &inputCoverage);
@@ skipping 15 matching lines @@
         }
     }
 
     pb->emitAndInstallProcs(optState, &inputColor, &inputCoverage);
 
     if (hasVertexShader) {
         pb->fVS.transformSkiaToGLCoords();
     }
 
     // write the secondary color output if necessary
-    if (GrOptDrawState::kNone_SecondaryOutputType != header.fSecondaryOutputType) {
+    if (GrGLProgramDesc::kNone_SecondaryOutputType != header.fSecondaryOutputType) {
         pb->fFS.enableSecondaryOutput(inputColor, inputCoverage);
     }
 
     pb->fFS.combineColorAndCoverage(inputColor, inputCoverage);
 
     return pb->finalize();
 }
 
 GrGLProgramBuilder*
-GrGLProgramBuilder::CreateProgramBuilder(const GrGLProgramDesc& desc,
-                                         const GrOptDrawState& optState,
+GrGLProgramBuilder::CreateProgramBuilder(const GrOptDrawState& optState,
                                          GrGpu::DrawType drawType,
                                          bool hasGeometryProcessor,
                                          GrGpuGL* gpu) {
-    if (desc.getHeader().fUseFragShaderOnly) {
+    const GrGLProgramDesc& desc = optState.desc().cast<GrGLProgramDesc>();
+    if (desc.header().fUseFragShaderOnly) {
         SkASSERT(gpu->glCaps().pathRenderingSupport());
         SkASSERT(gpu->glPathRendering()->texturingMode() ==
                  GrGLPathRendering::FixedFunction_TexturingMode);
+        SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.header().fColorInput);
+        SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.header().fCoverageInput);
         SkASSERT(!hasGeometryProcessor);
-        return SkNEW_ARGS(GrGLLegacyNvprProgramBuilder, (gpu, optState, desc));
+        return SkNEW_ARGS(GrGLLegacyNvprProgramBuilder, (gpu, optState));
     } else if (GrGpu::IsPathRenderingDrawType(drawType)) {
         SkASSERT(gpu->glCaps().pathRenderingSupport());
         SkASSERT(gpu->glPathRendering()->texturingMode() ==
                  GrGLPathRendering::SeparableShaders_TexturingMode);
         SkASSERT(!hasGeometryProcessor);
-        return SkNEW_ARGS(GrGLNvprProgramBuilder, (gpu, optState, desc));
+        return SkNEW_ARGS(GrGLNvprProgramBuilder, (gpu, optState));
     } else {
-        return SkNEW_ARGS(GrGLProgramBuilder, (gpu, optState, desc));
+        return SkNEW_ARGS(GrGLProgramBuilder, (gpu, optState));
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-GrGLProgramBuilder::GrGLProgramBuilder(GrGpuGL* gpu,
-                                       const GrOptDrawState& optState,
-                                       const GrGLProgramDesc& desc)
+GrGLProgramBuilder::GrGLProgramBuilder(GrGpuGL* gpu, const GrOptDrawState& optState)
     : fVS(this)
     , fGS(this)
-    , fFS(this, desc)
+    , fFS(this, optState.desc().cast<GrGLProgramDesc>().header().fFragPosKey)
     , fOutOfStage(true)
     , fStageIndex(-1)
     , fGeometryProcessor(NULL)
     , fOptState(optState)
-    , fDesc(desc)
+    , fDesc(optState.desc().cast<GrGLProgramDesc>())
     , fGpu(gpu)
     , fUniforms(kVarsPerBlock) {
 }
 
 void GrGLProgramBuilder::addVarying(GrSLType type,
                                     const char* name,
                                     const char** vsOutName,
                                     const char** fsInName,
                                     GrGLShaderVar::Precision fsPrecision) {
     SkString* fsInputName = fVS.addVarying(type, name, vsOutName);
@@ skipping 89 matching lines @@
 
 void GrGLProgramBuilder::emitAndInstallProcs(const GrOptDrawState& optState,
                                              GrGLSLExpr4* inputColor,
                                              GrGLSLExpr4* inputCoverage) {
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
     int numProcs = optState.numFragmentStages();
     this->emitAndInstallFragProcs(0, optState.numColorStages(), inputColor);
     if (optState.hasGeometryProcessor()) {
         const GrGeometryProcessor& gp = *optState.getGeometryProcessor();
         fVS.emitAttributes(gp);
-        ProcKeyProvider keyProvider(&fDesc, ProcKeyProvider::kGeometry_ProcessorType);
+        ProcKeyProvider keyProvider(&fDesc,
+                                    ProcKeyProvider::kGeometry_ProcessorType,
+                                    GrGLProgramDesc::kEffectKeyOffsetsAndLengthOffset);
         GrGLSLExpr4 output;
         this->emitAndInstallProc<GrGeometryProcessor>(gp, 0, keyProvider, *inputCoverage, &output);
         *inputCoverage = output;
     }
     this->emitAndInstallFragProcs(optState.numColorStages(), numProcs,  inputCoverage);
 }
 
 void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut) {
-    ProcKeyProvider keyProvider(&fDesc, ProcKeyProvider::kFragment_ProcessorType);
+    ProcKeyProvider keyProvider(&fDesc,
+                                ProcKeyProvider::kFragment_ProcessorType,
+                                GrGLProgramDesc::kEffectKeyOffsetsAndLengthOffset);
     for (int e = procOffset; e < numProcs; ++e) {
         GrGLSLExpr4 output;
         const GrFragmentStage& stage = fOptState.getFragmentStage(e);
         this->emitAndInstallProc<GrFragmentStage>(stage, e, keyProvider, *inOut, &output);
         *inOut = output;
     }
 }
 
 // TODO Processors cannot output zeros because an empty string is all 1s
 // the fix is to allow effects to take the GrGLSLExpr4 directly
@@ skipping 249 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }