blob: 5ede1ae828787fb895ef50b08bfd352969233c78 [file] [log] [blame]
egdaniel378092f2014-12-03 10:40:13 -08001/*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef GrXferProcessor_DEFINED
9#define GrXferProcessor_DEFINED
10
cdaltonee0175f2015-06-12 08:21:26 -070011#include "GrBlend.h"
egdaniel378092f2014-12-03 10:40:13 -080012#include "GrColor.h"
Brian Salomond61c9d92017-04-10 10:54:25 -040013#include "GrNonAtomicRef.h"
egdanielc2304142014-12-11 13:15:13 -080014#include "GrProcessor.h"
Hal Canaryce78bad2017-05-04 14:15:40 -040015#include "GrProcessorAnalysis.h"
egdaniel378092f2014-12-03 10:40:13 -080016#include "GrTypes.h"
egdaniel378092f2014-12-03 10:40:13 -080017
egdanielfa4cc8b2015-11-13 08:34:52 -080018class GrGLSLXferProcessor;
Hal Canaryce78bad2017-05-04 14:15:40 -040019class GrProcessorSet;
20class GrShaderCaps;
egdaniel95131432014-12-09 11:15:43 -080021
egdaniel378092f2014-12-03 10:40:13 -080022/**
cdalton9954bc32015-04-29 14:17:00 -070023 * Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes
24 * required after a pixel has been written, before it can be safely read again.
25 */
26enum GrXferBarrierType {
bsalomoncb02b382015-08-12 11:14:50 -070027 kNone_GrXferBarrierType = 0, //<! No barrier is required
28 kTexture_GrXferBarrierType, //<! Required when a shader reads and renders to the same texture.
29 kBlend_GrXferBarrierType, //<! Required by certain blend extensions.
cdalton9954bc32015-04-29 14:17:00 -070030};
bsalomoncb02b382015-08-12 11:14:50 -070031/** Should be able to treat kNone as false in boolean expressions */
32GR_STATIC_ASSERT(SkToBool(kNone_GrXferBarrierType) == false);
cdalton9954bc32015-04-29 14:17:00 -070033
34/**
egdaniel378092f2014-12-03 10:40:13 -080035 * GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst
cdaltonedbb31f2015-06-08 12:14:44 -070036 * color, and for applying any coverage. It does this by emitting fragment shader code and
37 * controlling the fixed-function blend state. When dual-source blending is available, it may also
38 * write a seconday fragment shader output color. GrXferProcessor has two modes of operation:
39 *
40 * Dst read: When allowed by the backend API, or when supplied a texture of the destination, the
41 * GrXferProcessor may read the destination color. While operating in this mode, the subclass only
42 * provides shader code that blends the src and dst colors, and the base class applies coverage.
43 *
44 * No dst read: When not performing a dst read, the subclass is given full control of the fixed-
45 * function blend state and/or secondary output, and is responsible to apply coverage on its own.
egdaniel378092f2014-12-03 10:40:13 -080046 *
47 * A GrXferProcessor is never installed directly into our draw state, but instead is created from a
48 * GrXPFactory once we have finalized the state of our draw.
49 */
Brian Salomond61c9d92017-04-10 10:54:25 -040050class GrXferProcessor : public GrProcessor, public GrNonAtomicRef<GrXferProcessor> {
egdaniel95131432014-12-09 11:15:43 -080051public:
52 /**
bsalomon6a44c6a2015-05-26 09:49:05 -070053 * A texture that contains the dst pixel values and an integer coord offset from device space
54 * to the space of the texture. Depending on GPU capabilities a DstTexture may be used by a
55 * GrXferProcessor for blending in the fragment shader.
56 */
Robert Phillipsbb581ce2017-05-29 15:05:15 -040057 class DstProxy {
bsalomon6a44c6a2015-05-26 09:49:05 -070058 public:
Robert Phillipsbb581ce2017-05-29 15:05:15 -040059 DstProxy() { fOffset.set(0, 0); }
bsalomon6a44c6a2015-05-26 09:49:05 -070060
Robert Phillipsbb581ce2017-05-29 15:05:15 -040061 DstProxy(const DstProxy& other) {
bsalomon6a44c6a2015-05-26 09:49:05 -070062 *this = other;
63 }
64
Robert Phillipsbb581ce2017-05-29 15:05:15 -040065 DstProxy(sk_sp<GrTextureProxy> proxy, const SkIPoint& offset)
66 : fProxy(std::move(proxy)) {
67 if (fProxy) {
68 fOffset = offset;
69 } else {
70 fOffset.set(0, 0);
71 }
72 }
bsalomon6a44c6a2015-05-26 09:49:05 -070073
Robert Phillipsbb581ce2017-05-29 15:05:15 -040074 DstProxy& operator=(const DstProxy& other) {
75 fProxy = other.fProxy;
bsalomon6a44c6a2015-05-26 09:49:05 -070076 fOffset = other.fOffset;
77 return *this;
78 }
79
Robert Phillipsbb581ce2017-05-29 15:05:15 -040080 bool operator==(const DstProxy& that) const {
81 return fProxy == that.fProxy && fOffset == that.fOffset;
Brian Salomon54d212e2017-03-21 14:22:38 -040082 }
Robert Phillipsbb581ce2017-05-29 15:05:15 -040083 bool operator!=(const DstProxy& that) const { return !(*this == that); }
Brian Salomon54d212e2017-03-21 14:22:38 -040084
bsalomon6a44c6a2015-05-26 09:49:05 -070085 const SkIPoint& offset() const { return fOffset; }
86
87 void setOffset(const SkIPoint& offset) { fOffset = offset; }
88 void setOffset(int ox, int oy) { fOffset.set(ox, oy); }
89
Robert Phillipsbb581ce2017-05-29 15:05:15 -040090 GrTextureProxy* proxy() const { return fProxy.get(); }
bsalomon6a44c6a2015-05-26 09:49:05 -070091
Robert Phillipsbb581ce2017-05-29 15:05:15 -040092 void setProxy(sk_sp<GrTextureProxy> proxy) {
93 fProxy = std::move(proxy);
94 if (!fProxy) {
Brian Salomon54d212e2017-03-21 14:22:38 -040095 fOffset = {0, 0};
96 }
bsalomon6a44c6a2015-05-26 09:49:05 -070097 }
98
Robert Phillipsbb581ce2017-05-29 15:05:15 -040099 bool instantiate(GrResourceProvider* resourceProvider) {
100 return SkToBool(fProxy->instantiate(resourceProvider));
101 }
102
bsalomon6a44c6a2015-05-26 09:49:05 -0700103 private:
Robert Phillipsbb581ce2017-05-29 15:05:15 -0400104 sk_sp<GrTextureProxy> fProxy;
105 SkIPoint fOffset;
bsalomon6a44c6a2015-05-26 09:49:05 -0700106 };
107
108 /**
egdaniel57d3b032015-11-13 11:57:27 -0800109 * Sets a unique key on the GrProcessorKeyBuilder calls onGetGLSLProcessorKey(...) to get the
bsalomon50785a32015-02-06 07:02:37 -0800110 * specific subclass's key.
Brian Salomon18dfa982017-04-03 16:57:43 -0400111 */
112 void getGLSLProcessorKey(const GrShaderCaps&,
113 GrProcessorKeyBuilder*,
114 const GrSurfaceOrigin* originIfDstTexture) const;
egdanielc2304142014-12-11 13:15:13 -0800115
116 /** Returns a new instance of the appropriate *GL* implementation class
117 for the given GrXferProcessor; caller is responsible for deleting
118 the object. */
egdaniel57d3b032015-11-13 11:57:27 -0800119 virtual GrGLSLXferProcessor* createGLSLInstance() const = 0;
egdanielc2304142014-12-11 13:15:13 -0800120
121 /**
Brian Salomon18dfa982017-04-03 16:57:43 -0400122 * Returns the barrier type, if any, that this XP will require. Note that the possibility
123 * that a kTexture type barrier is required is handled by the GrPipeline and need not be
124 * considered by subclass overrides of this function.
cdalton9954bc32015-04-29 14:17:00 -0700125 */
Brian Salomon18dfa982017-04-03 16:57:43 -0400126 virtual GrXferBarrierType xferBarrierType(const GrCaps& caps) const {
127 return kNone_GrXferBarrierType;
128 }
cdalton9954bc32015-04-29 14:17:00 -0700129
egdaniel95131432014-12-09 11:15:43 -0800130 struct BlendInfo {
cdaltonf4f2b442015-04-23 09:40:23 -0700131 void reset() {
cdalton8917d622015-05-06 13:40:21 -0700132 fEquation = kAdd_GrBlendEquation;
cdaltonf4f2b442015-04-23 09:40:23 -0700133 fSrcBlend = kOne_GrBlendCoeff;
134 fDstBlend = kZero_GrBlendCoeff;
135 fBlendConstant = 0;
136 fWriteColor = true;
137 }
egdaniel080e6732014-12-22 07:35:52 -0800138
bsalomonf7cc8772015-05-11 11:21:14 -0700139 SkDEBUGCODE(SkString dump() const;)
140
cdalton8917d622015-05-06 13:40:21 -0700141 GrBlendEquation fEquation;
142 GrBlendCoeff fSrcBlend;
143 GrBlendCoeff fDstBlend;
144 GrColor fBlendConstant;
145 bool fWriteColor;
egdaniel95131432014-12-09 11:15:43 -0800146 };
147
cdaltonedbb31f2015-06-08 12:14:44 -0700148 void getBlendInfo(BlendInfo* blendInfo) const;
egdaniel95131432014-12-09 11:15:43 -0800149
egdaniel95131432014-12-09 11:15:43 -0800150 bool willReadDstColor() const { return fWillReadDstColor; }
151
bsalomon50785a32015-02-06 07:02:37 -0800152 /**
cdalton86ae0a92015-06-08 15:11:04 -0700153 * If we are performing a dst read, returns whether the base class will use mixed samples to
154 * antialias the shader's final output. If not doing a dst read, the subclass is responsible
155 * for antialiasing and this returns false.
156 */
157 bool dstReadUsesMixedSamples() const { return fDstReadUsesMixedSamples; }
158
159 /**
egdanielc2304142014-12-11 13:15:13 -0800160 * Returns whether or not this xferProcossor will set a secondary output to be used with dual
161 * source blending.
162 */
cdaltonedbb31f2015-06-08 12:14:44 -0700163 bool hasSecondaryOutput() const;
egdanielc2304142014-12-11 13:15:13 -0800164
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400165 bool isLCD() const { return fIsLCD; }
166
egdanielc2304142014-12-11 13:15:13 -0800167 /** Returns true if this and other processor conservatively draw identically. It can only return
168 true when the two processor are of the same subclass (i.e. they return the same object from
169 from getFactory()).
170
171 A return value of true from isEqual() should not be used to test whether the processor would
egdaniel57d3b032015-11-13 11:57:27 -0800172 generate the same shader code. To test for identical code generation use getGLSLProcessorKey
173 */
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400174
egdanielc2304142014-12-11 13:15:13 -0800175 bool isEqual(const GrXferProcessor& that) const {
176 if (this->classID() != that.classID()) {
177 return false;
178 }
bsalomon50785a32015-02-06 07:02:37 -0800179 if (this->fWillReadDstColor != that.fWillReadDstColor) {
180 return false;
181 }
cdalton86ae0a92015-06-08 15:11:04 -0700182 if (this->fDstReadUsesMixedSamples != that.fDstReadUsesMixedSamples) {
183 return false;
184 }
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400185 if (fIsLCD != that.fIsLCD) {
186 return false;
187 }
egdanielc2304142014-12-11 13:15:13 -0800188 return this->onIsEqual(that);
189 }
Brian Salomon92aee3d2016-12-21 09:20:25 -0500190
egdaniel95131432014-12-09 11:15:43 -0800191protected:
Ethan Nicholasabff9562017-10-09 10:54:08 -0400192 GrXferProcessor(ClassID classID);
193 GrXferProcessor(ClassID classID, bool willReadDstColor, bool hasMixedSamples,
194 GrProcessorAnalysisCoverage);
egdaniel95131432014-12-09 11:15:43 -0800195
egdaniel378092f2014-12-03 10:40:13 -0800196private:
bsalomon50785a32015-02-06 07:02:37 -0800197 /**
198 * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
199 * processor's GL backend implementation.
200 */
Brian Salomon94efbf52016-11-29 13:43:05 -0500201 virtual void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const = 0;
bsalomon50785a32015-02-06 07:02:37 -0800202
cdaltonf4f2b442015-04-23 09:40:23 -0700203 /**
cdaltonedbb31f2015-06-08 12:14:44 -0700204 * If we are not performing a dst read, returns whether the subclass will set a secondary
cdalton86ae0a92015-06-08 15:11:04 -0700205 * output. When using dst reads, the base class controls the secondary output and this method
cdaltonedbb31f2015-06-08 12:14:44 -0700206 * will not be called.
207 */
208 virtual bool onHasSecondaryOutput() const { return false; }
209
210 /**
211 * If we are not performing a dst read, retrieves the fixed-function blend state required by the
cdalton86ae0a92015-06-08 15:11:04 -0700212 * subclass. When using dst reads, the base class controls the fixed-function blend state and
213 * this method will not be called. The BlendInfo struct comes initialized to "no blending".
cdaltonf4f2b442015-04-23 09:40:23 -0700214 */
215 virtual void onGetBlendInfo(BlendInfo*) const {}
216
egdanielc2304142014-12-11 13:15:13 -0800217 virtual bool onIsEqual(const GrXferProcessor&) const = 0;
egdaniel378092f2014-12-03 10:40:13 -0800218
Greg Daniel6ebe4b92017-05-19 10:56:46 -0400219 bool fWillReadDstColor;
220 bool fDstReadUsesMixedSamples;
221 bool fIsLCD;
egdaniel95131432014-12-09 11:15:43 -0800222
Ethan Nicholasabff9562017-10-09 10:54:08 -0400223 typedef GrProcessor INHERITED;
egdaniel378092f2014-12-03 10:40:13 -0800224};
225
226/**
227 * We install a GrXPFactory (XPF) early on in the pipeline before all the final draw information is
228 * known (e.g. whether there is fractional pixel coverage, will coverage be 1 or 4 channel, is the
229 * draw opaque, etc.). Once the state of the draw is finalized, we use the XPF along with all the
230 * draw information to create a GrXferProcessor (XP) which can implement the desired blending for
231 * the draw.
232 *
233 * Before the XP is created, the XPF is able to answer queries about what functionality the XPs it
234 * creates will have. For example, can it create an XP that supports RGB coverage or will the XP
235 * blend with the destination color.
Brian Salomona1633922017-01-09 11:46:10 -0500236 *
237 * GrXPFactories are intended to be static immutable objects. We pass them around as raw pointers
238 * and expect the pointers to always be valid and for the factories to be reusable and thread safe.
239 * Equality is tested for using pointer comparison. GrXPFactory destructors must be no-ops.
egdaniel378092f2014-12-03 10:40:13 -0800240 */
Brian Salomona1633922017-01-09 11:46:10 -0500241
242// In order to construct GrXPFactory subclass instances as constexpr the subclass, and therefore
243// GrXPFactory, must be a literal type. One requirement is having a trivial destructor. This is ok
244// since these objects have no need for destructors. However, GCC and clang throw a warning when a
245// class has virtual functions and a non-virtual destructor. We suppress that warning here and
246// for the subclasses.
Chris Dalton1ef80942017-12-04 12:01:30 -0700247#if defined(__GNUC__)
Brian Salomona1633922017-01-09 11:46:10 -0500248#pragma GCC diagnostic push
249#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
250#endif
Chris Dalton1ef80942017-12-04 12:01:30 -0700251#if defined(__clang__)
252#pragma clang diagnostic push
253#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
254#endif
Brian Salomona1633922017-01-09 11:46:10 -0500255class GrXPFactory {
egdaniel378092f2014-12-03 10:40:13 -0800256public:
Robert Phillipsbb581ce2017-05-29 15:05:15 -0400257 typedef GrXferProcessor::DstProxy DstProxy;
Brian Salomon5be6c952017-01-20 19:06:29 +0000258
Brian Salomon31853842017-03-28 16:32:05 -0400259 enum class AnalysisProperties : unsigned {
260 kNone = 0x0,
Brian Salomon4fc77402017-03-30 16:48:26 -0400261 /**
262 * The fragment shader will require the destination color.
263 */
Brian Salomon31853842017-03-28 16:32:05 -0400264 kReadsDstInShader = 0x1,
Brian Salomon4fc77402017-03-30 16:48:26 -0400265 /**
266 * The op may apply coverage as alpha and still blend correctly.
267 */
268 kCompatibleWithAlphaAsCoverage = 0x2,
269 /**
270 * The color input to the GrXferProcessor will be ignored.
271 */
272 kIgnoresInputColor = 0x4,
273 /**
274 * If set overlapping stencil and cover operations can be replaced by a combined stencil
275 * followed by a combined cover.
276 */
277 kCanCombineOverlappedStencilAndCover = 0x8,
278 /**
279 * The destination color will be provided to the fragment processor using a texture. This is
280 * additional information about the implementation of kReadsDstInShader.
281 */
282 kRequiresDstTexture = 0x10,
283 /**
284 * If set overlapping draws may not be combined because a barrier must be inserted between
285 * them.
286 */
287 kRequiresBarrierBetweenOverlappingDraws = 0x20,
Brian Salomon31853842017-03-28 16:32:05 -0400288 };
289 GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(AnalysisProperties);
egdaniel080e6732014-12-22 07:35:52 -0800290
Brian Salomond61c9d92017-04-10 10:54:25 -0400291 static sk_sp<const GrXferProcessor> MakeXferProcessor(const GrXPFactory*,
292 const GrProcessorAnalysisColor&,
293 GrProcessorAnalysisCoverage,
294 bool hasMixedSamples,
Brian Osman9a725dd2017-09-20 09:53:22 -0400295 const GrCaps& caps,
296 GrPixelConfigIsClamped dstIsClamped);
Brian Salomona076d872017-04-04 15:17:03 -0400297
Brian Salomon31853842017-03-28 16:32:05 -0400298 static AnalysisProperties GetAnalysisProperties(const GrXPFactory*,
Brian Salomona811b122017-03-30 08:21:32 -0400299 const GrProcessorAnalysisColor&,
300 const GrProcessorAnalysisCoverage&,
Brian Osman9a725dd2017-09-20 09:53:22 -0400301 const GrCaps&,
302 GrPixelConfigIsClamped);
Brian Salomon54d212e2017-03-21 14:22:38 -0400303
egdaniel915187b2014-12-05 12:58:28 -0800304protected:
Brian Salomona1633922017-01-09 11:46:10 -0500305 constexpr GrXPFactory() {}
egdaniel915187b2014-12-05 12:58:28 -0800306
egdaniel378092f2014-12-03 10:40:13 -0800307private:
Brian Salomond61c9d92017-04-10 10:54:25 -0400308 virtual sk_sp<const GrXferProcessor> makeXferProcessor(const GrProcessorAnalysisColor&,
309 GrProcessorAnalysisCoverage,
310 bool hasMixedSamples,
Brian Osman9a725dd2017-09-20 09:53:22 -0400311 const GrCaps&,
312 GrPixelConfigIsClamped) const = 0;
ethannicholas22793252016-01-30 09:59:10 -0800313
bsalomon50785a32015-02-06 07:02:37 -0800314 /**
Brian Salomon31853842017-03-28 16:32:05 -0400315 * Subclass analysis implementation. This should not return kNeedsDstInTexture as that will be
316 * inferred by the base class based on kReadsDstInShader and the caps.
bsalomon50785a32015-02-06 07:02:37 -0800317 */
Brian Salomona811b122017-03-30 08:21:32 -0400318 virtual AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&,
319 const GrProcessorAnalysisCoverage&,
Brian Osman9a725dd2017-09-20 09:53:22 -0400320 const GrCaps&,
321 GrPixelConfigIsClamped) const = 0;
egdaniel378092f2014-12-03 10:40:13 -0800322};
Chris Dalton1ef80942017-12-04 12:01:30 -0700323#if defined(__GNUC__)
Brian Salomona1633922017-01-09 11:46:10 -0500324#pragma GCC diagnostic pop
325#endif
Chris Dalton1ef80942017-12-04 12:01:30 -0700326#if defined(__clang__)
327#pragma clang diagnostic pop
328#endif
egdaniel378092f2014-12-03 10:40:13 -0800329
Brian Salomon31853842017-03-28 16:32:05 -0400330GR_MAKE_BITFIELD_CLASS_OPS(GrXPFactory::AnalysisProperties);
egdaniel378092f2014-12-03 10:40:13 -0800331
Brian Salomon31853842017-03-28 16:32:05 -0400332#endif