OptState owns program descriptor

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 38 matching lines @@
             combined[SkMatrix::kMPersp1] - combined[SkMatrix::kMScaleY]);
         combined.set(SkMatrix::kMTransY,
             combined[SkMatrix::kMPersp2] - combined[SkMatrix::kMTransY]);
     }
     return combined;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLProgram::GrGLProgram(GrGpuGL* gpu,
-                         const GrGLProgramDesc& desc,
+                         const GrProgramDesc& desc,
                          const BuiltinUniformHandles& builtinUniforms,
                          GrGLuint programID,
                          const UniformInfoArray& uniforms,
                          GrGLInstalledGeoProc* geometryProcessor,
                          GrGLInstalledFragProcs* fragmentProcessors)
     : fColor(GrColor_ILLEGAL)
     , fCoverage(GrColor_ILLEGAL)
     , fDstCopyTexUnit(-1)
     , fBuiltinUniformHandles(builtinUniforms)
     , fProgramID(programID)
@@ skipping 124 matching lines @@
             transforms[t].fCurrentValue = matrix;
         }
     }
 }
 
 void GrGLProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(!GrGpu::IsPathRenderingDrawType(drawType));
 }
 
 void GrGLProgram::setColor(const GrOptDrawState& optState, GrColor color) {
-    const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
+    const GrProgramDesc::KeyHeader& header = fDesc.header();
     switch (header.fColorInput) {
-        case GrGLProgramDesc::kAttribute_ColorInput:
+        case GrProgramDesc::kAttribute_ColorInput:
             // Attribute case is handled in GrGpuGL::setupGeometry
             break;
-        case GrGLProgramDesc::kUniform_ColorInput:
+        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 GrGLProgramDesc::kAllOnes_ColorInput:
+        case GrProgramDesc::kAllOnes_ColorInput:
             // Handled by shader creation
             break;
         default:
             SkFAIL("Unexpected color type.");
     }
 }
 
 void GrGLProgram::setCoverage(const GrOptDrawState& optState, GrColor coverage) {
-    const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
+    const GrProgramDesc::KeyHeader& header = fDesc.header();
     switch (header.fCoverageInput) {
-        case GrGLProgramDesc::kAttribute_ColorInput:
+        case GrProgramDesc::kAttribute_ColorInput:
             // Attribute case is handled in GrGpuGL::setupGeometry
             break;
-        case GrGLProgramDesc::kUniform_ColorInput:
+        case GrProgramDesc::kUniform_ColorInput:
             if (fCoverage != coverage) {
                 // OpenGL ES doesn't support unsigned byte varieties of glUniform
                 GrGLfloat c[4];
                 GrColorToRGBAFloat(coverage, c);
                 fProgramDataManager.set4fv(fBuiltinUniformHandles.fCoverageUni, 1, c);
                 fCoverage = coverage;
             }
             break;
-        case GrGLProgramDesc::kAllOnes_ColorInput:
+        case GrProgramDesc::kAllOnes_ColorInput:
             // Handled by shader creation
             break;
         default:
             SkFAIL("Unexpected coverage type.");
     }
 }
 
 void GrGLProgram::setMatrixAndRenderTargetHeight(GrGpu::DrawType drawType,
                                                  const GrOptDrawState& optState) {
     // Load the RT height uniform if it is needed to y-flip gl_FragCoord.
@@ skipping 27 matching lines @@
 
         GrGLfloat rtAdjustmentVec[4];
         fMatrixState.getRTAdjustmentVec(rtAdjustmentVec);
         fProgramDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
     }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLNvprProgramBase::GrGLNvprProgramBase(GrGpuGL* gpu,
-                                         const GrGLProgramDesc& desc,
+                                         const GrProgramDesc& desc,
                                          const BuiltinUniformHandles& builtinUniforms,
                                          GrGLuint programID,
                                          const UniformInfoArray& uniforms,
                                          GrGLInstalledFragProcs* fragmentProcessors)
     : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, NULL, fragmentProcessors) {
 }
 
 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 GrProgramDesc& desc,
                                  const BuiltinUniformHandles& builtinUniforms,
                                  GrGLuint programID,
                                  const UniformInfoArray& uniforms,
                                  GrGLInstalledFragProcs* fragmentProcessors,
                                  const SeparableVaryingInfoArray& separableVaryings)
     : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, fragmentProcessors) {
     int count = separableVaryings.count();
     fVaryings.push_back_n(count);
     for (int i = 0; i < count; i++) {
         Varying& varying = fVaryings[i];
@@ skipping 28 matching lines @@
                                                                       fragmentInput.fLocation,
                                                                       GR_GL_OBJECT_LINEAR,
                                                                       components,
                                                                       transform);
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 GrGLLegacyNvprProgram::GrGLLegacyNvprProgram(GrGpuGL* gpu,
-                                             const GrGLProgramDesc& desc,
+                                             const GrProgramDesc& desc,
                                              const BuiltinUniformHandles& builtinUniforms,
                                              GrGLuint programID,
                                              const UniformInfoArray& uniforms,
                                              GrGLInstalledFragProcs* fps,
                                              int texCoordSetCnt)
     : INHERITED(gpu, desc, builtinUniforms, programID, uniforms, fps)
     , fTexCoordSetCnt(texCoordSetCnt) {
 }
 
 void GrGLLegacyNvprProgram::didSetData(GrGpu::DrawType drawType) {
     SkASSERT(GrGpu::IsPathRenderingDrawType(drawType));
     fGpu->glPathRendering()->flushPathTexGenSettings(fTexCoordSetCnt);
 }
 
 void
 GrGLLegacyNvprProgram::setTransformData(const GrFragmentStage& 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, false, t);
         GrGLPathRendering::PathTexGenComponents components =
                 GrGLPathRendering::kST_PathTexGenComponents;
         if (proc.isPerspectiveCoordTransform(t, false)) {
             components = GrGLPathRendering::kSTR_PathTexGenComponents;
         }
         fGpu->glPathRendering()->enablePathTexGen(texCoordIndex++, components, transform);
     }
 }