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