Multi-string shaders

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 "GrGLProgramBuilder.h"
+#include "GrGLShaderStringBuilder.h"
 #include "../GrGLGpu.h"
 #include "../GrGLShaderVar.h"
 
 namespace {
 inline const char* sample_function_name(GrSLType type, GrGLSLGeneration glslGen) {
     if (kVec2f_GrSLType == type) {
         return glslGen >= k130_GrGLSLGeneration ? "texture" : "texture2D";
     } else {
         SkASSERT(kVec3f_GrSLType == type);
         return glslGen >= k130_GrGLSLGeneration ? "textureProj" : "texture2DProj";
@@ skipping 31 matching lines @@
     if (memcmp(swizzle, "rgba", 4)) {
         out->appendf(".%s", swizzle);
     }
 }
 }
 
 GrGLShaderBuilder::GrGLShaderBuilder(GrGLProgramBuilder* program)
     : fProgramBuilder(program)
     , fInputs(GrGLProgramBuilder::kVarsPerBlock)
     , fOutputs(GrGLProgramBuilder::kVarsPerBlock)
-    , fFeaturesAddedMask(0) {
+    , fFeaturesAddedMask(0)
+    , fCodeIndex(kCode)
+    , fFinalized(false) {
+    // We push back some dummy pointers which will later become our header
+    for (int i = 0; i <= kCode; i++) {
+        fShaderStrings.push_back();
+        fCompilerStrings.push_back(NULL);
+        fCompilerStringLengths.push_back(0);
+    }
+
+    this->main() = "void main() {";
 }
 
 void GrGLShaderBuilder::declAppend(const GrGLShaderVar& var) {
     SkString tempDecl;
     var.appendDecl(fProgramBuilder->ctxInfo(), &tempDecl);
     this->codeAppendf("%s;", tempDecl.c_str());
 }
 
 void GrGLShaderBuilder::emitFunction(GrSLType returnType,
                                      const char* name,
                                      int argCnt,
                                      const GrGLShaderVar* args,
                                      const char* body,
                                      SkString* outName) {
-    fFunctions.append(GrGLSLTypeString(returnType));
+    this->functions().append(GrGLSLTypeString(returnType));
     fProgramBuilder->nameVariable(outName, '\0', name);
-    fFunctions.appendf(" %s", outName->c_str());
-    fFunctions.append("(");
+    this->functions().appendf(" %s", outName->c_str());
+    this->functions().append("(");
     const GrGLContextInfo& ctxInfo = fProgramBuilder->gpu()->ctxInfo();
     for (int i = 0; i < argCnt; ++i) {
-        args[i].appendDecl(ctxInfo, &fFunctions);
+        args[i].appendDecl(ctxInfo, &this->functions());
         if (i < argCnt - 1) {
-            fFunctions.append(", ");
+            this->functions().append(", ");
         }
     }
-    fFunctions.append(") {\n");
-    fFunctions.append(body);
-    fFunctions.append("}\n\n");
+    this->functions().append(") {\n");
+    this->functions().append(body);
+    this->functions().append("}\n\n");
 }
 
 void GrGLShaderBuilder::appendTextureLookup(SkString* out,
                                             const TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) const {
     append_texture_lookup(out,
                           fProgramBuilder->gpu(),
                           fProgramBuilder->getUniformCStr(sampler.fSamplerUniform),
                           coordName,
                           sampler.configComponentMask(),
                           sampler.swizzle(),
                           varyingType);
 }
 
 void GrGLShaderBuilder::appendTextureLookup(const TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) {
-    this->appendTextureLookup(&fCode, sampler, coordName, varyingType);
+    this->appendTextureLookup(&this->code(), sampler, coordName, varyingType);
 }
 
 void GrGLShaderBuilder::appendTextureLookupAndModulate(const char* modulation,
                                                        const TextureSampler& sampler,
                                                        const char* coordName,
                                                        GrSLType varyingType) {
     SkString lookup;
     this->appendTextureLookup(&lookup, sampler, coordName, varyingType);
     this->codeAppend((GrGLSLExpr4(modulation) * GrGLSLExpr4(lookup)).c_str());
 }
@@ skipping 10 matching lines @@
             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)) {
-        fExtensions.appendf("#extension %s: require\n", extensionName);
-            fFeaturesAddedMask |= featureBit;
+        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->ctxInfo(), out);
         out->append(";\n");
     }
 }
 
 void GrGLShaderBuilder::appendTextureLookup(const char* samplerName,
                                             const char* coordName,
                                             uint32_t configComponentMask,
                                             const char* swizzle) {
-    append_texture_lookup(&fCode,
+    append_texture_lookup(&this->code(),
                           fProgramBuilder->gpu(),
                           samplerName,
                           coordName,
                           configComponentMask,
                           swizzle,
                           kVec2f_GrSLType);
 }
+
+bool
+GrGLShaderBuilder::finalize(GrGLuint programId, GrGLenum type, SkTDArray<GrGLuint>* shaderIds) {
+    SkASSERT(!fFinalized);
+    // 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;
+
+    if (!shaderId) {
+        return false;
+    }
+
+    *shaderIds->append() = shaderId;
+
+    return true;
+}