1 /* 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 11 #include "include/gpu/GrTypes.h" 12 #include "src/gpu/GrBlend.h" 13 #include "src/gpu/GrNonAtomicRef.h" 14 #include "src/gpu/GrProcessor.h" 15 #include "src/gpu/GrProcessorAnalysis.h" 16 #include "src/gpu/GrSurfaceProxyView.h" 17 18 class GrGLSLXferProcessor; 19 class GrProcessorSet; 20 class GrShaderCaps; 21 22 /** 23 * 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 */ 26 enum GrXferBarrierType { 27 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. 30 }; 31 /** Should be able to treat kNone as false in boolean expressions */ 32 static_assert(SkToBool(kNone_GrXferBarrierType) == false, ""); 33 34 /** 35 * GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst 36 * 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. 46 * 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 */ 50 class GrXferProcessor : public GrProcessor, public GrNonAtomicRef<GrXferProcessor> { 51 public: 52 /** 53 * 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 */ 57 class DstProxyView { 58 public: DstProxyView()59 DstProxyView() { fOffset.set(0, 0); } 60 DstProxyView(const DstProxyView & other)61 DstProxyView(const DstProxyView& other) { 62 *this = other; 63 } 64 DstProxyView(GrSurfaceProxyView view,const SkIPoint & offset)65 DstProxyView(GrSurfaceProxyView view, const SkIPoint& offset) 66 : fProxyView(std::move(view)) { 67 if (fProxyView.proxy()) { 68 fOffset = offset; 69 } else { 70 fOffset.set(0, 0); 71 } 72 } 73 74 DstProxyView& operator=(const DstProxyView& other) { 75 fProxyView = other.fProxyView; 76 fOffset = other.fOffset; 77 return *this; 78 } 79 80 bool operator==(const DstProxyView& that) const { 81 return fProxyView == that.fProxyView && fOffset == that.fOffset; 82 } 83 bool operator!=(const DstProxyView& that) const { return !(*this == that); } 84 offset()85 const SkIPoint& offset() const { return fOffset; } 86 setOffset(const SkIPoint & offset)87 void setOffset(const SkIPoint& offset) { fOffset = offset; } setOffset(int ox,int oy)88 void setOffset(int ox, int oy) { fOffset.set(ox, oy); } 89 proxy()90 GrTextureProxy* proxy() const { return fProxyView.asTextureProxy(); } proxyView()91 const GrSurfaceProxyView& proxyView() const { return fProxyView; } 92 setProxyView(GrSurfaceProxyView view)93 void setProxyView(GrSurfaceProxyView view) { 94 fProxyView = std::move(view); 95 if (!fProxyView.proxy()) { 96 fOffset = {0, 0}; 97 } 98 } 99 100 private: 101 GrSurfaceProxyView fProxyView; 102 SkIPoint fOffset; 103 }; 104 105 /** 106 * Sets a unique key on the GrProcessorKeyBuilder calls onGetGLSLProcessorKey(...) to get the 107 * specific subclass's key. 108 */ 109 void getGLSLProcessorKey(const GrShaderCaps&, 110 GrProcessorKeyBuilder*, 111 const GrSurfaceOrigin* originIfDstTexture) const; 112 113 /** Returns a new instance of the appropriate *GL* implementation class 114 for the given GrXferProcessor; caller is responsible for deleting 115 the object. */ 116 virtual GrGLSLXferProcessor* createGLSLInstance() const = 0; 117 118 /** 119 * Returns the barrier type, if any, that this XP will require. Note that the possibility 120 * that a kTexture type barrier is required is handled by the GrPipeline and need not be 121 * considered by subclass overrides of this function. 122 */ xferBarrierType(const GrCaps & caps)123 virtual GrXferBarrierType xferBarrierType(const GrCaps& caps) const { 124 return kNone_GrXferBarrierType; 125 } 126 127 struct BlendInfo { 128 SkDEBUGCODE(SkString dump() const;) 129 130 GrBlendEquation fEquation = kAdd_GrBlendEquation; 131 GrBlendCoeff fSrcBlend = kOne_GrBlendCoeff; 132 GrBlendCoeff fDstBlend = kZero_GrBlendCoeff; 133 SkPMColor4f fBlendConstant = SK_PMColor4fTRANSPARENT; 134 bool fWriteColor = true; 135 }; 136 getBlendInfo()137 inline BlendInfo getBlendInfo() const { 138 BlendInfo blendInfo; 139 if (!this->willReadDstColor()) { 140 this->onGetBlendInfo(&blendInfo); 141 } else if (this->dstReadUsesMixedSamples()) { 142 blendInfo.fDstBlend = kIS2A_GrBlendCoeff; 143 } 144 return blendInfo; 145 } 146 willReadDstColor()147 bool willReadDstColor() const { return fWillReadDstColor; } 148 149 /** 150 * If we are performing a dst read, returns whether the base class will use mixed samples to 151 * antialias the shader's final output. If not doing a dst read, the subclass is responsible 152 * for antialiasing and this returns false. 153 */ dstReadUsesMixedSamples()154 bool dstReadUsesMixedSamples() const { return fDstReadUsesMixedSamples; } 155 156 /** 157 * Returns whether or not this xferProcossor will set a secondary output to be used with dual 158 * source blending. 159 */ 160 bool hasSecondaryOutput() const; 161 isLCD()162 bool isLCD() const { return fIsLCD; } 163 164 /** Returns true if this and other processor conservatively draw identically. It can only return 165 true when the two processor are of the same subclass (i.e. they return the same object from 166 from getFactory()). 167 168 A return value of true from isEqual() should not be used to test whether the processor would 169 generate the same shader code. To test for identical code generation use getGLSLProcessorKey 170 */ 171 isEqual(const GrXferProcessor & that)172 bool isEqual(const GrXferProcessor& that) const { 173 if (this->classID() != that.classID()) { 174 return false; 175 } 176 if (this->fWillReadDstColor != that.fWillReadDstColor) { 177 return false; 178 } 179 if (this->fDstReadUsesMixedSamples != that.fDstReadUsesMixedSamples) { 180 return false; 181 } 182 if (fIsLCD != that.fIsLCD) { 183 return false; 184 } 185 return this->onIsEqual(that); 186 } 187 188 protected: 189 GrXferProcessor(ClassID classID); 190 GrXferProcessor(ClassID classID, bool willReadDstColor, bool hasMixedSamples, 191 GrProcessorAnalysisCoverage); 192 193 private: 194 /** 195 * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer 196 * processor's GL backend implementation. 197 */ 198 virtual void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const = 0; 199 200 /** 201 * If we are not performing a dst read, returns whether the subclass will set a secondary 202 * output. When using dst reads, the base class controls the secondary output and this method 203 * will not be called. 204 */ onHasSecondaryOutput()205 virtual bool onHasSecondaryOutput() const { return false; } 206 207 /** 208 * If we are not performing a dst read, retrieves the fixed-function blend state required by the 209 * subclass. When using dst reads, the base class controls the fixed-function blend state and 210 * this method will not be called. The BlendInfo struct comes initialized to "no blending". 211 */ onGetBlendInfo(BlendInfo *)212 virtual void onGetBlendInfo(BlendInfo*) const {} 213 214 virtual bool onIsEqual(const GrXferProcessor&) const = 0; 215 216 bool fWillReadDstColor; 217 bool fDstReadUsesMixedSamples; 218 bool fIsLCD; 219 220 typedef GrProcessor INHERITED; 221 }; 222 223 /** 224 * We install a GrXPFactory (XPF) early on in the pipeline before all the final draw information is 225 * known (e.g. whether there is fractional pixel coverage, will coverage be 1 or 4 channel, is the 226 * draw opaque, etc.). Once the state of the draw is finalized, we use the XPF along with all the 227 * draw information to create a GrXferProcessor (XP) which can implement the desired blending for 228 * the draw. 229 * 230 * Before the XP is created, the XPF is able to answer queries about what functionality the XPs it 231 * creates will have. For example, can it create an XP that supports RGB coverage or will the XP 232 * blend with the destination color. 233 * 234 * GrXPFactories are intended to be static immutable objects. We pass them around as raw pointers 235 * and expect the pointers to always be valid and for the factories to be reusable and thread safe. 236 * Equality is tested for using pointer comparison. GrXPFactory destructors must be no-ops. 237 */ 238 239 // In order to construct GrXPFactory subclass instances as constexpr the subclass, and therefore 240 // GrXPFactory, must be a literal type. One requirement is having a trivial destructor. This is ok 241 // since these objects have no need for destructors. However, GCC and clang throw a warning when a 242 // class has virtual functions and a non-virtual destructor. We suppress that warning here and 243 // for the subclasses. 244 #if defined(__GNUC__) 245 #pragma GCC diagnostic push 246 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor" 247 #endif 248 #if defined(__clang__) 249 #pragma clang diagnostic push 250 #pragma clang diagnostic ignored "-Wnon-virtual-dtor" 251 #endif 252 class GrXPFactory { 253 public: 254 typedef GrXferProcessor::DstProxyView DstProxyView; 255 256 enum class AnalysisProperties : unsigned { 257 kNone = 0x0, 258 /** 259 * The fragment shader will require the destination color. 260 */ 261 kReadsDstInShader = 0x1, 262 /** 263 * The op may apply coverage as alpha and still blend correctly. 264 */ 265 kCompatibleWithCoverageAsAlpha = 0x2, 266 /** 267 * The color input to the GrXferProcessor will be ignored. 268 */ 269 kIgnoresInputColor = 0x4, 270 /** 271 * The destination color will be provided to the fragment processor using a texture. This is 272 * additional information about the implementation of kReadsDstInShader. 273 */ 274 kRequiresDstTexture = 0x10, 275 /** 276 * If set, each pixel can only be touched once during a draw (e.g., because we have a dst 277 * texture or because we need an xfer barrier). 278 */ 279 kRequiresNonOverlappingDraws = 0x20, 280 }; 281 GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(AnalysisProperties); 282 283 static sk_sp<const GrXferProcessor> MakeXferProcessor(const GrXPFactory*, 284 const GrProcessorAnalysisColor&, 285 GrProcessorAnalysisCoverage, 286 bool hasMixedSamples, 287 const GrCaps& caps, 288 GrClampType); 289 290 static AnalysisProperties GetAnalysisProperties(const GrXPFactory*, 291 const GrProcessorAnalysisColor&, 292 const GrProcessorAnalysisCoverage&, 293 const GrCaps&, 294 GrClampType); 295 296 protected: GrXPFactory()297 constexpr GrXPFactory() {} 298 299 private: 300 virtual sk_sp<const GrXferProcessor> makeXferProcessor(const GrProcessorAnalysisColor&, 301 GrProcessorAnalysisCoverage, 302 bool hasMixedSamples, 303 const GrCaps&, 304 GrClampType) const = 0; 305 306 /** 307 * Subclass analysis implementation. This should not return kNeedsDstInTexture as that will be 308 * inferred by the base class based on kReadsDstInShader and the caps. 309 */ 310 virtual AnalysisProperties analysisProperties(const GrProcessorAnalysisColor&, 311 const GrProcessorAnalysisCoverage&, 312 const GrCaps&, 313 GrClampType) const = 0; 314 }; 315 #if defined(__GNUC__) 316 #pragma GCC diagnostic pop 317 #endif 318 #if defined(__clang__) 319 #pragma clang diagnostic pop 320 #endif 321 322 GR_MAKE_BITFIELD_CLASS_OPS(GrXPFactory::AnalysisProperties) 323 324 #endif 325