Add a GrGpuGL reference for GrGLProgram/GrGLUniformManager

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 "GrEffect.h"
 #include "GrDrawEffect.h"
 #include "GrGLEffect.h"
 #include "GrGpuGL.h"
 #include "GrGLShaderVar.h"
 #include "GrGLSL.h"
 #include "SkTrace.h"
 #include "SkXfermode.h"
 
 #include "SkRTConf.h"
 
 SK_DEFINE_INST_COUNT(GrGLProgram)
 
-#define GL_CALL(X) GR_GL_CALL(fContext.interface(), X)
-#define GL_CALL_RET(R, X) GR_GL_CALL_RET(fContext.interface(), R, X)
+#define GL_CALL(X) GR_GL_CALL(fGpu->glInterface(), X)
+#define GL_CALL_RET(R, X) GR_GL_CALL_RET(fGpu->glInterface(), R, X)
 
 SK_CONF_DECLARE(bool, c_PrintShaders, "gpu.printShaders", false,
                 "Print the source code for all shaders generated.");
 
 #define COL_ATTR_NAME "aColor"
 #define COV_ATTR_NAME "aCoverage"
 #define EDGE_ATTR_NAME "aEdge"
 
 namespace {
 inline const char* declared_color_output_name() { return "fsColorOut"; }
 inline const char* dual_source_output_name() { return "dualSourceOut"; }
 }
 
