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
|
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrClipMaskManager_DEFINED
#define GrClipMaskManager_DEFINED
#include "GrContext.h"
#include "GrNoncopyable.h"
#include "GrRect.h"
#include "GrStencil.h"
#include "GrTexture.h"
#include "SkClipStack.h"
#include "SkDeque.h"
#include "SkPath.h"
#include "SkRefCnt.h"
#include "GrClipMaskCache.h"
class GrGpu;
class GrPathRenderer;
class GrPathRendererChain;
class SkPath;
class GrTexture;
class GrDrawState;
/**
* The clip mask creator handles the generation of the clip mask. If anti
* aliasing is requested it will (in the future) generate a single channel
* (8bit) mask. If no anti aliasing is requested it will generate a 1-bit
* mask in the stencil buffer. In the non anti-aliasing case, if the clip
* mask can be represented as a rectangle then scissoring is used. In all
* cases scissoring is used to bound the range of the clip mask.
*/
class GrClipMaskManager : public GrNoncopyable {
public:
GR_DECLARE_RESOURCE_CACHE_DOMAIN(GetAlphaMaskDomain)
GrClipMaskManager()
: fGpu(NULL)
, fCurrClipMaskType(kNone_ClipMaskType) {
}
/**
* Creates a clip mask if necessary as a stencil buffer or alpha texture
* and sets the GrGpu's scissor and stencil state. If the return is false
* then the draw can be skipped.
*/
bool setupClipping(const GrClipData* clipDataIn);
void releaseResources();
bool isClipInStencil() const {
return kStencil_ClipMaskType == fCurrClipMaskType;
}
bool isClipInAlpha() const {
return kAlpha_ClipMaskType == fCurrClipMaskType;
}
void invalidateStencilMask() {
if (kStencil_ClipMaskType == fCurrClipMaskType) {
fCurrClipMaskType = kNone_ClipMaskType;
}
}
void setContext(GrContext* context) {
fAACache.setContext(context);
}
GrContext* getContext() {
return fAACache.getContext();
}
void setGpu(GrGpu* gpu) {
fGpu = gpu;
}
private:
/**
* Informs the helper function adjustStencilParams() about how the stencil
* buffer clip is being used.
*/
enum StencilClipMode {
// Draw to the clip bit of the stencil buffer
kModifyClip_StencilClipMode,
// Clip against the existing representation of the clip in the high bit
// of the stencil buffer.
kRespectClip_StencilClipMode,
// Neither writing to nor clipping against the clip bit.
kIgnoreClip_StencilClipMode,
};
GrGpu* fGpu;
/**
* We may represent the clip as a mask in the stencil buffer or as an alpha
* texture. It may be neither because the scissor rect suffices or we
* haven't yet examined the clip.
*/
enum ClipMaskType {
kNone_ClipMaskType,
kStencil_ClipMaskType,
kAlpha_ClipMaskType,
} fCurrClipMaskType;
GrClipMaskCache fAACache; // cache for the AA path
bool createStencilClipMask(const GrClipData& clipDataIn,
const GrIRect& devClipBounds);
bool createAlphaClipMask(const GrClipData& clipDataIn,
GrTexture** result,
GrIRect *devResultBounds);
bool createSoftwareClipMask(const GrClipData& clipDataIn,
GrTexture** result,
GrIRect *devResultBounds);
bool clipMaskPreamble(const GrClipData& clipDataIn,
GrTexture** result,
GrIRect *devResultBounds);
bool useSWOnlyPath(const SkClipStack& clipIn);
bool drawClipShape(GrTexture* target,
const SkClipStack::Iter::Clip* clip,
const GrIRect& resultBounds);
void drawTexture(GrTexture* target,
GrTexture* texture);
void getTemp(const GrIRect& bounds, GrAutoScratchTexture* temp);
void setupCache(const SkClipStack& clip,
const GrIRect& bounds);
/**
* Called prior to return control back the GrGpu in setupClipping. It
* updates the GrGpu with stencil settings that account stencil-based
* clipping.
*/
void setGpuStencil();
/**
* Adjusts the stencil settings to account for interaction with stencil
* clipping.
*/
void adjustStencilParams(GrStencilSettings* settings,
StencilClipMode mode,
int stencilBitCnt);
typedef GrNoncopyable INHERITED;
};
#endif // GrClipMaskManager_DEFINED
|
