GrTypes.h File Reference

#include "include/core/SkTypes.h"
#include "include/private/base/SkTo.h"
#include <cstddef>
#include <cstdint>

Go to the source code of this file.

Classes
class	GrTFlagsMask< TFlags >
struct	GrFlushInfo

Namespaces
namespace	skgpu

Macros
#define	GR_MAKE_BITFIELD_CLASS_OPS(X)
#define	GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X)

Typedefs
typedef GrBackendApi	GrBackend
using	GrRenderable = skgpu::Renderable
using	GrProtected = skgpu::Protected
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)

Enumerations
enum class	GrBackendApi : unsigned {   kOpenGL , kVulkan , kMetal , kDirect3D ,   kMock , kUnsupported , kOpenGL_GrBackend = kOpenGL }
enum	GrSurfaceOrigin : int { kTopLeft_GrSurfaceOrigin , kBottomLeft_GrSurfaceOrigin }
enum	GrGLBackendState {   kRenderTarget_GrGLBackendState = 1 << 0 , kTextureBinding_GrGLBackendState = 1 << 1 , 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 }
enum class	GrSemaphoresSubmitted : bool { kNo = false , kYes = true }
enum class	GrPurgeResourceOptions { kAllResources , kScratchResourcesOnly }
enum class	GrSyncCpu : bool { kNo = false , kYes = true }

Variables
static constexpr GrBackendApi	kMetal_GrBackend = GrBackendApi::kMetal
static constexpr GrBackendApi	kVulkan_GrBackend = GrBackendApi::kVulkan
static constexpr GrBackendApi	kMock_GrBackend = GrBackendApi::kMock
static const uint32_t	kAll_GrBackendState = 0xffffffff

Macro Definition Documentation

GR_DECL_BITFIELD_CLASS_OPS_FRIENDS

#define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS

(

X

)

Value:

    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>)

Definition at line 77 of file GrTypes.h.

                        : unsigned {
    kOpenGL,
    kVulkan,
    kMetal,
    kDirect3D,
 
    /**
     * Mock is a backend that does not draw anything. It is used for unit tests
     * and to measure CPU overhead.
     */
    kMock,
 
    /**
     * Ganesh doesn't support some context types (e.g. Dawn) and will return Unsupported.
     */
    kUnsupported,
 
    /**
     * Added here to support the legacy GrBackend enum value and clients who referenced it using
     * GrBackend::kOpenGL_GrBackend.
     */
    kOpenGL_GrBackend = kOpenGL,
};
 
/**
 * Previously the above enum was not an enum class but a normal enum. To support the legacy use of
 * the enum values we define them below so that no clients break.
 */
typedef GrBackendApi GrBackend;
 
static constexpr GrBackendApi kMetal_GrBackend = GrBackendApi::kMetal;
static constexpr GrBackendApi kVulkan_GrBackend = GrBackendApi::kVulkan;
static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
 
///////////////////////////////////////////////////////////////////////////////
 
/*
 * Can a GrBackendObject be rendered to?
 */
using GrRenderable = skgpu::Renderable;
 
/*
 * Used to say whether texture is backed by protected memory.
 */
using GrProtected = skgpu::Protected;
 
///////////////////////////////////////////////////////////////////////////////
 
/**
 * GPU SkImage and SkSurfaces can be stored such that (0, 0) in texture space may correspond to
 * either the top-left or bottom-left content pixel.
 */
enum GrSurfaceOrigin : int {
    kTopLeft_GrSurfaceOrigin,
    kBottomLeft_GrSurfaceOrigin,
};
 
/**
 * A GrContext's cache of backend context state can be partially invalidated.
 * These enums are specific to the GL backend and we'd add a new set for an alternative backend.
 */
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
};
 
