src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp - Issue 582963002: Solo gp

Unified Diff: src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

Issue 582963002: Solo gp (Closed) Base URL: https://skia.googlesource.com/skia.git@no_peb

Patch Set: fix Created 6 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« include/gpu/GrTypesPriv.h ('K') | « src/effects/gradients/SkTwoPointConicalGradient_gpu.h ('k') | src/effects/gradients/SkTwoPointRadialGradient.h » ('j') | src/gpu/gl/GrGLProcessor.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

index 720dc6345d5014cf3da0a4c9d66bfd386fbd14d0..cce4e7f0afcf4b0a05a0307bfe5cde25c2f26f7e 100644

--- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

+++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp

@@ -11,7 +11,7 @@

#include "SkTwoPointConicalGradient.h"

#if SK_SUPPORT_GPU

-#include "GrTBackendEffectFactory.h"

+#include "GrTBackendProcessorFactory.h"

#include "gl/builders/GrGLProgramBuilder.h"

// For brevity

typedef GrGLProgramDataManager::UniformHandle UniformHandle;

@@ -60,27 +60,27 @@ class GLEdge2PtConicalEffect;

class Edge2PtConicalEffect : public GrGradientEffect {

public:

- static GrEffect* Create(GrContext* ctx,

- const SkTwoPointConicalGradient& shader,

- const SkMatrix& matrix,

- SkShader::TileMode tm) {

+ static GrFragmentProcessor* Create(GrContext* ctx,

+ const SkTwoPointConicalGradient& shader,

+ const SkMatrix& matrix,

+ SkShader::TileMode tm) {

return SkNEW_ARGS(Edge2PtConicalEffect, (ctx, shader, matrix, tm));

}

virtual ~Edge2PtConicalEffect() {}

static const char* Name() { return "Two-Point Conical Gradient Edge Touching"; }

- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;

+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_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; }

- typedef GLEdge2PtConicalEffect GLEffect;

+ typedef GLEdge2PtConicalEffect GLProcessor;

private:

- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {

+ virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {

const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();

return (INHERITED::onIsEqual(sBase) &&

this->fCenterX1 == s.fCenterX1 &&

@@ -116,7 +116,7 @@ private:

this->addCoordTransform(&fBTransform);

}

- GR_DECLARE_EFFECT_TEST;

+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;

// @{

// Cache of values - these can change arbitrarily, EXCEPT

@@ -134,19 +134,19 @@ private:

class GLEdge2PtConicalEffect : public GrGLGradientEffect {

public:

- GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);

+ GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);

virtual ~GLEdge2PtConicalEffect() { }

virtual void emitCode(GrGLProgramBuilder*,

- const GrEffect&,

- const GrEffectKey&,

+ const GrFragmentProcessor&,

+ const GrProcessorKey&,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray&,

const TextureSamplerArray&) SK_OVERRIDE;

- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;

- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);

+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);

protected:

UniformHandle fParamUni;

@@ -167,16 +167,16 @@ private:

};

-const GrBackendEffectFactory& Edge2PtConicalEffect::getFactory() const {

- return GrTBackendEffectFactory<Edge2PtConicalEffect>::getInstance();

+const GrBackendFragmentProcessorFactory& Edge2PtConicalEffect::getFactory() const {

+ return GrTBackendFragmentProcessorFactory<Edge2PtConicalEffect>::getInstance();

}

-GR_DEFINE_EFFECT_TEST(Edge2PtConicalEffect);

+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);

-GrEffect* Edge2PtConicalEffect::TestCreate(SkRandom* random,

- GrContext* context,

- const GrDrawTargetCaps&,

- GrTexture**) {

+GrFragmentProcessor* Edge2PtConicalEffect::TestCreate(SkRandom* random,

+ GrContext* context,

+ const GrDrawTargetCaps&,

+ GrTexture**) {

SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};

SkScalar radius1 = random->nextUScalar1();

SkPoint center2;

@@ -203,14 +203,14 @@ GrEffect* Edge2PtConicalEffect::TestCreate(SkRandom* random,

colors, stops, colorCount,

tm));

SkPaint paint;

- GrEffect* effect;

+ GrFragmentProcessor* fp;

GrColor paintColor;

- SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));

- return effect;

+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));

+ return fp;

}

-GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory,

- const GrEffect& effect)

+GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory,

+ const GrProcessor&)

: INHERITED(factory)

, fVSVaryingName(NULL)

, fFSVaryingName(NULL)

@@ -218,8 +218,8 @@ GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& fac

