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

src/effects/gradients/SkTwoPointConicalGradient_gpu.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 "SkTwoPointConicalGradient_gpu.h"
 
@@ skipping 54 matching lines @@
                                        SkShader::TileMode tm) {
         return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm));
     }
 
     virtual ~Edge2PtConicalEffect() {}
 
     const char* name() const override {
         return "Two-Point Conical Gradient Edge Touching";
     }
 
-    GrGLFragmentProcessor* createGLInstance() const override;
-
     // The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
     SkScalar center() const { return fCenterX1; }
     SkScalar diffRadius() const { return fDiffRadius; }
     SkScalar radius() const { return fRadius0; }
 
 private:
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
+
     void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fCenterX1 == s.fCenterX1 &&
                 this->fRadius0 == s.fRadius0 &&
                 this->fDiffRadius == s.fDiffRadius);
     }
 
@@ skipping 45 matching lines @@
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLEdge2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLEdge2PtConicalEffect(const GrProcessor&);
     virtual ~GLEdge2PtConicalEffect() { }
 
     virtual void emitCode(EmitArgs&) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedRadius;
     SkScalar fCachedDiffRadius;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 void Edge2PtConicalEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                              GrProcessorKeyBuilder* b) const {
     GLEdge2PtConicalEffect::GenKey(*this, caps, b);
 }
 
-GrGLFragmentProcessor* Edge2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* Edge2PtConicalEffect::onCreateGLInstance() const {
     return SkNEW_ARGS(GLEdge2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
@@ skipping 83 matching lines @@
 
     // if r(t) > 0, then t will be the x coordinate
     fsBuilder->codeAppendf("\tif (%s * %s + %s > 0.0) {\n", tName.c_str(),
                            p2.c_str(), p0.c_str());
     fsBuilder->codeAppend("\t");
     this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
                     args.fSamplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
-void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLEdge2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
                                      const GrProcessor& processor) {
-    INHERITED::setData(pdman, processor);
+    INHERITED::onSetData(pdman, processor);
     const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();
     SkScalar radius0 = data.radius();
     SkScalar diffRadius = data.diffRadius();
 
     if (fCachedRadius != radius0 ||
         fCachedDiffRadius != diffRadius) {
 
         float values[3] = {
             SkScalarToFloat(radius0),
             SkScalarToFloat(SkScalarMul(radius0, radius0)),
@@ skipping 85 matching lines @@
         return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm,
                                                          focalX));
     }
 
     virtual ~FocalOutside2PtConicalEffect() { }
 
     const char* name() const override {
         return "Two-Point Conical Gradient Focal Outside";
     }
 
-    GrGLFragmentProcessor* createGLInstance() const override;
-
     bool isFlipped() const { return fIsFlipped; }
     SkScalar focal() const { return fFocalX; }
 
 private:
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
+
     void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fFocalX == s.fFocalX &&
                 this->fIsFlipped == s.fIsFlipped);
     }
 
     FocalOutside2PtConicalEffect(GrContext* ctx,
@@ skipping 15 matching lines @@
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLFocalOutside2PtConicalEffect(const GrProcessor&);
     virtual ~GLFocalOutside2PtConicalEffect() { }
 
     virtual void emitCode(EmitArgs&) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsFlipped;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 void FocalOutside2PtConicalEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                                      GrProcessorKeyBuilder* b) const {
     GLFocalOutside2PtConicalEffect::GenKey(*this, caps, b);
 }
 
-GrGLFragmentProcessor* FocalOutside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* FocalOutside2PtConicalEffect::onCreateGLInstance() const {
     return SkNEW_ARGS(GLFocalOutside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
@@ skipping 75 matching lines @@
                                coords2D, p0.c_str());
     }
 
     fsBuilder->codeAppendf("\tif (%s >= 0.0 && d >= 0.0) {\n", tName.c_str());
     fsBuilder->codeAppend("\t\t");
     this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
                     args.fSamplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
-void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLFocalOutside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
                                              const GrProcessor& processor) {
-    INHERITED::setData(pdman, processor);
+    INHERITED::onSetData(pdman, processor);
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         SkScalar oneMinus2F = 1.f - SkScalarMul(focal, focal);
 
         float values[2] = {
             SkScalarToFloat(focal),
             SkScalarToFloat(oneMinus2F),
@@ skipping 27 matching lines @@
         return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm,
                                                         focalX));
     }
 
     virtual ~FocalInside2PtConicalEffect() {}
 
     const char* name() const override {
         return "Two-Point Conical Gradient Focal Inside";
     }
 
