rename GrShaderDataManager -> GrProcessorDataManager

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 41 matching lines @@
         rot.setSinCos(-SkScalarMul(invDiffLen, diff.fY),
                        SkScalarMul(invDiffLen, diff.fX));
         invLMatrix->postConcat(rot);
     }
 }
 
 class Edge2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
-                                       GrShaderDataManager* shaderDataManager,
+                                       GrProcessorDataManager* procDataManager,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm) {
-        return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shaderDataManager, shader, matrix, tm));
+        return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm));
     }
 
     virtual ~Edge2PtConicalEffect() {}
 
     const char* name() const override {
         return "Two-Point Conical Gradient Edge Touching";
     }
 
     void getGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     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:
     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);
     }
 
     Edge2PtConicalEffect(GrContext* ctx,
-                         GrShaderDataManager* shaderDataManager,
+                         GrProcessorDataManager* procDataManager,
                          const SkTwoPointConicalGradient& shader,
                          const SkMatrix& matrix,
                          SkShader::TileMode tm)
-        : INHERITED(ctx, shaderDataManager, shader, matrix, tm),
+        : INHERITED(ctx, procDataManager, shader, matrix, tm),
         fCenterX1(shader.getCenterX1()),
         fRadius0(shader.getStartRadius()),
         fDiffRadius(shader.getDiffRadius()){
         this->initClassID<Edge2PtConicalEffect>();
         // We should only be calling this shader if we are degenerate case with touching circles
         // When deciding if we are in edge case, we scaled by the end radius for cases when the
         // start radius was close to zero, otherwise we scaled by the start radius.  In addition
         // Our test for the edge case in set_matrix_circle_conical has a higher tolerance so we
         // need the sqrt value below
         SkASSERT(SkScalarAbs(SkScalarAbs(fDiffRadius) - fCenterX1) <
@@ skipping 102 matching lines @@
     int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrFragmentProcessor* fp;
     GrColor paintColor;
     SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
                                                GrTest::TestMatrix(d->fRandom), NULL,
-                                               &paintColor, d->fShaderDataManager, &fp));
+                                               &paintColor, d->fProcDataManager, &fp));
     return fp;
 }
 
 GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrProcessor&)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedRadius(-SK_ScalarMax)
     , fCachedDiffRadius(-SK_ScalarMax) {}
 
 void GLEdge2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
@@ skipping 140 matching lines @@
 
     return conicalType;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class FocalOutside2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
-                                       GrShaderDataManager* shaderDataManager,
+                                       GrProcessorDataManager* procDataManager,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        SkScalar focalX) {
-        return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shaderDataManager, shader, matrix, tm,
+        return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm,
                                                          focalX));
     }
 
     virtual ~FocalOutside2PtConicalEffect() { }
 
     const char* name() const override {
         return "Two-Point Conical Gradient Focal Outside";
     }
 
     void getGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     GrGLFragmentProcessor* createGLInstance() const override;
 
     bool isFlipped() const { return fIsFlipped; }
     SkScalar focal() const { return fFocalX; }
 
 private:
     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,
-                                 GrShaderDataManager* shaderDataManager,
+                                 GrProcessorDataManager* procDataManager,
                                  const SkTwoPointConicalGradient& shader,
                                  const SkMatrix& matrix,
                                  SkShader::TileMode tm,
                                  SkScalar focalX)
-    : INHERITED(ctx, shaderDataManager, shader, matrix, tm)
+    : INHERITED(ctx, procDataManager, shader, matrix, tm)
     , fFocalX(focalX)
     , fIsFlipped(shader.isFlippedGrad()) {
         this->initClassID<FocalOutside2PtConicalEffect>();
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
     bool             fIsFlipped;
 
@@ skipping 71 matching lines @@
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrFragmentProcessor* effect;
     GrColor paintColor;
     GrPaint grPaint;
     SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
                                                GrTest::TestMatrix(d->fRandom), NULL,
-                                               &paintColor, d->fShaderDataManager,
+                                               &paintColor, d->fProcDataManager,
                                                &effect));
     return effect;
 }
 
 GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrProcessor& processor)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {
     const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
     fIsFlipped = data.isFlipped();
@@ skipping 76 matching lines @@
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLFocalInside2PtConicalEffect;
 
 class FocalInside2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
-                                       GrShaderDataManager* shaderDataManager,
+                                       GrProcessorDataManager* procDataManager,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        SkScalar focalX) {
-        return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shaderDataManager, shader, matrix, tm,
+        return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm,
                                                         focalX));
     }
 
     virtual ~FocalInside2PtConicalEffect() {}
 
     const char* name() const override {
         return "Two-Point Conical Gradient Focal Inside";
     }
 
     void getGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     GrGLFragmentProcessor* createGLInstance() const override;
 
     SkScalar focal() const { return fFocalX; }
 
     typedef GLFocalInside2PtConicalEffect GLProcessor;
 
 private:
     bool onIsEqual(const GrFragmentProcessor& sBase) const override {
         const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();
         return (INHERITED::onIsEqual(sBase) &&
                 this->fFocalX == s.fFocalX);
     }
 
     FocalInside2PtConicalEffect(GrContext* ctx,
-                                GrShaderDataManager* shaderDataManager,
+                                GrProcessorDataManager* procDataManager,
                                 const SkTwoPointConicalGradient& shader,
                                 const SkMatrix& matrix,
                                 SkShader::TileMode tm,
                                 SkScalar focalX)
