GrContextOptions.h

Go to the documentation of this file.

/*
 * 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/gpu/ShaderErrorHandler.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
 
#include <vector>
 
class SkExecutor;
 
#if defined(SK_GANESH)
struct SK_API GrContextOptions {
    enum class Enable {
        kNo,
        kYes,
        kDefault
    };
 
    enum class ShaderCacheStrategy {
        kSkSL,
        kBackendSource,
        kBackendBinary,
    };
 
    class SK_API PersistentCache {
    public:
        virtual ~PersistentCache() = default;
 
        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); }
 
        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;
    };
 
    using ShaderErrorHandler = skgpu::ShaderErrorHandler;
 
    GrContextOptions() {}
 
    // Suppress prints for the GrContext.
    bool fSuppressPrints = false;
 
    Enable fSkipGLErrorChecks = Enable::kDefault;
 
    int  fMaxTextureSizeOverride = SK_MaxS32;
 
    int  fBufferMapThreshold = -1;
 
    size_t fMinimumStagingBufferSize = 64 * 1024;
 
    SkExecutor* fExecutor = nullptr;
 
    bool fDoManualMipmapping = false;
 
    // FIXME: Once this is removed from Chrome and Android, rename to fEnable"".
    bool fDisableCoverageCountingPaths = true;
 
    bool fDisableDistanceFieldPaths = false;
 
    bool fAllowPathMaskCaching = true;
 
    bool fDisableGpuYUVConversion = false;
 
    size_t fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4;
 
    float fMinDistanceFieldFontSize = 18;
 
#if defined(SK_BUILD_FOR_ANDROID)
    float fGlyphsAsPathsFontSize = 384;
#elif defined(SK_BUILD_FOR_MAC)
    float fGlyphsAsPathsFontSize = 256;
#else
    float fGlyphsAsPathsFontSize = 324;
#endif
 
    Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault;
 
    bool fAvoidStencilBuffers = false;
 
    Enable fUseDrawInsteadOfClear = Enable::kDefault;
 
    Enable fReduceOpsTaskSplitting = Enable::kDefault;
 
    bool fPreferExternalImagesOverES3 = false;
 
    bool fDisableDriverCorrectnessWorkarounds = false;
 
    int fRuntimeProgramCacheSize = 256;
 
    PersistentCache* fPersistentCache = nullptr;
 
    ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary;
 
    ShaderErrorHandler* fShaderErrorHandler = nullptr;
 
    int  fInternalMultisampleCount = 4;
 
    int fMaxCachedVulkanSecondaryCommandBuffers = -1;
 
    bool fSuppressMipmapSupport = false;
 
    bool fDisableTessellationPathRenderer = false;
 
    bool fEnableExperimentalHardwareTessellation = false;
 
    bool fSupportBilerpFromGlyphAtlas = false;
 
    bool fReducedShaderVariations = false;
 
    bool fAllowMSAAOnNewIntel = false;
 
    bool fAlwaysUseTexStorageWhenAvailable = false;
 
    GrDirectContextDestroyedContext fContextDeleteContext = nullptr;
    GrDirectContextDestroyedProc fContextDeleteProc = nullptr;
 
#if defined(GR_TEST_UTILS)
    bool fFailFlushTimeCallbacks = false;
 
    bool fSuppressDualSourceBlending = false;
 
    bool fSuppressAdvancedBlendEquations = false;
 
    bool fSuppressFramebufferFetch = false;
 
    bool fAllPathsVolatile = false;
 
    bool fWireframeMode = false;
 
    bool fClearAllTextures = false;
 
    bool fRandomGLOOM = false;
 
    bool fDisallowWriteAndTransferPixelRowBytes = false;
 
    GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault;
 
    int fResourceCacheLimitOverride = -1;
 
    int  fMaxTextureAtlasSize = 2048;
#endif
 
    GrDriverBugWorkarounds fDriverBugWorkarounds;
};
#else
struct GrContextOptions {
    struct PersistentCache {};
};
#endif
 
#endif