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