, fCachedDiffRadius(-SK_ScalarMax) {}

void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

- const GrEffect&,

- const GrEffectKey& key,

+ const GrFragmentProcessor&,

+ const GrProcessorKey& key,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray& coords,

@@ -276,9 +276,9 @@ void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

}

void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,

- const GrEffect& effect) {

- INHERITED::setData(pdman, effect);

- const Edge2PtConicalEffect& data = effect.cast<Edge2PtConicalEffect>();

+ const GrProcessor& processor) {

+ INHERITED::setData(pdman, processor);

+ const Edge2PtConicalEffect& data = processor.cast<Edge2PtConicalEffect>();

SkScalar radius0 = data.radius();

SkScalar diffRadius = data.diffRadius();

@@ -297,9 +297,9 @@ void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,

}

-void GLEdge2PtConicalEffect::GenKey(const GrEffect& effect,

- const GrGLCaps&, GrEffectKeyBuilder* b) {

- b->add32(GenBaseGradientKey(effect));

+void GLEdge2PtConicalEffect::GenKey(const GrProcessor& processor,

+ const GrGLCaps&, GrProcessorKeyBuilder* b) {

+ b->add32(GenBaseGradientKey(processor));

}

//////////////////////////////////////////////////////////////////////////////

@@ -369,26 +369,26 @@ class GLFocalOutside2PtConicalEffect;

class FocalOutside2PtConicalEffect : public GrGradientEffect {

public:

- static GrEffect* Create(GrContext* ctx,

- const SkTwoPointConicalGradient& shader,

- const SkMatrix& matrix,

- SkShader::TileMode tm,

- SkScalar focalX) {

+ static GrFragmentProcessor* Create(GrContext* ctx,

+ const SkTwoPointConicalGradient& shader,

+ const SkMatrix& matrix,

+ SkShader::TileMode tm,

+ SkScalar focalX) {

return SkNEW_ARGS(FocalOutside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));

}

virtual ~FocalOutside2PtConicalEffect() { }

static const char* Name() { return "Two-Point Conical Gradient Focal Outside"; }

- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;

+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;

bool isFlipped() const { return fIsFlipped; }

SkScalar focal() const { return fFocalX; }

- typedef GLFocalOutside2PtConicalEffect GLEffect;

+ typedef GLFocalOutside2PtConicalEffect GLProcessor;

private:

- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {

+ virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {

const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();

return (INHERITED::onIsEqual(sBase) &&

this->fFocalX == s.fFocalX &&

@@ -402,7 +402,7 @@ private:

SkScalar focalX)

: INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isFlippedGrad()) {}

- GR_DECLARE_EFFECT_TEST;

+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;

SkScalar fFocalX;

bool fIsFlipped;

@@ -412,19 +412,19 @@ private:

class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {

public:

- GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);

+ GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);

virtual ~GLFocalOutside2PtConicalEffect() { }

virtual void emitCode(GrGLProgramBuilder*,

- const GrEffect&,

- const GrEffectKey&,

+ const GrFragmentProcessor&,

+ const GrProcessorKey&,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray&,

const TextureSamplerArray&) SK_OVERRIDE;

- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;

- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);

+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);

protected:

UniformHandle fParamUni;

@@ -446,16 +446,16 @@ private:

};

-const GrBackendEffectFactory& FocalOutside2PtConicalEffect::getFactory() const {

- return GrTBackendEffectFactory<FocalOutside2PtConicalEffect>::getInstance();

+const GrBackendFragmentProcessorFactory& FocalOutside2PtConicalEffect::getFactory() const {

+ return GrTBackendFragmentProcessorFactory<FocalOutside2PtConicalEffect>::getInstance();

}

-GR_DEFINE_EFFECT_TEST(FocalOutside2PtConicalEffect);

+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);

-GrEffect* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,

- GrContext* context,

- const GrDrawTargetCaps&,

- GrTexture**) {

+GrFragmentProcessor* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,

+ GrContext* context,

+ const GrDrawTargetCaps&,

+ GrTexture**) {

SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};

SkScalar radius1 = 0.f;

SkPoint center2;

@@ -479,25 +479,25 @@ GrEffect* FocalOutside2PtConicalEffect::TestCreate(SkRandom* random,

colors, stops, colorCount,

tm));

SkPaint paint;

- GrEffect* effect;

+ GrFragmentProcessor* effect;

GrColor paintColor;

- SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));

+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &effect));

return effect;

}

-GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory,

- const GrEffect& effect)

+GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,

