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