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 "SkData.h"
12#include "SkTypes.h"
13#include "GrTypes.h"
14#include "../private/GrTypesPriv.h"
15
16#include <vector>
17
18class SkExecutor;
19
20struct GrContextOptions {
21    enum class Enable {
22        /** Forces an option to be disabled. */
23        kNo,
24        /** Forces an option to be enabled. */
25        kYes,
26        /**
27         * Uses Skia's default behavior, which may use runtime properties (e.g. driver version).
28         */
29        kDefault
30    };
31
32    /**
33     * Abstract class which stores Skia data in a cache that persists between sessions. Currently,
34     * Skia stores compiled shader binaries (only when glProgramBinary / glGetProgramBinary are
35     * supported) when provided a persistent cache, but this may extend to other data in the future.
36     */
37    class PersistentCache {
38    public:
39        virtual ~PersistentCache() {}
40
41        /**
42         * Returns the data for the key if it exists in the cache, otherwise returns null.
43         */
44        virtual sk_sp<SkData> load(const SkData& key) = 0;
45
46        virtual void store(const SkData& key, const SkData& data) = 0;
47    };
48
49    GrContextOptions() {}
50
51    // Suppress prints for the GrContext.
52    bool fSuppressPrints = false;
53
54    /** Overrides: These options override feature detection using backend API queries. These
55        overrides can only reduce the feature set or limits, never increase them beyond the
56        detected values. */
57
58    int  fMaxTextureSizeOverride = SK_MaxS32;
59
60    /** the threshold in bytes above which we will use a buffer mapping API to map vertex and index
61        buffers to CPU memory in order to update them.  A value of -1 means the GrContext should
62        deduce the optimal value for this platform. */
63    int  fBufferMapThreshold = -1;
64
65    /**
66     * Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be
67     * done serially on the main thread. To have worker threads assist with various tasks, set this
68     * to a valid SkExecutor instance. Currently, used for software path rendering, but may be used
69     * for other tasks.
70     */
71    SkExecutor* fExecutor = nullptr;
72
73    /** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when
74        the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap
75        level and LOD control (ie desktop or ES3). */
76    bool fDoManualMipmapping = false;
77
78    /**
79     * Disables distance field rendering for paths. Distance field computation can be expensive,
80     * and yields no benefit if a path is not rendered multiple times with different transforms.
81     */
82    bool fDisableDistanceFieldPaths = false;
83
84    /**
85     * If true this allows path mask textures to be cached. This is only really useful if paths
86     * are commonly rendered at the same scale and fractional translation.
87     */
88    bool fAllowPathMaskCaching = true;
89
90    /**
91     * If true, sRGB support will not be enabled unless sRGB decoding can be disabled (via an
92     * extension). If mixed use of "legacy" mode and sRGB/color-correct mode is not required, this
93     * can be set to false, which will significantly expand the number of devices that qualify for
94     * sRGB support.
95     */
96    bool fRequireDecodeDisableForSRGB = true;
97
98    /**
99     * If true, the GPU will not be used to perform YUV -> RGB conversion when generating
100     * textures from codec-backed images.
101     */
102    bool fDisableGpuYUVConversion = false;
103
104    /**
105     * The maximum size of cache textures used for Skia's Glyph cache.
106     */
107    float fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4;
108
109    /**
110     * Below this threshold size in device space distance field fonts won't be used. Distance field
111     * fonts don't support hinting which is more important at smaller sizes. A negative value means
112     * use the default threshold.
113     */
114    float fMinDistanceFieldFontSize = -1.f;
115
116    /**
117     * Above this threshold size in device space glyphs are drawn as individual paths. A negative
118     * value means use the default threshold.
119     */
120    float fGlyphsAsPathsFontSize = -1.f;
121
122    /**
123     * Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by
124     * fGlypheCacheTextureMaximumBytes.
125     */
126    Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault;
127
128    /**
129     * Bugs on certain drivers cause stencil buffers to leak. This flag causes Skia to avoid
130     * allocating stencil buffers and use alternate rasterization paths, avoiding the leak.
131     */
132    bool fAvoidStencilBuffers = false;
133
134    /**
135     * When specifing new data for a vertex/index buffer that replaces old data Ganesh can give
136     * a hint to the driver that the previous data will not be used in future draws like this:
137     *  glBufferData(GL_..._BUFFER, size, NULL, usage);       //<--hint, NULL means
138     *  glBufferSubData(GL_..._BUFFER, 0, lessThanSize, data) //   old data can't be
139     *                                                        //   used again.
140     * However, this can be an unoptimization on some platforms, esp. Chrome.
141     * Chrome's cmd buffer will create a new allocation and memset the whole thing
142     * to zero (for security reasons).
143     * Defaults to the value of GR_GL_USE_BUFFER_DATA_NULL_HINT #define (which is, by default, 1).
144     */
145    Enable fUseGLBufferDataNullHint = Enable::kDefault;
146
147    /**
148     * If true, texture fetches from mip-mapped textures will be biased to read larger MIP levels.
149     * This has the effect of sharpening those textures, at the cost of some aliasing, and possible
150     * performance impact.
151     */
152    bool fSharpenMipmappedTextures = false;
153
154    /**
155     * Enables driver workaround to use draws instead of glClear. This only applies to
156     * kOpenGL_GrBackend.
157     */
158    Enable fUseDrawInsteadOfGLClear = Enable::kDefault;
159
160    /**
161     * Allow Ganesh to explicitly allocate resources at flush time rather than incrementally while
162     * drawing. This will eventually just be the way it is but, for now, it is optional.
163     */
164    Enable fExplicitlyAllocateGPUResources = Enable::kDefault;
165
166    /**
167     * Allow Ganesh to sort the opLists prior to allocating resources. This is an optional
168     * behavior that is only relevant when 'fExplicitlyAllocateGPUResources' is enabled.
169     * Eventually this will just be what is done and will not be optional.
170     */
171    Enable fSortRenderTargets = Enable::kDefault;
172
173    /**
174     * Disables correctness workarounds that are enabled for particular GPUs, OSes, or drivers.
175     * This does not affect code path choices that are made for perfomance reasons nor does it
176     * override other GrContextOption settings.
177     */
178    bool fDisableDriverCorrectnessWorkarounds = false;
179
180    /**
181     * Cache in which to store compiled shader binaries between runs.
182     */
183    PersistentCache* fPersistentCache = nullptr;
184
185#if GR_TEST_UTILS
186    /**
187     * Private options that are only meant for testing within Skia's tools.
188     */
189
190    /**
191     * If non-zero, overrides the maximum size of a tile for sw-backed images and bitmaps rendered
192     * by SkGpuDevice.
193     */
194    int  fMaxTileSizeOverride = 0;
195
196    /**
197     * Prevents use of dual source blending, to test that all xfer modes work correctly without it.
198     */
199    bool fSuppressDualSourceBlending = false;
200
201    /**
202     * If true, the caps will never report driver support for path rendering.
203     */
204    bool fSuppressPathRendering = false;
205
206    /**
207     * If true, the caps will never support geometry shaders.
208     */
209    bool fSuppressGeometryShaders = false;
210
211    /**
212     * Render everything in wireframe
213     */
214    bool fWireframeMode = false;
215
216    /**
217     * Include or exclude specific GPU path renderers.
218     */
219    GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault;
220
221    /**
222     * Disables using multiple texture units to batch multiple images into a single draw on
223     * supported GPUs.
224     */
225    bool fDisableImageMultitexturing = false;
226#endif
227
228#if SK_SUPPORT_ATLAS_TEXT
229    /**
230     * Controls whether distance field glyph vertices always have 3 components even when the view
231     * matrix does not have perspective.
232     */
233    Enable fDistanceFieldGlyphVerticesAlwaysHaveW = Enable::kDefault;
234#endif
235};
236
237#endif
238