1 /*
2  * Copyright 2011 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 
9 #include "src/gpu/GrStencilSettings.h"
10 
11 #include "src/gpu/GrProcessor.h"
12 
13 constexpr const GrUserStencilSettings gUnused(
14     GrUserStencilSettings::StaticInit<
15         0x0000,
16         GrUserStencilTest::kAlwaysIfInClip,
17         0xffff,
18         GrUserStencilOp::kKeep,
19         GrUserStencilOp::kKeep,
20         0x0000>()
21 );
22 
23 static_assert(kAll_StencilFlags == (gUnused.fCWFlags[0] & gUnused.fCCWFlags[0]));
24 
25 const GrUserStencilSettings& GrUserStencilSettings::kUnused = gUnused;
26 
reset(const GrUserStencilSettings & user,bool hasStencilClip,int numStencilBits)27 void GrStencilSettings::reset(const GrUserStencilSettings& user, bool hasStencilClip,
28                               int numStencilBits) {
29     uint16_t cwFlags = user.fCWFlags[hasStencilClip];
30     if (cwFlags & kSingleSided_StencilFlag) {
31         SkASSERT(cwFlags == user.fCCWFlags[hasStencilClip]);
32         fFlags = cwFlags;
33         if (!this->isDisabled()) {
34             fCWFace.reset(user.fCWFace, hasStencilClip, numStencilBits);
35         }
36         return;
37     }
38 
39     uint16_t ccwFlags = user.fCCWFlags[hasStencilClip];
40     fFlags = cwFlags & ccwFlags;
41     if (this->isDisabled()) {
42         return;
43     }
44     if (!(cwFlags & kDisabled_StencilFlag)) {
45         fCWFace.reset(user.fCWFace, hasStencilClip, numStencilBits);
46     } else {
47         fCWFace.setDisabled();
48     }
49     if (!(ccwFlags & kDisabled_StencilFlag)) {
50         fCCWFace.reset(user.fCCWFace, hasStencilClip, numStencilBits);
51     } else {
52         fCCWFace.setDisabled();
53     }
54 }
55 
reset(const GrStencilSettings & that)56 void GrStencilSettings::reset(const GrStencilSettings& that) {
57     fFlags = that.fFlags;
58     if ((kInvalid_PrivateFlag | kDisabled_StencilFlag) & fFlags) {
59         return;
60     }
61     if (!this->isTwoSided()) {
62         memcpy(&fCWFace, &that.fCWFace, sizeof(Face));
63     } else {
64         memcpy(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
65         static_assert(sizeof(Face) ==
66                       offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
67     }
68 }
69 
operator ==(const GrStencilSettings & that) const70 bool GrStencilSettings::operator==(const GrStencilSettings& that) const {
71     if ((kInvalid_PrivateFlag | kDisabled_StencilFlag) & (fFlags | that.fFlags)) {
72         // At least one is invalid and/or disabled.
73         if (kInvalid_PrivateFlag & (fFlags | that.fFlags)) {
74             return false; // We never allow invalid stencils to be equal.
75         }
76         // They're only equal if both are disabled.
77         return kDisabled_StencilFlag & (fFlags & that.fFlags);
78     }
79     if (kSingleSided_StencilFlag & (fFlags & that.fFlags)) {
80         return 0 == memcmp(&fCWFace, &that.fCWFace, sizeof(Face)); // Both are single sided.
81     } else if (kSingleSided_StencilFlag & (fFlags | that.fFlags)) {
82         return false;
83     } else {
84         return 0 == memcmp(&fCWFace, &that.fCWFace, 2 * sizeof(Face));
85         static_assert(sizeof(Face) ==
86                       offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
87     }
88     // memcmp relies on GrStencilSettings::Face being tightly packed.
89     static_assert(0 == offsetof(Face, fRef));
90     static_assert(2 == sizeof(Face::fRef));
91     static_assert(2 == offsetof(Face, fTest));
92     static_assert(2 == sizeof(Face::fTest));
93     static_assert(4 == offsetof(Face, fTestMask));
94     static_assert(2 == sizeof(Face::fTestMask));
95     static_assert(6 == offsetof(Face, fPassOp));
96     static_assert(1 == sizeof(Face::fPassOp));
97     static_assert(7 == offsetof(Face, fFailOp));
98     static_assert(1 == sizeof(Face::fFailOp));
99     static_assert(8 == offsetof(Face, fWriteMask));
100     static_assert(2 == sizeof(Face::fWriteMask));
101     static_assert(10 == sizeof(Face));
102 }
103 
104 static constexpr GrStencilTest gUserStencilTestToRaw[kGrUserStencilTestCount] = {
105     // Tests that respect the clip.
106     GrStencilTest::kAlways,  // kAlwaysIfInClip (This is only for when there is not a stencil clip).
107     GrStencilTest::kEqual,   // kEqualIfInClip.
108     GrStencilTest::kLess,    // kLessIfInClip.
109     GrStencilTest::kLEqual,  // kLEqualIfInClip.
110 
111     // Tests that ignore the clip.
112     GrStencilTest::kAlways,
113     GrStencilTest::kNever,
114     GrStencilTest::kGreater,
115     GrStencilTest::kGEqual,
116     GrStencilTest::kLess,
117     GrStencilTest::kLEqual,
118     GrStencilTest::kEqual,
119     GrStencilTest::kNotEqual
120 };
121 
122 static_assert(0 == (int)GrUserStencilTest::kAlwaysIfInClip);
123 static_assert(1 == (int)GrUserStencilTest::kEqualIfInClip);
124 static_assert(2 == (int)GrUserStencilTest::kLessIfInClip);
125 static_assert(3 == (int)GrUserStencilTest::kLEqualIfInClip);
126 static_assert(4 == (int)GrUserStencilTest::kAlways);
127 static_assert(5 == (int)GrUserStencilTest::kNever);
128 static_assert(6 == (int)GrUserStencilTest::kGreater);
129 static_assert(7 == (int)GrUserStencilTest::kGEqual);
130 static_assert(8 == (int)GrUserStencilTest::kLess);
131 static_assert(9 == (int)GrUserStencilTest::kLEqual);
132 static_assert(10 == (int)GrUserStencilTest::kEqual);
133 static_assert(11 == (int)GrUserStencilTest::kNotEqual);
134 
135 static constexpr GrStencilOp gUserStencilOpToRaw[kGrUserStencilOpCount] = {
136     GrStencilOp::kKeep,
137 
138     // Ops that only modify user bits.
139     GrStencilOp::kZero,
140     GrStencilOp::kReplace,
141     GrStencilOp::kInvert,
142     GrStencilOp::kIncWrap,
143     GrStencilOp::kDecWrap,
144     GrStencilOp::kIncClamp,  // kIncMaybeClamp.
145     GrStencilOp::kDecClamp,  // kDecMaybeClamp.
146 
147     // Ops that only modify the clip bit.
148     GrStencilOp::kZero,      // kZeroClipBit.
149     GrStencilOp::kReplace,   // kSetClipBit.
150     GrStencilOp::kInvert,    // kInvertClipBit.
151 
152     // Ops that modify clip and user bits.
153     GrStencilOp::kReplace,   // kSetClipAndReplaceUserBits.
154     GrStencilOp::kZero       // kZeroClipAndUserBits.
155 };
156 
157 static_assert(0 == (int)GrUserStencilOp::kKeep);
158 static_assert(1 == (int)GrUserStencilOp::kZero);
159 static_assert(2 == (int)GrUserStencilOp::kReplace);
160 static_assert(3 == (int)GrUserStencilOp::kInvert);
161 static_assert(4 == (int)GrUserStencilOp::kIncWrap);
162 static_assert(5 == (int)GrUserStencilOp::kDecWrap);
163 static_assert(6 == (int)GrUserStencilOp::kIncMaybeClamp);
164 static_assert(7 == (int)GrUserStencilOp::kDecMaybeClamp);
165 static_assert(8 == (int)GrUserStencilOp::kZeroClipBit);
166 static_assert(9 == (int)GrUserStencilOp::kSetClipBit);
167 static_assert(10 == (int)GrUserStencilOp::kInvertClipBit);
168 static_assert(11 == (int)GrUserStencilOp::kSetClipAndReplaceUserBits);
169 static_assert(12 == (int)GrUserStencilOp::kZeroClipAndUserBits);
170 
reset(const GrUserStencilSettings::Face & user,bool hasStencilClip,int numStencilBits)171 void GrStencilSettings::Face::reset(const GrUserStencilSettings::Face& user, bool hasStencilClip,
172                                     int numStencilBits) {
173     SkASSERT(user.fTest < (GrUserStencilTest)kGrUserStencilTestCount);
174     SkASSERT(user.fPassOp < (GrUserStencilOp)kGrUserStencilOpCount);
175     SkASSERT(user.fFailOp < (GrUserStencilOp)kGrUserStencilOpCount);
176     SkASSERT(numStencilBits > 0 && numStencilBits <= 16);
177     int clipBit = 1 << (numStencilBits - 1);
178     int userMask = clipBit - 1;
179 
180     GrUserStencilOp maxOp = std::max(user.fPassOp, user.fFailOp);
181     SkDEBUGCODE(GrUserStencilOp otherOp = std::min(user.fPassOp, user.fFailOp);)
182     if (maxOp <= kLastUserOnlyStencilOp) {
183         // Ops that only modify user bits.
184         fWriteMask = user.fWriteMask & userMask;
185         SkASSERT(otherOp <= kLastUserOnlyStencilOp);
186     } else if (maxOp <= kLastClipOnlyStencilOp) {
187         // Ops that only modify the clip bit.
188         fWriteMask = clipBit;
189         SkASSERT(GrUserStencilOp::kKeep == otherOp ||
190                  (otherOp > kLastUserOnlyStencilOp && otherOp <= kLastClipOnlyStencilOp));
191     } else {
192         // Ops that modify both clip and user bits.
193         fWriteMask = clipBit | (user.fWriteMask & userMask);
194         SkASSERT(GrUserStencilOp::kKeep == otherOp || otherOp > kLastClipOnlyStencilOp);
195     }
196 
197     fFailOp = gUserStencilOpToRaw[(int)user.fFailOp];
198     fPassOp = gUserStencilOpToRaw[(int)user.fPassOp];
199 
200     if (!hasStencilClip || user.fTest > kLastClippedStencilTest) {
201         // Ignore the clip.
202         fTestMask = user.fTestMask & userMask;
203         fTest = gUserStencilTestToRaw[(int)user.fTest];
204     } else if (GrUserStencilTest::kAlwaysIfInClip != user.fTest) {
205         // Respect the clip.
206         fTestMask = clipBit | (user.fTestMask & userMask);
207         fTest = gUserStencilTestToRaw[(int)user.fTest];
208     } else {
209         // Test only for clip.
210         fTestMask = clipBit;
211         fTest = GrStencilTest::kEqual;
212     }
213 
214     fRef = (clipBit | user.fRef) & (fTestMask | fWriteMask);
215 }
216 
setDisabled()217 void GrStencilSettings::Face::setDisabled() {
218     memset(this, 0, sizeof(*this));
219     static_assert(0 == (int)GrStencilTest::kAlways);
220     static_assert(0 == (int)GrStencilOp::kKeep);
221 }
222 
223 static constexpr GrUserStencilSettings gZeroStencilClipBit(
224     GrUserStencilSettings::StaticInit<
225         0x0000,
226         GrUserStencilTest::kAlways,
227         0xffff,
228         GrUserStencilOp::kZeroClipBit,
229         GrUserStencilOp::kZeroClipBit,
230         0x0000>()
231 );
232 static constexpr GrUserStencilSettings gSetStencilClipBit(
233     GrUserStencilSettings::StaticInit<
234         0x0000,
235         GrUserStencilTest::kAlways,
236         0xffff,
237         GrUserStencilOp::kSetClipBit,
238         GrUserStencilOp::kSetClipBit,
239         0x0000>()
240 );
241 
SetClipBitSettings(bool setToInside)242 const GrUserStencilSettings* GrStencilSettings::SetClipBitSettings(bool setToInside) {
243     return setToInside ? &gSetStencilClipBit : &gZeroStencilClipBit;
244 }
245 
genKey(GrProcessorKeyBuilder * b,bool includeRefs) const246 void GrStencilSettings::genKey(GrProcessorKeyBuilder* b, bool includeRefs) const {
247     b->add32(fFlags);
248     if (this->isDisabled()) {
249         return;
250     }
251     if (!this->isTwoSided()) {
252         constexpr int kCount16 = sizeof(Face) / sizeof(uint16_t);
253         static_assert(0 == sizeof(Face) % sizeof(uint16_t));
254         uint16_t* key = reinterpret_cast<uint16_t*>(b->add32n((kCount16 + 1) / 2));
255         if (includeRefs) {
256             memcpy(key, &fCWFace, sizeof(Face));
257         } else {
258             Face tempFace = fCWFace;
259             tempFace.fRef = 0;
260             memcpy(key, &tempFace, sizeof(Face));
261         }
262         key[kCount16] = 0;
263         static_assert(1 == kCount16 % 2);
264     } else {
265         constexpr int kCount32 = (2 * sizeof(Face)) / sizeof(uint32_t);
266         static_assert(0 == (2 * sizeof(Face)) % sizeof(uint32_t));
267         uint32_t* key = b->add32n(kCount32);
268         if (includeRefs) {
269             memcpy(key, &fCWFace, 2 * sizeof(Face));
270             static_assert(
271                     sizeof(Face) ==
272                     offsetof(GrStencilSettings, fCCWFace) - offsetof(GrStencilSettings, fCWFace));
273         } else {
274             Face tempFaces[2];
275             tempFaces[0] = fCWFace;
276             tempFaces[0].fRef = 0;
277             tempFaces[1] = fCCWFace;
278             tempFaces[1].fRef = 0;
279             memcpy(key, &tempFaces, 2 * sizeof(Face));
280         }
281     }
282     // We rely on GrStencilSettings::Face being tightly packed for the key to be reliable.
283     static_assert(0 == offsetof(Face, fRef));
284     static_assert(2 == sizeof(Face::fRef));
285     static_assert(2 == offsetof(Face, fTest));
286     static_assert(2 == sizeof(Face::fTest));
287     static_assert(4 == offsetof(Face, fTestMask));
288     static_assert(2 == sizeof(Face::fTestMask));
289     static_assert(6 == offsetof(Face, fPassOp));
290     static_assert(1 == sizeof(Face::fPassOp));
291     static_assert(7 == offsetof(Face, fFailOp));
292     static_assert(1 == sizeof(Face::fFailOp));
293     static_assert(8 == offsetof(Face, fWriteMask));
294     static_assert(2 == sizeof(Face::fWriteMask));
295     static_assert(10 == sizeof(Face));
296 }
297