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
|
/*
* 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 GrRenderTargetOpList_DEFINED
#define GrRenderTargetOpList_DEFINED
#include "GrClip.h"
#include "GrContext.h"
#include "GrOpList.h"
#include "GrPathProcessor.h"
#include "GrPrimitiveProcessor.h"
#include "GrPathRendering.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"
class GrAuditTrail;
class GrBatch;
class GrClearBatch;
class GrClip;
class GrCaps;
class GrPath;
class GrDrawPathBatchBase;
class GrPipelineBuilder;
class GrRenderTargetProxy;
class GrRenderTargetOpList final : public GrOpList {
public:
/** Options for GrRenderTargetOpList behavior. */
struct Options {
Options ()
: fClipBatchToBounds(false)
, fDrawBatchBounds(false)
, fMaxBatchLookback(-1)
, fMaxBatchLookahead(-1) {}
bool fClipBatchToBounds;
bool fDrawBatchBounds;
int fMaxBatchLookback;
int fMaxBatchLookahead;
};
GrRenderTargetOpList(GrRenderTargetProxy*, GrGpu*, GrResourceProvider*,
GrAuditTrail*, const Options&);
~GrRenderTargetOpList() override;
void makeClosed() override {
INHERITED::makeClosed();
fLastFullClearBatch = nullptr;
this->forwardCombine();
}
/**
* Empties the draw buffer of any queued up draws.
*/
void reset() override;
void abandonGpuResources() override;
void freeGpuResources() override;
/**
* Together these two functions flush all queued up draws to GrCommandBuffer. The return value
* of drawBatches() indicates whether any commands were actually issued to the GPU.
*/
void prepareBatches(GrBatchFlushState* flushState) override;
bool drawBatches(GrBatchFlushState* flushState) override;
/**
* Gets the capabilities of the draw target.
*/
const GrCaps* caps() const { return fGpu->caps(); }
void drawBatch(const GrPipelineBuilder&, GrRenderTargetContext*, const GrClip&, GrDrawBatch*);
void addBatch(sk_sp<GrBatch>);
/**
* Draws the path into user stencil bits. Upon return, all user stencil values
* inside the path will be nonzero. The path's fill must be either even/odd or
* winding (notnverse or hairline).It will respect the HW antialias boolean (if
* possible in the 3D API). Note, we will never have an inverse fill with
* stencil path.
*/
void stencilPath(GrRenderTargetContext*,
const GrClip&,
bool useHWAA,
const SkMatrix& viewMatrix,
const GrPath*);
/** Clears the entire render target */
void fullClear(GrRenderTarget*, GrColor color);
/** 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);
gr_instanced::InstancedRendering* instancedRendering() const {
SkASSERT(fInstancedRendering);
return fInstancedRendering;
}
SkDEBUGCODE(void dump() const override;)
private:
friend class GrRenderTargetContextPriv; // for clearStencilClip and stencil clip state.
// Returns the batch that the input batch was combined with or the input batch if it wasn't
// combined.
GrBatch* recordBatch(GrBatch*, const SkRect& clippedBounds);
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);
// Used only via GrRenderTargetContextPriv.
void clearStencilClip(const GrFixedClip&, bool insideStencilMask, GrRenderTarget*);
struct RecordedBatch {
sk_sp<GrBatch> fBatch;
SkRect fClippedBounds;
};
SkSTArray<256, RecordedBatch, true> fRecordedBatches;
GrClearBatch* fLastFullClearBatch;
// The context is only in service of the GrClip, remove once it doesn't need this.
GrContext* fContext;
GrGpu* fGpu;
GrResourceProvider* fResourceProvider;
bool fClipBatchToBounds;
bool fDrawBatchBounds;
int fMaxBatchLookback;
int fMaxBatchLookahead;
SkAutoTDelete<gr_instanced::InstancedRendering> fInstancedRendering;
int32_t fLastClipStackGenID;
SkIRect fLastClipStackRect;
SkIPoint fLastClipOrigin;
typedef GrOpList INHERITED;
};
#endif
|