-    GrGLFragmentProcessor* createGLInstance() const override;
-
     SkScalar focal() const { return fFocalX; }
 
     typedef GLFocalInside2PtConicalEffect GLProcessor;
 
 private:
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
+
     void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fFocalX == s.fFocalX);
     }
 
     FocalInside2PtConicalEffect(GrContext* ctx,
                                 GrProcessorDataManager* procDataManager,
@@ skipping 11 matching lines @@
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLFocalInside2PtConicalEffect(const GrProcessor&);
     virtual ~GLFocalInside2PtConicalEffect() {}
 
     virtual void emitCode(EmitArgs&) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
     UniformHandle fFocalUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedFocal;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 void FocalInside2PtConicalEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                GrProcessorKeyBuilder* b) const {
     GLFocalInside2PtConicalEffect::GenKey(*this, caps, b);
 }
 
-GrGLFragmentProcessor* FocalInside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* FocalInside2PtConicalEffect::onCreateGLInstance() const {
     return SkNEW_ARGS(GLFocalInside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
@@ skipping 52 matching lines @@
     const char* coords2D = coords2DString.c_str();
 
     // t = p.x * focalX + length(p)
     fsBuilder->codeAppendf("\tfloat %s = %s.x * %s  + length(%s);\n", tName.c_str(),
                            coords2D, focal.c_str(), coords2D);
 
     this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
                     args.fSamplers);
 }
 
-void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLFocalInside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
                                             const GrProcessor& processor) {
-    INHERITED::setData(pdman, processor);
+    INHERITED::onSetData(pdman, processor);
     const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();
     SkScalar focal = data.focal();
 
     if (fCachedFocal != focal) {
         pdman.set1f(fFocalUni, SkScalarToFloat(focal));
         fCachedFocal = focal;
     }
 }
 
 void GLFocalInside2PtConicalEffect::GenKey(const GrProcessor& processor,
@@ skipping 75 matching lines @@
                                        SkShader::TileMode tm,
                                        const CircleConicalInfo& info) {
         return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm,
                                                          info));
     }
 
     virtual ~CircleInside2PtConicalEffect() {}
 
     const char* name() const override { return "Two-Point Conical Gradient Inside"; }
 
-    GrGLFragmentProcessor* createGLInstance() const override;
-
     SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
     SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
     SkScalar A() const { return fInfo.fA; }
     SkScalar B() const { return fInfo.fB; }
     SkScalar C() const { return fInfo.fC; }
 
 private:
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
+
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const override;
 
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
                 this->fInfo.fA == s.fInfo.fA &&
                 this->fInfo.fB == s.fInfo.fB &&
                 this->fInfo.fC == s.fInfo.fC);
@@ skipping 15 matching lines @@
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLCircleInside2PtConicalEffect(const GrProcessor&);
     virtual ~GLCircleInside2PtConicalEffect() {}
 
     virtual void emitCode(EmitArgs&) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     // @{
     /// Values last uploaded as uniforms
 
     SkScalar fCachedCenterX;
     SkScalar fCachedCenterY;
     SkScalar fCachedA;
     SkScalar fCachedB;
     SkScalar fCachedC;
 
     // @}
 
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 void CircleInside2PtConicalEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                                      GrProcessorKeyBuilder* b) const {
     GLCircleInside2PtConicalEffect::GenKey(*this, caps, b);
 }
 
-GrGLFragmentProcessor* CircleInside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* CircleInside2PtConicalEffect::onCreateGLInstance() const {
     return SkNEW_ARGS(GLCircleInside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor*
 CircleInside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
@@ skipping 71 matching lines @@
     fsBuilder->codeAppendf("\tfloat pDotp = dot(%s,  %s);\n", coords2D, coords2D);
     fsBuilder->codeAppendf("\tfloat d = dot(%s,  %s) + %s.y;\n", coords2D, center.c_str(),
                            params.c_str());
     fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
                            tName.c_str(), params.c_str(), params.c_str());
 
     this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
                     args.fSamplers);
 }
 
