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