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 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrDrawOp_DEFINED
#define GrDrawOp_DEFINED
#include <functional>
#include "GrOp.h"
#include "GrPipeline.h"
/**
* GrDrawOps 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. GrDrawOpUploadToken is
* used to sequence the uploads relative to each other and to draws.
**/
class GrDrawOpUploadToken {
public:
static GrDrawOpUploadToken AlreadyFlushedToken() { return GrDrawOpUploadToken(0); }
GrDrawOpUploadToken(const GrDrawOpUploadToken& that) : fSequenceNumber(that.fSequenceNumber) {}
GrDrawOpUploadToken& operator =(const GrDrawOpUploadToken& that) {
fSequenceNumber = that.fSequenceNumber;
return *this;
}
bool operator==(const GrDrawOpUploadToken& that) const {
return fSequenceNumber == that.fSequenceNumber;
}
bool operator!=(const GrDrawOpUploadToken& that) const { return !(*this == that); }
private:
GrDrawOpUploadToken();
explicit GrDrawOpUploadToken(uint64_t sequenceNumber) : fSequenceNumber(sequenceNumber) {}
friend class GrOpFlushState;
uint64_t fSequenceNumber;
};
/**
* Base class for GrOps that draw. These ops have a GrPipeline installed by GrOpList.
*/
class GrDrawOp : public GrOp {
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 GrDrawOp::Target definition on how deferred uploaders work. */
using DeferredUploadFn = std::function<void(WritePixelsFn&)>;
class Target;
GrDrawOp(uint32_t classID) : INHERITED(classID) {}
void initPipeline(const GrPipeline::InitArgs& args) {
this->applyPipelineOptimizations(fPipeline.init(args));
}
/**
* Performs analysis of the fragment processors in GrProcessorSet and GrAppliedClip using the
* initial color and coverage from this op's geometry processor.
*/
void analyzeProcessors(GrProcessorSet::FragmentProcessorAnalysis* analysis,
const GrProcessorSet& processors,
const GrAppliedClip& appliedClip,
const GrCaps& caps) const {
FragmentProcessorAnalysisInputs input;
this->getFragmentProcessorAnalysisInputs(&input);
analysis->reset(*input.colorInput(), *input.coverageInput(), processors, appliedClip, caps);
}
protected:
static SkString DumpPipelineInfo(const GrPipeline& pipeline) {
SkString string;
string.appendf("RT: %d\n", pipeline.getRenderTarget()->uniqueID().asUInt());
string.append("ColorStages:\n");
for (int i = 0; i < pipeline.numColorFragmentProcessors(); i++) {
string.appendf("\t\t%s\n\t\t%s\n",
pipeline.getColorFragmentProcessor(i).name(),
pipeline.getColorFragmentProcessor(i).dumpInfo().c_str());
}
string.append("CoverageStages:\n");
for (int i = 0; i < pipeline.numCoverageFragmentProcessors(); i++) {
string.appendf("\t\t%s\n\t\t%s\n",
pipeline.getCoverageFragmentProcessor(i).name(),
pipeline.getCoverageFragmentProcessor(i).dumpInfo().c_str());
}
string.appendf("XP: %s\n", pipeline.getXferProcessor().name());
bool scissorEnabled = pipeline.getScissorState().enabled();
string.appendf("Scissor: ");
if (scissorEnabled) {
string.appendf("[L: %d, T: %d, R: %d, B: %d]\n",
pipeline.getScissorState().rect().fLeft,
pipeline.getScissorState().rect().fTop,
pipeline.getScissorState().rect().fRight,
pipeline.getScissorState().rect().fBottom);
} else {
string.appendf("<disabled>\n");
}
return string;
}
const GrPipeline* pipeline() const {
SkASSERT(fPipeline.isInitialized());
return &fPipeline;
}
/**
* This describes aspects of the GrPrimitiveProcessor produced by a GrDrawOp that are used in
* pipeline analysis.
*/
class FragmentProcessorAnalysisInputs {
public:
FragmentProcessorAnalysisInputs() = default;
GrPipelineInput* colorInput() { return &fColorInput; }
GrPipelineInput* coverageInput() { return &fCoverageInput; }
private:
GrPipelineInput fColorInput;
GrPipelineInput fCoverageInput;
};
private:
/**
* Provides information about the GrPrimitiveProccesor color and coverage outputs which become
* inputs to the first color and coverage fragment processors.
*/
virtual void getFragmentProcessorAnalysisInputs(FragmentProcessorAnalysisInputs*) const = 0;
/**
* After GrPipeline analysis is complete this is called so that the op can use the analysis
* results when constructing its GrPrimitiveProcessor.
*/
virtual void applyPipelineOptimizations(const GrPipelineOptimizations&) = 0;
protected:
struct QueuedUpload {
QueuedUpload(DeferredUploadFn&& upload, GrDrawOpUploadToken token)
: fUpload(std::move(upload))
, fUploadBeforeToken(token) {}
DeferredUploadFn fUpload;
GrDrawOpUploadToken fUploadBeforeToken;
};
SkTArray<QueuedUpload> fInlineUploads;
private:
GrPipeline fPipeline;
typedef GrOp INHERITED;
};
#endif
|
