class GrGLEffect;
class GrGLCaps;
-class GrEffect;
+class GrDrawEffect;
/**
* Used by effects to build their keys. It incorporates each per-effect key into a larger shader key.
* configuration that affect GLSL code generation. Two GrEffect instances that would cause
* this->createGLInstance()->emitCode() to produce different code must produce different keys.
*/
- virtual void getGLEffectKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*) const = 0;
+ virtual void getGLEffectKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) const = 0;
/**
* Creates a GrGLEffect instance that is used both to generate code for the GrEffect in a GLSL
* program and to manage updating uniforms for the program when it is used.
*/
- virtual GrGLEffect* createGLInstance(const GrEffect&) const = 0;
+ virtual GrGLEffect* createGLInstance(const GrDrawEffect&) const = 0;
/**
* Produces a human-reable name for the effect.
--- /dev/null
+
+#ifndef GrDrawEffect_DEFINED
+#define GrDrawEffect_DEFINED
+
+#include "GrEffectStage.h"
+
+/**
+ * This class is used to communicate the particular GrEffect used in a draw to the backend-specific
+ * effect subclass (e.g. GrGLEffect). It is used to by the backend-specific class to generate a
+ * cache key for the effect, generate code on a program cache miss, and to upload uniform values to
+ * the program.
+ * In addition to the effect, it also communicates any changes between the relationship between
+ * the view matrix and local coordinate system since the effect was installed in its GrDrawState.
+ * The typical use case is that sometime after an effect was installed a decision was made to draw
+ * in device coordinates (i.e. use an identity view-matrix). In such a case the GrDrawEffect's
+ * coord-change-matrix would be the inverse of the view matrix that was set when the effect was
+ * installed.
+ */
+class GrDrawEffect {
+public:
+ GrDrawEffect(const GrEffectStage& stage, bool explicitLocalCoords)
+ : fEffectStage(&stage)
+ , fExplicitLocalCoords(explicitLocalCoords) {
+ SkASSERT(fEffectStage);
+ SkASSERT(fEffectStage->getEffect());
+ }
+ const GrEffect* effect() const { return fEffectStage->getEffect(); }
+
+ template <typename T>
+ const T& castEffect() const { return *static_cast<const T*>(this->effect()); }
+
+ const SkMatrix& getCoordChangeMatrix() const {
+ if (fExplicitLocalCoords) {
+ return SkMatrix::I();
+ } else {
+ return fEffectStage->getCoordChangeMatrix();
+ }
+ }
+
+ bool programHasExplicitLocalCoords() const { return fExplicitLocalCoords; }
+
+private:
+ const GrEffectStage* fEffectStage;
+ bool fExplicitLocalCoords;
+};
+
+#endif
::operator delete(target, placement);
}
- /**
- * Helper for down-casting to a GrEffect subclass
- */
- template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
-
protected:
/**
* Subclasses call this from their constructor to register coordinate transformations. The
, fRequiresVertexShader(false) {}
/**
+ * Helper for down-casting to a GrEffect subclass
+ */
+ template <typename T> static const T& CastEffect(const GrEffect& effect) {
+ return *static_cast<const T*>(&effect);
+ }
+
+ /**
* If the effect subclass will read the destination pixel value then it must call this function
* from its constructor. Otherwise, when its generated backend-specific effect class attempts
* to generate code that reads the destination pixel it will fail.
#define GrTBackendEffectFactory_DEFINED
#include "GrBackendEffectFactory.h"
+#include "GrDrawEffect.h"
#include "gl/GrGLProgramEffects.h"
/**
* 1. The GrGLEffect used by GrEffect subclass MyEffect must be named or typedef'ed to
* MyEffect::GLEffect.
* 2. MyEffect::GLEffect must have a static function:
- * EffectKey GenKey(const GrEffect, const GrGLCaps&)
+ * EffectKey GenKey(const GrDrawEffect, const GrGLCaps&)
* which generates a key that maps 1 to 1 with code variations emitted by
* MyEffect::GLEffect::emitCode().
* 3. MyEffect must have a static function:
/** Implemented using GLEffect::GenKey as described in this class's comment. */
- virtual void getGLEffectKey(const GrEffect& effect,
+ virtual void getGLEffectKey(const GrDrawEffect& drawEffect,
const GrGLCaps& caps,
GrEffectKeyBuilder* b) const SK_OVERRIDE {
- GLEffect::GenKey(effect, caps, b);
+ GLEffect::GenKey(drawEffect, caps, b);
}
/** Returns a new instance of the appropriate *GL* implementation class
for the given GrEffect; caller is responsible for deleting
the object. */
- virtual GrGLEffect* createGLInstance(const GrEffect& effect) const SK_OVERRIDE {
- return SkNEW_ARGS(GLEffect, (*this, effect));
+ virtual GrGLEffect* createGLInstance(const GrDrawEffect& drawEffect) const SK_OVERRIDE {
+ return SkNEW_ARGS(GLEffect, (*this, drawEffect));
}
/** This class is a singleton. This function returns the single instance. */
class GLEffect : public GrGLEffect {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: GrGLEffect(factory) {
}
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) SK_OVERRIDE {
- SkXfermode::Mode mode = effect.cast<XferEffect>().mode();
- const GrTexture* backgroundTex =
- effect.cast<XferEffect>().backgroundAccess().getTexture();
+ SkXfermode::Mode mode = drawEffect.castEffect<XferEffect>().mode();
+ const GrTexture* backgroundTex = drawEffect.castEffect<XferEffect>().backgroundAccess().getTexture();
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
const char* dstColor;
if (backgroundTex) {
}
}
- static inline void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
// The background may come from the dst or from a texture.
- uint32_t key = effect.numTextures();
+ uint32_t key = drawEffect.effect()->numTextures();
SkASSERT(key <= 1);
- key |= effect.cast<XferEffect>().mode() << 1;
+ key |= drawEffect.castEffect<XferEffect>().mode() << 1;
b->add32(key);
}
}
}
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const XferEffect& s = other.cast<XferEffect>();
+ const XferEffect& s = CastEffect<XferEffect>(other);
return fMode == s.fMode &&
fBackgroundAccess.getTexture() == s.fBackgroundAccess.getTexture();
}
class GrGLAlphaThresholdEffect : public GrGLEffect {
public:
- GrGLAlphaThresholdEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLAlphaThresholdEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
typedef GrGLEffect INHERITED;
};
-GrGLAlphaThresholdEffect::GrGLAlphaThresholdEffect(const GrBackendEffectFactory& factory,
- const GrEffect&)
+GrGLAlphaThresholdEffect::GrGLAlphaThresholdEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED(factory) {
}
void GrGLAlphaThresholdEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GrGLAlphaThresholdEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const AlphaThresholdEffect& alpha_threshold = effect.cast<AlphaThresholdEffect>();
+ const GrDrawEffect& drawEffect) {
+ const AlphaThresholdEffect& alpha_threshold =
+ drawEffect.castEffect<AlphaThresholdEffect>();
pdman.set1f(fInnerThresholdVar, alpha_threshold.innerThreshold());
pdman.set1f(fOuterThresholdVar, alpha_threshold.outerThreshold());
}
}
bool AlphaThresholdEffect::onIsEqual(const GrEffect& sBase) const {
- const AlphaThresholdEffect& s = sBase.cast<AlphaThresholdEffect>();
+ const AlphaThresholdEffect& s = CastEffect<AlphaThresholdEffect>(sBase);
return (this->texture(0) == s.texture(0) &&
this->fInnerThreshold == s.fInnerThreshold &&
this->fOuterThreshold == s.fOuterThreshold);
class GrGLArithmeticEffect : public GrGLEffect {
public:
- GrGLArithmeticEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLArithmeticEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual ~GrGLArithmeticEffect();
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+ static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
private:
GrGLProgramDataManager::UniformHandle fKUni;
}
bool GrArithmeticEffect::onIsEqual(const GrEffect& sBase) const {
- const GrArithmeticEffect& s = sBase.cast<GrArithmeticEffect>();
+ const GrArithmeticEffect& s = CastEffect<GrArithmeticEffect>(sBase);
return fK1 == s.fK1 &&
fK2 == s.fK2 &&
fK3 == s.fK3 &&
///////////////////////////////////////////////////////////////////////////////
GrGLArithmeticEffect::GrGLArithmeticEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory),
fEnforcePMColor(true) {
}
}
void GrGLArithmeticEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- GrTexture* backgroundTex = effect.cast<GrArithmeticEffect>().backgroundTexture();
+ GrTexture* backgroundTex = drawEffect.castEffect<GrArithmeticEffect>().backgroundTexture();
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
const char* dstColor;
if (backgroundTex) {
}
}
-void GrGLArithmeticEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- const GrArithmeticEffect& arith = effect.cast<GrArithmeticEffect>();
+void GrGLArithmeticEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ const GrArithmeticEffect& arith = drawEffect.castEffect<GrArithmeticEffect>();
pdman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
fEnforcePMColor = arith.enforcePMColor();
}
-void GrGLArithmeticEffect::GenKey(const GrEffect& effect,
+void GrGLArithmeticEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
- const GrArithmeticEffect& arith = effect.cast<GrArithmeticEffect>();
+ const GrArithmeticEffect& arith = drawEffect.castEffect<GrArithmeticEffect>();
uint32_t key = arith.enforcePMColor() ? 1 : 0;
if (arith.backgroundTexture()) {
key |= 2;
class GrGLRectBlurEffect : public GrGLEffect {
public:
GrGLRectBlurEffect(const GrBackendEffectFactory& factory,
- const GrEffect&);
+ const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
-GrGLRectBlurEffect::GrGLRectBlurEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+GrGLRectBlurEffect::GrGLRectBlurEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED(factory) {
}
}
void GrGLRectBlurEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GrGLRectBlurEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrRectBlurEffect& rbe = effect.cast<GrRectBlurEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrRectBlurEffect& rbe = drawEffect.castEffect<GrRectBlurEffect>();
SkRect rect = rbe.getRect();
pdman.set4f(fProxyRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
}
bool GrRectBlurEffect::onIsEqual(const GrEffect& sBase) const {
- const GrRectBlurEffect& s = sBase.cast<GrRectBlurEffect>();
+ const GrRectBlurEffect& s = CastEffect<GrRectBlurEffect>(sBase);
return this->getSigma() == s.getSigma() && this->getRect() == s.getRect();
}
}
bool GrRRectBlurEffect::onIsEqual(const GrEffect& other) const {
- const GrRRectBlurEffect& rrbe = other.cast<GrRRectBlurEffect>();
+ const GrRRectBlurEffect& rrbe = CastEffect<GrRRectBlurEffect>(other);
return fRRect.getSimpleRadii().fX == rrbe.fRRect.getSimpleRadii().fX && fSigma == rrbe.fSigma;
}
class GrGLRRectBlurEffect : public GrGLEffect {
public:
- GrGLRRectBlurEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLRRectBlurEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fProxyRectUniform;
};
GrGLRRectBlurEffect::GrGLRRectBlurEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
}
void GrGLRRectBlurEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GrGLRRectBlurEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrRRectBlurEffect& brre = effect.cast<GrRRectBlurEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrRRectBlurEffect& brre = drawEffect.castEffect<GrRRectBlurEffect>();
SkRRect rrect = brre.getRRect();
float blurRadius = 3.f*SkScalarCeilToScalar(brre.getSigma()-1/6.0f);
class GLEffect : public GrGLEffect {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED(factory) {
}
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) SK_OVERRIDE {
- SkXfermode::Mode mode = effect.cast<ModeColorFilterEffect>().mode();
+ SkXfermode::Mode mode = drawEffect.castEffect<ModeColorFilterEffect>().mode();
SkASSERT(SkXfermode::kDst_Mode != mode);
const char* colorFilterColorUniName = NULL;
- if (effect.cast<ModeColorFilterEffect>().willUseFilterColor()) {
+ if (drawEffect.castEffect<ModeColorFilterEffect>().willUseFilterColor()) {
fFilterColorUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec4f_GrSLType, "FilterColor",
&colorFilterColorUniName);
}
GrGLSLExpr4 filter =
- color_filter_expression(mode, GrGLSLExpr4(colorFilterColorUniName),
- GrGLSLExpr4(inputColor));
+ color_filter_expression(mode, GrGLSLExpr4(colorFilterColorUniName), GrGLSLExpr4(inputColor));
builder->getFragmentShaderBuilder()->
codeAppendf("\t%s = %s;\n", outputColor, filter.c_str());
}
- static void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const ModeColorFilterEffect& colorModeFilter = effect.cast<ModeColorFilterEffect>();
+ const ModeColorFilterEffect& colorModeFilter = drawEffect.castEffect<ModeColorFilterEffect>();
// The SL code does not depend on filter color at the moment, so no need to represent it
// in the key.
b->add32(colorModeFilter.mode());
}
- virtual void setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) SK_OVERRIDE {
+ virtual void setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) SK_OVERRIDE {
if (fFilterColorUni.isValid()) {
- const ModeColorFilterEffect& colorModeFilter = effect.cast<ModeColorFilterEffect>();
+ const ModeColorFilterEffect& colorModeFilter = drawEffect.castEffect<ModeColorFilterEffect>();
GrGLfloat c[4];
GrColorToRGBAFloat(colorModeFilter.color(), c);
pdman.set4fv(fFilterColorUni, 1, c);
SkXfermode::Coeff srcCoeff;
SkAssertResult(SkXfermode::ModeAsCoeff(fMode, &srcCoeff, &dstCoeff));
// These could be calculated from the blend equation with template trickery..
- if (SkXfermode::kZero_Coeff == dstCoeff &&
- !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) {
+ if (SkXfermode::kZero_Coeff == dstCoeff && !GrBlendCoeffRefsDst(sk_blend_to_grblend(srcCoeff))) {
this->setWillNotUseInputColor();
}
}
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const ModeColorFilterEffect& s = other.cast<ModeColorFilterEffect>();
+ const ModeColorFilterEffect& s = CastEffect<ModeColorFilterEffect>(other);
return fMode == s.fMode && fColor == s.fColor;
}
class GLEffect : public GrGLEffect {
public:
// this class always generates the same code.
- static void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder* b) {}
+ static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder* b) {}
GLEffect(const GrBackendEffectFactory& factory,
- const GrEffect&)
+ const GrDrawEffect&)
: INHERITED(factory) {
}
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
}
virtual void setData(const GrGLProgramDataManager& uniManager,
- const GrEffect& effect) SK_OVERRIDE {
- const ColorMatrixEffect& cme = effect.cast<ColorMatrixEffect>();
+ const GrDrawEffect& drawEffect) SK_OVERRIDE {
+ const ColorMatrixEffect& cme = drawEffect.castEffect<ColorMatrixEffect>();
const float* m = cme.fMatrix.fMat;
// The GL matrix is transposed from SkColorMatrix.
GrGLfloat mt[] = {
ColorMatrixEffect(const SkColorMatrix& matrix) : fMatrix(matrix) {}
virtual bool onIsEqual(const GrEffect& s) const {
- const ColorMatrixEffect& cme = s.cast<ColorMatrixEffect>();
+ const ColorMatrixEffect& cme = CastEffect<ColorMatrixEffect>(s);
return cme.fMatrix == fMatrix;
}
class GrGLDisplacementMapEffect : public GrGLEffect {
public:
GrGLDisplacementMapEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrDrawEffect& drawEffect);
virtual ~GrGLDisplacementMapEffect();
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
SkDisplacementMapEffect::ChannelSelectorType fXChannelSelector;
}
bool GrDisplacementMapEffect::onIsEqual(const GrEffect& sBase) const {
- const GrDisplacementMapEffect& s = sBase.cast<GrDisplacementMapEffect>();
+ 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)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory)
- , fXChannelSelector(effect.cast<GrDisplacementMapEffect>().xChannelSelector())
- , fYChannelSelector(effect.cast<GrDisplacementMapEffect>().yChannelSelector()) {
+ , fXChannelSelector(drawEffect.castEffect<GrDisplacementMapEffect>().xChannelSelector())
+ , fYChannelSelector(drawEffect.castEffect<GrDisplacementMapEffect>().yChannelSelector()) {
}
GrGLDisplacementMapEffect::~GrGLDisplacementMapEffect() {
}
void GrGLDisplacementMapEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GrGLDisplacementMapEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrDisplacementMapEffect& displacementMap = effect.cast<GrDisplacementMapEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrDisplacementMapEffect& displacementMap =
+ drawEffect.castEffect<GrDisplacementMapEffect>();
GrTexture* colorTex = displacementMap.texture(1);
SkScalar scaleX = SkScalarDiv(displacementMap.scale().fX, SkIntToScalar(colorTex->width()));
SkScalar scaleY = SkScalarDiv(displacementMap.scale().fY, SkIntToScalar(colorTex->height()));
SkScalarToFloat(scaleY) : SkScalarToFloat(-scaleY));
}
-void GrGLDisplacementMapEffect::GenKey(const GrEffect& effect,
+void GrGLDisplacementMapEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
- const GrDisplacementMapEffect& displacementMap = effect.cast<GrDisplacementMapEffect>();
+ const GrDisplacementMapEffect& displacementMap =
+ drawEffect.castEffect<GrDisplacementMapEffect>();
uint32_t xKey = displacementMap.xChannelSelector();
uint32_t yKey = displacementMap.yChannelSelector() << kChannelSelectorKeyBits;
class GrGLLightingEffect : public GrGLEffect {
public:
GrGLLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrDrawEffect& effect);
virtual ~GrGLLightingEffect();
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder* b);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder* b);
/**
* Subclasses of GrGLLightingEffect must call INHERITED::setData();
*/
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
protected:
virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) = 0;
class GrGLDiffuseLightingEffect : public GrGLLightingEffect {
public:
GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrDrawEffect& drawEffect);
virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
typedef GrGLLightingEffect INHERITED;
class GrGLSpecularLightingEffect : public GrGLLightingEffect {
public:
GrGLSpecularLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrDrawEffect& effect);
virtual void emitLightFunc(GrGLProgramBuilder*, SkString* funcName) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
typedef GrGLLightingEffect INHERITED;
}
bool GrLightingEffect::onIsEqual(const GrEffect& sBase) const {
- const GrLightingEffect& s = sBase.cast<GrLightingEffect>();
+ const GrLightingEffect& s = CastEffect<GrLightingEffect>(sBase);
return this->texture(0) == s.texture(0) &&
fLight->isEqual(*s.fLight) &&
fSurfaceScale == s.fSurfaceScale;
}
bool GrDiffuseLightingEffect::onIsEqual(const GrEffect& sBase) const {
- const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>();
+ const GrDiffuseLightingEffect& s = CastEffect<GrDiffuseLightingEffect>(sBase);
return INHERITED::onIsEqual(sBase) &&
this->kd() == s.kd();
}
///////////////////////////////////////////////////////////////////////////////
GrGLLightingEffect::GrGLLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory) {
- const GrLightingEffect& m = effect.cast<GrLightingEffect>();
+ const GrLightingEffect& m = drawEffect.castEffect<GrLightingEffect>();
fLight = m.light()->createGLLight();
}
}
void GrGLLightingEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
fsBuilder->codeAppend(modulate.c_str());
}
-void GrGLLightingEffect::GenKey(const GrEffect& effect,
+void GrGLLightingEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps& caps, GrEffectKeyBuilder* b) {
- b->add32(effect.cast<GrLightingEffect>().light()->type());
+ b->add32(drawEffect.castEffect<GrLightingEffect>().light()->type());
}
void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrLightingEffect& lighting = effect.cast<GrLightingEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrLightingEffect& lighting = drawEffect.castEffect<GrLightingEffect>();
GrTexture* texture = lighting.texture(0);
float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f;
pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
///////////////////////////////////////////////////////////////////////////////
GrGLDiffuseLightingEffect::GrGLDiffuseLightingEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
- : INHERITED(factory, effect) {
+ const GrDrawEffect& drawEffect)
+ : INHERITED(factory, drawEffect) {
}
void GrGLDiffuseLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkString* funcName) {
}
void GrGLDiffuseLightingEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const GrDiffuseLightingEffect& diffuse = effect.cast<GrDiffuseLightingEffect>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const GrDiffuseLightingEffect& diffuse = drawEffect.castEffect<GrDiffuseLightingEffect>();
pdman.set1f(fKDUni, diffuse.kd());
}
}
bool GrSpecularLightingEffect::onIsEqual(const GrEffect& sBase) const {
- const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>();
+ 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)
- : INHERITED(factory, effect) {
+ const GrDrawEffect& drawEffect)
+ : INHERITED(factory, drawEffect) {
}
void GrGLSpecularLightingEffect::emitLightFunc(GrGLProgramBuilder* builder, SkString* funcName) {
}
void GrGLSpecularLightingEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const GrSpecularLightingEffect& spec = effect.cast<GrSpecularLightingEffect>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const GrSpecularLightingEffect& spec = drawEffect.castEffect<GrSpecularLightingEffect>();
pdman.set1f(fKSUni, spec.ks());
pdman.set1f(fShininessUni, spec.shininess());
}
class GLEffect : public GrGLEffect {
public:
GLEffect(const GrBackendEffectFactory& factory,
- const GrEffect&)
+ const GrDrawEffect&)
: INHERITED(factory) {
}
- static void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder* b) {}
+ static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder* b) {}
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
class GrGLMagnifierEffect : public GrGLEffect {
public:
- GrGLMagnifierEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLMagnifierEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
UniformHandle fOffsetVar;
typedef GrGLEffect INHERITED;
};
-GrGLMagnifierEffect::GrGLMagnifierEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+GrGLMagnifierEffect::GrGLMagnifierEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED(factory) {
}
void GrGLMagnifierEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GrGLMagnifierEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrMagnifierEffect& zoom = drawEffect.castEffect<GrMagnifierEffect>();
pdman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset());
pdman.set2f(fInvZoomVar, zoom.x_inv_zoom(), zoom.y_inv_zoom());
pdman.set2f(fInvInsetVar, zoom.x_inv_inset(), zoom.y_inv_inset());
}
bool GrMagnifierEffect::onIsEqual(const GrEffect& sBase) const {
- const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>();
+ const GrMagnifierEffect& s = CastEffect<GrMagnifierEffect>(sBase);
return (this->texture(0) == s.texture(0) &&
this->fXOffset == s.fXOffset &&
this->fYOffset == s.fYOffset &&
class GrGLMorphologyEffect : public GrGLEffect {
public:
- GrGLMorphologyEffect (const GrBackendEffectFactory&, const GrEffect&);
+ GrGLMorphologyEffect (const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder* b);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder* b);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
int width() const { return GrMorphologyEffect::WidthFromRadius(fRadius); }
};
GrGLMorphologyEffect::GrGLMorphologyEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory) {
- const GrMorphologyEffect& m = effect.cast<GrMorphologyEffect>();
+ const GrMorphologyEffect& m = drawEffect.castEffect<GrMorphologyEffect>();
fRadius = m.radius();
fType = m.type();
}
void GrGLMorphologyEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
fsBuilder->codeAppend(modulate.c_str());
}
-void GrGLMorphologyEffect::GenKey(const GrEffect& effect,
+void GrGLMorphologyEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
- const GrMorphologyEffect& m = effect.cast<GrMorphologyEffect>();
+ const GrMorphologyEffect& m = drawEffect.castEffect<GrMorphologyEffect>();
uint32_t key = static_cast<uint32_t>(m.radius());
key |= (m.type() << 8);
b->add32(key);
}
void GrGLMorphologyEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const Gr1DKernelEffect& kern = effect.cast<Gr1DKernelEffect>();
+ const GrDrawEffect& drawEffect) {
+ const Gr1DKernelEffect& kern = drawEffect.castEffect<Gr1DKernelEffect>();
GrTexture& texture = *kern.texture(0);
// the code we generated was for a specific kernel radius
SkASSERT(kern.radius() == fRadius);
}
bool GrMorphologyEffect::onIsEqual(const GrEffect& sBase) const {
- const GrMorphologyEffect& s = sBase.cast<GrMorphologyEffect>();
+ const GrMorphologyEffect& s = CastEffect<GrMorphologyEffect>(sBase);
return (this->texture(0) == s.texture(0) &&
this->radius() == s.radius() &&
this->direction() == s.direction() &&
class GrGLPerlinNoise : public GrGLEffect {
public:
GrGLPerlinNoise(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrDrawEffect& drawEffect);
virtual ~GrGLPerlinNoise() {}
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder* b);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder* b);
private:
private:
virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const GrPerlinNoiseEffect& s = sBase.cast<GrPerlinNoiseEffect>();
+ const GrPerlinNoiseEffect& s = CastEffect<GrPerlinNoiseEffect>(sBase);
return fType == s.fType &&
fPaintingData->fBaseFrequency == s.fPaintingData->fBaseFrequency &&
fNumOctaves == s.fNumOctaves &&
return effect;
}
-GrGLPerlinNoise::GrGLPerlinNoise(const GrBackendEffectFactory& factory, const GrEffect& effect)
+GrGLPerlinNoise::GrGLPerlinNoise(const GrBackendEffectFactory& factory, const GrDrawEffect& drawEffect)
: INHERITED (factory)
- , fType(effect.cast<GrPerlinNoiseEffect>().type())
- , fStitchTiles(effect.cast<GrPerlinNoiseEffect>().stitchTiles())
- , fNumOctaves(effect.cast<GrPerlinNoiseEffect>().numOctaves()) {
+ , fType(drawEffect.castEffect<GrPerlinNoiseEffect>().type())
+ , fStitchTiles(drawEffect.castEffect<GrPerlinNoiseEffect>().stitchTiles())
+ , fNumOctaves(drawEffect.castEffect<GrPerlinNoiseEffect>().numOctaves()) {
}
void GrGLPerlinNoise::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
outputColor, outputColor, outputColor, outputColor);
}
-void GrGLPerlinNoise::GenKey(const GrEffect& effect, const GrGLCaps&, GrEffectKeyBuilder* b) {
- const GrPerlinNoiseEffect& turbulence = effect.cast<GrPerlinNoiseEffect>();
+void GrGLPerlinNoise::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, GrEffectKeyBuilder* b) {
+ const GrPerlinNoiseEffect& turbulence = drawEffect.castEffect<GrPerlinNoiseEffect>();
uint32_t key = turbulence.numOctaves();
b->add32(key);
}
-void GrGLPerlinNoise::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
+void GrGLPerlinNoise::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
- const GrPerlinNoiseEffect& turbulence = effect.cast<GrPerlinNoiseEffect>();
+ const GrPerlinNoiseEffect& turbulence = drawEffect.castEffect<GrPerlinNoiseEffect>();
const SkVector& baseFrequency = turbulence.baseFrequency();
pdman.set2f(fBaseFrequencyUni, baseFrequency.fX, baseFrequency.fY);
class GLColorTableEffect : public GrGLEffect {
public:
- GLColorTableEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLColorTableEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
- static void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder* b) {}
+ static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder* b) {}
private:
typedef GrGLEffect INHERITED;
};
-GLColorTableEffect::GLColorTableEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+GLColorTableEffect::GLColorTableEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED(factory) {
}
void GLColorTableEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
}
void GrGLGradientEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
+ const GrDrawEffect& drawEffect) {
- const GrGradientEffect& e = effect.cast<GrGradientEffect>();
+ const GrGradientEffect& e = drawEffect.castEffect<GrGradientEffect>();
if (SkGradientShaderBase::kTwo_GpuColorType == e.getColorType()){
}
-uint32_t GrGLGradientEffect::GenBaseGradientKey(const GrEffect& effect) {
- const GrGradientEffect& e = effect.cast<GrGradientEffect>();
+uint32_t GrGLGradientEffect::GenBaseGradientKey(const GrDrawEffect& drawEffect) {
+ const GrGradientEffect& e = drawEffect.castEffect<GrGradientEffect>();
uint32_t key = 0;
}
bool GrGradientEffect::onIsEqual(const GrEffect& effect) const {
- const GrGradientEffect& s = effect.cast<GrGradientEffect>();
+ const GrGradientEffect& s = CastEffect<GrGradientEffect>(effect);
if (this->fColorType == s.getColorType()){
GrGLGradientEffect(const GrBackendEffectFactory& factory);
virtual ~GrGLGradientEffect();
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
protected:
/**
* by the base class. The subclasses must stick it in their key and then pass it to the below
* emit* functions from their emitCode function.
*/
- static uint32_t GenBaseGradientKey(const GrEffect&);
+ static uint32_t GenBaseGradientKey(const GrDrawEffect&);
// Emits the uniform used as the y-coord to texture samples in derived classes. Subclasses
// should call this method from their emitCode().
class GrGLLinearGradient : public GrGLGradientEffect {
public:
- GrGLLinearGradient(const GrBackendEffectFactory& factory, const GrEffect&)
+ GrGLLinearGradient(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) { }
virtual ~GrGLLinearGradient() { }
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static void GenKey(const GrEffect& effect, const GrGLCaps&, GrEffectKeyBuilder* b) {
- b->add32(GenBaseGradientKey(effect));
+ static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, GrEffectKeyBuilder* b) {
+ b->add32(GenBaseGradientKey(drawEffect));
}
private:
/////////////////////////////////////////////////////////////////////
void GrGLLinearGradient::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
public:
GrGLRadialGradient(const GrBackendEffectFactory& factory,
- const GrEffect&) : INHERITED (factory) { }
+ const GrDrawEffect&) : INHERITED (factory) { }
virtual ~GrGLRadialGradient() { }
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static void GenKey(const GrEffect& effect, const GrGLCaps&, GrEffectKeyBuilder* b) {
- b->add32(GenBaseGradientKey(effect));
+ static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, GrEffectKeyBuilder* b) {
+ b->add32(GenBaseGradientKey(drawEffect));
}
private:
/////////////////////////////////////////////////////////////////////
void GrGLRadialGradient::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
public:
GrGLSweepGradient(const GrBackendEffectFactory& factory,
- const GrEffect&) : INHERITED (factory) { }
+ const GrDrawEffect&) : INHERITED (factory) { }
virtual ~GrGLSweepGradient() { }
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static void GenKey(const GrEffect& effect, const GrGLCaps&, GrEffectKeyBuilder* b) {
- b->add32(GenBaseGradientKey(effect));
+ static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&, GrEffectKeyBuilder* b) {
+ b->add32(GenBaseGradientKey(drawEffect));
}
private:
/////////////////////////////////////////////////////////////////////
void GrGLSweepGradient::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
private:
virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const Edge2PtConicalEffect& s = sBase.cast<Edge2PtConicalEffect>();
+ const Edge2PtConicalEffect& s = CastEffect<Edge2PtConicalEffect>(sBase);
return (INHERITED::onIsEqual(sBase) &&
this->fCenterX1 == s.fCenterX1 &&
this->fRadius0 == s.fRadius0 &&
class GLEdge2PtConicalEffect : public GrGLGradientEffect {
public:
- GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+ GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
virtual ~GLEdge2PtConicalEffect() { }
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+ static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
protected:
UniformHandle fParamUni;
}
GLEdge2PtConicalEffect::GLEdge2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedDiffRadius(-SK_ScalarMax) {}
void GLEdge2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
if (kVec3f_GrSLType == coords[0].type()) {
fsBuilder->codeAppendf("\tvec3 interpolants = vec3(%s.xy / %s.z, %s.x / %s.z);\n",
- coords[0].c_str(), coords[0].c_str(), coords[1].c_str(),
- coords[1].c_str());
+ coords[0].c_str(), coords[0].c_str(), coords[1].c_str(), coords[1].c_str());
coords2D = "interpolants.xy";
bVar = "interpolants.z";
} else {
}
void GLEdge2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const Edge2PtConicalEffect& data = effect.cast<Edge2PtConicalEffect>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const Edge2PtConicalEffect& data = drawEffect.castEffect<Edge2PtConicalEffect>();
SkScalar radius0 = data.radius();
SkScalar diffRadius = data.diffRadius();
}
}
-void GLEdge2PtConicalEffect::GenKey(const GrEffect& effect,
+void GLEdge2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
- b->add32(GenBaseGradientKey(effect));
+ b->add32(GenBaseGradientKey(drawEffect));
}
//////////////////////////////////////////////////////////////////////////////
private:
virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const FocalOutside2PtConicalEffect& s = sBase.cast<FocalOutside2PtConicalEffect>();
+ const FocalOutside2PtConicalEffect& s = CastEffect<FocalOutside2PtConicalEffect>(sBase);
return (INHERITED::onIsEqual(sBase) &&
this->fFocalX == s.fFocalX &&
this->fIsFlipped == s.fIsFlipped);
class GLFocalOutside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+ GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
virtual ~GLFocalOutside2PtConicalEffect() { }
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+ static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
protected:
UniformHandle fParamUni;
}
GLFocalOutside2PtConicalEffect::GLFocalOutside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedFocal(SK_ScalarMax) {
- const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConicalEffect>();
+ const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutside2PtConicalEffect>();
fIsFlipped = data.isFlipped();
}
void GLFocalOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GLFocalOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const FocalOutside2PtConicalEffect& data = effect.cast<FocalOutside2PtConicalEffect>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const FocalOutside2PtConicalEffect& data = drawEffect.castEffect<FocalOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
SkScalar focal = data.focal();
}
}
-void GLFocalOutside2PtConicalEffect::GenKey(const GrEffect& effect,
+void GLFocalOutside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
uint32_t* key = b->add32n(2);
- key[0] = GenBaseGradientKey(effect);
- key[1] = effect.cast<FocalOutside2PtConicalEffect>().isFlipped();
+ key[0] = GenBaseGradientKey(drawEffect);
+ key[1] = drawEffect.castEffect<FocalOutside2PtConicalEffect>().isFlipped();
}
//////////////////////////////////////////////////////////////////////////////
private:
virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const FocalInside2PtConicalEffect& s = sBase.cast<FocalInside2PtConicalEffect>();
+ const FocalInside2PtConicalEffect& s = CastEffect<FocalInside2PtConicalEffect>(sBase);
return (INHERITED::onIsEqual(sBase) &&
this->fFocalX == s.fFocalX);
}
class GLFocalInside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+ GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
virtual ~GLFocalInside2PtConicalEffect() {}
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+ static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
protected:
UniformHandle fFocalUni;
}
GLFocalInside2PtConicalEffect::GLFocalInside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedFocal(SK_ScalarMax) {}
void GLFocalInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GLFocalInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const FocalInside2PtConicalEffect& data = effect.cast<FocalInside2PtConicalEffect>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const FocalInside2PtConicalEffect& data = drawEffect.castEffect<FocalInside2PtConicalEffect>();
SkScalar focal = data.focal();
if (fCachedFocal != focal) {
}
}
-void GLFocalInside2PtConicalEffect::GenKey(const GrEffect& effect,
+void GLFocalInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
- b->add32(GenBaseGradientKey(effect));
+ b->add32(GenBaseGradientKey(drawEffect));
}
//////////////////////////////////////////////////////////////////////////////
private:
virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const CircleInside2PtConicalEffect& s = sBase.cast<CircleInside2PtConicalEffect>();
+ const CircleInside2PtConicalEffect& s = CastEffect<CircleInside2PtConicalEffect>(sBase);
return (INHERITED::onIsEqual(sBase) &&
this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
this->fInfo.fA == s.fInfo.fA &&
class GLCircleInside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+ GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
virtual ~GLCircleInside2PtConicalEffect() {}
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+ static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
protected:
UniformHandle fCenterUni;
}
GLCircleInside2PtConicalEffect::GLCircleInside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedC(SK_ScalarMax) {}
void GLCircleInside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
// d = dot(e, p) + B
// t = d +/- sqrt(d^2 - A * dot(p, p) + C)
fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
- fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
- params.c_str());
+ fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(), params.c_str());
fsBuilder->codeAppendf("\tfloat %s = d + sqrt(d * d - %s.x * pDotp + %s.z);\n",
tName.c_str(), params.c_str(), params.c_str());
}
void GLCircleInside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const CircleInside2PtConicalEffect& data = effect.cast<CircleInside2PtConicalEffect>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const CircleInside2PtConicalEffect& data = drawEffect.castEffect<CircleInside2PtConicalEffect>();
SkScalar centerX = data.centerX();
SkScalar centerY = data.centerY();
SkScalar A = data.A();
}
}
-void GLCircleInside2PtConicalEffect::GenKey(const GrEffect& effect,
+void GLCircleInside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
- b->add32(GenBaseGradientKey(effect));
+ b->add32(GenBaseGradientKey(drawEffect));
}
//////////////////////////////////////////////////////////////////////////////
private:
virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const CircleOutside2PtConicalEffect& s = sBase.cast<CircleOutside2PtConicalEffect>();
+ const CircleOutside2PtConicalEffect& s = CastEffect<CircleOutside2PtConicalEffect>(sBase);
return (INHERITED::onIsEqual(sBase) &&
this->fInfo.fCenterEnd == s.fInfo.fCenterEnd &&
this->fInfo.fA == s.fInfo.fA &&
const CircleConicalInfo& info)
: INHERITED(ctx, shader, matrix, tm), fInfo(info) {
if (shader.getStartRadius() != shader.getEndRadius()) {
- fTLimit = SkScalarDiv(shader.getStartRadius(),
- (shader.getStartRadius() - shader.getEndRadius()));
+ fTLimit = SkScalarDiv(shader.getStartRadius(), (shader.getStartRadius() - shader.getEndRadius()));
} else {
fTLimit = SK_ScalarMin;
}
class GLCircleOutside2PtConicalEffect : public GrGLGradientEffect {
public:
- GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrEffect&);
+ GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&);
virtual ~GLCircleOutside2PtConicalEffect() {}
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+ static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
protected:
UniformHandle fCenterUni;
}
GLCircleOutside2PtConicalEffect::GLCircleOutside2PtConicalEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedB(SK_ScalarMax)
, fCachedC(SK_ScalarMax)
, fCachedTLimit(SK_ScalarMax) {
- const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConicalEffect>();
+ const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOutside2PtConicalEffect>();
fIsFlipped = data.isFlipped();
}
void GLCircleOutside2PtConicalEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
// t = d +/- sqrt(d^2 - A * dot(p, p) + C)
fsBuilder->codeAppendf("\tfloat pDotp = dot(%s, %s);\n", coords2D, coords2D);
- fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(),
- params.c_str());
- fsBuilder->codeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", params.c_str(),
- params.c_str());
+ fsBuilder->codeAppendf("\tfloat d = dot(%s, %s) + %s.y;\n", coords2D, center.c_str(), params.c_str());
+ fsBuilder->codeAppendf("\tfloat deter = d * d - %s.x * pDotp + %s.z;\n", params.c_str(), params.c_str());
// Must check to see if we flipped the circle order (to make sure start radius < end radius)
// If so we must also flip sign on sqrt
}
void GLCircleOutside2PtConicalEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const CircleOutside2PtConicalEffect& data = effect.cast<CircleOutside2PtConicalEffect>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const CircleOutside2PtConicalEffect& data = drawEffect.castEffect<CircleOutside2PtConicalEffect>();
SkASSERT(data.isFlipped() == fIsFlipped);
SkScalar centerX = data.centerX();
SkScalar centerY = data.centerY();
}
}
-void GLCircleOutside2PtConicalEffect::GenKey(const GrEffect& effect,
+void GLCircleOutside2PtConicalEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
uint32_t* key = b->add32n(2);
- key[0] = GenBaseGradientKey(effect);
- key[1] = effect.cast<CircleOutside2PtConicalEffect>().isFlipped();
+ key[0] = GenBaseGradientKey(drawEffect);
+ key[1] = drawEffect.castEffect<CircleOutside2PtConicalEffect>().isFlipped();
}
//////////////////////////////////////////////////////////////////////////////
public:
- GrGLRadial2Gradient(const GrBackendEffectFactory& factory, const GrEffect&);
+ GrGLRadial2Gradient(const GrBackendEffectFactory& factory, const GrDrawEffect&);
virtual ~GrGLRadial2Gradient() { }
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static void GenKey(const GrEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
+ static void GenKey(const GrDrawEffect&, const GrGLCaps& caps, GrEffectKeyBuilder* b);
protected:
private:
virtual bool onIsEqual(const GrEffect& sBase) const SK_OVERRIDE {
- const GrRadial2Gradient& s = sBase.cast<GrRadial2Gradient>();
+ 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& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory)
, fVSVaryingName(NULL)
, fFSVaryingName(NULL)
, fCachedRadius(-SK_ScalarMax)
, fCachedPosRoot(0) {
- const GrRadial2Gradient& data = effect.cast<GrRadial2Gradient>();
+ const GrRadial2Gradient& data = drawEffect.castEffect<GrRadial2Gradient>();
fIsDegenerate = data.isDegenerate();
}
void GrGLRadial2Gradient::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GrGLRadial2Gradient::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- INHERITED::setData(pdman, effect);
- const GrRadial2Gradient& data = effect.cast<GrRadial2Gradient>();
+ const GrDrawEffect& drawEffect) {
+ INHERITED::setData(pdman, drawEffect);
+ const GrRadial2Gradient& data = drawEffect.castEffect<GrRadial2Gradient>();
SkASSERT(data.isDegenerate() == fIsDegenerate);
SkScalar centerX1 = data.center();
SkScalar radius0 = data.radius();
}
}
-void GrGLRadial2Gradient::GenKey(const GrEffect& effect,
+void GrGLRadial2Gradient::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
uint32_t* key = b->add32n(2);
- key[0] = GenBaseGradientKey(effect);
- key[1] = effect.cast<GrRadial2Gradient>().isDegenerate();
+ key[0] = GenBaseGradientKey(drawEffect);
+ key[1] = drawEffect.castEffect<GrRadial2Gradient>().isDegenerate();
}
/////////////////////////////////////////////////////////////////////
class GLEffect : public GrGLGeometryProcessor {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
- const GrShaderVar& inQuadEdge = effect.cast<QuadEdgeEffect>().inQuadEdge();
+ const GrShaderVar& inQuadEdge = drawEffect.castEffect<QuadEdgeEffect>().inQuadEdge();
GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
vsBuilder->codeAppendf("\t%s = %s;\n", vsName, inQuadEdge.c_str());
}
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
typedef GrGLGeometryProcessor INHERITED;
class GLEffect : public GrGLGeometryProcessor {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const char *vsRectName, *fsRectName;
builder->addVarying(kVec4f_GrSLType, "Rect", &vsRectName, &fsRectName);
- const GrShaderVar& inRect = effect.cast<GrAlignedRectEffect>().inRect();
+ const GrShaderVar& inRect = drawEffect.castEffect<GrAlignedRectEffect>().inRect();
GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
vsBuilder->codeAppendf("\t%s = %s;\n", vsRectName, inRect.c_str());
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("coverage")).c_str());
}
- static void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
+ static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
- virtual void setData(const GrGLProgramDataManager& pdman, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager& pdman, const GrDrawEffect&) SK_OVERRIDE {}
private:
typedef GrGLGeometryProcessor INHERITED;
class GLEffect : public GrGLGeometryProcessor {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
builder->addVarying(kVec4f_GrSLType, "RectEdge",
&vsRectEdgeName, &fsRectEdgeName);
- const GrRectEffect& rectEffect = effect.cast<GrRectEffect>();
+ const GrRectEffect& rectEffect = drawEffect.castEffect<GrRectEffect>();
GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
vsBuilder->codeAppendf("%s = %s;", vsRectEdgeName, rectEffect.inRectEdge().c_str());
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("coverage")).c_str());
}
- static void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
+ static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
- virtual void setData(const GrGLProgramDataManager& pdman, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager& pdman, const GrDrawEffect&) SK_OVERRIDE {}
private:
typedef GrGLGeometryProcessor INHERITED;
class GLEffect : public GrGLGeometryProcessor {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
- const CircleEdgeEffect& circleEffect = effect.cast<CircleEdgeEffect>();
+ const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleEdgeEffect>();
const char *vsName, *fsName;
builder->addVarying(kVec4f_GrSLType, "CircleEdge", &vsName, &fsName);
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
}
- static void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const CircleEdgeEffect& circleEffect = effect.cast<CircleEdgeEffect>();
+ const CircleEdgeEffect& circleEffect = drawEffect.castEffect<CircleEdgeEffect>();
b->add32(circleEffect.isStroked());
}
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
typedef GrGLGeometryProcessor INHERITED;
}
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const CircleEdgeEffect& cee = other.cast<CircleEdgeEffect>();
+ const CircleEdgeEffect& cee = CastEffect<CircleEdgeEffect>(other);
return cee.fStroke == fStroke;
}
class GLEffect : public GrGLGeometryProcessor {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
- const EllipseEdgeEffect& ellipseEffect = effect.cast<EllipseEdgeEffect>();
+ const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<EllipseEdgeEffect>();
const char *vsOffsetName, *fsOffsetName;
const char *vsRadiiName, *fsRadiiName;
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
}
- static void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const EllipseEdgeEffect& ellipseEffect = effect.cast<EllipseEdgeEffect>();
+ const EllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<EllipseEdgeEffect>();
b->add32(ellipseEffect.isStroked());
}
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {
}
private:
}
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const EllipseEdgeEffect& eee = other.cast<EllipseEdgeEffect>();
+ const EllipseEdgeEffect& eee = CastEffect<EllipseEdgeEffect>(other);
return eee.fStroke == fStroke;
}
class GLEffect : public GrGLGeometryProcessor {
public:
- GLEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
- const DIEllipseEdgeEffect& ellipseEffect = effect.cast<DIEllipseEdgeEffect>();
+ const DIEllipseEdgeEffect& ellipseEffect = drawEffect.castEffect<DIEllipseEdgeEffect>();
const char *vsOffsetName0, *fsOffsetName0;
builder->addVarying(kVec2f_GrSLType, "EllipseOffsets0",
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
}
- static void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const DIEllipseEdgeEffect& ellipseEffect = effect.cast<DIEllipseEdgeEffect>();
+ const DIEllipseEdgeEffect& ellipseEffect =
+ drawEffect.castEffect<DIEllipseEdgeEffect>();
b->add32(ellipseEffect.getMode());
}
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {
}
private:
}
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const DIEllipseEdgeEffect& eee = other.cast<DIEllipseEdgeEffect>();
+ const DIEllipseEdgeEffect& eee = CastEffect<DIEllipseEdgeEffect>(other);
return eee.fMode == fMode;
}
class GrGLConicEffect : public GrGLGeometryProcessor {
public:
- GrGLConicEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLConicEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
GrEffectEdgeType fEdgeType;
};
GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
- const GrConicEffect& ce = effect.cast<GrConicEffect>();
+ const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>();
fEdgeType = ce.getEdgeType();
}
void GrGLConicEffect::emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
builder->addVarying(kVec4f_GrSLType, "ConicCoeffs",
&vsName, &fsName);
- const GrShaderVar& inConicCoeffs = effect.cast<GrConicEffect>().inConicCoeffs();
+ const GrShaderVar& inConicCoeffs = drawEffect.castEffect<GrConicEffect>().inConicCoeffs();
GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
vsBuilder->codeAppendf("%s = %s;", vsName, inConicCoeffs.c_str());
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
}
-void GrGLConicEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrConicEffect& ce = effect.cast<GrConicEffect>();
+ const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>();
uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
b->add32(key);
}
}
bool GrConicEffect::onIsEqual(const GrEffect& other) const {
- const GrConicEffect& ce = other.cast<GrConicEffect>();
+ const GrConicEffect& ce = CastEffect<GrConicEffect>(other);
return (ce.fEdgeType == fEdgeType);
}
class GrGLQuadEffect : public GrGLGeometryProcessor {
public:
- GrGLQuadEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLQuadEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
GrEffectEdgeType fEdgeType;
};
GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
- const GrQuadEffect& ce = effect.cast<GrQuadEffect>();
+ const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>();
fEdgeType = ce.getEdgeType();
}
void GrGLQuadEffect::emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName);
GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
- const GrShaderVar& inHairQuadEdge = effect.cast<GrQuadEffect>().inHairQuadEdge();
+ const GrShaderVar& inHairQuadEdge = drawEffect.castEffect<GrQuadEffect>().inHairQuadEdge();
vsBuilder->codeAppendf("%s = %s;", vsName, inHairQuadEdge.c_str());
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("edgeAlpha")).c_str());
}
-void GrGLQuadEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrQuadEffect& ce = effect.cast<GrQuadEffect>();
+ const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>();
uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
b->add32(key);
}
}
bool GrQuadEffect::onIsEqual(const GrEffect& other) const {
- const GrQuadEffect& ce = other.cast<GrQuadEffect>();
+ const GrQuadEffect& ce = CastEffect<GrQuadEffect>(other);
return (ce.fEdgeType == fEdgeType);
}
class GrGLCubicEffect : public GrGLGeometryProcessor {
public:
- GrGLCubicEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLCubicEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE {}
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
GrEffectEdgeType fEdgeType;
};
GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
- const GrCubicEffect& ce = effect.cast<GrCubicEffect>();
+ const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>();
fEdgeType = ce.getEdgeType();
}
void GrGLCubicEffect::emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
&vsName, &fsName, GrGLShaderVar::kHigh_Precision);
GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
- const GrShaderVar& inCubicCoeffs = effect.cast<GrCubicEffect>().inCubicCoeffs();
+ const GrShaderVar& inCubicCoeffs = drawEffect.castEffect<GrCubicEffect>().inCubicCoeffs();
vsBuilder->codeAppendf("%s = %s;", vsName, inCubicCoeffs.c_str());
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
(GrGLSLExpr4(inputColor) * GrGLSLExpr1(edgeAlpha.c_str())).c_str());
}
-void GrGLCubicEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrCubicEffect& ce = effect.cast<GrCubicEffect>();
+ const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>();
uint32_t key = ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
b->add32(key);
}
}
bool GrCubicEffect::onIsEqual(const GrEffect& other) const {
- const GrCubicEffect& ce = other.cast<GrCubicEffect>();
+ const GrCubicEffect& ce = CastEffect<GrCubicEffect>(other);
return (ce.fEdgeType == fEdgeType);
}
class GrGLBicubicEffect : public GrGLEffect {
public:
GrGLBicubicEffect(const GrBackendEffectFactory& factory,
- const GrEffect&);
+ const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrTextureDomain& domain = effect.cast<GrBicubicEffect>().domain();
+ const GrTextureDomain& domain = drawEffect.castEffect<GrBicubicEffect>().domain();
b->add32(GrTextureDomain::GLDomain::DomainKey(domain));
}
typedef GrGLEffect INHERITED;
};
-GrGLBicubicEffect::GrGLBicubicEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+GrGLBicubicEffect::GrGLBicubicEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED(factory) {
}
void GrGLBicubicEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrTextureDomain& domain = effect.cast<GrBicubicEffect>().domain();
+ const GrTextureDomain& domain = drawEffect.castEffect<GrBicubicEffect>().domain();
fCoefficientsUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kMat44f_GrSLType, "Coefficients");
}
void GrGLBicubicEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrBicubicEffect& bicubicEffect = effect.cast<GrBicubicEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrBicubicEffect& effect = drawEffect.castEffect<GrBicubicEffect>();
const GrTexture& texture = *effect.texture(0);
float imageIncrement[2];
imageIncrement[0] = 1.0f / texture.width();
imageIncrement[1] = 1.0f / texture.height();
pdman.set2fv(fImageIncrementUni, 1, imageIncrement);
- pdman.setMatrix4f(fCoefficientsUni, bicubicEffect.coefficients());
- fDomain.setData(pdman, bicubicEffect.domain(), texture.origin());
+ pdman.setMatrix4f(fCoefficientsUni, effect.coefficients());
+ fDomain.setData(pdman, effect.domain(), texture.origin());
}
static inline void convert_row_major_scalar_coeffs_to_column_major_floats(float dst[16],
}
bool GrBicubicEffect::onIsEqual(const GrEffect& sBase) const {
- const GrBicubicEffect& s = sBase.cast<GrBicubicEffect>();
+ const GrBicubicEffect& s = CastEffect<GrBicubicEffect>(sBase);
return this->textureAccess(0) == s.textureAccess(0) &&
!memcmp(fCoefficients, s.coefficients(), 16) &&
fDomain == s.fDomain;
#include "GrSingleTextureEffect.h"
#include "GrTextureDomain.h"
+#include "GrDrawEffect.h"
#include "gl/GrGLEffect.h"
#include "GrTBackendEffectFactory.h"
class GrGLConfigConversionEffect : public GrGLEffect {
public:
GrGLConfigConversionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
- const GrConfigConversionEffect& configConversionEffect = effect.cast<GrConfigConversionEffect>();
- fSwapRedAndBlue = configConversionEffect.swapsRedAndBlue();
- fPMConversion = configConversionEffect.pmConversion();
+ const GrConfigConversionEffect& effect = drawEffect.castEffect<GrConfigConversionEffect>();
+ fSwapRedAndBlue = effect.swapsRedAndBlue();
+ fPMConversion = effect.pmConversion();
}
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
fsBuilder->codeAppend(modulate.c_str());
}
- static inline void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrConfigConversionEffect& conv = effect.cast<GrConfigConversionEffect>();
+ const GrConfigConversionEffect& conv = drawEffect.castEffect<GrConfigConversionEffect>();
uint32_t key = (conv.swapsRedAndBlue() ? 0 : 1) | (conv.pmConversion() << 1);
b->add32(key);
}
}
bool GrConfigConversionEffect::onIsEqual(const GrEffect& s) const {
- const GrConfigConversionEffect& other = s.cast<GrConfigConversionEffect>();
+ const GrConfigConversionEffect& other = CastEffect<GrConfigConversionEffect>(s);
return this->texture(0) == s.texture(0) &&
other.fSwapRedAndBlue == fSwapRedAndBlue &&
other.fPMConversion == fPMConversion;
}
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const AARectEffect& aare = other.cast<AARectEffect>();
+ const AARectEffect& aare = CastEffect<AARectEffect>(other);
return fRect == aare.fRect;
}
class GLAARectEffect : public GrGLEffect {
public:
- GLAARectEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLAARectEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fRectUniform;
};
GLAARectEffect::GLAARectEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevRect.fLeft = SK_ScalarNaN;
}
void GLAARectEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const AARectEffect& aare =
effect.cast<AARectEffect>();
+ const AARectEffect& aare =
drawEffect.castEffect<AARectEffect>();
const char *rectName;
// The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
// respectively.
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GLAARectEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- const AARectEffect& aare =
effect.cast<AARectEffect>();
+void GLAARectEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ const AARectEffect& aare =
drawEffect.castEffect<AARectEffect>();
const SkRect& rect = aare.getRect();
if (rect != fPrevRect) {
pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f,
}
}
-void GLAARectEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GLAARectEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const AARectEffect& aare =
effect.cast<AARectEffect>();
+ const AARectEffect& aare =
drawEffect.castEffect<AARectEffect>();
b->add32(aare.getEdgeType());
}
class GrGLConvexPolyEffect : public GrGLEffect {
public:
- GrGLConvexPolyEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLConvexPolyEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fEdgeUniform;
};
GrGLConvexPolyEffect::GrGLConvexPolyEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevEdges[0] = SK_ScalarNaN;
}
void GrGLConvexPolyEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>();
+ const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>();
const char *edgeArrayName;
fEdgeUniform = builder->addUniformArray(GrGLProgramBuilder::kFragment_Visibility,
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GrGLConvexPolyEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>();
+void GrGLConvexPolyEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>();
size_t byteSize = 3 * cpe.getEdgeCount() * sizeof(SkScalar);
if (0 != memcmp(fPrevEdges, cpe.getEdges(), byteSize)) {
pdman.set3fv(fEdgeUniform, cpe.getEdgeCount(), cpe.getEdges());
}
}
-void GrGLConvexPolyEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GrGLConvexPolyEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrConvexPolyEffect& cpe = effect.cast<GrConvexPolyEffect>();
+ const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>();
GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8);
uint32_t key = (cpe.getEdgeCount() << 3) | cpe.getEdgeType();
b->add32(key);
}
bool GrConvexPolyEffect::onIsEqual(const GrEffect& other) const {
- const GrConvexPolyEffect& cpe = other.cast<GrConvexPolyEffect>();
+ const GrConvexPolyEffect& cpe = CastEffect<GrConvexPolyEffect>(other);
// ignore the fact that 0 == -0 and just use memcmp.
return (cpe.fEdgeType == fEdgeType && cpe.fEdgeCount == fEdgeCount &&
0 == memcmp(cpe.fEdges, fEdges, 3 * fEdgeCount * sizeof(SkScalar)));
class GrGLConvolutionEffect : public GrGLEffect {
public:
- GrGLConvolutionEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLConvolutionEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager& pdman, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager& pdman, const GrDrawEffect&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
private:
int width() const { return Gr1DKernelEffect::WidthFromRadius(fRadius); }
};
GrGLConvolutionEffect::GrGLConvolutionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory) {
- const GrConvolutionEffect& c = effect.cast<GrConvolutionEffect>();
+ const GrConvolutionEffect& c = drawEffect.castEffect<GrConvolutionEffect>();
fRadius = c.radius();
fUseBounds = c.useBounds();
fDirection = c.direction();
}
void GrGLConvolutionEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
void GrGLConvolutionEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrConvolutionEffect& conv = effect.cast<GrConvolutionEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrConvolutionEffect& conv = drawEffect.castEffect<GrConvolutionEffect>();
GrTexture& texture = *conv.texture(0);
// the code we generated was for a specific kernel radius
SkASSERT(conv.radius() == fRadius);
pdman.set1fv(fKernelUni, this->width(), conv.kernel());
}
-void GrGLConvolutionEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GrGLConvolutionEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrConvolutionEffect& conv = effect.cast<GrConvolutionEffect>();
+ const GrConvolutionEffect& conv = drawEffect.castEffect<GrConvolutionEffect>();
uint32_t key = conv.radius();
key <<= 2;
if (conv.useBounds()) {
}
bool GrConvolutionEffect::onIsEqual(const GrEffect& sBase) const {
- const GrConvolutionEffect& s = sBase.cast<GrConvolutionEffect>();
+ const GrConvolutionEffect& s = CastEffect<GrConvolutionEffect>(sBase);
return (this->texture(0) == s.texture(0) &&
this->radius() == s.radius() &&
this->direction() == s.direction() &&
class GrGLCustomCoordsTextureEffect : public GrGLGeometryProcessor {
public:
- GrGLCustomCoordsTextureEffect(const GrBackendEffectFactory& factory, const GrEffect& effect)
+ GrGLCustomCoordsTextureEffect(const GrBackendEffectFactory& factory, const GrDrawEffect& drawEffect)
: INHERITED (factory) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
const GrCustomCoordsTextureEffect& customCoordsTextureEffect =
- effect.cast<GrCustomCoordsTextureEffect>();
+ drawEffect.castEffect<GrCustomCoordsTextureEffect>();
SkASSERT(1 == customCoordsTextureEffect.getVertexAttribs().count());
SkString fsCoordName;
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) SK_OVERRIDE {}
+ const GrDrawEffect& drawEffect) SK_OVERRIDE {}
private:
typedef GrGLGeometryProcessor INHERITED;
}
bool GrCustomCoordsTextureEffect::onIsEqual(const GrEffect& other) const {
- const GrCustomCoordsTextureEffect& cte = other.cast<GrCustomCoordsTextureEffect>();
+ const GrCustomCoordsTextureEffect& cte = CastEffect<GrCustomCoordsTextureEffect>(other);
return fTextureAccess == cte.fTextureAccess;
}
class GLDashingCircleEffect : public GrGLGeometryProcessor {
public:
- GLDashingCircleEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLDashingCircleEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fParamUniform;
};
GLDashingCircleEffect::GLDashingCircleEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevRadius = SK_ScalarMin;
fPrevCenterX = SK_ScalarMin;
}
void GLDashingCircleEffect::emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const DashingCircleEffect& dce = effect.cast<DashingCircleEffect>();
+ const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>();
const char *paramName;
// The param uniforms, xyz, refer to circle radius - 0.5, cicles center x coord, and
// the total interval length of the dash.
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- const DashingCircleEffect& dce = effect.cast<DashingCircleEffect>();
+void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>();
SkScalar radius = dce.getRadius();
SkScalar centerX = dce.getCenterX();
SkScalar intervalLength = dce.getIntervalLength();
}
}
-void GLDashingCircleEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GLDashingCircleEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const DashingCircleEffect& dce = effect.cast<DashingCircleEffect>();
+ const DashingCircleEffect& dce = drawEffect.castEffect<DashingCircleEffect>();
b->add32(dce.getEdgeType());
}
}
bool DashingCircleEffect::onIsEqual(const GrEffect& other) const {
- const DashingCircleEffect& dce = other.cast<DashingCircleEffect>();
+ const DashingCircleEffect& dce = CastEffect<DashingCircleEffect>(other);
return (fEdgeType == dce.fEdgeType &&
fIntervalLength == dce.fIntervalLength &&
fRadius == dce.fRadius &&
class GLDashingLineEffect : public GrGLGeometryProcessor {
public:
- GLDashingLineEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLDashingLineEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fRectUniform;
};
GLDashingLineEffect::GLDashingLineEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevRect.fLeft = SK_ScalarNaN;
fPrevIntervalLength = SK_ScalarMax;
}
void GLDashingLineEffect::emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const DashingLineEffect& de = effect.cast<DashingLineEffect>();
+ const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>();
const char *rectName;
// The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
// respectively.
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- const DashingLineEffect& de = effect.cast<DashingLineEffect>();
+void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>();
const SkRect& rect = de.getRect();
SkScalar intervalLength = de.getIntervalLength();
if (rect != fPrevRect || intervalLength != fPrevIntervalLength) {
}
}
-void GLDashingLineEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GLDashingLineEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const DashingLineEffect& de = effect.cast<DashingLineEffect>();
+ const DashingLineEffect& de = drawEffect.castEffect<DashingLineEffect>();
b->add32(de.getEdgeType());
}
}
bool DashingLineEffect::onIsEqual(const GrEffect& other) const {
- const DashingLineEffect& de = other.cast<DashingLineEffect>();
+ const DashingLineEffect& de = CastEffect<DashingLineEffect>(other);
return (fEdgeType == de.fEdgeType &&
fRect == de.fRect &&
fIntervalLength == de.fIntervalLength);
class GrGLDistanceFieldTextureEffect : public GrGLGeometryProcessor {
public:
GrGLDistanceFieldTextureEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory)
, fTextureSize(SkISize::Make(-1,-1))
#ifdef SK_GAMMA_APPLY_TO_A8
{}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
const GrDistanceFieldTextureEffect& dfTexEffect =
- effect.cast<GrDistanceFieldTextureEffect>();
+ drawEffect.castEffect<GrDistanceFieldTextureEffect>();
SkASSERT(1 == dfTexEffect.getVertexAttribs().count());
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) SK_OVERRIDE {
+ const GrDrawEffect& drawEffect) SK_OVERRIDE {
SkASSERT(fTextureSizeUni.isValid());
- GrTexture* texture = effect.texture(0);
+ GrTexture* texture = drawEffect.effect()->texture(0);
if (texture->width() != fTextureSize.width() ||
texture->height() != fTextureSize.height()) {
fTextureSize = SkISize::Make(texture->width(), texture->height());
}
#ifdef SK_GAMMA_APPLY_TO_A8
const GrDistanceFieldTextureEffect& dfTexEffect =
- effect.cast<GrDistanceFieldTextureEffect>();
+ drawEffect.castEffect<GrDistanceFieldTextureEffect>();
float luminance = dfTexEffect.getLuminance();
if (luminance != fLuminance) {
pdman.set1f(fLuminanceUni, luminance);
#endif
}
- static inline void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
const GrDistanceFieldTextureEffect& dfTexEffect =
- effect.cast<GrDistanceFieldTextureEffect>();
+ drawEffect.castEffect<GrDistanceFieldTextureEffect>();
b->add32(dfTexEffect.getFlags());
}
}
bool GrDistanceFieldTextureEffect::onIsEqual(const GrEffect& other) const {
- const GrDistanceFieldTextureEffect& cte = other.cast<GrDistanceFieldTextureEffect>();
+ const GrDistanceFieldTextureEffect& cte = CastEffect<GrDistanceFieldTextureEffect>(other);
return fTextureAccess == cte.fTextureAccess &&
#ifdef SK_GAMMA_APPLY_TO_A8
fGammaTextureAccess == cte.fGammaTextureAccess &&
class GrGLDistanceFieldLCDTextureEffect : public GrGLGeometryProcessor {
public:
GrGLDistanceFieldLCDTextureEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory)
, fTextureSize(SkISize::Make(-1,-1))
, fTextColor(GrColor_ILLEGAL) {}
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) SK_OVERRIDE {
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
- effect.cast<GrDistanceFieldLCDTextureEffect>();
+ drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
SkASSERT(1 == dfTexEffect.getVertexAttribs().count());
SkString fsCoordName;
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) SK_OVERRIDE {
+ const GrDrawEffect& drawEffect) SK_OVERRIDE {
SkASSERT(fTextureSizeUni.isValid());
SkASSERT(fTextColorUni.isValid());
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
- effect.cast<GrDistanceFieldLCDTextureEffect>();
- GrTexture* texture = effect.texture(0);
+ drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
+ GrTexture* texture = drawEffect.effect()->texture(0);
if (texture->width() != fTextureSize.width() ||
texture->height() != fTextureSize.height()) {
fTextureSize = SkISize::Make(texture->width(), texture->height());
}
}
- static inline void GenKey(const GrEffect& effect, const GrGLCaps&,
+ static inline void GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
const GrDistanceFieldLCDTextureEffect& dfTexEffect =
- effect.cast<GrDistanceFieldLCDTextureEffect>();
+ drawEffect.castEffect<GrDistanceFieldLCDTextureEffect>();
b->add32(dfTexEffect.getFlags());
}
}
bool GrDistanceFieldLCDTextureEffect::onIsEqual(const GrEffect& other) const {
- const GrDistanceFieldLCDTextureEffect& cte = other.cast<GrDistanceFieldLCDTextureEffect>();
+ const GrDistanceFieldLCDTextureEffect& cte =
+ CastEffect<GrDistanceFieldLCDTextureEffect>(other);
return (fTextureAccess == cte.fTextureAccess &&
fGammaTextureAccess == cte.fGammaTextureAccess &&
fTextColor == cte.fTextColor &&
class GLDitherEffect : public GrGLEffect {
public:
- GLDitherEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLDitherEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
};
GLDitherEffect::GLDitherEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
}
void GLDitherEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
class GrGLMatrixConvolutionEffect : public GrGLEffect {
public:
GrGLMatrixConvolutionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect);
+ const GrDrawEffect& effect);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
typedef GrGLProgramDataManager::UniformHandle UniformHandle;
};
GrGLMatrixConvolutionEffect::GrGLMatrixConvolutionEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED(factory) {
- const GrMatrixConvolutionEffect& m = effect.cast<GrMatrixConvolutionEffect>();
+ const GrMatrixConvolutionEffect& m = drawEffect.castEffect<GrMatrixConvolutionEffect>();
fKernelSize = m.kernelSize();
fConvolveAlpha = m.convolveAlpha();
}
void GrGLMatrixConvolutionEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
sk_ignore_unused_variable(inputColor);
- const GrTextureDomain& domain = effect.cast<GrMatrixConvolutionEffect>().domain();
+ const GrTextureDomain& domain = drawEffect.castEffect<GrMatrixConvolutionEffect>().domain();
fBoundsUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
kVec4f_GrSLType, "Bounds");
fsBuilder->codeAppend(modulate.c_str());
}
-void GrGLMatrixConvolutionEffect::GenKey(const GrEffect& effect,
+void GrGLMatrixConvolutionEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&, GrEffectKeyBuilder* b) {
- const GrMatrixConvolutionEffect& m = effect.cast<GrMatrixConvolutionEffect>();
+ const GrMatrixConvolutionEffect& m = drawEffect.castEffect<GrMatrixConvolutionEffect>();
SkASSERT(m.kernelSize().width() <= 0x7FFF && m.kernelSize().height() <= 0xFFFF);
uint32_t key = m.kernelSize().width() << 16 | m.kernelSize().height();
key |= m.convolveAlpha() ? 1 << 31 : 0;
}
void GrGLMatrixConvolutionEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrMatrixConvolutionEffect& conv = effect.cast<GrMatrixConvolutionEffect>();
+ const GrDrawEffect& drawEffect) {
+ const GrMatrixConvolutionEffect& conv = drawEffect.castEffect<GrMatrixConvolutionEffect>();
GrTexture& texture = *conv.texture(0);
// the code we generated was for a specific kernel size
SkASSERT(conv.kernelSize() == fKernelSize);
}
bool GrMatrixConvolutionEffect::onIsEqual(const GrEffect& sBase) const {
- const GrMatrixConvolutionEffect& s = sBase.cast<GrMatrixConvolutionEffect>();
+ const GrMatrixConvolutionEffect& s = CastEffect<GrMatrixConvolutionEffect>(sBase);
return this->texture(0) == s.texture(0) &&
fKernelSize == s.kernelSize() &&
!memcmp(fKernel, s.kernel(),
}
bool CircleEffect::onIsEqual(const GrEffect& other) const {
- const CircleEffect& ce = other.cast<CircleEffect>();
+ const CircleEffect& ce = CastEffect<CircleEffect>(other);
return fEdgeType == ce.fEdgeType && fCenter == ce.fCenter && fRadius == ce.fRadius;
}
class GLCircleEffect : public GrGLEffect {
public:
- GLCircleEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLCircleEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fCircleUniform;
};
GLCircleEffect::GLCircleEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevRadius = -1.f;
}
void GLCircleEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const CircleEffect& ce = effect.cast<CircleEffect>();
+ const CircleEffect& ce = drawEffect.castEffect<CircleEffect>();
const char *circleName;
// The circle uniform is (center.x, center.y, radius + 0.5) for regular fills and
// (... ,radius - 0.5) for inverse fills.
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("d")).c_str());
}
-void GLCircleEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GLCircleEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const CircleEffect& ce = effect.cast<CircleEffect>();
+ const CircleEffect& ce = drawEffect.castEffect<CircleEffect>();
b->add32(ce.getEdgeType());
}
-void GLCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- const CircleEffect& ce = effect.cast<CircleEffect>();
+void GLCircleEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ const CircleEffect& ce = drawEffect.castEffect<CircleEffect>();
if (ce.getRadius() != fPrevRadius || ce.getCenter() != fPrevCenter) {
SkScalar radius = ce.getRadius();
if (GrEffectEdgeTypeIsInverseFill(ce.getEdgeType())) {
}
bool EllipseEffect::onIsEqual(const GrEffect& other) const {
- const EllipseEffect& ee = other.cast<EllipseEffect>();
+ const EllipseEffect& ee = CastEffect<EllipseEffect>(other);
return fEdgeType == ee.fEdgeType && fCenter == ee.fCenter && fRadii == ee.fRadii;
}
class GLEllipseEffect : public GrGLEffect {
public:
- GLEllipseEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLEllipseEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fEllipseUniform;
};
GLEllipseEffect::GLEllipseEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevRadii.fX = -1.f;
}
void GLEllipseEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const EllipseEffect& ee = effect.cast<EllipseEffect>();
+ const EllipseEffect& ee = drawEffect.castEffect<EllipseEffect>();
const char *ellipseName;
// The ellipse uniform is (center.x, center.y, 1 / rx^2, 1 / ry^2)
fEllipseUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GLEllipseEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GLEllipseEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const EllipseEffect& ee = effect.cast<EllipseEffect>();
+ const EllipseEffect& ee = drawEffect.castEffect<EllipseEffect>();
b->add32(ee.getEdgeType());
}
-void GLEllipseEffect::setData(const GrGLProgramDataManager& pdman, const GrEffect& effect) {
- const EllipseEffect& ee = effect.cast<EllipseEffect>();
+void GLEllipseEffect::setData(const GrGLProgramDataManager& pdman, const GrDrawEffect& drawEffect) {
+ const EllipseEffect& ee = drawEffect.castEffect<EllipseEffect>();
if (ee.getRadii() != fPrevRadii || ee.getCenter() != fPrevCenter) {
SkScalar invRXSqd = 1.f / (ee.getRadii().fX * ee.getRadii().fX);
SkScalar invRYSqd = 1.f / (ee.getRadii().fY * ee.getRadii().fY);
}
bool CircularRRectEffect::onIsEqual(const GrEffect& other) const {
- const CircularRRectEffect& crre = other.cast<CircularRRectEffect>();
+ const CircularRRectEffect& crre = CastEffect<CircularRRectEffect>(other);
// The corner flags are derived from fRRect, so no need to check them.
return fEdgeType == crre.fEdgeType && fRRect == crre.fRRect;
}
class GLCircularRRectEffect : public GrGLEffect {
public:
- GLCircularRRectEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLCircularRRectEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fInnerRectUniform;
};
GLCircularRRectEffect::GLCircularRRectEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevRRect.setEmpty();
}
void GLCircularRRectEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const CircularRRectEffect& crre = effect.cast<CircularRRectEffect>();
+ const CircularRRectEffect& crre = drawEffect.castEffect<CircularRRectEffect>();
const char *rectName;
const char *radiusPlusHalfName;
// The inner rect is the rrect bounds inset by the radius. Its left, top, right, and bottom
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GLCircularRRectEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GLCircularRRectEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const CircularRRectEffect& crre = effect.cast<CircularRRectEffect>();
+ const CircularRRectEffect& crre = drawEffect.castEffect<CircularRRectEffect>();
GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8);
b->add32((crre.getCircularCornerFlags() << 3) | crre.getEdgeType());
}
void GLCircularRRectEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const CircularRRectEffect& crre = effect.cast<CircularRRectEffect>();
+ const GrDrawEffect& drawEffect) {
+ const CircularRRectEffect& crre = drawEffect.castEffect<CircularRRectEffect>();
const SkRRect& rrect = crre.getRRect();
if (rrect != fPrevRRect) {
SkRect rect = rrect.getBounds();
}
bool EllipticalRRectEffect::onIsEqual(const GrEffect& other) const {
- const EllipticalRRectEffect& erre = other.cast<EllipticalRRectEffect>();
+ const EllipticalRRectEffect& erre = CastEffect<EllipticalRRectEffect>(other);
return fEdgeType == erre.fEdgeType && fRRect == erre.fRRect;
}
class GLEllipticalRRectEffect : public GrGLEffect {
public:
- GLEllipticalRRectEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GLEllipticalRRectEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
private:
GrGLProgramDataManager::UniformHandle fInnerRectUniform;
};
GLEllipticalRRectEffect::GLEllipticalRRectEffect(const GrBackendEffectFactory& factory,
- const GrEffect& effect)
+ const GrDrawEffect& drawEffect)
: INHERITED (factory) {
fPrevRRect.setEmpty();
}
void GLEllipticalRRectEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray& samplers) {
- const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
+ const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
const char *rectName;
// The inner rect is the rrect bounds inset by the x/y radii
fInnerRectUniform = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
(GrGLSLExpr4(inputColor) * GrGLSLExpr1("alpha")).c_str());
}
-void GLEllipticalRRectEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GLEllipticalRRectEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
+ const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
GR_STATIC_ASSERT(kLast_GrEffectEdgeType < (1 << 3));
b->add32(erre.getRRect().getType() | erre.getEdgeType() << 3);
}
void GLEllipticalRRectEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
+ const GrDrawEffect& drawEffect) {
+ const EllipticalRRectEffect& erre = drawEffect.castEffect<EllipticalRRectEffect>();
const SkRRect& rrect = erre.getRRect();
if (rrect != fPrevRRect) {
SkRect rect = rrect.getBounds();
class GrGLSimpleTextureEffect : public GrGLEffect {
public:
- GrGLSimpleTextureEffect(const GrBackendEffectFactory& factory, const GrEffect&)
+ GrGLSimpleTextureEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
: INHERITED (factory) {
}
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
}
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
- const GrSimpleTextureEffect& ste = other.cast<GrSimpleTextureEffect>();
+ const GrSimpleTextureEffect& ste = CastEffect<GrSimpleTextureEffect>(other);
return this->hasSameTextureParamsMatrixAndSourceCoords(ste);
}
class GrGLTextureDomainEffect : public GrGLEffect {
public:
- GrGLTextureDomainEffect(const GrBackendEffectFactory&, const GrEffect&);
+ GrGLTextureDomainEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
virtual void emitCode(GrGLProgramBuilder*,
- const GrEffect&,
+ const GrDrawEffect&,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) SK_OVERRIDE;
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) SK_OVERRIDE;
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE;
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
private:
GrTextureDomain::GLDomain fGLDomain;
};
GrGLTextureDomainEffect::GrGLTextureDomainEffect(const GrBackendEffectFactory& factory,
- const GrEffect&)
+ const GrDrawEffect&)
: INHERITED(factory) {
}
void GrGLTextureDomainEffect::emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray& coords,
const TextureSamplerArray& samplers) {
- const GrTextureDomainEffect& textureDomainEffect = effect.cast<GrTextureDomainEffect>();
- const GrTextureDomain& domain = textureDomainEffect.textureDomain();
+ const GrTextureDomainEffect& effect = drawEffect.castEffect<GrTextureDomainEffect>();
+ const GrTextureDomain& domain = effect.textureDomain();
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);
}
void GrGLTextureDomainEffect::setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) {
- const GrTextureDomainEffect& textureDomainEffect = effect.cast<GrTextureDomainEffect>();
- const GrTextureDomain& domain = textureDomainEffect.textureDomain();
+ const GrDrawEffect& drawEffect) {
+ const GrTextureDomainEffect& effect = drawEffect.castEffect<GrTextureDomainEffect>();
+ const GrTextureDomain& domain = effect.textureDomain();
fGLDomain.setData(pdman, domain, effect.texture(0)->origin());
}
-void GrGLTextureDomainEffect::GenKey(const GrEffect& effect, const GrGLCaps&,
+void GrGLTextureDomainEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&,
GrEffectKeyBuilder* b) {
- const GrTextureDomain& domain = effect.cast<GrTextureDomainEffect>().textureDomain();
+ const GrTextureDomain& domain = drawEffect.castEffect<GrTextureDomainEffect>().textureDomain();
b->add32(GrTextureDomain::GLDomain::DomainKey(domain));
}
}
bool GrTextureDomainEffect::onIsEqual(const GrEffect& sBase) const {
- const GrTextureDomainEffect& s = sBase.cast<GrTextureDomainEffect>();
+ const GrTextureDomainEffect& s = CastEffect<GrTextureDomainEffect>(sBase);
return this->hasSameTextureParamsMatrixAndSourceCoords(s) &&
this->fTextureDomain == s.fTextureDomain;
}
static const GrGLfloat kRec601ConversionMatrix[16];
// this class always generates the same code.
- static void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
+ static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
GLEffect(const GrBackendEffectFactory& factory,
- const GrEffect&)
+ const GrDrawEffect&)
: INHERITED(factory) {
}
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect&,
+ const GrDrawEffect& drawEffect,
const GrEffectKey&,
const char* outputColor,
const char* inputColor,
}
virtual void setData(const GrGLProgramDataManager& pdman,
- const GrEffect& effect) SK_OVERRIDE {
- const YUVtoRGBEffect& yuvEffect = effect.cast<YUVtoRGBEffect>();
+ const GrDrawEffect& drawEffect) SK_OVERRIDE {
+ const YUVtoRGBEffect& yuvEffect = drawEffect.castEffect<YUVtoRGBEffect>();
switch (yuvEffect.getColorSpace()) {
case kJPEG_SkYUVColorSpace:
pdman.setMatrix4f(fMatrixUni, kJPEGConversionMatrix);
}
virtual bool onIsEqual(const GrEffect& sBase) const {
- const YUVtoRGBEffect& s = sBase.cast<YUVtoRGBEffect>();
+ const YUVtoRGBEffect& s = CastEffect<YUVtoRGBEffect>(sBase);
return fYAccess.getTexture() == s.fYAccess.getTexture() &&
fUAccess.getTexture() == s.fUAccess.getTexture() &&
fVAccess.getTexture() == s.fVAccess.getTexture() &&
include/gpu/GrEffect.h. Objects of type GrGLEffect are responsible for emitting the
GLSL code that implements a GrEffect and for uploading uniforms at draw time. If they don't
always emit the same GLSL code, they must have a function:
- static inline void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*)
+ static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*)
that is used to implement a program cache. When two GrEffects produce the same key this means
that their GrGLEffects would emit the same GLSL code.
The GrGLEffect subclass must also have a constructor of the form:
- EffectSubclass::EffectSubclass(const GrBackendEffectFactory&, const GrEffect&)
+ EffectSubclass::EffectSubclass(const GrBackendEffectFactory&, const GrDrawEffect&)
+ The effect held by the GrDrawEffect is guaranteed to be of the type that generated the
+ GrGLEffect subclass instance.
These objects are created by the factory object returned by the GrEffect::getFactory().
*/
+class GrDrawEffect;
class GrGLTexture;
class GrGLGeometryProcessor;
stages.
@param builder Interface used to emit code in the shaders.
- @param effect The effect that generated this program stage.
+ @param drawEffect A wrapper on the effect that generated this program stage.
@param key The key that was computed by GenKey() from the generating GrEffect.
@param outputColor A predefined vec4 in the FS in which the stage should place its output
color (or coverage).
reads in the generated code.
*/
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
/** A GrGLEffect instance can be reused with any GrEffect that produces the same stage
key; this function reads data from a GrEffect and uploads any uniform variables required
- by the shaders created in emitCode(). The GrEffect is
+ by the shaders created in emitCode(). The GrEffect installed in the GrDrawEffect is
guaranteed to be of the same type that created this GrGLEffect and to have an identical
effect key as the one that created this GrGLEffect. Effects that use local coords have
to consider whether the GrEffectStage's coord change matrix should be used. When explicit
local coordinates are used it can be ignored. */
- virtual void setData(const GrGLProgramDataManager&, const GrEffect&) {}
+ virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) {}
const char* name() const { return fFactory.name(); }
- static void GenKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
+ static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
/** Used by the system when generating shader code, to see if this effect can be downcasted to
the internal GrGLGeometryProcessor type */
* This allows the effect subclass to emit vertex code.
*/
virtual void emitCode(GrGLFullProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
* Provide a default override for base class's emitCode() function.
*/
virtual void emitCode(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrDrawEffect& drawEffect,
const GrEffectKey& key,
const char* outputColor,
const char* inputColor,
#include "GrAllocator.h"
#include "GrEffect.h"
#include "GrCoordTransform.h"
+#include "GrDrawEffect.h"
#include "GrGLEffect.h"
#include "GrGpuGL.h"
#include "GrGLPathRendering.h"
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrGLProgramDesc.h"
#include "GrBackendEffectFactory.h"
+#include "GrDrawEffect.h"
#include "GrEffect.h"
#include "GrGpuGL.h"
#include "GrOptDrawState.h"
bool* setTrueIfReadsPos,
bool* setTrueIfRequiresVertexShader) {
const GrBackendEffectFactory& factory = stage.getEffect()->getFactory();
- const GrEffect& effect = *stage.getEffect();
- if (effect.willReadDstColor()) {
+ GrDrawEffect drawEffect(stage, useExplicitLocalCoords);
+ if (stage.getEffect()->willReadDstColor()) {
*setTrueIfReadsDst = true;
}
- if (effect.willReadFragmentPosition()) {
+ if (stage.getEffect()->willReadFragmentPosition()) {
*setTrueIfReadsPos = true;
}
- if (effect.requiresVertexShader()) {
+ if (stage.getEffect()->requiresVertexShader()) {
*setTrueIfRequiresVertexShader = true;
}
- factory.getGLEffectKey(effect, caps, b);
+ factory.getGLEffectKey(drawEffect, caps, b);
size_t size = b->size();
if (size > SK_MaxU16) {
*effectKeySize = 0; // suppresses a warning.
return false;
}
*effectKeySize = SkToU16(size);
- if (!GrGLProgramEffects::GenEffectMetaKey(stage,
- useExplicitLocalCoords,
- caps,
- b)) {
+ if (!GrGLProgramEffects::GenEffectMetaKey(drawEffect, caps, b)) {
return false;
}
return true;
#include "gl/builders/GrGLProgramBuilder.h"
#include "GrGLProgramEffects.h"
+#include "GrDrawEffect.h"
#include "gl/GrGLEffect.h"
#include "gl/GrGLPathRendering.h"
#include "gl/builders/GrGLProgramBuilder.h"
/**
* Retrieves the final matrix that a transform needs to apply to its source coords.
*/
-SkMatrix get_transform_matrix(const GrEffectStage& effectStage,
- bool useExplicitLocalCoords,
- int transformIdx) {
- const GrCoordTransform& coordTransform = effectStage.getEffect()->coordTransform(transformIdx);
+SkMatrix get_transform_matrix(const GrDrawEffect& drawEffect, int transformIdx) {
+ const GrCoordTransform& coordTransform = drawEffect.effect()->coordTransform(transformIdx);
SkMatrix combined;
if (kLocal_GrCoordSet == coordTransform.sourceCoords()) {
// If we have explicit local coords then we shouldn't need a coord change.
- const SkMatrix& ccm =
- useExplicitLocalCoords ? SkMatrix::I() : effectStage.getCoordChangeMatrix();
- combined.setConcat(coordTransform.getMatrix(), ccm);
+ SkASSERT(!drawEffect.programHasExplicitLocalCoords() ||
+ drawEffect.getCoordChangeMatrix().isIdentity());
+ combined.setConcat(coordTransform.getMatrix(), drawEffect.getCoordChangeMatrix());
} else {
combined = coordTransform.getMatrix();
}
}
return combined;
}
+
}
////////////////////////////////////////////////////////////////////////////////
-bool GrGLProgramEffects::GenEffectMetaKey(const GrEffectStage& effectStage,
- bool useExplicitLocalCoords,
- const GrGLCaps& caps,
+bool GrGLProgramEffects::GenEffectMetaKey(const GrDrawEffect& drawEffect, const GrGLCaps& caps,
GrEffectKeyBuilder* b) {
- uint32_t textureKey = GrGLProgramEffects::GenTextureKey(effectStage.getEffect(), caps);
- uint32_t transformKey = GrGLProgramEffects::GenTransformKey(effectStage,useExplicitLocalCoords);
- uint32_t attribKey = GrGLProgramEffects::GenAttribKey(effectStage.getEffect());
- uint32_t classID = effectStage.getEffect()->getFactory().effectClassID();
+ uint32_t textureKey = GrGLProgramEffects::GenTextureKey(drawEffect, caps);
+ uint32_t transformKey = GrGLProgramEffects::GenTransformKey(drawEffect);
+ uint32_t attribKey = GrGLProgramEffects::GenAttribKey(drawEffect.castEffect<GrEffect>());
+ uint32_t classID = drawEffect.effect()->getFactory().effectClassID();
// Currently we allow 16 bits for each of the above portions of the meta-key. Fail if they
// don't fit.
return true;
}
-uint32_t GrGLProgramEffects::GenAttribKey(const GrEffect* effect) {
+uint32_t GrGLProgramEffects::GenAttribKey(const GrEffect& effect) {
uint32_t key = 0;
- const GrEffect::VertexAttribArray& vars = effect->getVertexAttribs();
+ const GrEffect::VertexAttribArray& vars = effect.getVertexAttribs();
int numAttributes = vars.count();
SkASSERT(numAttributes <= 2);
for (int a = 0; a < numAttributes; ++a) {
return key;
}
-uint32_t GrGLProgramEffects::GenTransformKey(const GrEffectStage& effectStage,
- bool useExplicitLocalCoords) {
+uint32_t GrGLProgramEffects::GenTransformKey(const GrDrawEffect& drawEffect) {
uint32_t totalKey = 0;
- int numTransforms = effectStage.getEffect()->numTransforms();
+ int numTransforms = drawEffect.effect()->numTransforms();
for (int t = 0; t < numTransforms; ++t) {
uint32_t key = 0;
- const GrCoordTransform& coordTransform = effectStage.getEffect()->coordTransform(t);
+ const GrCoordTransform& coordTransform = drawEffect.effect()->coordTransform(t);
SkMatrix::TypeMask type0 = coordTransform.getMatrix().getType();
- SkMatrix::TypeMask type1 = SkMatrix::kIdentity_Mask;
- if (kLocal_GrCoordSet == coordTransform.sourceCoords() && !useExplicitLocalCoords) {
- type1 = effectStage.getCoordChangeMatrix().getType();
- } else if (kPosition_GrCoordSet == coordTransform.sourceCoords() && useExplicitLocalCoords) {
- // We only make the key indicate that device coords are referenced when the local coords
- // are not actually determined by positions. Otherwise the local coords var and position
- // var are identical.
- key |= kPositionCoords_Flag;
+ SkMatrix::TypeMask type1;
+ if (kLocal_GrCoordSet == coordTransform.sourceCoords()) {
+ type1 = drawEffect.getCoordChangeMatrix().getType();
+ } else {
+ if (drawEffect.programHasExplicitLocalCoords()) {
+ // We only make the key indicate that device coords are referenced when the local coords
+ // are not actually determined by positions. Otherwise the local coords var and position
+ // var are identical.
+ key |= kPositionCoords_Flag;
+ }
+ type1 = SkMatrix::kIdentity_Mask;
}
int combinedTypes = type0 | type1;
return totalKey;
}
-uint32_t GrGLProgramEffects::GenTextureKey(const GrEffect* effect, const GrGLCaps& caps) {
+uint32_t GrGLProgramEffects::GenTextureKey(const GrDrawEffect& drawEffect, const GrGLCaps& caps) {
uint32_t key = 0;
- int numTextures = effect->numTextures();
+ int numTextures = drawEffect.effect()->numTextures();
for (int t = 0; t < numTextures; ++t) {
- const GrTextureAccess& access = effect->textureAccess(t);
+ const GrTextureAccess& access = drawEffect.effect()->textureAccess(t);
uint32_t configComponentMask = GrPixelConfigComponentMask(access.getTexture()->config());
if (swizzle_requires_alpha_remapping(caps, configComponentMask, access.swizzleMask())) {
key |= 1 << t;
}
void GrGLProgramEffects::emitSamplers(GrGLProgramBuilder* builder,
- const GrEffect& effect,
+ const GrEffect* effect,
TextureSamplerArray* outSamplers) {
SkTArray<Sampler, true>& samplers = fSamplers.push_back();
- int numTextures = effect.numTextures();
+ int numTextures = effect->numTextures();
samplers.push_back_n(numTextures);
SkString name;
for (int t = 0; t < numTextures; ++t) {
kSampler2D_GrSLType,
name.c_str());
SkNEW_APPEND_TO_TARRAY(outSamplers, TextureSampler,
- (samplers[t].fUniform, effect.textureAccess(t)));
+ (samplers[t].fUniform, effect->textureAccess(t)));
}
}
}
}
-void GrGLProgramEffects::bindTextures(GrGpuGL* gpu, const GrEffect& effect, int effectIdx) {
+void GrGLProgramEffects::bindTextures(GrGpuGL* gpu, const GrEffect* effect, int effectIdx) {
const SkTArray<Sampler, true>& samplers = fSamplers[effectIdx];
int numSamplers = samplers.count();
- SkASSERT(numSamplers == effect.numTextures());
+ SkASSERT(numSamplers == effect->numTextures());
for (int s = 0; s < numSamplers; ++s) {
SkASSERT(samplers[s].fTextureUnit >= 0);
- const GrTextureAccess& textureAccess = effect.textureAccess(s);
+ const GrTextureAccess& textureAccess = effect->textureAccess(s);
gpu->bindTexture(samplers[s].fTextureUnit,
textureAccess.getParams(),
static_cast<GrGLTexture*>(textureAccess.getTexture()));
const char* outColor,
const char* inColor,
int stageIndex) {
- const GrEffect& effect = *stage.getEffect();
- SkSTArray<2, TransformedCoords> coords(effect.numTransforms());
- SkSTArray<4, TextureSampler> samplers(effect.numTextures());
+ GrDrawEffect drawEffect(stage, fHasExplicitLocalCoords);
+ const GrEffect* effect = stage.getEffect();
+ SkSTArray<2, TransformedCoords> coords(effect->numTransforms());
+ SkSTArray<4, TextureSampler> samplers(effect->numTextures());
GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
vsBuilder->emitAttributes(stage);
- this->emitTransforms(builder, stage, &coords);
+ this->emitTransforms(builder, drawEffect, &coords);
this->emitSamplers(builder, effect, &samplers);
- GrGLEffect* glEffect = effect.getFactory().createGLInstance(effect);
+ GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect);
fGLEffects.push_back(glEffect);
// Enclose custom code in a block to avoid namespace conflicts
if (glEffect->isVertexEffect()) {
GrGLGeometryProcessor* vertexEffect = static_cast<GrGLGeometryProcessor*>(glEffect);
- vertexEffect->emitCode(builder, effect, key, outColor, inColor, coords, samplers);
+ vertexEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers);
} else {
- glEffect->emitCode(builder, effect, key, outColor, inColor, coords, samplers);
+ glEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers);
}
vsBuilder->codeAppend("\t}\n");
}
void GrGLVertexProgramEffects::emitTransforms(GrGLFullProgramBuilder* builder,
- const GrEffectStage& effectStage,
+ const GrDrawEffect& drawEffect,
TransformedCoordsArray* outCoords) {
SkTArray<Transform, true>& transforms = fTransforms.push_back();
- uint32_t totalKey = GenTransformKey(effectStage, fHasExplicitLocalCoords);
- int numTransforms = effectStage.getEffect()->numTransforms();
+ uint32_t totalKey = GenTransformKey(drawEffect);
+ int numTransforms = drawEffect.effect()->numTransforms();
transforms.push_back_n(numTransforms);
SkTArray<PathTransform, true>* pathTransforms = NULL;
SkASSERT(numEffects == fTransforms.count());
SkASSERT(numEffects == fSamplers.count());
for (int e = 0; e < numEffects; ++e) {
- const GrEffectStage& effectStage = *effectStages[e];
- const GrEffect& effect = *effectStage.getEffect();
- fGLEffects[e]->setData(programDataManager, effect);
+ GrDrawEffect drawEffect(*effectStages[e], fHasExplicitLocalCoords);
+ fGLEffects[e]->setData(programDataManager, drawEffect);
if (GrGpu::IsPathRenderingDrawType(drawType)) {
- this->setPathTransformData(gpu, programDataManager, effectStage, e);
+ this->setPathTransformData(gpu, programDataManager, drawEffect, e);
} else {
- this->setTransformData(gpu, programDataManager, effectStage, e);
+ this->setTransformData(gpu, programDataManager, drawEffect, e);
}
- this->bindTextures(gpu, effect, e);
+ this->bindTextures(gpu, drawEffect.effect(), e);
}
}
SkASSERT(1 == fTransforms.count());
SkASSERT(1 == fSamplers.count());
SkASSERT(1 == fGLEffects.count());
- const GrEffect& effect = *effectStage->getEffect();
- fGLEffects[0]->setData(programDataManager, effect);
+ GrDrawEffect drawEffect(*effectStage, fHasExplicitLocalCoords);
+ fGLEffects[0]->setData(programDataManager, drawEffect);
if (GrGpu::IsPathRenderingDrawType(drawType)) {
- this->setPathTransformData(gpu, programDataManager, *effectStage, 0);
+ this->setPathTransformData(gpu, programDataManager, drawEffect, 0);
} else {
- this->setTransformData(gpu, programDataManager, *effectStage, 0);
+ this->setTransformData(gpu, programDataManager, drawEffect, 0);
}
- this->bindTextures(gpu, effect, 0);
+ this->bindTextures(gpu, drawEffect.effect(), 0);
}
void GrGLVertexProgramEffects::setTransformData(GrGpuGL* gpu,
const GrGLProgramDataManager& pdman,
- const GrEffectStage& effectStage,
+ const GrDrawEffect& drawEffect,
int effectIdx) {
SkTArray<Transform, true>& transforms = fTransforms[effectIdx];
int numTransforms = transforms.count();
- SkASSERT(numTransforms == effectStage.getEffect()->numTransforms());
+ SkASSERT(numTransforms == drawEffect.effect()->numTransforms());
for (int t = 0; t < numTransforms; ++t) {
SkASSERT(transforms[t].fHandle.isValid());
- const SkMatrix& matrix = get_transform_matrix(effectStage, fHasExplicitLocalCoords, t);
+ const SkMatrix& matrix = get_transform_matrix(drawEffect, t);
if (!transforms[t].fCurrentValue.cheapEqualTo(matrix)) {
pdman.setSkMatrix(transforms[t].fHandle, matrix);
transforms[t].fCurrentValue = matrix;
void GrGLVertexProgramEffects::setPathTransformData(GrGpuGL* gpu,
const GrGLProgramDataManager& pdman,
- const GrEffectStage& effectStage,
+ const GrDrawEffect& drawEffect,
int effectIdx) {
SkTArray<PathTransform, true>& transforms = fPathTransforms[effectIdx];
int numTransforms = transforms.count();
- SkASSERT(numTransforms == effectStage.getEffect()->numTransforms());
+ SkASSERT(numTransforms == drawEffect.effect()->numTransforms());
for (int t = 0; t < numTransforms; ++t) {
SkASSERT(transforms[t].fHandle.isValid());
- const SkMatrix& transform = get_transform_matrix(effectStage, fHasExplicitLocalCoords, t);
+ const SkMatrix& transform = get_transform_matrix(drawEffect, t);
if (transforms[t].fCurrentValue.cheapEqualTo(transform)) {
continue;
}
const char* outColor,
const char* inColor,
int stageIndex) {
- const GrEffect& effect = *stage.getEffect();
- SkSTArray<2, TransformedCoords> coords(effect.numTransforms());
- SkSTArray<4, TextureSampler> samplers(effect.numTextures());
+ GrDrawEffect drawEffect(stage, false);
+ const GrEffect* effect = stage.getEffect();
+ SkSTArray<2, TransformedCoords> coords(effect->numTransforms());
+ SkSTArray<4, TextureSampler> samplers(effect->numTextures());
- SkASSERT(0 == effect.getVertexAttribs().count());
- this->setupPathTexGen(builder, stage, &coords);
+ SkASSERT(0 == effect->getVertexAttribs().count());
+ this->setupPathTexGen(builder, drawEffect, &coords);
this->emitSamplers(builder, effect, &samplers);
- GrGLEffect* glEffect = effect.getFactory().createGLInstance(effect);
+ GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect);
fGLEffects.push_back(glEffect);
GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
fsBuilder->codeAppend(openBrace.c_str());
SkASSERT(!glEffect->isVertexEffect());
- glEffect->emitCode(builder, effect, key, outColor, inColor, coords, samplers);
+ glEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers);
fsBuilder->codeAppend("\t}\n");
}
void GrGLPathTexGenProgramEffects::setupPathTexGen(GrGLFragmentOnlyProgramBuilder* builder,
- const GrEffectStage& effectStage,
+ const GrDrawEffect& drawEffect,
TransformedCoordsArray* outCoords) {
- int numTransforms = effectStage.getEffect()->numTransforms();
- uint32_t totalKey = GenTransformKey(effectStage, false);
+ int numTransforms = drawEffect.effect()->numTransforms();
+ uint32_t totalKey = GenTransformKey(drawEffect);
int texCoordIndex = builder->addTexCoordSets(numTransforms);
SkNEW_APPEND_TO_TARRAY(&fTransforms, Transforms, (totalKey, texCoordIndex));
SkString name;
SkASSERT(numEffects == fTransforms.count());
SkASSERT(numEffects == fSamplers.count());
for (int e = 0; e < numEffects; ++e) {
- const GrEffectStage& effectStage = *effectStages[e];
- const GrEffect& effect = *effectStage.getEffect();
- fGLEffects[e]->setData(pdman, effect);
- this->setPathTexGenState(gpu, effectStage, e);
- this->bindTextures(gpu, effect, e);
+ GrDrawEffect drawEffect(*effectStages[e], false);
+ fGLEffects[e]->setData(pdman, drawEffect);
+ this->setPathTexGenState(gpu, drawEffect, e);
+ this->bindTextures(gpu, drawEffect.effect(), e);
}
}
void GrGLPathTexGenProgramEffects::setPathTexGenState(GrGpuGL* gpu,
- const GrEffectStage& effectStage,
+ const GrDrawEffect& drawEffect,
int effectIdx) {
uint32_t totalKey = fTransforms[effectIdx].fTransformKey;
int texCoordIndex = fTransforms[effectIdx].fTexCoordIndex;
- int numTransforms = effectStage.getEffect()->numTransforms();
+ int numTransforms = drawEffect.effect()->numTransforms();
for (int t = 0; t < numTransforms; ++t) {
switch (get_matrix_type(totalKey, t)) {
case kNoPersp_MatrixType: {
- const SkMatrix& transform = get_transform_matrix(effectStage, false, t);
+ const SkMatrix& transform = get_transform_matrix(drawEffect, t);
gpu->glPathRendering()->enablePathTexGen(
texCoordIndex++,
GrGLPathRendering::kST_PathTexGenComponents,
break;
}
case kGeneral_MatrixType: {
- const SkMatrix& transform = get_transform_matrix(effectStage, false, t);
+ const SkMatrix& transform = get_transform_matrix(drawEffect, t);
gpu->glPathRendering()->enablePathTexGen(
texCoordIndex++,
GrGLPathRendering::kSTR_PathTexGenComponents,
* which must be different for every GrEffect subclass. It can fail if an effect uses too many
* textures, attributes, etc for the space allotted in the meta-key.
*/
- static bool GenEffectMetaKey(const GrEffectStage&,
- bool,
- const GrGLCaps&,
- GrEffectKeyBuilder*);
+ static bool GenEffectMetaKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
virtual ~GrGLProgramEffects();
/**
* Helpers for GenEffectMetaKey.
*/
- static uint32_t GenAttribKey(const GrEffect*);
- static uint32_t GenTransformKey(const GrEffectStage&, bool useExplicitLocalCoords);
- static uint32_t GenTextureKey(const GrEffect*, const GrGLCaps&);
+ static uint32_t GenAttribKey(const GrEffect&);
+ static uint32_t GenTransformKey(const GrDrawEffect&);
+ static uint32_t GenTextureKey(const GrDrawEffect&, const GrGLCaps&);
GrGLProgramEffects(int reserveCount)
: fGLEffects(reserveCount)
* appends the necessary data to the TextureSamplerArray* object so effects can add texture
* lookups to their code. This method is only meant to be called during the construction phase.
*/
- void emitSamplers(GrGLProgramBuilder*, const GrEffect&, TextureSamplerArray*);
+ void emitSamplers(GrGLProgramBuilder*, const GrEffect*, TextureSamplerArray*);
/**
* Helper for setData(). Binds all the textures for an effect.
*/
- void bindTextures(GrGpuGL*, const GrEffect&, int effectIdx);
+ void bindTextures(GrGpuGL*, const GrEffect*, int effectIdx);
struct Sampler {
SkDEBUGCODE(Sampler() : fTextureUnit(-1) {})
* TransformedCoordsArray* object, which is in turn passed to the effect's emitCode() function.
*/
void emitTransforms(GrGLFullProgramBuilder*,
- const GrEffectStage&,
+ const GrDrawEffect&,
TransformedCoordsArray*);
/**
* Helper for setData(). Sets all the transform matrices for an effect.
*/
- void setTransformData(GrGpuGL* gpu, const GrGLProgramDataManager&, const GrEffectStage&,
- int effectIdx);
- void setPathTransformData(GrGpuGL* gpu, const GrGLProgramDataManager&, const GrEffectStage&,
+ void setTransformData(GrGpuGL* gpu, const GrGLProgramDataManager&, const GrDrawEffect&, int effectIdx);
+ void setPathTransformData(GrGpuGL* gpu, const GrGLProgramDataManager&, const GrDrawEffect&,
int effectIdx);
struct Transform {
* effect's emitCode() function.
*/
void setupPathTexGen(GrGLFragmentOnlyProgramBuilder*,
- const GrEffectStage&,
+ const GrDrawEffect&,
TransformedCoordsArray*);
/**
* Helper for setData(). Sets the PathTexGen state for each transform in an effect.
*/
- void setPathTexGenState(GrGpuGL*, const GrEffectStage&, int effectIdx);
+ void setPathTexGenState(GrGpuGL*, const GrDrawEffect&, int effectIdx);
struct Transforms {
Transforms(uint32_t transformKey, int texCoordIndex)
#include "gl/GrGLSLPrettyPrint.h"
#include "gl/GrGLUniformHandle.h"
#include "GrCoordTransform.h"
+#include "GrDrawEffect.h"
#include "../GrGpuGL.h"
#include "GrGLFragmentShaderBuilder.h"
#include "GrGLProgramBuilder.h"
#include "GrBackendEffectFactory.h"
#include "GrContextFactory.h"
+#include "GrDrawEffect.h"
#include "effects/GrConfigConversionEffect.h"
#include "gl/GrGLPathRendering.h"
#include "gl/GrGpuGL.h"
fKey.reset();
return false;
}
+ GrDrawEffect drawEffect(*stage, useLocalCoords);
GrEffectKeyBuilder b(&fKey);
uint16_t effectKeySize;
if (!GetEffectKeyAndUpdateStats(*stage, gpu->glCaps(), useLocalCoords, &b,
fKey.reset();
return false;
}
+ GrDrawEffect drawEffect(*stage, useLocalCoords);
GrEffectKeyBuilder b(&fKey);
uint16_t effectKeySize;
if (!GetEffectKeyAndUpdateStats(*stage, gpu->glCaps(), useLocalCoords, &b,
projects / platform / upstream / libSkiaSharp.git / commitdiff