| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2013 Google Inc. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license that can be | |
| 5 * found in the LICENSE file. | |
| 6 */ | |
| 7 | |
| 8 #include "SkLumaXfermode.h" | |
| 9 #include "SkColorPriv.h" | |
| 10 #include "SkFlattenableBuffers.h" | |
| 11 #include "SkString.h" | |
| 12 | |
| 13 #if SK_SUPPORT_GPU | |
| 14 #include "gl/GrGLEffect.h" | |
| 15 #include "GrContext.h" | |
| 16 #include "GrTBackendEffectFactory.h" | |
| 17 #endif | |
| 18 | |
| 19 class SkLumaMaskXfermodeSrcOver : public SkLumaMaskXfermode { | |
| 20 public: | |
| 21 SkLumaMaskXfermodeSrcOver(); | |
| 22 | |
| 23 SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLumaMaskXfermodeSrcOve
r) | |
| 24 | |
| 25 protected: | |
| 26 SkLumaMaskXfermodeSrcOver(SkFlattenableReadBuffer&); | |
| 27 | |
| 28 private: | |
| 29 typedef SkLumaMaskXfermode INHERITED; | |
| 30 | |
| 31 virtual SkPMColor lumaProc(const SkPMColor a, const SkPMColor b) const; | |
| 32 }; | |
| 33 | |
| 34 SkPMColor SkLumaMaskXfermode::lumaProc(const SkPMColor a, const SkPMColor b) con
st { | |
| 35 unsigned luma = SkComputeLuminance(SkGetPackedR32(b), | |
| 36 SkGetPackedG32(b), | |
| 37 SkGetPackedB32(b)); | |
| 38 return SkAlphaMulQ(a, SkAlpha255To256(luma)); | |
| 39 } | |
| 40 | |
| 41 template <typename T> | |
| 42 static inline const T* lumaOpA(SkXfermode::Mode mode, | |
| 43 const T* src, const T* dst) { | |
| 44 return SkXfermode::kSrcIn_Mode == mode ? src : dst; | |
| 45 } | |
| 46 | |
| 47 template <typename T> | |
| 48 static inline const T* lumaOpB(SkXfermode::Mode mode, | |
| 49 const T* src, const T* dst) { | |
| 50 return SkXfermode::kSrcIn_Mode == mode ? dst : src; | |
| 51 } | |
| 52 | |
| 53 SkXfermode* SkLumaMaskXfermode::Create(SkXfermode::Mode mode) { | |
| 54 if (kSrcIn_Mode == mode || kDstIn_Mode == mode) { | |
| 55 return SkNEW_ARGS(SkLumaMaskXfermode, (mode)); | |
| 56 } | |
| 57 if (kSrcOver_Mode == mode) { | |
| 58 return SkNEW_ARGS(SkLumaMaskXfermodeSrcOver, ()); | |
| 59 } | |
| 60 | |
| 61 return NULL; | |
| 62 } | |
| 63 | |
| 64 SkLumaMaskXfermode::SkLumaMaskXfermode(SkXfermode::Mode mode) | |
| 65 : fMode(mode) { | |
| 66 SkASSERT(kSrcIn_Mode == mode || kDstIn_Mode == mode || kSrcOver_Mode == mode
); | |
| 67 } | |
| 68 | |
| 69 SkLumaMaskXfermode::SkLumaMaskXfermode(SkFlattenableReadBuffer& buffer) | |
| 70 : INHERITED(buffer) | |
| 71 , fMode((SkXfermode::Mode)buffer.readUInt()) { | |
| 72 SkASSERT(kSrcIn_Mode == fMode || kDstIn_Mode == fMode || kSrcOver_Mode == fM
ode); | |
| 73 } | |
| 74 | |
| 75 void SkLumaMaskXfermode::flatten(SkFlattenableWriteBuffer& buffer) const { | |
| 76 INHERITED::flatten(buffer); | |
| 77 buffer.writeUInt(fMode); | |
| 78 } | |
| 79 | |
| 80 SkPMColor SkLumaMaskXfermode::xferColor(SkPMColor src, SkPMColor dst) const { | |
| 81 const SkPMColor* a = lumaOpA<SkPMColor>(fMode, &src, &dst); | |
| 82 const SkPMColor* b = lumaOpB<SkPMColor>(fMode, &src, &dst); | |
| 83 return this->lumaProc(*a, *b); | |
| 84 } | |
| 85 | |
| 86 void SkLumaMaskXfermode::xfer32(SkPMColor dst[], const SkPMColor src[], | |
| 87 int count, const SkAlpha aa[]) const { | |
| 88 const SkPMColor* a = lumaOpA<SkPMColor>(fMode, src, dst); | |
| 89 const SkPMColor* b = lumaOpB<SkPMColor>(fMode, src, dst); | |
| 90 | |
| 91 if (aa) { | |
| 92 for (int i = 0; i < count; ++i) { | |
| 93 unsigned cov = aa[i]; | |
| 94 if (cov) { | |
| 95 unsigned resC = this->lumaProc(a[i], b[i]); | |
| 96 if (cov < 255) { | |
| 97 resC = SkFastFourByteInterp256(resC, dst[i], | |
| 98 SkAlpha255To256(cov)); | |
| 99 } | |
| 100 dst[i] = resC; | |
| 101 } | |
| 102 } | |
| 103 } else { | |
| 104 for (int i = 0; i < count; ++i) { | |
| 105 dst[i] = this->lumaProc(a[i], b[i]); | |
| 106 } | |
| 107 } | |
| 108 } | |
| 109 | |
| 110 #ifdef SK_DEVELOPER | |
| 111 void SkLumaMaskXfermode::toString(SkString* str) const { | |
| 112 str->printf("SkLumaMaskXfermode: mode: %s", | |
| 113 fMode == kSrcIn_Mode ? "SRC_IN" : | |
| 114 fMode == kDstIn_Mode ? "DST_IN" : "SRC_OVER"); | |
| 115 } | |
| 116 #endif | |
| 117 | |
| 118 SkLumaMaskXfermodeSrcOver::SkLumaMaskXfermodeSrcOver() : SkLumaMaskXfermode(kSrc
Over_Mode) {} | |
| 119 | |
| 120 SkLumaMaskXfermodeSrcOver::SkLumaMaskXfermodeSrcOver(SkFlattenableReadBuffer& bu
ffer) | |
| 121 : INHERITED(buffer) { | |
| 122 } | |
| 123 | |
| 124 SkPMColor SkLumaMaskXfermodeSrcOver::lumaProc(const SkPMColor a, const SkPMColor
b) const { | |
| 125 unsigned luma = SkComputeLuminance(SkGetPackedR32(b), | |
| 126 SkGetPackedG32(b), | |
| 127 SkGetPackedB32(b)); | |
| 128 | |
| 129 unsigned oldAlpha = SkGetPackedA32(b); | |
| 130 unsigned newR = 0, newG = 0, newB = 0; | |
| 131 | |
| 132 if (oldAlpha > 0) { | |
| 133 newR = SkGetPackedR32(b) * 255 / oldAlpha; | |
| 134 newG = SkGetPackedG32(b) * 255 / oldAlpha; | |
| 135 newB = SkGetPackedB32(b) * 255 / oldAlpha; | |
| 136 } | |
| 137 | |
| 138 SkPMColor colorB = SkPremultiplyARGBInline(luma, newR, newG, newB); | |
| 139 | |
| 140 return SkPMSrcOver(colorB, a); | |
| 141 } | |
| 142 | |
| 143 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLumaMaskXfermode) | |
| 144 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLumaMaskXfermode) | |
| 145 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLumaMaskXfermodeSrcOver) | |
| 146 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | |
| 147 | |
| 148 #if SK_SUPPORT_GPU | |
| 149 ////////////////////////////////////////////////////////////////////////////// | |
| 150 | |
| 151 class GrGLLumaMaskEffect : public GrGLEffect { | |
| 152 public: | |
| 153 GrGLLumaMaskEffect(const GrBackendEffectFactory&, const GrDrawEffect&); | |
| 154 virtual ~GrGLLumaMaskEffect(); | |
| 155 | |
| 156 virtual void emitCode(GrGLShaderBuilder*, | |
| 157 const GrDrawEffect&, | |
| 158 EffectKey, | |
| 159 const char* outputColor, | |
| 160 const char* inputColor, | |
| 161 const TransformedCoordsArray&, | |
| 162 const TextureSamplerArray&) SK_OVERRIDE; | |
| 163 | |
| 164 static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&); | |
| 165 | |
| 166 private: | |
| 167 typedef GrGLEffect INHERITED; | |
| 168 }; | |
| 169 | |
| 170 class GrLumaMaskEffect : public GrEffect { | |
| 171 public: | |
| 172 static GrEffectRef* Create(SkXfermode::Mode mode) { | |
| 173 AutoEffectUnref effect(SkNEW_ARGS(GrLumaMaskEffect, (mode))); | |
| 174 return CreateEffectRef(effect); | |
| 175 } | |
| 176 | |
| 177 virtual ~GrLumaMaskEffect(); | |
| 178 | |
| 179 typedef GrGLLumaMaskEffect GLEffect; | |
| 180 static const char* Name() { return "LumaMask"; } | |
| 181 | |
| 182 virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; | |
| 183 virtual void getConstantColorComponents(GrColor*, uint32_t*) const SK_OVERRI
DE; | |
| 184 | |
| 185 SkXfermode::Mode getMode() const { return fMode; } | |
| 186 | |
| 187 private: | |
| 188 GrLumaMaskEffect(SkXfermode::Mode); | |
| 189 | |
| 190 virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE; | |
| 191 | |
| 192 const SkXfermode::Mode fMode; | |
| 193 }; | |
| 194 | |
| 195 ////////////////////////////////////////////////////////////////////////////// | |
| 196 | |
| 197 GrGLLumaMaskEffect::GrGLLumaMaskEffect(const GrBackendEffectFactory& factory, | |
| 198 const GrDrawEffect&) | |
| 199 : INHERITED(factory) { | |
| 200 } | |
| 201 | |
| 202 GrGLLumaMaskEffect::~GrGLLumaMaskEffect() { | |
| 203 } | |
| 204 | |
| 205 void GrGLLumaMaskEffect::emitCode(GrGLShaderBuilder* builder, | |
| 206 const GrDrawEffect& effect, | |
| 207 EffectKey key, | |
| 208 const char* outputColor, | |
| 209 const char* inputColor, | |
| 210 const TransformedCoordsArray&, | |
| 211 const TextureSamplerArray& samplers) { | |
| 212 | |
| 213 const GrLumaMaskEffect& lumaEffect = effect.castEffect<GrLumaMaskEffect>(); | |
| 214 const char* dstColor = builder->dstColor(); | |
| 215 SkASSERT(NULL != dstColor); | |
| 216 if (NULL == inputColor) { | |
| 217 inputColor = "vec4(1)"; | |
| 218 } | |
| 219 | |
| 220 const char *opA = lumaOpA<char>(lumaEffect.getMode(), inputColor, dstColor); | |
| 221 const char *opB = lumaOpB<char>(lumaEffect.getMode(), inputColor, dstColor); | |
| 222 | |
| 223 builder->fsCodeAppendf("\t\tfloat luma = dot(vec3(%f, %f, %f), %s.rgb); \n", | |
| 224 SK_ITU_BT709_LUM_COEFF_R, | |
| 225 SK_ITU_BT709_LUM_COEFF_G, | |
| 226 SK_ITU_BT709_LUM_COEFF_B, | |
| 227 opB); | |
| 228 if (SkXfermode::kSrcOver_Mode == lumaEffect.getMode()) { | |
| 229 builder->fsCodeAppendf("\t\tvec4 newB = %s;\n\t\tif (newB.a > 0.0) { new
B *= luma / newB.a; }\n\t\tnewB.a = luma;\n", opB); | |
| 230 builder->fsCodeAppendf("\t\t%s = newB + %s * (1.0 - luma); \n", outputCo
lor, opA); | |
| 231 } else { | |
| 232 builder->fsCodeAppendf("\t\t%s = %s * luma;\n", outputColor, opA); | |
| 233 } | |
| 234 } | |
| 235 | |
| 236 GrGLEffect::EffectKey GrGLLumaMaskEffect::GenKey(const GrDrawEffect& drawEffect, | |
| 237 const GrGLCaps&) { | |
| 238 const GrLumaMaskEffect& effect = drawEffect.castEffect<GrLumaMaskEffect>(); | |
| 239 return (EffectKey)effect.getMode(); | |
| 240 } | |
| 241 | |
| 242 ////////////////////////////////////////////////////////////////////////////// | |
| 243 | |
| 244 GrLumaMaskEffect::GrLumaMaskEffect(SkXfermode::Mode mode) | |
| 245 : fMode(mode) { | |
| 246 this->setWillReadDstColor(); | |
| 247 } | |
| 248 | |
| 249 GrLumaMaskEffect::~GrLumaMaskEffect() { | |
| 250 } | |
| 251 | |
| 252 const GrBackendEffectFactory& GrLumaMaskEffect::getFactory() const { | |
| 253 return GrTBackendEffectFactory<GrLumaMaskEffect>::getInstance(); | |
| 254 } | |
| 255 | |
| 256 void GrLumaMaskEffect::getConstantColorComponents(GrColor*, uint32_t *validFlags
) const { | |
| 257 *validFlags = 0; | |
| 258 } | |
| 259 | |
| 260 bool GrLumaMaskEffect::onIsEqual(const GrEffect& sBase) const { | |
| 261 return fMode == CastEffect<GrLumaMaskEffect>(sBase).fMode; | |
| 262 } | |
| 263 | |
| 264 ////////////////////////////////////////////////////////////////////////////// | |
| 265 | |
| 266 bool SkLumaMaskXfermode::asNewEffectOrCoeff(GrContext*, GrEffectRef** effect, | |
| 267 Coeff*, Coeff*, | |
| 268 GrTexture* background) const { | |
| 269 // No background texture support. | |
| 270 if (effect && !background) { | |
| 271 *effect = GrLumaMaskEffect::Create(fMode); | |
| 272 return true; | |
| 273 } | |
| 274 | |
| 275 return false; | |
| 276 } | |
| 277 | |
| 278 #endif // SK_SUPPORT_GPU | |
| OLD | NEW |
|---|
Chromium Code Reviews