+ const GrProcessor& processor)

: INHERITED(factory)

, fVSVaryingName(NULL)

, fFSVaryingName(NULL)

, fCachedFocal(SK_ScalarMax) {

- const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConicalEffect>();

+ const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();

fIsFlipped = data.isFlipped();

}

void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

- const GrEffect&,

- const GrEffectKey& key,

+ const GrFragmentProcessor&,

+ const GrProcessorKey& key,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray& coords,

@@ -545,9 +545,9 @@ void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

}

void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,

- const GrEffect& effect) {

- INHERITED::setData(pdman, effect);

- const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConicalEffect>();

+ const GrProcessor& processor) {

+ INHERITED::setData(pdman, processor);

+ const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();

SkASSERT(data.isFlipped() == fIsFlipped);

SkScalar focal = data.focal();

@@ -564,11 +564,11 @@ void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman

}

-void GLFocalOutside2PtConicalEffect::GenKey(const GrEffect& effect,

- const GrGLCaps&, GrEffectKeyBuilder* b) {

+void GLFocalOutside2PtConicalEffect::GenKey(const GrProcessor& processor,

+ const GrGLCaps&, GrProcessorKeyBuilder* b) {

uint32_t* key = b->add32n(2);

- key[0] = GenBaseGradientKey(effect);

- key[1] = effect.cast<FocalOutside2PtConicalEffect>().isFlipped();

+ key[0] = GenBaseGradientKey(processor);

+ key[1] = processor.cast<FocalOutside2PtConicalEffect>().isFlipped();

}

//////////////////////////////////////////////////////////////////////////////

@@ -578,25 +578,25 @@ class GLFocalInside2PtConicalEffect;

class FocalInside2PtConicalEffect : public GrGradientEffect {

public:

- static GrEffect* Create(GrContext* ctx,

- const SkTwoPointConicalGradient& shader,

- const SkMatrix& matrix,

- SkShader::TileMode tm,

- SkScalar focalX) {

+ static GrFragmentProcessor* Create(GrContext* ctx,

+ const SkTwoPointConicalGradient& shader,

+ const SkMatrix& matrix,

+ SkShader::TileMode tm,

+ SkScalar focalX) {

return SkNEW_ARGS(FocalInside2PtConicalEffect, (ctx, shader, matrix, tm, focalX));

}

virtual ~FocalInside2PtConicalEffect() {}

static const char* Name() { return "Two-Point Conical Gradient Focal Inside"; }

- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;

+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;

SkScalar focal() const { return fFocalX; }

- typedef GLFocalInside2PtConicalEffect GLEffect;

+ typedef GLFocalInside2PtConicalEffect GLProcessor;

private:

- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {

+ virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {

const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();

return (INHERITED::onIsEqual(sBase) &&

this->fFocalX == s.fFocalX);

@@ -609,7 +609,7 @@ private:

SkScalar focalX)

: INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {}

- GR_DECLARE_EFFECT_TEST;

+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;

SkScalar fFocalX;

@@ -618,19 +618,19 @@ private:

class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {

public:

- GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);

+ GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);

virtual ~GLFocalInside2PtConicalEffect() {}

virtual void emitCode(GrGLProgramBuilder*,

- const GrEffect&,

- const GrEffectKey&,

+ const GrFragmentProcessor&,

+ const GrProcessorKey&,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray&,

const TextureSamplerArray&) SK_OVERRIDE;

- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;

- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);

+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);

protected:

UniformHandle fFocalUni;

@@ -650,16 +650,16 @@ private:

};

-const GrBackendEffectFactory& FocalInside2PtConicalEffect::getFactory() const {

- return GrTBackendEffectFactory<FocalInside2PtConicalEffect>::getInstance();

+const GrBackendFragmentProcessorFactory& FocalInside2PtConicalEffect::getFactory() const {

+ return GrTBackendFragmentProcessorFactory<FocalInside2PtConicalEffect>::getInstance();

}

-GR_DEFINE_EFFECT_TEST(FocalInside2PtConicalEffect);

+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);

-GrEffect* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,

- GrContext* context,

- const GrDrawTargetCaps&,

- GrTexture**) {

+GrFragmentProcessor* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,

+ GrContext* context,

+ const GrDrawTargetCaps&,

+ GrTexture**) {

SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};

SkScalar radius1 = 0.f;

SkPoint center2;

@@ -686,21 +686,21 @@ GrEffect* FocalInside2PtConicalEffect::TestCreate(SkRandom* random,

tm));

SkPaint paint;

