Added tree structure to GrGLFragmentProcessor, i.e. GL instances

src/effects/SkLightingImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 515 matching lines @@
                                                     texture,
                                                     light,
                                                     surfaceScale,
                                                     matrix,
                                                     kd,
                                                     boundaryMode));
     }
 
     const char* name() const override { return "DiffuseLighting"; }
 
-    GrGLFragmentProcessor* createGLInstance() const override;
-
     SkScalar kd() const { return fKD; }
 
 private:
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
+
     void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     GrDiffuseLightingEffect(GrProcessorDataManager*,
                             GrTexture* texture,
                             const SkLight* light,
                             SkScalar surfaceScale,
                             const SkMatrix& matrix,
                             SkScalar kd,
@@ skipping 19 matching lines @@
                                                      light,
                                                      surfaceScale,
                                                      matrix,
                                                      ks,
                                                      shininess,
                                                      boundaryMode));
     }
 
     const char* name() const override { return "SpecularLighting"; }
 
-    GrGLFragmentProcessor* createGLInstance() const override;
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
 
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 private:
     void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     GrSpecularLightingEffect(GrProcessorDataManager*,
@@ skipping 919 matching lines @@
 
 class GrGLLightingEffect  : public GrGLFragmentProcessor {
 public:
     GrGLLightingEffect(const GrProcessor&);
     virtual ~GrGLLightingEffect();
 
     void emitCode(EmitArgs&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLSLCaps&, GrProcessorKeyBuilder* b);
 
+protected:
     /**
-     * Subclasses of GrGLLightingEffect must call INHERITED::setData();
+     * Subclasses of GrGLLightingEffect must call INHERITED::onSetData();
      */
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
-protected:
     virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) = 0;
 
 private:
     typedef GrGLFragmentProcessor INHERITED;
 
     UniformHandle       fImageIncrementUni;
     UniformHandle       fSurfaceScaleUni;
     GrGLLight*          fLight;
     BoundaryMode        fBoundaryMode;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDiffuseLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLDiffuseLightingEffect(const GrProcessor&);
     void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
+protected:
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKDUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpecularLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLSpecularLightingEffect(const GrProcessor&);
     void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
+protected:
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 private:
     typedef GrGLLightingEffect INHERITED;
 
     UniformHandle   fKSUni;
     UniformHandle   fShininessUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 42 matching lines @@
     const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>();
     return INHERITED::onIsEqual(sBase) &&
             this->kd() == s.kd();
 }
 
 void GrDiffuseLightingEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                                 GrProcessorKeyBuilder* b) const {
     GrGLDiffuseLightingEffect::GenKey(*this, caps, b);
 }
 
-GrGLFragmentProcessor* GrDiffuseLightingEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrDiffuseLightingEffect::onCreateGLInstance() const {
     return SkNEW_ARGS(GrGLDiffuseLightingEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect);
 
 GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar surfaceScale = d->fRandom->nextSScalar1();
     SkScalar kd = d->fRandom->nextUScalar1();
     SkAutoTUnref<SkLight> light(create_random_light(d->fRandom));
     SkMatrix matrix;
@@ skipping 105 matching lines @@
     GrGLSLMulVarBy4f(&modulate, args.fOutputColor, args.fInputColor);
     fsBuilder->codeAppend(modulate.c_str());
 }
 
 void GrGLLightingEffect::GenKey(const GrProcessor& proc,
                                 const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) {
     const GrLightingEffect& lighting = proc.cast<GrLightingEffect>();
     b->add32(lighting.boundaryMode() << 2 | lighting.light()->type());
 }
 
-void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
                                  const GrProcessor& proc) {
     const GrLightingEffect& lighting = proc.cast<GrLightingEffect>();
     GrTexture* texture = lighting.texture(0);
     float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f;
     pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
     pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale());
     SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.filterMatrix()));
     fLight->setData(pdman, transformedLight);
 }
 
@@ skipping 20 matching lines @@
     lightBody.appendf("\tfloat colorScale = %s * dot(normal, surfaceToLight);\n", kd);
     lightBody.appendf("\treturn vec4(lightColor * clamp(colorScale, 0.0, 1.0), 1.0);\n");
     builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType,
                                                       "light",
                                                       SK_ARRAY_COUNT(gLightArgs),
                                                       gLightArgs,
                                                       lightBody.c_str(),
                                                       funcName);
 }
 
-void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLDiffuseLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
                                         const GrProcessor& proc) {
-    INHERITED::setData(pdman, proc);
+    INHERITED::onSetData(pdman, proc);
     const GrDiffuseLightingEffect& diffuse = proc.cast<GrDiffuseLightingEffect>();
     pdman.set1f(fKDUni, diffuse.kd());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrSpecularLightingEffect::GrSpecularLightingEffect(GrProcessorDataManager* procDataManager,
                                                    GrTexture* texture,
                                                    const SkLight* light,
                                                    SkScalar surfaceScale,
@@ skipping 12 matching lines @@
     return INHERITED::onIsEqual(sBase) &&
            this->ks() == s.ks() &&
            this->shininess() == s.shininess();
 }
 
 void GrSpecularLightingEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                                 GrProcessorKeyBuilder* b) const {
     GrGLSpecularLightingEffect::GenKey(*this, caps, b);
 }
 
-GrGLFragmentProcessor* GrSpecularLightingEffect::createGLInstance() const {
+GrGLFragmentProcessor* GrSpecularLightingEffect::onCreateGLInstance() const {
     return SkNEW_ARGS(GrGLSpecularLightingEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect);
 
 GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(GrProcessorTestData* d) {
     SkScalar surfaceScale = d->fRandom->nextSScalar1();
     SkScalar ks = d->fRandom->nextUScalar1();
     SkScalar shininess = d->fRandom->nextUScalar1();
     SkAutoTUnref<SkLight> light(create_random_light(d->fRandom));
@@ skipping 36 matching lines @@
     lightBody.appendf("\tvec3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n");
     lightBody.appendf("\treturn vec4(color, max(max(color.r, color.g), color.b));\n");
     builder->getFragmentShaderBuilder()->emitFunction(kVec4f_GrSLType,
                                                       "light",
                                                       SK_ARRAY_COUNT(gLightArgs),
                                                       gLightArgs,
                                                       lightBody.c_str(),
                                                       funcName);
 }
 
-void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman,
+void GrGLSpecularLightingEffect::onSetData(const GrGLProgramDataManager& pdman,
                                          const GrProcessor& effect) {
-    INHERITED::setData(pdman, effect);
+    INHERITED::onSetData(pdman, effect);
     const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>();
     pdman.set1f(fKSUni, spec.ks());
     pdman.set1f(fShininessUni, spec.shininess());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 void GrGLLight::emitLightColorUniform(GrGLFPBuilder* builder) {
     fColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                     kVec3f_GrSLType, kDefault_GrSLPrecision,
                                     "LightColor");
@@ skipping 121 matching lines @@
 
     fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END