-GrGLProgram* GrGLProgram::Create(const GrGLContext& gl,
+GrGLProgram* GrGLProgram::Create(GrGpuGL* gpu,
                                  const GrGLProgramDesc& desc,
                                  const GrEffectStage* colorStages[],
                                  const GrEffectStage* coverageStages[]) {
-    GrGLProgram* program = SkNEW_ARGS(GrGLProgram, (gl, desc, colorStages, coverageStages));
+    GrGLProgram* program = SkNEW_ARGS(GrGLProgram, (gpu, desc, colorStages, coverageStages));
     if (!program->succeeded()) {
         delete program;
         program = NULL;
     }
     return program;
 }
 
-GrGLProgram::GrGLProgram(const GrGLContext& gl,
+GrGLProgram::GrGLProgram(GrGpuGL* gpu,
                          const GrGLProgramDesc& desc,
                          const GrEffectStage* colorStages[],
                          const GrEffectStage* coverageStages[])
-: fContext(gl)
-, fUniformManager(gl) {
+: fGpu(gpu)
+, fUniformManager(gpu) {
     fDesc = desc;
     fVShaderID = 0;
     fGShaderID = 0;
     fFShaderID = 0;
     fProgramID = 0;
 
     fDstCopyTexUnit = -1;
 
     fColor = GrColor_ILLEGAL;
     fColorFilterColor = GrColor_ILLEGAL;
@@ skipping 212 matching lines @@
         default:
             GrCrash("Unknown color type.");
             return kNone_GrSLConstantVec;
     }
 }
 
 void GrGLProgram::genGeometryShader(GrGLShaderBuilder::VertexBuilder* vertexBuilder) const {
 #if GR_GL_EXPERIMENTAL_GS
     // TODO: The builder should add all this glue code.
     if (fDesc.getHeader().fExperimentalGS) {
-        SkASSERT(fContext.info().glslGeneration() >= k150_GrGLSLGeneration);
+        SkASSERT(fGpu->glslGeneration() >= k150_GrGLSLGeneration);
         vertexBuilder->fGSHeader.append("layout(triangles) in;\n"
                                         "layout(triangle_strip, max_vertices = 6) out;\n");
         vertexBuilder->gsCodeAppend("\tfor (int i = 0; i < 3; ++i) {\n"
                                     "\t\tgl_Position = gl_in[i].gl_Position;\n");
         if (fDesc.getHeader().fEmitsPointSize) {
             vertexBuilder->gsCodeAppend("\t\tgl_PointSize = 1.0;\n");
         }
         SkASSERT(vertexBuilder->fGSInputs.count() == vertexBuilder->fGSOutputs.count());
         int count = vertexBuilder->fGSInputs.count();
         for (int i = 0; i < count; ++i) {
@@ skipping 28 matching lines @@
     for (int i = 0; i < stringCnt; ++i) {
         if (NULL == stringLengths || stringLengths[i] < 0) {
             GrPrintf(strings[i]);
         } else {
             GrPrintf("%.*s", stringLengths[i], strings[i]);
         }
     }
 }
 
 // Compiles a GL shader, returns shader ID or 0 if failed params have same meaning as glShaderSource
-GrGLuint compile_shader(const GrGLContext& gl,
+GrGLuint compile_shader(const GrGLInterface* gli,
                         GrGLenum type,
                         int stringCnt,
                         const char** strings,
                         int* stringLengths) {
     SK_TRACE_EVENT1("GrGLProgram::CompileShader",
                     "stringCount", SkStringPrintf("%i", stringCnt).c_str());
 
     GrGLuint shader;
-    GR_GL_CALL_RET(gl.interface(), shader, CreateShader(type));
+    GR_GL_CALL_RET(gli, shader, CreateShader(type));
     if (0 == shader) {
         return 0;
     }
 
-    const GrGLInterface* gli = gl.interface();
     GrGLint compiled = GR_GL_INIT_ZERO;
     GR_GL_CALL(gli, ShaderSource(shader, stringCnt, strings, stringLengths));
     GR_GL_CALL(gli, CompileShader(shader));
     GR_GL_CALL(gli, GetShaderiv(shader, GR_GL_COMPILE_STATUS, &compiled));
 
     if (!compiled) {
         GrGLint infoLen = GR_GL_INIT_ZERO;
         GR_GL_CALL(gli, GetShaderiv(shader, GR_GL_INFO_LOG_LENGTH, &infoLen));
         SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
         if (infoLen > 0) {
             // retrieve length even though we don't need it to workaround bug in chrome cmd buffer
             // param validation.
             GrGLsizei length = GR_GL_INIT_ZERO;
             GR_GL_CALL(gli, GetShaderInfoLog(shader, infoLen+1,
                                              &length, (char*)log.get()));
             print_shader(stringCnt, strings, stringLengths);
             GrPrintf("\n%s", log.get());
         }
         SkDEBUGFAIL("Shader compilation failed!");
         GR_GL_CALL(gli, DeleteShader(shader));
         return 0;
     }
     return shader;
 }
 
 // helper version of above for when shader is already flattened into a single SkString
-GrGLuint compile_shader(const GrGLContext& gl, GrGLenum type, const SkString& shader) {
+GrGLuint compile_shader(const GrGLInterface* gli, GrGLenum type, const SkString& shader) {
     const GrGLchar* str = shader.c_str();
     int length = shader.size();
-    return compile_shader(gl, type, 1, &str, &length);
+    return compile_shader(gli, type, 1, &str, &length);
 }
 
 void expand_known_value4f(SkString* string, GrSLConstantVec vec) {
     SkASSERT(string->isEmpty() == (vec != kNone_GrSLConstantVec));
     switch (vec) {
         case kNone_GrSLConstantVec:
             break;
         case kZeros_GrSLConstantVec:
             *string = GrGLSLZerosVecf(4);
             break;
@@ skipping 12 matching lines @@
     SkASSERT(!fGShaderID);
     SkASSERT(!fFShaderID);
 
     SkString shader;
     if (GrGLShaderBuilder::VertexBuilder* vertexBuilder = builder.getVertexBuilder()) {
         vertexBuilder->vsGetShader(&shader);
         if (c_PrintShaders) {
             GrPrintf(shader.c_str());
             GrPrintf("\n");
         }
-        if (!(fVShaderID = compile_shader(fContext, GR_GL_VERTEX_SHADER, shader))) {
+        if (!(fVShaderID = compile_shader(fGpu->glInterface(), GR_GL_VERTEX_SHADER, shader))) {
             return false;
         }
 
 #if GR_GL_EXPERIMENTAL_GS
         if (fDesc.getHeader().fExperimentalGS) {
             vertexBuilder->gsGetShader(&shader);
             if (c_PrintShaders) {
                 GrPrintf(shader.c_str());
                 GrPrintf("\n");
             }
-            if (!(fGShaderID = compile_shader(fContext, GR_GL_GEOMETRY_SHADER, shader))) {
+            if (!(fGShaderID = compile_shader(fGpu->glInterface(), GR_GL_GEOMETRY_SHADER, shader))) {
                 return false;
             }
         }
 #endif
     }
 
     builder.fsGetShader(&shader);
     if (c_PrintShaders) {
         GrPrintf(shader.c_str());
         GrPrintf("\n");
     }
-    if (!(fFShaderID = compile_shader(fContext, GR_GL_FRAGMENT_SHADER, shader))) {
+    if (!(fFShaderID = compile_shader(fGpu->glInterface(), GR_GL_FRAGMENT_SHADER, shader))) {
         return false;
     }
 
     return true;
 }
 
 bool GrGLProgram::genProgram(const GrEffectStage* colorStages[],
                              const GrEffectStage* coverageStages[]) {
     SkASSERT(0 == fProgramID);
 
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
 
     bool needsVertexShader = true;
 
-    GrGLShaderBuilder builder(fContext.info(), fUniformManager, fDesc, needsVertexShader);
+    GrGLShaderBuilder builder(fGpu->ctxInfo(), fUniformManager, fDesc, needsVertexShader);
 
     if (GrGLShaderBuilder::VertexBuilder* vertexBuilder = builder.getVertexBuilder()) {
         const char* viewMName;
         fUniformHandles.fViewMatrixUni = builder.addUniform(GrGLShaderBuilder::kVertex_Visibility,
                                                             kMat33f_GrSLType, "ViewM", &viewMName);
 
         vertexBuilder->vsCodeAppendf("\tvec3 pos3 = %s * vec3(%s, 1);\n"
                                      "\tgl_Position = vec4(pos3.xy, 0, pos3.z);\n",
                                      viewMName, vertexBuilder->positionAttribute().c_str());
 
         // we output point size in the GS if present
         if (header.fEmitsPointSize
 #if GR_GL_EXPERIMENTAL_GS
             && !header.fExperimentalGS
 #endif
             ) {
             vertexBuilder->vsCodeAppend("\tgl_PointSize = 1.0;\n");
         }
     }
 
     // the dual source output has no canonical var name, have to
     // declare an output, which is incompatible with gl_FragColor/gl_FragData.
     bool dualSourceOutputWritten = false;
 
     GrGLShaderVar colorOutput;
-    bool isColorDeclared = GrGLSLSetupFSColorOuput(fContext.info().glslGeneration(),
+    bool isColorDeclared = GrGLSLSetupFSColorOuput(fGpu->glslGeneration(),
                                                    declared_color_output_name(),
                                                    &colorOutput);
     if (isColorDeclared) {
         builder.fsOutputAppend(colorOutput);
     }
 
     // incoming color to current stage being processed.
     SkString inColor;
     GrSLConstantVec knownColorValue = this->genInputColor(&builder, &inColor);
 
@@ skipping 300 matching lines @@
         UniformHandle handle = effect->fSamplerUnis[s];
         if (handle.isValid()) {
             fUniformManager.setSampler(handle, *texUnitIdx);
             effect->fTextureUnits[s] = (*texUnitIdx)++;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void GrGLProgram::setEffectData(GrGpuGL* gpu,
-                                const GrEffectStage& stage,
+void GrGLProgram::setEffectData(const GrEffectStage& stage,
                                 const EffectAndSamplers& effect) {
 
     // Let the GrGLEffect set its data.
     bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
     GrDrawEffect drawEffect(stage, explicitLocalCoords);
     effect.fGLEffect->setData(fUniformManager, drawEffect);
 
     // Bind the texures for the effect.
     int numSamplers = effect.fSamplerUnis.count();
     SkASSERT((*stage.getEffect())->numTextures() == numSamplers);
     for (int s = 0; s < numSamplers; ++s) {
         UniformHandle handle = effect.fSamplerUnis[s];
         if (handle.isValid()) {
             const GrTextureAccess& access = (*stage.getEffect())->textureAccess(s);
             GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
             int unit = effect.fTextureUnits[s];
-            gpu->bindTexture(unit, access.getParams(), texture);
+            fGpu->bindTexture(unit, access.getParams(), texture);
         }
     }
 }
 
-void GrGLProgram::setData(GrGpuGL* gpu,
-                          GrDrawState::BlendOptFlags blendOpts,
+void GrGLProgram::setData(GrDrawState::BlendOptFlags blendOpts,
                           const GrEffectStage* colorStages[],
                           const GrEffectStage* coverageStages[],
                           const GrDeviceCoordTexture* dstCopy,
                           SharedGLState* sharedState) {
-    const GrDrawState& drawState = gpu->getDrawState();
+    const GrDrawState& drawState = fGpu->getDrawState();
 
     GrColor color;
     GrColor coverage;
     if (blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag) {
         color = 0;
         coverage = 0;
     } else if (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) {
         color = 0xffffffff;
         coverage = drawState.getCoverage();
     } else {
@@ skipping 17 matching lines @@
     if (NULL != dstCopy) {
         if (fUniformHandles.fDstCopyTopLeftUni.isValid()) {
             fUniformManager.set2f(fUniformHandles.fDstCopyTopLeftUni,
                                   static_cast<GrGLfloat>(dstCopy->offset().fX),
                                   static_cast<GrGLfloat>(dstCopy->offset().fY));
             fUniformManager.set2f(fUniformHandles.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.
-            gpu->bindTexture(fDstCopyTexUnit, kParams, texture);
+            fGpu->bindTexture(fDstCopyTexUnit, kParams, texture);
         } else {
             SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
             SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
         }
     } else {
         SkASSERT(!fUniformHandles.fDstCopyTopLeftUni.isValid());
         SkASSERT(!fUniformHandles.fDstCopyScaleUni.isValid());
         SkASSERT(!fUniformHandles.fDstCopySamplerUni.isValid());
     }
 
     for (int e = 0; e < fColorEffects.count(); ++e) {
         // We may have omitted the GrGLEffect because of the color filter logic in genProgram.
         // This can be removed when the color filter is an effect.
         if (NULL != fColorEffects[e].fGLEffect) {
-            this->setEffectData(gpu, *colorStages[e], fColorEffects[e]);
+            this->setEffectData(*colorStages[e], fColorEffects[e]);
         }
     }
 
     for (int e = 0; e < fCoverageEffects.count(); ++e) {
         if (NULL != fCoverageEffects[e].fGLEffect) {
-            this->setEffectData(gpu, *coverageStages[e], fCoverageEffects[e]);
+            this->setEffectData(*coverageStages[e], fCoverageEffects[e]);
         }
     }
 }
 
 void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
     const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
     if (!drawState.hasColorVertexAttribute()) {
         switch (header.fColorInput) {
@@ skipping 109 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }