Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 6a92126fcc5a80e218288937d151442f288e2947 / . / include / xgl.h
blob: 7fb33cc7c2afb062ce399718bb6837dcc433f320 [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,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame^]289// IMG CHANGE BEGIN - support for vertex input description
290 XGL_SLOT_VERTEX_INPUT = 0x00000004,
291 XGL_SLOT_NEXT_DESCRIPTOR_SET = 0x00000005,
292// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]293
294 XGL_DESCRIPTOR_SET_SLOT_TYPE_BEGIN_RANGE = XGL_SLOT_UNUSED,
295 XGL_DESCRIPTOR_SET_SLOT_TYPE_END_RANGE = XGL_SLOT_NEXT_DESCRIPTOR_SET,
296 XGL_NUM_DESCRIPTOR_SET_SLOT_TYPE = (XGL_DESCRIPTOR_SET_SLOT_TYPE_END_RANGE - XGL_DESCRIPTOR_SET_SLOT_TYPE_BEGIN_RANGE + 1),
297 XGL_MAX_ENUM(_XGL_DESCRIPTOR_SET_SLOT_TYPE)
298} XGL_DESCRIPTOR_SET_SLOT_TYPE;
299
300typedef enum _XGL_QUERY_TYPE
301{
302 XGL_QUERY_OCCLUSION = 0x00000000,
303 XGL_QUERY_PIPELINE_STATISTICS = 0x00000001,
304
305 XGL_QUERY_TYPE_BEGIN_RANGE = XGL_QUERY_OCCLUSION,
306 XGL_QUERY_TYPE_END_RANGE = XGL_QUERY_PIPELINE_STATISTICS,
307 XGL_NUM_QUERY_TYPE = (XGL_QUERY_TYPE_END_RANGE - XGL_QUERY_TYPE_BEGIN_RANGE + 1),
308 XGL_MAX_ENUM(_XGL_QUERY_TYPE)
309} XGL_QUERY_TYPE;
310
311typedef enum _XGL_TIMESTAMP_TYPE
312{
313 XGL_TIMESTAMP_TOP = 0x00000000,
314 XGL_TIMESTAMP_BOTTOM = 0x00000001,
315
316 XGL_TIMESTAMP_TYPE_BEGIN_RANGE = XGL_TIMESTAMP_TOP,
317 XGL_TIMESTAMP_TYPE_END_RANGE = XGL_TIMESTAMP_BOTTOM,
318 XGL_NUM_TIMESTAMP_TYPE = (XGL_TIMESTAMP_TYPE_END_RANGE - XGL_TIMESTAMP_TYPE_BEGIN_RANGE + 1),
319 XGL_MAX_ENUM(_XGL_TIMESTEAMP_TYPE)
320} XGL_TIMESTAMP_TYPE;
321
322typedef enum _XGL_BORDER_COLOR_TYPE
323{
324 XGL_BORDER_COLOR_OPAQUE_WHITE = 0x00000000,
325 XGL_BORDER_COLOR_TRANSPARENT_BLACK = 0x00000001,
326 XGL_BORDER_COLOR_OPAQUE_BLACK = 0x00000002,
327
328 XGL_BORDER_COLOR_TYPE_BEGIN_RANGE = XGL_BORDER_COLOR_OPAQUE_WHITE,
329 XGL_BORDER_COLOR_TYPE_END_RANGE = XGL_BORDER_COLOR_OPAQUE_BLACK,
330 XGL_NUM_BORDER_COLOR_TYPE = (XGL_BORDER_COLOR_TYPE_END_RANGE - XGL_BORDER_COLOR_TYPE_BEGIN_RANGE + 1),
331 XGL_MAX_ENUM(_XGL_BORDER_COLOR_TYPE)
332} XGL_BORDER_COLOR_TYPE;
333
334typedef enum _XGL_PIPELINE_BIND_POINT
335{
336 XGL_PIPELINE_BIND_POINT_COMPUTE = 0x00000000,
337 XGL_PIPELINE_BIND_POINT_GRAPHICS = 0x00000001,
338
339 XGL_PIPELINE_BIND_POINT_BEGIN_RANGE = XGL_PIPELINE_BIND_POINT_COMPUTE,
340 XGL_PIPELINE_BIND_POINT_END_RANGE = XGL_PIPELINE_BIND_POINT_GRAPHICS,
341 XGL_NUM_PIPELINE_BIND_POINT = (XGL_PIPELINE_BIND_POINT_END_RANGE - XGL_PIPELINE_BIND_POINT_BEGIN_RANGE + 1),
342 XGL_MAX_ENUM(_XGL_PIPELINE_BIND_POINT)
343} XGL_PIPELINE_BIND_POINT;
344
345typedef enum _XGL_STATE_BIND_POINT
346{
347 XGL_STATE_BIND_VIEWPORT = 0x00000000,
348 XGL_STATE_BIND_RASTER = 0x00000001,
349 XGL_STATE_BIND_DEPTH_STENCIL = 0x00000002,
350 XGL_STATE_BIND_COLOR_BLEND = 0x00000003,
351 XGL_STATE_BIND_MSAA = 0x00000004,
352
353 XGL_STATE_BIND_POINT_BEGIN_RANGE = XGL_STATE_BIND_VIEWPORT,
354 XGL_STATE_BIND_POINT_END_RANGE = XGL_STATE_BIND_MSAA,
355 XGL_NUM_STATE_BIND_POINT = (XGL_STATE_BIND_POINT_END_RANGE - XGL_STATE_BIND_POINT_BEGIN_RANGE + 1),
356 XGL_MAX_ENUM(_XGL_STATE_BIND_POINT)
357} XGL_STATE_BIND_POINT;
358
359typedef enum _XGL_PRIMITIVE_TOPOLOGY
360{
361 XGL_TOPOLOGY_POINT_LIST = 0x00000000,
362 XGL_TOPOLOGY_LINE_LIST = 0x00000001,
363 XGL_TOPOLOGY_LINE_STRIP = 0x00000002,
364 XGL_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
365 XGL_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
366 XGL_TOPOLOGY_RECT_LIST = 0x00000005,
367 XGL_TOPOLOGY_QUAD_LIST = 0x00000006,
368 XGL_TOPOLOGY_QUAD_STRIP = 0x00000007,
369 XGL_TOPOLOGY_LINE_LIST_ADJ = 0x00000008,
370 XGL_TOPOLOGY_LINE_STRIP_ADJ = 0x00000009,
371 XGL_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x0000000a,
372 XGL_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x0000000b,
373 XGL_TOPOLOGY_PATCH = 0x0000000c,
374
375 XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = XGL_TOPOLOGY_POINT_LIST,
376 XGL_PRIMITIVE_TOPOLOGY_END_RANGE = XGL_TOPOLOGY_PATCH,
377 XGL_NUM_PRIMITIVE_TOPOLOGY = (XGL_PRIMITIVE_TOPOLOGY_END_RANGE - XGL_PRIMITIVE_TOPOLOGY_BEGIN_RANGE + 1),
378 XGL_MAX_ENUM(_XGL_PRIMITIVE_TOPOLOGY)
379} XGL_PRIMITIVE_TOPOLOGY;
380
381typedef enum _XGL_INDEX_TYPE
382{
383 XGL_INDEX_8 = 0x00000000,
384 XGL_INDEX_16 = 0x00000001,
385 XGL_INDEX_32 = 0x00000002,
386
387 XGL_INDEX_TYPE_BEGIN_RANGE = XGL_INDEX_8,
388 XGL_INDEX_TYPE_END_RANGE = XGL_INDEX_32,
389 XGL_NUM_INDEX_TYPE = (XGL_INDEX_TYPE_END_RANGE - XGL_INDEX_TYPE_BEGIN_RANGE + 1),
390 XGL_MAX_ENUM(_XGL_INDEX_TYPE)
391} XGL_INDEX_TYPE;
392
393typedef enum _XGL_TEX_FILTER
394{
395 XGL_TEX_FILTER_NEAREST = 0,
396 XGL_TEX_FILTER_LINEAR = 1,
397 XGL_MAX_ENUM(_XGL_TEX_FILTER)
398} XGL_TEX_FILTER;
399
400typedef enum _XGL_TEX_MIPMAP_MODE
401{
402 XGL_TEX_MIPMAP_BASE = 0, // Always choose base level
403 XGL_TEX_MIPMAP_NEAREST = 1, // Choose nearest mip level
404 XGL_TEX_MIPMAP_LINEAR = 2, // Linear filter between mip levels
405 XGL_MAX_ENUM(_XGL_TEX_MIPMAP_MODE)
406} XGL_TEX_MIPMAP_MODE;
407
408typedef enum _XGL_TEX_ADDRESS
409{
410 XGL_TEX_ADDRESS_WRAP = 0x00000000,
411 XGL_TEX_ADDRESS_MIRROR = 0x00000001,
412 XGL_TEX_ADDRESS_CLAMP = 0x00000002,
413 XGL_TEX_ADDRESS_MIRROR_ONCE = 0x00000003,
414 XGL_TEX_ADDRESS_CLAMP_BORDER = 0x00000004,
415
416 XGL_TEX_ADDRESS_BEGIN_RANGE = XGL_TEX_ADDRESS_WRAP,
417 XGL_TEX_ADDRESS_END_RANGE = XGL_TEX_ADDRESS_CLAMP_BORDER,
418 XGL_NUM_TEX_ADDRESS = (XGL_TEX_ADDRESS_END_RANGE - XGL_TEX_ADDRESS_BEGIN_RANGE + 1),
419 XGL_MAX_ENUM(_XGL_TEX_ADDRESS)
420} XGL_TEX_ADDRESS;
421
422typedef enum _XGL_COMPARE_FUNC
423{
424 XGL_COMPARE_NEVER = 0x00000000,
425 XGL_COMPARE_LESS = 0x00000001,
426 XGL_COMPARE_EQUAL = 0x00000002,
427 XGL_COMPARE_LESS_EQUAL = 0x00000003,
428 XGL_COMPARE_GREATER = 0x00000004,
429 XGL_COMPARE_NOT_EQUAL = 0x00000005,
430 XGL_COMPARE_GREATER_EQUAL = 0x00000006,
431 XGL_COMPARE_ALWAYS = 0x00000007,
432
433 XGL_COMPARE_FUNC_BEGIN_RANGE = XGL_COMPARE_NEVER,
434 XGL_COMPARE_FUNC_END_RANGE = XGL_COMPARE_ALWAYS,
435 XGL_NUM_COMPARE_FUNC = (XGL_COMPARE_FUNC_END_RANGE - XGL_COMPARE_FUNC_BEGIN_RANGE + 1),
436 XGL_MAX_ENUM(_XGL_COMPARE_FUNC)
437} XGL_COMPARE_FUNC;
438
439typedef enum _XGL_FILL_MODE
440{
441 XFL_FILL_POINTS = 0x00000000,
442 XGL_FILL_WIREFRAME = 0x00000001,
443 XGL_FILL_SOLID = 0x00000002,
444
445 XGL_FILL_MODE_BEGIN_RANGE = XGL_FILL_SOLID,
446 XGL_FILL_MODE_END_RANGE = XFL_FILL_POINTS,
447 XGL_NUM_FILL_MODE = (XGL_FILL_MODE_END_RANGE - XGL_FILL_MODE_BEGIN_RANGE + 1),
448 XGL_MAX_ENUM(_XGL_FILL_MODE)
449} XGL_FILL_MODE;
450
451typedef enum _XGL_CULL_MODE
452{
453 XGL_CULL_NONE = 0x00000000,
454 XGL_CULL_FRONT = 0x00000001,
455 XGL_CULL_BACK = 0x00000002,
456 XGL_CULL_FRONT_AND_BACK = 0x00000003,
457
458 XGL_CULL_MODE_BEGIN_RANGE = XGL_CULL_NONE,
459 XGL_CULL_MODE_END_RANGE = XGL_CULL_FRONT_AND_BACK,
460 XGL_NUM_CULL_MODE = (XGL_CULL_MODE_END_RANGE - XGL_CULL_MODE_BEGIN_RANGE + 1),
461 XGL_MAX_ENUM(_XGL_CULL_MODE)
462} XGL_CULL_MODE;
463
464typedef enum _XGL_FACE_ORIENTATION
465{
466 XGL_FRONT_FACE_CCW = 0x00000000,
467 XGL_FRONT_FACE_CW = 0x00000001,
468
469 XGL_FACE_ORIENTATION_BEGIN_RANGE = XGL_FRONT_FACE_CCW,
470 XGL_FACE_ORIENTATION_END_RANGE = XGL_FRONT_FACE_CW,
471 XGL_NUM_FACE_ORIENTATION = (XGL_FACE_ORIENTATION_END_RANGE - XGL_FACE_ORIENTATION_BEGIN_RANGE + 1),
472 XGL_MAX_ENUM(_XGL_FACE_ORIENTATION)
473} XGL_FACE_ORIENTATION;
474
475typedef enum _XGL_BLEND
476{
477 XGL_BLEND_ZERO = 0x00000000,
478 XGL_BLEND_ONE = 0x00000001,
479 XGL_BLEND_SRC_COLOR = 0x00000002,
480 XGL_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
481 XGL_BLEND_DEST_COLOR = 0x00000004,
482 XGL_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
483 XGL_BLEND_SRC_ALPHA = 0x00000006,
484 XGL_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
485 XGL_BLEND_DEST_ALPHA = 0x00000008,
486 XGL_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
487 XGL_BLEND_CONSTANT_COLOR = 0x0000000a,
488 XGL_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
489 XGL_BLEND_CONSTANT_ALPHA = 0x0000000c,
490 XGL_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
491 XGL_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
492 XGL_BLEND_SRC1_COLOR = 0x0000000f,
493 XGL_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
494 XGL_BLEND_SRC1_ALPHA = 0x00000011,
495 XGL_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
496
497 XGL_BLEND_BEGIN_RANGE = XGL_BLEND_ZERO,
498 XGL_BLEND_END_RANGE = XGL_BLEND_ONE_MINUS_SRC1_ALPHA,
499 XGL_NUM_BLEND = (XGL_BLEND_END_RANGE - XGL_BLEND_BEGIN_RANGE + 1),
500 XGL_MAX_ENUM(_XGL_BLEND)
501} XGL_BLEND;
502
503typedef enum _XGL_BLEND_FUNC
504{
505 XGL_BLEND_FUNC_ADD = 0x00000000,
506 XGL_BLEND_FUNC_SUBTRACT = 0x00000001,
507 XGL_BLEND_FUNC_REVERSE_SUBTRACT = 0x00000002,
508 XGL_BLEND_FUNC_MIN = 0x00000003,
509 XGL_BLEND_FUNC_MAX = 0x00000004,
510
511 XGL_BLEND_FUNC_BEGIN_RANGE = XGL_BLEND_FUNC_ADD,
512 XGL_BLEND_FUNC_END_RANGE = XGL_BLEND_FUNC_MAX,
513 XGL_NUM_BLEND_FUNC = (XGL_BLEND_FUNC_END_RANGE - XGL_BLEND_FUNC_BEGIN_RANGE + 1),
514 XGL_MAX_ENUM(_XGL_BLEND_FUNC)
515} XGL_BLEND_FUNC;
516
517typedef enum _XGL_STENCIL_OP
518{
519 XGL_STENCIL_OP_KEEP = 0x00000000,
520 XGL_STENCIL_OP_ZERO = 0x00000001,
521 XGL_STENCIL_OP_REPLACE = 0x00000002,
522 XGL_STENCIL_OP_INC_CLAMP = 0x00000003,
523 XGL_STENCIL_OP_DEC_CLAMP = 0x00000004,
524 XGL_STENCIL_OP_INVERT = 0x00000005,
525 XGL_STENCIL_OP_INC_WRAP = 0x00000006,
526 XGL_STENCIL_OP_DEC_WRAP = 0x00000007,
527
528 XGL_STENCIL_OP_BEGIN_RANGE = XGL_STENCIL_OP_KEEP,
529 XGL_STENCIL_OP_END_RANGE = XGL_STENCIL_OP_DEC_WRAP,
530 XGL_NUM_STENCIL_OP = (XGL_STENCIL_OP_END_RANGE - XGL_STENCIL_OP_BEGIN_RANGE + 1),
531 XGL_MAX_ENUM(_XGL_STENCIL_OP)
532} XGL_STENCIL_OP;
533
534typedef enum _XGL_LOGIC_OP
535{
536 XGL_LOGIC_OP_COPY = 0x00000000,
537 XGL_LOGIC_OP_CLEAR = 0x00000001,
538 XGL_LOGIC_OP_AND = 0x00000002,
539 XGL_LOGIC_OP_AND_REVERSE = 0x00000003,
540 XGL_LOGIC_OP_AND_INVERTED = 0x00000004,
541 XGL_LOGIC_OP_NOOP = 0x00000005,
542 XGL_LOGIC_OP_XOR = 0x00000006,
543 XGL_LOGIC_OP_OR = 0x00000007,
544 XGL_LOGIC_OP_NOR = 0x00000008,
545 XGL_LOGIC_OP_EQUIV = 0x00000009,
546 XGL_LOGIC_OP_INVERT = 0x0000000a,
547 XGL_LOGIC_OP_OR_REVERSE = 0x0000000b,
548 XGL_LOGIC_OP_COPY_INVERTED = 0x0000000c,
549 XGL_LOGIC_OP_OR_INVERTED = 0x0000000d,
550 XGL_LOGIC_OP_NAND = 0x0000000e,
551 XGL_LOGIC_OP_SET = 0x0000000f,
552
553 XGL_LOGIC_OP_BEGIN_RANGE = XGL_LOGIC_OP_COPY,
554 XGL_LOGIC_OP_END_RANGE = XGL_LOGIC_OP_SET,
555 XGL_NUM_LOGIC_OP = (XGL_LOGIC_OP_END_RANGE - XGL_LOGIC_OP_BEGIN_RANGE + 1),
556 XGL_MAX_ENUM(_XGL_LOGIC_OP)
557} XGL_LOGIC_OP;
558
559typedef enum _XGL_ATOMIC_OP
560{
561 XGL_ATOMIC_ADD_INT32 = 0x00000000,
562 XGL_ATOMIC_SUB_INT32 = 0x00000001,
563 XGL_ATOMIC_MIN_UINT32 = 0x00000002,
564 XGL_ATOMIC_MAX_UINT32 = 0x00000003,
565 XGL_ATOMIC_MIN_SINT32 = 0x00000004,
566 XGL_ATOMIC_MAX_SINT32 = 0x00000005,
567 XGL_ATOMIC_AND_INT32 = 0x00000006,
568 XGL_ATOMIC_OR_INT32 = 0x00000007,
569 XGL_ATOMIC_XOR_INT32 = 0x00000008,
570 XGL_ATOMIC_INC_UINT32 = 0x00000009,
571 XGL_ATOMIC_DEC_UINT32 = 0x0000000a,
572 XGL_ATOMIC_ADD_INT64 = 0x0000000b,
573 XGL_ATOMIC_SUB_INT64 = 0x0000000c,
574 XGL_ATOMIC_MIN_UINT64 = 0x0000000d,
575 XGL_ATOMIC_MAX_UINT64 = 0x0000000e,
576 XGL_ATOMIC_MIN_SINT64 = 0x0000000f,
577 XGL_ATOMIC_MAX_SINT64 = 0x00000010,
578 XGL_ATOMIC_AND_INT64 = 0x00000011,
579 XGL_ATOMIC_OR_INT64 = 0x00000012,
580 XGL_ATOMIC_XOR_INT64 = 0x00000013,
581 XGL_ATOMIC_INC_UINT64 = 0x00000014,
582 XGL_ATOMIC_DEC_UINT64 = 0x00000015,
583
584 XGL_ATOMIC_OP_BEGIN_RANGE = XGL_ATOMIC_ADD_INT32,
585 XGL_ATOMIC_OP_END_RANGE = XGL_ATOMIC_DEC_UINT64,
586 XGL_NUM_ATOMIC_OP = (XGL_ATOMIC_OP_END_RANGE - XGL_ATOMIC_OP_BEGIN_RANGE + 1),
587 XGL_MAX_ENUM(_XGL_ATOMIC_OP)
588} XGL_ATOMIC_OP;
589
590typedef enum _XGL_SYSTEM_ALLOC_TYPE
591{
592 XGL_SYSTEM_ALLOC_API_OBJECT = 0x00000000,
593 XGL_SYSTEM_ALLOC_INTERNAL = 0x00000001,
594 XGL_SYSTEM_ALLOC_INTERNAL_TEMP = 0x00000002,
595 XGL_SYSTEM_ALLOC_INTERNAL_SHADER = 0x00000003,
596 XGL_SYSTEM_ALLOC_DEBUG = 0x00000004,
597
598 XGL_SYSTEM_ALLOC_BEGIN_RANGE = XGL_SYSTEM_ALLOC_API_OBJECT,
599 XGL_SYSTEM_ALLOC_END_RANGE = XGL_SYSTEM_ALLOC_DEBUG,
600 XGL_NUM_SYSTEM_ALLOC_TYPE = (XGL_SYSTEM_ALLOC_END_RANGE - XGL_SYSTEM_ALLOC_BEGIN_RANGE + 1),
601 XGL_MAX_ENUM(_XGL_SYSTEM_ALLOC_TYPE)
602} XGL_SYSTEM_ALLOC_TYPE;
603
604typedef enum _XGL_HEAP_MEMORY_TYPE
605{
606 XGL_HEAP_MEMORY_OTHER = 0x00000000,
607 XGL_HEAP_MEMORY_LOCAL = 0x00000001,
608 XGL_HEAP_MEMORY_REMOTE = 0x00000002,
609 XGL_HEAP_MEMORY_EMBEDDED = 0x00000003,
610
611 XGL_HEAP_MEMORY_BEGIN_RANGE = XGL_HEAP_MEMORY_OTHER,
612 XGL_HEAP_MEMORY_END_RANGE = XGL_HEAP_MEMORY_EMBEDDED,
613 XGL_NUM_HEAP_MEMORY_TYPE = (XGL_HEAP_MEMORY_END_RANGE - XGL_HEAP_MEMORY_BEGIN_RANGE + 1),
614 XGL_MAX_ENUM(_XGL_HEAP_MEMORY_TYPE)
615} XGL_HEAP_MEMORY_TYPE;
616
617typedef enum _XGL_PHYSICAL_GPU_TYPE
618{
619 XGL_GPU_TYPE_OTHER = 0x00000000,
620 XGL_GPU_TYPE_INTEGRATED = 0x00000001,
621 XGL_GPU_TYPE_DISCRETE = 0x00000002,
622 XGL_GPU_TYPE_VIRTUAL = 0x00000003,
623
624 XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE = XGL_GPU_TYPE_OTHER,
625 XGL_PHYSICAL_GPU_TYPE_END_RANGE = XGL_GPU_TYPE_VIRTUAL,
626 XGL_NUM_PHYSICAL_GPU_TYPE = (XGL_PHYSICAL_GPU_TYPE_END_RANGE - XGL_PHYSICAL_GPU_TYPE_BEGIN_RANGE + 1),
627 XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_TYPE)
628} XGL_PHYSICAL_GPU_TYPE;
629
630typedef enum _XGL_PHYSICAL_GPU_INFO_TYPE
631{
632 // Info type for xglGetGpuInfo()
633 XGL_INFO_TYPE_PHYSICAL_GPU_PROPERTIES = 0x00000000,
634 XGL_INFO_TYPE_PHYSICAL_GPU_PERFORMANCE = 0x00000001,
635 XGL_INFO_TYPE_PHYSICAL_GPU_QUEUE_PROPERTIES = 0x00000002,
636 XGL_INFO_TYPE_PHYSICAL_GPU_MEMORY_PROPERTIES = 0x00000003,
637
638 XGL_MAX_ENUM(_XGL_PHYSICAL_GPU_INFO_TYPE)
639} XGL_PHYSICAL_GPU_INFO_TYPE;
640
641typedef enum _XGL_MEMORY_HEAP_INFO_TYPE
642{
643 // Info type for xglGetMemoryHeapInfo()
644 XGL_INFO_TYPE_MEMORY_HEAP_PROPERTIES = 0x00000000,
645
646 XGL_MAX_ENUM(_XGL_MEMORY_HEAP_INFO_TYPE)
647} XGL_MEMORY_HEAP_INFO_TYPE;
648
649typedef enum _XGL_FORMAT_INFO_TYPE
650{
651 // Info type for xlgGetFormatInfo()
652 XGL_INFO_TYPE_FORMAT_PROPERTIES = 0x00000000,
653
654 XGL_MAX_ENUM(_XGL_FORMAT_INFO_TYPE)
655} XGL_FORMAT_INFO_TYPE;
656
657typedef enum _XGL_SUBRESOURCE_INFO_TYPE
658{
659 // Info type for xglGetImageSubresourceInfo()
660 XGL_INFO_TYPE_SUBRESOURCE_LAYOUT = 0x00000000,
661
662 XGL_MAX_ENUM(_XGL_SUBRESOURCE_INFO_TYPE)
663} XGL_SUBRESOURCE_INFO_TYPE;
664
665typedef enum _XGL_OBJECT_INFO_TYPE
666{
667 // Info type for xglGetObjectInfo()
668 XGL_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000000,
669
670 XGL_MAX_ENUM(_XGL_OBJECT_INFO_TYPE)
671} XGL_OBJECT_INFO_TYPE;
672
673typedef enum _XGL_VALIDATION_LEVEL
674{
675 XGL_VALIDATION_LEVEL_0 = 0x00000000,
676 XGL_VALIDATION_LEVEL_1 = 0x00000001,
677 XGL_VALIDATION_LEVEL_2 = 0x00000002,
678 XGL_VALIDATION_LEVEL_3 = 0x00000003,
679 XGL_VALIDATION_LEVEL_4 = 0x00000004,
680
681 XGL_VALIDATION_LEVEL_BEGIN_RANGE = XGL_VALIDATION_LEVEL_0,
682 XGL_VALIDATION_LEVEL_END_RANGE = XGL_VALIDATION_LEVEL_4,
683 XGL_NUM_VALIDATION_LEVEL = (XGL_VALIDATION_LEVEL_END_RANGE - XGL_VALIDATION_LEVEL_BEGIN_RANGE + 1),
684
685 XGL_MAX_ENUM(_XGL_VALIDATION_LEVEL)
686} XGL_VALIDATION_LEVEL;
687
688// ------------------------------------------------------------------------------------------------
689// Error and return codes
690
691typedef enum _XGL_RESULT_CODE
692{
693 // Return codes for successful operation execution (>= 0)
694 XGL_SUCCESS = 0x0000000,
695 XGL_UNSUPPORTED = 0x0000001,
696 XGL_NOT_READY = 0x0000002,
697 XGL_TIMEOUT = 0x0000003,
698 XGL_EVENT_SET = 0x0000004,
699 XGL_EVENT_RESET = 0x0000005,
700
701 // Error codes (negative values)
702 XGL_ERROR_UNKNOWN = -(0x00000001),
703 XGL_ERROR_UNAVAILABLE = -(0x00000002),
704 XGL_ERROR_INITIALIZATION_FAILED = -(0x00000003),
705 XGL_ERROR_OUT_OF_MEMORY = -(0x00000004),
706 XGL_ERROR_OUT_OF_GPU_MEMORY = -(0x00000005),
707 XGL_ERROR_DEVICE_ALREADY_CREATED = -(0x00000006),
708 XGL_ERROR_DEVICE_LOST = -(0x00000007),
709 XGL_ERROR_INVALID_POINTER = -(0x00000008),
710 XGL_ERROR_INVALID_VALUE = -(0x00000009),
711 XGL_ERROR_INVALID_HANDLE = -(0x0000000A),
712 XGL_ERROR_INVALID_ORDINAL = -(0x0000000B),
713 XGL_ERROR_INVALID_MEMORY_SIZE = -(0x0000000C),
714 XGL_ERROR_INVALID_EXTENSION = -(0x0000000D),
715 XGL_ERROR_INVALID_FLAGS = -(0x0000000E),
716 XGL_ERROR_INVALID_ALIGNMENT = -(0x0000000F),
717 XGL_ERROR_INVALID_FORMAT = -(0x00000010),
718 XGL_ERROR_INVALID_IMAGE = -(0x00000011),
719 XGL_ERROR_INVALID_DESCRIPTOR_SET_DATA = -(0x00000012),
720 XGL_ERROR_INVALID_QUEUE_TYPE = -(0x00000013),
721 XGL_ERROR_INVALID_OBJECT_TYPE = -(0x00000014),
722 XGL_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -(0x00000015),
723 XGL_ERROR_BAD_SHADER_CODE = -(0x00000016),
724 XGL_ERROR_BAD_PIPELINE_DATA = -(0x00000017),
725 XGL_ERROR_TOO_MANY_MEMORY_REFERENCES = -(0x00000018),
726 XGL_ERROR_NOT_MAPPABLE = -(0x00000019),
727 XGL_ERROR_MEMORY_MAP_FAILED = -(0x0000001A),
728 XGL_ERROR_MEMORY_UNMAP_FAILED = -(0x0000001B),
729 XGL_ERROR_INCOMPATIBLE_DEVICE = -(0x0000001C),
730 XGL_ERROR_INCOMPATIBLE_DRIVER = -(0x0000001D),
731 XGL_ERROR_INCOMPLETE_COMMAND_BUFFER = -(0x0000001E),
732 XGL_ERROR_BUILDING_COMMAND_BUFFER = -(0x0000001F),
733 XGL_ERROR_MEMORY_NOT_BOUND = -(0x00000020),
734 XGL_ERROR_INCOMPATIBLE_QUEUE = -(0x00000021),
735 XGL_ERROR_NOT_SHAREABLE = -(0x00000022),
736} XGL_RESULT;
737
738// ------------------------------------------------------------------------------------------------
739// XGL format definitions
740
741typedef enum _XGL_CHANNEL_FORMAT
742{
743 XGL_CH_FMT_UNDEFINED = 0,
744 XGL_CH_FMT_R4G4 = 1,
745 XGL_CH_FMT_R4G4B4A4 = 2,
746 XGL_CH_FMT_R5G6B5 = 3,
747 XGL_CH_FMT_B5G6R5 = 4,
748 XGL_CH_FMT_R5G5B5A1 = 5,
749 XGL_CH_FMT_R8 = 6,
750 XGL_CH_FMT_R8G8 = 7,
751 XGL_CH_FMT_R8G8B8A8 = 8,
752 XGL_CH_FMT_B8G8R8A8 = 9,
753 XGL_CH_FMT_R10G11B11 = 10,
754 XGL_CH_FMT_R11G11B10 = 11,
755 XGL_CH_FMT_R10G10B10A2 = 12,
756 XGL_CH_FMT_R16 = 13,
757 XGL_CH_FMT_R16G16 = 14,
758 XGL_CH_FMT_R16G16B16A16 = 15,
759 XGL_CH_FMT_R32 = 16,
760 XGL_CH_FMT_R32G32 = 17,
761 XGL_CH_FMT_R32G32B32 = 18,
762 XGL_CH_FMT_R32G32B32A32 = 19,
763 XGL_CH_FMT_R16G8 = 20,
764 XGL_CH_FMT_R32G8 = 21,
765 XGL_CH_FMT_R9G9B9E5 = 22,
766 XGL_CH_FMT_BC1 = 23,
767 XGL_CH_FMT_BC2 = 24,
768 XGL_CH_FMT_BC3 = 25,
769 XGL_CH_FMT_BC4 = 26,
770 XGL_CH_FMT_BC5 = 27,
771 XGL_CH_FMT_BC6U = 28,
772 XGL_CH_FMT_BC6S = 29,
773 XGL_CH_FMT_BC7 = 30,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame^]774// IMG CHANGE BEGIN - support for vertex input description
775 XGL_CH_FMT_R8G8B8 = 31,
776 XGL_CH_FMT_R16G16B16 = 32,
777 XGL_MAX_CH_FMT = XGL_CH_FMT_R16G16B16,
778// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]779 XGL_MAX_ENUM(_XGL_CHANNEL_FORMAT)
780} XGL_CHANNEL_FORMAT;
781
782typedef enum _XGL_NUM_FORMAT
783{
784 XGL_NUM_FMT_UNDEFINED = 0,
785 XGL_NUM_FMT_UNORM = 1,
786 XGL_NUM_FMT_SNORM = 2,
787 XGL_NUM_FMT_UINT = 3,
788 XGL_NUM_FMT_SINT = 4,
789 XGL_NUM_FMT_FLOAT = 5,
790 XGL_NUM_FMT_SRGB = 6,
791 XGL_NUM_FMT_DS = 7,
792 XGL_MAX_NUM_FMT = XGL_NUM_FMT_DS,
793 XGL_MAX_ENUM(_XGL_NUM_FORMAT)
794} XGL_NUM_FORMAT;
795
796typedef enum _XGL_PROVOKING_VERTEX_CONVENTION
797{
798 XGL_PROVOKING_VERTEX_FIRST = 0,
799 XGL_PROVOKING_VERTEX_LAST = 1,
800
801 XGL_PROVOKING_VERTEX_BEGIN_RANGE = XGL_PROVOKING_VERTEX_FIRST,
802 XGL_PROVOKING_VERTEX_END_RANGE = XGL_PROVOKING_VERTEX_LAST,
803 XGL_NUM_PROVOKING_VERTEX_CONVENTIONS = (XGL_PROVOKING_VERTEX_END_RANGE - XGL_PROVOKING_VERTEX_BEGIN_RANGE + 1),
804 XGL_MAX_ENUM(_XGL_PROVOKING_VERTEX_CONVENTION)
805} XGL_PROVOKING_VERTEX_CONVENTION;
806
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame^]807// IMG CHANGE BEGIN - support for vertex input description
808typedef enum _XGL_VERTEX_INPUT_STEP_RATE
809{
810 XGL_VERTEX_INPUT_STEP_RATE_VERTEX = 0x0,
811 XGL_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x1,
812 XGL_VERTEX_INPUT_STEP_RATE_DRAW = 0x2,
813 XGL_MAX_ENUM(_XGL_VERTEX_INPUT_STEP_RATE)
814} XGL_VERTEX_INPUT_STEP_RATE;
815// IMG CHANGE END
816
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]817typedef struct _XGL_FORMAT
818{
819 XGL_CHANNEL_FORMAT channelFormat;
820 XGL_NUM_FORMAT numericFormat;
821} XGL_FORMAT;
822
823// Shader stage enumerant
824typedef enum _XGL_PIPELINE_SHADER_STAGE
825{
826 XGL_SHADER_STAGE_VERTEX = 0,
827 XGL_SHADER_STAGE_TESS_CONTROL = 1,
828 XGL_SHADER_STAGE_TESS_EVALUATION = 2,
829 XGL_SHADER_STAGE_GEOMETRY = 3,
830 XGL_SHADER_STAGE_FRAGMENT = 4,
831 XGL_SHADER_STAGE_COMPUTE = 5,
832 XGL_MAX_ENUM(_XGL_PIPELINE_SHADER_STAGE)
833} XGL_PIPELINE_SHADER_STAGE;
834
835// Structure type enumerant
836typedef enum _XGL_STRUCTURE_TYPE
837{
838 XGL_STRUCTURE_TYPE_APPLICATION_INFO = 0,
839 XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 1,
840 XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO = 2,
841 XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO = 4,
842 XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5,
843 XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO = 6,
844 XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7,
845 XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION = 8,
846 XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9,
847 XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10,
848 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11,
849 XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO = 12,
850 XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 13,
851 XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 14,
852 XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO = 15,
853 XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO = 16,
854 XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO = 17,
855 XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO = 18,
856 XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO = 19,
857 XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO = 20,
858 XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO = 21,
859 XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO = 22,
860 XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 23,
861 XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO = 24,
862 XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 25,
863 XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 26,
864 XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 27,
Courtney Goeltzenleuchter7f11ed22014-08-15 14:54:58 -0600[diff] [blame]865 XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO = 28,
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]866 XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO = 29,
867 XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO = 30,
868 XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO = 31,
869 XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO = 32,
870 XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 33,
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame^]871// IMG CHANGE BEGIN - support for vertex input description
872 XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO = 34,
873// IMG CHANGE END
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]874 XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
875} XGL_STRUCTURE_TYPE;
876
877// ------------------------------------------------------------------------------------------------
878// Flags
879
880// Device creation flags
881typedef enum _XGL_DEVICE_CREATE_FLAGS
882{
883 XGL_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
884 XGL_DEVICE_CREATE_MGPU_IQ_MATCH_BIT = 0x00000002,
885} XGL_DEVICE_CREATE_FLAGS;
886
887// Queue capabilities
888typedef enum _XGL_QUEUE_FLAGS
889{
890 XGL_QUEUE_GRAPHICS_BIT = 0x00000001, // Queue supports graphics operations
891 XGL_QUEUE_COMPUTE_BIT = 0x00000002, // Queue supports compute operations
892 XGL_QUEUE_DMA_BIT = 0x00000004, // Queue supports DMA operations
893 XGL_QUEUE_EXTENDED_BIT = 0x80000000 // Extended queue
894} XGL_QUEUE_FLAGS;
895
896// Memory heap properties
897typedef enum _XGL_MEMORY_HEAP_FLAGS
898{
899 XGL_MEMORY_HEAP_CPU_VISIBLE_BIT = 0x00000001,
900 XGL_MEMORY_HEAP_CPU_GPU_COHERENT_BIT = 0x00000002,
901 XGL_MEMORY_HEAP_CPU_UNCACHED_BIT = 0x00000004,
902 XGL_MEMORY_HEAP_CPU_WRITE_COMBINED_BIT = 0x00000008,
903 XGL_MEMORY_HEAP_HOLDS_PINNED_BIT = 0x00000010,
904 XGL_MEMORY_HEAP_SHAREABLE_BIT = 0x00000020,
905} XGL_MEMORY_HEAP_FLAGS;
906
907// Memory allocation flags
908typedef enum _XGL_MEMORY_ALLOC_FLAGS
909{
910 XGL_MEMORY_ALLOC_VIRTUAL_BIT = 0x00000001,
911 XGL_MEMORY_ALLOC_SHAREABLE_BIT = 0x00000002,
912} XGL_MEMORY_ALLOC_FLAGS;
913
914// Image usage flags
915typedef enum _XGL_IMAGE_USAGE_FLAGS
916{
917 XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT = 0x00000001,
918 XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT = 0x00000002,
919 XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000004,
920 XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000008,
921} XGL_IMAGE_USAGE_FLAGS;
922
923// Image flags
924typedef enum _XGL_IMAGE_CREATE_FLAGS
925{
926 XGL_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
927 XGL_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002,
928 XGL_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004,
929} XGL_IMAGE_CREATE_FLAGS;
930
931// Depth-stencil view creation flags
932typedef enum _XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
933{
934 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
935 XGL_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
936} XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS;
937
938// Pipeline creation flags
939typedef enum _XGL_PIPELINE_CREATE_FLAGS
940{
941 XGL_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
942} XGL_PIPELINE_CREATE_FLAGS;
943
944// Semaphore creation flags
945typedef enum _XGL_SEMAPHORE_CREATE_FLAGS
946{
947 XGL_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001,
948} XGL_SEMAPHORE_CREATE_FLAGS;
949
950// Memory reference flags
951typedef enum _XGL_MEMORY_REF_FLAGS
952{
953 XGL_MEMORY_REF_READ_ONLY_BIT = 0x00000001,
954} XGL_MEMORY_REF_FLAGS;
955
956// Format capability flags
957typedef enum _XGL_FORMAT_FEATURE_FLAGS
958{
959 XGL_FORMAT_IMAGE_SHADER_READ_BIT = 0x00000001,
960 XGL_FORMAT_IMAGE_SHADER_WRITE_BIT = 0x00000002,
961 XGL_FORMAT_IMAGE_COPY_BIT = 0x00000004,
962 XGL_FORMAT_MEMORY_SHADER_ACCESS_BIT = 0x00000008,
963 XGL_FORMAT_COLOR_ATTACHMENT_WRITE_BIT = 0x00000010,
964 XGL_FORMAT_COLOR_ATTACHMENT_BLEND_BIT = 0x00000020,
965 XGL_FORMAT_DEPTH_ATTACHMENT_BIT = 0x00000040,
966 XGL_FORMAT_STENCIL_ATTACHMENT_BIT = 0x00000080,
967 XGL_FORMAT_MSAA_ATTACHMENT_BIT = 0x00000100,
968 XGL_FORMAT_CONVERSION_BIT = 0x00000200,
969} XGL_FORMAT_FEATURE_FLAGS;
970
971// Query flags
972typedef enum _XGL_QUERY_CONTROL_FLAGS
973{
974 XGL_QUERY_IMPRECISE_DATA_BIT = 0x00000001,
975} XGL_QUERY_CONTROL_FLAGS;
976
977// GPU compatibility flags
978typedef enum _XGL_GPU_COMPATIBILITY_FLAGS
979{
980 XGL_GPU_COMPAT_ASIC_FEATURES_BIT = 0x00000001,
981 XGL_GPU_COMPAT_IQ_MATCH_BIT = 0x00000002,
982 XGL_GPU_COMPAT_PEER_TRANSFER_BIT = 0x00000004,
983 XGL_GPU_COMPAT_SHARED_MEMORY_BIT = 0x00000008,
984 XGL_GPU_COMPAT_SHARED_SYNC_BIT = 0x00000010,
985 XGL_GPU_COMPAT_SHARED_GPU0_DISPLAY_BIT = 0x00000020,
986 XGL_GPU_COMPAT_SHARED_GPU1_DISPLAY_BIT = 0x00000040,
987} XGL_GPU_COMPATIBILITY_FLAGS;
988
989// Command buffer building flags
990typedef enum _XGL_CMD_BUFFER_BUILD_FLAGS
991{
992 XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT = 0x00000001,
993 XGL_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
994 XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
995 XGL_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
996} XGL_CMD_BUFFER_BUILD_FLAGS;
997
998// ------------------------------------------------------------------------------------------------
999// XGL structures
1000
1001typedef struct _XGL_OFFSET2D
1002{
1003 XGL_INT x;
1004 XGL_INT y;
1005} XGL_OFFSET2D;
1006
1007typedef struct _XGL_OFFSET3D
1008{
1009 XGL_INT x;
1010 XGL_INT y;
1011 XGL_INT z;
1012} XGL_OFFSET3D;
1013
1014typedef struct _XGL_EXTENT2D
1015{
1016 XGL_INT width;
1017 XGL_INT height;
1018} XGL_EXTENT2D;
1019
1020typedef struct _XGL_EXTENT3D
1021{
1022 XGL_INT width;
1023 XGL_INT height;
1024 XGL_INT depth;
1025} XGL_EXTENT3D;
1026
1027typedef struct _XGL_VIEWPORT
1028{
1029 XGL_FLOAT originX;
1030 XGL_FLOAT originY;
1031 XGL_FLOAT width;
1032 XGL_FLOAT height;
1033 XGL_FLOAT minDepth;
1034 XGL_FLOAT maxDepth;
1035} XGL_VIEWPORT;
1036
1037typedef struct _XGL_RECT
1038{
1039 XGL_OFFSET2D offset;
1040 XGL_EXTENT2D extent;
1041} XGL_RECT;
1042
1043typedef struct _XGL_PHYSICAL_GPU_PROPERTIES
1044{
1045 XGL_SIZE structSize;
1046 XGL_UINT32 apiVersion;
1047 XGL_UINT32 driverVersion;
1048 XGL_UINT32 vendorId;
1049 XGL_UINT32 deviceId;
1050 XGL_PHYSICAL_GPU_TYPE gpuType;
1051 XGL_CHAR gpuName[XGL_MAX_PHYSICAL_GPU_NAME];
1052 XGL_UINT maxMemRefsPerSubmission;
1053 XGL_GPU_SIZE virtualMemPageSize;
1054 XGL_GPU_SIZE maxInlineMemoryUpdateSize;
1055 XGL_UINT maxBoundDescriptorSets;
1056 XGL_UINT maxThreadGroupSize;
1057 XGL_UINT64 timestampFrequency;
1058 XGL_BOOL multiColorAttachmentClears;
1059} XGL_PHYSICAL_GPU_PROPERTIES;
1060
1061typedef struct _XGL_PHYSICAL_GPU_PERFORMANCE
1062{
1063 XGL_FLOAT maxGpuClock;
1064 XGL_FLOAT aluPerClock;
1065 XGL_FLOAT texPerClock;
1066 XGL_FLOAT primsPerClock;
1067 XGL_FLOAT pixelsPerClock;
1068} XGL_PHYSICAL_GPU_PERFORMANCE;
1069
1070typedef struct _XGL_GPU_COMPATIBILITY_INFO
1071{
1072 XGL_FLAGS compatibilityFlags; // XGL_GPU_COMPATIBILITY_FLAGS
1073} XGL_GPU_COMPATIBILITY_INFO;
1074
1075typedef struct _XGL_APPLICATION_INFO
1076{
1077 XGL_STRUCTURE_TYPE sType; // Type of structure. Should be XGL_STRUCTURE_TYPE_APPLICATION_INFO
1078 XGL_VOID* pNext; // Next structure in chain
1079 const XGL_CHAR* pAppName;
1080 XGL_UINT32 appVersion;
1081 const XGL_CHAR* pEngineName;
1082 XGL_UINT32 engineVersion;
1083 XGL_UINT32 apiVersion;
1084} XGL_APPLICATION_INFO;
1085
1086typedef XGL_VOID* (XGLAPI *XGL_ALLOC_FUNCTION)(
1087 XGL_VOID* pUserData,
1088 XGL_SIZE size,
1089 XGL_SIZE alignment,
1090 XGL_SYSTEM_ALLOC_TYPE allocType);
1091
1092typedef XGL_VOID (XGLAPI *XGL_FREE_FUNCTION)(
1093 XGL_VOID* pUserData,
1094 XGL_VOID* pMem);
1095
1096typedef struct _XGL_ALLOC_CALLBACKS
1097{
1098 XGL_VOID* pUserData;
1099 XGL_ALLOC_FUNCTION pfnAlloc;
1100 XGL_FREE_FUNCTION pfnFree;
1101} XGL_ALLOC_CALLBACKS;
1102
1103typedef struct _XGL_DEVICE_QUEUE_CREATE_INFO
1104{
1105 XGL_UINT queueNodeIndex;
1106 XGL_UINT queueCount;
1107} XGL_DEVICE_QUEUE_CREATE_INFO;
1108
1109typedef struct _XGL_DEVICE_CREATE_INFO
1110{
1111 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_DEVICE_CREATE_INFO
1112 XGL_VOID* pNext; // Pointer to next structure
1113 XGL_UINT queueRecordCount;
1114 const XGL_DEVICE_QUEUE_CREATE_INFO* pRequestedQueues;
1115 XGL_UINT extensionCount;
1116 const XGL_CHAR*const* ppEnabledExtensionNames;
1117 XGL_VALIDATION_LEVEL maxValidationLevel;
1118 XGL_FLAGS flags; // XGL_DEVICE_CREATE_FLAGS
1119} XGL_DEVICE_CREATE_INFO;
1120
1121typedef struct _XGL_PHYSICAL_GPU_QUEUE_PROPERTIES
1122{
1123 XGL_SIZE structSize; // Size of structure in bytes
1124 XGL_FLAGS queueFlags; // XGL_QUEUE_FLAGS
1125 XGL_UINT queueCount;
1126 XGL_UINT maxAtomicCounters;
1127 XGL_BOOL supportsTimestamps;
1128} XGL_PHYSICAL_GPU_QUEUE_PROPERTIES;
1129
1130typedef struct _XGL_PHYSICAL_GPU_MEMORY_PROPERTIES
1131{
1132 XGL_SIZE structSize; // Size of structure in bytes
1133 XGL_BOOL supportsMigration;
1134 XGL_BOOL supportsVirtualMemoryRemapping;
1135 XGL_BOOL supportsPinning;
1136} XGL_PHYSICAL_GPU_MEMORY_PROPERTIES;
1137
1138typedef struct _XGL_MEMORY_HEAP_PROPERTIES
1139{
1140 XGL_SIZE structSize; // Size of structure in bytes
1141 XGL_HEAP_MEMORY_TYPE heapMemoryType; // XGL_HEAP_MEMORY_TYPE
1142 XGL_GPU_SIZE heapSize; // Specified in bytes
1143 XGL_GPU_SIZE pageSize; // Specified in bytes
1144 XGL_FLAGS flags; // XGL_MEMORY_HEAP_FLAGS
1145 XGL_FLOAT gpuReadPerfRating;
1146 XGL_FLOAT gpuWritePerfRating;
1147 XGL_FLOAT cpuReadPerfRating;
1148 XGL_FLOAT cpuWritePerfRating;
1149} XGL_MEMORY_HEAP_PROPERTIES;
1150
1151typedef struct _XGL_MEMORY_ALLOC_INFO
1152{
1153 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
1154 XGL_VOID* pNext; // Pointer to next structure
1155 XGL_GPU_SIZE allocationSize; // Size of memory allocation
1156 XGL_GPU_SIZE alignment;
1157 XGL_FLAGS flags; // XGL_MEMORY_ALLOC_FLAGS
1158 XGL_UINT heapCount;
1159 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1160 XGL_MEMORY_PRIORITY memPriority;
1161} XGL_MEMORY_ALLOC_INFO;
1162
1163typedef struct _XGL_MEMORY_OPEN_INFO
1164{
1165 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO
1166 XGL_VOID* pNext; // Pointer to next structure
1167 XGL_GPU_MEMORY sharedMem;
1168} XGL_MEMORY_OPEN_INFO;
1169
1170typedef struct _XGL_PEER_MEMORY_OPEN_INFO
1171{
1172 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO
1173 XGL_VOID* pNext; // Pointer to next structure
1174 XGL_GPU_MEMORY originalMem;
1175} XGL_PEER_MEMORY_OPEN_INFO;
1176
1177typedef struct _XGL_VIRTUAL_MEMORY_REMAP_RANGE
1178{
1179 XGL_GPU_MEMORY virtualMem;
1180 XGL_GPU_SIZE virtualStartPage;
1181 XGL_GPU_MEMORY realMem;
1182 XGL_GPU_SIZE realStartPage;
1183 XGL_GPU_SIZE pageCount;
1184} XGL_VIRTUAL_MEMORY_REMAP_RANGE;
1185
1186typedef struct _XGL_MEMORY_REQUIREMENTS
1187{
1188 XGL_GPU_SIZE size; // Specified in bytes
1189 XGL_GPU_SIZE alignment; // Specified in bytes
1190 XGL_UINT heapCount;
1191 XGL_UINT heaps[XGL_MAX_MEMORY_HEAPS];
1192} XGL_MEMORY_REQUIREMENTS;
1193
1194typedef struct _XGL_FORMAT_PROPERTIES
1195{
1196 XGL_FLAGS linearTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1197 XGL_FLAGS optimalTilingFeatures; // XGL_FORMAT_FEATURE_FLAGS
1198} XGL_FORMAT_PROPERTIES;
1199
1200typedef struct _XGL_MEMORY_VIEW_ATTACH_INFO
1201{
1202 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO
1203 XGL_VOID* pNext; // Pointer to next structure
1204 XGL_GPU_MEMORY mem;
1205 XGL_GPU_SIZE offset;
1206 XGL_GPU_SIZE range;
1207 XGL_GPU_SIZE stride;
1208 XGL_FORMAT format;
1209 XGL_MEMORY_STATE state;
1210} XGL_MEMORY_VIEW_ATTACH_INFO;
1211
1212typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO
1213{
1214 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
1215 XGL_VOID* pNext; // Pointer to next structure
1216 XGL_IMAGE_VIEW view;
1217 XGL_IMAGE_STATE state;
1218} XGL_IMAGE_VIEW_ATTACH_INFO;
1219
1220typedef struct _XGL_MEMORY_STATE_TRANSITION
1221{
1222 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_STATE_TRANSITION
1223 XGL_VOID* pNext; // Pointer to next structure
1224 XGL_GPU_MEMORY mem;
1225 XGL_MEMORY_STATE oldState;
1226 XGL_MEMORY_STATE newState;
1227 XGL_GPU_SIZE offset;
1228 XGL_GPU_SIZE regionSize;
1229} XGL_MEMORY_STATE_TRANSITION;
1230
1231typedef struct _XGL_IMAGE_SUBRESOURCE
1232{
1233 XGL_IMAGE_ASPECT aspect;
1234 XGL_UINT mipLevel;
1235 XGL_UINT arraySlice;
1236} XGL_IMAGE_SUBRESOURCE;
1237
1238typedef struct _XGL_IMAGE_SUBRESOURCE_RANGE
1239{
1240 XGL_IMAGE_ASPECT aspect;
1241 XGL_UINT baseMipLevel;
1242 XGL_UINT mipLevels;
1243 XGL_UINT baseArraySlice;
1244 XGL_UINT arraySize;
1245} XGL_IMAGE_SUBRESOURCE_RANGE;
1246
1247typedef struct _XGL_IMAGE_STATE_TRANSITION
1248{
1249 XGL_IMAGE image;
1250 XGL_IMAGE_STATE oldState;
1251 XGL_IMAGE_STATE newState;
1252 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1253} XGL_IMAGE_STATE_TRANSITION;
1254
1255typedef struct _XGL_IMAGE_CREATE_INFO
1256{
1257 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO
1258 const XGL_VOID* pNext; // Pointer to next structure.
1259 XGL_IMAGE_TYPE imageType;
1260 XGL_FORMAT format;
1261 XGL_EXTENT3D extent;
1262 XGL_UINT mipLevels;
1263 XGL_UINT arraySize;
1264 XGL_UINT samples;
1265 XGL_IMAGE_TILING tiling;
1266 XGL_FLAGS usage; // XGL_IMAGE_USAGE_FLAGS
1267 XGL_FLAGS flags; // XGL_IMAGE_CREATE_FLAGS
1268} XGL_IMAGE_CREATE_INFO;
1269
1270typedef struct _XGL_PEER_IMAGE_OPEN_INFO
1271{
1272 XGL_IMAGE originalImage;
1273} XGL_PEER_IMAGE_OPEN_INFO;
1274
1275typedef struct _XGL_SUBRESOURCE_LAYOUT
1276{
1277 XGL_GPU_SIZE offset; // Specified in bytes
1278 XGL_GPU_SIZE size; // Specified in bytes
1279 XGL_GPU_SIZE rowPitch; // Specified in bytes
1280 XGL_GPU_SIZE depthPitch; // Specified in bytes
1281} XGL_SUBRESOURCE_LAYOUT;
1282
1283typedef struct _XGL_CHANNEL_MAPPING
1284{
1285 XGL_CHANNEL_SWIZZLE r;
1286 XGL_CHANNEL_SWIZZLE g;
1287 XGL_CHANNEL_SWIZZLE b;
1288 XGL_CHANNEL_SWIZZLE a;
1289} XGL_CHANNEL_MAPPING;
1290
1291typedef struct _XGL_IMAGE_VIEW_CREATE_INFO
1292{
1293 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
1294 const XGL_VOID* pNext; // Pointer to next structure
1295 XGL_IMAGE image;
1296 XGL_IMAGE_VIEW_TYPE viewType;
1297 XGL_FORMAT format;
1298 XGL_CHANNEL_MAPPING channels;
1299 XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange;
1300 XGL_FLOAT minLod;
1301} XGL_IMAGE_VIEW_CREATE_INFO;
1302
1303typedef struct _XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1304{
1305 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
1306 XGL_VOID* pNext; // Pointer to next structure
1307 XGL_IMAGE image;
1308 XGL_FORMAT format;
1309 XGL_UINT mipLevel;
1310 XGL_UINT baseArraySlice;
1311 XGL_UINT arraySize;
1312} XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO;
1313
1314typedef struct _XGL_DEPTH_STENCIL_VIEW_CREATE_INFO
1315{
1316 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO
1317 const XGL_VOID* pNext; // Pointer to next structure
1318 XGL_IMAGE image;
1319 XGL_UINT mipLevel;
1320 XGL_UINT baseArraySlice;
1321 XGL_UINT arraySize;
1322 XGL_FLAGS flags; // XGL_DEPTH_STENCIL_VIEW_CREATE_FLAGS
1323} XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
1324
1325typedef struct _XGL_COLOR_ATTACHMENT_BIND_INFO
1326{
1327 XGL_COLOR_ATTACHMENT_VIEW view;
1328 XGL_IMAGE_STATE colorAttachmentState; // XGL_IMAGE_STATE
1329} XGL_COLOR_ATTACHMENT_BIND_INFO;
1330
1331typedef struct _XGL_DEPTH_STENCIL_BIND_INFO
1332{
1333 XGL_DEPTH_STENCIL_VIEW view;
1334 XGL_IMAGE_STATE depthState; // XGL_IMAGE_STATE
1335 XGL_IMAGE_STATE stencilState; // XGL_IMAGE_STATE
1336} XGL_DEPTH_STENCIL_BIND_INFO;
1337
1338typedef struct _XGL_MEMORY_COPY
1339{
1340 XGL_GPU_SIZE srcOffset; // Specified in bytes
1341 XGL_GPU_SIZE destOffset; // Specified in bytes
1342 XGL_GPU_SIZE copySize; // Specified in bytes
1343} XGL_MEMORY_COPY;
1344
1345typedef struct _XGL_IMAGE_COPY
1346{
1347 XGL_IMAGE_SUBRESOURCE srcSubresource;
1348 XGL_OFFSET3D srcOffset;
1349 XGL_IMAGE_SUBRESOURCE destSubresource;
1350 XGL_OFFSET3D destOffset;
1351 XGL_EXTENT3D extent;
1352} XGL_IMAGE_COPY;
1353
1354typedef struct _XGL_MEMORY_IMAGE_COPY
1355{
1356 XGL_GPU_SIZE memOffset; // Specified in bytes
1357 XGL_IMAGE_SUBRESOURCE imageSubresource;
1358 XGL_OFFSET3D imageOffset;
1359 XGL_EXTENT3D imageExtent;
1360} XGL_MEMORY_IMAGE_COPY;
1361
1362typedef struct _XGL_IMAGE_RESOLVE
1363{
1364 XGL_IMAGE_SUBRESOURCE srcSubresource;
1365 XGL_OFFSET2D srcOffset;
1366 XGL_IMAGE_SUBRESOURCE destSubresource;
1367 XGL_OFFSET2D destOffset;
1368 XGL_EXTENT2D extent;
1369} XGL_IMAGE_RESOLVE;
1370
1371typedef struct _XGL_SHADER_CREATE_INFO
1372{
1373 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO
1374 const XGL_VOID* pNext; // Pointer to next structure
1375 XGL_SIZE codeSize; // Specified in bytes
1376 const XGL_VOID* pCode;
1377 XGL_FLAGS flags; // Reserved
1378} XGL_SHADER_CREATE_INFO;
1379
1380struct _XGL_DESCRIPTOR_SET_MAPPING;
1381
1382typedef struct _XGL_DESCRIPTOR_SLOT_INFO
1383{
1384 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1385 union
1386 {
1387 XGL_UINT shaderEntityIndex;// Shader IL slot index for given entity type
1388 const struct _XGL_DESCRIPTOR_SET_MAPPING* pNextLevelSet; // Pointer to next descriptor set level
1389 };
1390} XGL_DESCRIPTOR_SLOT_INFO;
1391
1392typedef struct _XGL_DESCRIPTOR_SET_MAPPING
1393{
1394 XGL_UINT descriptorCount;
1395 const XGL_DESCRIPTOR_SLOT_INFO* pDescriptorInfo;
1396} XGL_DESCRIPTOR_SET_MAPPING;
1397
1398typedef struct _XGL_LINK_CONST_BUFFER
1399{
1400 XGL_UINT bufferId;
1401 XGL_SIZE bufferSize;
1402 const XGL_VOID* pBufferData;
1403} XGL_LINK_CONST_BUFFER;
1404
1405typedef struct _XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO
1406{
1407 XGL_DESCRIPTOR_SET_SLOT_TYPE slotObjectType;
1408 XGL_UINT shaderEntityIndex;
1409} XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO;
1410
1411typedef struct _XGL_PIPELINE_SHADER
1412{
1413 XGL_PIPELINE_SHADER_STAGE stage;
1414 XGL_SHADER shader;
1415 XGL_DESCRIPTOR_SET_MAPPING descriptorSetMapping[XGL_MAX_DESCRIPTOR_SETS];
1416 XGL_UINT linkConstBufferCount;
1417 const XGL_LINK_CONST_BUFFER* pLinkConstBufferInfo;
1418 XGL_DYNAMIC_MEMORY_VIEW_SLOT_INFO dynamicMemoryViewMapping;
1419} XGL_PIPELINE_SHADER;
1420
1421typedef struct _XGL_COMPUTE_PIPELINE_CREATE_INFO
1422{
1423 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO
1424 const XGL_VOID* pNext; // Pointer to next structure
1425 XGL_PIPELINE_SHADER cs;
1426 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1427} XGL_COMPUTE_PIPELINE_CREATE_INFO;
1428
Chia-I Wu6a921262014-10-06 15:07:25 +0800[diff] [blame^]1429// IMG CHANGE BEGIN - support for vertex input description
1430
1431// Example descriptor set mapping:
1432//
1433// {
1434// .descriptorCount = 4;
1435// .pDescriptorInfo[0] =
1436// {
1437// .slotObjectType = XGL_SLOT_VERTEX_INPUT;
1438// .shaderEntityIndex = 2; // describes XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO.pVertexBindingDescriptions[2]
1439// }
1440// .pDescriptorInfo[1] =
1441// {
1442// .slotObjectType = XGL_SLOT_UNUSED;
1443// .shaderEntityIndex = 0;
1444// }
1445// .pDescriptorInfo[2] =
1446// {
1447// .slotObjectType = XGL_SLOT_VERTEX_INPUT;
1448// .shaderEntityIndex = 0; // describes XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO.pVertexBindingDescriptions[0]
1449// }
1450// .pDescriptorInfo[3] =
1451// {
1452// .slotObjectType = XGL_SLOT_VERTEX_INPUT;
1453// .shaderEntityIndex = 1; // describes XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO.pVertexBindingDescriptions[1]
1454// }
1455// }
1456//
1457// The shader inputs are mapped to pVertexAttributeDescriptions using a decoration in the BIL.
1458//
1459//
1460// Formats allowed for attributes (XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION.format) will be detailed in
1461// a table in the specification.
1462//
1463//
1464// Queryable limits:
1465//
1466// XGL_VERTEX_INPUT_BINDING_DESCRIPTION.strideInBytes
1467// XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION.offsetInBytes
1468//
1469//
1470
1471typedef struct _XGL_VERTEX_INPUT_BINDING_DESCRIPTION
1472{
1473 XGL_UINT strideInBytes; // Distance between vertices in bytes (0 = no advancement)
1474
1475 XGL_VERTEX_INPUT_STEP_RATE stepRate; // Rate at which binding is incremented
1476} XGL_VERTEX_INPUT_BINDING_DESCRIPTION;
1477
1478typedef struct _XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION
1479{
1480 XGL_UINT binding; // index into vertexBindingDescriptions
1481
1482 XGL_FORMAT format; // format of source data
1483
1484 XGL_UINT offsetInBytes; // Offset of first element in bytes from base of vertex
1485} XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION;
1486
1487typedef struct _XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO
1488{
1489 XGL_STRUCTURE_TYPE sType; // Should be XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
1490 XGL_VOID* pNext; // Pointer to next structure
1491
1492 XGL_UINT bindingCount; // number of bindings
1493 XGL_VERTEX_INPUT_BINDING_DESCRIPTION* pVertexBindingDescriptions;
1494
1495 XGL_UINT attributeCount; // number of attributes
1496 XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* pVertexAttributeDescriptions;
1497} XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO;
1498// IMG CHANGE END
1499
Courtney Goeltzenleuchter2220a3b2014-07-24 08:36:15 -0600[diff] [blame]1500typedef struct _XGL_PIPELINE_IA_STATE_CREATE_INFO
1501{
1502 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
1503 const XGL_VOID* pNext; // Pointer to next structure
1504 XGL_PRIMITIVE_TOPOLOGY topology;
1505 XGL_BOOL disableVertexReuse;
1506 XGL_PROVOKING_VERTEX_CONVENTION provokingVertex;
1507 XGL_BOOL primitiveRestartEnable;
1508 XGL_UINT32 primitiveRestartIndex;
1509} XGL_PIPELINE_IA_STATE_CREATE_INFO;
1510
1511typedef struct _XGL_PIPELINE_TESS_STATE_CREATE_INFO
1512{
1513 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_TESS_STATE_CREATE_INFO
1514 const XGL_VOID* pNext; // Pointer to next structure
1515 XGL_UINT patchControlPoints;
1516 XGL_FLOAT optimalTessFactor;
1517 XGL_FLOAT fixedTessFactor;
1518} XGL_PIPELINE_TESS_STATE_CREATE_INFO;
1519
1520typedef struct _XGL_PIPELINE_RS_STATE_CREATE_INFO
1521{
1522 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
1523 const XGL_VOID* pNext; // Pointer to next structure
1524 XGL_BOOL depthClipEnable;
1525 XGL_BOOL rasterizerDiscardEnable;
1526 XGL_FLOAT pointSize; // Size of points
1527} XGL_PIPELINE_RS_STATE_CREATE_INFO;
1528
1529typedef struct _XGL_PIPELINE_CB_ATTACHMENT_STATE
1530{
1531 XGL_BOOL blendEnable;
1532 XGL_FORMAT format;
1533 XGL_UINT8 channelWriteMask;
1534} XGL_PIPELINE_CB_ATTACHMENT_STATE;
1535
1536typedef struct _XGL_PIPELINE_CB_STATE_CREATE_INFO
1537{
1538 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
1539 const XGL_VOID* pNext; // Pointer to next structure
1540 XGL_BOOL alphaToCoverageEnable;
1541 XGL_BOOL dualSourceBlendEnable;
1542 XGL_LOGIC_OP logicOp;
1543 XGL_PIPELINE_CB_ATTACHMENT_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1544} XGL_PIPELINE_CB_STATE;
1545
1546typedef struct _XGL_PIPELINE_DB_STATE_CREATE_INFO
1547{
1548 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO
1549 const XGL_VOID* pNext; // Pointer to next structure
1550 XGL_FORMAT format;
1551} XGL_PIPELINE_DB_STATE_CREATE_INFO;
1552
1553typedef struct _XGL_PIPELINE_SHADER_STAGE_CREATE_INFO
1554{
1555 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
1556 const XGL_VOID* pNext; // Pointer to next structure
1557 XGL_PIPELINE_SHADER shader;
1558} XGL_PIPELINE_SHADER_STAGE_CREATE_INFO;
1559
1560typedef struct _XGL_GRAPHICS_PIPELINE_CREATE_INFO
1561{
1562 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
1563 const XGL_VOID* pNext; // Pointer to next structure
1564 XGL_FLAGS flags; // XGL_PIPELINE_CREATE_FLAGS
1565} XGL_GRAPHICS_PIPELINE_CREATE_INFO;
1566
1567typedef struct _XGL_SAMPLER_CREATE_INFO
1568{
1569 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO
1570 const XGL_VOID* pNext; // Pointer to next structure
1571 XGL_TEX_FILTER magFilter; // Filter mode for magnification
1572 XGL_TEX_FILTER minFilter; // Filter mode for minifiation
1573 XGL_TEX_MIPMAP_MODE mipMode; // Mipmap selection mode
1574 XGL_TEX_ADDRESS addressU;
1575 XGL_TEX_ADDRESS addressV;
1576 XGL_TEX_ADDRESS addressW;
1577 XGL_FLOAT mipLodBias;
1578 XGL_UINT maxAnisotropy;
1579 XGL_COMPARE_FUNC compareFunc;
1580 XGL_FLOAT minLod;
1581 XGL_FLOAT maxLod;
1582 XGL_BORDER_COLOR_TYPE borderColorType;
1583} XGL_SAMPLER_CREATE_INFO;
1584
1585typedef struct _XGL_DESCRIPTOR_SET_CREATE_INFO
1586{
1587 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO
1588 const XGL_VOID* pNext; // Pointer to next structure
1589 XGL_UINT slots;
1590} XGL_DESCRIPTOR_SET_CREATE_INFO;
1591
1592typedef struct _XGL_DESCRIPTOR_SET_ATTACH_INFO
1593{
1594 XGL_DESCRIPTOR_SET descriptorSet;
1595 XGL_UINT slotOffset;
1596} XGL_DESCRIPTOR_SET_ATTACH_INFO;
1597
1598typedef struct _XGL_VIEWPORT_STATE_CREATE_INFO
1599{
1600 XGL_UINT viewportCount;
1601 XGL_BOOL scissorEnable;
1602 XGL_VIEWPORT viewports[XGL_MAX_VIEWPORTS];
1603 XGL_RECT scissors[XGL_MAX_VIEWPORTS];
1604} XGL_VIEWPORT_STATE_CREATE_INFO;
1605
1606typedef struct _XGL_RASTER_STATE_CREATE_INFO
1607{
1608 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO
1609 const XGL_VOID* pNext; // Pointer to next structure
1610 XGL_FILL_MODE fillMode;
1611 XGL_CULL_MODE cullMode;
1612 XGL_FACE_ORIENTATION frontFace;
1613 XGL_INT depthBias;
1614 XGL_FLOAT depthBiasClamp;
1615 XGL_FLOAT slopeScaledDepthBias;
1616} XGL_RASTER_STATE_CREATE_INFO;
1617
1618typedef struct _XGL_MSAA_STATE_CREATE_INFO
1619{
1620 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO
1621 const XGL_VOID* pNext; // Pointer to next structure
1622 XGL_UINT samples;
1623 XGL_SAMPLE_MASK sampleMask;
1624} XGL_MSAA_STATE_CREATE_INFO;
1625
1626typedef struct _XGL_COLOR_ATTACHMENT_BLEND_STATE
1627{
1628 XGL_BOOL blendEnable;
1629 XGL_BLEND srcBlendColor;
1630 XGL_BLEND destBlendColor;
1631 XGL_BLEND_FUNC blendFuncColor;
1632 XGL_BLEND srcBlendAlpha;
1633 XGL_BLEND destBlendAlpha;
1634 XGL_BLEND_FUNC blendFuncAlpha;
1635} XGL_COLOR_ATTACHMENT_BLEND_STATE;
1636
1637typedef struct _XGL_COLOR_BLEND_STATE_CREATE_INFO
1638{
1639 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO
1640 const XGL_VOID* pNext; // Pointer to next structure
1641 XGL_COLOR_ATTACHMENT_BLEND_STATE attachment[XGL_MAX_COLOR_ATTACHMENTS];
1642 XGL_FLOAT blendConst[4];
1643} XGL_COLOR_BLEND_STATE_CREATE_INFO;
1644
1645typedef struct _XGL_STENCIL_OP_STATE
1646{
1647 XGL_STENCIL_OP stencilFailOp;
1648 XGL_STENCIL_OP stencilPassOp;
1649 XGL_STENCIL_OP stencilDepthFailOp;
1650 XGL_COMPARE_FUNC stencilFunc;
1651 XGL_UINT32 stencilRef;
1652} XGL_STENCIL_OP_STATE;
1653
1654typedef struct _XGL_DEPTH_STENCIL_STATE_CREATE_INFO
1655{
1656 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO
1657 const XGL_VOID* pNext; // Pointer to next structure
1658 XGL_BOOL depthTestEnable;
1659 XGL_BOOL depthWriteEnable;
1660 XGL_COMPARE_FUNC depthFunc;
1661 XGL_BOOL depthBoundsEnable;
1662 XGL_FLOAT minDepth;
1663 XGL_FLOAT maxDepth;
1664 XGL_BOOL stencilTestEnable;
1665 XGL_UINT32 stencilReadMask;
1666 XGL_UINT32 stencilWriteMask;
1667 XGL_STENCIL_OP_STATE front;
1668 XGL_STENCIL_OP_STATE back;
1669} XGL_DEPTH_STENCIL_STATE_CREATE_INFO;
1670
1671typedef struct _XGL_CMD_BUFFER_CREATE_INFO
1672{
1673 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO
1674 const XGL_VOID* pNext;
1675 XGL_QUEUE_TYPE queueType;
1676 XGL_FLAGS flags;
1677} XGL_CMD_BUFFER_CREATE_INFO;
1678
1679typedef struct _XGL_MEMORY_REF
1680{
1681 XGL_GPU_MEMORY mem;
1682 XGL_FLAGS flags; // XGL_MEMORY_REF_FLAGS
1683} XGL_MEMORY_REF;
1684
1685typedef struct _XGL_EVENT_CREATE_INFO
1686{
1687 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_CREATE_INFO
1688 const XGL_VOID* pNext; // Pointer to next structure
1689 XGL_FLAGS flags; // Reserved
1690} XGL_EVENT_CREATE_INFO;
1691
1692typedef struct _XGL_FENCE_CREATE_INFO
1693{
1694 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_FENCE_CREATE_INFO
1695 const XGL_VOID* pNext; // Pointer to next structure
1696 XGL_FLAGS flags; // Reserved
1697} XGL_FENCE_CREATE_INFO;
1698
1699typedef struct _XGL_QUEUE_SEMAPHORE_CREATE_INFO
1700{
1701 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
1702 const XGL_VOID* pNext; // Pointer to next structure
1703 XGL_UINT initialCount;
1704 XGL_FLAGS flags; // XGL_SEMAPHORE_CREATE_FLAGS
1705} XGL_QUEUE_SEMAPHORE_CREATE_INFO;
1706
1707typedef struct _XGL_QUEUE_SEMAPHORE_OPEN_INFO
1708{
1709 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_SEMAPHORE_OPEN_INFO
1710 const XGL_VOID* pNext; // Pointer to next structure
1711 XGL_QUEUE_SEMAPHORE sharedSemaphore;
1712} XGL_QUEUE_SEMAPHORE_OPEN_INFO;
1713
1714typedef struct _XGL_PIPELINE_STATISTICS_DATA
1715{
1716 XGL_UINT64 fsInvocations; // Fragment shader invocations
1717 XGL_UINT64 cPrimitives; // Clipper primitives
1718 XGL_UINT64 cInvocations; // Clipper invocations
1719 XGL_UINT64 vsInvocations; // Vertex shader invocations
1720 XGL_UINT64 gsInvocations; // Geometry shader invocations
1721 XGL_UINT64 gsPrimitives; // Geometry shader primitives
1722 XGL_UINT64 iaPrimitives; // Input primitives
1723 XGL_UINT64 iaVertices; // Input vertices
1724 XGL_UINT64 tcsInvocations; // Tessellation control shader invocations
1725 XGL_UINT64 tesInvocations; // Tessellation evaluation shader invocations
1726 XGL_UINT64 csInvocations; // Compute shader invocations
1727} XGL_PIPELINE_STATISTICS_DATA;
1728
1729typedef struct _XGL_QUERY_POOL_CREATE_INFO
1730{
1731 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO
1732 const XGL_VOID* pNext; // Pointer to next structure
1733 XGL_QUERY_TYPE queryType;
1734 XGL_UINT slots;
1735} XGL_QUERY_POOL_CREATE_INFO;
1736
1737typedef struct _XGL_DRAW_INDIRECT_CMD
1738{
1739 XGL_UINT32 vertexCount;
1740 XGL_UINT32 instanceCount;
1741 XGL_UINT32 firstVertex;
1742 XGL_UINT32 firstInstance;
1743} XGL_DRAW_INDIRECT_CMD;
1744
1745typedef struct _XGL_DRAW_INDEXED_INDIRECT_CMD
1746{
1747 XGL_UINT32 indexCount;
1748 XGL_UINT32 instanceCount;
1749 XGL_UINT32 firstIndex;
1750 XGL_INT32 vertexOffset;
1751 XGL_UINT32 firstInstance;
1752} XGL_DRAW_INDEXED_INDIRECT_CMD;
1753
1754typedef struct _XGL_DISPATCH_INDIRECT_CMD
1755{
1756 XGL_UINT32 x;
1757 XGL_UINT32 y;
1758 XGL_UINT32 z;
1759} XGL_DISPATCH_INDIRECT_CMD;
1760
1761// ------------------------------------------------------------------------------------------------
1762// API functions
1763
1764// GPU initialization
1765
1766XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
1767 const XGL_APPLICATION_INFO* pAppInfo,
1768 const XGL_ALLOC_CALLBACKS* pAllocCb,
1769 XGL_UINT maxGpus,
1770 XGL_UINT* pGpuCount,
1771 XGL_PHYSICAL_GPU* pGpus);
1772
1773XGL_RESULT XGLAPI xglGetGpuInfo(
1774 XGL_PHYSICAL_GPU gpu,
1775 XGL_PHYSICAL_GPU_INFO_TYPE infoType,
1776 XGL_SIZE* pDataSize,
1777 XGL_VOID* pData);
1778
1779// Device functions
1780
1781XGL_RESULT XGLAPI xglCreateDevice(
1782 XGL_PHYSICAL_GPU gpu,
1783 const XGL_DEVICE_CREATE_INFO* pCreateInfo,
1784 XGL_DEVICE* pDevice);
1785
1786XGL_RESULT XGLAPI xglDestroyDevice(
1787 XGL_DEVICE device);
1788
1789// Extension discovery functions
1790
1791XGL_RESULT XGLAPI xglGetExtensionSupport(
1792 XGL_PHYSICAL_GPU gpu,
1793 const XGL_CHAR* pExtName);
1794
1795// Queue functions
1796
1797XGL_RESULT XGLAPI xglGetDeviceQueue(
1798 XGL_DEVICE device,
1799 XGL_QUEUE_TYPE queueType,
1800 XGL_UINT queueIndex,
1801 XGL_QUEUE* pQueue);
1802
1803XGL_RESULT XGLAPI xglQueueSubmit(
1804 XGL_QUEUE queue,
1805 XGL_UINT cmdBufferCount,
1806 const XGL_CMD_BUFFER* pCmdBuffers,
1807 XGL_UINT memRefCount,
1808 const XGL_MEMORY_REF* pMemRefs,
1809 XGL_FENCE fence);
1810
1811XGL_RESULT XGLAPI xglQueueSetGlobalMemReferences(
1812 XGL_QUEUE queue,
1813 XGL_UINT memRefCount,
1814 const XGL_MEMORY_REF* pMemRefs);
1815
1816XGL_RESULT XGLAPI xglQueueWaitIdle(
1817 XGL_QUEUE queue);
1818
1819XGL_RESULT XGLAPI xglDeviceWaitIdle(
1820 XGL_DEVICE device);
1821
1822// Memory functions
1823
1824XGL_RESULT XGLAPI xglGetMemoryHeapCount(
1825 XGL_DEVICE device,
1826 XGL_UINT* pCount);
1827
1828XGL_RESULT XGLAPI xglGetMemoryHeapInfo(
1829 XGL_DEVICE device,
1830 XGL_UINT heapId,
1831 XGL_MEMORY_HEAP_INFO_TYPE infoType,
1832 XGL_SIZE* pDataSize,
1833 XGL_VOID* pData);
1834
1835XGL_RESULT XGLAPI xglAllocMemory(
1836 XGL_DEVICE device,
1837 const XGL_MEMORY_ALLOC_INFO* pAllocInfo,
1838 XGL_GPU_MEMORY* pMem);
1839
1840XGL_RESULT XGLAPI xglFreeMemory(
1841 XGL_GPU_MEMORY mem);
1842
1843XGL_RESULT XGLAPI xglSetMemoryPriority(
1844 XGL_GPU_MEMORY mem,
1845 XGL_MEMORY_PRIORITY priority);
1846
1847XGL_RESULT XGLAPI xglMapMemory(
1848 XGL_GPU_MEMORY mem,
1849 XGL_FLAGS flags, // Reserved
1850 XGL_VOID** ppData);
1851
1852XGL_RESULT XGLAPI xglUnmapMemory(
1853 XGL_GPU_MEMORY mem);
1854
1855XGL_RESULT XGLAPI xglPinSystemMemory(
1856 XGL_DEVICE device,
1857 const XGL_VOID* pSysMem,
1858 XGL_SIZE memSize,
1859 XGL_GPU_MEMORY* pMem);
1860
1861XGL_RESULT XGLAPI xglRemapVirtualMemoryPages(
1862 XGL_DEVICE device,
1863 XGL_UINT rangeCount,
1864 const XGL_VIRTUAL_MEMORY_REMAP_RANGE* pRanges,
1865 XGL_UINT preWaitSemaphoreCount,
1866 const XGL_QUEUE_SEMAPHORE* pPreWaitSemaphores,
1867 XGL_UINT postSignalSemaphoreCount,
1868 const XGL_QUEUE_SEMAPHORE* pPostSignalSemaphores);
1869
1870// Multi-device functions
1871
1872XGL_RESULT XGLAPI xglGetMultiGpuCompatibility(
1873 XGL_PHYSICAL_GPU gpu0,
1874 XGL_PHYSICAL_GPU gpu1,
1875 XGL_GPU_COMPATIBILITY_INFO* pInfo);
1876
1877XGL_RESULT XGLAPI xglOpenSharedMemory(
1878 XGL_DEVICE device,
1879 const XGL_MEMORY_OPEN_INFO* pOpenInfo,
1880 XGL_GPU_MEMORY* pMem);
1881
1882XGL_RESULT XGLAPI xglOpenSharedQueueSemaphore(
1883 XGL_DEVICE device,
1884 const XGL_QUEUE_SEMAPHORE_OPEN_INFO* pOpenInfo,
1885 XGL_QUEUE_SEMAPHORE* pSemaphore);
1886
1887XGL_RESULT XGLAPI xglOpenPeerMemory(
1888 XGL_DEVICE device,
1889 const XGL_PEER_MEMORY_OPEN_INFO* pOpenInfo,
1890 XGL_GPU_MEMORY* pMem);
1891
1892XGL_RESULT XGLAPI xglOpenPeerImage(
1893 XGL_DEVICE device,
1894 const XGL_PEER_IMAGE_OPEN_INFO* pOpenInfo,
1895 XGL_IMAGE* pImage,
1896 XGL_GPU_MEMORY* pMem);
1897
1898// Generic API object functions
1899
1900XGL_RESULT XGLAPI xglDestroyObject(
1901 XGL_OBJECT object);
1902
1903XGL_RESULT XGLAPI xglGetObjectInfo(
1904 XGL_BASE_OBJECT object,
1905 XGL_OBJECT_INFO_TYPE infoType,
1906 XGL_SIZE* pDataSize,
1907 XGL_VOID* pData);
1908
1909XGL_RESULT XGLAPI xglBindObjectMemory(
1910 XGL_OBJECT object,
1911 XGL_GPU_MEMORY mem,
1912 XGL_GPU_SIZE offset);
1913
1914// Fence functions
1915
1916XGL_RESULT XGLAPI xglCreateFence(
1917 XGL_DEVICE device,
1918 const XGL_FENCE_CREATE_INFO* pCreateInfo,
1919 XGL_FENCE* pFence);
1920
1921XGL_RESULT XGLAPI xglGetFenceStatus(
1922 XGL_FENCE fence);
1923
1924XGL_RESULT XGLAPI xglWaitForFences(
1925 XGL_DEVICE device,
1926 XGL_UINT fenceCount,
1927 const XGL_FENCE* pFences,
1928 XGL_BOOL waitAll,
1929 XGL_UINT64 timeout);
1930
1931// Queue semaphore functions
1932
1933XGL_RESULT XGLAPI xglCreateQueueSemaphore(
1934 XGL_DEVICE device,
1935 const XGL_QUEUE_SEMAPHORE_CREATE_INFO* pCreateInfo,
1936 XGL_QUEUE_SEMAPHORE* pSemaphore);
1937
1938XGL_RESULT XGLAPI xglSignalQueueSemaphore(
1939 XGL_QUEUE queue,
1940 XGL_QUEUE_SEMAPHORE semaphore);
1941
1942XGL_RESULT XGLAPI xglWaitQueueSemaphore(
1943 XGL_QUEUE queue,
1944 XGL_QUEUE_SEMAPHORE semaphore);
1945
1946// Event functions
1947
1948XGL_RESULT XGLAPI xglCreateEvent(
1949 XGL_DEVICE device,
1950 const XGL_EVENT_CREATE_INFO* pCreateInfo,
1951 XGL_EVENT* pEvent);
1952
1953XGL_RESULT XGLAPI xglGetEventStatus(
1954 XGL_EVENT event);
1955
1956XGL_RESULT XGLAPI xglSetEvent(
1957 XGL_EVENT event);
1958
1959XGL_RESULT XGLAPI xglResetEvent(
1960 XGL_EVENT event);
1961
1962// Query functions
1963
1964XGL_RESULT XGLAPI xglCreateQueryPool(
1965 XGL_DEVICE device,
1966 const XGL_QUERY_POOL_CREATE_INFO* pCreateInfo,
1967 XGL_QUERY_POOL* pQueryPool);
1968
1969XGL_RESULT XGLAPI xglGetQueryPoolResults(
1970 XGL_QUERY_POOL queryPool,
1971 XGL_UINT startQuery,
1972 XGL_UINT queryCount,
1973 XGL_SIZE* pDataSize,
1974 XGL_VOID* pData);
1975
1976// Format capabilities
1977
1978XGL_RESULT XGLAPI xglGetFormatInfo(
1979 XGL_DEVICE device,
1980 XGL_FORMAT format,
1981 XGL_FORMAT_INFO_TYPE infoType,
1982 XGL_SIZE* pDataSize,
1983 XGL_VOID* pData);
1984
1985// Image functions
1986
1987XGL_RESULT XGLAPI xglCreateImage(
1988 XGL_DEVICE device,
1989 const XGL_IMAGE_CREATE_INFO* pCreateInfo,
1990 XGL_IMAGE* pImage);
1991
1992XGL_RESULT XGLAPI xglGetImageSubresourceInfo(
1993 XGL_IMAGE image,
1994 const XGL_IMAGE_SUBRESOURCE* pSubresource,
1995 XGL_SUBRESOURCE_INFO_TYPE infoType,
1996 XGL_SIZE* pDataSize,
1997 XGL_VOID* pData);
1998
1999// Image view functions
2000
2001XGL_RESULT XGLAPI xglCreateImageView(
2002 XGL_DEVICE device,
2003 const XGL_IMAGE_VIEW_CREATE_INFO* pCreateInfo,
2004 XGL_IMAGE_VIEW* pView);
2005
2006XGL_RESULT XGLAPI xglCreateColorAttachmentView(
2007 XGL_DEVICE device,
2008 const XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO* pCreateInfo,
2009 XGL_COLOR_ATTACHMENT_VIEW* pView);
2010
2011XGL_RESULT XGLAPI xglCreateDepthStencilView(
2012 XGL_DEVICE device,
2013 const XGL_DEPTH_STENCIL_VIEW_CREATE_INFO* pCreateInfo,
2014 XGL_DEPTH_STENCIL_VIEW* pView);
2015
2016// Shader functions
2017
2018XGL_RESULT XGLAPI xglCreateShader(
2019 XGL_DEVICE device,
2020 const XGL_SHADER_CREATE_INFO* pCreateInfo,
2021 XGL_SHADER* pShader);
2022
2023// Pipeline functions
2024
2025XGL_RESULT XGLAPI xglCreateGraphicsPipeline(
2026 XGL_DEVICE device,
2027 const XGL_GRAPHICS_PIPELINE_CREATE_INFO* pCreateInfo,
2028 XGL_PIPELINE* pPipeline);
2029
2030XGL_RESULT XGLAPI xglCreateComputePipeline(
2031 XGL_DEVICE device,
2032 const XGL_COMPUTE_PIPELINE_CREATE_INFO* pCreateInfo,
2033 XGL_PIPELINE* pPipeline);
2034
2035XGL_RESULT XGLAPI xglStorePipeline(
2036 XGL_PIPELINE pipeline,
2037 XGL_SIZE* pDataSize,
2038 XGL_VOID* pData);
2039
2040XGL_RESULT XGLAPI xglLoadPipeline(
2041 XGL_DEVICE device,
2042 XGL_SIZE dataSize,
2043 const XGL_VOID* pData,
2044 XGL_PIPELINE* pPipeline);
2045
2046XGL_RESULT XGLAPI xglCreatePipelineDelta(
2047 XGL_DEVICE device,
2048 XGL_PIPELINE p1,
2049 XGL_PIPELINE p2,
2050 XGL_PIPELINE_DELTA* delta);
2051
2052// Sampler functions
2053
2054XGL_RESULT XGLAPI xglCreateSampler(
2055 XGL_DEVICE device,
2056 const XGL_SAMPLER_CREATE_INFO* pCreateInfo,
2057 XGL_SAMPLER* pSampler);
2058
2059// Descriptor set functions
2060
2061XGL_RESULT XGLAPI xglCreateDescriptorSet(
2062 XGL_DEVICE device,
2063 const XGL_DESCRIPTOR_SET_CREATE_INFO* pCreateInfo,
2064 XGL_DESCRIPTOR_SET* pDescriptorSet);
2065
2066XGL_VOID XGLAPI xglBeginDescriptorSetUpdate(
2067 XGL_DESCRIPTOR_SET descriptorSet);
2068
2069XGL_VOID XGLAPI xglEndDescriptorSetUpdate(
2070 XGL_DESCRIPTOR_SET descriptorSet);
2071
2072XGL_VOID XGLAPI xglAttachSamplerDescriptors(
2073 XGL_DESCRIPTOR_SET descriptorSet,
2074 XGL_UINT startSlot,
2075 XGL_UINT slotCount,
2076 const XGL_SAMPLER* pSamplers);
2077
2078XGL_VOID XGLAPI xglAttachImageViewDescriptors(
2079 XGL_DESCRIPTOR_SET descriptorSet,
2080 XGL_UINT startSlot,
2081 XGL_UINT slotCount,
2082 const XGL_IMAGE_VIEW_ATTACH_INFO* pImageViews);
2083
2084XGL_VOID XGLAPI xglAttachMemoryViewDescriptors(
2085 XGL_DESCRIPTOR_SET descriptorSet,
2086 XGL_UINT startSlot,
2087 XGL_UINT slotCount,
2088 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemViews);
2089
2090XGL_VOID XGLAPI xglAttachNestedDescriptors(
2091 XGL_DESCRIPTOR_SET descriptorSet,
2092 XGL_UINT startSlot,
2093 XGL_UINT slotCount,
2094 const XGL_DESCRIPTOR_SET_ATTACH_INFO* pNestedDescriptorSets);
2095
2096XGL_VOID XGLAPI xglClearDescriptorSetSlots(
2097 XGL_DESCRIPTOR_SET descriptorSet,
2098 XGL_UINT startSlot,
2099 XGL_UINT slotCount);
2100
2101// State object functions
2102
2103XGL_RESULT XGLAPI xglCreateViewportState(
2104 XGL_DEVICE device,
2105 const XGL_VIEWPORT_STATE_CREATE_INFO* pCreateInfo,
2106 XGL_VIEWPORT_STATE_OBJECT* pState);
2107
2108XGL_RESULT XGLAPI xglCreateRasterState(
2109 XGL_DEVICE device,
2110 const XGL_RASTER_STATE_CREATE_INFO* pCreateInfo,
2111 XGL_RASTER_STATE_OBJECT* pState);
2112
2113XGL_RESULT XGLAPI xglCreateMsaaState(
2114 XGL_DEVICE device,
2115 const XGL_MSAA_STATE_CREATE_INFO* pCreateInfo,
2116 XGL_MSAA_STATE_OBJECT* pState);
2117
2118XGL_RESULT XGLAPI xglCreateColorBlendState(
2119 XGL_DEVICE device,
2120 const XGL_COLOR_BLEND_STATE_CREATE_INFO* pCreateInfo,
2121 XGL_COLOR_BLEND_STATE_OBJECT* pState);
2122
2123XGL_RESULT XGLAPI xglCreateDepthStencilState(
2124 XGL_DEVICE device,
2125 const XGL_DEPTH_STENCIL_STATE_CREATE_INFO* pCreateInfo,
2126 XGL_DEPTH_STENCIL_STATE_OBJECT* pState);
2127
2128// Command buffer functions
2129
2130XGL_RESULT XGLAPI xglCreateCommandBuffer(
2131 XGL_DEVICE device,
2132 const XGL_CMD_BUFFER_CREATE_INFO* pCreateInfo,
2133 XGL_CMD_BUFFER* pCmdBuffer);
2134
2135XGL_RESULT XGLAPI xglBeginCommandBuffer(
2136 XGL_CMD_BUFFER cmdBuffer,
2137 XGL_FLAGS flags); // XGL_CMD_BUFFER_BUILD_FLAGS
2138
2139XGL_RESULT XGLAPI xglEndCommandBuffer(
2140 XGL_CMD_BUFFER cmdBuffer);
2141
2142XGL_RESULT XGLAPI xglResetCommandBuffer(
2143 XGL_CMD_BUFFER cmdBuffer);
2144
2145// Command buffer building functions
2146
2147XGL_VOID XGLAPI xglCmdBindPipeline(
2148 XGL_CMD_BUFFER cmdBuffer,
2149 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2150 XGL_PIPELINE pipeline);
2151
2152XGL_VOID XGLAPI xglCmdBindPipelineDelta(
2153 XGL_CMD_BUFFER cmdBuffer,
2154 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2155 XGL_PIPELINE_DELTA delta);
2156
2157XGL_VOID XGLAPI xglCmdBindStateObject(
2158 XGL_CMD_BUFFER cmdBuffer,
2159 XGL_STATE_BIND_POINT stateBindPoint,
2160 XGL_STATE_OBJECT state);
2161
2162XGL_VOID XGLAPI xglCmdBindDescriptorSet(
2163 XGL_CMD_BUFFER cmdBuffer,
2164 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2165 XGL_UINT index,
2166 XGL_DESCRIPTOR_SET descriptorSet,
2167 XGL_UINT slotOffset);
2168
2169XGL_VOID XGLAPI xglCmdBindDynamicMemoryView(
2170 XGL_CMD_BUFFER cmdBuffer,
2171 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2172 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
2173
2174XGL_VOID XGLAPI xglCmdBindIndexData(
2175 XGL_CMD_BUFFER cmdBuffer,
2176 XGL_GPU_MEMORY mem,
2177 XGL_GPU_SIZE offset,
2178 XGL_INDEX_TYPE indexType);
2179
2180XGL_VOID XGLAPI xglCmdBindAttachments(
2181 XGL_CMD_BUFFER cmdBuffer,
2182 XGL_UINT colorAttachmentCount,
2183 const XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments,
2184 const XGL_DEPTH_STENCIL_BIND_INFO* pDepthStencilAttachment);
2185
2186XGL_VOID XGLAPI xglCmdPrepareMemoryRegions(
2187 XGL_CMD_BUFFER cmdBuffer,
2188 XGL_UINT transitionCount,
2189 const XGL_MEMORY_STATE_TRANSITION* pStateTransitions);
2190
2191XGL_VOID XGLAPI xglCmdPrepareImages(
2192 XGL_CMD_BUFFER cmdBuffer,
2193 XGL_UINT transitionCount,
2194 const XGL_IMAGE_STATE_TRANSITION* pStateTransitions);
2195
2196XGL_VOID XGLAPI xglCmdDraw(
2197 XGL_CMD_BUFFER cmdBuffer,
2198 XGL_UINT firstVertex,
2199 XGL_UINT vertexCount,
2200 XGL_UINT firstInstance,
2201 XGL_UINT instanceCount);
2202
2203XGL_VOID XGLAPI xglCmdDrawIndexed(
2204 XGL_CMD_BUFFER cmdBuffer,
2205 XGL_UINT firstIndex,
2206 XGL_UINT indexCount,
2207 XGL_INT vertexOffset,
2208 XGL_UINT firstInstance,
2209 XGL_UINT instanceCount);
2210
2211XGL_VOID XGLAPI xglCmdDrawIndirect(
2212 XGL_CMD_BUFFER cmdBuffer,
2213 XGL_GPU_MEMORY mem,
2214 XGL_GPU_SIZE offset,
2215 XGL_UINT32 count,
2216 XGL_UINT32 stride);
2217
2218XGL_VOID XGLAPI xglCmdDrawIndexedIndirect(
2219 XGL_CMD_BUFFER cmdBuffer,
2220 XGL_GPU_MEMORY mem,
2221 XGL_GPU_SIZE offset,
2222 XGL_UINT32 count,
2223 XGL_UINT32 stride);
2224
2225XGL_VOID XGLAPI xglCmdDispatch(
2226 XGL_CMD_BUFFER cmdBuffer,
2227 XGL_UINT x,
2228 XGL_UINT y,
2229 XGL_UINT z);
2230
2231XGL_VOID XGLAPI xglCmdDispatchIndirect(
2232 XGL_CMD_BUFFER cmdBuffer,
2233 XGL_GPU_MEMORY mem,
2234 XGL_GPU_SIZE offset);
2235
2236XGL_VOID XGLAPI xglCmdCopyMemory(
2237 XGL_CMD_BUFFER cmdBuffer,
2238 XGL_GPU_MEMORY srcMem,
2239 XGL_GPU_MEMORY destMem,
2240 XGL_UINT regionCount,
2241 const XGL_MEMORY_COPY* pRegions);
2242
2243XGL_VOID XGLAPI xglCmdCopyImage(
2244 XGL_CMD_BUFFER cmdBuffer,
2245 XGL_IMAGE srcImage,
2246 XGL_IMAGE destImage,
2247 XGL_UINT regionCount,
2248 const XGL_IMAGE_COPY* pRegions);
2249
2250XGL_VOID XGLAPI xglCmdCopyMemoryToImage(
2251 XGL_CMD_BUFFER cmdBuffer,
2252 XGL_GPU_MEMORY srcMem,
2253 XGL_IMAGE destImage,
2254 XGL_UINT regionCount,
2255 const XGL_MEMORY_IMAGE_COPY* pRegions);
2256
2257XGL_VOID XGLAPI xglCmdCopyImageToMemory(
2258 XGL_CMD_BUFFER cmdBuffer,
2259 XGL_IMAGE srcImage,
2260 XGL_GPU_MEMORY destMem,
2261 XGL_UINT regionCount,
2262 const XGL_MEMORY_IMAGE_COPY* pRegions);
2263
2264XGL_VOID XGLAPI xglCmdCloneImageData(
2265 XGL_CMD_BUFFER cmdBuffer,
2266 XGL_IMAGE srcImage,
2267 XGL_IMAGE_STATE srcImageState,
2268 XGL_IMAGE destImage,
2269 XGL_IMAGE_STATE destImageState);
2270
2271XGL_VOID XGLAPI xglCmdUpdateMemory(
2272 XGL_CMD_BUFFER cmdBuffer,
2273 XGL_GPU_MEMORY destMem,
2274 XGL_GPU_SIZE destOffset,
2275 XGL_GPU_SIZE dataSize,
2276 const XGL_UINT32* pData);
2277
2278XGL_VOID XGLAPI xglCmdFillMemory(
2279 XGL_CMD_BUFFER cmdBuffer,
2280 XGL_GPU_MEMORY destMem,
2281 XGL_GPU_SIZE destOffset,
2282 XGL_GPU_SIZE fillSize,
2283 XGL_UINT32 data);
2284
2285XGL_VOID XGLAPI xglCmdClearColorImage(
2286 XGL_CMD_BUFFER cmdBuffer,
2287 XGL_IMAGE image,
2288 const XGL_FLOAT color[4],
2289 XGL_UINT rangeCount,
2290 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2291
2292XGL_VOID XGLAPI xglCmdClearColorImageRaw(
2293 XGL_CMD_BUFFER cmdBuffer,
2294 XGL_IMAGE image,
2295 const XGL_UINT32 color[4],
2296 XGL_UINT rangeCount,
2297 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2298
2299XGL_VOID XGLAPI xglCmdClearDepthStencil(
2300 XGL_CMD_BUFFER cmdBuffer,
2301 XGL_IMAGE image,
2302 XGL_FLOAT depth,
2303 XGL_UINT32 stencil,
2304 XGL_UINT rangeCount,
2305 const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges);
2306
2307XGL_VOID XGLAPI xglCmdResolveImage(
2308 XGL_CMD_BUFFER cmdBuffer,
2309 XGL_IMAGE srcImage,
2310 XGL_IMAGE destImage,
2311 XGL_UINT rectCount,
2312 const XGL_IMAGE_RESOLVE* pRects);
2313
2314XGL_VOID XGLAPI xglCmdSetEvent(
2315 XGL_CMD_BUFFER cmdBuffer,
2316 XGL_EVENT event);
2317
2318XGL_VOID XGLAPI xglCmdResetEvent(
2319 XGL_CMD_BUFFER cmdBuffer,
2320 XGL_EVENT event);
2321
2322XGL_VOID XGLAPI xglCmdMemoryAtomic(
2323 XGL_CMD_BUFFER cmdBuffer,
2324 XGL_GPU_MEMORY destMem,
2325 XGL_GPU_SIZE destOffset,
2326 XGL_UINT64 srcData,
2327 XGL_ATOMIC_OP atomicOp);
2328
2329XGL_VOID XGLAPI xglCmdBeginQuery(
2330 XGL_CMD_BUFFER cmdBuffer,
2331 XGL_QUERY_POOL queryPool,
2332 XGL_UINT slot,
2333 XGL_FLAGS flags);
2334
2335XGL_VOID XGLAPI xglCmdEndQuery(
2336 XGL_CMD_BUFFER cmdBuffer,
2337 XGL_QUERY_POOL queryPool,
2338 XGL_UINT slot);
2339
2340XGL_VOID XGLAPI xglCmdResetQueryPool(
2341 XGL_CMD_BUFFER cmdBuffer,
2342 XGL_QUERY_POOL queryPool,
2343 XGL_UINT startQuery,
2344 XGL_UINT queryCount);
2345
2346XGL_VOID XGLAPI xglCmdWriteTimestamp(
2347 XGL_CMD_BUFFER cmdBuffer,
2348 XGL_TIMESTAMP_TYPE timestampType,
2349 XGL_GPU_MEMORY destMem,
2350 XGL_GPU_SIZE destOffset);
2351
2352XGL_VOID XGLAPI xglCmdInitAtomicCounters(
2353 XGL_CMD_BUFFER cmdBuffer,
2354 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2355 XGL_UINT startCounter,
2356 XGL_UINT counterCount,
2357 const XGL_UINT32* pData);
2358
2359XGL_VOID XGLAPI xglCmdLoadAtomicCounters(
2360 XGL_CMD_BUFFER cmdBuffer,
2361 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2362 XGL_UINT startCounter,
2363 XGL_UINT counterCount,
2364 XGL_GPU_MEMORY srcMem,
2365 XGL_GPU_SIZE srcOffset);
2366
2367XGL_VOID XGLAPI xglCmdSaveAtomicCounters(
2368 XGL_CMD_BUFFER cmdBuffer,
2369 XGL_PIPELINE_BIND_POINT pipelineBindPoint,
2370 XGL_UINT startCounter,
2371 XGL_UINT counterCount,
2372 XGL_GPU_MEMORY destMem,
2373 XGL_GPU_SIZE destOffset);
2374
2375#ifdef __cplusplus
2376} // extern "C"
2377#endif // __cplusplus
2378
2379#endif // __XGL_H__
2380
2381/******************************************************************************************
2382
2383 Open Issues + Missing Features
2384 ------------------------------
2385
2386 Here are a few higher level issues that we'd like to fix given time. A feature missing
2387 from this header (or the following list) isn't necessarily an indication that we want
2388 to drop that feature. Only that we either haven't thought of it or haven't had time
2389 to add it yet.
2390
2391 1) Transform Feedback (XFB)
2392
2393 OpenGL supports transform feedback (XFB). That is not included in this header, but
2394 we feel there is likely value in including it.
2395
2396 To incorporate trasnform feedback, we could create a new pipeline stage. This would
2397 be injected into a PSO by including the following in the chain:
2398
2399 typedef struct _XGL_XFB_CREATE_INFO
2400 {
2401 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
2402 const XGL_VOID* pNext; // Pointer to next structure
2403 // More XFB state, if any goes here
2404 } XGL_DEPTH_STENCIL_VIEW_CREATE_INFO;
2405
2406 We expect that only the shader-side configuration (via layout qualifiers or their IR
2407 equivalent) is used to configure the data written to each stream. When transform
2408 feedback is part of the pipeline, transform feedback binding would be available
2409 through a new API bind point:
2410
2411 xglCmdBindTransformFeedbackMemoryView(
2412 XGL_CMD_BUFFER cmdBuffer,
2413 XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
2414 XGL_UINT index,
2415 const XGL_MEMORY_VIEW_ATTACH_INFO* pMemView);
2416
2417 2) Framebuffer Objects
2418
2419 The XGL API here doesn't have a direct equivalent for a framebuffer object. In GL,
2420 the framebuffer object owns attachments, and the indirection table for glDrawBuffers, etc.
2421 The indirection is gone - only identity is supported here.
2422
2423 We may introduce an analog to the framebuffer object that packages all color
2424 attachments. You would create a framebuffer thus:
2425
2426 typedef struct _XGL_FRAMEBUFFER_CREATE_INFO
2427 {
2428 XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_XFB_CREATE_INFO
2429 const XGL_VOID* pNext; // Pointer to next structure
2430 XGL_UINT32 colorAttachmentCount;
2431 XGL_COLOR_ATTACHMENT_BIND_INFO* pColorAttachments;
2432 XGL_DEPTH_STENCIL_BIND_INFO pDepthStencilAttachment;
2433 } XGL_FRAMEBUFFER_CREATE_INFO;
2434
2435 xglCreateFramebuffer(
2436 XGL_DEVICE device,
2437 const XGL_FRAMEBUFFER_CREATE_INFO* pInfo,
2438 XGL_FRAMEBUFFER* pFramebuffer);
2439
2440 We then replace the xglCmdBindAttachments API with:
2441
2442 xglBindFramebuffer(
2443 XGL_CMD_BUFFER cmdBuffer,
2444 XGL_PIPELINE_BIND_POINT pipelineBindPoint, // = GRAPHICS
2445 XGL_FRAMEBUFFER framebuffer);
2446
2447 3) "Bindless" + support for non-bindless hardware.
2448
2449 XGL doesn't have bindless textures the way that GL does. It has resource descriptor
2450 sets, or resource tables. Resource tables can be nested and hold references to more
2451 resource tables. They are explicitly sized by the application and have no artificial
2452 upper size limit. An application can still attach as many textures as they want to
2453 a resource descriptor set, and can modify the set asynchronously to GPU work.
2454 Therefore, we can still have "unlimited textures". An application hoping to use
2455 bindless can use an index into a large table of textures and achieve the same effect.
2456
2457 For non-bindless hardware, with fixed (but potentially large) register files for
2458 resource bindings, the table approach should still work if a limited size can be
2459 reported somehow.
2460
2461 4) Clean up some remaining Mantle'isms.
2462
2463 Queue types: It's a bit hand wavey. In Mantle, we have a "universal" queue type that
2464 supports compute and graphics and a "compute" queue that only supports compute. Devices
2465 must support at least one universal queue and DMA queues are an extension. I would like
2466 to do the following (and have attempted to do that here, but am only half done):
2467
2468 a) Separate out the queue capabilities (compute, DMA, graphics) and allow support
2469 for any number of queues with any combination of capabilities each.
2470
2471 b) Allow compute-only or even DMA-only (like video capture or SDI) devices to
2472 be supported.
2473
2474 c) Allow new queue types to be supported by extensions without having to allocate
2475 bits in the bitfield until they're promoted to core.
2476
2477 Terminology: There are still some references to "targets" (render targets) and other
2478 terminology that has been changed from Mantle. Need to do a clean-up pass.
2479
2480 4) The window system interface is an extension in Mantle. We have not tried to fold
2481 any of it into core here. There is no mention of SwapBuffers, presentation, default
2482 framebuffers or anything like that. In the extension, presentation is queued up into
2483 the graphics queue just like any other command.
2484
2485*******************************************************************************************/