/**
 * This value translates to reseting all the context state for any backend.
 */
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 to supply options to flush calls.
 *
 * After issuing all commands, fNumSemaphore semaphores will be signaled by the gpu. The client
 * passes in an array of fNumSemaphores GrBackendSemaphores. In general these GrBackendSemaphore's
 * can be either initialized or not. If they are initialized, the backend uses the passed in
 * semaphore. If it is not initialized, a new semaphore is created and the GrBackendSemaphore
 * object is initialized with that semaphore. The semaphores are not sent to the GPU until the next
 * GrContext::submit call is made. See the GrContext::submit for more information.
 *
 * The client will own and be responsible for deleting the underlying semaphores that are stored
 * and returned in initialized GrBackendSemaphore objects. The GrBackendSemaphore objects
 * themselves can be deleted as soon as this function returns.
 *
 * If a finishedProc is provided, the finishedProc will be called when all work submitted to the gpu
 * from this flush call and all previous flush calls has finished on the GPU. If the flush call
 * fails due to an error and nothing ends up getting sent to the GPU, the finished proc is called
 * immediately.
 *
 * If a submittedProc is provided, the submittedProc will be called when all work from this flush
 * call is submitted to the GPU. If the flush call fails due to an error and nothing will get sent
 * to the GPU, the submitted proc is called immediately. It is possibly that when work is finally
 * submitted, that the submission actual fails. In this case we will not reattempt to do the
 * submission. Skia notifies the client of these via the success bool passed into the submittedProc.
 * The submittedProc is useful to the client to know when semaphores that were sent with the flush
 * have actually been submitted to the GPU so that they can be waited on (or deleted if the submit
 * fails).
 * GrBackendSemaphores are not supported for the GL backend and will be ignored if set.
 */
struct GrFlushInfo {
    size_t fNumSemaphores = 0;
    GrBackendSemaphore* fSignalSemaphores = nullptr;
    GrGpuFinishedProc fFinishedProc = nullptr;
    GrGpuFinishedContext fFinishedContext = nullptr;
    GrGpuSubmittedProc fSubmittedProc = nullptr;
    GrGpuSubmittedContext fSubmittedContext = nullptr;
};
 
/**
 * Enum used as return value when flush with semaphores so the client knows whether the valid
 * semaphores will be submitted on the next GrContext::submit call.
 */
enum class GrSemaphoresSubmitted : bool {
    kNo = false,
    kYes = true
};
 
enum class GrPurgeResourceOptions {
    kAllResources,
    kScratchResourcesOnly,
};
 
enum class GrSyncCpu : bool {
    kNo = false,
    kYes = true,
};
 
#endif

GR_MAKE_BITFIELD_CLASS_OPS

#define GR_MAKE_BITFIELD_CLASS_OPS

(

X

)

Defines bitwise operators that make it possible to use an enum class as a basic bitfield.

Definition at line 42 of file GrTypes.h.

                                                              { \
        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); \
    } \
 

Typedef Documentation

GrBackend

typedef GrBackendApi GrBackend

Previously the above enum was not an enum class but a normal enum. To support the legacy use of the enum values we define them below so that no clients break.

Definition at line 123 of file GrTypes.h.

GrDirectContextDestroyedContext

typedef void* GrDirectContextDestroyedContext

Definition at line 184 of file GrTypes.h.

GrDirectContextDestroyedProc

typedef void(* GrDirectContextDestroyedProc) (GrDirectContextDestroyedContext destroyedContext)

Definition at line 185 of file GrTypes.h.

GrGpuFinishedContext

typedef void* GrGpuFinishedContext

Definition at line 178 of file GrTypes.h.

GrGpuFinishedProc

typedef void(* GrGpuFinishedProc) (GrGpuFinishedContext finishedContext)

Definition at line 179 of file GrTypes.h.

GrGpuSubmittedContext

typedef void* GrGpuSubmittedContext

Definition at line 181 of file GrTypes.h.

GrGpuSubmittedProc

typedef void(* GrGpuSubmittedProc) (GrGpuSubmittedContext submittedContext, bool success)

Definition at line 182 of file GrTypes.h.

GrProtected

using GrProtected = skgpu::Protected

Definition at line 139 of file GrTypes.h.

GrRenderable

using GrRenderable = skgpu::Renderable

