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
|
/*
* 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 "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;
~GrPaint() = default;
static GrPaint Clone(const GrPaint& src) { return GrPaint(src); }
/**
* 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; }
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(std::unique_ptr<GrFragmentProcessor> fp) {
SkASSERT(fp);
fColorFragmentProcessors.push_back(std::move(fp));
fTrivial = false;
}
/**
* Appends an additional coverage processor to the coverage computation.
*/
void addCoverageFragmentProcessor(std::unique_ptr<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(sk_sp<GrTextureProxy>, const SkMatrix&);
void addColorTextureProcessor(sk_sp<GrTextureProxy>, const SkMatrix&, const GrSamplerState&);
void addCoverageTextureProcessor(sk_sp<GrTextureProxy>, const SkMatrix&);
void addCoverageTextureProcessor(sk_sp<GrTextureProxy>, const SkMatrix&, const GrSamplerState&);
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:
// Since paint copying is expensive if there are fragment processors, we require going through
// the Clone() method.
GrPaint(const GrPaint&);
GrPaint& operator=(const GrPaint&) = delete;
friend class GrProcessorSet;
const GrXPFactory* fXPFactory = nullptr;
SkSTArray<4, std::unique_ptr<GrFragmentProcessor>> fColorFragmentProcessors;
SkSTArray<2, std::unique_ptr<GrFragmentProcessor>> fCoverageFragmentProcessors;
bool fDisableOutputConversionToSRGB = false;
bool fTrivial = true;
GrColor4f fColor = GrColor4f::OpaqueWhite();
};
#endif
|
