1 /* 2 * Copyright 2015 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef GrContextOptions_DEFINED 9 #define GrContextOptions_DEFINED 10 11 #include "include/core/SkData.h" 12 #include "include/core/SkString.h" 13 #include "include/core/SkTypes.h" 14 #include "include/gpu/GrDriverBugWorkarounds.h" 15 #include "include/gpu/GrTypes.h" 16 #include "include/gpu/ShaderErrorHandler.h" 17 #include "include/private/gpu/ganesh/GrTypesPriv.h" 18 19 #include <vector> 20 21 class SkExecutor; 22 23 #if defined(SK_GANESH) 24 struct SK_API GrContextOptions { 25 enum class Enable { 26 /** Forces an option to be disabled. */ 27 kNo, 28 /** Forces an option to be enabled. */ 29 kYes, 30 /** 31 * Uses Skia's default behavior, which may use runtime properties (e.g. driver version). 32 */ 33 kDefault 34 }; 35 36 enum class ShaderCacheStrategy { 37 kSkSL, 38 kBackendSource, 39 kBackendBinary, 40 }; 41 42 /** 43 * Abstract class which stores Skia data in a cache that persists between sessions. Currently, 44 * Skia stores compiled shader binaries (only when glProgramBinary / glGetProgramBinary are 45 * supported) when provided a persistent cache, but this may extend to other data in the future. 46 */ 47 class SK_API PersistentCache { 48 public: 49 virtual ~PersistentCache() = default; 50 51 /** 52 * Returns the data for the key if it exists in the cache, otherwise returns null. 53 */ 54 virtual sk_sp<SkData> load(const SkData& key) = 0; 55 56 // Placeholder until all clients override the 3-parameter store(), then remove this, and 57 // make that version pure virtual. storeGrContextOptions58 virtual void store(const SkData& /*key*/, const SkData& /*data*/) { SkASSERT(false); } 59 60 /** 61 * Stores data in the cache, indexed by key. description provides a human-readable 62 * version of the key. 63 */ storeGrContextOptions64 virtual void store(const SkData& key, const SkData& data, const SkString& /*description*/) { 65 this->store(key, data); 66 } 67 68 protected: 69 PersistentCache() = default; 70 PersistentCache(const PersistentCache&) = delete; 71 PersistentCache& operator=(const PersistentCache&) = delete; 72 }; 73 74 using ShaderErrorHandler = skgpu::ShaderErrorHandler; 75 GrContextOptionsGrContextOptions76 GrContextOptions() {} 77 78 // Suppress prints for the GrContext. 79 bool fSuppressPrints = false; 80 81 /** 82 * Controls whether we check for GL errors after functions that allocate resources (e.g. 83 * glTexImage2D), at the end of a GPU submission, or checking framebuffer completeness. The 84 * results of shader compilation and program linking are always checked, regardless of this 85 * option. Ignored on backends other than GL. 86 */ 87 Enable fSkipGLErrorChecks = Enable::kDefault; 88 89 /** Overrides: These options override feature detection using backend API queries. These 90 overrides can only reduce the feature set or limits, never increase them beyond the 91 detected values. */ 92 93 int fMaxTextureSizeOverride = SK_MaxS32; 94 95 /** the threshold in bytes above which we will use a buffer mapping API to map vertex and index 96 buffers to CPU memory in order to update them. A value of -1 means the GrContext should 97 deduce the optimal value for this platform. */ 98 int fBufferMapThreshold = -1; 99 100 /** 101 * Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be 102 * done serially on the main thread. To have worker threads assist with various tasks, set this 103 * to a valid SkExecutor instance. Currently, used for software path rendering, but may be used 104 * for other tasks. 105 */ 106 SkExecutor* fExecutor = nullptr; 107 108 /** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when 109 the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap 110 level control (ie desktop or ES3). */ 111 bool fDoManualMipmapping = false; 112 113 /** 114 * Disables the use of coverage counting shortcuts to render paths. Coverage counting can cause 115 * artifacts along shared edges if care isn't taken to ensure both contours wind in the same 116 * direction. 117 */ 118 // FIXME: Once this is removed from Chrome and Android, rename to fEnable"". 119 bool fDisableCoverageCountingPaths = true; 120 121 /** 122 * Disables distance field rendering for paths. Distance field computation can be expensive, 123 * and yields no benefit if a path is not rendered multiple times with different transforms. 124 */ 125 bool fDisableDistanceFieldPaths = false; 126 127 /** 128 * If true this allows path mask textures to be cached. This is only really useful if paths 129 * are commonly rendered at the same scale and fractional translation. 130 */ 131 bool fAllowPathMaskCaching = true; 132 133 /** 134 * If true, the GPU will not be used to perform YUV -> RGB conversion when generating 135 * textures from codec-backed images. 136 */ 137 bool fDisableGpuYUVConversion = false; 138 139 /** 140 * The maximum size of cache textures used for Skia's Glyph cache. 141 */ 142 size_t fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4; 143 144 /** 145 * Below this threshold size in device space distance field fonts won't be used. Distance field 146 * fonts don't support hinting which is more important at smaller sizes. 147 */ 148 float fMinDistanceFieldFontSize = 18; 149 150 /** 151 * Above this threshold size in device space glyphs are drawn as individual paths. 152 */ 153 #if defined(SK_BUILD_FOR_ANDROID) 154 float fGlyphsAsPathsFontSize = 384; 155 #elif defined(SK_BUILD_FOR_MAC) 156 float fGlyphsAsPathsFontSize = 256; 157 #else 158 float fGlyphsAsPathsFontSize = 324; 159 #endif 160 161 /** 162 * Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by 163 * fGlypheCacheTextureMaximumBytes. 164 */ 165 Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault; 166 167 /** 168 * Bugs on certain drivers cause stencil buffers to leak. This flag causes Skia to avoid 169 * allocating stencil buffers and use alternate rasterization paths, avoiding the leak. 170 */ 171 bool fAvoidStencilBuffers = false; 172 173 /** 174 * Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend. 175 */ 176 Enable fUseDrawInsteadOfClear = Enable::kDefault; 177 178 /** 179 * Allow Ganesh to more aggressively reorder operations to reduce the number of render passes. 180 * Offscreen draws will be done upfront instead of interrupting the main render pass when 181 * possible. May increase VRAM usage, but still observes the resource cache limit. 182 * Enabled by default. 183 */ 184 Enable fReduceOpsTaskSplitting = Enable::kDefault; 185 186 /** 187 * Some ES3 contexts report the ES2 external image extension, but not the ES3 version. 188 * If support for external images is critical, enabling this option will cause Ganesh to limit 189 * shaders to the ES2 shading language in that situation. 190 */ 191 bool fPreferExternalImagesOverES3 = false; 192 193 /** 194 * Disables correctness workarounds that are enabled for particular GPUs, OSes, or drivers. 195 * This does not affect code path choices that are made for perfomance reasons nor does it 196 * override other GrContextOption settings. 197 */ 198 bool fDisableDriverCorrectnessWorkarounds = false; 199 200 /** 201 * Maximum number of GPU programs or pipelines to keep active in the runtime cache. 202 */ 203 int fRuntimeProgramCacheSize = 256; 204 205 /** 206 * Cache in which to store compiled shader binaries between runs. 207 */ 208 PersistentCache* fPersistentCache = nullptr; 209 210 /** 211 * This affects the usage of the PersistentCache. We can cache SkSL, backend source (GLSL), or 212 * backend binaries (GL program binaries). By default we cache binaries, but if the driver's 213 * binary loading/storing is believed to have bugs, this can be limited to caching GLSL. 214 * Caching GLSL strings still saves CPU work when a GL program is created. 215 */ 216 ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary; 217 218 /** 219 * If present, use this object to report shader compilation failures. If not, report failures 220 * via SkDebugf and assert. 221 */ 222 ShaderErrorHandler* fShaderErrorHandler = nullptr; 223 224 /** 225 * Specifies the number of samples Ganesh should use when performing internal draws with MSAA 226 * (hardware capabilities permitting). 227 * 228 * If 0, Ganesh will disable internal code paths that use multisampling. 229 */ 230 int fInternalMultisampleCount = 4; 231 232 /** 233 * In Skia's vulkan backend a single GrContext submit equates to the submission of a single 234 * primary command buffer to the VkQueue. This value specifies how many vulkan secondary command 235 * buffers we will cache for reuse on a given primary command buffer. A single submit may use 236 * more than this many secondary command buffers, but after the primary command buffer is 237 * finished on the GPU it will only hold on to this many secondary command buffers for reuse. 238 * 239 * A value of -1 means we will pick a limit value internally. 240 */ 241 int fMaxCachedVulkanSecondaryCommandBuffers = -1; 242 243 /** 244 * If true, the caps will never support mipmaps. 245 */ 246 bool fSuppressMipmapSupport = false; 247 248 /** 249 * If true, the TessellationPathRenderer will not be used for path rendering. 250 * If false, will fallback to any driver workarounds, if set. 251 */ 252 bool fDisableTessellationPathRenderer = false; 253 254 /** 255 * If true, and if supported, enables hardware tessellation in the caps. 256 * DEPRECATED: This value is ignored; experimental hardware tessellation is always disabled. 257 */ 258 bool fEnableExperimentalHardwareTessellation = false; 259 260 /** 261 * If true, then add 1 pixel padding to all glyph masks in the atlas to support bi-lerp 262 * rendering of all glyphs. This must be set to true to use Slugs. 263 */ 264 #if defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG) || \ 265 defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_SERIALIZE) || \ 266 defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_STRIKE_SERIALIZE) 267 bool fSupportBilerpFromGlyphAtlas = true; 268 #else 269 bool fSupportBilerpFromGlyphAtlas = false; 270 #endif 271 272 /** 273 * Uses a reduced variety of shaders. May perform less optimally in steady state but can reduce 274 * jank due to shader compilations. 275 */ 276 bool fReducedShaderVariations = false; 277 278 /** 279 * If true, then allow to enable MSAA on new Intel GPUs. 280 */ 281 bool fAllowMSAAOnNewIntel = false; 282 283 /** 284 * Currently on ARM Android we disable the use of GL TexStorage because of memory regressions. 285 * However, some clients may still want to use TexStorage. For example, TexStorage support is 286 * required for creating protected textures. 287 * 288 * This flag has no impact on non GL backends. 289 */ 290 bool fAlwaysUseTexStorageWhenAvailable = false; 291 292 /** 293 * Optional callback that can be passed into the GrDirectContext which will be called when the 294 * GrDirectContext is about to be destroyed. When this call is made, it will be safe for the 295 * client to delete the GPU backend context that is backing the GrDirectContext. The 296 * GrDirectContextDestroyedContext will be passed back to the client in the callback. 297 */ 298 GrDirectContextDestroyedContext fContextDeleteContext = nullptr; 299 GrDirectContextDestroyedProc fContextDeleteProc = nullptr; 300 301 #if GR_TEST_UTILS 302 /** 303 * Private options that are only meant for testing within Skia's tools. 304 */ 305 306 /** 307 * Testing-only mode to exercise allocation failures in the flush-time callback objects. 308 * For now it only simulates allocation failure during the preFlush callback. 309 */ 310 bool fFailFlushTimeCallbacks = false; 311 312 /** 313 * Prevents use of dual source blending, to test that all xfer modes work correctly without it. 314 */ 315 bool fSuppressDualSourceBlending = false; 316 317 /** 318 * Prevents the use of non-coefficient-based blend equations, for testing dst reads, barriers, 319 * and in-shader blending. 320 */ 321 bool fSuppressAdvancedBlendEquations = false; 322 323 /** 324 * Prevents the use of framebuffer fetches, for testing dst reads and texture barriers. 325 */ 326 bool fSuppressFramebufferFetch = false; 327 328 /** 329 * If true, then all paths are processed as if "setIsVolatile" had been called. 330 */ 331 bool fAllPathsVolatile = false; 332 333 /** 334 * Render everything in wireframe 335 */ 336 bool fWireframeMode = false; 337 338 /** 339 * Enforces clearing of all textures when they're created. 340 */ 341 bool fClearAllTextures = false; 342 343 /** 344 * Randomly generate a (false) GL_OUT_OF_MEMORY error 345 */ 346 bool fRandomGLOOM = false; 347 348 /** 349 * Force off support for write/transfer pixels row bytes in caps. 350 */ 351 bool fDisallowWriteAndTransferPixelRowBytes = false; 352 353 /** 354 * Include or exclude specific GPU path renderers. 355 */ 356 GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault; 357 358 /** 359 * Specify the GPU resource cache limit. Equivalent to calling `setResourceCacheLimit` on the 360 * context at construction time. 361 * 362 * A value of -1 means use the default limit value. 363 */ 364 int fResourceCacheLimitOverride = -1; 365 366 /** 367 * Maximum width and height of internal texture atlases. 368 */ 369 int fMaxTextureAtlasSize = 2048; 370 #endif 371 372 GrDriverBugWorkarounds fDriverBugWorkarounds; 373 }; 374 #else 375 struct GrContextOptions { 376 struct PersistentCache {}; 377 }; 378 #endif 379 380 #endif 381