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
|
/*
* 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 SkRasterClip_DEFINED
#define SkRasterClip_DEFINED
#include "SkRegion.h"
#include "SkAAClip.h"
class SkRasterClip {
public:
SkRasterClip();
SkRasterClip(const SkIRect&);
SkRasterClip(const SkRasterClip&);
~SkRasterClip();
bool isBW() const { return fIsBW; }
bool isAA() const { return !fIsBW; }
const SkRegion& bwRgn() const { SkASSERT(fIsBW); return fBW; }
const SkAAClip& aaRgn() const { SkASSERT(!fIsBW); return fAA; }
bool isEmpty() const {
SkASSERT(this->computeIsEmpty() == fIsEmpty);
return fIsEmpty;
}
bool isRect() const {
SkASSERT(this->computeIsRect() == fIsRect);
return fIsRect;
}
bool isComplex() const;
const SkIRect& getBounds() const;
bool setEmpty();
bool setRect(const SkIRect&);
bool setPath(const SkPath& path, const SkRegion& clip, bool doAA);
bool setPath(const SkPath& path, const SkIRect& clip, bool doAA);
bool op(const SkIRect&, SkRegion::Op);
bool op(const SkRegion&, SkRegion::Op);
bool op(const SkRasterClip&, SkRegion::Op);
bool op(const SkRect&, SkRegion::Op, bool doAA);
void translate(int dx, int dy, SkRasterClip* dst) const;
void translate(int dx, int dy) {
this->translate(dx, dy, this);
}
bool quickContains(const SkIRect& rect) const;
bool quickContains(int left, int top, int right, int bottom) const {
return quickContains(SkIRect::MakeLTRB(left, top, right, bottom));
}
/**
* Return true if this region is empty, or if the specified rectangle does
* not intersect the region. Returning false is not a guarantee that they
* intersect, but returning true is a guarantee that they do not.
*/
bool quickReject(const SkIRect& rect) const {
return this->isEmpty() || rect.isEmpty() ||
!SkIRect::Intersects(this->getBounds(), rect);
}
// hack for SkCanvas::getTotalClip
const SkRegion& forceGetBW();
#ifdef SK_DEBUG
void validate() const;
#else
void validate() const {}
#endif
private:
SkRegion fBW;
SkAAClip fAA;
bool fIsBW;
// these 2 are caches based on querying the right obj based on fIsBW
bool fIsEmpty;
bool fIsRect;
bool computeIsEmpty() const {
return fIsBW ? fBW.isEmpty() : fAA.isEmpty();
}
bool computeIsRect() const {
return fIsBW ? fBW.isRect() : false;
}
bool updateCacheAndReturnNonEmpty() {
fIsEmpty = this->computeIsEmpty();
fIsRect = this->computeIsRect();
return !fIsEmpty;
}
void convertToAA();
};
class SkAutoRasterClipValidate : SkNoncopyable {
public:
SkAutoRasterClipValidate(const SkRasterClip& rc) : fRC(rc) {
fRC.validate();
}
~SkAutoRasterClipValidate() {
fRC.validate();
}
private:
const SkRasterClip& fRC;
};
#define SkAutoRasterClipValidate(...) SK_REQUIRE_LOCAL_VAR(SkAutoRasterClipValidate)
#ifdef SK_DEBUG
#define AUTO_RASTERCLIP_VALIDATE(rc) SkAutoRasterClipValidate arcv(rc)
#else
#define AUTO_RASTERCLIP_VALIDATE(rc)
#endif
///////////////////////////////////////////////////////////////////////////////
/**
* Encapsulates the logic of deciding if we need to change/wrap the blitter
* for aaclipping. If so, getRgn and getBlitter return modified values. If
* not, they return the raw blitter and (bw) clip region.
*
* We need to keep the constructor/destructor cost as small as possible, so we
* can freely put this guy on the stack, and not pay too much for the case when
* we're really BW anyways.
*/
class SkAAClipBlitterWrapper {
public:
SkAAClipBlitterWrapper();
SkAAClipBlitterWrapper(const SkRasterClip&, SkBlitter*);
SkAAClipBlitterWrapper(const SkAAClip*, SkBlitter*);
void init(const SkRasterClip&, SkBlitter*);
const SkIRect& getBounds() const {
SkASSERT(fClipRgn);
return fClipRgn->getBounds();
}
const SkRegion& getRgn() const {
SkASSERT(fClipRgn);
return *fClipRgn;
}
SkBlitter* getBlitter() {
SkASSERT(fBlitter);
return fBlitter;
}
private:
SkRegion fBWRgn;
SkAAClipBlitter fAABlitter;
// what we return
const SkRegion* fClipRgn;
SkBlitter* fBlitter;
};
#endif
|