-        : INHERITED(ctx, shaderDataManager, shader, matrix, tm), fFocalX(focalX) {
+        : INHERITED(ctx, procDataManager, shader, matrix, tm), fFocalX(focalX) {
         this->initClassID<FocalInside2PtConicalEffect>();
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     SkScalar         fFocalX;
 
     typedef GrGradientEffect INHERITED;
 };
 
@@ skipping 67 matching lines @@
     int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
     GrFragmentProcessor* fp;
     SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
                                                GrTest::TestMatrix(d->fRandom), NULL,
-                                               &paintColor, d->fShaderDataManager, &fp));
+                                               &paintColor, d->fProcDataManager, &fp));
     return fp;
 }
 
 GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrProcessor&)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedFocal(SK_ScalarMax) {}
 
 void GLFocalInside2PtConicalEffect::emitCode(GrGLFPBuilder* builder,
                                              const GrFragmentProcessor& fp,
@@ skipping 102 matching lines @@
     if (A < 0.f) {
         return kInside_ConicalType;
     }
     return kOutside_ConicalType;
 }
 
 class CircleInside2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
-                                       GrShaderDataManager* shaderDataManager,
+                                       GrProcessorDataManager* procDataManager,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        const CircleConicalInfo& info) {
-        return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shaderDataManager, shader, matrix, tm,
+        return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, procDataManager, shader, matrix, tm,
                                                          info));
     }
 
     virtual ~CircleInside2PtConicalEffect() {}
 
     const char* name() const override { return "Two-Point Conical Gradient Inside"; }
 
     virtual void getGLProcessorKey(const GrGLSLCaps& caps,
                                    GrProcessorKeyBuilder* b) const override;
 
     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:
     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);
     }
 
     CircleInside2PtConicalEffect(GrContext* ctx,
-                                 GrShaderDataManager* shaderDataManager,
+                                 GrProcessorDataManager* procDataManager,
                                  const SkTwoPointConicalGradient& shader,
                                  const SkMatrix& matrix,
                                  SkShader::TileMode tm,
                                  const CircleConicalInfo& info)
-        : INHERITED(ctx, shaderDataManager, shader, matrix, tm), fInfo(info) {
+        : INHERITED(ctx, procDataManager, shader, matrix, tm), fInfo(info) {
         this->initClassID<CircleInside2PtConicalEffect>();
     }
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     const CircleConicalInfo fInfo;
 
     typedef GrGradientEffect INHERITED;
 };
 
@@ skipping 72 matching lines @@
     int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
     GrFragmentProcessor* fp;
     SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
                                                GrTest::TestMatrix(d->fRandom), NULL,
-                                               &paintColor, d->fShaderDataManager, &fp));
+                                               &paintColor, d->fProcDataManager, &fp));
     return fp;
 }
 
 GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrProcessor& processor)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
@@ skipping 71 matching lines @@
                                             const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     b->add32(GenBaseGradientKey(processor));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class CircleOutside2PtConicalEffect : public GrGradientEffect {
 public:
 
     static GrFragmentProcessor* Create(GrContext* ctx,
-                                       GrShaderDataManager* shaderDataManager,
+                                       GrProcessorDataManager* procDataManager,
                                        const SkTwoPointConicalGradient& shader,
                                        const SkMatrix& matrix,
                                        SkShader::TileMode tm,
                                        const CircleConicalInfo& info) {
-        return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shaderDataManager, shader, matrix,
+        return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, procDataManager, shader, matrix,
                                                           tm, info));
     }
 
     virtual ~CircleOutside2PtConicalEffect() {}
 
     const char* name() const override { return "Two-Point Conical Gradient Outside"; }
 
     void getGLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder*) const override;
 
     GrGLFragmentProcessor* createGLInstance() const override;