Definition at line 134 of file GrTypes.h.

Enumeration Type Documentation

GrBackendApi

enum class GrBackendApi : unsigned

strong

Possible 3D APIs that may be used by Ganesh.

Enumerator
kOpenGL
kVulkan
kMetal
kDirect3D
kMock	Mock is a backend that does not draw anything. It is used for unit tests and to measure CPU overhead.
kUnsupported	Ganesh doesn't support some context types (e.g. Dawn) and will return Unsupported.
kOpenGL_GrBackend	Added here to support the legacy GrBackend enum value and clients who referenced it using GrBackend::kOpenGL_GrBackend.

Definition at line 95 of file GrTypes.h.

                        : unsigned {
    kOpenGL,
    kVulkan,
    kMetal,
    kDirect3D,
 
    /**
     * Mock is a backend that does not draw anything. It is used for unit tests
     * and to measure CPU overhead.
     */
    kMock,
 
    /**
     * Ganesh doesn't support some context types (e.g. Dawn) and will return Unsupported.
     */
    kUnsupported,
 
    /**
     * Added here to support the legacy GrBackend enum value and clients who referenced it using
     * GrBackend::kOpenGL_GrBackend.
     */
    kOpenGL_GrBackend = kOpenGL,
};

GrGLBackendState

enum GrGLBackendState

A GrContext's cache of backend context state can be partially invalidated. These enums are specific to the GL backend and we'd add a new set for an alternative backend.

Enumerator
kRenderTarget_GrGLBackendState
kTextureBinding_GrGLBackendState
kView_GrGLBackendState
kBlend_GrGLBackendState
kMSAAEnable_GrGLBackendState
kVertex_GrGLBackendState
kStencil_GrGLBackendState
kPixelStore_GrGLBackendState
kProgram_GrGLBackendState
kFixedFunction_GrGLBackendState
kMisc_GrGLBackendState
kALL_GrGLBackendState

Definition at line 156 of file GrTypes.h.

                      {
    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
};

GrPurgeResourceOptions

enum class GrPurgeResourceOptions

strong

Enumerator
kAllResources
kScratchResourcesOnly

Definition at line 234 of file GrTypes.h.

                                  {
    kAllResources,
    kScratchResourcesOnly,
};

GrSemaphoresSubmitted

enum class GrSemaphoresSubmitted : bool

strong

Enum used as return value when flush with semaphores so the client knows whether the valid semaphores will be submitted on the next GrContext::submit call.

Enumerator
kNo
kYes

Definition at line 229 of file GrTypes.h.

                                 : bool {
    kNo = false,
    kYes = true
};

GrSurfaceOrigin

enum GrSurfaceOrigin : int

GPU SkImage and SkSurfaces can be stored such that (0, 0) in texture space may correspond to either the top-left or bottom-left content pixel.

Enumerator
kTopLeft_GrSurfaceOrigin
kBottomLeft_GrSurfaceOrigin

Definition at line 147 of file GrTypes.h.

                     : int {
    kTopLeft_GrSurfaceOrigin,
    kBottomLeft_GrSurfaceOrigin,
};

GrSyncCpu

enum class GrSyncCpu : bool

strong

Enumerator
kNo
kYes

Definition at line 239 of file GrTypes.h.

                     : bool {
    kNo = false,
    kYes = true,
};

Variable Documentation

kAll_GrBackendState

const uint32_t kAll_GrBackendState = 0xffffffff

static

This value translates to reseting all the context state for any backend.

Definition at line 176 of file GrTypes.h.

kMetal_GrBackend

constexpr GrBackendApi kMetal_GrBackend = GrBackendApi::kMetal

staticconstexpr

Definition at line 125 of file GrTypes.h.

kMock_GrBackend

constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock

staticconstexpr

Definition at line 127 of file GrTypes.h.

kVulkan_GrBackend

constexpr GrBackendApi kVulkan_GrBackend = GrBackendApi::kVulkan

staticconstexpr

Definition at line 126 of file GrTypes.h.