GrTypes.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef GrTypes_DEFINED
#define GrTypes_DEFINED
 
#include "include/core/SkTypes.h"
#include "include/private/base/SkTo.h" // IWYU pragma: keep
 
#include <cstddef>
#include <cstdint>
class GrBackendSemaphore;
 
namespace skgpu {
enum class Mipmapped : bool;
enum class Protected : bool;
enum class Renderable : bool;
}
 
 
template<typename TFlags> class GrTFlagsMask {
public:
    constexpr explicit GrTFlagsMask(TFlags value) : GrTFlagsMask(static_cast<int>(value)) {}
    constexpr explicit GrTFlagsMask(int value) : fValue(value) {}
    constexpr int value() const { return fValue; }
private:
    const int fValue;
};
 
#define GR_MAKE_BITFIELD_CLASS_OPS(X) \
    [[maybe_unused]] constexpr GrTFlagsMask<X> operator~(X a) { \
        return GrTFlagsMask<X>(~static_cast<int>(a)); \
    } \
    [[maybe_unused]] constexpr X operator|(X a, X b) { \
        return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
    } \
    [[maybe_unused]] inline X& operator|=(X& a, X b) { \
        return (a = a | b); \
    } \
    [[maybe_unused]] constexpr bool operator&(X a, X b) { \
        return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
    } \
    [[maybe_unused]] constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
        return GrTFlagsMask<X>(a.value() | b.value()); \
    } \
    [[maybe_unused]] constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, X b) { \
        return GrTFlagsMask<X>(a.value() | static_cast<int>(b)); \
    } \
    [[maybe_unused]] constexpr GrTFlagsMask<X> operator|(X a, GrTFlagsMask<X> b) { \
        return GrTFlagsMask<X>(static_cast<int>(a) | b.value()); \
    } \
    [[maybe_unused]] constexpr X operator&(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
        return static_cast<X>(a.value() & b.value()); \
    } \
    [[maybe_unused]] constexpr X operator&(GrTFlagsMask<X> a, X b) { \
        return static_cast<X>(a.value() & static_cast<int>(b)); \
    } \
    [[maybe_unused]] constexpr X operator&(X a, GrTFlagsMask<X> b) { \
        return static_cast<X>(static_cast<int>(a) & b.value()); \
    } \
    [[maybe_unused]] inline X& operator&=(X& a, GrTFlagsMask<X> b) { \
        return (a = a & b); \
    } \
 
#define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
    friend constexpr GrTFlagsMask<X> operator ~(X); \
    friend constexpr X operator |(X, X); \
    friend X& operator |=(X&, X); \
    friend constexpr bool operator &(X, X); \
    friend constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X>, GrTFlagsMask<X>); \
    friend constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X>, X); \
    friend constexpr GrTFlagsMask<X> operator|(X, GrTFlagsMask<X>); \
    friend constexpr X operator&(GrTFlagsMask<X>, GrTFlagsMask<X>); \
    friend constexpr X operator&(GrTFlagsMask<X>, X); \
    friend constexpr X operator&(X, GrTFlagsMask<X>); \
    friend X& operator &=(X&, GrTFlagsMask<X>)
 
 
enum class GrBackendApi : unsigned {
    kOpenGL,
    kVulkan,
    kMetal,
    kDirect3D,
 
    kMock,
 
    kUnsupported,
 
    kOpenGL_GrBackend = kOpenGL,
};
 
typedef GrBackendApi GrBackend;
 
static constexpr GrBackendApi kMetal_GrBackend = GrBackendApi::kMetal;
static constexpr GrBackendApi kVulkan_GrBackend = GrBackendApi::kVulkan;
static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
 
 
using GrMipmapped = skgpu::Mipmapped;
using GrMipMapped = skgpu::Mipmapped;
 
/*
 * Can a GrBackendObject be rendered to?
 */
using GrRenderable = skgpu::Renderable;
 
/*
 * Used to say whether texture is backed by protected memory.
 */
using GrProtected = skgpu::Protected;
 
 
enum GrSurfaceOrigin : int {
    kTopLeft_GrSurfaceOrigin,
    kBottomLeft_GrSurfaceOrigin,
};
 
enum GrGLBackendState {
    kRenderTarget_GrGLBackendState     = 1 << 0,
    // Also includes samplers bound to texture units.
    kTextureBinding_GrGLBackendState   = 1 << 1,
    // View state stands for scissor and viewport
    kView_GrGLBackendState             = 1 << 2,
    kBlend_GrGLBackendState            = 1 << 3,
    kMSAAEnable_GrGLBackendState       = 1 << 4,
    kVertex_GrGLBackendState           = 1 << 5,
    kStencil_GrGLBackendState          = 1 << 6,
    kPixelStore_GrGLBackendState       = 1 << 7,
    kProgram_GrGLBackendState          = 1 << 8,
    kFixedFunction_GrGLBackendState    = 1 << 9,
    kMisc_GrGLBackendState             = 1 << 10,
    kALL_GrGLBackendState              = 0xffff
};
 
static const uint32_t kAll_GrBackendState = 0xffffffff;
 
typedef void* GrGpuFinishedContext;
typedef void (*GrGpuFinishedProc)(GrGpuFinishedContext finishedContext);
 
typedef void* GrGpuSubmittedContext;
typedef void (*GrGpuSubmittedProc)(GrGpuSubmittedContext submittedContext, bool success);
 
typedef void* GrDirectContextDestroyedContext;
typedef void (*GrDirectContextDestroyedProc)(GrDirectContextDestroyedContext destroyedContext);
 
struct GrFlushInfo {
    size_t fNumSemaphores = 0;
    GrBackendSemaphore* fSignalSemaphores = nullptr;
    GrGpuFinishedProc fFinishedProc = nullptr;
    GrGpuFinishedContext fFinishedContext = nullptr;
    GrGpuSubmittedProc fSubmittedProc = nullptr;
    GrGpuSubmittedContext fSubmittedContext = nullptr;
};
 
enum class GrSemaphoresSubmitted : bool {
    kNo = false,
    kYes = true
};
 
enum class GrPurgeResourceOptions {
    kAllResources,
    kScratchResourcesOnly,
};
 
enum class GrSyncCpu : bool {
    kNo = false,
    kYes = true,
};
 
#endif