Make all GrFragmentProcessors GL independent.

src/gpu/GrFragmentProcessor.cpp

 
 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrFragmentProcessor.h"
 #include "GrCoordTransform.h"
-#include "gl/GrGLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 
 GrFragmentProcessor::~GrFragmentProcessor() {
     // If we got here then our ref count must have reached zero, so we will have converted refs
     // to pending executions for all children.
     for (int i = 0; i < fChildProcessors.count(); ++i) {
@@ skipping 21 matching lines @@
         return false;
     }
     for (int i = 0; i < this->numChildProcessors(); ++i) {
         if (!this->childProcessor(i).isEqual(that.childProcessor(i), ignoreCoordTransforms)) {
             return false;
         }
     }
     return true;
 }
 
-GrGLFragmentProcessor* GrFragmentProcessor::createGLInstance() const {
-    GrGLFragmentProcessor* glFragProc = this->onCreateGLInstance();
+GrGLSLFragmentProcessor* GrFragmentProcessor::createGLInstance() const {
+    GrGLSLFragmentProcessor* glFragProc = this->onCreateGLInstance();
     glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
     for (int i = 0; i < fChildProcessors.count(); ++i) {
         glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLInstance();
     }
     return glFragProc;
 }
 
 void GrFragmentProcessor::addTextureAccess(const GrTextureAccess* textureAccess) {
     // Can't add texture accesses after registering any children since their texture accesses have
     // already been bubbled up into our fTextureAccesses array
@@ skipping 75 matching lines @@
     class PremulFragmentProcessor : public GrFragmentProcessor {
     public:
         PremulFragmentProcessor(const GrFragmentProcessor* processor) {
             this->initClassID<PremulFragmentProcessor>();
             this->registerChildProcessor(processor);
         }
 
         const char* name() const override { return "Premultiply"; }
 
     private:
-        GrGLFragmentProcessor* onCreateGLInstance() const override {
-            class GLFP : public GrGLFragmentProcessor {
+        GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+            class GLFP : public GrGLSLFragmentProcessor {
             public:
                 GLFP() {}
 
                 void emitCode(EmitArgs& args) override {
                     GrGLSLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
                     this->emitChild(0, nullptr, args);
                     fsBuilder->codeAppendf("%s.rgb *= %s.rgb;", args.fOutputColor,
                                                                 args.fInputColor);
                     fsBuilder->codeAppendf("%s *= %s.a;", args.fOutputColor, args.fInputColor);
                 }
@@ skipping 51 matching lines @@
     class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
     public:
         ReplaceInputFragmentProcessor(const GrFragmentProcessor* child, GrColor color)
             : fColor(color) {
             this->initClassID<ReplaceInputFragmentProcessor>();
             this->registerChildProcessor(child);
         }
 
         const char* name() const override { return "Replace Color"; }
 
-        GrGLFragmentProcessor* onCreateGLInstance() const override {
-            class GLFP : public GrGLFragmentProcessor {
+        GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+            class GLFP : public GrGLSLFragmentProcessor {
             public:
                 GLFP() : fHaveSetColor(false) {}
                 void emitCode(EmitArgs& args) override {
                     const char* colorName;
                     fColorUni = args.fBuilder->addUniform(GrGLSLProgramBuilder::kFragment_Visibility,
                                                           kVec4f_GrSLType, kDefault_GrSLPrecision,
                                                           "Color", &colorName);
                     this->emitChild(0, colorName, args);
                 }
 
@@ skipping 55 matching lines @@
         SeriesFragmentProcessor(const GrFragmentProcessor* children[], int cnt){
             SkASSERT(cnt > 1);
             this->initClassID<SeriesFragmentProcessor>();
             for (int i = 0; i < cnt; ++i) {
                 this->registerChildProcessor(children[i]);
             }
         }
 
         const char* name() const override { return "Series"; }
 
-        GrGLFragmentProcessor* onCreateGLInstance() const override {
-            class GLFP : public GrGLFragmentProcessor {
+        GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+            class GLFP : public GrGLSLFragmentProcessor {
             public:
                 GLFP() {}
                 void emitCode(EmitArgs& args) override {
                     SkString input(args.fInputColor);
                     for (int i = 0; i < this->numChildProcessors() - 1; ++i) {
                         SkString temp;
                         temp.printf("out%d", i);
                         this->emitChild(i, input.c_str(), &temp, args);
                         input = temp;
                     }
@@ skipping 56 matching lines @@
         }
     }
 
     if (1 == cnt) {
         return SkRef(series[0]);
     } else {
         return new SeriesFragmentProcessor(series, cnt);
     }
 }