1/*
2 * Copyright 2010 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef GrTypes_DEFINED
9#define GrTypes_DEFINED
10
11#include "include/core/SkMath.h"
12#include "include/core/SkTypes.h"
13#include "include/gpu/GrConfig.h"
14
15class GrBackendSemaphore;
16class SkImage;
17class SkSurface;
18
19////////////////////////////////////////////////////////////////////////////////
20
21/**
22 * Defines overloaded bitwise operators to make it easier to use an enum as a
23 * bitfield.
24 */
25#define GR_MAKE_BITFIELD_OPS(X) \
26 inline X operator |(X a, X b) { \
27 return (X) (+a | +b); \
28 } \
29 inline X& operator |=(X& a, X b) { \
30 return (a = a | b); \
31 } \
32 inline X operator &(X a, X b) { \
33 return (X) (+a & +b); \
34 } \
35 inline X& operator &=(X& a, X b) { \
36 return (a = a & b); \
37 } \
38 template <typename T> \
39 inline X operator &(T a, X b) { \
40 return (X) (+a & +b); \
41 } \
42 template <typename T> \
43 inline X operator &(X a, T b) { \
44 return (X) (+a & +b); \
45 } \
46
47#define GR_DECL_BITFIELD_OPS_FRIENDS(X) \
48 friend X operator |(X a, X b); \
49 friend X& operator |=(X& a, X b); \
50 \
51 friend X operator &(X a, X b); \
52 friend X& operator &=(X& a, X b); \
53 \
54 template <typename T> \
55 friend X operator &(T a, X b); \
56 \
57 template <typename T> \
58 friend X operator &(X a, T b); \
59
60/**
61 * Wraps a C++11 enum that we use as a bitfield, and enables a limited amount of
62 * masking with type safety. Instantiated with the ~ operator.
63 */
64template<typename TFlags> class GrTFlagsMask {
65public:
66 constexpr explicit GrTFlagsMask(TFlags value) : GrTFlagsMask(static_cast<int>(value)) {}
67 constexpr explicit GrTFlagsMask(int value) : fValue(value) {}
68 constexpr int value() const { return fValue; }
69private:
70 const int fValue;
71};
72
73// Or-ing a mask always returns another mask.
74template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(GrTFlagsMask<TFlags> a,
75 GrTFlagsMask<TFlags> b) {
76 return GrTFlagsMask<TFlags>(a.value() | b.value());
77}
78template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(GrTFlagsMask<TFlags> a,
79 TFlags b) {
80 return GrTFlagsMask<TFlags>(a.value() | static_cast<int>(b));
81}
82template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(TFlags a,
83 GrTFlagsMask<TFlags> b) {
84 return GrTFlagsMask<TFlags>(static_cast<int>(a) | b.value());
85}
86template<typename TFlags> inline GrTFlagsMask<TFlags>& operator|=(GrTFlagsMask<TFlags>& a,
87 GrTFlagsMask<TFlags> b) {
88 return (a = a | b);
89}
90
91// And-ing two masks returns another mask; and-ing one with regular flags returns flags.
92template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator&(GrTFlagsMask<TFlags> a,
93 GrTFlagsMask<TFlags> b) {
94 return GrTFlagsMask<TFlags>(a.value() & b.value());
95}
96template<typename TFlags> constexpr TFlags operator&(GrTFlagsMask<TFlags> a, TFlags b) {
97 return static_cast<TFlags>(a.value() & static_cast<int>(b));
98}
99template<typename TFlags> constexpr TFlags operator&(TFlags a, GrTFlagsMask<TFlags> b) {
100 return static_cast<TFlags>(static_cast<int>(a) & b.value());
101}
102template<typename TFlags> inline TFlags& operator&=(TFlags& a, GrTFlagsMask<TFlags> b) {
103 return (a = a & b);
104}
105
106/**
107 * Defines bitwise operators that make it possible to use an enum class as a
108 * basic bitfield.
109 */
110#define GR_MAKE_BITFIELD_CLASS_OPS(X) \
111 constexpr GrTFlagsMask<X> operator~(X a) { \
112 return GrTFlagsMask<X>(~static_cast<int>(a)); \
113 } \
114 constexpr X operator|(X a, X b) { \
115 return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
116 } \
117 inline X& operator|=(X& a, X b) { \
118 return (a = a | b); \
119 } \
120 constexpr bool operator&(X a, X b) { \
121 return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
122 } \
123
124#define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
125 friend constexpr GrTFlagsMask<X> operator ~(X); \
126 friend constexpr X operator |(X, X); \
127 friend X& operator |=(X&, X); \
128 friend constexpr bool operator &(X, X)
129
130///////////////////////////////////////////////////////////////////////////////
131
132/**
133 * Possible 3D APIs that may be used by Ganesh.
134 */
135enum class GrBackendApi : unsigned {
136 kOpenGL,
137 kVulkan,
138 kMetal,
139 kDirect3D,
140 kDawn,
141 /**
142 * Mock is a backend that does not draw anything. It is used for unit tests
143 * and to measure CPU overhead.
144 */
145 kMock,
146
147 /**
148 * Added here to support the legacy GrBackend enum value and clients who referenced it using
149 * GrBackend::kOpenGL_GrBackend.
150 */
151 kOpenGL_GrBackend = kOpenGL,
152};
153
154/**
155 * Previously the above enum was not an enum class but a normal enum. To support the legacy use of
156 * the enum values we define them below so that no clients break.
157 */
158typedef GrBackendApi GrBackend;
159
160static constexpr GrBackendApi kMetal_GrBackend = GrBackendApi::kMetal;
161static constexpr GrBackendApi kVulkan_GrBackend = GrBackendApi::kVulkan;
162static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
163
164///////////////////////////////////////////////////////////////////////////////
165
166/**
167 * Used to say whether a texture has mip levels allocated or not.
168 */
169enum class GrMipmapped : bool {
170 kNo = false,
171 kYes = true
172};
173/** Deprecated legacy alias of GrMipmapped. */
174using GrMipMapped = GrMipmapped;
175
176/*
177 * Can a GrBackendObject be rendered to?
178 */
179enum class GrRenderable : bool {
180 kNo = false,
181 kYes = true
182};
183
184/*
185 * Used to say whether texture is backed by protected memory.
186 */
187enum class GrProtected : bool {
188 kNo = false,
189 kYes = true
190};
191
192///////////////////////////////////////////////////////////////////////////////
193
194/**
195 * GPU SkImage and SkSurfaces can be stored such that (0, 0) in texture space may correspond to
196 * either the top-left or bottom-left content pixel.
197 */
198enum GrSurfaceOrigin : int {
199 kTopLeft_GrSurfaceOrigin,
200 kBottomLeft_GrSurfaceOrigin,
201};
202
203/**
204 * A GrContext's cache of backend context state can be partially invalidated.
205 * These enums are specific to the GL backend and we'd add a new set for an alternative backend.
206 */
207enum GrGLBackendState {
208 kRenderTarget_GrGLBackendState = 1 << 0,
209 // Also includes samplers bound to texture units.
210 kTextureBinding_GrGLBackendState = 1 << 1,
211 // View state stands for scissor and viewport
212 kView_GrGLBackendState = 1 << 2,
213 kBlend_GrGLBackendState = 1 << 3,
214 kMSAAEnable_GrGLBackendState = 1 << 4,
215 kVertex_GrGLBackendState = 1 << 5,
216 kStencil_GrGLBackendState = 1 << 6,
217 kPixelStore_GrGLBackendState = 1 << 7,
218 kProgram_GrGLBackendState = 1 << 8,
219 kFixedFunction_GrGLBackendState = 1 << 9,
220 kMisc_GrGLBackendState = 1 << 10,
221 kPathRendering_GrGLBackendState = 1 << 11,
222 kALL_GrGLBackendState = 0xffff
223};
224
225/**
226 * This value translates to reseting all the context state for any backend.
227 */
228static const uint32_t kAll_GrBackendState = 0xffffffff;
229
230typedef void* GrGpuFinishedContext;
231typedef void (*GrGpuFinishedProc)(GrGpuFinishedContext finishedContext);
232
233typedef void* GrGpuSubmittedContext;
234typedef void (*GrGpuSubmittedProc)(GrGpuSubmittedContext submittedContext, bool success);
235
236/**
237 * Struct to supply options to flush calls.
238 *
239 * After issuing all commands, fNumSemaphore semaphores will be signaled by the gpu. The client
240 * passes in an array of fNumSemaphores GrBackendSemaphores. In general these GrBackendSemaphore's
241 * can be either initialized or not. If they are initialized, the backend uses the passed in
242 * semaphore. If it is not initialized, a new semaphore is created and the GrBackendSemaphore
243 * object is initialized with that semaphore. The semaphores are not sent to the GPU until the next
244 * GrContext::submit call is made. See the GrContext::submit for more information.
245 *
246 * The client will own and be responsible for deleting the underlying semaphores that are stored
247 * and returned in initialized GrBackendSemaphore objects. The GrBackendSemaphore objects
248 * themselves can be deleted as soon as this function returns.
249 *
250 * If a finishedProc is provided, the finishedProc will be called when all work submitted to the gpu
251 * from this flush call and all previous flush calls has finished on the GPU. If the flush call
252 * fails due to an error and nothing ends up getting sent to the GPU, the finished proc is called
253 * immediately.
254 *
255 * If a submittedProc is provided, the submittedProc will be called when all work from this flush
256 * call is submitted to the GPU. If the flush call fails due to an error and nothing will get sent
257 * to the GPU, the submitted proc is called immediately. It is possibly that when work is finally
258 * submitted, that the submission actual fails. In this case we will not reattempt to do the
259 * submission. Skia notifies the client of these via the success bool passed into the submittedProc.
260 * The submittedProc is useful to the client to know when semaphores that were sent with the flush
261 * have actually been submitted to the GPU so that they can be waited on (or deleted if the submit
262 * fails).
263 * Note about GL: In GL work gets sent to the driver immediately during the flush call, but we don't
264 * really know when the driver sends the work to the GPU. Therefore, we treat the submitted proc as
265 * we do in other backends. It will be called when the next GrContext::submit is called after the
266 * flush (or possibly during the flush if there is no work to be done for the flush). The main use
267 * case for the submittedProc is to know when semaphores have been sent to the GPU and even in GL
268 * it is required to call GrContext::submit to flush them. So a client should be able to treat all
269 * backend APIs the same in terms of how the submitted procs are treated.
270 */
271struct GrFlushInfo {
272 int fNumSemaphores = 0;
273 GrBackendSemaphore* fSignalSemaphores = nullptr;
274 GrGpuFinishedProc fFinishedProc = nullptr;
275 GrGpuFinishedContext fFinishedContext = nullptr;
276 GrGpuSubmittedProc fSubmittedProc = nullptr;
277 GrGpuSubmittedContext fSubmittedContext = nullptr;
278};
279
280/**
281 * Enum used as return value when flush with semaphores so the client knows whether the valid
282 * semaphores will be submitted on the next GrContext::submit call.
283 */
284enum class GrSemaphoresSubmitted : bool {
285 kNo = false,
286 kYes = true
287};
288
289#endif
290