1 :
2 : /*
3 : * Copyright 2006 The Android Open Source Project
4 : *
5 : * Use of this source code is governed by a BSD-style license that can be
6 : * found in the LICENSE file.
7 : */
8 :
9 :
10 : #include "SkBlitRow.h"
11 : #include "SkColorFilter.h"
12 : #include "SkColorPriv.h"
13 : #include "SkUtils.h"
14 :
15 : #define ILLEGAL_XFERMODE_MODE ((SkXfermode::Mode)-1)
16 :
17 : // baseclass for filters that store a color and mode
18 0 : class SkModeColorFilter : public SkColorFilter {
19 : public:
20 : SkModeColorFilter(SkColor color) {
21 : fColor = color;
22 : fMode = ILLEGAL_XFERMODE_MODE;
23 :
24 : fPMColor = SkPreMultiplyColor(fColor);
25 : }
26 :
27 0 : SkModeColorFilter(SkColor color, SkXfermode::Mode mode) {
28 0 : fColor = color;
29 0 : fMode = mode;
30 :
31 0 : fPMColor = SkPreMultiplyColor(fColor);
32 0 : };
33 :
34 0 : virtual bool asColorMode(SkColor* color, SkXfermode::Mode* mode) {
35 0 : if (ILLEGAL_XFERMODE_MODE == fMode) {
36 0 : return false;
37 : }
38 :
39 0 : if (color) {
40 0 : *color = fColor;
41 : }
42 0 : if (mode) {
43 0 : *mode = fMode;
44 : }
45 0 : return true;
46 : }
47 :
48 : SkColor getColor() const { return fColor; }
49 : SkXfermode::Mode getMode() const { return fMode; }
50 : bool isModeValid() const { return ILLEGAL_XFERMODE_MODE != fMode; }
51 :
52 : protected:
53 0 : virtual void flatten(SkFlattenableWriteBuffer& buffer) {
54 0 : this->INHERITED::flatten(buffer);
55 0 : buffer.write32(fColor);
56 0 : buffer.write32(fMode);
57 0 : }
58 :
59 0 : SkModeColorFilter(SkFlattenableReadBuffer& buffer) {
60 0 : fColor = buffer.readU32();
61 0 : fMode = (SkXfermode::Mode)buffer.readU32();
62 :
63 0 : fPMColor = SkPreMultiplyColor(fColor);
64 0 : }
65 :
66 : // cache of fColor in premultiply space
67 : SkPMColor fPMColor;
68 :
69 : private:
70 : SkColor fColor;
71 : SkXfermode::Mode fMode;
72 :
73 : typedef SkColorFilter INHERITED;
74 : };
75 :
76 0 : class Src_SkModeColorFilter : public SkModeColorFilter {
77 : public:
78 0 : Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrc_Mode) {}
79 :
80 0 : virtual uint32_t getFlags() {
81 0 : if (SkGetPackedA32(fPMColor) == 0xFF) {
82 0 : return kAlphaUnchanged_Flag | kHasFilter16_Flag;
83 : } else {
84 0 : return 0;
85 : }
86 : }
87 :
88 0 : virtual void filterSpan(const SkPMColor shader[], int count,
89 : SkPMColor result[]) {
90 0 : sk_memset32(result, fPMColor, count);
91 0 : }
92 :
93 0 : virtual void filterSpan16(const uint16_t shader[], int count,
94 : uint16_t result[]) {
95 0 : SkASSERT(this->getFlags() & kHasFilter16_Flag);
96 0 : sk_memset16(result, SkPixel32ToPixel16(fPMColor), count);
97 0 : }
98 :
99 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
100 0 : return SkNEW_ARGS(Src_SkModeColorFilter, (buffer));
101 : }
102 :
103 : protected:
104 0 : virtual Factory getFactory() { return CreateProc; }
105 :
106 0 : Src_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
107 0 : : INHERITED(buffer) {}
108 :
109 : private:
110 : typedef SkModeColorFilter INHERITED;
111 : };
112 :
113 0 : class SrcOver_SkModeColorFilter : public SkModeColorFilter {
114 : public:
115 0 : SrcOver_SkModeColorFilter(SkColor color)
116 0 : : INHERITED(color, SkXfermode::kSrcOver_Mode) {
117 0 : fColor32Proc = NULL;
118 0 : }
119 :
120 0 : virtual uint32_t getFlags() {
121 0 : if (SkGetPackedA32(fPMColor) == 0xFF) {
122 0 : return kAlphaUnchanged_Flag | kHasFilter16_Flag;
123 : } else {
124 0 : return 0;
125 : }
126 : }
127 :
128 0 : virtual void filterSpan(const SkPMColor shader[], int count,
129 : SkPMColor result[]) {
130 0 : if (NULL == fColor32Proc) {
131 0 : fColor32Proc = SkBlitRow::ColorProcFactory();
132 : }
133 0 : fColor32Proc(result, shader, count, fPMColor);
134 0 : }
135 :
136 0 : virtual void filterSpan16(const uint16_t shader[], int count,
137 : uint16_t result[]) {
138 0 : SkASSERT(this->getFlags() & kHasFilter16_Flag);
139 0 : sk_memset16(result, SkPixel32ToPixel16(fPMColor), count);
140 0 : }
141 :
142 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
143 0 : return SkNEW_ARGS(SrcOver_SkModeColorFilter, (buffer));
144 : }
145 :
146 : protected:
147 0 : virtual Factory getFactory() { return CreateProc; }
148 :
149 0 : SrcOver_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
150 0 : : INHERITED(buffer), fColor32Proc(NULL) {}
151 :
152 : private:
153 :
154 : SkBlitRow::ColorProc fColor32Proc;
155 :
156 : typedef SkModeColorFilter INHERITED;
157 : };
158 :
159 : ///////////////////////////////////////////////////////////////////////////////
160 :
161 0 : class Proc_SkModeColorFilter : public SkModeColorFilter {
162 : public:
163 0 : Proc_SkModeColorFilter(SkColor color, SkXfermode::Mode mode) : INHERITED(color, mode) {
164 0 : fProc = SkXfermode::GetProc(mode);
165 0 : fProc16 = SkXfermode::GetProc16(mode, color);
166 0 : }
167 :
168 0 : Proc_SkModeColorFilter(SkColor color,
169 : SkXfermodeProc proc, SkXfermodeProc16 proc16)
170 0 : : INHERITED(color, ILLEGAL_XFERMODE_MODE) {
171 0 : fProc = proc;
172 0 : fProc16 = proc16;
173 0 : }
174 :
175 0 : virtual uint32_t getFlags() {
176 0 : return fProc16 ? (kAlphaUnchanged_Flag | kHasFilter16_Flag) : 0;
177 : }
178 :
179 0 : virtual void filterSpan(const SkPMColor shader[], int count,
180 : SkPMColor result[]) {
181 0 : SkPMColor color = fPMColor;
182 0 : SkXfermodeProc proc = fProc;
183 :
184 0 : for (int i = 0; i < count; i++) {
185 0 : result[i] = proc(color, shader[i]);
186 : }
187 0 : }
188 :
189 0 : virtual void filterSpan16(const uint16_t shader[], int count,
190 : uint16_t result[]) {
191 0 : SkASSERT(this->getFlags() & kHasFilter16_Flag);
192 :
193 0 : SkPMColor color = fPMColor;
194 0 : SkXfermodeProc16 proc16 = fProc16;
195 :
196 0 : for (int i = 0; i < count; i++) {
197 0 : result[i] = proc16(color, shader[i]);
198 : }
199 0 : }
200 :
201 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
202 0 : return SkNEW_ARGS(Proc_SkModeColorFilter, (buffer));
203 : }
204 :
205 : protected:
206 0 : virtual void flatten(SkFlattenableWriteBuffer& buffer) {
207 0 : this->INHERITED::flatten(buffer);
208 0 : buffer.writeFunctionPtr((void*)fProc);
209 0 : buffer.writeFunctionPtr((void*)fProc16);
210 0 : }
211 :
212 0 : virtual Factory getFactory() {
213 0 : return CreateProc;
214 : }
215 :
216 0 : Proc_SkModeColorFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
217 0 : fProc = (SkXfermodeProc) buffer.readFunctionPtr();
218 0 : fProc16 = (SkXfermodeProc16) buffer.readFunctionPtr();
219 0 : }
220 :
221 : private:
222 : SkXfermodeProc fProc;
223 : SkXfermodeProc16 fProc16;
224 :
225 : typedef SkModeColorFilter INHERITED;
226 : };
227 :
228 0 : SkColorFilter* SkColorFilter::CreateProcFilter(SkColor color,
229 : SkXfermodeProc proc,
230 : SkXfermodeProc16 proc16) {
231 : return proc ?
232 0 : SkNEW_ARGS(Proc_SkModeColorFilter, (color, proc, proc16)) :
233 0 : NULL;
234 : }
235 :
236 : ///////////////////////////////////////////////////////////////////////////////
237 :
238 0 : SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color,
239 : SkXfermode::Mode mode) {
240 0 : unsigned alpha = SkColorGetA(color);
241 :
242 : // first collaps some modes if possible
243 :
244 0 : if (SkXfermode::kClear_Mode == mode) {
245 0 : color = 0;
246 0 : mode = SkXfermode::kSrc_Mode;
247 0 : } else if (SkXfermode::kSrcOver_Mode == mode) {
248 0 : if (0 == alpha) {
249 0 : mode = SkXfermode::kDst_Mode;
250 0 : } else if (255 == alpha) {
251 0 : mode = SkXfermode::kSrc_Mode;
252 : }
253 : // else just stay srcover
254 : }
255 :
256 : // weed out combinations that are noops, and just return null
257 0 : if (SkXfermode::kDst_Mode == mode ||
258 : (0 == alpha && (SkXfermode::kSrcOver_Mode == mode ||
259 : SkXfermode::kDstOver_Mode == mode ||
260 : SkXfermode::kDstOut_Mode == mode ||
261 : SkXfermode::kSrcATop_Mode == mode ||
262 : SkXfermode::kXor_Mode == mode ||
263 : SkXfermode::kDarken_Mode == mode)) ||
264 : (0xFF == alpha && SkXfermode::kDstIn_Mode == mode)) {
265 0 : return NULL;
266 : }
267 :
268 0 : switch (mode) {
269 : case SkXfermode::kSrc_Mode:
270 0 : return SkNEW_ARGS(Src_SkModeColorFilter, (color));
271 : case SkXfermode::kSrcOver_Mode:
272 0 : return SkNEW_ARGS(SrcOver_SkModeColorFilter, (color));
273 : default:
274 0 : return SkNEW_ARGS(Proc_SkModeColorFilter, (color, mode));
275 : }
276 : }
277 :
278 : ///////////////////////////////////////////////////////////////////////////////
279 :
280 0 : static inline unsigned pin(unsigned value, unsigned max) {
281 0 : if (value > max) {
282 0 : value = max;
283 : }
284 0 : return value;
285 : }
286 :
287 : static inline unsigned SkUClampMax(unsigned value, unsigned max) {
288 : SkASSERT((int32_t)value >= 0);
289 : SkASSERT((int32_t)max >= 0);
290 :
291 : int diff = max - value;
292 : // clear diff if diff is positive
293 : diff &= diff >> 31;
294 :
295 : return value + diff;
296 : }
297 :
298 0 : class SkLightingColorFilter : public SkColorFilter {
299 : public:
300 0 : SkLightingColorFilter(SkColor mul, SkColor add) : fMul(mul), fAdd(add) {}
301 :
302 0 : virtual void filterSpan(const SkPMColor shader[], int count,
303 : SkPMColor result[]) {
304 0 : unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
305 0 : unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
306 0 : unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
307 :
308 0 : unsigned addR = SkColorGetR(fAdd);
309 0 : unsigned addG = SkColorGetG(fAdd);
310 0 : unsigned addB = SkColorGetB(fAdd);
311 :
312 0 : for (int i = 0; i < count; i++) {
313 0 : SkPMColor c = shader[i];
314 0 : if (c) {
315 0 : unsigned a = SkGetPackedA32(c);
316 0 : unsigned scaleA = SkAlpha255To256(a);
317 0 : unsigned r = pin(SkAlphaMul(SkGetPackedR32(c), scaleR) + SkAlphaMul(addR, scaleA), a);
318 0 : unsigned g = pin(SkAlphaMul(SkGetPackedG32(c), scaleG) + SkAlphaMul(addG, scaleA), a);
319 0 : unsigned b = pin(SkAlphaMul(SkGetPackedB32(c), scaleB) + SkAlphaMul(addB, scaleA), a);
320 0 : c = SkPackARGB32(a, r, g, b);
321 : }
322 0 : result[i] = c;
323 : }
324 0 : }
325 :
326 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
327 0 : return SkNEW_ARGS(SkLightingColorFilter, (buffer));
328 : }
329 :
330 : protected:
331 0 : virtual void flatten(SkFlattenableWriteBuffer& buffer) {
332 0 : this->INHERITED::flatten(buffer);
333 0 : buffer.write32(fMul);
334 0 : buffer.write32(fAdd);
335 0 : }
336 :
337 0 : virtual Factory getFactory() {
338 0 : return CreateProc;
339 : }
340 :
341 0 : SkLightingColorFilter(SkFlattenableReadBuffer& buffer) {
342 0 : fMul = buffer.readU32();
343 0 : fAdd = buffer.readU32();
344 0 : }
345 :
346 : SkColor fMul, fAdd;
347 :
348 : private:
349 : typedef SkColorFilter INHERITED;
350 : };
351 :
352 0 : class SkLightingColorFilter_JustAdd : public SkLightingColorFilter {
353 : public:
354 0 : SkLightingColorFilter_JustAdd(SkColor mul, SkColor add)
355 0 : : INHERITED(mul, add) {}
356 :
357 0 : virtual void filterSpan(const SkPMColor shader[], int count,
358 : SkPMColor result[]) {
359 0 : unsigned addR = SkColorGetR(fAdd);
360 0 : unsigned addG = SkColorGetG(fAdd);
361 0 : unsigned addB = SkColorGetB(fAdd);
362 :
363 0 : for (int i = 0; i < count; i++) {
364 0 : SkPMColor c = shader[i];
365 0 : if (c) {
366 0 : unsigned a = SkGetPackedA32(c);
367 0 : unsigned scaleA = SkAlpha255To256(a);
368 0 : unsigned r = pin(SkGetPackedR32(c) + SkAlphaMul(addR, scaleA), a);
369 0 : unsigned g = pin(SkGetPackedG32(c) + SkAlphaMul(addG, scaleA), a);
370 0 : unsigned b = pin(SkGetPackedB32(c) + SkAlphaMul(addB, scaleA), a);
371 0 : c = SkPackARGB32(a, r, g, b);
372 : }
373 0 : result[i] = c;
374 : }
375 0 : }
376 :
377 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
378 0 : return SkNEW_ARGS(SkLightingColorFilter_JustAdd, (buffer));
379 : }
380 :
381 : protected:
382 0 : virtual Factory getFactory() { return CreateProc; }
383 :
384 0 : SkLightingColorFilter_JustAdd(SkFlattenableReadBuffer& buffer)
385 0 : : INHERITED(buffer) {}
386 :
387 : private:
388 : typedef SkLightingColorFilter INHERITED;
389 : };
390 :
391 0 : class SkLightingColorFilter_JustMul : public SkLightingColorFilter {
392 : public:
393 0 : SkLightingColorFilter_JustMul(SkColor mul, SkColor add)
394 0 : : INHERITED(mul, add) {}
395 :
396 0 : virtual void filterSpan(const SkPMColor shader[], int count,
397 : SkPMColor result[]) {
398 0 : unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
399 0 : unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
400 0 : unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
401 :
402 0 : for (int i = 0; i < count; i++) {
403 0 : SkPMColor c = shader[i];
404 0 : if (c) {
405 0 : unsigned a = SkGetPackedA32(c);
406 0 : unsigned r = SkAlphaMul(SkGetPackedR32(c), scaleR);
407 0 : unsigned g = SkAlphaMul(SkGetPackedG32(c), scaleG);
408 0 : unsigned b = SkAlphaMul(SkGetPackedB32(c), scaleB);
409 0 : c = SkPackARGB32(a, r, g, b);
410 : }
411 0 : result[i] = c;
412 : }
413 0 : }
414 :
415 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
416 0 : return SkNEW_ARGS(SkLightingColorFilter_JustMul, (buffer));
417 : }
418 :
419 : protected:
420 0 : virtual Factory getFactory() { return CreateProc; }
421 :
422 0 : SkLightingColorFilter_JustMul(SkFlattenableReadBuffer& buffer)
423 0 : : INHERITED(buffer) {}
424 :
425 : private:
426 : typedef SkLightingColorFilter INHERITED;
427 : };
428 :
429 0 : class SkLightingColorFilter_SingleMul : public SkLightingColorFilter {
430 : public:
431 0 : SkLightingColorFilter_SingleMul(SkColor mul, SkColor add)
432 0 : : INHERITED(mul, add) {
433 0 : SkASSERT(SkColorGetR(add) == 0);
434 0 : SkASSERT(SkColorGetG(add) == 0);
435 0 : SkASSERT(SkColorGetB(add) == 0);
436 0 : SkASSERT(SkColorGetR(mul) == SkColorGetG(mul));
437 0 : SkASSERT(SkColorGetR(mul) == SkColorGetB(mul));
438 0 : }
439 :
440 0 : virtual uint32_t getFlags() {
441 0 : return this->INHERITED::getFlags() | (kAlphaUnchanged_Flag | kHasFilter16_Flag);
442 : }
443 :
444 0 : virtual void filterSpan16(const uint16_t shader[], int count,
445 : uint16_t result[]) {
446 : // all mul components are the same
447 0 : unsigned scale = SkAlpha255To256(SkColorGetR(fMul));
448 :
449 0 : if (count > 0) {
450 0 : do {
451 0 : *result++ = SkAlphaMulRGB16(*shader++, scale);
452 : } while (--count > 0);
453 : }
454 0 : }
455 :
456 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
457 0 : return SkNEW_ARGS(SkLightingColorFilter_SingleMul, (buffer));
458 : }
459 :
460 : protected:
461 0 : virtual Factory getFactory() { return CreateProc; }
462 :
463 0 : SkLightingColorFilter_SingleMul(SkFlattenableReadBuffer& buffer)
464 0 : : INHERITED(buffer) {}
465 :
466 : private:
467 : typedef SkLightingColorFilter INHERITED;
468 : };
469 :
470 0 : class SkLightingColorFilter_NoPin : public SkLightingColorFilter {
471 : public:
472 0 : SkLightingColorFilter_NoPin(SkColor mul, SkColor add)
473 0 : : INHERITED(mul, add) {}
474 :
475 0 : virtual void filterSpan(const SkPMColor shader[], int count,
476 : SkPMColor result[]) {
477 0 : unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
478 0 : unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
479 0 : unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
480 :
481 0 : unsigned addR = SkColorGetR(fAdd);
482 0 : unsigned addG = SkColorGetG(fAdd);
483 0 : unsigned addB = SkColorGetB(fAdd);
484 :
485 0 : for (int i = 0; i < count; i++) {
486 0 : SkPMColor c = shader[i];
487 0 : if (c) {
488 0 : unsigned a = SkGetPackedA32(c);
489 0 : unsigned scaleA = SkAlpha255To256(a);
490 0 : unsigned r = SkAlphaMul(SkGetPackedR32(c), scaleR) + SkAlphaMul(addR, scaleA);
491 0 : unsigned g = SkAlphaMul(SkGetPackedG32(c), scaleG) + SkAlphaMul(addG, scaleA);
492 0 : unsigned b = SkAlphaMul(SkGetPackedB32(c), scaleB) + SkAlphaMul(addB, scaleA);
493 0 : c = SkPackARGB32(a, r, g, b);
494 : }
495 0 : result[i] = c;
496 : }
497 0 : }
498 :
499 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
500 0 : return SkNEW_ARGS(SkLightingColorFilter_NoPin, (buffer));
501 : }
502 :
503 : protected:
504 0 : virtual Factory getFactory() { return CreateProc; }
505 :
506 0 : SkLightingColorFilter_NoPin(SkFlattenableReadBuffer& buffer)
507 0 : : INHERITED(buffer) {}
508 :
509 : private:
510 : typedef SkLightingColorFilter INHERITED;
511 : };
512 :
513 : ///////////////////////////////////////////////////////////////////////////////
514 :
515 0 : class SkSimpleColorFilter : public SkColorFilter {
516 : public:
517 0 : static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
518 0 : return SkNEW(SkSimpleColorFilter);
519 : }
520 :
521 : protected:
522 0 : void filterSpan(const SkPMColor src[], int count, SkPMColor result[]) {
523 0 : if (result != src) {
524 0 : memcpy(result, src, count * sizeof(SkPMColor));
525 : }
526 0 : }
527 :
528 0 : virtual void flatten(SkFlattenableWriteBuffer& buffer) {}
529 :
530 0 : virtual Factory getFactory() {
531 0 : return CreateProc;
532 : }
533 :
534 : };
535 :
536 0 : SkColorFilter* SkColorFilter::CreateLightingFilter(SkColor mul, SkColor add) {
537 0 : mul &= 0x00FFFFFF;
538 0 : add &= 0x00FFFFFF;
539 :
540 0 : if (0xFFFFFF == mul) {
541 0 : if (0 == add) {
542 0 : return SkNEW(SkSimpleColorFilter); // no change to the colors
543 : } else {
544 0 : return SkNEW_ARGS(SkLightingColorFilter_JustAdd, (mul, add));
545 : }
546 : }
547 :
548 0 : if (0 == add) {
549 0 : if (SkColorGetR(mul) == SkColorGetG(mul) &&
550 : SkColorGetR(mul) == SkColorGetB(mul)) {
551 0 : return SkNEW_ARGS(SkLightingColorFilter_SingleMul, (mul, add));
552 : } else {
553 0 : return SkNEW_ARGS(SkLightingColorFilter_JustMul, (mul, add));
554 : }
555 : }
556 :
557 0 : if (SkColorGetR(mul) + SkColorGetR(add) <= 255 &&
558 : SkColorGetG(mul) + SkColorGetG(add) <= 255 &&
559 : SkColorGetB(mul) + SkColorGetB(add) <= 255) {
560 0 : return SkNEW_ARGS(SkLightingColorFilter_NoPin, (mul, add));
561 : }
562 :
563 0 : return SkNEW_ARGS(SkLightingColorFilter, (mul, add));
564 : }
565 :
566 : SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkColorFilter)
567 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(Src_SkModeColorFilter)
568 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SrcOver_SkModeColorFilter)
569 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(Proc_SkModeColorFilter)
570 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter)
571 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustAdd)
572 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustMul)
573 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_SingleMul)
574 1464 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_NoPin)
575 4392 : SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSimpleColorFilter)
576 : SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
577 :
|