-void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLCircleInside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
                                              const GrProcessor& processor) {
-    INHERITED::setData(pdman, processor);
+    INHERITED::onSetData(pdman, processor);
     const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
     SkScalar A = data.A();
     SkScalar B = data.B();
     SkScalar C = data.C();
 
     if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
         fCachedA != A || fCachedB != B || fCachedC != C) {
 
@@ skipping 25 matching lines @@
                                        SkShader::TileMode tm,
                                        const CircleConicalInfo& info) {
         return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, procDataManager, shader, matrix,
                                                           tm, info));
     }
 
     virtual ~CircleOutside2PtConicalEffect() {}
 
     const char* name() const override { return "Two-Point Conical Gradient Outside"; }
 
-    GrGLFragmentProcessor* createGLInstance() const override;
-
     SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
     SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
     SkScalar A() const { return fInfo.fA; }
     SkScalar B() const { return fInfo.fB; }
     SkScalar C() const { return fInfo.fC; }
     SkScalar tLimit() const { return fTLimit; }
     bool isFlipped() const { return fIsFlipped; }
 
 private:
+    GrGLFragmentProcessor* onCreateGLInstance() const override;
+
     void onGetGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
                 this->fInfo.fA == s.fInfo.fA &&
                 this->fInfo.fB == s.fInfo.fB &&
                 this->fInfo.fC == s.fInfo.fC &&
                 this->fTLimit == s.fTLimit &&
@@ skipping 25 matching lines @@
 
     typedef GrGradientEffect INHERITED;
 };
 
 class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
 public:
     GLCircleOutside2PtConicalEffect(const GrProcessor&);
     virtual ~GLCircleOutside2PtConicalEffect() {}
 
     virtual void emitCode(EmitArgs&) override;
-    void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
     static void GenKey(const GrProcessor&, const GrGLSLCaps& caps, GrProcessorKeyBuilder* b);
 
 protected:
+    void onSetData(const GrGLProgramDataManager&, const GrProcessor&) override;
+
     UniformHandle fCenterUni;
     UniformHandle fParamUni;
 
     const char* fVSVaryingName;
     const char* fFSVaryingName;
 
     bool fIsFlipped;
 
     // @{
     /// Values last uploaded as uniforms
@@ skipping 10 matching lines @@
 private:
     typedef GrGLGradientEffect INHERITED;
 
 };
 
 void CircleOutside2PtConicalEffect::onGetGLProcessorKey(const GrGLSLCaps& caps,
                                                       GrProcessorKeyBuilder* b) const {
     GLCircleOutside2PtConicalEffect::GenKey(*this, caps, b);
 }
 
-GrGLFragmentProcessor* CircleOutside2PtConicalEffect::createGLInstance() const {
+GrGLFragmentProcessor* CircleOutside2PtConicalEffect::onCreateGLInstance() const {
     return SkNEW_ARGS(GLCircleOutside2PtConicalEffect, (*this));
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);
 
 /*
  * All Two point conical gradient test create functions may occasionally create edge case shaders
  */
 GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(GrProcessorTestData* d) {
     SkPoint center1 = {d->fRandom->nextUScalar1(), d->fRandom->nextUScalar1()};
@@ skipping 91 matching lines @@
         fsBuilder->codeAppendf("\tfloat %s = d - sqrt(deter);\n", tName.c_str());
     }
 
     fsBuilder->codeAppendf("\tif (%s >= %s.w && deter >= 0.0) {\n", tName.c_str(), params.c_str());
     fsBuilder->codeAppend("\t\t");
     this->emitColor(args.fBuilder, ge, tName.c_str(), args.fOutputColor, args.fInputColor,
                     args.fSamplers);
     fsBuilder->codeAppend("\t}\n");
 }
 
-void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
+void GLCircleOutside2PtConicalEffect::onSetData(const GrGLProgramDataManager& pdman,
                                               const GrProcessor& processor) {
-    INHERITED::setData(pdman, processor);
+    INHERITED::onSetData(pdman, processor);
     const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();
     SkASSERT(data.isFlipped() == fIsFlipped);
     SkScalar centerX = data.centerX();
     SkScalar centerY = data.centerY();
     SkScalar A = data.A();
     SkScalar B = data.B();
     SkScalar C = data.C();
     SkScalar tLimit = data.tLimit();
 
     if (fCachedCenterX != centerX || fCachedCenterY != centerY ||
@@ skipping 62 matching lines @@
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
         return Edge2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm);
     } else {
         return CircleOutside2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm,
                                                      info);
     }
 }
 
 #endif