/* * 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 \ inline X operator &(T a, X b) { \ return (X) (+a & +b); \ } \ template \ 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 \ friend X operator &(T a, X b); \ \ template \ 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 class GrTFlagsMask { public: constexpr explicit GrTFlagsMask(TFlags value) : GrTFlagsMask(static_cast(value)) {} constexpr explicit GrTFlagsMask(int value) : fValue(value) {} constexpr int value() const { return fValue; } private: const int fValue; }; // Or-ing a mask always returns another mask. template constexpr GrTFlagsMask operator|(GrTFlagsMask a, GrTFlagsMask b) { return GrTFlagsMask(a.value() | b.value()); } template constexpr GrTFlagsMask operator|(GrTFlagsMask a, TFlags b) { return GrTFlagsMask(a.value() | static_cast(b)); } template constexpr GrTFlagsMask operator|(TFlags a, GrTFlagsMask b) { return GrTFlagsMask(static_cast(a) | b.value()); } template inline GrTFlagsMask& operator|=(GrTFlagsMask& a, GrTFlagsMask b) { return (a = a | b); } // And-ing two masks returns another mask; and-ing one with regular flags returns flags. template constexpr GrTFlagsMask operator&(GrTFlagsMask a, GrTFlagsMask b) { return GrTFlagsMask(a.value() & b.value()); } template constexpr TFlags operator&(GrTFlagsMask a, TFlags b) { return static_cast(a.value() & static_cast(b)); } template constexpr TFlags operator&(TFlags a, GrTFlagsMask b) { return static_cast(static_cast(a) & b.value()); } template inline TFlags& operator&=(TFlags& a, GrTFlagsMask b) { return (a = a & b); } /** * Defines bitwise operators that make it possible to use an enum class as a * basic bitfield. */ #define GR_MAKE_BITFIELD_CLASS_OPS(X) \ constexpr GrTFlagsMask operator~(X a) { \ return GrTFlagsMask(~static_cast(a)); \ } \ constexpr X operator|(X a, X b) { \ return static_cast(static_cast(a) | static_cast(b)); \ } \ inline X& operator|=(X& a, X b) { \ return (a = a | b); \ } \ constexpr bool operator&(X a, X b) { \ return SkToBool(static_cast(a) & static_cast(b)); \ } \ #define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \ friend constexpr GrTFlagsMask operator ~(X); \ friend constexpr X operator |(X, X); \ friend X& operator |=(X&, X); \ friend constexpr bool operator &(X, X) //////////////////////////////////////////////////////////////////////////////// // compile time versions of min/max #define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b)) #define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a)) /** * divide, rounding up */ static inline constexpr int32_t GrIDivRoundUp(int x, int y) { SkASSERT(y > 0); return (x + (y-1)) / y; } static inline constexpr uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) { return (x + (y-1)) / y; } static inline constexpr size_t GrSizeDivRoundUp(size_t x, size_t y) { return (x + (y - 1)) / y; } /** * align up */ static inline constexpr uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) { return GrUIDivRoundUp(x, alignment) * alignment; } static inline constexpr size_t GrSizeAlignUp(size_t x, size_t alignment) { return GrSizeDivRoundUp(x, alignment) * alignment; } /** * amount of pad needed to align up */ static inline constexpr uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) { return (alignment - x % alignment) % alignment; } static inline constexpr size_t GrSizeAlignUpPad(size_t x, size_t alignment) { return (alignment - x % alignment) % alignment; } /** * align down */ static inline constexpr uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) { return (x / alignment) * alignment; } static inline constexpr size_t GrSizeAlignDown(size_t x, uint32_t alignment) { return (x / alignment) * alignment; } /////////////////////////////////////////////////////////////////////////////// /** * Possible 3D APIs that may be used by Ganesh. */ enum class GrBackendApi : unsigned { kMetal, kDawn, kOpenGL, kVulkan, /** * 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 }; /* * 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, kPathRendering_GrGLBackendState = 1 << 11, kALL_GrGLBackendState = 0xffff }; /** * This value translates to reseting all the context state for any backend. */ static const uint32_t kAll_GrBackendState = 0xffffffff; enum GrFlushFlags { kNone_GrFlushFlags = 0, // flush will wait till all submitted GPU work is finished before returning. kSyncCpu_GrFlushFlag = 0x1, }; typedef void* GrGpuFinishedContext; typedef void (*GrGpuFinishedProc)(GrGpuFinishedContext finishedContext); /** * 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 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. */ struct GrFlushInfo { GrFlushFlags fFlags = kNone_GrFlushFlags; int fNumSemaphores = 0; GrBackendSemaphore* fSignalSemaphores = nullptr; GrGpuFinishedProc fFinishedProc = nullptr; GrGpuFinishedContext fFinishedContext = nullptr; }; /** * Enum used as return value when flush with semaphores so the client knows whether the semaphores * were submitted to GPU or not. */ enum class GrSemaphoresSubmitted : bool { kNo = false, kYes = true }; /** * Array of SkImages and SkSurfaces which Skia will prepare for external use when passed into a * flush call on GrContext. All the SkImages and SkSurfaces must be GPU backed. * * If fPrepareSurfaceForPresent is not nullptr, then it must be an array the size of fNumSurfaces. * Each entry in the array corresponds to the SkSurface at the same index in the fSurfaces array. If * an entry is true, then that surface will be prepared for both external use and present. * * Currently this only has an effect if the backend API is Vulkan. In this case, all the underlying * VkImages associated with the SkImages and SkSurfaces will be transitioned into the VkQueueFamily * in which they were originally wrapped or created with. This allows a client to wrap a VkImage * from a queue which is different from the graphics queue and then have Skia transition it back to * that queue without needing to delete the SkImage or SkSurface. If the an SkSurface is also * flagged to be prepared for present, then its VkImageLayout will be set to * VK_IMAGE_LAYOUT_PRESENT_SRC_KHR if the VK_KHR_swapchain extension has been enabled for the * GrContext and the original queue is not VK_QUEUE_FAMILY_EXTERNAL or VK_QUEUE_FAMILY_FOREIGN_EXT. * * If an SkSurface or SkImage is used again, it will be transitioned back to the graphics queue and * whatever layout is needed for its use. */ struct GrPrepareForExternalIORequests { int fNumImages = 0; SkImage** fImages = nullptr; int fNumSurfaces = 0; SkSurface** fSurfaces = nullptr; bool* fPrepareSurfaceForPresent = nullptr; bool hasRequests() const { return fNumImages || fNumSurfaces; } }; #endif