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 | 0edea2c | 2015-05-21 08:27:44 -0700 | [diff] [blame] | 65 | bool mixedSamplesSupport() const { return fMixedSamplesSupport; } |
vbuzinov | 3e77ba9 | 2015-09-30 23:02:06 -0700 | [diff] [blame^] | 66 | bool programmableSampleLocationsSupport() const { return fProgrammableSampleLocationsSupport; } |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 67 | |
| 68 | /** |
| 69 | * Get the precision info for a variable of type kFloat_GrSLType, kVec2f_GrSLType, etc in a |
| 70 | * given shader type. If the shader type is not supported or the precision level is not |
| 71 | * supported in that shader type then the returned struct will report false when supported() is |
| 72 | * called. |
| 73 | */ |
| 74 | const PrecisionInfo& getFloatShaderPrecisionInfo(GrShaderType shaderType, |
| 75 | GrSLPrecision precision) const { |
| 76 | return fFloatPrecisions[shaderType][precision]; |
| 77 | }; |
| 78 | |
| 79 | /** |
| 80 | * Is there any difference between the float shader variable precision types? If this is true |
| 81 | * then unless the shader type is not supported, any call to getFloatShaderPrecisionInfo() would |
| 82 | * report the same info for all precisions in all shader types. |
| 83 | */ |
| 84 | bool floatPrecisionVaries() const { return fShaderPrecisionVaries; } |
| 85 | |
| 86 | protected: |
cdalton | 4cd6713 | 2015-06-10 19:23:46 -0700 | [diff] [blame] | 87 | /** Subclasses must call this after initialization in order to apply caps overrides requested by |
| 88 | the client. Note that overrides will only reduce the caps never expand them. */ |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 89 | void applyOptionsOverrides(const GrContextOptions& options); |
| 90 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 91 | bool fShaderDerivativeSupport : 1; |
| 92 | bool fGeometryShaderSupport : 1; |
| 93 | bool fPathRenderingSupport : 1; |
| 94 | bool fDstReadInShaderSupport : 1; |
| 95 | bool fDualSourceBlendingSupport : 1; |
cdalton | 0edea2c | 2015-05-21 08:27:44 -0700 | [diff] [blame] | 96 | bool fMixedSamplesSupport : 1; |
vbuzinov | 3e77ba9 | 2015-09-30 23:02:06 -0700 | [diff] [blame^] | 97 | bool fProgrammableSampleLocationsSupport : 1; |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 98 | |
| 99 | bool fShaderPrecisionVaries; |
| 100 | PrecisionInfo fFloatPrecisions[kGrShaderTypeCount][kGrSLPrecisionCount]; |
| 101 | |
| 102 | private: |
| 103 | typedef SkRefCnt INHERITED; |
| 104 | }; |
| 105 | |
| 106 | /** |
bsalomon | 4b91f76 | 2015-05-19 09:29:46 -0700 | [diff] [blame] | 107 | * Represents the capabilities of a GrContext. |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 108 | */ |
bsalomon | 4b91f76 | 2015-05-19 09:29:46 -0700 | [diff] [blame] | 109 | class GrCaps : public SkRefCnt { |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 110 | public: |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 111 | GrCaps(const GrContextOptions&); |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 112 | |
commit-bot@chromium.org | 8b656c6 | 2013-11-21 15:23:15 +0000 | [diff] [blame] | 113 | virtual SkString dump() const; |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 114 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 115 | GrShaderCaps* shaderCaps() const { return fShaderCaps; } |
| 116 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 117 | bool npotTextureTileSupport() const { return fNPOTTextureTileSupport; } |
commit-bot@chromium.org | 4744231 | 2013-12-19 16:18:01 +0000 | [diff] [blame] | 118 | /** To avoid as-yet-unnecessary complexity we don't allow any partial support of MIP Maps (e.g. |
| 119 | only for POT textures) */ |
| 120 | bool mipMapSupport() const { return fMipMapSupport; } |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 121 | bool twoSidedStencilSupport() const { return fTwoSidedStencilSupport; } |
| 122 | bool stencilWrapOpsSupport() const { return fStencilWrapOpsSupport; } |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 123 | bool discardRenderTargetSupport() const { return fDiscardRenderTargetSupport; } |
egdaniel | bdad9c3 | 2015-03-05 12:19:17 -0800 | [diff] [blame] | 124 | #if GR_FORCE_GPU_TRACE_DEBUGGING |
| 125 | bool gpuTracingSupport() const { return true; } |
| 126 | #else |
commit-bot@chromium.org | a3baf3b | 2014-02-21 18:45:30 +0000 | [diff] [blame] | 127 | bool gpuTracingSupport() const { return fGpuTracingSupport; } |
egdaniel | bdad9c3 | 2015-03-05 12:19:17 -0800 | [diff] [blame] | 128 | #endif |
krajcevski | 78697816 | 2014-07-30 11:25:44 -0700 | [diff] [blame] | 129 | bool compressedTexSubImageSupport() const { return fCompressedTexSubImageSupport; } |
bsalomon | d08ea5f | 2015-02-20 06:58:13 -0800 | [diff] [blame] | 130 | bool oversizedStencilSupport() const { return fOversizedStencilSupport; } |
cdalton | fd4167d | 2015-04-21 11:45:56 -0700 | [diff] [blame] | 131 | bool textureBarrierSupport() const { return fTextureBarrierSupport; } |
robertphillips@google.com | 2d2e5c4 | 2013-10-30 21:30:43 +0000 | [diff] [blame] | 132 | |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 133 | bool useDrawInsteadOfClear() const { return fUseDrawInsteadOfClear; } |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 134 | bool useDrawInsteadOfPartialRenderTargetWrite() const { |
| 135 | return fUseDrawInsteadOfPartialRenderTargetWrite; |
| 136 | } |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 137 | |
robertphillips | 6392668 | 2015-08-20 09:39:02 -0700 | [diff] [blame] | 138 | bool preferVRAMUseOverFlushes() const { return fPreferVRAMUseOverFlushes; } |
| 139 | |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 140 | /** |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 141 | * Indicates the capabilities of the fixed function blend unit. |
| 142 | */ |
| 143 | enum BlendEquationSupport { |
| 144 | kBasic_BlendEquationSupport, //<! Support to select the operator that |
| 145 | // combines src and dst terms. |
| 146 | kAdvanced_BlendEquationSupport, //<! Additional fixed function support for specific |
| 147 | // SVG/PDF blend modes. Requires blend barriers. |
| 148 | kAdvancedCoherent_BlendEquationSupport, //<! Advanced blend equation support that does not |
| 149 | // require blend barriers, and permits overlap. |
| 150 | |
| 151 | kLast_BlendEquationSupport = kAdvancedCoherent_BlendEquationSupport |
| 152 | }; |
| 153 | |
| 154 | BlendEquationSupport blendEquationSupport() const { return fBlendEquationSupport; } |
| 155 | |
| 156 | bool advancedBlendEquationSupport() const { |
| 157 | return fBlendEquationSupport >= kAdvanced_BlendEquationSupport; |
| 158 | } |
| 159 | |
| 160 | bool advancedCoherentBlendEquationSupport() const { |
| 161 | return kAdvancedCoherent_BlendEquationSupport == fBlendEquationSupport; |
| 162 | } |
| 163 | |
cdalton | 1dd0542 | 2015-06-12 09:01:18 -0700 | [diff] [blame] | 164 | bool canUseAdvancedBlendEquation(GrBlendEquation equation) const { |
| 165 | SkASSERT(GrBlendEquationIsAdvanced(equation)); |
| 166 | return SkToBool(fAdvBlendEqBlacklist & (1 << equation)); |
| 167 | } |
| 168 | |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 169 | /** |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 170 | * Indicates whether GPU->CPU memory mapping for GPU resources such as vertex buffers and |
| 171 | * textures allows partial mappings or full mappings. |
| 172 | */ |
| 173 | enum MapFlags { |
| 174 | kNone_MapFlags = 0x0, //<! Cannot map the resource. |
| 175 | |
| 176 | kCanMap_MapFlag = 0x1, //<! The resource can be mapped. Must be set for any of |
| 177 | // the other flags to have meaning.k |
| 178 | kSubset_MapFlag = 0x2, //<! The resource can be partially mapped. |
| 179 | }; |
| 180 | |
| 181 | uint32_t mapBufferFlags() const { return fMapBufferFlags; } |
| 182 | |
robertphillips@google.com | 2d2e5c4 | 2013-10-30 21:30:43 +0000 | [diff] [blame] | 183 | // Scratch textures not being reused means that those scratch textures |
skia.committer@gmail.com | 7ed98df | 2013-10-31 07:01:53 +0000 | [diff] [blame] | 184 | // 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] | 185 | // recycled in the texture cache. This is to prevent ghosting by drivers |
| 186 | // (in particular for deferred architectures). |
commit-bot@chromium.org | b835652 | 2013-07-18 22:26:39 +0000 | [diff] [blame] | 187 | bool reuseScratchTextures() const { return fReuseScratchTextures; } |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 188 | bool reuseScratchBuffers() const { return fReuseScratchBuffers; } |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 189 | |
| 190 | int maxRenderTargetSize() const { return fMaxRenderTargetSize; } |
| 191 | int maxTextureSize() const { return fMaxTextureSize; } |
bsalomon | c59a1df | 2015-06-01 07:13:42 -0700 | [diff] [blame] | 192 | /** 0 unless GPU has problems with small textures */ |
| 193 | int minTextureSize() const { return fMinTextureSize; } |
| 194 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 195 | // Will be 0 if MSAA is not supported |
| 196 | int maxSampleCount() const { return fMaxSampleCount; } |
| 197 | |
commit-bot@chromium.org | 6b7938f | 2013-10-15 14:18:16 +0000 | [diff] [blame] | 198 | bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const { |
commit-bot@chromium.org | 7388051 | 2013-10-14 15:33:45 +0000 | [diff] [blame] | 199 | SkASSERT(kGrPixelConfigCnt > config); |
commit-bot@chromium.org | 6b7938f | 2013-10-15 14:18:16 +0000 | [diff] [blame] | 200 | return fConfigRenderSupport[config][withMSAA]; |
commit-bot@chromium.org | 7388051 | 2013-10-14 15:33:45 +0000 | [diff] [blame] | 201 | } |
| 202 | |
commit-bot@chromium.org | 6e7ddaa | 2014-05-30 13:55:58 +0000 | [diff] [blame] | 203 | bool isConfigTexturable(GrPixelConfig config) const { |
| 204 | SkASSERT(kGrPixelConfigCnt > config); |
| 205 | return fConfigTextureSupport[config]; |
commit-bot@chromium.org | 42dc813 | 2014-05-27 19:26:59 +0000 | [diff] [blame] | 206 | } |
| 207 | |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 208 | bool suppressPrints() const { return fSupressPrints; } |
| 209 | |
| 210 | bool drawPathMasksToCompressedTexturesSupport() const { |
joshualitt | 7224c86 | 2015-05-29 06:46:47 -0700 | [diff] [blame] | 211 | return fDrawPathMasksToCompressedTextureSupport; |
| 212 | } |
| 213 | |
| 214 | size_t geometryBufferMapThreshold() const { |
joshualitt | e5b74c6 | 2015-06-01 14:17:47 -0700 | [diff] [blame] | 215 | SkASSERT(fGeometryBufferMapThreshold >= 0); |
joshualitt | 7224c86 | 2015-05-29 06:46:47 -0700 | [diff] [blame] | 216 | return fGeometryBufferMapThreshold; |
| 217 | } |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 218 | |
joshualitt | 5800155 | 2015-06-26 12:46:36 -0700 | [diff] [blame] | 219 | bool supportsInstancedDraws() const { |
| 220 | return fSupportsInstancedDraws; |
| 221 | } |
| 222 | |
egdaniel | 51c8d40 | 2015-08-06 10:54:13 -0700 | [diff] [blame] | 223 | bool fullClearIsFree() const { return fFullClearIsFree; } |
| 224 | |
bsalomon | 7dea7b7 | 2015-08-19 08:26:51 -0700 | [diff] [blame] | 225 | /** True in environments that will issue errors if memory uploaded to buffers |
| 226 | is not initialized (even if not read by draw calls). */ |
| 227 | bool mustClearUploadedBufferData() const { return fMustClearUploadedBufferData; } |
| 228 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 229 | protected: |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 230 | /** Subclasses must call this at the end of their constructors in order to apply caps |
| 231 | overrides requested by the client. Note that overrides will only reduce the caps never |
| 232 | expand them. */ |
| 233 | void applyOptionsOverrides(const GrContextOptions& options); |
| 234 | |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 235 | SkAutoTUnref<GrShaderCaps> fShaderCaps; |
| 236 | |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 237 | bool fNPOTTextureTileSupport : 1; |
| 238 | bool fMipMapSupport : 1; |
| 239 | bool fTwoSidedStencilSupport : 1; |
| 240 | bool fStencilWrapOpsSupport : 1; |
| 241 | bool fDiscardRenderTargetSupport : 1; |
| 242 | bool fReuseScratchTextures : 1; |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 243 | bool fReuseScratchBuffers : 1; |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 244 | bool fGpuTracingSupport : 1; |
| 245 | bool fCompressedTexSubImageSupport : 1; |
| 246 | bool fOversizedStencilSupport : 1; |
| 247 | bool fTextureBarrierSupport : 1; |
joshualitt | 5800155 | 2015-06-26 12:46:36 -0700 | [diff] [blame] | 248 | bool fSupportsInstancedDraws : 1; |
egdaniel | 51c8d40 | 2015-08-06 10:54:13 -0700 | [diff] [blame] | 249 | bool fFullClearIsFree : 1; |
bsalomon | 7dea7b7 | 2015-08-19 08:26:51 -0700 | [diff] [blame] | 250 | bool fMustClearUploadedBufferData : 1; |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 251 | |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 252 | // Driver workaround |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 253 | bool fUseDrawInsteadOfClear : 1; |
| 254 | bool fUseDrawInsteadOfPartialRenderTargetWrite : 1; |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 255 | |
robertphillips | 6392668 | 2015-08-20 09:39:02 -0700 | [diff] [blame] | 256 | // ANGLE workaround |
| 257 | bool fPreferVRAMUseOverFlushes : 1; |
| 258 | |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 259 | BlendEquationSupport fBlendEquationSupport; |
cdalton | 1dd0542 | 2015-06-12 09:01:18 -0700 | [diff] [blame] | 260 | uint32_t fAdvBlendEqBlacklist; |
| 261 | GR_STATIC_ASSERT(kLast_GrBlendEquation < 32); |
| 262 | |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 263 | uint32_t fMapBufferFlags; |
joshualitt | e5b74c6 | 2015-06-01 14:17:47 -0700 | [diff] [blame] | 264 | int fGeometryBufferMapThreshold; |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 265 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 266 | int fMaxRenderTargetSize; |
| 267 | int fMaxTextureSize; |
bsalomon | c59a1df | 2015-06-01 07:13:42 -0700 | [diff] [blame] | 268 | int fMinTextureSize; |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 269 | int fMaxSampleCount; |
| 270 | |
commit-bot@chromium.org | 6b7938f | 2013-10-15 14:18:16 +0000 | [diff] [blame] | 271 | // The first entry for each config is without msaa and the second is with. |
| 272 | bool fConfigRenderSupport[kGrPixelConfigCnt][2]; |
commit-bot@chromium.org | 6e7ddaa | 2014-05-30 13:55:58 +0000 | [diff] [blame] | 273 | bool fConfigTextureSupport[kGrPixelConfigCnt]; |
commit-bot@chromium.org | 42dc813 | 2014-05-27 19:26:59 +0000 | [diff] [blame] | 274 | |
egdaniel | bc127a3 | 2014-09-19 12:07:43 -0700 | [diff] [blame] | 275 | private: |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 276 | bool fSupressPrints : 1; |
| 277 | bool fDrawPathMasksToCompressedTextureSupport : 1; |
| 278 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 279 | typedef SkRefCnt INHERITED; |
| 280 | }; |
| 281 | |
| 282 | #endif |