blob: 049ffd2b7419d5920dcc41d7221adde746d2d91c [file] [log] [blame]
/*
* 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/SkMath.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GrConfig.h"
class GrBackendSemaphore;
class SkImage;
class SkSurface;
////////////////////////////////////////////////////////////////////////////////
/**
* Defines overloaded bitwise operators to make it easier to use an enum as a
* bitfield.
*/
#define GR_MAKE_BITFIELD_OPS(X) \
inline X operator |(X a, X b) { \
return (X) (+a | +b); \
} \
inline X& operator |=(X& a, X b) { \
return (a = a | b); \
} \
inline X operator &(X a, X b) { \
return (X) (+a & +b); \
} \
inline X& operator &=(X& a, X b) { \
return (a = a & b); \
} \
template <typename T> \
inline X operator &(T a, X b) { \
return (X) (+a & +b); \
} \
template <typename T> \
inline X operator &(X a, T b) { \
return (X) (+a & +b); \
} \
#define GR_DECL_BITFIELD_OPS_FRIENDS(X) \
friend X operator |(X a, X b); \
friend X& operator |=(X& a, X b); \
\
friend X operator &(X a, X b); \
friend X& operator &=(X& a, X b); \
\
template <typename T> \
friend X operator &(T a, X b); \
\
template <typename T> \
friend X operator &(X a, T b); \
/**
* Wraps a C++11 enum that we use as a bitfield, and enables a limited amount of
* masking with type safety. Instantiated with the ~ operator.
*/
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;
};
/**
* Defines bitwise operators that make it possible to use an enum class as a
* basic bitfield.
*/
#define GR_MAKE_BITFIELD_CLASS_OPS(X) \
SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator~(X a) { \
return GrTFlagsMask<X>(~static_cast<int>(a)); \
} \
SK_MAYBE_UNUSED constexpr X operator|(X a, X b) { \
return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
} \
SK_MAYBE_UNUSED inline X& operator|=(X& a, X b) { \
return (a = a | b); \
} \
SK_MAYBE_UNUSED constexpr bool operator&(X a, X b) { \
return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
} \
SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
return GrTFlagsMask<X>(a.value() | b.value()); \
} \
SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, X b) { \
return GrTFlagsMask<X>(a.value() | static_cast<int>(b)); \
} \
SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(X a, GrTFlagsMask<X> b) { \
return GrTFlagsMask<X>(static_cast<int>(a) | b.value()); \
} \
SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
return static_cast<X>(a.value() & b.value()); \
} \
SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, X b) { \
return static_cast<X>(a.value() & static_cast<int>(b)); \
} \
SK_MAYBE_UNUSED constexpr X operator&(X a, GrTFlagsMask<X> b) { \
return static_cast<X>(static_cast<int>(a) & b.value()); \
} \
SK_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>)
///////////////////////////////////////////////////////////////////////////////
/**
* Possible 3D APIs that may be used by Ganesh.
*/
enum class GrBackendApi : unsigned {
kOpenGL,
kVulkan,
kMetal,
kDirect3D,
kDawn,
/**
* Mock is a backend that does not draw anything. It is used for unit tests
* and to measure CPU overhead.
*/
kMock,
/**
* 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;
///////////////////////////////////////////////////////////////////////////////
/**
* Used to say whether a texture has mip levels allocated or not.
*/
enum class GrMipmapped : bool {
kNo = false,
kYes = true
};
/** Deprecated legacy alias of GrMipmapped. */
using GrMipMapped = GrMipmapped;
/*
* Can a GrBackendObject be rendered to?
*/
enum class GrRenderable : bool {
kNo = false,
kYes = true
};
/*
* Used to say whether texture is backed by protected memory.
*/
enum class GrProtected : bool {
kNo = false,
kYes = true
};
///////////////////////////////////////////////////////////////////////////////
/**
* 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);
/**
* 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).
* Note about GL: In GL work gets sent to the driver immediately during the flush call, but we don't
* really know when the driver sends the work to the GPU. Therefore, we treat the submitted proc as
* we do in other backends. It will be called when the next GrContext::submit is called after the
* flush (or possibly during the flush if there is no work to be done for the flush). The main use
* case for the submittedProc is to know when semaphores have been sent to the GPU and even in GL
* it is required to call GrContext::submit to flush them. So a client should be able to treat all
* backend APIs the same in terms of how the submitted procs are treated.
*/
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
};
#endif