0b04b6b16f
This reverts commit9a2d3d1e19
. Reason for revert: relanding with fix Original change's description: > Revert "Fix texture barriers on DMSAA" > > This reverts commit1a3f4ab490
. > > Reason for revert: breaking dmsaa test on intel hd405, https://ci.chromium.org/raw/build/logs.chromium.org/skia/54538c41f1c1b111/+/annotations > > Original change's description: > > Fix texture barriers on DMSAA > > > > Bug: skia:11396 > > Change-Id: Iad74958c05ed086fe85656b9dc5418d5ab4589e7 > > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/419838 > > Commit-Queue: Greg Daniel <egdaniel@google.com> > > Reviewed-by: Chris Dalton <csmartdalton@google.com> > > Reviewed-by: Brian Salomon <bsalomon@google.com> > > TBR=egdaniel@google.com,bsalomon@google.com,csmartdalton@google.com > > Change-Id: I8be8107a98584dfb7f831a296078753fecfcebcf > No-Presubmit: true > No-Tree-Checks: true > No-Try: true > Bug: skia:11396 > Reviewed-on: https://skia-review.googlesource.com/c/skia/+/421056 > Reviewed-by: Greg Daniel <egdaniel@google.com> > Commit-Queue: Greg Daniel <egdaniel@google.com> # Not skipping CQ checks because this is a reland. Bug: skia:11396 Change-Id: I6c65a3639e87b32a30774f33445bb3174a4fdffa Reviewed-on: https://skia-review.googlesource.com/c/skia/+/421058 Reviewed-by: Chris Dalton <csmartdalton@google.com> Commit-Queue: Greg Daniel <egdaniel@google.com>
375 lines
13 KiB
C++
375 lines
13 KiB
C++
/*
|
|
* Copyright 2015 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#ifndef GrContextOptions_DEFINED
|
|
#define GrContextOptions_DEFINED
|
|
|
|
#include "include/core/SkData.h"
|
|
#include "include/core/SkString.h"
|
|
#include "include/core/SkTypes.h"
|
|
#include "include/gpu/GrDriverBugWorkarounds.h"
|
|
#include "include/gpu/GrTypes.h"
|
|
#include "include/private/GrTypesPriv.h"
|
|
|
|
#include <vector>
|
|
|
|
class SkExecutor;
|
|
|
|
#if SK_SUPPORT_GPU
|
|
struct SK_API GrContextOptions {
|
|
enum class Enable {
|
|
/** Forces an option to be disabled. */
|
|
kNo,
|
|
/** Forces an option to be enabled. */
|
|
kYes,
|
|
/**
|
|
* Uses Skia's default behavior, which may use runtime properties (e.g. driver version).
|
|
*/
|
|
kDefault
|
|
};
|
|
|
|
enum class ShaderCacheStrategy {
|
|
kSkSL,
|
|
kBackendSource,
|
|
kBackendBinary,
|
|
};
|
|
|
|
/**
|
|
* Abstract class which stores Skia data in a cache that persists between sessions. Currently,
|
|
* Skia stores compiled shader binaries (only when glProgramBinary / glGetProgramBinary are
|
|
* supported) when provided a persistent cache, but this may extend to other data in the future.
|
|
*/
|
|
class SK_API PersistentCache {
|
|
public:
|
|
virtual ~PersistentCache() = default;
|
|
|
|
/**
|
|
* Returns the data for the key if it exists in the cache, otherwise returns null.
|
|
*/
|
|
virtual sk_sp<SkData> load(const SkData& key) = 0;
|
|
|
|
// Placeholder until all clients override the 3-parameter store(), then remove this, and
|
|
// make that version pure virtual.
|
|
virtual void store(const SkData& /*key*/, const SkData& /*data*/) { SkASSERT(false); }
|
|
|
|
/**
|
|
* Stores data in the cache, indexed by key. description provides a human-readable
|
|
* version of the key.
|
|
*/
|
|
virtual void store(const SkData& key, const SkData& data, const SkString& /*description*/) {
|
|
this->store(key, data);
|
|
}
|
|
|
|
protected:
|
|
PersistentCache() = default;
|
|
PersistentCache(const PersistentCache&) = delete;
|
|
PersistentCache& operator=(const PersistentCache&) = delete;
|
|
};
|
|
|
|
/**
|
|
* Abstract class to report errors when compiling shaders. If fShaderErrorHandler is present,
|
|
* it will be called to report any compilation failures. Otherwise, failures will be reported
|
|
* via SkDebugf and asserts.
|
|
*/
|
|
class SK_API ShaderErrorHandler {
|
|
public:
|
|
virtual ~ShaderErrorHandler() = default;
|
|
|
|
virtual void compileError(const char* shader, const char* errors) = 0;
|
|
|
|
protected:
|
|
ShaderErrorHandler() = default;
|
|
ShaderErrorHandler(const ShaderErrorHandler&) = delete;
|
|
ShaderErrorHandler& operator=(const ShaderErrorHandler&) = delete;
|
|
};
|
|
|
|
GrContextOptions() {}
|
|
|
|
// Suppress prints for the GrContext.
|
|
bool fSuppressPrints = false;
|
|
|
|
/**
|
|
* Controls whether we check for GL errors after functions that allocate resources (e.g.
|
|
* glTexImage2D), for shader compilation success, and program link success. Ignored on
|
|
* backends other than GL.
|
|
*/
|
|
Enable fSkipGLErrorChecks = Enable::kDefault;
|
|
|
|
/** Overrides: These options override feature detection using backend API queries. These
|
|
overrides can only reduce the feature set or limits, never increase them beyond the
|
|
detected values. */
|
|
|
|
int fMaxTextureSizeOverride = SK_MaxS32;
|
|
|
|
/** the threshold in bytes above which we will use a buffer mapping API to map vertex and index
|
|
buffers to CPU memory in order to update them. A value of -1 means the GrContext should
|
|
deduce the optimal value for this platform. */
|
|
int fBufferMapThreshold = -1;
|
|
|
|
/**
|
|
* Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be
|
|
* done serially on the main thread. To have worker threads assist with various tasks, set this
|
|
* to a valid SkExecutor instance. Currently, used for software path rendering, but may be used
|
|
* for other tasks.
|
|
*/
|
|
SkExecutor* fExecutor = nullptr;
|
|
|
|
/** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when
|
|
the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap
|
|
level control (ie desktop or ES3). */
|
|
bool fDoManualMipmapping = false;
|
|
|
|
/**
|
|
* Disables the use of coverage counting shortcuts to render paths. Coverage counting can cause
|
|
* artifacts along shared edges if care isn't taken to ensure both contours wind in the same
|
|
* direction.
|
|
*/
|
|
// FIXME: Once this is removed from Chrome and Android, rename to fEnable"".
|
|
bool fDisableCoverageCountingPaths = true;
|
|
|
|
/**
|
|
* Disables distance field rendering for paths. Distance field computation can be expensive,
|
|
* and yields no benefit if a path is not rendered multiple times with different transforms.
|
|
*/
|
|
bool fDisableDistanceFieldPaths = false;
|
|
|
|
/**
|
|
* If true this allows path mask textures to be cached. This is only really useful if paths
|
|
* are commonly rendered at the same scale and fractional translation.
|
|
*/
|
|
bool fAllowPathMaskCaching = true;
|
|
|
|
/**
|
|
* If true, the GPU will not be used to perform YUV -> RGB conversion when generating
|
|
* textures from codec-backed images.
|
|
*/
|
|
bool fDisableGpuYUVConversion = false;
|
|
|
|
/**
|
|
* The maximum size of cache textures used for Skia's Glyph cache.
|
|
*/
|
|
size_t fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4;
|
|
|
|
/**
|
|
* Below this threshold size in device space distance field fonts won't be used. Distance field
|
|
* fonts don't support hinting which is more important at smaller sizes.
|
|
*/
|
|
float fMinDistanceFieldFontSize = 18;
|
|
|
|
/**
|
|
* Above this threshold size in device space glyphs are drawn as individual paths.
|
|
*/
|
|
#if defined(SK_BUILD_FOR_ANDROID)
|
|
float fGlyphsAsPathsFontSize = 384;
|
|
#elif defined(SK_BUILD_FOR_MAC)
|
|
float fGlyphsAsPathsFontSize = 256;
|
|
#else
|
|
float fGlyphsAsPathsFontSize = 324;
|
|
#endif
|
|
|
|
/**
|
|
* Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by
|
|
* fGlypheCacheTextureMaximumBytes.
|
|
*/
|
|
Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault;
|
|
|
|
/**
|
|
* Bugs on certain drivers cause stencil buffers to leak. This flag causes Skia to avoid
|
|
* allocating stencil buffers and use alternate rasterization paths, avoiding the leak.
|
|
*/
|
|
bool fAvoidStencilBuffers = false;
|
|
|
|
/**
|
|
* If true, texture fetches from mip-mapped textures will be biased to read larger MIP levels.
|
|
* This has the effect of sharpening those textures, at the cost of some aliasing, and possible
|
|
* performance impact.
|
|
*/
|
|
bool fSharpenMipmappedTextures = false;
|
|
|
|
/**
|
|
* Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend.
|
|
*/
|
|
Enable fUseDrawInsteadOfClear = Enable::kDefault;
|
|
|
|
/**
|
|
* Allow Ganesh to more aggressively reorder operations to reduce the number of render passes.
|
|
* Offscreen draws will be done upfront instead of interrupting the main render pass when
|
|
* possible. May increase VRAM usage, but still observes the resource cache limit.
|
|
* Enabled by default.
|
|
*/
|
|
Enable fReduceOpsTaskSplitting = Enable::kDefault;
|
|
|
|
/**
|
|
* Some ES3 contexts report the ES2 external image extension, but not the ES3 version.
|
|
* If support for external images is critical, enabling this option will cause Ganesh to limit
|
|
* shaders to the ES2 shading language in that situation.
|
|
*/
|
|
bool fPreferExternalImagesOverES3 = false;
|
|
|
|
/**
|
|
* Disables correctness workarounds that are enabled for particular GPUs, OSes, or drivers.
|
|
* This does not affect code path choices that are made for perfomance reasons nor does it
|
|
* override other GrContextOption settings.
|
|
*/
|
|
bool fDisableDriverCorrectnessWorkarounds = false;
|
|
|
|
/**
|
|
* Maximum number of GPU programs or pipelines to keep active in the runtime cache.
|
|
*/
|
|
int fRuntimeProgramCacheSize = 256;
|
|
|
|
/**
|
|
* Cache in which to store compiled shader binaries between runs.
|
|
*/
|
|
PersistentCache* fPersistentCache = nullptr;
|
|
|
|
/**
|
|
* This affects the usage of the PersistentCache. We can cache SkSL, backend source (GLSL), or
|
|
* backend binaries (GL program binaries). By default we cache binaries, but if the driver's
|
|
* binary loading/storing is believed to have bugs, this can be limited to caching GLSL.
|
|
* Caching GLSL strings still saves CPU work when a GL program is created.
|
|
*/
|
|
ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary;
|
|
|
|
/**
|
|
* If present, use this object to report shader compilation failures. If not, report failures
|
|
* via SkDebugf and assert.
|
|
*/
|
|
ShaderErrorHandler* fShaderErrorHandler = nullptr;
|
|
|
|
/**
|
|
* Specifies the number of samples Ganesh should use when performing internal draws with MSAA
|
|
* (hardware capabilities permitting).
|
|
*
|
|
* If 0, Ganesh will disable internal code paths that use multisampling.
|
|
*/
|
|
int fInternalMultisampleCount = 4;
|
|
|
|
/**
|
|
* In Skia's vulkan backend a single GrContext submit equates to the submission of a single
|
|
* primary command buffer to the VkQueue. This value specifies how many vulkan secondary command
|
|
* buffers we will cache for reuse on a given primary command buffer. A single submit may use
|
|
* more than this many secondary command buffers, but after the primary command buffer is
|
|
* finished on the GPU it will only hold on to this many secondary command buffers for reuse.
|
|
*
|
|
* A value of -1 means we will pick a limit value internally.
|
|
*/
|
|
int fMaxCachedVulkanSecondaryCommandBuffers = -1;
|
|
|
|
/**
|
|
* If true, the caps will never support mipmaps.
|
|
*/
|
|
bool fSuppressMipmapSupport = false;
|
|
|
|
/**
|
|
* If true, and if supported, enables hardware tessellation in the caps.
|
|
*/
|
|
bool fEnableExperimentalHardwareTessellation = false;
|
|
|
|
/**
|
|
* Uses a reduced variety of shaders. May perform less optimally in steady state but can reduce
|
|
* jank due to shader compilations.
|
|
*/
|
|
bool fReducedShaderVariations = false;
|
|
|
|
#if GR_TEST_UTILS
|
|
/**
|
|
* Private options that are only meant for testing within Skia's tools.
|
|
*/
|
|
|
|
/**
|
|
* Experimental: Should the Ganesh' Next Generation Architecture be used instead of the
|
|
* old architecture?
|
|
*/
|
|
Enable fUseNGA = Enable::kDefault;
|
|
|
|
/**
|
|
* Prevents use of dual source blending, to test that all xfer modes work correctly without it.
|
|
*/
|
|
bool fSuppressDualSourceBlending = false;
|
|
|
|
/**
|
|
* Prevents the use of non-coefficient-based blend equations, for testing dst reads, barriers,
|
|
* and in-shader blending.
|
|
*/
|
|
bool fSuppressAdvancedBlendEquations = false;
|
|
|
|
/**
|
|
* Prevents the use of framebuffer fetches, for testing dst reads and texture barriers.
|
|
*/
|
|
bool fSuppressFramebufferFetch = false;
|
|
|
|
/**
|
|
* If true, the caps will never support geometry shaders.
|
|
*/
|
|
bool fSuppressGeometryShaders = false;
|
|
|
|
/**
|
|
* If greater than zero and less than the actual hardware limit, overrides the maximum number of
|
|
* tessellation segments supported by the caps.
|
|
*/
|
|
int fMaxTessellationSegmentsOverride = 0;
|
|
|
|
/**
|
|
* If true, then all paths are processed as if "setIsVolatile" had been called.
|
|
*/
|
|
bool fAllPathsVolatile = false;
|
|
|
|
/**
|
|
* Render everything in wireframe
|
|
*/
|
|
bool fWireframeMode = false;
|
|
|
|
/**
|
|
* Enforces clearing of all textures when they're created.
|
|
*/
|
|
bool fClearAllTextures = false;
|
|
|
|
/**
|
|
* Randomly generate a (false) GL_OUT_OF_MEMORY error
|
|
*/
|
|
bool fRandomGLOOM = false;
|
|
|
|
/**
|
|
* Force off support for write/transfer pixels row bytes in caps.
|
|
*/
|
|
bool fDisallowWriteAndTransferPixelRowBytes = false;
|
|
|
|
/**
|
|
* Include or exclude specific GPU path renderers.
|
|
*/
|
|
GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault;
|
|
|
|
/**
|
|
* Specify the GPU resource cache limit. Equivalent to calling `setResourceCacheLimit` on the
|
|
* context at construction time.
|
|
*
|
|
* A value of -1 means use the default limit value.
|
|
*/
|
|
int fResourceCacheLimitOverride = -1;
|
|
|
|
/**
|
|
* If true, then always try to use hardware tessellation, regardless of how small a path may be.
|
|
*/
|
|
bool fAlwaysPreferHardwareTessellation = false;
|
|
|
|
/**
|
|
* Maximum width and height of internal texture atlases.
|
|
*/
|
|
int fMaxTextureAtlasSize = 2048;
|
|
#endif
|
|
|
|
GrDriverBugWorkarounds fDriverBugWorkarounds;
|
|
};
|
|
#else
|
|
struct GrContextOptions {
|
|
struct PersistentCache {};
|
|
};
|
|
#endif
|
|
|
|
#endif
|