Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 7f11ed21f3bb9902a0064cda7c30d38918ef5c5f / . / include / xgl.h
blob: 7145b35999b3ff311903c923212524489a23a496 [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
51#include <stdint.h>
52
53#define XGL_MAKE_VERSION(major, minor, patch) \
54 ((major << 22) | (minor << 12) | patch)
55
56// XGL API version supported by this file
57#define XGL_API_VERSION XGL_MAKE_VERSION(0, 22, 0)
58
59#ifndef XGLAPI
60 #define XGLAPI
61#endif
62
63#ifdef __cplusplus
64extern "C"
65{
66#endif // __cplusplus
67
68/*
69 * Datatypes
70 */
71typedef unsigned char XGL_BOOL;
72typedef void XGL_VOID;
73typedef signed char XGL_CHAR; /* 1-byte signed */
74typedef int32_t XGL_INT; /* 4-byte signed */
75typedef int32_t XGL_INT32; /* 4-byte signed */
76typedef uint32_t XGL_UINT; /* 4-byte unsigned */
77typedef uint32_t XGL_UINT32; /* 4-byte unsigned */
78typedef uint64_t XGL_UINT64; /* 8-byte unsigned */
79typedef uint32_t XGL_SIZE; /* 4-byte unsigned */
80typedef uint32_t XGL_GPU_SIZE; /* 4-byte unsigned */
81typedef uint32_t XGL_FLAGS; /* 4-byte unsigned */
82typedef uint32_t XGL_SAMPLE_MASK; /* 4-byte unsigned */
83typedef uint8_t XGL_UINT8; /* 1-byte unsigned */
84typedef float XGL_FLOAT; /* single precision float */
85typedef double XGL_DOUBLE; /* double precision float in [0,1] */
86
87/*
88***************************************************************************************************
89* Core XGL API
90***************************************************************************************************
91*/
92
93#ifdef __cplusplus
94 #define XGL_DEFINE_HANDLE(_obj) struct _obj##_T {}; typedef _obj##_T* _obj;
95 #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) struct _obj##_T : public _base##_T {}; typedef _obj##_T* _obj;
96#else // __cplusplus
97 #define XGL_DEFINE_HANDLE(_obj) typedef void* _obj;
98 #define XGL_DEFINE_SUBCLASS_HANDLE(_obj, _base) typedef void* _obj;
99#endif // __cplusplus
100
101XGL_DEFINE_HANDLE(XGL_PHYSICAL_GPU)
102XGL_DEFINE_HANDLE(XGL_BASE_OBJECT)
103XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEVICE, XGL_BASE_OBJECT)
104XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE, XGL_BASE_OBJECT)
105XGL_DEFINE_SUBCLASS_HANDLE(XGL_GPU_MEMORY, XGL_BASE_OBJECT)
106XGL_DEFINE_SUBCLASS_HANDLE(XGL_OBJECT, XGL_BASE_OBJECT)
107XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE, XGL_OBJECT)
108XGL_DEFINE_SUBCLASS_HANDLE(XGL_IMAGE_VIEW, XGL_OBJECT)
109XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_ATTACHMENT_VIEW, XGL_OBJECT)
110XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_VIEW, XGL_OBJECT)
111XGL_DEFINE_SUBCLASS_HANDLE(XGL_SHADER, XGL_OBJECT)
112XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE, XGL_OBJECT)
113XGL_DEFINE_SUBCLASS_HANDLE(XGL_PIPELINE_DELTA, XGL_OBJECT)
114XGL_DEFINE_SUBCLASS_HANDLE(XGL_SAMPLER, XGL_OBJECT)
115XGL_DEFINE_SUBCLASS_HANDLE(XGL_DESCRIPTOR_SET, XGL_OBJECT)
116XGL_DEFINE_SUBCLASS_HANDLE(XGL_STATE_OBJECT, XGL_OBJECT)
117XGL_DEFINE_SUBCLASS_HANDLE(XGL_VIEWPORT_STATE_OBJECT, XGL_STATE_OBJECT)
118XGL_DEFINE_SUBCLASS_HANDLE(XGL_RASTER_STATE_OBJECT, XGL_STATE_OBJECT)
119XGL_DEFINE_SUBCLASS_HANDLE(XGL_MSAA_STATE_OBJECT, XGL_STATE_OBJECT)
120XGL_DEFINE_SUBCLASS_HANDLE(XGL_COLOR_BLEND_STATE_OBJECT, XGL_STATE_OBJECT)
121XGL_DEFINE_SUBCLASS_HANDLE(XGL_DEPTH_STENCIL_STATE_OBJECT, XGL_STATE_OBJECT)
122XGL_DEFINE_SUBCLASS_HANDLE(XGL_CMD_BUFFER, XGL_OBJECT)
123XGL_DEFINE_SUBCLASS_HANDLE(XGL_FENCE, XGL_OBJECT)
124XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUEUE_SEMAPHORE, XGL_OBJECT)
125XGL_DEFINE_SUBCLASS_HANDLE(XGL_EVENT, XGL_OBJECT)
126XGL_DEFINE_SUBCLASS_HANDLE(XGL_QUERY_POOL, XGL_OBJECT)
127
128#define XGL_MAX_PHYSICAL_GPUS 16
129#define XGL_MAX_PHYSICAL_GPU_NAME 256
130#define XGL_MAX_MEMORY_HEAPS 8
131#define XGL_MAX_DESCRIPTOR_SETS 2
132#define XGL_MAX_VIEWPORTS 16
133#define XGL_MAX_COLOR_ATTACHMENTS 8
134
135#define XGL_LOD_CLAMP_NONE MAX_FLOAT
136#define XGL_LAST_MIP_OR_SLICE 0xffffffff
137
138#define XGL_TRUE 1
139#define XGL_FALSE 0
140
141#define XGL_NULL_HANDLE 0
142
143// This macro defines MAX_UINT in enumerations to force compilers to use 32 bits
144// to represent them. This may or may not be necessary on some compilers. The
145// option to compile it out may allow compilers that warn about missing enumerants
146// in switch statements to be silenced.
147#define XGL_MAX_ENUM(T) T##_MAX_ENUM = 0xFFFFFFFF
148
149// ------------------------------------------------------------------------------------------------
150// Enumerations
151
152
153typedef enum _XGL_QUEUE_TYPE
154{
155 XGL_QUEUE_TYPE_GRAPHICS = 0x1,
156 XGL_QUEUE_TYPE_COMPUTE = 0x2,
157 XGL_QUEUE_TYPE_DMA = 0x3,
158 XGL_MAX_ENUM(_XGL_QUEUE_TYPE)
159} XGL_QUEUE_TYPE;
160
161typedef enum _XGL_MEMORY_PRIORITY
162{
163 XGL_MEMORY_PRIORITY_UNUSED = 0x0,
164 XGL_MEMORY_PRIORITY_VERY_LOW = 0x1,
165 XGL_MEMORY_PRIORITY_LOW = 0x2,
166 XGL_MEMORY_PRIORITY_NORMAL = 0x3,
167 XGL_MEMORY_PRIORITY_HIGH = 0x4,
168 XGL_MEMORY_PRIORITY_VERY_HIGH = 0x5,
169
170 XGL_MEMORY_PRIORITY_BEGIN_RANGE = XGL_MEMORY_PRIORITY_UNUSED,
171 XGL_MEMORY_PRIORITY_END_RANGE = XGL_MEMORY_PRIORITY_VERY_HIGH,
172 XGL_NUM_MEMORY_PRIORITY = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1),
173} XGL_MEMORY_PRIORITY;
174
175typedef enum _XGL_MEMORY_STATE
176{
177 XGL_MEMORY_STATE_DATA_TRANSFER = 0x00000000,
178 XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_ONLY = 0x00000001,
179 XGL_MEMORY_STATE_GRAPHICS_SHADER_WRITE_ONLY = 0x00000002,
180 XGL_MEMORY_STATE_GRAPHICS_SHADER_READ_WRITE = 0x00000003,
181 XGL_MEMORY_STATE_COMPUTE_SHADER_READ_ONLY = 0x00000004,
182 XGL_MEMORY_STATE_COMPUTE_SHADER_WRITE_ONLY = 0x00000005,
183 XGL_MEMORY_STATE_COMPUTE_SHADER_READ_WRITE = 0x00000006,
184 XGL_MEMORY_STATE_MULTI_SHADER_READ_ONLY = 0x00000007,
185 XGL_MEMORY_STATE_INDEX_DATA = 0x00000008,
186 XGL_MEMORY_STATE_INDIRECT_ARG = 0x00000009,
187 XGL_MEMORY_STATE_WRITE_TIMESTAMP = 0x0000000A,
188 XGL_MEMORY_STATE_QUEUE_ATOMIC = 0x0000000B,
189
190 XGL_MEMORY_STATE_BEGIN_RANGE = XGL_MEMORY_STATE_DATA_TRANSFER,
191 XGL_MEMORY_STATE_END_RANGE = XGL_MEMORY_STATE_QUEUE_ATOMIC,
192 XGL_NUM_MEMORY_STATE = (XGL_MEMORY_STATE_END_RANGE - XGL_MEMORY_STATE_BEGIN_RANGE + 1),
193 XGL_MAX_ENUM(_XGL_MEMORY_STATE)
194} XGL_MEMORY_STATE;
195
196typedef enum _XGL_IMAGE_STATE
197{
198 XGL_IMAGE_STATE_DATA_TRANSFER = 0x00000000,
199 XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY = 0x00000001,
200 XGL_IMAGE_STATE_GRAPHICS_SHADER_WRITE_ONLY = 0x00000002,
201 XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_WRITE = 0x00000003,
202 XGL_IMAGE_STATE_COMPUTE_SHADER_READ_ONLY = 0x00000004,
203 XGL_IMAGE_STATE_COMPUTE_SHADER_WRITE_ONLY = 0x00000005,
204 XGL_IMAGE_STATE_COMPUTE_SHADER_READ_WRITE = 0x00000006,
205 XGL_IMAGE_STATE_MULTI_SHADER_READ_ONLY = 0x00000007,
206 XGL_IMAGE_STATE_TARGET_AND_SHADER_READ_ONLY = 0x00000008,
207 XGL_IMAGE_STATE_UNINITIALIZED_TARGET = 0x00000009,
208 XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL = 0x0000000A,
209 XGL_IMAGE_STATE_TARGET_SHADER_ACCESS_OPTIMAL = 0x0000000B,
210 XGL_IMAGE_STATE_CLEAR = 0x0000000C,
211 XGL_IMAGE_STATE_RESOLVE_SOURCE = 0x0000000D,
212 XGL_IMAGE_STATE_RESOLVE_DESTINATION = 0x0000000E,
213
214 XGL_IMAGE_STATE_BEGIN_RANGE = XGL_IMAGE_STATE_DATA_TRANSFER,
215 XGL_IMAGE_STATE_END_RANGE = XGL_IMAGE_STATE_RESOLVE_DESTINATION,
216 XGL_NUM_IMAGE_STATE = (XGL_IMAGE_STATE_END_RANGE - XGL_IMAGE_STATE_BEGIN_RANGE + 1),
217 XGL_MAX_ENUM(_XGL_IMAGE_STATE)
218} XGL_IMAGE_STATE;
219
220typedef enum _XGL_IMAGE_TYPE
221{
222 XGL_IMAGE_1D = 0x00000000,
223 XGL_IMAGE_2D = 0x00000001,
224 XGL_IMAGE_3D = 0x00000002,
225
226 XGL_IMAGE_TYPE_BEGIN_RANGE = XGL_IMAGE_1D,
227 XGL_IMAGE_TYPE_END_RANGE = XGL_IMAGE_3D,
228 XGL_NUM_IMAGE_TYPE = (XGL_IMAGE_TYPE_END_RANGE - XGL_IMAGE_TYPE_BEGIN_RANGE + 1),
229 XGL_MAX_ENUM(_XGL_IMAGE_TYPE)
230} XGL_IMAGE_TYPE;
231
232typedef enum _XGL_IMAGE_TILING
233{
234 XGL_LINEAR_TILING = 0x00000000,
235 XGL_OPTIMAL_TILING = 0x00000001,
236
237 XGL_IMAGE_TILING_BEGIN_RANGE = XGL_LINEAR_TILING,
238 XGL_IMAGE_TILING_END_RANGE = XGL_OPTIMAL_TILING,
239 XGL_NUM_IMAGE_TILING = (XGL_IMAGE_TILING_END_RANGE - XGL_IMAGE_TILING_BEGIN_RANGE + 1),
240 XGL_MAX_ENUM(_XGL_IMAGE_TILING)
241} XGL_IMAGE_TILING;
242
243typedef enum _XGL_IMAGE_VIEW_TYPE
244{
245 XGL_IMAGE_VIEW_1D = 0x00000000,
246 XGL_IMAGE_VIEW_2D = 0x00000001,
247 XGL_IMAGE_VIEW_3D = 0x00000002,
248 XGL_IMAGE_VIEW_CUBE = 0x00000003,
249
250 XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE = XGL_IMAGE_VIEW_1D,
251 XGL_IMAGE_VIEW_TYPE_END_RANGE = XGL_IMAGE_VIEW_CUBE,
252 XGL_NUM_IMAGE_VIEW_TYPE = (XGL_IMAGE_VIEW_TYPE_END_RANGE - XGL_IMAGE_VIEW_TYPE_BEGIN_RANGE + 1),
253 XGL_MAX_ENUM(_XGL_IMAGE_VIEW_TYPE)
254} XGL_IMAGE_VIEW_TYPE;
255
256typedef enum _XGL_IMAGE_ASPECT
257{
258 XGL_IMAGE_ASPECT_COLOR = 0x00000000,
259 XGL_IMAGE_ASPECT_DEPTH = 0x00000001,
260 XGL_IMAGE_ASPECT_STENCIL = 0x00000002,
261
262 XGL_IMAGE_ASPECT_BEGIN_RANGE = XGL_IMAGE_ASPECT_COLOR,
263 XGL_IMAGE_ASPECT_END_RANGE = XGL_IMAGE_ASPECT_STENCIL,
264 XGL_NUM_IMAGE_ASPECT = (XGL_IMAGE_ASPECT_END_RANGE - XGL_IMAGE_ASPECT_BEGIN_RANGE + 1),
265 XGL_MAX_ENUM(_XGL_IMAGE_ASPECT)
266} XGL_IMAGE_ASPECT;
267
268typedef enum _XGL_CHANNEL_SWIZZLE
269{
270 XGL_CHANNEL_SWIZZLE_ZERO = 0x00000000,
271 XGL_CHANNEL_SWIZZLE_ONE = 0x00000001,
272 XGL_CHANNEL_SWIZZLE_R = 0x00000002,
273 XGL_CHANNEL_SWIZZLE_G = 0x00000003,
274 XGL_CHANNEL_SWIZZLE_B = 0x00000004,
275 XGL_CHANNEL_SWIZZLE_A = 0x00000005,
276
277 XGL_CHANNEL_SWIZZLE_BEGIN_RANGE = XGL_CHANNEL_SWIZZLE_ZERO,
278 XGL_CHANNEL_SWIZZLE_END_RANGE = XGL_CHANNEL_SWIZZLE_A,
279 XGL_NUM_CHANNEL_SWIZZLE = (XGL_CHANNEL_SWIZZLE_END_RANGE - XGL_CHANNEL_SWIZZLE_BEGIN_RANGE + 1),
280 XGL_MAX_ENUM(_XGL_CHANNEL_SWIZZLE)
281} XGL_CHANNEL_SWIZZLE;
282
283typedef enum _XGL_DESCRIPTOR_SET_SLOT_TYPE
284{
285 XGL_SLOT_UNUSED = 0x00000000,
286 XGL_SLOT_SHADER_RESOURCE = 0x00000001,
287 XGL_SLOT_SHADER_UAV = 0x00000002,
288 XGL_SLOT_SHADER_SAMPLER = 0x00000003,
289 XGL_SLOT_NEXT_DESCRIPTOR_SET = 0x00000004,
290
291 XGL_DESCRIPTOR_SET_SLOT_TYPE_BEGIN_RANGE = XGL_SLOT_UNUSED,
292 XGL_DESCRIPTOR_SET_SLOT_TYPE_END_RANGE = XGL_SLOT_NEXT_DESCRIPTOR_SET,
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{
438 XFL_FILL_POINTS = 0x00000000,
439 XGL_FILL_WIREFRAME = 0x00000001,
440 XGL_FILL_SOLID = 0x00000002,
441
442 XGL_FILL_MODE_BEGIN_RANGE = XGL_FILL_SOLID,
443 XGL_FILL_MODE_END_RANGE = XFL_FILL_POINTS,
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,
771 XGL_MAX_CH_FMT = XGL_CH_FMT_BC7,
772 XGL_MAX_ENUM(_XGL_CHANNEL_FORMAT)
773} XGL_CHANNEL_FORMAT;
774
775typedef enum _XGL_NUM_FORMAT
776{
777 XGL_NUM_FMT_UNDEFINED = 0,
778 XGL_NUM_FMT_UNORM = 1,
779 XGL_NUM_FMT_SNORM = 2,
780 XGL_NUM_FMT_UINT = 3,
781 XGL_NUM_FMT_SINT = 4,
782 XGL_NUM_FMT_FLOAT = 5,
783 XGL_NUM_FMT_SRGB = 6,
784 XGL_NUM_FMT_DS = 7,
785 XGL_MAX_NUM_FMT = XGL_NUM_FMT_DS,
786 XGL_MAX_ENUM(_XGL_NUM_FORMAT)
787} XGL_NUM_FORMAT;
788
789typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
790{
791 XGL_PROVOKING_VERTEX_FIRST = 0,
792 XGL_PROVOKING_VERTEX_LAST = 1,
793
794 XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
795 XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
796 XGL_NUM_PROVOKING_VERTEX_CONVENTIONS = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
797 XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
798} XGL_PROVOKING_VERTEX_CONVENTION;
799
800typedef struct _XGL_FORMAT
801{
802 XGL_CHANNEL_FORMAT channelFormat;
803 XGL_NUM_FORMAT numericFormat;
804} XGL_FORMAT;
805
806// Shader stage enumerant
807typedef enum _XGL_PIPELINE_SHADER_STAGE
808{
809 XGL_SHADER_STAGE_VERTEX = 0,
810 XGL_SHADER_STAGE_TESS_CONTROL = 1,
811 XGL_SHADER_STAGE_TESS_EVALUATION = 2,
812 XGL_SHADER_STAGE_GEOMETRY = 3,
813 XGL_SHADER_STAGE_FRAGMENT = 4,
814 XGL_SHADER_STAGE_COMPUTE = 5,
815 XGL_MAX_ENUM(_XGL_PIPELINE_SHADER_STAGE)
816} XGL_PIPELINE_SHADER_STAGE;
817
818// Structure type enumerant
819typedef enum _XGL_STRUCTURE_TYPE
820{
821 XGL_STRUCTURE_TYPE_APPLICATION_INFO = 0,
822 XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
823 XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
824 XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4,
825 XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5,
826 XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO = 6,
827 XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7,
828 XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION = 8,
829 XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9,
830 XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10,
831 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11,
832 XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12,
833 XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13,
834 XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14,
835 XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO = 15,
836 XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO = 16,
837 XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO = 17,
838 XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO = 18,
839 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO = 19,
840 XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
841 XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
842 XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
843 XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23,
844 XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24,
845 XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
846 XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
847 XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
Courtney Goeltzenleuchter7f11ed22014-08-15 14:54:58 -0600[diff] [blame^]848 XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 28,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]849 XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO = 29,
850 XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 30,
851 XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 31,
852 XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 32,
853 XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 33,
854 XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
855} XGL_STRUCTURE_TYPE;
856
857// ------------------------------------------------------------------------------------------------
858// Flags
859
860// Device creation flags
861typedef enum _XGL_DEVICE_CREATE_FLAGS
862{
863 XGL_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
864 XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002,
865} XGL_DEVICE_CREATE_FLAGS;
866
867// Queue capabilities
868typedef enum _XGL_QUEUE_FLAGS
869{
870 XGL_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations
871 XGL_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations
872 XGL_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations
873 XGL_QUEUE_EXTENDED_BIT = 0x80000000 // Extended queue
874} XGL_QUEUE_FLAGS;
875
876// Memory heap properties
877typedef enum _XGL_MEMORY_HEAP_FLAGS
878{
879 XGL_MEMORY_HEAP_CPU_VISIBLE_BIT = 0x00000001,
880 XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT = 0x00000002,
881 XGL_MEMORY_HEAP_CPU_UNCACHED_BIT = 0x00000004,
882 XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT = 0x00000008,
883 XGL_MEMORY_HEAP_HOLDS_PINNED_BIT = 0x00000010,
884 XGL_MEMORY_HEAP_SHAREABLE_BIT = 0x00000020,
885} XGL_MEMORY_HEAP_FLAGS;
886
887// Memory allocation flags
888typedef enum _XGL_MEMORY_ALLOC_FLAGS
889{
890 XGL_MEMORY_ALLOC_VIRTUAL_BIT = 0x00000001,
891 XGL_MEMORY_ALLOC_SHAREABLE_BIT = 0x00000002,
892} XGL_MEMORY_ALLOC_FLAGS;
893
894// Image usage flags
895typedef enum _XGL_IMAGE_USAGE_FLAGS
896{
897 XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001,
898 XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002,
899 XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000004,
900 XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000008,
901} XGL_IMAGE_USAGE_FLAGS;
902
903// Image flags
904typedef enum _XGL_IMAGE_CREATE_FLAGS
905{
906 XGL_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
907 XGL_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002,
908 XGL_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004,
909} XGL_IMAGE_CREATE_FLAGS;
910
911// Depth-stencil view creation flags
912typedef enum _XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
913{
914 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
915 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
916} XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS;
917
918// Pipeline creation flags
919typedef enum _XGL_PIPELINE_CREATE_FLAGS
920{
921 XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
922} XGL_PIPELINE_CREATE_FLAGS;
923
924// Semaphore creation flags
925typedef enum _XGL_SEMAPHORE_CREATE_FLAGS
926{
927 XGL_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001,
928} XGL_SEMAPHORE_CREATE_FLAGS;
929
930// Memory reference flags
931typedef enum _XGL_MEMORY_REF_FLAGS
932{
933 XGL_MEMORY_REF_READ_ONLY_BIT = 0x00000001,
934} XGL_MEMORY_REF_FLAGS;
935
936// Format capability flags
937typedef enum _XGL_FORMAT_FEATURE_FLAGS
938{
939 XGL_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001,
940 XGL_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002,
941 XGL_FORMAT_IMAGE_COPY_BIT = 0x00000004,
942 XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT = 0x00000008,
943 XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT = 0x00000010,
944 XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000020,
945 XGL_FORMAT_DEPTH_ATTACHMENT_BIT = 0x00000040,
946 XGL_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080,
947 XGL_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100,
948 XGL_FORMAT_CONVERSION_BIT = 0x00000200,
949} XGL_FORMAT_FEATURE_FLAGS;
950
951// Query flags
952typedef enum _XGL_QUERY_CONTROL_FLAGS
953{
954 XGL_QUERY_IMPRECISE_DATA_BIT = 0x00000001,
955} XGL_QUERY_CONTROL_FLAGS;
956
957// GPU compatibility flags
958typedef enum _XGL_GPU_COMPATIBILITY_FLAGS
959{
960 XGL_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001,
961 XGL_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002,
962 XGL_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004,
963 XGL_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008,
964 XGL_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010,
965 XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020,
966 XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040,
967} XGL_GPU_COMPATIBILITY_FLAGS;
968
969// Command buffer building flags
970typedef enum _XGL_CMD_BUFFER_BUILD_FLAGS
971{
972 XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001,
973 XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
974 XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
975 XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
976} XGL_CMD_BUFFER_BUILD_FLAGS;
977
978// ------------------------------------------------------------------------------------------------
979// XGL structures
980
981typedef struct _XGL_OFFSET2D
982{
983 XGL_INT x;
984 XGL_INT y;
985} XGL_OFFSET2D;
986
987typedef struct _XGL_OFFSET3D
988{
989 XGL_INT x;
990 XGL_INT y;
991 XGL_INT z;
992} XGL_OFFSET3D;
993
994typedef struct _XGL_EXTENT2D
995{
996 XGL_INT width;
997 XGL_INT height;
998} XGL_EXTENT2D;
999
1000typedef struct _XGL_EXTENT3D
1001{
1002 XGL_INT width;
1003 XGL_INT height;
1004 XGL_INT depth;
1005} XGL_EXTENT3D;
1006
1007typedef struct _XGL_VIEWPORT
1008{
1009 XGL_FLOAT originX;
1010 XGL_FLOAT originY;
1011 XGL_FLOAT width;
1012 XGL_FLOAT height;
1013 XGL_FLOAT minDepth;
1014 XGL_FLOAT maxDepth;
1015} XGL_VIEWPORT;
1016
1017typedef struct _XGL_RECT
1018{
1019 XGL_OFFSET2D offset;
1020 XGL_EXTENT2D extent;
1021} XGL_RECT;
1022
1023typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
1024{
1025 XGL_SIZE structSize;
1026 XGL_UINT32 apiVersion;
1027 XGL_UINT32 driverVersion;
1028 XGL_UINT32 vendorId;
1029 XGL_UINT32 deviceId;
1030 XGL_PHYSICAL_GPU_TYPE gpuType;
1031 XGL_CHAR gpuName[XGL_MAX_PHYSICAL_GPU_NAME];
1032 XGL_UINT maxMemRefsPerSubmission;
1033 XGL_GPU_SIZE virtualMemPageSize;
1034 XGL_GPU_SIZE maxInlineMemoryUpdateSize;
1035 XGL_UINT maxBoundDescriptorSets;
1036 XGL_UINT maxThreadGroupSize;
1037 XGL_UINT64 timestampFrequency;
1038 XGL_BOOL multiColorAttachmentClears;
1039} XGL_PHYSICAL_GPU_PROPERTIES;
1040
1041typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE
1042{
1043 XGL_FLOAT maxGpuClock;
1044 XGL_FLOAT aluPerClock;
1045 XGL_FLOAT texPerClock;
1046 XGL_FLOAT primsPerClock;
1047 XGL_FLOAT pixelsPerClock;
1048} XGL_PHYSICAL_GPU_PERFORMANCE;
1049
1050typedef struct _XGL_GPU_COMPATIBILITY_INFO
1051{
1052 XGL_FLAGS compatibilityFlags; // XGL_GPU_COMPATIBILITY_FLAGS
1053} XGL_GPU_COMPATIBILITY_INFO;
1054
1055typedef struct _XGL_APPLICATION_INFO
1056{
1057 XGL_STRUCTURE_TYPE sType; // Type of structure. Should be XGL_STRUCTURE_TYPE_APPLICATION_INFO
1058 XGL_VOID* pNext; // Next structure in chain
1059 const XGL_CHAR* pAppName;
1060 XGL_UINT32 appVersion;
1061 const XGL_CHAR* pEngineName;
1062 XGL_UINT32 engineVersion;
1063 XGL_UINT32 apiVersion;
1064} XGL_APPLICATION_INFO;
1065
1066typedef XGL_VOID* (XGLAPI *XGL_ALLOC_FUNCTION)(
1067 XGL_VOID* pUserData,
1068 XGL_SIZE size,
1069 XGL_SIZE alignment,
1070 XGL_SYSTEM_ALLOC_TYPE allocType);
1071
1072typedef XGL_VOID (XGLAPI *XGL_FREE_FUNCTION)(
1073 XGL_VOID* pUserData,
1074 XGL_VOID* pMem);
1075
1076typedef struct _XGL_ALLOC_CALLBACKS
1077{
1078 XGL_VOID* pUserData;
1079 XGL_ALLOC_FUNCTION pfnAlloc;
1080 XGL_FREE_FUNCTION pfnFree;
1081} XGL_ALLOC_CALLBACKS;
1082
1083typedef struct _XGL_DEVICE_QUEUE_CREATE_INFO
1084{
1085 XGL_UINT queueNodeIndex;
1086 XGL_UINT queueCount;
1087} XGL_DEVICE_QUEUE_CREATE_INFO;
1088
1089typedef struct _XGL_DEVICE_CREATE_INFO
1090{
1091 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO
1092 XGL_VOID* pNext; // Pointer to next structure
1093 XGL_UINT queueRecordCount;
1094 const XGL_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues;
1095 XGL_UINT extensionCount;
1096 const XGL_CHAR*const* ppEnabledExtensionNames;
1097 XGL_VALIDATION_LEVEL maxValidationLevel;
1098 XGL_FLAGS flags; // XGL_DEVICE_CREATE_FLAGS
1099} XGL_DEVICE_CREATE_INFO;
1100
1101typedef struct _XGL_PHYSICAL_GPU_QUEUE_PROPERTIES
1102{
1103 XGL_SIZE structSize; // Size of structure in bytes
1104 XGL_FLAGS queueFlags; // XGL_QUEUE_FLAGS
1105 XGL_UINT queueCount;
1106 XGL_UINT maxAtomicCounters;
1107 XGL_BOOL supportsTimestamps;
1108} XGL_PHYSICAL_GPU_QUEUE_PROPERTIES;
1109
1110typedef struct _XGL_PHYSICAL_GPU_MEMORY_PROPERTIES
1111{
1112 XGL_SIZE structSize; // Size of structure in bytes
1113 XGL_BOOL supportsMigration;
1114 XGL_BOOL supportsVirtualMemoryRemapping;
1115 XGL_BOOL supportsPinning;
1116} XGL_PHYSICAL_GPU_MEMORY_PROPERTIES;
1117
1118typedef struct _XGL_MEMORY_HEAP_PROPERTIES
1119{
1120 XGL_SIZE structSize; // Size of structure in bytes
1121 XGL_HEAP_MEMORY_TYPE heapMemoryType; // XGL_HEAP_MEMORY_TYPE
1122 XGL_GPU_SIZE heapSize; // Specified in bytes
1123 XGL_GPU_SIZE pageSize; // Specified in bytes
1124 XGL_FLAGS flags; // XGL_MEMORY_HEAP_FLAGS
1125 XGL_FLOAT gpuReadPerfRating;
1126 XGL_FLOAT gpuWritePerfRating;
1127 XGL_FLOAT cpuReadPerfRating;
1128 XGL_FLOAT cpuWritePerfRating;
1129} XGL_MEMORY_HEAP_PROPERTIES;
1130
1131typedef struct _XGL_MEMORY_ALLOC_INFO
1132{
1133 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
1134 XGL_VOID* pNext; // Pointer to next structure
1135 XGL_GPU_SIZE allocationSize; // Size of memory allocation
1136 XGL_GPU_SIZE alignment;
1137 XGL_FLAGS flags; // XGL_MEMORY_ALLOC_FLAGS
1138 XGL_UINT heapCount;
1139 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1140 XGL_MEMORY_PRIORITY memPriority;
1141} XGL_MEMORY_ALLOC_INFO;
1142
1143typedef struct _XGL_MEMORY_OPEN_INFO
1144{
1145 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO
1146 XGL_VOID* pNext; // Pointer to next structure
1147 XGL_GPU_MEMORY sharedMem;
1148} XGL_MEMORY_OPEN_INFO;
1149
1150typedef struct _XGL_PEER_MEMORY_OPEN_INFO
1151{
1152 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
1153 XGL_VOID* pNext; // Pointer to next structure
1154 XGL_GPU_MEMORY originalMem;
1155} XGL_PEER_MEMORY_OPEN_INFO;
1156
1157typedef struct _XGL_VIRTUAL_MEMORY_REMAP_RANGE
1158{
1159 XGL_GPU_MEMORY virtualMem;
1160 XGL_GPU_SIZE virtualStartPage;
1161 XGL_GPU_MEMORY realMem;
1162 XGL_GPU_SIZE realStartPage;
1163 XGL_GPU_SIZE pageCount;
1164} XGL_VIRTUAL_MEMORY_REMAP_RANGE;
1165
1166typedef struct _XGL_MEMORY_REQUIREMENTS
1167{
1168 XGL_GPU_SIZE size; // Specified in bytes
1169 XGL_GPU_SIZE alignment; // Specified in bytes
1170 XGL_UINT heapCount;
1171 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1172} XGL_MEMORY_REQUIREMENTS;
1173
1174typedef struct _XGL_FORMAT_PROPERTIES
1175{
1176 XGL_FLAGS linearTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1177 XGL_FLAGS optimalTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1178} XGL_FORMAT_PROPERTIES;
1179
1180typedef struct _XGL_MEMORY_VIEW_ATTACH_INFO
1181{
1182 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
1183 XGL_VOID* pNext; // Pointer to next structure
1184 XGL_GPU_MEMORY mem;
1185 XGL_GPU_SIZE offset;
1186 XGL_GPU_SIZE range;
1187 XGL_GPU_SIZE stride;
1188 XGL_FORMAT format;
1189 XGL_MEMORY_STATE state;
1190} XGL_MEMORY_VIEW_ATTACH_INFO;
1191
1192typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
1193{
1194 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
1195 XGL_VOID* pNext; // Pointer to next structure
1196 XGL_IMAGE_VIEW view;
1197 XGL_IMAGE_STATE state;
1198} XGL_IMAGE_VIEW_ATTACH_INFO;
1199
1200typedef struct _XGL_MEMORY_STATE_TRANSITION
1201{
1202 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION
1203 XGL_VOID* pNext; // Pointer to next structure
1204 XGL_GPU_MEMORY mem;
1205 XGL_MEMORY_STATE oldState;
1206 XGL_MEMORY_STATE newState;
1207 XGL_GPU_SIZE offset;
1208 XGL_GPU_SIZE regionSize;
1209} XGL_MEMORY_STATE_TRANSITION;
1210
1211typedef struct _XGL_IMAGE_SUBRESOURCE
1212{
1213 XGL_IMAGE_ASPECT aspect;
1214 XGL_UINT mipLevel;
1215 XGL_UINT arraySlice;
1216} XGL_IMAGE_SUBRESOURCE;
1217
1218typedef struct _XGL_IMAGE_SUBRESOURCE_RANGE
1219{
1220 XGL_IMAGE_ASPECT aspect;
1221 XGL_UINT baseMipLevel;
1222 XGL_UINT mipLevels;
1223 XGL_UINT baseArraySlice;
1224 XGL_UINT arraySize;
1225} XGL_IMAGE_SUBRESOURCE_RANGE;
1226
1227typedef struct _XGL_IMAGE_STATE_TRANSITION
1228{
1229 XGL_IMAGE image;
1230 XGL_IMAGE_STATE oldState;
1231 XGL_IMAGE_STATE newState;
1232 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1233} XGL_IMAGE_STATE_TRANSITION;
1234
1235typedef struct _XGL_IMAGE_CREATE_INFO
1236{
1237 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
1238 const XGL_VOID* pNext; // Pointer to next structure.
1239 XGL_IMAGE_TYPE imageType;
1240 XGL_FORMAT format;
1241 XGL_EXTENT3D extent;
1242 XGL_UINT mipLevels;
1243 XGL_UINT arraySize;
1244 XGL_UINT samples;
1245 XGL_IMAGE_TILING tiling;
1246 XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS
1247 XGL_FLAGS flags; // XGL_IMAGE_CREATE_FLAGS
1248} XGL_IMAGE_CREATE_INFO;
1249
1250typedef struct _XGL_PEER_IMAGE_OPEN_INFO
1251{
1252 XGL_IMAGE originalImage;
1253} XGL_PEER_IMAGE_OPEN_INFO;
1254
1255typedef struct _XGL_SUBRESOURCE_LAYOUT
1256{
1257 XGL_GPU_SIZE offset; // Specified in bytes
1258 XGL_GPU_SIZE size; // Specified in bytes
1259 XGL_GPU_SIZE rowPitch; // Specified in bytes
1260 XGL_GPU_SIZE depthPitch; // Specified in bytes
1261} XGL_SUBRESOURCE_LAYOUT;
1262
1263typedef struct _XGL_CHANNEL_MAPPING
1264{
1265 XGL_CHANNEL_SWIZZLE r;
1266 XGL_CHANNEL_SWIZZLE g;
1267 XGL_CHANNEL_SWIZZLE b;
1268 XGL_CHANNEL_SWIZZLE a;
1269} XGL_CHANNEL_MAPPING;
1270
1271typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
1272{
1273 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
1274 const XGL_VOID* pNext; // Pointer to next structure
1275 XGL_IMAGE image;
1276 XGL_IMAGE_VIEW_TYPE viewType;
1277 XGL_FORMAT format;
1278 XGL_CHANNEL_MAPPING channels;
1279 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1280 XGL_FLOAT minLod;
1281} XGL_IMAGE_VIEW_CREATE_INFO;
1282
1283typedef struct _XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1284{
1285 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1286 XGL_VOID* pNext; // Pointer to next structure
1287 XGL_IMAGE image;
1288 XGL_FORMAT format;
1289 XGL_UINT mipLevel;
1290 XGL_UINT baseArraySlice;
1291 XGL_UINT arraySize;
1292} XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO;
1293
1294typedef struct _XGL_DEPTH_STENCIL_VIEW_CREATE_INFO
1295{
1296 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
1297 const XGL_VOID* pNext; // Pointer to next structure
1298 XGL_IMAGE image;
1299 XGL_UINT mipLevel;
1300 XGL_UINT baseArraySlice;
1301 XGL_UINT arraySize;
1302 XGL_FLAGS flags; // XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
1303} XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
1304
1305typedef struct _XGL_COLOR_ATTACHMENT_BIND_INFO
1306{
1307 XGL_COLOR_ATTACHMENT_VIEW view;
1308 XGL_IMAGE_STATE colorAttachmentState; // XGL_IMAGE_STATE
1309} XGL_COLOR_ATTACHMENT_BIND_INFO;
1310
1311typedef struct _XGL_DEPTH_STENCIL_BIND_INFO
1312{
1313 XGL_DEPTH_STENCIL_VIEW view;
1314 XGL_IMAGE_STATE depthState; // XGL_IMAGE_STATE
1315 XGL_IMAGE_STATE stencilState; // XGL_IMAGE_STATE
1316} XGL_DEPTH_STENCIL_BIND_INFO;
1317
1318typedef struct _XGL_MEMORY_COPY
1319{
1320 XGL_GPU_SIZE srcOffset; // Specified in bytes
1321 XGL_GPU_SIZE destOffset; // Specified in bytes
1322 XGL_GPU_SIZE copySize; // Specified in bytes
1323} XGL_MEMORY_COPY;
1324
1325typedef struct _XGL_IMAGE_COPY
1326{
1327 XGL_IMAGE_SUBRESOURCE srcSubresource;
1328 XGL_OFFSET3D srcOffset;
1329 XGL_IMAGE_SUBRESOURCE destSubresource;
1330 XGL_OFFSET3D destOffset;
1331 XGL_EXTENT3D extent;
1332} XGL_IMAGE_COPY;
1333
1334typedef struct _XGL_MEMORY_IMAGE_COPY
1335{
1336 XGL_GPU_SIZE memOffset; // Specified in bytes
1337 XGL_IMAGE_SUBRESOURCE imageSubresource;
1338 XGL_OFFSET3D imageOffset;
1339 XGL_EXTENT3D imageExtent;
1340} XGL_MEMORY_IMAGE_COPY;
1341
1342typedef struct _XGL_IMAGE_RESOLVE
1343{
1344 XGL_IMAGE_SUBRESOURCE srcSubresource;
1345 XGL_OFFSET2D srcOffset;
1346 XGL_IMAGE_SUBRESOURCE destSubresource;
1347 XGL_OFFSET2D destOffset;
1348 XGL_EXTENT2D extent;
1349} XGL_IMAGE_RESOLVE;
1350
1351typedef struct _XGL_SHADER_CREATE_INFO
1352{
1353 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO
1354 const XGL_VOID* pNext; // Pointer to next structure
1355 XGL_SIZE codeSize; // Specified in bytes
1356 const XGL_VOID* pCode;
1357 XGL_FLAGS flags; // Reserved
1358} XGL_SHADER_CREATE_INFO;
1359
1360struct _XGL_DESCRIPTOR_SET_MAPPING;
1361
1362typedef struct _XGL_DESCRIPTOR_SLOT_INFO
1363{
1364 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1365 union
1366 {
1367 XGL_UINT shaderEntityIndex;// Shader IL slot index for given entity type
1368 const struct _XGL_DESCRIPTOR_SET_MAPPING* pNextLevelSet; // Pointer to next descriptor set level
1369 };
1370} XGL_DESCRIPTOR_SLOT_INFO;
1371
1372typedef struct _XGL_DESCRIPTOR_SET_MAPPING
1373{
1374 XGL_UINT descriptorCount;
1375 const XGL_DESCRIPTOR_SLOT_INFO* pDescriptorInfo;
1376} XGL_DESCRIPTOR_SET_MAPPING;
1377
1378typedef struct _XGL_LINK_CONST_BUFFER
1379{
1380 XGL_UINT bufferId;
1381 XGL_SIZE bufferSize;
1382 const XGL_VOID* pBufferData;
1383} XGL_LINK_CONST_BUFFER;
1384
1385typedef struct _XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO
1386{
1387 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1388 XGL_UINT shaderEntityIndex;
1389} XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO;
1390
1391typedef struct _XGL_PIPELINE_SHADER
1392{
1393 XGL_PIPELINE_SHADER_STAGE stage;
1394 XGL_SHADER shader;
1395 XGL_DESCRIPTOR_SET_MAPPING descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
1396 XGL_UINT linkConstBufferCount;
1397 const XGL_LINK_CONST_BUFFER* pLinkConstBufferInfo;
1398 XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO dynamicMemoryViewMapping;
1399} XGL_PIPELINE_SHADER;
1400
1401typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
1402{
1403 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
1404 const XGL_VOID* pNext; // Pointer to next structure
1405 XGL_PIPELINE_SHADER cs;
1406 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1407} XGL_COMPUTE_PIPELINE_CREATE_INFO;
1408
1409typedef struct _XGL_PIPELINE_IA_STATE_CREATE_INFO
1410{
1411 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
1412 const XGL_VOID* pNext; // Pointer to next structure
1413 XGL_PRIMITIVE_TOPOLOGY topology;
1414 XGL_BOOL disableVertexReuse;
1415 XGL_PROVOKING_VERTEX_CONVENTION provokingVertex;
1416 XGL_BOOL primitiveRestartEnable;
1417 XGL_UINT32 primitiveRestartIndex;
1418} XGL_PIPELINE_IA_STATE_CREATE_INFO;
1419
1420typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO
1421{
1422 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
1423 const XGL_VOID* pNext; // Pointer to next structure
1424 XGL_UINT patchControlPoints;
1425 XGL_FLOAT optimalTessFactor;
1426 XGL_FLOAT fixedTessFactor;
1427} XGL_PIPELINE_TESS_STATE_CREATE_INFO;
1428
1429typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO
1430{
1431 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
1432 const XGL_VOID* pNext; // Pointer to next structure
1433 XGL_BOOL depthClipEnable;
1434 XGL_BOOL rasterizerDiscardEnable;
1435 XGL_FLOAT pointSize; // Size of points
1436} XGL_PIPELINE_RS_STATE_CREATE_INFO;
1437
1438typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE
1439{
1440 XGL_BOOL blendEnable;
1441 XGL_FORMAT format;
1442 XGL_UINT8 channelWriteMask;
1443} XGL_PIPELINE_CB_ATTACHMENT_STATE;
1444
1445typedef struct _XGL_PIPELINE_CB_STATE_CREATE_INFO
1446{
1447 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
1448 const XGL_VOID* pNext; // Pointer to next structure
1449 XGL_BOOL alphaToCoverageEnable;
1450 XGL_BOOL dualSourceBlendEnable;
1451 XGL_LOGIC_OP logicOp;
1452 XGL_PIPELINE_CB_ATTACHMENT_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1453} XGL_PIPELINE_CB_STATE;
1454
1455typedef struct _XGL_PIPELINE_DB_STATE_CREATE_INFO
1456{
1457 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
1458 const XGL_VOID* pNext; // Pointer to next structure
1459 XGL_FORMAT format;
1460} XGL_PIPELINE_DB_STATE_CREATE_INFO;
1461
1462typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
1463{
1464 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
1465 const XGL_VOID* pNext; // Pointer to next structure
1466 XGL_PIPELINE_SHADER shader;
1467} XGL_PIPELINE_SHADER_STAGE_CREATE_INFO;
1468
1469typedef struct _XGL_GRAPHICS_PIPELINE_CREATE_INFO
1470{
1471 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
1472 const XGL_VOID* pNext; // Pointer to next structure
1473 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1474} XGL_GRAPHICS_PIPELINE_CREATE_INFO;
1475
1476typedef struct _XGL_SAMPLER_CREATE_INFO
1477{
1478 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
1479 const XGL_VOID* pNext; // Pointer to next structure
1480 XGL_TEX_FILTER magFilter; // Filter mode for magnification
1481 XGL_TEX_FILTER minFilter; // Filter mode for minifiation
1482 XGL_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode
1483 XGL_TEX_ADDRESS addressU;
1484 XGL_TEX_ADDRESS addressV;
1485 XGL_TEX_ADDRESS addressW;
1486 XGL_FLOAT mipLodBias;
1487 XGL_UINT maxAnisotropy;
1488 XGL_COMPARE_FUNC compareFunc;
1489 XGL_FLOAT minLod;
1490 XGL_FLOAT maxLod;
1491 XGL_BORDER_COLOR_TYPE borderColorType;
1492} XGL_SAMPLER_CREATE_INFO;
1493
1494typedef struct _XGL_DESCRIPTOR_SET_CREATE_INFO
1495{
1496 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
1497 const XGL_VOID* pNext; // Pointer to next structure
1498 XGL_UINT slots;
1499} XGL_DESCRIPTOR_SET_CREATE_INFO;
1500
1501typedef struct _XGL_DESCRIPTOR_SET_ATTACH_INFO
1502{
1503 XGL_DESCRIPTOR_SET descriptorSet;
1504 XGL_UINT slotOffset;
1505} XGL_DESCRIPTOR_SET_ATTACH_INFO;
1506
1507typedef struct _XGL_VIEWPORT_STATE_CREATE_INFO
1508{
1509 XGL_UINT viewportCount;
1510 XGL_BOOL scissorEnable;
1511 XGL_VIEWPORT viewports[XGL_MAX_VIEWPORTS];
1512 XGL_RECT scissors[XGL_MAX_VIEWPORTS];
1513} XGL_VIEWPORT_STATE_CREATE_INFO;
1514
1515typedef struct _XGL_RASTER_STATE_CREATE_INFO
1516{
1517 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO
1518 const XGL_VOID* pNext; // Pointer to next structure
1519 XGL_FILL_MODE fillMode;
1520 XGL_CULL_MODE cullMode;
1521 XGL_FACE_ORIENTATION frontFace;
1522 XGL_INT depthBias;
1523 XGL_FLOAT depthBiasClamp;
1524 XGL_FLOAT slopeScaledDepthBias;
1525} XGL_RASTER_STATE_CREATE_INFO;
1526
1527typedef struct _XGL_MSAA_STATE_CREATE_INFO
1528{
1529 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO
1530 const XGL_VOID* pNext; // Pointer to next structure
1531 XGL_UINT samples;
1532 XGL_SAMPLE_MASK sampleMask;
1533} XGL_MSAA_STATE_CREATE_INFO;
1534
1535typedef struct _XGL_COLOR_ATTACHMENT_BLEND_STATE
1536{
1537 XGL_BOOL blendEnable;
1538 XGL_BLEND srcBlendColor;
1539 XGL_BLEND destBlendColor;
1540 XGL_BLEND_FUNC blendFuncColor;
1541 XGL_BLEND srcBlendAlpha;
1542 XGL_BLEND destBlendAlpha;
1543 XGL_BLEND_FUNC blendFuncAlpha;
1544} XGL_COLOR_ATTACHMENT_BLEND_STATE;
1545
1546typedef struct _XGL_COLOR_BLEND_STATE_CREATE_INFO
1547{
1548 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO
1549 const XGL_VOID* pNext; // Pointer to next structure
1550 XGL_COLOR_ATTACHMENT_BLEND_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1551 XGL_FLOAT blendConst[4];
1552} XGL_COLOR_BLEND_STATE_CREATE_INFO;
1553
1554typedef struct _XGL_STENCIL_OP_STATE
1555{
1556 XGL_STENCIL_OP stencilFailOp;
1557 XGL_STENCIL_OP stencilPassOp;
1558 XGL_STENCIL_OP stencilDepthFailOp;
1559 XGL_COMPARE_FUNC stencilFunc;
1560 XGL_UINT32 stencilRef;
1561} XGL_STENCIL_OP_STATE;
1562
1563typedef struct _XGL_DEPTH_STENCIL_STATE_CREATE_INFO
1564{
1565 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO
1566 const XGL_VOID* pNext; // Pointer to next structure
1567 XGL_BOOL depthTestEnable;
1568 XGL_BOOL depthWriteEnable;
1569 XGL_COMPARE_FUNC depthFunc;
1570 XGL_BOOL depthBoundsEnable;
1571 XGL_FLOAT minDepth;
1572 XGL_FLOAT maxDepth;
1573 XGL_BOOL stencilTestEnable;
1574 XGL_UINT32 stencilReadMask;
1575 XGL_UINT32 stencilWriteMask;
1576 XGL_STENCIL_OP_STATE front;
1577 XGL_STENCIL_OP_STATE back;
1578} XGL_DEPTH_STENCIL_STATE_CREATE_INFO;
1579
1580typedef struct _XGL_CMD_BUFFER_CREATE_INFO
1581{
1582 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
1583 const XGL_VOID* pNext;
1584 XGL_QUEUE_TYPE queueType;
1585 XGL_FLAGS flags;
1586} XGL_CMD_BUFFER_CREATE_INFO;
1587
1588typedef struct _XGL_MEMORY_REF
1589{
1590 XGL_GPU_MEMORY mem;
1591 XGL_FLAGS flags; // XGL_MEMORY_REF_FLAGS
1592} XGL_MEMORY_REF;
1593
1594typedef struct _XGL_EVENT_CREATE_INFO
1595{
1596 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
1597 const XGL_VOID* pNext; // Pointer to next structure
1598 XGL_FLAGS flags; // Reserved
1599} XGL_EVENT_CREATE_INFO;
1600
1601typedef struct _XGL_FENCE_CREATE_INFO
1602{
1603 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO
1604 const XGL_VOID* pNext; // Pointer to next structure
1605 XGL_FLAGS flags; // Reserved
1606} XGL_FENCE_CREATE_INFO;
1607
1608typedef struct _XGL_QUEUE_SEMAPHORE_CREATE_INFO
1609{
1610 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
1611 const XGL_VOID* pNext; // Pointer to next structure
1612 XGL_UINT initialCount;
1613 XGL_FLAGS flags; // XGL_SEMAPHORE_CREATE_FLAGS
1614} XGL_QUEUE_SEMAPHORE_CREATE_INFO;
1615
1616typedef struct _XGL_QUEUE_SEMAPHORE_OPEN_INFO
1617{
1618 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
1619 const XGL_VOID* pNext; // Pointer to next structure
1620 XGL_QUEUE_SEMAPHORE sharedSemaphore;
1621} XGL_QUEUE_SEMAPHORE_OPEN_INFO;
1622
1623typedef struct _XGL_PIPELINE_STATISTICS_DATA
1624{
1625 XGL_UINT64 fsInvocations; // Fragment shader invocations
1626 XGL_UINT64 cPrimitives; // Clipper primitives
1627 XGL_UINT64 cInvocations; // Clipper invocations
1628 XGL_UINT64 vsInvocations; // Vertex shader invocations
1629 XGL_UINT64 gsInvocations; // Geometry shader invocations
1630 XGL_UINT64 gsPrimitives; // Geometry shader primitives
1631 XGL_UINT64 iaPrimitives; // Input primitives
1632 XGL_UINT64 iaVertices; // Input vertices
1633 XGL_UINT64 tcsInvocations; // Tessellation control shader invocations
1634 XGL_UINT64 tesInvocations; // Tessellation evaluation shader invocations
1635 XGL_UINT64 csInvocations; // Compute shader invocations
1636} XGL_PIPELINE_STATISTICS_DATA;
1637
1638typedef struct _XGL_QUERY_POOL_CREATE_INFO
1639{
1640 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
1641 const XGL_VOID* pNext; // Pointer to next structure
1642 XGL_QUERY_TYPE queryType;
1643 XGL_UINT slots;
1644} XGL_QUERY_POOL_CREATE_INFO;
1645
1646typedef struct _XGL_DRAW_INDIRECT_CMD
1647{
1648 XGL_UINT32 vertexCount;
1649 XGL_UINT32 instanceCount;
1650 XGL_UINT32 firstVertex;
1651 XGL_UINT32 firstInstance;
1652} XGL_DRAW_INDIRECT_CMD;
1653
1654typedef struct _XGL_DRAW_INDEXED_INDIRECT_CMD
1655{
1656 XGL_UINT32 indexCount;
1657 XGL_UINT32 instanceCount;
1658 XGL_UINT32 firstIndex;
1659 XGL_INT32 vertexOffset;
1660 XGL_UINT32 firstInstance;
1661} XGL_DRAW_INDEXED_INDIRECT_CMD;
1662
1663typedef struct _XGL_DISPATCH_INDIRECT_CMD
1664{
1665 XGL_UINT32 x;
1666 XGL_UINT32 y;
1667 XGL_UINT32 z;
1668} XGL_DISPATCH_INDIRECT_CMD;
1669
1670// ------------------------------------------------------------------------------------------------
1671// API functions
1672
1673// GPU initialization
1674
1675XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
1676 const XGL_APPLICATION_INFO* pAppInfo,
1677 const XGL_ALLOC_CALLBACKS* pAllocCb,
1678 XGL_UINT maxGpus,
1679 XGL_UINT* pGpuCount,
1680 XGL_PHYSICAL_GPU* pGpus);
1681
1682XGL_RESULT XGLAPI xglGetGpuInfo(
1683 XGL_PHYSICAL_GPU gpu,
1684 XGL_PHYSICAL_GPU_INFO_TYPE infoType,
1685 XGL_SIZE* pDataSize,
1686 XGL_VOID* pData);
1687
1688// Device functions
1689
1690XGL_RESULT XGLAPI xglCreateDevice(
1691 XGL_PHYSICAL_GPU gpu,
1692 const XGL_DEVICE_CREATE_INFO* pCreateInfo,
1693 XGL_DEVICE* pDevice);
1694
1695XGL_RESULT XGLAPI xglDestroyDevice(
1696 XGL_DEVICE device);
1697
1698// Extension discovery functions
1699
1700XGL_RESULT XGLAPI xglGetExtensionSupport(
1701 XGL_PHYSICAL_GPU gpu,
1702 const XGL_CHAR* pExtName);
1703
1704// Queue functions
1705
1706XGL_RESULT XGLAPI xglGetDeviceQueue(
1707 XGL_DEVICE device,
1708 XGL_QUEUE_TYPE queueType,
1709 XGL_UINT queueIndex,
1710 XGL_QUEUE* pQueue);
1711
1712XGL_RESULT XGLAPI xglQueueSubmit(
1713 XGL_QUEUE queue,
1714 XGL_UINT cmdBufferCount,
1715 const XGL_CMD_BUFFER* pCmdBuffers,
1716 XGL_UINT memRefCount,
1717 const XGL_MEMORY_REF* pMemRefs,
1718 XGL_FENCE fence);
1719
1720XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
1721 XGL_QUEUE queue,
1722 XGL_UINT memRefCount,
1723 const XGL_MEMORY_REF* pMemRefs);
1724
1725XGL_RESULT XGLAPI xglQueueWaitIdle(
1726 XGL_QUEUE queue);
1727
1728XGL_RESULT XGLAPI xglDeviceWaitIdle(
1729 XGL_DEVICE device);
1730
1731// Memory functions
1732
1733XGL_RESULT XGLAPI xglGetMemoryHeapCount(
1734 XGL_DEVICE device,
1735 XGL_UINT* pCount);
1736
1737XGL_RESULT XGLAPI xglGetMemoryHeapInfo(
1738 XGL_DEVICE device,
1739 XGL_UINT heapId,
1740 XGL_MEMORY_HEAP_INFO_TYPE infoType,
1741 XGL_SIZE* pDataSize,
1742 XGL_VOID* pData);
1743
1744XGL_RESULT XGLAPI xglAllocMemory(
1745 XGL_DEVICE device,
1746 const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
1747 XGL_GPU_MEMORY* pMem);
1748
1749XGL_RESULT XGLAPI xglFreeMemory(
1750 XGL_GPU_MEMORY mem);
1751
1752XGL_RESULT XGLAPI xglSetMemoryPriority(
1753 XGL_GPU_MEMORY mem,
1754 XGL_MEMORY_PRIORITY priority);
1755
1756XGL_RESULT XGLAPI xglMapMemory(
1757 XGL_GPU_MEMORY mem,
1758 XGL_FLAGS flags, // Reserved
1759 XGL_VOID** ppData);
1760
1761XGL_RESULT XGLAPI xglUnmapMemory(
1762 XGL_GPU_MEMORY mem);
1763
1764XGL_RESULT XGLAPI xglPinSystemMemory(
1765 XGL_DEVICE device,
1766 const XGL_VOID* pSysMem,
1767 XGL_SIZE memSize,
1768 XGL_GPU_MEMORY* pMem);
1769
1770XGL_RESULT XGLAPI xglRemapVirtualMemoryPages(
1771 XGL_DEVICE device,
1772 XGL_UINT rangeCount,
1773 const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
1774 XGL_UINT preWaitSemaphoreCount,
1775 const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
1776 XGL_UINT postSignalSemaphoreCount,
1777 const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
1778
1779// Multi-device functions
1780
1781XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
1782 XGL_PHYSICAL_GPU gpu0,
1783 XGL_PHYSICAL_GPU gpu1,
1784 XGL_GPU_COMPATIBILITY_INFO* pInfo);
1785
1786XGL_RESULT XGLAPI xglOpenSharedMemory(
1787 XGL_DEVICE device,
1788 const XGL_MEMORY_OPEN_INFO* pOpenInfo,
1789 XGL_GPU_MEMORY* pMem);
1790
1791XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
1792 XGL_DEVICE device,
1793 const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
1794 XGL_QUEUE_SEMAPHORE* pSemaphore);
1795
1796XGL_RESULT XGLAPI xglOpenPeerMemory(
1797 XGL_DEVICE device,
1798 const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
1799 XGL_GPU_MEMORY* pMem);
1800
1801XGL_RESULT XGLAPI xglOpenPeerImage(
1802 XGL_DEVICE device,
1803 const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
1804 XGL_IMAGE* pImage,
1805 XGL_GPU_MEMORY* pMem);
1806
1807// Generic API object functions
1808
1809XGL_RESULT XGLAPI xglDestroyObject(
1810 XGL_OBJECT object);
1811
1812XGL_RESULT XGLAPI xglGetObjectInfo(
1813 XGL_BASE_OBJECT object,
1814 XGL_OBJECT_INFO_TYPE infoType,
1815 XGL_SIZE* pDataSize,
1816 XGL_VOID* pData);
1817
1818XGL_RESULT XGLAPI xglBindObjectMemory(
1819 XGL_OBJECT object,
1820 XGL_GPU_MEMORY mem,
1821 XGL_GPU_SIZE offset);
1822
1823// Fence functions
1824
1825XGL_RESULT XGLAPI xglCreateFence(
1826 XGL_DEVICE device,
1827 const XGL_FENCE_CREATE_INFO* pCreateInfo,
1828 XGL_FENCE* pFence);
1829
1830XGL_RESULT XGLAPI xglGetFenceStatus(
1831 XGL_FENCE fence);
1832
1833XGL_RESULT XGLAPI xglWaitForFences(
1834 XGL_DEVICE device,
1835 XGL_UINT fenceCount,
1836 const XGL_FENCE* pFences,
1837 XGL_BOOL waitAll,
1838 XGL_UINT64 timeout);
1839
1840// Queue semaphore functions
1841
1842XGL_RESULT XGLAPI xglCreateQueueSemaphore(
1843 XGL_DEVICE device,
1844 const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
1845 XGL_QUEUE_SEMAPHORE* pSemaphore);
1846
1847XGL_RESULT XGLAPI xglSignalQueueSemaphore(
1848 XGL_QUEUE queue,
1849 XGL_QUEUE_SEMAPHORE semaphore);
1850
1851XGL_RESULT XGLAPI xglWaitQueueSemaphore(
1852 XGL_QUEUE queue,
1853 XGL_QUEUE_SEMAPHORE semaphore);
1854
1855// Event functions
1856
1857XGL_RESULT XGLAPI xglCreateEvent(
1858 XGL_DEVICE device,
1859 const XGL_EVENT_CREATE_INFO* pCreateInfo,
1860 XGL_EVENT* pEvent);
1861
1862XGL_RESULT XGLAPI xglGetEventStatus(
1863 XGL_EVENT event);
1864
1865XGL_RESULT XGLAPI xglSetEvent(
1866 XGL_EVENT event);
1867
1868XGL_RESULT XGLAPI xglResetEvent(
1869 XGL_EVENT event);
1870
1871// Query functions
1872
1873XGL_RESULT XGLAPI xglCreateQueryPool(
1874 XGL_DEVICE device,
1875 const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
1876 XGL_QUERY_POOL* pQueryPool);
1877
1878XGL_RESULT XGLAPI xglGetQueryPoolResults(
1879 XGL_QUERY_POOL queryPool,
1880 XGL_UINT startQuery,
1881 XGL_UINT queryCount,
1882 XGL_SIZE* pDataSize,
1883 XGL_VOID* pData);
1884
1885// Format capabilities
1886
1887XGL_RESULT XGLAPI xglGetFormatInfo(
1888 XGL_DEVICE device,
1889 XGL_FORMAT format,
1890 XGL_FORMAT_INFO_TYPE infoType,
1891 XGL_SIZE* pDataSize,
1892 XGL_VOID* pData);
1893
1894// Image functions
1895
1896XGL_RESULT XGLAPI xglCreateImage(
1897 XGL_DEVICE device,
1898 const XGL_IMAGE_CREATE_INFO* pCreateInfo,
1899 XGL_IMAGE* pImage);
1900
1901XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
1902 XGL_IMAGE image,
1903 const XGL_IMAGE_SUBRESOURCE* pSubresource,
1904 XGL_SUBRESOURCE_INFO_TYPE infoType,
1905 XGL_SIZE* pDataSize,
1906 XGL_VOID* pData);
1907
1908// Image view functions
1909
1910XGL_RESULT XGLAPI xglCreateImageView(
1911 XGL_DEVICE device,
1912 const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
1913 XGL_IMAGE_VIEW* pView);
1914
1915XGL_RESULT XGLAPI xglCreateColorAttachmentView(
1916 XGL_DEVICE device,
1917 const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
1918 XGL_COLOR_ATTACHMENT_VIEW* pView);
1919
1920XGL_RESULT XGLAPI xglCreateDepthStencilView(
1921 XGL_DEVICE device,
1922 const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
1923 XGL_DEPTH_STENCIL_VIEW* pView);
1924
1925// Shader functions
1926
1927XGL_RESULT XGLAPI xglCreateShader(
1928 XGL_DEVICE device,
1929 const XGL_SHADER_CREATE_INFO* pCreateInfo,
1930 XGL_SHADER* pShader);
1931
1932// Pipeline functions
1933
1934XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
1935 XGL_DEVICE device,
1936 const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
1937 XGL_PIPELINE* pPipeline);
1938
1939XGL_RESULT XGLAPI xglCreateComputePipeline(
1940 XGL_DEVICE device,
1941 const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
1942 XGL_PIPELINE* pPipeline);
1943
1944XGL_RESULT XGLAPI xglStorePipeline(
1945 XGL_PIPELINE pipeline,
1946 XGL_SIZE* pDataSize,
1947 XGL_VOID* pData);
1948
1949XGL_RESULT XGLAPI xglLoadPipeline(
1950 XGL_DEVICE device,
1951 XGL_SIZE dataSize,
1952 const XGL_VOID* pData,
1953 XGL_PIPELINE* pPipeline);
1954
1955XGL_RESULT XGLAPI xglCreatePipelineDelta(
1956 XGL_DEVICE device,
1957 XGL_PIPELINE p1,
1958 XGL_PIPELINE p2,
1959 XGL_PIPELINE_DELTA* delta);
1960
1961// Sampler functions
1962
1963XGL_RESULT XGLAPI xglCreateSampler(
1964 XGL_DEVICE device,
1965 const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
1966 XGL_SAMPLER* pSampler);
1967
1968// Descriptor set functions
1969
1970XGL_RESULT XGLAPI xglCreateDescriptorSet(
1971 XGL_DEVICE device,
1972 const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
1973 XGL_DESCRIPTOR_SET* pDescriptorSet);
1974
1975XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(
1976 XGL_DESCRIPTOR_SET descriptorSet);
1977
1978XGL_VOID XGLAPI xglEndDescriptorSetUpdate(
1979 XGL_DESCRIPTOR_SET descriptorSet);
1980
1981XGL_VOID XGLAPI xglAttachSamplerDescriptors(
1982 XGL_DESCRIPTOR_SET descriptorSet,
1983 XGL_UINT startSlot,
1984 XGL_UINT slotCount,
1985 const XGL_SAMPLER* pSamplers);
1986
1987XGL_VOID XGLAPI xglAttachImageViewDescriptors(
1988 XGL_DESCRIPTOR_SET descriptorSet,
1989 XGL_UINT startSlot,
1990 XGL_UINT slotCount,
1991 const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
1992
1993XGL_VOID XGLAPI xglAttachMemoryViewDescriptors(
1994 XGL_DESCRIPTOR_SET descriptorSet,
1995 XGL_UINT startSlot,
1996 XGL_UINT slotCount,
1997 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
1998
1999XGL_VOID XGLAPI xglAttachNestedDescriptors(
2000 XGL_DESCRIPTOR_SET descriptorSet,
2001 XGL_UINT startSlot,
2002 XGL_UINT slotCount,
2003 const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
2004
2005XGL_VOID XGLAPI xglClearDescriptorSetSlots(
2006 XGL_DESCRIPTOR_SET descriptorSet,
2007 XGL_UINT startSlot,
2008 XGL_UINT slotCount);
2009
2010// State object functions
2011
2012XGL_RESULT XGLAPI xglCreateViewportState(
2013 XGL_DEVICE device,
2014 const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
2015 XGL_VIEWPORT_STATE_OBJECT* pState);
2016
2017XGL_RESULT XGLAPI xglCreateRasterState(
2018 XGL_DEVICE device,
2019 const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
2020 XGL_RASTER_STATE_OBJECT* pState);
2021
2022XGL_RESULT XGLAPI xglCreateMsaaState(
2023 XGL_DEVICE device,
2024 const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
2025 XGL_MSAA_STATE_OBJECT* pState);
2026
2027XGL_RESULT XGLAPI xglCreateColorBlendState(
2028 XGL_DEVICE device,
2029 const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
2030 XGL_COLOR_BLEND_STATE_OBJECT* pState);
2031
2032XGL_RESULT XGLAPI xglCreateDepthStencilState(
2033 XGL_DEVICE device,
2034 const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
2035 XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
2036
2037// Command buffer functions
2038
2039XGL_RESULT XGLAPI xglCreateCommandBuffer(
2040 XGL_DEVICE device,
2041 const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
2042 XGL_CMD_BUFFER* pCmdBuffer);
2043
2044XGL_RESULT XGLAPI xglBeginCommandBuffer(
2045 XGL_CMD_BUFFER cmdBuffer,
2046 XGL_FLAGS flags); // XGL_CMD_BUFFER_BUILD_FLAGS
2047
2048XGL_RESULT XGLAPI xglEndCommandBuffer(
2049 XGL_CMD_BUFFER cmdBuffer);
2050
2051XGL_RESULT XGLAPI xglResetCommandBuffer(
2052 XGL_CMD_BUFFER cmdBuffer);
2053
2054// Command buffer building functions
2055
2056XGL_VOID XGLAPI xglCmdBindPipeline(
2057 XGL_CMD_BUFFER cmdBuffer,
2058 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2059 XGL_PIPELINE pipeline);
2060
2061XGL_VOID XGLAPI xglCmdBindPipelineDelta(
2062 XGL_CMD_BUFFER cmdBuffer,
2063 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2064 XGL_PIPELINE_DELTA delta);
2065
2066XGL_VOID XGLAPI xglCmdBindStateObject(
2067 XGL_CMD_BUFFER cmdBuffer,
2068 XGL_STATE_BIND_POINT stateBindPoint,
2069 XGL_STATE_OBJECT state);
2070
2071XGL_VOID XGLAPI xglCmdBindDescriptorSet(
2072 XGL_CMD_BUFFER cmdBuffer,
2073 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2074 XGL_UINT index,
2075 XGL_DESCRIPTOR_SET descriptorSet,
2076 XGL_UINT slotOffset);
2077
2078XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(
2079 XGL_CMD_BUFFER cmdBuffer,
2080 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2081 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
2082
2083XGL_VOID XGLAPI xglCmdBindIndexData(
2084 XGL_CMD_BUFFER cmdBuffer,
2085 XGL_GPU_MEMORY mem,
2086 XGL_GPU_SIZE offset,
2087 XGL_INDEX_TYPE indexType);
2088
2089XGL_VOID XGLAPI xglCmdBindAttachments(
2090 XGL_CMD_BUFFER cmdBuffer,
2091 XGL_UINT colorAttachmentCount,
2092 const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments,
2093 const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment);
2094
2095XGL_VOID XGLAPI xglCmdPrepareMemoryRegions(
2096 XGL_CMD_BUFFER cmdBuffer,
2097 XGL_UINT transitionCount,
2098 const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
2099
2100XGL_VOID XGLAPI xglCmdPrepareImages(
2101 XGL_CMD_BUFFER cmdBuffer,
2102 XGL_UINT transitionCount,
2103 const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
2104
2105XGL_VOID XGLAPI xglCmdDraw(
2106 XGL_CMD_BUFFER cmdBuffer,
2107 XGL_UINT firstVertex,
2108 XGL_UINT vertexCount,
2109 XGL_UINT firstInstance,
2110 XGL_UINT instanceCount);
2111
2112XGL_VOID XGLAPI xglCmdDrawIndexed(
2113 XGL_CMD_BUFFER cmdBuffer,
2114 XGL_UINT firstIndex,
2115 XGL_UINT indexCount,
2116 XGL_INT vertexOffset,
2117 XGL_UINT firstInstance,
2118 XGL_UINT instanceCount);
2119
2120XGL_VOID XGLAPI xglCmdDrawIndirect(
2121 XGL_CMD_BUFFER cmdBuffer,
2122 XGL_GPU_MEMORY mem,
2123 XGL_GPU_SIZE offset,
2124 XGL_UINT32 count,
2125 XGL_UINT32 stride);
2126
2127XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(
2128 XGL_CMD_BUFFER cmdBuffer,
2129 XGL_GPU_MEMORY mem,
2130 XGL_GPU_SIZE offset,
2131 XGL_UINT32 count,
2132 XGL_UINT32 stride);
2133
2134XGL_VOID XGLAPI xglCmdDispatch(
2135 XGL_CMD_BUFFER cmdBuffer,
2136 XGL_UINT x,
2137 XGL_UINT y,
2138 XGL_UINT z);
2139
2140XGL_VOID XGLAPI xglCmdDispatchIndirect(
2141 XGL_CMD_BUFFER cmdBuffer,
2142 XGL_GPU_MEMORY mem,
2143 XGL_GPU_SIZE offset);
2144
2145XGL_VOID XGLAPI xglCmdCopyMemory(
2146 XGL_CMD_BUFFER cmdBuffer,
2147 XGL_GPU_MEMORY srcMem,
2148 XGL_GPU_MEMORY destMem,
2149 XGL_UINT regionCount,
2150 const XGL_MEMORY_COPY* pRegions);
2151
2152XGL_VOID XGLAPI xglCmdCopyImage(
2153 XGL_CMD_BUFFER cmdBuffer,
2154 XGL_IMAGE srcImage,
2155 XGL_IMAGE destImage,
2156 XGL_UINT regionCount,
2157 const XGL_IMAGE_COPY* pRegions);
2158
2159XGL_VOID XGLAPI xglCmdCopyMemoryToImage(
2160 XGL_CMD_BUFFER cmdBuffer,
2161 XGL_GPU_MEMORY srcMem,
2162 XGL_IMAGE destImage,
2163 XGL_UINT regionCount,
2164 const XGL_MEMORY_IMAGE_COPY* pRegions);
2165
2166XGL_VOID XGLAPI xglCmdCopyImageToMemory(
2167 XGL_CMD_BUFFER cmdBuffer,
2168 XGL_IMAGE srcImage,
2169 XGL_GPU_MEMORY destMem,
2170 XGL_UINT regionCount,
2171 const XGL_MEMORY_IMAGE_COPY* pRegions);
2172
2173XGL_VOID XGLAPI xglCmdCloneImageData(
2174 XGL_CMD_BUFFER cmdBuffer,
2175 XGL_IMAGE srcImage,
2176 XGL_IMAGE_STATE srcImageState,
2177 XGL_IMAGE destImage,
2178 XGL_IMAGE_STATE destImageState);
2179
2180XGL_VOID XGLAPI xglCmdUpdateMemory(
2181 XGL_CMD_BUFFER cmdBuffer,
2182 XGL_GPU_MEMORY destMem,
2183 XGL_GPU_SIZE destOffset,
2184 XGL_GPU_SIZE dataSize,
2185 const XGL_UINT32* pData);
2186
2187XGL_VOID XGLAPI xglCmdFillMemory(
2188 XGL_CMD_BUFFER cmdBuffer,
2189 XGL_GPU_MEMORY destMem,
2190 XGL_GPU_SIZE destOffset,
2191 XGL_GPU_SIZE fillSize,
2192 XGL_UINT32 data);
2193
2194XGL_VOID XGLAPI xglCmdClearColorImage(
2195 XGL_CMD_BUFFER cmdBuffer,
2196 XGL_IMAGE image,
2197 const XGL_FLOAT color[4],
2198 XGL_UINT rangeCount,
2199 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2200
2201XGL_VOID XGLAPI xglCmdClearColorImageRaw(
2202 XGL_CMD_BUFFER cmdBuffer,
2203 XGL_IMAGE image,
2204 const XGL_UINT32 color[4],
2205 XGL_UINT rangeCount,
2206 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2207
2208XGL_VOID XGLAPI xglCmdClearDepthStencil(
2209 XGL_CMD_BUFFER cmdBuffer,
2210 XGL_IMAGE image,
2211 XGL_FLOAT depth,
2212 XGL_UINT32 stencil,
2213 XGL_UINT rangeCount,
2214 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2215
2216XGL_VOID XGLAPI xglCmdResolveImage(
2217 XGL_CMD_BUFFER cmdBuffer,
2218 XGL_IMAGE srcImage,
2219 XGL_IMAGE destImage,
2220 XGL_UINT rectCount,
2221 const XGL_IMAGE_RESOLVE* pRects);
2222
2223XGL_VOID XGLAPI xglCmdSetEvent(
2224 XGL_CMD_BUFFER cmdBuffer,
2225 XGL_EVENT event);
2226
2227XGL_VOID XGLAPI xglCmdResetEvent(
2228 XGL_CMD_BUFFER cmdBuffer,
2229 XGL_EVENT event);
2230
2231XGL_VOID XGLAPI xglCmdMemoryAtomic(
2232 XGL_CMD_BUFFER cmdBuffer,
2233 XGL_GPU_MEMORY destMem,
2234 XGL_GPU_SIZE destOffset,
2235 XGL_UINT64 srcData,
2236 XGL_ATOMIC_OP atomicOp);
2237
2238XGL_VOID XGLAPI xglCmdBeginQuery(
2239 XGL_CMD_BUFFER cmdBuffer,
2240 XGL_QUERY_POOL queryPool,
2241 XGL_UINT slot,
2242 XGL_FLAGS flags);
2243
2244XGL_VOID XGLAPI xglCmdEndQuery(
2245 XGL_CMD_BUFFER cmdBuffer,
2246 XGL_QUERY_POOL queryPool,
2247 XGL_UINT slot);
2248
2249XGL_VOID XGLAPI xglCmdResetQueryPool(
2250 XGL_CMD_BUFFER cmdBuffer,
2251 XGL_QUERY_POOL queryPool,
2252 XGL_UINT startQuery,
2253 XGL_UINT queryCount);
2254
2255XGL_VOID XGLAPI xglCmdWriteTimestamp(
2256 XGL_CMD_BUFFER cmdBuffer,
2257 XGL_TIMESTAMP_TYPE timestampType,
2258 XGL_GPU_MEMORY destMem,
2259 XGL_GPU_SIZE destOffset);
2260
2261XGL_VOID XGLAPI xglCmdInitAtomicCounters(
2262 XGL_CMD_BUFFER cmdBuffer,
2263 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2264 XGL_UINT startCounter,
2265 XGL_UINT counterCount,
2266 const XGL_UINT32* pData);
2267
2268XGL_VOID XGLAPI xglCmdLoadAtomicCounters(
2269 XGL_CMD_BUFFER cmdBuffer,
2270 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2271 XGL_UINT startCounter,
2272 XGL_UINT counterCount,
2273 XGL_GPU_MEMORY srcMem,
2274 XGL_GPU_SIZE srcOffset);
2275
2276XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
2277 XGL_CMD_BUFFER cmdBuffer,
2278 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2279 XGL_UINT startCounter,
2280 XGL_UINT counterCount,
2281 XGL_GPU_MEMORY destMem,
2282 XGL_GPU_SIZE destOffset);
2283
2284#ifdef __cplusplus
2285} // extern "C"
2286#endif // __cplusplus
2287
2288#endif // __XGL_H__
2289
2290/******************************************************************************************
2291
2292 Open Issues + Missing Features
2293 ------------------------------
2294
2295 Here are a few higher level issues that we'd like to fix given time. A feature missing
2296 from this header (or the following list) isn't necessarily an indication that we want
2297 to drop that feature. Only that we either haven't thought of it or haven't had time
2298 to add it yet.
2299
2300 1) Transform Feedback (XFB)
2301
2302 OpenGL supports transform feedback (XFB). That is not included in this header, but
2303 we feel there is likely value in including it.
2304
2305 To incorporate trasnform feedback, we could create a new pipeline stage. This would
2306 be injected into a PSO by including the following in the chain:
2307
2308 typedef struct _XGL_XFB_CREATE_INFO
2309 {
2310 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
2311 const XGL_VOID* pNext; // Pointer to next structure
2312 // More XFB state, if any goes here
2313 } XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
2314
2315 We expect that only the shader-side configuration (via layout qualifiers or their IR
2316 equivalent) is used to configure the data written to each stream. When transform
2317 feedback is part of the pipeline, transform feedback binding would be available
2318 through a new API bind point:
2319
2320 xglCmdBindTransformFeedbackMemoryView(
2321 XGL_CMD_BUFFER cmdBuffer,
2322 XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
2323 XGL_UINT index,
2324 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
2325
2326 2) Framebuffer Objects
2327
2328 The XGL API here doesn't have a direct equivalent for a framebuffer object. In GL,
2329 the framebuffer object owns attachments, and the indirection table for glDrawBuffers, etc.
2330 The indirection is gone - only identity is supported here.
2331
2332 We may introduce an analog to the framebuffer object that packages all color
2333 attachments. You would create a framebuffer thus:
2334
2335 typedef struct _XGL_FRAMEBUFFER_CREATE_INFO
2336 {
2337 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
2338 const XGL_VOID* pNext; // Pointer to next structure
2339 XGL_UINT32 colorAttachmentCount;
2340 XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments;
2341 XGL_DEPTH_STENCIL_BIND_INFO pDepthStencilAttachment;
2342 } XGL_FRAMEBUFFER_CREATE_INFO;
2343
2344 xglCreateFramebuffer(
2345 XGL_DEVICE device,
2346 const XGL_FRAMEBUFFER_CREATE_INFO* pInfo,
2347 XGL_FRAMEBUFFER* pFramebuffer);
2348
2349 We then replace the xglCmdBindAttachments API with:
2350
2351 xglBindFramebuffer(
2352 XGL_CMD_BUFFER cmdBuffer,
2353 XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
2354 XGL_FRAMEBUFFER framebuffer);
2355
2356 3) "Bindless" + support for non-bindless hardware.
2357
2358 XGL doesn't have bindless textures the way that GL does. It has resource descriptor
2359 sets, or resource tables. Resource tables can be nested and hold references to more
2360 resource tables. They are explicitly sized by the application and have no artificial
2361 upper size limit. An application can still attach as many textures as they want to
2362 a resource descriptor set, and can modify the set asynchronously to GPU work.
2363 Therefore, we can still have "unlimited textures". An application hoping to use
2364 bindless can use an index into a large table of textures and achieve the same effect.
2365
2366 For non-bindless hardware, with fixed (but potentially large) register files for
2367 resource bindings, the table approach should still work if a limited size can be
2368 reported somehow.
2369
2370 4) Clean up some remaining Mantle'isms.
2371
2372 Queue types: It's a bit hand wavey. In Mantle, we have a "universal" queue type that
2373 supports compute and graphics and a "compute" queue that only supports compute. Devices
2374 must support at least one universal queue and DMA queues are an extension. I would like
2375 to do the following (and have attempted to do that here, but am only half done):
2376
2377 a) Separate out the queue capabilities (compute, DMA, graphics) and allow support
2378 for any number of queues with any combination of capabilities each.
2379
2380 b) Allow compute-only or even DMA-only (like video capture or SDI) devices to
2381 be supported.
2382
2383 c) Allow new queue types to be supported by extensions without having to allocate
2384 bits in the bitfield until they're promoted to core.
2385
2386 Terminology: There are still some references to "targets" (render targets) and other
2387 terminology that has been changed from Mantle. Need to do a clean-up pass.
2388
2389 4) The window system interface is an extension in Mantle. We have not tried to fold
2390 any of it into core here. There is no mention of SwapBuffers, presentation, default
2391 framebuffers or anything like that. In the extension, presentation is queued up into
2392 the graphics queue just like any other command.
2393
2394*******************************************************************************************/