1
2/*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10#ifndef GrPaint_DEFINED
11#define GrPaint_DEFINED
12
13#include "include/core/SkBlendMode.h"
14#include "include/core/SkRefCnt.h"
15#include "include/core/SkRegion.h"
16#include "src/core/SkTLazy.h"
17#include "src/gpu/GrColor.h"
18#include "src/gpu/GrFragmentProcessor.h"
19
20class GrTextureProxy;
21class GrXPFactory;
22
23/**
24 * The paint describes how color and coverage are computed at each pixel by GrContext draw
25 * functions and the how color is blended with the destination pixel.
26 *
27 * The paint allows installation of custom color and coverage stages. New types of stages are
28 * created by subclassing GrProcessor.
29 *
30 * The primitive color computation starts with the color specified by setColor(). This color is the
31 * input to the first color stage. Each color stage feeds its output to the next color stage.
32 *
33 * Fractional pixel coverage follows a similar flow. The GrGeometryProcessor (specified elsewhere)
34 * provides the initial coverage which is passed to the first coverage fragment processor, which
35 * feeds its output to next coverage fragment processor.
36 *
37 * setXPFactory is used to control blending between the output color and dest. It also implements
38 * the application of fractional coverage from the coverage pipeline.
39 */
40class GrPaint {
41public:
42 GrPaint() = default;
43 ~GrPaint() = default;
44
45 static GrPaint Clone(const GrPaint& src) { return GrPaint(src); }
46
47 /**
48 * The initial color of the drawn primitive. Defaults to solid white.
49 */
50 void setColor4f(const SkPMColor4f& color) { fColor = color; }
51 const SkPMColor4f& getColor4f() const { return fColor; }
52
53 void setXPFactory(const GrXPFactory* xpFactory) {
54 fXPFactory = xpFactory;
55 fTrivial &= !SkToBool(xpFactory);
56 }
57
58 void setPorterDuffXPFactory(SkBlendMode mode);
59
60 void setCoverageSetOpXPFactory(SkRegion::Op, bool invertCoverage = false);
61
62 /**
63 * Sets a processor for color computation.
64 */
65 void setColorFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp) {
66 SkASSERT(fp);
67 SkASSERT(fColorFragmentProcessor == nullptr);
68 fColorFragmentProcessor = std::move(fp);
69 fTrivial = false;
70 }
71
72 /**
73 * Appends an additional coverage processor to the coverage computation.
74 */
75 void setCoverageFragmentProcessor(std::unique_ptr<GrFragmentProcessor> fp) {
76 SkASSERT(fp);
77 SkASSERT(fCoverageFragmentProcessor == nullptr);
78 fCoverageFragmentProcessor = std::move(fp);
79 fTrivial = false;
80 }
81
82 bool hasColorFragmentProcessor() const { return fColorFragmentProcessor ? true : false; }
83 int hasCoverageFragmentProcessor() const { return fCoverageFragmentProcessor ? true : false; }
84 int numTotalFragmentProcessors() const {
85 return (this->hasColorFragmentProcessor() ? 1 : 0) +
86 (this->hasCoverageFragmentProcessor() ? 1 : 0);
87 }
88
89 const GrXPFactory* getXPFactory() const { return fXPFactory; }
90
91 GrFragmentProcessor* getColorFragmentProcessor() const {
92 return fColorFragmentProcessor.get();
93 }
94 GrFragmentProcessor* getCoverageFragmentProcessor() const {
95 return fCoverageFragmentProcessor.get();
96 }
97
98 /**
99 * Returns true if the paint's output color will be constant after blending. If the result is
100 * true, constantColor will be updated to contain the constant color. Note that we can conflate
101 * coverage and color, so the actual values written to pixels with partial coverage may still
102 * not seem constant, even if this function returns true.
103 */
104 bool isConstantBlendedColor(SkPMColor4f* constantColor) const;
105
106 /**
107 * A trivial paint is one that uses src-over and has no fragment processors.
108 * It may have variable sRGB settings.
109 **/
110 bool isTrivial() const { return fTrivial; }
111
112 friend void assert_alive(GrPaint& p) {
113 SkASSERT(p.fAlive);
114 }
115
116private:
117 // Since paint copying is expensive if there are fragment processors, we require going through
118 // the Clone() method.
119 GrPaint(const GrPaint&);
120 GrPaint& operator=(const GrPaint&) = delete;
121
122 friend class GrProcessorSet;
123
124 const GrXPFactory* fXPFactory = nullptr;
125 std::unique_ptr<GrFragmentProcessor> fColorFragmentProcessor;
126 std::unique_ptr<GrFragmentProcessor> fCoverageFragmentProcessor;
127 bool fTrivial = true;
128 SkPMColor4f fColor = SK_PMColor4fWHITE;
129 SkDEBUGCODE(bool fAlive = true;) // Set false after moved from.
130};
131
132#endif
133