blob: 10f930f0a214d33902baef883c7782f15705e6ea [file] [log] [blame]
bsalomon@google.comc26d94f2013-03-25 18:19:00 +00001
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 */
bsalomon4b91f762015-05-19 09:29:46 -07008#ifndef GrCaps_DEFINED
9#define GrCaps_DEFINED
bsalomon@google.comc26d94f2013-03-25 18:19:00 +000010
Mike Kleinc0bd9f92019-04-23 12:05:21 -050011#include "include/core/SkImageInfo.h"
12#include "include/core/SkRefCnt.h"
13#include "include/core/SkString.h"
14#include "include/gpu/GrBlend.h"
15#include "include/gpu/GrDriverBugWorkarounds.h"
16#include "include/private/GrTypesPriv.h"
17#include "src/gpu/GrShaderCaps.h"
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +000018
Robert Phillipsfc711a22018-02-13 17:03:00 -050019class GrBackendFormat;
Greg Danielfaa095e2017-12-19 13:15:02 -050020class GrBackendRenderTarget;
Greg Danielf5d87582017-12-18 14:48:15 -050021class GrBackendTexture;
bsalomon682c2692015-05-22 14:01:46 -070022struct GrContextOptions;
Robert Phillipsbf25d432017-04-07 10:08:53 -040023class GrRenderTargetProxy;
Brian Salomon3d86a192018-02-27 16:46:11 -050024class GrSurface;
Greg Daniel25af6712018-04-25 10:44:38 -040025class GrSurfaceProxy;
Brian Osman71a18892017-08-10 10:23:25 -040026class SkJSONWriter;
jvanverthe9c0fc62015-04-29 11:18:05 -070027
28/**
bsalomon4b91f762015-05-19 09:29:46 -070029 * Represents the capabilities of a GrContext.
jvanverthe9c0fc62015-04-29 11:18:05 -070030 */
bsalomon4b91f762015-05-19 09:29:46 -070031class GrCaps : public SkRefCnt {
jvanverthe9c0fc62015-04-29 11:18:05 -070032public:
bsalomon682c2692015-05-22 14:01:46 -070033 GrCaps(const GrContextOptions&);
bsalomon@google.comc26d94f2013-03-25 18:19:00 +000034
Brian Osman71a18892017-08-10 10:23:25 -040035 void dumpJSON(SkJSONWriter*) const;
36
Brian Salomon94efbf52016-11-29 13:43:05 -050037 const GrShaderCaps* shaderCaps() const { return fShaderCaps.get(); }
jvanverthe9c0fc62015-04-29 11:18:05 -070038
bsalomon@google.comc26d94f2013-03-25 18:19:00 +000039 bool npotTextureTileSupport() const { return fNPOTTextureTileSupport; }
commit-bot@chromium.org47442312013-12-19 16:18:01 +000040 /** 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; }
brianosman64d094d2016-03-25 06:01:59 -070043
44 /**
45 * Skia convention is that a device only has sRGB support if it supports sRGB formats for both
Brian Osman9363ac42018-06-01 16:10:53 -040046 * textures and framebuffers.
brianosman64d094d2016-03-25 06:01:59 -070047 */
brianosmana6359362016-03-21 06:55:37 -070048 bool srgbSupport() const { return fSRGBSupport; }
brianosman35b784d2016-05-05 11:52:53 -070049 /**
50 * Is there support for enabling/disabling sRGB writes for sRGB-capable color buffers?
51 */
52 bool srgbWriteControl() const { return fSRGBWriteControl; }
commit-bot@chromium.orga3baf3b2014-02-21 18:45:30 +000053 bool gpuTracingSupport() const { return fGpuTracingSupport; }
bsalomond08ea5f2015-02-20 06:58:13 -080054 bool oversizedStencilSupport() const { return fOversizedStencilSupport; }
cdaltonfd4167d2015-04-21 11:45:56 -070055 bool textureBarrierSupport() const { return fTextureBarrierSupport; }
Robert Phillips7f861922018-01-30 13:13:42 +000056 bool sampleLocationsSupport() const { return fSampleLocationsSupport; }
csmartdalton2b5f2cb2016-06-10 14:06:32 -070057 bool multisampleDisableSupport() const { return fMultisampleDisableSupport; }
Chris Dalton1d616352017-05-31 12:51:23 -060058 bool instanceAttribSupport() const { return fInstanceAttribSupport; }
Chris Dalton6ce447a2019-06-23 18:07:38 -060059 bool mixedSamplesSupport() const { return fMixedSamplesSupport; }
Brian Osman499bf1a2018-09-17 11:32:42 -040060 bool halfFloatVertexAttributeSupport() const { return fHalfFloatVertexAttributeSupport; }
Chris Dalton27059d32018-01-23 14:06:50 -070061
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
csmartdalton485a1202016-07-13 10:16:32 -070066 bool preferClientSideDynamicBuffers() const { return fPreferClientSideDynamicBuffers; }
robertphillips@google.com2d2e5c42013-10-30 21:30:43 +000067
Chris Dalton344e9032017-12-11 15:42:09 -070068 // 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
robertphillips63926682015-08-20 09:39:02 -070072 bool preferVRAMUseOverFlushes() const { return fPreferVRAMUseOverFlushes; }
73
Chris Dalton0dffbab2019-03-27 13:08:50 -060074 bool preferTrianglesOverSampleMask() const { return fPreferTrianglesOverSampleMask; }
75
Eric Karl5c779752017-05-08 12:02:07 -070076 bool avoidStencilBuffers() const { return fAvoidStencilBuffers; }
77
Greg Daniel4374e962018-09-28 15:09:47 -040078 bool avoidWritePixelsFastPath() const { return fAvoidWritePixelsFastPath; }
79
csmartdaltone0d36292016-07-29 08:14:20 -070080 /**
cdalton8917d622015-05-06 13:40:21 -070081 * Indicates the capabilities of the fixed function blend unit.
82 */
83 enum BlendEquationSupport {
84 kBasic_BlendEquationSupport, //<! Support to select the operator that
85 // combines src and dst terms.
86 kAdvanced_BlendEquationSupport, //<! Additional fixed function support for specific
87 // SVG/PDF blend modes. Requires blend barriers.
88 kAdvancedCoherent_BlendEquationSupport, //<! Advanced blend equation support that does not
89 // require blend barriers, and permits overlap.
90
91 kLast_BlendEquationSupport = kAdvancedCoherent_BlendEquationSupport
92 };
93
94 BlendEquationSupport blendEquationSupport() const { return fBlendEquationSupport; }
95
96 bool advancedBlendEquationSupport() const {
97 return fBlendEquationSupport >= kAdvanced_BlendEquationSupport;
98 }
99
100 bool advancedCoherentBlendEquationSupport() const {
101 return kAdvancedCoherent_BlendEquationSupport == fBlendEquationSupport;
102 }
103
Chris Dalton302d5be2019-01-22 23:41:25 -0700104 bool isAdvancedBlendEquationBlacklisted(GrBlendEquation equation) const {
cdalton1dd05422015-06-12 09:01:18 -0700105 SkASSERT(GrBlendEquationIsAdvanced(equation));
Chris Dalton302d5be2019-01-22 23:41:25 -0700106 SkASSERT(this->advancedBlendEquationSupport());
cdalton1dd05422015-06-12 09:01:18 -0700107 return SkToBool(fAdvBlendEqBlacklist & (1 << equation));
108 }
109
cdalton8917d622015-05-06 13:40:21 -0700110 /**
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000111 * 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 {
Brian Salomon105d7c22019-04-16 13:46:14 -0400115 kNone_MapFlags = 0x0, //<! Cannot map the resource.
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000116
Brian Salomon105d7c22019-04-16 13:46:14 -0400117 kCanMap_MapFlag = 0x1, //<! The resource can be mapped. Must be set for any of
118 // the other flags to have meaning.
119 kSubset_MapFlag = 0x2, //<! The resource can be partially mapped.
120 kAsyncRead_MapFlag = 0x4, //<! Are maps for reading asynchronous WRT GrGpuCommandBuffers
121 // submitted to GrGpu.
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000122 };
123
124 uint32_t mapBufferFlags() const { return fMapBufferFlags; }
125
robertphillips@google.com2d2e5c42013-10-30 21:30:43 +0000126 // Scratch textures not being reused means that those scratch textures
skia.committer@gmail.com7ed98df2013-10-31 07:01:53 +0000127 // that we upload to (i.e., don't have a render target) will not be
robertphillips@google.com2d2e5c42013-10-30 21:30:43 +0000128 // recycled in the texture cache. This is to prevent ghosting by drivers
129 // (in particular for deferred architectures).
commit-bot@chromium.orgb8356522013-07-18 22:26:39 +0000130 bool reuseScratchTextures() const { return fReuseScratchTextures; }
robertphillips1b8e1b52015-06-24 06:54:10 -0700131 bool reuseScratchBuffers() const { return fReuseScratchBuffers; }
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000132
bsalomon7dbd45d2016-03-23 10:40:53 -0700133 /// maximum number of attribute values per vertex
134 int maxVertexAttributes() const { return fMaxVertexAttributes; }
135
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000136 int maxRenderTargetSize() const { return fMaxRenderTargetSize; }
Chris Dalton2612bae2018-02-22 13:41:37 -0700137
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.comc26d94f2013-03-25 18:19:00 +0000142 int maxTextureSize() const { return fMaxTextureSize; }
Chris Dalton2612bae2018-02-22 13:41:37 -0700143
bsalomon8c07b7a2015-11-02 11:36:52 -0800144 /** 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. */
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400146 int maxTileSize() const {
147 SkASSERT(fMaxTileSize <= fMaxTextureSize);
148 return fMaxTileSize;
149 }
bsalomonc59a1df2015-06-01 07:13:42 -0700150
csmartdalton9bc11872016-08-09 12:42:47 -0700151 int maxWindowRectangles() const { return fMaxWindowRectangles; }
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000152
Greg Daniel2a303902018-02-20 10:25:54 -0500153 // 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
Robert Phillipsf209e882019-06-25 15:59:50 -0400158 virtual bool isFormatSRGB(const GrBackendFormat&) const = 0;
159
Greg Daniel2f2caea2019-07-08 14:24:47 -0400160 virtual bool isFormatTexturable(GrColorType, const GrBackendFormat&) const = 0;
Robert Phillipsb7b7e5f2017-05-22 13:23:19 -0400161 virtual bool isConfigTexturable(GrPixelConfig) const = 0;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500162
Greg Danielbb76ace2017-09-29 15:58:22 -0400163 // Returns whether a texture of the given config can be copied to a texture of the same config.
Greg Daniel5c96db82019-07-09 14:06:58 -0400164 virtual bool isFormatCopyable(GrColorType, const GrBackendFormat&) const = 0;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500165 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.
Greg Daniel5c96db82019-07-09 14:06:58 -0400169 virtual int maxRenderTargetSampleCount(GrColorType, const GrBackendFormat&) const = 0;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500170 virtual int maxRenderTargetSampleCount(GrPixelConfig) const = 0;
171
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600172 // Returns the number of samples to use when performing internal draws to the given config with
Chris Daltona1638a52019-06-24 11:54:24 -0600173 // MSAA or mixed samples. If 0, Ganesh should not attempt to use internal multisampling.
174 int internalMultisampleCount(GrPixelConfig config) const {
175 return SkTMin(fInternalMultisampleCount, this->maxRenderTargetSampleCount(config));
Chris Dalton1e6c5b82019-06-17 14:16:49 -0600176 }
177
Brian Salomonbdecacf2018-02-02 20:32:49 -0500178 bool isConfigRenderable(GrPixelConfig config) const {
179 return this->maxRenderTargetSampleCount(config) > 0;
180 }
181
Greg Daniel64329092019-07-16 16:16:21 -0400182 bool isFormatRenderable(GrColorType ct, const GrBackendFormat& format) const {
183 return this->maxRenderTargetSampleCount(ct, format) > 0;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500184 }
185
186 // Find a sample count greater than or equal to the requested count which is supported for a
187 // color buffer of the given config or 0 if no such sample count is supported. If the requested
188 // sample count is 1 then 1 will be returned if non-MSAA rendering is supported, otherwise 0.
189 // For historical reasons requestedCount==0 is handled identically to requestedCount==1.
Robert Phillipsd8f79a22019-06-24 13:25:42 -0400190 virtual int getRenderTargetSampleCount(int requestedCount,
Greg Daniel5c96db82019-07-09 14:06:58 -0400191 GrColorType, const GrBackendFormat&) const = 0;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500192 virtual int getRenderTargetSampleCount(int requestedCount, GrPixelConfig) const = 0;
commit-bot@chromium.org42dc8132014-05-27 19:26:59 +0000193
Brian Salomon5f33a8c2018-02-26 14:32:39 -0500194 /**
Brian Salomon3d86a192018-02-27 16:46:11 -0500195 * Backends may have restrictions on what types of surfaces support GrGpu::writePixels().
196 * If this returns false then the caller should implement a fallback where a temporary texture
197 * is created, pixels are written to it, and then that is copied or drawn into the the surface.
Brian Salomon5f33a8c2018-02-26 14:32:39 -0500198 */
Brian Salomonc67c31c2018-12-06 10:00:03 -0500199 bool surfaceSupportsWritePixels(const GrSurface*) const;
Brian Salomon19eaf2d2018-03-19 16:06:44 -0400200
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400201 /**
Brian Salomondc0710f2019-07-01 14:59:32 -0400202 * Indicates whether surface supports GrGpu::readPixels, must be copied, or cannot be read.
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400203 */
Brian Salomondc0710f2019-07-01 14:59:32 -0400204 enum class SurfaceReadPixelsSupport {
205 /** GrGpu::readPixels is supported by the surface. */
206 kSupported,
207 /**
208 * GrGpu::readPixels is not supported by this surface but this surface can be drawn
209 * or copied to a Ganesh-created GrTextureType::kTexture2D and then that surface will be
210 * readable.
211 */
212 kCopyToTexture2D,
213 /**
214 * Not supported
215 */
216 kUnsupported,
Emircan Uysaler23ca4e72019-06-24 10:53:09 -0400217 };
Brian Salomon19eaf2d2018-03-19 16:06:44 -0400218 /**
Brian Salomondc0710f2019-07-01 14:59:32 -0400219 * Backends may have restrictions on what types of surfaces support GrGpu::readPixels(). We may
220 * either be able to read directly from the surface, read from a copy of the surface, or not
221 * read at all.
Brian Salomon19eaf2d2018-03-19 16:06:44 -0400222 */
Brian Salomondc0710f2019-07-01 14:59:32 -0400223 virtual SurfaceReadPixelsSupport surfaceSupportsReadPixels(const GrSurface*) const = 0;
Brian Salomon5f33a8c2018-02-26 14:32:39 -0500224
225 /**
226 * Given a dst pixel config and a src color type what color type must the caller coax the
227 * the data into in order to use GrGpu::writePixels().
228 */
229 virtual GrColorType supportedWritePixelsColorType(GrPixelConfig config,
Brian Salomonf30b1c12019-06-20 12:25:02 -0400230 GrColorType srcColorType) const {
Brian Salomon5f33a8c2018-02-26 14:32:39 -0500231 return GrPixelConfigToColorType(config);
232 }
233
Brian Salomonf30b1c12019-06-20 12:25:02 -0400234 struct SupportedRead {
235 GrSwizzle fSwizzle;
236 GrColorType fColorType;
237 };
238
Brian Salomon19eaf2d2018-03-19 16:06:44 -0400239 /**
Brian Salomonf30b1c12019-06-20 12:25:02 -0400240 * Given a src surface's pixel config and its backend format as well as a color type the caller
241 * would like read into, this provides a legal color type that the caller may pass to
242 * GrGpu::readPixels(). The returned color type may differ from the passed dstColorType, in
243 * which case the caller must convert the read pixel data (see GrConvertPixels). When converting
244 * to dstColorType the swizzle in the returned struct should be applied. The caller must check
245 * the returned color type for kUnknown.
Brian Salomon19eaf2d2018-03-19 16:06:44 -0400246 */
Greg Danielc6dc5cf2019-07-17 16:02:00 -0400247 virtual SupportedRead supportedReadPixelsColorType(GrColorType srcColorType,
248 GrPixelConfig srcConfig,
Brian Salomonf30b1c12019-06-20 12:25:02 -0400249 const GrBackendFormat& srcFormat,
250 GrColorType dstColorType) const;
Brian Salomon19eaf2d2018-03-19 16:06:44 -0400251
Brian Salomon1047a492019-07-02 12:25:21 -0400252 /**
253 * Do GrGpu::writePixels() and GrGpu::transferPixelsTo() support a src buffer where the row
254 * bytes is not equal to bpp * w?
255 */
256 bool writePixelsRowBytesSupport() const { return fWritePixelsRowBytesSupport; }
257 /**
258 * Does GrGpu::readPixels() support a dst buffer where the row bytes is not equal to bpp * w?
259 */
260 bool readPixelsRowBytesSupport() const { return fReadPixelsRowBytesSupport; }
261
Brian Salomone05ba5a2019-04-08 11:59:07 -0400262 /** Are transfer buffers (to textures and from surfaces) supported? */
263 bool transferBufferSupport() const { return fTransferBufferSupport; }
264
265 /**
Brian Salomon26de56e2019-04-10 12:14:26 -0400266 * Gets the alignment requirement for the buffer offset used with GrGpu::transferPixelsFrom for
267 * a given GrColorType. To check whether a pixels as GrColorType can be read for a given surface
268 * see supportedReadPixelsColorType() and surfaceSupportsReadPixels().
Brian Salomone05ba5a2019-04-08 11:59:07 -0400269 *
270 * @param bufferColorType The color type of the pixel data that will be stored in the transfer
271 * buffer.
Brian Salomon26de56e2019-04-10 12:14:26 -0400272 * @return minimum required alignment for the buffer offset or zero if reading to the color type
273 * is not supported.
Brian Salomone05ba5a2019-04-08 11:59:07 -0400274 */
Brian Salomon26de56e2019-04-10 12:14:26 -0400275 size_t transferFromOffsetAlignment(GrColorType bufferColorType) const;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400276
robertphillipscaef3452015-11-11 13:18:11 -0800277 bool suppressPrints() const { return fSuppressPrints; }
278
cdalton397536c2016-03-25 12:15:03 -0700279 size_t bufferMapThreshold() const {
280 SkASSERT(fBufferMapThreshold >= 0);
281 return fBufferMapThreshold;
joshualitt7224c862015-05-29 06:46:47 -0700282 }
bsalomon682c2692015-05-22 14:01:46 -0700283
Mike Kleinfc6c37b2016-09-27 09:34:10 -0400284 /** True in environments that will issue errors if memory uploaded to buffers
bsalomon7dea7b72015-08-19 08:26:51 -0700285 is not initialized (even if not read by draw calls). */
286 bool mustClearUploadedBufferData() const { return fMustClearUploadedBufferData; }
287
Kevin Lubick61a5f0a2019-03-28 09:47:15 -0400288 /** For some environments, there is a performance or safety concern to not
289 initializing textures. For example, with WebGL and Firefox, there is a large
290 performance hit to not doing it.
291 */
292 bool shouldInitializeTextures() const { return fShouldInitializeTextures; }
293
Brian Salomona3e29962019-07-16 11:52:08 -0400294 /**
295 * When this is true it is required that all textures are initially cleared. However, the
296 * clearing must be implemented by passing level data to GrGpu::createTexture() rather than
297 * be implemeted by GrGpu::createTexture().
298 *
299 * TODO: Make this take GrBacknedFormat when canClearTextureOnCreation() does as well.
300 */
301 bool createTextureMustSpecifyAllLevels() const {
302 return this->shouldInitializeTextures() && !this->canClearTextureOnCreation();
303 }
Kevin Lubick61a5f0a2019-03-28 09:47:15 -0400304
Greg Danielb2acf0a2018-09-12 09:17:11 -0400305 /** Returns true if the given backend supports importing AHardwareBuffers via the
306 * GrAHardwarebufferImageGenerator. This will only ever be supported on Android devices with API
307 * level >= 26.
308 * */
309 bool supportsAHardwareBufferImages() const { return fSupportsAHardwareBufferImages; }
310
Jim Van Verthfbdc0802017-05-02 16:15:53 -0400311 bool wireframeMode() const { return fWireframeMode; }
312
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400313 /** Supports using GrFence. */
jvanverth84741b32016-09-30 08:39:02 -0700314 bool fenceSyncSupport() const { return fFenceSyncSupport; }
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400315
316 /** Supports using GrSemaphore. */
317 bool semaphoreSupport() const { return fSemaphoreSupport; }
318
Brian Osman2c2bc112017-02-28 10:02:49 -0500319 bool crossContextTextureSupport() const { return fCrossContextTextureSupport; }
Brian Salomon467921e2017-03-06 16:17:12 -0500320 /**
Greg Daniel25af6712018-04-25 10:44:38 -0400321 * Returns whether or not we will be able to do a copy given the passed in params
322 */
Brian Salomonc67c31c2018-12-06 10:00:03 -0500323 bool canCopySurface(const GrSurfaceProxy* dst, const GrSurfaceProxy* src,
324 const SkIRect& srcRect, const SkIPoint& dstPoint) const;
Greg Daniel25af6712018-04-25 10:44:38 -0400325
Brian Salomonf7232642018-09-19 08:58:08 -0400326 bool dynamicStateArrayGeometryProcessorTextureSupport() const {
327 return fDynamicStateArrayGeometryProcessorTextureSupport;
328 }
329
Michael Ludwigc39d0c82019-01-15 10:03:43 -0500330 // Not all backends support clearing with a scissor test (e.g. Metal), this will always
331 // return true if performColorClearsAsDraws() returns true.
Michael Ludwiga21d1962019-01-11 15:26:22 -0500332 bool performPartialClearsAsDraws() const {
Michael Ludwigc39d0c82019-01-15 10:03:43 -0500333 return fPerformColorClearsAsDraws || fPerformPartialClearsAsDraws;
Michael Ludwiga21d1962019-01-11 15:26:22 -0500334 }
335
336 // Many drivers have issues with color clears.
Chris Daltona8fbeba2019-03-30 00:31:23 -0600337 bool performColorClearsAsDraws() const { return fPerformColorClearsAsDraws; }
Michael Ludwiga21d1962019-01-11 15:26:22 -0500338
339 /// Adreno 4xx devices experience an issue when there are a large number of stencil clip bit
340 /// clears. The minimal repro steps are not precisely known but drawing a rect with a stencil
341 /// op instead of using glClear seems to resolve the issue.
Chris Daltona8fbeba2019-03-30 00:31:23 -0600342 bool performStencilClearsAsDraws() const { return fPerformStencilClearsAsDraws; }
343
344 // Can we use coverage counting shortcuts to render paths? Coverage counting can cause artifacts
345 // along shared edges if care isn't taken to ensure both contours wind in the same direction.
346 bool allowCoverageCounting() const { return fAllowCoverageCounting; }
347
348 // Should we disable the CCPR code due to a faulty driver?
349 bool driverBlacklistCCPR() const { return fDriverBlacklistCCPR; }
Ethan Nicholas56d19a52018-10-15 11:26:20 -0400350
Greg Daniel25af6712018-04-25 10:44:38 -0400351 /**
Brian Salomon467921e2017-03-06 16:17:12 -0500352 * This is can be called before allocating a texture to be a dst for copySurface. This is only
Robert Phillipsbf25d432017-04-07 10:08:53 -0400353 * used for doing dst copies needed in blends, thus the src is always a GrRenderTargetProxy. It
Brian Salomon2a4f9832018-03-03 22:43:43 -0500354 * will populate config and flags fields of the desc such that copySurface can efficiently
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400355 * succeed as well as the proxy origin. renderable will be set to kYes if the destination
356 * texture should be renderable in order to implement the copy as a draw. rectsMustMatch will be
357 * set to true if the copy operation must ensure that the src and dest rects are identical.
358 * disallowSubrect will be set to true if copy rect must equal src's bounds.
Brian Salomon467921e2017-03-06 16:17:12 -0500359 */
Robert Phillipsbf25d432017-04-07 10:08:53 -0400360 virtual bool initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* desc,
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400361 GrRenderable* renderable, bool* rectsMustMatch,
362 bool* disallowSubrect) const = 0;
Brian Salomon467921e2017-03-06 16:17:12 -0500363
Brian Salomonf2c2ba92019-07-17 09:59:59 -0400364 bool validateSurfaceDesc(const GrSurfaceDesc&, GrRenderable renderable, GrMipMapped) const;
Brian Salomonbdecacf2018-02-02 20:32:49 -0500365
Greg Danielf5d87582017-12-18 14:48:15 -0500366 /**
Brian Salomonf391d0f2018-12-14 09:18:50 -0500367 * If the GrBackendRenderTarget can be used with the supplied SkColorType the return will be
368 * the config that matches the backend format and requested SkColorType. Otherwise, kUnknown is
369 * returned.
Greg Danielf5d87582017-12-18 14:48:15 -0500370 */
Brian Salomonf391d0f2018-12-14 09:18:50 -0500371 virtual GrPixelConfig validateBackendRenderTarget(const GrBackendRenderTarget&,
Robert Phillips1e2cb442019-07-02 15:51:28 -0400372 GrColorType) const = 0;
Greg Danielf5d87582017-12-18 14:48:15 -0500373
Greg Daniel627d0532019-07-08 16:48:14 -0400374 bool areColorTypeAndFormatCompatible(GrColorType grCT,
Robert Phillips1e2cb442019-07-02 15:51:28 -0400375 const GrBackendFormat& format) const {
Robert Phillips1e2cb442019-07-02 15:51:28 -0400376 if (GrColorType::kUnknown == grCT) {
377 return false;
378 }
379
Greg Daniel627d0532019-07-08 16:48:14 -0400380 return this->onAreColorTypeAndFormatCompatible(grCT, format);
Robert Phillips1e2cb442019-07-02 15:51:28 -0400381 }
Robert Phillipsc046ff02019-07-01 10:34:03 -0400382
Brian Salomonf391d0f2018-12-14 09:18:50 -0500383 // TODO: replace validateBackendRenderTarget with calls to getConfigFromBackendFormat?
Robert Phillipsfc711a22018-02-13 17:03:00 -0500384 // TODO: it seems like we could pass the full SkImageInfo and validate its colorSpace too
Brian Salomonf391d0f2018-12-14 09:18:50 -0500385 // Returns kUnknown if a valid config could not be determined.
Greg Daniel627d0532019-07-08 16:48:14 -0400386 GrPixelConfig getConfigFromBackendFormat(const GrBackendFormat& format,
387 GrColorType grCT) const {
388 if (GrColorType::kUnknown == grCT) {
389 return kUnknown_GrPixelConfig;
390 }
391
392 return this->onGetConfigFromBackendFormat(format, grCT);
393 }
Robert Phillipsfc711a22018-02-13 17:03:00 -0500394
Jim Van Verthb7f0b9c2018-10-22 14:12:03 -0400395 /**
Brian Salomonf391d0f2018-12-14 09:18:50 -0500396 * Special method only for YUVA images. Returns a config that matches the backend format or
397 * kUnknown if a config could not be determined.
Jim Van Verth9bf81202018-10-30 15:53:36 -0400398 */
Robert Phillips97256382019-07-17 15:26:36 -0400399 virtual GrPixelConfig getYUVAConfigFromBackendFormat(const GrBackendFormat&) const = 0;
400 virtual GrColorType getYUVAColorTypeFromBackendFormat(const GrBackendFormat&) const = 0;
Jim Van Verth9bf81202018-10-30 15:53:36 -0400401
Brian Salomonf391d0f2018-12-14 09:18:50 -0500402 /** These are used when creating a new texture internally. */
Greg Daniele877dce2019-07-11 10:52:43 -0400403 virtual GrBackendFormat getBackendFormatFromColorType(GrColorType ct) const = 0;
Greg Daniel4065d452018-11-16 15:43:41 -0500404
Brian Salomonbb8dde82019-06-27 10:52:13 -0400405 virtual GrBackendFormat getBackendFormatFromCompressionType(SkImage::CompressionType) const = 0;
406
Timothy Liang036fdfe2018-06-28 15:50:36 -0400407 /**
Brian Salomona3e29962019-07-16 11:52:08 -0400408 * Used by implementation of shouldInitializeTextures(). Indicates whether GrGpu implements the
409 * clear in GrGpu::createTexture() or if false then the caller must provide cleared MIP level
410 * data or GrGpu::createTexture() will fail.
411 *
412 * TODO: Make this take a GrBackendFormat so that GL can make this faster for cases
413 * when the format is renderable and glTexClearImage is not available. Doing this
414 * is overly complicated until the GrPixelConfig/format mess is straightened out..
415 */
416 virtual bool canClearTextureOnCreation() const = 0;
417
418 /**
Michael Ludwigf23a1522018-12-10 11:36:13 -0500419 * The CLAMP_TO_BORDER wrap mode for texture coordinates was added to desktop GL in 1.3, and
420 * GLES 3.2, but is also available in extensions. Vulkan and Metal always have support.
421 */
422 bool clampToBorderSupport() const { return fClampToBorderSupport; }
423
Greg Danieleb4a8272019-05-16 16:52:55 -0400424 /**
425 * Returns the GrSwizzle to use when sampling from a texture with the passed in GrBackendFormat
426 * and GrColorType.
427 */
428 virtual GrSwizzle getTextureSwizzle(const GrBackendFormat&, GrColorType) const = 0;
429
430 /**
431 * Returns the GrSwizzle to use when outputting to a render target with the passed in
432 * GrBackendFormat and GrColorType.
433 */
434 virtual GrSwizzle getOutputSwizzle(const GrBackendFormat&, GrColorType) const = 0;
435
Adrienne Walker3ed33992018-05-15 11:44:34 -0700436 const GrDriverBugWorkarounds& workarounds() const { return fDriverBugWorkarounds; }
437
Brian Salomon947efe22019-07-16 15:36:11 -0400438 /**
439 * Given a possibly generic GrPixelConfig and a backend format return a specific
440 * GrPixelConfig.
441 */
442 GrPixelConfig makeConfigSpecific(GrPixelConfig config, const GrBackendFormat& format) const {
443 auto ct = GrPixelConfigToColorType(config);
444 auto result = this->getConfigFromBackendFormat(format, ct);
445 SkASSERT(config == result || AreConfigsCompatible(config, result));
446 return result;
447 }
448
Robert Phillips0902c982019-07-16 07:47:56 -0400449#ifdef SK_DEBUG
450 // This is just a debugging entry point until we're weaned off of GrPixelConfig. It
451 // should be used to verify that the pixel config from user-level code (the genericConfig)
452 // is compatible with a pixel config we've computed from scratch (the specificConfig).
453 static bool AreConfigsCompatible(GrPixelConfig genericConfig, GrPixelConfig specificConfig);
454#endif
455
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000456protected:
bsalomon4ee6bd82015-05-27 13:23:23 -0700457 /** Subclasses must call this at the end of their constructors in order to apply caps
458 overrides requested by the client. Note that overrides will only reduce the caps never
459 expand them. */
460 void applyOptionsOverrides(const GrContextOptions& options);
461
bungeman6bd52842016-10-27 09:30:08 -0700462 sk_sp<GrShaderCaps> fShaderCaps;
jvanverthe9c0fc62015-04-29 11:18:05 -0700463
joshualitt83bc2292015-06-18 14:18:02 -0700464 bool fNPOTTextureTileSupport : 1;
465 bool fMipMapSupport : 1;
brianosmana6359362016-03-21 06:55:37 -0700466 bool fSRGBSupport : 1;
brianosman35b784d2016-05-05 11:52:53 -0700467 bool fSRGBWriteControl : 1;
joshualitt83bc2292015-06-18 14:18:02 -0700468 bool fReuseScratchTextures : 1;
robertphillips1b8e1b52015-06-24 06:54:10 -0700469 bool fReuseScratchBuffers : 1;
joshualitt83bc2292015-06-18 14:18:02 -0700470 bool fGpuTracingSupport : 1;
joshualitt83bc2292015-06-18 14:18:02 -0700471 bool fOversizedStencilSupport : 1;
472 bool fTextureBarrierSupport : 1;
Robert Phillips7f861922018-01-30 13:13:42 +0000473 bool fSampleLocationsSupport : 1;
csmartdalton2b5f2cb2016-06-10 14:06:32 -0700474 bool fMultisampleDisableSupport : 1;
Chris Dalton1d616352017-05-31 12:51:23 -0600475 bool fInstanceAttribSupport : 1;
Chris Dalton6ce447a2019-06-23 18:07:38 -0600476 bool fMixedSamplesSupport : 1;
Chris Dalton27059d32018-01-23 14:06:50 -0700477 bool fUsePrimitiveRestart : 1;
csmartdalton485a1202016-07-13 10:16:32 -0700478 bool fPreferClientSideDynamicBuffers : 1;
Chris Dalton344e9032017-12-11 15:42:09 -0700479 bool fPreferFullscreenClears : 1;
bsalomon7dea7b72015-08-19 08:26:51 -0700480 bool fMustClearUploadedBufferData : 1;
Kevin Lubick61a5f0a2019-03-28 09:47:15 -0400481 bool fShouldInitializeTextures : 1;
Greg Danielb2acf0a2018-09-12 09:17:11 -0400482 bool fSupportsAHardwareBufferImages : 1;
Brian Osman499bf1a2018-09-17 11:32:42 -0400483 bool fHalfFloatVertexAttributeSupport : 1;
Michael Ludwigf23a1522018-12-10 11:36:13 -0500484 bool fClampToBorderSupport : 1;
Michael Ludwiga21d1962019-01-11 15:26:22 -0500485 bool fPerformPartialClearsAsDraws : 1;
486 bool fPerformColorClearsAsDraws : 1;
487 bool fPerformStencilClearsAsDraws : 1;
Chris Daltona8fbeba2019-03-30 00:31:23 -0600488 bool fAllowCoverageCounting : 1;
Brian Salomone05ba5a2019-04-08 11:59:07 -0400489 bool fTransferBufferSupport : 1;
Brian Salomon1047a492019-07-02 12:25:21 -0400490 bool fWritePixelsRowBytesSupport : 1;
491 bool fReadPixelsRowBytesSupport : 1;
robertphillips1b8e1b52015-06-24 06:54:10 -0700492
bsalomon63b21962014-11-05 07:05:34 -0800493 // Driver workaround
Chris Daltona8fbeba2019-03-30 00:31:23 -0600494 bool fDriverBlacklistCCPR : 1;
Eric Karl5c779752017-05-08 12:02:07 -0700495 bool fAvoidStencilBuffers : 1;
Greg Daniel4374e962018-09-28 15:09:47 -0400496 bool fAvoidWritePixelsFastPath : 1;
bsalomon63b21962014-11-05 07:05:34 -0800497
Brian Salomon01b476a2018-01-23 11:06:41 -0500498 // ANGLE performance workaround
robertphillips63926682015-08-20 09:39:02 -0700499 bool fPreferVRAMUseOverFlushes : 1;
500
Chris Dalton0dffbab2019-03-27 13:08:50 -0600501 // On some platforms it's better to make more triangles than to use the sample mask (MSAA only).
502 bool fPreferTrianglesOverSampleMask : 1;
503
jvanverth84741b32016-09-30 08:39:02 -0700504 bool fFenceSyncSupport : 1;
Brian Salomon9ff5acb2019-05-08 09:04:47 -0400505 bool fSemaphoreSupport : 1;
ethannicholas28ef4452016-03-25 09:26:03 -0700506
Brian Salomonf7232642018-09-19 08:58:08 -0400507 // Requires fence sync support in GL.
Brian Osman2c2bc112017-02-28 10:02:49 -0500508 bool fCrossContextTextureSupport : 1;
509
Brian Salomonf7232642018-09-19 08:58:08 -0400510 // Not (yet) implemented in VK backend.
511 bool fDynamicStateArrayGeometryProcessorTextureSupport : 1;
512
cdalton8917d622015-05-06 13:40:21 -0700513 BlendEquationSupport fBlendEquationSupport;
cdalton1dd05422015-06-12 09:01:18 -0700514 uint32_t fAdvBlendEqBlacklist;
515 GR_STATIC_ASSERT(kLast_GrBlendEquation < 32);
516
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000517 uint32_t fMapBufferFlags;
cdalton397536c2016-03-25 12:15:03 -0700518 int fBufferMapThreshold;
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000519
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000520 int fMaxRenderTargetSize;
Chris Dalton2612bae2018-02-22 13:41:37 -0700521 int fMaxPreferredRenderTargetSize;
bsalomon7dbd45d2016-03-23 10:40:53 -0700522 int fMaxVertexAttributes;
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000523 int fMaxTextureSize;
bsalomon8c07b7a2015-11-02 11:36:52 -0800524 int fMaxTileSize;
csmartdalton9bc11872016-08-09 12:42:47 -0700525 int fMaxWindowRectangles;
Chris Daltona1638a52019-06-24 11:54:24 -0600526 int fInternalMultisampleCount;
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000527
Adrienne Walker68314842018-05-14 14:02:53 -0700528 GrDriverBugWorkarounds fDriverBugWorkarounds;
529
egdanielbc127a32014-09-19 12:07:43 -0700530private:
Mike Kleinfc6c37b2016-09-27 09:34:10 -0400531 virtual void onApplyOptionsOverrides(const GrContextOptions&) {}
Brian Osman71a18892017-08-10 10:23:25 -0400532 virtual void onDumpJSON(SkJSONWriter*) const {}
Brian Salomonc67c31c2018-12-06 10:00:03 -0500533 virtual bool onSurfaceSupportsWritePixels(const GrSurface*) const = 0;
534 virtual bool onCanCopySurface(const GrSurfaceProxy* dst, const GrSurfaceProxy* src,
535 const SkIRect& srcRect, const SkIPoint& dstPoint) const = 0;
Brian Salomon26de56e2019-04-10 12:14:26 -0400536 virtual size_t onTransferFromOffsetAlignment(GrColorType bufferColorType) const = 0;
egdanielb7e7d572015-11-04 04:23:53 -0800537
Greg Daniel2a303902018-02-20 10:25:54 -0500538 // Backends should implement this if they have any extra requirements for use of window
539 // rectangles for a specific GrBackendRenderTarget outside of basic support.
540 virtual bool onIsWindowRectanglesSupportedForRT(const GrBackendRenderTarget&) const {
541 return true;
542 }
543
Greg Daniel627d0532019-07-08 16:48:14 -0400544 virtual GrPixelConfig onGetConfigFromBackendFormat(const GrBackendFormat& format,
545 GrColorType ct) const = 0;
546
547 virtual bool onAreColorTypeAndFormatCompatible(GrColorType, const GrBackendFormat&) const = 0;
548
549
robertphillipscaef3452015-11-11 13:18:11 -0800550 bool fSuppressPrints : 1;
Jim Van Verthfbdc0802017-05-02 16:15:53 -0400551 bool fWireframeMode : 1;
bsalomon682c2692015-05-22 14:01:46 -0700552
bsalomon@google.comc26d94f2013-03-25 18:19:00 +0000553 typedef SkRefCnt INHERITED;
554};
555
556#endif