Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 714df45f6733792374ad4fcb6e0fef3b47fbeb89 / . / include / xgl.h
blob: 2e40aed8c1160adf5d8f000b3a65ffaa28a674ea [file] [log] [blame]
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1//
2// File: xgl.h
3//
4// Copyright 2014 ADVANCED MICRO DEVICES, INC. All Rights Reserved.
5//
6// AMD is granting you permission to use this software and documentation (if
7// any) (collectively, the "Materials") pursuant to the terms and conditions
8// of the Software License Agreement included with the Materials. If you do
9// not have a copy of the Software License Agreement, contact your AMD
10// representative for a copy.
11// You agree that you will not reverse engineer or decompile the Materials,
12// in whole or in part, except as allowed by applicable law.
13//
14// WARRANTY DISCLAIMER: THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF
15// ANY KIND. AMD DISCLAIMS ALL WARRANTIES, EXPRESS, IMPLIED, OR STATUTORY,
16// INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY,
17// FITNESS FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, THAT THE SOFTWARE
18// WILL RUN UNINTERRUPTED OR ERROR-FREE OR WARRANTIES ARISING FROM CUSTOM OF
19// TRADE OR COURSE OF USAGE. THE ENTIRE RISK ASSOCIATED WITH THE USE OF THE
20// SOFTWARE IS ASSUMED BY YOU.
21// Some jurisdictions do not allow the exclusion of implied warranties, so
22// the above exclusion may not apply to You.
23//
24// LIMITATION OF LIABILITY AND INDEMNIFICATION: AMD AND ITS LICENSORS WILL
25// NOT, UNDER ANY CIRCUMSTANCES BE LIABLE TO YOU FOR ANY PUNITIVE, DIRECT,
26// INCIDENTAL, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM USE OF
27// THE SOFTWARE OR THIS AGREEMENT EVEN IF AMD AND ITS LICENSORS HAVE BEEN
28// ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
29// In no event shall AMD's total liability to You for all damages, losses,
30// and causes of action (whether in contract, tort (including negligence) or
31// otherwise) exceed the amount of $100 USD. You agree to defend, indemnify
32// and hold harmless AMD and its licensors, and any of their directors,
33// officers, employees, affiliates or agents from and against any and all
34// loss, damage, liability and other expenses (including reasonable attorneys'
35// fees), resulting from Your use of the Software or violation of the terms and
36// conditions of this Agreement.
37//
38// U.S. GOVERNMENT RESTRICTED RIGHTS: The Materials are provided with "RESTRICTED
39// RIGHTS." Use, duplication, or disclosure by the Government is subject to the
40// restrictions as set forth in FAR 52.227-14 and DFAR252.227-7013, et seq., or
41// its successor. Use of the Materials by the Government constitutes
42// acknowledgement of AMD's proprietary rights in them.
43//
44// EXPORT RESTRICTIONS: The Materials may be subject to export restrictions as
45// stated in the Software License Agreement.
46//
47
48#ifndef __XGL_H__
49#define __XGL_H__
50
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]51#define XGL_MAKE_VERSION(major, minor, patch) \
52 ((major << 22) | (minor << 12) | patch)
53
Jeremy Hayes4c329eb2015-01-14 14:58:37 -0700[diff] [blame]54#include "xglPlatform.h"
55
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]56// XGL API version supported by this file
Courtney Goeltzenleuchter691362c2015-01-15 13:02:34 -0700[diff] [blame]57#define XGL_API_VERSION XGL_MAKE_VERSION(0, 30, 3)
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]58
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]59#ifdef __cplusplus
60extern "C"
61{
62#endif // __cplusplus
63
64/*
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]65***************************************************************************************************
66* Core XGL API
67***************************************************************************************************
68*/
69
70#ifdef __cplusplus
71 #define XGL_DEFINE_HANDLE(_obj) struct _obj##_T {}; typedef _obj##_T* _obj;
72 #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
73#else // __cplusplus
74 #define XGL_DEFINE_HANDLE(_obj) typedef void* _obj;
75 #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj;
76#endif // __cplusplus
77
78XGL_DEFINE_HANDLE(XGL_PHYSICAL_GPU)
79XGL_DEFINE_HANDLE(XGL_BASE_OBJECT)
80XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEVICE, XGL_BASE_OBJECT)
81XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE, XGL_BASE_OBJECT)
82XGL_DEFINE_SUBCLASS_HANDLE(XGL_GPU_MEMORY, XGL_BASE_OBJECT)
83XGL_DEFINE_SUBCLASS_HANDLE(XGL_OBJECT, XGL_BASE_OBJECT)
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]84XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER, XGL_OBJECT)
85XGL_DEFINE_SUBCLASS_HANDLE(XGL_BUFFER_VIEW, XGL_OBJECT)
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]86XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE, XGL_OBJECT)
87XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE_VIEW, XGL_OBJECT)
88XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_ATTACHMENT_VIEW, XGL_OBJECT)
89XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_VIEW, XGL_OBJECT)
90XGL_DEFINE_SUBCLASS_HANDLE(XGL_SHADER, XGL_OBJECT)
91XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE, XGL_OBJECT)
92XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE_DELTA, XGL_OBJECT)
93XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT)
94XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT)
95XGL_DEFINE_SUBCLASS_HANDLE(XGL_STATE_OBJECT, XGL_OBJECT)
96XGL_DEFINE_SUBCLASS_HANDLE(XGL_VIEWPORT_STATE_OBJECT, XGL_STATE_OBJECT)
97XGL_DEFINE_SUBCLASS_HANDLE(XGL_RASTER_STATE_OBJECT, XGL_STATE_OBJECT)
98XGL_DEFINE_SUBCLASS_HANDLE(XGL_MSAA_STATE_OBJECT, XGL_STATE_OBJECT)
99XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_BLEND_STATE_OBJECT, XGL_STATE_OBJECT)
100XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_STATE_OBJECT, XGL_STATE_OBJECT)
101XGL_DEFINE_SUBCLASS_HANDLE(XGL_CMD_BUFFER, XGL_OBJECT)
102XGL_DEFINE_SUBCLASS_HANDLE(XGL_FENCE, XGL_OBJECT)
103XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE_SEMAPHORE, XGL_OBJECT)
104XGL_DEFINE_SUBCLASS_HANDLE(XGL_EVENT, XGL_OBJECT)
105XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUERY_POOL, XGL_OBJECT)
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]106XGL_DEFINE_SUBCLASS_HANDLE(XGL_FRAMEBUFFER, XGL_OBJECT)
107XGL_DEFINE_SUBCLASS_HANDLE(XGL_RENDER_PASS, XGL_OBJECT)
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]108
109#define XGL_MAX_PHYSICAL_GPUS 16
110#define XGL_MAX_PHYSICAL_GPU_NAME 256
111#define XGL_MAX_MEMORY_HEAPS 8
112#define XGL_MAX_DESCRIPTOR_SETS 2
113#define XGL_MAX_VIEWPORTS 16
114#define XGL_MAX_COLOR_ATTACHMENTS 8
115
116#define XGL_LOD_CLAMP_NONE MAX_FLOAT
117#define XGL_LAST_MIP_OR_SLICE 0xffffffff
118
119#define XGL_TRUE 1
120#define XGL_FALSE 0
121
122#define XGL_NULL_HANDLE 0
123
124// This macro defines MAX_UINT in enumerations to force compilers to use 32 bits
125// to represent them. This may or may not be necessary on some compilers. The
126// option to compile it out may allow compilers that warn about missing enumerants
127// in switch statements to be silenced.
128#define XGL_MAX_ENUM(T) T##_MAX_ENUM = 0xFFFFFFFF
129
130// ------------------------------------------------------------------------------------------------
131// Enumerations
132
133
134typedef enum _XGL_QUEUE_TYPE
135{
136 XGL_QUEUE_TYPE_GRAPHICS = 0x1,
137 XGL_QUEUE_TYPE_COMPUTE = 0x2,
138 XGL_QUEUE_TYPE_DMA = 0x3,
139 XGL_MAX_ENUM(_XGL_QUEUE_TYPE)
140} XGL_QUEUE_TYPE;
141
142typedef enum _XGL_MEMORY_PRIORITY
143{
144 XGL_MEMORY_PRIORITY_UNUSED = 0x0,
145 XGL_MEMORY_PRIORITY_VERY_LOW = 0x1,
146 XGL_MEMORY_PRIORITY_LOW = 0x2,
147 XGL_MEMORY_PRIORITY_NORMAL = 0x3,
148 XGL_MEMORY_PRIORITY_HIGH = 0x4,
149 XGL_MEMORY_PRIORITY_VERY_HIGH = 0x5,
150
151 XGL_MEMORY_PRIORITY_BEGIN_RANGE = XGL_MEMORY_PRIORITY_UNUSED,
152 XGL_MEMORY_PRIORITY_END_RANGE = XGL_MEMORY_PRIORITY_VERY_HIGH,
153 XGL_NUM_MEMORY_PRIORITY = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1),
154} XGL_MEMORY_PRIORITY;
155
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]156typedef enum _XGL_BUFFER_STATE
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]157{
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]158 XGL_BUFFER_STATE_DATA_TRANSFER = 0x00000000,
159 XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY = 0x00000001,
160 XGL_BUFFER_STATE_GRAPHICS_SHADER_WRITE_ONLY = 0x00000002,
161 XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_WRITE = 0x00000003,
162 XGL_BUFFER_STATE_COMPUTE_SHADER_READ_ONLY = 0x00000004,
163 XGL_BUFFER_STATE_COMPUTE_SHADER_WRITE_ONLY = 0x00000005,
164 XGL_BUFFER_STATE_COMPUTE_SHADER_READ_WRITE = 0x00000006,
165 XGL_BUFFER_STATE_MULTI_SHADER_READ_ONLY = 0x00000007,
166 XGL_BUFFER_STATE_INDEX_DATA = 0x00000008,
167 XGL_BUFFER_STATE_INDIRECT_ARG = 0x00000009,
168 XGL_BUFFER_STATE_WRITE_TIMESTAMP = 0x0000000A,
169 XGL_BUFFER_STATE_QUEUE_ATOMIC = 0x0000000B,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]170
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]171 XGL_BUFFER_STATE_BEGIN_RANGE = XGL_BUFFER_STATE_DATA_TRANSFER,
172 XGL_BUFFER_STATE_END_RANGE = XGL_BUFFER_STATE_QUEUE_ATOMIC,
173 XGL_NUM_BUFFER_STATE = (XGL_BUFFER_STATE_END_RANGE - XGL_BUFFER_STATE_BEGIN_RANGE + 1),
174 XGL_MAX_ENUM(_XGL_BUFFER_STATE)
175} XGL_BUFFER_STATE;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]176
177typedef enum _XGL_IMAGE_STATE
178{
179 XGL_IMAGE_STATE_DATA_TRANSFER = 0x00000000,
180 XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY = 0x00000001,
181 XGL_IMAGE_STATE_GRAPHICS_SHADER_WRITE_ONLY = 0x00000002,
182 XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_WRITE = 0x00000003,
183 XGL_IMAGE_STATE_COMPUTE_SHADER_READ_ONLY = 0x00000004,
184 XGL_IMAGE_STATE_COMPUTE_SHADER_WRITE_ONLY = 0x00000005,
185 XGL_IMAGE_STATE_COMPUTE_SHADER_READ_WRITE = 0x00000006,
186 XGL_IMAGE_STATE_MULTI_SHADER_READ_ONLY = 0x00000007,
187 XGL_IMAGE_STATE_TARGET_AND_SHADER_READ_ONLY = 0x00000008,
188 XGL_IMAGE_STATE_UNINITIALIZED_TARGET = 0x00000009,
189 XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL = 0x0000000A,
190 XGL_IMAGE_STATE_TARGET_SHADER_ACCESS_OPTIMAL = 0x0000000B,
191 XGL_IMAGE_STATE_CLEAR = 0x0000000C,
192 XGL_IMAGE_STATE_RESOLVE_SOURCE = 0x0000000D,
193 XGL_IMAGE_STATE_RESOLVE_DESTINATION = 0x0000000E,
194
195 XGL_IMAGE_STATE_BEGIN_RANGE = XGL_IMAGE_STATE_DATA_TRANSFER,
196 XGL_IMAGE_STATE_END_RANGE = XGL_IMAGE_STATE_RESOLVE_DESTINATION,
197 XGL_NUM_IMAGE_STATE = (XGL_IMAGE_STATE_END_RANGE - XGL_IMAGE_STATE_BEGIN_RANGE + 1),
198 XGL_MAX_ENUM(_XGL_IMAGE_STATE)
199} XGL_IMAGE_STATE;
200
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]201typedef enum _XGL_ATTACHMENT_LOAD_OP
202{
203 XGL_ATTACHMENT_LOAD_OP_LOAD = 0x00000000,
204 XGL_ATTACHMENT_LOAD_OP_CLEAR = 0x00000001,
205 XGL_ATTACHMENT_LOAD_OP_DONT_CARE = 0x00000002,
206} XGL_ATTACHMENT_LOAD_OP;
207
208typedef enum _XGL_ATTACHMENT_STORE_OP
209{
210 XGL_ATTACHMENT_STORE_OP_STORE = 0x00000000,
211 XGL_ATTACHMENT_STORE_OP_RESOLVE_MSAA = 0x00000001,
212 XGL_ATTACHMENT_STORE_OP_DONT_CARE = 0x00000002,
213} XGL_ATTACHMENT_STORE_OP;
214
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]215typedef enum _XGL_IMAGE_TYPE
216{
217 XGL_IMAGE_1D = 0x00000000,
218 XGL_IMAGE_2D = 0x00000001,
219 XGL_IMAGE_3D = 0x00000002,
220
221 XGL_IMAGE_TYPE_BEGIN_RANGE = XGL_IMAGE_1D,
222 XGL_IMAGE_TYPE_END_RANGE = XGL_IMAGE_3D,
223 XGL_NUM_IMAGE_TYPE = (XGL_IMAGE_TYPE_END_RANGE - XGL_IMAGE_TYPE_BEGIN_RANGE + 1),
224 XGL_MAX_ENUM(_XGL_IMAGE_TYPE)
225} XGL_IMAGE_TYPE;
226
227typedef enum _XGL_IMAGE_TILING
228{
229 XGL_LINEAR_TILING = 0x00000000,
230 XGL_OPTIMAL_TILING = 0x00000001,
231
232 XGL_IMAGE_TILING_BEGIN_RANGE = XGL_LINEAR_TILING,
233 XGL_IMAGE_TILING_END_RANGE = XGL_OPTIMAL_TILING,
234 XGL_NUM_IMAGE_TILING = (XGL_IMAGE_TILING_END_RANGE - XGL_IMAGE_TILING_BEGIN_RANGE + 1),
235 XGL_MAX_ENUM(_XGL_IMAGE_TILING)
236} XGL_IMAGE_TILING;
237
238typedef enum _XGL_IMAGE_VIEW_TYPE
239{
240 XGL_IMAGE_VIEW_1D = 0x00000000,
241 XGL_IMAGE_VIEW_2D = 0x00000001,
242 XGL_IMAGE_VIEW_3D = 0x00000002,
243 XGL_IMAGE_VIEW_CUBE = 0x00000003,
244
245 XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE = XGL_IMAGE_VIEW_1D,
246 XGL_IMAGE_VIEW_TYPE_END_RANGE = XGL_IMAGE_VIEW_CUBE,
247 XGL_NUM_IMAGE_VIEW_TYPE = (XGL_IMAGE_VIEW_TYPE_END_RANGE - XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1),
248 XGL_MAX_ENUM(_XGL_IMAGE_VIEW_TYPE)
249} XGL_IMAGE_VIEW_TYPE;
250
251typedef enum _XGL_IMAGE_ASPECT
252{
253 XGL_IMAGE_ASPECT_COLOR = 0x00000000,
254 XGL_IMAGE_ASPECT_DEPTH = 0x00000001,
255 XGL_IMAGE_ASPECT_STENCIL = 0x00000002,
256
257 XGL_IMAGE_ASPECT_BEGIN_RANGE = XGL_IMAGE_ASPECT_COLOR,
258 XGL_IMAGE_ASPECT_END_RANGE = XGL_IMAGE_ASPECT_STENCIL,
259 XGL_NUM_IMAGE_ASPECT = (XGL_IMAGE_ASPECT_END_RANGE - XGL_IMAGE_ASPECT_BEGIN_RANGE + 1),
260 XGL_MAX_ENUM(_XGL_IMAGE_ASPECT)
261} XGL_IMAGE_ASPECT;
262
263typedef enum _XGL_CHANNEL_SWIZZLE
264{
265 XGL_CHANNEL_SWIZZLE_ZERO = 0x00000000,
266 XGL_CHANNEL_SWIZZLE_ONE = 0x00000001,
267 XGL_CHANNEL_SWIZZLE_R = 0x00000002,
268 XGL_CHANNEL_SWIZZLE_G = 0x00000003,
269 XGL_CHANNEL_SWIZZLE_B = 0x00000004,
270 XGL_CHANNEL_SWIZZLE_A = 0x00000005,
271
272 XGL_CHANNEL_SWIZZLE_BEGIN_RANGE = XGL_CHANNEL_SWIZZLE_ZERO,
273 XGL_CHANNEL_SWIZZLE_END_RANGE = XGL_CHANNEL_SWIZZLE_A,
274 XGL_NUM_CHANNEL_SWIZZLE = (XGL_CHANNEL_SWIZZLE_END_RANGE - XGL_CHANNEL_SWIZZLE_BEGIN_RANGE + 1),
275 XGL_MAX_ENUM(_XGL_CHANNEL_SWIZZLE)
276} XGL_CHANNEL_SWIZZLE;
277
278typedef enum _XGL_DESCRIPTOR_SET_SLOT_TYPE
279{
280 XGL_SLOT_UNUSED = 0x00000000,
281 XGL_SLOT_SHADER_RESOURCE = 0x00000001,
282 XGL_SLOT_SHADER_UAV = 0x00000002,
283 XGL_SLOT_SHADER_SAMPLER = 0x00000003,
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]284 XGL_SLOT_NEXT_DESCRIPTOR_SET = 0x00000004,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]285
Cody Northrop40316a32014-12-09 19:08:33 -0700[diff] [blame]286 // LUNARG CHANGE BEGIN - differentiate between textures and buffers
287 XGL_SLOT_SHADER_TEXTURE_RESOURCE = 0x00000005,
288
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]289 XGL_DESCRIPTOR_SET_SLOT_TYPE_BEGIN_RANGE = XGL_SLOT_UNUSED,
Cody Northrop40316a32014-12-09 19:08:33 -0700[diff] [blame]290 XGL_DESCRIPTOR_SET_SLOT_TYPE_END_RANGE = XGL_SLOT_SHADER_TEXTURE_RESOURCE,
291 // LUNARG CHANGE END
292
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]293 XGL_NUM_DESCRIPTOR_SET_SLOT_TYPE = (XGL_DESCRIPTOR_SET_SLOT_TYPE_END_RANGE - XGL_DESCRIPTOR_SET_SLOT_TYPE_BEGIN_RANGE + 1),
294 XGL_MAX_ENUM(_XGL_DESCRIPTOR_SET_SLOT_TYPE)
295} XGL_DESCRIPTOR_SET_SLOT_TYPE;
296
297typedef enum _XGL_QUERY_TYPE
298{
299 XGL_QUERY_OCCLUSION = 0x00000000,
300 XGL_QUERY_PIPELINE_STATISTICS = 0x00000001,
301
302 XGL_QUERY_TYPE_BEGIN_RANGE = XGL_QUERY_OCCLUSION,
303 XGL_QUERY_TYPE_END_RANGE = XGL_QUERY_PIPELINE_STATISTICS,
304 XGL_NUM_QUERY_TYPE = (XGL_QUERY_TYPE_END_RANGE - XGL_QUERY_TYPE_BEGIN_RANGE + 1),
305 XGL_MAX_ENUM(_XGL_QUERY_TYPE)
306} XGL_QUERY_TYPE;
307
308typedef enum _XGL_TIMESTAMP_TYPE
309{
310 XGL_TIMESTAMP_TOP = 0x00000000,
311 XGL_TIMESTAMP_BOTTOM = 0x00000001,
312
313 XGL_TIMESTAMP_TYPE_BEGIN_RANGE = XGL_TIMESTAMP_TOP,
314 XGL_TIMESTAMP_TYPE_END_RANGE = XGL_TIMESTAMP_BOTTOM,
315 XGL_NUM_TIMESTAMP_TYPE = (XGL_TIMESTAMP_TYPE_END_RANGE - XGL_TIMESTAMP_TYPE_BEGIN_RANGE + 1),
316 XGL_MAX_ENUM(_XGL_TIMESTEAMP_TYPE)
317} XGL_TIMESTAMP_TYPE;
318
319typedef enum _XGL_BORDER_COLOR_TYPE
320{
321 XGL_BORDER_COLOR_OPAQUE_WHITE = 0x00000000,
322 XGL_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001,
323 XGL_BORDER_COLOR_OPAQUE_BLACK = 0x00000002,
324
325 XGL_BORDER_COLOR_TYPE_BEGIN_RANGE = XGL_BORDER_COLOR_OPAQUE_WHITE,
326 XGL_BORDER_COLOR_TYPE_END_RANGE = XGL_BORDER_COLOR_OPAQUE_BLACK,
327 XGL_NUM_BORDER_COLOR_TYPE = (XGL_BORDER_COLOR_TYPE_END_RANGE - XGL_BORDER_COLOR_TYPE_BEGIN_RANGE + 1),
328 XGL_MAX_ENUM(_XGL_BORDER_COLOR_TYPE)
329} XGL_BORDER_COLOR_TYPE;
330
331typedef enum _XGL_PIPELINE_BIND_POINT
332{
333 XGL_PIPELINE_BIND_POINT_COMPUTE = 0x00000000,
334 XGL_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001,
335
336 XGL_PIPELINE_BIND_POINT_BEGIN_RANGE = XGL_PIPELINE_BIND_POINT_COMPUTE,
337 XGL_PIPELINE_BIND_POINT_END_RANGE = XGL_PIPELINE_BIND_POINT_GRAPHICS,
338 XGL_NUM_PIPELINE_BIND_POINT = (XGL_PIPELINE_BIND_POINT_END_RANGE - XGL_PIPELINE_BIND_POINT_BEGIN_RANGE + 1),
339 XGL_MAX_ENUM(_XGL_PIPELINE_BIND_POINT)
340} XGL_PIPELINE_BIND_POINT;
341
342typedef enum _XGL_STATE_BIND_POINT
343{
344 XGL_STATE_BIND_VIEWPORT = 0x00000000,
345 XGL_STATE_BIND_RASTER = 0x00000001,
346 XGL_STATE_BIND_DEPTH_STENCIL = 0x00000002,
347 XGL_STATE_BIND_COLOR_BLEND = 0x00000003,
348 XGL_STATE_BIND_MSAA = 0x00000004,
349
350 XGL_STATE_BIND_POINT_BEGIN_RANGE = XGL_STATE_BIND_VIEWPORT,
351 XGL_STATE_BIND_POINT_END_RANGE = XGL_STATE_BIND_MSAA,
352 XGL_NUM_STATE_BIND_POINT = (XGL_STATE_BIND_POINT_END_RANGE - XGL_STATE_BIND_POINT_BEGIN_RANGE + 1),
353 XGL_MAX_ENUM(_XGL_STATE_BIND_POINT)
354} XGL_STATE_BIND_POINT;
355
356typedef enum _XGL_PRIMITIVE_TOPOLOGY
357{
358 XGL_TOPOLOGY_POINT_LIST = 0x00000000,
359 XGL_TOPOLOGY_LINE_LIST = 0x00000001,
360 XGL_TOPOLOGY_LINE_STRIP = 0x00000002,
361 XGL_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
362 XGL_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
363 XGL_TOPOLOGY_RECT_LIST = 0x00000005,
364 XGL_TOPOLOGY_QUAD_LIST = 0x00000006,
365 XGL_TOPOLOGY_QUAD_STRIP = 0x00000007,
366 XGL_TOPOLOGY_LINE_LIST_ADJ = 0x00000008,
367 XGL_TOPOLOGY_LINE_STRIP_ADJ = 0x00000009,
368 XGL_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x0000000a,
369 XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x0000000b,
370 XGL_TOPOLOGY_PATCH = 0x0000000c,
371
372 XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = XGL_TOPOLOGY_POINT_LIST,
373 XGL_PRIMITIVE_TOPOLOGY_END_RANGE = XGL_TOPOLOGY_PATCH,
374 XGL_NUM_PRIMITIVE_TOPOLOGY = (XGL_PRIMITIVE_TOPOLOGY_END_RANGE - XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1),
375 XGL_MAX_ENUM(_XGL_PRIMITIVE_TOPOLOGY)
376} XGL_PRIMITIVE_TOPOLOGY;
377
378typedef enum _XGL_INDEX_TYPE
379{
380 XGL_INDEX_8 = 0x00000000,
381 XGL_INDEX_16 = 0x00000001,
382 XGL_INDEX_32 = 0x00000002,
383
384 XGL_INDEX_TYPE_BEGIN_RANGE = XGL_INDEX_8,
385 XGL_INDEX_TYPE_END_RANGE = XGL_INDEX_32,
386 XGL_NUM_INDEX_TYPE = (XGL_INDEX_TYPE_END_RANGE - XGL_INDEX_TYPE_BEGIN_RANGE + 1),
387 XGL_MAX_ENUM(_XGL_INDEX_TYPE)
388} XGL_INDEX_TYPE;
389
390typedef enum _XGL_TEX_FILTER
391{
392 XGL_TEX_FILTER_NEAREST = 0,
393 XGL_TEX_FILTER_LINEAR = 1,
394 XGL_MAX_ENUM(_XGL_TEX_FILTER)
395} XGL_TEX_FILTER;
396
397typedef enum _XGL_TEX_MIPMAP_MODE
398{
399 XGL_TEX_MIPMAP_BASE = 0, // Always choose base level
400 XGL_TEX_MIPMAP_NEAREST = 1, // Choose nearest mip level
401 XGL_TEX_MIPMAP_LINEAR = 2, // Linear filter between mip levels
402 XGL_MAX_ENUM(_XGL_TEX_MIPMAP_MODE)
403} XGL_TEX_MIPMAP_MODE;
404
405typedef enum _XGL_TEX_ADDRESS
406{
407 XGL_TEX_ADDRESS_WRAP = 0x00000000,
408 XGL_TEX_ADDRESS_MIRROR = 0x00000001,
409 XGL_TEX_ADDRESS_CLAMP = 0x00000002,
410 XGL_TEX_ADDRESS_MIRROR_ONCE = 0x00000003,
411 XGL_TEX_ADDRESS_CLAMP_BORDER = 0x00000004,
412
413 XGL_TEX_ADDRESS_BEGIN_RANGE = XGL_TEX_ADDRESS_WRAP,
414 XGL_TEX_ADDRESS_END_RANGE = XGL_TEX_ADDRESS_CLAMP_BORDER,
415 XGL_NUM_TEX_ADDRESS = (XGL_TEX_ADDRESS_END_RANGE - XGL_TEX_ADDRESS_BEGIN_RANGE + 1),
416 XGL_MAX_ENUM(_XGL_TEX_ADDRESS)
417} XGL_TEX_ADDRESS;
418
419typedef enum _XGL_COMPARE_FUNC
420{
421 XGL_COMPARE_NEVER = 0x00000000,
422 XGL_COMPARE_LESS = 0x00000001,
423 XGL_COMPARE_EQUAL = 0x00000002,
424 XGL_COMPARE_LESS_EQUAL = 0x00000003,
425 XGL_COMPARE_GREATER = 0x00000004,
426 XGL_COMPARE_NOT_EQUAL = 0x00000005,
427 XGL_COMPARE_GREATER_EQUAL = 0x00000006,
428 XGL_COMPARE_ALWAYS = 0x00000007,
429
430 XGL_COMPARE_FUNC_BEGIN_RANGE = XGL_COMPARE_NEVER,
431 XGL_COMPARE_FUNC_END_RANGE = XGL_COMPARE_ALWAYS,
432 XGL_NUM_COMPARE_FUNC = (XGL_COMPARE_FUNC_END_RANGE - XGL_COMPARE_FUNC_BEGIN_RANGE + 1),
433 XGL_MAX_ENUM(_XGL_COMPARE_FUNC)
434} XGL_COMPARE_FUNC;
435
436typedef enum _XGL_FILL_MODE
437{
Jeremy Hayes4c329eb2015-01-14 14:58:37 -0700[diff] [blame]438 XGL_FILL_POINTS = 0x00000000,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]439 XGL_FILL_WIREFRAME = 0x00000001,
440 XGL_FILL_SOLID = 0x00000002,
441
Jeremy Hayes4c329eb2015-01-14 14:58:37 -0700[diff] [blame]442 XGL_FILL_MODE_BEGIN_RANGE = XGL_FILL_POINTS,
443 XGL_FILL_MODE_END_RANGE = XGL_FILL_SOLID,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]444 XGL_NUM_FILL_MODE = (XGL_FILL_MODE_END_RANGE - XGL_FILL_MODE_BEGIN_RANGE + 1),
445 XGL_MAX_ENUM(_XGL_FILL_MODE)
446} XGL_FILL_MODE;
447
448typedef enum _XGL_CULL_MODE
449{
450 XGL_CULL_NONE = 0x00000000,
451 XGL_CULL_FRONT = 0x00000001,
452 XGL_CULL_BACK = 0x00000002,
453 XGL_CULL_FRONT_AND_BACK = 0x00000003,
454
455 XGL_CULL_MODE_BEGIN_RANGE = XGL_CULL_NONE,
456 XGL_CULL_MODE_END_RANGE = XGL_CULL_FRONT_AND_BACK,
457 XGL_NUM_CULL_MODE = (XGL_CULL_MODE_END_RANGE - XGL_CULL_MODE_BEGIN_RANGE + 1),
458 XGL_MAX_ENUM(_XGL_CULL_MODE)
459} XGL_CULL_MODE;
460
461typedef enum _XGL_FACE_ORIENTATION
462{
463 XGL_FRONT_FACE_CCW = 0x00000000,
464 XGL_FRONT_FACE_CW = 0x00000001,
465
466 XGL_FACE_ORIENTATION_BEGIN_RANGE = XGL_FRONT_FACE_CCW,
467 XGL_FACE_ORIENTATION_END_RANGE = XGL_FRONT_FACE_CW,
468 XGL_NUM_FACE_ORIENTATION = (XGL_FACE_ORIENTATION_END_RANGE - XGL_FACE_ORIENTATION_BEGIN_RANGE + 1),
469 XGL_MAX_ENUM(_XGL_FACE_ORIENTATION)
470} XGL_FACE_ORIENTATION;
471
472typedef enum _XGL_BLEND
473{
474 XGL_BLEND_ZERO = 0x00000000,
475 XGL_BLEND_ONE = 0x00000001,
476 XGL_BLEND_SRC_COLOR = 0x00000002,
477 XGL_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
478 XGL_BLEND_DEST_COLOR = 0x00000004,
479 XGL_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
480 XGL_BLEND_SRC_ALPHA = 0x00000006,
481 XGL_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
482 XGL_BLEND_DEST_ALPHA = 0x00000008,
483 XGL_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
484 XGL_BLEND_CONSTANT_COLOR = 0x0000000a,
485 XGL_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
486 XGL_BLEND_CONSTANT_ALPHA = 0x0000000c,
487 XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
488 XGL_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
489 XGL_BLEND_SRC1_COLOR = 0x0000000f,
490 XGL_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
491 XGL_BLEND_SRC1_ALPHA = 0x00000011,
492 XGL_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
493
494 XGL_BLEND_BEGIN_RANGE = XGL_BLEND_ZERO,
495 XGL_BLEND_END_RANGE = XGL_BLEND_ONE_MINUS_SRC1_ALPHA,
496 XGL_NUM_BLEND = (XGL_BLEND_END_RANGE - XGL_BLEND_BEGIN_RANGE + 1),
497 XGL_MAX_ENUM(_XGL_BLEND)
498} XGL_BLEND;
499
500typedef enum _XGL_BLEND_FUNC
501{
502 XGL_BLEND_FUNC_ADD = 0x00000000,
503 XGL_BLEND_FUNC_SUBTRACT = 0x00000001,
504 XGL_BLEND_FUNC_REVERSE_SUBTRACT = 0x00000002,
505 XGL_BLEND_FUNC_MIN = 0x00000003,
506 XGL_BLEND_FUNC_MAX = 0x00000004,
507
508 XGL_BLEND_FUNC_BEGIN_RANGE = XGL_BLEND_FUNC_ADD,
509 XGL_BLEND_FUNC_END_RANGE = XGL_BLEND_FUNC_MAX,
510 XGL_NUM_BLEND_FUNC = (XGL_BLEND_FUNC_END_RANGE - XGL_BLEND_FUNC_BEGIN_RANGE + 1),
511 XGL_MAX_ENUM(_XGL_BLEND_FUNC)
512} XGL_BLEND_FUNC;
513
514typedef enum _XGL_STENCIL_OP
515{
516 XGL_STENCIL_OP_KEEP = 0x00000000,
517 XGL_STENCIL_OP_ZERO = 0x00000001,
518 XGL_STENCIL_OP_REPLACE = 0x00000002,
519 XGL_STENCIL_OP_INC_CLAMP = 0x00000003,
520 XGL_STENCIL_OP_DEC_CLAMP = 0x00000004,
521 XGL_STENCIL_OP_INVERT = 0x00000005,
522 XGL_STENCIL_OP_INC_WRAP = 0x00000006,
523 XGL_STENCIL_OP_DEC_WRAP = 0x00000007,
524
525 XGL_STENCIL_OP_BEGIN_RANGE = XGL_STENCIL_OP_KEEP,
526 XGL_STENCIL_OP_END_RANGE = XGL_STENCIL_OP_DEC_WRAP,
527 XGL_NUM_STENCIL_OP = (XGL_STENCIL_OP_END_RANGE - XGL_STENCIL_OP_BEGIN_RANGE + 1),
528 XGL_MAX_ENUM(_XGL_STENCIL_OP)
529} XGL_STENCIL_OP;
530
531typedef enum _XGL_LOGIC_OP
532{
533 XGL_LOGIC_OP_COPY = 0x00000000,
534 XGL_LOGIC_OP_CLEAR = 0x00000001,
535 XGL_LOGIC_OP_AND = 0x00000002,
536 XGL_LOGIC_OP_AND_REVERSE = 0x00000003,
537 XGL_LOGIC_OP_AND_INVERTED = 0x00000004,
538 XGL_LOGIC_OP_NOOP = 0x00000005,
539 XGL_LOGIC_OP_XOR = 0x00000006,
540 XGL_LOGIC_OP_OR = 0x00000007,
541 XGL_LOGIC_OP_NOR = 0x00000008,
542 XGL_LOGIC_OP_EQUIV = 0x00000009,
543 XGL_LOGIC_OP_INVERT = 0x0000000a,
544 XGL_LOGIC_OP_OR_REVERSE = 0x0000000b,
545 XGL_LOGIC_OP_COPY_INVERTED = 0x0000000c,
546 XGL_LOGIC_OP_OR_INVERTED = 0x0000000d,
547 XGL_LOGIC_OP_NAND = 0x0000000e,
548 XGL_LOGIC_OP_SET = 0x0000000f,
549
550 XGL_LOGIC_OP_BEGIN_RANGE = XGL_LOGIC_OP_COPY,
551 XGL_LOGIC_OP_END_RANGE = XGL_LOGIC_OP_SET,
552 XGL_NUM_LOGIC_OP = (XGL_LOGIC_OP_END_RANGE - XGL_LOGIC_OP_BEGIN_RANGE + 1),
553 XGL_MAX_ENUM(_XGL_LOGIC_OP)
554} XGL_LOGIC_OP;
555
556typedef enum _XGL_ATOMIC_OP
557{
558 XGL_ATOMIC_ADD_INT32 = 0x00000000,
559 XGL_ATOMIC_SUB_INT32 = 0x00000001,
560 XGL_ATOMIC_MIN_UINT32 = 0x00000002,
561 XGL_ATOMIC_MAX_UINT32 = 0x00000003,
562 XGL_ATOMIC_MIN_SINT32 = 0x00000004,
563 XGL_ATOMIC_MAX_SINT32 = 0x00000005,
564 XGL_ATOMIC_AND_INT32 = 0x00000006,
565 XGL_ATOMIC_OR_INT32 = 0x00000007,
566 XGL_ATOMIC_XOR_INT32 = 0x00000008,
567 XGL_ATOMIC_INC_UINT32 = 0x00000009,
568 XGL_ATOMIC_DEC_UINT32 = 0x0000000a,
569 XGL_ATOMIC_ADD_INT64 = 0x0000000b,
570 XGL_ATOMIC_SUB_INT64 = 0x0000000c,
571 XGL_ATOMIC_MIN_UINT64 = 0x0000000d,
572 XGL_ATOMIC_MAX_UINT64 = 0x0000000e,
573 XGL_ATOMIC_MIN_SINT64 = 0x0000000f,
574 XGL_ATOMIC_MAX_SINT64 = 0x00000010,
575 XGL_ATOMIC_AND_INT64 = 0x00000011,
576 XGL_ATOMIC_OR_INT64 = 0x00000012,
577 XGL_ATOMIC_XOR_INT64 = 0x00000013,
578 XGL_ATOMIC_INC_UINT64 = 0x00000014,
579 XGL_ATOMIC_DEC_UINT64 = 0x00000015,
580
581 XGL_ATOMIC_OP_BEGIN_RANGE = XGL_ATOMIC_ADD_INT32,
582 XGL_ATOMIC_OP_END_RANGE = XGL_ATOMIC_DEC_UINT64,
583 XGL_NUM_ATOMIC_OP = (XGL_ATOMIC_OP_END_RANGE - XGL_ATOMIC_OP_BEGIN_RANGE + 1),
584 XGL_MAX_ENUM(_XGL_ATOMIC_OP)
585} XGL_ATOMIC_OP;
586
587typedef enum _XGL_SYSTEM_ALLOC_TYPE
588{
589 XGL_SYSTEM_ALLOC_API_OBJECT = 0x00000000,
590 XGL_SYSTEM_ALLOC_INTERNAL = 0x00000001,
591 XGL_SYSTEM_ALLOC_INTERNAL_TEMP = 0x00000002,
592 XGL_SYSTEM_ALLOC_INTERNAL_SHADER = 0x00000003,
593 XGL_SYSTEM_ALLOC_DEBUG = 0x00000004,
594
595 XGL_SYSTEM_ALLOC_BEGIN_RANGE = XGL_SYSTEM_ALLOC_API_OBJECT,
596 XGL_SYSTEM_ALLOC_END_RANGE = XGL_SYSTEM_ALLOC_DEBUG,
597 XGL_NUM_SYSTEM_ALLOC_TYPE = (XGL_SYSTEM_ALLOC_END_RANGE - XGL_SYSTEM_ALLOC_BEGIN_RANGE + 1),
598 XGL_MAX_ENUM(_XGL_SYSTEM_ALLOC_TYPE)
599} XGL_SYSTEM_ALLOC_TYPE;
600
601typedef enum _XGL_HEAP_MEMORY_TYPE
602{
603 XGL_HEAP_MEMORY_OTHER = 0x00000000,
604 XGL_HEAP_MEMORY_LOCAL = 0x00000001,
605 XGL_HEAP_MEMORY_REMOTE = 0x00000002,
606 XGL_HEAP_MEMORY_EMBEDDED = 0x00000003,
607
608 XGL_HEAP_MEMORY_BEGIN_RANGE = XGL_HEAP_MEMORY_OTHER,
609 XGL_HEAP_MEMORY_END_RANGE = XGL_HEAP_MEMORY_EMBEDDED,
610 XGL_NUM_HEAP_MEMORY_TYPE = (XGL_HEAP_MEMORY_END_RANGE - XGL_HEAP_MEMORY_BEGIN_RANGE + 1),
611 XGL_MAX_ENUM(_XGL_HEAP_MEMORY_TYPE)
612} XGL_HEAP_MEMORY_TYPE;
613
614typedef enum _XGL_PHYSICAL_GPU_TYPE
615{
616 XGL_GPU_TYPE_OTHER = 0x00000000,
617 XGL_GPU_TYPE_INTEGRATED = 0x00000001,
618 XGL_GPU_TYPE_DISCRETE = 0x00000002,
619 XGL_GPU_TYPE_VIRTUAL = 0x00000003,
620
621 XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE = XGL_GPU_TYPE_OTHER,
622 XGL_PHYSICAL_GPU_TYPE_END_RANGE = XGL_GPU_TYPE_VIRTUAL,
623 XGL_NUM_PHYSICAL_GPU_TYPE = (XGL_PHYSICAL_GPU_TYPE_END_RANGE - XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1),
624 XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_TYPE)
625} XGL_PHYSICAL_GPU_TYPE;
626
627typedef enum _XGL_PHYSICAL_GPU_INFO_TYPE
628{
629 // Info type for xglGetGpuInfo()
630 XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES = 0x00000000,
631 XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE = 0x00000001,
632 XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES = 0x00000002,
633 XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES = 0x00000003,
634
635 XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_INFO_TYPE)
636} XGL_PHYSICAL_GPU_INFO_TYPE;
637
638typedef enum _XGL_MEMORY_HEAP_INFO_TYPE
639{
640 // Info type for xglGetMemoryHeapInfo()
641 XGL_INFO_TYPE_MEMORY_HEAP_PROPERTIES = 0x00000000,
642
643 XGL_MAX_ENUM(_XGL_MEMORY_HEAP_INFO_TYPE)
644} XGL_MEMORY_HEAP_INFO_TYPE;
645
646typedef enum _XGL_FORMAT_INFO_TYPE
647{
648 // Info type for xlgGetFormatInfo()
649 XGL_INFO_TYPE_FORMAT_PROPERTIES = 0x00000000,
650
651 XGL_MAX_ENUM(_XGL_FORMAT_INFO_TYPE)
652} XGL_FORMAT_INFO_TYPE;
653
654typedef enum _XGL_SUBRESOURCE_INFO_TYPE
655{
656 // Info type for xglGetImageSubresourceInfo()
657 XGL_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000,
658
659 XGL_MAX_ENUM(_XGL_SUBRESOURCE_INFO_TYPE)
660} XGL_SUBRESOURCE_INFO_TYPE;
661
662typedef enum _XGL_OBJECT_INFO_TYPE
663{
664 // Info type for xglGetObjectInfo()
665 XGL_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000000,
666
667 XGL_MAX_ENUM(_XGL_OBJECT_INFO_TYPE)
668} XGL_OBJECT_INFO_TYPE;
669
670typedef enum _XGL_VALIDATION_LEVEL
671{
672 XGL_VALIDATION_LEVEL_0 = 0x00000000,
673 XGL_VALIDATION_LEVEL_1 = 0x00000001,
674 XGL_VALIDATION_LEVEL_2 = 0x00000002,
675 XGL_VALIDATION_LEVEL_3 = 0x00000003,
676 XGL_VALIDATION_LEVEL_4 = 0x00000004,
677
678 XGL_VALIDATION_LEVEL_BEGIN_RANGE = XGL_VALIDATION_LEVEL_0,
679 XGL_VALIDATION_LEVEL_END_RANGE = XGL_VALIDATION_LEVEL_4,
680 XGL_NUM_VALIDATION_LEVEL = (XGL_VALIDATION_LEVEL_END_RANGE - XGL_VALIDATION_LEVEL_BEGIN_RANGE + 1),
681
682 XGL_MAX_ENUM(_XGL_VALIDATION_LEVEL)
683} XGL_VALIDATION_LEVEL;
684
685// ------------------------------------------------------------------------------------------------
686// Error and return codes
687
688typedef enum _XGL_RESULT_CODE
689{
690 // Return codes for successful operation execution (>= 0)
691 XGL_SUCCESS = 0x0000000,
692 XGL_UNSUPPORTED = 0x0000001,
693 XGL_NOT_READY = 0x0000002,
694 XGL_TIMEOUT = 0x0000003,
695 XGL_EVENT_SET = 0x0000004,
696 XGL_EVENT_RESET = 0x0000005,
697
698 // Error codes (negative values)
699 XGL_ERROR_UNKNOWN = -(0x00000001),
700 XGL_ERROR_UNAVAILABLE = -(0x00000002),
701 XGL_ERROR_INITIALIZATION_FAILED = -(0x00000003),
702 XGL_ERROR_OUT_OF_MEMORY = -(0x00000004),
703 XGL_ERROR_OUT_OF_GPU_MEMORY = -(0x00000005),
704 XGL_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006),
705 XGL_ERROR_DEVICE_LOST = -(0x00000007),
706 XGL_ERROR_INVALID_POINTER = -(0x00000008),
707 XGL_ERROR_INVALID_VALUE = -(0x00000009),
708 XGL_ERROR_INVALID_HANDLE = -(0x0000000A),
709 XGL_ERROR_INVALID_ORDINAL = -(0x0000000B),
710 XGL_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C),
711 XGL_ERROR_INVALID_EXTENSION = -(0x0000000D),
712 XGL_ERROR_INVALID_FLAGS = -(0x0000000E),
713 XGL_ERROR_INVALID_ALIGNMENT = -(0x0000000F),
714 XGL_ERROR_INVALID_FORMAT = -(0x00000010),
715 XGL_ERROR_INVALID_IMAGE = -(0x00000011),
716 XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012),
717 XGL_ERROR_INVALID_QUEUE_TYPE = -(0x00000013),
718 XGL_ERROR_INVALID_OBJECT_TYPE = -(0x00000014),
719 XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015),
720 XGL_ERROR_BAD_SHADER_CODE = -(0x00000016),
721 XGL_ERROR_BAD_PIPELINE_DATA = -(0x00000017),
722 XGL_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018),
723 XGL_ERROR_NOT_MAPPABLE = -(0x00000019),
724 XGL_ERROR_MEMORY_MAP_FAILED = -(0x0000001A),
725 XGL_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B),
726 XGL_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C),
727 XGL_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D),
728 XGL_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E),
729 XGL_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F),
730 XGL_ERROR_MEMORY_NOT_BOUND = -(0x00000020),
731 XGL_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021),
732 XGL_ERROR_NOT_SHAREABLE = -(0x00000022),
733} XGL_RESULT;
734
735// ------------------------------------------------------------------------------------------------
736// XGL format definitions
737
738typedef enum _XGL_CHANNEL_FORMAT
739{
740 XGL_CH_FMT_UNDEFINED = 0,
741 XGL_CH_FMT_R4G4 = 1,
742 XGL_CH_FMT_R4G4B4A4 = 2,
743 XGL_CH_FMT_R5G6B5 = 3,
744 XGL_CH_FMT_B5G6R5 = 4,
745 XGL_CH_FMT_R5G5B5A1 = 5,
746 XGL_CH_FMT_R8 = 6,
747 XGL_CH_FMT_R8G8 = 7,
748 XGL_CH_FMT_R8G8B8A8 = 8,
749 XGL_CH_FMT_B8G8R8A8 = 9,
750 XGL_CH_FMT_R10G11B11 = 10,
751 XGL_CH_FMT_R11G11B10 = 11,
752 XGL_CH_FMT_R10G10B10A2 = 12,
753 XGL_CH_FMT_R16 = 13,
754 XGL_CH_FMT_R16G16 = 14,
755 XGL_CH_FMT_R16G16B16A16 = 15,
756 XGL_CH_FMT_R32 = 16,
757 XGL_CH_FMT_R32G32 = 17,
758 XGL_CH_FMT_R32G32B32 = 18,
759 XGL_CH_FMT_R32G32B32A32 = 19,
760 XGL_CH_FMT_R16G8 = 20,
761 XGL_CH_FMT_R32G8 = 21,
762 XGL_CH_FMT_R9G9B9E5 = 22,
763 XGL_CH_FMT_BC1 = 23,
764 XGL_CH_FMT_BC2 = 24,
765 XGL_CH_FMT_BC3 = 25,
766 XGL_CH_FMT_BC4 = 26,
767 XGL_CH_FMT_BC5 = 27,
768 XGL_CH_FMT_BC6U = 28,
769 XGL_CH_FMT_BC6S = 29,
770 XGL_CH_FMT_BC7 = 30,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]771// IMG CHANGE BEGIN - support for vertex input description
772 XGL_CH_FMT_R8G8B8 = 31,
773 XGL_CH_FMT_R16G16B16 = 32,
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]774
775 // optional? TBD'
776 XGL_CH_FMT_B10G10R10A2 = 33,
777 XGL_CH_FMT_R64 = 34,
778 XGL_CH_FMT_R64G64 = 35,
779 XGL_CH_FMT_R64G64B64 = 36,
780 XGL_CH_FMT_R64G64B64A64 = 37,
781
782 XGL_MAX_CH_FMT = XGL_CH_FMT_R64G64B64A64,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]783// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]784 XGL_MAX_ENUM(_XGL_CHANNEL_FORMAT)
785} XGL_CHANNEL_FORMAT;
786
787typedef enum _XGL_NUM_FORMAT
788{
789 XGL_NUM_FMT_UNDEFINED = 0,
790 XGL_NUM_FMT_UNORM = 1,
791 XGL_NUM_FMT_SNORM = 2,
792 XGL_NUM_FMT_UINT = 3,
793 XGL_NUM_FMT_SINT = 4,
794 XGL_NUM_FMT_FLOAT = 5,
795 XGL_NUM_FMT_SRGB = 6,
796 XGL_NUM_FMT_DS = 7,
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]797// IMG CHANGE BEGIN - support for vertex input description
798 XGL_NUM_FMT_USCALED = 8,
799 XGL_NUM_FMT_SSCALED = 9,
800 XGL_MAX_NUM_FMT = XGL_NUM_FMT_SSCALED,
801// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]802 XGL_MAX_ENUM(_XGL_NUM_FORMAT)
803} XGL_NUM_FORMAT;
804
805typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
806{
807 XGL_PROVOKING_VERTEX_FIRST = 0,
808 XGL_PROVOKING_VERTEX_LAST = 1,
809
810 XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
811 XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
812 XGL_NUM_PROVOKING_VERTEX_CONVENTIONS = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
813 XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
814} XGL_PROVOKING_VERTEX_CONVENTION;
815
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]816// IMG CHANGE BEGIN - support for vertex input description
817typedef enum _XGL_VERTEX_INPUT_STEP_RATE
818{
819 XGL_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0,
820 XGL_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1,
821 XGL_VERTEX_INPUT_STEP_RATE_DRAW = 0x2,
822 XGL_MAX_ENUM(_XGL_VERTEX_INPUT_STEP_RATE)
823} XGL_VERTEX_INPUT_STEP_RATE;
824// IMG CHANGE END
825
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]826typedef struct _XGL_FORMAT
827{
828 XGL_CHANNEL_FORMAT channelFormat;
829 XGL_NUM_FORMAT numericFormat;
830} XGL_FORMAT;
831
832// Shader stage enumerant
833typedef enum _XGL_PIPELINE_SHADER_STAGE
834{
835 XGL_SHADER_STAGE_VERTEX = 0,
836 XGL_SHADER_STAGE_TESS_CONTROL = 1,
837 XGL_SHADER_STAGE_TESS_EVALUATION = 2,
838 XGL_SHADER_STAGE_GEOMETRY = 3,
839 XGL_SHADER_STAGE_FRAGMENT = 4,
840 XGL_SHADER_STAGE_COMPUTE = 5,
841 XGL_MAX_ENUM(_XGL_PIPELINE_SHADER_STAGE)
842} XGL_PIPELINE_SHADER_STAGE;
843
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]844// Graphics workload submit type. Used for rendering workloads.
845typedef enum _XGL_RENDER_PASS_OPERATION
846{
847 XGL_RENDER_PASS_OPERATION_BEGIN, // Start rendering
848 XGL_RENDER_PASS_OPERATION_CONTINUE, // Continue rendering
849 XGL_RENDER_PASS_OPERATION_END, // End rendering
850 XGL_RENDER_PASS_OPERATION_BEGIN_AND_END, // Start and finish rendering in a single command buffer
851
852 XGL_MAX_ENUM(_XGL_RENDER_PASS_OPERATION)
853} XGL_RENDER_PASS_OPERATION;
854
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]855// Structure type enumerant
856typedef enum _XGL_STRUCTURE_TYPE
857{
858 XGL_STRUCTURE_TYPE_APPLICATION_INFO = 0,
859 XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
860 XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
861 XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4,
862 XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]863 XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 6,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]864 XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]865 XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION = 8,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]866 XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9,
867 XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10,
868 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11,
869 XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12,
870 XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13,
871 XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14,
872 XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO = 15,
873 XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO = 16,
874 XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO = 17,
875 XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO = 18,
876 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO = 19,
877 XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
878 XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
879 XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
880 XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23,
881 XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24,
882 XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
883 XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
884 XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
Courtney Goeltzenleuchter7f11ed22014-08-15 14:54:58 -0600[diff] [blame]885 XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 28,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]886 XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO = 29,
887 XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 30,
888 XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 31,
889 XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 32,
890 XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 33,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]891 XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 37,
892 XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 38,
893 XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 39,
894 XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 40,
895 XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 41,
896 XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 42,
897 XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO = 43,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]898// IMG CHANGE BEGIN - support for vertex input description
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]899 XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 90,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]900// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]901 XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
902} XGL_STRUCTURE_TYPE;
903
904// ------------------------------------------------------------------------------------------------
905// Flags
906
907// Device creation flags
908typedef enum _XGL_DEVICE_CREATE_FLAGS
909{
910 XGL_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
911 XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002,
912} XGL_DEVICE_CREATE_FLAGS;
913
914// Queue capabilities
915typedef enum _XGL_QUEUE_FLAGS
916{
917 XGL_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations
918 XGL_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations
919 XGL_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations
920 XGL_QUEUE_EXTENDED_BIT = 0x80000000 // Extended queue
921} XGL_QUEUE_FLAGS;
922
923// Memory heap properties
924typedef enum _XGL_MEMORY_HEAP_FLAGS
925{
926 XGL_MEMORY_HEAP_CPU_VISIBLE_BIT = 0x00000001,
927 XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT = 0x00000002,
928 XGL_MEMORY_HEAP_CPU_UNCACHED_BIT = 0x00000004,
929 XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT = 0x00000008,
930 XGL_MEMORY_HEAP_HOLDS_PINNED_BIT = 0x00000010,
931 XGL_MEMORY_HEAP_SHAREABLE_BIT = 0x00000020,
932} XGL_MEMORY_HEAP_FLAGS;
933
934// Memory allocation flags
935typedef enum _XGL_MEMORY_ALLOC_FLAGS
936{
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]937 XGL_MEMORY_ALLOC_SHAREABLE_BIT = 0x00000001,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]938} XGL_MEMORY_ALLOC_FLAGS;
939
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]940// Buffer usage flags
941typedef enum _XGL_BUFFER_USAGE_FLAGS
942{
943 XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001, // Shader read (e.g. TBO, image buffer, UBO, SBBO)
944 XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002, // Shader write (e.g. image buffer, SSBO)
945 XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004, // Shader atomic operations (e.g. image buffer, SSBO)
946 XGL_BUFFER_USAGE_UNIFORM_READ_BIT = 0x00000008, // Uniform read (UBO)
947 XGL_BUFFER_USAGE_INDEX_FETCH_BIT = 0x00000010, // Fixed function index fetch (index buffer)
948 XGL_BUFFER_USAGE_VERTEX_FETCH_BIT = 0x00000020, // Fixed function vertex fetch (VBO)
949 XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT = 0x00000040, // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
950} XGL_BUFFER_USAGE_FLAGS;
951
952// Buffer flags
953typedef enum _XGL_BUFFER_CREATE_FLAGS
954{
955 XGL_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001,
956 XGL_BUFFER_CREATE_SPARSE_BIT = 0x00000002,
957} XGL_BUFFER_CREATE_FLAGS;
958
959typedef enum _XGL_BUFFER_VIEW_TYPE
960{
961 XGL_BUFFER_VIEW_RAW = 0x00000000, // Raw buffer without special structure (e.g. UBO, SSBO, indirect and parameter buffers)
962 XGL_BUFFER_VIEW_TYPED = 0x00000001, // Typed buffer, format and channels are used (TBO, image buffer)
963 XGL_BUFFER_VIEW_STRUCTURED = 0x00000002, // Structured buffer, stride is used (VBO, DX-style structured buffer)
964
965 XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE = XGL_BUFFER_VIEW_RAW,
966 XGL_BUFFER_VIEW_TYPE_END_RANGE = XGL_BUFFER_VIEW_STRUCTURED,
967 XGL_NUM_BUFFER_VIEW_TYPE = (XGL_BUFFER_VIEW_TYPE_END_RANGE - XGL_BUFFER_VIEW_TYPE_BEGIN_RANGE + 1),
968 XGL_MAX_ENUM(_XGL_BUFFER_VIEW_TYPE)
969} XGL_BUFFER_VIEW_TYPE;
970
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]971// Image usage flags
972typedef enum _XGL_IMAGE_USAGE_FLAGS
973{
974 XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001,
975 XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]976 XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT = 0x00000004,
977 XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000008,
978 XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000010,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]979} XGL_IMAGE_USAGE_FLAGS;
980
981// Image flags
982typedef enum _XGL_IMAGE_CREATE_FLAGS
983{
984 XGL_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
985 XGL_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002,
986 XGL_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]987 XGL_IMAGE_CREATE_SPARSE_BIT = 0x00000008,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]988} XGL_IMAGE_CREATE_FLAGS;
989
990// Depth-stencil view creation flags
991typedef enum _XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
992{
993 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
994 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
995} XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS;
996
997// Pipeline creation flags
998typedef enum _XGL_PIPELINE_CREATE_FLAGS
999{
1000 XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
1001} XGL_PIPELINE_CREATE_FLAGS;
1002
1003// Semaphore creation flags
1004typedef enum _XGL_SEMAPHORE_CREATE_FLAGS
1005{
1006 XGL_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001,
1007} XGL_SEMAPHORE_CREATE_FLAGS;
1008
1009// Memory reference flags
1010typedef enum _XGL_MEMORY_REF_FLAGS
1011{
1012 XGL_MEMORY_REF_READ_ONLY_BIT = 0x00000001,
1013} XGL_MEMORY_REF_FLAGS;
1014
1015// Format capability flags
1016typedef enum _XGL_FORMAT_FEATURE_FLAGS
1017{
1018 XGL_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001,
1019 XGL_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002,
1020 XGL_FORMAT_IMAGE_COPY_BIT = 0x00000004,
1021 XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT = 0x00000008,
1022 XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT = 0x00000010,
1023 XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000020,
1024 XGL_FORMAT_DEPTH_ATTACHMENT_BIT = 0x00000040,
1025 XGL_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080,
1026 XGL_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100,
1027 XGL_FORMAT_CONVERSION_BIT = 0x00000200,
1028} XGL_FORMAT_FEATURE_FLAGS;
1029
1030// Query flags
1031typedef enum _XGL_QUERY_CONTROL_FLAGS
1032{
1033 XGL_QUERY_IMPRECISE_DATA_BIT = 0x00000001,
1034} XGL_QUERY_CONTROL_FLAGS;
1035
1036// GPU compatibility flags
1037typedef enum _XGL_GPU_COMPATIBILITY_FLAGS
1038{
1039 XGL_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001,
1040 XGL_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002,
1041 XGL_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004,
1042 XGL_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008,
1043 XGL_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010,
1044 XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020,
1045 XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040,
1046} XGL_GPU_COMPATIBILITY_FLAGS;
1047
1048// Command buffer building flags
1049typedef enum _XGL_CMD_BUFFER_BUILD_FLAGS
1050{
1051 XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001,
1052 XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
1053 XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
1054 XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
1055} XGL_CMD_BUFFER_BUILD_FLAGS;
1056
1057// ------------------------------------------------------------------------------------------------
1058// XGL structures
1059
1060typedef struct _XGL_OFFSET2D
1061{
1062 XGL_INT x;
1063 XGL_INT y;
1064} XGL_OFFSET2D;
1065
1066typedef struct _XGL_OFFSET3D
1067{
1068 XGL_INT x;
1069 XGL_INT y;
1070 XGL_INT z;
1071} XGL_OFFSET3D;
1072
1073typedef struct _XGL_EXTENT2D
1074{
1075 XGL_INT width;
1076 XGL_INT height;
1077} XGL_EXTENT2D;
1078
1079typedef struct _XGL_EXTENT3D
1080{
1081 XGL_INT width;
1082 XGL_INT height;
1083 XGL_INT depth;
1084} XGL_EXTENT3D;
1085
1086typedef struct _XGL_VIEWPORT
1087{
1088 XGL_FLOAT originX;
1089 XGL_FLOAT originY;
1090 XGL_FLOAT width;
1091 XGL_FLOAT height;
1092 XGL_FLOAT minDepth;
1093 XGL_FLOAT maxDepth;
1094} XGL_VIEWPORT;
1095
1096typedef struct _XGL_RECT
1097{
1098 XGL_OFFSET2D offset;
1099 XGL_EXTENT2D extent;
1100} XGL_RECT;
1101
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1102typedef struct _XGL_CHANNEL_MAPPING
1103{
1104 XGL_CHANNEL_SWIZZLE r;
1105 XGL_CHANNEL_SWIZZLE g;
1106 XGL_CHANNEL_SWIZZLE b;
1107 XGL_CHANNEL_SWIZZLE a;
1108} XGL_CHANNEL_MAPPING;
1109
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1110typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
1111{
1112 XGL_SIZE structSize;
1113 XGL_UINT32 apiVersion;
1114 XGL_UINT32 driverVersion;
1115 XGL_UINT32 vendorId;
1116 XGL_UINT32 deviceId;
1117 XGL_PHYSICAL_GPU_TYPE gpuType;
1118 XGL_CHAR gpuName[XGL_MAX_PHYSICAL_GPU_NAME];
1119 XGL_UINT maxMemRefsPerSubmission;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1120 XGL_GPU_SIZE maxInlineMemoryUpdateSize;
1121 XGL_UINT maxBoundDescriptorSets;
1122 XGL_UINT maxThreadGroupSize;
1123 XGL_UINT64 timestampFrequency;
1124 XGL_BOOL multiColorAttachmentClears;
1125} XGL_PHYSICAL_GPU_PROPERTIES;
1126
1127typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE
1128{
1129 XGL_FLOAT maxGpuClock;
1130 XGL_FLOAT aluPerClock;
1131 XGL_FLOAT texPerClock;
1132 XGL_FLOAT primsPerClock;
1133 XGL_FLOAT pixelsPerClock;
1134} XGL_PHYSICAL_GPU_PERFORMANCE;
1135
1136typedef struct _XGL_GPU_COMPATIBILITY_INFO
1137{
1138 XGL_FLAGS compatibilityFlags; // XGL_GPU_COMPATIBILITY_FLAGS
1139} XGL_GPU_COMPATIBILITY_INFO;
1140
1141typedef struct _XGL_APPLICATION_INFO
1142{
1143 XGL_STRUCTURE_TYPE sType; // Type of structure. Should be XGL_STRUCTURE_TYPE_APPLICATION_INFO
1144 XGL_VOID* pNext; // Next structure in chain
1145 const XGL_CHAR* pAppName;
1146 XGL_UINT32 appVersion;
1147 const XGL_CHAR* pEngineName;
1148 XGL_UINT32 engineVersion;
1149 XGL_UINT32 apiVersion;
1150} XGL_APPLICATION_INFO;
1151
1152typedef XGL_VOID* (XGLAPI *XGL_ALLOC_FUNCTION)(
1153 XGL_VOID* pUserData,
1154 XGL_SIZE size,
1155 XGL_SIZE alignment,
1156 XGL_SYSTEM_ALLOC_TYPE allocType);
1157
1158typedef XGL_VOID (XGLAPI *XGL_FREE_FUNCTION)(
1159 XGL_VOID* pUserData,
1160 XGL_VOID* pMem);
1161
1162typedef struct _XGL_ALLOC_CALLBACKS
1163{
1164 XGL_VOID* pUserData;
1165 XGL_ALLOC_FUNCTION pfnAlloc;
1166 XGL_FREE_FUNCTION pfnFree;
1167} XGL_ALLOC_CALLBACKS;
1168
1169typedef struct _XGL_DEVICE_QUEUE_CREATE_INFO
1170{
1171 XGL_UINT queueNodeIndex;
1172 XGL_UINT queueCount;
1173} XGL_DEVICE_QUEUE_CREATE_INFO;
1174
1175typedef struct _XGL_DEVICE_CREATE_INFO
1176{
1177 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO
1178 XGL_VOID* pNext; // Pointer to next structure
1179 XGL_UINT queueRecordCount;
1180 const XGL_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues;
1181 XGL_UINT extensionCount;
1182 const XGL_CHAR*const* ppEnabledExtensionNames;
1183 XGL_VALIDATION_LEVEL maxValidationLevel;
1184 XGL_FLAGS flags; // XGL_DEVICE_CREATE_FLAGS
1185} XGL_DEVICE_CREATE_INFO;
1186
Jon Ashburn183dfd02014-10-22 18:13:16 -0600[diff] [blame]1187typedef struct _XGL_LAYER_CREATE_INFO
1188{
1189 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO
1190 XGL_VOID* pNext; // Pointer to next structure
1191 XGL_UINT layerCount;
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]1192 const XGL_CHAR *const* ppActiveLayerNames; // layer name from the layer's xglEnumerateLayers())
Jon Ashburn183dfd02014-10-22 18:13:16 -0600[diff] [blame]1193} XGL_LAYER_CREATE_INFO;
1194
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1195typedef struct _XGL_PHYSICAL_GPU_QUEUE_PROPERTIES
1196{
1197 XGL_SIZE structSize; // Size of structure in bytes
1198 XGL_FLAGS queueFlags; // XGL_QUEUE_FLAGS
1199 XGL_UINT queueCount;
1200 XGL_UINT maxAtomicCounters;
1201 XGL_BOOL supportsTimestamps;
1202} XGL_PHYSICAL_GPU_QUEUE_PROPERTIES;
1203
1204typedef struct _XGL_PHYSICAL_GPU_MEMORY_PROPERTIES
1205{
1206 XGL_SIZE structSize; // Size of structure in bytes
1207 XGL_BOOL supportsMigration;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1208 XGL_BOOL supportsPinning;
1209} XGL_PHYSICAL_GPU_MEMORY_PROPERTIES;
1210
1211typedef struct _XGL_MEMORY_HEAP_PROPERTIES
1212{
1213 XGL_SIZE structSize; // Size of structure in bytes
1214 XGL_HEAP_MEMORY_TYPE heapMemoryType; // XGL_HEAP_MEMORY_TYPE
1215 XGL_GPU_SIZE heapSize; // Specified in bytes
1216 XGL_GPU_SIZE pageSize; // Specified in bytes
1217 XGL_FLAGS flags; // XGL_MEMORY_HEAP_FLAGS
1218 XGL_FLOAT gpuReadPerfRating;
1219 XGL_FLOAT gpuWritePerfRating;
1220 XGL_FLOAT cpuReadPerfRating;
1221 XGL_FLOAT cpuWritePerfRating;
1222} XGL_MEMORY_HEAP_PROPERTIES;
1223
1224typedef struct _XGL_MEMORY_ALLOC_INFO
1225{
1226 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
1227 XGL_VOID* pNext; // Pointer to next structure
1228 XGL_GPU_SIZE allocationSize; // Size of memory allocation
1229 XGL_GPU_SIZE alignment;
1230 XGL_FLAGS flags; // XGL_MEMORY_ALLOC_FLAGS
1231 XGL_UINT heapCount;
1232 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1233 XGL_MEMORY_PRIORITY memPriority;
1234} XGL_MEMORY_ALLOC_INFO;
1235
1236typedef struct _XGL_MEMORY_OPEN_INFO
1237{
1238 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO
1239 XGL_VOID* pNext; // Pointer to next structure
1240 XGL_GPU_MEMORY sharedMem;
1241} XGL_MEMORY_OPEN_INFO;
1242
1243typedef struct _XGL_PEER_MEMORY_OPEN_INFO
1244{
1245 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
1246 XGL_VOID* pNext; // Pointer to next structure
1247 XGL_GPU_MEMORY originalMem;
1248} XGL_PEER_MEMORY_OPEN_INFO;
1249
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1250typedef struct _XGL_MEMORY_REQUIREMENTS
1251{
1252 XGL_GPU_SIZE size; // Specified in bytes
1253 XGL_GPU_SIZE alignment; // Specified in bytes
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1254 XGL_GPU_SIZE granularity; // Granularity on which xglBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1255 XGL_UINT heapCount;
1256 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1257} XGL_MEMORY_REQUIREMENTS;
1258
1259typedef struct _XGL_FORMAT_PROPERTIES
1260{
1261 XGL_FLAGS linearTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1262 XGL_FLAGS optimalTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1263} XGL_FORMAT_PROPERTIES;
1264
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1265typedef struct _XGL_BUFFER_VIEW_ATTACH_INFO
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1266{
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1267 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1268 XGL_VOID* pNext; // Pointer to next structure
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1269 XGL_BUFFER_VIEW view;
1270 XGL_BUFFER_STATE state;
1271} XGL_BUFFER_VIEW_ATTACH_INFO;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1272
1273typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
1274{
1275 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
1276 XGL_VOID* pNext; // Pointer to next structure
1277 XGL_IMAGE_VIEW view;
1278 XGL_IMAGE_STATE state;
1279} XGL_IMAGE_VIEW_ATTACH_INFO;
1280
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1281typedef struct _XGL_BUFFER_STATE_TRANSITION
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1282{
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1283 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1284 XGL_VOID* pNext; // Pointer to next structure
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1285 XGL_BUFFER buffer;
1286 XGL_BUFFER_STATE oldState;
1287 XGL_BUFFER_STATE newState;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1288 XGL_GPU_SIZE offset;
1289 XGL_GPU_SIZE regionSize;
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1290} XGL_BUFFER_STATE_TRANSITION;
1291
1292typedef struct _XGL_BUFFER_CREATE_INFO
1293{
1294 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO
1295 const XGL_VOID* pNext; // Pointer to next structure.
1296 XGL_GPU_SIZE size; // Specified in bytes
1297 XGL_FLAGS usage; // XGL_BUFFER_USAGE_FLAGS
1298 XGL_FLAGS flags; // XGL_BUFFER_CREATE_FLAGS
1299} XGL_BUFFER_CREATE_INFO;
1300
1301typedef struct _XGL_BUFFER_VIEW_CREATE_INFO
1302{
1303 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO
1304 const XGL_VOID* pNext; // Pointer to next structure.
1305 XGL_BUFFER buffer;
1306 XGL_BUFFER_VIEW_TYPE viewType;
1307 XGL_GPU_SIZE stride; // Optionally specifies stride between elements
1308 XGL_FORMAT format; // Optionally specifies format of elements
1309 XGL_CHANNEL_MAPPING channels; // Optionally specifies format channel mapping
1310 XGL_GPU_SIZE offset; // Specified in bytes
1311 XGL_GPU_SIZE range; // View size specified in bytes
1312} XGL_BUFFER_VIEW_CREATE_INFO;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1313
1314typedef struct _XGL_IMAGE_SUBRESOURCE
1315{
1316 XGL_IMAGE_ASPECT aspect;
1317 XGL_UINT mipLevel;
1318 XGL_UINT arraySlice;
1319} XGL_IMAGE_SUBRESOURCE;
1320
1321typedef struct _XGL_IMAGE_SUBRESOURCE_RANGE
1322{
1323 XGL_IMAGE_ASPECT aspect;
1324 XGL_UINT baseMipLevel;
1325 XGL_UINT mipLevels;
1326 XGL_UINT baseArraySlice;
1327 XGL_UINT arraySize;
1328} XGL_IMAGE_SUBRESOURCE_RANGE;
1329
1330typedef struct _XGL_IMAGE_STATE_TRANSITION
1331{
1332 XGL_IMAGE image;
1333 XGL_IMAGE_STATE oldState;
1334 XGL_IMAGE_STATE newState;
1335 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1336} XGL_IMAGE_STATE_TRANSITION;
1337
1338typedef struct _XGL_IMAGE_CREATE_INFO
1339{
1340 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
1341 const XGL_VOID* pNext; // Pointer to next structure.
1342 XGL_IMAGE_TYPE imageType;
1343 XGL_FORMAT format;
1344 XGL_EXTENT3D extent;
1345 XGL_UINT mipLevels;
1346 XGL_UINT arraySize;
1347 XGL_UINT samples;
1348 XGL_IMAGE_TILING tiling;
1349 XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS
1350 XGL_FLAGS flags; // XGL_IMAGE_CREATE_FLAGS
1351} XGL_IMAGE_CREATE_INFO;
1352
1353typedef struct _XGL_PEER_IMAGE_OPEN_INFO
1354{
1355 XGL_IMAGE originalImage;
1356} XGL_PEER_IMAGE_OPEN_INFO;
1357
1358typedef struct _XGL_SUBRESOURCE_LAYOUT
1359{
1360 XGL_GPU_SIZE offset; // Specified in bytes
1361 XGL_GPU_SIZE size; // Specified in bytes
1362 XGL_GPU_SIZE rowPitch; // Specified in bytes
1363 XGL_GPU_SIZE depthPitch; // Specified in bytes
1364} XGL_SUBRESOURCE_LAYOUT;
1365
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1366typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
1367{
1368 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
1369 const XGL_VOID* pNext; // Pointer to next structure
1370 XGL_IMAGE image;
1371 XGL_IMAGE_VIEW_TYPE viewType;
1372 XGL_FORMAT format;
1373 XGL_CHANNEL_MAPPING channels;
1374 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1375 XGL_FLOAT minLod;
1376} XGL_IMAGE_VIEW_CREATE_INFO;
1377
1378typedef struct _XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1379{
1380 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1381 XGL_VOID* pNext; // Pointer to next structure
1382 XGL_IMAGE image;
1383 XGL_FORMAT format;
1384 XGL_UINT mipLevel;
1385 XGL_UINT baseArraySlice;
1386 XGL_UINT arraySize;
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]1387 XGL_IMAGE msaaResolveImage;
1388 XGL_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1389} XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO;
1390
1391typedef struct _XGL_DEPTH_STENCIL_VIEW_CREATE_INFO
1392{
1393 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
1394 const XGL_VOID* pNext; // Pointer to next structure
1395 XGL_IMAGE image;
1396 XGL_UINT mipLevel;
1397 XGL_UINT baseArraySlice;
1398 XGL_UINT arraySize;
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]1399 XGL_IMAGE msaaResolveImage;
1400 XGL_IMAGE_SUBRESOURCE_RANGE msaaResolveSubResource;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1401 XGL_FLAGS flags; // XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
1402} XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
1403
1404typedef struct _XGL_COLOR_ATTACHMENT_BIND_INFO
1405{
1406 XGL_COLOR_ATTACHMENT_VIEW view;
1407 XGL_IMAGE_STATE colorAttachmentState; // XGL_IMAGE_STATE
1408} XGL_COLOR_ATTACHMENT_BIND_INFO;
1409
1410typedef struct _XGL_DEPTH_STENCIL_BIND_INFO
1411{
1412 XGL_DEPTH_STENCIL_VIEW view;
1413 XGL_IMAGE_STATE depthState; // XGL_IMAGE_STATE
1414 XGL_IMAGE_STATE stencilState; // XGL_IMAGE_STATE
1415} XGL_DEPTH_STENCIL_BIND_INFO;
1416
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1417typedef struct _XGL_BUFFER_COPY
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1418{
1419 XGL_GPU_SIZE srcOffset; // Specified in bytes
1420 XGL_GPU_SIZE destOffset; // Specified in bytes
1421 XGL_GPU_SIZE copySize; // Specified in bytes
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1422} XGL_BUFFER_COPY;
1423
1424typedef struct _XGL_IMAGE_MEMORY_BIND_INFO
1425{
1426 XGL_IMAGE_SUBRESOURCE subresource;
1427 XGL_OFFSET3D offset;
1428 XGL_EXTENT3D extent;
1429} XGL_IMAGE_MEMORY_BIND_INFO;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1430
1431typedef struct _XGL_IMAGE_COPY
1432{
1433 XGL_IMAGE_SUBRESOURCE srcSubresource;
1434 XGL_OFFSET3D srcOffset;
1435 XGL_IMAGE_SUBRESOURCE destSubresource;
1436 XGL_OFFSET3D destOffset;
1437 XGL_EXTENT3D extent;
1438} XGL_IMAGE_COPY;
1439
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1440typedef struct _XGL_BUFFER_IMAGE_COPY
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1441{
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1442 XGL_GPU_SIZE bufferOffset; // Specified in bytes
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1443 XGL_IMAGE_SUBRESOURCE imageSubresource;
1444 XGL_OFFSET3D imageOffset;
1445 XGL_EXTENT3D imageExtent;
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1446} XGL_BUFFER_IMAGE_COPY;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1447
1448typedef struct _XGL_IMAGE_RESOLVE
1449{
1450 XGL_IMAGE_SUBRESOURCE srcSubresource;
1451 XGL_OFFSET2D srcOffset;
1452 XGL_IMAGE_SUBRESOURCE destSubresource;
1453 XGL_OFFSET2D destOffset;
1454 XGL_EXTENT2D extent;
1455} XGL_IMAGE_RESOLVE;
1456
1457typedef struct _XGL_SHADER_CREATE_INFO
1458{
1459 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO
1460 const XGL_VOID* pNext; // Pointer to next structure
1461 XGL_SIZE codeSize; // Specified in bytes
1462 const XGL_VOID* pCode;
1463 XGL_FLAGS flags; // Reserved
1464} XGL_SHADER_CREATE_INFO;
1465
1466struct _XGL_DESCRIPTOR_SET_MAPPING;
1467
1468typedef struct _XGL_DESCRIPTOR_SLOT_INFO
1469{
1470 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1471 union
1472 {
1473 XGL_UINT shaderEntityIndex;// Shader IL slot index for given entity type
1474 const struct _XGL_DESCRIPTOR_SET_MAPPING* pNextLevelSet; // Pointer to next descriptor set level
1475 };
1476} XGL_DESCRIPTOR_SLOT_INFO;
1477
1478typedef struct _XGL_DESCRIPTOR_SET_MAPPING
1479{
1480 XGL_UINT descriptorCount;
1481 const XGL_DESCRIPTOR_SLOT_INFO* pDescriptorInfo;
1482} XGL_DESCRIPTOR_SET_MAPPING;
1483
1484typedef struct _XGL_LINK_CONST_BUFFER
1485{
1486 XGL_UINT bufferId;
1487 XGL_SIZE bufferSize;
1488 const XGL_VOID* pBufferData;
1489} XGL_LINK_CONST_BUFFER;
1490
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1491typedef struct _XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1492{
1493 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1494 XGL_UINT shaderEntityIndex;
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1495} XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1496
1497typedef struct _XGL_PIPELINE_SHADER
1498{
1499 XGL_PIPELINE_SHADER_STAGE stage;
1500 XGL_SHADER shader;
1501 XGL_DESCRIPTOR_SET_MAPPING descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
1502 XGL_UINT linkConstBufferCount;
1503 const XGL_LINK_CONST_BUFFER* pLinkConstBufferInfo;
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1504 XGL_DYNAMIC_BUFFER_VIEW_SLOT_INFO dynamicBufferViewMapping;
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1505} XGL_PIPELINE_SHADER;
1506
1507typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
1508{
1509 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
1510 const XGL_VOID* pNext; // Pointer to next structure
1511 XGL_PIPELINE_SHADER cs;
1512 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1513} XGL_COMPUTE_PIPELINE_CREATE_INFO;
1514
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]1515// IMG CHANGE BEGIN - support for vertex input description
1516
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]1517//
1518// The shader inputs are mapped to pVertexAttributeDescriptions using a decoration in the BIL.
1519//
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]1520// The binding parameter in xglCmdBindVertexBuffer describes the index into pVertexBindingDescriptions[]
1521//
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame]1522//
1523// Formats allowed for attributes (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION.format) will be detailed in
1524// a table in the specification.
1525//
1526//
1527// Queryable limits:
1528//
1529// XGL_VERTEX_INPUT_BINDING_DESCRIPTION.strideInBytes
1530// XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION.offsetInBytes
1531//
1532//
1533
1534typedef struct _XGL_VERTEX_INPUT_BINDING_DESCRIPTION
1535{
1536 XGL_UINT strideInBytes; // Distance between vertices in bytes (0 = no advancement)
1537
1538 XGL_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented
1539} XGL_VERTEX_INPUT_BINDING_DESCRIPTION;
1540
1541typedef struct _XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION
1542{
1543 XGL_UINT binding; // index into vertexBindingDescriptions
1544
1545 XGL_FORMAT format; // format of source data
1546
1547 XGL_UINT offsetInBytes; // Offset of first element in bytes from base of vertex
1548} XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION;
1549
1550typedef struct _XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO
1551{
1552 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
1553 XGL_VOID* pNext; // Pointer to next structure
1554
1555 XGL_UINT bindingCount; // number of bindings
1556 XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions;
1557
1558 XGL_UINT attributeCount; // number of attributes
1559 XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
1560} XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO;
1561// IMG CHANGE END
1562
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1563typedef struct _XGL_PIPELINE_IA_STATE_CREATE_INFO
1564{
1565 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
1566 const XGL_VOID* pNext; // Pointer to next structure
1567 XGL_PRIMITIVE_TOPOLOGY topology;
1568 XGL_BOOL disableVertexReuse;
1569 XGL_PROVOKING_VERTEX_CONVENTION provokingVertex;
1570 XGL_BOOL primitiveRestartEnable;
1571 XGL_UINT32 primitiveRestartIndex;
1572} XGL_PIPELINE_IA_STATE_CREATE_INFO;
1573
1574typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO
1575{
1576 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
1577 const XGL_VOID* pNext; // Pointer to next structure
1578 XGL_UINT patchControlPoints;
1579 XGL_FLOAT optimalTessFactor;
1580 XGL_FLOAT fixedTessFactor;
1581} XGL_PIPELINE_TESS_STATE_CREATE_INFO;
1582
1583typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO
1584{
1585 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
1586 const XGL_VOID* pNext; // Pointer to next structure
1587 XGL_BOOL depthClipEnable;
1588 XGL_BOOL rasterizerDiscardEnable;
1589 XGL_FLOAT pointSize; // Size of points
1590} XGL_PIPELINE_RS_STATE_CREATE_INFO;
1591
1592typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE
1593{
1594 XGL_BOOL blendEnable;
1595 XGL_FORMAT format;
1596 XGL_UINT8 channelWriteMask;
1597} XGL_PIPELINE_CB_ATTACHMENT_STATE;
1598
1599typedef struct _XGL_PIPELINE_CB_STATE_CREATE_INFO
1600{
1601 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
1602 const XGL_VOID* pNext; // Pointer to next structure
1603 XGL_BOOL alphaToCoverageEnable;
1604 XGL_BOOL dualSourceBlendEnable;
1605 XGL_LOGIC_OP logicOp;
1606 XGL_PIPELINE_CB_ATTACHMENT_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1607} XGL_PIPELINE_CB_STATE;
1608
1609typedef struct _XGL_PIPELINE_DB_STATE_CREATE_INFO
1610{
1611 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
1612 const XGL_VOID* pNext; // Pointer to next structure
1613 XGL_FORMAT format;
1614} XGL_PIPELINE_DB_STATE_CREATE_INFO;
1615
1616typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
1617{
1618 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
1619 const XGL_VOID* pNext; // Pointer to next structure
1620 XGL_PIPELINE_SHADER shader;
1621} XGL_PIPELINE_SHADER_STAGE_CREATE_INFO;
1622
1623typedef struct _XGL_GRAPHICS_PIPELINE_CREATE_INFO
1624{
1625 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
1626 const XGL_VOID* pNext; // Pointer to next structure
1627 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1628} XGL_GRAPHICS_PIPELINE_CREATE_INFO;
1629
1630typedef struct _XGL_SAMPLER_CREATE_INFO
1631{
1632 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
1633 const XGL_VOID* pNext; // Pointer to next structure
1634 XGL_TEX_FILTER magFilter; // Filter mode for magnification
1635 XGL_TEX_FILTER minFilter; // Filter mode for minifiation
1636 XGL_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode
1637 XGL_TEX_ADDRESS addressU;
1638 XGL_TEX_ADDRESS addressV;
1639 XGL_TEX_ADDRESS addressW;
1640 XGL_FLOAT mipLodBias;
1641 XGL_UINT maxAnisotropy;
1642 XGL_COMPARE_FUNC compareFunc;
1643 XGL_FLOAT minLod;
1644 XGL_FLOAT maxLod;
1645 XGL_BORDER_COLOR_TYPE borderColorType;
1646} XGL_SAMPLER_CREATE_INFO;
1647
1648typedef struct _XGL_DESCRIPTOR_SET_CREATE_INFO
1649{
1650 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
1651 const XGL_VOID* pNext; // Pointer to next structure
1652 XGL_UINT slots;
1653} XGL_DESCRIPTOR_SET_CREATE_INFO;
1654
1655typedef struct _XGL_DESCRIPTOR_SET_ATTACH_INFO
1656{
1657 XGL_DESCRIPTOR_SET descriptorSet;
1658 XGL_UINT slotOffset;
1659} XGL_DESCRIPTOR_SET_ATTACH_INFO;
1660
1661typedef struct _XGL_VIEWPORT_STATE_CREATE_INFO
1662{
1663 XGL_UINT viewportCount;
1664 XGL_BOOL scissorEnable;
1665 XGL_VIEWPORT viewports[XGL_MAX_VIEWPORTS];
1666 XGL_RECT scissors[XGL_MAX_VIEWPORTS];
1667} XGL_VIEWPORT_STATE_CREATE_INFO;
1668
1669typedef struct _XGL_RASTER_STATE_CREATE_INFO
1670{
1671 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO
1672 const XGL_VOID* pNext; // Pointer to next structure
1673 XGL_FILL_MODE fillMode;
1674 XGL_CULL_MODE cullMode;
1675 XGL_FACE_ORIENTATION frontFace;
1676 XGL_INT depthBias;
1677 XGL_FLOAT depthBiasClamp;
1678 XGL_FLOAT slopeScaledDepthBias;
1679} XGL_RASTER_STATE_CREATE_INFO;
1680
1681typedef struct _XGL_MSAA_STATE_CREATE_INFO
1682{
1683 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO
1684 const XGL_VOID* pNext; // Pointer to next structure
1685 XGL_UINT samples;
1686 XGL_SAMPLE_MASK sampleMask;
1687} XGL_MSAA_STATE_CREATE_INFO;
1688
1689typedef struct _XGL_COLOR_ATTACHMENT_BLEND_STATE
1690{
1691 XGL_BOOL blendEnable;
1692 XGL_BLEND srcBlendColor;
1693 XGL_BLEND destBlendColor;
1694 XGL_BLEND_FUNC blendFuncColor;
1695 XGL_BLEND srcBlendAlpha;
1696 XGL_BLEND destBlendAlpha;
1697 XGL_BLEND_FUNC blendFuncAlpha;
1698} XGL_COLOR_ATTACHMENT_BLEND_STATE;
1699
1700typedef struct _XGL_COLOR_BLEND_STATE_CREATE_INFO
1701{
1702 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO
1703 const XGL_VOID* pNext; // Pointer to next structure
1704 XGL_COLOR_ATTACHMENT_BLEND_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1705 XGL_FLOAT blendConst[4];
1706} XGL_COLOR_BLEND_STATE_CREATE_INFO;
1707
1708typedef struct _XGL_STENCIL_OP_STATE
1709{
1710 XGL_STENCIL_OP stencilFailOp;
1711 XGL_STENCIL_OP stencilPassOp;
1712 XGL_STENCIL_OP stencilDepthFailOp;
1713 XGL_COMPARE_FUNC stencilFunc;
1714 XGL_UINT32 stencilRef;
1715} XGL_STENCIL_OP_STATE;
1716
1717typedef struct _XGL_DEPTH_STENCIL_STATE_CREATE_INFO
1718{
1719 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO
1720 const XGL_VOID* pNext; // Pointer to next structure
1721 XGL_BOOL depthTestEnable;
1722 XGL_BOOL depthWriteEnable;
1723 XGL_COMPARE_FUNC depthFunc;
1724 XGL_BOOL depthBoundsEnable;
1725 XGL_FLOAT minDepth;
1726 XGL_FLOAT maxDepth;
1727 XGL_BOOL stencilTestEnable;
1728 XGL_UINT32 stencilReadMask;
1729 XGL_UINT32 stencilWriteMask;
1730 XGL_STENCIL_OP_STATE front;
1731 XGL_STENCIL_OP_STATE back;
1732} XGL_DEPTH_STENCIL_STATE_CREATE_INFO;
1733
1734typedef struct _XGL_CMD_BUFFER_CREATE_INFO
1735{
1736 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
1737 const XGL_VOID* pNext;
1738 XGL_QUEUE_TYPE queueType;
1739 XGL_FLAGS flags;
1740} XGL_CMD_BUFFER_CREATE_INFO;
1741
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]1742typedef struct _XGL_CMD_BUFFER_BEGIN_INFO
1743{
1744 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
1745 const XGL_VOID* pNext;
1746
1747 XGL_FLAGS flags; // XGL_CMD_BUFFER_BUILD_FLAGS
1748} XGL_CMD_BUFFER_BEGIN_INFO;
1749
1750typedef struct _XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO
1751{
1752 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO
1753 const XGL_VOID* pNext; // Pointer to next structure
1754
1755 XGL_RENDER_PASS renderPass;
1756 XGL_RENDER_PASS_OPERATION operation;
1757
1758} XGL_CMD_BUFFER_GRAPHICS_BEGIN_INFO;
1759
1760// Union allowing specification of floating point or raw color data. Actual value selected is based on image being cleared.
1761typedef union _XGL_CLEAR_COLOR_VALUE
1762{
1763 XGL_FLOAT floatColor[4];
1764 XGL_UINT rawColor[4];
1765} XGL_CLEAR_COLOR_VALUE;
1766
1767typedef struct _XGL_CLEAR_COLOR
1768{
1769 XGL_CLEAR_COLOR_VALUE color;
1770 XGL_BOOL useRawValue;
1771} XGL_CLEAR_COLOR;
1772
1773typedef struct _XGL_RENDER_PASS_CREATE_INFO
1774{
1775 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
1776 const XGL_VOID* pNext; // Pointer to next structure
1777
1778 XGL_RECT renderArea;
1779 XGL_FRAMEBUFFER framebuffer;
1780 XGL_ATTACHMENT_LOAD_OP* pColorLoadOps; // Array of size equivalent to the number of attachments in the framebuffer
1781 XGL_ATTACHMENT_STORE_OP* pColorStoreOps; // Array of size equivalent to the number of attachments in the framebuffer
1782 XGL_CLEAR_COLOR* pColorLoadClearValues; // Array of size equivalent to the number of attachments in the framebuffer
1783 XGL_ATTACHMENT_LOAD_OP depthLoadOp;
1784 XGL_FLOAT depthLoadClearValue;
1785 XGL_ATTACHMENT_STORE_OP depthStoreOp;
1786 XGL_ATTACHMENT_LOAD_OP stencilLoadOp;
1787 XGL_UINT32 stencilLoadClearValue;
1788 XGL_ATTACHMENT_STORE_OP stencilStoreOp;
1789} XGL_RENDER_PASS_CREATE_INFO;
1790
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1791typedef struct _XGL_MEMORY_REF
1792{
1793 XGL_GPU_MEMORY mem;
1794 XGL_FLAGS flags; // XGL_MEMORY_REF_FLAGS
1795} XGL_MEMORY_REF;
1796
1797typedef struct _XGL_EVENT_CREATE_INFO
1798{
1799 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
1800 const XGL_VOID* pNext; // Pointer to next structure
1801 XGL_FLAGS flags; // Reserved
1802} XGL_EVENT_CREATE_INFO;
1803
1804typedef struct _XGL_FENCE_CREATE_INFO
1805{
1806 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO
1807 const XGL_VOID* pNext; // Pointer to next structure
1808 XGL_FLAGS flags; // Reserved
1809} XGL_FENCE_CREATE_INFO;
1810
1811typedef struct _XGL_QUEUE_SEMAPHORE_CREATE_INFO
1812{
1813 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
1814 const XGL_VOID* pNext; // Pointer to next structure
1815 XGL_UINT initialCount;
1816 XGL_FLAGS flags; // XGL_SEMAPHORE_CREATE_FLAGS
1817} XGL_QUEUE_SEMAPHORE_CREATE_INFO;
1818
1819typedef struct _XGL_QUEUE_SEMAPHORE_OPEN_INFO
1820{
1821 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
1822 const XGL_VOID* pNext; // Pointer to next structure
1823 XGL_QUEUE_SEMAPHORE sharedSemaphore;
1824} XGL_QUEUE_SEMAPHORE_OPEN_INFO;
1825
1826typedef struct _XGL_PIPELINE_STATISTICS_DATA
1827{
1828 XGL_UINT64 fsInvocations; // Fragment shader invocations
1829 XGL_UINT64 cPrimitives; // Clipper primitives
1830 XGL_UINT64 cInvocations; // Clipper invocations
1831 XGL_UINT64 vsInvocations; // Vertex shader invocations
1832 XGL_UINT64 gsInvocations; // Geometry shader invocations
1833 XGL_UINT64 gsPrimitives; // Geometry shader primitives
1834 XGL_UINT64 iaPrimitives; // Input primitives
1835 XGL_UINT64 iaVertices; // Input vertices
1836 XGL_UINT64 tcsInvocations; // Tessellation control shader invocations
1837 XGL_UINT64 tesInvocations; // Tessellation evaluation shader invocations
1838 XGL_UINT64 csInvocations; // Compute shader invocations
1839} XGL_PIPELINE_STATISTICS_DATA;
1840
1841typedef struct _XGL_QUERY_POOL_CREATE_INFO
1842{
1843 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
1844 const XGL_VOID* pNext; // Pointer to next structure
1845 XGL_QUERY_TYPE queryType;
1846 XGL_UINT slots;
1847} XGL_QUERY_POOL_CREATE_INFO;
1848
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]1849typedef struct _XGL_FRAMEBUFFER_CREATE_INFO
1850{
1851 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
1852 const XGL_VOID* pNext; // Pointer to next structure
1853
1854 XGL_UINT colorAttachmentCount;
1855 XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments;
1856 XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment;
1857 XGL_UINT sampleCount;
1858
1859} XGL_FRAMEBUFFER_CREATE_INFO;
1860
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1861typedef struct _XGL_DRAW_INDIRECT_CMD
1862{
1863 XGL_UINT32 vertexCount;
1864 XGL_UINT32 instanceCount;
1865 XGL_UINT32 firstVertex;
1866 XGL_UINT32 firstInstance;
1867} XGL_DRAW_INDIRECT_CMD;
1868
1869typedef struct _XGL_DRAW_INDEXED_INDIRECT_CMD
1870{
1871 XGL_UINT32 indexCount;
1872 XGL_UINT32 instanceCount;
1873 XGL_UINT32 firstIndex;
1874 XGL_INT32 vertexOffset;
1875 XGL_UINT32 firstInstance;
1876} XGL_DRAW_INDEXED_INDIRECT_CMD;
1877
1878typedef struct _XGL_DISPATCH_INDIRECT_CMD
1879{
1880 XGL_UINT32 x;
1881 XGL_UINT32 y;
1882 XGL_UINT32 z;
1883} XGL_DISPATCH_INDIRECT_CMD;
1884
1885// ------------------------------------------------------------------------------------------------
1886// API functions
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1887typedef XGL_RESULT (XGLAPI *xglInitAndEnumerateGpusType)(const XGL_APPLICATION_INFO* pAppInfo, const XGL_ALLOC_CALLBACKS* pAllocCb, XGL_UINT maxGpus, XGL_UINT* pGpuCount, XGL_PHYSICAL_GPU* pGpus);
1888typedef XGL_RESULT (XGLAPI *xglGetGpuInfoType)(XGL_PHYSICAL_GPU gpu, XGL_PHYSICAL_GPU_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1889typedef XGL_VOID * (XGLAPI *xglGetProcAddrType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR * pName);
1890typedef XGL_RESULT (XGLAPI *xglCreateDeviceType)(XGL_PHYSICAL_GPU gpu, const XGL_DEVICE_CREATE_INFO* pCreateInfo, XGL_DEVICE* pDevice);
1891typedef XGL_RESULT (XGLAPI *xglDestroyDeviceType)(XGL_DEVICE device);
1892typedef XGL_RESULT (XGLAPI *xglGetExtensionSupportType)(XGL_PHYSICAL_GPU gpu, const XGL_CHAR* pExtName);
1893typedef XGL_RESULT (XGLAPI *xglEnumerateLayersType)(XGL_PHYSICAL_GPU gpu, XGL_SIZE maxLayerCount, XGL_SIZE maxStringSize, XGL_SIZE* pOutLayerCount, XGL_CHAR* const* pOutLayers, XGL_VOID* pReserved);
1894typedef XGL_RESULT (XGLAPI *xglGetDeviceQueueType)(XGL_DEVICE device, XGL_QUEUE_TYPE queueType, XGL_UINT queueIndex, XGL_QUEUE* pQueue);
1895typedef XGL_RESULT (XGLAPI *xglQueueSubmitType)(XGL_QUEUE queue, XGL_UINT cmdBufferCount, const XGL_CMD_BUFFER* pCmdBuffers, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs, XGL_FENCE fence);
1896typedef XGL_RESULT (XGLAPI *xglQueueSetGlobalMemReferencesType)(XGL_QUEUE queue, XGL_UINT memRefCount, const XGL_MEMORY_REF* pMemRefs);
1897typedef XGL_RESULT (XGLAPI *xglQueueWaitIdleType)(XGL_QUEUE queue);
1898typedef XGL_RESULT (XGLAPI *xglDeviceWaitIdleType)(XGL_DEVICE device);
1899typedef XGL_RESULT (XGLAPI *xglGetMemoryHeapCountType)(XGL_DEVICE device, XGL_UINT* pCount);
1900typedef XGL_RESULT (XGLAPI *xglGetMemoryHeapInfoType)(XGL_DEVICE device, XGL_UINT heapId, XGL_MEMORY_HEAP_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1901typedef XGL_RESULT (XGLAPI *xglAllocMemoryType)(XGL_DEVICE device, const XGL_MEMORY_ALLOC_INFO* pAllocInfo, XGL_GPU_MEMORY* pMem);
1902typedef XGL_RESULT (XGLAPI *xglFreeMemoryType)(XGL_GPU_MEMORY mem);
1903typedef XGL_RESULT (XGLAPI *xglSetMemoryPriorityType)(XGL_GPU_MEMORY mem, XGL_MEMORY_PRIORITY priority);
1904typedef XGL_RESULT (XGLAPI *xglMapMemoryType)(XGL_GPU_MEMORY mem, XGL_FLAGS flags, XGL_VOID** ppData);
1905typedef XGL_RESULT (XGLAPI *xglUnmapMemoryType)(XGL_GPU_MEMORY mem);
1906typedef XGL_RESULT (XGLAPI *xglPinSystemMemoryType)(XGL_DEVICE device, const XGL_VOID* pSysMem, XGL_SIZE memSize, XGL_GPU_MEMORY* pMem);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1907typedef XGL_RESULT (XGLAPI *xglGetMultiGpuCompatibilityType)(XGL_PHYSICAL_GPU gpu0, XGL_PHYSICAL_GPU gpu1, XGL_GPU_COMPATIBILITY_INFO* pInfo);
1908typedef XGL_RESULT (XGLAPI *xglOpenSharedMemoryType)(XGL_DEVICE device, const XGL_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
1909typedef XGL_RESULT (XGLAPI *xglOpenSharedQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
1910typedef XGL_RESULT (XGLAPI *xglOpenPeerMemoryType)(XGL_DEVICE device, const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo, XGL_GPU_MEMORY* pMem);
1911typedef XGL_RESULT (XGLAPI *xglOpenPeerImageType)(XGL_DEVICE device, const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo, XGL_IMAGE* pImage, XGL_GPU_MEMORY* pMem);
1912typedef XGL_RESULT (XGLAPI *xglDestroyObjectType)(XGL_OBJECT object);
1913typedef XGL_RESULT (XGLAPI *xglGetObjectInfoType)(XGL_BASE_OBJECT object, XGL_OBJECT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1914typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryType)(XGL_OBJECT object, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
1915typedef XGL_RESULT (XGLAPI *xglBindObjectMemoryRangeType)(XGL_OBJECT object, XGL_GPU_SIZE rangeOffset, XGL_GPU_SIZE rangeSize, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
1916typedef XGL_RESULT (XGLAPI *xglBindImageMemoryRangeType)(XGL_IMAGE image, const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo, XGL_GPU_MEMORY mem, XGL_GPU_SIZE memOffset);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1917typedef XGL_RESULT (XGLAPI *xglCreateFenceType)(XGL_DEVICE device, const XGL_FENCE_CREATE_INFO* pCreateInfo, XGL_FENCE* pFence);
1918typedef XGL_RESULT (XGLAPI *xglGetFenceStatusType)(XGL_FENCE fence);
1919typedef XGL_RESULT (XGLAPI *xglWaitForFencesType)(XGL_DEVICE device, XGL_UINT fenceCount, const XGL_FENCE* pFences, XGL_BOOL waitAll, XGL_UINT64 timeout);
1920typedef XGL_RESULT (XGLAPI *xglCreateQueueSemaphoreType)(XGL_DEVICE device, const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo, XGL_QUEUE_SEMAPHORE* pSemaphore);
1921typedef XGL_RESULT (XGLAPI *xglSignalQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
1922typedef XGL_RESULT (XGLAPI *xglWaitQueueSemaphoreType)(XGL_QUEUE queue, XGL_QUEUE_SEMAPHORE semaphore);
1923typedef XGL_RESULT (XGLAPI *xglCreateEventType)(XGL_DEVICE device, const XGL_EVENT_CREATE_INFO* pCreateInfo, XGL_EVENT* pEvent);
1924typedef XGL_RESULT (XGLAPI *xglGetEventStatusType)(XGL_EVENT event);
1925typedef XGL_RESULT (XGLAPI *xglSetEventType)(XGL_EVENT event);
1926typedef XGL_RESULT (XGLAPI *xglResetEventType)(XGL_EVENT event);
1927typedef XGL_RESULT (XGLAPI *xglCreateQueryPoolType)(XGL_DEVICE device, const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo, XGL_QUERY_POOL* pQueryPool);
1928typedef XGL_RESULT (XGLAPI *xglGetQueryPoolResultsType)(XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount, XGL_SIZE* pDataSize, XGL_VOID* pData);
1929typedef XGL_RESULT (XGLAPI *xglGetFormatInfoType)(XGL_DEVICE device, XGL_FORMAT format, XGL_FORMAT_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1930typedef XGL_RESULT (XGLAPI *xglCreateBufferType)(XGL_DEVICE device, const XGL_BUFFER_CREATE_INFO* pCreateInfo, XGL_BUFFER* pBuffer);
1931typedef XGL_RESULT (XGLAPI *xglCreateBufferViewType)(XGL_DEVICE device, const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo, XGL_BUFFER_VIEW* pView);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1932typedef XGL_RESULT (XGLAPI *xglCreateImageType)(XGL_DEVICE device, const XGL_IMAGE_CREATE_INFO* pCreateInfo, XGL_IMAGE* pImage);
1933typedef XGL_RESULT (XGLAPI *xglGetImageSubresourceInfoType)(XGL_IMAGE image, const XGL_IMAGE_SUBRESOURCE* pSubresource, XGL_SUBRESOURCE_INFO_TYPE infoType, XGL_SIZE* pDataSize, XGL_VOID* pData);
1934typedef XGL_RESULT (XGLAPI *xglCreateImageViewType)(XGL_DEVICE device, const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo, XGL_IMAGE_VIEW* pView);
1935typedef XGL_RESULT (XGLAPI *xglCreateColorAttachmentViewType)(XGL_DEVICE device, const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo, XGL_COLOR_ATTACHMENT_VIEW* pView);
1936typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilViewType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_VIEW* pView);
1937typedef XGL_RESULT (XGLAPI *xglCreateShaderType)(XGL_DEVICE device, const XGL_SHADER_CREATE_INFO* pCreateInfo, XGL_SHADER* pShader);
1938typedef XGL_RESULT (XGLAPI *xglCreateGraphicsPipelineType)(XGL_DEVICE device, const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
1939typedef XGL_RESULT (XGLAPI *xglCreateComputePipelineType)(XGL_DEVICE device, const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo, XGL_PIPELINE* pPipeline);
1940typedef XGL_RESULT (XGLAPI *xglStorePipelineType)(XGL_PIPELINE pipeline, XGL_SIZE* pDataSize, XGL_VOID* pData);
1941typedef XGL_RESULT (XGLAPI *xglLoadPipelineType)(XGL_DEVICE device, XGL_SIZE dataSize, const XGL_VOID* pData, XGL_PIPELINE* pPipeline);
1942typedef XGL_RESULT (XGLAPI *xglCreatePipelineDeltaType)(XGL_DEVICE device, XGL_PIPELINE p1, XGL_PIPELINE p2, XGL_PIPELINE_DELTA* delta);
1943typedef XGL_RESULT (XGLAPI *xglCreateSamplerType)(XGL_DEVICE device, const XGL_SAMPLER_CREATE_INFO* pCreateInfo, XGL_SAMPLER* pSampler);
1944typedef XGL_RESULT (XGLAPI *xglCreateDescriptorSetType)(XGL_DEVICE device, const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo, XGL_DESCRIPTOR_SET* pDescriptorSet);
1945typedef XGL_VOID (XGLAPI *xglBeginDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
1946typedef XGL_VOID (XGLAPI *xglEndDescriptorSetUpdateType)(XGL_DESCRIPTOR_SET descriptorSet);
1947typedef XGL_VOID (XGLAPI *xglAttachSamplerDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_SAMPLER* pSamplers);
1948typedef XGL_VOID (XGLAPI *xglAttachImageViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1949typedef XGL_VOID (XGLAPI *xglAttachBufferViewDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1950typedef XGL_VOID (XGLAPI *xglAttachNestedDescriptorsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount, const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
1951typedef XGL_VOID (XGLAPI *xglClearDescriptorSetSlotsType)(XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT startSlot, XGL_UINT slotCount);
1952typedef XGL_RESULT (XGLAPI *xglCreateViewportStateType)(XGL_DEVICE device, const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo, XGL_VIEWPORT_STATE_OBJECT* pState);
1953typedef XGL_RESULT (XGLAPI *xglCreateRasterStateType)(XGL_DEVICE device, const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo, XGL_RASTER_STATE_OBJECT* pState);
1954typedef XGL_RESULT (XGLAPI *xglCreateMsaaStateType)(XGL_DEVICE device, const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo, XGL_MSAA_STATE_OBJECT* pState);
1955typedef XGL_RESULT (XGLAPI *xglCreateColorBlendStateType)(XGL_DEVICE device, const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo, XGL_COLOR_BLEND_STATE_OBJECT* pState);
1956typedef XGL_RESULT (XGLAPI *xglCreateDepthStencilStateType)(XGL_DEVICE device, const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo, XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
1957typedef XGL_RESULT (XGLAPI *xglCreateCommandBufferType)(XGL_DEVICE device, const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo, XGL_CMD_BUFFER* pCmdBuffer);
Jeremy Hayese0c3b222015-01-14 16:17:08 -0700[diff] [blame]1958typedef XGL_RESULT (XGLAPI *xglBeginCommandBufferType)(XGL_CMD_BUFFER cmdBuffer, const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1959typedef XGL_RESULT (XGLAPI *xglEndCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
1960typedef XGL_RESULT (XGLAPI *xglResetCommandBufferType)(XGL_CMD_BUFFER cmdBuffer);
1961typedef XGL_VOID (XGLAPI *xglCmdBindPipelineType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE pipeline);
1962typedef XGL_VOID (XGLAPI *xglCmdBindPipelineDeltaType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_PIPELINE_DELTA delta);
1963typedef XGL_VOID (XGLAPI *xglCmdBindStateObjectType)(XGL_CMD_BUFFER cmdBuffer, XGL_STATE_BIND_POINT stateBindPoint, XGL_STATE_OBJECT state);
1964typedef XGL_VOID (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT index, XGL_DESCRIPTOR_SET descriptorSet, XGL_UINT slotOffset);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1965typedef XGL_VOID (XGLAPI *xglCmdBindDynamicBufferViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView);
1966typedef XGL_VOID (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT binding);
1967typedef XGL_VOID (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType);
1968typedef XGL_VOID (XGLAPI *xglCmdPrepareBufferRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_BUFFER_STATE_TRANSITION* pStateTransitions);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1969typedef XGL_VOID (XGLAPI *xglCmdPrepareImagesType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
1970typedef XGL_VOID (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount);
1971typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1972typedef XGL_VOID (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
1973typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1974typedef XGL_VOID (XGLAPI *xglCmdDispatchType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT x, XGL_UINT y, XGL_UINT z);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1975typedef XGL_VOID (XGLAPI *xglCmdDispatchIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset);
1976typedef XGL_VOID (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_BUFFER destBuffer, XGL_UINT regionCount, const XGL_BUFFER_COPY* pRegions);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1977typedef XGL_VOID (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_IMAGE_COPY* pRegions);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1978typedef XGL_VOID (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
1979typedef XGL_VOID (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1980typedef XGL_VOID (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1981typedef XGL_VOID (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData);
1982typedef XGL_VOID (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1983typedef XGL_VOID (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_FLOAT color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
1984typedef XGL_VOID (XGLAPI *xglCmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_UINT32 color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
1985typedef XGL_VOID (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_FLOAT depth, XGL_UINT32 stencil, XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
1986typedef XGL_VOID (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT rectCount, const XGL_IMAGE_RESOLVE* pRects);
1987typedef XGL_VOID (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
1988typedef XGL_VOID (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1989typedef XGL_VOID (XGLAPI *xglCmdBufferAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1990typedef XGL_VOID (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot, XGL_FLAGS flags);
1991typedef XGL_VOID (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot);
1992typedef XGL_VOID (XGLAPI *xglCmdResetQueryPoolType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT startQuery, XGL_UINT queryCount);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1993typedef XGL_VOID (XGLAPI *xglCmdWriteTimestampType)(XGL_CMD_BUFFER cmdBuffer, XGL_TIMESTAMP_TYPE timestampType, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1994typedef XGL_VOID (XGLAPI *xglCmdInitAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, const XGL_UINT32* pData);
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]1995typedef XGL_VOID (XGLAPI *xglCmdLoadAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_BUFFER srcBuffer, XGL_GPU_SIZE srcOffset);
1996typedef XGL_VOID (XGLAPI *xglCmdSaveAtomicCountersType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, XGL_UINT startCounter, XGL_UINT counterCount, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset);
Jeremy Hayese0c3b222015-01-14 16:17:08 -0700[diff] [blame]1997typedef XGL_RESULT (XGLAPI *xglCreateFramebufferType)(XGL_DEVICE device, const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo, XGL_FRAMEBUFFER* pFramebuffer);
1998typedef XGL_RESULT (XGLAPI *xglCreateRenderPassType)(XGL_DEVICE device, const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo, XGL_RENDER_PASS* pRenderPass);
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]1999
2000#ifdef XGL_PROTOTYPES
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2001
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2002// GPU initialization
2003
2004XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
2005 const XGL_APPLICATION_INFO* pAppInfo,
2006 const XGL_ALLOC_CALLBACKS* pAllocCb,
2007 XGL_UINT maxGpus,
2008 XGL_UINT* pGpuCount,
2009 XGL_PHYSICAL_GPU* pGpus);
2010
2011XGL_RESULT XGLAPI xglGetGpuInfo(
2012 XGL_PHYSICAL_GPU gpu,
2013 XGL_PHYSICAL_GPU_INFO_TYPE infoType,
2014 XGL_SIZE* pDataSize,
2015 XGL_VOID* pData);
2016
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]2017XGL_VOID * XGLAPI xglGetProcAddr(
2018 XGL_PHYSICAL_GPU gpu,
2019 const XGL_CHAR* pName);
2020
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2021// Device functions
2022
2023XGL_RESULT XGLAPI xglCreateDevice(
2024 XGL_PHYSICAL_GPU gpu,
2025 const XGL_DEVICE_CREATE_INFO* pCreateInfo,
2026 XGL_DEVICE* pDevice);
2027
2028XGL_RESULT XGLAPI xglDestroyDevice(
2029 XGL_DEVICE device);
2030
2031// Extension discovery functions
2032
2033XGL_RESULT XGLAPI xglGetExtensionSupport(
2034 XGL_PHYSICAL_GPU gpu,
2035 const XGL_CHAR* pExtName);
2036
Jon Ashburn96f28fc2014-10-15 15:30:23 -0600[diff] [blame]2037// Layer discovery function
2038XGL_RESULT XGLAPI xglEnumerateLayers(
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]2039 XGL_PHYSICAL_GPU gpu,
2040 XGL_SIZE maxLayerCount,
2041 XGL_SIZE maxStringSize,
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]2042 XGL_SIZE* pOutLayerCount,
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]2043 XGL_CHAR* const* pOutLayers,
Jon Ashburn6847c2b2014-11-25 12:56:49 -0700[diff] [blame]2044 XGL_VOID* pReserved);
Jon Ashburn96f28fc2014-10-15 15:30:23 -0600[diff] [blame]2045
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2046// Queue functions
2047
2048XGL_RESULT XGLAPI xglGetDeviceQueue(
2049 XGL_DEVICE device,
2050 XGL_QUEUE_TYPE queueType,
2051 XGL_UINT queueIndex,
2052 XGL_QUEUE* pQueue);
2053
2054XGL_RESULT XGLAPI xglQueueSubmit(
2055 XGL_QUEUE queue,
2056 XGL_UINT cmdBufferCount,
2057 const XGL_CMD_BUFFER* pCmdBuffers,
2058 XGL_UINT memRefCount,
2059 const XGL_MEMORY_REF* pMemRefs,
2060 XGL_FENCE fence);
2061
2062XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
2063 XGL_QUEUE queue,
2064 XGL_UINT memRefCount,
2065 const XGL_MEMORY_REF* pMemRefs);
2066
2067XGL_RESULT XGLAPI xglQueueWaitIdle(
2068 XGL_QUEUE queue);
2069
2070XGL_RESULT XGLAPI xglDeviceWaitIdle(
2071 XGL_DEVICE device);
2072
2073// Memory functions
2074
2075XGL_RESULT XGLAPI xglGetMemoryHeapCount(
2076 XGL_DEVICE device,
2077 XGL_UINT* pCount);
2078
2079XGL_RESULT XGLAPI xglGetMemoryHeapInfo(
2080 XGL_DEVICE device,
2081 XGL_UINT heapId,
2082 XGL_MEMORY_HEAP_INFO_TYPE infoType,
2083 XGL_SIZE* pDataSize,
2084 XGL_VOID* pData);
2085
2086XGL_RESULT XGLAPI xglAllocMemory(
2087 XGL_DEVICE device,
2088 const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
2089 XGL_GPU_MEMORY* pMem);
2090
2091XGL_RESULT XGLAPI xglFreeMemory(
2092 XGL_GPU_MEMORY mem);
2093
2094XGL_RESULT XGLAPI xglSetMemoryPriority(
2095 XGL_GPU_MEMORY mem,
2096 XGL_MEMORY_PRIORITY priority);
2097
2098XGL_RESULT XGLAPI xglMapMemory(
2099 XGL_GPU_MEMORY mem,
2100 XGL_FLAGS flags, // Reserved
2101 XGL_VOID** ppData);
2102
2103XGL_RESULT XGLAPI xglUnmapMemory(
2104 XGL_GPU_MEMORY mem);
2105
2106XGL_RESULT XGLAPI xglPinSystemMemory(
2107 XGL_DEVICE device,
2108 const XGL_VOID* pSysMem,
2109 XGL_SIZE memSize,
2110 XGL_GPU_MEMORY* pMem);
2111
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2112// Multi-device functions
2113
2114XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
2115 XGL_PHYSICAL_GPU gpu0,
2116 XGL_PHYSICAL_GPU gpu1,
2117 XGL_GPU_COMPATIBILITY_INFO* pInfo);
2118
2119XGL_RESULT XGLAPI xglOpenSharedMemory(
2120 XGL_DEVICE device,
2121 const XGL_MEMORY_OPEN_INFO* pOpenInfo,
2122 XGL_GPU_MEMORY* pMem);
2123
2124XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
2125 XGL_DEVICE device,
2126 const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
2127 XGL_QUEUE_SEMAPHORE* pSemaphore);
2128
2129XGL_RESULT XGLAPI xglOpenPeerMemory(
2130 XGL_DEVICE device,
2131 const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
2132 XGL_GPU_MEMORY* pMem);
2133
2134XGL_RESULT XGLAPI xglOpenPeerImage(
2135 XGL_DEVICE device,
2136 const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
2137 XGL_IMAGE* pImage,
2138 XGL_GPU_MEMORY* pMem);
2139
2140// Generic API object functions
2141
2142XGL_RESULT XGLAPI xglDestroyObject(
2143 XGL_OBJECT object);
2144
2145XGL_RESULT XGLAPI xglGetObjectInfo(
2146 XGL_BASE_OBJECT object,
2147 XGL_OBJECT_INFO_TYPE infoType,
2148 XGL_SIZE* pDataSize,
2149 XGL_VOID* pData);
2150
2151XGL_RESULT XGLAPI xglBindObjectMemory(
2152 XGL_OBJECT object,
2153 XGL_GPU_MEMORY mem,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2154 XGL_GPU_SIZE memOffset);
2155
2156XGL_RESULT XGLAPI xglBindObjectMemoryRange(
2157 XGL_OBJECT object,
2158 XGL_GPU_SIZE rangeOffset,
2159 XGL_GPU_SIZE rangeSize,
2160 XGL_GPU_MEMORY mem,
2161 XGL_GPU_SIZE memOffset);
2162
2163XGL_RESULT XGLAPI xglBindImageMemoryRange(
2164 XGL_IMAGE image,
2165 const XGL_IMAGE_MEMORY_BIND_INFO* bindInfo,
2166 XGL_GPU_MEMORY mem,
2167 XGL_GPU_SIZE memOffset);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2168
2169// Fence functions
2170
2171XGL_RESULT XGLAPI xglCreateFence(
2172 XGL_DEVICE device,
2173 const XGL_FENCE_CREATE_INFO* pCreateInfo,
2174 XGL_FENCE* pFence);
2175
2176XGL_RESULT XGLAPI xglGetFenceStatus(
2177 XGL_FENCE fence);
2178
2179XGL_RESULT XGLAPI xglWaitForFences(
2180 XGL_DEVICE device,
2181 XGL_UINT fenceCount,
2182 const XGL_FENCE* pFences,
2183 XGL_BOOL waitAll,
2184 XGL_UINT64 timeout);
2185
2186// Queue semaphore functions
2187
2188XGL_RESULT XGLAPI xglCreateQueueSemaphore(
2189 XGL_DEVICE device,
2190 const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
2191 XGL_QUEUE_SEMAPHORE* pSemaphore);
2192
2193XGL_RESULT XGLAPI xglSignalQueueSemaphore(
2194 XGL_QUEUE queue,
2195 XGL_QUEUE_SEMAPHORE semaphore);
2196
2197XGL_RESULT XGLAPI xglWaitQueueSemaphore(
2198 XGL_QUEUE queue,
2199 XGL_QUEUE_SEMAPHORE semaphore);
2200
2201// Event functions
2202
2203XGL_RESULT XGLAPI xglCreateEvent(
2204 XGL_DEVICE device,
2205 const XGL_EVENT_CREATE_INFO* pCreateInfo,
2206 XGL_EVENT* pEvent);
2207
2208XGL_RESULT XGLAPI xglGetEventStatus(
2209 XGL_EVENT event);
2210
2211XGL_RESULT XGLAPI xglSetEvent(
2212 XGL_EVENT event);
2213
2214XGL_RESULT XGLAPI xglResetEvent(
2215 XGL_EVENT event);
2216
2217// Query functions
2218
2219XGL_RESULT XGLAPI xglCreateQueryPool(
2220 XGL_DEVICE device,
2221 const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
2222 XGL_QUERY_POOL* pQueryPool);
2223
2224XGL_RESULT XGLAPI xglGetQueryPoolResults(
2225 XGL_QUERY_POOL queryPool,
2226 XGL_UINT startQuery,
2227 XGL_UINT queryCount,
2228 XGL_SIZE* pDataSize,
2229 XGL_VOID* pData);
2230
2231// Format capabilities
2232
2233XGL_RESULT XGLAPI xglGetFormatInfo(
2234 XGL_DEVICE device,
2235 XGL_FORMAT format,
2236 XGL_FORMAT_INFO_TYPE infoType,
2237 XGL_SIZE* pDataSize,
2238 XGL_VOID* pData);
2239
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2240// Buffer functions
2241
2242XGL_RESULT XGLAPI xglCreateBuffer(
2243 XGL_DEVICE device,
2244 const XGL_BUFFER_CREATE_INFO* pCreateInfo,
2245 XGL_BUFFER* pBuffer);
2246
2247// Buffer view functions
2248
2249XGL_RESULT XGLAPI xglCreateBufferView(
2250 XGL_DEVICE device,
2251 const XGL_BUFFER_VIEW_CREATE_INFO* pCreateInfo,
2252 XGL_BUFFER_VIEW* pView);
2253
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2254// Image functions
2255
2256XGL_RESULT XGLAPI xglCreateImage(
2257 XGL_DEVICE device,
2258 const XGL_IMAGE_CREATE_INFO* pCreateInfo,
2259 XGL_IMAGE* pImage);
2260
2261XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
2262 XGL_IMAGE image,
2263 const XGL_IMAGE_SUBRESOURCE* pSubresource,
2264 XGL_SUBRESOURCE_INFO_TYPE infoType,
2265 XGL_SIZE* pDataSize,
2266 XGL_VOID* pData);
2267
2268// Image view functions
2269
2270XGL_RESULT XGLAPI xglCreateImageView(
2271 XGL_DEVICE device,
2272 const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
2273 XGL_IMAGE_VIEW* pView);
2274
2275XGL_RESULT XGLAPI xglCreateColorAttachmentView(
2276 XGL_DEVICE device,
2277 const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
2278 XGL_COLOR_ATTACHMENT_VIEW* pView);
2279
2280XGL_RESULT XGLAPI xglCreateDepthStencilView(
2281 XGL_DEVICE device,
2282 const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
2283 XGL_DEPTH_STENCIL_VIEW* pView);
2284
2285// Shader functions
2286
2287XGL_RESULT XGLAPI xglCreateShader(
2288 XGL_DEVICE device,
2289 const XGL_SHADER_CREATE_INFO* pCreateInfo,
2290 XGL_SHADER* pShader);
2291
2292// Pipeline functions
2293
2294XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
2295 XGL_DEVICE device,
2296 const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
2297 XGL_PIPELINE* pPipeline);
2298
2299XGL_RESULT XGLAPI xglCreateComputePipeline(
2300 XGL_DEVICE device,
2301 const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
2302 XGL_PIPELINE* pPipeline);
2303
2304XGL_RESULT XGLAPI xglStorePipeline(
2305 XGL_PIPELINE pipeline,
2306 XGL_SIZE* pDataSize,
2307 XGL_VOID* pData);
2308
2309XGL_RESULT XGLAPI xglLoadPipeline(
2310 XGL_DEVICE device,
2311 XGL_SIZE dataSize,
2312 const XGL_VOID* pData,
2313 XGL_PIPELINE* pPipeline);
2314
2315XGL_RESULT XGLAPI xglCreatePipelineDelta(
2316 XGL_DEVICE device,
2317 XGL_PIPELINE p1,
2318 XGL_PIPELINE p2,
2319 XGL_PIPELINE_DELTA* delta);
2320
2321// Sampler functions
2322
2323XGL_RESULT XGLAPI xglCreateSampler(
2324 XGL_DEVICE device,
2325 const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
2326 XGL_SAMPLER* pSampler);
2327
2328// Descriptor set functions
2329
2330XGL_RESULT XGLAPI xglCreateDescriptorSet(
2331 XGL_DEVICE device,
2332 const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
2333 XGL_DESCRIPTOR_SET* pDescriptorSet);
2334
2335XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(
2336 XGL_DESCRIPTOR_SET descriptorSet);
2337
2338XGL_VOID XGLAPI xglEndDescriptorSetUpdate(
2339 XGL_DESCRIPTOR_SET descriptorSet);
2340
2341XGL_VOID XGLAPI xglAttachSamplerDescriptors(
2342 XGL_DESCRIPTOR_SET descriptorSet,
2343 XGL_UINT startSlot,
2344 XGL_UINT slotCount,
2345 const XGL_SAMPLER* pSamplers);
2346
2347XGL_VOID XGLAPI xglAttachImageViewDescriptors(
2348 XGL_DESCRIPTOR_SET descriptorSet,
2349 XGL_UINT startSlot,
2350 XGL_UINT slotCount,
2351 const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
2352
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2353XGL_VOID XGLAPI xglAttachBufferViewDescriptors(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2354 XGL_DESCRIPTOR_SET descriptorSet,
2355 XGL_UINT startSlot,
2356 XGL_UINT slotCount,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2357 const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferViews);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2358
2359XGL_VOID XGLAPI xglAttachNestedDescriptors(
2360 XGL_DESCRIPTOR_SET descriptorSet,
2361 XGL_UINT startSlot,
2362 XGL_UINT slotCount,
2363 const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
2364
2365XGL_VOID XGLAPI xglClearDescriptorSetSlots(
2366 XGL_DESCRIPTOR_SET descriptorSet,
2367 XGL_UINT startSlot,
2368 XGL_UINT slotCount);
2369
2370// State object functions
2371
2372XGL_RESULT XGLAPI xglCreateViewportState(
2373 XGL_DEVICE device,
2374 const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
2375 XGL_VIEWPORT_STATE_OBJECT* pState);
2376
2377XGL_RESULT XGLAPI xglCreateRasterState(
2378 XGL_DEVICE device,
2379 const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
2380 XGL_RASTER_STATE_OBJECT* pState);
2381
2382XGL_RESULT XGLAPI xglCreateMsaaState(
2383 XGL_DEVICE device,
2384 const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
2385 XGL_MSAA_STATE_OBJECT* pState);
2386
2387XGL_RESULT XGLAPI xglCreateColorBlendState(
2388 XGL_DEVICE device,
2389 const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
2390 XGL_COLOR_BLEND_STATE_OBJECT* pState);
2391
2392XGL_RESULT XGLAPI xglCreateDepthStencilState(
2393 XGL_DEVICE device,
2394 const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
2395 XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
2396
2397// Command buffer functions
2398
2399XGL_RESULT XGLAPI xglCreateCommandBuffer(
2400 XGL_DEVICE device,
2401 const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
2402 XGL_CMD_BUFFER* pCmdBuffer);
2403
2404XGL_RESULT XGLAPI xglBeginCommandBuffer(
2405 XGL_CMD_BUFFER cmdBuffer,
Jon Ashburn05200972014-12-31 16:56:13 -0700[diff] [blame]2406 const XGL_CMD_BUFFER_BEGIN_INFO* pBeginInfo);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2407
2408XGL_RESULT XGLAPI xglEndCommandBuffer(
2409 XGL_CMD_BUFFER cmdBuffer);
2410
2411XGL_RESULT XGLAPI xglResetCommandBuffer(
2412 XGL_CMD_BUFFER cmdBuffer);
2413
2414// Command buffer building functions
2415
2416XGL_VOID XGLAPI xglCmdBindPipeline(
2417 XGL_CMD_BUFFER cmdBuffer,
2418 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2419 XGL_PIPELINE pipeline);
2420
2421XGL_VOID XGLAPI xglCmdBindPipelineDelta(
2422 XGL_CMD_BUFFER cmdBuffer,
2423 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2424 XGL_PIPELINE_DELTA delta);
2425
2426XGL_VOID XGLAPI xglCmdBindStateObject(
2427 XGL_CMD_BUFFER cmdBuffer,
2428 XGL_STATE_BIND_POINT stateBindPoint,
2429 XGL_STATE_OBJECT state);
2430
2431XGL_VOID XGLAPI xglCmdBindDescriptorSet(
2432 XGL_CMD_BUFFER cmdBuffer,
2433 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2434 XGL_UINT index,
2435 XGL_DESCRIPTOR_SET descriptorSet,
2436 XGL_UINT slotOffset);
2437
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2438XGL_VOID XGLAPI xglCmdBindDynamicBufferView(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2439 XGL_CMD_BUFFER cmdBuffer,
2440 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2441 const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2442
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]2443// IMG CHANGE BEGIN - support for vertex input description
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2444XGL_VOID XGLAPI xglCmdBindVertexBuffer(
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]2445 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2446 XGL_BUFFER buffer,
Chia-I Wu3b04af52014-11-08 10:48:20 +0800[diff] [blame]2447 XGL_GPU_SIZE offset,
2448 XGL_UINT binding);
2449// IMG CHANGE END
2450
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2451XGL_VOID XGLAPI xglCmdBindIndexBuffer(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2452 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2453 XGL_BUFFER buffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2454 XGL_GPU_SIZE offset,
2455 XGL_INDEX_TYPE indexType);
2456
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2457XGL_VOID XGLAPI xglCmdPrepareBufferRegions(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2458 XGL_CMD_BUFFER cmdBuffer,
2459 XGL_UINT transitionCount,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2460 const XGL_BUFFER_STATE_TRANSITION* pStateTransitions);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2461
2462XGL_VOID XGLAPI xglCmdPrepareImages(
2463 XGL_CMD_BUFFER cmdBuffer,
2464 XGL_UINT transitionCount,
2465 const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
2466
2467XGL_VOID XGLAPI xglCmdDraw(
2468 XGL_CMD_BUFFER cmdBuffer,
2469 XGL_UINT firstVertex,
2470 XGL_UINT vertexCount,
2471 XGL_UINT firstInstance,
2472 XGL_UINT instanceCount);
2473
2474XGL_VOID XGLAPI xglCmdDrawIndexed(
2475 XGL_CMD_BUFFER cmdBuffer,
2476 XGL_UINT firstIndex,
2477 XGL_UINT indexCount,
2478 XGL_INT vertexOffset,
2479 XGL_UINT firstInstance,
2480 XGL_UINT instanceCount);
2481
2482XGL_VOID XGLAPI xglCmdDrawIndirect(
2483 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2484 XGL_BUFFER buffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2485 XGL_GPU_SIZE offset,
2486 XGL_UINT32 count,
2487 XGL_UINT32 stride);
2488
2489XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(
2490 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2491 XGL_BUFFER buffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2492 XGL_GPU_SIZE offset,
2493 XGL_UINT32 count,
2494 XGL_UINT32 stride);
2495
2496XGL_VOID XGLAPI xglCmdDispatch(
2497 XGL_CMD_BUFFER cmdBuffer,
2498 XGL_UINT x,
2499 XGL_UINT y,
2500 XGL_UINT z);
2501
2502XGL_VOID XGLAPI xglCmdDispatchIndirect(
2503 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2504 XGL_BUFFER buffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2505 XGL_GPU_SIZE offset);
2506
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2507XGL_VOID XGLAPI xglCmdCopyBuffer(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2508 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2509 XGL_BUFFER srcBuffer,
2510 XGL_BUFFER destBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2511 XGL_UINT regionCount,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2512 const XGL_BUFFER_COPY* pRegions);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2513
2514XGL_VOID XGLAPI xglCmdCopyImage(
2515 XGL_CMD_BUFFER cmdBuffer,
2516 XGL_IMAGE srcImage,
2517 XGL_IMAGE destImage,
2518 XGL_UINT regionCount,
2519 const XGL_IMAGE_COPY* pRegions);
2520
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2521XGL_VOID XGLAPI xglCmdCopyBufferToImage(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2522 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2523 XGL_BUFFER srcBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2524 XGL_IMAGE destImage,
2525 XGL_UINT regionCount,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2526 const XGL_BUFFER_IMAGE_COPY* pRegions);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2527
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2528XGL_VOID XGLAPI xglCmdCopyImageToBuffer(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2529 XGL_CMD_BUFFER cmdBuffer,
2530 XGL_IMAGE srcImage,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2531 XGL_BUFFER destBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2532 XGL_UINT regionCount,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2533 const XGL_BUFFER_IMAGE_COPY* pRegions);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2534
2535XGL_VOID XGLAPI xglCmdCloneImageData(
2536 XGL_CMD_BUFFER cmdBuffer,
2537 XGL_IMAGE srcImage,
2538 XGL_IMAGE_STATE srcImageState,
2539 XGL_IMAGE destImage,
2540 XGL_IMAGE_STATE destImageState);
2541
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2542XGL_VOID XGLAPI xglCmdUpdateBuffer(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2543 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2544 XGL_BUFFER destBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2545 XGL_GPU_SIZE destOffset,
2546 XGL_GPU_SIZE dataSize,
2547 const XGL_UINT32* pData);
2548
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2549XGL_VOID XGLAPI xglCmdFillBuffer(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2550 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2551 XGL_BUFFER destBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2552 XGL_GPU_SIZE destOffset,
2553 XGL_GPU_SIZE fillSize,
2554 XGL_UINT32 data);
2555
2556XGL_VOID XGLAPI xglCmdClearColorImage(
2557 XGL_CMD_BUFFER cmdBuffer,
2558 XGL_IMAGE image,
2559 const XGL_FLOAT color[4],
2560 XGL_UINT rangeCount,
2561 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2562
2563XGL_VOID XGLAPI xglCmdClearColorImageRaw(
2564 XGL_CMD_BUFFER cmdBuffer,
2565 XGL_IMAGE image,
2566 const XGL_UINT32 color[4],
2567 XGL_UINT rangeCount,
2568 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2569
2570XGL_VOID XGLAPI xglCmdClearDepthStencil(
2571 XGL_CMD_BUFFER cmdBuffer,
2572 XGL_IMAGE image,
2573 XGL_FLOAT depth,
2574 XGL_UINT32 stencil,
2575 XGL_UINT rangeCount,
2576 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2577
2578XGL_VOID XGLAPI xglCmdResolveImage(
2579 XGL_CMD_BUFFER cmdBuffer,
2580 XGL_IMAGE srcImage,
2581 XGL_IMAGE destImage,
2582 XGL_UINT rectCount,
2583 const XGL_IMAGE_RESOLVE* pRects);
2584
2585XGL_VOID XGLAPI xglCmdSetEvent(
2586 XGL_CMD_BUFFER cmdBuffer,
2587 XGL_EVENT event);
2588
2589XGL_VOID XGLAPI xglCmdResetEvent(
2590 XGL_CMD_BUFFER cmdBuffer,
2591 XGL_EVENT event);
2592
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2593XGL_VOID XGLAPI xglCmdBufferAtomic(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2594 XGL_CMD_BUFFER cmdBuffer,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2595 XGL_BUFFER destBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2596 XGL_GPU_SIZE destOffset,
2597 XGL_UINT64 srcData,
2598 XGL_ATOMIC_OP atomicOp);
2599
2600XGL_VOID XGLAPI xglCmdBeginQuery(
2601 XGL_CMD_BUFFER cmdBuffer,
2602 XGL_QUERY_POOL queryPool,
2603 XGL_UINT slot,
2604 XGL_FLAGS flags);
2605
2606XGL_VOID XGLAPI xglCmdEndQuery(
2607 XGL_CMD_BUFFER cmdBuffer,
2608 XGL_QUERY_POOL queryPool,
2609 XGL_UINT slot);
2610
2611XGL_VOID XGLAPI xglCmdResetQueryPool(
2612 XGL_CMD_BUFFER cmdBuffer,
2613 XGL_QUERY_POOL queryPool,
2614 XGL_UINT startQuery,
2615 XGL_UINT queryCount);
2616
2617XGL_VOID XGLAPI xglCmdWriteTimestamp(
2618 XGL_CMD_BUFFER cmdBuffer,
2619 XGL_TIMESTAMP_TYPE timestampType,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2620 XGL_BUFFER destBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2621 XGL_GPU_SIZE destOffset);
2622
2623XGL_VOID XGLAPI xglCmdInitAtomicCounters(
2624 XGL_CMD_BUFFER cmdBuffer,
2625 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2626 XGL_UINT startCounter,
2627 XGL_UINT counterCount,
2628 const XGL_UINT32* pData);
2629
2630XGL_VOID XGLAPI xglCmdLoadAtomicCounters(
2631 XGL_CMD_BUFFER cmdBuffer,
2632 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2633 XGL_UINT startCounter,
2634 XGL_UINT counterCount,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2635 XGL_BUFFER srcBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2636 XGL_GPU_SIZE srcOffset);
2637
2638XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
2639 XGL_CMD_BUFFER cmdBuffer,
2640 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2641 XGL_UINT startCounter,
2642 XGL_UINT counterCount,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2643 XGL_BUFFER destBuffer,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2644 XGL_GPU_SIZE destOffset);
2645
Jeremy Hayese0c3b222015-01-14 16:17:08 -0700[diff] [blame]2646XGL_RESULT XGLAPI xglCreateFramebuffer(
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]2647 XGL_DEVICE device,
2648 const XGL_FRAMEBUFFER_CREATE_INFO* pCreateInfo,
2649 XGL_FRAMEBUFFER* pFramebuffer);
2650
Jeremy Hayese0c3b222015-01-14 16:17:08 -0700[diff] [blame]2651XGL_RESULT XGLAPI xglCreateRenderPass(
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]2652 XGL_DEVICE device,
2653 const XGL_RENDER_PASS_CREATE_INFO* pCreateInfo,
2654 XGL_RENDER_PASS* pRenderPass);
2655
Mark Lobodzinski953a1692015-01-09 15:12:03 -0600[diff] [blame]2656#endif /* XGL_PROTOTYPES */
2657
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2658#ifdef __cplusplus
Jeremy Hayes4c329eb2015-01-14 14:58:37 -0700[diff] [blame]2659}; // extern "C"
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2660#endif // __cplusplus
2661
2662#endif // __XGL_H__
2663
2664/******************************************************************************************
2665
2666 Open Issues + Missing Features
2667 ------------------------------
2668
2669 Here are a few higher level issues that we'd like to fix given time. A feature missing
2670 from this header (or the following list) isn't necessarily an indication that we want
2671 to drop that feature. Only that we either haven't thought of it or haven't had time
2672 to add it yet.
2673
2674 1) Transform Feedback (XFB)
2675
2676 OpenGL supports transform feedback (XFB). That is not included in this header, but
2677 we feel there is likely value in including it.
2678
2679 To incorporate trasnform feedback, we could create a new pipeline stage. This would
2680 be injected into a PSO by including the following in the chain:
2681
2682 typedef struct _XGL_XFB_CREATE_INFO
2683 {
2684 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
2685 const XGL_VOID* pNext; // Pointer to next structure
2686 // More XFB state, if any goes here
2687 } XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
2688
2689 We expect that only the shader-side configuration (via layout qualifiers or their IR
2690 equivalent) is used to configure the data written to each stream. When transform
2691 feedback is part of the pipeline, transform feedback binding would be available
2692 through a new API bind point:
2693
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2694 xglCmdBindTransformFeedbackBufferView(
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2695 XGL_CMD_BUFFER cmdBuffer,
2696 XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
2697 XGL_UINT index,
Chia-I Wu714df452015-01-01 07:55:04 +0800[diff] [blame^]2698 const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView);
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2699
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]2700 2) "Bindless" + support for non-bindless hardware.
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2701
2702 XGL doesn't have bindless textures the way that GL does. It has resource descriptor
2703 sets, or resource tables. Resource tables can be nested and hold references to more
2704 resource tables. They are explicitly sized by the application and have no artificial
2705 upper size limit. An application can still attach as many textures as they want to
2706 a resource descriptor set, and can modify the set asynchronously to GPU work.
2707 Therefore, we can still have "unlimited textures". An application hoping to use
2708 bindless can use an index into a large table of textures and achieve the same effect.
2709
2710 For non-bindless hardware, with fixed (but potentially large) register files for
2711 resource bindings, the table approach should still work if a limited size can be
2712 reported somehow.
2713
Jon Ashburnefdadf82014-12-24 12:09:06 -0700[diff] [blame]2714 3) Clean up some remaining Mantle'isms.
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]2715
2716 Queue types: It's a bit hand wavey. In Mantle, we have a "universal" queue type that
2717 supports compute and graphics and a "compute" queue that only supports compute. Devices
2718 must support at least one universal queue and DMA queues are an extension. I would like
2719 to do the following (and have attempted to do that here, but am only half done):
2720
2721 a) Separate out the queue capabilities (compute, DMA, graphics) and allow support
2722 for any number of queues with any combination of capabilities each.
2723
2724 b) Allow compute-only or even DMA-only (like video capture or SDI) devices to
2725 be supported.
2726
2727 c) Allow new queue types to be supported by extensions without having to allocate
2728 bits in the bitfield until they're promoted to core.
2729
2730 Terminology: There are still some references to "targets" (render targets) and other
2731 terminology that has been changed from Mantle. Need to do a clean-up pass.
2732
2733 4) The window system interface is an extension in Mantle. We have not tried to fold
2734 any of it into core here. There is no mention of SwapBuffers, presentation, default
2735 framebuffers or anything like that. In the extension, presentation is queued up into
2736 the graphics queue just like any other command.
2737
2738*******************************************************************************************/