GrColor paintColor;

- GrEffect* effect;

- SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));

- return effect;

+ GrFragmentProcessor* fp;

+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &fp));

+ return fp;

}

-GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory,

- const GrEffect& effect)

+GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory,

+ const GrProcessor&)

: INHERITED(factory)

, fVSVaryingName(NULL)

, fFSVaryingName(NULL)

, fCachedFocal(SK_ScalarMax) {}

void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

- const GrEffect&,

- const GrEffectKey& key,

+ const GrFragmentProcessor&,

+ const GrProcessorKey& key,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray& coords,

@@ -728,9 +728,9 @@ void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

}

void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,

- const GrEffect& effect) {

- INHERITED::setData(pdman, effect);

- const FocalInside2PtConicalEffect& data = effect.cast<FocalInside2PtConicalEffect>();

+ const GrProcessor& processor) {

+ INHERITED::setData(pdman, processor);

+ const FocalInside2PtConicalEffect& data = processor.cast<FocalInside2PtConicalEffect>();

SkScalar focal = data.focal();

if (fCachedFocal != focal) {

@@ -739,9 +739,9 @@ void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,

}

-void GLFocalInside2PtConicalEffect::GenKey(const GrEffect& effect,

- const GrGLCaps&, GrEffectKeyBuilder* b) {

- b->add32(GenBaseGradientKey(effect));

+void GLFocalInside2PtConicalEffect::GenKey(const GrProcessor& processor,

+ const GrGLCaps&, GrProcessorKeyBuilder* b) {

+ b->add32(GenBaseGradientKey(processor));

}

//////////////////////////////////////////////////////////////////////////////

@@ -813,18 +813,18 @@ class GLCircleInside2PtConicalEffect;

class CircleInside2PtConicalEffect : public GrGradientEffect {

public:

- static GrEffect* Create(GrContext* ctx,

- const SkTwoPointConicalGradient& shader,

- const SkMatrix& matrix,

- SkShader::TileMode tm,

- const CircleConicalInfo& info) {

+ static GrFragmentProcessor* Create(GrContext* ctx,

+ const SkTwoPointConicalGradient& shader,

+ const SkMatrix& matrix,

+ SkShader::TileMode tm,

+ const CircleConicalInfo& info) {

return SkNEW_ARGS(CircleInside2PtConicalEffect, (ctx, shader, matrix, tm, info));

}

virtual ~CircleInside2PtConicalEffect() {}

static const char* Name() { return "Two-Point Conical Gradient Inside"; }

- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;

+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;

SkScalar centerX() const { return fInfo.fCenterEnd.fX; }

SkScalar centerY() const { return fInfo.fCenterEnd.fY; }

@@ -832,10 +832,10 @@ public:

SkScalar B() const { return fInfo.fB; }

SkScalar C() const { return fInfo.fC; }

- typedef GLCircleInside2PtConicalEffect GLEffect;

+ typedef GLCircleInside2PtConicalEffect GLProcessor;

private:

- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {

+ virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {

const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();

return (INHERITED::onIsEqual(sBase) &&

this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&

@@ -851,7 +851,7 @@ private:

const CircleConicalInfo& info)

: INHERITED(ctx, shader, matrix, tm), fInfo(info) {}

- GR_DECLARE_EFFECT_TEST;

+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;

const CircleConicalInfo fInfo;

@@ -860,19 +860,19 @@ private:

class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {

public:

- GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);

+ GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);

virtual ~GLCircleInside2PtConicalEffect() {}

virtual void emitCode(GrGLProgramBuilder*,

- const GrEffect&,

- const GrEffectKey&,

+ const GrFragmentProcessor&,

+ const GrProcessorKey&,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray&,

const TextureSamplerArray&) SK_OVERRIDE;

- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;

- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);

+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);

protected:

UniformHandle fCenterUni;

@@ -897,16 +897,16 @@ private:

};

-const GrBackendEffectFactory& CircleInside2PtConicalEffect::getFactory() const {

- return GrTBackendEffectFactory<CircleInside2PtConicalEffect>::getInstance();

+const GrBackendFragmentProcessorFactory& CircleInside2PtConicalEffect::getFactory() const {

+ return GrTBackendFragmentProcessorFactory<CircleInside2PtConicalEffect>::getInstance();

}

-GR_DEFINE_EFFECT_TEST(CircleInside2PtConicalEffect);

+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);

-GrEffect* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,

- GrContext* context,

- const GrDrawTargetCaps&,

- GrTexture**) {

+GrFragmentProcessor* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,

+ GrContext* context,

+ const GrDrawTargetCaps&,

+ GrTexture**) {

SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};

SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0

SkPoint center2;

@@ -932,13 +932,13 @@ GrEffect* CircleInside2PtConicalEffect::TestCreate(SkRandom* random,

tm));

