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 | |
Brian Salomon | c588603 | 2017-07-19 11:48:05 -0400 | [diff] [blame] | 11 | #include "../private/GrTypesPriv.h" |
cdalton | 1dd0542 | 2015-06-12 09:01:18 -0700 | [diff] [blame] | 12 | #include "GrBlend.h" |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 13 | #include "GrShaderCaps.h" |
Greg Daniel | f5d8758 | 2017-12-18 14:48:15 -0500 | [diff] [blame] | 14 | #include "SkImageInfo.h" |
commit-bot@chromium.org | 8b656c6 | 2013-11-21 15:23:15 +0000 | [diff] [blame] | 15 | #include "SkRefCnt.h" |
| 16 | #include "SkString.h" |
| 17 | |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 18 | class GrBackendFormat; |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 19 | class GrBackendRenderTarget; |
Greg Daniel | f5d8758 | 2017-12-18 14:48:15 -0500 | [diff] [blame] | 20 | class GrBackendTexture; |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 21 | struct GrContextOptions; |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 22 | class GrRenderTargetProxy; |
Brian Salomon | 3d86a19 | 2018-02-27 16:46:11 -0500 | [diff] [blame^] | 23 | class GrSurface; |
Brian Osman | 71a1889 | 2017-08-10 10:23:25 -0400 | [diff] [blame] | 24 | class SkJSONWriter; |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 25 | |
| 26 | /** |
bsalomon | 4b91f76 | 2015-05-19 09:29:46 -0700 | [diff] [blame] | 27 | * Represents the capabilities of a GrContext. |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 28 | */ |
bsalomon | 4b91f76 | 2015-05-19 09:29:46 -0700 | [diff] [blame] | 29 | class GrCaps : public SkRefCnt { |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 30 | public: |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 31 | GrCaps(const GrContextOptions&); |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 32 | |
Brian Osman | 71a1889 | 2017-08-10 10:23:25 -0400 | [diff] [blame] | 33 | void dumpJSON(SkJSONWriter*) const; |
| 34 | |
Brian Salomon | 94efbf5 | 2016-11-29 13:43:05 -0500 | [diff] [blame] | 35 | const GrShaderCaps* shaderCaps() const { return fShaderCaps.get(); } |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 36 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 37 | bool npotTextureTileSupport() const { return fNPOTTextureTileSupport; } |
commit-bot@chromium.org | 4744231 | 2013-12-19 16:18:01 +0000 | [diff] [blame] | 38 | /** To avoid as-yet-unnecessary complexity we don't allow any partial support of MIP Maps (e.g. |
| 39 | only for POT textures) */ |
| 40 | bool mipMapSupport() const { return fMipMapSupport; } |
brianosman | 64d094d | 2016-03-25 06:01:59 -0700 | [diff] [blame] | 41 | |
| 42 | /** |
| 43 | * Skia convention is that a device only has sRGB support if it supports sRGB formats for both |
| 44 | * textures and framebuffers. In addition: |
| 45 | * Decoding to linear of an sRGB texture can be disabled. |
brianosman | 64d094d | 2016-03-25 06:01:59 -0700 | [diff] [blame] | 46 | */ |
brianosman | a635936 | 2016-03-21 06:55:37 -0700 | [diff] [blame] | 47 | bool srgbSupport() const { return fSRGBSupport; } |
brianosman | 35b784d | 2016-05-05 11:52:53 -0700 | [diff] [blame] | 48 | /** |
| 49 | * Is there support for enabling/disabling sRGB writes for sRGB-capable color buffers? |
| 50 | */ |
| 51 | bool srgbWriteControl() const { return fSRGBWriteControl; } |
Brian Osman | 57bc3ea | 2017-07-27 09:58:11 -0400 | [diff] [blame] | 52 | bool srgbDecodeDisableSupport() const { return fSRGBDecodeDisableSupport; } |
commit-bot@chromium.org | 28361fa | 2014-03-28 16:08:05 +0000 | [diff] [blame] | 53 | bool discardRenderTargetSupport() const { return fDiscardRenderTargetSupport; } |
commit-bot@chromium.org | a3baf3b | 2014-02-21 18:45:30 +0000 | [diff] [blame] | 54 | bool gpuTracingSupport() const { return fGpuTracingSupport; } |
bsalomon | d08ea5f | 2015-02-20 06:58:13 -0800 | [diff] [blame] | 55 | bool oversizedStencilSupport() const { return fOversizedStencilSupport; } |
cdalton | fd4167d | 2015-04-21 11:45:56 -0700 | [diff] [blame] | 56 | bool textureBarrierSupport() const { return fTextureBarrierSupport; } |
Robert Phillips | 7f86192 | 2018-01-30 13:13:42 +0000 | [diff] [blame] | 57 | bool sampleLocationsSupport() const { return fSampleLocationsSupport; } |
csmartdalton | 2b5f2cb | 2016-06-10 14:06:32 -0700 | [diff] [blame] | 58 | bool multisampleDisableSupport() const { return fMultisampleDisableSupport; } |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 59 | bool instanceAttribSupport() const { return fInstanceAttribSupport; } |
egdaniel | eed519e | 2016-01-15 11:36:18 -0800 | [diff] [blame] | 60 | bool usesMixedSamples() const { return fUsesMixedSamples; } |
Chris Dalton | 27059d3 | 2018-01-23 14:06:50 -0700 | [diff] [blame] | 61 | |
Greg Daniel | 2a30390 | 2018-02-20 10:25:54 -0500 | [diff] [blame] | 62 | // Returns whether mixed samples is supported for the given backend render target. |
| 63 | bool isMixedSamplesSupportedForRT(const GrBackendRenderTarget& rt) const { |
| 64 | return this->usesMixedSamples() && this->onIsMixedSamplesSupportedForRT(rt); |
| 65 | } |
| 66 | |
Chris Dalton | 27059d3 | 2018-01-23 14:06:50 -0700 | [diff] [blame] | 67 | // Primitive restart functionality is core in ES 3.0, but using it will cause slowdowns on some |
| 68 | // systems. This cap is only set if primitive restart will improve performance. |
| 69 | bool usePrimitiveRestart() const { return fUsePrimitiveRestart; } |
| 70 | |
csmartdalton | 485a120 | 2016-07-13 10:16:32 -0700 | [diff] [blame] | 71 | bool preferClientSideDynamicBuffers() const { return fPreferClientSideDynamicBuffers; } |
robertphillips@google.com | 2d2e5c4 | 2013-10-30 21:30:43 +0000 | [diff] [blame] | 72 | |
Chris Dalton | 344e903 | 2017-12-11 15:42:09 -0700 | [diff] [blame] | 73 | // On tilers, an initial fullscreen clear is an OPTIMIZATION. It allows the hardware to |
| 74 | // initialize each tile with a constant value rather than loading each pixel from memory. |
| 75 | bool preferFullscreenClears() const { return fPreferFullscreenClears; } |
| 76 | |
robertphillips | 6392668 | 2015-08-20 09:39:02 -0700 | [diff] [blame] | 77 | bool preferVRAMUseOverFlushes() const { return fPreferVRAMUseOverFlushes; } |
| 78 | |
Chris Dalton | e4679fa | 2017-09-29 13:58:26 -0600 | [diff] [blame] | 79 | bool blacklistCoverageCounting() const { return fBlacklistCoverageCounting; } |
| 80 | |
Eric Karl | 5c77975 | 2017-05-08 12:02:07 -0700 | [diff] [blame] | 81 | bool avoidStencilBuffers() const { return fAvoidStencilBuffers; } |
| 82 | |
csmartdalton | e0d3629 | 2016-07-29 08:14:20 -0700 | [diff] [blame] | 83 | /** |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 84 | * Indicates the capabilities of the fixed function blend unit. |
| 85 | */ |
| 86 | enum BlendEquationSupport { |
| 87 | kBasic_BlendEquationSupport, //<! Support to select the operator that |
| 88 | // combines src and dst terms. |
| 89 | kAdvanced_BlendEquationSupport, //<! Additional fixed function support for specific |
| 90 | // SVG/PDF blend modes. Requires blend barriers. |
| 91 | kAdvancedCoherent_BlendEquationSupport, //<! Advanced blend equation support that does not |
| 92 | // require blend barriers, and permits overlap. |
| 93 | |
| 94 | kLast_BlendEquationSupport = kAdvancedCoherent_BlendEquationSupport |
| 95 | }; |
| 96 | |
| 97 | BlendEquationSupport blendEquationSupport() const { return fBlendEquationSupport; } |
| 98 | |
| 99 | bool advancedBlendEquationSupport() const { |
| 100 | return fBlendEquationSupport >= kAdvanced_BlendEquationSupport; |
| 101 | } |
| 102 | |
| 103 | bool advancedCoherentBlendEquationSupport() const { |
| 104 | return kAdvancedCoherent_BlendEquationSupport == fBlendEquationSupport; |
| 105 | } |
| 106 | |
cdalton | 1dd0542 | 2015-06-12 09:01:18 -0700 | [diff] [blame] | 107 | bool canUseAdvancedBlendEquation(GrBlendEquation equation) const { |
| 108 | SkASSERT(GrBlendEquationIsAdvanced(equation)); |
| 109 | return SkToBool(fAdvBlendEqBlacklist & (1 << equation)); |
| 110 | } |
| 111 | |
cdalton | 8917d62 | 2015-05-06 13:40:21 -0700 | [diff] [blame] | 112 | /** |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 113 | * Indicates whether GPU->CPU memory mapping for GPU resources such as vertex buffers and |
| 114 | * textures allows partial mappings or full mappings. |
| 115 | */ |
| 116 | enum MapFlags { |
| 117 | kNone_MapFlags = 0x0, //<! Cannot map the resource. |
| 118 | |
| 119 | kCanMap_MapFlag = 0x1, //<! The resource can be mapped. Must be set for any of |
Robert Phillips | bdda0ba | 2017-08-31 09:17:43 -0400 | [diff] [blame] | 120 | // the other flags to have meaning. |
commit-bot@chromium.org | 160b478 | 2014-05-05 12:32:37 +0000 | [diff] [blame] | 121 | kSubset_MapFlag = 0x2, //<! The resource can be partially mapped. |
| 122 | }; |
| 123 | |
| 124 | uint32_t mapBufferFlags() const { return fMapBufferFlags; } |
| 125 | |
robertphillips@google.com | 2d2e5c4 | 2013-10-30 21:30:43 +0000 | [diff] [blame] | 126 | // Scratch textures not being reused means that those scratch textures |
skia.committer@gmail.com | 7ed98df | 2013-10-31 07:01:53 +0000 | [diff] [blame] | 127 | // 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] | 128 | // recycled in the texture cache. This is to prevent ghosting by drivers |
| 129 | // (in particular for deferred architectures). |
commit-bot@chromium.org | b835652 | 2013-07-18 22:26:39 +0000 | [diff] [blame] | 130 | bool reuseScratchTextures() const { return fReuseScratchTextures; } |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 131 | bool reuseScratchBuffers() const { return fReuseScratchBuffers; } |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 132 | |
bsalomon | 7dbd45d | 2016-03-23 10:40:53 -0700 | [diff] [blame] | 133 | /// maximum number of attribute values per vertex |
| 134 | int maxVertexAttributes() const { return fMaxVertexAttributes; } |
| 135 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 136 | int maxRenderTargetSize() const { return fMaxRenderTargetSize; } |
Chris Dalton | 2612bae | 2018-02-22 13:41:37 -0700 | [diff] [blame] | 137 | |
| 138 | /** This is the largest render target size that can be used without incurring extra perfomance |
| 139 | cost. It is usually the max RT size, unless larger render targets are known to be slower. */ |
| 140 | int maxPreferredRenderTargetSize() const { return fMaxPreferredRenderTargetSize; } |
| 141 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 142 | int maxTextureSize() const { return fMaxTextureSize; } |
Chris Dalton | 2612bae | 2018-02-22 13:41:37 -0700 | [diff] [blame] | 143 | |
bsalomon | 8c07b7a | 2015-11-02 11:36:52 -0800 | [diff] [blame] | 144 | /** This is the maximum tile size to use by GPU devices for rendering sw-backed images/bitmaps. |
| 145 | It is usually the max texture size, unless we're overriding it for testing. */ |
| 146 | int maxTileSize() const { SkASSERT(fMaxTileSize <= fMaxTextureSize); return fMaxTileSize; } |
bsalomon | c59a1df | 2015-06-01 07:13:42 -0700 | [diff] [blame] | 147 | |
cdalton | af8bc7d | 2016-02-05 09:35:20 -0800 | [diff] [blame] | 148 | int maxRasterSamples() const { return fMaxRasterSamples; } |
Greg Daniel | 81e7bf8 | 2017-07-19 14:47:42 -0400 | [diff] [blame] | 149 | |
csmartdalton | 9bc1187 | 2016-08-09 12:42:47 -0700 | [diff] [blame] | 150 | int maxWindowRectangles() const { return fMaxWindowRectangles; } |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 151 | |
Greg Daniel | 2a30390 | 2018-02-20 10:25:54 -0500 | [diff] [blame] | 152 | // Returns whether mixed samples is supported for the given backend render target. |
| 153 | bool isWindowRectanglesSupportedForRT(const GrBackendRenderTarget& rt) const { |
| 154 | return this->maxWindowRectangles() > 0 && this->onIsWindowRectanglesSupportedForRT(rt); |
| 155 | } |
| 156 | |
Chris Dalton | 584a79a | 2017-11-15 13:14:01 -0700 | [diff] [blame] | 157 | // A tuned, platform-specific value for the maximum number of analytic fragment processors we |
| 158 | // should use to implement a clip, before falling back on a mask. |
| 159 | int maxClipAnalyticFPs() const { return fMaxClipAnalyticFPs; } |
| 160 | |
Robert Phillips | b7b7e5f | 2017-05-22 13:23:19 -0400 | [diff] [blame] | 161 | virtual bool isConfigTexturable(GrPixelConfig) const = 0; |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 162 | |
Greg Daniel | bb76ace | 2017-09-29 15:58:22 -0400 | [diff] [blame] | 163 | // Returns whether a texture of the given config can be copied to a texture of the same config. |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 164 | virtual bool isConfigCopyable(GrPixelConfig) const = 0; |
| 165 | |
| 166 | // Returns the maximum supported sample count for a config. 0 means the config is not renderable |
| 167 | // 1 means the config is renderable but doesn't support MSAA. |
| 168 | virtual int maxRenderTargetSampleCount(GrPixelConfig) const = 0; |
| 169 | |
| 170 | bool isConfigRenderable(GrPixelConfig config) const { |
| 171 | return this->maxRenderTargetSampleCount(config) > 0; |
| 172 | } |
| 173 | |
| 174 | // TODO: Remove this after Flutter updated to no longer use it. |
| 175 | bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const { |
| 176 | return this->maxRenderTargetSampleCount(config) > (withMSAA ? 1 : 0); |
| 177 | } |
| 178 | |
| 179 | // Find a sample count greater than or equal to the requested count which is supported for a |
| 180 | // color buffer of the given config or 0 if no such sample count is supported. If the requested |
| 181 | // sample count is 1 then 1 will be returned if non-MSAA rendering is supported, otherwise 0. |
| 182 | // For historical reasons requestedCount==0 is handled identically to requestedCount==1. |
| 183 | virtual int getRenderTargetSampleCount(int requestedCount, GrPixelConfig) const = 0; |
| 184 | // TODO: Remove. Legacy name used by Chrome. |
| 185 | int getSampleCount(int requestedCount, GrPixelConfig config) const { |
| 186 | return this->getRenderTargetSampleCount(requestedCount, config); |
| 187 | } |
commit-bot@chromium.org | 42dc813 | 2014-05-27 19:26:59 +0000 | [diff] [blame] | 188 | |
Brian Salomon | 5f33a8c | 2018-02-26 14:32:39 -0500 | [diff] [blame] | 189 | /** |
Brian Salomon | 3d86a19 | 2018-02-27 16:46:11 -0500 | [diff] [blame^] | 190 | * Backends may have restrictions on what types of surfaces support GrGpu::writePixels(). |
| 191 | * If this returns false then the caller should implement a fallback where a temporary texture |
| 192 | * is created, pixels are written to it, and then that is copied or drawn into the the surface. |
Brian Salomon | 5f33a8c | 2018-02-26 14:32:39 -0500 | [diff] [blame] | 193 | */ |
Brian Salomon | 3d86a19 | 2018-02-27 16:46:11 -0500 | [diff] [blame^] | 194 | virtual bool surfaceSupportsWritePixels(const GrSurface* surface) const = 0; |
Brian Salomon | 5f33a8c | 2018-02-26 14:32:39 -0500 | [diff] [blame] | 195 | |
| 196 | /** |
| 197 | * Given a dst pixel config and a src color type what color type must the caller coax the |
| 198 | * the data into in order to use GrGpu::writePixels(). |
| 199 | */ |
| 200 | virtual GrColorType supportedWritePixelsColorType(GrPixelConfig config, |
| 201 | GrColorType /*srcColorType*/) const { |
| 202 | return GrPixelConfigToColorType(config); |
| 203 | } |
| 204 | |
robertphillips | caef345 | 2015-11-11 13:18:11 -0800 | [diff] [blame] | 205 | bool suppressPrints() const { return fSuppressPrints; } |
| 206 | |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 207 | size_t bufferMapThreshold() const { |
| 208 | SkASSERT(fBufferMapThreshold >= 0); |
| 209 | return fBufferMapThreshold; |
joshualitt | 7224c86 | 2015-05-29 06:46:47 -0700 | [diff] [blame] | 210 | } |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 211 | |
Mike Klein | fc6c37b | 2016-09-27 09:34:10 -0400 | [diff] [blame] | 212 | /** True in environments that will issue errors if memory uploaded to buffers |
bsalomon | 7dea7b7 | 2015-08-19 08:26:51 -0700 | [diff] [blame] | 213 | is not initialized (even if not read by draw calls). */ |
| 214 | bool mustClearUploadedBufferData() const { return fMustClearUploadedBufferData; } |
| 215 | |
Jim Van Verth | fbdc080 | 2017-05-02 16:15:53 -0400 | [diff] [blame] | 216 | bool wireframeMode() const { return fWireframeMode; } |
| 217 | |
ethannicholas | 28ef445 | 2016-03-25 09:26:03 -0700 | [diff] [blame] | 218 | bool sampleShadingSupport() const { return fSampleShadingSupport; } |
| 219 | |
jvanverth | 84741b3 | 2016-09-30 08:39:02 -0700 | [diff] [blame] | 220 | bool fenceSyncSupport() const { return fFenceSyncSupport; } |
Brian Osman | 2c2bc11 | 2017-02-28 10:02:49 -0500 | [diff] [blame] | 221 | bool crossContextTextureSupport() const { return fCrossContextTextureSupport; } |
jvanverth | 84741b3 | 2016-09-30 08:39:02 -0700 | [diff] [blame] | 222 | |
Brian Salomon | 467921e | 2017-03-06 16:17:12 -0500 | [diff] [blame] | 223 | /** |
| 224 | * This is can be called before allocating a texture to be a dst for copySurface. This is only |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 225 | * used for doing dst copies needed in blends, thus the src is always a GrRenderTargetProxy. It |
| 226 | * will populate the origin, config, and flags fields of the desc such that copySurface can |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 227 | * efficiently succeed. rectsMustMatch will be set to true if the copy operation must ensure |
| 228 | * that the src and dest rects are identical. disallowSubrect will be set to true if copy rect |
| 229 | * must equal src's bounds. |
Brian Salomon | 467921e | 2017-03-06 16:17:12 -0500 | [diff] [blame] | 230 | */ |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 231 | virtual bool initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* desc, |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 232 | bool* rectsMustMatch, bool* disallowSubrect) const = 0; |
Brian Salomon | 467921e | 2017-03-06 16:17:12 -0500 | [diff] [blame] | 233 | |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 234 | bool validateSurfaceDesc(const GrSurfaceDesc&, GrMipMapped) const; |
| 235 | |
Greg Daniel | f5d8758 | 2017-12-18 14:48:15 -0500 | [diff] [blame] | 236 | /** |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 237 | * Returns true if the GrBackendTexture can be used with the supplied SkColorType. If it is |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 238 | * compatible, the passed in GrPixelConfig will be set to a config that matches the backend |
| 239 | * format and requested SkColorType. |
Greg Daniel | f5d8758 | 2017-12-18 14:48:15 -0500 | [diff] [blame] | 240 | */ |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 241 | virtual bool validateBackendTexture(const GrBackendTexture& tex, SkColorType ct, |
| 242 | GrPixelConfig*) const = 0; |
| 243 | virtual bool validateBackendRenderTarget(const GrBackendRenderTarget&, SkColorType, |
| 244 | GrPixelConfig*) const = 0; |
Greg Daniel | f5d8758 | 2017-12-18 14:48:15 -0500 | [diff] [blame] | 245 | |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 246 | // TODO: replace validateBackendTexture and validateBackendRenderTarget with calls to |
| 247 | // getConfigFromBackendFormat? |
| 248 | // TODO: it seems like we could pass the full SkImageInfo and validate its colorSpace too |
| 249 | virtual bool getConfigFromBackendFormat(const GrBackendFormat& format, SkColorType ct, |
| 250 | GrPixelConfig*) const = 0; |
| 251 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 252 | protected: |
bsalomon | 4ee6bd8 | 2015-05-27 13:23:23 -0700 | [diff] [blame] | 253 | /** Subclasses must call this at the end of their constructors in order to apply caps |
| 254 | overrides requested by the client. Note that overrides will only reduce the caps never |
| 255 | expand them. */ |
| 256 | void applyOptionsOverrides(const GrContextOptions& options); |
| 257 | |
bungeman | 6bd5284 | 2016-10-27 09:30:08 -0700 | [diff] [blame] | 258 | sk_sp<GrShaderCaps> fShaderCaps; |
jvanverth | e9c0fc6 | 2015-04-29 11:18:05 -0700 | [diff] [blame] | 259 | |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 260 | bool fNPOTTextureTileSupport : 1; |
| 261 | bool fMipMapSupport : 1; |
brianosman | a635936 | 2016-03-21 06:55:37 -0700 | [diff] [blame] | 262 | bool fSRGBSupport : 1; |
brianosman | 35b784d | 2016-05-05 11:52:53 -0700 | [diff] [blame] | 263 | bool fSRGBWriteControl : 1; |
Brian Osman | 57bc3ea | 2017-07-27 09:58:11 -0400 | [diff] [blame] | 264 | bool fSRGBDecodeDisableSupport : 1; |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 265 | bool fDiscardRenderTargetSupport : 1; |
| 266 | bool fReuseScratchTextures : 1; |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 267 | bool fReuseScratchBuffers : 1; |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 268 | bool fGpuTracingSupport : 1; |
joshualitt | 83bc229 | 2015-06-18 14:18:02 -0700 | [diff] [blame] | 269 | bool fOversizedStencilSupport : 1; |
| 270 | bool fTextureBarrierSupport : 1; |
Robert Phillips | 7f86192 | 2018-01-30 13:13:42 +0000 | [diff] [blame] | 271 | bool fSampleLocationsSupport : 1; |
csmartdalton | 2b5f2cb | 2016-06-10 14:06:32 -0700 | [diff] [blame] | 272 | bool fMultisampleDisableSupport : 1; |
Chris Dalton | 1d61635 | 2017-05-31 12:51:23 -0600 | [diff] [blame] | 273 | bool fInstanceAttribSupport : 1; |
egdaniel | eed519e | 2016-01-15 11:36:18 -0800 | [diff] [blame] | 274 | bool fUsesMixedSamples : 1; |
Chris Dalton | 27059d3 | 2018-01-23 14:06:50 -0700 | [diff] [blame] | 275 | bool fUsePrimitiveRestart : 1; |
csmartdalton | 485a120 | 2016-07-13 10:16:32 -0700 | [diff] [blame] | 276 | bool fPreferClientSideDynamicBuffers : 1; |
Chris Dalton | 344e903 | 2017-12-11 15:42:09 -0700 | [diff] [blame] | 277 | bool fPreferFullscreenClears : 1; |
bsalomon | 7dea7b7 | 2015-08-19 08:26:51 -0700 | [diff] [blame] | 278 | bool fMustClearUploadedBufferData : 1; |
robertphillips | 1b8e1b5 | 2015-06-24 06:54:10 -0700 | [diff] [blame] | 279 | |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 280 | // Driver workaround |
Chris Dalton | e4679fa | 2017-09-29 13:58:26 -0600 | [diff] [blame] | 281 | bool fBlacklistCoverageCounting : 1; |
Eric Karl | 5c77975 | 2017-05-08 12:02:07 -0700 | [diff] [blame] | 282 | bool fAvoidStencilBuffers : 1; |
bsalomon | 63b2196 | 2014-11-05 07:05:34 -0800 | [diff] [blame] | 283 | |
Brian Salomon | 01b476a | 2018-01-23 11:06:41 -0500 | [diff] [blame] | 284 | // ANGLE performance workaround |
robertphillips | 6392668 | 2015-08-20 09:39:02 -0700 | [diff] [blame] | 285 | bool fPreferVRAMUseOverFlushes : 1; |
| 286 | |
ethannicholas | 28ef445 | 2016-03-25 09:26:03 -0700 | [diff] [blame] | 287 | bool fSampleShadingSupport : 1; |
jvanverth | 84741b3 | 2016-09-30 08:39:02 -0700 | [diff] [blame] | 288 | // TODO: this may need to be an enum to support different fence types |
| 289 | bool fFenceSyncSupport : 1; |
ethannicholas | 28ef445 | 2016-03-25 09:26:03 -0700 | [diff] [blame] | 290 | |
Brian Osman | 2c2bc11 | 2017-02-28 10:02:49 -0500 | [diff] [blame] | 291 | // Vulkan doesn't support this (yet) and some drivers have issues, too |
| 292 | bool fCrossContextTextureSupport : 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; |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 299 | int fBufferMapThreshold; |
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; |
Chris Dalton | 2612bae | 2018-02-22 13:41:37 -0700 | [diff] [blame] | 302 | int fMaxPreferredRenderTargetSize; |
bsalomon | 7dbd45d | 2016-03-23 10:40:53 -0700 | [diff] [blame] | 303 | int fMaxVertexAttributes; |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 304 | int fMaxTextureSize; |
bsalomon | 8c07b7a | 2015-11-02 11:36:52 -0800 | [diff] [blame] | 305 | int fMaxTileSize; |
cdalton | af8bc7d | 2016-02-05 09:35:20 -0800 | [diff] [blame] | 306 | int fMaxRasterSamples; |
csmartdalton | 9bc1187 | 2016-08-09 12:42:47 -0700 | [diff] [blame] | 307 | int fMaxWindowRectangles; |
Chris Dalton | 584a79a | 2017-11-15 13:14:01 -0700 | [diff] [blame] | 308 | int fMaxClipAnalyticFPs; |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 309 | |
egdaniel | bc127a3 | 2014-09-19 12:07:43 -0700 | [diff] [blame] | 310 | private: |
Mike Klein | fc6c37b | 2016-09-27 09:34:10 -0400 | [diff] [blame] | 311 | virtual void onApplyOptionsOverrides(const GrContextOptions&) {} |
Brian Osman | 71a1889 | 2017-08-10 10:23:25 -0400 | [diff] [blame] | 312 | virtual void onDumpJSON(SkJSONWriter*) const {} |
egdaniel | b7e7d57 | 2015-11-04 04:23:53 -0800 | [diff] [blame] | 313 | |
Greg Daniel | 2a30390 | 2018-02-20 10:25:54 -0500 | [diff] [blame] | 314 | // Backends should implement this if they have any extra requirements for use of mixed |
| 315 | // samples for a specific GrBackendRenderTarget outside of basic support. |
| 316 | virtual bool onIsMixedSamplesSupportedForRT(const GrBackendRenderTarget&) const { |
| 317 | return true; |
| 318 | } |
| 319 | // Backends should implement this if they have any extra requirements for use of window |
| 320 | // rectangles for a specific GrBackendRenderTarget outside of basic support. |
| 321 | virtual bool onIsWindowRectanglesSupportedForRT(const GrBackendRenderTarget&) const { |
| 322 | return true; |
| 323 | } |
| 324 | |
robertphillips | caef345 | 2015-11-11 13:18:11 -0800 | [diff] [blame] | 325 | bool fSuppressPrints : 1; |
Jim Van Verth | fbdc080 | 2017-05-02 16:15:53 -0400 | [diff] [blame] | 326 | bool fWireframeMode : 1; |
bsalomon | 682c269 | 2015-05-22 14:01:46 -0700 | [diff] [blame] | 327 | |
bsalomon@google.com | c26d94f | 2013-03-25 18:19:00 +0000 | [diff] [blame] | 328 | typedef SkRefCnt INHERITED; |
| 329 | }; |
| 330 | |
| 331 | #endif |