Move shader compiling to ProgramBuilder and various ShaderBuilder cleanups.

src/gpu/gl/builders/GrGLShaderBuilder.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 "GrGLShaderBuilder.h"
-#include "GrGLProgramBuilder.h"
-#include "GrGLShaderStringBuilder.h"
-#include "gl/GrGLCaps.h"
-#include "gl/GrGLContext.h"
 #include "gl/GrGLGpu.h"
+#include "gl/builders/GrGLProgramBuilder.h"
 #include "glsl/GrGLSLCaps.h"
 #include "glsl/GrGLSLShaderVar.h"
 #include "glsl/GrGLSLTextureSampler.h"
 
 namespace {
 void append_texture_lookup(SkString* out,
                            GrGLGpu* gpu,
                            const char* samplerName,
                            const char* coordName,
                            uint32_t configComponentMask,
@@ skipping 92 matching lines @@
 
 void GrGLShaderBuilder::appendTextureLookupAndModulate(const char* modulation,
                                                        const GrGLSLTextureSampler& sampler,
                                                        const char* coordName,
                                                        GrSLType varyingType) {
     SkString lookup;
     this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
     this->codeAppend((GrGLSLExpr4(modulation) * GrGLSLExpr4(lookup)).c_str());
 }
 
-
-const GrGLenum* GrGLShaderBuilder::GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps) {
-    if (caps.textureSwizzleSupport() && GrPixelConfigIsAlphaOnly(config)) {
-        if (caps.textureRedSupport()) {
-            static const GrGLenum gRedSmear[] = { GR_GL_RED, GR_GL_RED, GR_GL_RED, GR_GL_RED };
-            return gRedSmear;
-        } else {
-            static const GrGLenum gAlphaSmear[] = { GR_GL_ALPHA, GR_GL_ALPHA,
-                                                    GR_GL_ALPHA, GR_GL_ALPHA };
-            return gAlphaSmear;
-        }
-    } else {
-        static const GrGLenum gStraight[] = { GR_GL_RED, GR_GL_GREEN, GR_GL_BLUE, GR_GL_ALPHA };
-        return gStraight;
-    }
-}
-
 void GrGLShaderBuilder::addFeature(uint32_t featureBit, const char* extensionName) {
     if (!(featureBit & fFeaturesAddedMask)) {
         this->extensions().appendf("#extension %s: require\n", extensionName);
         fFeaturesAddedMask |= featureBit;
     }
 }
 
 void GrGLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const {
     for (int i = 0; i < vars.count(); ++i) {
         vars[i].appendDecl(fProgramBuilder->glslCaps(), out);
         out->append(";\n");
     }
 }
 
 void GrGLShaderBuilder::appendTextureLookup(const char* samplerName,
                                             const char* coordName,
                                             uint32_t configComponentMask,
                                             const char* swizzle) {
     append_texture_lookup(&this->code(),
                           fProgramBuilder->gpu(),
                           samplerName,
                           coordName,
                           configComponentMask,
                           swizzle,
                           kVec2f_GrSLType);
 }
 
 void GrGLShaderBuilder::addLayoutQualifier(const char* param, InterfaceQualifier interface) {
-    SkASSERT(fProgramBuilder->gpu()->glslGeneration() >= k330_GrGLSLGeneration ||
-             fProgramBuilder->gpu()->glCaps().glslCaps()->mustEnableAdvBlendEqs());
+    SkASSERT(fProgramBuilder->glslCaps()->generation() >= k330_GrGLSLGeneration ||
+             fProgramBuilder->glslCaps()->mustEnableAdvBlendEqs());
     fLayoutParams[interface].push_back() = param;
 }
 
 void GrGLShaderBuilder::compileAndAppendLayoutQualifiers() {
     static const char* interfaceQualifierNames[] = {
         "out"
     };
 
     for (int interface = 0; interface <= kLastInterfaceQualifier; ++interface) {
         const SkTArray<SkString>& params = fLayoutParams[interface];
         if (params.empty()) {
             continue;
         }
         this->layoutQualifiers().appendf("layout(%s", params[0].c_str());
         for (int i = 1; i < params.count(); ++i) {
             this->layoutQualifiers().appendf(", %s", params[i].c_str());
         }
         this->layoutQualifiers().appendf(") %s;\n", interfaceQualifierNames[interface]);
     }
 
     GR_STATIC_ASSERT(0 == GrGLShaderBuilder::kOut_InterfaceQualifier);
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(interfaceQualifierNames) == kLastInterfaceQualifier + 1);
 }
 
-bool
-GrGLShaderBuilder::finalize(GrGLuint programId, GrGLenum type, SkTDArray<GrGLuint>* shaderIds) {
+void GrGLShaderBuilder::finalize(uint32_t visibility) {
     SkASSERT(!fFinalized);
+    this->versionDecl() = fProgramBuilder->glslCaps()->versionDeclString();
+    this->compileAndAppendLayoutQualifiers();
+    fProgramBuilder->appendUniformDecls((GrGLProgramBuilder::ShaderVisibility) visibility,
+                                        &this->uniforms());
+    this->appendDecls(fInputs, &this->inputs());
+    SkASSERT(k110_GrGLSLGeneration != fProgramBuilder->glslCaps()->generation() ||
+             fOutputs.empty());
+    this->appendDecls(fOutputs, &this->outputs());
+    this->onFinalize();
     // append the 'footer' to code
     this->code().append("}");
 
     for (int i = 0; i <= fCodeIndex; i++) {
         fCompilerStrings[i] = fShaderStrings[i].c_str();
         fCompilerStringLengths[i] = (int)fShaderStrings[i].size();
     }
 
-    GrGLGpu* gpu = fProgramBuilder->gpu();
-    GrGLuint shaderId = GrGLCompileAndAttachShader(gpu->glContext(),
-                                                   programId,
-                                                   type,
-                                                   fCompilerStrings.begin(),
-                                                   fCompilerStringLengths.begin(),
-                                                   fCompilerStrings.count(),
-                                                   gpu->stats());
+    fFinalized = true;
+}
 
-    fFinalized = true;
-
-    if (!shaderId) {
-        return false;
-    }
-
-    *shaderIds->append() = shaderId;
-
-    return true;
-}