SkPaint paint;

GrColor paintColor;

- GrEffect* effect;

- SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));

- return effect;

+ GrFragmentProcessor* processor;

+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));

+ return processor;

}

-GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory,

- const GrEffect& effect)

+GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory,

+ const GrProcessor& processor)

: INHERITED(factory)

, fVSVaryingName(NULL)

, fFSVaryingName(NULL)

@@ -949,8 +949,8 @@ GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEf

, fCachedC(SK_ScalarMax) {}

void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

- const GrEffect&,

- const GrEffectKey& key,

+ const GrFragmentProcessor&,

+ const GrProcessorKey& key,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray& coords,

@@ -992,9 +992,9 @@ void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

}

void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,

- const GrEffect& effect) {

- INHERITED::setData(pdman, effect);

- const CircleInside2PtConicalEffect& data = effect.cast<CircleInside2PtConicalEffect>();

+ const GrProcessor& processor) {

+ INHERITED::setData(pdman, processor);

+ const CircleInside2PtConicalEffect& data = processor.cast<CircleInside2PtConicalEffect>();

SkScalar centerX = data.centerX();

SkScalar centerY = data.centerY();

SkScalar A = data.A();

@@ -1015,9 +1015,9 @@ void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman

}

-void GLCircleInside2PtConicalEffect::GenKey(const GrEffect& effect,

- const GrGLCaps&, GrEffectKeyBuilder* b) {

- b->add32(GenBaseGradientKey(effect));

+void GLCircleInside2PtConicalEffect::GenKey(const GrProcessor& processor,

+ const GrGLCaps&, GrProcessorKeyBuilder* b) {

+ b->add32(GenBaseGradientKey(processor));

}

//////////////////////////////////////////////////////////////////////////////

@@ -1027,18 +1027,18 @@ class GLCircleOutside2PtConicalEffect;

class CircleOutside2PtConicalEffect : public GrGradientEffect {

public:

- static GrEffect* Create(GrContext* ctx,

- const SkTwoPointConicalGradient& shader,

- const SkMatrix& matrix,

- SkShader::TileMode tm,

- const CircleConicalInfo& info) {

+ static GrFragmentProcessor* Create(GrContext* ctx,

+ const SkTwoPointConicalGradient& shader,

+ const SkMatrix& matrix,

+ SkShader::TileMode tm,

+ const CircleConicalInfo& info) {

return SkNEW_ARGS(CircleOutside2PtConicalEffect, (ctx, shader, matrix, tm, info));

}

virtual ~CircleOutside2PtConicalEffect() {}

static const char* Name() { return "Two-Point Conical Gradient Outside"; }

- virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;

+ virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;

SkScalar centerX() const { return fInfo.fCenterEnd.fX; }

SkScalar centerY() const { return fInfo.fCenterEnd.fY; }

@@ -1048,10 +1048,10 @@ public:

SkScalar tLimit() const { return fTLimit; }

bool isFlipped() const { return fIsFlipped; }

- typedef GLCircleOutside2PtConicalEffect GLEffect;

+ typedef GLCircleOutside2PtConicalEffect GLProcessor;

private:

- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {

+ virtual bool onIsEqual(const GrProcessor& sBase) const SK_OVERRIDE {

const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();

return (INHERITED::onIsEqual(sBase) &&

this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&

@@ -1078,7 +1078,7 @@ private:

fIsFlipped = shader.isFlippedGrad();

}

- GR_DECLARE_EFFECT_TEST;

+ GR_DECLARE_FRAGMENT_PROCESSOR_TEST;

const CircleConicalInfo fInfo;

SkScalar fTLimit;

@@ -1089,19 +1089,19 @@ private:

class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {

public:

- GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);

+ GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory&, const GrProcessor&);

virtual ~GLCircleOutside2PtConicalEffect() {}

virtual void emitCode(GrGLProgramBuilder*,

- const GrEffect&,

- const GrEffectKey&,

+ const GrFragmentProcessor&,

+ const GrProcessorKey&,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray&,

const TextureSamplerArray&) SK_OVERRIDE;

- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;

+ virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;

- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);

+ static void GenKey(const GrProcessor&, const GrGLCaps& caps, GrProcessorKeyBuilder* b);

protected:

UniformHandle fCenterUni;

@@ -1129,16 +1129,16 @@ private:

};

-const GrBackendEffectFactory& CircleOutside2PtConicalEffect::getFactory() const {

- return GrTBackendEffectFactory<CircleOutside2PtConicalEffect>::getInstance();

+const GrBackendFragmentProcessorFactory& CircleOutside2PtConicalEffect::getFactory() const {

+ return GrTBackendFragmentProcessorFactory<CircleOutside2PtConicalEffect>::getInstance();

}

-GR_DEFINE_EFFECT_TEST(CircleOutside2PtConicalEffect);

+GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);

-GrEffect* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,

- GrContext* context,

- const GrDrawTargetCaps&,

- GrTexture**) {

+GrFragmentProcessor* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,

+ GrContext* context,

+ const GrDrawTargetCaps&,

+ GrTexture**) {

SkPoint center1 = {random->nextUScalar1(), random->nextUScalar1()};

SkScalar radius1 = random->nextUScalar1() + 0.0001f; // make sure radius1 != 0

SkPoint center2;

@@ -1165,13 +1165,13 @@ GrEffect* CircleOutside2PtConicalEffect::TestCreate(SkRandom* random,

tm));

SkPaint paint;

GrColor paintColor;

- GrEffect* effect;

- SkAssertResult(shader->asNewEffect(context, paint, NULL, &paintColor, &effect));

- return effect;

+ GrFragmentProcessor* processor;

+ SkAssertResult(shader->asFragmentProcessor(context, paint, NULL, &paintColor, &processor));

+ return processor;

}

-GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory,

- const GrEffect& effect)

+GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,

+ const GrProcessor& processor)

: INHERITED(factory)

, fVSVaryingName(NULL)

, fFSVaryingName(NULL)

@@ -1181,13 +1181,13 @@ GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackend

, fCachedB(SK_ScalarMax)

, fCachedC(SK_ScalarMax)

, fCachedTLimit(SK_ScalarMax) {

- const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConicalEffect>();

+ const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();

fIsFlipped = data.isFlipped();

}

void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

- const GrEffect&,

- const GrEffectKey& key,

+ const GrFragmentProcessor&,

+ const GrProcessorKey& key,

const char* outputColor,

const char* inputColor,

const TransformedCoordsArray& coords,

@@ -1245,9 +1245,9 @@ void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,

}

void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,

- const GrEffect& effect) {

- INHERITED::setData(pdman, effect);

- const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConicalEffect>();

+ const GrProcessor& processor) {

+ INHERITED::setData(pdman, processor);

+ const CircleOutside2PtConicalEffect& data = processor.cast<CircleOutside2PtConicalEffect>();

SkASSERT(data.isFlipped() == fIsFlipped);

SkScalar centerX = data.centerX();

SkScalar centerY = data.centerY();

@@ -1272,19 +1272,19 @@ void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdma

}

-void GLCircleOutside2PtConicalEffect::GenKey(const GrEffect& effect,

- const GrGLCaps&, GrEffectKeyBuilder* b) {

+void GLCircleOutside2PtConicalEffect::GenKey(const GrProcessor& processor,

+ const GrGLCaps&, GrProcessorKeyBuilder* b) {

uint32_t* key = b->add32n(2);

- key[0] = GenBaseGradientKey(effect);

- key[1] = effect.cast<CircleOutside2PtConicalEffect>().isFlipped();

+ key[0] = GenBaseGradientKey(processor);

+ key[1] = processor.cast<CircleOutside2PtConicalEffect>().isFlipped();

}

//////////////////////////////////////////////////////////////////////////////

-GrEffect* Gr2PtConicalGradientEffect::Create(GrContext* ctx,

- const SkTwoPointConicalGradient& shader,

- SkShader::TileMode tm,

- const SkMatrix* localMatrix) {

+GrFragmentProcessor* Gr2PtConicalGradientEffect::Create(GrContext* ctx,

+ const SkTwoPointConicalGradient& shader,

+ SkShader::TileMode tm,

+ const SkMatrix* localMatrix) {

SkMatrix matrix;

if (!shader.getLocalMatrix().invert(&matrix)) {

return NULL;

« include/gpu/GrTypesPriv.h ('K') | « src/effects/gradients/SkTwoPointConicalGradient_gpu.h ('k') | src/effects/gradients/SkTwoPointRadialGradient.h » ('j') | src/gpu/gl/GrGLProcessor.h » ('J')