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/SkTypes.h" 13 #include "include/gpu/GrDriverBugWorkarounds.h" 14 #include "include/gpu/GrTypes.h" 15 #include "include/private/GrTypesPriv.h" 16 17 #include <vector> 18 19 class SkExecutor; 20 21 #if SK_SUPPORT_GPU 22 struct SK_API GrContextOptions { 23 enum class Enable { 24 /** Forces an option to be disabled. */ 25 kNo, 26 /** Forces an option to be enabled. */ 27 kYes, 28 /** 29 * Uses Skia's default behavior, which may use runtime properties (e.g. driver version). 30 */ 31 kDefault 32 }; 33 34 enum class ShaderCacheStrategy { 35 kSkSL, 36 kBackendSource, 37 kBackendBinary, 38 }; 39 40 /** 41 * Abstract class which stores Skia data in a cache that persists between sessions. Currently, 42 * Skia stores compiled shader binaries (only when glProgramBinary / glGetProgramBinary are 43 * supported) when provided a persistent cache, but this may extend to other data in the future. 44 */ 45 class SK_API PersistentCache { 46 public: ~PersistentCacheGrContextOptions47 virtual ~PersistentCache() {} 48 49 /** 50 * Returns the data for the key if it exists in the cache, otherwise returns null. 51 */ 52 virtual sk_sp<SkData> load(const SkData& key) = 0; 53 54 virtual void store(const SkData& key, const SkData& data) = 0; 55 }; 56 57 /** 58 * Abstract class to report errors when compiling shaders. If fShaderErrorHandler is present, 59 * it will be called to report any compilation failures. Otherwise, failures will be reported 60 * via SkDebugf and asserts. 61 */ 62 class SK_API ShaderErrorHandler { 63 public: ~ShaderErrorHandlerGrContextOptions64 virtual ~ShaderErrorHandler() {} 65 virtual void compileError(const char* shader, const char* errors) = 0; 66 }; 67 GrContextOptionsGrContextOptions68 GrContextOptions() {} 69 70 // Suppress prints for the GrContext. 71 bool fSuppressPrints = false; 72 73 /** Overrides: These options override feature detection using backend API queries. These 74 overrides can only reduce the feature set or limits, never increase them beyond the 75 detected values. */ 76 77 int fMaxTextureSizeOverride = SK_MaxS32; 78 79 /** the threshold in bytes above which we will use a buffer mapping API to map vertex and index 80 buffers to CPU memory in order to update them. A value of -1 means the GrContext should 81 deduce the optimal value for this platform. */ 82 int fBufferMapThreshold = -1; 83 84 /** 85 * Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be 86 * done serially on the main thread. To have worker threads assist with various tasks, set this 87 * to a valid SkExecutor instance. Currently, used for software path rendering, but may be used 88 * for other tasks. 89 */ 90 SkExecutor* fExecutor = nullptr; 91 92 /** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when 93 the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap 94 level and LOD control (ie desktop or ES3). */ 95 bool fDoManualMipmapping = false; 96 97 /** 98 * Disables the use of coverage counting shortcuts to render paths. Coverage counting can cause 99 * artifacts along shared edges if care isn't taken to ensure both contours wind in the same 100 * direction. 101 */ 102 // FIXME: Once this is removed from Chrome and Android, rename to fEnable"". 103 bool fDisableCoverageCountingPaths = true; 104 105 /** 106 * Disables distance field rendering for paths. Distance field computation can be expensive, 107 * and yields no benefit if a path is not rendered multiple times with different transforms. 108 */ 109 bool fDisableDistanceFieldPaths = false; 110 111 /** 112 * If true this allows path mask textures to be cached. This is only really useful if paths 113 * are commonly rendered at the same scale and fractional translation. 114 */ 115 bool fAllowPathMaskCaching = true; 116 117 /** 118 * If true, the GPU will not be used to perform YUV -> RGB conversion when generating 119 * textures from codec-backed images. 120 */ 121 bool fDisableGpuYUVConversion = false; 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 * Below this threshold size in device space distance field fonts won't be used. Distance field 130 * fonts don't support hinting which is more important at smaller sizes. A negative value means 131 * use the default threshold. 132 */ 133 float fMinDistanceFieldFontSize = -1.f; 134 135 /** 136 * Above this threshold size in device space glyphs are drawn as individual paths. A negative 137 * value means use the default threshold. 138 */ 139 float fGlyphsAsPathsFontSize = -1.f; 140 141 /** 142 * Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by 143 * fGlypheCacheTextureMaximumBytes. 144 */ 145 Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault; 146 147 /** 148 * Bugs on certain drivers cause stencil buffers to leak. This flag causes Skia to avoid 149 * allocating stencil buffers and use alternate rasterization paths, avoiding the leak. 150 */ 151 bool fAvoidStencilBuffers = false; 152 153 /** 154 * If true, texture fetches from mip-mapped textures will be biased to read larger MIP levels. 155 * This has the effect of sharpening those textures, at the cost of some aliasing, and possible 156 * performance impact. 157 */ 158 bool fSharpenMipmappedTextures = false; 159 160 /** 161 * Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend. 162 */ 163 Enable fUseDrawInsteadOfClear = Enable::kDefault; 164 165 /** 166 * Allow Ganesh to more aggressively reorder operations. 167 * Eventually this will just be what is done and will not be optional. 168 */ 169 Enable fReduceOpsTaskSplitting = Enable::kDefault; 170 171 /** 172 * Some ES3 contexts report the ES2 external image extension, but not the ES3 version. 173 * If support for external images is critical, enabling this option will cause Ganesh to limit 174 * shaders to the ES2 shading language in that situation. 175 */ 176 bool fPreferExternalImagesOverES3 = false; 177 178 /** 179 * Disables correctness workarounds that are enabled for particular GPUs, OSes, or drivers. 180 * This does not affect code path choices that are made for perfomance reasons nor does it 181 * override other GrContextOption settings. 182 */ 183 bool fDisableDriverCorrectnessWorkarounds = false; 184 185 /** 186 * Maximum number of GPU programs or pipelines to keep active in the runtime cache. 187 */ 188 int fRuntimeProgramCacheSize = 256; 189 190 /** 191 * Cache in which to store compiled shader binaries between runs. 192 */ 193 PersistentCache* fPersistentCache = nullptr; 194 195 /** 196 * This affects the usage of the PersistentCache. We can cache SkSL, backend source (GLSL), or 197 * backend binaries (GL program binaries). By default we cache binaries, but if the driver's 198 * binary loading/storing is believed to have bugs, this can be limited to caching GLSL. 199 * Caching GLSL strings still saves CPU work when a GL program is created. 200 */ 201 ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary; 202 203 /** 204 * If present, use this object to report shader compilation failures. If not, report failures 205 * via SkDebugf and assert. 206 */ 207 ShaderErrorHandler* fShaderErrorHandler = nullptr; 208 209 /** 210 * Specifies the number of samples Ganesh should use when performing internal draws with MSAA or 211 * mixed samples (hardware capabilities permitting). 212 * 213 * If 0, Ganesh will disable internal code paths that use multisampling. 214 */ 215 int fInternalMultisampleCount = 4; 216 217 #if GR_TEST_UTILS 218 /** 219 * Private options that are only meant for testing within Skia's tools. 220 */ 221 222 /** 223 * If non-zero, overrides the maximum size of a tile for sw-backed images and bitmaps rendered 224 * by SkGpuDevice. 225 */ 226 int fMaxTileSizeOverride = 0; 227 228 /** 229 * Prevents use of dual source blending, to test that all xfer modes work correctly without it. 230 */ 231 bool fSuppressDualSourceBlending = false; 232 233 /** 234 * If true, the caps will never support geometry shaders. 235 */ 236 bool fSuppressGeometryShaders = false; 237 238 /** 239 * Render everything in wireframe 240 */ 241 bool fWireframeMode = false; 242 243 /** 244 * Enforces clearing of all textures when they're created. 245 */ 246 bool fClearAllTextures = false; 247 248 /** 249 * Include or exclude specific GPU path renderers. 250 */ 251 GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kAll; 252 #endif 253 254 #if SK_SUPPORT_ATLAS_TEXT 255 /** 256 * Controls whether distance field glyph vertices always have 3 components even when the view 257 * matrix does not have perspective. 258 */ 259 Enable fDistanceFieldGlyphVerticesAlwaysHaveW = Enable::kDefault; 260 #endif 261 262 GrDriverBugWorkarounds fDriverBugWorkarounds; 263 }; 264 #else 265 struct GrContextOptions { 266 struct PersistentCache {}; 267 }; 268 #endif 269 270 #endif 271