of GrGLEffect.
*/
-class GrEffect;
+class GrEffectRef;
class GrEffectStage;
class GrGLEffect;
class GrGLCaps;
};
virtual EffectKey glEffectKey(const GrEffectStage&, const GrGLCaps&) const = 0;
- virtual GrGLEffect* createGLInstance(const GrEffect&) const = 0;
+ virtual GrGLEffect* createGLInstance(const GrEffectRef&) const = 0;
bool operator ==(const GrBackendEffectFactory& b) const {
return fEffectClassID == b.fEffectClassID;
GrEffect* get() { return fEffect; }
const GrEffect* get() const { return fEffect; }
+ const GrEffect* operator-> () { return fEffect; }
+ const GrEffect* operator-> () const { return fEffect; }
+
void* operator new(size_t size);
void operator delete(void* target);
GrEffect subclass objects should be created by factory functions that return GrEffectRef.
There is no public way to wrap a GrEffect in a GrEffectRef. Thus, a factory should be a static
member function of a GrEffect subclass.
+
+ Because almost no code should ever handle a GrEffect outside of a GrEffectRef, we privately
+ inherit from GrRefCnt to help prevent accidental direct ref'ing/unref'ing of effects.
*/
-class GrEffect : public GrRefCnt {
+class GrEffect : private GrRefCnt {
public:
SK_DECLARE_INST_COUNT(GrEffect)
computed by the GrBackendEffectFactory:
effectA.getFactory().glEffectKey(effectA) == effectB.getFactory().glEffectKey(effectB).
*/
- bool isEqual(const GrEffect& other) const {
- if (&this->getFactory() != &other.getFactory()) {
+ bool isEqual(const GrEffectRef& other) const {
+ if (&this->getFactory() != &other->getFactory()) {
return false;
}
bool result = this->onIsEqual(other);
#if GR_DEBUG
if (result) {
- GrAssert(this->numTextures() == other.numTextures());
+ GrAssert(this->numTextures() == other->numTextures());
for (int i = 0; i < this->numTextures(); ++i) {
- GrAssert(*fTextureAccesses[i] == *other.fTextureAccesses[i]);
+ GrAssert(*fTextureAccesses[i] == *other->fTextureAccesses[i]);
}
}
#endif
void* operator new(size_t size);
void operator delete(void* target);
+ /** These use non-standard names because GrEffects should only be ref'ed an unref'ed deep in
+ the bowels. Rendering code should use GrEffectRef. */
+ void addRef() { this->ref(); }
+ void subRef() { this->unref(); }
+
protected:
/**
* Subclasses call this from their constructor to register GrTextureAcceses. The effect subclass
GrEffect() : fEffectRef(NULL) {};
- /** This should be called by GrEffect subclass factories */
+ /** This should be called by GrEffect subclass factories. See the comment on AutoEffectUnref for
+ an example factory function. */
static GrEffectRef* CreateEffectRef(GrEffect* effect) {
if (NULL == effect->fEffectRef) {
effect->fEffectRef = SkNEW_ARGS(GrEffectRef, (effect));
return effect->fEffectRef;
}
+ /** Helper used in subclass factory functions to unref the effect after it has been wrapped in a
+ GrEffectRef. E.g.:
+
+ class EffectSubclass : public GrEffect {
+ public:
+ GrEffectRef* Create(ParamType1 param1, ParamType2 param2, ...) {
+ AutoEffectUnref effect(SkNEW_ARGS(EffectSubclass, (param1, param2, ...)));
+ return CreateEffectRef(effect);
+ }
+ */
+ class AutoEffectUnref {
+ public:
+ AutoEffectUnref(GrEffect* effect) : fEffect(effect) { }
+ ~AutoEffectUnref() { fEffect->subRef(); }
+ operator GrEffect*() { return fEffect; }
+ private:
+ GrEffect* fEffect;
+ };
+
+ /** Helper for getting the GrEffect out of a GrEffectRef and down-casting to a GrEffect subclass
+ */
+ template <typename T>
+ static const T& CastEffect(const GrEffectRef& effectRef) {
+ GrAssert(NULL != effectRef.get());
+ return *static_cast<const T*>(effectRef.get());
+ }
+
private:
/** Subclass implements this to support isEqual(). It will only be called if it is known that
- the two effects are of the same subclass (i.e. they return the same object
- from getFactory()).*/
- virtual bool onIsEqual(const GrEffect& other) const = 0;
+ the two effects are of the same subclass (i.e. they return the same object from
+ getFactory()).*/
+ virtual bool onIsEqual(const GrEffectRef& other) const = 0;
- void EffectRefDestroyed() {
- fEffectRef = NULL;
- }
+ void EffectRefDestroyed() { fEffectRef = NULL; }
friend class GrEffectRef; // to call GrEffectRef destroyed
return false;
}
- if (!this->getEffect()->isEqual(*other.getEffect())) {
+ if (!(*this->getEffect())->isEqual(*other.getEffect())) {
return false;
}
return EffectRef;
}
- // TODO: Push GrEffectRef deeper and make this getter return it rather than GrEffect.
- const GrEffect* getEffect() const {
- if (NULL != fEffectRef) {
- return fEffectRef->get();
- } else {
- return NULL;
- }
- }
+ const GrEffectRef* getEffect() const { return fEffectRef; }
private:
SkMatrix fCoordChangeMatrix;
};
#endif
-
const GrGLCaps& caps) const SK_OVERRIDE {
GrAssert(kIllegalEffectClassID != fEffectClassID);
EffectKey effectKey = GLEffect::GenKey(stage, caps);
- EffectKey textureKey = GLEffect::GenTextureKey(*stage.getEffect(), caps);
+ EffectKey textureKey = GLEffect::GenTextureKey(stage.getEffect(), caps);
#if GR_DEBUG
static const EffectKey kIllegalIDMask = (uint16_t) (~((1U << kEffectKeyBits) - 1));
GrAssert(!(kIllegalIDMask & effectKey));
/** Returns a new instance of the appropriate *GL* implementation class
for the given GrEffect; caller is responsible for deleting
the object. */
- virtual GLEffect* createGLInstance(const GrEffect& effect) const SK_OVERRIDE {
+ virtual GLEffect* createGLInstance(const GrEffectRef& effect) const SK_OVERRIDE {
return SkNEW_ARGS(GLEffect, (*this, effect));
}
typedef GrGLBicubicEffect GLEffect;
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
static GrEffectRef* Create(GrTexture* tex, const SkScalar coefficients[16]) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrBicubicEffect, (tex, coefficients)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrBicubicEffect, (tex, coefficients)));
return CreateEffectRef(effect);
}
private:
GrBicubicEffect(GrTexture*, const SkScalar coefficients[16]);
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
float fCoefficients[16];
GR_DECLARE_EFFECT_TEST;
class GrGLBicubicEffect : public GrGLEffect {
public:
GrGLBicubicEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrEffectRef& effect);
virtual void emitCode(GrGLShaderBuilder*,
const GrEffectStage&,
EffectKey,
};
GrGLBicubicEffect::GrGLBicubicEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: INHERITED(factory)
, fCoefficientsUni(GrGLUniformManager::kInvalidUniformHandle)
, fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle) {
}
GrGLEffect::EffectKey GrGLBicubicEffect::GenKey(const GrEffectStage& s, const GrGLCaps&) {
- const GrBicubicEffect& m =
- static_cast<const GrBicubicEffect&>(*s.getEffect());
+ const GrBicubicEffect& m = GetEffectFromStage<GrBicubicEffect>(s);
EffectKey matrixKey = GrGLEffectMatrix::GenKey(m.getMatrix(),
s.getCoordChangeMatrix(),
m.texture(0));
void GrGLBicubicEffect::setData(const GrGLUniformManager& uman,
const GrEffectStage& stage) {
- const GrBicubicEffect& effect =
- static_cast<const GrBicubicEffect&>(*stage.getEffect());
+ const GrBicubicEffect& effect = GetEffectFromStage<GrBicubicEffect>(stage);
GrTexture& texture = *effect.texture(0);
float imageIncrement[2];
imageIncrement[0] = 1.0f / texture.width();
return GrTBackendEffectFactory<GrBicubicEffect>::getInstance();
}
-bool GrBicubicEffect::onIsEqual(const GrEffect& sBase) const {
- const GrBicubicEffect& s =
- static_cast<const GrBicubicEffect&>(sBase);
+bool GrBicubicEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrBicubicEffect& s = CastEffect<GrBicubicEffect>(sBase);
return this->texture(0) == s.texture(0) &&
!memcmp(fCoefficients, s.coefficients(), 16);
}
class GrGLBlendEffect : public GrGLEffect {
public:
GrGLBlendEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrEffectRef& effect);
virtual ~GrGLBlendEffect();
virtual void emitCode(GrGLShaderBuilder*,
static GrEffectRef* Create(SkBlendImageFilter::Mode mode,
GrTexture* foreground,
GrTexture* background) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrBlendEffect, (mode, foreground, background)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrBlendEffect, (mode, foreground, background)));
return CreateEffectRef(effect);
}
void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
private:
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GrBlendEffect(SkBlendImageFilter::Mode mode, GrTexture* foreground, GrTexture* background);
GrTextureAccess fForegroundAccess;
GrBlendEffect::~GrBlendEffect() {
}
-bool GrBlendEffect::onIsEqual(const GrEffect& sBase) const {
- const GrBlendEffect& s = static_cast<const GrBlendEffect&>(sBase);
+bool GrBlendEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrBlendEffect& s = CastEffect<GrBlendEffect>(sBase);
return fForegroundAccess.getTexture() == s.fForegroundAccess.getTexture() &&
fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture() &&
fMode == s.fMode;
///////////////////////////////////////////////////////////////////////////////
-GrGLBlendEffect::GrGLBlendEffect(const GrBackendEffectFactory& factory, const GrEffect& effect)
+GrGLBlendEffect::GrGLBlendEffect(const GrBackendEffectFactory& factory, const GrEffectRef& effect)
: INHERITED(factory),
- fMode(static_cast<const GrBlendEffect&>(effect).mode()) {
+ fMode(CastEffect<GrBlendEffect>(effect).mode()) {
}
GrGLBlendEffect::~GrGLBlendEffect() {
}
void GrGLBlendEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
- const GrBlendEffect& blend = static_cast<const GrBlendEffect&>(*stage.getEffect());
+ const GrBlendEffect& blend = GetEffectFromStage<GrBlendEffect>(stage);
GrTexture* fgTex = blend.texture(0);
GrTexture* bgTex = blend.texture(1);
fForegroundEffectMatrix.setData(uman,
}
GrGLEffect::EffectKey GrGLBlendEffect::GenKey(const GrEffectStage& stage, const GrGLCaps&) {
- const GrBlendEffect& blend = static_cast<const GrBlendEffect&>(*stage.getEffect());
+ const GrBlendEffect& blend = GetEffectFromStage<GrBlendEffect>(stage);
GrTexture* fgTex = blend.texture(0);
GrTexture* bgTex = blend.texture(1);
class ColorMatrixEffect : public GrEffect {
public:
static GrEffectRef* Create(const SkColorMatrix& matrix) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(ColorMatrixEffect, (matrix)));
+ AutoEffectUnref effect(SkNEW_ARGS(ColorMatrixEffect, (matrix)));
return CreateEffectRef(effect);
}
static EffectKey GenKey(const GrEffectStage&, const GrGLCaps&) { return 0; }
GLEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: INHERITED(factory)
, fMatrixHandle(GrGLUniformManager::kInvalidUniformHandle)
, fVectorHandle(GrGLUniformManager::kInvalidUniformHandle) {}
virtual void setData(const GrGLUniformManager& uniManager,
const GrEffectStage& stage) SK_OVERRIDE {
- const ColorMatrixEffect& cme =
- static_cast<const ColorMatrixEffect&>(*stage.getEffect());
+ const ColorMatrixEffect& cme = GetEffectFromStage<ColorMatrixEffect>(stage);
const float* m = cme.fMatrix.fMat;
// The GL matrix is transposed from SkColorMatrix.
GrGLfloat mt[] = {
private:
ColorMatrixEffect(const SkColorMatrix& matrix) : fMatrix(matrix) {}
- virtual bool onIsEqual(const GrEffect& s) const {
- const ColorMatrixEffect& cme = static_cast<const ColorMatrixEffect&>(s);
+ virtual bool onIsEqual(const GrEffectRef& s) const {
+ const ColorMatrixEffect& cme = CastEffect<ColorMatrixEffect>(s);
return cme.fMatrix == fMatrix;
}
class GrGLDisplacementMapEffect : public GrGLEffect {
public:
GrGLDisplacementMapEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrEffectRef& effect);
virtual ~GrGLDisplacementMapEffect();
virtual void emitCode(GrGLShaderBuilder*,
static GrEffectRef* Create(SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
SkScalar scale, GrTexture* displacement, GrTexture* color) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrDisplacementMapEffect, (xChannelSelector,
- yChannelSelector,
- scale,
- displacement,
- color)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrDisplacementMapEffect, (xChannelSelector,
+ yChannelSelector,
+ scale,
+ displacement,
+ color)));
return CreateEffectRef(effect);
}
void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
private:
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GrDisplacementMapEffect(SkDisplacementMapEffect::ChannelSelectorType xChannelSelector,
SkDisplacementMapEffect::ChannelSelectorType yChannelSelector,
GrDisplacementMapEffect::~GrDisplacementMapEffect() {
}
-bool GrDisplacementMapEffect::onIsEqual(const GrEffect& sBase) const {
- const GrDisplacementMapEffect& s = static_cast<const GrDisplacementMapEffect&>(sBase);
+bool GrDisplacementMapEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrDisplacementMapEffect& s = CastEffect<GrDisplacementMapEffect>(sBase);
return fDisplacementAccess.getTexture() == s.fDisplacementAccess.getTexture() &&
fColorAccess.getTexture() == s.fColorAccess.getTexture() &&
fXChannelSelector == s.fXChannelSelector &&
///////////////////////////////////////////////////////////////////////////////
-GrGLDisplacementMapEffect::GrGLDisplacementMapEffect(const GrBackendEffectFactory& factory, const GrEffect& effect)
+GrGLDisplacementMapEffect::GrGLDisplacementMapEffect(const GrBackendEffectFactory& factory,
+ const GrEffectRef& effect)
: INHERITED(factory)
- , fXChannelSelector(static_cast<const GrDisplacementMapEffect&>(effect).xChannelSelector())
- , fYChannelSelector(static_cast<const GrDisplacementMapEffect&>(effect).yChannelSelector()) {
+ , fXChannelSelector(CastEffect<GrDisplacementMapEffect>(effect).xChannelSelector())
+ , fYChannelSelector(CastEffect<GrDisplacementMapEffect>(effect).yChannelSelector()) {
}
GrGLDisplacementMapEffect::~GrGLDisplacementMapEffect() {
}
void GrGLDisplacementMapEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
- const GrDisplacementMapEffect& displacementMap = static_cast<const GrDisplacementMapEffect&>(*stage.getEffect());
+ const GrDisplacementMapEffect& displacementMap = GetEffectFromStage<GrDisplacementMapEffect>(stage);
GrTexture* displTex = displacementMap.texture(0);
GrTexture* colorTex = displacementMap.texture(1);
fDisplacementEffectMatrix.setData(uman,
GrGLEffect::EffectKey GrGLDisplacementMapEffect::GenKey(const GrEffectStage& stage,
const GrGLCaps&) {
const GrDisplacementMapEffect& displacementMap =
- static_cast<const GrDisplacementMapEffect&>(*stage.getEffect());
+ GetEffectFromStage<GrDisplacementMapEffect>(stage);
GrTexture* displTex = displacementMap.texture(0);
GrTexture* colorTex = displacementMap.texture(1);
}
protected:
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
private:
typedef GrSingleTextureEffect INHERITED;
const SkLight* light,
SkScalar surfaceScale,
SkScalar kd) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrDiffuseLightingEffect, (texture,
- light,
- surfaceScale,
- kd)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrDiffuseLightingEffect, (texture,
+ light,
+ surfaceScale,
+ kd)));
return CreateEffectRef(effect);
}
SkScalar kd() const { return fKD; }
private:
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GrDiffuseLightingEffect(GrTexture* texture,
const SkLight* light,
SkScalar surfaceScale,
SkScalar ks,
SkScalar shininess) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrSpecularLightingEffect, (texture,
- light,
- surfaceScale,
- ks,
- shininess)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrSpecularLightingEffect, (texture,
+ light,
+ surfaceScale,
+ ks,
+ shininess)));
return CreateEffectRef(effect);
}
static const char* Name() { return "SpecularLighting"; }
SkScalar shininess() const { return fShininess; }
private:
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GrSpecularLightingEffect(GrTexture* texture,
const SkLight* light,
class GrGLLightingEffect : public GrGLEffect {
public:
GrGLLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrEffectRef& effect);
virtual ~GrGLLightingEffect();
virtual void emitCode(GrGLShaderBuilder*,
class GrGLDiffuseLightingEffect : public GrGLLightingEffect {
public:
GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrEffectRef& effect);
virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;
virtual void setData(const GrGLUniformManager&, const GrEffectStage&) SK_OVERRIDE;
class GrGLSpecularLightingEffect : public GrGLLightingEffect {
public:
GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrEffectRef& effect);
virtual void emitLightFunc(GrGLShaderBuilder*, SkString* funcName) SK_OVERRIDE;
virtual void setData(const GrGLUniformManager&, const GrEffectStage&) SK_OVERRIDE;
fLight->unref();
}
-bool GrLightingEffect::onIsEqual(const GrEffect& sBase) const {
- const GrLightingEffect& s = static_cast<const GrLightingEffect&>(sBase);
+bool GrLightingEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrLightingEffect& s = CastEffect<GrLightingEffect>(sBase);
return this->texture(0) == s.texture(0) &&
fLight->isEqual(*s.fLight) &&
fSurfaceScale == s.fSurfaceScale;
return GrTBackendEffectFactory<GrDiffuseLightingEffect>::getInstance();
}
-bool GrDiffuseLightingEffect::onIsEqual(const GrEffect& sBase) const {
- const GrDiffuseLightingEffect& s =
- static_cast<const GrDiffuseLightingEffect&>(sBase);
+bool GrDiffuseLightingEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrDiffuseLightingEffect& s = CastEffect<GrDiffuseLightingEffect>(sBase);
return INHERITED::onIsEqual(sBase) &&
this->kd() == s.kd();
}
///////////////////////////////////////////////////////////////////////////////
GrGLLightingEffect::GrGLLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: INHERITED(factory)
, fImageIncrementUni(kInvalidUniformHandle)
, fSurfaceScaleUni(kInvalidUniformHandle) {
- const GrLightingEffect& m = static_cast<const GrLightingEffect&>(effect);
+ const GrLightingEffect& m = CastEffect<GrLightingEffect>(effect);
fLight = m.light()->createGLLight();
}
GrGLEffect::EffectKey GrGLLightingEffect::GenKey(const GrEffectStage& s,
const GrGLCaps& caps) {
- const GrLightingEffect& effect = static_cast<const GrLightingEffect&>(*s.getEffect());
- EffectKey key = static_cast<const GrLightingEffect&>(*s.getEffect()).light()->type();
+ const GrLightingEffect& effect = GetEffectFromStage<GrLightingEffect>(s);
+ EffectKey key = effect.light()->type();
key <<= GrGLEffectMatrix::kKeyBits;
EffectKey matrixKey = GrGLEffectMatrix::GenKey(effect.getMatrix(),
s.getCoordChangeMatrix(),
}
void GrGLLightingEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
- const GrLightingEffect& effect =static_cast<const GrLightingEffect&>(*stage.getEffect());
+ const GrLightingEffect& effect = GetEffectFromStage<GrLightingEffect>(stage);
GrTexture* texture = effect.texture(0);
float ySign = texture->origin() == GrSurface::kTopLeft_Origin ? -1.0f : 1.0f;
uman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
///////////////////////////////////////////////////////////////////////////////
GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: INHERITED(factory, effect)
, fKDUni(kInvalidUniformHandle) {
}
void GrGLDiffuseLightingEffect::setData(const GrGLUniformManager& uman,
const GrEffectStage& stage) {
INHERITED::setData(uman, stage);
- const GrDiffuseLightingEffect& effect =
- static_cast<const GrDiffuseLightingEffect&>(*stage.getEffect());
+ const GrDiffuseLightingEffect& effect = GetEffectFromStage<GrDiffuseLightingEffect>(stage);
uman.set1f(fKDUni, effect.kd());
}
return GrTBackendEffectFactory<GrSpecularLightingEffect>::getInstance();
}
-bool GrSpecularLightingEffect::onIsEqual(const GrEffect& sBase) const {
- const GrSpecularLightingEffect& s =
- static_cast<const GrSpecularLightingEffect&>(sBase);
+bool GrSpecularLightingEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrSpecularLightingEffect& s = CastEffect<GrSpecularLightingEffect>(sBase);
return INHERITED::onIsEqual(sBase) &&
this->ks() == s.ks() &&
this->shininess() == s.shininess();
///////////////////////////////////////////////////////////////////////////////
GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: GrGLLightingEffect(factory, effect)
, fKSUni(kInvalidUniformHandle)
, fShininessUni(kInvalidUniformHandle) {
void GrGLSpecularLightingEffect::setData(const GrGLUniformManager& uman,
const GrEffectStage& stage) {
INHERITED::setData(uman, stage);
- const GrSpecularLightingEffect& effect =
- static_cast<const GrSpecularLightingEffect&>(*stage.getEffect());
+ const GrSpecularLightingEffect& effect = GetEffectFromStage<GrSpecularLightingEffect>(stage);
uman.set1f(fKSUni, effect.ks());
uman.set1f(fShininessUni, effect.shininess());
}
float yZoom,
float xInset,
float yInset) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrMagnifierEffect, (texture,
- xOffset,
- yOffset,
- xZoom,
- yZoom,
- xInset,
- yInset)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrMagnifierEffect, (texture,
+ xOffset,
+ yOffset,
+ xZoom,
+ yZoom,
+ xInset,
+ yInset)));
return CreateEffectRef(effect);
}
, fXInset(xInset)
, fYInset(yInset) {}
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GR_DECLARE_EFFECT_TEST;
class GrGLMagnifierEffect : public GrGLEffect {
public:
- GrGLMagnifierEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ GrGLMagnifierEffect(const GrBackendEffectFactory& factory, const GrEffectRef& effect);
virtual void emitCode(GrGLShaderBuilder*,
const GrEffectStage&,
typedef GrGLEffect INHERITED;
};
-GrGLMagnifierEffect::GrGLMagnifierEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+GrGLMagnifierEffect::GrGLMagnifierEffect(const GrBackendEffectFactory& factory, const GrEffectRef&)
: INHERITED(factory)
, fOffsetVar(GrGLUniformManager::kInvalidUniformHandle)
, fZoomVar(GrGLUniformManager::kInvalidUniformHandle)
void GrGLMagnifierEffect::setData(const GrGLUniformManager& uman,
const GrEffectStage& stage) {
- const GrMagnifierEffect& zoom = static_cast<const GrMagnifierEffect&>(*stage.getEffect());
-
+ const GrMagnifierEffect& zoom = GetEffectFromStage<GrMagnifierEffect>(stage);
uman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset());
uman.set2f(fZoomVar, zoom.x_zoom(), zoom.y_zoom());
uman.set2f(fInsetVar, zoom.x_inset(), zoom.y_inset());
}
GrGLEffect::EffectKey GrGLMagnifierEffect::GenKey(const GrEffectStage& stage, const GrGLCaps&) {
- const GrMagnifierEffect& zoom = static_cast<const GrMagnifierEffect&>(*stage.getEffect());
+ const GrMagnifierEffect& zoom = GetEffectFromStage<GrMagnifierEffect>(stage);
return GrGLEffectMatrix::GenKey(zoom.getMatrix(),
stage.getCoordChangeMatrix(),
zoom.texture(0));
return GrTBackendEffectFactory<GrMagnifierEffect>::getInstance();
}
-bool GrMagnifierEffect::onIsEqual(const GrEffect& sBase) const {
- const GrMagnifierEffect& s = static_cast<const GrMagnifierEffect&>(sBase);
+bool GrMagnifierEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrMagnifierEffect& s = CastEffect<GrMagnifierEffect>(sBase);
return (this->texture(0) == s.texture(0) &&
this->fXOffset == s.fXOffset &&
this->fYOffset == s.fYOffset &&
const SkIPoint& target,
TileMode tileMode,
bool convolveAlpha) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrMatrixConvolutionEffect, (texture,
- kernelSize,
- kernel,
- gain,
- bias,
- target,
- tileMode,
- convolveAlpha)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrMatrixConvolutionEffect, (texture,
+ kernelSize,
+ kernel,
+ gain,
+ bias,
+ target,
+ tileMode,
+ convolveAlpha)));
return CreateEffectRef(effect);
}
virtual ~GrMatrixConvolutionEffect();
TileMode tileMode,
bool convolveAlpha);
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
SkISize fKernelSize;
float *fKernel;
class GrGLMatrixConvolutionEffect : public GrGLEffect {
public:
GrGLMatrixConvolutionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrEffectRef& effect);
virtual void emitCode(GrGLShaderBuilder*,
const GrEffectStage&,
EffectKey,
};
GrGLMatrixConvolutionEffect::GrGLMatrixConvolutionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: INHERITED(factory)
, fKernelUni(GrGLUniformManager::kInvalidUniformHandle)
, fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle)
, fTargetUni(GrGLUniformManager::kInvalidUniformHandle)
, fGainUni(GrGLUniformManager::kInvalidUniformHandle)
, fBiasUni(GrGLUniformManager::kInvalidUniformHandle) {
- const GrMatrixConvolutionEffect& m = static_cast<const GrMatrixConvolutionEffect&>(effect);
+ const GrMatrixConvolutionEffect& m = CastEffect<GrMatrixConvolutionEffect>(effect);
fKernelSize = m.kernelSize();
fTileMode = m.tileMode();
fConvolveAlpha = m.convolveAlpha();
};
GrGLEffect::EffectKey GrGLMatrixConvolutionEffect::GenKey(const GrEffectStage& s, const GrGLCaps&) {
- const GrMatrixConvolutionEffect& m =
- static_cast<const GrMatrixConvolutionEffect&>(*s.getEffect());
+ const GrMatrixConvolutionEffect& m = GetEffectFromStage<GrMatrixConvolutionEffect>(s);
EffectKey key = encodeXY(m.kernelSize().width(), m.kernelSize().height());
key |= m.tileMode() << 7;
key |= m.convolveAlpha() ? 1 << 9 : 0;
void GrGLMatrixConvolutionEffect::setData(const GrGLUniformManager& uman,
const GrEffectStage& stage) {
- const GrMatrixConvolutionEffect& effect =
- static_cast<const GrMatrixConvolutionEffect&>(*stage.getEffect());
+ const GrMatrixConvolutionEffect& effect = GetEffectFromStage<GrMatrixConvolutionEffect>(stage);
GrTexture& texture = *effect.texture(0);
// the code we generated was for a specific kernel size
GrAssert(effect.kernelSize() == fKernelSize);
return GrTBackendEffectFactory<GrMatrixConvolutionEffect>::getInstance();
}
-bool GrMatrixConvolutionEffect::onIsEqual(const GrEffect& sBase) const {
- const GrMatrixConvolutionEffect& s =
- static_cast<const GrMatrixConvolutionEffect&>(sBase);
+bool GrMatrixConvolutionEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrMatrixConvolutionEffect& s = CastEffect<GrMatrixConvolutionEffect>(sBase);
return this->texture(0) == s.texture(0) &&
fKernelSize == s.kernelSize() &&
!memcmp(fKernel, s.kernel(), fKernelSize.width() * fKernelSize.height() * sizeof(float)) &&
};
static GrEffectRef* Create(GrTexture* tex, Direction dir, int radius, MorphologyType type) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrMorphologyEffect, (tex, dir, radius, type)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrMorphologyEffect, (tex, dir, radius, type)));
return CreateEffectRef(effect);
}
MorphologyType fType;
private:
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GrMorphologyEffect(GrTexture*, Direction, int radius, MorphologyType);
class GrGLMorphologyEffect : public GrGLEffect {
public:
- GrGLMorphologyEffect (const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ GrGLMorphologyEffect (const GrBackendEffectFactory&, const GrEffectRef&);
virtual void emitCode(GrGLShaderBuilder*,
const GrEffectStage&,
};
GrGLMorphologyEffect::GrGLMorphologyEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: INHERITED(factory)
, fImageIncrementUni(GrGLUniformManager::kInvalidUniformHandle) {
- const GrMorphologyEffect& m = static_cast<const GrMorphologyEffect&>(effect);
+ const GrMorphologyEffect& m = CastEffect<GrMorphologyEffect>(effect);
fRadius = m.radius();
fType = m.type();
}
}
GrGLEffect::EffectKey GrGLMorphologyEffect::GenKey(const GrEffectStage& s, const GrGLCaps&) {
- const GrMorphologyEffect& m = static_cast<const GrMorphologyEffect&>(*s.getEffect());
+ const GrMorphologyEffect& m = GetEffectFromStage<GrMorphologyEffect>(s);
EffectKey key = static_cast<EffectKey>(m.radius());
key |= (m.type() << 8);
key <<= GrGLEffectMatrix::kKeyBits;
}
void GrGLMorphologyEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
- const Gr1DKernelEffect& kern = static_cast<const Gr1DKernelEffect&>(*stage.getEffect());
+ const Gr1DKernelEffect& kern = GetEffectFromStage<Gr1DKernelEffect>(stage);
GrTexture& texture = *kern.texture(0);
// the code we generated was for a specific kernel radius
GrAssert(kern.radius() == fRadius);
return GrTBackendEffectFactory<GrMorphologyEffect>::getInstance();
}
-bool GrMorphologyEffect::onIsEqual(const GrEffect& sBase) const {
- const GrMorphologyEffect& s =
- static_cast<const GrMorphologyEffect&>(sBase);
+bool GrMorphologyEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrMorphologyEffect& s = CastEffect<GrMorphologyEffect>(sBase);
return (this->texture(0) == s.texture(0) &&
this->radius() == s.radius() &&
this->direction() == s.direction() &&
class ColorTableEffect : public GrEffect {
public:
static GrEffectRef* Create(GrTexture* texture, unsigned flags) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(ColorTableEffect, (texture, flags)));
+ AutoEffectUnref effect(SkNEW_ARGS(ColorTableEffect, (texture, flags)));
return CreateEffectRef(effect);
}
typedef GLColorTableEffect GLEffect;
private:
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
explicit ColorTableEffect(GrTexture* texture, unsigned flags);
class GLColorTableEffect : public GrGLEffect {
public:
- GLColorTableEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ GLColorTableEffect(const GrBackendEffectFactory&, const GrEffectRef&);
virtual void emitCode(GrGLShaderBuilder*,
const GrEffectStage&,
typedef GrGLEffect INHERITED;
};
-GLColorTableEffect::GLColorTableEffect(
- const GrBackendEffectFactory& factory, const GrEffect& effect)
+GLColorTableEffect::GLColorTableEffect(const GrBackendEffectFactory& factory, const GrEffectRef&)
: INHERITED(factory) {
}
return GrTBackendEffectFactory<ColorTableEffect>::getInstance();
}
-bool ColorTableEffect::onIsEqual(const GrEffect& sBase) const {
- return this->texture(0) == sBase.texture(0);
+bool ColorTableEffect::onIsEqual(const GrEffectRef& sBase) const {
+ return this->texture(0) == sBase->texture(0);
}
void ColorTableEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
}
void GrGLGradientEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
- const GrGradientEffect& e = static_cast<const GrGradientEffect&>(*stage.getEffect());
+ const GrGradientEffect& e = GetEffectFromStage<GrGradientEffect>(stage);
const GrTexture* texture = e.texture(0);
fEffectMatrix.setData(uman, e.getMatrix(), stage.getCoordChangeMatrix(), texture);
}
GrGLEffect::EffectKey GrGLGradientEffect::GenMatrixKey(const GrEffectStage& s) {
- const GrGradientEffect& e = static_cast<const GrGradientEffect&>(*s.getEffect());
+ const GrGradientEffect& e = GetEffectFromStage<GrGradientEffect>(s);
const GrTexture* texture = e.texture(0);
return GrGLEffectMatrix::GenKey(e.getMatrix(), s.getCoordChangeMatrix(), texture);
}
}
}
-bool GrGradientEffect::onIsEqual(const GrEffect& effect) const {
- const GrGradientEffect& s = static_cast<const GrGradientEffect&>(effect);
+bool GrGradientEffect::onIsEqual(const GrEffectRef& effect) const {
+ const GrGradientEffect& s = CastEffect<GrGradientEffect>(effect);
return fTextureAccess.getTexture() == s.fTextureAccess.getTexture() &&
fTextureAccess.getParams().getTileModeX() ==
s.fTextureAccess.getParams().getTileModeX() &&
SkScalar** stops,
SkShader::TileMode* tm);
- virtual bool onIsEqual(const GrEffect& effect) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef& effect) const SK_OVERRIDE;
private:
#endif
#endif
-
class GrGLLinearGradient : public GrGLGradientEffect {
public:
- GrGLLinearGradient(const GrBackendEffectFactory& factory,
- const GrEffect&)
+ GrGLLinearGradient(const GrBackendEffectFactory& factory, const GrEffectRef&)
: INHERITED (factory) { }
virtual ~GrGLLinearGradient() { }
const SkLinearGradient& shader,
const SkMatrix& matrix,
SkShader::TileMode tm) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrLinearGradient, (ctx, shader, matrix, tm)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrLinearGradient, (ctx, shader, matrix, tm)));
return CreateEffectRef(effect);
}
public:
GrGLRadialGradient(const GrBackendEffectFactory& factory,
- const GrEffect&) : INHERITED (factory) { }
+ const GrEffectRef&) : INHERITED (factory) { }
virtual ~GrGLRadialGradient() { }
virtual void emitCode(GrGLShaderBuilder*,
const SkRadialGradient& shader,
const SkMatrix& matrix,
SkShader::TileMode tm) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrRadialGradient, (ctx, shader, matrix, tm)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrRadialGradient, (ctx, shader, matrix, tm)));
return CreateEffectRef(effect);
}
public:
GrGLSweepGradient(const GrBackendEffectFactory& factory,
- const GrEffect&) : INHERITED (factory) { }
+ const GrEffectRef&) : INHERITED (factory) { }
virtual ~GrGLSweepGradient() { }
virtual void emitCode(GrGLShaderBuilder*,
static GrEffectRef* Create(GrContext* ctx,
const SkSweepGradient& shader,
const SkMatrix& matrix) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrSweepGradient, (ctx, shader, matrix)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrSweepGradient, (ctx, shader, matrix)));
return CreateEffectRef(effect);
}
virtual ~GrSweepGradient() { }
public:
GrGLConical2Gradient(const GrBackendEffectFactory& factory,
- const GrEffect&);
+ const GrEffectRef&);
virtual ~GrGLConical2Gradient() { }
virtual void emitCode(GrGLShaderBuilder*,
const SkTwoPointConicalGradient& shader,
const SkMatrix& matrix,
SkShader::TileMode tm) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrConical2Gradient, (ctx, shader, matrix, tm)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrConical2Gradient, (ctx, shader, matrix, tm)));
return CreateEffectRef(effect);
}
typedef GrGLConical2Gradient GLEffect;
private:
- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const GrConical2Gradient& s = static_cast<const GrConical2Gradient&>(sBase);
+ virtual bool onIsEqual(const GrEffectRef& sBase) const SK_OVERRIDE {
+ const GrConical2Gradient& s = CastEffect<GrConical2Gradient>(sBase);
return (INHERITED::onIsEqual(sBase) &&
this->fCenterX1 == s.fCenterX1 &&
this->fRadius0 == s.fRadius0 &&
/////////////////////////////////////////////////////////////////////
-GrGLConical2Gradient::GrGLConical2Gradient(
- const GrBackendEffectFactory& factory,
- const GrEffect& baseData)
+GrGLConical2Gradient::GrGLConical2Gradient(const GrBackendEffectFactory& factory,
+ const GrEffectRef& baseData)
: INHERITED(factory)
, fVSParamUni(kInvalidUniformHandle)
, fFSParamUni(kInvalidUniformHandle)
, fCachedRadius(-SK_ScalarMax)
, fCachedDiffRadius(-SK_ScalarMax) {
- const GrConical2Gradient& data =
- static_cast<const GrConical2Gradient&>(baseData);
+ const GrConical2Gradient& data = CastEffect<GrConical2Gradient>(baseData);
fIsDegenerate = data.isDegenerate();
}
void GrGLConical2Gradient::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
INHERITED::setData(uman, stage);
- const GrConical2Gradient& data = static_cast<const GrConical2Gradient&>(*stage.getEffect());
+ const GrConical2Gradient& data = GetEffectFromStage<GrConical2Gradient>(stage);
GrAssert(data.isDegenerate() == fIsDegenerate);
SkScalar centerX1 = data.center();
SkScalar radius0 = data.radius();
};
EffectKey key = GenMatrixKey(s);
- if (static_cast<const GrConical2Gradient&>(*s.getEffect()).isDegenerate()) {
+ if (GetEffectFromStage<GrConical2Gradient>(s).isDegenerate()) {
key |= kIsDegenerate;
}
return key;
public:
- GrGLRadial2Gradient(const GrBackendEffectFactory& factory,
- const GrEffect&);
+ GrGLRadial2Gradient(const GrBackendEffectFactory& factory, const GrEffectRef&);
virtual ~GrGLRadial2Gradient() { }
virtual void emitCode(GrGLShaderBuilder*,
const SkTwoPointRadialGradient& shader,
const SkMatrix& matrix,
SkShader::TileMode tm) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrRadial2Gradient, (ctx, shader, matrix, tm)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrRadial2Gradient, (ctx, shader, matrix, tm)));
return CreateEffectRef(effect);
}
typedef GrGLRadial2Gradient GLEffect;
private:
- virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const GrRadial2Gradient& s = static_cast<const GrRadial2Gradient&>(sBase);
+ virtual bool onIsEqual(const GrEffectRef& sBase) const SK_OVERRIDE {
+ const GrRadial2Gradient& s = CastEffect<GrRadial2Gradient>(sBase);
return (INHERITED::onIsEqual(sBase) &&
this->fCenterX1 == s.fCenterX1 &&
this->fRadius0 == s.fRadius0 &&
/////////////////////////////////////////////////////////////////////
-GrGLRadial2Gradient::GrGLRadial2Gradient(
- const GrBackendEffectFactory& factory,
- const GrEffect& baseData)
+GrGLRadial2Gradient::GrGLRadial2Gradient(const GrBackendEffectFactory& factory,
+ const GrEffectRef& baseData)
: INHERITED(factory)
, fVSParamUni(kInvalidUniformHandle)
, fFSParamUni(kInvalidUniformHandle)
, fCachedRadius(-SK_ScalarMax)
, fCachedPosRoot(0) {
- const GrRadial2Gradient& data =
- static_cast<const GrRadial2Gradient&>(baseData);
+ const GrRadial2Gradient& data = CastEffect<GrRadial2Gradient>(baseData);
fIsDegenerate = data.isDegenerate();
}
void GrGLRadial2Gradient::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
INHERITED::setData(uman, stage);
- const GrRadial2Gradient& data = static_cast<const GrRadial2Gradient&>(*stage.getEffect());
+ const GrRadial2Gradient& data = GetEffectFromStage<GrRadial2Gradient>(stage);
GrAssert(data.isDegenerate() == fIsDegenerate);
SkScalar centerX1 = data.center();
SkScalar radius0 = data.radius();
};
EffectKey key = GenMatrixKey(s);
- if (static_cast<const GrRadial2Gradient&>(*s.getEffect()).isDegenerate()) {
+ if (GetEffectFromStage<GrRadial2Gradient>(s).isDegenerate()) {
key |= kIsDegenerate;
}
return key;
GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kReset_ASRInit);
GrDrawState* drawState = target->drawState();
drawState->setRenderTarget(rt);
- SkAutoTUnref<GrEffectRef> conv(GrConvolutionEffect::Create(texture,
- direction,
- radius,
- sigma));
+ SkAutoTUnref<GrEffectRef> conv(GrConvolutionEffect::CreateGuassian(texture,
+ direction,
+ radius,
+ sigma));
drawState->stage(0)->setEffect(conv);
target->drawSimpleRect(rect, NULL);
}
GrAssert(NULL != drawState.getRenderTarget());
for (int s = 0; s < GrDrawState::kNumStages; ++s) {
if (drawState.isStageEnabled(s)) {
- const GrEffect* effect = drawState.getStage(s).getEffect();
+ const GrEffectRef& effect = *drawState.getStage(s).getEffect();
int numTextures = effect->numTextures();
for (int t = 0; t < numTextures; ++t) {
GrTexture* texture = effect->texture(t);
// Run through the color stages
int stageCnt = drawState.getFirstCoverageStage();
for (int s = 0; s < stageCnt; ++s) {
- const GrEffect* effect = drawState.getStage(s).getEffect();
+ const GrEffectRef* effect = drawState.getStage(s).getEffect();
if (NULL != effect) {
- effect->getConstantColorComponents(&color, &validComponentFlags);
+ (*effect)->getConstantColorComponents(&color, &validComponentFlags);
}
}
}
}
for (int s = drawState.getFirstCoverageStage(); s < GrDrawState::kNumStages; ++s) {
- const GrEffect* effect = drawState.getStage(s).getEffect();
+ const GrEffectRef* effect = drawState.getStage(s).getEffect();
if (NULL != effect) {
- effect->getConstantColorComponents(&color, &validComponentFlags);
+ (*effect)->getConstantColorComponents(&color, &validComponentFlags);
}
}
}
return;
}
- GrTexture* devTex = grPaint.getColorStage(kBitmapTextureIdx).getEffect()->texture(0);
+ GrTexture* devTex = (*grPaint.getColorStage(kBitmapTextureIdx).getEffect())->texture(0);
SkASSERT(NULL != devTex);
SkImageFilter* filter = paint.getImageFilter();
class GrGLConfigConversionEffect : public GrGLEffect {
public:
GrGLConfigConversionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& s) : INHERITED (factory) {
- const GrConfigConversionEffect& effect = static_cast<const GrConfigConversionEffect&>(s);
+ const GrEffectRef& s) : INHERITED (factory) {
+ const GrConfigConversionEffect& effect = CastEffect<GrConfigConversionEffect>(s);
fSwapRedAndBlue = effect.swapsRedAndBlue();
fPMConversion = effect.pmConversion();
}
void setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
const GrConfigConversionEffect& effect =
- static_cast<const GrConfigConversionEffect&>(*stage.getEffect());
+ GetEffectFromStage<GrConfigConversionEffect>(stage);
fEffectMatrix.setData(uman,
effect.getMatrix(),
stage.getCoordChangeMatrix(),
}
static inline EffectKey GenKey(const GrEffectStage& s, const GrGLCaps&) {
- const GrConfigConversionEffect& effect =
- static_cast<const GrConfigConversionEffect&>(*s.getEffect());
+ const GrConfigConversionEffect& effect = GetEffectFromStage<GrConfigConversionEffect>(s);
EffectKey key = static_cast<EffectKey>(effect.swapsRedAndBlue()) |
(effect.pmConversion() << 1);
key <<= GrGLEffectMatrix::kKeyBits;
return GrTBackendEffectFactory<GrConfigConversionEffect>::getInstance();
}
-bool GrConfigConversionEffect::onIsEqual(const GrEffect& s) const {
- const GrConfigConversionEffect& other = static_cast<const GrConfigConversionEffect&>(s);
- return this->texture(0) == s.texture(0) &&
+bool GrConfigConversionEffect::onIsEqual(const GrEffectRef& s) const {
+ const GrConfigConversionEffect& other = CastEffect<GrConfigConversionEffect>(s);
+ return this->texture(0) == s->texture(0) &&
other.fSwapRedAndBlue == fSwapRedAndBlue &&
other.fPMConversion == fPMConversion;
}
} else {
swapRB = random->nextBool();
}
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrConfigConversionEffect,
- (textures[GrEffectUnitTest::kSkiaPMTextureIdx],
- swapRB,
- pmConv,
- GrEffectUnitTest::TestMatrix(random))));
+ AutoEffectUnref effect(SkNEW_ARGS(GrConfigConversionEffect,
+ (textures[GrEffectUnitTest::kSkiaPMTextureIdx],
+ swapRB,
+ pmConv,
+ GrEffectUnitTest::TestMatrix(random))));
return CreateEffectRef(effect);
}
// We then verify that two reads produced the same values.
GrPaint paint;
- SkAutoTUnref<GrEffect> pmToUPM1(SkNEW_ARGS(GrConfigConversionEffect, (dataTex,
- false,
- *pmToUPMRule,
- SkMatrix::I())));
- SkAutoTUnref<GrEffect> upmToPM(SkNEW_ARGS(GrConfigConversionEffect, (readTex,
- false,
- *upmToPMRule,
- SkMatrix::I())));
- SkAutoTUnref<GrEffect> pmToUPM2(SkNEW_ARGS(GrConfigConversionEffect, (tempTex,
- false,
- *pmToUPMRule,
- SkMatrix::I())));
+ AutoEffectUnref pmToUPM1(SkNEW_ARGS(GrConfigConversionEffect, (dataTex,
+ false,
+ *pmToUPMRule,
+ SkMatrix::I())));
+ AutoEffectUnref upmToPM(SkNEW_ARGS(GrConfigConversionEffect, (readTex,
+ false,
+ *upmToPMRule,
+ SkMatrix::I())));
+ AutoEffectUnref pmToUPM2(SkNEW_ARGS(GrConfigConversionEffect, (tempTex,
+ false,
+ *pmToUPMRule,
+ SkMatrix::I())));
SkAutoTUnref<GrEffectRef> pmToUPMEffect1(CreateEffectRef(pmToUPM1));
SkAutoTUnref<GrEffectRef> upmToPMEffect(CreateEffectRef(upmToPM));
// The PM conversions assume colors are 0..255
return false;
}
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrConfigConversionEffect, (texture,
- swapRedAndBlue,
- pmConversion,
- matrix)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrConfigConversionEffect, (texture,
+ swapRedAndBlue,
+ pmConversion,
+ matrix)));
stage->setEffect(CreateEffectRef(effect))->unref();
return true;
}
PMConversion pmConversion,
const SkMatrix& matrix);
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
bool fSwapRedAndBlue;
PMConversion fPMConversion;
class GrGLConvolutionEffect : public GrGLEffect {
public:
- GrGLConvolutionEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLConvolutionEffect(const GrBackendEffectFactory&, const GrEffectRef&);
virtual void emitCode(GrGLShaderBuilder*,
const GrEffectStage&,
};
GrGLConvolutionEffect::GrGLConvolutionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrEffectRef& effect)
: INHERITED(factory)
, fKernelUni(kInvalidUniformHandle)
, fImageIncrementUni(kInvalidUniformHandle) {
- const GrConvolutionEffect& c =
- static_cast<const GrConvolutionEffect&>(effect);
+ const GrConvolutionEffect& c = CastEffect<GrConvolutionEffect>(effect);
fRadius = c.radius();
}
}
void GrGLConvolutionEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
- const GrConvolutionEffect& conv = static_cast<const GrConvolutionEffect&>(*stage.getEffect());
+ const GrConvolutionEffect& conv = GetEffectFromStage<GrConvolutionEffect>(stage);
GrTexture& texture = *conv.texture(0);
// the code we generated was for a specific kernel radius
GrAssert(conv.radius() == fRadius);
}
GrGLEffect::EffectKey GrGLConvolutionEffect::GenKey(const GrEffectStage& s, const GrGLCaps&) {
- const GrConvolutionEffect& conv = static_cast<const GrConvolutionEffect&>(*s.getEffect());
- EffectKey key = static_cast<const GrConvolutionEffect&>(*s.getEffect()).radius();
+ const GrConvolutionEffect& conv = GetEffectFromStage<GrConvolutionEffect>(s);
+ EffectKey key = conv.radius();
key <<= GrGLEffectMatrix::kKeyBits;
EffectKey matrixKey = GrGLEffectMatrix::GenKey(conv.getMatrix(),
s.getCoordChangeMatrix(),
return GrTBackendEffectFactory<GrConvolutionEffect>::getInstance();
}
-bool GrConvolutionEffect::onIsEqual(const GrEffect& sBase) const {
- const GrConvolutionEffect& s = static_cast<const GrConvolutionEffect&>(sBase);
+bool GrConvolutionEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrConvolutionEffect& s = CastEffect<GrConvolutionEffect>(sBase);
return (this->texture(0) == s.texture(0) &&
this->radius() == s.radius() &&
this->direction() == s.direction() &&
return GrConvolutionEffect::Create(textures[texIdx], dir, radius,kernel);
}
-
/// Convolve with an arbitrary user-specified kernel
static GrEffectRef* Create(GrTexture* tex, Direction dir, int halfWidth, const float* kernel) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrConvolutionEffect, (tex,
- dir,
- halfWidth,
- kernel)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrConvolutionEffect, (tex,
+ dir,
+ halfWidth,
+ kernel)));
return CreateEffectRef(effect);
}
/// Convolve with a Gaussian kernel
- static GrEffectRef* Create(GrTexture* tex,
- Direction dir,
- int halfWidth,
- float gaussianSigma) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrConvolutionEffect, (tex,
- dir,
- halfWidth,
- gaussianSigma)));
+ static GrEffectRef* CreateGuassian(GrTexture* tex,
+ Direction dir,
+ int halfWidth,
+ float gaussianSigma) {
+ AutoEffectUnref effect(SkNEW_ARGS(GrConvolutionEffect, (tex,
+ dir,
+ halfWidth,
+ gaussianSigma)));
return CreateEffectRef(effect);
}
int halfWidth,
float gaussianSigma);
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GR_DECLARE_EFFECT_TEST;
class GrGLSimpleTextureEffect : public GrGLEffect {
public:
- GrGLSimpleTextureEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GrGLSimpleTextureEffect(const GrBackendEffectFactory& factory, const GrEffectRef&)
: INHERITED (factory) {}
virtual void emitCode(GrGLShaderBuilder* builder,
}
static inline EffectKey GenKey(const GrEffectStage& stage, const GrGLCaps&) {
- const GrSimpleTextureEffect& ste =
- static_cast<const GrSimpleTextureEffect&>(*stage.getEffect());
+ const GrSimpleTextureEffect& ste = GetEffectFromStage<GrSimpleTextureEffect>(stage);
return GrGLEffectMatrix::GenKey(ste.getMatrix(),
stage.getCoordChangeMatrix(),
ste.texture(0));
}
virtual void setData(const GrGLUniformManager& uman, const GrEffectStage& stage) SK_OVERRIDE {
- const GrSimpleTextureEffect& ste =
- static_cast<const GrSimpleTextureEffect&>(*stage.getEffect());
+ const GrSimpleTextureEffect& ste = GetEffectFromStage<GrSimpleTextureEffect>(stage);
fEffectMatrix.setData(uman, ste.getMatrix(), stage.getCoordChangeMatrix(), ste.texture(0));
}
public:
/* unfiltered, clamp mode */
static GrEffectRef* Create(GrTexture* tex, const SkMatrix& matrix) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix)));
return CreateEffectRef(effect);
}
/* clamp mode */
static GrEffectRef* Create(GrTexture* tex, const SkMatrix& matrix, bool bilerp) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix, bilerp)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix, bilerp)));
return CreateEffectRef(effect);
}
static GrEffectRef* Create(GrTexture* tex, const SkMatrix& matrix, const GrTextureParams& p) {
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix, p)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrSimpleTextureEffect, (tex, matrix, p)));
return CreateEffectRef(effect);
}
GrSimpleTextureEffect(GrTexture* texture, const SkMatrix& matrix, const GrTextureParams& params)
: GrSingleTextureEffect(texture, matrix, params) {}
- virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const GrSimpleTextureEffect& ste = static_cast<const GrSimpleTextureEffect&>(other);
+ virtual bool onIsEqual(const GrEffectRef& other) const SK_OVERRIDE {
+ const GrSimpleTextureEffect& ste = CastEffect<GrSimpleTextureEffect>(other);
return this->hasSameTextureParamsAndMatrix(ste);
}
class GrGLTextureDomainEffect : public GrGLEffect {
public:
- GrGLTextureDomainEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLTextureDomainEffect(const GrBackendEffectFactory&, const GrEffectRef&);
virtual void emitCode(GrGLShaderBuilder*,
const GrEffectStage&,
};
GrGLTextureDomainEffect::GrGLTextureDomainEffect(const GrBackendEffectFactory& factory,
- const GrEffect&)
+ const GrEffectRef&)
: INHERITED(factory)
, fNameUni(GrGLUniformManager::kInvalidUniformHandle) {
fPrevDomain[0] = SK_FloatNaN;
const char* outputColor,
const char* inputColor,
const TextureSamplerArray& samplers) {
- const GrTextureDomainEffect& effect =
- static_cast<const GrTextureDomainEffect&>(*stage.getEffect());
+ const GrTextureDomainEffect& effect = GetEffectFromStage<GrTextureDomainEffect>(stage);
const char* coords;
fEffectMatrix.emitCodeMakeFSCoords2D(builder, key, vertexCoords, &coords);
}
void GrGLTextureDomainEffect::setData(const GrGLUniformManager& uman, const GrEffectStage& stage) {
- const GrTextureDomainEffect& effect =
- static_cast<const GrTextureDomainEffect&>(*stage.getEffect());
+ const GrTextureDomainEffect& effect = GetEffectFromStage<GrTextureDomainEffect>(stage);
const GrRect& domain = effect.domain();
float values[4] = {
}
GrGLEffect::EffectKey GrGLTextureDomainEffect::GenKey(const GrEffectStage& stage, const GrGLCaps&) {
- const GrTextureDomainEffect& effect =
- static_cast<const GrTextureDomainEffect&>(*stage.getEffect());
+ const GrTextureDomainEffect& effect = GetEffectFromStage<GrTextureDomainEffect>(stage);
EffectKey key = effect.wrapMode();
key <<= GrGLEffectMatrix::kKeyBits;
EffectKey matrixKey = GrGLEffectMatrix::GenKey(effect.getMatrix(),
GrAssert(clippedDomain.fLeft <= clippedDomain.fRight);
GrAssert(clippedDomain.fTop <= clippedDomain.fBottom);
- SkAutoTUnref<GrEffect> effect(SkNEW_ARGS(GrTextureDomainEffect, (texture,
- matrix,
- clippedDomain,
- wrapMode,
- bilerp)));
+ AutoEffectUnref effect(SkNEW_ARGS(GrTextureDomainEffect, (texture,
+ matrix,
+ clippedDomain,
+ wrapMode,
+ bilerp)));
return CreateEffectRef(effect);
}
return GrTBackendEffectFactory<GrTextureDomainEffect>::getInstance();
}
-bool GrTextureDomainEffect::onIsEqual(const GrEffect& sBase) const {
- const GrTextureDomainEffect& s = static_cast<const GrTextureDomainEffect&>(sBase);
+bool GrTextureDomainEffect::onIsEqual(const GrEffectRef& sBase) const {
+ const GrTextureDomainEffect& s = CastEffect<GrTextureDomainEffect>(sBase);
return this->hasSameTextureParamsAndMatrix(s) && this->fTextureDomain == s.fTextureDomain;
}
WrapMode,
bool bilerp);
- virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
+ virtual bool onIsEqual(const GrEffectRef&) const SK_OVERRIDE;
GR_DECLARE_EFFECT_TEST;
void GrGLEffect::setData(const GrGLUniformManager&, const GrEffectStage&) {
}
-GrGLEffect::EffectKey GrGLEffect::GenTextureKey(const GrEffect& effect,
+GrGLEffect::EffectKey GrGLEffect::GenTextureKey(const GrEffectRef* effect,
const GrGLCaps& caps) {
EffectKey key = 0;
- for (int index = 0; index < effect.numTextures(); ++index) {
- const GrTextureAccess& access = effect.textureAccess(index);
+ for (int index = 0; index < (*effect)->numTextures(); ++index) {
+ const GrTextureAccess& access = (*effect)->textureAccess(index);
EffectKey value = GrGLShaderBuilder::KeyForTextureAccess(access, caps) << index;
GrAssert(0 == (value & key)); // keys for each access ought not to overlap
key |= value;
const char* name() const { return fFactory.name(); }
- static EffectKey GenTextureKey(const GrEffect&, const GrGLCaps&);
+ static EffectKey GenTextureKey(const GrEffectRef*, const GrGLCaps&);
+
+ /**
+ * GrGLEffect subclasses get passed a GrEffectStage in their emitCode and setData functions.
+ * The GrGLEffect usually needs to cast the stage's effect to the GrEffect subclass that
+ * generated the GrGLEffect. This helper does just that.
+ */
+ template <typename T>
+ static const T& GetEffectFromStage(const GrEffectStage& effectStage) {
+ GrAssert(NULL != effectStage.getEffect());
+ return CastEffect<T>(*effectStage.getEffect());
+ }
+
+ /**
+ * Extracts the GrEffect from a GrEffectRef and down-casts to a GrEffect subclass. Usually used
+ * in a GrGLEffect subclass's constructor (which takes const GrEffectRef&).
+ */
+ template <typename T>
+ static const T& CastEffect(const GrEffectRef& effectRef) {
+ GrAssert(NULL != effectRef.get());
+ return *static_cast<const T*>(effectRef.get());
+ }
protected:
const GrBackendEffectFactory& fFactory;
for (int u = 0; u < numSamplers; ++u) {
UniformHandle handle = fUniformHandles.fSamplerUnis[s][u];
if (GrGLUniformManager::kInvalidUniformHandle != handle) {
- const GrTextureAccess& access = stage.getEffect()->textureAccess(u);
+ const GrTextureAccess& access = (*stage.getEffect())->textureAccess(u);
GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
gpu->bindTexture(texUnitIdx, access.getParams(), texture);
++texUnitIdx;
SkTArray<GrGLUniformManager::UniformHandle, true>* samplerHandles) {
GrAssert(NULL != stage.getEffect());
- const GrEffect& effect = *stage.getEffect();
- int numTextures = effect.numTextures();
+ const GrEffectRef& effect = *stage.getEffect();
+ int numTextures = effect->numTextures();
SkSTArray<8, GrGLShaderBuilder::TextureSampler> textureSamplers;
textureSamplers.push_back_n(numTextures);
for (int i = 0; i < numTextures; ++i) {
- textureSamplers[i].init(this, &effect.textureAccess(i), i);
+ textureSamplers[i].init(this, &effect->textureAccess(i), i);
samplerHandles->push_back(textureSamplers[i].fSamplerUniform);
}
- GrGLEffect* glEffect = effect.getFactory().createGLInstance(effect);
+ GrGLEffect* glEffect = effect->getFactory().createGLInstance(effect);
// Enclose custom code in a block to avoid namespace conflicts
this->fVSCode.appendf("\t{ // %s\n", glEffect->name());
bool skip = s < drawState.getFirstCoverageStage() ? skipColor : skipCoverage;
if (!skip && drawState.isStageEnabled(s)) {
lastEnabledStage = s;
- const GrEffect* effect = drawState.getStage(s).getEffect();
+ const GrEffectRef& effect = *drawState.getStage(s).getEffect();
const GrBackendEffectFactory& factory = effect->getFactory();
desc->fEffectKeys[s] = factory.glEffectKey(drawState.getStage(s), this->glCaps());
} else {
stages[s].setEffect(effect.get());
if (NULL != stages[s].getEffect()) {
pdesc.fEffectKeys[s] =
- stages[s].getEffect()->getFactory().glEffectKey(stages[s], this->glCaps());
+ (*stages[s].getEffect())->getFactory().glEffectKey(stages[s],
+ this->glCaps());
}
}
}
projects / platform / upstream / libSkiaSharp.git / commitdiff