@@ skipping 12 matching lines @@
         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 &&
                 this->fIsFlipped == s.fIsFlipped);
     }
 
     CircleOutside2PtConicalEffect(GrContext* ctx,
-                                  GrShaderDataManager* shaderDataManager,
+                                  GrProcessorDataManager* procDataManager,
                                   const SkTwoPointConicalGradient& shader,
                                   const SkMatrix& matrix,
                                   SkShader::TileMode tm,
                                   const CircleConicalInfo& info)
-        : INHERITED(ctx, shaderDataManager, shader, matrix, tm), fInfo(info) {
+        : INHERITED(ctx, procDataManager, shader, matrix, tm), fInfo(info) {
         this->initClassID<CircleOutside2PtConicalEffect>();
         if (shader.getStartRadius() != shader.getEndRadius()) {
             fTLimit = shader.getStartRadius() / (shader.getStartRadius() - shader.getEndRadius());
         } else {
             fTLimit = SK_ScalarMin;
         }
 
         fIsFlipped = shader.isFlippedGrad();
     }
 
@@ skipping 84 matching lines @@
     int colorCount = RandomGradientParams(d->fRandom, colors, &stops, &tm);
     SkAutoTUnref<SkShader> shader(SkGradientShader::CreateTwoPointConical(center1, radius1,
                                                                           center2, radius2,
                                                                           colors, stops, colorCount,
                                                                           tm));
     SkPaint paint;
     GrColor paintColor;
     GrFragmentProcessor* fp;
     SkAssertResult(shader->asFragmentProcessor(d->fContext, paint,
                                                GrTest::TestMatrix(d->fRandom), NULL,
-                                               &paintColor, d->fShaderDataManager, &fp));
+                                               &paintColor, d->fProcDataManager, &fp));
     return fp;
 }
 
 GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrProcessor& processor)
     : fVSVaryingName(NULL)
     , fFSVaryingName(NULL)
     , fCachedCenterX(SK_ScalarMax)
     , fCachedCenterY(SK_ScalarMax)
     , fCachedA(SK_ScalarMax)
     , fCachedB(SK_ScalarMax)
@@ skipping 94 matching lines @@
 void GLCircleOutside2PtConicalEffect::GenKey(const GrProcessor& processor,
                                              const GrGLSLCaps&, GrProcessorKeyBuilder* b) {
     uint32_t* key = b->add32n(2);
     key[0] = GenBaseGradientKey(processor);
     key[1] = processor.cast<CircleOutside2PtConicalEffect>().isFlipped();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrFragmentProcessor* Gr2PtConicalGradientEffect::Create(GrContext* ctx,
-                                                        GrShaderDataManager* shaderDataManager,
+                                                        GrProcessorDataManager* procDataManager,
                                                         const SkTwoPointConicalGradient& shader,
                                                         SkShader::TileMode tm,
                                                         const SkMatrix* localMatrix) {
     SkMatrix matrix;
     if (!shader.getLocalMatrix().invert(&matrix)) {
         return NULL;
     }
     if (localMatrix) {
         SkMatrix inv;
         if (!localMatrix->invert(&inv)) {
             return NULL;
         }
         matrix.postConcat(inv);
     }
 
     if (shader.getStartRadius() < kErrorTol) {
         SkScalar focalX;
         ConicalType type = set_matrix_focal_conical(shader, &matrix, &focalX);
         if (type == kInside_ConicalType) {
-            return FocalInside2PtConicalEffect::Create(ctx, shaderDataManager, shader, matrix, tm,
+            return FocalInside2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm,
                                                        focalX);
         } else if(type == kEdge_ConicalType) {
             set_matrix_edge_conical(shader, &matrix);
-            return Edge2PtConicalEffect::Create(ctx, shaderDataManager, shader, matrix, tm);
+            return Edge2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm);
         } else {
-            return FocalOutside2PtConicalEffect::Create(ctx, shaderDataManager, shader, matrix, tm,
+            return FocalOutside2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm,
                                                         focalX);
         }
     }
 
     CircleConicalInfo info;
     ConicalType type = set_matrix_circle_conical(shader, &matrix, &info);
 
     if (type == kInside_ConicalType) {
-        return CircleInside2PtConicalEffect::Create(ctx, shaderDataManager,  shader, matrix, tm,
+        return CircleInside2PtConicalEffect::Create(ctx, procDataManager,  shader, matrix, tm,
                                                     info);
     } else if (type == kEdge_ConicalType) {
         set_matrix_edge_conical(shader, &matrix);
-        return Edge2PtConicalEffect::Create(ctx, shaderDataManager, shader, matrix, tm);
+        return Edge2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm);
     } else {
-        return CircleOutside2PtConicalEffect::Create(ctx, shaderDataManager, shader, matrix, tm,
+        return CircleOutside2PtConicalEffect::Create(ctx, procDataManager, shader, matrix, tm,
                                                      info);
     }
 }
 
 #endif