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