class SkArithmeticMode_scalar : public SkXfermode {
public:
- static SkArithmeticMode_scalar* Create(SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4) {
- return SkNEW_ARGS(SkArithmeticMode_scalar, (k1, k2, k3, k4));
+ static SkArithmeticMode_scalar* Create(SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4,
+ bool enforcePMColor) {
+ return SkNEW_ARGS(SkArithmeticMode_scalar, (k1, k2, k3, k4, enforcePMColor));
}
virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
#endif
private:
- SkArithmeticMode_scalar(SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4) {
+ SkArithmeticMode_scalar(SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4, bool enforcePMColor) {
fK[0] = k1;
fK[1] = k2;
fK[2] = k3;
fK[3] = k4;
+ fEnforcePMColor = enforcePMColor;
}
SkArithmeticMode_scalar(SkReadBuffer& buffer) : INHERITED(buffer) {
fK[1] = buffer.readScalar();
fK[2] = buffer.readScalar();
fK[3] = buffer.readScalar();
+ fEnforcePMColor = buffer.readBool();
}
virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
buffer.writeScalar(fK[1]);
buffer.writeScalar(fK[2]);
buffer.writeScalar(fK[3]);
+ buffer.writeBool(fEnforcePMColor);
}
SkScalar fK[4];
+ bool fEnforcePMColor;
typedef SkXfermode INHERITED;
};
} else {
a = arith(k1, k2, k3, k4, SkGetPackedA32(sc), SkGetPackedA32(dc));
r = arith(k1, k2, k3, k4, SkGetPackedR32(sc), SkGetPackedR32(dc));
- r = SkMin32(r, a);
g = arith(k1, k2, k3, k4, SkGetPackedG32(sc), SkGetPackedG32(dc));
- g = SkMin32(g, a);
b = arith(k1, k2, k3, k4, SkGetPackedB32(sc), SkGetPackedB32(dc));
- b = SkMin32(b, a);
+ if (fEnforcePMColor) {
+ r = SkMin32(r, a);
+ g = SkMin32(g, a);
+ b = SkMin32(b, a);
+ }
}
// apply antialias coverage if necessary
g = SkAlphaMul(g, scale);
b = SkAlphaMul(b, scale);
}
- dst[i] = SkPackARGB32(a, r, g, b);
+ dst[i] = fEnforcePMColor ? SkPackARGB32(a, r, g, b) : SkPackARGB32NoCheck(a, r, g, b);
}
}
}
str->append("SkArithmeticMode_scalar: ");
for (int i = 0; i < 4; ++i) {
str->appendScalar(fK[i]);
- if (i < 3) {
- str->append(" ");
- }
+ str->append(" ");
}
+ str->appendS32(fEnforcePMColor ? 1 : 0);
}
#endif
#endif
SkXfermode* SkArithmeticMode::Create(SkScalar k1, SkScalar k2,
- SkScalar k3, SkScalar k4) {
+ SkScalar k3, SkScalar k4,
+ bool enforcePMColor) {
if (fitsInBits(k1, 8) && fitsInBits(k2, 16) &&
fitsInBits(k2, 16) && fitsInBits(k2, 24)) {
return SkNEW_ARGS(SkArithmeticMode_linear, (i2, i3, i4));
#endif
}
- return SkArithmeticMode_scalar::Create(k1, k2, k3, k4);
+ return SkArithmeticMode_scalar::Create(k1, k2, k3, k4, enforcePMColor);
}
virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE;
+ static EffectKey GenKey(const GrDrawEffect&, const GrGLCaps& caps);
+
private:
GrGLUniformManager::UniformHandle fKUni;
+ bool fEnforcePMColor;
typedef GrGLEffect INHERITED;
};
class GrArithmeticEffect : public GrEffect {
public:
- static GrEffectRef* Create(float k1, float k2, float k3, float k4, GrTexture* background) {
- AutoEffectUnref effect(SkNEW_ARGS(GrArithmeticEffect, (k1, k2, k3, k4, background)));
+ static GrEffectRef* Create(float k1, float k2, float k3, float k4, bool enforcePMColor,
+ GrTexture* background) {
+ AutoEffectUnref effect(SkNEW_ARGS(GrArithmeticEffect, (k1, k2, k3, k4, enforcePMColor,
+ background)));
return CreateEffectRef(effect);
}
float k2() const { return fK2; }
float k3() const { return fK3; }
float k4() const { return fK4; }
+ bool enforcePMColor() const { return fEnforcePMColor; }
private:
virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE;
- GrArithmeticEffect(float k1, float k2, float k3, float k4, GrTexture* background);
+ GrArithmeticEffect(float k1, float k2, float k3, float k4, bool enforcePMColor,
+ GrTexture* background);
float fK1, fK2, fK3, fK4;
+ bool fEnforcePMColor;
GrCoordTransform fBackgroundTransform;
GrTextureAccess fBackgroundAccess;
///////////////////////////////////////////////////////////////////////////////
GrArithmeticEffect::GrArithmeticEffect(float k1, float k2, float k3, float k4,
- GrTexture* background)
- : fK1(k1), fK2(k2), fK3(k3), fK4(k4) {
+ bool enforcePMColor, GrTexture* background)
+ : fK1(k1), fK2(k2), fK3(k3), fK4(k4), fEnforcePMColor(enforcePMColor) {
if (background) {
fBackgroundTransform.reset(kLocal_GrCoordSet, background);
this->addCoordTransform(&fBackgroundTransform);
fK2 == s.fK2 &&
fK3 == s.fK3 &&
fK4 == s.fK4 &&
+ fEnforcePMColor == s.fEnforcePMColor &&
backgroundTexture() == s.backgroundTexture();
}
GrGLArithmeticEffect::GrGLArithmeticEffect(const GrBackendEffectFactory& factory,
const GrDrawEffect& drawEffect)
- : INHERITED(factory) {
+ : INHERITED(factory),
+ fEnforcePMColor(true) {
}
GrGLArithmeticEffect::~GrGLArithmeticEffect() {
builder->fsCodeAppendf("\t\t%s = clamp(%s, 0.0, 1.0);\n", outputColor, outputColor);
if (gUseUnpremul) {
builder->fsCodeAppendf("\t\t%s.rgb *= %s.a;\n", outputColor, outputColor);
- } else {
+ } else if (fEnforcePMColor) {
builder->fsCodeAppendf("\t\t%s.rgb = min(%s.rgb, %s.a);\n", outputColor, outputColor, outputColor);
}
}
void GrGLArithmeticEffect::setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) {
const GrArithmeticEffect& arith = drawEffect.castEffect<GrArithmeticEffect>();
uman.set4f(fKUni, arith.k1(), arith.k2(), arith.k3(), arith.k4());
+ fEnforcePMColor = arith.enforcePMColor();
+}
+
+GrGLEffect::EffectKey GrGLArithmeticEffect::GenKey(const GrDrawEffect& drawEffect,
+ const GrGLCaps&) {
+ const GrArithmeticEffect& arith = drawEffect.castEffect<GrArithmeticEffect>();
+ EffectKey key = arith.enforcePMColor() ? 1 : 0;
+ if (arith.backgroundTexture()) {
+ key |= 2;
+ }
+ return key;
}
GrEffectRef* GrArithmeticEffect::TestCreate(SkRandom* rand,
float k2 = rand->nextF();
float k3 = rand->nextF();
float k4 = rand->nextF();
+ bool enforcePMColor = rand->nextBool();
- AutoEffectUnref gEffect(SkNEW_ARGS(GrArithmeticEffect, (k1, k2, k3, k4, NULL)));
+ AutoEffectUnref gEffect(SkNEW_ARGS(GrArithmeticEffect,
+ (k1, k2, k3, k4, enforcePMColor, NULL)));
return CreateEffectRef(gEffect);
}
SkScalarToFloat(fK[1]),
SkScalarToFloat(fK[2]),
SkScalarToFloat(fK[3]),
+ fEnforcePMColor,
background);
}
return true;