Rename some processor functions from GL to GLSL

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"
@@ skipping 32 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;
 }
 
-GrGLSLFragmentProcessor* GrFragmentProcessor::createGLInstance() const {
-    GrGLSLFragmentProcessor* glFragProc = this->onCreateGLInstance();
+GrGLSLFragmentProcessor* GrFragmentProcessor::createGLSLInstance() const {
+    GrGLSLFragmentProcessor* glFragProc = this->onCreateGLSLInstance();
     glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
     for (int i = 0; i < fChildProcessors.count(); ++i) {
-        glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLInstance();
+        glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLSLInstance();
     }
     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
     SkASSERT(fChildProcessors.empty());
 
     INHERITED::addTextureAccess(textureAccess);
@@ skipping 72 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:
-        GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+        GrGLSLFragmentProcessor* onCreateGLSLInstance() 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);
                 }
             };
             return new GLFP;
         }
 
-        void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override {}
+        void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override {}
 
         bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
 
         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             // TODO: Add a helper to GrInvariantOutput that handles multiplying by color with flags?
             if (!(inout->validFlags() & kA_GrColorComponentFlag)) {
                 inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
                 return;
             }
 
@@ skipping 36 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"; }
 
-        GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+        GrGLSLFragmentProcessor* onCreateGLSLInstance() 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 18 matching lines @@
 
                 GrGLSLProgramDataManager::UniformHandle fColorUni;
                 bool    fHaveSetColor;
                 GrColor fPreviousColor;
             };
 
             return new GLFP;
         }
 
     private:
-        void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {}
+        void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override
+        {}
 
         bool onIsEqual(const GrFragmentProcessor& that) const override {
             return fColor == that.cast<ReplaceInputFragmentProcessor>().fColor;
         }
 
         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             inout->setToOther(kRGBA_GrColorComponentFlags, fColor,
                               GrInvariantOutput::kWillNot_ReadInput);
             this->childProcessor(0).computeInvariantOutput(inout);
         }
@@ skipping 17 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"; }
 
-        GrGLSLFragmentProcessor* onCreateGLInstance() const override {
+        GrGLSLFragmentProcessor* onCreateGLSLInstance() 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;
                     }
                     // Last guy writes to our output variable.
                     this->emitChild(this->numChildProcessors() - 1, input.c_str(), args);
                 }
             };
             return new GLFP;
         }
 
     private:
-        void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override {}
+        void onGetGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override {}
 
         bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
 
         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             GrProcOptInfo info;
             SkTDArray<const GrFragmentProcessor*> children;
             children.setCount(this->numChildProcessors());
             for (int i = 0; i < children.count(); ++i) {
                 children[i] = &this->childProcessor(i);
             }
@@ skipping 37 matching lines @@
         }
     }
 
     if (1 == cnt) {
         return SkRef(series[0]);
     } else {
         return new SeriesFragmentProcessor(series, cnt);
     }
 }