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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/*
* Copyright 2010 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrClip_DEFINED
#define GrClip_DEFINED
#include "SkClipStack.h"
#include "GrSurface.h"
struct SkIRect;
/**
* GrClip encapsulates the information required to construct the clip
* masks. 'A GrClip is either wide open, just an IRect, just a Rect, or a full clipstack.
* If the clip is a clipstack than the origin is used to translate the stack with
* respect to device coordinates. This allows us to use a clip stack that is
* specified for a root device with a layer device that is restricted to a subset
* of the original canvas. For other clip types the origin will always be (0,0).
*
* NOTE: GrClip *must* point to a const clipstack
*/
class GrClip : SkNoncopyable {
public:
GrClip() : fClipType(kWideOpen_ClipType) {
fOrigin.setZero();
}
GrClip(const SkIRect& rect) : fClipType(kIRect_ClipType) {
fOrigin.setZero();
fClip.fIRect = rect;
}
GrClip(const SkRect& rect) : fClipType(kRect_ClipType) {
fOrigin.setZero();
fClip.fRect = rect;
}
~GrClip() { this->reset(); }
const GrClip& operator=(const GrClip& other) {
this->reset();
fClipType = other.fClipType;
switch (other.fClipType) {
case kWideOpen_ClipType:
fOrigin.setZero();
break;
case kClipStack_ClipType:
fClip.fStack = SkRef(other.clipStack());
fOrigin = other.origin();
break;
case kIRect_ClipType:
fClip.fIRect = other.irect();
fOrigin.setZero();
break;
case kRect_ClipType:
fClip.fRect = other.rect();
fOrigin.setZero();
break;
}
return *this;
}
bool operator==(const GrClip& other) const {
if (this->clipType() != other.clipType()) {
return false;
}
switch (fClipType) {
case kWideOpen_ClipType:
return true;
case kClipStack_ClipType:
if (this->origin() != other.origin()) {
return false;
}
if (this->clipStack() && other.clipStack()) {
return *this->clipStack() == *other.clipStack();
} else {
return this->clipStack() == other.clipStack();
}
break;
case kIRect_ClipType:
return this->irect() == other.irect();
break;
case kRect_ClipType:
return this->rect() == other.rect();
break;
}
}
bool operator!=(const GrClip& other) const {
return !(*this == other);
}
const SkClipStack* clipStack() const {
SkASSERT(kClipStack_ClipType == fClipType);
return fClip.fStack;
}
void setClipStack(const SkClipStack* clipStack, const SkIPoint* origin = NULL) {
this->reset();
if (clipStack->isWideOpen()) {
fClipType = kWideOpen_ClipType;
fOrigin.setZero();
} else {
fClipType = kClipStack_ClipType;
fClip.fStack = SkRef(clipStack);
if (origin) {
fOrigin = *origin;
} else {
fOrigin.setZero();
}
}
}
const SkIRect& irect() const {
SkASSERT(kIRect_ClipType == fClipType);
return fClip.fIRect;
}
const SkRect& rect() const {
SkASSERT(kRect_ClipType == fClipType);
return fClip.fRect;
}
void reset() {
if (kClipStack_ClipType == fClipType) {
fClip.fStack->unref();
fClip.fStack = NULL;
}
fClipType = kWideOpen_ClipType;
fOrigin.setZero();
}
// We support this for all cliptypes to simplify the logic a bit in clip mask manager.
// non clipstack clip types MUST have a (0,0) origin
const SkIPoint& origin() const {
SkASSERT(fClipType == kClipStack_ClipType || (fOrigin.fX == 0 && fOrigin.fY == 0));
return fOrigin;
}
bool isWideOpen(const SkRect& rect) const {
return (kWideOpen_ClipType == fClipType) ||
(kClipStack_ClipType == fClipType && this->clipStack()->isWideOpen()) ||
(kIRect_ClipType == fClipType && this->irect().contains(rect)) ||
(kRect_ClipType == fClipType && this->rect().contains(rect));
}
bool isWideOpen(const SkIRect& rect) const {
return (kWideOpen_ClipType == fClipType) ||
(kClipStack_ClipType == fClipType && this->clipStack()->isWideOpen()) ||
(kIRect_ClipType == fClipType && this->irect().contains(rect)) ||
(kRect_ClipType == fClipType && this->rect().contains(rect));
}
bool isWideOpen() const {
return (kWideOpen_ClipType == fClipType) ||
(kClipStack_ClipType == fClipType && this->clipStack()->isWideOpen());
}
bool quickContains(const SkRect& rect) const {
return (kWideOpen_ClipType == fClipType) ||
(kClipStack_ClipType == fClipType && this->clipStack()->quickContains(rect)) ||
(kIRect_ClipType == fClipType && this->irect().contains(rect)) ||
(kRect_ClipType == fClipType && this->rect().contains(rect));
}
void getConservativeBounds(const GrSurface* surface,
SkIRect* devResult,
bool* isIntersectionOfRects = NULL) const {
this->getConservativeBounds(surface->width(), surface->height(),
devResult, isIntersectionOfRects);
}
void getConservativeBounds(int width, int height,
SkIRect* devResult,
bool* isIntersectionOfRects = NULL) const;
static const GrClip& WideOpen();
enum ClipType {
kClipStack_ClipType,
kWideOpen_ClipType,
kIRect_ClipType,
kRect_ClipType,
};
ClipType clipType() const { return fClipType; }
private:
union Clip {
const SkClipStack* fStack;
SkRect fRect;
SkIRect fIRect;
} fClip;
SkIPoint fOrigin;
ClipType fClipType;
};
#endif
|
