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
|
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrPaint_DEFINED
#define GrPaint_DEFINED
#include "GrColor.h"
#include "GrColorSpaceXform.h"
#include "GrFragmentProcessor.h"
#include "SkBlendMode.h"
#include "SkRefCnt.h"
#include "SkRegion.h"
#include "SkTLazy.h"
class GrTextureProxy;
class GrXPFactory;
/**
* The paint describes how color and coverage are computed at each pixel by GrContext draw
* functions and the how color is blended with the destination pixel.
*
* The paint allows installation of custom color and coverage stages. New types of stages are
* created by subclassing GrProcessor.
*
* The primitive color computation starts with the color specified by setColor(). This color is the
* input to the first color stage. Each color stage feeds its output to the next color stage.
*
* Fractional pixel coverage follows a similar flow. The GrGeometryProcessor (specified elsewhere)
* provides the initial coverage which is passed to the first coverage fragment processor, which
* feeds its output to next coverage fragment processor.
*
* setXPFactory is used to control blending between the output color and dest. It also implements
* the application of fractional coverage from the coverage pipeline.
*/
class GrPaint {
public:
GrPaint() = default;
explicit GrPaint(const GrPaint&) = default;
~GrPaint() = default;
/**
* The initial color of the drawn primitive. Defaults to solid white.
*/
void setColor4f(const GrColor4f& color) { fColor = color; }
const GrColor4f& getColor4f() const { return fColor; }
/**
* Legacy getter, until all code handles 4f directly.
*/
GrColor getColor() const { return fColor.toGrColor(); }
/**
* Should shader output conversion from linear to sRGB be disabled.
* Only relevant if the destination is sRGB. Defaults to false.
*/
void setDisableOutputConversionToSRGB(bool srgb) { fDisableOutputConversionToSRGB = srgb; }
bool getDisableOutputConversionToSRGB() const { return fDisableOutputConversionToSRGB; }
/**
* Should sRGB inputs be allowed to perform sRGB to linear conversion. With this flag
* set to false, sRGB textures will be treated as linear (including filtering).
*/
void setAllowSRGBInputs(bool allowSRGBInputs) { fAllowSRGBInputs = allowSRGBInputs; }
bool getAllowSRGBInputs() const { return fAllowSRGBInputs; }
/**
* Should rendering be gamma-correct, end-to-end. Causes sRGB render targets to behave
* as such (with linear blending), and sRGB inputs to be filtered and decoded correctly.
*/
void setGammaCorrect(bool gammaCorrect) {
this->setDisableOutputConversionToSRGB(!gammaCorrect);
this->setAllowSRGBInputs(gammaCorrect);
}
void setXPFactory(const GrXPFactory* xpFactory) {
fXPFactory = xpFactory;
fTrivial &= !SkToBool(xpFactory);
}
void setPorterDuffXPFactory(SkBlendMode mode);
void setCoverageSetOpXPFactory(SkRegion::Op, bool invertCoverage = false);
/**
* Appends an additional color processor to the color computation.
*/
void addColorFragmentProcessor(sk_sp<GrFragmentProcessor> fp) {
SkASSERT(fp);
fColorFragmentProcessors.push_back(std::move(fp));
fTrivial = false;
}
/**
* Appends an additional coverage processor to the coverage computation.
*/
void addCoverageFragmentProcessor(sk_sp<GrFragmentProcessor> fp) {
SkASSERT(fp);
fCoverageFragmentProcessors.push_back(std::move(fp));
fTrivial = false;
}
/**
* Helpers for adding color or coverage effects that sample a texture. The matrix is applied
* to the src space position to compute texture coordinates.
*/
void addColorTextureProcessor(GrResourceProvider*, sk_sp<GrTextureProxy>,
sk_sp<GrColorSpaceXform>, const SkMatrix&);
void addColorTextureProcessor(GrResourceProvider*, sk_sp<GrTextureProxy>,
sk_sp<GrColorSpaceXform>, const SkMatrix&,
const GrSamplerParams&);
void addCoverageTextureProcessor(GrResourceProvider*, sk_sp<GrTextureProxy>, const SkMatrix&);
void addCoverageTextureProcessor(GrResourceProvider*, sk_sp<GrTextureProxy>,
const SkMatrix&, const GrSamplerParams&);
int numColorFragmentProcessors() const { return fColorFragmentProcessors.count(); }
int numCoverageFragmentProcessors() const { return fCoverageFragmentProcessors.count(); }
int numTotalFragmentProcessors() const { return this->numColorFragmentProcessors() +
this->numCoverageFragmentProcessors(); }
const GrXPFactory* getXPFactory() const { return fXPFactory; }
GrFragmentProcessor* getColorFragmentProcessor(int i) const {
return fColorFragmentProcessors[i].get();
}
GrFragmentProcessor* getCoverageFragmentProcessor(int i) const {
return fCoverageFragmentProcessors[i].get();
}
/**
* Returns true if the paint's output color will be constant after blending. If the result is
* true, constantColor will be updated to contain the constant color. Note that we can conflate
* coverage and color, so the actual values written to pixels with partial coverage may still
* not seem constant, even if this function returns true.
*/
bool isConstantBlendedColor(GrColor* constantColor) const;
/**
* A trivial paint is one that uses src-over and has no fragment processors.
* It may have variable sRGB settings.
**/
bool isTrivial() const { return fTrivial; }
private:
template <bool> class MoveOrImpl;
public:
/**
* A temporary instance of this class can be used to select between moving an existing paint or
* a temporary copy of an existing paint into a call site. MoveOrClone(paint, false) is a rvalue
* reference to paint while MoveOrClone(paint, true) is a rvalue reference to a copy of paint.
*/
using MoveOrClone = MoveOrImpl<true>;
/**
* A temporary instance of this class can be used to select between moving an existing or a
* newly default constructed paint into a call site. MoveOrNew(paint, false) is a rvalue
* reference to paint while MoveOrNew(paint, true) is a rvalue reference to a default paint.
*/
using MoveOrNew = MoveOrImpl<false>;
private:
GrPaint& operator=(const GrPaint&) = delete;
friend class GrProcessorSet;
const GrXPFactory* fXPFactory = nullptr;
SkSTArray<4, sk_sp<GrFragmentProcessor>> fColorFragmentProcessors;
SkSTArray<2, sk_sp<GrFragmentProcessor>> fCoverageFragmentProcessors;
bool fDisableOutputConversionToSRGB = false;
bool fAllowSRGBInputs = false;
bool fTrivial = true;
GrColor4f fColor = GrColor4f::OpaqueWhite();
};
/** This is the implementation of MoveOrCopy and MoveOrNew. */
template <bool COPY_IF_NEW>
class GrPaint::MoveOrImpl {
public:
MoveOrImpl(GrPaint& paint, bool newPaint) {
if (newPaint) {
if (COPY_IF_NEW) {
fStorage.init(paint);
} else {
fStorage.init();
};
fPaint = fStorage.get();
} else {
fPaint = &paint;
}
}
operator GrPaint&&() && { return std::move(*fPaint); }
GrPaint& paint() { return *fPaint; }
private:
SkTLazy<GrPaint> fStorage;
GrPaint* fPaint;
};
#endif
|
