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
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrDrawBatch_DEFINED
#define GrDrawBatch_DEFINED
#include <functional>
#include "GrBatch.h"
#include "GrPipeline.h"
struct GrInitInvariantOutput;
/**
* GrDrawBatches are flushed in two phases (preDraw, and draw). In preDraw uploads to GrGpuResources
* and draws are determined and scheduled. They are issued in the draw phase. GrBatchToken is used
* to sequence the uploads relative to each other and to draws.
**/
class GrBatchDrawToken {
public:
static GrBatchDrawToken AlreadyFlushedToken() { return GrBatchDrawToken(0); }
GrBatchDrawToken(const GrBatchDrawToken& that) : fSequenceNumber(that.fSequenceNumber) {}
GrBatchDrawToken& operator =(const GrBatchDrawToken& that) {
fSequenceNumber = that.fSequenceNumber;
return *this;
}
bool operator==(const GrBatchDrawToken& that) const {
return fSequenceNumber == that.fSequenceNumber;
}
bool operator!=(const GrBatchDrawToken& that) const { return !(*this == that); }
private:
GrBatchDrawToken();
explicit GrBatchDrawToken(uint64_t sequenceNumber) : fSequenceNumber(sequenceNumber) {}
friend class GrBatchFlushState;
uint64_t fSequenceNumber;
};
/**
* Base class for GrBatches that draw. These batches have a GrPipeline installed by GrOpList.
*/
class GrDrawBatch : public GrBatch {
public:
/** Method that performs an upload on behalf of a DeferredUploadFn. */
using WritePixelsFn = std::function<bool(GrSurface* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes)>;
/** See comments before GrDrawBatch::Target definition on how deferred uploaders work. */
using DeferredUploadFn = std::function<void(WritePixelsFn&)>;
class Target;
GrDrawBatch(uint32_t classID);
~GrDrawBatch() override;
/**
* Fills in a structure informing the XP of overrides to its normal behavior.
*/
void getPipelineOptimizations(GrPipelineOptimizations* override) const;
bool installPipeline(const GrPipeline::CreateArgs&);
// TODO no GrPrimitiveProcessors yet read fragment position
bool willReadFragmentPosition() const { return false; }
// TODO: this needs to be updated to return GrSurfaceProxy::UniqueID
// This is a bit more exciting than the other call sites since it uses the pipeline
GrGpuResource::UniqueID renderTargetUniqueID() const final {
return this->pipeline()->getRenderTarget()->uniqueID();
}
// TODO: store a GrRenderTargetContext instead
GrRenderTarget* renderTarget() const final {
return this->pipeline()->getRenderTarget();
}
SkString dumpInfo() const override {
SkString string;
string.appendf("RT: %d\n", this->renderTargetUniqueID().asUInt());
string.append("ColorStages:\n");
for (int i = 0; i < this->pipeline()->numColorFragmentProcessors(); i++) {
string.appendf("\t\t%s\n\t\t%s\n",
this->pipeline()->getColorFragmentProcessor(i).name(),
this->pipeline()->getColorFragmentProcessor(i).dumpInfo().c_str());
}
string.append("CoverageStages:\n");
for (int i = 0; i < this->pipeline()->numCoverageFragmentProcessors(); i++) {
string.appendf("\t\t%s\n\t\t%s\n",
this->pipeline()->getCoverageFragmentProcessor(i).name(),
this->pipeline()->getCoverageFragmentProcessor(i).dumpInfo().c_str());
}
string.appendf("XP: %s\n", this->pipeline()->getXferProcessor().name());
bool scissorEnabled = this->pipeline()->getScissorState().enabled();
string.appendf("Scissor: ");
if (scissorEnabled) {
string.appendf("[L: %d, T: %d, R: %d, B: %d]\n",
this->pipeline()->getScissorState().rect().fLeft,
this->pipeline()->getScissorState().rect().fTop,
this->pipeline()->getScissorState().rect().fRight,
this->pipeline()->getScissorState().rect().fBottom);
} else {
string.appendf("<disabled>\n");
}
string.append(INHERITED::dumpInfo());
return string;
}
protected:
const GrPipeline* pipeline() const {
SkASSERT(fPipelineInstalled);
return reinterpret_cast<const GrPipeline*>(fPipelineStorage.get());
}
virtual void computePipelineOptimizations(GrInitInvariantOutput* color,
GrInitInvariantOutput* coverage,
GrBatchToXPOverrides* overrides) const = 0;
private:
/**
* initBatchTracker is a hook for the some additional overrides / optimization possibilities
* from the GrXferProcessor.
*/
virtual void initBatchTracker(const GrXPOverridesForBatch&) = 0;
protected:
struct QueuedUpload {
QueuedUpload(DeferredUploadFn&& upload, GrBatchDrawToken token)
: fUpload(std::move(upload))
, fUploadBeforeToken(token) {}
DeferredUploadFn fUpload;
GrBatchDrawToken fUploadBeforeToken;
};
SkTArray<QueuedUpload> fInlineUploads;
private:
SkAlignedSTStorage<1, GrPipeline> fPipelineStorage;
bool fPipelineInstalled;
typedef GrBatch INHERITED;
};
#endif
|
