1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
/*
* Copyright 2013 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkColorFilter.h"
#include "Test.h"
#if SK_SUPPORT_GPU
#include "GrContext.h"
#include "GrFragmentProcessor.h"
#include "GrInvariantOutput.h"
#include "SkGr.h"
static GrColor filterColor(const GrColor& color, uint32_t flags) {
uint32_t mask = 0;
if (flags & kR_GrColorComponentFlag) {
mask = 0xFF << GrColor_SHIFT_R;
}
if (flags & kG_GrColorComponentFlag) {
mask |= 0xFF << GrColor_SHIFT_G;
}
if (flags & kB_GrColorComponentFlag) {
mask |= 0xFF << GrColor_SHIFT_B;
}
if (flags & kA_GrColorComponentFlag) {
mask |= 0xFF << GrColor_SHIFT_A;
}
return color & mask;
}
DEF_GPUTEST_FOR_ALL_CONTEXTS(GpuColorFilter, reporter, ctxInfo) {
struct GetConstantComponentTestCase {
// "Shape drawn with"
uint32_t inputComponents; // "rgb of", "red of", "alpha of", ...
GrColor inputColor; // "[color]"
SkColor filterColor; // "with filter color [color]"
SkXfermode::Mode filterMode; // "in mode [mode]"
// "produces"
uint32_t outputComponents; // "rgb of", "red of", "alpha of", ...
GrColor outputColor; // "[color]"
};
// Shorthands.
enum {
kR = kR_GrColorComponentFlag,
kG = kG_GrColorComponentFlag,
kB = kB_GrColorComponentFlag,
kA = kA_GrColorComponentFlag,
kRGB = kRGB_GrColorComponentFlags,
kRGBA = kRGBA_GrColorComponentFlags
};
// Note: below, SkColors are non-premultiplied, where as GrColors are premultiplied.
const SkColor c1 = SkColorSetARGB(200, 200, 200, 200);
const SkColor c2 = SkColorSetARGB(60, 60, 60, 60);
const GrColor gr_c1 = SkColorToPremulGrColor(c1);
const GrColor gr_c2 = SkColorToPremulGrColor(c2);
const GrColor gr_black = GrColorPackA4(0);
const GrColor gr_white = GrColorPackA4(255);
const GrColor gr_whiteTrans = GrColorPackA4(128);
GetConstantComponentTestCase filterTests[] = {
// A color filtered with Clear produces black.
{ kRGBA, gr_white, SK_ColorBLACK, SkXfermode::kClear_Mode, kRGBA, gr_black },
{ kRGBA, gr_c1, SK_ColorWHITE, SkXfermode::kClear_Mode, kRGBA, gr_black },
{ kR, gr_white, c1, SkXfermode::kClear_Mode, kRGBA, gr_black },
// A color filtered with a color in mode Src, produces the filter color.
{ kRGBA, gr_c2, c1, SkXfermode::kSrc_Mode, kRGBA, gr_c1 },
{ kA, gr_c1, c1, SkXfermode::kSrc_Mode, kRGBA, gr_c1 },
// A color filtered with SrcOver produces a color.
{ kRGBA, gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kSrcOver_Mode, kRGBA, GrColorPackRGBA(164, 164, 164, 192)},
// An unknown color with known alpha filtered with SrcOver produces an unknown color with known alpha.
{ kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kSrcOver_Mode, kA , GrColorPackRGBA(0, 0, 0, 192)},
// A color with unknown alpha filtered with SrcOver produces a color with unknown alpha.
{ kRGB , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kSrcOver_Mode, kRGB, GrColorPackRGBA(164, 164, 164, 0)},
// A color filtered with DstOver produces a color.
{ kRGBA, gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kDstOver_Mode, kRGBA, GrColorPackRGBA(178, 178, 178, 192)},
// An unknown color with known alpha filtered with DstOver produces an unknown color with known alpha.
{ kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kDstOver_Mode, kA , GrColorPackRGBA(0, 0, 0, 192)},
// A color with unknown alpha filtered with DstOver produces an unknown color.
{ kRGB , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kDstOver_Mode, 0 , gr_black},
// An unknown color with known alpha and red component filtered with Multiply produces an unknown color with known red and alpha.
{ kR|kA , gr_whiteTrans, SkColorSetARGB(128, 200, 200, 200), SkXfermode::kModulate_Mode, kR|kA, GrColorPackRGBA(50, 0, 0, 64) }
};
GrPaint paint;
for (size_t i = 0; i < SK_ARRAY_COUNT(filterTests); ++i) {
const GetConstantComponentTestCase& test = filterTests[i];
auto cf(SkColorFilter::MakeModeFilter(test.filterColor, test.filterMode));
SkAutoTUnref<const GrFragmentProcessor> fp( cf->asFragmentProcessor(ctxInfo.fGrContext));
REPORTER_ASSERT(reporter, fp);
GrInvariantOutput inout(test.inputColor,
static_cast<GrColorComponentFlags>(test.inputComponents),
false);
fp->computeInvariantOutput(&inout);
REPORTER_ASSERT(reporter, filterColor(inout.color(), inout.validFlags()) ==
test.outputColor);
REPORTER_ASSERT(reporter, test.outputComponents == inout.validFlags());
}
}
#endif
|
