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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
/*
* 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 GrDrawTarget_DEFINED
#define GrDrawTarget_DEFINED
#include "GrClip.h"
#include "GrContext.h"
#include "GrPathProcessor.h"
#include "GrPrimitiveProcessor.h"
#include "GrPathRendering.h"
#include "GrPipelineBuilder.h"
#include "GrXferProcessor.h"
#include "batches/GrDrawBatch.h"
#include "SkClipStack.h"
#include "SkMatrix.h"
#include "SkPath.h"
#include "SkStringUtils.h"
#include "SkStrokeRec.h"
#include "SkTArray.h"
#include "SkTLazy.h"
#include "SkTypes.h"
#include "SkXfermode.h"
//#define ENABLE_MDB 1
class GrAuditTrail;
class GrBatch;
class GrClip;
class GrCaps;
class GrPath;
class GrDrawPathBatchBase;
class GrDrawTarget final : public SkRefCnt {
public:
/** Options for GrDrawTarget behavior. */
struct Options {
Options ()
: fClipBatchToBounds(false)
, fDrawBatchBounds(false)
, fMaxBatchLookback(-1)
, fMaxBatchLookahead(-1) {}
bool fClipBatchToBounds;
bool fDrawBatchBounds;
int fMaxBatchLookback;
int fMaxBatchLookahead;
};
GrDrawTarget(GrRenderTarget*, GrGpu*, GrResourceProvider*, GrAuditTrail*, const Options&);
~GrDrawTarget() override;
void makeClosed() {
// We only close drawTargets When MDB is enabled. When MDB is disabled there is only
// ever one drawTarget and all calls will be funnelled into it.
#ifdef ENABLE_MDB
this->setFlag(kClosed_Flag);
#endif
this->forwardCombine();
}
bool isClosed() const { return this->isSetFlag(kClosed_Flag); }
// TODO: this entry point is only needed in the non-MDB world. Remove when
// we make the switch to MDB
void clearRT() { fRenderTarget = nullptr; }
/*
* Notify this drawTarget that it relies on the contents of 'dependedOn'
*/
void addDependency(GrSurface* dependedOn);
/*
* Does this drawTarget depend on 'dependedOn'?
*/
bool dependsOn(GrDrawTarget* dependedOn) const {
return fDependencies.find(dependedOn) >= 0;
}
/*
* Dump out the drawTarget dependency DAG
*/
SkDEBUGCODE(void dump() const;)
/**
* Empties the draw buffer of any queued up draws.
*/
void reset();
/**
* Together these two functions flush all queued up draws to the Gpu.
*/
void prepareBatches(GrBatchFlushState* flushState);
void drawBatches(GrBatchFlushState* flushState);
/**
* Gets the capabilities of the draw target.
*/
const GrCaps* caps() const { return fGpu->caps(); }
void drawBatch(const GrPipelineBuilder&, GrDrawContext*, const GrClip&, GrDrawBatch*);
/**
* Draws path into the stencil buffer. The fill must be either even/odd or
* winding (not inverse or hairline). It will respect the HW antialias flag
* on the GrPipelineBuilder (if possible in the 3D API). Note, we will never have an inverse
* fill with stencil path
*/
void stencilPath(const GrPipelineBuilder&, GrDrawContext*,
const GrClip&, const SkMatrix& viewMatrix,
const GrPath*, GrPathRendering::FillType);
/**
* Clear the passed in drawContext. Ignores the GrPipelineBuilder and clip. Clears the whole
* thing if rect is nullptr, otherwise just the rect. If canIgnoreRect is set then the entire
* drawContext can be optionally cleared.
*/
void clear(const SkIRect* rect,
GrColor color,
bool canIgnoreRect,
GrDrawContext*);
/** Discards the contents render target. */
void discard(GrRenderTarget*);
/**
* Copies a pixel rectangle from one surface to another. This call may finalize
* reserved vertex/index data (as though a draw call was made). The src pixels
* copied are specified by srcRect. They are copied to a rect of the same
* size in dst with top left at dstPoint. If the src rect is clipped by the
* src bounds then pixel values in the dst rect corresponding to area clipped
* by the src rect are not overwritten. This method is not guaranteed to succeed
* depending on the type of surface, configs, etc, and the backend-specific
* limitations.
*/
bool copySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
private:
friend class GrDrawingManager; // for resetFlag & TopoSortTraits
friend class GrDrawContextPriv; // for clearStencilClip
enum Flags {
kClosed_Flag = 0x01, //!< This drawTarget can't accept any more batches
kWasOutput_Flag = 0x02, //!< Flag for topological sorting
kTempMark_Flag = 0x04, //!< Flag for topological sorting
};
void setFlag(uint32_t flag) {
fFlags |= flag;
}
void resetFlag(uint32_t flag) {
fFlags &= ~flag;
}
bool isSetFlag(uint32_t flag) const {
return SkToBool(fFlags & flag);
}
struct TopoSortTraits {
static void Output(GrDrawTarget* dt, int /* index */) {
dt->setFlag(GrDrawTarget::kWasOutput_Flag);
}
static bool WasOutput(const GrDrawTarget* dt) {
return dt->isSetFlag(GrDrawTarget::kWasOutput_Flag);
}
static void SetTempMark(GrDrawTarget* dt) {
dt->setFlag(GrDrawTarget::kTempMark_Flag);
}
static void ResetTempMark(GrDrawTarget* dt) {
dt->resetFlag(GrDrawTarget::kTempMark_Flag);
}
static bool IsTempMarked(const GrDrawTarget* dt) {
return dt->isSetFlag(GrDrawTarget::kTempMark_Flag);
}
static int NumDependencies(const GrDrawTarget* dt) {
return dt->fDependencies.count();
}
static GrDrawTarget* Dependency(GrDrawTarget* dt, int index) {
return dt->fDependencies[index];
}
};
void recordBatch(GrBatch*);
void forwardCombine();
// Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
// but couldn't be made. Otherwise, returns true. This method needs to be protected because it
// needs to be accessed by GLPrograms to setup a correct drawstate
bool setupDstReadIfNecessary(const GrPipelineBuilder&,
GrRenderTarget*,
const GrClip&,
const GrPipelineOptimizations& optimizations,
GrXferProcessor::DstTexture*,
const SkRect& batchBounds);
void addDependency(GrDrawTarget* dependedOn);
// Used only by drawContextPriv.
void clearStencilClip(const SkIRect&, bool insideClip, GrRenderTarget*);
SkSTArray<256, SkAutoTUnref<GrBatch>, true> fBatches;
// The context is only in service of the clip mask manager, remove once CMM doesn't need this.
GrContext* fContext;
GrGpu* fGpu;
GrResourceProvider* fResourceProvider;
GrAuditTrail* fAuditTrail;
SkDEBUGCODE(int fDebugID;)
uint32_t fFlags;
// 'this' drawTarget relies on the output of the drawTargets in 'fDependencies'
SkTDArray<GrDrawTarget*> fDependencies;
GrRenderTarget* fRenderTarget;
bool fClipBatchToBounds;
bool fDrawBatchBounds;
int fMaxBatchLookback;
int fMaxBatchLookahead;
typedef SkRefCnt INHERITED;
};
#endif
|
