Multi-string shaders

src/gpu/gl/builders/GrGLShaderBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
+#include "SkTArray.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLProgramDesc.h"
 #include "gl/GrGLProgramDataManager.h"
 
 #include <stdarg.h>
 
 class GrGLContextInfo;
 class GrGLProgramBuilder;
 
 /**
@@ skipping 45 matching lines @@
     /** If texture swizzling is available using tex parameters then it is preferred over mangling
         the generated shader code. This potentially allows greater reuse of cached shaders. */
     static const GrGLenum* GetTexParamSwizzle(GrPixelConfig config, const GrGLCaps& caps);
 
     /**
     * Called by GrGLProcessors to add code to one of the shaders.
     */
     void codeAppendf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
        va_list args;
        va_start(args, format);
-       fCode.appendVAList(format, args);
+       this->code().appendVAList(format, args);
        va_end(args);
     }
 
-    void codeAppend(const char* str) { fCode.append(str); }
+    void codeAppend(const char* str) { this->code().append(str); }
 
     void codePrependf(const char format[], ...) SK_PRINTF_LIKE(2, 3) {
        va_list args;
        va_start(args, format);
-       fCode.prependVAList(format, args);
+       this->code().prependVAList(format, args);
        va_end(args);
     }
 
     /**
      * Appends a variable declaration to one of the shaders
      */
     void declAppend(const GrGLShaderVar& var);
 
     /** Emits a helper function outside of main() in the fragment shader. */
     void emitFunction(GrSLType returnType,
@@ skipping 35 matching lines @@
     void appendTextureLookup(const char* samplerName,
                              const char* coordName,
                              uint32_t configComponentMask,
                              const char* swizzle);
 
     /*
      * A general function which enables an extension in a shader if the feature bit is not present
      */
     void addFeature(uint32_t featureBit, const char* extensionName);
 
+    void nextStage() {
+        fShaderStrings.push_back();
+        fCompilerStrings.push_back(this->code().c_str());
+        fCompilerStringLengths.push_back((int)this->code().size());
+        fCodeIndex++;
+    }
+
+    SkString& versionDecl() { return fShaderStrings[kVersionDecl]; }
+    SkString& extensions() { return fShaderStrings[kExtensions]; }
+    SkString& precisionQualifier() { return fShaderStrings[kPrecisionQualifier]; }
+    SkString& uniforms() { return fShaderStrings[kUniforms]; }
+    SkString& inputs() { return fShaderStrings[kInputs]; }
+    SkString& outputs() { return fShaderStrings[kOutputs]; }
+    SkString& functions() { return fShaderStrings[kFunctions]; }
+    SkString& main() { return fShaderStrings[kMain]; }
+    SkString& code() { return fShaderStrings[fCodeIndex]; }
+    bool finalize(GrGLuint programId, GrGLenum type, SkTDArray<GrGLuint>* shaderIds);
+
+    enum {
+        kVersionDecl,
+        kExtensions,
+        kPrecisionQualifier,
+        kUniforms,
+        kInputs,
+        kOutputs,
+        kFunctions,
+        kMain,
+        kCode,
+    };
+
     GrGLProgramBuilder* fProgramBuilder;
-
+    SkSTArray<kCode, const char*, true> fCompilerStrings;
+    SkSTArray<kCode, int, true> fCompilerStringLengths;
+    SkSTArray<kCode, SkString> fShaderStrings;
     SkString fCode;
     SkString fFunctions;
     SkString fExtensions;
 
     VarArray fInputs;
     VarArray fOutputs;
     uint32_t fFeaturesAddedMask;
+    int fCodeIndex;
+    bool fFinalized;
+
+    friend class GrGLProgramBuilder;
 };
 #endif