bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 1 | |
| 2 | /* |
| 3 | * Copyright 2013 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 | */ |
bsalomon | 4b91f76 | 2015-05-19 09:29:46 -0700 | [diff] [blame] | 8 | #ifndef GrCaps_DEFINED |
| 9 | #define GrCaps_DEFINED |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 10 | |
commit-bot@chromium.org | 8b656c6 | 2013-11-21 15:23:15 +0000 | [diff] [blame] | 11 | #include "GrTypes.h" |
bsalomon | 17168df | 2014-12-09 09:00:49 -0800 | [diff] [blame] | 12 | #include "GrTypesPriv.h" |
cdalton | 1dd0542 | 2015-06-12 09:01:18 -0700 | [diff] [blame] | 13 | #include "GrBlend.h" |
bsalomon | 17168df | 2014-12-09 09:00:49 -0800 | [diff] [blame] | 14 | #include "GrShaderVar.h" |
commit-bot@chromium.org | 8b656c6 | 2013-11-21 15:23:15 +0000 | [diff] [blame] | 15 | #include "SkRefCnt.h" |
| 16 | #include "SkString.h" |
| 17 | |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 18 | struct GrContextOptions; |
| 19 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 20 | class GrShaderCaps : public SkRefCnt { |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 21 | public: |
bsalomon | 17168df | 2014-12-09 09:00:49 -0800 | [diff] [blame] | 22 | /** Info about shader variable precision within a given shader stage. That is, this info |
bsalomon | c0bd648 | 2014-12-09 10:04:14 -0800 | [diff] [blame] | 23 | is relevant to a float (or vecNf) variable declared with a GrSLPrecision |
bsalomon | 17168df | 2014-12-09 09:00:49 -0800 | [diff] [blame] | 24 | in a given GrShaderType. The info here is hoisted from the OpenGL spec. */ |
| 25 | struct PrecisionInfo { |
| 26 | PrecisionInfo() { |
| 27 | fLogRangeLow = 0; |
| 28 | fLogRangeHigh = 0; |
| 29 | fBits = 0; |
| 30 | } |
| 31 | |
| 32 | /** Is this precision level allowed in the shader stage? */ |
| 33 | bool supported() const { return 0 != fBits; } |
| 34 | |
| 35 | bool operator==(const PrecisionInfo& that) const { |
| 36 | return fLogRangeLow == that.fLogRangeLow && fLogRangeHigh == that.fLogRangeHigh && |
| 37 | fBits == that.fBits; |
| 38 | } |
| 39 | bool operator!=(const PrecisionInfo& that) const { return !(*this == that); } |
| 40 | |
| 41 | /** floor(log2(|min_value|)) */ |
| 42 | int fLogRangeLow; |
| 43 | /** floor(log2(|max_value|)) */ |
| 44 | int fLogRangeHigh; |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 45 | /** Number of bits of precision. As defined in OpenGL (with names modified to reflect this |
bsalomon | 17168df | 2014-12-09 09:00:49 -0800 | [diff] [blame] | 46 | struct) : |
| 47 | """ |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 48 | If the smallest representable value greater than 1 is 1 + e, then fBits will |
| 49 | contain floor(log2(e)), and every value in the range [2^fLogRangeLow, |
| 50 | 2^fLogRangeHigh] can be represented to at least one part in 2^fBits. |
| 51 | """ |
bsalomon | 17168df | 2014-12-09 09:00:49 -0800 | [diff] [blame] | 52 | */ |
| 53 | int fBits; |
| 54 | }; |
| 55 | |
bsalomon | 424cc26 | 2015-05-22 10:37:30 -0700 | [diff] [blame] | 56 | GrShaderCaps(); |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 57 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 58 | virtual SkString dump() const; |
| 59 | |
| 60 | bool shaderDerivativeSupport() const { return fShaderDerivativeSupport; } |
| 61 | bool geometryShaderSupport() const { return fGeometryShaderSupport; } |
| 62 | bool pathRenderingSupport() const { return fPathRenderingSupport; } |
| 63 | bool dstReadInShaderSupport() const { return fDstReadInShaderSupport; } |
| 64 | bool dualSourceBlendingSupport() const { return fDualSourceBlendingSupport; } |
cdalton | 793dc26 | 2016-02-08 10:11:47 -0800 | [diff] [blame] | 65 | bool integerSupport() const { return fIntegerSupport; } |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 66 | |
| 67 | /** |
| 68 | * Get the precision info for a variable of type kFloat_GrSLType, kVec2f_GrSLType, etc in a |
| 69 | * given shader type. If the shader type is not supported or the precision level is not |
| 70 | * supported in that shader type then the returned struct will report false when supported() is |
| 71 | * called. |
| 72 | */ |
| 73 | const PrecisionInfo& getFloatShaderPrecisionInfo(GrShaderType shaderType, |
robertphillips | 2eb1009 | 2015-12-11 04:59:36 -0800 | [diff] [blame] | 74 | GrSLPrecision precision) const { |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 75 | return fFloatPrecisions[shaderType][precision]; |
| 76 | }; |
| 77 | |
| 78 | /** |
| 79 | * Is there any difference between the float shader variable precision types? If this is true |
| 80 | * then unless the shader type is not supported, any call to getFloatShaderPrecisionInfo() would |
| 81 | * report the same info for all precisions in all shader types. |
| 82 | */ |
| 83 | bool floatPrecisionVaries() const { return fShaderPrecisionVaries; } |
| 84 | |
ethannicholas | 2279325 | 2016-01-30 09:59:10 -0800 | [diff] [blame] | 85 | /** |
| 86 | * PLS storage size in bytes (0 when not supported). The PLS spec defines a minimum size of 16 |
| 87 | * bytes whenever PLS is supported. |
| 88 | */ |
| 89 | int pixelLocalStorageSize() const { return fPixelLocalStorageSize; } |
| 90 | |
| 91 | /** |
| 92 | * True if this context supports the necessary extensions and features to enable the PLS path |
| 93 | * renderer. |
| 94 | */ |
| 95 | bool plsPathRenderingSupport() const { |
| 96 | #if GR_ENABLE_PLS_PATH_RENDERING |
| 97 | return fPLSPathRenderingSupport; |
| 98 | #else |
| 99 | return false; |
| 100 | #endif |
| 101 | } |
| 102 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 103 | protected: |
cdalton | 4cd6713 | 2015-06-10 19:23:46 -0700 | [diff] [blame] | 104 | /** Subclasses must call this after initialization in order to apply caps overrides requested by |
| 105 | the client. Note that overrides will only reduce the caps never expand them. */ |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 106 | void applyOptionsOverrides(const GrContextOptions& options); |
| 107 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 108 | bool fShaderDerivativeSupport : 1; |
| 109 | bool fGeometryShaderSupport : 1; |
| 110 | bool fPathRenderingSupport : 1; |
| 111 | bool fDstReadInShaderSupport : 1; |
| 112 | bool fDualSourceBlendingSupport : 1; |
cdalton | 793dc26 | 2016-02-08 10:11:47 -0800 | [diff] [blame] | 113 | bool fIntegerSupport : 1; |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 114 | |
| 115 | bool fShaderPrecisionVaries; |
| 116 | PrecisionInfo fFloatPrecisions[kGrShaderTypeCount][kGrSLPrecisionCount]; |
ethannicholas | 2279325 | 2016-01-30 09:59:10 -0800 | [diff] [blame] | 117 | int fPixelLocalStorageSize; |
| 118 | bool fPLSPathRenderingSupport; |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 119 | |
| 120 | private: |
egdaniel | b7e7d57 | 2015-11-04 04:23:53 -0800 | [diff] [blame] | 121 | virtual void onApplyOptionsOverrides(const GrContextOptions&) {}; |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 122 | typedef SkRefCnt INHERITED; |
| 123 | }; |
| 124 | |
| 125 | /** |
bsalomon | 4b91f76 | 2015-05-19 09:29:46 -0700 | [diff] [blame] | 126 | * Represents the capabilities of a GrContext. |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 127 | */ |
bsalomon | 4b91f76 | 2015-05-19 09:29:46 -0700 | [diff] [blame] | 128 | class GrCaps : public SkRefCnt { |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 129 | public: |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 130 | GrCaps(const GrContextOptions&); |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 131 | |
commit-bot@chromium.org | 8b656c6 | 2013-11-21 15:23:15 +0000 | [diff] [blame] | 132 | virtual SkString dump() const; |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 133 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 134 | GrShaderCaps* shaderCaps() const { return fShaderCaps; } |
| 135 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 136 | bool npotTextureTileSupport() const { return fNPOTTextureTileSupport; } |
commit-bot@chromium.org | 4744231 | 2013-12-19 16:18:01 +0000 | [diff] [blame] | 137 | /** To avoid as-yet-unnecessary complexity we don't allow any partial support of MIP Maps (e.g. |
| 138 | only for POT textures) */ |
| 139 | bool mipMapSupport() const { return fMipMapSupport; } |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 140 | bool twoSidedStencilSupport() const { return fTwoSidedStencilSupport; } |
| 141 | bool stencilWrapOpsSupport() const { return fStencilWrapOpsSupport; } |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 142 | bool discardRenderTargetSupport() const { return fDiscardRenderTargetSupport; } |
commit-bot@chromium.org | a3baf3b | 2014-02-21 18:45:30 +0000 | [diff] [blame] | 143 | bool gpuTracingSupport() const { return fGpuTracingSupport; } |
krajcevski | 78697816 | 2014-07-30 11:25:44 -0700 | [diff] [blame] | 144 | bool compressedTexSubImageSupport() const { return fCompressedTexSubImageSupport; } |
bsalomon | d08ea5f | 2015-02-20 06:58:13 -0800 | [diff] [blame] | 145 | bool oversizedStencilSupport() const { return fOversizedStencilSupport; } |
cdalton | fd4167d | 2015-04-21 11:45:56 -0700 | [diff] [blame] | 146 | bool textureBarrierSupport() const { return fTextureBarrierSupport; } |
cdalton | eb79eea | 2016-02-26 10:39:34 -0800 | [diff] [blame] | 147 | bool sampleLocationsSupport() const { return fSampleLocationsSupport; } |
egdaniel | eed519e | 2016-01-15 11:36:18 -0800 | [diff] [blame] | 148 | bool usesMixedSamples() const { return fUsesMixedSamples; } |
robertphillips@google.com | 2d2e5c4 | 2013-10-30 21:30:43 +0000 | [diff] [blame] | 149 | |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 150 | bool useDrawInsteadOfClear() const { return fUseDrawInsteadOfClear; } |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 151 | bool useDrawInsteadOfPartialRenderTargetWrite() const { |
| 152 | return fUseDrawInsteadOfPartialRenderTargetWrite; |
| 153 | } |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 154 | |
bsalomon | babafcc | 2016-02-16 11:36:47 -0800 | [diff] [blame] | 155 | bool useDrawInsteadOfAllRenderTargetWrites() const { |
| 156 | return fUseDrawInsteadOfAllRenderTargetWrites; |
| 157 | } |
| 158 | |
robertphillips | 6392668 | 2015-08-20 09:39:02 -0700 | [diff] [blame] | 159 | bool preferVRAMUseOverFlushes() const { return fPreferVRAMUseOverFlushes; } |
| 160 | |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 161 | /** |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 162 | * Indicates the capabilities of the fixed function blend unit. |
| 163 | */ |
| 164 | enum BlendEquationSupport { |
| 165 | kBasic_BlendEquationSupport, //<! Support to select the operator that |
| 166 | // combines src and dst terms. |
| 167 | kAdvanced_BlendEquationSupport, //<! Additional fixed function support for specific |
| 168 | // SVG/PDF blend modes. Requires blend barriers. |
| 169 | kAdvancedCoherent_BlendEquationSupport, //<! Advanced blend equation support that does not |
| 170 | // require blend barriers, and permits overlap. |
| 171 | |
| 172 | kLast_BlendEquationSupport = kAdvancedCoherent_BlendEquationSupport |
| 173 | }; |
| 174 | |
| 175 | BlendEquationSupport blendEquationSupport() const { return fBlendEquationSupport; } |
| 176 | |
| 177 | bool advancedBlendEquationSupport() const { |
| 178 | return fBlendEquationSupport >= kAdvanced_BlendEquationSupport; |
| 179 | } |
| 180 | |
| 181 | bool advancedCoherentBlendEquationSupport() const { |
| 182 | return kAdvancedCoherent_BlendEquationSupport == fBlendEquationSupport; |
| 183 | } |
| 184 | |
cdalton | 1dd0542 | 2015-06-12 09:01:18 -0700 | [diff] [blame] | 185 | bool canUseAdvancedBlendEquation(GrBlendEquation equation) const { |
| 186 | SkASSERT(GrBlendEquationIsAdvanced(equation)); |
| 187 | return SkToBool(fAdvBlendEqBlacklist & (1 << equation)); |
| 188 | } |
| 189 | |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 190 | /** |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 191 | * Indicates whether GPU->CPU memory mapping for GPU resources such as vertex buffers and |
| 192 | * textures allows partial mappings or full mappings. |
| 193 | */ |
| 194 | enum MapFlags { |
| 195 | kNone_MapFlags = 0x0, //<! Cannot map the resource. |
| 196 | |
| 197 | kCanMap_MapFlag = 0x1, //<! The resource can be mapped. Must be set for any of |
| 198 | // the other flags to have meaning.k |
| 199 | kSubset_MapFlag = 0x2, //<! The resource can be partially mapped. |
| 200 | }; |
| 201 | |
| 202 | uint32_t mapBufferFlags() const { return fMapBufferFlags; } |
| 203 | |
robertphillips@google.com | 2d2e5c4 | 2013-10-30 21:30:43 +0000 | [diff] [blame] | 204 | // Scratch textures not being reused means that those scratch textures |
skia.committer@gmail.com | 7ed98df | 2013-10-31 07:01:53 +0000 | [diff] [blame] | 205 | // that we upload to (i.e., don't have a render target) will not be |
robertphillips@google.com | 2d2e5c4 | 2013-10-30 21:30:43 +0000 | [diff] [blame] | 206 | // recycled in the texture cache. This is to prevent ghosting by drivers |
| 207 | // (in particular for deferred architectures). |
commit-bot@chromium.org | b835652 | 2013-07-18 22:26:39 +0000 | [diff] [blame] | 208 | bool reuseScratchTextures() const { return fReuseScratchTextures; } |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 209 | bool reuseScratchBuffers() const { return fReuseScratchBuffers; } |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 210 | |
| 211 | int maxRenderTargetSize() const { return fMaxRenderTargetSize; } |
| 212 | int maxTextureSize() const { return fMaxTextureSize; } |
bsalomon | 8c07b7a | 2015-11-02 11:36:52 -0800 | [diff] [blame] | 213 | /** This is the maximum tile size to use by GPU devices for rendering sw-backed images/bitmaps. |
| 214 | It is usually the max texture size, unless we're overriding it for testing. */ |
| 215 | int maxTileSize() const { SkASSERT(fMaxTileSize <= fMaxTextureSize); return fMaxTileSize; } |
bsalomon | c59a1df | 2015-06-01 07:13:42 -0700 | [diff] [blame] | 216 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 217 | // Will be 0 if MSAA is not supported |
egdaniel | eed519e | 2016-01-15 11:36:18 -0800 | [diff] [blame] | 218 | int maxColorSampleCount() const { return fMaxColorSampleCount; } |
| 219 | // Will be 0 if MSAA is not supported |
| 220 | int maxStencilSampleCount() const { return fMaxStencilSampleCount; } |
cdalton | af8bc7d | 2016-02-05 09:35:20 -0800 | [diff] [blame] | 221 | // Will be 0 if raster multisample is not supported. Raster multisample is a special HW mode |
| 222 | // where the rasterizer runs with more samples than are in the target framebuffer. |
| 223 | int maxRasterSamples() const { return fMaxRasterSamples; } |
egdaniel | eed519e | 2016-01-15 11:36:18 -0800 | [diff] [blame] | 224 | // We require the sample count to be less than maxColorSampleCount and maxStencilSampleCount. |
| 225 | // If we are using mixed samples, we only care about stencil. |
| 226 | int maxSampleCount() const { |
| 227 | if (this->usesMixedSamples()) { |
| 228 | return this->maxStencilSampleCount(); |
| 229 | } else { |
| 230 | return SkTMin(this->maxColorSampleCount(), this->maxStencilSampleCount()); |
| 231 | } |
| 232 | } |
| 233 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 234 | |
bsalomon | 41e4384e | 2016-01-08 09:12:44 -0800 | [diff] [blame] | 235 | virtual bool isConfigTexturable(GrPixelConfig config) const = 0; |
| 236 | virtual bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const = 0; |
commit-bot@chromium.org | 42dc813 | 2014-05-27 19:26:59 +0000 | [diff] [blame] | 237 | |
robertphillips | caef345 | 2015-11-11 13:18:11 -0800 | [diff] [blame] | 238 | bool suppressPrints() const { return fSuppressPrints; } |
| 239 | |
| 240 | bool immediateFlush() const { return fImmediateFlush; } |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 241 | |
| 242 | bool drawPathMasksToCompressedTexturesSupport() const { |
joshualitt | 7224c86 | 2015-05-29 06:46:47 -0700 | [diff] [blame] | 243 | return fDrawPathMasksToCompressedTextureSupport; |
| 244 | } |
| 245 | |
| 246 | size_t geometryBufferMapThreshold() const { |
joshualitt | e5b74c6 | 2015-06-01 14:17:47 -0700 | [diff] [blame] | 247 | SkASSERT(fGeometryBufferMapThreshold >= 0); |
joshualitt | 7224c86 | 2015-05-29 06:46:47 -0700 | [diff] [blame] | 248 | return fGeometryBufferMapThreshold; |
| 249 | } |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 250 | |
joshualitt | 5800155 | 2015-06-26 12:46:36 -0700 | [diff] [blame] | 251 | bool supportsInstancedDraws() const { |
| 252 | return fSupportsInstancedDraws; |
| 253 | } |
| 254 | |
egdaniel | 51c8d40 | 2015-08-06 10:54:13 -0700 | [diff] [blame] | 255 | bool fullClearIsFree() const { return fFullClearIsFree; } |
| 256 | |
bsalomon | 7dea7b7 | 2015-08-19 08:26:51 -0700 | [diff] [blame] | 257 | /** True in environments that will issue errors if memory uploaded to buffers |
| 258 | is not initialized (even if not read by draw calls). */ |
| 259 | bool mustClearUploadedBufferData() const { return fMustClearUploadedBufferData; } |
| 260 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 261 | protected: |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 262 | /** Subclasses must call this at the end of their constructors in order to apply caps |
| 263 | overrides requested by the client. Note that overrides will only reduce the caps never |
| 264 | expand them. */ |
| 265 | void applyOptionsOverrides(const GrContextOptions& options); |
| 266 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 267 | SkAutoTUnref<GrShaderCaps> fShaderCaps; |
| 268 | |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 269 | bool fNPOTTextureTileSupport : 1; |
| 270 | bool fMipMapSupport : 1; |
| 271 | bool fTwoSidedStencilSupport : 1; |
| 272 | bool fStencilWrapOpsSupport : 1; |
| 273 | bool fDiscardRenderTargetSupport : 1; |
| 274 | bool fReuseScratchTextures : 1; |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 275 | bool fReuseScratchBuffers : 1; |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 276 | bool fGpuTracingSupport : 1; |
| 277 | bool fCompressedTexSubImageSupport : 1; |
| 278 | bool fOversizedStencilSupport : 1; |
| 279 | bool fTextureBarrierSupport : 1; |
cdalton | eb79eea | 2016-02-26 10:39:34 -0800 | [diff] [blame] | 280 | bool fSampleLocationsSupport : 1; |
egdaniel | eed519e | 2016-01-15 11:36:18 -0800 | [diff] [blame] | 281 | bool fUsesMixedSamples : 1; |
joshualitt | 5800155 | 2015-06-26 12:46:36 -0700 | [diff] [blame] | 282 | bool fSupportsInstancedDraws : 1; |
egdaniel | 51c8d40 | 2015-08-06 10:54:13 -0700 | [diff] [blame] | 283 | bool fFullClearIsFree : 1; |
bsalomon | 7dea7b7 | 2015-08-19 08:26:51 -0700 | [diff] [blame] | 284 | bool fMustClearUploadedBufferData : 1; |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 285 | |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 286 | // Driver workaround |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 287 | bool fUseDrawInsteadOfClear : 1; |
| 288 | bool fUseDrawInsteadOfPartialRenderTargetWrite : 1; |
bsalomon | babafcc | 2016-02-16 11:36:47 -0800 | [diff] [blame] | 289 | bool fUseDrawInsteadOfAllRenderTargetWrites : 1; |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 290 | |
robertphillips | 6392668 | 2015-08-20 09:39:02 -0700 | [diff] [blame] | 291 | // ANGLE workaround |
| 292 | bool fPreferVRAMUseOverFlushes : 1; |
| 293 | |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 294 | BlendEquationSupport fBlendEquationSupport; |
cdalton | 1dd0542 | 2015-06-12 09:01:18 -0700 | [diff] [blame] | 295 | uint32_t fAdvBlendEqBlacklist; |
| 296 | GR_STATIC_ASSERT(kLast_GrBlendEquation < 32); |
| 297 | |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 298 | uint32_t fMapBufferFlags; |
joshualitt | e5b74c6 | 2015-06-01 14:17:47 -0700 | [diff] [blame] | 299 | int fGeometryBufferMapThreshold; |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 300 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 301 | int fMaxRenderTargetSize; |
| 302 | int fMaxTextureSize; |
bsalomon | 8c07b7a | 2015-11-02 11:36:52 -0800 | [diff] [blame] | 303 | int fMaxTileSize; |
egdaniel | eed519e | 2016-01-15 11:36:18 -0800 | [diff] [blame] | 304 | int fMaxColorSampleCount; |
| 305 | int fMaxStencilSampleCount; |
cdalton | af8bc7d | 2016-02-05 09:35:20 -0800 | [diff] [blame] | 306 | int fMaxRasterSamples; |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 307 | |
egdaniel | bc127a3 | 2014-09-19 12:07:43 -0700 | [diff] [blame] | 308 | private: |
egdaniel | b7e7d57 | 2015-11-04 04:23:53 -0800 | [diff] [blame] | 309 | virtual void onApplyOptionsOverrides(const GrContextOptions&) {}; |
| 310 | |
robertphillips | caef345 | 2015-11-11 13:18:11 -0800 | [diff] [blame] | 311 | bool fSuppressPrints : 1; |
| 312 | bool fImmediateFlush: 1; |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 313 | bool fDrawPathMasksToCompressedTextureSupport : 1; |
| 314 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 315 | typedef SkRefCnt INHERITED; |
| 316 | }; |
| 317 | |
| 318 | #endif |