Remove backend factories
BUG=skia:
Review URL: https://codereview.chromium.org/778453002
diff --git a/src/effects/SkAlphaThresholdFilter.cpp b/src/effects/SkAlphaThresholdFilter.cpp
index ffdba32..6f9fefc 100644
--- a/src/effects/SkAlphaThresholdFilter.cpp
+++ b/src/effects/SkAlphaThresholdFilter.cpp
@@ -47,14 +47,12 @@
#include "GrCoordTransform.h"
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
-#include "gl/GrGLProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-#include "GrTBackendProcessorFactory.h"
#include "GrTextureAccess.h"
#include "SkGr.h"
-class GrGLAlphaThresholdEffect;
+#include "gl/GrGLProcessor.h"
+#include "gl/builders/GrGLProgramBuilder.h"
class AlphaThresholdEffect : public GrFragmentProcessor {
@@ -71,13 +69,14 @@
virtual ~AlphaThresholdEffect() {};
- static const char* Name() { return "Alpha Threshold"; }
+ virtual const char* name() const SK_OVERRIDE { return "Alpha Threshold"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
float innerThreshold() const { return fInnerThreshold; }
float outerThreshold() const { return fOuterThreshold; }
- typedef GrGLAlphaThresholdEffect GLProcessor;
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
private:
AlphaThresholdEffect(GrTexture* texture,
@@ -92,6 +91,7 @@
, fMaskCoordTransform(kLocal_GrCoordSet,
GrCoordTransform::MakeDivByTextureWHMatrix(maskTexture), maskTexture)
, fMaskTextureAccess(maskTexture) {
+ this->initClassID<AlphaThresholdEffect>();
this->addCoordTransform(&fImageCoordTransform);
this->addTextureAccess(&fImageTextureAccess);
this->addCoordTransform(&fMaskCoordTransform);
@@ -116,7 +116,7 @@
class GrGLAlphaThresholdEffect : public GrGLFragmentProcessor {
public:
- GrGLAlphaThresholdEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLAlphaThresholdEffect(const GrFragmentProcessor&) {}
virtual void emitCode(GrGLFPBuilder*,
const GrFragmentProcessor&,
@@ -135,11 +135,6 @@
typedef GrGLFragmentProcessor INHERITED;
};
-GrGLAlphaThresholdEffect::GrGLAlphaThresholdEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory) {
-}
-
void GrGLAlphaThresholdEffect::emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor&,
const char* outputColor,
@@ -213,8 +208,13 @@
///////////////////////////////////////////////////////////////////////////////
-const GrBackendFragmentProcessorFactory& AlphaThresholdEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<AlphaThresholdEffect>::getInstance();
+void AlphaThresholdEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GrGLAlphaThresholdEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* AlphaThresholdEffect::createGLInstance() const {
+ return SkNEW_ARGS(GrGLAlphaThresholdEffect, (*this));
}
bool AlphaThresholdEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp
index d1e7472..240173b 100644
--- a/src/effects/SkArithmeticMode.cpp
+++ b/src/effects/SkArithmeticMode.cpp
@@ -17,7 +17,6 @@
#include "GrInvariantOutput.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
-#include "GrTBackendProcessorFactory.h"
#endif
static const bool gUseUnpremul = false;
@@ -241,7 +240,7 @@
class GrGLArithmeticEffect : public GrGLFragmentProcessor {
public:
- GrGLArithmeticEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLArithmeticEffect(const GrProcessor&);
virtual ~GrGLArithmeticEffect();
virtual void emitCode(GrGLFPBuilder*,
@@ -273,10 +272,17 @@
virtual ~GrArithmeticEffect();
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE { return "Arithmetic"; }
- typedef GrGLArithmeticEffect GLProcessor;
- static const char* Name() { return "Arithmetic"; }
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrGLArithmeticEffect::GenKey(*this, caps, b);
+ }
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GrGLArithmeticEffect, (*this));
+ }
+
GrTexture* backgroundTexture() const { return fBackgroundAccess.getTexture(); }
float k1() const { return fK1; }
@@ -307,6 +313,7 @@
GrArithmeticEffect::GrArithmeticEffect(float k1, float k2, float k3, float k4,
bool enforcePMColor, GrTexture* background)
: fK1(k1), fK2(k2), fK3(k3), fK4(k4), fEnforcePMColor(enforcePMColor) {
+ this->initClassID<GrArithmeticEffect>();
if (background) {
fBackgroundTransform.reset(kLocal_GrCoordSet, background);
this->addCoordTransform(&fBackgroundTransform);
@@ -329,10 +336,6 @@
fEnforcePMColor == s.fEnforcePMColor;
}
-const GrBackendFragmentProcessorFactory& GrArithmeticEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrArithmeticEffect>::getInstance();
-}
-
void GrArithmeticEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
// TODO: optimize this
inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
@@ -340,10 +343,8 @@
///////////////////////////////////////////////////////////////////////////////
-GrGLArithmeticEffect::GrGLArithmeticEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory),
- fEnforcePMColor(true) {
+GrGLArithmeticEffect::GrGLArithmeticEffect(const GrProcessor&)
+ : fEnforcePMColor(true) {
}
GrGLArithmeticEffect::~GrGLArithmeticEffect() {
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index b5bcc3c..728ba06 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -22,12 +22,11 @@
#include "GrTexture.h"
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
-#include "gl/GrGLProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-#include "effects/GrSimpleTextureEffect.h"
-#include "GrTBackendProcessorFactory.h"
#include "SkGrPixelRef.h"
#include "SkDraw.h"
+#include "effects/GrSimpleTextureEffect.h"
+#include "gl/GrGLProcessor.h"
+#include "gl/builders/GrGLProgramBuilder.h"
#endif
SkScalar SkBlurMaskFilter::ConvertRadiusToSigma(SkScalar radius) {
@@ -609,11 +608,13 @@
public:
virtual ~GrRectBlurEffect();
- static const char* Name() { return "RectBlur"; }
+ virtual const char* name() const SK_OVERRIDE { return "RectBlur"; }
- typedef GrGLRectBlurEffect GLProcessor;
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE;
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
/**
* Create a simple filter effect with custom bicubic coefficients.
*/
@@ -659,8 +660,7 @@
class GrGLRectBlurEffect : public GrGLFragmentProcessor {
public:
- GrGLRectBlurEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor&);
+ GrGLRectBlurEffect(const GrProcessor&) {}
virtual void emitCode(GrGLFPBuilder*,
const GrFragmentProcessor&,
const char* outputColor,
@@ -679,12 +679,6 @@
typedef GrGLFragmentProcessor INHERITED;
};
-
-
-GrGLRectBlurEffect::GrGLRectBlurEffect(const GrBackendProcessorFactory& factory, const GrProcessor&)
- : INHERITED(factory) {
-}
-
void OutputRectBlurProfileLookup(GrGLFPFragmentBuilder* fsBuilder,
const GrGLShaderBuilder::TextureSampler& sampler,
const char *output,
@@ -794,10 +788,10 @@
GrRectBlurEffect::GrRectBlurEffect(const SkRect& rect, float sigma,
GrTexture *blur_profile)
- : INHERITED(),
- fRect(rect),
+ : fRect(rect),
fSigma(sigma),
fBlurProfileAccess(blur_profile) {
+ this->initClassID<GrRectBlurEffect>();
this->addTextureAccess(&fBlurProfileAccess);
this->setWillReadFragmentPosition();
}
@@ -805,8 +799,13 @@
GrRectBlurEffect::~GrRectBlurEffect() {
}
-const GrBackendFragmentProcessorFactory& GrRectBlurEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrRectBlurEffect>::getInstance();
+void GrRectBlurEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GrGLRectBlurEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrRectBlurEffect::createGLInstance() const {
+ return SkNEW_ARGS(GrGLRectBlurEffect, (*this));
}
bool GrRectBlurEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
@@ -870,22 +869,21 @@
return true;
}
-class GrGLRRectBlurEffect;
-
class GrRRectBlurEffect : public GrFragmentProcessor {
public:
static GrFragmentProcessor* Create(GrContext* context, float sigma, const SkRRect&);
virtual ~GrRRectBlurEffect() {};
- static const char* Name() { return "GrRRectBlur"; }
+ virtual const char* name() const SK_OVERRIDE { return "GrRRectBlur"; }
const SkRRect& getRRect() const { return fRRect; }
float getSigma() const { return fSigma; }
- typedef GrGLRRectBlurEffect GLProcessor;
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE;
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
private:
GrRRectBlurEffect(float sigma, const SkRRect&, GrTexture* profileTexture);
@@ -981,14 +979,11 @@
inout->mulByUnknownAlpha();
}
-const GrBackendFragmentProcessorFactory& GrRRectBlurEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrRRectBlurEffect>::getInstance();
-}
-
GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture)
: fRRect(rrect),
fSigma(sigma),
fNinePatchAccess(ninePatchTexture) {
+ this->initClassID<GrRRectBlurEffect>();
this->addTextureAccess(&fNinePatchAccess);
this->setWillReadFragmentPosition();
}
@@ -1019,7 +1014,7 @@
class GrGLRRectBlurEffect : public GrGLFragmentProcessor {
public:
- GrGLRRectBlurEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLRRectBlurEffect(const GrProcessor&) {}
virtual void emitCode(GrGLFPBuilder*,
const GrFragmentProcessor&,
@@ -1037,11 +1032,6 @@
typedef GrGLFragmentProcessor INHERITED;
};
-GrGLRRectBlurEffect::GrGLRRectBlurEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED (factory) {
-}
-
void GrGLRRectBlurEffect::emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor&,
const char* outputColor,
@@ -1116,6 +1106,13 @@
pdman.set1f(fCornerRadiusUniform, radius);
}
+void GrRRectBlurEffect::getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const {
+ GrGLRRectBlurEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrRRectBlurEffect::createGLInstance() const {
+ return SkNEW_ARGS(GrGLRRectBlurEffect, (*this));
+}
bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context,
GrPaint* grp,
diff --git a/src/effects/SkColorCubeFilter.cpp b/src/effects/SkColorCubeFilter.cpp
index 30641c3..c26229d 100644
--- a/src/effects/SkColorCubeFilter.cpp
+++ b/src/effects/SkColorCubeFilter.cpp
@@ -15,11 +15,10 @@
#include "GrContext.h"
#include "GrCoordTransform.h"
#include "GrInvariantOutput.h"
-#include "gl/GrGLProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
-#include "GrTBackendProcessorFactory.h"
#include "GrTexturePriv.h"
#include "SkGr.h"
+#include "gl/GrGLProcessor.h"
+#include "gl/builders/GrGLProgramBuilder.h"
#endif
///////////////////////////////////////////////////////////////////////////////
@@ -193,16 +192,20 @@
virtual ~GrColorCubeEffect();
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE { return "ColorCube"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
int colorCubeSize() const { return fColorCubeAccess.getTexture()->width(); }
- static const char* Name() { return "ColorCube"; }
virtual void onComputeInvariantOutput(GrInvariantOutput*) const SK_OVERRIDE;
class GLProcessor : public GrGLFragmentProcessor {
public:
- GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&);
+ GLProcessor(const GrProcessor&);
virtual ~GLProcessor();
virtual void emitCode(GrGLFPBuilder*,
@@ -239,6 +242,7 @@
GrColorCubeEffect::GrColorCubeEffect(GrTexture* colorCube)
: fColorCubeTransform(kLocal_GrCoordSet, colorCube)
, fColorCubeAccess(colorCube, "bgra", GrTextureParams::kBilerp_FilterMode) {
+ this->initClassID<GrColorCubeEffect>();
this->addCoordTransform(&fColorCubeTransform);
this->addTextureAccess(&fColorCubeAccess);
}
@@ -246,8 +250,12 @@
GrColorCubeEffect::~GrColorCubeEffect() {
}
-const GrBackendFragmentProcessorFactory& GrColorCubeEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrColorCubeEffect>::getInstance();
+void GrColorCubeEffect::getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const {
+ GLProcessor::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrColorCubeEffect::createGLInstance() const {
+ return SkNEW_ARGS(GLProcessor, (*this));
}
void GrColorCubeEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
@@ -256,9 +264,7 @@
///////////////////////////////////////////////////////////////////////////////
-GrColorCubeEffect::GLProcessor::GLProcessor(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory) {
+GrColorCubeEffect::GLProcessor::GLProcessor(const GrProcessor&) {
}
GrColorCubeEffect::GLProcessor::~GLProcessor() {
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index 92e6f43..d8cc42c 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -115,10 +115,9 @@
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "GrProcessorUnitTest.h"
-#include "GrTBackendProcessorFactory.h"
+#include "SkGr.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
-#include "SkGr.h"
namespace {
/**
@@ -195,19 +194,23 @@
return true;
}
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<ModeColorFilterEffect>::getInstance();
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GLProcessor::GenKey(*this, caps, b);
}
- static const char* Name() { return "ModeColorFilterEffect"; }
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GLProcessor, (*this));
+ }
+
+ virtual const char* name() const SK_OVERRIDE { return "ModeColorFilterEffect"; }
SkXfermode::Mode mode() const { return fMode; }
GrColor color() const { return fColor; }
class GLProcessor : public GrGLFragmentProcessor {
public:
- GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&)
- : INHERITED(factory) {
+ GLProcessor(const GrProcessor&) {
}
virtual void emitCode(GrGLFPBuilder* builder,
@@ -263,7 +266,9 @@
private:
ModeColorFilterEffect(GrColor color, SkXfermode::Mode mode)
: fMode(mode),
- fColor(color) {}
+ fColor(color) {
+ this->initClassID<ModeColorFilterEffect>();
+ }
virtual bool onIsEqual(const GrFragmentProcessor& other) const SK_OVERRIDE {
const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>();
diff --git a/src/effects/SkColorMatrixFilter.cpp b/src/effects/SkColorMatrixFilter.cpp
index 27231b1..c497655 100644
--- a/src/effects/SkColorMatrixFilter.cpp
+++ b/src/effects/SkColorMatrixFilter.cpp
@@ -325,7 +325,6 @@
#if SK_SUPPORT_GPU
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
@@ -335,12 +334,18 @@
return SkNEW_ARGS(ColorMatrixEffect, (matrix));
}
- static const char* Name() { return "Color Matrix"; }
+ virtual const char* name() const SK_OVERRIDE { return "Color Matrix"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<ColorMatrixEffect>::getInstance();
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GLProcessor::GenKey(*this, caps, b);
}
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GLProcessor, (*this));
+ }
+
+
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
class GLProcessor : public GrGLFragmentProcessor {
@@ -348,10 +353,7 @@
// this class always generates the same code.
static void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b) {}
- GLProcessor(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory) {
- }
+ GLProcessor(const GrProcessor&) {}
virtual void emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor&,
@@ -410,7 +412,9 @@
};
private:
- ColorMatrixEffect(const SkColorMatrix& matrix) : fMatrix(matrix) {}
+ ColorMatrixEffect(const SkColorMatrix& matrix) : fMatrix(matrix) {
+ this->initClassID<ColorMatrixEffect>();
+ }
virtual bool onIsEqual(const GrFragmentProcessor& s) const {
const ColorMatrixEffect& cme = s.cast<ColorMatrixEffect>();
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index d39240e..04919ee 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -16,7 +16,6 @@
#include "GrInvariantOutput.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
-#include "GrTBackendProcessorFactory.h"
#endif
namespace {
@@ -287,8 +286,7 @@
#if SK_SUPPORT_GPU
class GrGLDisplacementMapEffect : public GrGLFragmentProcessor {
public:
- GrGLDisplacementMapEffect(const GrBackendProcessorFactory&,
- const GrProcessor&);
+ GrGLDisplacementMapEffect(const GrProcessor&);
virtual ~GrGLDisplacementMapEffect();
virtual void emitCode(GrGLFPBuilder*,
@@ -328,15 +326,22 @@
virtual ~GrDisplacementMapEffect();
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrGLDisplacementMapEffect::GenKey(*this, caps, b);
+ }
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GrGLDisplacementMapEffect, (*this));
+ }
+
SkDisplacementMapEffect::ChannelSelectorType xChannelSelector() const
{ return fXChannelSelector; }
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector() const
{ return fYChannelSelector; }
const SkVector& scale() const { return fScale; }
- typedef GrGLDisplacementMapEffect GLProcessor;
- static const char* Name() { return "DisplacementMap"; }
+ virtual const char* name() const SK_OVERRIDE { return "DisplacementMap"; }
private:
virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
@@ -456,6 +461,7 @@
, fXChannelSelector(xChannelSelector)
, fYChannelSelector(yChannelSelector)
, fScale(scale) {
+ this->initClassID<GrDisplacementMapEffect>();
this->addCoordTransform(&fDisplacementTransform);
this->addTextureAccess(&fDisplacementAccess);
this->addCoordTransform(&fColorTransform);
@@ -472,10 +478,6 @@
fScale == s.fScale;
}
-const GrBackendFragmentProcessorFactory& GrDisplacementMapEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrDisplacementMapEffect>::getInstance();
-}
-
void GrDisplacementMapEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
// Any displacement offset bringing a pixel out of bounds will output a color of (0,0,0,0),
// so the only way we'd get a constant alpha is if the input color image has a constant alpha
@@ -514,10 +516,8 @@
///////////////////////////////////////////////////////////////////////////////
-GrGLDisplacementMapEffect::GrGLDisplacementMapEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& proc)
- : INHERITED(factory)
- , fXChannelSelector(proc.cast<GrDisplacementMapEffect>().xChannelSelector())
+GrGLDisplacementMapEffect::GrGLDisplacementMapEffect(const GrProcessor& proc)
+ : fXChannelSelector(proc.cast<GrDisplacementMapEffect>().xChannelSelector())
, fYChannelSelector(proc.cast<GrDisplacementMapEffect>().yChannelSelector()) {
}
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 740ad02..512c13e 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -15,12 +15,11 @@
#include "SkTypes.h"
#if SK_SUPPORT_GPU
+#include "GrFragmentProcessor.h"
+#include "GrInvariantOutput.h"
#include "effects/GrSingleTextureEffect.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
-#include "GrFragmentProcessor.h"
-#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
class GrGLDiffuseLightingEffect;
class GrGLSpecularLightingEffect;
@@ -374,11 +373,12 @@
kd));
}
- static const char* Name() { return "DiffuseLighting"; }
+ virtual const char* name() const SK_OVERRIDE { return "DiffuseLighting"; }
- typedef GrGLDiffuseLightingEffect GLProcessor;
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
SkScalar kd() const { return fKD; }
private:
@@ -410,11 +410,13 @@
ks,
shininess));
}
- static const char* Name() { return "SpecularLighting"; }
- typedef GrGLSpecularLightingEffect GLProcessor;
+ virtual const char* name() const SK_OVERRIDE { return "SpecularLighting"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
SkScalar ks() const { return fKS; }
SkScalar shininess() const { return fShininess; }
@@ -1190,7 +1192,7 @@
class GrGLLightingEffect : public GrGLFragmentProcessor {
public:
- GrGLLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLLightingEffect(const GrProcessor&);
virtual ~GrGLLightingEffect();
virtual void emitCode(GrGLFPBuilder*,
@@ -1222,7 +1224,7 @@
class GrGLDiffuseLightingEffect : public GrGLLightingEffect {
public:
- GrGLDiffuseLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLDiffuseLightingEffect(const GrProcessor&);
virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
@@ -1236,7 +1238,7 @@
class GrGLSpecularLightingEffect : public GrGLLightingEffect {
public:
- GrGLSpecularLightingEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLSpecularLightingEffect(const GrProcessor&);
virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) SK_OVERRIDE;
virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
@@ -1281,10 +1283,7 @@
const SkMatrix& matrix,
SkScalar kd)
: INHERITED(texture, light, surfaceScale, matrix), fKD(kd) {
-}
-
-const GrBackendFragmentProcessorFactory& GrDiffuseLightingEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrDiffuseLightingEffect>::getInstance();
+ this->initClassID<GrDiffuseLightingEffect>();
}
bool GrDiffuseLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
@@ -1293,6 +1292,15 @@
this->kd() == s.kd();
}
+void GrDiffuseLightingEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GrGLDiffuseLightingEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrDiffuseLightingEffect::createGLInstance() const {
+ return SkNEW_ARGS(GrGLDiffuseLightingEffect, (*this));
+}
+
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrDiffuseLightingEffect);
GrFragmentProcessor* GrDiffuseLightingEffect::TestCreate(SkRandom* random,
@@ -1313,9 +1321,7 @@
///////////////////////////////////////////////////////////////////////////////
-GrGLLightingEffect::GrGLLightingEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& fp)
- : INHERITED(factory) {
+GrGLLightingEffect::GrGLLightingEffect(const GrProcessor& fp) {
const GrLightingEffect& m = fp.cast<GrLightingEffect>();
fLight = m.light()->createGLLight();
}
@@ -1440,9 +1446,8 @@
///////////////////////////////////////////////////////////////////////////////
-GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& proc)
- : INHERITED(factory, proc) {
+GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrProcessor& proc)
+ : INHERITED(proc) {
}
void GrGLDiffuseLightingEffect::emitLightFunc(GrGLFPBuilder* builder, SkString* funcName) {
@@ -1486,10 +1491,7 @@
: INHERITED(texture, light, surfaceScale, matrix),
fKS(ks),
fShininess(shininess) {
-}
-
-const GrBackendFragmentProcessorFactory& GrSpecularLightingEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrSpecularLightingEffect>::getInstance();
+ this->initClassID<GrSpecularLightingEffect>();
}
bool GrSpecularLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
@@ -1499,6 +1501,15 @@
this->shininess() == s.shininess();
}
+void GrSpecularLightingEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GrGLSpecularLightingEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrSpecularLightingEffect::createGLInstance() const {
+ return SkNEW_ARGS(GrGLSpecularLightingEffect, (*this));
+}
+
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrSpecularLightingEffect);
GrFragmentProcessor* GrSpecularLightingEffect::TestCreate(SkRandom* random,
@@ -1519,9 +1530,8 @@
///////////////////////////////////////////////////////////////////////////////
-GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& proc)
- : INHERITED(factory, proc) {
+GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrProcessor& proc)
+ : INHERITED(proc) {
}
void GrGLSpecularLightingEffect::emitLightFunc(GrGLFPBuilder* builder, SkString* funcName) {
diff --git a/src/effects/SkLumaColorFilter.cpp b/src/effects/SkLumaColorFilter.cpp
index 9ad5797..47cc8f1 100644
--- a/src/effects/SkLumaColorFilter.cpp
+++ b/src/effects/SkLumaColorFilter.cpp
@@ -11,11 +11,10 @@
#include "SkString.h"
#if SK_SUPPORT_GPU
-#include "gl/GrGLProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
#include "GrContext.h"
#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
+#include "gl/GrGLProcessor.h"
+#include "gl/builders/GrGLProgramBuilder.h"
#endif
void SkLumaColorFilter::filterSpan(const SkPMColor src[], int count,
@@ -64,18 +63,20 @@
return SkRef(gLumaEffect);
}
- static const char* Name() { return "Luminance-to-Alpha"; }
+ virtual const char* name() const SK_OVERRIDE { return "Luminance-to-Alpha"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<LumaColorFilterEffect>::getInstance();
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GLProcessor::GenKey(*this, caps, b);
+ }
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GLProcessor, (*this));
}
class GLProcessor : public GrGLFragmentProcessor {
public:
- GLProcessor(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory) {
- }
+ GLProcessor(const GrProcessor&) {}
static void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b) {}
@@ -105,6 +106,10 @@
};
private:
+ LumaColorFilterEffect() {
+ this->initClassID<LumaColorFilterEffect>();
+ }
+
virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
diff --git a/src/effects/SkMagnifierImageFilter.cpp b/src/effects/SkMagnifierImageFilter.cpp
index 973ac66..1f89473 100644
--- a/src/effects/SkMagnifierImageFilter.cpp
+++ b/src/effects/SkMagnifierImageFilter.cpp
@@ -14,15 +14,12 @@
////////////////////////////////////////////////////////////////////////////////
#if SK_SUPPORT_GPU
+#include "GrInvariantOutput.h"
#include "effects/GrSingleTextureEffect.h"
#include "gl/GrGLProcessor.h"
-#include "gl/builders/GrGLProgramBuilder.h"
#include "gl/GrGLSL.h"
#include "gl/GrGLTexture.h"
-#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
-
-class GrGLMagnifierEffect;
+#include "gl/builders/GrGLProgramBuilder.h"
class GrMagnifierEffect : public GrSingleTextureEffect {
@@ -45,9 +42,12 @@
virtual ~GrMagnifierEffect() {};
- static const char* Name() { return "Magnifier"; }
+ virtual const char* name() const SK_OVERRIDE { return "Magnifier"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
+
float x_offset() const { return fXOffset; }
float y_offset() const { return fYOffset; }
float x_inv_zoom() const { return fXInvZoom; }
@@ -55,8 +55,6 @@
float x_inv_inset() const { return fXInvInset; }
float y_inv_inset() const { return fYInvInset; }
- typedef GrGLMagnifierEffect GLProcessor;
-
private:
GrMagnifierEffect(GrTexture* texture,
float xOffset,
@@ -71,7 +69,9 @@
, fXInvZoom(xInvZoom)
, fYInvZoom(yInvZoom)
, fXInvInset(xInvInset)
- , fYInvInset(yInvInset) {}
+ , fYInvInset(yInvInset) {
+ this->initClassID<GrMagnifierEffect>();
+ }
virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE;
@@ -94,7 +94,7 @@
class GrGLMagnifierEffect : public GrGLFragmentProcessor {
public:
- GrGLMagnifierEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLMagnifierEffect(const GrProcessor&);
virtual void emitCode(GrGLFPBuilder*,
const GrFragmentProcessor&,
@@ -113,9 +113,7 @@
typedef GrGLFragmentProcessor INHERITED;
};
-GrGLMagnifierEffect::GrGLMagnifierEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory) {
+GrGLMagnifierEffect::GrGLMagnifierEffect(const GrProcessor&) {
}
void GrGLMagnifierEffect::emitCode(GrGLFPBuilder* builder,
@@ -181,6 +179,15 @@
/////////////////////////////////////////////////////////////////////
+void GrMagnifierEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GrGLMagnifierEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* GrMagnifierEffect::createGLInstance() const {
+ return SkNEW_ARGS(GrGLMagnifierEffect, (*this));
+}
+
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect);
GrFragmentProcessor* GrMagnifierEffect::TestCreate(SkRandom* random,
@@ -211,10 +218,6 @@
///////////////////////////////////////////////////////////////////////////////
-const GrBackendFragmentProcessorFactory& GrMagnifierEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrMagnifierEffect>::getInstance();
-}
-
bool GrMagnifierEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>();
return (this->fXOffset == s.fXOffset &&
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index 3d27d10..f896751 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -16,10 +16,9 @@
#include "GrContext.h"
#include "GrInvariantOutput.h"
#include "GrTexture.h"
-#include "GrTBackendProcessorFactory.h"
+#include "effects/Gr1DKernelEffect.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
-#include "effects/Gr1DKernelEffect.h"
#endif
SkMorphologyImageFilter::SkMorphologyImageFilter(int radiusX,
@@ -268,9 +267,6 @@
#if SK_SUPPORT_GPU
///////////////////////////////////////////////////////////////////////////////
-
-class GrGLMorphologyEffect;
-
/**
* Morphology effects. Depending upon the type of morphology, either the
* component-wise min (Erode_Type) or max (Dilate_Type) of all pixels in the
@@ -295,11 +291,11 @@
MorphologyType type() const { return fType; }
- static const char* Name() { return "Morphology"; }
+ virtual const char* name() const SK_OVERRIDE { return "Morphology"; }
- typedef GrGLMorphologyEffect GLProcessor;
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
protected:
@@ -321,7 +317,7 @@
class GrGLMorphologyEffect : public GrGLFragmentProcessor {
public:
- GrGLMorphologyEffect (const GrBackendProcessorFactory&, const GrProcessor&);
+ GrGLMorphologyEffect(const GrProcessor&);
virtual void emitCode(GrGLFPBuilder*,
const GrFragmentProcessor&,
@@ -344,9 +340,7 @@
typedef GrGLFragmentProcessor INHERITED;
};
-GrGLMorphologyEffect::GrGLMorphologyEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& proc)
- : INHERITED(factory) {
+GrGLMorphologyEffect::GrGLMorphologyEffect(const GrProcessor& proc) {
const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
fRadius = m.radius();
fType = m.type();
@@ -428,15 +422,19 @@
MorphologyType type)
: Gr1DKernelEffect(texture, direction, radius)
, fType(type) {
+ this->initClassID<GrMorphologyEffect>();
}
GrMorphologyEffect::~GrMorphologyEffect() {
}
-const GrBackendFragmentProcessorFactory& GrMorphologyEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<GrMorphologyEffect>::getInstance();
+void GrMorphologyEffect::getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const {
+ GrGLMorphologyEffect::GenKey(*this, caps, b);
}
+GrGLFragmentProcessor* GrMorphologyEffect::createGLInstance() const {
+ return SkNEW_ARGS(GrGLMorphologyEffect, (*this));
+}
bool GrMorphologyEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
const GrMorphologyEffect& s = sBase.cast<GrMorphologyEffect>();
return (this->radius() == s.radius() &&
diff --git a/src/effects/SkPerlinNoiseShader.cpp b/src/effects/SkPerlinNoiseShader.cpp
index 8c608fa..ebe6159 100644
--- a/src/effects/SkPerlinNoiseShader.cpp
+++ b/src/effects/SkPerlinNoiseShader.cpp
@@ -18,10 +18,9 @@
#include "GrContext.h"
#include "GrCoordTransform.h"
#include "GrInvariantOutput.h"
+#include "SkGr.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
-#include "GrTBackendProcessorFactory.h"
-#include "SkGr.h"
#endif
static const int kBlockSize = 256;
@@ -487,12 +486,9 @@
#if SK_SUPPORT_GPU
-#include "GrTBackendProcessorFactory.h"
-
class GrGLPerlinNoise : public GrGLFragmentProcessor {
public:
- GrGLPerlinNoise(const GrBackendProcessorFactory&,
- const GrProcessor&);
+ GrGLPerlinNoise(const GrProcessor&);
virtual ~GrGLPerlinNoise() {}
virtual void emitCode(GrGLFPBuilder*,
@@ -536,10 +532,17 @@
SkDELETE(fPaintingData);
}
- static const char* Name() { return "PerlinNoise"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<GrPerlinNoiseEffect>::getInstance();
+ virtual const char* name() const SK_OVERRIDE { return "PerlinNoise"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrGLPerlinNoise::GenKey(*this, caps, b);
}
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GrGLPerlinNoise, (*this));
+ }
+
const SkPerlinNoiseShader::StitchData& stitchData() const { return fPaintingData->fStitchDataInit; }
SkPerlinNoiseShader::Type type() const { return fType; }
@@ -549,8 +552,6 @@
const SkMatrix& matrix() const { return fCoordTransform.getMatrix(); }
uint8_t alpha() const { return fAlpha; }
- typedef GrGLPerlinNoise GLProcessor;
-
private:
virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
const GrPerlinNoiseEffect& s = sBase.cast<GrPerlinNoiseEffect>();
@@ -578,6 +579,7 @@
, fPermutationsAccess(permutationsTexture)
, fNoiseAccess(noiseTexture)
, fPaintingData(paintingData) {
+ this->initClassID<GrPerlinNoiseEffect>();
this->addTextureAccess(&fPermutationsAccess);
this->addTextureAccess(&fNoiseAccess);
fCoordTransform.reset(kLocal_GrCoordSet, matrix);
@@ -631,10 +633,8 @@
return effect;
}
-GrGLPerlinNoise::GrGLPerlinNoise(const GrBackendProcessorFactory& factory,
- const GrProcessor& processor)
- : INHERITED (factory)
- , fType(processor.cast<GrPerlinNoiseEffect>().type())
+GrGLPerlinNoise::GrGLPerlinNoise(const GrProcessor& processor)
+ : fType(processor.cast<GrPerlinNoiseEffect>().type())
, fStitchTiles(processor.cast<GrPerlinNoiseEffect>().stitchTiles())
, fNumOctaves(processor.cast<GrPerlinNoiseEffect>().numOctaves()) {
}
diff --git a/src/effects/SkTableColorFilter.cpp b/src/effects/SkTableColorFilter.cpp
index 7cd628f..db25a6f 100644
--- a/src/effects/SkTableColorFilter.cpp
+++ b/src/effects/SkTableColorFilter.cpp
@@ -253,25 +253,22 @@
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
#include "SkGr.h"
#include "effects/GrTextureStripAtlas.h"
#include "gl/GrGLProcessor.h"
#include "gl/builders/GrGLProgramBuilder.h"
-
-class GLColorTableEffect;
-
class ColorTableEffect : public GrFragmentProcessor {
public:
static GrFragmentProcessor* Create(GrContext* context, SkBitmap bitmap, unsigned flags);
virtual ~ColorTableEffect();
- static const char* Name() { return "ColorTable"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE { return "ColorTable"; }
- typedef GLColorTableEffect GLProcessor;
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
const GrTextureStripAtlas* atlas() const { return fAtlas; }
int atlasRow() const { return fRow; }
@@ -298,7 +295,7 @@
class GLColorTableEffect : public GrGLFragmentProcessor {
public:
- GLColorTableEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GLColorTableEffect(const GrProcessor&);
virtual void emitCode(GrGLFPBuilder*,
const GrFragmentProcessor&,
@@ -316,9 +313,8 @@
typedef GrGLFragmentProcessor INHERITED;
};
-GLColorTableEffect::GLColorTableEffect(const GrBackendProcessorFactory& factory, const GrProcessor&)
- : INHERITED(factory) {
- }
+GLColorTableEffect::GLColorTableEffect(const GrProcessor&) {
+}
void GLColorTableEffect::setData(const GrGLProgramDataManager& pdm, const GrProcessor& proc) {
// The textures are organized in a strip where the rows are ordered a, r, g, b.
@@ -420,7 +416,7 @@
, fFlags(flags)
, fAtlas(atlas)
, fRow(row) {
-
+ this->initClassID<ColorTableEffect>();
this->addTextureAccess(&fTextureAccess);
}
@@ -430,8 +426,13 @@
}
}
-const GrBackendFragmentProcessorFactory& ColorTableEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<ColorTableEffect>::getInstance();
+void ColorTableEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GLColorTableEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* ColorTableEffect::createGLInstance() const {
+ return SkNEW_ARGS(GLColorTableEffect, (*this));
}
bool ColorTableEffect::onIsEqual(const GrFragmentProcessor& other) const {
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index e70be04..f3e5131 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -887,13 +887,11 @@
#include "effects/GrTextureStripAtlas.h"
#include "GrInvariantOutput.h"
-#include "GrTBackendProcessorFactory.h"
#include "gl/builders/GrGLProgramBuilder.h"
#include "SkGr.h"
-GrGLGradientEffect::GrGLGradientEffect(const GrBackendProcessorFactory& factory)
- : INHERITED(factory)
- , fCachedYCoord(SK_ScalarMax) {
+GrGLGradientEffect::GrGLGradientEffect()
+ : fCachedYCoord(SK_ScalarMax) {
}
GrGLGradientEffect::~GrGLGradientEffect() { }
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index ecc5e34..72014d3 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -297,7 +297,6 @@
#include "gl/GrGLProcessor.h"
class GrFragmentStage;
-class GrBackendProcessorFactory;
class GrInvariantOutput;
/*
@@ -397,7 +396,7 @@
// Base class for GL gradient effects
class GrGLGradientEffect : public GrGLFragmentProcessor {
public:
- GrGLGradientEffect(const GrBackendProcessorFactory& factory);
+ GrGLGradientEffect();
virtual ~GrGLGradientEffect();
virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
diff --git a/src/effects/gradients/SkLinearGradient.cpp b/src/effects/gradients/SkLinearGradient.cpp
index 1faca5e..958862f 100644
--- a/src/effects/gradients/SkLinearGradient.cpp
+++ b/src/effects/gradients/SkLinearGradient.cpp
@@ -451,7 +451,6 @@
#if SK_SUPPORT_GPU
-#include "GrTBackendProcessorFactory.h"
#include "gl/builders/GrGLProgramBuilder.h"
#include "SkGr.h"
@@ -460,8 +459,7 @@
class GrGLLinearGradient : public GrGLGradientEffect {
public:
- GrGLLinearGradient(const GrBackendProcessorFactory& factory, const GrProcessor&)
- : INHERITED (factory) { }
+ GrGLLinearGradient(const GrProcessor&) {}
virtual ~GrGLLinearGradient() { }
@@ -495,19 +493,25 @@
virtual ~GrLinearGradient() { }
- static const char* Name() { return "Linear Gradient"; }
- const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<GrLinearGradient>::getInstance();
+ virtual const char* name() const { return "Linear Gradient"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrGLLinearGradient::GenKey(*this, caps, b);
}
- typedef GrGLLinearGradient GLProcessor;
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GrGLLinearGradient, (*this));
+ }
private:
GrLinearGradient(GrContext* ctx,
const SkLinearGradient& shader,
const SkMatrix& matrix,
SkShader::TileMode tm)
- : INHERITED(ctx, shader, matrix, tm) { }
+ : INHERITED(ctx, shader, matrix, tm) {
+ this->initClassID<GrLinearGradient>();
+ }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrGradientEffect INHERITED;
@@ -547,7 +551,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const GrLinearGradient& ge = fp.cast<GrLinearGradient>();
this->emitUniforms(builder, ge);
SkString t = builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0);
t.append(".x");
diff --git a/src/effects/gradients/SkRadialGradient.cpp b/src/effects/gradients/SkRadialGradient.cpp
index 7c0e8f6..e880df2 100644
--- a/src/effects/gradients/SkRadialGradient.cpp
+++ b/src/effects/gradients/SkRadialGradient.cpp
@@ -461,15 +461,13 @@
#if SK_SUPPORT_GPU
-#include "GrTBackendProcessorFactory.h"
-#include "gl/builders/GrGLProgramBuilder.h"
#include "SkGr.h"
+#include "gl/builders/GrGLProgramBuilder.h"
class GrGLRadialGradient : public GrGLGradientEffect {
public:
- GrGLRadialGradient(const GrBackendProcessorFactory& factory,
- const GrProcessor&) : INHERITED (factory) { }
+ GrGLRadialGradient(const GrProcessor&) {}
virtual ~GrGLRadialGradient() { }
virtual void emitCode(GrGLFPBuilder*,
@@ -502,12 +500,16 @@
virtual ~GrRadialGradient() { }
- static const char* Name() { return "Radial Gradient"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<GrRadialGradient>::getInstance();
+ virtual const char* name() const SK_OVERRIDE { return "Radial Gradient"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrGLRadialGradient::GenKey(*this, caps, b);
}
- typedef GrGLRadialGradient GLProcessor;
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GrGLRadialGradient, (*this));
+ }
private:
GrRadialGradient(GrContext* ctx,
@@ -515,6 +517,7 @@
const SkMatrix& matrix,
SkShader::TileMode tm)
: INHERITED(ctx, shader, matrix, tm) {
+ this->initClassID<GrRadialGradient>();
}
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@@ -556,7 +559,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const GrRadialGradient& ge = fp.cast<GrRadialGradient>();
this->emitUniforms(builder, ge);
SkString t("length(");
t.append(builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0));
diff --git a/src/effects/gradients/SkSweepGradient.cpp b/src/effects/gradients/SkSweepGradient.cpp
index 1637006..2493060 100644
--- a/src/effects/gradients/SkSweepGradient.cpp
+++ b/src/effects/gradients/SkSweepGradient.cpp
@@ -177,15 +177,13 @@
#if SK_SUPPORT_GPU
-#include "GrTBackendProcessorFactory.h"
-#include "gl/builders/GrGLProgramBuilder.h"
#include "SkGr.h"
+#include "gl/builders/GrGLProgramBuilder.h"
class GrGLSweepGradient : public GrGLGradientEffect {
public:
- GrGLSweepGradient(const GrBackendProcessorFactory& factory,
- const GrProcessor&) : INHERITED (factory) { }
+ GrGLSweepGradient(const GrProcessor&) {}
virtual ~GrGLSweepGradient() { }
virtual void emitCode(GrGLFPBuilder*,
@@ -215,18 +213,24 @@
}
virtual ~GrSweepGradient() { }
- static const char* Name() { return "Sweep Gradient"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<GrSweepGradient>::getInstance();
+ virtual const char* name() const SK_OVERRIDE { return "Sweep Gradient"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrGLSweepGradient::GenKey(*this, caps, b);
}
- typedef GrGLSweepGradient GLProcessor;
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GrGLSweepGradient, (*this));
+ }
private:
GrSweepGradient(GrContext* ctx,
const SkSweepGradient& shader,
const SkMatrix& matrix)
- : INHERITED(ctx, shader, matrix, SkShader::kClamp_TileMode) { }
+ : INHERITED(ctx, shader, matrix, SkShader::kClamp_TileMode) {
+ this->initClassID<GrSweepGradient>();
+ }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrGradientEffect INHERITED;
@@ -264,7 +268,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const GrSweepGradient& ge = fp.cast<GrSweepGradient>();
this->emitUniforms(builder, ge);
SkString coords2D = builder->getFragmentShaderBuilder()->ensureFSCoords2D(coords, 0);
const GrGLContextInfo ctxInfo = builder->ctxInfo();
diff --git a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
index 7bd2409..e918429 100644
--- a/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
+++ b/src/effects/gradients/SkTwoPointConicalGradient_gpu.cpp
@@ -11,7 +11,6 @@
#include "SkTwoPointConicalGradient.h"
#if SK_SUPPORT_GPU
-#include "GrTBackendProcessorFactory.h"
#include "gl/builders/GrGLProgramBuilder.h"
// For brevity
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
@@ -55,8 +54,6 @@
}
}
-class GLEdge2PtConicalEffect;
-
class Edge2PtConicalEffect : public GrGradientEffect {
public:
@@ -69,16 +66,19 @@
virtual ~Edge2PtConicalEffect() {}
- static const char* Name() { return "Two-Point Conical Gradient Edge Touching"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE {
+ return "Two-Point Conical Gradient Edge Touching";
+ }
+
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() 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 GLProcessor;
-
private:
virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
@@ -96,6 +96,7 @@
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
@@ -137,7 +138,7 @@
class GLEdge2PtConicalEffect : public GrGLGradientEffect {
public:
- GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+ GLEdge2PtConicalEffect(const GrProcessor&);
virtual ~GLEdge2PtConicalEffect() { }
virtual void emitCode(GrGLFPBuilder*,
@@ -169,8 +170,13 @@
};
-const GrBackendFragmentProcessorFactory& Edge2PtConicalEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<Edge2PtConicalEffect>::getInstance();
+void Edge2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GLEdge2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* Edge2PtConicalEffect::createGLInstance() const {
+ return SkNEW_ARGS(GLEdge2PtConicalEffect, (*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Edge2PtConicalEffect);
@@ -214,10 +220,8 @@
return fp;
}
-GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory)
- , fVSVaryingName(NULL)
+GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrProcessor&)
+ : fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedRadius(-SK_ScalarMax)
, fCachedDiffRadius(-SK_ScalarMax) {}
@@ -228,7 +232,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const Edge2PtConicalEffect& ge = fp.cast<Edge2PtConicalEffect>();
this->emitUniforms(builder, ge);
fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Conical2FSParams", 3);
@@ -368,8 +372,6 @@
//////////////////////////////////////////////////////////////////////////////
-class GLFocalOutside2PtConicalEffect;
-
class FocalOutside2PtConicalEffect : public GrGradientEffect {
public:
@@ -383,14 +385,17 @@
virtual ~FocalOutside2PtConicalEffect() { }
- static const char* Name() { return "Two-Point Conical Gradient Focal Outside"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE {
+ return "Two-Point Conical Gradient Focal Outside";
+ }
+
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
bool isFlipped() const { return fIsFlipped; }
SkScalar focal() const { return fFocalX; }
- typedef GLFocalOutside2PtConicalEffect GLProcessor;
-
private:
virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();
@@ -404,7 +409,9 @@
const SkMatrix& matrix,
SkShader::TileMode tm,
SkScalar focalX)
- : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isFlippedGrad()) {}
+ : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX), fIsFlipped(shader.isFlippedGrad()) {
+ this->initClassID<FocalOutside2PtConicalEffect>();
+ }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@@ -416,7 +423,7 @@
class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+ GLFocalOutside2PtConicalEffect(const GrProcessor&);
virtual ~GLFocalOutside2PtConicalEffect() { }
virtual void emitCode(GrGLFPBuilder*,
@@ -449,8 +456,13 @@
};
-const GrBackendFragmentProcessorFactory& FocalOutside2PtConicalEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<FocalOutside2PtConicalEffect>::getInstance();
+void FocalOutside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GLFocalOutside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* FocalOutside2PtConicalEffect::createGLInstance() const {
+ return SkNEW_ARGS(GLFocalOutside2PtConicalEffect, (*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalOutside2PtConicalEffect);
@@ -491,10 +503,8 @@
return effect;
}
-GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& processor)
- : INHERITED(factory)
- , fVSVaryingName(NULL)
+GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrProcessor& processor)
+ : fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedFocal(SK_ScalarMax) {
const FocalOutside2PtConicalEffect& data = processor.cast<FocalOutside2PtConicalEffect>();
@@ -507,7 +517,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const FocalOutside2PtConicalEffect& ge = fp.cast<FocalOutside2PtConicalEffect>();
this->emitUniforms(builder, ge);
fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Conical2FSParams", 2);
@@ -593,8 +603,13 @@
virtual ~FocalInside2PtConicalEffect() {}
- static const char* Name() { return "Two-Point Conical Gradient Focal Inside"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE {
+ return "Two-Point Conical Gradient Focal Inside";
+ }
+
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
SkScalar focal() const { return fFocalX; }
@@ -612,7 +627,9 @@
const SkMatrix& matrix,
SkShader::TileMode tm,
SkScalar focalX)
- : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {}
+ : INHERITED(ctx, shader, matrix, tm), fFocalX(focalX) {
+ this->initClassID<FocalInside2PtConicalEffect>();
+ }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@@ -623,7 +640,7 @@
class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+ GLFocalInside2PtConicalEffect(const GrProcessor&);
virtual ~GLFocalInside2PtConicalEffect() {}
virtual void emitCode(GrGLFPBuilder*,
@@ -654,8 +671,13 @@
};
-const GrBackendFragmentProcessorFactory& FocalInside2PtConicalEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<FocalInside2PtConicalEffect>::getInstance();
+void FocalInside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GLFocalInside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* FocalInside2PtConicalEffect::createGLInstance() const {
+ return SkNEW_ARGS(GLFocalInside2PtConicalEffect, (*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(FocalInside2PtConicalEffect);
@@ -698,10 +720,8 @@
return fp;
}
-GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor&)
- : INHERITED(factory)
- , fVSVaryingName(NULL)
+GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrProcessor&)
+ : fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedFocal(SK_ScalarMax) {}
@@ -711,7 +731,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const FocalInside2PtConicalEffect& ge = fp.cast<FocalInside2PtConicalEffect>();
this->emitUniforms(builder, ge);
fFocalUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Conical2FSParams");
@@ -814,8 +834,6 @@
return kOutside_ConicalType;
}
-class GLCircleInside2PtConicalEffect;
-
class CircleInside2PtConicalEffect : public GrGradientEffect {
public:
@@ -829,8 +847,12 @@
virtual ~CircleInside2PtConicalEffect() {}
- static const char* Name() { return "Two-Point Conical Gradient Inside"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE { return "Two-Point Conical Gradient Inside"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
@@ -838,8 +860,6 @@
SkScalar B() const { return fInfo.fB; }
SkScalar C() const { return fInfo.fC; }
- typedef GLCircleInside2PtConicalEffect GLProcessor;
-
private:
virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();
@@ -855,7 +875,9 @@
const SkMatrix& matrix,
SkShader::TileMode tm,
const CircleConicalInfo& info)
- : INHERITED(ctx, shader, matrix, tm), fInfo(info) {}
+ : INHERITED(ctx, shader, matrix, tm), fInfo(info) {
+ this->initClassID<CircleInside2PtConicalEffect>();
+ }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
@@ -866,7 +888,7 @@
class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory, const GrProcessor&);
+ GLCircleInside2PtConicalEffect(const GrProcessor&);
virtual ~GLCircleInside2PtConicalEffect() {}
virtual void emitCode(GrGLFPBuilder*,
@@ -902,8 +924,13 @@
};
-const GrBackendFragmentProcessorFactory& CircleInside2PtConicalEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<CircleInside2PtConicalEffect>::getInstance();
+void CircleInside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GLCircleInside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* CircleInside2PtConicalEffect::createGLInstance() const {
+ return SkNEW_ARGS(GLCircleInside2PtConicalEffect, (*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleInside2PtConicalEffect);
@@ -945,10 +972,8 @@
return processor;
}
-GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& processor)
- : INHERITED(factory)
- , fVSVaryingName(NULL)
+GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrProcessor& processor)
+ : fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedCenterX(SK_ScalarMax)
, fCachedCenterY(SK_ScalarMax)
@@ -962,7 +987,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const CircleInside2PtConicalEffect& ge = fp.cast<CircleInside2PtConicalEffect>();
this->emitUniforms(builder, ge);
fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, "Conical2FSCenter");
@@ -1029,8 +1054,6 @@
//////////////////////////////////////////////////////////////////////////////
-class GLCircleOutside2PtConicalEffect;
-
class CircleOutside2PtConicalEffect : public GrGradientEffect {
public:
@@ -1044,8 +1067,11 @@
virtual ~CircleOutside2PtConicalEffect() {}
- static const char* Name() { return "Two-Point Conical Gradient Outside"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
+ virtual const char* name() const SK_OVERRIDE { return "Two-Point Conical Gradient Outside"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const SK_OVERRIDE;
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE;
SkScalar centerX() const { return fInfo.fCenterEnd.fX; }
SkScalar centerY() const { return fInfo.fCenterEnd.fY; }
@@ -1055,8 +1081,6 @@
SkScalar tLimit() const { return fTLimit; }
bool isFlipped() const { return fIsFlipped; }
- typedef GLCircleOutside2PtConicalEffect GLProcessor;
-
private:
virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();
@@ -1075,6 +1099,7 @@
SkShader::TileMode tm,
const CircleConicalInfo& info)
: INHERITED(ctx, shader, matrix, tm), fInfo(info) {
+ this->initClassID<CircleOutside2PtConicalEffect>();
if (shader.getStartRadius() != shader.getEndRadius()) {
fTLimit = SkScalarDiv(shader.getStartRadius(),
(shader.getStartRadius() - shader.getEndRadius()));
@@ -1096,7 +1121,7 @@
class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory&, const GrProcessor&);
+ GLCircleOutside2PtConicalEffect(const GrProcessor&);
virtual ~GLCircleOutside2PtConicalEffect() {}
virtual void emitCode(GrGLFPBuilder*,
@@ -1135,8 +1160,13 @@
};
-const GrBackendFragmentProcessorFactory& CircleOutside2PtConicalEffect::getFactory() const {
- return GrTBackendFragmentProcessorFactory<CircleOutside2PtConicalEffect>::getInstance();
+void CircleOutside2PtConicalEffect::getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const {
+ GLCircleOutside2PtConicalEffect::GenKey(*this, caps, b);
+}
+
+GrGLFragmentProcessor* CircleOutside2PtConicalEffect::createGLInstance() const {
+ return SkNEW_ARGS(GLCircleOutside2PtConicalEffect, (*this));
}
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(CircleOutside2PtConicalEffect);
@@ -1179,10 +1209,8 @@
return processor;
}
-GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendProcessorFactory& factory,
- const GrProcessor& processor)
- : INHERITED(factory)
- , fVSVaryingName(NULL)
+GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrProcessor& processor)
+ : fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedCenterX(SK_ScalarMax)
, fCachedCenterY(SK_ScalarMax)
@@ -1200,7 +1228,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const CircleOutside2PtConicalEffect& ge = fp.cast<CircleOutside2PtConicalEffect>();
this->emitUniforms(builder, ge);
fCenterUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec2f_GrSLType, "Conical2FSCenter");
diff --git a/src/effects/gradients/SkTwoPointRadialGradient.cpp b/src/effects/gradients/SkTwoPointRadialGradient.cpp
index 8ce3f43..2783112 100644
--- a/src/effects/gradients/SkTwoPointRadialGradient.cpp
+++ b/src/effects/gradients/SkTwoPointRadialGradient.cpp
@@ -386,9 +386,8 @@
#if SK_SUPPORT_GPU
-#include "GrTBackendProcessorFactory.h"
-#include "gl/builders/GrGLProgramBuilder.h"
#include "SkGr.h"
+#include "gl/builders/GrGLProgramBuilder.h"
// For brevity
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
@@ -397,7 +396,7 @@
public:
- GrGLRadial2Gradient(const GrBackendProcessorFactory& factory, const GrProcessor&);
+ GrGLRadial2Gradient(const GrProcessor&);
virtual ~GrGLRadial2Gradient() { }
virtual void emitCode(GrGLFPBuilder*,
@@ -447,9 +446,15 @@
virtual ~GrRadial2Gradient() { }
- static const char* Name() { return "Two-Point Radial Gradient"; }
- virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
- return GrTBackendFragmentProcessorFactory<GrRadial2Gradient>::getInstance();
+ virtual const char* name() const SK_OVERRIDE { return "Two-Point Radial Gradient"; }
+
+ virtual void getGLProcessorKey(const GrGLCaps& caps,
+ GrProcessorKeyBuilder* b) const SK_OVERRIDE {
+ GrGLRadial2Gradient::GenKey(*this, caps, b);
+ }
+
+ virtual GrGLFragmentProcessor* createGLInstance() const SK_OVERRIDE {
+ return SkNEW_ARGS(GrGLRadial2Gradient, (*this));
}
// The radial gradient parameters can collapse to a linear (instead of quadratic) equation.
@@ -458,8 +463,6 @@
SkScalar radius() const { return fRadius0; }
bool isPosRoot() const { return SkToBool(fPosRoot); }
- typedef GrGLRadial2Gradient GLProcessor;
-
private:
virtual bool onIsEqual(const GrFragmentProcessor& sBase) const SK_OVERRIDE {
const GrRadial2Gradient& s = sBase.cast<GrRadial2Gradient>();
@@ -477,6 +480,7 @@
, fCenterX1(shader.getCenterX1())
, fRadius0(shader.getStartRadius())
, fPosRoot(shader.getDiffRadius() < 0) {
+ this->initClassID<GrRadial2Gradient>();
// We pass the linear part of the quadratic as a varying.
// float b = 2.0 * (fCenterX1 * x - fRadius0 * z)
fBTransform = this->getCoordTransform();
@@ -542,10 +546,8 @@
/////////////////////////////////////////////////////////////////////
-GrGLRadial2Gradient::GrGLRadial2Gradient(const GrBackendProcessorFactory& factory,
- const GrProcessor& processor)
- : INHERITED(factory)
- , fVSVaryingName(NULL)
+GrGLRadial2Gradient::GrGLRadial2Gradient(const GrProcessor& processor)
+ : fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedCenter(SK_ScalarMax)
, fCachedRadius(-SK_ScalarMax)
@@ -561,7 +563,7 @@
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrGradientEffect& ge = fp.cast<GrGradientEffect>();
+ const GrRadial2Gradient& ge = fp.cast<GrRadial2Gradient>();
this->emitUniforms(builder, ge);
fParamUni = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
kFloat_GrSLType, "Radial2FSParams", 6);