GrContextFactory.h

Go to the documentation of this file.

/*
 * Copyright 2012 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef GrContextFactory_DEFINED
#define GrContextFactory_DEFINED
 
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrDirectContext.h"
 
#include "include/private/base/SkTArray.h"
#include "tools/gpu/ContextType.h"
#include "tools/gpu/TestContext.h"
 
#ifdef SK_GL
#include "tools/gpu/gl/GLTestContext.h"
#endif
 
struct GrVkBackendContext;
 
namespace sk_gpu_test {
class ContextInfo;
 
/**
 * This is a simple class that is useful in test apps that use different
 * GrContexts backed by different types of GL contexts. It manages creating the
 * GL context and a GrContext that uses it. The GL/Gr contexts persist until the
 * factory is destroyed (though the caller can always grab a ref on the returned
 * Gr and GL contexts to make them outlive the factory).
 */
class GrContextFactory : SkNoncopyable {
public:
    using ContextType = skgpu::ContextType;
 
    /**
     * Overrides for the initial GrContextOptions provided at construction time, and required
     * features that will cause context creation to fail if not present.
     */
    enum class ContextOverrides {
        kNone                          = 0x0,
        kAvoidStencilBuffers           = 0x1,
        kFakeGLESVersionAs2            = 0x2,
        kReducedShaders                = 0x4,
    };
 
    explicit GrContextFactory(const GrContextOptions& opts);
    GrContextFactory();
 
    ~GrContextFactory();
 
    void destroyContexts();
    void abandonContexts();
    void releaseResourcesAndAbandonContexts();
 
    /**
     * Get a context initialized with a type of GL context. It also makes the GL context current.
     */
    ContextInfo getContextInfo(ContextType type, ContextOverrides = ContextOverrides::kNone);
 
    /**
     * Get a context in the same share group as the passed in GrContext, with the same type and
     * overrides. To get multiple contexts in a single share group, pass the same shareContext,
     * with different values for shareIndex.
     */
    ContextInfo getSharedContextInfo(GrDirectContext* shareContext, uint32_t shareIndex = 0);
 
    /**
     * Get a GrContext initialized with a type of GL context. It also makes the GL context current.
     */
    GrDirectContext* get(ContextType type, ContextOverrides overrides = ContextOverrides::kNone);
    const GrContextOptions& getGlobalOptions() const { return fGlobalOptions; }
 
private:
    ContextInfo getContextInfoInternal(ContextType type, ContextOverrides overrides,
                                       GrDirectContext* shareContext, uint32_t shareIndex);
 
    struct Context {
        ContextType       fType;
        ContextOverrides  fOverrides;
        GrContextOptions  fOptions;
        GrBackendApi      fBackend;
        TestContext*      fTestContext;
        GrDirectContext*  fGrContext;
        GrDirectContext*  fShareContext;
        uint32_t          fShareIndex;
 
        bool              fAbandoned;
    };
    skia_private::TArray<Context, true> fContexts;
#ifdef SK_GL
    std::unique_ptr<GLTestContext>      fSentinelGLContext;
#endif
 
    const GrContextOptions              fGlobalOptions;
};
 
class ContextInfo {
public:
    ContextInfo() = default;
    ContextInfo(const ContextInfo&) = default;
    ContextInfo& operator=(const ContextInfo&) = default;
 
    skgpu::ContextType type() const { return fType; }
    GrBackendApi backend() const { return skgpu::ganesh::ContextTypeBackend(fType); }
 
    GrDirectContext* directContext() const { return fContext; }
    TestContext* testContext() const { return fTestContext; }
 
#ifdef SK_GL
    GLTestContext* glContext() const {
        SkASSERT(GrBackendApi::kOpenGL == this->backend());
        return static_cast<GLTestContext*>(fTestContext);
    }
#endif
 
    const GrContextOptions& options() const { return fOptions; }
 
private:
    ContextInfo(skgpu::ContextType type,
                TestContext* testContext,
                GrDirectContext* context,
                const GrContextOptions& options)
            : fType(type), fTestContext(testContext), fContext(context), fOptions(options) {}
 
    skgpu::ContextType fType = skgpu::ContextType::kGL;
    // Valid until the factory destroys it via abandonContexts() or destroyContexts().
    TestContext* fTestContext = nullptr;
    GrDirectContext* fContext = nullptr;
    GrContextOptions fOptions;
 
    friend class GrContextFactory;
};
 
}  // namespace sk_gpu_test
 
GR_MAKE_BITFIELD_CLASS_OPS(sk_gpu_test::GrContextFactory::ContextOverrides)
 
#endif